coverity: remove unnecesary consts in methods declaration
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Nov 2013 13:05:10 +0000 (13:05 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 29 Nov 2013 13:05:10 +0000 (13:05 +0000)
21 files changed:
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.cxx
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrMaker.cxx
PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrMaker.h
PWG/CaloTrackCorrBase/AliAnaScale.h
PWG/CaloTrackCorrBase/AliCaloPID.cxx
PWG/CaloTrackCorrBase/AliCaloPID.h
PWG/CaloTrackCorrBase/AliCaloTrackMCReader.cxx
PWG/CaloTrackCorrBase/AliCaloTrackMCReader.h
PWG/CaloTrackCorrBase/AliCaloTrackReader.cxx
PWG/CaloTrackCorrBase/AliCaloTrackReader.h
PWG/CaloTrackCorrBase/AliCalorimeterUtils.cxx
PWG/CaloTrackCorrBase/AliCalorimeterUtils.h
PWG/CaloTrackCorrBase/AliFiducialCut.cxx
PWG/CaloTrackCorrBase/AliFiducialCut.h
PWG/CaloTrackCorrBase/AliIsolationCut.cxx
PWG/CaloTrackCorrBase/AliIsolationCut.h
PWG/CaloTrackCorrBase/AliMCAnalysisUtils.cxx
PWG/CaloTrackCorrBase/AliMCAnalysisUtils.h
PWG/CaloTrackCorrBase/AliNeutralMesonSelection.cxx
PWG/CaloTrackCorrBase/AliNeutralMesonSelection.h

index b74d051..2298380 100755 (executable)
@@ -112,9 +112,8 @@ void AliAnaCaloTrackCorrBaseClass::AddAODParticle(AliAODPWG4Particle pc)
   
 }      
 
-//_______________________________________________________________________________
-Int_t AliAnaCaloTrackCorrBaseClass::CheckMixedEventVertex(const Int_t caloLabel, 
-                                                          const Int_t trackLabel)
+//__________________________________________________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::CheckMixedEventVertex(Int_t caloLabel, Int_t trackLabel)
 {
   // Check vertex in mixed events
   
@@ -204,9 +203,9 @@ void AliAnaCaloTrackCorrBaseClass::ConnectInputOutputAODBranches()
   }
 }
 
-//__________________________________________________________________________________________
-AliVCluster * AliAnaCaloTrackCorrBaseClass::FindCluster(TObjArray* clusters, const Int_t id, 
-                                                        Int_t & iclus, const Int_t first) 
+//_____________________________________________________________________________________
+AliVCluster * AliAnaCaloTrackCorrBaseClass::FindCluster(TObjArray* clusters, Int_t id,
+                                                        Int_t & iclus, Int_t first)
 {
   // Given the cluster ID stored in AliAODPWG4Particle, get the originator cluster and its index in the array
   
@@ -405,8 +404,8 @@ AliGenEventHeader *  AliAnaCaloTrackCorrBaseClass::GetMCGenEventHeader() const
 }
 
 
-//___________________________________________________________
-Int_t AliAnaCaloTrackCorrBaseClass::GetEventCentralityBin()
+//________________________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventCentralityBin() const
 {
   // Define the centrality bin for mixing
   // In pp collisions analysis hardcoded track multiplicities
@@ -465,8 +464,8 @@ Int_t AliAnaCaloTrackCorrBaseClass::GetEventCentralityBin()
   
 }
 
-//_________________________________________________
-Int_t AliAnaCaloTrackCorrBaseClass::GetEventRPBin()
+//_______________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventRPBin() const
 {
   //Reaction plane bin
   
@@ -494,8 +493,8 @@ Int_t AliAnaCaloTrackCorrBaseClass::GetEventRPBin()
   
 }
 
-//_________________________________________________
-Int_t AliAnaCaloTrackCorrBaseClass::GetEventVzBin()
+//_______________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventVzBin() const
 {
   // Return Vz bin, divide vertex in GetNZvertBin() bins, 
   // depending on the vertex cut
@@ -512,8 +511,8 @@ Int_t AliAnaCaloTrackCorrBaseClass::GetEventVzBin()
   return curZvertBin;
 }
 
