Changeset 562

Timestamp:

Oct 10, 2011, 9:13:32 AM (13 years ago)

Author:

campagne

Message:

continue w/wo calibration stuff (jec)

File:

• BAORadio/AmasNancay/trunk/mergeAnaFiles.cc (modified) (26 diffs)

BAORadio/AmasNancay/trunk/mergeAnaFiles.cc

@@ -1 +1 @@
 // Utilisation de SOPHYA pour faciliter les tests ...
-#include <regex.h>
-//#include <regexp.h>
-#include <stdio.h>
-
 #include "sopnamsp.h"
 #include "machdefs.h"
-
-#include <stdlib.h>
 #include <dirent.h>
 #include <matharr.h>
 
 // include standard c/c++
+#include <regex.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits>
 #include <iostream>
 #include <fstream>
@@ -40 +38 @@
 const sa_size_t NUMBER_OF_CHANNELS = 2;
 const sa_size_t NUMBER_OF_FREQ     = 8192;
-const sa_size_t TOTAL_NUM_CYCLES   = 500;
 const r_4    LOWER_FREQUENCY       = 1250.0; //MHz
 const r_4    TOTAL_BANDWIDTH       = 250.0;  //MHz
@@ -52 +49 @@
   string ppfFile_;    //generic name of the input files
   int nSliceInFreq_;  //used by reduceSpectra() fnc
-  string typeOfCalib_;//type of calibration to be done
   string calibFreq_;  //freq. value used for calibration
+  r_4 rcalibFreq_;    //float version
+  string calibBandFreq_;  //band of freq. used for calibration
+  r_4 rcalibBandFreq_;    //float version
+  int maxNumberCycles_;//maximum number of cycles to be treated
 } para;
 //--------------------------------------------------------------
 //Utility functions
 
-sa_size_t freqTochan(r_4 f){
+sa_size_t freqToChan(r_4 f){
   return (sa_size_t)((f-LOWER_FREQUENCY)/TOTAL_BANDWIDTH*NUMBER_OF_FREQ);
+}
+//--------
+//COMPUTE the mean value on a freq. range for all channels
+//--------
+void meanInRange(const TMatrix<r_4> mtx, 
+                 sa_size_t chLow,
+                 sa_size_t chHigh, 
+                 TVector<r_4>& vec){
+  sa_size_t nr = mtx.NRows();
+  for (sa_size_t ir=0; ir<nr; ir++){
+    TVector<r_4> tmp(mtx(Range(ir),Range(chLow,chHigh)),false);
+    double mean, sigma;
+    MeanSigma(tmp,mean,sigma);
+    vec(ir) = mean;
+  }
 }
 //---------
@@ -244 +259 @@
 //   //Loop on files
 //   uint_4 nRuns=0;
-//   TArray<r_4> tableOfSpectra(NUMBER_OF_FREQ,NUMBER_OF_CHANNELS,TOTAL_NUM_CYCLES); //TOTAL_NUM_CYCLES should be large enough...
+//   TArray<r_4> tableOfSpectra(NUMBER_OF_FREQ,NUMBER_OF_CHANNELS,para.maxNumberCycles_); //para.maxNumberCycles_ should be large enough...
 
 
@@ -358 +373 @@
   iFileEnd = listOfFiles.end();
 
+  //mean ON-OFF over the list of cycles
+  TMatrix<r_4> meanDiffONOFF_noCalib(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);          //set to 0 
+  TMatrix<r_4> meanDiffONOFF_perRunCalib(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);      //set to 0
+  TMatrix<r_4> meanDiffONOFF_perCycleCalib(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);    //set to 0
+  char* onffTupleName[7]={"cycle",
+                          "onoffRaw0","onoffRun0","onoffCycle0",
+                          "onoffRaw1","onoffRun1","onoffCycle1"};
+  NTuple onoffevolution(7,onffTupleName);
+  r_4 xnt[7];
+
+  //Lower and Higher freq. bin to perform mean follow up
+  sa_size_t chLow = freqToChan(para.rcalibFreq_ - (para.rcalibBandFreq_*0.5));
+  sa_size_t chHigh = freqToChan(para.rcalibFreq_ + (para.rcalibBandFreq_*0.5));
+  
   //Loop on files/run
-  uint_4 totalNumberCycles=0; //total number of cycles for normalisation
+
+  int totalNumberCycles=0; //total number of cycles for normalisation
   for (iFile = listOfFiles.begin(); iFile != iFileEnd; ++iFile) {
     if (para.debuglev_>90){
@@ -462 +492 @@
       cout << "(nr,nc): "<< nr << "," << nc << endl;
       calibBAOfactors_Off_Cycle_Ch0.Print(cout);
+      cout << endl;
     }
 
@@ -476 +507 @@
       cout << "Fill calib. with mean value " << endl; 
       calibBAOfactors_Off_Run_Ch0.Print(cout);
+      cout << endl;
     }
     ifs.close();
@@ -493 +525 @@
       cout << "(nr,nc): "<< nr << "," << nc << endl;
       calibBAOfactors_Off_Cycle_Ch1.Print(cout);
+      cout << endl;
     }
     TMatrix<r_4> calibBAOfactors_Off_Run_Ch1(nr,nc);
