cosmetic changes, remove unneeded consts

diff --git a/EMCAL/AliCaloRawAnalyzerCrude.cxx b/EMCAL/AliCaloRawAnalyzerCrude.cxx
index a753498dba0645ffcf99c4246148cdae101ef0e9..27cf481550837af2b26b5233c0794012b55268ef 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerCrude.cxx
+++ b/EMCAL/AliCaloRawAnalyzerCrude.cxx
@@ -33,17 +33,11 @@ ClassImp(AliCaloRawAnalyzerCrude)
 
 AliCaloRawAnalyzerCrude::AliCaloRawAnalyzerCrude() : AliCaloRawAnalyzer("Crude", "Crude")
 {
-  //Comment
+  // Ctor
+  
   fAlgo=Algo::kCrude;
 }
 
-
-AliCaloRawAnalyzerCrude::~AliCaloRawAnalyzerCrude()
-{
-  //Comment
-}
-
-
 AliCaloFitResults
 AliCaloRawAnalyzerCrude::Evaluate(const vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2)
 {

diff --git a/EMCAL/AliCaloRawAnalyzerCrude.h b/EMCAL/AliCaloRawAnalyzerCrude.h
index 0d4b6635966dd2ccd81f99e5e8eada1a207a8af4..2ffdb703f7a24a3649943eda60dc697cce355d31 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerCrude.h
+++ b/EMCAL/AliCaloRawAnalyzerCrude.h
@@ -37,10 +37,12 @@ class  AliCaloRawAnalyzerCrude : public  AliCaloRawAnalyzer
 
  public:
    AliCaloRawAnalyzerCrude(); 
-  virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, 
+
+  virtual ~AliCaloRawAnalyzerCrude() { ; }
+  
+  virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
                                       const UInt_t altrocfg1,  const UInt_t altrocfg2 );
-  virtual ~AliCaloRawAnalyzerCrude();
- 
+  
  private:
   ClassDef(AliCaloRawAnalyzerCrude, 1)  
 };

diff --git a/EMCAL/AliCaloRawAnalyzerFactory.cxx b/EMCAL/AliCaloRawAnalyzerFactory.cxx
index dc65a1cb323a0267ab84c683560692c719344491..8c99c898b3710ed74bb90528367b95e7205066cd 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerFactory.cxx
+++ b/EMCAL/AliCaloRawAnalyzerFactory.cxx
@@ -34,9 +34,10 @@ AliCaloRawAnalyzerFactory::AliCaloRawAnalyzerFactory()
 AliCaloRawAnalyzer*
 AliCaloRawAnalyzerFactory::CreateAnalyzer( const int algo )
 {
-  // return new AliCaloRawAnalyzerKStandard();
-  switch ( algo) 
-    {
+  // Return the requested algorithm
+  
+  switch ( algo)
+  {
     case  kFastFit:
       return new  AliCaloRawAnalyzerFastFit();
       break;

diff --git a/EMCAL/AliCaloRawAnalyzerFakeALTRO.cxx b/EMCAL/AliCaloRawAnalyzerFakeALTRO.cxx
index 5d21ed809d3863f77dc81b59d47a25cdbfda5f25..3e8107b6af233f8407c5eb20ecaa29a4ccd465db 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerFakeALTRO.cxx
+++ b/EMCAL/AliCaloRawAnalyzerFakeALTRO.cxx
@@ -49,9 +49,11 @@ AliCaloRawAnalyzerFakeALTRO::~AliCaloRawAnalyzerFakeALTRO()
 }
 
 AliCaloFitResults
-AliCaloRawAnalyzerFakeALTRO::Evaluate( const vector<AliCaloBunchInfo>  &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2 )
+AliCaloRawAnalyzerFakeALTRO::Evaluate( const vector<AliCaloBunchInfo>  &bunchvector,
+                                      UInt_t altrocfg1, UInt_t altrocfg2 )
 {
   // Extracting signal parameters using fitting
+  
   short maxampindex; //index of maximum amplitude
   short maxamp; //Maximum amplitude
   int index = SelectBunch( bunchvector,  &maxampindex,  &maxamp );

diff --git a/EMCAL/AliCaloRawAnalyzerFakeALTRO.h b/EMCAL/AliCaloRawAnalyzerFakeALTRO.h
index 55d58367b86f916ce16b657195c184b0fbb9e82a..e78357653fd379afcef369953156a884cd3367cb 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerFakeALTRO.h
+++ b/EMCAL/AliCaloRawAnalyzerFakeALTRO.h
@@ -16,13 +16,18 @@ class  AliCaloRawAnalyzerFakeALTRO : public AliCaloRawAnalyzerFitter
   friend class AliCaloRawAnalyzerFactory;
 
  public:
+  
   virtual ~AliCaloRawAnalyzerFakeALTRO();
-  virtual AliCaloFitResults  Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2 );
+  
+  virtual AliCaloFitResults  Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
+                                       UInt_t altrocfg1,
+                                       UInt_t altrocfg2 );
   
  private:
+  
   AliCaloRawAnalyzerFakeALTRO();
-  AliCaloRawAnalyzerFakeALTRO(const AliCaloRawAnalyzerFakeALTRO & );
-  AliCaloRawAnalyzerFakeALTRO  & operator = (const AliCaloRawAnalyzerFakeALTRO  &);
+  AliCaloRawAnalyzerFakeALTRO(               const AliCaloRawAnalyzerFakeALTRO & );
+  AliCaloRawAnalyzerFakeALTRO  & operator = (const AliCaloRawAnalyzerFakeALTRO & );
   ClassDef(AliCaloRawAnalyzerFakeALTRO,1)
 
 };

