//______________________________________________________________________________
AliESD::AliESD():
- fEventNumber(0),
+ fEventNumberInFile(0),
+ fBunchCrossNumber(0),
+ fOrbitNumber(0),
+ fPeriodNumber(0),
fRunNumber(0),
fTimeStamp(0),
fEventType(0),
fSPDVertex(),
fPrimaryVertex(),
fSPDMult(),
+ fT0clock(0),
fT0timeStart(0),
+ fT0trig(0),
fTracks("AliESDtrack",15000),
fHLTConfMapTracks("AliESDHLTtrack",25000),
fHLTHoughTracks("AliESDHLTtrack",15000),
fCaloClusters("AliESDCaloCluster",10000),
fEMCALClusters(0),
fFirstEMCALCluster(-1),
+ fEMCALTriggerPosition(0x0),
+ fEMCALTriggerAmplitudes(0x0),
fPHOSClusters(0),
fFirstPHOSCluster(-1),
+ fPHOSTriggerPosition(0x0),
+ fPHOSTriggerAmplitudes(0x0),
fESDFMD(0x0),
- fESDVZERO(0x0)
+ fESDVZERO(0x0),
+ fESDACORDE(0x0),
+ fErrorLogs("AliRawDataErrorLog",5)
{
- for (Int_t i=0; i<24; i++) {
+ //
+ // Standar constructor
+ //
+
+ for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
+ for (Int_t i=0; i<24; i++) {
fT0time[i] = 0;
fT0amplitude[i] = 0;
}
+ for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
+ for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
}
+
//______________________________________________________________________________
AliESD::AliESD(const AliESD& esd):
TObject(esd),
- fEventNumber(esd.fEventNumber),
+ fEventNumberInFile(esd.fEventNumberInFile),
+ fBunchCrossNumber(esd.fBunchCrossNumber),
+ fOrbitNumber(esd.fOrbitNumber),
+ fPeriodNumber(esd.fPeriodNumber),
fRunNumber(esd.fRunNumber),
fTimeStamp(esd.fTimeStamp),
fEventType(esd.fEventType),
fSPDVertex(esd.fSPDVertex),
fPrimaryVertex(esd.fPrimaryVertex),
fSPDMult(esd.fSPDMult),
+ fT0clock(esd.fT0clock),
fT0timeStart(esd.fT0timeStart),
+ fT0trig(esd.fT0trig),
fTracks(*((TClonesArray*)esd.fTracks.Clone())),
fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
fEMCALClusters(esd.fEMCALClusters),
fFirstEMCALCluster(esd.fFirstEMCALCluster),
+ fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
+ fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
fPHOSClusters(esd.fPHOSClusters),
fFirstPHOSCluster(esd.fFirstPHOSCluster),
+ fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
+ fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
fESDFMD(esd.fESDFMD),
- fESDVZERO(esd.fESDVZERO)
+ fESDVZERO(esd.fESDVZERO),
+ fESDACORDE(esd.fESDACORDE),
+ fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
{
+ //
+ // copy constructor
+ //
+ for (Int_t i=0; i<3; i++)fT0TOF[i] = esd.fT0TOF[i];
for (Int_t i=0; i<24; i++) {
fT0time[i] = esd.fT0time[i];
fT0amplitude[i] = esd.fT0amplitude[i];
}
+ for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
+ for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
}
-//______________________________________________________________________________
-AliESD & AliESD::operator=(const AliESD& source) {
-
- // Assignment operator
-
- if(&source == this) return *this;
-
- fEventNumber = source.fEventNumber;
- fRunNumber = source.fRunNumber;
- fTimeStamp = source.fTimeStamp;
- fEventType = source.fEventType;
- fTriggerMask = source.fTriggerMask;
- fTriggerCluster = source.fTriggerCluster;
- fRecoVersion = source.fRecoVersion;
- fMagneticField = source.fMagneticField;
- fZDCN1Energy = source.fZDCN1Energy;
- fZDCP1Energy = source.fZDCP1Energy;
- fZDCN2Energy = source.fZDCN2Energy;
- fZDCP2Energy = source.fZDCP2Energy;
- fZDCEMEnergy = source.fZDCEMEnergy;
- fZDCParticipants = source.fZDCParticipants;
- fT0zVertex = source.fT0zVertex;
- fSPDVertex = source.fSPDVertex;
- fPrimaryVertex = source.fPrimaryVertex;
- fSPDMult = source.fSPDMult;
- fT0timeStart = source.fT0timeStart;
- fTracks = *((TClonesArray*)source.fTracks.Clone());
- fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
- fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
- fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
- fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
- fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
- fV0s = *((TClonesArray*)source.fV0s.Clone());
- fCascades = *((TClonesArray*)source.fCascades.Clone());
- fKinks = *((TClonesArray*)source.fKinks.Clone());
- fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
- fEMCALClusters = source.fEMCALClusters;
- fFirstEMCALCluster = source.fFirstEMCALCluster;
- fPHOSClusters = source.fPHOSClusters;
- fFirstPHOSCluster = source.fFirstPHOSCluster;
- fESDFMD = source.fESDFMD;
- fESDVZERO = source.fESDVZERO;
-
- for (Int_t i=0; i<24; i++) {
- fT0time[i] = source.fT0time[i];
- fT0amplitude[i] = source.fT0amplitude[i];
- }
-
- return *this;
-
-}
-
-
//______________________________________________________________________________
AliESD::~AliESD()
{
fCaloClusters.Delete();
delete fESDFMD;
delete fESDVZERO;
+ delete fEMCALTriggerPosition;
+ delete fEMCALTriggerAmplitudes;
+ delete fPHOSTriggerPosition;
+ delete fPHOSTriggerAmplitudes;
+ delete fESDACORDE;
+
+ fErrorLogs.Delete();
+
}
//______________________________________________________________________________
void AliESD::Reset()
{
- fEventNumber=0;
+ //
+ // Reset the contents and delete the entries in TClonesArrays
+ //
+
+ fEventNumberInFile=0;
+ fBunchCrossNumber=0;
+ fOrbitNumber=0;
+ fPeriodNumber=0;
fRunNumber=0;
fTimeStamp = 0;
fEventType = 0;
fZDCEMEnergy=0;
fZDCParticipants=0;
fT0zVertex=0;
+
+ for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
+ for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
+
+ for (Int_t i=0; i<24; i++) {
+ fT0time[i] = 0;
+ fT0amplitude[i] = 0;
+ }
fT0timeStart = 0;
+ fT0clock = 0;
+ for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
+//
+ fSPDMult.~AliMultiplicity();
+ new (&fSPDMult) AliMultiplicity();
+ fSPDVertex.~AliESDVertex();
new (&fSPDVertex) AliESDVertex();
+ fPrimaryVertex.~AliESDVertex();
new (&fPrimaryVertex) AliESDVertex();
- new (&fSPDMult) AliMultiplicity();
- fTracks.Clear();
- fHLTConfMapTracks.Clear();
- fHLTHoughTracks.Clear();
- fMuonTracks.Clear();
- fPmdTracks.Clear();
- fTrdTracks.Clear();
- fV0s.Clear();
- fCascades.Clear();
- fCaloClusters.Clear();
+//
+ fTracks.Delete();
+ fHLTConfMapTracks.Delete();
+ fHLTHoughTracks.Delete();
+ fMuonTracks.Delete();
+ fPmdTracks.Delete();
+ fTrdTracks.Delete();
+ fV0s.Delete();
+ fCascades.Delete();
+ fKinks.Delete();
+ fCaloClusters.Delete();
+//
fEMCALClusters=0;
fFirstEMCALCluster=-1;
fPHOSClusters=0;
fFirstPHOSCluster=-1;
+//
+ if (fEMCALTriggerPosition) fEMCALTriggerPosition ->Reset();
+ if (fEMCALTriggerAmplitudes) fEMCALTriggerAmplitudes->Reset();
+ if (fPHOSTriggerPosition) fPHOSTriggerPosition ->Reset();
+ if (fPHOSTriggerAmplitudes) fPHOSTriggerAmplitudes ->Reset();
+//
if (fESDFMD) fESDFMD->Clear();
+//
+ if (fESDVZERO){
+ fESDVZERO->~AliESDVZERO();
+ new (fESDVZERO) AliESDVZERO();
+ }
+//
+ if (fESDACORDE){
+ fESDACORDE->~AliESDACORDE();
+ new (fESDACORDE) AliESDACORDE();
+ }
+//
+ fErrorLogs.Delete();
+}
+
+
+Bool_t AliESD::RemoveKink(Int_t rm) {
+ // ---------------------------------------------------------
+ // Remove a kink candidate and references to it from ESD,
+ // if this candidate does not come from a reconstructed decay
+ // Not yet implemented...
+ // ---------------------------------------------------------
+ Int_t last=GetNumberOfKinks()-1;
+ if ((rm<0)||(rm>last)) return kFALSE;
+
+ return kTRUE;
+}
+
+Bool_t AliESD::RemoveV0(Int_t rm) {
+ // ---------------------------------------------------------
+ // Remove a V0 candidate and references to it from ESD,
+ // if this candidate does not come from a reconstructed decay
+ // ---------------------------------------------------------
+ Int_t last=GetNumberOfV0s()-1;
+ if ((rm<0)||(rm>last)) return kFALSE;
+
+ AliESDv0 *v0=GetV0(rm);
+ Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
+
+ v0=GetV0(last);
+ Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
+
+ Int_t used=0;
+
+ // Check if this V0 comes from a reconstructed decay
+ Int_t ncs=GetNumberOfCascades();
+ for (Int_t n=0; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+
+ Int_t csIdxP=cs->GetPindex();
+ Int_t csIdxN=cs->GetNindex();
+
+ if (idxP==csIdxP)
+ if (idxN==csIdxN) return kFALSE;
+
+ if (csIdxP==lastIdxP)
+ if (csIdxN==lastIdxN) used++;
+ }
+
+ //Replace the removed V0 with the last V0
+ TClonesArray &a=fV0s;
+ delete a.RemoveAt(rm);
+
+ if (rm==last) return kTRUE;
+
+ //v0 is pointing to the last V0 candidate...
+ new (a[rm]) AliESDv0(*v0);
+ delete a.RemoveAt(last);
+
+ if (!used) return kTRUE;
+
+
+ // Remap the indices of the daughters of reconstructed decays
+ for (Int_t n=0; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+
+
+ Int_t csIdxP=cs->GetPindex();
+ Int_t csIdxN=cs->GetNindex();
+
+ if (csIdxP==lastIdxP)
+ if (csIdxN==lastIdxN) {
+ cs->AliESDv0::SetIndex(1,idxP);
+ cs->AliESDv0::SetIndex(0,idxN);
+ used--;
+ if (!used) return kTRUE;
+ }
+ }
+
+ return kTRUE;
+}
+
+Bool_t AliESD::RemoveTrack(Int_t rm) {
+ // ---------------------------------------------------------
+ // Remove a track and references to it from ESD,
+ // if this track does not come from a reconstructed decay
+ // ---------------------------------------------------------
+ Int_t last=GetNumberOfTracks()-1;
+ if ((rm<0)||(rm>last)) return kFALSE;
+
+ Int_t used=0;
+
+ // Check if this track comes from the reconstructed primary vertex
+ if (fPrimaryVertex.GetStatus()) {
+ UShort_t *primIdx=fPrimaryVertex.GetIndices();
+ Int_t n=fPrimaryVertex.GetNIndices();
+ while (n--) {
+ Int_t idx=Int_t(primIdx[n]);
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+ }
+ }
+
+ // Check if this track comes from a reconstructed decay
+ Int_t nv0=GetNumberOfV0s();
+ for (Int_t n=0; n<nv0; n++) {
+ AliESDv0 *v0=GetV0(n);
+
+ Int_t idx=v0->GetNindex();
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+
+ idx=v0->GetPindex();
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+ }
+
+ Int_t ncs=GetNumberOfCascades();
+ for (Int_t n=0; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+
+ Int_t idx=cs->GetIndex();
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+ }
+
+ Int_t nkn=GetNumberOfKinks();
+ for (Int_t n=0; n<nkn; n++) {
+ AliESDkink *kn=GetKink(n);
+
+ Int_t idx=kn->GetIndex(0);
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+
+ idx=kn->GetIndex(1);
+ if (rm==idx) return kFALSE;
+ if (idx==last) used++;
+ }
+
+
+ //Replace the removed track with the last track
+ TClonesArray &a=fTracks;
+ delete a.RemoveAt(rm);
+
+ if (rm==last) return kTRUE;
+
+ AliESDtrack *t=GetTrack(last);
+ t->SetID(rm);
+ new (a[rm]) AliESDtrack(*t);
+ delete a.RemoveAt(last);
+
+
+ if (!used) return kTRUE;
+
+
+ // Remap the indices of the tracks used for the primary vertex reconstruction
+ if (fPrimaryVertex.GetStatus()) {
+ UShort_t *primIdx=fPrimaryVertex.GetIndices();
+ Int_t n=fPrimaryVertex.GetNIndices();
+ while (n--) {
+ Int_t idx=Int_t(primIdx[n]);
+ if (idx==last) {
+ primIdx[n]=Short_t(rm);
+ used--;
+ if (!used) return kTRUE;
+ }
+ }
+ }
+
+ // Remap the indices of the daughters of reconstructed decays
+ for (Int_t n=0; n<nv0; n++) {
+ AliESDv0 *v0=GetV0(n);
+ if (v0->GetIndex(0)==last) {
+ v0->SetIndex(0,rm);
+ used--;
+ if (!used) return kTRUE;
+ }
+ if (v0->GetIndex(1)==last) {
+ v0->SetIndex(1,rm);
+ used--;
+ if (!used) return kTRUE;
+ }
+ }
+
+ for (Int_t n=0; n<ncs; n++) {
+ AliESDcascade *cs=GetCascade(n);
+ if (cs->GetIndex()==last) {
+ cs->SetIndex(rm);
+ used--;
+ if (!used) return kTRUE;
+ }
+ }
+
+ for (Int_t n=0; n<nkn; n++) {
+ AliESDkink *kn=GetKink(n);
+ if (kn->GetIndex(0)==last) {
+ kn->SetIndex(rm,0);
+ used--;
+ if (!used) return kTRUE;
+ }
+ if (kn->GetIndex(1)==last) {
+ kn->SetIndex(rm,1);
+ used--;
+ if (!used) return kTRUE;
+ }
+ }
+
+ return kTRUE;
+}
+
+
+Bool_t AliESD::Clean(Float_t *cleanPars) {
+ //
+ // Remove the data which are not needed for the physics analysis.
+ //
+ // 1) Cleaning the V0 candidates
+ // ---------------------------
+ // If the cosine of the V0 pointing angle "csp" and
+ // the DCA between the daughter tracks "dca" does not satisfy
+ // the conditions
+ //
+ // csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
+ //
+ // an attempt to remove this V0 candidate from ESD is made.
+ //
+ // The V0 candidate gets removed if it does not belong to any
+ // recosntructed cascade decay
+ //
+ // 12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
+ //
+ // 2) Cleaning the tracks
+ // ----------------------
+ // If track's transverse parameter is larger than cleanPars[2]
+ // OR
+ // track's longitudinal parameter is larger than cleanPars[3]
+ // an attempt to remove this track from ESD is made.
+ //
+ // The track gets removed if it does not come
+ // from a reconstructed decay
+ //
+ Bool_t rc=kFALSE;
+
+ Float_t dcaMax=cleanPars[0];
+ Float_t cspMin=cleanPars[1];
+
+ Int_t nV0s=GetNumberOfV0s();
+ for (Int_t i=nV0s-1; i>=0; i--) {
+ AliESDv0 *v0=GetV0(i);
+
+ Float_t dca=v0->GetDcaV0Daughters();
+ Float_t csp=v0->GetV0CosineOfPointingAngle();
+ Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
+ if (csp > cspcut) continue;
+
+ if (RemoveV0(i)) rc=kTRUE;
+ }
+
+
+ Float_t dmax=cleanPars[2], zmax=cleanPars[3];
+
+ const AliESDVertex *vertex=GetVertex();
+ Bool_t vtxOK=vertex->GetStatus();
+
+ Int_t nTracks=GetNumberOfTracks();
+ for (Int_t i=nTracks-1; i>=0; i--) {
+ AliESDtrack *track=GetTrack(i);
+ Float_t xy,z; track->GetImpactParameters(xy,z);
+ if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
+ if (RemoveTrack(i)) rc=kTRUE;
+ }
+ }
+
+ return rc;
}
Int_t AliESD::AddV0(const AliESDv0 *v) {
// Print header information of the event
//
printf("ESD run information\n");
- printf("Event # %d Run # %d Trigger %lld Magnetic field %f \n",
- GetEventNumber(),
+ printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
+ GetEventNumberInFile(),
+ GetBunchCrossNumber(),
+ GetOrbitNumber(),
+ GetPeriodNumber(),
GetRunNumber(),
GetTriggerMask(),
GetMagneticField() );
fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
+ printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
+ GetDiamondX(),GetDiamondY());
printf("SPD Multiplicity. Number of tracklets %d \n",
fSPDMult.GetNumberOfTracklets());
printf("Event from reconstruction version %d \n",fRecoVersion);
Int_t ntrk=GetNumberOfTracks();
for (Int_t i=0; i<ntrk; i++) {
- const AliESDtrack *t=GetTrack(i);
+ AliESDtrack *t=GetTrack(i);
const AliESDfriendTrack *f=t->GetFriendTrack();
ev->AddTrack(f);
+
+ t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
+
}
}
+
+void AliESD::SetDiamond(const AliESDVertex *vertex)
+{
+ //
+ // Set the interaction diamond
+ //
+ fDiamondXY[0]=vertex->GetXv();
+ fDiamondXY[1]=vertex->GetYv();
+ Double_t cov[6];
+ vertex->GetCovMatrix(cov);
+ fDiamondCovXY[0]=cov[0];
+ fDiamondCovXY[1]=cov[1];
+ fDiamondCovXY[2]=cov[2];
+ }