@@ -506 +539 @@
       cout << "Fill calib. with mean value " << endl; 
       calibBAOfactors_Off_Run_Ch1.Print(cout);
+      cout << endl;
     }
     ifs.close();
@@ -523 +557 @@
       cout << "(nr,nc): "<< nr << "," << nc << endl;
       calibBAOfactors_On_Cycle_Ch0.Print(cout);
-        
+      cout << endl;      
     }
 
@@ -538 +572 @@
       cout << "Fill calib. with mean value " << endl; 
       calibBAOfactors_On_Run_Ch0.Print(cout);
+      cout << endl;
     }
     ifs.close();
@@ -554 +589 @@
       cout << "(nr,nc): "<< nr << "," << nc << endl;
       calibBAOfactors_On_Cycle_Ch1.Print(cout);
+      cout << endl;
     }
     TMatrix<r_4> calibBAOfactors_On_Run_Ch1(nr,nc);
@@ -567 +603 @@
       cout << "Fill calib. with mean value " << endl; 
       calibBAOfactors_On_Run_Ch1.Print(cout);
+      cout << endl;
     }
 
@@ -572 +609 @@
     
     //link <cycle> - <calibration coefficient>
-    map<int,r_4> calibBAO_Off_Ch0;
-    map<int,r_4> calibBAO_Off_Ch1;
-    map<int,r_4> calibBAO_On_Ch0;
-    map<int,r_4> calibBAO_On_Ch1;
-    if (para.typeOfCalib_ == "perRun") {
-      sa_size_t nr = calibBAOfactors_Off_Run_Ch0.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_Off_Ch0[(int)calibBAOfactors_Off_Run_Ch0(0,ir)]
-          = calibBAOfactors_Off_Run_Ch0(1,ir);
-      }
-      nr = calibBAOfactors_Off_Run_Ch1.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_Off_Ch1[(int)calibBAOfactors_Off_Run_Ch1(0,ir)]
-          = calibBAOfactors_Off_Run_Ch1(1,ir);
-      }
-
-      nr = calibBAOfactors_On_Run_Ch0.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_On_Ch0[(int)calibBAOfactors_On_Run_Ch0(0,ir)]
-          = calibBAOfactors_On_Run_Ch0(1,ir);
-      }
-      nr = calibBAOfactors_On_Run_Ch1.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_On_Ch1[(int)calibBAOfactors_On_Run_Ch1(0,ir)]
-          = calibBAOfactors_On_Run_Ch1(1,ir);
-      }
+    //We cannot rely on identical cycle list of the OFF and ON calibration
+    map<int,r_4> calibBAO_Off_Run_Ch0;
+    map<int,r_4> calibBAO_Off_Run_Ch1;
+    map<int,r_4> calibBAO_On_Run_Ch0;
+    map<int,r_4> calibBAO_On_Run_Ch1;
+
+    map<int,r_4> calibBAO_Off_Cycle_Ch0;
+    map<int,r_4> calibBAO_Off_Cycle_Ch1;
+    map<int,r_4> calibBAO_On_Cycle_Ch0;
+    map<int,r_4> calibBAO_On_Cycle_Ch1;
+
+    //per Run based BAO coefficients
+    nr = calibBAOfactors_Off_Run_Ch0.NRows();
+    for (sa_size_t ir=0; ir<nr; ++ir){
+      calibBAO_Off_Run_Ch0[(int)calibBAOfactors_Off_Run_Ch0(ir,0)]
+        = calibBAOfactors_Off_Run_Ch0(ir,1);
+      calibBAO_Off_Cycle_Ch0[(int)calibBAOfactors_Off_Cycle_Ch0(ir,0)]
+        = calibBAOfactors_Off_Cycle_Ch0(ir,1);
+      calibBAO_Off_Run_Ch1[(int)calibBAOfactors_Off_Run_Ch1(ir,0)]
+        = calibBAOfactors_Off_Run_Ch1(ir,1);
+      calibBAO_Off_Cycle_Ch1[(int)calibBAOfactors_Off_Cycle_Ch1(ir,0)]
+        = calibBAOfactors_Off_Cycle_Ch1(ir,1);
+    }
+    
+    nr = calibBAOfactors_On_Run_Ch0.NRows();
+    for (sa_size_t ir=0; ir<nr; ++ir){
+      calibBAO_On_Run_Ch0[(int)calibBAOfactors_On_Run_Ch0(ir,0)]
+        = calibBAOfactors_On_Run_Ch0(ir,1);
+      calibBAO_On_Cycle_Ch0[(int)calibBAOfactors_On_Cycle_Ch0(ir,0)]
+        = calibBAOfactors_On_Cycle_Ch0(ir,1);
+      calibBAO_On_Run_Ch1[(int)calibBAOfactors_On_Run_Ch1(ir,0)]
+        = calibBAOfactors_On_Run_Ch1(ir,1);
+      calibBAO_On_Cycle_Ch1[(int)calibBAOfactors_On_Cycle_Ch1(ir,0)]
+        = calibBAOfactors_On_Cycle_Ch1(ir,1);
+    }
       