diff --git a/EMCAL/AliCaloRawAnalyzerFastFit.cxx b/EMCAL/AliCaloRawAnalyzerFastFit.cxx
index 65a0b161cfa4290a39b353e98c4f016f038fd3b6..c775db79b83098e7a0e76e68220401fa813199bb 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerFastFit.cxx
+++ b/EMCAL/AliCaloRawAnalyzerFastFit.cxx
@@ -45,7 +45,7 @@ AliCaloRawAnalyzerFastFit::AliCaloRawAnalyzerFastFit() : AliCaloRawAnalyzerFitte
 
 AliCaloFitResults 
 AliCaloRawAnalyzerFastFit::Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
-                                   const UInt_t altrocfg1,  const UInt_t altrocfg2 )
+                                     UInt_t altrocfg1, UInt_t altrocfg2 )
 {
   // Execute algorithm
   

diff --git a/EMCAL/AliCaloRawAnalyzerFastFit.h b/EMCAL/AliCaloRawAnalyzerFastFit.h
index b20ba871f0a2a819a3e5f3d74d439431b3b296e8..a82f38b621c1dce020b2779b8eb133d988335e9d 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerFastFit.h
+++ b/EMCAL/AliCaloRawAnalyzerFastFit.h
@@ -28,14 +28,14 @@
 
 class  AliCaloRawAnalyzerFastFit : public AliCaloRawAnalyzerFitter
 {
-  friend class  AliCaloRawAnalyzerFactory; // comment
+  friend class  AliCaloRawAnalyzerFactory; // RuleChecker request
   
  public:
   
   virtual ~AliCaloRawAnalyzerFastFit() { ; }
   
   virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
-                                      const UInt_t altrocfg1,  const UInt_t altrocfg2 );
+                                      UInt_t altrocfg1, UInt_t altrocfg2 );
 
 private:
 

