remove unnecessary consts, add spaces or change comments
authorgconesab <gustavo.conesa.balbastre@cern.ch>
Wed, 20 Aug 2014 10:22:01 +0000 (12:22 +0200)
committergconesab <gustavo.conesa.balbastre@cern.ch>
Wed, 20 Aug 2014 10:24:09 +0000 (12:24 +0200)
EMCAL/AliCaloRawAnalyzer.cxx
EMCAL/AliCaloRawAnalyzer.h

index 60f7c67..9e0d1dc 100644 (file)
@@ -68,6 +68,7 @@ void
 AliCaloRawAnalyzer::SetTimeConstraint(const int min, const int max ) 
 {
   //Require that the bin if the maximum ADC value is between min and max (timebin)
+  
   if(  ( min > max ) || min > ALTROMAXSAMPLES  || max > ALTROMAXSAMPLES  )
     {
       AliWarning( Form( "Attempt to set Invalid time bin range (Min , Max) = (%d, %d), Ingored",  min, max ) ); 
@@ -83,7 +84,8 @@ AliCaloRawAnalyzer::SetTimeConstraint(const int min, const int max )
 UShort_t 
 AliCaloRawAnalyzer::Max(const UShort_t *data, const int length ) const
 {
-  //------------
+  // Get maximum of array
+  
   UShort_t tmpmax  = data[0];
 
   for(int i=0; i < length; i++)
@@ -98,7 +100,8 @@ AliCaloRawAnalyzer::Max(const UShort_t *data, const int length ) const
 
 
 void 
-AliCaloRawAnalyzer::SelectSubarray( const Double_t *data, const int length, const short maxindex,int *const first,  int *const last, const int cut) const
+AliCaloRawAnalyzer::SelectSubarray( const Double_t *data, int length, short maxindex,
+                                    int * first, int * last, int cut) const
 {
   //Selection of subset of data from one bunch that will be used for fitting or
   //Peak finding.  Go to the left and right of index of the maximum time bin
@@ -141,16 +144,20 @@ AliCaloRawAnalyzer::SelectSubarray( const Double_t *data, const int length, cons
 
   *first = tmpfirst;
   *last =  tmplast;
+  
   return;
 }
 
 
 
 Float_t 
-AliCaloRawAnalyzer::ReverseAndSubtractPed( const AliCaloBunchInfo *bunch, const UInt_t /*altrocfg1*/,  const UInt_t /*altrocfg2*/, double *outarray ) const
+AliCaloRawAnalyzer::ReverseAndSubtractPed( const AliCaloBunchInfo *bunch,
+                                           UInt_t /*altrocfg1*/, UInt_t /*altrocfg2*/,
+                                           double *outarray ) const
 {
   //Time sample comes in reversed order, revers them back
   //Subtract the baseline based on content of altrocfg1 and altrocfg2.
+  
   Int_t length =  bunch->GetLength(); 
   const UShort_t *sig = bunch->GetData();
 
@@ -167,9 +174,10 @@ AliCaloRawAnalyzer::ReverseAndSubtractPed( const AliCaloBunchInfo *bunch, const
 
 
 Float_t 
-AliCaloRawAnalyzer::EvaluatePedestal(const UShort_t * const data, const int /*length*/ ) const
+AliCaloRawAnalyzer::EvaluatePedestal(const UShort_t * data, int /*length*/ ) const
 {
-  //  double ped = 0;
+  //  Pedestal evaluation if not zero suppressed
+  
   double tmp = 0;
 
   if( fIsZerosupressed == false ) 
@@ -185,9 +193,10 @@ AliCaloRawAnalyzer::EvaluatePedestal(const UShort_t * const data, const int /*le
 
 
 short  
-AliCaloRawAnalyzer::Max( const AliCaloBunchInfo *const bunch , int *const maxindex ) const
+AliCaloRawAnalyzer::Max( const AliCaloBunchInfo * bunch , int * maxindex ) const
 {
-  //comment
+  // Get maximum in bunch array
+  
   short tmpmax = -1;
   int tmpindex = -1;
   const UShort_t *sig = bunch->GetData();
@@ -239,7 +248,8 @@ AliCaloRawAnalyzer::CheckBunchEdgesForMax( const AliCaloBunchInfo *const bunch )
 
 
 int 
-AliCaloRawAnalyzer::SelectBunch( const vector<AliCaloBunchInfo> &bunchvector, short *const maxampbin, short *const maxamplitude )
+AliCaloRawAnalyzer::SelectBunch( const vector<AliCaloBunchInfo> &bunchvector,
+                                 short * maxampbin, short * maxamplitude )
 {
   //We select the bunch with the highest amplitude unless any time constraints is set
   short max = -1;
@@ -288,7 +298,7 @@ AliCaloRawAnalyzer::IsInTimeRange( const int maxindex, const int maxtindx, const
 void 
 AliCaloRawAnalyzer::PrintBunches( const vector<AliCaloBunchInfo> &bvctr ) 
 {
-  //comment
+  // Print bunch vector info
   cout << __FILE__ << __LINE__<< "*************** Printing Bunches *******************" << endl;
   cout << __FILE__ << __LINE__<< "*** There are " << bvctr.size() << ", bunches" << endl;
 
@@ -304,7 +314,7 @@ AliCaloRawAnalyzer::PrintBunches( const vector<AliCaloBunchInfo> &bvctr )
 void 
 AliCaloRawAnalyzer::PrintBunch( const AliCaloBunchInfo &bunch )
 {
-  //comment
+  // Print bunch infor
   cout << __FILE__ << ":" << __LINE__ << endl;
   cout << __FILE__ << __LINE__   << ", startimebin = " << bunch.GetStartBin() << ", length =" <<  bunch.GetLength() << endl;
   const UShort_t *sig =  bunch.GetData();  
@@ -318,10 +328,9 @@ AliCaloRawAnalyzer::PrintBunch( const AliCaloBunchInfo &bunch )
 
 
 Double_t
-AliCaloRawAnalyzer::CalculateChi2(const Double_t amp, const Double_t time,
-                                 const Int_t first, const Int_t last,
-                                 const Double_t adcErr, 
-                                 const Double_t tau) const
+AliCaloRawAnalyzer::CalculateChi2( Double_t amp,    Double_t time,
+                                   Int_t    first,  Int_t    last,
+                                   Double_t adcErr, Double_t tau) const
 {
   //   Input:
   //   amp   - max amplitude;
@@ -365,8 +374,8 @@ AliCaloRawAnalyzer::CalculateChi2(const Double_t amp, const Double_t time,
 
 
 void
-AliCaloRawAnalyzer::CalculateMeanAndRMS(const Int_t first, const Int_t last,
-                                       Double_t & mean, Double_t & rms)
+AliCaloRawAnalyzer::CalculateMeanAndRMS(Int_t first, Int_t last,
+                                        Double_t & mean, Double_t & rms)
 {
   //   Input:
   //   first, last - sample array indices to be used
@@ -407,10 +416,14 @@ AliCaloRawAnalyzer::CalculateMeanAndRMS(const Int_t first, const Int_t last,
 
 
 int
-AliCaloRawAnalyzer::PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector, const UInt_t altrocfg1,  
-                                          const UInt_t altrocfg2, Int_t & index, Float_t & maxf, short & maxamp, 
-                                          short & maxrev, Float_t & ped, int & first, int & last,const int acut )
-{ // method to do the selection of what should possibly be fitted
+AliCaloRawAnalyzer::PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector,
+                                          UInt_t altrocfg1, UInt_t altrocfg2, Int_t & index,
+                                          Float_t & maxf, short & maxamp,
+                                          short & maxrev, Float_t & ped,
+                                          int & first, int & last, int acut )
+{
+  // method to do the selection of what should possibly be fitted
+  
   int nsamples  = 0;
   short maxampindex = 0;
   index = SelectBunch( bunchvector,  &maxampindex,  &maxamp ); // select the bunch with the highest amplitude unless any time constraints is set
index 5aa5b97..4745718 100644 (file)
@@ -43,52 +43,65 @@ public:
   virtual ~AliCaloRawAnalyzer() { ; }
 
   virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &/*bunchvector*/, 
-                                     const UInt_t /*altrocfg1*/,  const UInt_t /*altrocfg2*/ )  = 0;
+                                      UInt_t /*altrocfg1*/,  UInt_t /*altrocfg2*/ )  = 0;
 
   static void PrintBunches( const std::vector<AliCaloBunchInfo> &bunchvector );
-  static void PrintBunch( const AliCaloBunchInfo &bunch );
+  static void PrintBunch  ( const AliCaloBunchInfo &bunch );
   
   int PreFitEvaluateSamples( const std::vector<AliCaloBunchInfo>  &bunchvector, 
-                                    const UInt_t altrocfg1,  const UInt_t altrocfg2, Int_t & index, 
-                                    Float_t & maxf, short & maxamp, short & maxampindex, 
-                                   Float_t & ped, int & first, int & last, const int acut);
+                             UInt_t altrocfg1, UInt_t altrocfg2, Int_t & index,
+                             Float_t & maxf, short & maxamp, short & maxampindex,
+                             Float_t & ped, int & first, int & last, int acut);
   
-  void SetTimeConstraint(const int min, const int max );
-  void SetVerbose(bool verbose = true){ fVerbose = verbose; };
-  void SetIsZeroSuppressed(const bool iszs = true) { fIsZerosupressed = iszs; } ;
-  void SetAmpCut(const Float_t cut) { fAmpCut = cut ; } ;
-  void SetFitArrayCut(const Int_t cut) { fFitArrayCut = cut ; } ;
-  void SetNsampleCut(const Int_t cut) { fNsampleCut = cut ; } ;
-  void SetOverflowCut(const Int_t cut) { fOverflowCut = cut ; } ;
-  void SetNsamplePed(const Int_t i) { fNsamplePed = i ; } ;
+  void SetTimeConstraint  (int min, int max );
+  void SetVerbose         (bool verbose = true){ fVerbose     = verbose; }
+  void SetIsZeroSuppressed(bool iszs = true)   { fIsZerosupressed = iszs ; }
+  void SetAmpCut     (Float_t cut)             { fAmpCut      = cut ; }
+  void SetFitArrayCut(Int_t cut)               { fFitArrayCut = cut ; }
+  void SetNsampleCut (Int_t cut)               { fNsampleCut  = cut ; }
+  void SetOverflowCut(Int_t cut)               { fOverflowCut = cut ; }
+  void SetNsamplePed (Int_t i)                 { fNsamplePed  = i   ; }
+  void SetL1Phase    (Double_t phase)          { fL1Phase     = phase ; }
 
-  bool GetIsZeroSuppressed() const { return fIsZerosupressed;} ;
-  Float_t GetAmpCut() const { return fAmpCut; } ;
-  Int_t GetFitArrayCut() const { return fFitArrayCut; } ;
-  Int_t GetNsampleCut() const { return fNsampleCut; } ;
-  Int_t GetOverflowCut() const { return fOverflowCut; } ;
-  Int_t GetNsamplePed() const { return fNsamplePed; } ;
+  bool    GetIsZeroSuppressed() const { return fIsZerosupressed;}
+  Float_t GetAmpCut()      const { return fAmpCut      ; }
+  Int_t   GetFitArrayCut() const { return fFitArrayCut ; }
+  Int_t   GetNsampleCut()  const { return fNsampleCut  ; }
+  Int_t   GetOverflowCut() const { return fOverflowCut ; }
+  Int_t   GetNsamplePed()  const { return fNsamplePed  ; }
 
   // access to array info
   Double_t GetReversed(const int i) const { return fReversed[i]; }
-  const char * GetAlgoName() const { return fName;  };
-  const char * GetAlgoAbbr() const { return fNameShort;  };
-  Algo::fitAlgorithm GetAlgo() const { return fAlgo; };
+  const char * GetAlgoName()   const { return fName      ; }
+  const char * GetAlgoAbbr()   const { return fNameShort ; }
+  Algo::fitAlgorithm GetAlgo() const { return fAlgo      ; }
 
   Double_t CalculateChi2(const Double_t amp, const Double_t time,
-                        const Int_t first, const Int_t last,
-                        const Double_t adcErr=1, 
-                        const Double_t tau=2.35) const;
+                         const Int_t first, const Int_t last,
+                         const Double_t adcErr=1,
+                         const Double_t tau=2.35) const;
+  
   void CalculateMeanAndRMS(const Int_t first, const Int_t last,
-                          Double_t & mean, Double_t & rms);
-  void SetL1Phase(const Double_t phase) {fL1Phase = phase;};
-  short Max( const AliCaloBunchInfo *const bunch, int *const maxindex) const;
+                           Double_t & mean, Double_t & rms);
+  
+  short Max( const AliCaloBunchInfo *const bunch, int * maxindex) const;
+  
   UShort_t Max(const UShort_t *data, const int length ) const;
+  
   bool CheckBunchEdgesForMax( const AliCaloBunchInfo *const bunch) const;
+  
   bool IsInTimeRange( const int maxindex, const int maxtime, const int mintime ) const;
-  Float_t  ReverseAndSubtractPed( const AliCaloBunchInfo *bunch, const UInt_t altrocfg1,  const UInt_t altrocfg2, double *outarray ) const;
-  int  SelectBunch( const std::vector<AliCaloBunchInfo> &bunchvector, short *const maxampbin, short *const maxamplitude );
-  void SelectSubarray( const Double_t *date, const int length, const short maxindex, int *const  first, int *const last, const int cut) const;
+  
+  Float_t  ReverseAndSubtractPed( const AliCaloBunchInfo *bunch,
+                                  UInt_t altrocfg1,  UInt_t altrocfg2,
+                                  double *  outarray ) const;
+  
+  int  SelectBunch( const std::vector<AliCaloBunchInfo> &bunchvector,
+                    short * maxampbin, short * maxamplitude );
+  
+  void SelectSubarray( const Double_t *date, int length, short maxindex,
+                       int * first, int * last, int cut) const;
+  
   Float_t EvaluatePedestal(const UShort_t * const data, const int length ) const;
   
   // Used in AliCaloRawAnalyzerFitter
@@ -107,10 +120,13 @@ protected:
   int fOverflowCut; // value when ADC starts to saturate
   int fNsamplePed;   //Number of samples used for pedestal calculation (first in bunch) 
   bool fIsZerosupressed; //Wether or not the data is zeros supressed, by default its assumed that the baseline is also subtracted if set to true
+  
   bool fVerbose;     //Print debug information to std out if set to true
   char fName[256]; // Name of the algorithm
   char fNameShort[256]; // Abbrevation for the name
+  
   Algo::fitAlgorithm fAlgo; // Which algorithm to use
+
   Double_t fL1Phase; // Phase of the ADC sampling clock relative to the LHC clock
   Double_t fAmp;     // The amplitude in entities of ADC counts
   Double_t fTof;     // The amplitude in entities of ADC counts