From 85c60a8ef6c7d60a77a305e6b551e6084ad1a9d8 Mon Sep 17 00:00:00 2001 From: hristov Date: Fri, 10 Mar 2006 13:23:36 +0000 Subject: [PATCH] Using AliESDCaloCluster instead of AliESDtrack --- EMCAL/AliEMCALRecPoint.cxx | 27 +++++-- EMCAL/AliEMCALRecPoint.h | 12 ++- EMCAL/AliEMCALReconstructor.cxx | 72 ++++++++++-------- EMCAL/AliEMCALReconstructor.h | 1 - PHOS/AliPHOSFastRecParticle.h | 8 +- PHOS/AliPHOSGammaJet.cxx | 36 +++++---- PHOS/AliPHOSRecParticle.cxx | 2 +- PHOS/AliPHOSRecParticle.h | 4 +- PHOS/AliPHOSReconstructor.cxx | 23 +++--- STEER/AliESD.cxx | 27 ++++--- STEER/AliESD.h | 40 ++++++---- STEER/AliESDCaloCluster.cxx | 129 ++++++++++++++++++++++++++++++++ STEER/AliESDCaloCluster.h | 124 ++++++++++++++++++++++++++++++ STEER/AliESDpid.cxx | 16 ++-- STEER/AliESDtrack.cxx | 86 ++++++--------------- STEER/AliESDtrack.h | 47 ++++-------- STEER/AliEventTag.cxx | 14 ++-- STEER/AliEventTag.h | 15 ++-- STEER/AliReconstruction.cxx | 4 +- STEER/AliTag.cxx | 8 +- STEER/AliTag.h | 14 ++-- STEER/AliTagCreator.cxx | 4 +- STEER/ESDLinkDef.h | 1 + STEER/libESD.pkg | 1 + 24 files changed, 483 insertions(+), 232 deletions(-) create mode 100644 STEER/AliESDCaloCluster.cxx create mode 100644 STEER/AliESDCaloCluster.h diff --git a/EMCAL/AliEMCALRecPoint.cxx b/EMCAL/AliEMCALRecPoint.cxx index 96f08930a77..41cac02ffa1 100644 --- a/EMCAL/AliEMCALRecPoint.cxx +++ b/EMCAL/AliEMCALRecPoint.cxx @@ -45,6 +45,7 @@ AliEMCALRecPoint::AliEMCALRecPoint() : AliRecPoint() { // ctor + fClusterType = -1; fMaxTrack = 0 ; fMulDigit = 0 ; fMaxParent = 0; @@ -52,6 +53,7 @@ AliEMCALRecPoint::AliEMCALRecPoint() fAmp = 0. ; fCoreEnergy = 0 ; fEnergyList = 0 ; + fTimeList = 0 ; fAbsIdList = 0; fParentsList = 0; fTime = 0. ; @@ -65,6 +67,7 @@ AliEMCALRecPoint::AliEMCALRecPoint() AliEMCALRecPoint::AliEMCALRecPoint(const char * opt) : AliRecPoint(opt) { // ctor + fClusterType = -1; fMaxTrack = 1000 ; fMaxParent = 1000; fMulDigit = 0 ; @@ -72,6 +75,7 @@ AliEMCALRecPoint::AliEMCALRecPoint(const char * opt) : AliRecPoint(opt) fAmp = 0. ; fCoreEnergy = 0 ; fEnergyList = 0 ; + fTimeList = 0 ; fAbsIdList = 0; fParentsList = new Int_t[fMaxParent]; fTime = -1. ; @@ -86,6 +90,8 @@ AliEMCALRecPoint::~AliEMCALRecPoint() // dtor if ( fEnergyList ) delete[] fEnergyList ; + if ( fTimeList ) + delete[] fTimeList ; if ( fAbsIdList ) delete[] fAbsIdList ; if ( fParentsList) @@ -100,6 +106,8 @@ void AliEMCALRecPoint::AddDigit(AliEMCALDigit & digit, Float_t Energy) if(fEnergyList == 0) fEnergyList = new Float_t[fMaxDigit]; + if(fTimeList == 0) + fTimeList = new Float_t[fMaxDigit]; if(fAbsIdList == 0) { fAbsIdList = new Int_t[fMaxDigit]; fSuperModuleNumber = geom->GetSuperModuleNumber(digit.GetId()); @@ -109,12 +117,14 @@ void AliEMCALRecPoint::AddDigit(AliEMCALDigit & digit, Float_t Energy) fMaxDigit*=2 ; Int_t * tempo = new Int_t[fMaxDigit]; Float_t * tempoE = new Float_t[fMaxDigit]; + Float_t * tempoT = new Float_t[fMaxDigit]; Int_t * tempoId = new Int_t[fMaxDigit]; Int_t index ; for ( index = 0 ; index < fMulDigit ; index++ ){ tempo[index] = fDigitsList[index] ; tempoE[index] = fEnergyList[index] ; + tempoT[index] = fTimeList[index] ; tempoId[index] = fAbsIdList[index] ; } @@ -124,22 +134,28 @@ void AliEMCALRecPoint::AddDigit(AliEMCALDigit & digit, Float_t Energy) delete [] fEnergyList ; fEnergyList = new Float_t[fMaxDigit]; + delete [] fTimeList ; + fTimeList = new Float_t[fMaxDigit]; + delete [] fAbsIdList ; fAbsIdList = new Int_t[fMaxDigit]; for ( index = 0 ; index < fMulDigit ; index++ ){ fDigitsList[index] = tempo[index] ; fEnergyList[index] = tempoE[index] ; + fTimeList[index] = tempoT[index] ; fAbsIdList[index] = tempoId[index] ; } delete [] tempo ; delete [] tempoE ; + delete [] tempoT ; delete [] tempoId ; } // if fDigitsList[fMulDigit] = digit.GetIndexInList() ; fEnergyList[fMulDigit] = Energy ; + fTimeList[fMulDigit] = digit.GetTime() ; fAbsIdList[fMulDigit] = digit.GetId(); fMulDigit++ ; fAmp += Energy ; @@ -159,8 +175,6 @@ Bool_t AliEMCALRecPoint::AreNeighbours(AliEMCALDigit * digit1, AliEMCALDigit * d areNeighbours = kFALSE ; - // AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance(); - geom->GetCellIndex(digit1->GetId(), nSupMod,nTower,nIphi,nIeta); geom->GetCellPhiEtaIndexInSModule(nSupMod,nTower,nIphi,nIeta, relid1[0],relid1[1]); @@ -344,7 +358,6 @@ void AliEMCALRecPoint::EvalDispersion(Float_t logWeight, TClonesArray * digits) Double_t d = 0., wtot = 0., w = 0., xyzi[3], diff=0.; Int_t iDigit=0, nstat=0, i=0; AliEMCALDigit * digit ; - // AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance(); // Calculates the centre of gravity in the local EMCAL-module coordinates if (!fLocPos.Mag()) @@ -380,7 +393,6 @@ void AliEMCALRecPoint::EvalLocalPosition(Float_t logWeight, TClonesArray * digit // Info("Print", " logWeight %f : cluster energy %f ", logWeight, fAmp); // for testing AliEMCALDigit * digit; - // AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance(); Int_t i=0, nstat=0; Double_t clXYZ[3]={0.,0.,0.}, clRmsXYZ[3]={0.,0.,0.}, xyzi[3], wtot=0., w=0.; @@ -444,7 +456,6 @@ void AliEMCALRecPoint::EvalCoreEnergy(Float_t logWeight, TClonesArray * digits) AliEMCALDigit * digit ; const Float_t kDeg2Rad = TMath::DegToRad() ; - // AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance(); Int_t iDigit; @@ -480,7 +491,6 @@ void AliEMCALRecPoint::EvalElipsAxis(Float_t logWeight,TClonesArray * digits) const Float_t kDeg2Rad = TMath::DegToRad(); AliEMCALDigit * digit ; - // AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance(); TString gn(geom->GetName()); Int_t iDigit; @@ -835,11 +845,12 @@ void AliEMCALRecPoint::Print(Option_t *) const printf("\n Local x %6.2f y %7.2f z %7.1f \n", fLocPos[0], fLocPos[1], fLocPos[2]); - message = " Multiplicity = %d" ; + message = " ClusterType = %d" ; + message += " Multiplicity = %d" ; message += " Cluster Energy = %f" ; message += " Core energy = %f" ; message += " Core radius = %f" ; message += " Number of primaries %d" ; message += " Stored at position %d" ; - Info("Print", message.Data(), fMulDigit, fAmp, fCoreEnergy, fCoreRadius, fMulTrack, GetIndexInList() ) ; + Info("Print", message.Data(), fClusterType, fMulDigit, fAmp, fCoreEnergy, fCoreRadius, fMulTrack, GetIndexInList() ) ; } diff --git a/EMCAL/AliEMCALRecPoint.h b/EMCAL/AliEMCALRecPoint.h index f988d24d849..4bd14e01c3a 100644 --- a/EMCAL/AliEMCALRecPoint.h +++ b/EMCAL/AliEMCALRecPoint.h @@ -37,6 +37,9 @@ class AliEMCALRecPoint : public AliRecPoint { virtual void Draw(Option_t * option="") ; virtual void ExecuteEvent(Int_t event, Int_t, Int_t) ; + virtual void SetClusterType(Int_t ver) { fClusterType = ver; } + virtual Int_t GetClusterType() const { return fClusterType; } + virtual void EvalAll(Float_t logWeight, TClonesArray * digits); virtual void EvalLocalPosition(Float_t logWeight, TClonesArray * digits) ; // void EvalLocalPositionSimple(TClonesArray *digits); // ?? @@ -55,6 +58,7 @@ class AliEMCALRecPoint : public AliRecPoint { virtual void GetElipsAxis(Float_t * lambda)const {lambda[0] = fLambda[0]; lambda[1] = fLambda[1];}; Float_t * GetEnergiesList() const {return fEnergyList ;} // gets the list of energies making this recpoint + Float_t * GetTimeList() const {return fTimeList ;} // gets the list of digit times in this recpoint 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 @@ -80,6 +84,8 @@ class AliEMCALRecPoint : public AliRecPoint { return *this ; } + enum RecPointType {kPseudoCluster, kClusterv1}; + protected: void EvalCoreEnergy(Float_t logWeight,TClonesArray * digits) ; virtual void EvalDispersion(Float_t logWeight,TClonesArray * digits) ; // computes the dispersion of the shower @@ -89,10 +95,14 @@ protected: Float_t ThetaToEta(Float_t arg) const; //Converts Theta (Radians) to Eta(Radians) Float_t EtaToTheta(Float_t arg) const; //Converts Eta (Radians) to Theta(Radians) +private: + Int_t fClusterType; // type of cluster stored: + // pseudocluster or v1 Float_t fCoreEnergy ; // energy in a shower core Float_t fLambda[2] ; // shower ellipse axes - Float_t fDispersion ; // shower dispersion + Float_t fDispersion ; // shower dispersio Float_t *fEnergyList ; //[fMulDigit] energy of digits + Float_t *fTimeList ; //[fMulDigit] time of digits Int_t *fAbsIdList; //[fMulDigit] absId of digits Float_t fTime ; // Time of the digit with maximal energy deposition Float_t fCoreRadius; // The radius in which the core energy is evaluated diff --git a/EMCAL/AliEMCALReconstructor.cxx b/EMCAL/AliEMCALReconstructor.cxx index 6e4d388eafb..70aca110c64 100644 --- a/EMCAL/AliEMCALReconstructor.cxx +++ b/EMCAL/AliEMCALReconstructor.cxx @@ -67,8 +67,8 @@ void AliEMCALReconstructor::Reconstruct(AliRunLoader* runLoader) const if ( Debug() ) clu.ExecuteTask("deb all") ; else - clu.ExecuteTask("") ; - + clu.ExecuteTask("pseudo") ; + } //____________________________________________________________________________ @@ -83,13 +83,13 @@ void AliEMCALReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* r rawreader->Reset() ; TString headerFile(runLoader->GetFileName()) ; TString branchName(runLoader->GetEventFolder()->GetName()) ; - + AliEMCALClusterizerv1 clu(headerFile, branchName); clu.SetEventRange(0, -1) ; // do all the events if ( Debug() ) - clu.ExecuteTask("deb all") ; + clu.ExecuteTask("deb pseudo all") ; else - clu.ExecuteTask("") ; + clu.ExecuteTask("pseudo") ; } @@ -103,42 +103,54 @@ void AliEMCALReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const TString headerFile(runLoader->GetFileName()) ; TString branchName(runLoader->GetEventFolder()->GetName()) ; - // PID is not implemented. Skipping for now - //AliEMCALPIDv1 pid(headerFile, branchName); - - // do current event; the loop over events is done by AliReconstruction::Run() - /* - pid.SetEventRange(eventNumber, eventNumber) ; - if ( Debug() ) - pid.ExecuteTask("deb all") ; - else - pid.ExecuteTask("") ; - */ - - // Creates AliESDtrack from AliEMCALRecPoints + // Creates AliESDCaloCluster from AliEMCALRecPoints AliRunLoader *rl = AliRunLoader::GetRunLoader(); AliEMCALLoader *emcalLoader = dynamic_cast(rl->GetDetectorLoader("EMCAL")); rl->LoadRecPoints(); rl->GetEvent(eventNumber); TObjArray *clusters = emcalLoader->RecPoints(); Int_t nClusters = clusters->GetEntries(); - esd->SetNumberOfEMCALParticles(nClusters) ; - esd->SetFirstEMCALParticle(esd->GetNumberOfTracks()) ; + esd->SetNumberOfEMCALClusters(nClusters) ; + esd->SetFirstEMCALCluster(esd->GetNumberOfCaloClusters()) ; for (Int_t iClust = 0 ; iClust < nClusters ; iClust++) { const AliEMCALRecPoint * clust = emcalLoader->RecPoint(iClust); - if (Debug()) - clust->Print(); - AliESDtrack * et = new AliESDtrack() ; - // fills the ESDtrack - Double_t xyz[3]; + + if (Debug()) clust->Print(); + + AliESDCaloCluster * ec = new AliESDCaloCluster() ; + // fills the ESDCaloCluster + Float_t xyz[3]; TVector3 gpos; clust->GetGlobalPosition(gpos); for (Int_t ixyz=0; ixyz<3; ixyz++) xyz[ixyz] = gpos[ixyz]; - et->SetEMCALposition(xyz) ; - et->SetEMCALsignal (clust->GetEnergy()) ; - // add the track to the esd object - esd->AddTrack(et); - delete et; + + Int_t digitMult = clust->GetMultiplicity(); + UShort_t *amplList = new UShort_t[digitMult]; + UShort_t *timeList = new UShort_t[digitMult]; + UShort_t *digiList = new UShort_t[digitMult]; + Float_t *amplFloat = clust->GetEnergiesList(); + Float_t *timeFloat = clust->GetTimeList(); + Int_t *digitInts = clust->GetAbsId(); + // Convert Float_t* and Int_t* to UShort_t* to save memory + for (Int_t iDigit=0; iDigitSetClusterType(clust->GetClusterType()); + ec->SetGlobalPosition(xyz); + ec->SetClusterEnergy(clust->GetEnergy()); + ec->SetClusterDisp(clust->GetDispersion()); + ec->SetClusterChi2(-1); //not yet implemented + ec->SetNumberOfDigits(clust->GetMultiplicity()); + ec->SetDigitAmplitude(amplList); //energies + ec->SetDigitTime(timeList); //times + ec->SetDigitIndex(digiList); //indices + + // add the cluster to the esd object + esd->AddCaloCluster(ec); + delete ec; } } diff --git a/EMCAL/AliEMCALReconstructor.h b/EMCAL/AliEMCALReconstructor.h index c426f07f5c2..ad4e63ea334 100644 --- a/EMCAL/AliEMCALReconstructor.h +++ b/EMCAL/AliEMCALReconstructor.h @@ -17,7 +17,6 @@ #include "AliReconstructor.h" class AliEMCALDigitizer ; class AliEMCALClusterizer ; -class AliEMCALPID ; class AliEMCALSDigitizer ; class AliESD ; class AliRawReaderFile ; diff --git a/PHOS/AliPHOSFastRecParticle.h b/PHOS/AliPHOSFastRecParticle.h index ae9ffff743d..faa5ddcd492 100644 --- a/PHOS/AliPHOSFastRecParticle.h +++ b/PHOS/AliPHOSFastRecParticle.h @@ -8,6 +8,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.36 2005/05/28 14:19:04 schutz + * Compilation warnings fixed by T.P. + * */ //_________________________________________________________________________ @@ -22,8 +25,7 @@ class TClonesArray; #include "TParticle.h" -#include "AliESDtrack.h" - +#include "AliPID.h" // --- Standard library --- // --- AliRoot header files --- @@ -102,7 +104,7 @@ class AliPHOSFastRecParticle : public TParticle { Int_t fIndexInList ; // the index of this RecParticle in the list stored in TreeR (to be set by analysis) Float_t fTof ; // time of fliht Int_t fType ; // particle type obtained by "virtual" reconstruction - Double_t fPID[AliPID::kSPECIESN] ; // PID probability densities + Float_t fPID[AliPID::kSPECIESN] ; // PID probability densities private: diff --git a/PHOS/AliPHOSGammaJet.cxx b/PHOS/AliPHOSGammaJet.cxx index b0423492741..5be2356ef2b 100644 --- a/PHOS/AliPHOSGammaJet.cxx +++ b/PHOS/AliPHOSGammaJet.cxx @@ -17,6 +17,9 @@ /* History of cvs commits: * * $Log$ + * Revision 1.11 2006/01/31 20:30:52 hristov + * Including TFile.h + * * Revision 1.10 2006/01/23 18:04:08 hristov * Removing meaningless const * @@ -59,6 +62,7 @@ #include "AliPHOSFastGlobalReconstruction.h" #include "AliESD.h" #include "AliESDtrack.h" +#include "AliESDCaloCluster.h" #include "Riostream.h" @@ -839,26 +843,26 @@ void AliPHOSGammaJet::CreateParticleListFromESD(TClonesArray * pl, Int_t index = pl->GetEntries() ; Int_t npar = 0 ; - Double_t pid[AliPID::kSPECIESN]; + Float_t *pid = new Float_t[AliPID::kSPECIESN]; //########### PHOS ############## //Info("CreateParticleListFromESD","Fill ESD PHOS list"); - Int_t begphos = esd->GetFirstPHOSParticle(); - Int_t endphos = esd->GetFirstPHOSParticle() + - esd->GetNumberOfPHOSParticles() ; + Int_t begphos = esd->GetFirstPHOSCluster(); + Int_t endphos = esd->GetFirstPHOSCluster() + + esd->GetNumberOfPHOSClusters() ; Int_t indexNePHOS = plNePHOS->GetEntries() ; if(strstr(fOptionGJ,"deb all")) Info("CreateParticleListFromESD","PHOS: first particle %d, last particle %d", begphos,endphos); for (npar = begphos; npar < endphos; npar++) {//////////////PHOS track loop - AliESDtrack * track = esd->GetTrack(npar) ; // retrieve track from esd + AliESDCaloCluster * clus = esd->GetCaloCluster(npar) ; // retrieve track from esd //Create a TParticle to fill the particle list - Double_t en = track->GetPHOSsignal() ; - Double_t * p = new Double_t(); - track->GetPHOSposition(p) ; + Float_t en = clus->GetClusterEnergy() ; + Float_t *p = new Float_t(); + clus->GetGlobalPosition(p) ; TVector3 pos(p[0],p[1],p[2]) ; Double_t phi = pos.Phi(); Double_t theta= pos.Theta(); @@ -871,7 +875,7 @@ void AliPHOSGammaJet::CreateParticleListFromESD(TClonesArray * pl, //Select only photons - track->GetPHOSpid(pid); + pid=clus->GetPid(); //cout<<"pid "< 0.75) new((*plNePHOS)[indexNePHOS++]) TParticle(*particle) ; @@ -911,20 +915,20 @@ void AliPHOSGammaJet::CreateParticleListFromESD(TClonesArray * pl, //##########Uncomment when ESD for EMCAL works ########## //Info("CreateParticleListFromESD","Fill ESD EMCAL list"); - Int_t begem = esd->GetFirstEMCALParticle(); - Int_t endem = esd->GetFirstEMCALParticle() + - esd->GetNumberOfEMCALParticles() ; + Int_t begem = esd->GetFirstEMCALCluster(); + Int_t endem = esd->GetFirstEMCALCluster() + + esd->GetNumberOfEMCALClusters() ; Int_t indexNe = plNe->GetEntries() ; if(strstr(fOptionGJ,"deb all")) Info("CreateParticleListFromESD","EMCAL: first particle %d, last particle %d", begem,endem); for (npar = begem; npar < endem; npar++) {//////////////EMCAL track loop - AliESDtrack * track = esd->GetTrack(npar) ; // retrieve track from esd + AliESDCaloCluster * clus = esd->GetCaloCluster(npar) ; // retrieve track from esd - Double_t en = track->GetEMCALsignal() ; - Double_t *p = new Double_t(); - track->GetEMCALposition(p) ; + Float_t en = clus->GetClusterEnergy() ; + Float_t *p = new Float_t(); + clus->GetGlobalPosition(p) ; TVector3 pos(p[0],p[1],p[2]) ; Double_t phi = pos.Phi(); Double_t theta= pos.Theta(); diff --git a/PHOS/AliPHOSRecParticle.cxx b/PHOS/AliPHOSRecParticle.cxx index 8a4881b88ec..78224515d14 100644 --- a/PHOS/AliPHOSRecParticle.cxx +++ b/PHOS/AliPHOSRecParticle.cxx @@ -263,7 +263,7 @@ const TParticle * AliPHOSRecParticle::GetPrimary(Int_t index) const } //____________________________________________________________________________ -void AliPHOSRecParticle::SetPID(Int_t type, Double_t weight) +void AliPHOSRecParticle::SetPID(Int_t type, Float_t weight) { // Set the probability densities that this reconstructed particle // has a type of i: diff --git a/PHOS/AliPHOSRecParticle.h b/PHOS/AliPHOSRecParticle.h index 1d85e880ccb..297e5b36b1d 100644 --- a/PHOS/AliPHOSRecParticle.h +++ b/PHOS/AliPHOSRecParticle.h @@ -37,9 +37,9 @@ class AliPHOSRecParticle : public AliPHOSFastRecParticle { virtual const TParticle * GetPrimary(Int_t index) const ; virtual const TParticle * GetPrimary() const ; Int_t GetPrimaryIndex() const ; - const Double_t *GetPID() { return fPID ; } + const Float_t *GetPID() { return fPID ; } void SetDebug() { fDebug = kTRUE ; } - void SetPID(Int_t type, Double_t weight) ; + void SetPID(Int_t type, Float_t weight) ; void SetPos(TVector3 pos) { fPos.SetXYZ( pos.X(), pos.Y(), pos.Z() ); } void UnsetDebug() { fDebug = kFALSE ; } void SetTrackSegment(Int_t index){fPHOSTrackSegment = index; } diff --git a/PHOS/AliPHOSReconstructor.cxx b/PHOS/AliPHOSReconstructor.cxx index 24824c599b3..9c8b0d1df58 100644 --- a/PHOS/AliPHOSReconstructor.cxx +++ b/PHOS/AliPHOSReconstructor.cxx @@ -109,25 +109,26 @@ void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const AliPHOSGetter::Instance()->Event(eventNumber, "P") ; TClonesArray *recParticles = AliPHOSGetter::Instance()->RecParticles(); Int_t nOfRecParticles = recParticles->GetEntries(); - esd->SetNumberOfPHOSParticles(nOfRecParticles) ; - esd->SetFirstPHOSParticle(esd->GetNumberOfTracks()) ; + esd->SetNumberOfPHOSClusters(nOfRecParticles) ; + esd->SetFirstPHOSCluster(esd->GetNumberOfTracks()) ; for (Int_t recpart = 0 ; recpart < nOfRecParticles ; recpart++) { AliPHOSRecParticle * rp = dynamic_cast(recParticles->At(recpart)); if (Debug()) rp->Print(); - AliESDtrack * et = new AliESDtrack() ; - // fills the ESDtrack - Double_t xyz[3]; + AliESDCaloCluster * ec = new AliESDCaloCluster() ; +// AliESDtrack * et = new AliESDtrack() ; + // fills the ESDCaloCluster + Float_t xyz[3]; for (Int_t ixyz=0; ixyz<3; ixyz++) xyz[ixyz] = rp->GetPos()[ixyz]; - et->SetPHOSposition(xyz) ; - et->SetPHOSsignal (rp->Energy()) ; - et->SetPHOSpid (rp->GetPID()) ; - et->SetLabel (rp->GetPrimaryIndex()); + ec->SetGlobalPosition(xyz); + ec->SetClusterEnergy(rp->Energy()); + ec->SetPid (rp->GetPID()) ; + ec->SetPrimaryIndex (rp->GetPrimaryIndex()); // add the track to the esd object - esd->AddTrack(et); - delete et; + esd->AddCaloCluster(ec); + delete ec; } } diff --git a/STEER/AliESD.cxx b/STEER/AliESD.cxx index 9deb7f24545..d79514cca26 100644 --- a/STEER/AliESD.cxx +++ b/STEER/AliESD.cxx @@ -48,12 +48,14 @@ AliESD::AliESD(): fCascades("AliESDcascade",20), fKinks("AliESDkink",4000), fV0MIs("AliESDV0MI",4000), - fPHOSParticles(0), - fEMCALParticles(0), - fFirstPHOSParticle(-1), - fFirstEMCALParticle(-1), + fCaloClusters("AliESDCaloCluster",10000), + fEMCALClusters(0), + fFirstEMCALCluster(-1), + fPHOSClusters(0), + fFirstPHOSCluster(-1), fESDFMD(0x0) { + } //______________________________________________________________________________ @@ -71,6 +73,7 @@ AliESD::~AliESD() fCascades.Delete(); fKinks.Delete(); fV0MIs.Delete(); + fCaloClusters.Delete(); delete fESDFMD; } @@ -115,10 +118,11 @@ void AliESD::Reset() fPmdTracks.Clear(); fV0s.Clear(); fCascades.Clear(); - fPHOSParticles=0; - fEMCALParticles=0; - fFirstPHOSParticle=-1; - fFirstEMCALParticle=-1; + fCaloClusters.Clear(); + fEMCALClusters=0; + fFirstEMCALCluster=-1; + fPHOSClusters=0; + fFirstPHOSCluster=-1; if (fESDFMD) fESDFMD->Clear(); } @@ -140,16 +144,17 @@ void AliESD::Print(Option_t *) const fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes()); printf("Event from reconstruction version %d \n",fRecoVersion); printf("Number of tracks: \n"); - printf(" charged %d\n",GetNumberOfTracks()-GetNumberOfPHOSParticles()-GetNumberOfEMCALParticles()); + printf(" charged %d\n", GetNumberOfTracks()); printf(" hlt CF %d\n", GetNumberOfHLTConfMapTracks()); printf(" hlt HT %d\n", GetNumberOfHLTHoughTracks()); - printf(" phos %d\n", GetNumberOfPHOSParticles()); - printf(" emcal %d\n", GetNumberOfEMCALParticles()); + printf(" phos %d\n", GetNumberOfPHOSClusters()); + printf(" emcal %d\n", GetNumberOfEMCALClusters()); printf(" muon %d\n", GetNumberOfMuonTracks()); printf(" pmd %d\n", GetNumberOfPmdTracks()); printf(" v0 %d\n", GetNumberOfV0s()); printf(" cascades %d\n)", GetNumberOfCascades()); printf(" kinks %d\n)", GetNumberOfKinks()); printf(" V0MIs %d\n)", GetNumberOfV0MIs()); + printf(" CaloClusters %d\n)", GetNumberOfCaloClusters()); printf(" FMD %s\n)", (fESDFMD ? "yes" : "no")); } diff --git a/STEER/AliESD.h b/STEER/AliESD.h index 05a92d8cb51..70c86156e69 100644 --- a/STEER/AliESD.h +++ b/STEER/AliESD.h @@ -24,6 +24,7 @@ #include "AliESDkink.h" #include "AliESDtrack.h" #include "AliESDHLTtrack.h" +#include "AliESDCaloCluster.h" #include "AliESDv0.h" #include "AliESDV0MI.h" #include "AliESDFMD.h" @@ -107,7 +108,15 @@ public: return fV0MIs.GetEntriesFast()-1; } - + AliESDCaloCluster *GetCaloCluster(Int_t i) const { + return (AliESDCaloCluster *)fCaloClusters.UncheckedAt(i); + } + Int_t AddCaloCluster(const AliESDCaloCluster *c) { + AliESDCaloCluster *clus = new(fCaloClusters[fCaloClusters.GetEntriesFast()]) AliESDCaloCluster(*c); + clus->SetID(fCaloClusters.GetEntriesFast()-1); + return fCaloClusters.GetEntriesFast()-1; + } + void SetVertex(const AliESDVertex* vertex) { new(&fPrimaryVertex) AliESDVertex(*vertex); } @@ -126,14 +135,17 @@ public: Int_t GetNumberOfCascades() const {return fCascades.GetEntriesFast();} Int_t GetNumberOfKinks() const {return fKinks.GetEntriesFast();} Int_t GetNumberOfV0MIs() const {return fV0MIs.GetEntriesFast();} - Int_t GetNumberOfPHOSParticles() const {return fPHOSParticles;} - void SetNumberOfPHOSParticles(Int_t part) { fPHOSParticles = part ; } - void SetFirstPHOSParticle(Int_t index) { fFirstPHOSParticle = index ; } - Int_t GetFirstPHOSParticle() const { return fFirstPHOSParticle ; } - Int_t GetNumberOfEMCALParticles() const {return fEMCALParticles;} - void SetNumberOfEMCALParticles(Int_t part) { fEMCALParticles = part ; } - void SetFirstEMCALParticle(Int_t index) { fFirstEMCALParticle = index ; } - Int_t GetFirstEMCALParticle() const { return fFirstEMCALParticle ; } + Int_t GetNumberOfCaloClusters() const {return fCaloClusters.GetEntriesFast();} + + Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;} + void SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;} + Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;} + void SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;} + + Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;} + void SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; } + void SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; } + Int_t GetFirstPHOSCluster() const { return fFirstPHOSCluster ; } Float_t GetT0zVertex() const {return fT0zVertex;} void SetT0zVertex(Float_t z) {fT0zVertex=z;} @@ -185,10 +197,12 @@ protected: TClonesArray fCascades; // Cascade vertices TClonesArray fKinks; // Kinks TClonesArray fV0MIs; // V0MI - Int_t fPHOSParticles; // Number of PHOS particles (stored as fTracks) - Int_t fEMCALParticles; // Number of EMCAL particles (stored as fTracks) - Int_t fFirstPHOSParticle; // First PHOS particle in the fTracks list - Int_t fFirstEMCALParticle;// First EMCAL particle in the fTracks list + TClonesArray fCaloClusters; // Calorimeter clusters for PHOS/EMCAL + Int_t fEMCALClusters; // Number of EMCAL clusters (subset of caloclusters) + Int_t fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list + + Int_t fPHOSClusters; // Number of PHOS clusters (subset of caloclusters) + Int_t fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list AliESDFMD * fESDFMD; // FMD object containing rough multiplicity diff --git a/STEER/AliESDCaloCluster.cxx b/STEER/AliESDCaloCluster.cxx new file mode 100644 index 00000000000..b506ebf3cac --- /dev/null +++ b/STEER/AliESDCaloCluster.cxx @@ -0,0 +1,129 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +/* $Id$ */ +/* $Log $ */ + +//----------------------------------------------------------------- +// Implementation of the ESD Calorimeter cluster class +// ESD = Event Summary Data +// This is the class to deal with during the phisics analysis of data +// +// J.L. Klay (LLNL) +//----------------------------------------------------------------- + +#include "AliESDCaloCluster.h" + +ClassImp(AliESDCaloCluster) + +//_______________________________________________________________________ +AliESDCaloCluster::AliESDCaloCluster() : + fID(0), + fClusterType(-1), + fEMCALCluster(kFALSE), + fEnergy(-1), + fDispersion(-1), + fChi2(-1), + fNumberOfDigits(0), + fDigitAmplitude(0), + fDigitTime(0), + fDigitIndex(0) +{ + // + // The default ESD constructor + // + fGlobalPos[0] = fGlobalPos[1] = fGlobalPos[2] = 0.; + for(Int_t i=0; i=0) { + sum+=p[i]; + fPID[i] = p[i]; + } + else { + fPID[i] = 0; + } + + if(sum>0) + for (Int_t i=0; i +#include "AliPID.h" + + +class AliESDCaloCluster : public TObject { + +public: + + AliESDCaloCluster(); + AliESDCaloCluster(const AliESDCaloCluster& clus); + virtual ~AliESDCaloCluster(); + + void SetID(Int_t id) {fID = id;} + Int_t GetID() const {return fID;} + + void SetClusterType(Int_t type) { fClusterType = type; } + Int_t GetClusterType() const {return fClusterType; } + + void SetEMCAL(Bool_t emc) { fEMCALCluster = emc;} + Bool_t IsEMCAL() const {return fEMCALCluster;} + + void SetPHOS(Bool_t phos) { fPHOSCluster = phos;} + Bool_t IsPHOS() const {return fPHOSCluster;} + + void SetGlobalPosition(const Float_t *pos) { + fGlobalPos[0] = pos[0]; fGlobalPos[1] = pos[1]; fGlobalPos[2] = pos[2]; + } + void GetGlobalPosition(Float_t *pos) const { + pos[0] = fGlobalPos[0]; pos[1] = fGlobalPos[1]; pos[2] = fGlobalPos[2]; + } + + void SetClusterEnergy(Float_t ene) { fEnergy = ene;} + Float_t GetClusterEnergy() const { return fEnergy;} + + void SetClusterDisp(Float_t disp) { fDispersion = disp; } + Float_t GetClusterDisp() const { return fDispersion; } + + void SetClusterChi2(Float_t chi2) { fChi2 = chi2; } + Float_t GetClusterChi2() const { return fChi2; } + + void SetPid(const Float_t *p); + Float_t *GetPid() {return fPID;} + + void SetPrimaryIndex(Int_t primary) { fPrimaryIndex = primary; } + Int_t GetPrimaryIndex() const { return fPrimaryIndex; } + + void SetM20(Float_t m20) { fM20 = m20; } + Float_t GetM20() const { return fM20; } + + void SetM02(Float_t m02) { fM02 = m02; } + Float_t GetM02() const { return fM02; } + + void SetM11(Float_t m11) { fM11 = m11; } + Float_t GetM11() const { return fM11; } + + void SetNExMax(UShort_t nExMax) { fNExMax = nExMax; } + UShort_t GetNExMax() const { return fNExMax; } + + void SetEmcCpvDistance(Float_t dEmcCpv) { fEmcCpvDistance = dEmcCpv; } + Float_t GetEmcCpvDistance() const { return fEmcCpvDistance; } + + void SetNumberOfDigits(Int_t ndig) { fNumberOfDigits = ndig; } + Int_t GetNumberOfDigits() const { return fNumberOfDigits; } + + void SetDigitAmplitude(UShort_t *adc) { fDigitAmplitude = adc;} + UShort_t *GetDigitAmplitude() const { return fDigitAmplitude;} + + void SetDigitTime(UShort_t *time) { fDigitTime = time;} + UShort_t *GetDigitTime() const { return fDigitTime;} + + void SetDigitIndex(UShort_t *digit) { fDigitIndex = digit;} + UShort_t *GetDigitIndex() const { return fDigitIndex; } + +protected: + + Int_t fID; // Unique Id of the cluster + Int_t fClusterType; // Flag for different clustering versions + Bool_t fEMCALCluster; // Is this is an EMCAL cluster? + Bool_t fPHOSCluster; // Is this is a PHOS cluster? + Float_t fGlobalPos[3]; // position in global coordinate system + Float_t fEnergy; // energy measured by calorimeter + Float_t fDispersion; // cluster dispersion, for shape analysis + Float_t fChi2; // chi2 of cluster fit + Float_t fPID[AliPID::kSPECIESN]; //"detector response probabilities" (for the PID) + Int_t fPrimaryIndex; // primary track number associated with this cluster + Float_t fM20; // 2-nd moment along the main eigen axis + Float_t fM02; // 2-nd moment along the second eigen axis + Float_t fM11; // 2-nd mixed moment Mxy + UShort_t fNExMax ; // number of (Ex-)maxima before unfolding + Float_t fEmcCpvDistance; // the distance from PHOS EMC rec.point to the closest CPV rec.point + + + + Int_t fNumberOfDigits; // number of calorimeter digits in cluster + // Very important! The streamer needs to + // know how big these arrays are for + // each event that is written out: + UShort_t* fDigitAmplitude; //[fNumberOfDigits] digit energy (integer units) + UShort_t* fDigitTime; //[fNumberOfDigits] time of this digit (integer units) + UShort_t* fDigitIndex; //[fNumberOfDigits] calorimeter digit index + + ClassDef(AliESDCaloCluster,1) //ESDCaloCluster +}; + +#endif + diff --git a/STEER/AliESDpid.cxx b/STEER/AliESDpid.cxx index e512d95a25d..49844a1a675 100644 --- a/STEER/AliESDpid.cxx +++ b/STEER/AliESDpid.cxx @@ -81,14 +81,14 @@ Int_t AliESDpid::MakePID(AliESD *event) for (j=0; jGetStatus()&AliESDtrack::kPHOSpid )!=0) { - Double_t d[10]; - t->GetPHOSpid(d); - Int_t j, ok=0; - for (j=0; jkeps) ok=1; - if (ok) - for (j=0; jGetStatus()&AliESDtrack::kPHOSpid )!=0) { + // Double_t d[10]; + // t->GetPHOSpid(d); + // Int_t j, ok=0; + // for (j=0; jkeps) ok=1; + // if (ok) + // for (j=0; jGetStatus()&AliESDtrack::kRICHpid )!=0) { Double_t d[10]; diff --git a/STEER/AliESDtrack.cxx b/STEER/AliESDtrack.cxx index f164e3be837..e04fcb65d75 100644 --- a/STEER/AliESDtrack.cxx +++ b/STEER/AliESDtrack.cxx @@ -96,8 +96,7 @@ AliESDtrack::AliESDtrack() : fTOFchi2(0), fTOFindex(0), fTOFsignal(-1), - fPHOSsignal(-1), - fEMCALsignal(-1), + // fPHOSsignal(-1), fRICHchi2(1e10), fRICHncls(0), fRICHindex(0), @@ -121,14 +120,11 @@ AliESDtrack::AliESDtrack() : fRICHr[i]=1.; } - for (Int_t i=0; i0;} Bool_t IsRICH() const {return fFlags&kRICHpid;} Bool_t IsPHOS() const {return fFlags&kPHOSpid;} - Bool_t IsEMCAL() const {return fFlags&kEMCALpid;} void SetTrackPointArray(AliTrackPointArray *points) { fPoints = points; } AliTrackPointArray *GetTrackPointArray() const { return fPoints; } @@ -234,7 +222,7 @@ public: kTPCin=0x0010,kTPCout=0x0020,kTPCrefit=0x0040,kTPCpid=0x0080, kTRDin=0x0100,kTRDout=0x0200,kTRDrefit=0x0400,kTRDpid=0x0800, kTOFin=0x1000,kTOFout=0x2000,kTOFrefit=0x4000,kTOFpid=0x8000, - kPHOSpid=0x10000, kRICHpid=0x20000, kEMCALpid=0x40000, + kPHOSpid=0x10000, kRICHpid=0x20000, kTRDbackup=0x80000, kTRDStop=0x20000000, kESDpid=0x40000000, @@ -315,14 +303,9 @@ protected: Float_t fTOFInfo[10]; //! TOF informations // PHOS related track information - Float_t fPHOSpos[3]; // position localised by PHOS in global coordinate system - Float_t fPHOSsignal; // energy measured by PHOS - Float_t fPHOSr[AliPID::kSPECIESN]; // PID information from PHOS - - // EMCAL related track information - Float_t fEMCALpos[3]; //position localised by EMCAL in global coordinate system - Float_t fEMCALsignal; // energy measured by EMCAL - Float_t fEMCALr[AliPID::kSPECIESN]; // PID information from EMCAL + // Float_t fPHOSpos[3]; // position localised by PHOS in global coordinate system + // Float_t fPHOSsignal; // energy measured by PHOS + //Float_t fPHOSr[AliPID::kSPECIESN]; // PID information from PHOS // HMPID related track information Float_t fRICHchi2; // chi2 in the RICH @@ -337,7 +320,7 @@ protected: AliTrackPointArray *fPoints; // Array which contains the track space points in the global frame - ClassDef(AliESDtrack,22) //ESDtrack + ClassDef(AliESDtrack,23) //ESDtrack }; #endif diff --git a/STEER/AliEventTag.cxx b/STEER/AliEventTag.cxx index 085a58b6d9c..d7a0889e53f 100644 --- a/STEER/AliEventTag.cxx +++ b/STEER/AliEventTag.cxx @@ -53,9 +53,9 @@ ClassImp(AliEventTag) fNumberOfCascades(-10), fNumberOfKinks(-10), fNumberOfPMDTracks(-10), - fNumberOfPHOSTracks(-10), - fNumberOfEMCALTracks(-10), fNumberOfFMDTracks(-10), + fNumberOfPHOSClusters(-10), + fNumberOfEMCALClusters(-10), fNumberOfJetCandidates(-10), fMaxJetEnergy(-100.0), fNumberOfHardPhotonsCandidates(-10), @@ -131,10 +131,10 @@ AliEventTag::AliEventTag(const AliEventTag & EvTag) : TObject(EvTag) SetNumOfKinks(EvTag.GetNumOfKinks()); SetNumOfPMDTracks(EvTag.GetNumOfPMDTracks()); - SetNumOfPHOSTracks(EvTag.GetNumOfPHOSTracks()); - SetNumOfEMCALTracks(EvTag.GetNumOfEMCALTracks()); SetNumOfFMDTracks(EvTag.GetNumOfFMDTracks()); - + SetNumOfPHOSClusters(EvTag.GetNumOfPHOSClusters()); + SetNumOfEMCALClusters(EvTag.GetNumOfEMCALClusters()); + SetNumOfJetCandidates(EvTag.GetNumOfJetCandidates()); SetNumOfHardPhotonsCandidates(EvTag.GetNumOfHardPhotonsCandidates()); @@ -218,9 +218,9 @@ AliEventTag & AliEventTag::operator=(const AliEventTag &EvTag) SetNumOfKinks(EvTag.GetNumOfKinks()); SetNumOfPMDTracks(EvTag.GetNumOfPMDTracks()); - SetNumOfPHOSTracks(EvTag.GetNumOfPHOSTracks()); - SetNumOfEMCALTracks(EvTag.GetNumOfEMCALTracks()); SetNumOfFMDTracks(EvTag.GetNumOfFMDTracks()); + SetNumOfPHOSClusters(EvTag.GetNumOfPHOSClusters()); + SetNumOfEMCALClusters(EvTag.GetNumOfEMCALClusters()); SetNumOfJetCandidates(EvTag.GetNumOfJetCandidates()); SetNumOfHardPhotonsCandidates(EvTag.GetNumOfHardPhotonsCandidates()); diff --git a/STEER/AliEventTag.h b/STEER/AliEventTag.h index baf85179f14..45da3eabfac 100644 --- a/STEER/AliEventTag.h +++ b/STEER/AliEventTag.h @@ -61,14 +61,13 @@ class AliEventTag : public TObject void SetNumOfKinks(Int_t Ptr) {fNumberOfKinks = Ptr;} void SetNumOfPMDTracks(Int_t Ptr) {fNumberOfPMDTracks = Ptr;} - void SetNumOfPHOSTracks(Int_t Ptr) {fNumberOfPHOSTracks = Ptr;} - void SetNumOfEMCALTracks(Int_t Ptr) {fNumberOfEMCALTracks = Ptr;} void SetNumOfFMDTracks(Int_t Ptr) {fNumberOfFMDTracks = Ptr;} + void SetNumOfPHOSClusters(Int_t Ptr) {fNumberOfPHOSClusters = Ptr;} + void SetNumOfEMCALClusters(Int_t Ptr) {fNumberOfEMCALClusters = Ptr;} void SetNumOfJetCandidates(Int_t Ptr) {fNumberOfJetCandidates = Ptr;} void SetNumOfHardPhotonsCandidates(Int_t Ptr) {fNumberOfHardPhotonsCandidates = Ptr;} - void SetMaxJetEnergy(Float_t f) {fMaxJetEnergy = f;} void SetMaxNeutralEnergy(Float_t f) {fMaxNeutralEnergy = f;} @@ -143,9 +142,9 @@ class AliEventTag : public TObject Int_t GetNumOfKinks() const {return fNumberOfKinks;} Int_t GetNumOfPMDTracks() const {return fNumberOfPMDTracks;} - Int_t GetNumOfPHOSTracks() const {return fNumberOfPHOSTracks;} - Int_t GetNumOfEMCALTracks() const {return fNumberOfEMCALTracks;} Int_t GetNumOfFMDTracks() const {return fNumberOfFMDTracks;} + Int_t GetNumOfPHOSClusters() const {return fNumberOfPHOSClusters;} + Int_t GetNumOfEMCALClusters() const {return fNumberOfEMCALClusters;} Int_t GetNumOfJetCandidates() const {return fNumberOfJetCandidates;} Int_t GetNumOfHardPhotonsCandidates() const {return fNumberOfHardPhotonsCandidates;} @@ -219,9 +218,9 @@ class AliEventTag : public TObject Int_t fNumberOfCascades; //Number of cascades Int_t fNumberOfKinks; //Number of kinks Int_t fNumberOfPMDTracks; //PMD tracks - Int_t fNumberOfPHOSTracks; //PHOS tracks - Int_t fNumberOfEMCALTracks; //EMCAL tracks Int_t fNumberOfFMDTracks; //FMD tracks + Int_t fNumberOfPHOSClusters; //PHOS clusters + Int_t fNumberOfEMCALClusters; //EMCAL clusters Int_t fNumberOfJetCandidates; //Jet candidates Float_t fMaxJetEnergy; //jet energy info @@ -268,7 +267,7 @@ class AliEventTag : public TObject Float_t fEventPlaneAngle; //event plane info Float_t fHBTRadii; //HBT info - ClassDef(AliEventTag,4) //(ClassName, ClassVersion) + ClassDef(AliEventTag,5) //(ClassName, ClassVersion) }; //______________________________________________________________________________ diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index 86a6886acf2..2c03c433db9 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -1439,8 +1439,8 @@ void AliReconstruction::CreateTag(TFile* file) evTag->SetNumOfElectronsAbove3GeV(nEl3GeV); evTag->SetNumOfElectronsAbove10GeV(nEl10GeV); - evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles()); - evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles()); + evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters()); + evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters()); evTag->SetTotalMomentum(totalP); evTag->SetMeanPt(meanPt); diff --git a/STEER/AliTag.cxx b/STEER/AliTag.cxx index 3fc34ea05b4..982146d3f8f 100644 --- a/STEER/AliTag.cxx +++ b/STEER/AliTag.cxx @@ -160,9 +160,9 @@ AliEventTag::AliEventTag() fNumberOfKinks = -10; fNumberOfPMDTracks = -10; - fNumberOfPHOSTracks = -10; - fNumberOfEMCALTracks = -10; fNumberOfFMDTracks = -10; + fNumberOfPHOSTracks = -10; + fNumberOfEMCALClusters = -10; fNumberOfJetCandidates = -10; fNumberOfHardPhotonsCandidates = -10; @@ -236,9 +236,9 @@ void AliEventTag::CopyTag(AliEventTag *EvTag) SetNumOfKinks(EvTag->GetNumOfKinks()); SetNumOfPMDTracks(EvTag->GetNumOfPMDTracks()); - SetNumOfPHOSTracks(EvTag->GetNumOfPHOSTracks()); - SetNumOfEMCALTracks(EvTag->GetNumOfEMCALTracks()); SetNumOfFMDTracks(EvTag->GetNumOfFMDTracks()); + SetNumOfPHOSTracks(EvTag->GetNumOfPHOSTracks()); + SetNumOfEMCALClusters(EvTag->GetNumOfEMCALClusters()); SetNumOfJetCandidates(EvTag->GetNumOfJetCandidates()); SetNumOfHardPhotonsCandidates(EvTag->GetNumOfHardPhotonsCandidates()); diff --git a/STEER/AliTag.h b/STEER/AliTag.h index 7519aa42dc4..a77bed064a9 100644 --- a/STEER/AliTag.h +++ b/STEER/AliTag.h @@ -32,8 +32,8 @@ class AliEventTag : public TObject Int_t fNumberOfCascades; //Number of cascades Int_t fNumberOfKinks; //Number of kinks Int_t fNumberOfPMDTracks; //PMD tracks - Int_t fNumberOfPHOSTracks; //PHOS tracks - Int_t fNumberOfEMCALTracks; //EMCAL tracks + Int_t fNumberOfPHOSClusters; //PHOS clusters + Int_t fNumberOfEMCALClusters; //EMCAL clusters Int_t fNumberOfFMDTracks; //FMD tracks Int_t fNumberOfJetCandidates; //Jet candidates Int_t fNumberOfHardPhotonsCandidates; //Hard photons candidates @@ -93,8 +93,8 @@ class AliEventTag : public TObject void SetNumOfKinks(Int_t Ptr) {fNumberOfKinks = Ptr;} void SetNumOfPMDTracks(Int_t Ptr) {fNumberOfPMDTracks = Ptr;} - void SetNumOfPHOSTracks(Int_t Ptr) {fNumberOfPHOSTracks = Ptr;} - void SetNumOfEMCALTracks(Int_t Ptr) {fNumberOfEMCALTracks = Ptr;} + void SetNumOfPHOSClusters(Int_t Ptr) {fNumberOfPHOSClusters = Ptr;} + void SetNumOfEMCALClusters(Int_t Ptr) {fNumberOfEMCALClusters = Ptr;} void SetNumOfFMDTracks(Int_t Ptr) {fNumberOfFMDTracks = Ptr;} void SetNumOfJetCandidates(Int_t Ptr) {fNumberOfJetCandidates = Ptr;} @@ -155,9 +155,9 @@ class AliEventTag : public TObject Int_t GetNumOfKinks() {return fNumberOfKinks;} Int_t GetNumOfPMDTracks() {return fNumberOfPMDTracks;} - Int_t GetNumOfPHOSTracks() {return fNumberOfPHOSTracks;} - Int_t GetNumOfEMCALTracks() {return fNumberOfEMCALTracks;} Int_t GetNumOfFMDTracks() {return fNumberOfFMDTracks;} + Int_t GetNumOfPHOSClusters() {return fNumberOfPHOSClusters;} + Int_t GetNumOfEMCALClusters() {return fNumberOfEMCALClusters;} Int_t GetNumOfJetCandidates() {return fNumberOfJetCandidates;} Int_t GetNumOfHardPhotonsCandidates() {return fNumberOfHardPhotonsCandidates;} @@ -186,7 +186,7 @@ class AliEventTag : public TObject Float_t GetFlowV1() {return fFlowV1;} Float_t GetFlowV2() {return fFlowV2;} - ClassDef(AliEventTag,1) //(ClassName, ClassVersion) + ClassDef(AliEventTag,2) //(ClassName, ClassVersion) }; //______________________________________________________________________________ diff --git a/STEER/AliTagCreator.cxx b/STEER/AliTagCreator.cxx index e0d64093954..fe1789a1e45 100644 --- a/STEER/AliTagCreator.cxx +++ b/STEER/AliTagCreator.cxx @@ -440,8 +440,8 @@ void AliTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, co evTag->SetNumOfElectronsAbove3GeV(nEl3GeV); evTag->SetNumOfElectronsAbove10GeV(nEl10GeV); - evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles()); - evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles()); + evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters()); + evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters()); evTag->SetTotalMomentum(totalP); evTag->SetMeanPt(meanPt); diff --git a/STEER/ESDLinkDef.h b/STEER/ESDLinkDef.h index fbcb0254841..434cc31d984 100644 --- a/STEER/ESDLinkDef.h +++ b/STEER/ESDLinkDef.h @@ -22,6 +22,7 @@ #pragma link C++ class AliESDkink+; #pragma link C++ class AliESDV0MI+; #pragma link C++ class AliESDV0MIParams+; +#pragma link C++ class AliESDCaloCluster+; #pragma link C++ class AliKalmanTrack+; #pragma link C++ class AliHelix+; diff --git a/STEER/libESD.pkg b/STEER/libESD.pkg index f2372cbc02c..75f128a7a4d 100644 --- a/STEER/libESD.pkg +++ b/STEER/libESD.pkg @@ -3,6 +3,7 @@ SRCS = AliESD.cxx \ AliESDMuonTrack.cxx AliESDPmdTrack.cxx AliESDHLTtrack.cxx \ AliESDv0.cxx AliESDcascade.cxx AliESDVertex.cxx \ AliESDpid.cxx AliESDkink.cxx AliESDV0MI.cxx \ + AliESDCaloCluster.cxx \ AliKalmanTrack.cxx AliHelix.cxx AliExternalTrackParam.cxx \ AliLog.cxx AliPID.cxx AliESDV0MIParams.cxx \ AliRunTag.cxx AliLHCTag.cxx AliDetectorTag.cxx AliEventTag.cxx \ -- 2.39.3