-    } else if (para.typeOfCalib_ == "perCycle") {
-
-      sa_size_t nr = calibBAOfactors_Off_Cycle_Ch0.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_Off_Ch0[(int)calibBAOfactors_Off_Cycle_Ch0(0,ir)]
-          = calibBAOfactors_Off_Cycle_Ch0(1,ir);
-      }
-      nr = calibBAOfactors_Off_Cycle_Ch1.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_Off_Ch1[(int)calibBAOfactors_Off_Cycle_Ch1(0,ir)]
-          = calibBAOfactors_Off_Cycle_Ch1(1,ir);
-      }
-
-      nr = calibBAOfactors_On_Cycle_Ch0.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_On_Ch0[(int)calibBAOfactors_On_Cycle_Ch0(0,ir)]
-          = calibBAOfactors_On_Cycle_Ch0(1,ir);
-      }
-      nr = calibBAOfactors_On_Cycle_Ch1.NRows();
-      for (sa_size_t ir=0; ir<nr; ++ir){
-        calibBAO_On_Ch1[(int)calibBAOfactors_On_Cycle_Ch1(0,ir)]
-          = calibBAOfactors_On_Cycle_Ch1(1,ir);
-      }
-
-    } else {
-      throw "Unknow calibration type: " + para.typeOfCalib_;
-    }
-
 
     
@@ -635 +653 @@
     //Loop on cyles
     for (list<int>::iterator ic=commonCycles.begin(); ic!=commonCycles.end(); ++ic){
+
+      if(para.debuglev_>9){
+        cout << "Calibration coefficients for cycle "<<*ic << endl; 
+        cout << "Off Run Ch0 " << calibBAO_Off_Run_Ch0[*ic] << " "
+             << "Ch1 " << calibBAO_Off_Run_Ch1[*ic] << "\n"
+             << "On Run Ch0 " << calibBAO_On_Run_Ch0[*ic] << " "
+             << "Ch1 " << calibBAO_On_Run_Ch1[*ic] << "\n"
+             << "Off Cycle Ch0 " << calibBAO_Off_Cycle_Ch0[*ic] << " "
+             << "Ch1 " << calibBAO_Off_Cycle_Ch1[*ic] << "\n"
+             << "On Cycle Ch0 " << calibBAO_On_Cycle_Ch0[*ic] << " "
+             << "Ch1 " << calibBAO_On_Cycle_Ch1[*ic] << endl;
+      }
+      
       string ppftag;
       //load ON phase
@@ -641 +672 @@
       
       ppftag = "specRawOn"+cycle.str();
-      TMatrix<r_4> aSpecON(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);
-      fin.GetObject(aSpecON,ppftag);
-
+      TMatrix<r_4> aSpecOn(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);
+      fin.GetObject(aSpecOn,ppftag);
+
+      TMatrix<r_4> aSpecOn_BAOCalibRun(aSpecOn,false);
+      aSpecOn_BAOCalibRun(Range(0),Range::all()) /= calibBAO_On_Run_Ch0[*ic];
+      aSpecOn_BAOCalibRun(Range(1),Range::all()) /= calibBAO_On_Run_Ch1[*ic];
+
+      TMatrix<r_4> aSpecOn_BAOCalibCycle(aSpecOn,false);
+      aSpecOn_BAOCalibCycle(Range(0),Range::all()) /= calibBAO_On_Cycle_Ch0[*ic];
+      aSpecOn_BAOCalibCycle(Range(1),Range::all()) /= calibBAO_On_Cycle_Ch1[*ic];
       
-
-
-
       ppftag = "specRawOff"+cycle.str();
-      TMatrix<r_4> aSpecOFF(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);
-      fin.GetObject(aSpecOFF,ppftag);
+      TMatrix<r_4> aSpecOff(NUMBER_OF_CHANNELS,NUMBER_OF_FREQ);
+      fin.GetObject(aSpecOff,ppftag);
+
+      TMatrix<r_4> aSpecOff_BAOCalibRun(aSpecOff,false);
+      aSpecOff_BAOCalibRun(Range(0),Range::all()) /= calibBAO_Off_Run_Ch0[*ic];
+      aSpecOff_BAOCalibRun(Range(1),Range::all()) /= calibBAO_Off_Run_Ch1[*ic];
+
+      TMatrix<r_4> aSpecOff_BAOCalibCycle(aSpecOff,false);
+      aSpecOff_BAOCalibCycle(Range(0),Range::all()) /= calibBAO_Off_Cycle_Ch0[*ic];
+      aSpecOff_BAOCalibCycle(Range(1),Range::all()) /= calibBAO_Off_Cycle_Ch1[*ic];
+
+
+      //Perform the difference ON-OFF with the different calibration options
+      TMatrix<r_4> diffOnOff_noCalib = aSpecOn - aSpecOff;
+      meanDiffONOFF_noCalib += diffOnOff_noCalib;
       
+      TMatrix<r_4> diffOnOff_perRunCalib = aSpecOn_BAOCalibRun - aSpecOff_BAOCalibRun;
+      meanDiffONOFF_perRunCalib += diffOnOff_perRunCalib;
+
+      TMatrix<r_4> diffOnOff_perCycleCalib = aSpecOn_BAOCalibCycle - aSpecOff_BAOCalibCycle;
+      meanDiffONOFF_perCycleCalib += diffOnOff_perCycleCalib;
+
+      //Fill NTuple
+      xnt[0] = *ic;
+      
+      TVector<r_4> meanInRange_noCalib(NUMBER_OF_CHANNELS);
+      meanInRange(diffOnOff_noCalib,chLow,chHigh,meanInRange_noCalib);
+      xnt[1] = meanInRange_noCalib(0);
+      xnt[2] = meanInRange_noCalib(1);
+
+      TVector<r_4> meanInRange_perRunCalib(NUMBER_OF_CHANNELS);
+      meanInRange(diffOnOff_perRunCalib,chLow,chHigh,meanInRange_perRunCalib);
+      xnt[3] = meanInRange_perRunCalib(0);
+      xnt[4] = meanInRange_perRunCalib(1);
+
+      TVector<r_4> meanInRange_perCycleCalib(NUMBER_OF_CHANNELS);
+      meanInRange(diffOnOff_perCycleCalib,chLow,chHigh,meanInRange_perCycleCalib);
+      xnt[3] = meanInRange_perCycleCalib(0);
+      xnt[4] = meanInRange_perCycleCalib(1);
+      
+      onoffevolution.Fill(xnt);
+
       totalNumberCycles++;
-        
+      if (totalNumberCycles >= para.maxNumberCycles_) break;    
+
     }//eo loop on cycles
