X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=STEER%2FESD%2FAliESDEvent.cxx;h=3bb69e763cb014339fe7dadbe0ab0db60c091ddb;hb=1c762523bceff64dc81cc232ea9155fada924ffc;hp=9a7b4f5764807a1d13c8c70d2f2a69f2862640d4;hpb=5d8eaff6eb5b68b9a2a820bf402c2c014d54352d;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/ESD/AliESDEvent.cxx b/STEER/ESD/AliESDEvent.cxx index 9a7b4f57648..3bb69e763cb 100644 --- a/STEER/ESD/AliESDEvent.cxx +++ b/STEER/ESD/AliESDEvent.cxx @@ -13,7 +13,7 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -/* $Id$ */ +/* $Id: AliESDEvent.cxx 64008 2013-08-28 13:09:59Z hristov $ */ //----------------------------------------------------------------- // Implementation of the AliESDEvent class @@ -44,6 +44,9 @@ #include "AliESDFMD.h" #include "AliESD.h" #include "AliESDMuonTrack.h" +#include "AliESDMuonCluster.h" +#include "AliESDMuonPad.h" +#include "AliESDMuonGlobalTrack.h" // AU #include "AliESDPmdTrack.h" #include "AliESDTrdTrack.h" #include "AliESDVertex.h" @@ -67,19 +70,17 @@ #include "AliRawDataErrorLog.h" #include "AliLog.h" #include "AliESDACORDE.h" +#include "AliESDAD.h" #include "AliESDHLTDecision.h" #include "AliCentrality.h" #include "AliESDCosmicTrack.h" -#ifdef MFT_UPGRADE -#include "AliESDMFT.h" -#endif +#include "AliTriggerConfiguration.h" +#include "AliTriggerClass.h" +#include "AliTriggerCluster.h" #include "AliEventplane.h" - ClassImp(AliESDEvent) - - // here we define the names, some classes are no TNamed, therefore the classnames // are the Names const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun", @@ -98,6 +99,9 @@ ClassImp(AliESDEvent) "TrkPileupVertices", "Tracks", "MuonTracks", + "MuonClusters", + "MuonPads", + "MuonGlobalTracks", // AU "PmdTracks", "AliESDTrdTrigger", "TrdTracks", @@ -110,12 +114,13 @@ ClassImp(AliESDEvent) "PHOSCells", "AliRawDataErrorLogs", "AliESDACORDE", + "AliESDAD", "AliTOFHeader", - "CosmicTracks" - #ifdef MFT_UPGRADE -// , "AliESDMFT" - #endif - }; + "CosmicTracks", + "AliESDTOFCluster", + "AliESDTOFHit", + "AliESDTOFMatch"}; + //______________________________________________________________________________ AliESDEvent::AliESDEvent(): @@ -134,11 +139,15 @@ AliESDEvent::AliESDEvent(): fPHOSTrigger(0), fEMCALTrigger(0), fESDACORDE(0), + fESDAD(0), fTrdTrigger(0), fSPDPileupVertices(0), fTrkPileupVertices(0), fTracks(0), fMuonTracks(0), + fMuonClusters(0), + fMuonPads(0), + fMuonGlobalTracks(0), // AU fPmdTracks(0), fTrdTracks(0), fTrdTracklets(0), @@ -148,18 +157,22 @@ AliESDEvent::AliESDEvent(): fCaloClusters(0), fEMCALCells(0), fPHOSCells(0), fCosmicTracks(0), + fESDTOFClusters(0), + fESDTOFHits(0), + fESDTOFMatches(0), fErrorLogs(0), + fOldMuonStructure(kFALSE), fESDOld(0), fESDFriendOld(0), fConnected(kFALSE), fUseOwnList(kFALSE), + fTracksConnected(kFALSE), fTOFHeader(0), fCentrality(0), fEventplane(0), - fDetectorStatus(0xFFFFFFFF) - #ifdef MFT_UPGRADE -// , fESDMFT(0) - #endif + fDetectorStatus(0xFFFFFFFF), + fDAQDetectorPattern(0xFFFF), + fDAQAttributes(0xFFFF) { } //______________________________________________________________________________ @@ -179,11 +192,15 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)), fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)), fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)), + fESDAD(new AliESDAD(*esd.fESDAD)), fTrdTrigger(new AliESDTrdTrigger(*esd.fTrdTrigger)), fSPDPileupVertices(new TClonesArray(*esd.fSPDPileupVertices)), fTrkPileupVertices(new TClonesArray(*esd.fTrkPileupVertices)), fTracks(new TClonesArray(*esd.fTracks)), fMuonTracks(new TClonesArray(*esd.fMuonTracks)), + fMuonClusters(new TClonesArray(*esd.fMuonClusters)), + fMuonPads(new TClonesArray(*esd.fMuonPads)), + fMuonGlobalTracks(new TClonesArray(*esd.fMuonGlobalTracks)), // AU fPmdTracks(new TClonesArray(*esd.fPmdTracks)), fTrdTracks(new TClonesArray(*esd.fTrdTracks)), fTrdTracklets(new TClonesArray(*esd.fTrdTracklets)), @@ -194,20 +211,22 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)), fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)), fCosmicTracks(new TClonesArray(*esd.fCosmicTracks)), + fESDTOFClusters(esd.fESDTOFClusters ? new TClonesArray(*esd.fESDTOFClusters) : 0), + fESDTOFHits(esd.fESDTOFHits ? new TClonesArray(*esd.fESDTOFHits) : 0), + fESDTOFMatches(esd.fESDTOFMatches ? new TClonesArray(*esd.fESDTOFMatches) : 0), fErrorLogs(new TClonesArray(*esd.fErrorLogs)), + fOldMuonStructure(esd.fOldMuonStructure), fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0), fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0), fConnected(esd.fConnected), fUseOwnList(esd.fUseOwnList), + fTracksConnected(kFALSE), fTOFHeader(new AliTOFHeader(*esd.fTOFHeader)), fCentrality(new AliCentrality(*esd.fCentrality)), fEventplane(new AliEventplane(*esd.fEventplane)), - fDetectorStatus(esd.fDetectorStatus) - #ifdef MFT_UPGRADE -// , fESDMFT(new AliESDMFT(*esd.fESDMFT)) - #endif - - + fDetectorStatus(esd.fDetectorStatus), + fDAQDetectorPattern(esd.fDAQDetectorPattern), + fDAQAttributes(esd.fDAQAttributes) { printf("copying ESD event...\n"); // AU // CKB init in the constructor list and only add here ... @@ -228,6 +247,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): AddObject(fTrkPileupVertices); AddObject(fTracks); AddObject(fMuonTracks); + AddObject(fMuonGlobalTracks); // AU AddObject(fPmdTracks); AddObject(fTrdTracks); AddObject(fTrdTracklets); @@ -238,13 +258,17 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): AddObject(fEMCALCells); AddObject(fPHOSCells); AddObject(fCosmicTracks); + AddObject(fESDTOFClusters); + AddObject(fESDTOFHits); + AddObject(fESDTOFMatches); AddObject(fErrorLogs); AddObject(fESDACORDE); + AddObject(fESDAD); AddObject(fTOFHeader); - #ifdef MFT_UPGRADE -// AddObject(fESDMFT); - #endif + AddObject(fMuonClusters); + AddObject(fMuonPads); GetStdContent(); + ConnectTracks(); } @@ -252,7 +276,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) { // Assignment operator - + printf("operator = ESD\n"); if(&source == this) return *this; AliVEvent::operator=(source); @@ -335,14 +359,20 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) { } } + fOldMuonStructure = source.fOldMuonStructure; + fCentrality = source.fCentrality; fEventplane = source.fEventplane; fConnected = source.fConnected; fUseOwnList = source.fUseOwnList; - + fDetectorStatus = source.fDetectorStatus; + fDAQDetectorPattern = source.fDAQDetectorPattern; + fDAQAttributes = source.fDAQAttributes; + fTracksConnected = kFALSE; + ConnectTracks(); return *this; } @@ -365,6 +395,7 @@ AliESDEvent::~AliESDEvent() if (fCentrality) delete fCentrality; if (fEventplane) delete fEventplane; + } void AliESDEvent::Copy(TObject &obj) const { @@ -389,7 +420,9 @@ void AliESDEvent::Reset() // Reset the standard contents ResetStdContent(); - + fDetectorStatus = 0xFFFFFFFF; + fDAQDetectorPattern = 0xFFFF; + fDAQAttributes = 0xFFFF; // reset for the old data without AliESDEvent... if(fESDOld)fESDOld->Reset(); if(fESDFriendOld){ @@ -427,6 +460,7 @@ void AliESDEvent::Reset() } +//______________________________________________________________________________ Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){ // // funtion to reset using the already allocated space @@ -442,6 +476,7 @@ Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){ return kTRUE; } +//______________________________________________________________________________ void AliESDEvent::ResetStdContent() { // Reset the standard contents @@ -462,6 +497,13 @@ void AliESDEvent::ResetStdContent() fESDACORDE->~AliESDACORDE(); new (fESDACORDE) AliESDACORDE(); } + + if(fESDAD){ + fESDAD->~AliESDAD(); + new (fESDAD) AliESDAD(); + } + + if(fESDTZERO) fESDTZERO->Reset(); // CKB no clear/reset implemented if(fTPCVertex){ @@ -492,19 +534,17 @@ void AliESDEvent::ResetStdContent() fTrdTrigger->~AliESDTrdTrigger(); new (fTrdTrigger) AliESDTrdTrigger(); } - #ifdef MFT_UPGRADE - //if(fESDMFT){ -// fESDMFT->~AliESDMFT(); -// new (fESDMFT) AliESDMFT(); - // } - #endif if(fPHOSTrigger)fPHOSTrigger->DeAllocate(); if(fEMCALTrigger)fEMCALTrigger->DeAllocate(); if(fSPDPileupVertices)fSPDPileupVertices->Delete(); if(fTrkPileupVertices)fTrkPileupVertices->Delete(); + fTracksConnected = kFALSE; if(fTracks)fTracks->Delete(); - if(fMuonTracks)fMuonTracks->Delete(); + if(fMuonTracks)fMuonTracks->Clear("C"); + if(fMuonClusters)fMuonClusters->Clear("C"); + if(fMuonPads)fMuonPads->Clear("C"); + if(fMuonGlobalTracks)fMuonGlobalTracks->Clear("C"); // AU if(fPmdTracks)fPmdTracks->Delete(); if(fTrdTracks)fTrdTracks->Delete(); if(fTrdTracklets)fTrdTracklets->Delete(); @@ -515,6 +555,9 @@ void AliESDEvent::ResetStdContent() if(fPHOSCells)fPHOSCells->DeleteContainer(); if(fEMCALCells)fEMCALCells->DeleteContainer(); if(fCosmicTracks)fCosmicTracks->Delete(); + if(fESDTOFClusters)fESDTOFClusters->Clear(); + if(fESDTOFHits)fESDTOFHits->Clear(); + if(fESDTOFMatches)fESDTOFMatches->Clear(); if(fErrorLogs) fErrorLogs->Delete(); // don't reset fconnected fConnected and the list @@ -522,6 +565,7 @@ void AliESDEvent::ResetStdContent() } +//______________________________________________________________________________ Int_t AliESDEvent::AddV0(const AliESDv0 *v) { // // Add V0 @@ -532,6 +576,32 @@ Int_t AliESDEvent::AddV0(const AliESDv0 *v) { return idx; } +//______________________________________________________________________________ +Bool_t AliESDEvent::IsDetectorInTriggerCluster(TString detector, AliTriggerConfiguration* trigConf) const { + // Check if a given detector was read-out in the analyzed event + const TObjArray& classesArray=trigConf->GetClasses(); + ULong64_t trigMask=GetTriggerMask(); + ULong64_t trigMaskNext50=GetTriggerMaskNext50(); + Int_t nclasses = classesArray.GetEntriesFast(); + for(Int_t iclass=0; iclass < nclasses; iclass++ ) { + AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass); + ULong64_t classMask=trclass->GetMask(); + ULong64_t classMaskNext50=trclass->GetMaskNext50(); + if(trigMask & classMask){ + TString detList=trclass->GetCluster()->GetDetectorsInCluster(); + if(detList.Contains(detector.Data())){ + return kTRUE; + } + } + if(trigMaskNext50 & classMaskNext50){ + TString detList=trclass->GetCluster()->GetDetectorsInCluster(); + if(detList.Contains(detector.Data())){ + return kTRUE; + } + } + } + return kFALSE; +} //______________________________________________________________________________ void AliESDEvent::Print(Option_t *) const { @@ -539,19 +609,20 @@ void AliESDEvent::Print(Option_t *) const // Print header information of the event // printf("ESD run information\n"); - printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n", + printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld %lld Magnetic field %f \n", GetEventNumberInFile(), GetBunchCrossNumber(), GetOrbitNumber(), GetPeriodNumber(), GetRunNumber(), GetTriggerMask(), + GetTriggerMaskNext50(), GetMagneticField() ); if (fPrimaryVertex) printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n", - fPrimaryVertex->GetXv(), fPrimaryVertex->GetXRes(), - fPrimaryVertex->GetYv(), fPrimaryVertex->GetYRes(), - fPrimaryVertex->GetZv(), fPrimaryVertex->GetZRes()); + fPrimaryVertex->GetX(), fPrimaryVertex->GetXRes(), + fPrimaryVertex->GetY(), fPrimaryVertex->GetYRes(), + fPrimaryVertex->GetZ(), fPrimaryVertex->GetZRes()); printf("Mean vertex in RUN: X=%.4f Y=%.4f Z=%.4f cm\n", GetDiamondX(),GetDiamondY(),GetDiamondZ()); if(fSPDMult) @@ -564,6 +635,7 @@ void AliESDEvent::Print(Option_t *) const printf("Number of tracks: \n"); printf(" charged %d\n", GetNumberOfTracks()); printf(" muon %d\n", GetNumberOfMuonTracks()); + printf(" glob muon %d\n", GetNumberOfMuonGlobalTracks()); // AU printf(" pmd %d\n", GetNumberOfPmdTracks()); printf(" trd %d\n", GetNumberOfTrdTracks()); printf(" trd trkl %d\n", GetNumberOfTrdTracklets()); @@ -577,11 +649,9 @@ void AliESDEvent::Print(Option_t *) const printf(" CaloClusters %d\n", GetNumberOfCaloClusters()); printf(" FMD %s\n", (fESDFMD ? "yes" : "no")); printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no")); + printf(" muClusters %d\n", fMuonClusters ? fMuonClusters->GetEntriesFast() : 0); + printf(" muPad %d\n", fMuonPads ? fMuonPads->GetEntriesFast() : 0); if (fCosmicTracks) printf(" Cosmics %d\n", GetNumberOfCosmicTracks()); - #ifdef MFT_UPGRADE - //printf(" MFT %s\n", (fESDMFT ? "yes" : "no")); - #endif - TObject* pHLTDecision=GetHLTTriggerDecision(); printf("HLT trigger decision: %s\n", pHLTDecision?pHLTDecision->GetOption():"not available"); @@ -590,10 +660,12 @@ void AliESDEvent::Print(Option_t *) const return; } -void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const { - // - // Attaches the complementary info to the ESD - // +//______________________________________________________________________________ +void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const +{ +// +// Attaches the complementary info to the ESD +// if (!ev) return; // to be sure that we set the tracks also @@ -604,27 +676,32 @@ void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const { for (Int_t i=0; iGetTrack(i); + if (!f) {AliFatal(Form("NULL pointer for ESD track %d",i));} GetTrack(i)->SetFriendTrack(f); } } -Bool_t AliESDEvent::RemoveKink(Int_t rm) const { - // --------------------------------------------------------- - // Remove a kink candidate and references to it from ESD, - // if this candidate does not come from a reconstructed decay - // Not yet implemented... - // --------------------------------------------------------- +//______________________________________________________________________________ +Bool_t AliESDEvent::RemoveKink(Int_t rm) const +{ +// --------------------------------------------------------- +// 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 AliESDEvent::RemoveV0(Int_t rm) const { - // --------------------------------------------------------- - // Remove a V0 candidate and references to it from ESD, - // if this candidate does not come from a reconstructed decay - // --------------------------------------------------------- +//______________________________________________________________________________ +Bool_t AliESDEvent::RemoveV0(Int_t rm) const +{ +// --------------------------------------------------------- +// 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; @@ -684,11 +761,13 @@ Bool_t AliESDEvent::RemoveV0(Int_t rm) const { return kTRUE; } -Bool_t AliESDEvent::RemoveTrack(Int_t rm) const { - // --------------------------------------------------------- - // Remove a track and references to it from ESD, - // if this track does not come from a reconstructed decay - // --------------------------------------------------------- +//______________________________________________________________________________ +Bool_t AliESDEvent::RemoveTrack(Int_t rm) const +{ +// --------------------------------------------------------- +// 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; @@ -772,20 +851,22 @@ Bool_t AliESDEvent::RemoveTrack(Int_t rm) const { } } - - + // from here on we remove the track + // //Replace the removed track with the last track TClonesArray &a=*fTracks; + AliESDtrack* trm = GetTrack(rm); + trm->SuppressTOFMatches(); // remove reference to this track from stored TOF clusters delete a.RemoveAt(rm); - + // if (rm==last) return kTRUE; AliESDtrack *t=GetTrack(last); + if (!t) {AliFatal(Form("NULL pointer for ESD track %d",last));} t->SetID(rm); new (a[rm]) AliESDtrack(*t); delete a.RemoveAt(last); - if (!used) return kTRUE; @@ -882,8 +963,9 @@ Bool_t AliESDEvent::RemoveTrack(Int_t rm) const { return kTRUE; } - -Bool_t AliESDEvent::Clean(Float_t *cleanPars) { +//______________________________________________________________________________ +Bool_t AliESDEvent::Clean(Float_t *cleanPars) +{ // // Remove the data which are not needed for the physics analysis. // @@ -937,6 +1019,7 @@ Bool_t AliESDEvent::Clean(Float_t *cleanPars) { Int_t nTracks=GetNumberOfTracks(); for (Int_t i=nTracks-1; i>=0; i--) { AliESDtrack *track=GetTrack(i); + if (!track) {AliFatal(Form("NULL pointer for ESD track %d",i));} Float_t xy,z; track->GetImpactParameters(xy,z); if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) { if (RemoveTrack(i)) rc=kTRUE; @@ -946,6 +1029,7 @@ Bool_t AliESDEvent::Clean(Float_t *cleanPars) { return rc; } +//______________________________________________________________________________ Char_t AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx) { // Add a pileup primary vertex reconstructed with SPD @@ -956,6 +1040,7 @@ Char_t AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx) return n; } +//______________________________________________________________________________ Char_t AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx) { // Add a pileup primary vertex reconstructed with SPD @@ -966,68 +1051,253 @@ Char_t AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx) return n; } +//______________________________________________________________________________ Int_t AliESDEvent::AddTrack(const AliESDtrack *t) { // Add track TClonesArray &ftr = *fTracks; AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t); track->SetID(fTracks->GetEntriesFast()-1); + track->SetESDEvent(this); return track->GetID(); } +//______________________________________________________________________________ AliESDtrack* AliESDEvent::NewTrack() { // Add a new track TClonesArray &ftr = *fTracks; AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(); track->SetID(fTracks->GetEntriesFast()-1); + track->SetESDEvent(this); return track; } - void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) +//______________________________________________________________________________ +Bool_t AliESDEvent::MoveMuonObjects() { - TClonesArray &fmu = *fMuonTracks; - new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t); + // move MUON clusters and pads to the new ESD structure in needed. + // to ensure backward compatibility + + if (!fOldMuonStructure) return kTRUE; + + if (!fMuonTracks || !fMuonClusters || !fMuonPads) return kFALSE; + + Bool_t reset = kTRUE; + Bool_t containTrackerData = kFALSE; + for (Int_t i = 0; i < fMuonTracks->GetEntriesFast(); i++) { + + AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i); + + if (track->ContainTrackerData()) containTrackerData = kTRUE; + else continue; + + if (!track->IsOldTrack()) continue; + + // remove objects connected to previous event if needed + if (reset) { + if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C"); + if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C"); + reset = kFALSE; + } + + track->MoveClustersToESD(*this); + + } + + // remove objects connected to previous event if needed + if (!containTrackerData) { + if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C"); + if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C"); + } + + return kTRUE; } +//______________________________________________________________________________ +AliESDMuonTrack* AliESDEvent::GetMuonTrack(Int_t i) +{ + // get the MUON track at the position i in the internal array of track + if (!fMuonTracks) return 0x0; + if (!MoveMuonObjects()) return 0x0; + AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i); + track->SetESDEvent(this); + return track; +} + +//______________________________________________________________________________ +AliESDMuonGlobalTrack* AliESDEvent::GetMuonGlobalTrack(Int_t i) // AU +{ + // get the MUON+MFT track at the position i in the internal array of track + if (!fMuonGlobalTracks) return 0x0; + AliESDMuonGlobalTrack *track = (AliESDMuonGlobalTrack*) fMuonGlobalTracks->UncheckedAt(i); + track->SetESDEvent(this); + return track; +} + +//______________________________________________________________________________ +void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) +{ + // add a MUON track + TClonesArray &fmu = *fMuonTracks; + AliESDMuonTrack *track = new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t); + track->MoveClustersToESD(*this); +} + +//______________________________________________________________________________ +void AliESDEvent::AddMuonGlobalTrack(const AliESDMuonGlobalTrack *t) // AU +{ + // add a MUON+MFT track + TClonesArray &fmu = *fMuonGlobalTracks; + new (fmu[fMuonGlobalTracks->GetEntriesFast()]) AliESDMuonGlobalTrack(*t); +} + +//______________________________________________________________________________ + +AliESDMuonTrack* AliESDEvent::NewMuonTrack() +{ + // create a new MUON track at the end of the internal array of track + TClonesArray &fmu = *fMuonTracks; + return new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(); +} + +//______________________________________________________________________________ +AliESDMuonGlobalTrack* AliESDEvent::NewMuonGlobalTrack() // AU +{ + // create a new MUON+MFT track at the end of the internal array of track + TClonesArray &fmu = *fMuonGlobalTracks; + return new(fmu[fMuonGlobalTracks->GetEntriesFast()]) AliESDMuonGlobalTrack(); +} + +//______________________________________________________________________________ +Int_t AliESDEvent::GetNumberOfMuonClusters() +{ + // get the number of MUON clusters + if (!fMuonClusters) return 0; + if (!MoveMuonObjects()) return 0; + return fMuonClusters->GetEntriesFast(); +} + +//______________________________________________________________________________ +AliESDMuonCluster* AliESDEvent::GetMuonCluster(Int_t i) +{ + // get the MUON cluster at the position i in the internal array of cluster + if (!fMuonClusters) return 0x0; + if (!MoveMuonObjects()) return 0x0; + return (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i); +} + +//______________________________________________________________________________ +AliESDMuonCluster* AliESDEvent::FindMuonCluster(UInt_t clusterId) +{ + // find the MUON cluster with this Id in the internal array of cluster + if (!fMuonClusters) return 0x0; + if (!MoveMuonObjects()) return 0x0; + for (Int_t i = 0; i < fMuonClusters->GetEntriesFast(); i++) { + AliESDMuonCluster *cluster = (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i); + if (cluster->GetUniqueID() == clusterId) return cluster; + } + return 0x0; +} + +//______________________________________________________________________________ +AliESDMuonCluster* AliESDEvent::NewMuonCluster() +{ + // create a new MUON cluster at the end of the internal array of cluster + TClonesArray &fmu = *fMuonClusters; + return new(fmu[fMuonClusters->GetEntriesFast()]) AliESDMuonCluster(); +} + +//______________________________________________________________________________ +Int_t AliESDEvent::GetNumberOfMuonPads() +{ + // get the number of MUON pads + if (!fMuonPads) return 0; + if (!MoveMuonObjects()) return 0; + return fMuonPads->GetEntriesFast(); +} + +//______________________________________________________________________________ +AliESDMuonPad* AliESDEvent::GetMuonPad(Int_t i) +{ + // get the MUON pad at the position i in the internal array of pad + if (!fMuonPads) return 0x0; + if (!MoveMuonObjects()) return 0x0; + return (AliESDMuonPad*) fMuonPads->UncheckedAt(i); +} + +//______________________________________________________________________________ +AliESDMuonPad* AliESDEvent::FindMuonPad(UInt_t padId) +{ + // find the MUON pad with this Id in the internal array of pad + if (!fMuonPads) return 0x0; + if (!MoveMuonObjects()) return 0x0; + for (Int_t i = 0; i < fMuonPads->GetEntriesFast(); i++) { + AliESDMuonPad *pad = (AliESDMuonPad*) fMuonPads->UncheckedAt(i); + if (pad->GetUniqueID() == padId) return pad; + } + return 0x0; +} + +//______________________________________________________________________________ +AliESDMuonPad* AliESDEvent::NewMuonPad() +{ + // create a new MUON pad at the end of the internal array of pad + TClonesArray &fmu = *fMuonPads; + return new(fmu[fMuonPads->GetEntriesFast()]) AliESDMuonPad(); +} + +//______________________________________________________________________________ void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t) { TClonesArray &fpmd = *fPmdTracks; new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t); } +//______________________________________________________________________________ void AliESDEvent::SetTrdTrigger(const AliESDTrdTrigger *t) { *fTrdTrigger = *t; } +//______________________________________________________________________________ void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t) { TClonesArray &ftrd = *fTrdTracks; new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t); } +//______________________________________________________________________________ void AliESDEvent::AddTrdTracklet(const AliESDTrdTracklet *trkl) { new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(*trkl); } +//______________________________________________________________________________ +void AliESDEvent::AddTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label) +{ + new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(trackletWord, hcid, label); +} + +//______________________________________________________________________________ Int_t AliESDEvent::AddKink(const AliESDkink *c) { - // Add kink - TClonesArray &fk = *fKinks; - AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c); - kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps.. - return fKinks->GetEntriesFast()-1; + // Add kink + TClonesArray &fk = *fKinks; + AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c); + kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps.. + return fKinks->GetEntriesFast()-1; } +//______________________________________________________________________________ void AliESDEvent::AddCascade(const AliESDcascade *c) { TClonesArray &fc = *fCascades; new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c); } +//______________________________________________________________________________ void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t) { TClonesArray &ft = *fCosmicTracks; @@ -1035,21 +1305,24 @@ void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t) } +//______________________________________________________________________________ Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) { - // Add calocluster - TClonesArray &fc = *fCaloClusters; - AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c); - clus->SetID(fCaloClusters->GetEntriesFast()-1); - return fCaloClusters->GetEntriesFast()-1; - } + // Add calocluster + TClonesArray &fc = *fCaloClusters; + AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c); + clus->SetID(fCaloClusters->GetEntriesFast()-1); + return fCaloClusters->GetEntriesFast()-1; +} +//______________________________________________________________________________ void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const { TClonesArray &errlogs = *fErrorLogs; new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log); } +//______________________________________________________________________________ void AliESDEvent::SetZDCData(const AliESDZDC * obj) { // use already allocated space @@ -1057,6 +1330,7 @@ void AliESDEvent::SetZDCData(const AliESDZDC * obj) *fESDZDC = *obj; } +//______________________________________________________________________________ void AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex) { // Set the TPC vertex @@ -1067,6 +1341,7 @@ void AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex) } } +//______________________________________________________________________________ void AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex) { // Set the SPD vertex @@ -1077,6 +1352,7 @@ void AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex) } } +//______________________________________________________________________________ void AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex) { // Set the primary vertex reconstructed using he ESD tracks. @@ -1087,6 +1363,7 @@ void AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex) } } +//______________________________________________________________________________ const AliESDVertex * AliESDEvent::GetPrimaryVertex() const { // @@ -1104,6 +1381,7 @@ const AliESDVertex * AliESDEvent::GetPrimaryVertex() const return fSPDVertex; } +//______________________________________________________________________________ AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const { // @@ -1129,6 +1407,7 @@ AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const return vertex; } +//______________________________________________________________________________ void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) { // Set the SPD Multiplicity @@ -1138,6 +1417,7 @@ void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) } +//______________________________________________________________________________ void AliESDEvent::SetFMDData(AliESDFMD * obj) { // use already allocated space @@ -1146,6 +1426,7 @@ void AliESDEvent::SetFMDData(AliESDFMD * obj) } } +//______________________________________________________________________________ void AliESDEvent::SetVZEROData(const AliESDVZERO * obj) { // use already allocated space @@ -1153,6 +1434,7 @@ void AliESDEvent::SetVZEROData(const AliESDVZERO * obj) *fESDVZERO = *obj; } +//______________________________________________________________________________ void AliESDEvent::SetTZEROData(const AliESDTZERO * obj) { // use already allocated space @@ -1160,21 +1442,22 @@ void AliESDEvent::SetTZEROData(const AliESDTZERO * obj) *fESDTZERO = *obj; } -#ifdef MFT_UPGRADE -//void AliESDEvent::SetMFTData(AliESDMFT * obj) -//{ -// if(fESDMFT) -// *fESDMFT = *obj; -//} -#endif +//______________________________________________________________________________ void AliESDEvent::SetACORDEData(AliESDACORDE * obj) { if(fESDACORDE) *fESDACORDE = *obj; } +//______________________________________________________________________________ +void AliESDEvent::SetADData(AliESDAD * obj) +{ + if(fESDAD) + *fESDAD = *obj; +} +//______________________________________________________________________________ void AliESDEvent::GetESDfriend(AliESDfriend *ev) const { // @@ -1186,6 +1469,7 @@ void AliESDEvent::GetESDfriend(AliESDfriend *ev) const for (Int_t i=0; iGetFriendTrack(); ev->AddTrack(f); @@ -1193,10 +1477,11 @@ void AliESDEvent::GetESDfriend(AliESDfriend *ev) const } - AliESDfriend *fr = (AliESDfriend*)(const_cast(this)->FindListObject("AliESDfriend")); + AliESDfriend *fr = (AliESDfriend*)(const_cast(this)->FindFriend()); if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend()); } +//______________________________________________________________________________ void AliESDEvent::AddObject(TObject* obj) { // Add an object to the list of object. @@ -1206,7 +1491,7 @@ void AliESDEvent::AddObject(TObject* obj) fESDObjects->AddLast(obj); } - +//______________________________________________________________________________ void AliESDEvent::GetStdContent() { // set pointers for standard content @@ -1228,6 +1513,9 @@ void AliESDEvent::GetStdContent() fTrkPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrkPileupVertices]); fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]); fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]); + fMuonClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonClusters]); + fMuonPads = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonPads]); + fMuonGlobalTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonGlobalTracks]); // AU fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]); fTrdTrigger = (AliESDTrdTrigger*)fESDObjects->FindObject(fgkESDListName[kTrdTrigger]); fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]); @@ -1240,13 +1528,15 @@ void AliESDEvent::GetStdContent() fPHOSCells = (AliESDCaloCells*)fESDObjects->FindObject(fgkESDListName[kPHOSCells]); fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]); fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]); + fESDAD = (AliESDAD*)fESDObjects->FindObject(fgkESDListName[kESDAD]); fTOFHeader = (AliTOFHeader*)fESDObjects->FindObject(fgkESDListName[kTOFHeader]); fCosmicTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCosmicTracks]); - #ifdef MFT_UPGRADE - // fESDMFT = (AliESDMFT*)fESDObjects->FindObject(fgkESDListName[kESDMFT]); - #endif + fESDTOFClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFclusters]); + fESDTOFHits = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFhit]); + fESDTOFMatches = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFmatch]); } +//______________________________________________________________________________ void AliESDEvent::SetStdNames(){ // Set the names of the standard contents // @@ -1266,12 +1556,13 @@ void AliESDEvent::SetStdNames(){ } } - +//______________________________________________________________________________ void AliESDEvent::CreateStdContent(Bool_t bUseThisList){ fUseOwnList = bUseThisList; CreateStdContent(); } +//______________________________________________________________________________ void AliESDEvent::CreateStdContent() { // create the standard AOD content and set pointers @@ -1293,6 +1584,9 @@ void AliESDEvent::CreateStdContent() AddObject(new TClonesArray("AliESDVertex",0)); AddObject(new TClonesArray("AliESDtrack",0)); AddObject(new TClonesArray("AliESDMuonTrack",0)); + AddObject(new TClonesArray("AliESDMuonCluster",0)); + AddObject(new TClonesArray("AliESDMuonPad",0)); + AddObject(new TClonesArray("AliESDMuonGlobalTrack",0)); // AU AddObject(new TClonesArray("AliESDPmdTrack",0)); AddObject(new AliESDTrdTrigger()); AddObject(new TClonesArray("AliESDTrdTrack",0)); @@ -1305,11 +1599,12 @@ void AliESDEvent::CreateStdContent() AddObject(new AliESDCaloCells()); AddObject(new TClonesArray("AliRawDataErrorLog",0)); AddObject(new AliESDACORDE()); + AddObject(new AliESDAD()); AddObject(new AliTOFHeader()); AddObject(new TClonesArray("AliESDCosmicTrack",0)); - #ifdef MFT_UPGRADE - //AddObject(new AliESDMFT()); - #endif + AddObject(new TClonesArray("AliESDTOFCluster",0)); + AddObject(new TClonesArray("AliESDTOFHit",0)); + AddObject(new TClonesArray("AliESDTOFMatch",0)); // check the order of the indices against enum... @@ -1319,6 +1614,34 @@ void AliESDEvent::CreateStdContent() GetStdContent(); } +//______________________________________________________________________________ +void AliESDEvent::CompleteStdContent() +{ + // Create missing standard objects and add them to the TList of objects + // + // Add cosmic tracks for cases where esd files were created + // before adding them to the std content + if (!fESDObjects->FindObject(fgkESDListName[kCosmicTracks])) { + TClonesArray* cosmics = new TClonesArray("AliESDCosmicTrack",0); + fESDObjects->AddAt(cosmics, kCosmicTracks); + fESDObjects->SetOwner(kTRUE); + } + // Add new MUON containers if missing (for backward compatibility) + if (!fESDObjects->FindObject(fgkESDListName[kMuonClusters])) { + TClonesArray* muonClusters = new TClonesArray("AliESDMuonCluster",0); + muonClusters->SetName(fgkESDListName[kMuonClusters]); + fESDObjects->AddAt(muonClusters, kMuonClusters); + fESDObjects->SetOwner(kTRUE); + } + if (!fESDObjects->FindObject(fgkESDListName[kMuonPads])) { + TClonesArray* muonPads = new TClonesArray("AliESDMuonPad",0); + muonPads->SetName(fgkESDListName[kMuonPads]); + fESDObjects->AddAt(muonPads, kMuonPads); + fESDObjects->SetOwner(kTRUE); + } +} + +//______________________________________________________________________________ TObject* AliESDEvent::FindListObject(const char *name) const { // // Find object with name "name" in the list of branches @@ -1329,6 +1652,7 @@ TObject* AliESDEvent::FindListObject(const char *name) const { return 0; } +//______________________________________________________________________________ Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const { // fills the provided TRefArray with all found phos clusters @@ -1348,6 +1672,7 @@ Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const return clusters->GetEntriesFast(); } +//______________________________________________________________________________ Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const { // fills the provided TRefArray with all found emcal clusters @@ -1367,6 +1692,7 @@ Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const return clusters->GetEntriesFast(); } +//______________________________________________________________________________ void AliESDEvent::WriteToTree(TTree* tree) const { // Book the branches as in TTree::Branch(TCollection*) // but add a "." at the end of top level branches which are @@ -1392,9 +1718,13 @@ void AliESDEvent::WriteToTree(TTree* tree) const { tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),kBufsize, splitLevel); } } -} + tree->Branch("fDetectorStatus",(void*)&fDetectorStatus,"fDetectorStatus/l"); + tree->Branch("fDAQDetectorPattern",(void*)&fDAQDetectorPattern,"fDAQDetectorPattern/i"); + tree->Branch("fDAQAttributes",(void*)&fDAQAttributes,"fDAQAttributes/i"); +} +//______________________________________________________________________________ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ // // Connect the ESDEvent to a tree @@ -1408,6 +1738,7 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ // if we find the "ESD" branch on the tree we do have the old structure if(tree->GetBranch("ESD")) { + fOldMuonStructure = kFALSE; char ** address = (char **)(tree->GetBranch("ESD")->GetAddress()); // do we have the friend branch TBranch * esdFB = tree->GetBranch("ESDfriend."); @@ -1490,7 +1821,11 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ // If connected use the connected list if objects fESDObjects->Delete(); fESDObjects = connectedList; + tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus); //PH probably redundant + tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern); + tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes); GetStdContent(); + fOldMuonStructure = fESDObjects->TestBit(BIT(23)); fConnected = true; return; } @@ -1513,12 +1848,14 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ // in principle // we only need new things in the list if we do no already have it.. // TODO just add new entries + CompleteStdContent(); if(fESDObjects->GetEntries()GetEntries(),kESDListN)); } // set the branch addresses + fOldMuonStructure = kFALSE; TIter next(fESDObjects); TNamed *el; while((el=(TNamed*)next())){ @@ -1542,16 +1879,24 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ } else{ AliWarning(Form("AliESDEvent::ReadFromTree() No Branch found with Name %s or %s.",bname.Data(),bname.Data())); + if (bname == fgkESDListName[kMuonClusters]) { + fOldMuonStructure = kTRUE; + } } } } } + tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus); + tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern); + tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes); + GetStdContent(); // when reading back we are not owner of the list // must not delete it fESDObjects->SetOwner(kTRUE); fESDObjects->SetName("ESDObjectsConnectedToTree"); + fESDObjects->SetBit(BIT(23), fOldMuonStructure); // we are not owner of the list objects // must not delete it tree->GetUserInfo()->Add(fESDObjects); @@ -1562,6 +1907,7 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ // we can't get the list from the user data, create standard content // and set it by hand (no ESDfriend at the moment CreateStdContent(); + fOldMuonStructure = kFALSE; TIter next(fESDObjects); TNamed *el; while((el=(TNamed*)next())){ @@ -1575,8 +1921,15 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ if(br){ tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el)); } + else if (bname == fgkESDListName[kMuonClusters]) { + fOldMuonStructure = kTRUE; + } } } + tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus); + tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern); + tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes); + GetStdContent(); // when reading back we are not owner of the list // must not delete it @@ -1584,7 +1937,7 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ } } - +//______________________________________________________________________________ void AliESDEvent::CopyFromOldESD() { // Method which copies over everthing from the old esd structure to the @@ -1676,14 +2029,10 @@ void AliESDEvent::CopyFromOldESD() AddCaloCluster(fESDOld->GetCaloCluster(i)); } - #ifdef MFT_UPGRADE - // MFT -// if (fESDOld->GetMFTData()) SetMFTData(fESDOld->GetMFTData()); - #endif - }// if fesdold } +//______________________________________________________________________________ Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const { // Check if the event satisfies the trigger @@ -1691,12 +2040,13 @@ Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const // trigExpr can be any logical expression // of the trigger classes defined in AliESDRun // In case of wrong syntax return kTRUE. + // Modified by rl for 100 classes - to be tested TString expr(trigExpr); if (expr.IsNull()) return kTRUE; ULong64_t mask = GetTriggerMask(); - for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses; itrig++) { + for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses/2; itrig++) { if (mask & (1ull << itrig)) { expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"1"); } @@ -1704,6 +2054,15 @@ Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"0"); } } + ULong64_t maskNext50 = GetTriggerMaskNext50(); + for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses/2; itrig++) { + if (maskNext50 & (1ull << itrig)) { + expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig+50),"1"); + } + else { + expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig+50),"0"); + } + } Int_t error; if ((gROOT->ProcessLineFast(expr.Data(),&error) == 0) && @@ -1715,6 +2074,7 @@ Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const } +//______________________________________________________________________________ TObject* AliESDEvent::GetHLTTriggerDecision() const { // get the HLT trigger decission object @@ -1737,6 +2097,7 @@ TString AliESDEvent::GetHLTTriggerDescription() const return description; } +//______________________________________________________________________________ Bool_t AliESDEvent::IsHLTTriggerFired(const char* name) const { // get the HLT trigger decission description @@ -1816,6 +2177,9 @@ void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t // trITSSApure : using ITS standalone tracks + tracklets from clusters not used by tracks // if useDCAFlag is true: account for the ESDtrack flag marking the tracks with large DCA // if useV0Flag is true: account for the ESDtrack flag marking conversion and K0's V0s + + AliWarning("This obsolete method will be eliminated soon. Use AliESDtrackCuts::GetReferenceMultiplicity"); + tracklets = trITSSApure = trITSTPC = 0; int ntr = fSPDMult ? fSPDMult->GetNumberOfTracklets() : 0; // @@ -1831,6 +2195,7 @@ void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t ntr = GetNumberOfTracks(); for (int itr=ntr;itr--;) { AliESDtrack *t = GetTrack(itr); + if (!t) {AliFatal(Form("NULL pointer for ESD track %d",itr));} if (TMath::Abs(t->Eta())>eta) continue; if (!t->IsOn(AliESDtrack::kITSin)) continue; if (useDCAFlag && t->IsOn(AliESDtrack::kMultSec)) continue; @@ -1841,6 +2206,7 @@ void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t // } +//______________________________________________________________________________ Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const { Int_t nTracklets=GetMultiplicity()->GetNumberOfTracklets(); if(nTracklets<20) return IsPileupFromSPD(3,0.8); @@ -1848,6 +2214,7 @@ Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const { else return IsPileupFromSPD(5,0.8); } +//______________________________________________________________________________ void AliESDEvent::SetTOFHeader(const AliTOFHeader *header) { // @@ -1867,18 +2234,21 @@ void AliESDEvent::SetTOFHeader(const AliTOFHeader *header) } +//______________________________________________________________________________ AliCentrality* AliESDEvent::GetCentrality() { if (!fCentrality) fCentrality = new AliCentrality(); return fCentrality; } +//______________________________________________________________________________ AliEventplane* AliESDEvent::GetEventplane() { if (!fEventplane) fEventplane = new AliEventplane(); return fEventplane; } +//______________________________________________________________________________ Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const { // Get VZERO Multiplicity for channel i @@ -1896,3 +2266,194 @@ Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const return (fESDVZERO->GetMultiplicity(i)/factor); } + +//______________________________________________________________________________ +void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster,Int_t *mapping) +{ + // Reset TClonesArray of TOF clusters + if (!fESDTOFClusters) { + AliError("fESDTOFClusters is not initialized"); + return; + } + fESDTOFClusters->Clear(); + + Int_t goodhit[20000]; + if(mapping){ + for(Int_t i=0;i < 20000;i++){ + goodhit[i] = 0; + } + } + + for(Int_t i=0;i < ntofclusters;i++){ + + if(cluster[i].GetNMatchableTracks() || !mapping){ + if(mapping) + mapping[i] = fESDTOFClusters->GetEntriesFast(); + + // update TClonesArray + TClonesArray &ftr = *fESDTOFClusters; + AliESDTOFCluster *clusterTBW = new(ftr[fESDTOFClusters->GetEntriesFast()])AliESDTOFCluster(cluster[i]); + + if(mapping){ + // loop over hit in the cluster + for(Int_t k=0;k < clusterTBW->GetNTOFhits();k++){ + Int_t ipos = clusterTBW->GetHitIndex(k); + goodhit[ipos] = 1; // hit should be kept + } + } + } + } + + if(mapping){ + AliInfo(Form("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fESDTOFClusters->GetEntriesFast())); + Int_t hitnewpos[20000]={0}; + Int_t nhitOriginal = fESDTOFHits->GetEntries(); + for(Int_t i=0;i < fESDTOFHits->GetEntries();i++){ + if(goodhit[i]){ + hitnewpos[i] = i; + } + else{ // remove hit and decrease the hit array + TClonesArray &a=*fESDTOFHits; + Int_t lastpos = fESDTOFHits->GetEntries()-1; + + if(i == lastpos) + delete a.RemoveAt(i); + else{ + Int_t nhitBefore = fESDTOFHits->GetEntries(); + for(Int_t k=nhitBefore-1;k>i;k--){ // find the last good track + if(!goodhit[k]){ // remove track + delete a.RemoveAt(k); + if(k-i==1) delete a.RemoveAt(i); + } + else{ // replace last one to the "i" + AliESDTOFHit *last = (AliESDTOFHit *) fESDTOFHits->At(k); + delete a.RemoveAt(i); + new (a[i]) AliESDTOFHit(*last); + delete a.RemoveAt(k); + hitnewpos[k] = i; + k = 0; + } + } + } + } + } + + // remap cluster to hits + for(Int_t i=0;i < fESDTOFClusters->GetEntries();i++){ + AliESDTOFCluster *cl = (AliESDTOFCluster *) fESDTOFClusters->At(i); + // loop over hit in the cluster + for(Int_t k=0;k < cl->GetNTOFhits();k++){ + cl->SetHitIndex(k,hitnewpos[cl->GetHitIndex(k)]); + } + } + AliInfo(Form("TOF hit before of matching = %i , after = %i\n",nhitOriginal,fESDTOFHits->GetEntriesFast())); + } // end mapping + +} + +//______________________________________________________________________________ +void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster[],Int_t *mapping) +{ + // Reset TClonesArray of TOF clusters + if(fESDTOFClusters)fESDTOFClusters->Delete(); + + Int_t goodhit[20000]; + if(mapping){ + for(Int_t i=0;i < 20000;i++){ + goodhit[i] = 0; + } + } + + for(Int_t i=0;i < ntofclusters;i++){ + + if(cluster[i]->GetNMatchableTracks() || !mapping){ + if(mapping) + mapping[i] = fESDTOFClusters->GetEntriesFast(); + + // update TClonesArray + TClonesArray &ftr = *fESDTOFClusters; + AliESDTOFCluster *clusterTBW = new(ftr[fESDTOFClusters->GetEntriesFast()])AliESDTOFCluster(*(cluster[i])); + + if(mapping){ + // loop over hit in the cluster + for(Int_t k=0;k < clusterTBW->GetNTOFhits();k++){ + Int_t ipos = clusterTBW->GetHitIndex(k); + goodhit[ipos] = 1; // hit should be kept + } + } + } + } + + if(mapping){ + AliInfo(Form("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fESDTOFClusters->GetEntriesFast())); + Int_t hitnewpos[20000]={0}; + Int_t nhitOriginal = fESDTOFHits->GetEntries(); + for(Int_t i=0;i < fESDTOFHits->GetEntries();i++){ + if(goodhit[i]){ + hitnewpos[i] = i; + } + else{ // remove hit and decrease the hit array + TClonesArray &a=*fESDTOFHits; + Int_t lastpos = fESDTOFHits->GetEntries()-1; + + if(i == lastpos) + delete a.RemoveAt(i); + else{ + Int_t nhitBefore = fESDTOFHits->GetEntries(); + for(Int_t k=nhitBefore-1;k>i;k--){ // find the last good track + if(!goodhit[k]){ // remove track + delete a.RemoveAt(k); + if(k-i==1) delete a.RemoveAt(i); + } + else{ // replace last one to the "i" + AliESDTOFHit *last = (AliESDTOFHit *) fESDTOFHits->At(k); + delete a.RemoveAt(i); + new (a[i]) AliESDTOFHit(*last); + delete a.RemoveAt(k); + hitnewpos[k] = i; + k = 0; + } + } + } + } + } + + // remap cluster to hits + for(Int_t i=0;i < fESDTOFClusters->GetEntries();i++){ + AliESDTOFCluster *cl = (AliESDTOFCluster *) fESDTOFClusters->At(i); + // loop over hit in the cluster + for(Int_t k=0;k < cl->GetNTOFhits();k++){ + cl->SetHitIndex(k,hitnewpos[cl->GetHitIndex(k)]); + } + } + AliInfo(Form("TOF hit before of matching = %i , after = %i\n",nhitOriginal,fESDTOFHits->GetEntriesFast())); + } // end mapping + +} + +//______________________________________________________________________________ +void AliESDEvent::ConnectTracks() { +// Connect tracks to this event + if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return; + AliESDtrack *track; + TIter next(fTracks); + while ((track=(AliESDtrack*)next())) track->SetESDEvent(this); + // + // The same for TOF clusters + if (fESDTOFClusters) { + AliESDTOFCluster *clus; + TIter nextTOF(fESDTOFClusters); + while ((clus=(AliESDTOFCluster*)nextTOF())) clus->SetEvent((AliVEvent *) this); + } + fTracksConnected = kTRUE; + // +} + +//______________________________________________________________________________ +AliESDfriend* AliESDEvent::FindFriend() const +{ + return static_cast(FindListObject("AliESDfriend")); +} + +AliVEvent::EDataLayoutType AliESDEvent::GetDataLayoutType() const {return AliVEvent::kESD;} +