diff --git a/EMCAL/AliCaloRawAnalyzerFitter.h b/EMCAL/AliCaloRawAnalyzerFitter.h
index 1a981887d6b5d065bbe9be0bfc4cbee03bec2178..fafac0646b87d55c939a6a68252453477f6dd759 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerFitter.h
+++ b/EMCAL/AliCaloRawAnalyzerFitter.h
@@ -32,7 +32,9 @@ class  TGraph;
 class  AliCaloRawAnalyzerFitter : public AliCaloRawAnalyzer
 {
 public:
+  
   AliCaloRawAnalyzerFitter( const char *name, const char *nameshort );
+
   virtual ~AliCaloRawAnalyzerFitter();
 
   TF1 * GetFit() const { return fTf1; };

diff --git a/EMCAL/AliCaloRawAnalyzerKStandard.cxx b/EMCAL/AliCaloRawAnalyzerKStandard.cxx
index 1752a1d011faa4c28aebb1bd5c63e3914023d6ba..0abcd7b3f3403317c8312af37fb1dfe12b274bcd 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerKStandard.cxx
+++ b/EMCAL/AliCaloRawAnalyzerKStandard.cxx
@@ -57,7 +57,7 @@ AliCaloRawAnalyzerKStandard::~AliCaloRawAnalyzerKStandard()
 
 
 AliCaloFitResults
-AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo>  &bunchlist, const UInt_t altrocfg1,  const UInt_t altrocfg2 )
+AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo>  &bunchlist, UInt_t altrocfg1, UInt_t altrocfg2 )
 {
   //Evaluation Amplitude and TOF
   Float_t pedEstimate  = 0;
@@ -119,7 +119,8 @@ AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo>  &bunchlis
 
        
 void
- AliCaloRawAnalyzerKStandard::FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const 
+ AliCaloRawAnalyzerKStandard::FitRaw( Int_t firstTimeBin, Int_t lastTimeBin,
+                                      Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const
 { 
   // Fits the raw signal time distribution
   int nsamples = lastTimeBin - firstTimeBin + 1;

diff --git a/EMCAL/AliCaloRawAnalyzerKStandard.h b/EMCAL/AliCaloRawAnalyzerKStandard.h
index a46eaa7d7450780acb5966f4a8ffd732b03df406..6e9cb83a1448044ddbc7d88ec7f88d7c93682fd4 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerKStandard.h
+++ b/EMCAL/AliCaloRawAnalyzerKStandard.h
@@ -27,18 +27,26 @@ class  TGraph;
 
 class  AliCaloRawAnalyzerKStandard : public AliCaloRawAnalyzerFitter
 {
-  friend class AliCaloRawAnalyzerFactory; // Factory for creation of raw analyzer (= shutting up the rule checker )
+  friend class AliCaloRawAnalyzerFactory; // Factory for creation of raw analyzer (rule checker request)
   
  public:
+  
   virtual ~AliCaloRawAnalyzerKStandard();
-  virtual AliCaloFitResults  Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2 );
-  void FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, 
-             Float_t & chi2, Bool_t & fitDone) const ;
+  
+  virtual AliCaloFitResults  Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
+                                       UInt_t altrocfg1,
+                                       UInt_t altrocfg2 );
+  
+  void FitRaw( Int_t firstTimeBin, Int_t lastTimeBin,
+               Float_t & amp,  Float_t & time,
+               Float_t & chi2, Bool_t & fitDone) const ;
  
  private:
+  
   AliCaloRawAnalyzerKStandard();
-  AliCaloRawAnalyzerKStandard(const AliCaloRawAnalyzerKStandard & );
-  AliCaloRawAnalyzerKStandard  & operator = (const AliCaloRawAnalyzerKStandard  &);
+  AliCaloRawAnalyzerKStandard(               const AliCaloRawAnalyzerKStandard & );
+  AliCaloRawAnalyzerKStandard  & operator = (const AliCaloRawAnalyzerKStandard & );
+  
   ClassDef(AliCaloRawAnalyzerKStandard, 2)
 };
 