-
+    if (totalNumberCycles >= para.maxNumberCycles_) break;          
+  
   }//eo loop on spectra in a file
+  cout << "End of jobs: we have treated " << totalNumberCycles << " cycles" << endl;
+  //Normalisation
+  if(totalNumberCycles>0){
+    meanDiffONOFF_noCalib       /= (r_4)totalNumberCycles;
+    meanDiffONOFF_perRunCalib   /= (r_4)totalNumberCycles;
+    meanDiffONOFF_perCycleCalib /= (r_4)totalNumberCycles;
+  }  
+  
+  //Compute the reduced version of the mean and sigma
+  TMatrix<r_4> meanRedMtx_noCalib(NUMBER_OF_CHANNELS,para.nSliceInFreq_);
+  TMatrix<r_4> sigmaRedMtx_noCalib(NUMBER_OF_CHANNELS,para.nSliceInFreq_);
+  reduceSpectra(meanDiffONOFF_noCalib,meanRedMtx_noCalib,sigmaRedMtx_noCalib);
+
+  TMatrix<r_4> meanRedMtx_perRunCalib(NUMBER_OF_CHANNELS,para.nSliceInFreq_);
+  TMatrix<r_4> sigmaRedMtx_perRunCalib(NUMBER_OF_CHANNELS,para.nSliceInFreq_);
+  reduceSpectra(meanDiffONOFF_perRunCalib,meanRedMtx_perRunCalib,sigmaRedMtx_perRunCalib);
+
+  TMatrix<r_4> meanRedMtx_perCycleCalib(NUMBER_OF_CHANNELS,para.nSliceInFreq_);
+  TMatrix<r_4> sigmaRedMtx_perCycleCalib(NUMBER_OF_CHANNELS,para.nSliceInFreq_);
+  reduceSpectra(meanDiffONOFF_perCycleCalib,meanRedMtx_perCycleCalib,sigmaRedMtx_perCycleCalib);
+
+  {//save the results
+    stringstream tmp;
+    tmp << totalNumberCycles;
+    string fileName = para.outPath_+"/onoffsurvey_"+StringToLower(para.sourceName_)+"-"+tmp.str()+"Cycles.ppf";
+    POutPersist fos(fileName);
+
+    string tag = "meanNoCalib";
+    fos << PPFNameTag(tag) << meanDiffONOFF_noCalib;
+    tag = "meanPerRunCalib";
+    fos << PPFNameTag(tag) << meanDiffONOFF_perRunCalib;
+    tag = "meanPerCycleCalib";
+    fos << PPFNameTag(tag) << meanDiffONOFF_perCycleCalib;
+
+    tag = "redmeanNoCalib";
+    fos << PPFNameTag(tag) << meanRedMtx_noCalib;
+    tag = "redsigmaNoCalib";
+    fos << PPFNameTag(tag) << sigmaRedMtx_noCalib;
+
+    tag = "redmeanPerRunCalib";
+    fos << PPFNameTag(tag) << meanRedMtx_perRunCalib;
+    tag = "redsigmaPerRunCalib";
+    fos << PPFNameTag(tag) << sigmaRedMtx_perRunCalib;
+
+    tag = "redmeanPerCycleCalib";
+    fos << PPFNameTag(tag) << meanRedMtx_perCycleCalib;
+    tag = "redsigmaPerCycleCalib";
+    fos << PPFNameTag(tag) << sigmaRedMtx_perCycleCalib;
+    
+    tag = "onoffevol";
+    fos << PPFNameTag(tag) << onoffevolution;    
+  }//end of save
 }
 //-------------------------------------------------------
