Enabled -Wall and fixed code to remove warnings
authorTito Dal Canton <tito.canton@ligo.org>
Fri, 25 Jan 2013 10:33:11 +0000 (11:33 +0100)
committerTito Dal Canton <tito.canton@ligo.org>
Fri, 25 Jan 2013 10:33:11 +0000 (11:33 +0100)
15 files changed:
cbc/Makefile.common
common/Makefile
common/include/array/GWArray.hpp
common/include/cluster/GWClusterSimpleMax.hpp
common/include/coincidence/GWCoincSimplest.hpp
common/include/convert/GWConvert.hpp
common/include/fft/GWFFTApple.hpp
common/include/fft/GWFFTBase.hpp
common/include/filter/GWFilter.hpp
common/include/frame/GWFrame.hpp
common/include/frame/GWFrameCache.hpp
common/include/series/GWSeries.hpp
common/include/templatebank/GWTemplateBank.hpp
common/include/waveform/GWWaveformBase.hpp
common/src/runtime/GWRuntime.cpp

index 20532cd..9668140 100644 (file)
@@ -55,8 +55,7 @@ BINDIR=$(BUILDDIR)/$(TARGET)/bin
 MANDIR=$(BUILDDIR)/$(TARGET)/man
 
 # TODO: something like if $(TARGET)==debug:
-# TODO: warning free code -Wall !!!
-CFLAGS = -fPIC -g
+CFLAGS = -fPIC -g -Wall
 # else if $(TARGET)==release:
 #CFLAGS = -fPIC -Wall -O3
 
index 6708558..63dc82c 100644 (file)
@@ -46,8 +46,7 @@ OBJDIR=$(BUILDDIR)/$(TARGET)/obj
 LIBDIR=$(BUILDDIR)/$(TARGET)/lib
 
 # TODO: something like if $(TARGET)==debug:
-# TODO: warning free code -Wall !!!
-CFLAGS = -fPIC -g
+CFLAGS = -fPIC -g -Wall
 # else if $(TARGET)==release:
 #CFLAGS = -fPIC -Wall -O3
 
index f38b22e..c4f65b6 100644 (file)
@@ -21,7 +21,7 @@
 using namespace std;
 
 #define M_GWARRAY_ARRAY_ARRAY_ARITHMETIC_KERNELCALL(mymessage,par0,par1,par2) \
-       T mtype; \
+       T mtype = 0; \
        cl_int err = 0; \
        cl_uint4 idx = ocl.KernelSelector(mtype,mtype); \
     cl::Event kernelEvent; \
@@ -51,7 +51,7 @@ using namespace std;
 /******************************************************************************/
 
 #define _M_GWARRAY_COMPOUND_ARRAY_ARRAY_ARITHMETIC_KERNELCALL(mymessage,par0,par1) \
-       T mtype; \
+       T mtype = 0; \
        cl_int err = 0; \
        cl_uint4 idx = ocl.KernelSelector(mtype,mtype); \
     cl::Event kernelEvent; \
@@ -67,12 +67,11 @@ using namespace std;
     m_runtime->appQueues[0].finish();
 
 #define _M_GWARRAY_COMPOUND_ARRAY_NUM_ARITHMETIC_KERNELCALL(mymessage,par0,par1) \
-       T mtype; \
+       T mtype = 0; \
        cl_int err = 0; \
        cl_uint4 idx = ocl.KernelSelector(mtype,mtype); \
     cl::Event kernelEvent; \
        cl_uint globalSize = this->length; \
-       cl_uint batch_size = 1;\
        if ((idx.s[1] > 3) && (myop < 4)) { \
         globalSize = globalSize * 2; \
     }; \
@@ -264,7 +263,8 @@ template <typename T> OpenCLObject Array<T>::ocl;
  */
 /******************************************************************************/
 