-//____________________________________________________________________________________________________
-Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin(const Int_t iCen, const Int_t iVz, const Int_t iRP)
+//________________________________________________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin(Int_t iCen, Int_t iVz, Int_t iRP) const
 {
   // Event mixing bin, combination of vz, centrality and reaction plane bins
   
@@ -523,8 +522,8 @@ Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin(const Int_t iCen, const Int_t
     return iCen*GetNZvertBin()*GetNRPBin()+iVz*GetNRPBin()+iRP;
 }
 
-//__________________________________________________
-Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin()
+//________________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin() const
 {
   // Event mixing bin, combination of vz, centrality and reaction plane bins
   
index 711c202..77d4ed9 100755 (executable)
@@ -176,11 +176,11 @@ public:
   virtual Int_t          GetMaxMulti()                     const { return fMaxMulti  ; }  
   virtual Int_t          GetMinMulti()                     const { return fMinMulti  ; }  
     
-  virtual Int_t          GetEventCentralityBin();
-  virtual Int_t          GetEventRPBin();
-  virtual Int_t          GetEventVzBin();
-  virtual Int_t          GetEventMixBin();
-  virtual Int_t          GetEventMixBin(const Int_t iCen, const Int_t iVz, const Int_t iRP);
+  virtual Int_t          GetEventCentralityBin()          const;
+  virtual Int_t          GetEventRPBin()                  const;
+  virtual Int_t          GetEventVzBin()                  const;
+  virtual Int_t          GetEventMixBin()                 const;
+  virtual Int_t          GetEventMixBin(Int_t iCen, Int_t iVz, Int_t iRP) const;
   
   virtual void           SetMultiBin (Int_t n = 1 )              { fMultiBin  = n ; if(n < 1) fMultiBin  = 1 ; } // number of bins in Multiplicity  
   virtual void           SetNZvertBin(Int_t n = 1 )              { fNZvertBin = n ; if(n < 1) fNZvertBin = 1 ; } // number of bins for vertex position
@@ -195,18 +195,19 @@ public:
   virtual void           SwitchOnOwnMix()                        { fDoOwnMix         = kTRUE  ; }
   virtual void           SwitchOffOwnMix()                       { fDoOwnMix         = kFALSE ; }
   
-  virtual Bool_t         DoOwnMix()                              { return fDoOwnMix           ; }
-  virtual Bool_t         UseTrackMultBins()                      { return fUseTrackMultBins   ; }
+  virtual Bool_t         DoOwnMix()                        const { return fDoOwnMix           ; }
+  virtual Bool_t         UseTrackMultBins()                const { return fUseTrackMultBins   ; }
 
   //Mixed event  
-  virtual Int_t           CheckMixedEventVertex(const Int_t caloLabel, const Int_t trackLabel) ;
-  virtual AliMixedEvent * GetMixedEvent()                        { return GetReader()->GetMixedEvent()  ; } 
+  virtual Int_t           CheckMixedEventVertex(Int_t caloLabel, Int_t trackLabel) ;
+  virtual AliMixedEvent * GetMixedEvent()                  const { return GetReader()->GetMixedEvent()  ; }
   virtual Int_t           GetNMixedEvent()                 const { return GetReader()->GetNMixedEvent() ; } 
   
   //Vertex methods
   virtual void           GetVertex(Double_t vertex[3])     const { GetReader()->GetVertex(vertex)       ; } 
-  virtual Double_t*      GetVertex(const Int_t evtIndex)   const { return GetReader()->GetVertex(evtIndex) ; } 
-  virtual void           GetVertex(Double_t vertex[3], const Int_t evtIndex) const { GetReader()->GetVertex(vertex,evtIndex) ; } 
+  virtual Double_t*      GetVertex(Int_t evtIndex)         const { return GetReader()->GetVertex(evtIndex) ; }
+  virtual void           GetVertex(Double_t vertex[3],
+                                   Int_t evtIndex)         const { GetReader()->GetVertex(vertex,evtIndex) ; }
 
   
   //MULTIPLICITY
@@ -249,28 +250,28 @@ public:
   
   virtual AliPHOSGeoUtils          * GetPHOSGeometry()     const { return fCaloUtils->GetPHOSGeometry()  ; }
 
-  virtual void                       SetCaloPID(AliCaloPID * const pid)                             { delete fCaloPID; fCaloPID = pid     ; }
+  virtual void                       SetCaloPID(AliCaloPID * pid)                                   { delete fCaloPID; fCaloPID = pid     ; }
   
   virtual void                       SetCaloUtils(AliCalorimeterUtils * caloutils)                  { fCaloUtils = caloutils              ; }  
   
-  virtual void                       SetFiducialCut(AliFiducialCut * const fc)                      { delete fFidCut;  fFidCut  = fc      ; }
+  virtual void                       SetFiducialCut(AliFiducialCut * fc)                            { delete fFidCut;  fFidCut  = fc      ; }
   
-  virtual void                       SetHistogramRanges(AliHistogramRanges * const hr)              { delete fHisto;   fHisto   = hr      ; }
+  virtual void                       SetHistogramRanges(AliHistogramRanges * hr)                    { delete fHisto;   fHisto   = hr      ; }
   
-  virtual void                       SetIsolationCut(AliIsolationCut * const ic)                    { delete fIC;      fIC      = ic      ; }
+  virtual void                       SetIsolationCut(AliIsolationCut * ic)                          { delete fIC;      fIC      = ic      ; }
   
-  virtual void                       SetMCAnalysisUtils(AliMCAnalysisUtils * const mcutils)         { delete fMCUtils; fMCUtils = mcutils ; }  
+  virtual void                       SetMCAnalysisUtils(AliMCAnalysisUtils * mcutils)               { delete fMCUtils; fMCUtils = mcutils ; }
   
   virtual void                       SetNeutralMesonSelection(AliNeutralMesonSelection * const nms) { delete fNMS;     fNMS     = nms     ; }
   
-  virtual void                       SetReader(AliCaloTrackReader * const reader)                   { fReader = reader                    ; }
+  virtual void                       SetReader(AliCaloTrackReader * reader)                         { fReader = reader                    ; }
   
   //Calorimeter specific access methods and calculations
     
   virtual Bool_t         IsTrackMatched(AliVCluster * cluster, AliVEvent* event) {
    return GetCaloPID()->IsTrackMatched(cluster, fCaloUtils, event) ; } 
   
-  virtual Int_t          GetModuleNumberCellIndexes(const Int_t absId, const TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const {
+  virtual Int_t          GetModuleNumberCellIndexes(Int_t absId, TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const {
          return fCaloUtils->GetModuleNumberCellIndexes(absId, calo, icol, irow,iRCU) ; }
   
   virtual Int_t          GetModuleNumber(AliAODPWG4Particle * part) const {
index 889c4e0..2e5f6e4 100755 (executable)
@@ -884,9 +884,8 @@ void AliAnaCaloTrackCorrMaker::Print(const Option_t * opt) const
   
 }
 
-//_______________________________________________________________________
-void AliAnaCaloTrackCorrMaker::ProcessEvent(const Int_t iEntry,
-                                            const char * currentFileName)
+//_____________________________________________________________________________________
+void AliAnaCaloTrackCorrMaker::ProcessEvent(Int_t iEntry, const char * currentFileName)
 {
   //Process analysis for this event
   
index aa796f8..9e4eefe 100755 (executable)
@@ -80,7 +80,7 @@ class AliAnaCaloTrackCorrMaker : public TObject {
   
   void    Print(const Option_t * opt) const;
   
-  void    ProcessEvent(const Int_t iEntry, const char * currentFileName) ;
+  void    ProcessEvent(Int_t iEntry, const char * currentFileName) ;
   
   void    Terminate(TList * outputList);
   
index d2673b8..70186fc 100755 (executable)
@@ -29,7 +29,7 @@ public:
   
   virtual void Exec(Option_t * opt = "") ;
   
-  void         Set(const Double_t val)    { fScale = val   ; }
+  void         Set(Double_t val)          { fScale = val   ; }
   
   void         SetDebugLevel(Int_t level) { fDebug = level ; }
 
index 8d08bd2..6f37b85 100755 (executable)
@@ -97,7 +97,7 @@ fSplitWidthSigma(0),      fMassShiftHighECell(0)
 }
 
 //________________________________________
-AliCaloPID::AliCaloPID(const Int_t flux) : 
+AliCaloPID::AliCaloPID(Int_t flux) :
 TObject(),                fDebug(-1),                  fParticleFlux(flux),
 //Bayesian
 fEMCALPIDUtils(),         fUseBayesianWeights(kFALSE), fRecalculateBayesian(kFALSE),
@@ -333,8 +333,8 @@ void AliCaloPID::InitParameters()
 }
 
 
-//_____________________________________________________________________________________________________
-Bool_t AliCaloPID::IsInPi0SplitAsymmetryRange(const Float_t energy, const Float_t asy, const Int_t nlm)
+//_________________________________________________________________________________________
+Bool_t AliCaloPID::IsInPi0SplitAsymmetryRange(Float_t energy, Float_t asy, Int_t nlm) const
 {
   // Select the appropriate mass range for pi0 selection in splitting method
   // No used yet in splitting ID decision
@@ -362,8 +362,8 @@ Bool_t AliCaloPID::IsInPi0SplitAsymmetryRange(const Float_t energy, const Float_
   
 }
 
-//_________________________________________________________________________________________________
-Bool_t AliCaloPID::IsInPi0SplitMassRange(const Float_t energy, const Float_t mass, const Int_t nlm)
+//______________________________________________________________________________________
+Bool_t AliCaloPID::IsInPi0SplitMassRange(Float_t energy, Float_t mass, Int_t nlm) const
 {
   // Select the appropriate mass range for pi0 selection in splitting method
   
@@ -406,7 +406,7 @@ Bool_t AliCaloPID::IsInPi0SplitMassRange(const Float_t energy, const Float_t mas
 }
 
 //________________________________________________
-Bool_t AliCaloPID::IsInM02Range(const Float_t m02)
+Bool_t AliCaloPID::IsInM02Range(Float_t m02) const
 {
   // Select the appropriate m02 range, fix cut, not E dependent 
     
@@ -418,8 +418,8 @@ Bool_t AliCaloPID::IsInM02Range(const Float_t m02)
   
 }
 
-//___________________________________________________________________________________________
-Bool_t AliCaloPID::IsInPi0M02Range(const Float_t energy, const Float_t m02,  const Int_t nlm)
+//_______________________________________________________________________________
+Bool_t AliCaloPID::IsInPi0M02Range(Float_t energy, Float_t m02,  Int_t nlm) const
 {
   // Select the appropriate m02 range in splitting method for pi0
   
@@ -462,8 +462,8 @@ Bool_t AliCaloPID::IsInPi0M02Range(const Float_t energy, const Float_t m02,  con
 }
 
 
-//_____________________________________________________________________________________________
-Bool_t AliCaloPID::IsInEtaM02Range(const Float_t energy, const Float_t m02,  const Int_t nlm)
+//______________________________________________________________________________
+Bool_t AliCaloPID::IsInEtaM02Range(Float_t energy, Float_t m02, Int_t nlm) const
 {
   // Select the appropriate m02 range in splitting method to select eta's
   // Use same parametrization as pi0, just shift the distributions (to be tuned)
@@ -514,8 +514,8 @@ Bool_t AliCaloPID::IsInEtaM02Range(const Float_t energy, const Float_t m02,  con
   
 }
 
-//_____________________________________________________________________________________________
-Bool_t AliCaloPID::IsInConM02Range(const Float_t energy, const Float_t m02,  const Int_t nlm)
+//______________________________________________________________________________
+Bool_t AliCaloPID::IsInConM02Range(Float_t energy, Float_t m02, Int_t nlm) const
 {
   // Select the appropriate m02 range in splitting method for converted photons
   // Just min limit for pi0s is max for conversion.
@@ -553,8 +553,8 @@ AliEMCALPIDUtils *AliCaloPID::GetEMCALPIDUtils()
 }
 
 
-//______________________________________________________________________
-Int_t AliCaloPID::GetIdentifiedParticleType(const AliVCluster * cluster) 
+//________________________________________________________________ 
+Int_t AliCaloPID::GetIdentifiedParticleType(AliVCluster * cluster)
 {
   // Returns a PDG number corresponding to the likely ID of the cluster
   
@@ -608,10 +608,8 @@ Int_t AliCaloPID::GetIdentifiedParticleType(const AliVCluster * cluster)
   
 }
 
-//_______________________________________________________________________________
-Int_t AliCaloPID::GetIdentifiedParticleTypeFromBayesWeights(const Bool_t isEMCAL, 
-                                                            const Double_t * pid, 
-                                                            const Float_t energy) 
+//_________________________________________________________________________________________________________
+Int_t AliCaloPID::GetIdentifiedParticleTypeFromBayesWeights(Bool_t isEMCAL, Double_t * pid, Float_t energy)
 {
   //Return most probable identity of the particle after bayesian weights calculated in reconstruction
   
@@ -680,7 +678,7 @@ Int_t AliCaloPID::GetIdentifiedParticleTypeFromBayesWeights(const Bool_t isEMCAL
   
 }
 
-//____________________________________________________________________________________________________
+//____________________________________________________________________________________________________________
 Int_t AliCaloPID::GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster* cluster, 
                                                                 AliVCaloCells* cells,
                                                                 AliCalorimeterUtils * caloutils,
@@ -690,7 +688,7 @@ Int_t AliCaloPID::GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster* clu
                                                                 TLorentzVector & l1, TLorentzVector & l2,
                                                                 Int_t   & absId1,   Int_t   & absId2,
                                                                 Float_t & distbad1, Float_t & distbad2,
-                                                                Bool_t  & fidcut1,  Bool_t  & fidcut2  )
+                                                                Bool_t  & fidcut1,  Bool_t  & fidcut2  ) const
 {
   // Split the cluster in 2, do invariant mass, get the mass and decide 
   // if this is a photon, pi0, eta, ...
index 2447c17..71adde5 100755 (executable)
@@ -48,7 +48,7 @@ class AliCaloPID : public TObject {
  public: 
   
   AliCaloPID() ; // ctor
-  AliCaloPID(const Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
+  AliCaloPID(Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
   AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
   virtual ~AliCaloPID() ;//virtual dtor
        
@@ -73,17 +73,17 @@ class AliCaloPID : public TObject {
 
   void      InitParameters();
   
-  Bool_t    IsInPi0SplitAsymmetryRange(const Float_t energy, const Float_t asy,  const Int_t nlm);
+  Bool_t    IsInPi0SplitAsymmetryRange(Float_t energy, Float_t asy,  Int_t nlm) const;
 
-  Bool_t    IsInPi0SplitMassRange     (const Float_t energy, const Float_t mass, const Int_t nlm);
+  Bool_t    IsInPi0SplitMassRange     (Float_t energy, Float_t mass, Int_t nlm) const;
   
-  Bool_t    IsInM02Range              (const Float_t m02);
-  Bool_t    IsInPi0M02Range           (const Float_t energy, const Float_t m02,  const Int_t nlm);
-  Bool_t    IsInEtaM02Range           (const Float_t energy, const Float_t m02,  const Int_t nlm);
-  Bool_t    IsInConM02Range           (const Float_t energy, const Float_t m02,  const Int_t nlm);
+  Bool_t    IsInM02Range              (Float_t m02) const;
+  Bool_t    IsInPi0M02Range           (Float_t energy, Float_t m02,  Int_t nlm) const;
+  Bool_t    IsInEtaM02Range           (Float_t energy, Float_t m02,  Int_t nlm) const;
+  Bool_t    IsInConM02Range           (Float_t energy, Float_t m02,  Int_t nlm) const;
   
   
-  Int_t     GetIdentifiedParticleTypeFromBayesWeights(const Bool_t isEMCAL, const Double_t * pid, const Float_t energy) ;
+  Int_t     GetIdentifiedParticleTypeFromBayesWeights(Bool_t isEMCAL, Double_t * pid, Float_t energy) ;
 
   Int_t     GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster * cluster, AliVCaloCells* cells, 
                                                           AliCalorimeterUtils * caloutils,
@@ -92,9 +92,9 @@ class AliCaloPID : public TObject {
                                                           TLorentzVector & l1  , TLorentzVector & l2,
                                                           Int_t   & absId1,   Int_t   & absId2,
                                                           Float_t & distbad1, Float_t & distbad2,
-                                                          Bool_t  & fidcut1,  Bool_t  & fidcut2  ) ;
+                                                          Bool_t  & fidcut1,  Bool_t  & fidcut2  ) const;
   
-  Int_t     GetIdentifiedParticleType(const AliVCluster * cluster) ;
+  Int_t     GetIdentifiedParticleType(AliVCluster * cluster) ;
   
   TString   GetPIDParametersList();
   
@@ -109,11 +109,11 @@ class AliCaloPID : public TObject {
   
   //Check if cluster photon-like. Uses photon cluster parameterization in real pp data 
   //Returns distance in sigmas. Recommended cut 2.5
-  Float_t TestPHOSDispersion(const Double_t pt, const Double_t m20, const Double_t m02) const ; 
+  Float_t TestPHOSDispersion(Double_t pt, Double_t m20, Double_t m02) const ;
   //Checks distance to the closest track. Takes into account 
   //non-perpendicular incidence of tracks.
-  Float_t TestPHOSChargedVeto(const Double_t dx,  const Double_t dz, const Double_t ptTrack, 
-                              const Int_t chargeTrack, const Double_t mf) const ;
+  Float_t TestPHOSChargedVeto(Double_t dx, Double_t dz, Double_t ptTrack,
+                              Int_t chargeTrack, Double_t mf) const ;
   
   // Setters, getters
   
index d2c6bf4..91683bd 100755 (executable)
@@ -118,10 +118,10 @@ void AliCaloTrackMCReader::InitParameters()
   
 }
 
-//_________________________________________________________________________________
-void  AliCaloTrackMCReader::CheckOverlap(const Float_t anglethres, const Int_t imom, 
-                                         Int_t & iPrimary, Int_t & index, TLorentzVector & mom, 
-                                         Int_t & pdg) 
+//__________________________________________________________________________
+void  AliCaloTrackMCReader::CheckOverlap(Float_t anglethres, Int_t imom,
+                                         Int_t & iPrimary, Int_t & index,
+                                         TLorentzVector & mom, Int_t & pdg)
 {
   //Check overlap of decay photons
   if( fIndex2ndPhoton==iPrimary )
@@ -160,7 +160,9 @@ void  AliCaloTrackMCReader::CheckOverlap(const Float_t anglethres, const Int_t i
       else
       {
         //Do not check overlapping for next decay photon from same meson
-        if(iPrimary == idaug1) {fIndex2ndPhoton = idaug1+1;
+        if(iPrimary == idaug1)
+        {
+          fIndex2ndPhoton = idaug1+1;
         }
         
       }
@@ -225,7 +227,7 @@ void  AliCaloTrackMCReader::FillCalorimeters(Int_t & iParticle,
 }
 
 //___________________________________________________________________________
-Bool_t AliCaloTrackMCReader::FillInputEvent(const Int_t iEntry, 
+Bool_t AliCaloTrackMCReader::FillInputEvent(Int_t iEntry,
                                             const char * /*currentFileName*/)
 {
   //Fill the event counter and input lists that are needed, called by the analysis maker.
@@ -407,7 +409,7 @@ void AliCaloTrackMCReader::Print(const Option_t * opt) const
 }
 
 //________________________________________________________________
-void AliCaloTrackMCReader::MakePi0Decay(const TLorentzVector p0, 
+void AliCaloTrackMCReader::MakePi0Decay(TLorentzVector p0,
                                         TLorentzVector &p1, 
                                         TLorentzVector &p2) const 
 //, Double_t &angle)
@@ -461,7 +463,6 @@ void AliCaloTrackMCReader::SetInputOutputMCEvent(AliVEvent* /*esd*/,
   SetOutputEvent(aod);
 }
 
-
 //________________________________________________________________
 Bool_t AliCaloTrackMCReader::SkipNeutralParticles(Int_t pdg) const 
 {
@@ -475,9 +476,8 @@ Bool_t AliCaloTrackMCReader::SkipNeutralParticles(Int_t pdg) const
   
 }
 
-
 //_______________________________________________________________________
-void AliCaloTrackMCReader::SetTrackChargeAndPID(const Int_t pdgCode, 
+void AliCaloTrackMCReader::SetTrackChargeAndPID(Int_t pdgCode,
                                                 AliAODTrack *track) const 
 {
   //Give a PID weight for tracks equal to 1 depending on the particle type
index 3c4daa3..661b8c5 100755 (executable)
@@ -38,21 +38,21 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
 
   // Main methos in source file
   
-  void   CheckOverlap(const Float_t anglethres, const Int_t imom, Int_t & iPrimary, Int_t & index, TLorentzVector & mom, Int_t & pdg);
+  void   CheckOverlap(Float_t anglethres, Int_t imom, Int_t & iPrimary, Int_t & index, TLorentzVector & mom, Int_t & pdg);
 
   void   FillCalorimeters(Int_t & iParticle, TParticle* particle, TLorentzVector & momentum) ;
 
-  Bool_t FillInputEvent(const Int_t iEntry, const char * currentFileName) ;
+  Bool_t FillInputEvent(Int_t iEntry, const char * currentFileName) ;
   
   void   InitParameters();
   
-  void   MakePi0Decay(const TLorentzVector p0, TLorentzVector &p1, TLorentzVector &p2) const ;//, Double_t &angle); 
+  void   MakePi0Decay(TLorentzVector p0, TLorentzVector &p1, TLorentzVector &p2) const ;//, Double_t &angle);
 
   void   Print(const Option_t * opt) const; 
   
-  void   SetCaloClusterPID   (const Int_t pdgCode, AliVCluster *calo ) const ;
+  void   SetCaloClusterPID   (Int_t pdgCode, AliVCluster *calo ) const ;
   
-  void   SetTrackChargeAndPID(const Int_t pdgCode, AliAODTrack *track) const ;
+  void   SetTrackChargeAndPID(Int_t pdgCode, AliAODTrack *track) const ;
   
   void   SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
 
@@ -61,8 +61,8 @@ class AliCaloTrackMCReader : public AliCaloTrackReader {
   AliVEvent*  GetInputEvent()               const { return (AliVEvent *) GetMC()   ; }
   
   void      GetVertex(Double_t v[3]) const ;
-  Double_t* GetVertex(const Int_t evtIndex) const {return fVertex[evtIndex];}
-  void      GetVertex(Double_t vertex[3], const Int_t evtIndex) const 
+  Double_t* GetVertex(Int_t evtIndex) const {return fVertex[evtIndex];}
+  void      GetVertex(Double_t vertex[3], Int_t evtIndex) const 
   { vertex[0]=fVertex[evtIndex][0];  vertex[1]=fVertex[evtIndex][1];  vertex[2]=fVertex[evtIndex][2]; }  
   
   // Particle type, status, arrays 
index 3efa132..032530f 100755 (executable)
@@ -205,7 +205,7 @@ AliCaloTrackReader::~AliCaloTrackReader()
 }
 
 //________________________________________________________________________
-Bool_t  AliCaloTrackReader::AcceptDCA(const Float_t pt, const Float_t dca)
+Bool_t  AliCaloTrackReader::AcceptDCA(Float_t pt, Float_t dca)
 {
   // Accept track if DCA is smaller than function
   
@@ -858,8 +858,8 @@ Bool_t AliCaloTrackReader::IsHIJINGLabel(Int_t label)
   }//AOD
 }
 
-//___________________________________________________________
-Bool_t AliCaloTrackReader::IsInTimeWindow(const Double_t tof, const Float_t energy) const
+//__________________________________________________________________________
+Bool_t AliCaloTrackReader::IsInTimeWindow(Double_t tof, Float_t energy) const
 {
   // Cluster time selection window
   
@@ -937,9 +937,8 @@ Bool_t AliCaloTrackReader::IsPileUpFromNotSPDAndNotEMCal() const
   else                                            return kFALSE;
 }
 
-//_________________________________________________________________________
-Bool_t AliCaloTrackReader::FillInputEvent(const Int_t iEntry,
-                                          const char * /*currentFileName*/)
+//___________________________________________________________________________________
+Bool_t AliCaloTrackReader::FillInputEvent(Int_t iEntry, const char * /*curFileName*/)
 {
   //Fill the event counter and input lists that are needed, called by the analysis maker.
   
@@ -1305,9 +1304,8 @@ void AliCaloTrackReader::GetVertex(Double_t vertex[3]) const
   vertex[2]=fVertex[0][2];
 }
 
-//____________________________________________________________
-void AliCaloTrackReader::GetVertex(Double_t vertex[3],
-                                   const Int_t evtIndex) const
+//__________________________________________________________________________
+void AliCaloTrackReader::GetVertex(Double_t vertex[3], Int_t evtIndex) const
 {
   //Return vertex position for mixed event, recover the vertex in a particular event.
   
@@ -1588,9 +1586,8 @@ void AliCaloTrackReader::FillInputCTS()
   
 }
 
-//__________________________________________________________________
-void AliCaloTrackReader::FillInputEMCALAlgorithm(AliVCluster * clus,
-                                                 const Int_t iclus)
+//_______________________________________________________________________________
+void AliCaloTrackReader::FillInputEMCALAlgorithm(AliVCluster * clus, Int_t iclus)
 {
   //Fill the EMCAL data in the array, do it
   
@@ -2043,7 +2040,7 @@ Bool_t AliCaloTrackReader::CheckForPrimaryVertex()
 }
 
 //________________________________________________________________________________
-TArrayI AliCaloTrackReader::GetTriggerPatches(const Int_t tmin, const Int_t tmax )
+TArrayI AliCaloTrackReader::GetTriggerPatches(Int_t tmin, Int_t tmax )
 {
   // Select the patches that triggered
   // Depend on L0 or L1
index ccb09bf..17a506b 100755 (executable)
@@ -76,8 +76,8 @@ public:
   // Input/output event setters and getters
   //---------------------------------------
   
-  virtual void    SetInputEvent(AliVEvent* const input) ;
-  virtual void    SetOutputEvent(AliAODEvent* const aod)   { fOutputEvent = aod            ; }
+  virtual void    SetInputEvent(AliVEvent* input) ;
+  virtual void    SetOutputEvent(AliAODEvent*  aod)        { fOutputEvent = aod            ; }
   virtual void    SetMC(AliMCEvent* const mc)              { fMC          = mc             ; }
   virtual void    SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) { ; }
   
@@ -123,7 +123,7 @@ public:
   
   // Track DCA cut
   
-  Bool_t           AcceptDCA(const Float_t pt, const Float_t dca);
+  Bool_t           AcceptDCA(Float_t pt, Float_t dca);
   Double_t         GetTrackDCACut(Int_t i)           const { if(i >= 0 && i < 3 ) return fTrackDCACut[i] ;
                                                              else return -999              ; }
   
@@ -148,7 +148,7 @@ public:
   Double_t         GetEMCALTimeCutMin()              const { return fEMCALTimeCutMin       ; }
   Double_t         GetEMCALTimeCutMax()              const { return fEMCALTimeCutMax       ; } 
 
-  Bool_t           IsInTimeWindow(const Double_t tof, const Float_t energy)  const ;
+  Bool_t           IsInTimeWindow(Double_t tof, Float_t energy)  const ;
   
   void             SetEMCALTimeCut(Double_t a, Double_t b) { fEMCALTimeCutMin = a ; 
                                                              fEMCALTimeCutMax = b          ; } // ns
@@ -167,7 +167,7 @@ public:
   virtual AliFiducialCut * GetFiducialCut()                { 
                     if(!fFiducialCut) fFiducialCut = new AliFiducialCut(); 
                     return  fFiducialCut                                                   ; }
-  virtual void     SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc           ; }
+  virtual void     SetFiducialCut(AliFiducialCut * fc)     { fFiducialCut = fc           ; }
   virtual Bool_t   IsFiducialCutOn()                 const { return fCheckFidCut           ; }
   virtual void     SwitchOnFiducialCut()                   { fCheckFidCut = kTRUE          ; 
                                                              fFiducialCut = new AliFiducialCut() ; }
@@ -218,7 +218,7 @@ public:
   
   // Filling/ filtering / detector information access methods
   
-  virtual Bool_t   FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
+  virtual Bool_t   FillInputEvent(Int_t iEntry, const char *currentFileName)  ;
   virtual void     FillInputCTS() ;
   virtual void     FillInputEMCAL() ;
   virtual void     FillInputEMCALAlgorithm(AliVCluster * clus, const Int_t iclus) ;
@@ -431,7 +431,7 @@ public:
   //-------------------------------
 
   virtual void      GetVertex(Double_t v[3])         const ;
-  virtual Double_t* GetVertex(const Int_t evtIndex)  const { return fVertex[evtIndex]            ; }
+  virtual Double_t* GetVertex(Int_t evtIndex)        const { return fVertex[evtIndex]            ; }
   virtual void      GetVertex(Double_t vertex[3],    const Int_t evtIndex) const ;
   virtual void      FillVertexArray();
   virtual Bool_t    CheckForPrimaryVertex();
index 942c14e..464e386 100755 (executable)
@@ -492,9 +492,8 @@ void AliCalorimeterUtils::AccessGeometry(AliVEvent* inputEvent)
   
 }
 
-//______________________________________________________________________________________
-Bool_t AliCalorimeterUtils::AreNeighbours(const TString calo, 
-                                          const Int_t absId1, const Int_t absId2 ) const
+//________________________________________________________________________________________
+Bool_t AliCalorimeterUtils::AreNeighbours(TString calo, Int_t absId1, Int_t absId2 ) const
 {
   // Tells if (true) or not (false) two cells are neighbours
   // A neighbour is defined as being two cells which share a side or corner
@@ -682,8 +681,8 @@ Bool_t AliCalorimeterUtils::CheckCellFiducialRegion(AliVCluster* cluster,
        
 }      
 
-//_________________________________________________________________________________________________________
-Bool_t AliCalorimeterUtils::ClusterContainsBadChannel(TString calorimeter,UShort_t* cellList, Int_t nCells)
+//__________________________________________________________________________________________________________
+Bool_t AliCalorimeterUtils::ClusterContainsBadChannel(TString calorimeter, UShort_t* cellList, Int_t nCells)
 {
        // Check that in the cluster cells, there is no bad channel of those stored 
        // in fEMCALBadChannelMap or fPHOSBadChannelMap
@@ -787,10 +786,9 @@ Int_t  AliCalorimeterUtils::GetMaxEnergyCell(AliVCaloCells* cells, const AliVClu
   
 }
 
-//__________________________________________________________________________
-AliVTrack * AliCalorimeterUtils::GetMatchedTrack(const AliVCluster* cluster, 
-                                                 const AliVEvent* event, 
-                                                 const Int_t index) const
+//___________________________________________________________________________________
+AliVTrack * AliCalorimeterUtils::GetMatchedTrack(AliVCluster* cluster,
+                                                 AliVEvent* event, Int_t index) const
 {
   // Get the matched track given its index, usually just the first match
   // Since it is different for ESDs and AODs here it is a wrap method to do it
@@ -941,7 +939,7 @@ Int_t AliCalorimeterUtils::GetModuleNumber(AliVCluster * cluster) const
 }
 
 //___________________________________________________________________________________________________
-Int_t AliCalorimeterUtils::GetModuleNumberCellIndexes(const Int_t absId, const TString calo, 
+Int_t AliCalorimeterUtils::GetModuleNumberCellIndexes(Int_t absId, TString calo,
                                                       Int_t & icol, Int_t & irow, Int_t & iRCU) const
 {
        //Get the EMCAL/PHOS module, columns, row and RCU number that corresponds to this absId
@@ -1333,9 +1331,8 @@ void AliCalorimeterUtils::InitPHOSGeometry(Int_t runnumber)
        }       
 }
 
-//__________________________________________________________________
-Bool_t AliCalorimeterUtils::MaskFrameCluster(const Int_t iSM,  
-                                             const Int_t ieta) const 
+//_______________________________________________________________________
+Bool_t AliCalorimeterUtils::MaskFrameCluster(Int_t iSM, Int_t ieta) const
 {
   //Check if cell is in one of the regions where we have significant amount 
   //of material in front. Only EMCAL
@@ -1379,9 +1376,8 @@ void AliCalorimeterUtils::Print(const Option_t * opt) const
   printf("    \n") ;
 } 
 
-//__________________________________________________________________________________________
-void AliCalorimeterUtils::RecalibrateCellAmplitude(Float_t & amp,
-                                                   const TString calo, const Int_t id) const
+//_____________________________________________________________________________________________
+void AliCalorimeterUtils::RecalibrateCellAmplitude(Float_t & amp, TString calo, Int_t id) const
 {
   //Recaculate cell energy if recalibration factor
   
@@ -1401,10 +1397,8 @@ void AliCalorimeterUtils::RecalibrateCellAmplitude(Float_t & amp,
   }
 }
 
-//_________________________________________________________________________________
-void AliCalorimeterUtils::RecalibrateCellTime(Double_t & time, 
-                                              const TString calo, 
-                                              const Int_t id, const Int_t bc) const
+//____________________________________________________________________________________________________
+void AliCalorimeterUtils::RecalibrateCellTime(Double_t & time, TString calo, Int_t id, Int_t bc) const
 {
   // Recalculate time if time recalibration available for EMCAL
   // not ready for PHOS
@@ -1496,14 +1490,13 @@ void AliCalorimeterUtils::RecalculateClusterTrackMatching(AliVEvent * event,
 }
 
 //___________________________________________________________________________
-void AliCalorimeterUtils::SplitEnergy(const Int_t absId1, const Int_t absId2,
-                                      AliVCluster* cluster, 
+void AliCalorimeterUtils::SplitEnergy(Int_t absId1, Int_t absId2,
+                                      AliVCluster* cluster,
                                       AliVCaloCells* cells,
                                       //Float_t & e1, Float_t & e2,
                                       AliAODCaloCluster* cluster1,
                                       AliAODCaloCluster* cluster2,
-                                      const Int_t nMax,
-                                      const Int_t eventNumber)
+                                      Int_t nMax, Int_t eventNumber)
 {
   
   // Split energy of cluster between the 2 local maxima, sum energy on 3x3, and if the 2 
index 7c5cb91..bf7408f 100755 (executable)
@@ -45,7 +45,7 @@ class AliCalorimeterUtils : public TObject {
        
   // Cluster contents
   
-  Bool_t        AreNeighbours(const TString calo, const Int_t absId1, const Int_t absId2) const ;  
+  Bool_t        AreNeighbours(TString calo, Int_t absId1, Int_t absId2) const ;
 
   Int_t         GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells)  ;
   
@@ -60,13 +60,10 @@ class AliCalorimeterUtils : public TObject {
   
   Int_t         GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu, Float_t & fraction) const ;
   
-  void          SplitEnergy(const Int_t absId1, const Int_t absId2, 
-                            AliVCluster *cluster, 
-                            AliVCaloCells* cells,
+  void          SplitEnergy(Int_t absId1, Int_t absId2, AliVCluster *cluster, AliVCaloCells* cells,
                             //Float_t & e1, Float_t & e2,
-                            AliAODCaloCluster *cluster1, 
-                            AliAODCaloCluster *cluster2, 
-                            const Int_t nMax, const Int_t eventNumber = 0);//, Int_t *absIdList, Float_t *maxEList,
+                            AliAODCaloCluster *cluster1, AliAODCaloCluster *cluster2,
+                            Int_t nMax, Int_t eventNumber = 0);//, Int_t *absIdList, Float_t *maxEList,
   
   void          SwitchOnClusterPlot()                      { fPlotCluster = kTRUE         ; }
   void          SwitchOffClusterPlot()                     { fPlotCluster = kFALSE        ; }
@@ -117,7 +114,7 @@ class AliCalorimeterUtils : public TObject {
                   return fEMCALRecoUtils->GetEMCALChannelStatus(iSM,iCol,iRow); }//Channel is ok by default
 
   Int_t         GetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow) const { 
-                  if(fPHOSBadChannelMap)return (Int_t) ((TH2I*)fPHOSBadChannelMap->At(imod))->GetBinContent(iCol,iRow); 
+                  if(fPHOSBadChannelMap) return (Int_t) ((TH2I*)fPHOSBadChannelMap->At(imod))->GetBinContent(iCol,iRow); 
                   else return 0 ; }//Channel is ok by default
   
   void          SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
@@ -146,13 +143,13 @@ class AliCalorimeterUtils : public TObject {
   void          SetMaskCellColumn(Int_t ipos, Int_t icol) { 
                   if(ipos < fNMaskCellColumns) fMaskCellColumns[ipos] = icol;
                   else printf("Not set, position larger than allocated set size first")                               ; }
-  Bool_t        MaskFrameCluster(const Int_t iSM, const Int_t ieta) const ;
+  Bool_t        MaskFrameCluster(Int_t iSM, Int_t ieta) const ;
   
   
   //Calorimeter indexes information
   Int_t         GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent* inputEvent) const;
   Int_t         GetModuleNumber(AliVCluster * cluster) const;
-  Int_t         GetModuleNumberCellIndexes(const Int_t absId, const TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const ;
+  Int_t         GetModuleNumberCellIndexes(Int_t absId, TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const ;
        
   //Modules fiducial region
   Bool_t        CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells, AliVEvent * event, Int_t iev=0) const ;
@@ -197,8 +194,8 @@ class AliCalorimeterUtils : public TObject {
   void          SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(map)        ; }
   void          SetPHOSChannelRecalibrationFactors (TObjArray *map)      { fPHOSRecalibrationFactors  = map;}
 
-  void          RecalibrateCellTime     (Double_t & time, const TString calo, const Int_t absId, const Int_t bunchCrossNumber) const ;
-  void          RecalibrateCellAmplitude(Float_t  & amp,  const TString calo, const Int_t absId) const ;
+  void          RecalibrateCellTime     (Double_t & time, TString calo, Int_t absId, Int_t bunchCrossNumber) const ;
+  void          RecalibrateCellAmplitude(Float_t  & amp,  TString calo, Int_t absId) const ;
   Float_t       RecalibrateClusterEnergy(AliVCluster* cluster, AliVCaloCells * cells);
 
   // Run dependent energy calibrations (EMCAL)
@@ -212,15 +209,15 @@ class AliCalorimeterUtils : public TObject {
   void         SwitchOffTimeRecalibration()                              { fEMCALRecoUtils->SwitchOffTimeRecalibration()   ; }
   void         SwitchOnTimeRecalibration()                               { fEMCALRecoUtils->SwitchOnTimeRecalibration()    ; }
   
-  Float_t      GetEMCALChannelTimeRecalibrationFactor(const Int_t bc, const Int_t absID) const 
+  Float_t      GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const
   { return fEMCALRecoUtils->GetEMCALChannelTimeRecalibrationFactor(bc, absID) ; } 
        
-  void         SetEMCALChannelTimeRecalibrationFactor(const Int_t bc, const Int_t absID, Double_t c = 0) 
+  void         SetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID, Double_t c = 0)
   { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactor(bc, absID, c) ; }  
   
-  TH1F *       GetEMCALChannelTimeRecalibrationFactors(const Int_t bc)const       { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; }   
-  void         SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)            { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map)        ; }
-  void         SetEMCALChannelTimeRecalibrationFactors(const Int_t bc , TH1F* h)  { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(bc , h)     ; }
+  TH1F *       GetEMCALChannelTimeRecalibrationFactors(Int_t bc) const     { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; }
+  void         SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)     { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map)        ; }
+  void         SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h) { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(bc , h)     ; }
   
   //EMCAL specific utils for the moment
   void          SetEMCALRecoUtils(AliEMCALRecoUtils * ru)  { fEMCALRecoUtils = ru          ; }
@@ -245,7 +242,7 @@ class AliCalorimeterUtils : public TObject {
 
   // *** Track Matching ***
   
-  AliVTrack *   GetMatchedTrack(const AliVCluster * cluster, const AliVEvent * event, const Int_t index = 0) const ;
+  AliVTrack *   GetMatchedTrack(AliVCluster * cluster, AliVEvent * event, Int_t index = 0) const ;
   
   // Recalculation
   void          RecalculateClusterTrackMatching(AliVEvent * event, TObjArray* clusterArray = 0x0) ;
index 8301409..b5cdad7 100755 (executable)
@@ -74,9 +74,8 @@ AliFiducialCut::~AliFiducialCut()
 }
 
 
-//___________________________________________________________________
-Bool_t AliFiducialCut::IsInFiducialCut(const TLorentzVector momentum, 
-                                       const TString det) const
+//________________________________________________________________________________
+Bool_t AliFiducialCut::IsInFiducialCut(TLorentzVector momentum, TString det) const
 {
   //Selects EMCAL or PHOS cluster or CTS track if it is inside eta-phi defined regions
   
@@ -110,7 +109,7 @@ Bool_t AliFiducialCut::IsInFiducialCut(const TLorentzVector momentum,
 }
 
 //___________________________________________________________________________________________
-Bool_t AliFiducialCut::CheckFiducialRegion(const TLorentzVector momentum, 
+Bool_t AliFiducialCut::CheckFiducialRegion(TLorentzVector momentum,
                                            const TArrayF* minphi, const TArrayF* maxphi, 
                                            const TArrayF* mineta, const TArrayF* maxeta) const 
 {
@@ -243,10 +242,8 @@ void AliFiducialCut::Print(const Option_t * opt) const
   
 } 
 
-//_______________________________________________________________
-void AliFiducialCut::SetSimpleCTSFiducialCut(const Float_t eta, 
-                                             const Float_t minphi, 
-                                             const Float_t maxphi)
+//_______________________________________________________________________________________
+void AliFiducialCut::SetSimpleCTSFiducialCut(Float_t eta, Float_t minphi, Float_t maxphi)
 {
   
   //Method to set simple acceptance cut to CTS
@@ -263,10 +260,8 @@ void AliFiducialCut::SetSimpleCTSFiducialCut(const Float_t eta,
   
 }
 
-//__________________________________________________________________
-void AliFiducialCut::SetSimpleEMCALFiducialCut(const Float_t eta, 
-                                               const Float_t minphi, 
-                                               const Float_t maxphi)
+//_________________________________________________________________________________________
+void AliFiducialCut::SetSimpleEMCALFiducialCut(Float_t eta, Float_t minphi, Float_t maxphi)
 {
   //Method to set simple acceptance cut to EMCAL
   
@@ -280,13 +275,10 @@ void AliFiducialCut::SetSimpleEMCALFiducialCut(const Float_t eta,
   fEMCALFidCutMinPhi->SetAt(minphi,0);
   fEMCALFidCutMaxPhi->SetAt(maxphi,0);
   
-  
 }
 
-//_________________________________________________________________
-void AliFiducialCut::SetSimplePHOSFiducialCut(const Float_t eta, 
-                                              const Float_t minphi, 
-                                              const Float_t maxphi)
+//________________________________________________________________________________________
+void AliFiducialCut::SetSimplePHOSFiducialCut(Float_t eta, Float_t minphi, Float_t maxphi)
 {
   //Method to set simple acceptance cut to PHOS
   
index 5bd1f5c..2cb98b3 100755 (executable)
@@ -28,11 +28,11 @@ public:
   
   void      InitParameters();
     
-  Bool_t    CheckFiducialRegion(const TLorentzVector lv, 
+  Bool_t    CheckFiducialRegion(TLorentzVector lv,
                                 const TArrayF* minphi, const TArrayF* maxphi, 
                                 const TArrayF* mineta, const TArrayF* maxeta) const ;
   
-  Bool_t    IsInFiducialCut    (const TLorentzVector lv, const TString det) const ;
+  Bool_t    IsInFiducialCut    (TLorentzVector lv, TString det) const ;
   
   void      DoCTSFiducialCut  (Bool_t b)     { fCTSFiducialCut   = b    ; }
   void      DoEMCALFiducialCut(Bool_t b)     { fEMCALFiducialCut = b    ; }
@@ -42,9 +42,9 @@ public:
   Bool_t    GetEMCALFiducialCut()      const { return fEMCALFiducialCut ; }
   Bool_t    GetPHOSFiducialCutStatus() const { return fPHOSFiducialCut  ; }
   
-  void      SetSimpleCTSFiducialCut  (const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
-  void      SetSimpleEMCALFiducialCut(const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
-  void      SetSimplePHOSFiducialCut (const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
+  void      SetSimpleCTSFiducialCut  (Float_t abseta, Float_t phimin, Float_t phimax) ;
+  void      SetSimpleEMCALFiducialCut(Float_t abseta, Float_t phimin, Float_t phimax) ;
+  void      SetSimplePHOSFiducialCut (Float_t abseta, Float_t phimin, Float_t phimax) ;
   
   void      Print(const Option_t * opt)const;
   
index 3e05742..db87e05 100755 (executable)
@@ -66,11 +66,11 @@ fFracIsThresh(1)
   
 }
 
-//__________________________________________________________________________________________________________________________________________
-void AliIsolationCut::CalculateUEBandClusterNormalization(      AliCaloTrackReader * /*reader*/,const Float_t   etaC, const Float_t /*phiC*/,
-                                                          const Float_t   phiUEptsumCluster,    const Float_t   etaUEptsumCluster,
-                                                                Float_t & phiUEptsumClusterNorm,      Float_t & etaUEptsumClusterNorm,
-                                                                Float_t & excessFracEta,              Float_t & excessFracPhi              ) const
+//_________________________________________________________________________________________________________________________________
+void AliIsolationCut::CalculateUEBandClusterNormalization(AliCaloTrackReader * /*reader*/, Float_t   etaC, Float_t /*phiC*/,
+                                                           Float_t   phiUEptsumCluster,     Float_t   etaUEptsumCluster,
+                                                           Float_t & phiUEptsumClusterNorm, Float_t & etaUEptsumClusterNorm,
+                                                           Float_t & excessFracEta,         Float_t & excessFracPhi         ) const
 {
   // Normalize cluster background band
   
@@ -107,11 +107,11 @@ void AliIsolationCut::CalculateUEBandClusterNormalization(      AliCaloTrackRead
   
 }
 
-//________________________________________________________________________________________________________________________________________
-void AliIsolationCut::CalculateUEBandTrackNormalization  (      AliCaloTrackReader * reader,    const Float_t   etaC, const Float_t /*phiC*/,
-                                                          const Float_t   phiUEptsumTrack,      const Float_t   etaUEptsumTrack,
-                                                                Float_t & phiUEptsumTrackNorm,        Float_t & etaUEptsumTrackNorm,
-                                                                Float_t & excessFracEta,              Float_t & excessFracPhi              ) const
+//________________________________________________________________________________________________________________________________
+void AliIsolationCut::CalculateUEBandTrackNormalization  (AliCaloTrackReader * reader,    Float_t   etaC, Float_t /*phiC*/,
+                                                          Float_t   phiUEptsumTrack,      Float_t   etaUEptsumTrack,
+                                                          Float_t & phiUEptsumTrackNorm,  Float_t & etaUEptsumTrackNorm,
+                                                          Float_t & excessFracEta,        Float_t & excessFracPhi          ) const
 {
   // Normalize track background band
   
@@ -151,8 +151,8 @@ void AliIsolationCut::CalculateUEBandTrackNormalization  (      AliCaloTrackRead
   
 }
 
-//______________________________________________________________________________
-Float_t AliIsolationCut::CalculateExcessAreaFraction(const Float_t excess) const 
+//________________________________________________________________________
+Float_t AliIsolationCut::CalculateExcessAreaFraction(Float_t excess) const
 {
   // Area of a circunference segment segment 1/2 R^2 (angle-sin(angle)), angle = 2*ACos((R-excess)/R)
   
@@ -401,9 +401,9 @@ void  AliIsolationCut::MakeIsolationCut(TObjArray * plCTS,
                                         TObjArray * plNe, 
                                         AliCaloTrackReader * reader, 
                                         AliCaloPID * pid,
-                                        const Bool_t bFillAOD, 
+                                        Bool_t bFillAOD,
                                         AliAODPWG4ParticleCorrelation  *pCandidate, 
-                                        const TString & aodArrayRefName,
+                                        TString aodArrayRefName,
                                         Int_t   & n, 
                                         Int_t   & nfrac, 
                                         Float_t & coneptsum,  
@@ -810,8 +810,8 @@ void AliIsolationCut::Print(const Option_t * opt) const
 } 
 
 //___________________________________________________________________________
-Float_t AliIsolationCut::Radius(const Float_t etaC, const Float_t phiC, 
-                                const Float_t eta , const Float_t phi) const
+Float_t AliIsolationCut::Radius(Float_t etaC, Float_t phiC,
+                                Float_t eta , Float_t phi) const
 {
   // Calculate the distance to trigger from any particle
 
index bec2e56..f12321e 100755 (executable)
@@ -47,27 +47,27 @@ class AliIsolationCut : public TObject {
   void       MakeIsolationCut(TObjArray * plCTS, TObjArray * plNe, 
                               AliCaloTrackReader * reader, 
                               AliCaloPID * pid, 
-                              const Bool_t bFillAOD,
-                              AliAODPWG4ParticleCorrelation  * pCandidate, const TString &aodObjArrayName,
+                              Bool_t bFillAOD,
+                              AliAODPWG4ParticleCorrelation  * pCandidate, TString aodObjArrayName,
                               Int_t &n, Int_t & nfrac, Float_t &ptsum, Bool_t & isolated) const ;  
   
   void       Print(const Option_t * opt) const ;
   
-  Float_t    Radius(const Float_t etaCandidate, const Float_t phiCandidate, const Float_t eta, const Float_t phi) const ; 
+  Float_t    Radius(Float_t etaCandidate, Float_t phiCandidate, Float_t eta, Float_t phi) const ;
   
   // Cone background studies medthods
   
-  Float_t  CalculateExcessAreaFraction(const Float_t excess) const ;
+  Float_t  CalculateExcessAreaFraction(Float_t excess) const ;
 
-  void     CalculateUEBandClusterNormalization(AliCaloTrackReader * reader,          const Float_t   etaC, const Float_t phiC,
-                                               const Float_t   phiUEptsumCluster,    const Float_t   etaUEptsumCluster,
-                                                     Float_t & phiUEptsumClusterNorm,      Float_t & etaUEptsumClusterNorm,
-                                                     Float_t & excessFracEta,              Float_t & excessFracPhi              ) const ;
-  
-  void     CalculateUEBandTrackNormalization  (AliCaloTrackReader * reader,          const Float_t   etaC, const Float_t phiC,
-                                               const Float_t   phiUEptsumTrack,      const Float_t   etaUEptsumTrack,
-                                                     Float_t & phiUEptsumTrackNorm,        Float_t & etaUEptsumTrackNorm,
-                                                     Float_t & excessFracEta,              Float_t & excessFracPhi              )   const ;
+  void     CalculateUEBandClusterNormalization(AliCaloTrackReader * reader,     Float_t   etaC, Float_t phiC,
+                                               Float_t   phiUEptsumCluster,     Float_t   etaUEptsumCluster,
+                                               Float_t & phiUEptsumClusterNorm, Float_t & etaUEptsumClusterNorm,
+                                               Float_t & excessFracEta,         Float_t & excessFracPhi              ) const ;
+  
+  void     CalculateUEBandTrackNormalization  (AliCaloTrackReader * reader,     Float_t   etaC,  Float_t phiC,
+                                               Float_t   phiUEptsumTrack,       Float_t   etaUEptsumTrack,
+                                               Float_t & phiUEptsumTrackNorm,   Float_t & etaUEptsumTrackNorm,
+                                               Float_t & excessFracEta,         Float_t & excessFracPhi              )   const ;
 
   void            GetCoeffNormBadCell(AliAODPWG4ParticleCorrelation * pCandidate,
                                AliCaloTrackReader * reader, 
index 6f69c13..686d636 100755 (executable)
@@ -63,7 +63,7 @@ AliMCAnalysisUtils::~AliMCAnalysisUtils()
 }
 
 //_____________________________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t index2, 
+Int_t AliMCAnalysisUtils::CheckCommonAncestor(Int_t index1, Int_t index2, 
                                               const AliCaloTrackReader* reader, 
                                               Int_t & ancPDG, Int_t & ancStatus, 
                                               TLorentzVector & momentum, TVector3 & prodVertex) 
@@ -212,9 +212,8 @@ Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t in
   return ancLabel;
 }
 
-//_____________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t * label, 
-                                      const Int_t nlabels, 
+//_______________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t * label, Int_t nlabels,
                                       const AliCaloTrackReader* reader)
 {
   //Play with the montecarlo particles if available
@@ -236,9 +235,8 @@ Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t * label,
   return tag ;
 }
 
-//_____________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t label, 
-                                      const AliCaloTrackReader* reader)
+//__________________________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOrigin(Int_t label, const AliCaloTrackReader* reader)
 {
   //Play with the montecarlo particles if available
   Int_t tag = 0;
@@ -261,10 +259,8 @@ Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t label,
   return tag ;
 }      
 
-//_________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOriginInStack(const Int_t *labels, 
-                                             const Int_t nlabels, 
-                                             AliStack* stack) 
+//_______________________________________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOriginInStack(const Int_t *labels, Int_t nlabels, AliStack* stack)
 {
   // Play with the MC stack if available. Tag particles depending on their origin.
   // Do same things as in CheckOriginInAOD but different input.
@@ -561,9 +557,8 @@ Int_t AliMCAnalysisUtils::CheckOriginInStack(const Int_t *labels,
 }
 
 
-//_________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOriginInAOD(const Int_t *labels, 
-                                           const Int_t nlabels, 
+//____________________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOriginInAOD(const Int_t *labels, Int_t nlabels,
                                            const TClonesArray *mcparticles) 
 {
   // Play with the MCParticles in AOD if available. Tag particles depending on their origin.
@@ -822,11 +817,9 @@ Int_t AliMCAnalysisUtils::CheckOriginInAOD(const Int_t *labels,
   
 }
 
-//_________________________________________________________________________
-void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels, 
-                                                    const Int_t nlabels, 
-                                                    const Int_t mesonIndex, 
-                                                    AliStack *stack, 
+//_________________________________________________________________________________________
+void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels,    Int_t nlabels,
+                                                    Int_t mesonIndex, AliStack *stack,
                                                     Int_t &tag)
 {
   //Check if cluster is formed from the contribution of 2 decay photons from pi0 or eta. Input in stack
@@ -952,12 +945,9 @@ void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels,
   
 }      
 
-//__________________________________________________________________________________
-void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels,
-                                                    const Int_t nlabels, 
-                                                    const Int_t mesonIndex, 
-                                                    const TClonesArray *mcparticles, 
-                                                    Int_t & tag )
+//________________________________________________________________________________________________________
+void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels, Int_t nlabels, Int_t mesonIndex,
+                                                    const TClonesArray *mcparticles, Int_t & tag   )
 {
   //Check if cluster is formed from the contribution of 2 decay photons from pi0 or eta. Input in AODMCParticles
   
@@ -1101,7 +1091,7 @@ void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels,
   
 }
 
-//_________________________________________________________________________
+//_____________________________________________________________________
 TList * AliMCAnalysisUtils::GetJets(const AliCaloTrackReader * reader)
 {
   //Return list of jets (TParticles) and index of most likely parton that originated it.
@@ -1251,8 +1241,8 @@ TList * AliMCAnalysisUtils::GetJets(const AliCaloTrackReader * reader)
 }
 
 
-//________________________________________________________________________________________________________
-TLorentzVector AliMCAnalysisUtils::GetDaughter(const Int_t idaugh, const Int_t label,
+//__________________________________________________________________________________________________________
+TLorentzVector AliMCAnalysisUtils::GetDaughter(Int_t idaugh, Int_t label,
                                                const AliCaloTrackReader* reader,
                                                Int_t & pdg, Int_t & status, Bool_t & ok, Int_t & daughlabel)
 {
@@ -1321,9 +1311,8 @@ TLorentzVector AliMCAnalysisUtils::GetDaughter(const Int_t idaugh, const Int_t l
   return daughter;
 }
 
-//_______________________________________________________________________________________________
-TLorentzVector AliMCAnalysisUtils::GetMother(const Int_t label, const AliCaloTrackReader* reader,
-                                             Bool_t & ok) 
+//______________________________________________________________________________________________________
+TLorentzVector AliMCAnalysisUtils::GetMother(Int_t label, const AliCaloTrackReader* reader, Bool_t & ok)
 {
   //Return the kinematics of the particle that generated the signal
   
@@ -1331,8 +1320,8 @@ TLorentzVector AliMCAnalysisUtils::GetMother(const Int_t label, const AliCaloTra
   return GetMother(label,reader,pdg,status, ok,momlabel);
 }
 
-//_______________________________________________________________________________________________
-TLorentzVector AliMCAnalysisUtils::GetMother(const Int_t label, const AliCaloTrackReader* reader,
+//_________________________________________________________________________________________
+TLorentzVector AliMCAnalysisUtils::GetMother(Int_t label, const AliCaloTrackReader* reader,
                                              Int_t & pdg, Int_t & status, Bool_t & ok)
 {
   //Return the kinematics of the particle that generated the signal
@@ -1341,8 +1330,8 @@ TLorentzVector AliMCAnalysisUtils::GetMother(const Int_t label, const AliCaloTra
   return GetMother(label,reader,pdg,status, ok,momlabel);
 }
 
-//_______________________________________________________________________________________________
-TLorentzVector AliMCAnalysisUtils::GetMother(const Int_t label, const AliCaloTrackReader* reader, 
+//______________________________________________________________________________________________________
+TLorentzVector AliMCAnalysisUtils::GetMother(Int_t label, const AliCaloTrackReader* reader, 
                                              Int_t & pdg, Int_t & status, Bool_t & ok, Int_t & momlabel)
 {
   //Return the kinematics of the particle that generated the signal, its pdg and its status and its label mother
@@ -1406,8 +1395,9 @@ TLorentzVector AliMCAnalysisUtils::GetMother(const Int_t label, const AliCaloTra
   return mom;
 }
 
-//_____________________________________________________________________________________
-TLorentzVector AliMCAnalysisUtils::GetMotherWithPDG(const Int_t label, const Int_t pdg, const AliCaloTrackReader* reader,
+//___________________________________________________________________________________
+TLorentzVector AliMCAnalysisUtils::GetMotherWithPDG(Int_t label, Int_t pdg,
+                                                    const AliCaloTrackReader* reader,
                                                     Bool_t & ok, Int_t & momlabel)
 {
   //Return the kinematics of the particle that generated the signal
@@ -1497,8 +1487,8 @@ TLorentzVector AliMCAnalysisUtils::GetMotherWithPDG(const Int_t label, const Int
   return grandmom;
 }
 
-//____________________________________________________________________________________________________
-TLorentzVector AliMCAnalysisUtils::GetGrandMother(const Int_t label, const AliCaloTrackReader* reader,
+//______________________________________________________________________________________________
+TLorentzVector AliMCAnalysisUtils::GetGrandMother(Int_t label, const AliCaloTrackReader* reader,
                                                   Int_t & pdg, Int_t & status, Bool_t & ok,
                                                   Int_t & grandMomLabel, Int_t & greatMomLabel)
 {
@@ -1576,8 +1566,8 @@ TLorentzVector AliMCAnalysisUtils::GetGrandMother(const Int_t label, const AliCa
   return grandmom;
 }
 
-//___________________________________________________________________________________________________________________________
-void AliMCAnalysisUtils::GetMCDecayAsymmetryAngleForPDG(const Int_t label, const Int_t pdg, const AliCaloTrackReader* reader,
+//_______________________________________________________________________________________________________________
+void AliMCAnalysisUtils::GetMCDecayAsymmetryAngleForPDG(Int_t label, Int_t pdg, const AliCaloTrackReader* reader,
                                                         Float_t & asym, Float_t & angle, Bool_t & ok)
 {
   //In case of an eta or pi0 decay into 2 photons, get the asymmetry  in the energy of the photons
@@ -1689,8 +1679,8 @@ void AliMCAnalysisUtils::GetMCDecayAsymmetryAngleForPDG(const Int_t label, const
 }
 
 
-//_______________________________________________________________________________________________________
-Int_t AliMCAnalysisUtils::GetNDaughters(const Int_t label, const AliCaloTrackReader* reader, Bool_t & ok)
+//_________________________________________________________________________________________________
+Int_t AliMCAnalysisUtils::GetNDaughters(Int_t label, const AliCaloTrackReader* reader, Bool_t & ok)
 {
   // Return the the number of daughters of a given MC particle
   
@@ -1748,9 +1738,9 @@ Int_t AliMCAnalysisUtils::GetNDaughters(const Int_t label, const AliCaloTrackRea
   return -1;
 }
 
-//_______________________________________________________________________________
-Int_t AliMCAnalysisUtils::GetNOverlaps(const Int_t * label, const UInt_t nlabels,
-                                       const Int_t mctag, const Int_t mesonLabel,
+//_________________________________________________________________________________
+Int_t AliMCAnalysisUtils::GetNOverlaps(const Int_t * label, UInt_t nlabels,
+                                       Int_t mctag, Int_t mesonLabel,
                                        AliCaloTrackReader * reader, Int_t *overpdg)
 {
   // Compare the primary depositing more energy with the rest,
@@ -1842,8 +1832,8 @@ void AliMCAnalysisUtils::Print(const Option_t * opt) const
   
 } 
 
-//________________________________________________________
-void AliMCAnalysisUtils::PrintMCTag(const Int_t tag) const
+//__________________________________________________
+void AliMCAnalysisUtils::PrintMCTag(Int_t tag) const
 {
   // print the assigned origins to this particle
   
@@ -1871,7 +1861,6 @@ void AliMCAnalysisUtils::PrintMCTag(const Int_t tag) const
          CheckTagBit(tag,kMCUnknown),
          CheckTagBit(tag,kMCBadLabel)
          );
-  
 } 
 
 
index 87e00ed..0a43b07 100755 (executable)
@@ -49,45 +49,45 @@ class AliMCAnalysisUtils : public TObject {
   // Methods to check origin of clusters
   //--------------------------------------
   
-  Int_t   CheckCommonAncestor(const Int_t index1, const Int_t index2, const AliCaloTrackReader* reader, 
+  Int_t   CheckCommonAncestor(Int_t index1, Int_t index2, const AliCaloTrackReader* reader, 
                              Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum, TVector3 & v) ;
   
-  Int_t   CheckOrigin(const Int_t label, const AliCaloTrackReader * reader) ;
+  Int_t   CheckOrigin(Int_t label, const AliCaloTrackReader * reader) ;
   
   //Check the label of the most significant particle but do checks on the rest of the contributing labels
-  Int_t   CheckOrigin       (const Int_t *label,  const Int_t nlabels, const AliCaloTrackReader * reader) ;
-  Int_t   CheckOriginInStack(const Int_t *labels, const Int_t nlabels, AliStack * stack)                ; // ESD
-  Int_t   CheckOriginInAOD  (const Int_t *labels, const Int_t nlabels, const TClonesArray* mcparticles) ; // AOD
+  Int_t   CheckOrigin       (const Int_t *label,  Int_t nlabels, const AliCaloTrackReader * reader) ;
+  Int_t   CheckOriginInStack(const Int_t *labels, Int_t nlabels, AliStack * stack)                ; // ESD
+  Int_t   CheckOriginInAOD  (const Int_t *labels, Int_t nlabels, const TClonesArray* mcparticles) ; // AOD
   
-  void    CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex, AliStack * stack, Int_t & tag); // ESD
-  void    CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex, const TClonesArray* mcparticles, Int_t & tag); // AOD
+  void    CheckOverlapped2GammaDecay(const Int_t *labels, Int_t nlabels, Int_t mesonIndex, AliStack * stack, Int_t & tag); // ESD
+  void    CheckOverlapped2GammaDecay(const Int_t *labels, Int_t nlabels, Int_t mesonIndex, const TClonesArray* mcparticles, Int_t & tag); // AOD
   
-  TLorentzVector GetMother     (const Int_t label,const AliCaloTrackReader* reader, Bool_t & ok);
-  TLorentzVector GetMother     (const Int_t label,const AliCaloTrackReader* reader, Int_t & pdg, Int_t & status, Bool_t & ok);
-  TLorentzVector GetMother     (const Int_t label,const AliCaloTrackReader* reader, Int_t & pdg, Int_t & status, Bool_t & ok, Int_t & momLabel);
-  TLorentzVector GetGrandMother(const Int_t label,const AliCaloTrackReader* reader,
+  TLorentzVector GetMother     (Int_t label,const AliCaloTrackReader* reader, Bool_t & ok);
+  TLorentzVector GetMother     (Int_t label,const AliCaloTrackReader* reader, Int_t & pdg, Int_t & status, Bool_t & ok);
+  TLorentzVector GetMother     (Int_t label,const AliCaloTrackReader* reader, Int_t & pdg, Int_t & status, Bool_t & ok, Int_t & momLabel);
+  TLorentzVector GetGrandMother(Int_t label,const AliCaloTrackReader* reader,
                                 Int_t & pdg, Int_t & status, Bool_t & ok, Int_t & grandMomLabel, Int_t & greatMomLabel);
 
-  TLorentzVector GetMotherWithPDG(const Int_t label, const Int_t pdg,const AliCaloTrackReader* reader, Bool_t & ok, Int_t & momLabel);
+  TLorentzVector GetMotherWithPDG(Int_t label, Int_t pdg,const AliCaloTrackReader* reader, Bool_t & ok, Int_t & momLabel);
   
-  void GetMCDecayAsymmetryAngleForPDG(const Int_t label, const Int_t pdg,const AliCaloTrackReader* reader,
+  void GetMCDecayAsymmetryAngleForPDG(Int_t label, Int_t pdg,const AliCaloTrackReader* reader,
                                       Float_t & asy, Float_t & angle, Bool_t & ok);
 
-  Int_t          GetNDaughters(const Int_t label,const AliCaloTrackReader* reader, Bool_t & ok);
-  TLorentzVector GetDaughter  (const Int_t daughter, const Int_t label,const AliCaloTrackReader* reader,
+  Int_t          GetNDaughters(Int_t label,const AliCaloTrackReader* reader, Bool_t & ok);
+  TLorentzVector GetDaughter  (Int_t daughter, Int_t label,const AliCaloTrackReader* reader,
                                Int_t & pdg, Int_t & status, Bool_t & ok, Int_t & daugLabel);
 
-  Int_t          GetNOverlaps(const Int_t * label, const UInt_t nlabels,
-                              const Int_t mctag, const Int_t mesonLabel,
+  Int_t          GetNOverlaps(const Int_t * label, UInt_t nlabels,
+                              Int_t mctag, Int_t mesonLabel,
                               AliCaloTrackReader * reader,Int_t *overpdg);
   
   //Check or set the bits produced in the above methods
-  void    SetTagBit(Int_t &tag, const UInt_t set) const {
+  void    SetTagBit(Int_t &tag, UInt_t set) const {
     // Set bit of type set (mcTypes) in tag
     tag |= (1<<set) ; 
   } 
   
-  Bool_t  CheckTagBit(const Int_t tag, const UInt_t test) const {
+  Bool_t  CheckTagBit(Int_t tag, UInt_t test) const {
     // Check if in tag the bit test (mcTypes) is set.
     if (tag & (1<<test) ) return  kTRUE ;    
     else return kFALSE ;
@@ -107,7 +107,7 @@ class AliMCAnalysisUtils : public TObject {
   TString GetMCGenerator()        const { return fMCGenerator  ; }     
   
   void    Print(const Option_t * opt) const;
-  void    PrintMCTag(const Int_t tag) const;
+  void    PrintMCTag(Int_t tag) const;
 
  private:
   Int_t   fCurrentEvent;        // Current Event
index 38261b9..de3d3d2 100755 (executable)
@@ -192,9 +192,8 @@ void AliNeutralMesonSelection::InitParameters()
 
 }
 
-//_____________________________________________________________________
-Bool_t AliNeutralMesonSelection::IsAngleInWindow(const Float_t angle,
-                                                 const Float_t e) const 
+//______________________________________________________________________________
+Bool_t AliNeutralMesonSelection::IsAngleInWindow(Float_t angle, Float_t e) const
 {
  
   // Check if the opening angle of the candidate pairs is inside 
index 6d0476e..d5790cd 100755 (executable)
@@ -60,7 +60,7 @@ class AliNeutralMesonSelection : public TObject {
   void     SwitchOnAngleSelection()                     { fUseAngleCut = kTRUE           ; }
   void     SwitchOffAngleSelection()                    { fUseAngleCut = kFALSE          ; }
 
-  Bool_t   IsAngleInWindow(const Float_t angle, const Float_t e) const ;
+  Bool_t   IsAngleInWindow(Float_t angle, Float_t e) const ;
   
   //Invariant mass selection