}
//____________________________________________________________________________
-AliEMCALDigitizer::AliEMCALDigitizer(const TString alirunFileName, const TString eventFolderName):
+AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName):
AliDigitizer("EMCAL"+AliConfig::fgkDigitizerTaskName, alirunFileName),
fInputFileNames(0), fEventNames(0), fEventFolderName(eventFolderName)
{
}
//____________________________________________________________________________
-void AliEMCALDigitizer::Digitize(const Int_t event)
+void AliEMCALDigitizer::Digitize(Int_t event)
{
// Makes the digitization of the collected summable digits
}
//__________________________________________________________________
-void AliEMCALDigitizer::MixWith(const TString alirunFileName, const TString eventFolderName)
+void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
{
// Allows to produce digits by superimposing background and signal event.
// It is assumed, that headers file with SIGNAL events is opened in
public:
AliEMCALDigitizer() ; // ctor
- AliEMCALDigitizer(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
+ AliEMCALDigitizer(TString alirunFileNameFile, TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
AliEMCALDigitizer(const AliEMCALDigitizer & dtizer) ;
AliEMCALDigitizer(AliRunDigitizer * manager) ;
virtual ~AliEMCALDigitizer() ;
- void Digitize(const Int_t event); // Make Digits from SDigits stored in fSDigits
+ void Digitize(Int_t event); // Make Digits from SDigits stored in fSDigits
void Exec(Option_t *option); // Supervising method
- const Float_t GetDigitThreshold() const { return fDigitThreshold;}
- const Float_t GetPedestal() const { return fPedestal; }
- const Float_t GetPinNoise() const { return fPinNoise;}
- const Float_t GetSlope() const { return fSlope; }
- const Float_t GetTimeResolution() const { return fTimeResolution ; }
- const Float_t GetECAchannel() const { return fADCchannelEC ; }
- const Float_t GetECApedestal() const { return fADCpedestalEC ; }
+ Float_t GetDigitThreshold() const { return fDigitThreshold;}
+ Float_t GetPedestal() const { return fPedestal; }
+ Float_t GetPinNoise() const { return fPinNoise;}
+ Float_t GetSlope() const { return fSlope; }
+ Float_t GetTimeResolution() const { return fTimeResolution ; }
+ Float_t GetECAchannel() const { return fADCchannelEC ; }
+ Float_t GetECApedestal() const { return fADCpedestalEC ; }
void SetDigitThreshold(Float_t EMCThreshold) {fDigitThreshold = EMCThreshold;}
void SetPinNoise(Float_t PinNoise ) {fPinNoise = PinNoise;}
//General
- const Int_t GetDigitsInRun() const { return fDigitsInRun; }
- void MixWith(const TString alirunFileName,
- const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ; // Add another one file to mix
+ Int_t GetDigitsInRun() const { return fDigitsInRun; }
+ void MixWith(TString alirunFileName,
+ TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ; // Add another one file to mix
void Print()const ;
AliEMCALDigitizer & operator = (const AliEMCALDigitizer & /*rvalue*/) {
}
//______________________________________________________________________
-const Bool_t AliEMCALGeometry::AreInSameTower(Int_t id1, Int_t id2) const {
+Bool_t AliEMCALGeometry::AreInSameTower(Int_t id1, Int_t id2) const {
// Find out whether two hits are in the same tower
Int_t idmax = TMath::Max(id1, id2) ;
Int_t idmin = TMath::Min(id1, id2) ;
}
//______________________________________________________________________
-void AliEMCALGeometry::PosInAlice(const Int_t absid, Float_t &theta, Float_t &phi) const
+void AliEMCALGeometry::PosInAlice(Int_t absid, Float_t &theta, Float_t &phi) const
{
// Converts the relative numbering into the local EMCAL-module (x, z)
// coordinates
}
//______________________________________________________________________
-void AliEMCALGeometry::XYZFromIndex(const Int_t absid, TVector3 &v) const {
+void AliEMCALGeometry::XYZFromIndex(Int_t absid, TVector3 &v) const {
// given the tower relative number it returns the X, Y and Z
// of the tower.
return *(GetInstance()) ;
};
- const Bool_t AreInSameTower(Int_t id1, Int_t id2) const ;
+ Bool_t AreInSameTower(Int_t id1, Int_t id2) const ;
virtual void GetGlobal(const AliRecPoint *, TVector3 &, TMatrix &) const {}
virtual void GetGlobal(const AliRecPoint *, TVector3 &) const {}
virtual Bool_t Impact(const TParticle *) const {return kTRUE;}
Bool_t IsInitialized(void) const { return fgInit ; }
// Return EMCA geometrical parameters
// geometry
- const Float_t GetAlFrontThickness() const { return fAlFrontThick;}
- const Float_t GetArm1PhiMin() const { return fArm1PhiMin ; }
- const Float_t GetArm1PhiMax() const { return fArm1PhiMax ; }
- const Float_t GetArm1EtaMin() const { return fArm1EtaMin;}
- const Float_t GetArm1EtaMax() const { return fArm1EtaMax;}
- const Float_t GetIPDistance() const { return fIPDistance;}
- const Float_t GetIP2ECASection() const { return ( GetIPDistance() + GetAlFrontThickness() + GetGap2Active() ) ; }
- const Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; }
- const Float_t GetShellThickness() const { return fShellThickness ; }
- const Float_t GetZLength() const { return fZLength ; }
- const Float_t GetGap2Active() const {return fGap2Active ; }
- const Float_t GetDeltaEta() const {return (fArm1EtaMax-fArm1EtaMin)/
+ Float_t GetAlFrontThickness() const { return fAlFrontThick;}
+ Float_t GetArm1PhiMin() const { return fArm1PhiMin ; }
+ Float_t GetArm1PhiMax() const { return fArm1PhiMax ; }
+ Float_t GetArm1EtaMin() const { return fArm1EtaMin;}
+ Float_t GetArm1EtaMax() const { return fArm1EtaMax;}
+ Float_t GetIPDistance() const { return fIPDistance;}
+ Float_t GetIP2ECASection() const { return ( GetIPDistance() + GetAlFrontThickness() + GetGap2Active() ) ; }
+ Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; }
+ Float_t GetShellThickness() const { return fShellThickness ; }
+ Float_t GetZLength() const { return fZLength ; }
+ Float_t GetGap2Active() const {return fGap2Active ; }
+ Float_t GetDeltaEta() const {return (fArm1EtaMax-fArm1EtaMin)/
((Float_t)fNZ);}
- const Float_t GetDeltaPhi() const {return (fArm1PhiMax-fArm1PhiMin)/
+ Float_t GetDeltaPhi() const {return (fArm1PhiMax-fArm1PhiMin)/
((Float_t)fNPhi);}
- const Int_t GetNECLayers() const {return fNECLayers ;}
- const Int_t GetNZ() const {return fNZ ;}
- const Int_t GetNEta() const {return fNZ ;}
- const Int_t GetNPhi() const {return fNPhi ;}
- const Int_t GetNTowers() const {return fNPhi * fNZ ;}
- const Float_t GetECPbRadThick()const {return fECPbRadThickness;}
- const Float_t GetECScintThick() const {return fECScintThick;}
- const Float_t GetSampling() const {return fSampling ; }
- const Bool_t IsInECA(Int_t index) const { if ( (index > 0 && (index <= GetNZ() * GetNPhi()))) return kTRUE; else return kFALSE ;}
+ Int_t GetNECLayers() const {return fNECLayers ;}
+ Int_t GetNZ() const {return fNZ ;}
+ Int_t GetNEta() const {return fNZ ;}
+ Int_t GetNPhi() const {return fNPhi ;}
+ Int_t GetNTowers() const {return fNPhi * fNZ ;}
+ Float_t GetECPbRadThick()const {return fECPbRadThickness;}
+ Float_t GetECScintThick() const {return fECScintThick;}
+ Float_t GetSampling() const {return fSampling ; }
+ Bool_t IsInECA(Int_t index) const { if ( (index > 0 && (index <= GetNZ() * GetNPhi()))) return kTRUE; else return kFALSE ;}
Float_t AngleFromEta(Float_t eta){ // returns theta in radians for a given pseudorapidity
return 2.0*TMath::ATan(TMath::Exp(-eta));
void EtaPhiFromIndex(Int_t index,Float_t &eta,Float_t &phi) const;
// returns x, y, and z (cm) on the inner surface of a given EMCAL Cell specified by relid.
void XYZFromIndex(const Int_t *relid,Float_t &x,Float_t &y, Float_t &z) const;
- void XYZFromIndex(const Int_t absid, TVector3 &v) const;
+ void XYZFromIndex(Int_t absid, TVector3 &v) const;
// for a given eta and phi in the EMCAL it returns the tower index.
Int_t TowerIndexFromEtaPhi(Float_t eta,Float_t phi) const;
// for a given eta and phi in the EMCAL it returns the pretower index.
Int_t PreTowerIndexFromEtaPhi(Float_t eta,Float_t phi) const;
// Returns theta and phi (degree) for a given EMCAL cell indicated by relid or absid
void PosInAlice(const Int_t *relid, Float_t &theta, Float_t &phi) const ;
- void PosInAlice(const Int_t absid, Float_t &theta, Float_t &phi) const ;
+ void PosInAlice(Int_t absid, Float_t &theta, Float_t &phi) const ;
Bool_t AbsToRelNumbering(Int_t AbsId, Int_t *relid) const;
void SetNZ(Int_t nz) { fNZ= nz ; printf("SetNZ: Number of modules in Z set to %d", fNZ) ; }
void SetNPhi(Int_t nphi) { fNPhi= nphi ; printf("SetNPhi: Number of modules in Phi set to %d", fNPhi) ; }
return rv ;
}
//____________________________________________________________________________
-void AliEMCALGetter::Event(const Int_t event, const char* opt)
+void AliEMCALGetter::Event(Int_t event, const char* opt)
{
// Reads the content of all Tree's S, D and R
}
//____________________________________________________________________________
-TParticle * AliEMCALGetter::Secondary(const TParticle* p, const Int_t index) const
+TParticle * AliEMCALGetter::Secondary(const TParticle* p, Int_t index) const
{
// Return first (index=1) or second (index=2) secondary particle of primary particle p
}
//____________________________________________________________________________
-void AliEMCALGetter::Track(const Int_t itrack)
+void AliEMCALGetter::Track(Int_t itrack)
{
// Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
static void Print() ;
// //=========== General information about run ==============
- Bool_t IsLoaded(const TString tree) const { return fLoadingStatus.Contains(tree) ; }
- void SetLoaded(const TString tree) { fLoadingStatus += tree ; }
+ Bool_t IsLoaded(TString tree) const { return fLoadingStatus.Contains(tree) ; }
+ void SetLoaded(TString tree) { fLoadingStatus += tree ; }
Int_t MaxEvent() const ;
Int_t EventNumber() const ;
AliEMCALGeometry * EMCALGeometry() const ;
// //========== Methods to read something from file ==========
- void Event(const Int_t event, const char * opt = "HSDRP") ;
- void Track(const Int_t itrack) ;
+ void Event(Int_t event, const char * opt = "HSDRP") ;
+ void Track(Int_t itrack) ;
// //-----------------now getter's data--------------------------------------
// // AliEMCALCalibrationDB * CalibrationDB(){return fcdb; }
TClonesArray * Primaries(void) ;
TParticle * Primary(Int_t index) const ;
Int_t NPrimaries()const { return fNPrimaries; }
- TParticle * Secondary(const TParticle * p, const Int_t index=1) const ;
+ TParticle * Secondary(const TParticle * p, Int_t index=1) const ;
// //=========== Hits =================
// TTree * TreeH(TString filename="") ;
TClonesArray * Hits(void) const ;
- AliEMCALHit * Hit(const Int_t index) const { return dynamic_cast<AliEMCALHit*>(Hits()->At(index) );}
+ AliEMCALHit * Hit(Int_t index) const { return dynamic_cast<AliEMCALHit*>(Hits()->At(index) );}
TTree * TreeH() const ;
//=========== SDigits ==============
TClonesArray * SDigits() const ;
- AliEMCALDigit * SDigit(const Int_t index) const { return static_cast<AliEMCALDigit *>(SDigits()->At(index)) ;}
+ AliEMCALDigit * SDigit(Int_t index) const { return static_cast<AliEMCALDigit *>(SDigits()->At(index)) ;}
TTree * TreeS() const ;
AliEMCALSDigitizer * SDigitizer() ;
//========== Digits ================
TClonesArray * Digits() const ;
- AliEMCALDigit * Digit(const Int_t index) const { return static_cast<AliEMCALDigit *>(Digits()->At(index)) ;}
+ AliEMCALDigit * Digit(Int_t index) const { return static_cast<AliEMCALDigit *>(Digits()->At(index)) ;}
TTree * TreeD() const ;
AliEMCALDigitizer * Digitizer() ;
TString GetDigitsFileName() const { return EmcalLoader()->GetDigitsFileName() ; }
//========== RecPoints =============
TObjArray * ECARecPoints() const;
- AliEMCALTowerRecPoint * ECARecPoint(const Int_t index) const{ return static_cast<AliEMCALTowerRecPoint *>(ECARecPoints()->At(index)) ;}
+ AliEMCALTowerRecPoint * ECARecPoint(Int_t index) const{ return static_cast<AliEMCALTowerRecPoint *>(ECARecPoints()->At(index)) ;}
TTree * TreeR() const ;
AliEMCALClusterizer * Clusterizer() ;
TString GetRecPointsFileName() const { return EmcalLoader()->GetRecPointsFileName() ; }
//========== TrackSegments TClonesArray * TrackSegments(const char * name = 0) {
TClonesArray * TrackSegments() const ;
- AliEMCALTrackSegment * TrackSegments(const Int_t index) const { return static_cast<AliEMCALTrackSegment *>(TrackSegments()->At(index)) ;}
+ AliEMCALTrackSegment * TrackSegments(Int_t index) const { return static_cast<AliEMCALTrackSegment *>(TrackSegments()->At(index)) ;}
TTree * TreeT() const ;
AliEMCALTrackSegmentMaker * TrackSegmentMaker() ;
TString GetTracksFileName() const { return EmcalLoader()->GetTracksFileName() ; }
//========== RecParticles ===========
TClonesArray * RecParticles() const ;
- AliEMCALRecParticle * RecPaticles(const Int_t index) const { return static_cast<AliEMCALRecParticle *>(RecParticles()->At(index)) ;}
+ AliEMCALRecParticle * RecPaticles(Int_t index) const { return static_cast<AliEMCALRecParticle *>(RecParticles()->At(index)) ;}
TTree * TreeP() const ;
AliEMCALPID * PID() ;
TString GetRecParticlesFileName() const { return EmcalLoader()->GetRecParticlesFileName() ; }
virtual ~AliEMCALHadronCorrection() {}
// Add for particle
- virtual Double_t GetEnergy(const Double_t pmom,const Double_t eta,const Int_t gid)=0;
+ virtual Double_t GetEnergy(Double_t pmom, Double_t eta, Int_t gid)=0;
ClassDef(AliEMCALHadronCorrection,1) // Hadron correction for EMC (abstract class)
};
}
Double_t
-AliEMCALHadronCorrectionv0::GetEnergy(const Double_t pmom,const Double_t eta,const Int_t /*gid*/)
+AliEMCALHadronCorrectionv0::GetEnergy(Double_t pmom, Double_t eta, Int_t /*gid*/)
{
Int_t iEta=0; // index
Double_t etaw = TMath::Abs(eta);
public:
static AliEMCALHadronCorrectionv0* Instance();
- virtual Double_t GetEnergy(const Double_t pmom,const Double_t eta,const Int_t gid);
- Double_t GetEnergy(const Double_t pmom, const Double_t eta)
+ virtual Double_t GetEnergy(Double_t pmom, Double_t eta, Int_t gid);
+ Double_t GetEnergy(Double_t pmom, Double_t eta)
{return GetEnergy(pmom,eta,7);}
virtual ~AliEMCALHadronCorrectionv0() {}
}
Double_t
-AliEMCALHadronCorrectionv1::GetEnergy(const Double_t pmom,const Double_t eta,const Int_t /*gid*/)
+AliEMCALHadronCorrectionv1::GetEnergy(Double_t pmom, Double_t eta, Int_t /*gid*/)
{
Double_t etai = TMath::Abs(eta);
Double_t value = fPar[5]*pmom*pmom*pmom+ fPar[0]*pmom*pmom+fPar[1]*pmom +fPar[2]*pmom*etai +fPar[3]*etai + fPar[4];
class AliEMCALHadronCorrectionv1: public AliEMCALHadronCorrection {
public:
static AliEMCALHadronCorrectionv1* Instance();
- virtual Double_t GetEnergy(const Double_t pmom,const Double_t eta,const Int_t gid);
- Double_t GetEnergy(const Double_t pmom, const Double_t eta)
+ virtual Double_t GetEnergy(Double_t pmom, Double_t eta, Int_t gid);
+ Double_t GetEnergy(Double_t pmom, Double_t eta)
{return GetEnergy(pmom,eta,7);}
void SetGeometry(TString name, Double_t fs = 1.);
}
}
-const Char_t* AliEMCALJetMicroDst::DefineName(const Int_t mode)
+const Char_t* AliEMCALJetMicroDst::DefineName(Int_t mode)
{
//DefineName member
static TString dir, name;
void FillJetsControl(); // 18-jan-2003
- Bool_t Open(const Int_t mode=1) {return Open(DefineName(mode));} // *MENU*
+ Bool_t Open(Int_t mode=1) {return Open(DefineName(mode));} // *MENU*
Bool_t Open(const char *fname); // *MENU*
- const Char_t* DefineName(const Int_t mode=1); // *MENU*
+ const Char_t* DefineName(Int_t mode=1); // *MENU*
Bool_t Initialize(TFile *file);
void Print(Option_t* option="") const; // *MENU*
Int_t GetEntry(Int_t entry);
}
//____________________________________________________________________________
-Int_t AliEMCALTowerRecPoint::GetMultiplicityAtLevel(const Float_t H) const
+Int_t AliEMCALTowerRecPoint::GetMultiplicityAtLevel(Float_t H) const
{
// Calculates the multiplicity of digits with energy larger than H*energy
Float_t GetMaximalEnergy(void) const ; // get the highest energy in the cluster
Int_t GetMaximumMultiplicity() const {return fMaxDigit ;} // gets the maximum number of digits allowed
Int_t GetMultiplicity(void) const { return fMulDigit ; } // gets the number of digits making this recpoint
- Int_t GetMultiplicityAtLevel(const Float_t level) const ; // computes multiplicity of digits with
+ Int_t GetMultiplicityAtLevel(Float_t level) const ; // computes multiplicity of digits with
// energy above relative level
virtual Int_t GetNumberOfLocalMax(AliEMCALDigit ** maxAt, Float_t * maxAtEnergy,
Float_t locMaxCut,TClonesArray * digits ) const ;