}
//____________________________________________________________________________
-void AliPHOSAnalyze::DrawRecon(Int_t Nevent,Int_t Nmod,const char * branchName,const char* branchTitle){
+void AliPHOSAnalyze::DrawRecon(Int_t Nevent,Int_t Nmod){
//Draws pimary particles and reconstructed
//digits, RecPoints, RecPartices etc
//for event Nevent in the module Nmod.
Info("LS", message.Data()) ;
}
//____________________________________________________________________________
- void AliPHOSAnalyze::InvariantMass(const char* branchTitle)
+ void AliPHOSAnalyze::InvariantMass()
{
// Calculates Real and Mixed invariant mass distributions
if (fRunLoader == 0x0)
}
//____________________________________________________________________________
- void AliPHOSAnalyze::EnergyResolution(const char * branchTitle)
+ void AliPHOSAnalyze::EnergyResolution()
{
//fills two dimentional histo: energy of primary vs. energy of reconstructed
}
//____________________________________________________________________________
-void AliPHOSAnalyze::PositionResolution(const char * branchTitle)
+void AliPHOSAnalyze::PositionResolution()
{
//fills two dimentional histo: energy vs. primary - reconstructed distance
}
//____________________________________________________________________________
-void AliPHOSAnalyze::Contamination(const char* RecPointsTitle){
+void AliPHOSAnalyze::Contamination(){
// fills spectra of primary photons and several kinds of
// reconstructed particles, so that analyzing them one can
// estimate conatmination, efficiency of registration etc.
AliPHOSAnalyze(const AliPHOSAnalyze & ana) ; // cpy ctor
virtual ~AliPHOSAnalyze() ; // dtor
- void DrawRecon(Int_t Nevent= 0,Int_t Nmod = 1,
- const char* branchName = "PHOSRP",
- const char* branchTitle = "Default") ;
+ void DrawRecon(Int_t Nevent= 0,Int_t Nmod = 1) ;
// draws positions of entering of primaries and reconstructed objects in PHOS
- void InvariantMass(const char* RecPartTitle = "Default") ; // Photons invariant mass distributions
+ void InvariantMass() ; // Photons invariant mass distributions
- void EnergyResolution (const char* RecPartTitle = "Default") ; // analyzes Energy resolution ;
+ void EnergyResolution () ; // analyzes Energy resolution ;
- void PositionResolution(const char* RecPartTitle = "Default") ; // analyzes Position resolution ;
+ void PositionResolution() ; // analyzes Position resolution ;
- void Contamination(const char* RecPartTitle = "Default") ; // Counts contamination of photon spectrum
+ void Contamination() ; // Counts contamination of photon spectrum
void Ls() ; //Prints PHOS-related contents of TreeS, TreeD and TreeR
fctdb = 0 ;
}
//____________________________________________________________________________
-AliPHOSCalibrationDB::AliPHOSCalibrationDB(const char* filename ,const char * database):
+AliPHOSCalibrationDB::AliPHOSCalibrationDB(const char * database):
TNamed("AliPHOSCalibrationDB",database){
//Creates the containers: we prepare places for all channels in PHOS
public:
AliPHOSCalibrationDB() ; // ctor
- AliPHOSCalibrationDB(const char* filename ,const char * database = "Primordial") ;
+ AliPHOSCalibrationDB(const char * database) ;
virtual ~AliPHOSCalibrationDB() ; // dtor
//Main method: calibrates if gains are known, otherwise - returns 0
cmngr->WriteData(&gains) ;
}
//_____________________________________________________________________________
-void AliPHOSCalibrator::Print(const Option_t * option)const
+void AliPHOSCalibrator::Print(const Option_t *)const
{
// prints everything
printf("--------------AliPHOSCalibrator-----------------\n") ;
void PlotGain(Int_t channel) ; //Plot histo with gains for a channel
void PlotGains() ; //Plot all gains
- void Print(const Option_t * option) const ;
+ virtual void Print(const Option_t *) const ;
TH1F * PedestalHisto(Int_t channel)
{return dynamic_cast<TH1F* >(fPedHistos->At(channel)) ;} ;
virtual void MakeClusters() {Warning("MakeClusters", "Not Defined" ) ; }
virtual void Print()const {Warning("Print", "Not Defined" ) ; }
- virtual void SetEmcClusteringThreshold(Float_t) = 0;//{Warning("SetEmcClusteringThreshold", "Not Defined" ) ; }
- virtual void SetEmcLocalMaxCut(Float_t ) = 0;//cut) {Warning("SetEmcLocalMaxCut", "Not Defined" ) ; }
+ virtual void SetEmcClusteringThreshold(Float_t) = 0;
+ virtual void SetEmcLocalMaxCut(Float_t ) = 0;
- virtual void SetEmcLogWeight(Float_t) = 0;// w) {Warning("SetEmcLogWeight", "Not Defined" ) ; }
- virtual void SetEmcTimeGate(Float_t) = 0;// gate) {Warning("SetEmcTimeGate", "Not Defined" ) ; }
- virtual void SetCpvClusteringThreshold(Float_t) = 0;// cluth) {Warning("SetCpvClusteringThreshold", "Not Defined" ) ; }
- virtual void SetCpvLocalMaxCut(Float_t) = 0;// cut) {Warning("SetCpvLocalMaxCut", "Not Defined" ) ; }
- virtual void SetCpvLogWeight(Float_t) = 0;// w) {Warning("SetCpvLogWeight", "Not Defined" ) ; }
- virtual void SetUnfolding(Bool_t) = 0;// toUnfold ){Warning("SetUnfolding", "Not Defined" ) ;}
+ virtual void SetEmcLogWeight(Float_t) = 0;
+ virtual void SetEmcTimeGate(Float_t) = 0;
+ virtual void SetCpvClusteringThreshold(Float_t) = 0;
+ virtual void SetCpvLocalMaxCut(Float_t) = 0;
+ virtual void SetCpvLogWeight(Float_t) = 0;
+ virtual void SetUnfolding(Bool_t) = 0;
void SetEventFolderName(TString name) { fEventFolderName = name ; }
AliPHOSClusterizer & operator = (const AliPHOSClusterizer & rvalue) {return *this ;}
return 0 ;
}
//____________________________________________________________________________
-void AliPHOSConTableDB::Print(Option_t * option)const {
+void AliPHOSConTableDB::Print(Option_t *)const {
//prints configuraion
TString message ;
//Transforms AbsId number in PHOS into channel number in prototype
Int_t AbsId2Raw(Int_t AbsId)const ;
- virtual void Print(Option_t * option="") const ;
+ virtual void Print(Option_t *) const ;
AliPHOSConTableDB& operator=(const AliPHOSConTableDB& cdb) ;
Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
- WriteDigits(ievent) ;
+ WriteDigits() ;
if(strstr(option,"deb"))
PrintDigits(option);
}
//____________________________________________________________________________
-void AliPHOSDigitizer::WriteDigits(Int_t event)
+void AliPHOSDigitizer::WriteDigits()
{
// Makes TreeD in the output file.
void InitParameters() ;
void PrintDigits(Option_t * option) ;
void Unload() ;
- void WriteDigits(Int_t evt) ; // Writes Digits for particular event
+ void WriteDigits() ; // Writes Digits for the current event
Float_t TimeOfNoise(void) const; // Calculate time signal generated by noise
//Calculate the time of crossing of the threshold by front edge
}
//____________________________________________________________________________
-void AliPHOSFastRecParticle::Print(Option_t * opt)const
+void AliPHOSFastRecParticle::Print(Option_t *)const
{
// Print the type, energy and momentum of the reconstructed particle
return fIndexInList ;
}
virtual const Int_t GetNPrimaries() const {return 0 ;}
- virtual const TParticle * GetPrimary(Int_t index=0) const {return 0 ;}
+ virtual const TParticle * GetPrimary(Int_t) const {return 0 ;}
const Int_t GetType() const {
// returns the type of the particle
return fType ;
TString Name() const ;
virtual void Paint(Option_t * option="");
- virtual void Print(Option_t * option="") const ;
+ virtual void Print(Option_t *) const ;
void SetType(Int_t type) ;
}
//____________________________________________________________________________
-AliPHOSGammaJet::AliPHOSGammaJet(const AliPHOSGammaJet * gj) {
+AliPHOSGammaJet::AliPHOSGammaJet(const AliPHOSGammaJet & gj) : TTask(gj) {
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-void AliPHOSGammaJet::Exec(Option_t *option)
+void AliPHOSGammaJet::Exec(Option_t *)
{
// does the job
Int_t id_g = -1;
GetGammaJet(particleList,gamma, id_g);
GetLeadingCharge(particleList,charge, id_g);
- GetLeadingPi0(particleList,pi0, id_g);
+ GetLeadingPi0(particleList,pi0);
Info("Pi0Decay", "Gamma: %f %d", gamma.Energy(), id_g) ;
Info("Pi0Decay", "Charge: %f", charge.Energy()) ;
Info("Pi0Decay", "Pi0: %f", pi0.Energy()) ;
}
//____________________________________________________________________________
-void AliPHOSGammaJet::GetLeadingPi0(TList &particleList, TLorentzVector &pi0, Int_t & id)
+void AliPHOSGammaJet::GetLeadingPi0(TList &particleList, TLorentzVector &pi0)
{
TParticle *particle = 0x0;
Int_t ksCode = particle->GetStatusCode();
if((ksCode == 2))
- //&&(id != iPrimary)&&(particle->GetPdgCode() == 111))
{
pt_i = particle->Pt();
if(pt_i> pt_max){
}
//____________________________________________________________________________
-void AliPHOSGammaJet::GetLeadingGammaPair(TList &particleList, TLorentzVector &gammapair, Int_t & id,
- Double_t & thetacut,Double_t & ratiocut1, Double_t & ratiocut2,
- Double_t & invmasscut1,Double_t & invmasscut2)
-{
+// void AliPHOSGammaJet::GetLeadingGammaPair(TList &particleList, TLorentzVector &gammapair, Int_t & id,
+// Double_t & thetacut,Double_t & ratiocut1, Double_t & ratiocut2,
+// Double_t & invmasscut1,Double_t & invmasscut2)
+// {
// TParticle *particle = 0x0;
// Int_t iPrimary=-1;
// }// if kscode 1
// }//while
// // cout<<"iPrimary "<<iPrimary<<endl;
-}
+// }
AliPHOSGammaJet() ; // default ctor
AliPHOSGammaJet(const TString inputfilename) ; //ctor
- AliPHOSGammaJet(const AliPHOSGammaJet * gj) ; // cpy ctor
+ AliPHOSGammaJet(const AliPHOSGammaJet & gj) ; // cpy ctor
~AliPHOSGammaJet() ; // dtor
- virtual void Exec(Option_t *option);
+ virtual void Exec(Option_t *);
void GetGammaJet(TList & particleList, TLorentzVector & gamma, Int_t & id) ;
void GetLeadingCharge(TList & particleList, TLorentzVector & charge, Int_t & id) ;
- void GetLeadingPi0(TList & particleList, TLorentzVector & pi0, Int_t & id) ;
- void GetLeadingGammaPair(TList &particleList, TLorentzVector &gammapair, Int_t & id,
- Double_t & thetacut,Double_t & ratiocut1, Double_t & ratiocut2,
- Double_t & invmasscut1,Double_t & invmasscut2);
+ void GetLeadingPi0(TList & particleList, TLorentzVector & pi0) ;
+// void GetLeadingGammaPair(TList &particleList, TLorentzVector &gammapair, Int_t & id,
+// Double_t & thetacut,Double_t & ratiocut1, Double_t & ratiocut2,
+// Double_t & invmasscut1,Double_t & invmasscut2);
void Pi0Decay(Double_t mPi0, TLorentzVector &p0,
TLorentzVector &p1, TLorentzVector &p2, Double_t &angle) ;
private:
}
-void AliPHOSIhepAnalyze::HitsCPV(TClonesArray& hits, Int_t nev)
+void AliPHOSIhepAnalyze::HitsCPV(Int_t nev)
{
// Cumulative list of charged CPV impacts in event nev.
void AnalyzeEMC1(Int_t Nevents); // resolutions, mult and cluster lengths for EMC
void AnalyzeCPV2(Int_t Nevents); // delta(gen)/delta(rec) between hits
void CpvSingle(Int_t Nevents); // signle particle analysis
- virtual void HitsCPV(TClonesArray& hits, Int_t event);
+ virtual void HitsCPV(Int_t event);
TString GetFileName() { return fFileName; }
private:
return kFALSE ;
}
//____________________________________________________________________________
-Bool_t AliPHOSJet::IsInCone(const Double_t e,const Double_t eta,const Double_t phi)const
+Bool_t AliPHOSJet::IsInCone(const Double_t eta,const Double_t phi)const
{
//Says if particle is inside the defined cone
Double_t dEta ;
fSumPhi = 0. ;
}
//____________________________________________________________________________
-void AliPHOSJet::Print(Option_t * option){
+void AliPHOSJet::Print(){
//Print jet parameters
printf("-------------- AliPHOSJet ------------\n") ;
printf(" Energy............. %f \n",fEnergy) ;
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 e,const Double_t eta,const Double_t phi)const ;
+ Bool_t IsInCone(const Double_t eta,const 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 ;
else return fSumPhi/fSumEnergy ;}
Int_t GetNJetParticles(void)const{return fNpart;}
- void Print(Option_t * option="") ;
+ void Print() ;
AliPHOSJet & operator = (const AliPHOSJet & rvalue) {
// assignement operator requested by coding convention but not needed
Fatal("operator =", "not implemented") ; return *this ;
if(iDigit!= ind){ //first digit already in jet
digit = static_cast<AliPHOSDigit *>(copyDigits->At(iDigit));
CalculateEEtaPhi(digit,e,eta,phi) ;
- if(jet->IsInCone(e,eta,phi) && //is cell in cone
+ if(jet->IsInCone(eta,phi) && //is cell in cone
jet->AcceptConeDeviation(e,eta,phi)){//if cone does not move too much
jet->AddDigit(e,eta,phi,-1) ; //accept new direction
}
//note, that digits might be returned as anused later
for(Int_t icell = 0 ; icell < copyDigits->GetEntries() ; icell++){
digit = static_cast<AliPHOSDigit *>(copyDigits->At(icell));
- if(jet->IsInCone(e,eta,phi)){ //is cell in cone
+ if(jet->IsInCone(eta,phi)){ //is cell in cone
CalculateEEtaPhi(digit,e,eta,phi) ;
jet->AddDigit(e,eta,phi,digit->GetIndexInList()) ;
}
phi = pos.Phi() ;
}
//____________________________________________________________________________
-void AliPHOSJetFinder::Print(Option_t * option){
+void AliPHOSJetFinder::Print(){
//Print parameters of the found jet
printf("\n --------------- AliPHOSJetFinder --------------- \n") ;
printf(" Jets found .........%d \n",fNJets) ;
void FindJetsFromParticles(const TClonesArray * plist,TObjArray * jetslist) ; //Do the job
void FindJetsFromDigits(const TClonesArray * digits,TObjArray * jetslist) ; //Do the job
- void Print(Option_t * option = "") ;
+ void Print() ;
void SetEtSeed(Double_t etseed){fEtSeed = etseed ;} ;
void SetEtMin(Double_t etmin){fEtMin = etmin ;} ;
AliPHOSPID(const AliPHOSPID & pid) : TTask(pid) {;}
virtual ~AliPHOSPID() ; // dtor
- virtual void Exec(Option_t * option) { Warning("Exec", "not defined" ) ; }
+ virtual void Exec(Option_t *) = 0;
virtual const Int_t GetRecParticlesInRun() const { Warning("GetRecParticlesInRun", "not defined" ) ; return 0 ;}
virtual void Print() const { Warning("Print", "not defined" ) ;}
- virtual void SetCpvtoEmcDistanceCut(Float_t Cluster_En, TString Eff_Pur,Float_t cut ) { Warning("SetCpvtoEmcDistanceCut", "not defined" ) ;}
void SetEventFolderName(TString name) { fEventFolderName = name ; }
- virtual void SetTimeGate(Float_t Cluster_En, TString Eff_Pur, Float_t gate) { Warning("SetTimeGate", "not defined" ) ; }
virtual const char * Version() const { Warning("Version", "not defined" ) ; return 0 ; }
- virtual void WriteRecParticles(Int_t event) { Warning("WriteRecParticles", "not defined" ) ; }
+ virtual void WriteRecParticles() = 0;
private:
virtual void Init() { Warning("Init", "not defined" ) ; }
if(gime->TrackSegments() && //Skip events, where no track segments made
gime->TrackSegments()->GetEntriesFast()) {
MakeRecParticles() ;
- WriteRecParticles(ievent);
+ WriteRecParticles();
if(strstr(option,"deb"))
PrintRecParticles(option) ;
//increment the total number of rec particles per run
}
//____________________________________________________________________________
-void AliPHOSPIDv1::WriteRecParticles(Int_t event)
+void AliPHOSPIDv1::WriteRecParticles()
{
AliPHOSGetter *gime = AliPHOSGetter::Instance() ;
const Int_t GetHardPi0Bit (AliPHOSEmcRecPoint * emc) const;
TVector3 GetMomentumDirection(AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * cpv)const ;
void PrintRecParticles(Option_t * option) ;
- virtual void WriteRecParticles(Int_t event) ;
+ virtual void WriteRecParticles() ;
void SetParameters() ; //Fills the matrix of parameters
void Unload();
virtual void Print() const ;
virtual void Reset() { fChange=kFALSE ; }
virtual void Set(TObject * obj) {fObject = obj ;}
- virtual void Update(TObject * value) {} ;
+ virtual void Update() {} ;
private:
}
//____________________________________________________________________________
-void AliPHOSRaw2Digits::Exec(Option_t * option){
+void AliPHOSRaw2Digits::Exec(){
//This is steering method performing all the conversion
if(!fIsInitialized) //need initialization
gAlice->TreeE()->Fill();
}
//____________________________________________________________________________
-void AliPHOSRaw2Digits::Print(Option_t * option)const{
+void AliPHOSRaw2Digits::Print()const{
//prints current configuration and status.
printf("----------AliPHOSRaw2Digits---------- \n") ;
AliPHOSRaw2Digits(AliPHOSRaw2Digits & r2d) ; // cpy ctor
virtual ~AliPHOSRaw2Digits() ; // dtor
- void Exec(Option_t *option) ;
+ void Exec() ;
void SetBeamEnergy(Float_t energy){fBeamEnergy = energy ;}
void SetInputFile(TString inname="Run_1234.fz"){fInName=inname ; }
{for(Int_t i=0;i<3;i++)fTarget[i]=pos[i] ;}
void SetConTableDB(AliPHOSConTableDB * ctdb){fctdb = ctdb ;}
void SetMaxEventsPerFile(Int_t nev=20000){fMaxPerFile = nev ;}
- void Print(Option_t *option="")const ;
+ void Print()const ;
AliPHOSRaw2Digits & operator = ( AliPHOSRaw2Digits & r2d ) { return *this ; }
private:
// Put a comment here
}
-Float_t AliPHOSRecCpvManager::Dispersion(Float_t etot, Float_t ai, Float_t ei) const
+Float_t AliPHOSRecCpvManager::Dispersion(Float_t etot, Float_t ai) const
{
//"Dispresion" of energy deposition in the cell.
// etot is the total shower energy, ai is the
void AG(Float_t e, Float_t dx, Float_t dy, Float_t& a, Float_t& gradx, Float_t& grady );
- Float_t Dispersion(Float_t etot, Float_t ai, Float_t ei) const;
+ Float_t Dispersion(Float_t etot, Float_t ai) const;
Float_t OneGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const ;
Float_t TwoGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const ;
AliPHOSRecEmcManager::~AliPHOSRecEmcManager(void) {}
-Float_t AliPHOSRecEmcManager::Dispersion(Float_t eTot, Float_t ai, Float_t ei) const
+Float_t AliPHOSRecEmcManager::Dispersion(Float_t ei) const
{
//"Dispresion" of energy deposition in the cell.
// eTot is the total shower energy, ai is the
return ei;
}
-Float_t AliPHOSRecEmcManager::OneGamChi2(Float_t ai, Float_t ei, Float_t eTot, Float_t& gi) const
+Float_t AliPHOSRecEmcManager::OneGamChi2(Float_t ai, Float_t ei, Float_t, Float_t& gi) const
{
// Chi2 used in OneGam (one-gamma fitting).
// gi is d(Chi2)/d(ai).
}
-Float_t AliPHOSRecEmcManager::TwoGamChi2(Float_t ai, Float_t ei, Float_t eTot, Float_t& gi) const
+Float_t AliPHOSRecEmcManager::TwoGamChi2(Float_t ai, Float_t ei, Float_t, Float_t& gi) const
{
// calculates chi^2
Float_t da = ai - ei;
void AG(Float_t e, Float_t dx, Float_t dy, Float_t& a, Float_t& gradx, Float_t& grady );
- Float_t Dispersion(Float_t eTot, Float_t ai, Float_t ei) const;
+ Float_t Dispersion(Float_t ei) const;
- Float_t OneGamChi2(Float_t ai, Float_t ei, Float_t eTot, Float_t& gi)const;
- Float_t TwoGamChi2(Float_t ai, Float_t ei, Float_t eTot, Float_t& gi)const;
+ Float_t OneGamChi2(Float_t ai, Float_t ei, Float_t, Float_t& gi)const;
+ Float_t TwoGamChi2(Float_t ai, Float_t ei, Float_t, Float_t& gi)const;
Float_t OneGamChisqCut() const{ return fOneGamChisqCut; }
Float_t OneGamInitialStep() const{ return fOneGamInitialStep; }
virtual ~AliPHOSRecManager(void) {}
virtual void AG(Float_t e, Float_t dx, Float_t dy, Float_t& A, Float_t& gradX, Float_t& gradY ) = 0;
- virtual Float_t Dispersion(Float_t eTot, Float_t ai, Float_t ei) const = 0;
- virtual Float_t OneGamChi2(Float_t ai, Float_t ei, Float_t eTot, Float_t& gi) const = 0 ;
- virtual Float_t TwoGamChi2(Float_t ai, Float_t ei, Float_t eTot, Float_t& gi) const = 0;
+ virtual Float_t OneGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const = 0 ;
+ virtual Float_t TwoGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const = 0;
virtual Float_t OneGamChisqCut()const = 0 ;
virtual Float_t OneGamInitialStep() const = 0;
fIsInitialized = kTRUE ;
}
//____________________________________________________________________________
-void AliPHOSReconstructioner::Exec(Option_t *option)
+void AliPHOSReconstructioner::Exec(Option_t)
{
- //chesk, if the names of branches, which should be made conicide with already
+ //check, if the names of branches, which should be made conicide with already
//existing
if(!fIsInitialized)
Init() ;
// Delete data members if any
}
-void AliPHOSReconstructioner::Print(Option_t * option)const {
+void AliPHOSReconstructioner::Print()const {
// Print reconstructioner data
TString message ;
virtual ~AliPHOSReconstructioner() ;
- virtual void Exec(Option_t * option) ;
+ virtual void Exec(Option_t) ;
AliPHOSDigitizer * GetDigitizer() const { return fDigitizer ; }
AliPHOSClusterizer * GetClusterizer()const { return fClusterizer ; }
AliPHOSTrackSegmentMaker * GetTSMaker() const { return fTSMaker ; }
AliPHOSSDigitizer * GetSDigitizer() const { return fSDigitizer ; }
- void Print(Option_t * option)const ;
+ void Print()const ;
// void SetBranchTitle(const char* branch,const char * title) ;
// // Sets the branch titles to separate different reconstruction flows
}
//____________________________________________________________________________
-void AliPHOSTrackSegment::Print(Option_t * opt) const
+void AliPHOSTrackSegment::Print(Option_t *) const
{
// Print all information on this track Segment
Int_t GetEmcIndex() const { return fEmcRecPoint ; }
Int_t GetCpvIndex() const { return fPpsdUpRecPoint; }
- virtual void Print(Option_t * option) const;
+ virtual void Print(Option_t *) const;
void SetIndexInList(Int_t val){ fIndexInList = val ; }
void SetCpvRecPoint(AliPHOSRecPoint * PpsdUpRecPoint ); //sets PPSD up Rec Point
AliPHOSTrackSegmentMaker(const AliPHOSTrackSegmentMaker & tsmaker) : TTask(tsmaker) { ; }
virtual ~ AliPHOSTrackSegmentMaker() ;
- virtual void Exec(Option_t * option){Warning("Exec", "Not Defined" ) ; }
+ virtual void Exec(Option_t *) = 0;
virtual const Int_t GetTrackSegmentsInRun() const {Warning("GetTrackSegmentsInRun", "Not Defined" ) ; return 0 ; }
virtual void Print()const {Warning("Print", "Not Defined" ) ; }
void SetEventFolderName(TString name) { fEventFolderName = name ; }
- virtual void WriteTrackSegments(Int_t event){Warning("WriteTrackSegments", "Not Defined" ) ; }
+ virtual void WriteTrackSegments() = 0;
protected:
TString fEventFolderName ; // event folder name
MakePairs() ;
}
- WriteTrackSegments(ievent) ;
+ WriteTrackSegments() ;
if(strstr(option,"deb"))
PrintTrackSegments(option);
}
//____________________________________________________________________________
-void AliPHOSTrackSegmentMakerv1::WriteTrackSegments(Int_t event)
+void AliPHOSTrackSegmentMakerv1::WriteTrackSegments()
{
// Writes found TrackSegments to TreeR. Creates branches
// "PHOSTS" and "AliPHOSTrackSegmentMaker" with the same title.
void Init() ;
void InitParameters() ;
void PrintTrackSegments(Option_t *option) ;
- virtual void WriteTrackSegments(Int_t event) ;
+ virtual void WriteTrackSegments() ;
private:
moduleNumber--;
TClonesArray *cpvDigits = new TClonesArray("AliPHOSCPVDigit",0); // array of digits for current hit
- CPVDigitize(pmom,xyd,moduleNumber,cpvDigits);
+ CPVDigitize(pmom,xyd,cpvDigits);
Float_t xmean = 0;
Float_t zmean = 0;
}
//____________________________________________________________________________
-void AliPHOSv1::CPVDigitize (TLorentzVector p, Float_t *zxhit, Int_t moduleNumber, TClonesArray *cpvDigits)
+void AliPHOSv1::CPVDigitize (TLorentzVector p, Float_t *zxhit, TClonesArray *cpvDigits)
{
// ------------------------------------------------------------------------
// Digitize one CPV hit:
return *this ;
}
- void CPVDigitize (TLorentzVector p, Float_t *xy, Int_t moduleNumber, TClonesArray *digits) ;
+ void CPVDigitize (TLorentzVector p, Float_t *xy, TClonesArray *digits) ;
Float_t CPVPadResponseFunction(Float_t qhit, Float_t zg, Float_t xg) ;
Double_t CPVCumulPadResponse(Double_t x, Double_t y) ;