diff --git a/EMCAL/AliCaloRawAnalyzerNN.cxx b/EMCAL/AliCaloRawAnalyzerNN.cxx
index 69825b6e0aa021198417e3163679be5efd1d9d72..5e79beb2aa9f45b7ea46298f32a699008cfad678 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerNN.cxx
+++ b/EMCAL/AliCaloRawAnalyzerNN.cxx
@@ -37,7 +37,8 @@ ClassImp( AliCaloRawAnalyzerNN )
 
 AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network", "NN"), fNeuralNet(0)
 {
-  // Comment
+  // Ctor
+  
   fAlgo=Algo::kNeuralNet;
 
   fNeuralNet = new AliCaloNeuralFit();
@@ -52,13 +53,14 @@ AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Networ
 
 AliCaloRawAnalyzerNN::~AliCaloRawAnalyzerNN()
 {
+  // Dtor
   delete fNeuralNet;
 }
 
 
 AliCaloFitResults 
 AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
-                                      const UInt_t altrocfg1,  const UInt_t altrocfg2 )
+                                UInt_t altrocfg1,  UInt_t altrocfg2 )
 {
   // The eveluation of  Peak position and amplitude using the Neural Network
   if( bunchvector.size()  <=  0 )

diff --git a/EMCAL/AliCaloRawAnalyzerNN.h b/EMCAL/AliCaloRawAnalyzerNN.h
index 87d60854dee68aa2f7d98b1e32eb9a340cccc4bc..a9e4b49b4fc3d63cc4df4c165c069d2d9286ea53 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerNN.h
+++ b/EMCAL/AliCaloRawAnalyzerNN.h
@@ -29,21 +29,22 @@ class AliCaloBunchInfo;
 class AliCaloFitResults;
 class AliCaloNeuralFit;
 
-
 class  AliCaloRawAnalyzerNN : public AliCaloRawAnalyzer
 {
   friend class AliCaloRawAnalyzerFactory; // self explanatory
+  
  public:
-  // AliCaloRawAnalyzerNN();
+  
   virtual ~AliCaloRawAnalyzerNN();
   virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, 
-                                      const UInt_t altrocfg1,  const UInt_t altrocfg2 );
-  //  virtual void SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const  first, int *const last ) const;
+                                      UInt_t altrocfg1, UInt_t altrocfg2 );
 
  private:
+
   AliCaloRawAnalyzerNN();
-  AliCaloRawAnalyzerNN( const AliCaloRawAnalyzerNN   & );
-  AliCaloRawAnalyzerNN   & operator = ( const  AliCaloRawAnalyzerNN  & );
+  AliCaloRawAnalyzerNN(                 const AliCaloRawAnalyzerNN & );
+  AliCaloRawAnalyzerNN   & operator = ( const AliCaloRawAnalyzerNN & );
+  
   AliCaloNeuralFit *fNeuralNet; // pointer to the class whick actually implements the Neural Network for EMCAL
   Double_t fNNInput[5]; // The 5 input Neurons to the network ( mix bin + to samples on each side )
   ClassDef( AliCaloRawAnalyzerNN, 1 )

diff --git a/EMCAL/AliCaloRawAnalyzerPeakFinder.cxx b/EMCAL/AliCaloRawAnalyzerPeakFinder.cxx
index 0facb60dfc221f77dcbb8405d88230dbe61d25a2..e8bc413026a5babdcd1e56af0b941c1dce375363 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerPeakFinder.cxx
+++ b/EMCAL/AliCaloRawAnalyzerPeakFinder.cxx
@@ -21,10 +21,10 @@
 // The amplitude is extracted  as a
 // weighted sum of the samples using the 
 // best possible weights.
-// The wights is calculated only once and the
-// Actual extraction of amplitude and peak position
-// Is done with a simple vector multiplication, allowing for
-// Extreemely fast computations. 
+// The weights are calculated only once and the
+// actual extraction of amplitude and peak position
+// is done with a simple vector multiplication, allowing
+// extremely fast computations.
 
 #include "AliCaloRawAnalyzerPeakFinder.h"
 #include "AliCaloBunchInfo.h"
@@ -39,8 +39,6 @@
 
 using namespace std;
 
-
-
 ClassImp( AliCaloRawAnalyzerPeakFinder )
 
 
@@ -49,7 +47,7 @@ AliCaloRawAnalyzerPeakFinder::AliCaloRawAnalyzerPeakFinder() :AliCaloRawAnalyzer
                                                              fRunOnAlien(false),
                                                              fIsInitialized(false)
 {
-  //Comment
+  // Ctor
   fAlgo= Algo::kPeakFinder;
   fPeakFinderVectors = new AliCaloPeakFinderVectors() ;
   ResetVectors();
@@ -76,12 +74,6 @@ AliCaloRawAnalyzerPeakFinder::ResetVectors()
 }
 
 
-AliCaloRawAnalyzerPeakFinder::~AliCaloRawAnalyzerPeakFinder()
-{
-  //comment
-}
-
-
 Double_t  
 AliCaloRawAnalyzerPeakFinder::ScanCoarse(const Double_t *const array, const int length ) const
 {

diff --git a/EMCAL/AliCaloRawAnalyzerPeakFinder.h b/EMCAL/AliCaloRawAnalyzerPeakFinder.h
index a46a9964958740911b8164803e22bb47f91eefe3..510bf035f99307c3faf948f319af721a0280c7f4 100644 (file)
--- a/EMCAL/AliCaloRawAnalyzerPeakFinder.h
+++ b/EMCAL/AliCaloRawAnalyzerPeakFinder.h
@@ -32,30 +32,40 @@ class AliCaloPeakFinderVectors;
 
 class  AliCaloRawAnalyzerPeakFinder : public AliCaloRawAnalyzer
 {
-  friend class AliCaloRawAnalyzerFactory; // shutting up the rule checker
+  friend class AliCaloRawAnalyzerFactory; // rule checker request
+  
  public:
-  virtual ~AliCaloRawAnalyzerPeakFinder();
+  
+  virtual ~AliCaloRawAnalyzerPeakFinder() { ; }
+  
   virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, 
-                                     const UInt_t altrocfg1,  const UInt_t altrocfg2 );
+                                      UInt_t altrocfg1, UInt_t altrocfg2 );
 
  private:
+  
   AliCaloRawAnalyzerPeakFinder();
-  AliCaloRawAnalyzerPeakFinder( const AliCaloRawAnalyzerPeakFinder   & );
-  AliCaloRawAnalyzerPeakFinder   & operator = ( const  AliCaloRawAnalyzerPeakFinder  & );
+  AliCaloRawAnalyzerPeakFinder(                const AliCaloRawAnalyzerPeakFinder & );
+  AliCaloRawAnalyzerPeakFinder  & operator = ( const AliCaloRawAnalyzerPeakFinder & );
+  
   void     LoadVectorsOCDB();
-  void     CopyVectors(const AliCaloPeakFinderVectors *const pfvectors );
+  void     CopyVectors(const AliCaloPeakFinderVectors * pfvectors );
   void     ResetVectors();
   void     WriteRootFile() const;
-  void PrintVectors();
-  Double_t ScanCoarse(const Double_t *const array, const int length ) const ; // Find a rough estimate of peak position and t0
-  Double_t fPFAmpVectorsCoarse[PF::MAXSTART][PF::SAMPLERANGE][100];  // Vectors for Amplitude extraction, first iteration
-  Double_t fPFTofVectorsCoarse[PF::MAXSTART][PF::SAMPLERANGE][100];  // Vectors for TOF extraction, first iteration
-  Double_t fPFAmpVectors[PF::MAXSTART][PF::SAMPLERANGE][100];        // Vectors for Amplitude extraction, second iteration
-  Double_t fPFTofVectors[PF::MAXSTART][PF::SAMPLERANGE][100];        // Vectors for TOF extraction, second iteration
-  AliCaloPeakFinderVectors  *fPeakFinderVectors; // Collection of Peak-Fincer vectors
-  bool fRunOnAlien; // Wether or not we are running on the GRID
+  void     PrintVectors();
+  Double_t ScanCoarse( const Double_t *array, Int_t  length ) const ; // Find a rough estimate of peak position and t0
+  
+  Double_t fPFAmpVectorsCoarse[PF::MAXSTART][PF::SAMPLERANGE][100];   // Vectors for Amplitude extraction, first iteration
+  Double_t fPFTofVectorsCoarse[PF::MAXSTART][PF::SAMPLERANGE][100];   // Vectors for TOF extraction, first iteration
+  Double_t fPFAmpVectors      [PF::MAXSTART][PF::SAMPLERANGE][100];   // Vectors for Amplitude extraction, second iteration
+  Double_t fPFTofVectors      [PF::MAXSTART][PF::SAMPLERANGE][100];   // Vectors for TOF extraction, second iteration
+  
+  AliCaloPeakFinderVectors * fPeakFinderVectors; // Collection of Peak-Fincer vectors
+  
+  bool fRunOnAlien;    // Wether or not we are running on the GRID
   bool fIsInitialized; // init flag
+ 
   ClassDef( AliCaloRawAnalyzerPeakFinder, 1 )
+  
 };