X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliESDEvent.cxx;h=4f8f55e05bf1d8623a796461780557a4dd3613f3;hb=29e40e095caa7a82588c067c774b46914c910749;hp=82a5d6d1d888eaf8d36e097225ce9837b5020bac;hpb=fe25f014bdd5b2c2feca6549a5a435c5b9739a66;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliESDEvent.cxx b/STEER/AliESDEvent.cxx index 82a5d6d1d88..4f8f55e05bf 100644 --- a/STEER/AliESDEvent.cxx +++ b/STEER/AliESDEvent.cxx @@ -35,6 +35,8 @@ #include "TList.h" #include "TRefArray.h" #include +#include +#include #include "AliESDEvent.h" #include "AliESDfriend.h" @@ -49,6 +51,7 @@ #include "AliESDPmdTrack.h" #include "AliESDTrdTrack.h" #include "AliESDVertex.h" +#include "AliVertexerTracks.h" #include "AliESDcascade.h" #include "AliESDkink.h" #include "AliESDtrack.h" @@ -62,6 +65,8 @@ #include "AliRawDataErrorLog.h" #include "AliLog.h" #include "AliESDACORDE.h" +#include "AliESDHLTDecision.h" + ClassImp(AliESDEvent) @@ -80,6 +85,8 @@ ClassImp(AliESDEvent) "AliMultiplicity", "PHOSTrigger", "EMCALTrigger", + "SPDPileupVertices", + "TrkPileupVertices", "Tracks", "MuonTracks", "PmdTracks", @@ -110,6 +117,8 @@ AliESDEvent::AliESDEvent(): fPHOSTrigger(0), fEMCALTrigger(0), fESDACORDE(0), + fSPDPileupVertices(0), + fTrkPileupVertices(0), fTracks(0), fMuonTracks(0), fPmdTracks(0), @@ -123,11 +132,7 @@ AliESDEvent::AliESDEvent(): fESDOld(0), fESDFriendOld(0), fConnected(kFALSE), - fUseOwnList(kFALSE), - fEMCALClusters(0), - fFirstEMCALCluster(-1), - fPHOSClusters(0), - fFirstPHOSCluster(-1) + fUseOwnList(kFALSE) { } //______________________________________________________________________________ @@ -147,6 +152,8 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)), fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)), fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)), + fSPDPileupVertices(new TClonesArray(*esd.fSPDPileupVertices)), + fTrkPileupVertices(new TClonesArray(*esd.fTrkPileupVertices)), fTracks(new TClonesArray(*esd.fTracks)), fMuonTracks(new TClonesArray(*esd.fMuonTracks)), fPmdTracks(new TClonesArray(*esd.fPmdTracks)), @@ -158,14 +165,10 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)), fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)), fErrorLogs(new TClonesArray(*esd.fErrorLogs)), - fESDOld(new AliESD(*esd.fESDOld)), - fESDFriendOld(new AliESDfriend(*esd.fESDFriendOld)), + fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0), + fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0), fConnected(esd.fConnected), - fUseOwnList(esd.fUseOwnList), - fEMCALClusters(esd.fEMCALClusters), - fFirstEMCALCluster(esd.fFirstEMCALCluster), - fPHOSClusters(esd.fPHOSClusters), - fFirstPHOSCluster(esd.fFirstPHOSCluster) + fUseOwnList(esd.fUseOwnList) { // CKB init in the constructor list and only add here ... @@ -181,6 +184,8 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd): AddObject(fSPDMult); AddObject(fPHOSTrigger); AddObject(fEMCALTrigger); + AddObject(fSPDPileupVertices); + AddObject(fTrkPileupVertices); AddObject(fTracks); AddObject(fMuonTracks); AddObject(fPmdTracks); @@ -284,11 +289,6 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) { fConnected = source.fConnected; fUseOwnList = source.fUseOwnList; - fEMCALClusters = source.fEMCALClusters; - fFirstEMCALCluster = source.fFirstEMCALCluster; - fPHOSClusters = source.fPHOSClusters; - fFirstPHOSCluster = source.fFirstPHOSCluster; - return *this; @@ -419,6 +419,8 @@ void AliESDEvent::ResetStdContent() } if(fPHOSTrigger)fPHOSTrigger->Reset(); if(fEMCALTrigger)fEMCALTrigger->Reset(); + if(fSPDPileupVertices)fSPDPileupVertices->Delete(); + if(fTrkPileupVertices)fTrkPileupVertices->Delete(); if(fTracks)fTracks->Delete(); if(fMuonTracks)fMuonTracks->Delete(); if(fPmdTracks)fPmdTracks->Delete(); @@ -433,10 +435,6 @@ void AliESDEvent::ResetStdContent() // don't reset fconnected fConnected and the list - fEMCALClusters=0; - fFirstEMCALCluster=-1; - fPHOSClusters=0; - fFirstPHOSCluster=-1; } @@ -465,14 +463,20 @@ void AliESDEvent::Print(Option_t *) const GetRunNumber(), GetTriggerMask(), GetMagneticField() ); - printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n", + if (fPrimaryVertex) + printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n", 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("Mean vertex in RUN: X=%.4f Y=%.4f Z=%.4f cm\n", + GetDiamondX(),GetDiamondY(),GetDiamondZ()); + if(fSPDMult) printf("SPD Multiplicity. Number of tracklets %d \n", fSPDMult->GetNumberOfTracklets()); + printf("Number of pileup primary vertices reconstructed with SPD %d\n", + GetNumberOfPileupVerticesSPD()); + printf("Number of pileup primary vertices reconstructed using the tracks %d\n", + GetNumberOfPileupVerticesTracks()); printf("Number of tracks: \n"); printf(" charged %d\n", GetNumberOfTracks()); printf(" muon %d\n", GetNumberOfMuonTracks()); @@ -486,10 +490,11 @@ void AliESDEvent::Print(Option_t *) const if(fEMCALCells)printf(" EMCALCells %d\n", fEMCALCells->GetNumberOfCells()); else printf(" EMCALCells not in the Event\n"); printf(" CaloClusters %d\n", GetNumberOfCaloClusters()); - printf(" phos %d\n", GetNumberOfPHOSClusters()); - printf(" emcal %d\n", GetNumberOfEMCALClusters()); printf(" FMD %s\n", (fESDFMD ? "yes" : "no")); printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no")); + TObject* pHLTDecision=GetHLTTriggerDecision(); + printf("HLT trigger decision: %s\n", pHLTDecision?pHLTDecision->GetOption():"not available"); + if (pHLTDecision) pHLTDecision->Print("compact"); return; } @@ -639,6 +644,15 @@ Bool_t AliESDEvent::RemoveTrack(Int_t rm) const { Int_t idx=cs->GetIndex(); if (rm==idx) return kFALSE; if (idx==last) used++; + + AliESDv0 *v0=cs; + 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 nkn=GetNumberOfKinks(); @@ -654,6 +668,20 @@ Bool_t AliESDEvent::RemoveTrack(Int_t rm) const { if (idx==last) used++; } + // Check if this track is associated with a CaloCluster + Int_t ncl=GetNumberOfCaloClusters(); + for (Int_t n=0; nGetTracksMatched(); + Int_t s=arr->GetSize(); + while (s--) { + Int_t idx=arr->At(s); + if (rm==idx) return kFALSE; + if (idx==last) used++; + } + } + + //Replace the removed track with the last track TClonesArray &a=*fTracks; @@ -718,6 +746,17 @@ Bool_t AliESDEvent::RemoveTrack(Int_t rm) const { used--; if (!used) return kTRUE; } + AliESDv0 *v0=cs; + 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; nGetTracksMatched(); + Int_t s=arr->GetSize(); + while (s--) { + Int_t idx=arr->At(s); + if (idx==last) { + arr->AddAt(rm,s); + used--; + if (!used) return kTRUE; + } + } + } + return kTRUE; } @@ -801,6 +855,26 @@ Bool_t AliESDEvent::Clean(Float_t *cleanPars) { return rc; } +Char_t AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx) +{ + // Add a pileup primary vertex reconstructed with SPD + TClonesArray &ftr = *fSPDPileupVertices; + Char_t n=Char_t(ftr.GetEntriesFast()); + AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx); + vertex->SetID(n); + return n; +} + +Char_t AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx) +{ + // Add a pileup primary vertex reconstructed with SPD + TClonesArray &ftr = *fTrkPileupVertices; + Char_t n=Char_t(ftr.GetEntriesFast()); + AliESDVertex *vertex = new(ftr[n]) AliESDVertex(*vtx); + vertex->SetID(n); + return n; +} + Int_t AliESDEvent::AddTrack(const AliESDtrack *t) { // Add track @@ -910,6 +984,31 @@ const AliESDVertex * AliESDEvent::GetPrimaryVertex() const return fSPDVertex; } +AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const +{ + // + // Removes diamond constraint from fPrimaryVertex (reconstructed with tracks) + // Returns a AliESDVertex which has to be deleted by the user + // + if(!fPrimaryVertex) { + AliWarning("No primary vertex from tracks available."); + return 0; + } + if(!fPrimaryVertex->GetStatus()) { + AliWarning("No primary vertex from tracks available."); + return 0; + } + + AliVertexerTracks vertexer(GetMagneticField()); + Float_t diamondxyz[3]={(Float_t)GetDiamondX(),(Float_t)GetDiamondY(),0.}; + Float_t diamondcovxy[3]; GetDiamondCovXY(diamondcovxy); + Float_t diamondcov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,7.}; + AliESDVertex *vertex = + (AliESDVertex*)vertexer.RemoveConstraintFromVertex(fPrimaryVertex,diamondxyz,diamondcov); + + return vertex; +} + void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) { // Set the SPD Multiplicity @@ -990,6 +1089,8 @@ void AliESDEvent::GetStdContent() fSPDMult = (AliMultiplicity*)fESDObjects->FindObject(fgkESDListName[kSPDMult]); fPHOSTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kPHOSTrigger]); fEMCALTrigger = (AliESDCaloTrigger*)fESDObjects->FindObject(fgkESDListName[kEMCALTrigger]); + fSPDPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kSPDPileupVertices]); + fTrkPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrkPileupVertices]); fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]); fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]); fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]); @@ -1047,6 +1148,8 @@ void AliESDEvent::CreateStdContent() AddObject(new AliMultiplicity()); AddObject(new AliESDCaloTrigger()); AddObject(new AliESDCaloTrigger()); + AddObject(new TClonesArray("AliESDVertex",0)); + AddObject(new TClonesArray("AliESDVertex",0)); AddObject(new TClonesArray("AliESDtrack",0)); AddObject(new TClonesArray("AliESDMuonTrack",0)); AddObject(new TClonesArray("AliESDPmdTrack",0)); @@ -1068,7 +1171,7 @@ void AliESDEvent::CreateStdContent() GetStdContent(); } -TObject* AliESDEvent::FindListObject(const char *name){ +TObject* AliESDEvent::FindListObject(const char *name) const { // // Find object with name "name" in the list of branches // @@ -1130,18 +1233,21 @@ void AliESDEvent::WriteToTree(TTree* tree) const { while ((obj = next())) { branchname.Form("%s", obj->GetName()); + if(branchname.CompareTo("AliESDfriend")==0)branchname = "ESDfriend."; if ((kSplitlevel > 1) && !obj->InheritsFrom(TClonesArray::Class())) { if(!branchname.EndsWith("."))branchname += "."; } if (!tree->FindBranch(branchname)) { - tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj), - kBufsize, kSplitlevel - 1); + // For the custom streamer to be called splitlevel + // has to be negative, only needed for HLT + Int_t splitLevel = (TString(obj->ClassName()) == "AliHLTGlobalTriggerDecision") ? -1 : kSplitlevel - 1; + tree->Bronch(branchname, obj->ClassName(), fESDObjects->GetObjectRef(obj),kBufsize, splitLevel); } } } -void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){ +void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){ // // Connect the ESDEvent to a tree // @@ -1213,7 +1319,7 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){ if(fESDFriendOld)AddObject(fESDFriendOld); // we are not owner of the list objects // must not delete it - fESDObjects->SetOwner(kFALSE); + fESDObjects->SetOwner(kTRUE); fESDObjects->SetName("ESDObjectsConnectedToTree"); tree->GetUserInfo()->Add(fESDObjects); fConnected = true; @@ -1228,8 +1334,11 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){ esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent"); if(esdEvent){ // Check if already connected to tree + esdEvent->Reset(); TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree")); - if (connectedList) { + + + if (connectedList && (strcmp(opt, "reconnect"))) { // If connected use the connected list if objects fESDObjects->Delete(); fESDObjects = connectedList; @@ -1240,14 +1349,13 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){ // Connect to tree // prevent a memory leak when reading back the TList - + // if (!(strcmp(opt, "reconnect"))) fESDObjects->Delete(); + if(!fUseOwnList){ - delete fESDObjects; - fESDObjects = 0; // create a new TList from the UserInfo TList... // copy constructor does not work... fESDObjects = (TList*)(esdEvent->GetList()->Clone()); - fESDObjects->SetOwner(kFALSE); + fESDObjects->SetOwner(kTRUE); } else if ( fESDObjects->GetEntries()==0){ // at least create the std content if we want to read to our list @@ -1293,13 +1401,14 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){ GetStdContent(); // when reading back we are not owner of the list // must not delete it - fESDObjects->SetOwner(kFALSE); + fESDObjects->SetOwner(kTRUE); fESDObjects->SetName("ESDObjectsConnectedToTree"); // we are not owner of the list objects // must not delete it tree->GetUserInfo()->Add(fESDObjects); + tree->GetUserInfo()->SetOwner(kFALSE); fConnected = true; - }// no esdEvent + }// no esdEvent --> else { // we can't get the list from the user data, create standard content // and set it by hand (no ESDfriend at the moment @@ -1322,7 +1431,7 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* /*opt*/){ GetStdContent(); // when reading back we are not owner of the list // must not delete it - fESDObjects->SetOwner(kFALSE); + fESDObjects->SetOwner(kTRUE); } } @@ -1359,6 +1468,11 @@ void AliESDEvent::CopyFromOldESD() fESDOld->GetZDCN2Energy(), fESDOld->GetZDCP2Energy(), fESDOld->GetZDCParticipants(), + 0, + 0, + 0, + 0, + 0, 0); // FMD @@ -1416,5 +1530,169 @@ void AliESDEvent::CopyFromOldESD() }// if fesdold } +Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const +{ + // Check if the event satisfies the trigger + // selection expression trigExpr. + // trigExpr can be any logical expression + // of the trigger classes defined in AliESDRun + // In case of wrong syntax return kTRUE. + + TString expr(trigExpr); + if (expr.IsNull()) return kTRUE; + + ULong64_t mask = GetTriggerMask(); + for(Int_t itrig = 0; itrig < AliESDRun::kNTriggerClasses; itrig++) { + if (mask & (1ull << itrig)) { + expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"1"); + } + else { + expr.ReplaceAll(GetESDRun()->GetTriggerClass(itrig),"0"); + } + } + + Int_t error; + if ((gROOT->ProcessLineFast(expr.Data(),&error) == 0) && + (error == TInterpreter::kNoError)) { + return kFALSE; + } + + return kTRUE; + +} + +TObject* AliESDEvent::GetHLTTriggerDecision() const +{ + // get the HLT trigger decission object + + // cast away const'nes because the FindListObject method + // is not const + AliESDEvent* pNonConst=const_cast(this); + return pNonConst->FindListObject("HLTGlobalTrigger"); +} + +TString AliESDEvent::GetHLTTriggerDescription() const +{ + // get the HLT trigger decission description + TString description; + TObject* pDecision=GetHLTTriggerDecision(); + if (pDecision) { + description=pDecision->GetTitle(); + } + return description; +} +Bool_t AliESDEvent::IsHLTTriggerFired(const char* name) const +{ + // get the HLT trigger decission description + TObject* pDecision=GetHLTTriggerDecision(); + if (!pDecision) return kFALSE; + + Option_t* option=pDecision->GetOption(); + if (option==NULL || *option!='1') return kFALSE; + + if (name) { + TString description=GetHLTTriggerDescription(); + Int_t index=description.Index(name); + if (index<0) return kFALSE; + index+=strlen(name); + if (index>=description.Length()) return kFALSE; + if (description[index]!=0 && description[index]!=' ') return kFALSE; + } + return kTRUE; +} + +Bool_t AliESDEvent::IsPileupFromSPD(Int_t ncont, Double_t distz, Double_t nSigmaDeltaZ, Double_t nSigmaXY, Int_t option) const { + // + // This function checks if there was a pile up + // reconstructed with SPD + // + Double_t diamx= GetDiamondX(); + Double_t diamsigma2x= GetSigma2DiamondX(); + Double_t diamy= GetDiamondY(); + Double_t diamsigma2y= GetSigma2DiamondY(); + + Double_t sigmax= TMath::Sqrt(diamsigma2x); + Double_t sigmay= TMath::Sqrt(diamsigma2y); + + Double_t z1=fSPDVertex->GetZ(); + Int_t nc1=fSPDVertex->GetNContributors(); + if(nc1<1) return kFALSE; + Int_t nPileVert=GetNumberOfPileupVerticesSPD(); + if(nPileVert==0) return kFALSE; + for(Int_t i=0; iGetZ(); + Double_t x2=pv->GetX(); + Double_t y2=pv->GetY(); + Int_t nc2=pv->GetNContributors(); + Double_t distanceZ=TMath::Abs(z2-z1); + Double_t distanceX=TMath::Abs(x2-diamx); + Double_t distanceY=TMath::Abs(y2-diamy); + Double_t errzDist=0.; + Double_t errxDist=0.; + Double_t erryDist=0.; + if(option==0){ + Double_t ez1=fSPDVertex->GetZRes(); + Double_t ez2=pv->GetZRes(); + errzDist=TMath::Sqrt(ez1*ez1+ez2*ez2); + }else{ + Double_t resol1=-75.6+834.6/TMath::Sqrt((Double_t)nc1); + resol1/=10000.; + Double_t resol2=-75.6+834.6/TMath::Sqrt((Double_t)nc2); + resol2/=10000.; + errzDist=TMath::Sqrt(resol1*resol1+resol2*resol2); + } + + + Double_t ex2 = pv->GetXRes(); + Double_t ey2= pv->GetYRes(); + errxDist=TMath::Sqrt(ex2*ex2+sigmax*sigmax); + erryDist=TMath::Sqrt(ey2*ey2+sigmay*sigmay); + + if(nc2>=ncont && distanceZ>nSigmaDeltaZ*errzDist && distanceXdistz) + + return kTRUE; + } + + + + return kFALSE; + } + + +//______________________________________________________________________________ +void AliESDEvent::EstimateMultiplicity(Int_t &tracklets, Int_t &trITSTPC, Int_t &trITSSApure, Double_t eta, Bool_t useDCAFlag,Bool_t useV0Flag) const +{ + // + // calculates 3 estimators for the multiplicity in the -eta:eta range + // tracklets : using SPD tracklets only + // trITSTPC : using TPC/ITS + complementary ITS SA tracks + tracklets from clusters not used by tracks + // 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 + tracklets = trITSSApure = trITSTPC = 0; + int ntr = fSPDMult ? fSPDMult->GetNumberOfTracklets() : 0; + // + // count tracklets + for (int itr=ntr;itr--;) { + if (TMath::Abs(fSPDMult->GetEta(itr))>eta) continue; + tracklets++; + if (fSPDMult->FreeClustersTracklet(itr,0)) trITSTPC++; // not used in ITS/TPC or ITS_SA track + if (fSPDMult->FreeClustersTracklet(itr,1)) trITSSApure++; // not used in ITS_SA_Pure track + } + // + // count real tracks + ntr = GetNumberOfTracks(); + for (int itr=ntr;itr--;) { + AliESDtrack *t = GetTrack(itr); + if (TMath::Abs(t->Eta())>eta) continue; + if (!t->IsOn(AliESDtrack::kITSin)) continue; + if (useDCAFlag && t->IsOn(AliESDtrack::kMultSec)) continue; + if (useV0Flag && t->IsOn(AliESDtrack::kMultInV0)) continue; + if (t->IsOn(AliESDtrack::kITSpureSA)) trITSSApure++; + else trITSTPC++; + } + // +}