#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliMCEvent.h"
-#include "AliHeader.h"
-#include "AliESDHeader.h"
-#include "AliAODHeader.h"
-#include "AliAODMCHeader.h"
-#include "AliGenEventHeader.h"
-#include "AliGenCocktailEventHeader.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"
-#include "AliMCParticle.h"
-#include "AliAODMCParticle.h"
#include "AliExternalTrackParam.h"
#include "AliCentrality.h"
#include "AliAnalysisFilter.h"
-#include "AliPIDResponse.h"
-#include "AliTPCPIDResponse.h"
-#include "AliAODTracklets.h"
+#include "AliVMultiplicity.h"
+#include "AliAnalysisUtils.h"
// root
#include "TMath.h"
#include "TFile.h"
//-----------------------------------------------------------------------------
AliAnalysisTaskCFTree::AliAnalysisTaskCFTree(const char* name) :
- AliAnalysisTask(name,""),
- fDebug(0),
- fMode(0),
- fIsAOD(1),
- fInputHandler(0x0),
- fMcHandler(0x0),
+ AliAnalysisTaskSE(name),
fTrackFilter(0x0),
fHybridConstrainedMask(0),
fTPConlyConstrainedMask(0),
- fPIDResponse(0x0),
+ fUtils(0x0),
fListOfHistos(0x0),
fEventStatistics(0x0),
fTree(0x0),
- fParticles(0x0),
+ fTracks(0x0),
fTracklets(0x0),
fMuons(0x0),
+ fMcParticles(0x0),
fField(0),
- fCentrality(0),
- fZvtx(0),
- fRunNumber(0),
+ fCentrality(),
+ fVtxZ(0),
+ fVtxTPConly(0),
+ fVtxContributors(0),
fPeriod(0),
fOrbit(),
fBc(),
fSelectMask(0),
- fSelectBit(AliVEvent::kMB),
+ fIsPileupSPD(0),
+ fIsPileupMV(0),
+ fSelectBit(AliVEvent::kAny),
fZVertexCut(10.),
- fnTracksVertex(1),
- fCentralityMethod("V0M"),
fTrackFilterBit(0xffffffff),
fTrackEtaCut(1.0),
fPtMin(0.15),
fDphiCut(1.e9),
fStoreTracks(0),
fStoreTracklets(0),
- fStoreMuons(0)
+ fStoreMuons(0),
+ fStoreMcTracks(0),
+ fStoreMcTracklets(0),
+ fStoreMcMuons(0),
+ fStorePidInfo(0)
{
Info("AliAnalysisTaskCFTree","Calling Constructor");
DefineInput(0,TChain::Class());
- DefineOutput(0,TList::Class());
- DefineOutput(1,TTree::Class());
+ DefineOutput(1,TList::Class());
+ DefineOutput(2,TTree::Class());
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-void AliAnalysisTaskCFTree::ConnectInputData(Option_t* /*option*/){
- fInputHandler = dynamic_cast<AliInputEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
- fMcHandler = dynamic_cast<AliInputEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
- if (fInputHandler) fInputHandler->SetNeedField();
-}
-//-----------------------------------------------------------------------------
-
-
-//-----------------------------------------------------------------------------
-void AliAnalysisTaskCFTree::CreateOutputObjects(){
+void AliAnalysisTaskCFTree::UserCreateOutputObjects(){
fListOfHistos = new TList();
fListOfHistos->SetOwner();
fEventStatistics = new TH1I("fEventStatistics","",10,0,10);
fListOfHistos->Add(fEventStatistics);
- if (fStoreTracks) fParticles = new TClonesArray("AliCFParticle",2000);
- if (fStoreTracklets) fTracklets = new TClonesArray("AliCFParticle",100);
- if (fStoreMuons) fMuons = new TClonesArray("AliCFParticle",100);
+ if (fStoreTracks) fTracks = new TClonesArray("AliCFParticle",2000);
+ if (fStoreTracklets) fTracklets = new TClonesArray("AliCFParticle",2000);
+ if (fStoreMuons) fMuons = new TClonesArray("AliCFParticle",2000);
+ if (fStoreMcTracks) fMcParticles = new TClonesArray("AliCFParticle",2000);
// create file-resident tree
TDirectory *owd = gDirectory;
OpenFile(1);
fTree = new TTree("events","events");
owd->cd();
- fTree->Branch("cent",&fCentrality);
- fTree->Branch("zvtx",&fZvtx);
+ fTree->Branch("cent",&fCentrality,"fCentrality[6]/F");
+ fTree->Branch("vtxz",&fVtxZ);
+ fTree->Branch("vtxTPConly",&fVtxTPConly);
+ fTree->Branch("vtxContributors",&fVtxContributors);
fTree->Branch("field",&fField);
- fTree->Branch("run",&fRunNumber);
+ fTree->Branch("run",&fCurrentRunNumber);
fTree->Branch("period",&fPeriod);
fTree->Branch("orbit",&fOrbit);
fTree->Branch("bc",&fBc);
fTree->Branch("mask",&fSelectMask);
- if (fStoreTracks) fTree->Branch("particles",&fParticles);
- if (fStoreTracklets) fTree->Branch("tracklets",&fTracklets);
- if (fStoreMuons) fTree->Branch("muons",&fMuons);
- PostData(0,fListOfHistos);
- PostData(1,fTree);
+ fTree->Branch("pileupspd",&fIsPileupSPD);
+ fTree->Branch("pileupmv",&fIsPileupMV);
+ if (fTracks) fTree->Branch("tracks",&fTracks);
+ if (fTracklets) fTree->Branch("tracklets",&fTracklets);
+ if (fMuons) fTree->Branch("muons",&fMuons);
+ if (fMcParticles) fTree->Branch("mcparticles",&fMcParticles);
+
+ fUtils = new AliAnalysisUtils();
+
+ PostData(1,fListOfHistos);
+ PostData(2,fTree);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-void AliAnalysisTaskCFTree::Exec(Option_t *){
- if (fParticles) fParticles->Clear();
- if (fTracklets) fTracklets->Clear();
- if (fMuons) fMuons->Clear();
-
+void AliAnalysisTaskCFTree::UserExec(Option_t *){
fEventStatistics->Fill("before cuts",1);
- AliVEvent* event = fInputHandler->GetEvent();
- if (!event) return;
+ if (!fInputEvent) return;
fEventStatistics->Fill("after event check",1);
- fPIDResponse = fInputHandler->GetPIDResponse();
+ // TODO
+ // TString classes = fInputEvent->GetFiredTriggerClasses();
+ // fClassesFired = 0;
+ // fClassesFired |= (classes.Contains("CINT7-S-") << 0);
+ // fClassesFired |= (classes.Contains("CINT7-B-") << 0);
+ // fClassesFired |= (classes.Contains("CSHM8-S-") << 1);
+ // fClassesFired |= (classes.Contains("CSHM8-B-") << 1);
+ // fClassesFired |= (classes.Contains("CMSL7-S-") << 2);
+ // fClassesFired |= (classes.Contains("CMSL7-B-") << 2);
+ // fClassesFired |= (classes.Contains("CMSH7-S-") << 3);
+ // fClassesFired |= (classes.Contains("CMSH7-B-") << 3);
+ // fClassesFired |= (classes.Contains("CMUL7-S-") << 4);
+ // fClassesFired |= (classes.Contains("CMUL7-B-") << 4);
+ // fClassesFired |= (classes.Contains("CMLL7-S-") << 5);
+ // fClassesFired |= (classes.Contains("CMLL7-B-") << 5);
+ // fClassesFired |= (classes.Contains("CINT8-S-") << 6);
+ // fClassesFired |= (classes.Contains("CSPI7-S-") << 7);
+ // fClassesFired |= (classes.Contains("CSPI8-S-") << 8);
+ // fClassesFired |= (classes.Contains("CMSL8-S-") << 9);
+ // fClassesFired |= (classes.Contains("CMSH8-S-") <<10);
+ // fClassesFired |= (classes.Contains("CMUL8-S-") <<11);
+ // fClassesFired |= (classes.Contains("CMLL8-S-") <<12);
+ // fClassesFired |= (classes.Contains("C0MUL-SA") <<13);
+ // fClassesFired |= (classes.Contains("C0MUL-SC") <<14);
+ // if (!fClassesFired) return;
+ // fEventStatistics->Fill("after trigger check",1);
fSelectMask = fInputHandler->IsEventSelected();
if (!(fSelectMask & fSelectBit)) return;
- fEventStatistics->Fill("after trigger selection",1);
- fRunNumber = event->GetRunNumber();
- fPeriod = event->GetPeriodNumber();
- fOrbit = event->GetOrbitNumber();
- fBc = event->GetBunchCrossNumber();
- fField = event->GetMagneticField();
- fCentrality = event->GetCentrality()->GetCentralityPercentile(fCentralityMethod);
- if (fMode==0){ // Data analysis
- const AliVVertex* vertex = event->GetPrimaryVertex();
- if (!vertex) return;
- fZvtx = vertex->GetZ();
- TString name(vertex->GetName());
- if (name.CompareTo("PrimaryVertex") && name.CompareTo("SPDVertex")) return; // Reject TPC only vertex
- fEventStatistics->Fill("after rejection of TPC only vertex",1);
- if (TMath::Abs(fZvtx) >= fZVertexCut || vertex->GetNContributors()<fnTracksVertex) return;
- fEventStatistics->Fill("after vertex selection",1);
-
- if (fParticles) {
- for (Int_t ipart=0;ipart<event->GetNumberOfTracks();ipart++){
- AliVTrack* track = (AliVTrack*) event->GetTrack(ipart);
- if (!track) continue;
- UInt_t mask = GetFilterMap(track);
- if (!(mask & fTrackFilterBit)) continue;
+ fEventStatistics->Fill("after physics selection",1);
+
+ fPeriod = fInputEvent->GetPeriodNumber();
+ fOrbit = fInputEvent->GetOrbitNumber();
+ fBc = fInputEvent->GetBunchCrossNumber();
+ fField = fInputEvent->GetMagneticField();
+ fCentrality[0] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0M");
+ fCentrality[1] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0A");
+ fCentrality[2] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0C");
+ fCentrality[3] = fInputEvent->GetCentrality()->GetCentralityPercentile("CL1");
+ fCentrality[4] = fInputEvent->GetCentrality()->GetCentralityPercentile("ZNA");
+ fCentrality[5] = fInputEvent->GetCentrality()->GetCentralityPercentile("ZNC");
+ fIsPileupSPD = fUtils->IsPileUpSPD(fInputEvent);
+ fIsPileupMV = fUtils->IsPileUpMV(fInputEvent);
+// fNofITSClusters[i] = esd->GetMultiplicity()->GetNumberOfITSClusters(i);
+
+ const AliVVertex* vertex = fInputEvent->GetPrimaryVertex();
+ fVtxZ = vertex->GetZ();
+ fVtxTPConly = TString(vertex->GetName()).CompareTo("PrimaryVertex") && TString(vertex->GetName()).CompareTo("SPDVertex");
+ fVtxContributors = vertex->GetNContributors();
+ if (TMath::Abs(fVtxZ) >= fZVertexCut) return;
+ fEventStatistics->Fill("after vertex cut",1);
+
+ if (fTracks) {
+ fTracks->Clear();
+ for (Int_t ipart=0;ipart<fInputEvent->GetNumberOfTracks();ipart++){
+ AliVTrack* track = (AliVTrack*) fInputEvent->GetTrack(ipart);
+ if (!track) continue;
+ UInt_t mask = GetFilterMap(track);
+ if (!(mask & fTrackFilterBit)) continue;
- if (track->InheritsFrom("AliAODTrack")) AddTrack(track,mask,0);
- else if (track->InheritsFrom("AliESDtrack")) {
- if (mask) AddTrack(track,mask,1);
- if (mask & fHybridConstrainedMask) AddTrack(track,mask,2);
- if (mask & fTPConlyConstrainedMask) AddTrack(track,mask,3);
- }
- }
- }
- if (fIsAOD){
- AliAODEvent* aod = (AliAODEvent*) event;
-
- if (fStoreTracklets){
- AliAODTracklets* tracklets = aod->GetTracklets();
- Int_t nTracklets = tracklets->GetNumberOfTracklets();
- for (Int_t i=0;i<nTracklets;i++){
- Float_t phi = tracklets->GetPhi(i);
- Float_t theta = tracklets->GetTheta(i);
- Float_t dphi = tracklets->GetDeltaPhi(i);
- if (TMath::Abs(dphi)>fDphiCut) continue;
- new ((*fTracklets)[fTracklets->GetEntriesFast()]) AliCFParticle(dphi,-TMath::Log(TMath::Tan(theta/2)),phi,0,0);
- }
- }
-
- if (fStoreMuons){
- for (Int_t iTrack = 0; iTrack < aod->GetNTracks(); iTrack++) {
- AliAODTrack* track = aod->GetTrack(iTrack);
- if (!track->IsMuonTrack()) continue;
- Float_t pt = track->Pt();
- Float_t eta = track->Eta();
- Float_t phi = track->Phi();
- Short_t charge = track->Charge();
- Float_t dca = track->DCA();
- Float_t chi2 = track->Chi2perNDF();
- Float_t rabs = track->GetRAtAbsorberEnd();
- Int_t mask = track->GetMatchTrigger();
- if (rabs < 17.6 || rabs > 89.5) continue;
- if (eta < -4 || eta > -2.5) continue;
- AliCFParticle* part = new ((*fMuons)[fMuons->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,3);
- part->SetAt(dca,0);
- part->SetAt(chi2,1);
- part->SetAt(rabs,2);
- }
+ if (track->InheritsFrom("AliAODTrack")) AddTrack(track,mask,0);
+ else if (track->InheritsFrom("AliESDtrack")) {
+ if (mask) AddTrack(track,mask,1);
+ if (mask & fHybridConstrainedMask) AddTrack(track,mask,2);
+ if (mask & fTPConlyConstrainedMask) AddTrack(track,mask,3);
}
}
}
- else { // MC analysis
- AliMCEvent* mcEvent = fMcHandler ? fMcHandler->MCEvent() : 0;
- TClonesArray* mcTracks = dynamic_cast<TClonesArray*>(event->FindListObject(AliAODMCParticle::StdBranchName()));
- if (!mcEvent && !mcTracks) { printf("No mc object found\n"); return; }
- fEventStatistics->Fill("after mc objects check",1);
-
- Int_t nPrimGen = 0;
- Int_t nProduced = 0;
- if (mcEvent) { // ESD
- AliHeader* header = (AliHeader*) mcEvent->Header();
- AliGenCocktailEventHeader* cocktailHeader = dynamic_cast<AliGenCocktailEventHeader*> (header->GenEventHeader());
- AliGenEventHeader* mcHeader = dynamic_cast<AliGenEventHeader*> (cocktailHeader ? cocktailHeader->GetHeaders()->First() : header->GenEventHeader());
- if (!mcHeader) { printf("mc header not found\n"); return; }
- nProduced = mcEvent->GetNumberOfTracks();
- nPrimGen = mcHeader->NProduced();
- fZvtx = mcEvent->GetPrimaryVertex()->GetZ();
- } else { // AOD
- AliAODMCHeader* mcHeader = (AliAODMCHeader*) event->FindListObject(AliAODMCHeader::StdBranchName());
- if (!mcHeader) { printf("AliAODMCHeader not found\n"); return; }
- if (mcHeader->GetCocktailHeaders()) {
- nProduced = mcTracks->GetEntriesFast();
- AliGenEventHeader* header0 = mcHeader->GetCocktailHeader(0);
- if (!header0) { printf("first header expected but not found\n"); return; }
- nPrimGen = header0->NProduced();
- } else nPrimGen = nProduced;
- fZvtx = mcHeader->GetVtxZ();
+ if (fTracklets){
+ fTracklets->Clear();
+ AliVMultiplicity* mult = fInputEvent->GetMultiplicity();
+ Int_t nTracklets = mult->GetNumberOfTracklets();
+ for (Int_t i=0;i<nTracklets;i++){
+ Float_t phi = mult->GetPhi(i);
+ Float_t eta = -TMath::Log(TMath::Tan(mult->GetTheta(i)/2));
+ Float_t dphi = mult->GetDeltaPhi(i);
+ if (TMath::Abs(dphi)>fDphiCut) continue;
+ AliCFParticle* tracklet = new ((*fTracklets)[fTracklets->GetEntriesFast()]) AliCFParticle(dphi,eta,phi,0,0,fStoreMcTracklets?4:0);
+ if (!fStoreMcTracklets || !fMCEvent) continue;
+ Int_t label1 = mult->GetLabel(i,0);
+ Int_t label2 = mult->GetLabel(i,1);
+ if (label1!=label2) continue;
+ AliVParticle* particle = fMCEvent->GetTrack(label1);
+ if (!particle) continue;
+ Short_t charge = particle->Charge();
+ Float_t ptMC = particle->Pt();
+ Float_t etaMC = particle->Eta();
+ Float_t phiMC = particle->Phi();
+ Float_t pdg = particle->PdgCode();
+ tracklet->SetCharge(charge);
+ tracklet->SetAt(ptMC,0);
+ tracklet->SetAt(etaMC,1);
+ tracklet->SetAt(phiMC,2);
+ tracklet->SetAt(pdg,3);
}
- fEventStatistics->Fill("after mc header check",1);
-
- if (TMath::Abs(fZvtx)>fZVertexCut) return;
- fEventStatistics->Fill("after MC vertex cut",1);
-
- const AliVVertex* vertex = event->GetPrimaryVertex();
- if (!vertex) return;
- fEventStatistics->Fill("after check for vertex object",1);
- TString name(vertex->GetName());
- if (name.CompareTo("PrimaryVertex") && name.CompareTo("SPDVertex")) fZvtx=1000; // Reject TPC only vertex
- fEventStatistics->Fill("after rejection of TPC only vertex",1);
- if (vertex->GetNContributors()<fnTracksVertex) fZvtx=-1000;
- fEventStatistics->Fill("after check for vertex contributors",1);
-
- if (fParticles) {
- UInt_t* masks = new UInt_t[nProduced];
- for (Int_t i=0;i<nProduced;i++) masks[i]=0;
-
- // Loop over reconstructed tracks to set masks
- for (Int_t ipart=0;ipart<event->GetNumberOfTracks();ipart++){
- AliVTrack* part = (AliVTrack*) event->GetTrack(ipart);
- if (!part) continue;
- Int_t label = TMath::Abs(part->GetLabel());
- if (label>=nProduced) continue;
- masks[label] |= GetFilterMap(part);
- }
-
- // Loop over mc tracks to be stored
- for (Int_t ipart=0;ipart<nProduced;ipart++){
- AliVParticle* part = 0;
- Bool_t isPrimary = 0;
- if (mcTracks) { // AOD analysis
- AliAODMCParticle* particle = (AliAODMCParticle*) mcTracks->At(ipart);
- if (!particle) continue;
- // skip injected signals
- AliAODMCParticle* mother = particle;
- while (!mother->IsPrimary()) mother = (AliAODMCParticle*) mcTracks->At(mother->GetMother());
- if (mother->GetLabel()>=nPrimGen) continue;
- part = particle;
- // check for primary
- isPrimary = particle->IsPhysicalPrimary();
- } else { // ESD analysis
- AliMCParticle* particle = (AliMCParticle*) mcEvent->GetTrack(ipart);
- if (!particle) continue;
- // skip injected signals
- AliMCParticle* mother = particle;
- while (mother->GetMother()>=0) mother = (AliMCParticle*) mcEvent->GetTrack(mother->GetMother());
- if (mother->GetLabel()>=nPrimGen) continue;
- part = particle;
- // check for primary
- isPrimary = mcEvent->IsPhysicalPrimary(ipart);
- }
-
- // store only primaries and all reconstructed (non-zero mask)
- Int_t mask = masks[ipart];
- if (isPrimary) mask |= (1 << 30);
- if (!mask) continue;
- AddTrack(part,mask);
+ }
+
+ AliAODEvent* aod = dynamic_cast<AliAODEvent*> (fInputEvent);
+ if (fMuons && aod){ // aod only
+ fMuons->Clear();
+ for (Int_t iTrack = 0; iTrack < aod->GetNTracks(); iTrack++) {
+ AliAODTrack* track = aod->GetTrack(iTrack);
+ if (!track->IsMuonTrack()) continue;
+ Float_t pt = track->Pt();
+ Float_t eta = track->Eta();
+ Float_t phi = track->Phi();
+ Short_t charge = track->Charge();
+ Float_t dca = track->DCA();
+ Float_t chi2 = track->Chi2perNDF();
+ Float_t rabs = track->GetRAtAbsorberEnd();
+ Int_t mask = track->GetMatchTrigger();
+ if (rabs < 17.6 || rabs > 89.5) continue;
+ if (eta < -4 || eta > -2.5) continue;
+ AliCFParticle* part = new ((*fMuons)[fMuons->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,fStoreMcMuons?11:3);
+ part->SetAt(dca,0);
+ part->SetAt(chi2,1);
+ part->SetAt(rabs,2);
+ if (!fStoreMcMuons || !fMCEvent) continue;
+ Int_t label = TMath::Abs(track->GetLabel());
+ AliVParticle* mcpart = fMCEvent->GetTrack(label);
+ if (!mcpart) continue;
+ Int_t mcpdg = mcpart->PdgCode();
+ Float_t mcpt = mcpart->Pt();
+ Float_t mceta = mcpart->Eta();
+ Float_t mcphi = mcpart->Phi();
+ part->SetAt(mcpt,3);
+ part->SetAt(mceta,4);
+ part->SetAt(mcphi,5);
+ part->SetAt(mcpdg,6);
+ part->SetAt(0,10);
+ Bool_t isPrimary = fMCEvent->IsPhysicalPrimary(label);
+ if (isPrimary) continue;
+ label = mcpart->GetMother();
+ while (!isPrimary && label>=0) {
+ mcpart = (AliVParticle*) fMCEvent->GetTrack(label);
+ label = mcpart->GetMother();
+ isPrimary = fMCEvent->IsPhysicalPrimary(label);
}
- delete[] masks;
+ if (!mcpart) continue;
+ Float_t mcprimarypt = mcpart->Pt();
+ Float_t mcprimaryeta = mcpart->Eta();
+ Float_t mcprimaryphi = mcpart->Phi();
+ Int_t mcprimarypdg = mcpart->PdgCode();
+ part->SetAt(mcprimarypt,7);
+ part->SetAt(mcprimaryeta,8);
+ part->SetAt(mcprimaryphi,9);
+ part->SetAt(mcprimarypdg,10);
}
-
- if (fIsAOD){
- AliAODEvent* aod = (AliAODEvent*) event;
-
- if (fTracklets) {
- AliAODTracklets* tracklets = aod->GetTracklets();
- Int_t nTracklets = tracklets->GetNumberOfTracklets();
- for (Int_t i=0;i<nTracklets;i++){
- Float_t phi = tracklets->GetPhi(i);
- Float_t theta = tracklets->GetTheta(i);
- Float_t dphi = tracklets->GetDeltaPhi(i);
- if (TMath::Abs(dphi)>fDphiCut) continue;
- AliCFParticle* tracklet = new ((*fTracklets)[fTracklets->GetEntriesFast()]) AliCFParticle(dphi,-TMath::Log(TMath::Tan(theta/2)),phi,0,0,4);
- Int_t label1 = tracklets->GetLabel(i,0);
- Int_t label2 = tracklets->GetLabel(i,1);
- if (label1!=label2) continue;
- if (!mcTracks) continue;
- AliAODMCParticle* particle = (AliAODMCParticle*) mcTracks->At(label1);
- if (!particle) continue;
- Short_t charge = particle->Charge();
- Float_t ptMC = particle->Pt();
- Float_t etaMC = particle->Eta();
- Float_t phiMC = particle->Phi();
- Float_t pdg = particle->PdgCode();
- tracklet->SetCharge(charge);
- tracklet->SetAt(ptMC,0);
- tracklet->SetAt(etaMC,1);
- tracklet->SetAt(phiMC,2);
- tracklet->SetAt(pdg,3);
- }
- }
+ }
- if (fMuons){
- for (Int_t iTrack = 0; iTrack < aod->GetNTracks(); iTrack++) {
- AliAODTrack* track = aod->GetTrack(iTrack);
- if (!track->IsMuonTrack()) continue;
- Float_t pt = track->Pt();
- Float_t eta = track->Eta();
- Float_t phi = track->Phi();
- Short_t charge = track->Charge();
- Float_t dca = track->DCA();
- Float_t chi2 = track->Chi2perNDF();
- Float_t rabs = track->GetRAtAbsorberEnd();
- Int_t mask = track->GetMatchTrigger();
- if (rabs < 17.6 || rabs > 89.5) continue;
- if (eta < -4 || eta > -2.5) continue;
- AliCFParticle* part = new ((*fMuons)[fMuons->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,3);
- part->SetAt(dca,0);
- part->SetAt(chi2,1);
- part->SetAt(rabs,2);
- }
- }
+ if (fMcParticles && fMCEvent) {
+ fMcParticles->Clear();
+ TString gen;
+ for (Int_t ipart=0;ipart<fMCEvent->GetNumberOfTracks();ipart++){
+ AliVParticle* part = fMCEvent->GetTrack(ipart);
+ Bool_t isCocktail = fMCEvent->GetCocktailGenerator(ipart,gen);
+ if (isCocktail && !gen.Contains("Pythia") && !gen.Contains("Hijing") && !gen.Contains("AMPT") && !gen.Contains("DPMJET")) continue;
+ Float_t pt = part->Pt();
+ Float_t eta = part->Eta();
+ Float_t phi = part->Phi();
+ Char_t charge = part->Charge();
+ Int_t mask = part->PdgCode();
+ // TODO
+ // Bool_t isPrimary = fMCEvent->IsPhysicalPrimary(ipart);
+ // if (pt < fMcPtMin) continue;
+ // if (TMath::Abs(eta) > fMcTrackEtaCut) continue;
+ new ((*fMcParticles)[fMcParticles->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask);
}
}
+
fTree->Fill();
- PostData(0,fListOfHistos);
- PostData(1,fTree);
+ PostData(1,fListOfHistos);
+ PostData(2,fTree);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-UInt_t AliAnalysisTaskCFTree::GetFilterMap(AliVParticle* particle){
+UInt_t AliAnalysisTaskCFTree::GetFilterMap(AliVTrack* track){
UInt_t mask = 0;
- if (particle->InheritsFrom("AliAODTrack")) {
- AliAODTrack* part = (AliAODTrack*) particle;
+ if (track->InheritsFrom("AliAODTrack")) {
+ AliAODTrack* part = (AliAODTrack*) track;
mask = part->GetFilterMap();
Double_t nCrossedRaws = part->GetTPCNCrossedRows();
Double_t nFindableClusters = part->GetTPCNclsF();
if (itsRefit) mask |= (1 << 28);
if (nSharedClusters/nClusters<=fSharedClusterCut) mask |= (1 << 29);
if (part->GetLabel()<0) mask |= (1 << 31);
- } else if (particle->InheritsFrom("AliESDtrack")){
- AliESDtrack* part = (AliESDtrack*) particle;
+ } else if (track->InheritsFrom("AliESDtrack")){
+ AliESDtrack* part = (AliESDtrack*) track;
if (!fTrackFilter) AliFatal("Track filter undefined");
mask |= fTrackFilter->IsSelected(part);
}
//-----------------------------------------------------------------------------
-AliCFParticle* AliAnalysisTaskCFTree::AddTrack(AliVParticle* part, UInt_t mask, UInt_t flag){
+AliCFParticle* AliAnalysisTaskCFTree::AddTrack(AliVTrack* track, UInt_t mask, UInt_t flag){
- // skip neutral mc particles
- Char_t charge = part->Charge();
+ // skip neutral mc trackicles
+ Char_t charge = track->Charge();
if (charge==0) return NULL;
// set pt,eta,phi
Float_t pt=0,eta=0,phi=0;
- if (flag==0 || flag==1){ // AOD, MC or Global ESD tracks
- pt = part->Pt();
- eta = part->Eta();
- phi = part->Phi();
+ if (flag==0 || flag==1){ // AOD or Global ESD tracks
+ pt = track->Pt();
+ eta = track->Eta();
+ phi = track->Phi();
if (flag==1) mask &= (~fHybridConstrainedMask) & (~fTPConlyConstrainedMask);
}
else if (flag==2) { // Hybrid constrained tracks (ESD)
- AliESDtrack* track = (AliESDtrack*) part;
- const AliExternalTrackParam* param = track->GetConstrainedParam();
+ AliESDtrack* part = (AliESDtrack*) track;
+ const AliExternalTrackParam* param = part->GetConstrainedParam();
pt = param->Pt();
eta = param->Eta();
phi = param->Phi();
mask &= fHybridConstrainedMask;
}
else if (flag==3) { // TPC only constrained tracks (ESD)
- AliESDtrack* track = (AliESDtrack*) part;
+ AliESDtrack* part = (AliESDtrack*) track;
AliESDtrack tpcTrack;
- if (!track->FillTPCOnlyTrack(tpcTrack)) return NULL;
+ if (!part->FillTPCOnlyTrack(tpcTrack)) return NULL;
AliExternalTrackParam param;
- const AliESDVertex* vtxSPD = ((AliESDEvent*) fInputHandler->GetEvent())->GetPrimaryVertexSPD();
+ const AliESDVertex* vtxSPD = ((AliESDEvent*) fInputEvent)->GetPrimaryVertexSPD();
if (!tpcTrack.RelateToVertexTPC(vtxSPD,fField,1.e30,¶m)) return NULL;
pt = param.Pt();
eta = param.Eta();
// kinematic cuts
if (pt < fPtMin || TMath::Abs(eta) > fTrackEtaCut) return NULL;
-
- AliCFParticle* cfpart = new ((*fParticles)[fParticles->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,3);
+ AliCFParticle* cftrack = new ((*fTracks)[fTracks->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,fStorePidInfo ? 3: 0);
- AliVTrack* track = dynamic_cast<AliVTrack*> (part);
- if (!track) return cfpart;
+ if (!fStorePidInfo) return cftrack;
Float_t ncl = track->GetTPCsignalN();
Float_t dedx = track->GetTPCsignalTunedOnData(); if (dedx<=0) dedx = track->GetTPCsignal();
Float_t beta = -99;
track->GetIntegratedTimes(tof);
beta = tof[0]/track->GetTOFsignal();
}
- cfpart->SetAt(ncl,0);
- cfpart->SetAt(dedx,1);
- cfpart->SetAt(beta,2);
- return cfpart;
+ cftrack->SetAt(ncl,0);
+ cftrack->SetAt(dedx,1);
+ cftrack->SetAt(beta,2);
+ return cftrack;
}
// Analysis task to produce trees of lightweight events
// evgeny.kryshen@cern.ch
-#include "AliAnalysisTask.h"
-class AliInputEventHandler;
+#include "AliAnalysisTaskSE.h"
class TList;
class TH1I;
class TTree;
class TClonesArray;
class AliAnalysisFilter;
-class AliPIDResponse;
-class AliVParticle;
+class AliVTrack;
class AliCFParticle;
+class AliAnalysisUtils;
-class AliAnalysisTaskCFTree : public AliAnalysisTask {
+class AliAnalysisTaskCFTree : public AliAnalysisTaskSE {
public:
AliAnalysisTaskCFTree(const char* name="AliAnalysisTaskCFTree");
virtual ~AliAnalysisTaskCFTree(){};
- virtual void ConnectInputData(Option_t *);
- virtual void CreateOutputObjects();
- virtual void Exec(Option_t *option);
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *option);
void SetTrackFilter(AliAnalysisFilter* filter) { fTrackFilter = filter; }
void SetHybridConstrainedMask(UInt_t mask) { fHybridConstrainedMask = mask; }
void SetTPConlyConstrainedMask(UInt_t mask) { fTPConlyConstrainedMask = mask; }
- void SetDebug(Int_t val) { fDebug = val; }
- void SetMode(Int_t val) { fMode = val; }
- void SetAOD(Bool_t val) { fIsAOD = val; }
// Event cut setters
void SetEventSelectionBit(UInt_t val) { fSelectBit = val; }
void SetZVertex(Float_t val) { fZVertexCut = val; }
- void SetTracksInVertex(Int_t val) { fnTracksVertex = val; }
- void SetCentralityMethod(char* val) { fCentralityMethod = val; }
// Track cut setters
void SetTrackFilterBit(UInt_t val) { fTrackFilterBit = val; }
void SetTrackEtaCut(Float_t val) { fTrackEtaCut = val; }
void SetFoundFractionCut(Float_t val) { fFoundFractionCut = val; }
void SetDphiCut(Float_t val) { fDphiCut = val; }
// Switchers for additional data to be stored
- void SetStoreTracks(Bool_t val=kTRUE) { fStoreTracks = val; }
- void SetStoreTracklets(Bool_t val=kTRUE) { fStoreTracklets = val; }
- void SetStoreMuons(Bool_t val=kTRUE) { fStoreMuons = val; }
+ void SetStoreTracks(Bool_t val=kTRUE) { fStoreTracks = val; }
+ void SetStoreTracklets(Bool_t val=kTRUE) { fStoreTracklets = val; }
+ void SetStoreMuons(Bool_t val=kTRUE) { fStoreMuons = val; }
+ void SetStoreMcTracks(Bool_t val=kTRUE) { fStoreMcTracks = val; }
+ void SetStoreMcTracklets(Bool_t val=kTRUE) { fStoreMcTracklets = val; }
+ void SetStoreMcMuons(Bool_t val=kTRUE) { fStoreMcMuons = val; }
+ void SetStorePidInfo(Bool_t val=kTRUE) { fStorePidInfo = val; }
protected:
AliAnalysisTaskCFTree(const AliAnalysisTaskCFTree &task);
AliAnalysisTaskCFTree& operator=(const AliAnalysisTaskCFTree &task);
- UInt_t GetFilterMap(AliVParticle* part);
- AliCFParticle* AddTrack(AliVParticle* track, UInt_t mask, UInt_t flag=0);
+ UInt_t GetFilterMap(AliVTrack* part);
+ AliCFParticle* AddTrack(AliVTrack* track, UInt_t mask, UInt_t flag=0);
- Int_t fDebug; // debug level
- Int_t fMode; // Analysis mode: 0 - data, 1 - mc
- Bool_t fIsAOD; // kTRUE - AOD
- AliInputEventHandler* fInputHandler; // AOD or ESD input handler
- AliInputEventHandler* fMcHandler; // MC input handler (ESD)
- AliAnalysisFilter* fTrackFilter; // track filter used in ESD analysis
+ AliAnalysisFilter* fTrackFilter; // track filter used in ESD analysis
UInt_t fHybridConstrainedMask; // Filter mask for hybrid constrained tracks (ESD analysis)
UInt_t fTPConlyConstrainedMask; // Filter mask for TPConly constrained tracks (ESD analysis)
- AliPIDResponse* fPIDResponse; //!
+ AliAnalysisUtils* fUtils; //! analysis utils to detect pileup
TList* fListOfHistos; //! list of output histograms
TH1I* fEventStatistics; //! cut-by-cut counter of events
TTree* fTree; //! output tree
// Tree variables
- TClonesArray* fParticles; //! tree var: selected AliCFParticles
+ TClonesArray* fTracks; //! tree var: selected AliCFParticles
TClonesArray* fTracklets; //! tree var: selected tracklets (stored if fStoreTracklets=kTRUE)
TClonesArray* fMuons; //! tree var: selected muons (stored if fStoreMuons=kTRUE)
+ TClonesArray* fMcParticles; //! tree var: MC particles
Float_t fField; // tree var: magnetic field value
- Float_t fCentrality; // tree var: centrality
- Float_t fZvtx; // tree var: z-vertex
- Int_t fRunNumber; // tree var: run number
+ Float_t fCentrality[6]; // tree var: centrality
+ Float_t fVtxZ; // tree var: z-vertex
+ Bool_t fVtxTPConly; // tree var: is vertex TPC only
+ UInt_t fVtxContributors; // tree var: number of vertex contributors
UInt_t fPeriod; // tree var: period
UInt_t fOrbit; // tree var: orbit
UShort_t fBc; // tree var: bunch crossing
UInt_t fSelectMask; // tree var: physics selection mask
+ Bool_t fIsPileupSPD; // tree var: is pileup from SPD flag
+ Bool_t fIsPileupMV; // tree var: is pileup from MV flag
+
// Event cuts
UInt_t fSelectBit; // event selection bit
Float_t fZVertexCut; // Z-vertex cut
- Int_t fnTracksVertex; // min number of vertex contributors
- TString fCentralityMethod; // method to determine centrality
// Track cuts
UInt_t fTrackFilterBit; // track filter bits to be stored
Float_t fTrackEtaCut; // maximum abs(eta) cut
Bool_t fStoreTracks; // if kTRUE - Barrel tracks will be stored as AliCFParticles
Bool_t fStoreTracklets; // if kTRUE - SPD tracklets will be stored as AliCFParticles
Bool_t fStoreMuons; // if kTRUE - muon tracks will be stored as AliCFParticles
- ClassDef(AliAnalysisTaskCFTree,3);
+ Bool_t fStoreMcTracks; // if kTRUE - mc particles will be stored as AliCFParticles
+ Bool_t fStoreMcTracklets; // if kTRUE - Store Monte-Carlo info for tracklets
+ Bool_t fStoreMcMuons; // if kTRUE - Store Monte-Carlo info for muons
+ Bool_t fStorePidInfo; // if kTRUE - Store PID info for tracks
+ ClassDef(AliAnalysisTaskCFTree,4);
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff