void Ls() ; //Prints PHOS-related contents of TreeS, TreeD and TreeR
- void SetEnergyCorrection(const Float_t ecor){fCorrection = ecor ;}
+ void SetEnergyCorrection(Float_t ecor){fCorrection = ecor ;}
AliPHOSAnalyze & operator = (const AliPHOSAnalyze & /*rvalue*/) {
// assignement operator requested by coding convention but not needed
private:
- Float_t CorrectedEnergy(const Float_t ReconstEnergy)const
+ Float_t CorrectedEnergy(Float_t ReconstEnergy)const
{return ReconstEnergy * fCorrection;}
//Converts reconstructed energy (energy of the EMCRecPoint) to the energy of primary
//The coeficient shoud be (and was) calculated usin Erec vs. Eprim plot
}
//____________________________________________________________________________
-AliPHOSDigitizer::AliPHOSDigitizer(const TString alirunFileName, const TString eventFolderName):
+AliPHOSDigitizer::AliPHOSDigitizer(TString alirunFileName, TString eventFolderName):
AliDigitizer("PHOS"+AliConfig::fgkDigitizerTaskName, alirunFileName),
fInputFileNames(0), fEventNames(0), fEventFolderName(eventFolderName)
{
}
//____________________________________________________________________________
-void AliPHOSDigitizer::Digitize(const Int_t event)
+void AliPHOSDigitizer::Digitize(Int_t event)
{
// Makes the digitization of the collected summable digits.
}
//__________________________________________________________________
-void AliPHOSDigitizer::MixWith(const TString alirunFileName, const TString eventFolderName)
+void AliPHOSDigitizer::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:
AliPHOSDigitizer() ; // ctor
- AliPHOSDigitizer(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
+ AliPHOSDigitizer(TString alirunFileNameFile, TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
AliPHOSDigitizer(const AliPHOSDigitizer & dtizer) ;
AliPHOSDigitizer(AliRunDigitizer * manager) ;
virtual ~AliPHOSDigitizer() ;
- void Digitize(const Int_t event) ; // Make Digits from SDigits
+ void Digitize(Int_t event) ; // Make Digits from SDigits
void Exec(Option_t *option); // Supervising method
//CPV parameters
- const Float_t GetCPVNoise() const { return fCPVNoise ;}
- const Float_t GetCPVThreshold() const { return fCPVDigitThreshold ;}
- const Float_t GetCPVchannel() const { return fADCchanelCpv; }
- const Float_t GetCPVpedestal() const { return fADCpedestalCpv; }
+ Float_t GetCPVNoise() const { return fCPVNoise ;}
+ Float_t GetCPVThreshold() const { return fCPVDigitThreshold ;}
+ Float_t GetCPVchannel() const { return fADCchanelCpv; }
+ Float_t GetCPVpedestal() const { return fADCpedestalCpv; }
void SetCPVNoise(Float_t CPVNoise) {fCPVNoise = CPVNoise;}
void SetCPVThreshold(Float_t CPVThreshold) {fCPVDigitThreshold= CPVThreshold;}
//EMC parameters
- const Float_t GetEMCThreshold() const { return fEMCDigitThreshold;}
- const Float_t GetEMCchannel() const { return fADCchanelEmc; }
- const Float_t GetEMCpedestal() const { return fADCpedestalEmc; }
- const Float_t GetPinNoise() const { return fPinNoise;}
- const Float_t GetTimeResolution() const { return fTimeResolution ; }
+ Float_t GetEMCThreshold() const { return fEMCDigitThreshold;}
+ Float_t GetEMCchannel() const { return fADCchanelEmc; }
+ Float_t GetEMCpedestal() const { return fADCpedestalEmc; }
+ Float_t GetPinNoise() const { return fPinNoise;}
+ Float_t GetTimeResolution() const { return fTimeResolution ; }
void SetEMCThreshold(Float_t EMCThreshold) {fEMCDigitThreshold = EMCThreshold;}
void SetPinNoise(Float_t PinNoise ) {fPinNoise = PinNoise;}
void SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
//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 ;
AliPHOSDigitizer & operator = (const AliPHOSDigitizer & /*rvalue*/) {
}
//____________________________________________________________________________
-Int_t AliPHOSEmcRecPoint::GetMultiplicityAtLevel(const Float_t H) const
+Int_t AliPHOSEmcRecPoint::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
Short_t GetNExMax(void) const {return fNExMax ;} // Number of maxima found in cluster in unfolding:
// 0: was no unfolging
}
//____________________________________________________________________________
-Bool_t AliPHOSGeometry::AbsToRelNumbering(const Int_t AbsId, Int_t * relid) const
+Bool_t AliPHOSGeometry::AbsToRelNumbering(Int_t AbsId, Int_t * relid) const
{
// Converts the absolute numbering into the following array/
// relid[0] = PHOS Module number 1:fNModules
}
//____________________________________________________________________________
-void AliPHOSGeometry::EmcModuleCoverage(const Int_t mod, Double_t & tm, Double_t & tM, Double_t & pm, Double_t & pM, Option_t * opt) const
+void AliPHOSGeometry::EmcModuleCoverage(Int_t mod, Double_t & tm, Double_t & tM, Double_t & pm, Double_t & pM, Option_t * opt) const
{
// calculates the angular coverage in theta and phi of one EMC (=PHOS) module
}
//____________________________________________________________________________
-void AliPHOSGeometry::ImpactOnEmc(const Double_t theta, const Double_t phi, Int_t & ModuleNumber, Double_t & z, Double_t & x) const
+void AliPHOSGeometry::ImpactOnEmc(Double_t theta, Double_t phi, Int_t & ModuleNumber, Double_t & z, Double_t & x) const
{
// calculates the impact coordinates on PHOS of a neutral particle
// emitted in the direction theta and phi in the ALICE global coordinate system
//____________________________________________________________________________
-void AliPHOSGeometry::RelPosInAlice(const Int_t id, TVector3 & pos ) const
+void AliPHOSGeometry::RelPosInAlice(Int_t id, TVector3 & pos ) const
{
// Converts the absolute numbering into the global ALICE coordinate system
static TString Radian(void){ return TString("rad") ; } // a global for radian (rad)
- Bool_t AbsToRelNumbering(const Int_t AbsId, Int_t * RelId) const ;
+ Bool_t AbsToRelNumbering(Int_t AbsId, Int_t * RelId) const ;
// converts the absolute PHOS numbering to a relative
- void EmcModuleCoverage(const Int_t m, Double_t & tm, Double_t & tM, Double_t & pm,
+ void EmcModuleCoverage(Int_t m, Double_t & tm, Double_t & tM, Double_t & pm,
Double_t & pM, Option_t * opt = Radian() ) const ;
// calculates the angular coverage in theta and phi of a EMC module
void EmcXtalCoverage(Double_t & theta, Double_t & phi, Option_t * opt = Radian() ) const ;
// calculates the angular coverage in theta and phi of a
// single crystal in a EMC module
- void ImpactOnEmc(const Double_t theta, const Double_t phi, Int_t & ModuleNumber,
+ void ImpactOnEmc(Double_t theta, Double_t phi, Int_t & ModuleNumber,
Double_t & z, Double_t & x) const ;
// calculates the impact coordinates of a neutral particle
// emitted in direction theta and phi in ALICE
- Bool_t IsInEMC(const Int_t id) const { if (id > GetNModules() * GetNCristalsInModule() ) return kFALSE; return kTRUE; }
+ Bool_t IsInEMC(Int_t id) const { if (id > GetNModules() * GetNCristalsInModule() ) return kFALSE; return kTRUE; }
void RelPosInModule(const Int_t * RelId, Float_t & y, Float_t & z) const ;
// gets the position of element (pad or Xtal) relative to
// center of PHOS module
- void RelPosInAlice(const Int_t AbsId, TVector3 & pos) const ;
+ void RelPosInAlice(Int_t AbsId, TVector3 & pos) const ;
// gets the position of element (pad or Xtal) relative to Alice
Bool_t RelToAbsNumbering(const Int_t * RelId, Int_t & AbsId) const ;
// converts the absolute PHOS numbering to a relative
return rv ;
}
//____________________________________________________________________________
-void AliPHOSGetter::Event(const Int_t event, const char* opt)
+void AliPHOSGetter::Event(Int_t event, const char* opt)
{
// Reads the content of all Tree's S, D and R
}
//____________________________________________________________________________
-TParticle * AliPHOSGetter::Secondary(const TParticle* p, const Int_t index) const
+TParticle * AliPHOSGetter::Secondary(const TParticle* p, Int_t index) const
{
// Return first (index=1) or second (index=2) secondary particle of primary particle p
}
//____________________________________________________________________________
-void AliPHOSGetter::Track(const Int_t itrack)
+void AliPHOSGetter::Track(Int_t itrack)
{
// Read the first entry of PHOS 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 ;
AliPHOSGeometry * PHOSGeometry() 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--------------------------------------
// AliPHOSCalibrationDB * 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 =================
TClonesArray * Hits(void) ;
- AliPHOSHit * Hit(const Int_t index) { return dynamic_cast<AliPHOSHit*>(Hits()->At(index) );}
+ AliPHOSHit * Hit(Int_t index) { return dynamic_cast<AliPHOSHit*>(Hits()->At(index) );}
TTree * TreeH() const ;
//=========== SDigits ==============
TClonesArray * SDigits() ;
- AliPHOSDigit * SDigit(const Int_t index) { return static_cast<AliPHOSDigit *>(SDigits()->At(index)) ;}
+ AliPHOSDigit * SDigit(Int_t index) { return static_cast<AliPHOSDigit *>(SDigits()->At(index)) ;}
TTree * TreeS() const ;
AliPHOSSDigitizer * SDigitizer() ;
//========== Digits ================
TClonesArray * Digits() ;
- AliPHOSDigit * Digit(const Int_t index) { return static_cast<AliPHOSDigit *>(Digits()->At(index)) ;}
+ AliPHOSDigit * Digit(Int_t index) { return static_cast<AliPHOSDigit *>(Digits()->At(index)) ;}
TTree * TreeD() const ;
AliPHOSDigitizer * Digitizer() ;
TString GetDigitsFileName() const { return PhosLoader()->GetDigitsFileName() ; }
//========== RecPoints =============
TObjArray * EmcRecPoints() ;
- AliPHOSEmcRecPoint * EmcRecPoint(const Int_t index) { return static_cast<AliPHOSEmcRecPoint *>(EmcRecPoints()->At(index)) ;}
+ AliPHOSEmcRecPoint * EmcRecPoint(Int_t index) { return static_cast<AliPHOSEmcRecPoint *>(EmcRecPoints()->At(index)) ;}
TObjArray * CpvRecPoints() ;
- AliPHOSCpvRecPoint * CpvRecPoint(const Int_t index) { return static_cast<AliPHOSCpvRecPoint *>(CpvRecPoints()->At(index)) ;}
+ AliPHOSCpvRecPoint * CpvRecPoint(Int_t index) { return static_cast<AliPHOSCpvRecPoint *>(CpvRecPoints()->At(index)) ;}
TTree * TreeR() const ;
AliPHOSClusterizer * Clusterizer() ;
TString GetRecPointsFileName() const { return PhosLoader()->GetRecPointsFileName() ; }
//========== TrackSegments TClonesArray * TrackSegments(const char * name = 0) {
TClonesArray * TrackSegments() ;
- AliPHOSTrackSegment * TrackSegments(const Int_t index) { return static_cast<AliPHOSTrackSegment *>(TrackSegments()->At(index)) ;}
+ AliPHOSTrackSegment * TrackSegments(Int_t index) { return static_cast<AliPHOSTrackSegment *>(TrackSegments()->At(index)) ;}
TTree * TreeT() const ;
AliPHOSTrackSegmentMaker * TrackSegmentMaker() ;
TString GetTracksFileName() const { return PhosLoader()->GetTracksFileName() ; }
//========== RecParticles ===========
TClonesArray * RecParticles() ;
- AliPHOSRecParticle * RecPaticles(const Int_t index) { return static_cast<AliPHOSRecParticle *>(RecParticles()->At(index)) ;}
+ AliPHOSRecParticle * RecPaticles(Int_t index) { return static_cast<AliPHOSRecParticle *>(RecParticles()->At(index)) ;}
TTree * TreeP() const ;
AliPHOSPID * PID() ;
TString GetRecParticlesFileName() const { return PhosLoader()->GetRecParticlesFileName() ; }
}
//____________________________________________________________________________
-void AliPHOSJet::AddParticle(const TParticle * p,const Int_t index){
+void AliPHOSJet::AddParticle(const TParticle * p, Int_t index){
//adds particle to jet. Calculates change in jet direction,
//due to addition of this particle and if it is smaller, than fMaxDev,
//add particle, axcept new direction and return true.
}
}
//____________________________________________________________________________
-void AliPHOSJet::AddDigit(const Double_t e,const Double_t eta,const Double_t phi, const Int_t index){
+void AliPHOSJet::AddDigit(Double_t e, Double_t eta, Double_t phi, Int_t index){
//adds particle to jet. Calculates change in jet direction,
//due to addition of this particle and if it is smaller, than fMaxDev,
//add particle, axcept new direction and return true.
return kFALSE ;
}
//____________________________________________________________________________
-Bool_t AliPHOSJet::AcceptConeDeviation(const Double_t e,const Double_t eta,const Double_t phi)const
+Bool_t AliPHOSJet::AcceptConeDeviation(Double_t e, Double_t eta, Double_t phi)const
{ //Calculate cone deviation in case of inclusion of the given
//particle to jet.
return kFALSE ;
}
//____________________________________________________________________________
-Bool_t AliPHOSJet::IsInCone(const Double_t eta,const Double_t phi)const
+Bool_t AliPHOSJet::IsInCone(Double_t eta, Double_t phi)const
{
//Says if particle is inside the defined cone
Double_t dEta ;
}
virtual ~AliPHOSJet() ;
- void AddDigit(const Double_t e,const Double_t eta,const Double_t phi,const Int_t index) ;
- void AddParticle(const TParticle * p,const Int_t index) ;
+ void AddDigit(Double_t e, Double_t eta, Double_t phi, Int_t index) ;
+ void AddParticle(const TParticle * p, Int_t index) ;
//adds particle p to jet. index: index of p in list of all particles in event
Double_t DistanceToJet(const TParticle *p)const ;
const Int_t * Indexs(Int_t & nIndexs)const{nIndexs = fNpart; return fList->GetArray() ;}
Bool_t IsInCone(const TParticle * p)const ;
- Bool_t IsInCone(const Double_t eta,const Double_t phi)const ;
+ Bool_t IsInCone(Double_t eta, Double_t phi)const ;
Bool_t AcceptConeDeviation(const TParticle *p)const ;
- Bool_t AcceptConeDeviation(const Double_t e,const Double_t eta,const Double_t phi)const ;
+ Bool_t AcceptConeDeviation(Double_t e, Double_t eta, Double_t phi)const ;
void SetConeRadius(Double_t r){fConeRad = r ;} ;
void SetMaxConeMove(Double_t max = 0.15){fMaxConeMove = max ;} ;
AliPHOSPID(const AliPHOSPID & pid) : TTask(pid) {;}
virtual ~AliPHOSPID() ; // dtor
- virtual const Int_t GetRecParticlesInRun() const { Warning("GetRecParticlesInRun", "not defined" ) ; return 0 ;}
+ virtual Int_t GetRecParticlesInRun() const { Warning("GetRecParticlesInRun", "not defined" ) ; return 0 ;}
virtual void Print() const { Warning("Print", "not defined" ) ;}
void SetEventRange(Int_t first=0, Int_t last=-1) {fFirstEvent=first; fLastEvent=last; }
void SetEventFolderName(TString name) { fEventFolderName = name ; }
virtual void Exec(Option_t * option);
// virtual char * GetRecParticlesBranch()const {return (char*) fRecParticlesTitle.Data() ;}
// virtual char * GetTrackSegmentsBranch()const{return (char*) fTrackSegmentsTitle.Data(); }
- virtual const Int_t GetRecParticlesInRun() const {return fRecParticlesInRun ;}
+ virtual Int_t GetRecParticlesInRun() const {return fRecParticlesInRun ;}
virtual void PlotDispersionCuts()const ;
virtual void Print()const ;
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetParameterCalibration(Int_t i) const
+Float_t AliPHOSPIDv1::GetParameterCalibration(Int_t i) const
{
// Get the i-th parameter "Calibration"
Float_t param = 0.;
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetCalibratedEnergy(const Float_t e) const
+Float_t AliPHOSPIDv1::GetCalibratedEnergy(Float_t e) const
{
// It calibrates Energy depending on the recpoint energy.
// The energy of the reconstructed cluster is corrected with
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetParameterCpv2Emc(Int_t i, TString axis) const
+Float_t AliPHOSPIDv1::GetParameterCpv2Emc(Int_t i, TString axis) const
{
// Get the i-th parameter "CPV-EMC distance" for the specified axis
Float_t param = 0.;
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetCpv2EmcDistanceCut(TString axis, Float_t e) const
+Float_t AliPHOSPIDv1::GetCpv2EmcDistanceCut(TString axis, Float_t e) const
{
// Get CpvtoEmcDistance Cut depending on the cluster energy, axis and
// Purity-Efficiency point
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetEllipseParameter(TString particle, TString param, Float_t e) const
+Float_t AliPHOSPIDv1::GetEllipseParameter(TString particle, TString param, Float_t e) const
{
// Calculates the parameter param of the ellipse
}
//_____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetParameterPhotonBoundary (Int_t i) const
+Float_t AliPHOSPIDv1::GetParameterPhotonBoundary (Int_t i) const
{
// Get the parameter "i" to calculate the boundary on the moment M2x
// for photons at high p_T
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetParameterPi0Boundary (Int_t i) const
+Float_t AliPHOSPIDv1::GetParameterPi0Boundary (Int_t i) const
{
// Get the parameter "i" to calculate the boundary on the moment M2x
// for pi0 at high p_T
}
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetParameterTimeGate(Int_t i) const
+Float_t AliPHOSPIDv1::GetParameterTimeGate(Int_t i) const
{
// Get TimeGate parameter depending on Purity-Efficiency i:
// i=0 - Low purity, i=1 - Medium purity, i=2 - High purity
}
//_____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetParameterToCalculateEllipse(TString particle, TString param, Int_t i) const
+Float_t AliPHOSPIDv1::GetParameterToCalculateEllipse(TString particle, TString param, Int_t i) const
{
// Get the parameter "i" that is needed to calculate the ellipse
// parameter "param" for the particle "particle" ("photon" or "pi0")
//____________________________________________________________________________
-const Float_t AliPHOSPIDv1::GetDistance(AliPHOSEmcRecPoint * emc,AliPHOSRecPoint * cpv, Option_t * axis)const
+Float_t AliPHOSPIDv1::GetDistance(AliPHOSEmcRecPoint * emc,AliPHOSRecPoint * cpv, Option_t * axis)const
{
// Calculates the distance between the EMC RecPoint and the PPSD RecPoint
return 100000000 ;
}
//____________________________________________________________________________
-const Int_t AliPHOSPIDv1::GetCPVBit(AliPHOSEmcRecPoint * emc,AliPHOSRecPoint * cpv,const Int_t effPur, Float_t e) const
+Int_t AliPHOSPIDv1::GetCPVBit(AliPHOSEmcRecPoint * emc,AliPHOSRecPoint * cpv, Int_t effPur, Float_t e) const
{
if(effPur>2 || effPur<0)
Error("GetCPVBit","Invalid Efficiency-Purity choice %d",effPur);
}
//____________________________________________________________________________
-const Int_t AliPHOSPIDv1::GetPrincipalBit(TString particle, const Double_t* p,const Int_t effPur, Float_t e)const
+Int_t AliPHOSPIDv1::GetPrincipalBit(TString particle, const Double_t* p, Int_t effPur, Float_t e)const
{
//Is the particle inside de PCA ellipse?
}
//____________________________________________________________________________
-const Int_t AliPHOSPIDv1::GetHardPhotonBit(AliPHOSEmcRecPoint * emc) const
+Int_t AliPHOSPIDv1::GetHardPhotonBit(AliPHOSEmcRecPoint * emc) const
{
// Set bit for identified hard photons (E > 30 GeV)
// if the second moment M2x is below the boundary
}
//____________________________________________________________________________
-const Int_t AliPHOSPIDv1::GetHardPi0Bit(AliPHOSEmcRecPoint * emc) const
+Int_t AliPHOSPIDv1::GetHardPi0Bit(AliPHOSEmcRecPoint * emc) const
{
// Set bit for identified hard pi0 (E > 30 GeV)
// if the second moment M2x is above the boundary
const TString GetFileNameParameters() const {return fFileNameParameters ;}
// Get number of rec.particles in this run
- virtual const Int_t GetRecParticlesInRun() const {return fRecParticlesInRun ;}
+ virtual Int_t GetRecParticlesInRun() const {return fRecParticlesInRun ;}
// Get PID parameters as they are defined in fParameters
- const Float_t GetParameterCalibration (Int_t i) const;
- const Float_t GetParameterCpv2Emc (Int_t i, TString axis) const;
- const Float_t GetParameterTimeGate (Int_t i) const;
- const Float_t GetParameterToCalculateEllipse(TString particle, TString param, Int_t i) const ;
- const Float_t GetParameterPhotonBoundary (Int_t i) const;
- const Float_t GetParameterPi0Boundary (Int_t i) const;
+ Float_t GetParameterCalibration (Int_t i) const;
+ Float_t GetParameterCpv2Emc (Int_t i, TString axis) const;
+ Float_t GetParameterTimeGate (Int_t i) const;
+ Float_t GetParameterToCalculateEllipse(TString particle, TString param, Int_t i) const ;
+ Float_t GetParameterPhotonBoundary (Int_t i) const;
+ Float_t GetParameterPi0Boundary (Int_t i) const;
// Get energy-dependent PID parameters
- const Float_t GetCalibratedEnergy (const Float_t e) const;
- const Float_t GetCpv2EmcDistanceCut (TString axis, Float_t e) const ;
- const Float_t GetEllipseParameter (TString particle, TString param, Float_t e) const;
+ Float_t GetCalibratedEnergy (Float_t e) const;
+ Float_t GetCpv2EmcDistanceCut (TString axis, Float_t e) const ;
+ Float_t GetEllipseParameter (TString particle, TString param, Float_t e) const;
// Set PID parameters to change appropriate element of fParameters
void SetParameterCalibration (Int_t i, Float_t param);
virtual void InitParameters() ;
void MakeRecParticles(void ) ;
// Relative Distance CPV-EMC
- const Float_t GetDistance (AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * cpv, Option_t * axis)const ;
- const Int_t GetCPVBit (AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * cpv, Int_t EffPur, Float_t e) const;
- const Int_t GetPrincipalBit (TString particle, const Double_t* P, Int_t EffPur, Float_t e)const ; //Principal cut
- const Int_t GetHardPhotonBit(AliPHOSEmcRecPoint * emc) const;
- const Int_t GetHardPi0Bit (AliPHOSEmcRecPoint * emc) const;
+ Float_t GetDistance (AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * cpv, Option_t * axis)const ;
+ Int_t GetCPVBit (AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * cpv, Int_t EffPur, Float_t e) const;
+ Int_t GetPrincipalBit (TString particle, const Double_t* P, Int_t EffPur, Float_t e)const ; //Principal cut
+ Int_t GetHardPhotonBit(AliPHOSEmcRecPoint * emc) const;
+ Int_t GetHardPi0Bit (AliPHOSEmcRecPoint * emc) const;
TVector3 GetMomentumDirection(AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * cpv)const ;
void PrintRecParticles(Option_t * option) ;
virtual void WriteRecParticles() ;
Int_t primaryindex = dynamic_cast<AliPHOSEmcRecPoint*>(gime->EmcRecPoints()->At(emcRPindex))->GetPrimaries(dummy)[index] ;
return gime->Primary(primaryindex) ;
}
- return 0 ;
+ // return 0 ;
}
}
//____________________________________________________________________________
-Double_t AliPHOSvFast::MakeEnergy(const Double_t energy)
+Double_t AliPHOSvFast::MakeEnergy(Double_t energy)
{
// Smears the energy according to the energy dependent energy resolution.
// A gaussian distribution is assumed
}
//____________________________________________________________________________
-TVector3 AliPHOSvFast::MakePosition(const Double_t energy, const TVector3 pos, const Double_t theta, const Double_t phi)
+TVector3 AliPHOSvFast::MakePosition(Double_t energy, TVector3 pos, Double_t theta, Double_t phi)
{
// Smears the impact position according to the energy dependent position resolution
// A gaussian position distribution is assumed
}
//____________________________________________________________________________
-void AliPHOSvFast::MakeRecParticle(const Int_t modid, const TVector3 pos, AliPHOSFastRecParticle & rp)
+void AliPHOSvFast::MakeRecParticle(Int_t modid, TVector3 pos, AliPHOSFastRecParticle & rp)
{
// Modify the primary particle properties according
// 1. the response function of PHOS
}
void MakeBranch(Option_t* opt);
- Double_t MakeEnergy(const Double_t energy) ; // makes the detected energy
- TVector3 MakePosition(const Double_t energy, const TVector3 pos, const Double_t th, const Double_t ph) ;
+ Double_t MakeEnergy(Double_t energy) ; // makes the detected energy
+ TVector3 MakePosition(Double_t energy, TVector3 pos, Double_t th, Double_t ph) ;
// makes the detected position
- void MakeRecParticle(const Int_t modid, const TVector3 pos, AliPHOSFastRecParticle & rp) ; // makes a reconstructes particle from primary
+ void MakeRecParticle(Int_t modid, TVector3 pos, AliPHOSFastRecParticle & rp) ; // makes a reconstructes particle from primary
Int_t MakeType(AliPHOSFastRecParticle & rp) ; // gets the detected type of particle
// gets TClonesArray of reconstructed particles
TClonesArray * FastRecParticles() const { return fFastRecParticles ; }