#include "TList.h"
#include "TRefArray.h"
#include <TNamed.h>
+#include <TROOT.h>
+#include <TInterpreter.h>
#include "AliESDEvent.h"
#include "AliESDfriend.h"
#include "AliRawDataErrorLog.h"
#include "AliLog.h"
#include "AliESDACORDE.h"
+#include "AliESDHLTDecision.h"
+
ClassImp(AliESDEvent)
fESDOld(0),
fESDFriendOld(0),
fConnected(kFALSE),
- fUseOwnList(kFALSE),
- fEMCALClusters(0),
- fFirstEMCALCluster(-1),
- fPHOSClusters(0),
- fFirstPHOSCluster(-1)
+ fUseOwnList(kFALSE)
{
}
//______________________________________________________________________________
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 ...
fConnected = source.fConnected;
fUseOwnList = source.fUseOwnList;
- fEMCALClusters = source.fEMCALClusters;
- fFirstEMCALCluster = source.fFirstEMCALCluster;
- fPHOSClusters = source.fPHOSClusters;
- fFirstPHOSCluster = source.fFirstPHOSCluster;
-
return *this;
// don't reset fconnected fConnected and the list
- fEMCALClusters=0;
- fFirstEMCALCluster=-1;
- fPHOSClusters=0;
- fFirstPHOSCluster=-1;
}
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());
+ GetNumberOfPileupVerticesSPD());
printf("Number of pileup primary vertices reconstructed using the tracks %d\n",
- GetNumberOfPileupVerticesTracks());
+ GetNumberOfPileupVerticesTracks());
printf("Number of tracks: \n");
printf(" charged %d\n", GetNumberOfTracks());
printf(" muon %d\n", GetNumberOfMuonTracks());
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;
}
GetStdContent();
}
-TObject* AliESDEvent::FindListObject(const char *name){
+TObject* AliESDEvent::FindListObject(const char *name) const {
//
// Find object with name "name" in the list of branches
//
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);
}
}
}
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;
esdEvent = (AliESDEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliESDEvent");
if(esdEvent){
// Check if already connected to tree
+ esdEvent->Reset();
TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("ESDObjectsConnectedToTree"));
// Connect to tree
// prevent a memory leak when reading back the TList
- if (!(strcmp(opt, "reconnect"))) fESDObjects->Delete();
+ // 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
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
GetStdContent();
// when reading back we are not owner of the list
// must not delete it
- fESDObjects->SetOwner(kFALSE);
+ fESDObjects->SetOwner(kTRUE);
}
}
}// 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
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; i<nPileVert;i++){
+ const AliESDVertex* pv=GetPileupVertexSPD(i);
+ Double_t z2=pv->GetZ();
+ 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 && distanceX<nSigmaXY*errxDist && distanceY<nSigmaXY*erryDist && distanceZ>distz)
+
+ 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++;
+ }
+ //
+}