#pragma link C++ class AliRsnAnalysisPhi900GeV+;
#pragma link C++ class AliRsnAnalysisPhi7TeV+;
+#pragma link C++ class AliRsnMonitorTrack+;
+#pragma link C++ class AliRsnAnalysisMonitorTask+;
+
#endif
--- /dev/null
+//
+// Implementation file for implementation of data analysis aft 900 GeV
+//
+// Author: A. Pulvirenti
+//
+
+#include "Riostream.h"
+#include <iomanip>
+
+#include "TH1.h"
+#include "TTree.h"
+#include "TParticle.h"
+#include "TRandom.h"
+#include "TLorentzVector.h"
+
+#include "AliLog.h"
+#include "AliESDpid.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+#include "AliESDtrack.h"
+#include "AliStack.h"
+#include "AliMCEvent.h"
+#include "AliTOFT0maker.h"
+#include "AliTOFcalib.h"
+#include "AliCDBManager.h"
+#include "AliITSPIDResponse.h"
+#include "AliRsnMonitorTrack.h"
+
+#include "AliRsnAnalysisMonitorTask.h"
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const char *name) :
+ AliAnalysisTaskSE(name),
+ fEventType(2),
+ fNTracks(0),
+ fOut(0x0),
+ fTracks(0x0),
+ fMaxITSband(1E6),
+ fTPCpLimit(0.35),
+ fLargeTPCband(-1E6),
+ fSmallTPCband( 1E6),
+ fESDtrackCutsTPC(),
+ fESDtrackCutsITS(),
+ fESDpid(0x0),
+ fTOFmaker(0x0),
+ fTOFcalib(0x0),
+ fTOFcalibrateESD(kFALSE),
+ fTOFcorrectTExp(kFALSE),
+ fTOFuseT0(kFALSE),
+ fTOFtuneMC(kFALSE),
+ fTOFresolution(0.0)
+
+{
+//
+// Constructor
+//
+
+ DefineOutput(1, TTree::Class());
+}
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitorTask& copy) :
+ AliAnalysisTaskSE(copy),
+ fEventType(2),
+ fNTracks(0),
+ fOut(0x0),
+ fTracks(0x0),
+ fMaxITSband(copy.fMaxITSband),
+ fTPCpLimit(copy.fTPCpLimit),
+ fLargeTPCband(copy.fLargeTPCband),
+ fSmallTPCband(copy.fSmallTPCband),
+ fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
+ fESDtrackCutsITS(copy.fESDtrackCutsITS),
+ fESDpid(0x0),
+ fTOFmaker(0x0),
+ fTOFcalib(0x0),
+ fTOFcalibrateESD(kFALSE),
+ fTOFcorrectTExp(kFALSE),
+ fTOFuseT0(kFALSE),
+ fTOFtuneMC(kFALSE),
+ fTOFresolution(0.0)
+{
+//
+// Copy constructor
+//
+}
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisMonitorTask& AliRsnAnalysisMonitorTask::operator=(const AliRsnAnalysisMonitorTask& copy)
+{
+//
+// Assignment operator
+//
+
+ fMaxITSband = copy.fMaxITSband;
+
+ fTPCpLimit = copy.fTPCpLimit;
+ fLargeTPCband = copy.fSmallTPCband;
+ fSmallTPCband = copy.fLargeTPCband;
+
+ fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
+ fESDtrackCutsITS = copy.fESDtrackCutsITS;
+
+ fTOFcalibrateESD = copy.fTOFcalibrateESD;
+ fTOFcorrectTExp = copy.fTOFcorrectTExp;
+ fTOFuseT0 = copy.fTOFuseT0;
+ fTOFtuneMC = copy.fTOFtuneMC;
+ fTOFresolution = copy.fTOFresolution;
+
+ return (*this);
+}
+
+//__________________________________________________________________________________________________
+AliRsnAnalysisMonitorTask::~AliRsnAnalysisMonitorTask()
+{
+//
+// Destructor
+//
+
+ if (fOut) delete fOut;
+ if (fESDpid) delete fESDpid;
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisMonitorTask::UserCreateOutputObjects()
+{
+//
+// Create the output data container
+//
+
+ // setup TPC response
+ fESDpid = new AliESDpid;
+ fESDpid->GetTPCResponse().SetBetheBlochParameters(fTPCpar[0], fTPCpar[1], fTPCpar[2], fTPCpar[3], fTPCpar[4]);
+
+ // setup TOF maker & calibration
+ fTOFcalib = new AliTOFcalib;
+ fTOFmaker = new AliTOFT0maker(fESDpid, fTOFcalib);
+ fTOFmaker->SetTimeResolution(fTOFresolution);
+
+ // initialize all the branch arrays
+ fTracks = new TClonesArray("AliRsnMonitorTrack", 0);
+
+ // create output tree
+ OpenFile(1);
+ fOut = new TTree("rsnMonitor", "Informations on single tracks for cut checking");
+
+ // link branches
+ fOut->Branch("ntracks", &fNTracks , "ntracks/I" );
+ fOut->Branch("evtype" , &fEventType , "evtype/I" );
+ fOut->Branch("vertex" , &fVertex , "vertex[3]/F");
+ fOut->Branch("tracks" , "TClonesArray", &fTracks );
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisMonitorTask::UserExec(Option_t *)
+{
+//
+// Main execution function.
+// Fills the fHEvents data member with the following legenda:
+// 0 -- event OK, prim vertex with tracks
+// 1 -- event OK, prim vertex with SPD
+// 2 -- event OK but vz large
+// 3 -- event bad
+//
+
+ static Int_t evNum = 0;
+ evNum++;
+
+ // retrieve ESD event and related stack (if available)
+ AliESDEvent *esd = dynamic_cast<AliESDEvent*>(fInputEvent);
+ AliStack *stack = (fMCEvent ? fMCEvent->Stack() : 0x0);
+
+ // check the event
+ EventEval(esd);
+
+ // if processable, then process it
+ if (fEventType == 0) ProcessESD(esd, esd->GetPrimaryVertexTracks(), stack);
+ else if (fEventType == 1) ProcessESD(esd, esd->GetPrimaryVertexSPD() , stack);
+ else
+ {
+ fTracks->Delete();
+ fTracks->Clear();
+ fNTracks = 0;
+ }
+
+ // add a new entry in the TTree
+ fOut->Fill();
+
+ // update histogram container
+ PostData(1, fOut);
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisMonitorTask::Terminate(Option_t *)
+{
+//
+// Terminate
+//
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisMonitorTask::EventEval(AliESDEvent *esd)
+{
+//
+// Checks if the event is good for analysis.
+// Sets the 'fEventType' flag to:
+// ---> 0 if a good primary vertex with tracks was found,
+// ---> 1 if a good SPD primary vertex was found
+// ---> 2 otherwise (event to be rejected)
+// In any case, adds an entry to the TTree, to keep trace of all events.
+//
+
+ // get number of tracks
+ fNTracks = esd->GetNumberOfTracks();
+
+ // get the best primary vertex:
+ // first try that with tracks, then the SPD one
+ const AliESDVertex *vTrk = esd->GetPrimaryVertexTracks();
+ const AliESDVertex *vSPD = esd->GetPrimaryVertexSPD();
+ if(vTrk->GetNContributors() > 0)
+ {
+ fVertex[0] = vTrk->GetXv();
+ fVertex[1] = vTrk->GetYv();
+ fVertex[2] = vTrk->GetZv();
+ fEventType = 0;
+ }
+ else if (vSPD->GetNContributors() > 0)
+ {
+ fVertex[0] = vSPD->GetXv();
+ fVertex[1] = vSPD->GetYv();
+ fVertex[2] = vSPD->GetZv();
+ fEventType = 1;
+ }
+ else
+ {
+ fNTracks = 0;
+ fEventType = 2;
+ }
+}
+
+//__________________________________________________________________________________________________
+void AliRsnAnalysisMonitorTask::ProcessESD
+(AliESDEvent *esd, const AliESDVertex *v, AliStack *stack)
+{
+//
+// Process the ESD container, to read all tracks and copy their useful values.
+// All info are stored into an AliRsnMonitorTrack object and saved into the
+// TClonesArray which is one of the branches of the output TTree.
+//
+
+ // clear array
+ fTracks->Delete();
+ fTracks->Clear();
+
+ // reject empty events
+ if (!fNTracks) return;
+
+ // ITS stuff #1
+ // create the response function and initialize it to MC or not
+ // depending if the AliStack object is there or not
+ Bool_t isMC = (stack != 0x0);
+ AliITSPIDResponse itsrsp(isMC);
+
+ // TOF stuff #1: init OCDB
+ Int_t run = esd->GetRunNumber();
+ AliCDBManager *cdb = AliCDBManager::Instance();
+ cdb->SetDefaultStorage("raw://");
+ cdb->SetRun(run);
+ // TOF stuff #2: init calibration
+ fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
+ fTOFcalib->Init();
+ // TOF stuff #3: calibrate
+ if (fTOFcalibrateESD) fTOFcalib->CalibrateESD(esd);
+ if (fTOFtuneMC) fTOFmaker->TuneForMC(esd);
+ if (fTOFuseT0)
+ {
+ fTOFmaker->ComputeT0TOF(esd);
+ fTOFmaker->ApplyT0TOF(esd);
+ fESDpid->MakePID(esd, kFALSE, 0.);
+ }
+ // TOF stuff #4: define fixed functions for compatibility range
+ Double_t a1 = 0.01, a2 = -0.03;
+ Double_t b1 = 0.25, b2 = 0.25;
+ Double_t c1 = 0.05, c2 = -0.03;
+ Double_t ymax, ymin;
+
+ // loop on all tracks
+ Int_t i, k, size, nITS;
+ Double_t tpcMaxNSigma, itsdedx[4], tofRef, tofRel;
+ Bool_t okTOF, okTrack, isTPC, isITSSA, matchedTOF;
+ UChar_t itsCluMap;
+ Float_t b[2], bCov[3];
+ AliRsnMonitorTrack mon;
+
+ for (i = 0; i < fNTracks; i++)
+ {
+ AliESDtrack *track = esd->GetTrack(i);
+
+ // skip NULL pointers, kink daughters and tracks which
+ // cannot be propagated to primary vertex
+ if (!track) continue;
+ if ((Int_t)track->GetKinkIndex(0) > 0) continue;
+ if (!track->RelateToVertex(v, esd->GetMagneticField(), kVeryBig)) continue;
+
+ // reset the output object
+ // 'usable' flag will need to be set to 'ok'
+ mon.Reset();
+
+ // copy general info
+ mon.Status() = (UInt_t)track->GetStatus();
+ mon.Length() = (Double_t)track->GetIntegratedLength();
+ mon.Charge() = (Int_t)track->Charge();
+ mon.PrecX() = (Double_t)track->Px();
+ mon.PrecY() = (Double_t)track->Py();
+ mon.PrecZ() = (Double_t)track->Pz();
+
+ // evaluate some flags from the status to decide what to do next in some points
+ isTPC = ((mon.Status() & AliESDtrack::kTPCin) != 0);
+ isITSSA = ((mon.Status() & AliESDtrack::kTPCin) == 0 && (mon.Status() & AliESDtrack::kITSrefit) != 0 && (mon.Status() & AliESDtrack::kITSpureSA) == 0 && (mon.Status() & AliESDtrack::kITSpid) != 0);
+ matchedTOF = ((mon.Status() & AliESDtrack::kTOFout) != 0 && (mon.Status() & AliESDtrack::kTIME) != 0);
+
+ // accept only tracks which are TPC+ITS or ITS standalone
+ if (!isTPC && !isITSSA) continue;
+
+ // set the track type in the output object
+ mon.ITSsa() = isITSSA;
+
+ // get DCA to primary vertex
+ track->GetImpactParameters(b, bCov);
+ mon.DCAr() = (Double_t)b[0];
+ mon.DCAz() = (Double_t)b[1];
+
+ // get ITS info
+ track->GetITSdEdxSamples(itsdedx);
+ mon.ITSchi2() = track->GetITSchi2();
+ mon.ITSsignal() = track->GetITSsignal();
+ mon.ITSnsigma() = itsrsp.GetNumberOfSigmas(mon.Prec(), mon.ITSsignal(), AliPID::kKaon, nITS, kTRUE);
+ for (k = 0; k < 6; k++)
+ {
+ mon.ITSmap(k) = track->HasPointOnITSLayer(k);
+ if (k < 4) mon.ITSdedx(k) = itsdedx[k];
+ }
+
+ // get TPC info
+ mon.TPCcount() = (Int_t)track->GetTPCclusters(0);
+ mon.TPCdedx() = (Double_t)track->GetTPCsignal();
+ mon.TPCchi2() = (Double_t)track->GetTPCchi2();
+ mon.TPCnsigma() = fESDpid->NumberOfSigmasTPC(track, AliPID::kKaon);
+ mon.PtpcX() = mon.PtpcY() = mon.PtpcZ() = 1E10;
+ if (track->GetInnerParam())
+ {
+ mon.PtpcX() = track->GetInnerParam()->Px();
+ mon.PtpcY() = track->GetInnerParam()->Py();
+ mon.PtpcZ() = track->GetInnerParam()->Pz();
+ for (k = 0; k < AliPID::kSPECIES; k++) mon.TPCref(k) = fESDpid->GetTPCResponse().GetExpectedSignal(mon.Ptpc(), (AliPID::EParticleType)k);
+ }
+
+ // get TOF info
+ Double_t time[10];
+ track->GetIntegratedTimes(time);
+ mon.TOFsignal() = (Double_t)track->GetTOFsignal();
+ for (k = 0; k < AliPID::kSPECIES; k++)
+ {
+ mon.TOFref(k) = time[k];
+ mon.TOFsigma(k) = (Double_t)fTOFmaker->GetExpectedSigma(mon.Prec(), time[k], AliPID::ParticleMass(k));
+ }
+
+ // if we are here, the track is usable
+ mon.SetUsable();
+
+ // now check the track against its cuts
+ // and update the flag related to it
+ // first, assume that cuts were passed
+ // and if they aren't, just update the flag accordingly
+ mon.CutsPassed() = kTRUE;
+ if (TMath::Abs(mon.DCAz()) > 3.0) mon.CutsPassed() = kFALSE;
+
+ if (isTPC)
+ {
+ // check standard ESD cuts
+ if (!fESDtrackCutsTPC.IsSelected(track)) mon.CutsPassed() = kFALSE;
+
+ // check TPC dE/dx
+ if (mon.Ptpc() > fTPCpLimit) tpcMaxNSigma = fSmallTPCband; else tpcMaxNSigma = fLargeTPCband;
+ if (TMath::Abs(mon.TPCnsigma()) > tpcMaxNSigma) mon.CutsPassed() = kFALSE;
+
+ // check TOF (only if momentum is large than function asymptote and flags are OK)
+ okTOF = kTRUE;
+ if (matchedTOF && mon.Prec() > TMath::Max(b1, b2))
+ {
+ tofRef = mon.TOFref(AliPID::kKaon);
+ if (tofRef > 0.0)
+ {
+ tofRel = (mon.TOFsignal() - tofRef) / tofRef;
+ ymax = a1 / (mon.Prec() - b1) + c1;
+ ymin = a2 / (mon.Prec() - b2) + c2;
+ okTOF = (tofRel >= ymin && tofRel <= ymax);
+ }
+ }
+ if (!okTOF) mon.CutsPassed() = kFALSE;
+ }
+ else
+ {
+ // check standard ESD cuts
+ if (!fESDtrackCutsITS.IsSelected(track)) mon.CutsPassed() = kFALSE;
+
+ // check dE/dx
+ itsCluMap = track->GetITSClusterMap();
+ nITS = 0;
+ for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
+ if (nITS < 3) okTrack = kFALSE; // track not good for PID
+ if (TMath::Abs(mon.ITSnsigma()) > fMaxITSband) mon.CutsPassed() = kFALSE;
+ }
+
+ // collect only tracks which are declared usable
+ if (mon.IsUsable())
+ {
+ size = (Int_t)fTracks->GetEntriesFast();
+ new ((*fTracks)[size]) AliRsnMonitorTrack(mon);
+ }
+ }
+}
--- /dev/null
+//
+// Header file for implementation of data analysis aft 900 GeV
+//
+// Author: A. Pulvirenti
+//
+
+#ifndef ALIRSNANALYSISMONITORTASK_H
+#define ALIRSNANALYSISMONITORTASK_H
+
+#include "AliAnalysisTaskSE.h"
+#include "AliESDtrackCuts.h"
+
+class TH1I;
+class TH1F;
+class TTree;
+
+class AliStack;
+class AliESDEvent;
+class AliESDVertex;
+class AliESDpid;
+class AliTOFT0maker;
+class AliTOFcalib;
+
+class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE
+{
+ public:
+
+ AliRsnAnalysisMonitorTask(const char *name = "Phi7TeV");
+ AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitorTask& copy);
+ AliRsnAnalysisMonitorTask& operator=(const AliRsnAnalysisMonitorTask& copy);
+ virtual ~AliRsnAnalysisMonitorTask();
+
+ void SetITSband(Double_t v) {fMaxITSband = v;}
+
+ void SetTPClargeBandLimit(Double_t v) {fTPCpLimit = v;}
+ void SetTPCbands(Double_t min, Double_t max) {fLargeTPCband = min; fSmallTPCband = max;}
+ void SetTPCpar(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4)
+ {fTPCpar[0]=p0;fTPCpar[1]=p1;fTPCpar[2]=p2;fTPCpar[3]=p3;fTPCpar[4]=p4;}
+
+ void SetTOFcalibrateESD(Bool_t yn = kTRUE) {fTOFcalibrateESD = yn;}
+ void SetTOFcorrectTExp (Bool_t yn = kTRUE) {fTOFcorrectTExp = yn;}
+ void SetTOFuseT0 (Bool_t yn = kTRUE) {fTOFuseT0 = yn;}
+ void SetTOFtuneMC (Bool_t yn = kTRUE) {fTOFtuneMC = yn;}
+ void SetTOFresolution (Double_t v = 100.0) {fTOFresolution = v;}
+
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *option = "");
+ virtual void Terminate(Option_t *option = "");
+
+ void EventEval(AliESDEvent *esd);
+ Bool_t IsTPCtrack(AliESDtrack *track);
+ Bool_t IsITSSAtrack(AliESDtrack *track);
+ AliESDtrackCuts& GetCutsTPC() {return fESDtrackCutsTPC;}
+ AliESDtrackCuts& GetCutsITS() {return fESDtrackCutsITS;}
+ void ProcessESD(AliESDEvent *esd, const AliESDVertex *v, AliStack *stack);
+
+ private:
+
+ Int_t fEventType; // event classification (0 = vertex with tracks, 1 = vertex with SPD, 2 = bad vertex)
+ Double_t fVertex[3]; // primary vertex position
+ Int_t fNTracks; // counter for tracks
+
+ TTree *fOut; // output TTree
+ TClonesArray *fTracks; // array of data from tracks
+
+ Double_t fMaxITSband; // range for ITS de/dx band
+ Double_t fTPCpLimit; // limit to choose what band to apply
+ Double_t fTPCpar[5]; // parameters for TPC bethe-Bloch
+ Double_t fLargeTPCband; // range for TPC de/dx band - min
+ Double_t fSmallTPCband; // range for TPC de/dx band - max
+
+ AliESDtrackCuts fESDtrackCutsTPC; // ESD standard defined track cuts for TPC tracks
+ AliESDtrackCuts fESDtrackCutsITS; // ESD standard defined track cuts for ITS-SA tracks
+ AliESDpid *fESDpid; //! PID manager
+
+ AliTOFT0maker *fTOFmaker; //! TOF time0 computator
+ AliTOFcalib *fTOFcalib; //! TOF calibration
+ Bool_t fTOFcalibrateESD; // TOF settings
+ Bool_t fTOFcorrectTExp; // TOF settings
+ Bool_t fTOFuseT0; // TOF settings
+ Bool_t fTOFtuneMC; // TOF settings
+ Double_t fTOFresolution; // TOF settings
+
+ // ROOT dictionary
+ ClassDef(AliRsnAnalysisMonitorTask,1)
+};
+
+#endif
//
}
-//__________________________________________________________________________________________________
-Bool_t AliRsnAnalysisPhi7TeV::IsTPCtrack(AliESDtrack *track)
-{
-//
-// Checks if it is a TPC track or ITS standalone
-//
-
- ULong_t status = (ULong_t)track->GetStatus();
-
- if ((status & AliESDtrack::kTPCin) != 0) return kTRUE;
-
- return kFALSE;
-}
-
-//__________________________________________________________________________________________________
-Bool_t AliRsnAnalysisPhi7TeV::IsITSSAtrack(AliESDtrack *track)
-{
-//
-// Checks if it is a TPC track or ITS standalone
-//
-
- ULong_t status = (ULong_t)track->GetStatus();
-
- if ((status & AliESDtrack::kTPCin) == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0) return kTRUE;
-
- return kFALSE;
-}
-
//__________________________________________________________________________________________________
Int_t AliRsnAnalysisPhi7TeV::EventEval(AliESDEvent *esd)
{
Int_t ntracks = esd->GetNumberOfTracks();
TArrayI pos(ntracks);
TArrayI neg(ntracks);
+ TArrayI itspos(ntracks);
+ TArrayI itsneg(ntracks);
// loop on all tracks
ULong_t status;
Int_t i, k, charge, npos = 0, nneg = 0, nITS;
Double_t times[10], tpcNSigma, tpcMaxNSigma, itsSignal, itsNSigma, mom, tofTime, tofSigma, tofRef, tofRel;
- Bool_t okTOF, okTrack;
+ Bool_t okTOF, okTrack, isTPC, isITSSA;
UChar_t itsCluMap;
for (i = 0; i < ntracks; i++)
{
if (!track) continue;
// get commonly used variables
- status = (ULong_t)track->GetStatus();
- mom = track->P();
+ status = (ULong_t)track->GetStatus();
+ mom = track->P();
+ isTPC = ((status & AliESDtrack::kTPCin) != 0);
+ isITSSA = ((status & AliESDtrack::kTPCin) == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
+
+ // accept only tracks which are TPC+ITS or ITS standalone
+ if (!isTPC && !isITSSA) continue;
// define selection properties depending on track type
// it track is standard TPC+ITS+TOF track, check standard cuts and TOF
// if the track is an ITS standalone, check its specific cuts only
okTrack = kTRUE;
- if (IsTPCtrack(track))
+ if (isTPC)
{
// check standard ESD cuts
if (!fESDtrackCutsTPC.IsSelected(track)) okTrack = kFALSE;
}
if (!okTOF) okTrack = kFALSE;
}
- else if (IsITSSAtrack(track))
+ else
{
// check standard ESD cuts
if (!fESDtrackCutsITS.IsSelected(track)) okTrack = kFALSE;
- // check that PID is computed
- if ((status & AliESDtrack::kITSpid) == 0) okTrack = kFALSE;
-
// check dE/dx
itsSignal = track->GetITSsignal();
itsCluMap = track->GetITSClusterMap();
itsNSigma = itsrsp.GetNumberOfSigmas(mom, itsSignal, AliPID::kKaon, nITS, kTRUE);
if (TMath::Abs(itsNSigma) > fMaxITSband) okTrack = kFALSE;
}
- else
- okTrack = kFALSE;
// skip tracks not passing cuts
if (!okTrack) continue;
// charged tracks arrays
charge = (Int_t)track->Charge();
if (charge > 0)
- pos[npos++] = i;
+ {
+ pos[npos] = i;
+ if (isITSSA) itspos[npos] = 1; else itspos[npos] = 0;
+ npos++;
+ }
else if (charge < 0)
- neg[nneg++] = i;
+ {
+ neg[nneg] = i;
+ if (isITSSA) itsneg[nneg] = 1; else itsneg[nneg] = 0;
+ nneg++;
+ }
}
// resize arrays accordingly
pos.Set(npos);
neg.Set(nneg);
+ itspos.Set(npos);
+ itsneg.Set(nneg);
// loop on unlike-sign pairs to compute invariant mass signal
Int_t ip, in, lp, ln;
fPt = (Float_t)vsum.Perp();
fEta = (Float_t)vsum.Eta();
fY = (Float_t)vref.Rapidity();
- fITS[0] = IsITSSAtrack(tp) ? 1 : 0;
- fITS[1] = IsITSSAtrack(tn) ? 1 : 0;
+ fITS[0] = itspos[ip];
+ fITS[1] = itsneg[in];
if (fIM < 0.9 || fIM > 1.4) continue;
if (fPt < 0.0 || fPt > 20.0) continue;
fPt = (Float_t)vsum.Perp();
fEta = (Float_t)vsum.Eta();
fY = (Float_t)vref.Rapidity();
- fITS[0] = IsITSSAtrack(t1) ? 1 : 0;
- fITS[1] = IsITSSAtrack(t2) ? 1 : 0;
+ fITS[0] = itspos[i1];
+ fITS[1] = itspos[i2];
if (fIM < 0.9 || fIM > 1.4) continue;
if (fPt < 0.0 || fPt > 20.0) continue;
fPt = (Float_t)vsum.Perp();
fEta = (Float_t)vsum.Eta();
fY = (Float_t)vref.Rapidity();
- fITS[0] = IsITSSAtrack(t1) ? 1 : 0;
- fITS[1] = IsITSSAtrack(t2) ? 1 : 0;
+ fITS[0] = itsneg[i1];
+ fITS[1] = itsneg[i2];
if (fIM < 0.9 || fIM > 1.4) continue;
if (fPt < 0.0 || fPt > 20.0) continue;
virtual void Terminate(Option_t *option = "");
Int_t EventEval(AliESDEvent *esd);
- Bool_t IsTPCtrack(AliESDtrack *track);
- Bool_t IsITSSAtrack(AliESDtrack *track);
AliESDtrackCuts* GetCutsTPC() {return &fESDtrackCutsTPC;}
AliESDtrackCuts* GetCutsITS() {return &fESDtrackCutsITS;}
TH1F *fVertexY[2]; // histogram of Y coordinate of primary vertex ([0] = tracks, [1] = SPD)
TH1F *fVertexZ[2]; // histogram of Z coordinate of primary vertex ([0] = tracks, [1] = SPD)
- AliESDtrackCuts fESDtrackCutsTPC; //! ESD standard defined track cuts for TPC tracks
- AliESDtrackCuts fESDtrackCutsITS; //! ESD standard defined track cuts for ITS-SA tracks
+ AliESDtrackCuts fESDtrackCutsTPC; // ESD standard defined track cuts for TPC tracks
+ AliESDtrackCuts fESDtrackCutsITS; // ESD standard defined track cuts for ITS-SA tracks
AliESDpid *fESDpid; //! PID manager
AliTOFT0maker *fTOFmaker; //! TOF time0 computator
AliTOFcalib *fTOFcalib; //! TOF calibration
--- /dev/null
+#include <TParticle.h>
+
+#include "AliLog.h"
+#include "AliStack.h"
+#include "AliESDtrack.h"
+#include "AliTOFT0maker.h"
+
+#include "AliRsnMonitorTrack.h"
+
+ClassImp(AliRsnMonitorTrack)
+
+AliRsnMonitorTrack::AliRsnMonitorTrack() :
+ fUsable(kFALSE),
+ fCutsPassed(kFALSE),
+ fPrim(kFALSE),
+ fPDG(0),
+ fPDGM(0),
+ fMother(-1),
+ fStatus(0),
+ fLength(0.0),
+ fCharge(0),
+ fITSsa(kFALSE),
+ fITSchi2(1E10),
+ fITSsignal(0.0),
+ fITSnsigma(1E10),
+ fTPCchi2(1E10),
+ fTPCdedx(1E10),
+ fTPCcount(0),
+ fTPCnsigma(1E10),
+ fTOFsignal(0.0)
+{
+//
+// Unique constructor
+//
+}
+
+AliRsnMonitorTrack::AliRsnMonitorTrack(const AliRsnMonitorTrack& copy) :
+ TObject(copy),
+ fUsable(copy.fUsable),
+ fCutsPassed(copy.fCutsPassed),
+ fPrim(copy.fPrim),
+ fPDG(copy.fPDG),
+ fPDGM(copy.fPDGM),
+ fMother(copy.fMother),
+ fStatus(copy.fStatus),
+ fLength(copy.fLength),
+ fCharge(copy.fCharge),
+ fITSsa(copy.fITSsa),
+ fITSchi2(copy.fITSchi2),
+ fITSsignal(copy.fITSsignal),
+ fITSnsigma(copy.fITSnsigma),
+ fTPCchi2(copy.fTPCchi2),
+ fTPCdedx(copy.fTPCdedx),
+ fTPCcount(copy.fTPCcount),
+ fTPCnsigma(copy.fTPCnsigma),
+ fTOFsignal(copy.fTOFsignal)
+{
+//
+// Copy constructor
+//
+
+ Int_t k;
+
+ for (k = 0; k < 2; k++) fDCA[k] = copy.fDCA[k];
+ for (k = 0; k < 6; k++) fITSmap[k] = copy.fITSmap[k];
+ for (k = 0; k < 4; k++) fITSdedx[k] = copy.fITSdedx[k];
+ for (k = 0; k < AliPID::kSPECIES; k++)
+ {
+ fTPCref [k] = copy.fTPCref [k];
+ fTOFref [k] = copy.fTOFref [k];
+ fTOFsigma[k] = copy.fTOFsigma[k];
+ }
+ for (k = 0; k < 3; k++)
+ {
+ fPsim[k] = copy.fPsim[k];
+ fPrec[k] = copy.fPrec[k];
+ fPtpc[k] = copy.fPtpc[k];
+ }
+}
+
+//_____________________________________________________________________________________________
+void AliRsnMonitorTrack::Reset()
+{
+//
+// Generic reset method, to set all fields to meaningless values
+//
+
+ Int_t k;
+
+ fUsable = kFALSE;
+ fCutsPassed = kFALSE;
+ fITSsa = kFALSE;
+ fPrim = kFALSE;
+ fPDG = 0;
+ fMother = -1;
+ fPDGM = 0;
+ fStatus = 0;
+ fLength = 0.0;
+ fCharge = 0;
+
+ for (k = 0; k < 2; k++) fDCA[k] = 1E10;
+
+ for (k = 0; k < 6; k++) fITSmap[k] = kFALSE;
+ fITSchi2 = 1E10;
+ for (k = 0; k < 4; k++) fITSdedx[k] = 0.0;
+ fITSsignal = 0.0;
+ fITSnsigma = 1E10;
+
+ fTPCchi2 = 1E10;
+ fTPCdedx = 1E10;
+ fTPCcount = 0;
+ fTPCnsigma = 1E10;
+
+ fTOFsignal = 1E10;
+
+ for (k = 0; k < AliPID::kSPECIES; k++)
+ {
+ fTPCref [k] = 1E10;
+ fTOFref [k] = 1E10;
+ fTOFsigma[k] = 1E10;
+ }
+
+ for (k = 0; k < 3; k++) fPsim[k] = fPrec[k] = fPtpc[k] = 0.0;
+}
+
+//__________________________________________________________________________________________________
+Bool_t AliRsnMonitorTrack::AdoptMC(Int_t label, AliStack *stack)
+{
+//
+// Get info from MC for a given track in the stack
+//
+
+ if (!stack) return kFALSE;
+
+ Int_t nPart = stack->GetNtrack();
+ if (label < 0 || label > nPart)
+ {
+ AliError(Form("Label = %d -- MAX = %d", label, nPart));
+ return kFALSE;
+ }
+
+ TParticle *mc = stack->Particle(label);
+ if (!mc) return kFALSE;
+
+ // 'direct' data
+ fPDG = (Int_t)mc->GetPdgCode();
+ fMother = (Int_t)mc->GetFirstMother();
+ fPrim = (Bool_t)stack->IsPhysicalPrimary(label);
+ fPDGM = 0;
+ fPsim[0] = mc->Px();
+ fPsim[1] = mc->Py();
+ fPsim[2] = mc->Pz();
+
+ // assign mother (if any)
+ if (fMother >= 0 && fMother < nPart)
+ {
+ TParticle *m = stack->Particle(fMother);
+ if (m) fPDGM = (Int_t)TMath::Abs(m->GetPdgCode());
+ }
+
+ return kTRUE;
+}
--- /dev/null
+//
+// Class AliRsnMonitorTrack
+//
+// Monitor object used
+// for storing info ina TTree
+// and studying cut values and variables.
+//
+// author: A. Pulvirenti
+//
+
+#ifndef ALIRSNMONITORTRACK_H
+#define ALIRSNMONITORTRACK_H
+
+#include "AliPID.h"
+
+class AliESDtrack;
+class AliTOFT0maker;
+class AliStack;
+
+class AliRsnMonitorTrack : public TObject
+{
+ public:
+
+ AliRsnMonitorTrack();
+ AliRsnMonitorTrack(const AliRsnMonitorTrack& copy);
+ //AliRsnMonitorTrack& operator=(const AliRsnMonitorTrack& copy) {MakeCopy(copy); return (*this);}
+ virtual ~AliRsnMonitorTrack() { /*nothing*/ }
+
+ void Reset();
+ Bool_t AdoptMC(Int_t label, AliStack *stack);
+
+ Bool_t& IsUsable() {return fUsable;}
+ void SetUsable() {fUsable = kTRUE;}
+ Bool_t& CutsPassed() {return fCutsPassed;}
+
+ Double_t& PsimX() {return fPsim[0];}
+ Double_t& PrecX() {return fPrec[0];}
+ Double_t& PtpcX() {return fPtpc[0];}
+
+ Double_t& PsimY() {return fPsim[1];}
+ Double_t& PrecY() {return fPrec[1];}
+ Double_t& PtpcY() {return fPtpc[1];}
+
+ Double_t& PsimZ() {return fPsim[2];}
+ Double_t& PrecZ() {return fPrec[2];}
+ Double_t& PtpcZ() {return fPtpc[2];}
+
+ Double_t PsimT() {return TMath::Sqrt(fPsim[0]*fPsim[0] + fPsim[1]*fPsim[1]);}
+ Double_t PrecT() {return TMath::Sqrt(fPrec[0]*fPrec[0] + fPrec[1]*fPrec[1]);}
+ Double_t PtpcT() {return TMath::Sqrt(fPtpc[0]*fPtpc[0] + fPtpc[1]*fPtpc[1]);}
+
+ Double_t Psim() {return TMath::Sqrt(PsimT()*PsimT() + fPsim[2]*fPsim[2]);}
+ Double_t Prec() {return TMath::Sqrt(PrecT()*PrecT() + fPrec[2]*fPrec[2]);}
+ Double_t Ptpc() {return TMath::Sqrt(PtpcT()*PtpcT() + fPtpc[2]*fPtpc[2]);}
+
+ Bool_t& Prim() {return fPrim;}
+ Int_t& PDG() {return fPDG;}
+ Int_t& PDGM() {return fPDGM;}
+ Int_t& Mother() {return fMother;}
+
+ UInt_t& Status() {return fStatus;}
+ Double_t& Length() {return fLength;}
+ Int_t& Charge() {return fCharge;}
+ Bool_t& ITSsa() {return fITSsa;}
+ Double_t& DCAr() {return fDCA[0];}
+ Double_t& DCAz() {return fDCA[1];}
+
+ Bool_t& ITSmap(Int_t i) {if (i>=0 && i<6) return fITSmap[i]; else return fITSmap[0];}
+ Int_t ITScount() {return (SPDcount() + SDDcount() + SSDcount());}
+ Int_t SPDcount() {Int_t count=0; if (fITSmap[0]) count++; if (fITSmap[1]) count++; return count;}
+ Int_t SDDcount() {Int_t count=0; if (fITSmap[2]) count++; if (fITSmap[3]) count++; return count;}
+ Int_t SSDcount() {Int_t count=0; if (fITSmap[4]) count++; if (fITSmap[5]) count++; return count;}
+ Double_t& ITSchi2() {return fITSchi2;}
+ Double_t& ITSdedx(Int_t i) {if (i>=0 && i<4) return fITSdedx[i]; else return fITSdedx[0];}
+ Double_t& ITSsignal() {return fITSsignal;}
+ Double_t& ITSnsigma() {return fITSnsigma;}
+
+ Double_t& TPCdedx() {return fTPCdedx;}
+ Int_t& TPCcount() {return fTPCcount;}
+ Double_t& TPCref(Int_t i) {if (i>=0 && i<AliPID::kSPECIES) return fTPCref[i]; else return fTPCref[0];}
+ Double_t& TPCchi2() {return fTPCchi2;}
+ Double_t& TPCnsigma() {return fTPCnsigma;}
+
+ Double_t& TOFsignal() {return fTOFsignal;}
+ Double_t& TOFsigma(Int_t i){if (i>=0 && i<AliPID::kSPECIES) return fTOFsigma[i]; else return fTOFsigma[0];}
+ Double_t& TOFref(Int_t i) {if (i>=0 && i<AliPID::kSPECIES) return fTOFref[i]; else return fTOFref[0];}
+
+ private:
+
+ Bool_t fUsable; // utility flag
+ Bool_t fCutsPassed; // did it pass all defined cuts?
+
+ Bool_t fPrim; // is physical primary?
+ Int_t fPDG; // true PDG code
+ Int_t fPDGM; // PDG code of mother (if any)
+ Int_t fMother; // label of mother (if any)
+
+ UInt_t fStatus; // 'status' flag of track in ESD (0 = none)
+ Double_t fLength; // integrated length
+ Int_t fCharge; // track charge
+ Bool_t fITSsa; // to know if its is ITS standalone
+ Double_t fDCA[2]; // DCA ([0] = xy, [1] = z)
+
+ Bool_t fITSmap[6]; // ITS cluster map
+ Double_t fITSchi2; // chi2 in ITS
+ Double_t fITSdedx[4]; // ITS dEdx signal in the 4 analog layers
+ Double_t fITSsignal; // ITS signal used for PID
+ Double_t fITSnsigma; // number of sigmas ITS
+
+ Double_t fTPCchi2; // TPC chi 2
+ Double_t fTPCdedx; // TPC dEdx signal
+ Int_t fTPCcount; // # TPC clusters
+ Double_t fTPCref[AliPID::kSPECIES]; // ALEPH Bethe-Bloch count for: e, mu, pi, K, p
+ Double_t fTPCnsigma; // number of sigmas TPC
+
+ Double_t fTOFsignal; // TOF signal
+ Double_t fTOFsigma[AliPID::kSPECIES]; // TOF sigma for: e, mu, pi, K, p
+ Double_t fTOFref[AliPID::kSPECIES]; // expected times for: e, mu, pi, K, p
+
+ Double_t fPsim[3]; // simulated momentum
+ Double_t fPrec[3]; // reconstructed momentum
+ Double_t fPtpc[3]; // reconstructed momentum at the TPC inner wall
+
+ ClassDef(AliRsnMonitorTrack, 1)
+};
+
+#endif
RESONANCES/AliRsnAnalysisTrackEffSE.cxx \
RESONANCES/AliRsnTOFT0maker.cxx \
RESONANCES/AliRsnAnalysisPhi900GeV.cxx \
- RESONANCES/AliRsnAnalysisPhi7TeV.cxx
+ RESONANCES/AliRsnAnalysisPhi7TeV.cxx \
+ RESONANCES/AliRsnMonitorTrack.cxx \
+ RESONANCES/AliRsnAnalysisMonitorTask.cxx \
HDRS= $(SRCS:.cxx=.h)