@@ -744 +872 @@
   
 
-  TArray<r_4> tableOfSpectra(NUMBER_OF_FREQ,NUMBER_OF_CHANNELS,TOTAL_NUM_CYCLES); //TOTAL_NUM_CYCLES should be large enough...
+  TArray<r_4> tableOfSpectra(NUMBER_OF_FREQ,NUMBER_OF_CHANNELS,para.maxNumberCycles_); //para.maxNumberCycles_ should be large enough...
 
   StringMatch match("specONOFFRaw[0-9]+"); //Tag of the PPF objects
@@ -765 +893 @@
     iSpecEnd = listOfSpectra.end();
     //Loop of spectra matrix
-    for (iSpec = listOfSpectra.begin(); iSpec !=iSpecEnd && (sa_size_t)nSpectra < TOTAL_NUM_CYCLES ;  ++iSpec){
+    for (iSpec = listOfSpectra.begin(); iSpec !=iSpecEnd && (sa_size_t)nSpectra < para.maxNumberCycles_ ;  ++iSpec){
       if (para.debuglev_>90){
         cout << " spactra <" << *iSpec << ">" << endl;
@@ -798 +926 @@
 
 
-  sa_size_t f1320=freqTochan(1320.);
-  sa_size_t f1345=freqTochan(1345.);
-  sa_size_t f1355=freqTochan(1355.);
-  sa_size_t f1380=freqTochan(1380.);
+  sa_size_t f1320=freqToChan(1320.);
+  sa_size_t f1345=freqToChan(1345.);
+  sa_size_t f1355=freqToChan(1355.);
+  sa_size_t f1380=freqToChan(1380.);
   //Compute baseline arround 1350Mhz on [1320-1345] U [1355-1380]
   if (para.debuglev_>9){
@@ -821 +949 @@
   }  
   meanMed.Print(cout);
+  cout << endl;
+
   
   //Compute the sigma in the range 1320MHz-1380MHz
@@ -840 +970 @@
   }
   sigmaMed.Print(cout);
+  cout << endl;
+
   
   
@@ -896 +1028 @@
   string typeOfCalib="perRun";
   string calibFreq = "1346";
-  
+  string calibBandFreq="6.25";
+  string mxcycles;
+
   //  bool okarg=false;
   int ka=1;
@@ -902 +1036 @@
     if (strcmp(arg[ka],"-h")==0) {
       cout << "Usage:  -act [meanRawDiffOnOff]|medianRawDiffOnOff|meanCalibBAODiffOnOff\n"
-           << " -calibopt [perRun]|perCcyle (cf. in case of calibration to be done)\n"
+           << " -mxcycles <number> (max. number of cycles to be treated)\n"
            << " -calibfreq <number> (cf. freq. used by calibration operation)\n"
+           << " -calibbandfreq <number> (cf. band of freq. used by calibration operation)\n"
            << " -src [Abell85]\n -inPath [.]|<top_root_dir of the ppf file>\n" 
            << " (ex. /sps/baoradio/AmasNancay/JEC/\n " 
@@ -921 +1056 @@
       ka+=2;
     }
-    else if (strcmp(arg[ka],"-calibopt")==0) {
-      typeOfCalib=arg[ka+1];
+    else if (strcmp(arg[ka],"-calibfreq")==0) {
+      calibFreq=arg[ka+1];
       ka+=2;
     }    
-    else if (strcmp(arg[ka],"-calibfreq")==0) {
-      calibFreq=arg[ka+1];
+    else if (strcmp(arg[ka],"-calibbandfreq")==0) {
+      calibBandFreq=arg[ka+1];
+      ka+=2;
+    }    
+    else if (strcmp(arg[ka],"-mxcycles")==0) {
+      mxcycles=arg[ka+1];
       ka+=2;
     }    
@@ -958 +1097 @@
   para.ppfFile_    = ppfFile;
   para.nSliceInFreq_ = atoi(nSliceInFreq.c_str());
-  para.typeOfCalib_ = typeOfCalib;
   para.calibFreq_   = calibFreq;
+  para.calibBandFreq_ = calibBandFreq;
+  para.rcalibFreq_   = atof(calibFreq.c_str());
+  para.rcalibBandFreq_ = atof(calibBandFreq.c_str());
+  if (mxcycles != "") {
+    para.maxNumberCycles_ = atoi(mxcycles.c_str());
+  } else {
+    para.maxNumberCycles_ = std::numeric_limits<int>::max();
+  }
 
   cout << "Dump Initial parameters ............" << endl;
   cout << " action = " << action << "\n"
+       << " maxNumberCycles = " << para.maxNumberCycles_ << "\n"
        << " inputPath = " << para.inPath_  << "\n" 
        << " outputPath = " <<  para.outPath_ << "\n"
@@ -968 +1115 @@
        << " ppfFile = " <<  para.ppfFile_ << "\n"
        << " nSliceInFreq = " << para.nSliceInFreq_  << "\n"
-       << " typeOfCalib = " << para.typeOfCalib_ << "\n"
        << " calibFreq = " <<  para.calibFreq_ << "\n"
+       << " calibBandFreq = " <<  para.calibBandFreq_ << "\n"
        << " debuglev = "  << para.debuglev_   << "\n";
   cout << "...................................." << endl;