-template <typename T> cl_int Array <T>::CreateWorkSpace(size_t newlength) {
+template <typename T> cl_int Array <T>::CreateWorkSpace(size_t newlength)
+{
     cl_int err = 0;
     if (work_space_length != newlength) {
         m_logger->Log(GW::DEBUG,__func__,
@@ -280,7 +280,8 @@ template <typename T> cl_int Array <T>::CreateWorkSpace(size_t newlength) {
         ocl.checkErr(err,  "Array::CreateWorkSpace");
         work_space_length = newlength;
     }
-};
+    return err;
+}
 
 /******************************************************************************/
 /*!
@@ -825,10 +826,10 @@ template <typename T> cl_int Array <T>::Init() {
 /******************************************************************************/
 
 template <typename T> template <typename T2> Array <T> & Array<T>
-                                          :: operator = (const Array<T2> &rhs) {
-
-       T            this_type;
-    T2           rhs_type;
+                                          :: operator = (const Array<T2> &rhs)
+{
+       T            this_type = 0;
+    T2           rhs_type = 0;
     cl_int       err  = 0;
        cl_uint      myop = gwarrayAssign;
        cl_uint4     idx  = ocl.KernelSelector(this_type, rhs_type);
@@ -850,6 +851,7 @@ template <typename T> template <typename T2> Array <T> & Array<T>
 
     m_runtime->appQueues[0].finish();
     ocl.checkErr(err,  "Assignment kernel");
+    return *this;
 };
 
 
@@ -991,11 +993,10 @@ template <typename T> cl_int Array<T>::Segment(std::vector<Array <T> > &dest, cl
 
 template <typename T>  T  Array<T>::sum()
 {
-       T mtype;
-       T sum;
+       T sum = 0;
        cl_int  err     = 0;
        cl_uint myop    = gwarraySum;
-       cl_uint4 toCall = ocl.KernelSelector(mtype,mtype);
+       cl_uint4 toCall = ocl.KernelSelector(sum, sum);
        std::vector<cl::Event> kernelEvents(1);
 
     CreateWorkSpace(length);
@@ -1029,7 +1030,7 @@ template <typename T>  T  Array<T>::sum()
     ocl.checkErr(err, "ReadBuffer");
 
     sum = 0;
-    for (int i = 0; i < minlength; i++) {
+    for (unsigned int i = 0; i < minlength; i++) {
         sum += tmpCPUBuffer[i];
     }
     delete[] tmpCPUBuffer;
@@ -1038,12 +1039,11 @@ template <typename T>  T  Array<T>::sum()
 
 template <typename T>  T  Array<T>::max()
 {
-       T mtype;
-       T mymax, myabs;
+       T mymax = 0;
        cl_int  err       = 0;
     cl_uint minlength = 512;
        cl_uint myop      = gwarrayMax;
-       cl_uint4 toCall   = ocl.KernelSelector(mtype,mtype);
+       cl_uint4 toCall   = ocl.KernelSelector(mymax, mymax);
        std::vector<cl::Event> kernelEvents(1);
 
     //Enlarging the work_space if necessary
@@ -1078,7 +1078,7 @@ template <typename T>  T  Array<T>::max()
     ocl.checkErr(err, "ReadBuffer");
 
     mymax = tmpCPUBuffer[0];
-    for (int i = 0; i < minlength; i++) {
+    for (unsigned int i = 0; i < minlength; i++) {
         if (::abs(tmpCPUBuffer[i]) >= ::abs(tmpCPUBuffer[0]))
             mymax = tmpCPUBuffer[i];
     }
@@ -1200,15 +1200,16 @@ template <typename T> cl_int Array <T>:: Create(const size_t lngth) {
        return err;
 }
 
-template <typename T> cl_int Array <T>::Write(const char * filename, const char * format) {
+template <typename T> cl_int Array <T>::Write(const char * filename, const char * format)
+{
        T *myBuff = new T[length];
        Fetch(myBuff);
        m_logger->Log(GW::DEBUG,__func__,"Writing Array to file : %s", filename);
-       if (format == "binary")  {
-               ofstream myFile (filename, ios::out | ios::binary | ios::trunc);
-               myFile.write( ( char *) myBuff, length * elementsize);
+       if (std::string(format) == "binary")  {
+        ofstream myFile (filename, ios::out | ios::binary | ios::trunc);
+        myFile.write( ( char *) myBuff, length * elementsize);
                myFile.close();
-       } else if  (format == "ascii") {
+       } else if (std::string(format) == "ascii") {
                ofstream myFile (filename, ios::out | ios::trunc);
                for (int i = 0; i < length; i++) {
                        myFile << i << " " << myBuff[i] << endl;
@@ -1216,28 +1217,31 @@ template <typename T> cl_int Array <T>::Write(const char * filename, const char
                myFile.close();
        }
     delete[] myBuff;
+    return 0;
 };
 
-template <typename T> cl_int Array <T>::Read(const char * filename, const char * format) {
+template <typename T> cl_int Array <T>::Read(const char * filename, const char * format)
+{
        T *myBuff = new T[length]; 
-       if (format == "binary") {               
-               ifstream myFile (filename, ios::in | ios::binary );
-               myFile.read( ( char *) myBuff, length * elementsize);
+       if (std::string(format) == "binary") {
+        ifstream myFile (filename, ios::in | ios::binary );
+        myFile.read( ( char *) myBuff, length * elementsize);
                myFile.close();
-       } else if (format == "ascii") {
+       } else if (std::string(format) == "ascii") {
                ifstream myFile (filename, ios::in );
-                for (int i = 0; i < length; i++) {
-                        myFile >> myBuff[i];
-                }
-                myFile.close();
+        for (int i = 0; i < length; i++) {
+            myFile >> myBuff[i];
+        }
+        myFile.close();
        }
        Dispatch(myBuff);
     delete[] myBuff;
+    return 0;
 };
 
 #define _M_REAL_FILL_KERNEL(mytype)  {                             \
        cl_int err = 0;                                                \
-       mytype mtype;                                                  \
+       mytype mtype = 0;                                              \
     cl::Event kernelEvent;                                         \
     cl_uint gsize = max - min + 1;                                 \
        cl_uint4 idx  = ocl.KernelSelector(mtype,mtype);               \
@@ -1255,7 +1259,7 @@ template <typename T> cl_int Array <T>::Read(const char * filename, const char *
 
 #define _M_COMPLEX_FILL_KERNEL(mytype)  {                      \
        cl_int err = 0;                                            \
-       mytype mtype;                                              \
+       mytype mtype = 0;                                          \
         cl::Event kernelEvent;                                 \
         cl_uint gsize = max - min + 1;                         \
        cl_uint4 idx  = ocl.KernelSelector(mtype,mtype);           \
index 22b7490..698ae6e 100644 (file)
@@ -74,7 +74,6 @@ template <typename T> OpenCLObject ClusterSimpleMax<T>::ocl;
 template <typename T> cl_int ClusterSimpleMax<T>::CreateWorkSpace(
                                                              size_t newlength)
 {
-
     if (dev_work_space->length != newlength) {
         GWToolsBase::m_logger->Log(GW::DEBUG, __func__,
             "(Re)creating workspace for ClusterSimpleMax f size: %d -> %d ",
@@ -89,8 +88,8 @@ template <typename T> cl_int ClusterSimpleMax<T>::CreateWorkSpace(
 
         host_work_space = new cl_float[newlength];
     }
-
-};
+    return 0;
+}
 
 
 /******************************************************************************/
@@ -210,7 +209,7 @@ template <typename T> void ClusterSimpleMax<T>::FindClusters(
 
     dev_work_space->Fetch(host_work_space);
 
-    for (int i = 0; i < num_of_triggers; i++) {
+    for (unsigned int i = 0; i < num_of_triggers; i++) {
         if (host_work_space[2 * i] > threshold) {
             myTrigger.IntrParams = *IntrParams;
             myTrigger.snr        = (double) host_work_space[2 * i];
index adc04dd..3d5ea37 100644 (file)
@@ -53,6 +53,7 @@ template <typename T> cl_int CoincSimplest <T> ::FindCoincidences(
                   std::vector <TriggerList> triggers     //!<the TriggerLists
                 )
 {
+    return CL_SUCCESS;
 }
 
 
index 9081b97..d064346 100644 (file)
@@ -50,7 +50,7 @@ int Converter::RealToComplex(size_t length, cl_float * src, cl_complex_float *&
         m_logger->Log(GW::ERROR,__func__,"Cannot allocate memory.");
         return -1;
     }
-    for (int i = 0; i < length; i++) {
+    for (unsigned int i = 0; i < length; i++) {
         dest[i].s0  = src[i];
         dest[i].s1  = 0.0;
     }
index ce641e1..aae3860 100644 (file)
@@ -60,9 +60,10 @@ template <typename T> class FFTApple : public FFTBase  <T> {
  */
 /******************************************************************************/
 
-template <typename T> int FFTApple <T>::CreatePlan(cl_uint N) {
+template <typename T> int FFTApple <T>::CreatePlan(cl_uint N)
+{
+    cl_int err = 0;
     if ( plan_length != N ) {
-        cl_int err = 0;
         n.x = N;
         n.y = 1;
         n.z = 1;
@@ -73,7 +74,8 @@ template <typename T> int FFTApple <T>::CreatePlan(cl_uint N) {
         }
         plan_length = N;
     }
-};
+    return err;
+}
 
 
 /******************************************************************************/
@@ -91,7 +93,8 @@ template <typename T> int FFTApple<T>::Forward(Array <T> * src, Array <T> * dest
        err = clFFT_ExecuteInterleaved(GWToolsBase::m_runtime->appQueues[0](), plan, batch_size, clFFT_Forward, src->data(), dest->data(), 0, NULL, NULL);
        GWToolsBase::m_runtime->appQueues[0].finish();
        Timer.Stop(0);
-};
+    return err;
+}
 
 /******************************************************************************/
 /*!
@@ -110,7 +113,8 @@ template <typename T> int FFTApple<T>::Forward(TimeSeries <T> * src, FrequencySe
        GWToolsBase::m_runtime->appQueues[0].finish();
     dest->delta_f = 1. / (src->length * src->delta_t);
        Timer.Stop(0);
-};
+    return err;
+}
 
 
 /******************************************************************************/
@@ -128,7 +132,8 @@ template <typename T> int FFTApple<T>::Inverse(Array <T> * src, Array <T> * dest
        err = clFFT_ExecuteInterleaved(GWToolsBase::m_runtime->appQueues[0](), plan, batch_size, clFFT_Inverse, src->data(), dest->data(), 0, NULL, NULL);
        GWToolsBase::m_runtime->appQueues[0].finish();
        Timer.Stop(0);
-};
+    return err;
+}
 
 /******************************************************************************/
 /*!
@@ -147,7 +152,8 @@ template <typename T> int FFTApple<T>::Inverse(FrequencySeries <T> * src, TimeSe
        GWToolsBase::m_runtime->appQueues[0].finish();
     dest->delta_t = 1. / src->delta_f / src->length;
        Timer.Stop(0);
-};
+    return err;
+}
 
 
 }
index 8218c9c..46d41a0 100644 (file)
@@ -98,6 +98,7 @@ template  <typename T> int FFTBase<T>::Forward(
        for (int i = 0; i < src->size(); i++) {
                Forward( &((*src)[i]), &((*dst)[i]), batch_size);
        }
+    return 0;
 }
 
 template  <typename T> int FFTBase<T>::Forward(
@@ -108,9 +109,9 @@ template  <typename T> int FFTBase<T>::Forward(
        for (int i = 0; i < src->size(); i++) {
                Forward( &((*src)[i]), &((*dst)[i]), batch_size);
        }
+    return 0;
 }
 
-
 template  <typename T> int FFTBase<T>::Inverse(
                        std::vector<GW::Array<T> > * src,
                        std::vector<GW::Array<T> > * dst,
@@ -119,7 +120,7 @@ template  <typename T> int FFTBase<T>::Inverse(
        for (int i = 0; i < src->size(); i++) {
                Inverse(&((*src)[i]), &((*dst)[i]), batch_size);
        }
-
+    return 0;
 }
 
 template  <typename T> int FFTBase<T>::Inverse(
@@ -130,7 +131,7 @@ template  <typename T> int FFTBase<T>::Inverse(
        for (int i = 0; i < src->size(); i++) {
                Inverse(&((*src)[i]), &((*dst)[i]), batch_size);
        }
-
+    return 0;
 }
 
 } // end of namespace
index 59f20cf..a7ec957 100644 (file)
@@ -148,12 +148,14 @@ enum filterKernelEnum {
  */
 /******************************************************************************/
 
-template <typename T> cl_int Filter<T>::AutoCorrelation(Array <T> * src,  Array <T> * autocorr) {
+template <typename T> cl_int Filter<T>::AutoCorrelation(Array <T> * src,  Array <T> * autocorr)
+{
        (*autocorr) = (*src);
        (*autocorr).abs();
        (*autocorr).sqr();
        myFFT->Inverse(autocorr, autocorr);
-};
+    return CL_SUCCESS;
+}
 
 /******************************************************************************/
 /*!
@@ -163,11 +165,14 @@ template <typename T> cl_int Filter<T>::AutoCorrelation(Array <T> * src,  Array
  */
 /******************************************************************************/
 
-template <typename T> cl_int Filter<T>::CrossCorrelation(Array <T> * src1, Array <T> * src2, Array <T> * crosscorr) {
+template <typename T> cl_int Filter<T>::CrossCorrelation(
+    Array <T> * src1, Array <T> * src2, Array <T> * crosscorr)
+{
        (*crosscorr) = (*src1);
        (*crosscorr) *= (*src2);
        myFFT->Inverse(crosscorr,crosscorr);
-};
+    return CL_SUCCESS;
+}
 
 /******************************************************************************/
 /*!
@@ -177,10 +182,11 @@ template <typename T> cl_int Filter<T>::CrossCorrelation(Array <T> * src1, Array
  */
 /******************************************************************************/
 
-template <typename T> cl_int Filter<T>::Whiten(Array <T> * src,  Array <T> * psd) {
+template <typename T> cl_int Filter<T>::Whiten(Array <T> * src,  Array <T> * psd)
+{
        (*src) /= (*psd);
     return CL_SUCCESS;
-};
+}
 
 /******************************************************************************/
 /*!
@@ -194,7 +200,7 @@ template <typename T> cl_int Filter<T>::Whiten(
                                     std::vector<GW::Array<T> > * src,
                                     Array <T> * psd
 ) {
-       for (int i = 0; i < src->size(); i++) {
+       for (unsigned int i = 0; i < src->size(); i++) {
                (*src)[i] /= (*psd);
        }
     return CL_SUCCESS;
@@ -212,7 +218,7 @@ template <typename T> cl_int Filter<T>::Whiten(
                                     std::vector<GW::FrequencySeries<T> > * src,
                                     GW::FrequencySeries <T> * psd
 ) {
-       for (int i = 0; i < src->size(); i++) {
+       for (unsigned int i = 0; i < src->size(); i++) {
                (*src)[i] /= (*psd);
        }
     return CL_SUCCESS;
@@ -226,65 +232,66 @@ template <typename T> cl_int Filter<T>::Whiten(
  */
 /******************************************************************************/
 
-template <typename T> cl_int Filter<T>::Init() {
-        cl_int err;
+template <typename T> cl_int Filter<T>::Init()
+{
+    cl_int err;
 
-        if (ocl.isbuilt ==  false) {
-            string kernelFileName(m_commif->get_home());
-            kernelFileName += "/kernels/GWFilter.cl";
-            ocl.Build(kernelFileName.c_str(), m_logger, m_runtime);
-            ocl.isbuilt = true;
-        }
-        // The LowPass kernels
-        ocl.kernels[gwfilterLowPass][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatLowPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(floatLowPass)");
-        ocl.kernels[gwfilterLowPass][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleLowPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(doubleLowPass)");
-        ocl.kernels[gwfilterLowPass][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatLowPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexFloatLowPass)");
-        ocl.kernels[gwfilterLowPass][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleLowPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexDoubleLowPass)");
-
-        // The HighPass kernels
-        ocl.kernels[gwfilterHighPass][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatHighPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(floatHighPass)");
-        ocl.kernels[gwfilterHighPass][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleHighPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(doubleHighPass)");
-        ocl.kernels[gwfilterHighPass][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatHighPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexFloatHighPass)");
-        ocl.kernels[gwfilterHighPass][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleHighPass", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexDoubleHighPass)");
-
-        // The Resample kernels
-        ocl.kernels[gwfilterResample][gwcl_int][gwcl_int] = cl::Kernel(ocl.program, "intResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(intResample)");
-        ocl.kernels[gwfilterResample][gwcl_uint][gwcl_uint] = cl::Kernel(ocl.program, "uintResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(uintResample)");
-        ocl.kernels[gwfilterResample][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(floatResample)");
-        ocl.kernels[gwfilterResample][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(doubleResample)");
-
-        ocl.kernels[gwfilterResample][gwcl_complex_int][gwcl_complex_int] = cl::Kernel(ocl.program, "complexIntResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexIntResample)");
-        ocl.kernels[gwfilterResample][gwcl_complex_uint][gwcl_complex_uint] = cl::Kernel(ocl.program, "complexUintResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(omplexUintResample)");
-        ocl.kernels[gwfilterResample][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexFloatResample)");
-        ocl.kernels[gwfilterResample][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleResample", &err);
-        ocl.checkErr(err,  "cl::Kernel(compleDoubleResample)");
-
-
-        // The Hann window kernel
-        ocl.kernels[gwfilterHann][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatHannWindow", &err);
-        ocl.checkErr(err,  "cl::Kernel(floatHannWindow)");
-        ocl.kernels[gwfilterHann][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleHannWindow", &err);
-        ocl.checkErr(err,  "cl::Kernel(doubleHannWindow)");
-        ocl.kernels[gwfilterHann][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatHannWindow", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexFloatHannWindow)");
-        ocl.kernels[gwfilterHann][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleHannWindow", &err);
-        ocl.checkErr(err,  "cl::Kernel(complexDoubleHannWindow)");
-};
+    if (ocl.isbuilt ==  false) {
+        string kernelFileName(m_commif->get_home());
+        kernelFileName += "/kernels/GWFilter.cl";
+        ocl.Build(kernelFileName.c_str(), m_logger, m_runtime);
+        ocl.isbuilt = true;
+    }
+    // The LowPass kernels
+    ocl.kernels[gwfilterLowPass][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatLowPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(floatLowPass)");
+    ocl.kernels[gwfilterLowPass][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleLowPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(doubleLowPass)");
+    ocl.kernels[gwfilterLowPass][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatLowPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexFloatLowPass)");
+    ocl.kernels[gwfilterLowPass][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleLowPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexDoubleLowPass)");
+
+    // The HighPass kernels
+    ocl.kernels[gwfilterHighPass][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatHighPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(floatHighPass)");
+    ocl.kernels[gwfilterHighPass][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleHighPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(doubleHighPass)");
+    ocl.kernels[gwfilterHighPass][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatHighPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexFloatHighPass)");
+    ocl.kernels[gwfilterHighPass][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleHighPass", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexDoubleHighPass)");
+
+    // The Resample kernels
+    ocl.kernels[gwfilterResample][gwcl_int][gwcl_int] = cl::Kernel(ocl.program, "intResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(intResample)");
+    ocl.kernels[gwfilterResample][gwcl_uint][gwcl_uint] = cl::Kernel(ocl.program, "uintResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(uintResample)");
+    ocl.kernels[gwfilterResample][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(floatResample)");
+    ocl.kernels[gwfilterResample][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(doubleResample)");
+
+    ocl.kernels[gwfilterResample][gwcl_complex_int][gwcl_complex_int] = cl::Kernel(ocl.program, "complexIntResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexIntResample)");
+    ocl.kernels[gwfilterResample][gwcl_complex_uint][gwcl_complex_uint] = cl::Kernel(ocl.program, "complexUintResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(omplexUintResample)");
+    ocl.kernels[gwfilterResample][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexFloatResample)");
+    ocl.kernels[gwfilterResample][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleResample", &err);
+    ocl.checkErr(err,  "cl::Kernel(compleDoubleResample)");
+
+    // The Hann window kernel
+    ocl.kernels[gwfilterHann][gwcl_float][gwcl_float] = cl::Kernel(ocl.program, "floatHannWindow", &err);
+    ocl.checkErr(err,  "cl::Kernel(floatHannWindow)");
+    ocl.kernels[gwfilterHann][gwcl_double][gwcl_double] = cl::Kernel(ocl.program, "doubleHannWindow", &err);
+    ocl.checkErr(err,  "cl::Kernel(doubleHannWindow)");
+    ocl.kernels[gwfilterHann][gwcl_complex_float][gwcl_complex_float] = cl::Kernel(ocl.program, "complexFloatHannWindow", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexFloatHannWindow)");
+    ocl.kernels[gwfilterHann][gwcl_complex_double][gwcl_complex_double] = cl::Kernel(ocl.program, "complexDoubleHannWindow", &err);
+    ocl.checkErr(err,  "cl::Kernel(complexDoubleHannWindow)");
+    return err;
+}
 
 /******************************************************************************/
 /*!
@@ -333,7 +340,8 @@ template <typename T> int Filter<T>::LowPass(Array <T> * myArray, cl_uint idx,
 /******************************************************************************/
 
 template <typename T> int Filter<T>::LowPass(TimeSeries <T> * src, double freq,
-                                                           double half_width) {
+                                                           double half_width)
+{
     // The normalisation factor
     T N;
     N = src->length;
@@ -357,7 +365,8 @@ template <typename T> int Filter<T>::LowPass(TimeSeries <T> * src, double freq,
     // Converting back to time domain and normalizing
     myFFT->Inverse(src,src);
     *src /= N;
-};
+    return CL_SUCCESS;
+}
 
 
 /******************************************************************************/
@@ -371,12 +380,12 @@ template <typename T> int Filter<T>::LowPass(TimeSeries <T> * src, double freq,
 /******************************************************************************/
 
 template <typename T> int Filter<T>::HighPass(Array <T> * src, cl_uint idx,
-                                                           cl_uint half_width) {
-
-    T mtype;
+                                                           cl_uint half_width)
+{
+    T mtype = 0;
     cl_int  err     = 0;
     cl_uint myop    = gwfilterHighPass;
-    cl_uint4 toCall = ocl.KernelSelector(mtype,mtype);
+    cl_uint4 toCall = ocl.KernelSelector(mtype, mtype);
     std::vector<cl::Event> kernelEvents(1);
 
     cl::NDRange globalWorkSize = src->length;
@@ -412,7 +421,8 @@ template <typename T> int Filter<T>::HighPass(Array <T> * src, cl_uint idx,
 /******************************************************************************/
 
 template <typename T> int Filter<T>::HighPass(TimeSeries <T> * src, double freq,
-                                                           double half_width) {
+                                                           double half_width)
+{
     // The normalisation factor
     T N;
     N = src->length;
@@ -436,7 +446,8 @@ template <typename T> int Filter<T>::HighPass(TimeSeries <T> * src, double freq,
     // Converting back to time domain and normalizing
     myFFT->Inverse(src,src);
     *src /= N;
-};
+    return CL_SUCCESS;
+}
 
 
 /******************************************************************************/
@@ -448,10 +459,10 @@ template <typename T> int Filter<T>::HighPass(TimeSeries <T> * src, double freq,
 /******************************************************************************/
 
 template <typename T> int Filter<T>::HannWindow(Array <T> * myArray) {
-        T mtype;
+        T mtype = 0;
         cl_int  err     = 0;
         cl_uint myop    = gwfilterHann;
-        cl_uint4 toCall = ocl.KernelSelector(mtype,mtype);
+        cl_uint4 toCall = ocl.KernelSelector(mtype, mtype);
         std::vector<cl::Event> kernelEvents(1);
 
         cl::NDRange globalWorkSize = myArray->length;
@@ -478,12 +489,10 @@ template <typename T> int Filter<T>::HannWindow(Array <T> * myArray) {
 template <typename T> int Filter<T>::SmoothPSD(
                                 Array <T> * myPSD,
                                 cl_uint inv_spectrum_size,
-                                cl_uint half_width
-) {
-    T myzero;
-    T mylength;
-    mylength = myPSD->length;
-    myzero   = 0;
+                                cl_uint half_width)
+{
+    T myzero = 0;
+    T mylength = myPSD->length;
 
     Array <T> tmpArray(myPSD->length, m_commif, m_logger, m_runtime);
     Array <T> tmpArray2(myPSD->length, m_commif, m_logger, m_runtime);
@@ -531,7 +540,7 @@ template <typename T> T Filter<T>:: MedianPSDBias(unsigned int nn)
 
     if (nn >= nmax)
         return 0.69314718055994529;    // ln(2)
-    for (int i = 1; i <= n; ++i) {
+    for (unsigned int i = 1; i <= n; ++i) {
         ans -= 1.0 / (2*i);
         ans += 1.0 / (2*i + 1);
     }
@@ -556,8 +565,8 @@ template <typename T> int Filter<T>::PSD(TimeSeries <T> * myArray,
     // Determining the segment size and the maximum number of segments
     // with 0.5 overlap
     // FIXME get this parameters from application's CLI
-    cl_int segment_size          = myPSD->length;
-    cl_int number_of_segments = myArray->length / (segment_size / 2) - 1;
+    cl_uint segment_size         = myPSD->length;
+    cl_uint number_of_segments = myArray->length / (segment_size / 2) - 1;
 
     // check consistency of input and output sampling
     // FIXME would it be more useful to just reset it to the correct value,
@@ -740,19 +749,15 @@ template <typename T> cl_int Filter<T>::BandPassTimeDomain(
                                             Array <T> * myArray,
                                             double fmin,
                                             double fmax,
-                                            cl_uint sampling_rate
-)
+                                            cl_uint sampling_rate)
 {
-
     Array <T> *fftArray = new Array<T>(myArray->length, m_commif, m_logger, m_runtime);
 
     double duration = 1. / sampling_rate * myArray->length;
     double df       = 1. / duration;
 
     // Auxiliary variables to fill up the arrays
-    T myzero, mylength;
-    myzero   = 0.;
-    mylength = myArray->length;
+    T myzero = 0, mylength = myArray->length;
 
     // Borders for the bandpass filter
     cl_uint min     = fmin / df;
@@ -780,7 +785,8 @@ template <typename T> cl_int Filter<T>::BandPassTimeDomain(
     myFFT->Inverse(fftArray, myArray);
     *myArray /= mylength;
     delete fftArray;
-};
+    return CL_SUCCESS;
+}
 
 
 } // end of namespace
index 68940a0..662266b 100644 (file)
@@ -52,44 +52,46 @@ class Frame {
     \r
 };\r
 \r
-int Frame::Open(char * filename) {\r
-       int err = 0;\r
+int Frame::Open(char * filename)\r
+{\r
        m_logger->Log(GW::DEBUG, __func__,"Opening the frame file: %s.", filename);\r
 \r
        frFile = FrFileINew(filename);\r
-\r
-        if (frFile == NULL ) {\r
-                m_logger->Log(GW::ERROR, __func__,"Error reading the frame file: %s.", filename);\r
-                m_logger->Log(GW::ERROR, __func__,"Exiting.");\r
-                exit(-1);\r
-        } else {\r
-               return 0;\r
-       }       \r
-};\r
+    \r
+    if (frFile == NULL ) {\r
+        m_logger->Log(GW::ERROR, __func__,"Error reading the frame file: %s.", filename);\r
+        m_logger->Log(GW::ERROR, __func__,"Exiting.");\r
+        return -1;\r
+    }\r
+    return 0;\r
+}\r
 \r
 \r
-int Frame::ReadChannel(char * channel_name, const double start, const double length) {\r
-       int err = 0;\r
+int Frame::ReadChannel(char * channel_name, const double start, const double length)\r
+{\r
        m_logger->Log(GW::DEBUG, __func__,"Reading the channel: %s.", channel_name);\r
 \r
        vect = FrFileIGetVectF(frFile,  channel_name, start, length);\r
-        if (vect == NULL ) {\r
-                m_logger->Log(GW::ERROR, __func__,"Error reading the specified channel: %s.", channel_name);\r
-                m_logger->Log(GW::ERROR, __func__,"Exiting.");\r
-                exit(-1);\r
-        } else {\r
-               return 0;\r
-       }       \r
-};\r
-\r
-\r
-int Frame::FreeChannel(char * channel_name) {\r
-        FrVectFree(vect);\r
-};\r
-\r
-int Frame::Close() {\r
+    if (vect == NULL ) {\r
+        m_logger->Log(GW::ERROR, __func__,"Error reading the specified channel: %s.", channel_name);\r
+        m_logger->Log(GW::ERROR, __func__,"Exiting.");\r
+        return -1;\r
+    }\r
+    return 0;  \r
+}\r
+\r
+\r
+int Frame::FreeChannel(char * channel_name)\r
+{\r
+    FrVectFree(vect);\r
+    return 0;\r
+}\r
+\r
+int Frame::Close()\r
+{\r
        FrFileIEnd(frFile);\r
-};\r
+    return 0;\r
+}\r
 \r
 } // end of GW namespace\r
 \r
index 30181b9..3b71b66 100644 (file)
@@ -89,8 +89,8 @@ class FrameCache : public GWToolsBase {
  */\r
 /******************************************************************************/\r
 \r
-int FrameCache::OpenCacheFile() {\r
-       int err = 0;\r
+int FrameCache::OpenCacheFile()\r
+{\r
        m_logger->Log(GW::DEBUG, __func__,\r
                                "Opening the cache file: %s.", filename.c_str());\r
 \r
@@ -100,11 +100,10 @@ int FrameCache::OpenCacheFile() {
         m_logger->Log(GW::ERROR, __func__,\r
                          "Error reading the frame file: %s.", filename.c_str());\r
         m_logger->Log(GW::ERROR, __func__,"Exiting.");\r
-        exit(-1);\r
-    } else {\r
-           return 0;\r
-       }\r
-};\r
+        return -1;\r
+    }\r
+    return 0;\r
+}\r
 \r
 \r
 \r
@@ -209,7 +208,7 @@ cl_int FrameCache::ReadData(std::string channel, const double start,
     bool isalloc = false;\r
 \r
 // Looping through on the frame cache entries\r
-    for (int i = 0; i < entries.size(); i++) {\r
+    for (unsigned int i = 0; i < entries.size(); i++) {\r
                if ((entries[i].framestart + entries[i].framelength > start) &&\r
             (entries[i].framestart < end)) {\r
 \r
@@ -242,7 +241,7 @@ cl_int FrameCache::ReadData(std::string channel, const double start,
             // Coping the data read to the allocated buffer;\r
             m_logger->Log(GW::DEBUG,__func__,"Coping the data into memory.");\r
             int shift  = (readstart - start) * sampling_rate;\r
-            for (int i = 0; i < myFrame.vect->nData; i++) {\r
+            for (unsigned int i = 0; i < myFrame.vect->nData; i++) {\r
                 ptr[shift + i] = myFrame.vect->dataF[i];\r
             }\r
 \r
@@ -298,6 +297,7 @@ int FrameCache::ReadData(std::string channel, const double start,
                  end - start, start, sampling_rate);\r
     /* Free the allocated buffer */\r
     free(ptr);\r
+    return 0;\r
 }\r
 \r
 \r
@@ -310,8 +310,10 @@ int FrameCache::ReadData(std::string channel, const double start,
  */\r
 /******************************************************************************/\r
 \r
-int FrameCache::CloseCacheFile() {\r
+int FrameCache::CloseCacheFile()\r
+{\r
     cacheFile.close();\r
+    return 0;\r
 }\r
 \r
 \r
index b971fc8..2cb90e7 100644 (file)
@@ -249,11 +249,11 @@ template <typename T> cl_int FrequencySeries <T> :: Write(const char* filename,
     Fetch(myBuff);
     m_logger->Log(GW::DEBUG,__func__,"Writing FrequencySeries to file : %s",
                filename);
-    if (format == "binary")  {
+    if (std::string(format) == "binary")  {
                ofstream myFile (filename, ios::out | ios::binary | ios::trunc);
                myFile.write((char *) myBuff, length * elementsize);
                myFile.close();
-       } else if (format == "ascii") {
+       } else if (std::string(format) == "ascii") {
                unsigned int i;
                ofstream myFile(filename, ios::out | ios::trunc);
                // negative frequencies
@@ -265,6 +265,7 @@ template <typename T> cl_int FrequencySeries <T> :: Write(const char* filename,
                myFile.close();
        }
        delete[] myBuff;
+    return 0;
 }
 
 };
index bd18bb8..c8461be 100644 (file)
@@ -144,7 +144,6 @@ template <typename T> cl_int TemplateBank<T>::ReadFromASCII(const std::string fi
 {
     std::ifstream               bankFile;
     std::string                 line;
-    size_t                      templatecount;
     std::vector<string>         cols;
     stringstream                linestream;
        IntrinsicWaveformParameters params;
@@ -195,7 +194,7 @@ template <typename T> cl_int TemplateBank<T>::ReadFromASCII(const std::string fi
                // This is the line where the parameter name are defined
         if (! cols[0].compare("@Parameters:"))    {
             m_logger->Log(GW::DEBUG,__func__,"Template bank parameters:");
-            for (int i = 1; i < cols.size() - 1; i++) {
+            for (unsigned int i = 1; i < cols.size() - 1; i++) {
                 parameters.push_back(cols[i]);
                 m_logger->Log(GW::DEBUG,__func__,"  %s", cols[i].c_str());
             }
@@ -207,7 +206,7 @@ template <typename T> cl_int TemplateBank<T>::ReadFromASCII(const std::string fi
                // Filling up the template bank
         } else {
             params.clear();
-            for (int i = 0; i < parameters.size() ; i++) {
+            for (unsigned int i = 0; i < parameters.size() ; i++) {
                 params[parameters[i]] = (float) atof(cols[i].c_str());
                                m_logger->Log(GW::INSANE,__func__,"Reading parameter: %s = %f",
                                 parameters[i].c_str(), atof(cols[i].c_str()));
index 3a534e8..da3009b 100644 (file)
@@ -76,7 +76,7 @@ class ExtrinsicWaveformParameters {
 
   public:
     ExtrinsicWaveformParameters() : distance(1 * SI_Mpc), iota(0.),
-        phi(0.), theta(0.), varphi(0.), psi(0.), time_shift(0.) {};
+        varphi(0.), phi(0.), theta(0.), psi(0.), time_shift(0.) {};
 
     double distance;   //!< the distance to observer [m]
     double iota;       //!< angle of l.o.s and initial orbital angular momentum [rad]
index de72240..7ab9c21 100644 (file)
@@ -438,6 +438,7 @@ cl_int GW::Runtime::RuntimeInit()
 \r
 \r
     }\r
+    return CL_SUCCESS;\r
 }\r
 \r
 \r