: AliAnalysisTaskSE()
,fESD(0)
,fAOD(0)
+ ,fAODJets(0)
,fAODExtension(0)
,fNonStdFile("")
,fBranchRecJets("jets")
,fTrackTypeGen(0)
,fJetTypeGen(0)
,fJetTypeRecEff(0)
+ ,fUseAODInputJets(kTRUE)
,fFilterMask(0)
,fUsePhysicsSelection(kTRUE)
,fEventClass(0)
,fTracksRecCuts(0)
,fTracksGen(0)
,fTracksAODMCCharged(0)
+ ,fTracksAODMCChargedSec(0)
,fTracksRecQualityCuts(0)
,fJetsRec(0)
,fJetsRecCuts(0)
,fh1nRecBckgJetsCuts(0)
,fh1nGenBckgJets(0)
,fh2PtRecVsGenPrim(0)
+ ,fh2PtRecVsGenSec(0)
,fQATrackHistosRecEffGen(0)
- ,fQATrackHistosRecEffRec(0)
+ ,fQATrackHistosRecEffRec(0)
+ ,fQATrackHistosSecRec(0)
,fFFHistosRecEffGen(0)
,fFFHistosRecEffRec(0)
+ ,fFFHistosSecRec(0)
,fhnResponseSinglePt(0)
,fhnResponseJetTrackPt(0)
,fhnResponseJetZ(0)
: AliAnalysisTaskSE(name)
,fESD(0)
,fAOD(0)
+ ,fAODJets(0)
,fAODExtension(0)
,fNonStdFile("")
,fBranchRecJets("jets")
,fTrackTypeGen(0)
,fJetTypeGen(0)
,fJetTypeRecEff(0)
+ ,fUseAODInputJets(kTRUE)
,fFilterMask(0)
,fUsePhysicsSelection(kTRUE)
,fEventClass(0)
,fTracksRecCuts(0)
,fTracksGen(0)
,fTracksAODMCCharged(0)
+ ,fTracksAODMCChargedSec(0)
,fTracksRecQualityCuts(0)
,fJetsRec(0)
,fJetsRecCuts(0)
,fh1nRecBckgJetsCuts(0)
,fh1nGenBckgJets(0)
,fh2PtRecVsGenPrim(0)
+ ,fh2PtRecVsGenSec(0)
,fQATrackHistosRecEffGen(0)
- ,fQATrackHistosRecEffRec(0)
+ ,fQATrackHistosRecEffRec(0)
+ ,fQATrackHistosSecRec(0)
,fFFHistosRecEffGen(0)
,fFFHistosRecEffRec(0)
+ ,fFFHistosSecRec(0)
,fhnResponseSinglePt(0)
,fhnResponseJetTrackPt(0)
,fhnResponseJetZ(0)
: AliAnalysisTaskSE()
,fESD(copy.fESD)
,fAOD(copy.fAOD)
+ ,fAODJets(copy.fAODJets)
,fAODExtension(copy.fAODExtension)
,fNonStdFile(copy.fNonStdFile)
,fBranchRecJets(copy.fBranchRecJets)
,fTrackTypeGen(copy.fTrackTypeGen)
,fJetTypeGen(copy.fJetTypeGen)
,fJetTypeRecEff(copy.fJetTypeRecEff)
+ ,fUseAODInputJets(copy.fUseAODInputJets)
,fFilterMask(copy.fFilterMask)
,fUsePhysicsSelection(copy.fUsePhysicsSelection)
,fEventClass(copy.fEventClass)
,fTracksRecCuts(copy.fTracksRecCuts)
,fTracksGen(copy.fTracksGen)
,fTracksAODMCCharged(copy.fTracksAODMCCharged)
+ ,fTracksAODMCChargedSec(copy.fTracksAODMCChargedSec)
,fTracksRecQualityCuts(copy.fTracksRecQualityCuts)
,fJetsRec(copy.fJetsRec)
,fJetsRecCuts(copy.fJetsRecCuts)
,fh1nRecBckgJetsCuts(copy.fh1nRecBckgJetsCuts)
,fh1nGenBckgJets(copy.fh1nGenBckgJets)
,fh2PtRecVsGenPrim(copy.fh2PtRecVsGenPrim)
+ ,fh2PtRecVsGenSec(copy.fh2PtRecVsGenSec)
,fQATrackHistosRecEffGen(copy.fQATrackHistosRecEffGen)
,fQATrackHistosRecEffRec(copy.fQATrackHistosRecEffRec)
+ ,fQATrackHistosSecRec(copy.fQATrackHistosSecRec)
,fFFHistosRecEffGen(copy.fFFHistosRecEffGen)
- ,fFFHistosRecEffRec(copy.fFFHistosRecEffRec)
+ ,fFFHistosRecEffRec(copy.fFFHistosRecEffRec)
+ ,fFFHistosSecRec(copy.fFFHistosSecRec)
,fhnResponseSinglePt(copy.fhnResponseSinglePt)
,fhnResponseJetTrackPt(copy.fhnResponseJetTrackPt)
,fhnResponseJetZ(copy.fhnResponseJetZ)
AliAnalysisTaskSE::operator=(o);
fESD = o.fESD;
fAOD = o.fAOD;
+ fAODJets = o.fAODJets;
fAODExtension = o.fAODExtension;
fNonStdFile = o.fNonStdFile;
fBranchRecJets = o.fBranchRecJets;
fTrackTypeGen = o.fTrackTypeGen;
fJetTypeGen = o.fJetTypeGen;
fJetTypeRecEff = o.fJetTypeRecEff;
+ fUseAODInputJets = o.fUseAODInputJets;
fFilterMask = o.fFilterMask;
fUsePhysicsSelection = o.fUsePhysicsSelection;
fEventClass = o.fEventClass;
fTracksRecCuts = o.fTracksRecCuts;
fTracksGen = o.fTracksGen;
fTracksAODMCCharged = o.fTracksAODMCCharged;
+ fTracksAODMCChargedSec = o.fTracksAODMCChargedSec;
fTracksRecQualityCuts = o.fTracksRecQualityCuts;
fJetsRec = o.fJetsRec;
fJetsRecCuts = o.fJetsRecCuts;
fh1nGenJets = o.fh1nGenJets;
fh1nRecEffJets = o.fh1nRecEffJets;
fh2PtRecVsGenPrim = o.fh2PtRecVsGenPrim;
+ fh2PtRecVsGenSec = o.fh2PtRecVsGenSec;
fQATrackHistosRecEffGen = o.fQATrackHistosRecEffGen;
fQATrackHistosRecEffRec = o.fQATrackHistosRecEffRec;
+ fQATrackHistosSecRec = o.fQATrackHistosSecRec;
fFFHistosRecEffGen = o.fFFHistosRecEffGen;
- fFFHistosRecEffRec = o.fFFHistosRecEffRec;
+ fFFHistosRecEffRec = o.fFFHistosRecEffRec;
+ fFFHistosSecRec = o.fFFHistosSecRec;
fhnResponseSinglePt = o.fhnResponseSinglePt;
fhnResponseJetTrackPt = o.fhnResponseJetTrackPt;
fhnResponseJetZ = o.fhnResponseJetZ;
{
// destructor
- if(fTracksRec) delete fTracksRec;
- if(fTracksRecCuts) delete fTracksRecCuts;
- if(fTracksGen) delete fTracksGen;
- if(fTracksAODMCCharged) delete fTracksAODMCCharged;
- if(fTracksRecQualityCuts) delete fTracksRecQualityCuts;
- if(fJetsRec) delete fJetsRec;
- if(fJetsRecCuts) delete fJetsRecCuts;
- if(fJetsGen) delete fJetsGen;
- if(fJetsRecEff) delete fJetsRecEff;
+ if(fTracksRec) delete fTracksRec;
+ if(fTracksRecCuts) delete fTracksRecCuts;
+ if(fTracksGen) delete fTracksGen;
+ if(fTracksAODMCCharged) delete fTracksAODMCCharged;
+ if(fTracksAODMCChargedSec) delete fTracksAODMCChargedSec;
+ if(fTracksRecQualityCuts) delete fTracksRecQualityCuts;
+ if(fJetsRec) delete fJetsRec;
+ if(fJetsRecCuts) delete fJetsRecCuts;
+ if(fJetsGen) delete fJetsGen;
+ if(fJetsRecEff) delete fJetsRecEff;
if(fBckgMode &&
(fBckgType[0]==kBckgClusters || fBckgType[1]==kBckgClusters || fBckgType[2]==kBckgClusters || fBckgType[3]==kBckgClusters || fBckgType[4]==kBckgClusters ||
fBckgType[0]==kBckgClustersOutLeading || fBckgType[1]==kBckgClustersOutLeading || fBckgType[2]==kBckgClustersOutLeading ||
fTracksAODMCCharged = new TList();
fTracksAODMCCharged->SetOwner(kFALSE);
+ fTracksAODMCChargedSec = new TList();
+ fTracksAODMCChargedSec->SetOwner(kFALSE);
+
fTracksRecQualityCuts = new TList();
fTracksRecQualityCuts->SetOwner(kFALSE);
fh1nGenJets = new TH1F("fh1nGenJets","generated jets per event",10,-0.5,9.5);
fh1nRecEffJets = new TH1F("fh1nRecEffJets","reconstruction effiency: jets per event",10,-0.5,9.5);
fh2PtRecVsGenPrim = new TH2F("fh2PtRecVsGenPrim","rec vs gen pt",fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax,fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax);
+ fh2PtRecVsGenSec = new TH2F("fh2PtRecVsGenSec","rec vs gen pt",fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax,fQATrackNBinsPt,fQATrackPtMin,fQATrackPtMax);
// Background
if(fBckgMode) {
fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
fQATrackHighPtThreshold);
+ fQATrackHistosSecRec = new AliFragFuncQATrackHistos("SecRec", fQATrackNBinsPt, fQATrackPtMin, fQATrackPtMax,
+ fQATrackNBinsEta, fQATrackEtaMin, fQATrackEtaMax,
+ fQATrackNBinsPhi, fQATrackPhiMin, fQATrackPhiMax,
+ fQATrackHighPtThreshold);
+
Int_t nBinsResponseSinglePt[2] = {fFFNBinsPt, fFFNBinsPt};
Double_t binMinResponseSinglePt[2] = {fFFPtMin, fFFPtMin};
fFFNBinsXi, fFFXiMin, fFFXiMax,
fFFNBinsZ , fFFZMin , fFFZMax);
+ fFFHistosSecRec = new AliFragFuncHistos("SecRec", fFFNBinsJetPt, fFFJetPtMin, fFFJetPtMax,
+ fFFNBinsPt, fFFPtMin, fFFPtMax,
+ fFFNBinsXi, fFFXiMin, fFFXiMax,
+ fFFNBinsZ , fFFZMin , fFFZMax);
+
Int_t nBinsResponseJetTrackPt[3] = {fFFNBinsJetPt,fFFNBinsPt,fFFNBinsPt};
Double_t binMinResponseJetTrackPt[3] = {fFFJetPtMin,fFFPtMin, fFFPtMin};
if(fQAMode&1){
fQATrackHistosRecEffGen->DefineHistos();
fQATrackHistosRecEffRec->DefineHistos();
+ fQATrackHistosSecRec->DefineHistos();
}
if(fFFMode){
fFFHistosRecEffGen->DefineHistos();
fFFHistosRecEffRec->DefineHistos();
+ fFFHistosSecRec->DefineHistos();
}
} // end: efficiency
if(fQAMode&1){
fQATrackHistosRecEffGen->AddToOutput(fCommonHistList);
fQATrackHistosRecEffRec->AddToOutput(fCommonHistList);
+ fQATrackHistosSecRec->AddToOutput(fCommonHistList);
fCommonHistList->Add(fhnResponseSinglePt);
}
if(fFFMode){
fFFHistosRecEffGen->AddToOutput(fCommonHistList);
fFFHistosRecEffRec->AddToOutput(fCommonHistList);
+ fFFHistosSecRec->AddToOutput(fCommonHistList);
fCommonHistList->Add(fhnResponseJetTrackPt);
fCommonHistList->Add(fhnResponseJetZ);
fCommonHistList->Add(fhnResponseJetXi);
}
fCommonHistList->Add(fh1nRecEffJets);
fCommonHistList->Add(fh2PtRecVsGenPrim);
+ fCommonHistList->Add(fh2PtRecVsGenSec);
}
TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
if( handler && handler->InheritsFrom("AliAODInputHandler") ) {
fAOD = ((AliAODInputHandler*)handler)->GetEvent();
+ if(fUseAODInputJets) fAODJets = fAOD;
if (fDebug > 1) Printf("%s:%d AOD event from input", (char*)__FILE__,__LINE__);
}
else {
handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
if( handler && handler->InheritsFrom("AliAODHandler") ) {
- fAOD = ((AliAODHandler*)handler)->GetAOD();
+ fAOD = ((AliAODHandler*)handler)->GetAOD();
+ fAODJets = fAOD;
if (fDebug > 1) Printf("%s:%d AOD event from output", (char*)__FILE__,__LINE__);
}
}
+ if(!fAODJets && !fUseAODInputJets){ // case we have AOD in input & output and want jets from output
+ TObject* outHandler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
+ if( outHandler && outHandler->InheritsFrom("AliAODHandler") ) {
+ fAODJets = ((AliAODHandler*)outHandler)->GetAOD();
+ if (fDebug > 1) Printf("%s:%d jets from output AOD", (char*)__FILE__,__LINE__);
+ }
+ }
+
if(fNonStdFile.Length()!=0){
// case we have an AOD extension - fetch the jets from the extended output
Printf("%s:%d AODEvent not found", (char*)__FILE__,__LINE__);
return;
}
+ if(!fAODJets){
+ Printf("%s:%d AODEvent with jet branch not found", (char*)__FILE__,__LINE__);
+ return;
+ }
+
// event selection **************************************************
// *** event class ***
if(fEffMode && (fJetTypeRecEff != kJetsUndef)){
- // arrays for generated particles: reconstructed AOD track index, isPrimary flag, are initialized in AssociateGenRec(...) function
+ // arrays holding for each generated particle the reconstructed AOD track index & isPrimary flag, are initialized in AssociateGenRec(...) function
TArrayI indexAODTr;
TArrayS isGenPrim;
-
- // array for reconcstructed AOD tracks: generated particle index, initialized in AssociateGenRec(...) function
+
+ // array holding for each reconstructed AOD track generated particle index, initialized in AssociateGenRec(...) function
TArrayI indexMCTr;
-
+
+ // ... and another set for secondaries (secondary MC tracks are stored in a different list)
+ TArrayI indexAODTrSec;
+ TArrayS isGenSec;
+ TArrayI indexMCTrSec;
+
Int_t nTracksAODMCCharged = GetListOfTracks(fTracksAODMCCharged, kTrackAODMCCharged);
if(fDebug>2)Printf("%s:%d selected AODMC tracks: %d ",(char*)__FILE__,__LINE__,nTracksAODMCCharged);
+ Int_t nTracksAODMCChargedSec = GetListOfTracks(fTracksAODMCChargedSec, kTrackAODMCChargedSec);
+ if(fDebug>2)Printf("%s:%d selected AODMC secondary tracks: %d ",(char*)__FILE__,__LINE__,nTracksAODMCChargedSec);
+
Int_t nTracksRecQualityCuts = GetListOfTracks(fTracksRecQualityCuts, kTrackAODQualityCuts);
if(fDebug>2)Printf("%s:%d selected rec tracks quality after cuts, full acceptance/pt : %d ",(char*)__FILE__,__LINE__,nTracksRecQualityCuts);
// associate gen and rec tracks, store indices in TArrays
- AssociateGenRec(fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,indexMCTr,isGenPrim);
+ AssociateGenRec(fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,indexMCTr,isGenPrim,fh2PtRecVsGenPrim);
+ AssociateGenRec(fTracksAODMCChargedSec,fTracksRecQualityCuts,indexAODTrSec,indexMCTrSec,isGenSec,fh2PtRecVsGenSec);
// single track eff
- if(fQAMode&1) FillSingleTrackRecEffHisto(fQATrackHistosRecEffGen,fQATrackHistosRecEffRec,fTracksAODMCCharged,indexAODTr,isGenPrim);
+ if(fQAMode&1) FillSingleTrackHistosRecGen(fQATrackHistosRecEffGen,fQATrackHistosRecEffRec,fTracksAODMCCharged,indexAODTr,isGenPrim);
if(fQAMode&1) FillSingleTrackResponse(fhnResponseSinglePt,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim);
+ // secondaries
+ if(fQAMode&1) FillSingleTrackHistosRecGen(0x0,fQATrackHistosSecRec,fTracksAODMCChargedSec,indexAODTrSec,isGenSec);
// jet track eff
Double_t sumPtGenLeadingJetRecEff = 0;
+ Double_t sumPtGenLeadingJetSec = 0;
Double_t sumPtRecLeadingJetRecEff = 0;
for(Int_t ij=0; ij<nRecEffJets; ++ij){
if(ij==0){ // leading jet
- TList* jettracklistGen = new TList();
- GetJetTracksPointing(fTracksGen, jettracklistGen, jet, GetFFRadius(), sumPtGenLeadingJetRecEff); // for efficiency: gen tracks from pointing with gen/rec jet
+ TList* jettracklistGenPrim = new TList();
+ GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, GetFFRadius(), sumPtGenLeadingJetRecEff); // for efficiency: gen tracks from pointing with gen/rec jet
+
+ TList* jettracklistGenSec = new TList();
+ GetJetTracksPointing(fTracksAODMCChargedSec, jettracklistGenSec, jet, GetFFRadius(), sumPtGenLeadingJetSec); // for efficiency: gen tracks from pointing with gen/rec jet
TList* jettracklistRec = new TList();
GetJetTracksPointing(fTracksRecCuts,jettracklistRec, jet, GetFFRadius(), sumPtRecLeadingJetRecEff); // bin efficiency in jet pt bins using rec tracks
if(fQAMode&2) fQAJetHistosRecEffLeading->FillJetQA( jetEta, jetPhi, sumPtGenLeadingJetRecEff );
- if(fFFMode) FillJetTrackRecEffHisto(fFFHistosRecEffGen,fFFHistosRecEffRec,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,
- jettracklistGen,fTracksAODMCCharged,indexAODTr,isGenPrim,fUseRecEffRecJetPtBins);
-
+ if(fFFMode) FillJetTrackHistosRecGen(fFFHistosRecEffGen,fFFHistosRecEffRec,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,
+ jettracklistGenPrim,fTracksAODMCCharged,indexAODTr,isGenPrim,fUseRecEffRecJetPtBins);
+
if(fFFMode) FillJetTrackResponse(fhnResponseJetTrackPt,fhnResponseJetZ,fhnResponseJetXi,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,
- jettracklistGen,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,fUseResponseRecJetPtBins);
+ jettracklistGenPrim,fTracksAODMCCharged,fTracksRecQualityCuts,indexAODTr,isGenPrim,fUseResponseRecJetPtBins);
+
+ // secondaries: use jet pt from primaries
+ if(fFFMode) FillJetTrackHistosRecGen(0x0,fFFHistosSecRec,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,
+ jettracklistGenSec,fTracksAODMCChargedSec,indexAODTrSec,isGenSec,fUseRecEffRecJetPtBins);
- delete jettracklistGen;
+ delete jettracklistGenPrim;
+ delete jettracklistGenSec;
delete jettracklistRec;
}
}
fTracksRecCuts->Clear();
fTracksGen->Clear();
fTracksAODMCCharged->Clear();
+ fTracksAODMCChargedSec->Clear();
fTracksRecQualityCuts->Clear();
fJetsRec->Clear();
iCount++;
}
}
- else if (type==kTrackAODMCCharged || type==kTrackAODMCAll || type==kTrackAODMCChargedAcceptance) {
+ else if (type==kTrackAODMCCharged || type==kTrackAODMCAll || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSec) {
// MC particles (from AOD), physical primaries, all or rather charged or rather charged within acceptance
if(!fAOD) return -1;
for(int it=0; it<tca->GetEntriesFast(); ++it){
AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(it));
if(!part)continue;
- if(!part->IsPhysicalPrimary())continue;
+ if(type != kTrackAODMCChargedSec && !part->IsPhysicalPrimary())continue;
+ if(type == kTrackAODMCChargedSec && part->IsPhysicalPrimary())continue;
- if (type==kTrackAODMCCharged || type==kTrackAODMCChargedAcceptance){
+ if (type==kTrackAODMCCharged || type==kTrackAODMCChargedAcceptance || type==kTrackAODMCChargedSec){
if(part->Charge()==0) continue;
if(type==kTrackAODMCChargedAcceptance &&
( part->Eta() > fTrackEtaMax
}
TClonesArray *aodRecJets = 0;
- if(fBranchRecJets.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchRecJets.Data()));
+ if(fBranchRecJets.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecJets.Data()));
+ if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecJets.Data()));
if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecJets.Data()));
- if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->GetList()->FindObject(fBranchRecJets.Data()));
if(!aodRecJets){
if(fBranchRecJets.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecJets.Data());
}
TClonesArray *aodGenJets = 0;
- if(fBranchGenJets.Length()) aodGenJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchGenJets.Data()));
- if(!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAOD->GetList()->FindObject(fBranchGenJets.Data()));
+ if(fBranchGenJets.Length()) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchGenJets.Data()));
+ if(!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchGenJets.Data()));
if(fAODExtension&&!aodGenJets) aodGenJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchGenJets.Data()));
if(!aodGenJets){
}
TClonesArray *aodRecJets = 0;
- if(fBranchRecBckgClusters.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchRecBckgClusters.Data()));
- if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAOD->GetList()->FindObject(fBranchRecBckgClusters.Data()));
- if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecBckgClusters.Data()));
+ if(fBranchRecBckgClusters.Length()) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->FindListObject(fBranchRecBckgClusters.Data()));
+ if(!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODJets->GetList()->FindObject(fBranchRecBckgClusters.Data()));
+ if(fAODExtension&&!aodRecJets) aodRecJets = dynamic_cast<TClonesArray*>(fAODExtension->GetAOD()->FindListObject(fBranchRecBckgClusters.Data()));
if(!aodRecJets){
if(fBranchRecBckgClusters.Length()) Printf("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fBranchRecBckgClusters.Data());
}
// _ ________________________________________________________________________________________________________________________________
-void AliAnalysisTaskFragmentationFunction::AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,TArrayS& isGenPrim)
+void AliAnalysisTaskFragmentationFunction::AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,
+ TArrayS& isRefGen,TH2F* fh2PtRecVsGen)
{
// associate generated and reconstructed tracks, fill TArrays of list indices
-
Int_t nTracksRec = tracksRec->GetSize();
Int_t nTracksGen = tracksAODMCCharged->GetSize();
TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
+
if(!nTracksGen) return;
if(!tca) return;
// set size
indexAODTr.Set(nTracksGen);
indexMCTr.Set(nTracksRec);
- isGenPrim.Set(nTracksGen);
+ isRefGen.Set(nTracksGen);
indexAODTr.Reset(-1);
indexMCTr.Reset(-1);
- isGenPrim.Reset(0);
+ isRefGen.Reset(0);
// loop over reconstructed tracks, get generated track
indexAODTr[listIndex] = iRec;
indexMCTr[iRec] = listIndex;
}
- }
+ }
- // define primary sample for reconstruction efficiency
+ // define reference sample of primaries/secondaries (for reconstruction efficiency / contamination)
for(Int_t iGen=0; iGen<nTracksGen; iGen++){
if(TMath::Abs(pdg) == 211 || TMath::Abs(pdg) == 2212 || TMath::Abs(pdg) == 321 ||
TMath::Abs(pdg) == 11 || TMath::Abs(pdg) == 13){
- isGenPrim[iGen] = kTRUE;
+ isRefGen[iGen] = kTRUE;
Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
AliAODTrack* vt = dynamic_cast<AliAODTrack*>(tracksRec->At(iRec));
if(vt){
Float_t recPt = vt->Pt();
- fh2PtRecVsGenPrim->Fill(genPt,recPt);
+ fh2PtRecVsGen->Fill(genPt,recPt);
}
}
}
}
// _____________________________________________________________________________________________________________________________________________
-void AliAnalysisTaskFragmentationFunction::FillSingleTrackRecEffHisto(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
- const TArrayI& indexAODTr, const TArrayS& isGenPrim){
+void AliAnalysisTaskFragmentationFunction::FillSingleTrackHistosRecGen(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
+ const TArrayI& indexAODTr, const TArrayS& isRefGen){
// fill QA for single track reconstruction efficiency
for(Int_t iGen=0; iGen<nTracksGen; iGen++){
- if(isGenPrim[iGen] != 1) continue; // select primaries
+ if(isRefGen[iGen] != 1) continue; // select primaries
AliAODMCParticle* gentrack = dynamic_cast<AliAODMCParticle*> (tracksGen->At(iGen));
- if(!gentrack)continue;
+ if(!gentrack) continue;
Double_t ptGen = gentrack->Pt();
Double_t etaGen = gentrack->Eta();
Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
if(phiGen < fTrackPhiMin || phiGen > fTrackPhiMax) continue;
if(ptGen < fTrackPtCut) continue;
- trackQAGen->FillTrackQA(etaGen, phiGen, ptGen);
+ if(trackQAGen) trackQAGen->FillTrackQA(etaGen, phiGen, ptGen);
Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
- if(iRec>=0) trackQARec->FillTrackQA(etaGen, phiGen, ptGen);
+ if(iRec>=0 && trackQARec) trackQARec->FillTrackQA(etaGen, phiGen, ptGen);
}
}
// ______________________________________________________________________________________________________________________________________________________
-void AliAnalysisTaskFragmentationFunction::FillJetTrackRecEffHisto(TObject* histGen, TObject* histRec, Double_t jetPtGen, Double_t jetPtRec, TList* jetTrackList,
- const TList* tracksGen, const TArrayI& indexAODTr, const TArrayS& isGenPrim, const Bool_t useRecJetPt)
-{
- // fill objects for jet track reconstruction efficiency
+void AliAnalysisTaskFragmentationFunction::FillJetTrackHistosRecGen(TObject* histGen,TObject* histRec,Double_t jetPtGen,Double_t jetPtRec, TList* jetTrackList, const TList* tracksGen,
+ const TArrayI& indexAODTr,const TArrayS& isRefGen, const Bool_t useRecJetPt)
+{
+ // fill objects for jet track reconstruction efficiency or secondaries contamination
// arguments histGen/histRec can be of different type: AliFragFuncHistos*, AliFragFuncIntraJetHistos*, ...
Int_t nTracksJet = jetTrackList->GetSize(); // list with AODMC tracks
continue;
}
- if(isGenPrim[iGen] != 1) continue; // select primaries
-
+
+ if(isRefGen[iGen] != 1) continue; // select primaries
+
Double_t ptGen = gentrack->Pt();
Double_t etaGen = gentrack->Eta();
Double_t phiGen = TVector2::Phi_0_2pi(gentrack->Phi());
Int_t iRec = indexAODTr[iGen]; // can be -1 if no good reconstructed track
Bool_t isRec = (iRec>=0) ? kTRUE : kFALSE;
- if(dynamic_cast<AliFragFuncHistos*>(histGen) && dynamic_cast<AliFragFuncHistos*>(histRec)){
+ if(dynamic_cast<AliFragFuncHistos*>(histGen) || dynamic_cast<AliFragFuncHistos*>(histRec)){ // histGen can be NULL for secondaries -> ||
// after checking can afford normal cast
- AliFragFuncHistos* effFFhistGen = (AliFragFuncHistos*)(histGen);
- AliFragFuncHistos* effFFhistRec = (AliFragFuncHistos*)(histRec);
-
- if(useRecJetPt) effFFhistGen->FillFF( ptGen, jetPtRec, incrementJetPtGenFF );
- else effFFhistGen->FillFF( ptGen, jetPtGen, incrementJetPtGenFF );
+ AliFragFuncHistos* FFhistGen = (AliFragFuncHistos*) (histGen);
+ AliFragFuncHistos* FFhistRec = (AliFragFuncHistos*) (histRec);
- incrementJetPtGenFF = kFALSE;
+ if(FFhistGen){
+ if(useRecJetPt) FFhistGen->FillFF( ptGen, jetPtRec, incrementJetPtGenFF );
+ else FFhistGen->FillFF( ptGen, jetPtGen, incrementJetPtGenFF );
+
+ incrementJetPtGenFF = kFALSE;
+ }
- if(isRec){
- if(useRecJetPt) effFFhistRec->FillFF( ptGen, jetPtRec, incrementJetPtRecFF );
- else effFFhistRec->FillFF( ptGen, jetPtGen, incrementJetPtRecFF );
+
+ if(FFhistRec && isRec){
+
+ if(useRecJetPt) FFhistRec->FillFF( ptGen, jetPtRec, incrementJetPtRecFF );
+ else FFhistRec->FillFF( ptGen, jetPtGen, incrementJetPtRecFF );
incrementJetPtRecFF = kFALSE;
}
}
}
-
// _____________________________________________________________________________________________________________________________________________
void AliAnalysisTaskFragmentationFunction::FillSingleTrackResponse(THnSparse* hnResponse, TList* tracksGen, TList* tracksRec,
const TArrayI& indexAODTr, const TArrayS& isGenPrim)
Float_t trackPhiMin = 0., Float_t trackPhiMax = 2*TMath::Pi())
{fTrackPtCut = trackPt; fTrackEtaMin = trackEtaMin; fTrackEtaMax = trackEtaMax;
fTrackPhiMin = trackPhiMin; fTrackPhiMax = trackPhiMax;}
+
+ virtual void UseAODInputJets(Bool_t b) {fUseAODInputJets = b;}
virtual void SetFilterMask(UInt_t i) {fFilterMask = i;}
virtual void UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;}
virtual void SetEventClass(Int_t i){fEventClass = i;}
Double_t GetDiJetBin(Double_t invMass, Double_t leadingJetPt, Double_t eMean, Int_t kindSlices); // function to find which bin fill
Double_t InvMass(const AliAODJet* jet1, const AliAODJet* jet2);
- void AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,TArrayS& isGenPrim);
- void FillSingleTrackRecEffHisto(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen, const TArrayI& indexAODTr, const TArrayS& isGenPrim);
- void FillJetTrackRecEffHisto(TObject* histGen,TObject* histRec,Double_t jetPtGen,Double_t jetPtRec, TList* jetTrackList, const TList* tracksGen,
- const TArrayI& indexAODTr,const TArrayS& isGenPrim, const Bool_t useRecJetPt);
- void FillSingleTrackResponse(THnSparse* hnResponse, TList* tracksGen, TList* tracksRec, const TArrayI& indexAODTr, const TArrayS& isGenPrim);
+ void AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,TArrayS& isRefGen,TH2F* fh2PtRecVsGen);
+
+ void FillSingleTrackHistosRecGen(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
+ const TArrayI& indexAODTr, const TArrayS& isRefGen);
+ void FillJetTrackHistosRecGen(TObject* histGen,TObject* histRec,Double_t jetPtGen,Double_t jetPtRec, TList* jetTrackList, const TList* tracksGen,
+ const TArrayI& indexAODTr,const TArrayS& isRefGen, const Bool_t useRecJetPt);
+ void FillSingleTrackResponse(THnSparse* hnResponse, TList* tracksGen, TList* tracksRec, const TArrayI& indexAODTr, const TArrayS& isGenPrim);
void FillJetTrackResponse(THnSparse* hnResponsePt, THnSparse* hnResponseZ, THnSparse* hnResponseXi,
Double_t jetPtGen, Double_t jetPtRec, TList* jetTrackList,
const TList* tracksGen, TList* tracksRec, const TArrayI& indexAODTr, const TArrayS& isGenPrim,const Bool_t useRecJetPt);
-
- //
Float_t CalcJetArea(const Float_t etaJet, const Float_t rc) const;
// Consts
enum {kTrackUndef=0, kTrackAOD, kTrackAODQualityCuts, kTrackAODCuts, kTrackKineAll, kTrackKineCharged, kTrackKineChargedAcceptance,
- kTrackAODMCAll, kTrackAODMCCharged, kTrackAODMCChargedAcceptance};
+ kTrackAODMCAll, kTrackAODMCCharged, kTrackAODMCChargedAcceptance, kTrackAODMCChargedSec};
enum {kJetsUndef=0, kJetsRec, kJetsRecAcceptance, kJetsGen, kJetsGenAcceptance, kJetsKine, kJetsKineAcceptance};
enum {kBckgPerp=0, kBckgOutLJ, kBckgOut2J, kBckgClusters, kBckgClustersOutLeading, kBckgOut3J, kBckgOutAJ, kBckgOutLJStat,
kBckgOut2JStat, kBckgOut3JStat, kBckgOutAJStat, kBckgASide, kBckgASideWindow, kBckgPerpWindow};
AliESDEvent* fESD; // ESD event
AliAODEvent* fAOD; // AOD event
+ AliAODEvent* fAODJets; // AOD event with jet branch (case we have AOD both in input and output)
AliAODExtension *fAODExtension; //! where we take the jets from can be input or output AOD
//AliMCEvent* fMCEvent; // MC event
TString fNonStdFile; // name of delta aod file to catch the extension
Int_t fJetTypeRecEff; // type of jets used for filling reconstruction efficiency histos
+ Bool_t fUseAODInputJets; // take jets from in/output - only relevant if AOD event both in input AND output and we want to use output
UInt_t fFilterMask; // filter bit for selected tracks
Bool_t fUsePhysicsSelection; // switch for event selection
Int_t fEventClass; // event class to be looked at for this instace of the task
Float_t fAvgTrials; // average number of trials per event
- TList* fTracksRec; //! reconstructed tracks
- TList* fTracksRecCuts; //! reconstructed tracks after cuts
- TList* fTracksGen; //! generated tracks
- TList* fTracksAODMCCharged; //! AOD MC tracks
- TList* fTracksRecQualityCuts; //! reconstructed tracks after quality cuts, no acceptance/pt cut
+ TList* fTracksRec; //! reconstructed tracks
+ TList* fTracksRecCuts; //! reconstructed tracks after cuts
+ TList* fTracksGen; //! generated tracks
+ TList* fTracksAODMCCharged; //! AOD MC tracks
+ TList* fTracksAODMCChargedSec; //! AOD MC tracks - secondaries
+ TList* fTracksRecQualityCuts; //! reconstructed tracks after quality cuts, no acceptance/pt cut
TList* fJetsRec; //! jets from reconstructed tracks
TH1F *fh1nRecEffJets; //! number of jets for reconstruction eff per event
TH1F *fh1nRecBckgJetsCuts; //! number of jets from reconstructed tracks per event
TH1F *fh1nGenBckgJets; //! number of jets from generated tracks per event
- TH2F *fh2PtRecVsGenPrim; //! association rec/gen MC: rec vs gen pt
+ TH2F *fh2PtRecVsGenPrim; //! association rec/gen MC: rec vs gen pt, primaries
+ TH2F *fh2PtRecVsGenSec; //! association rec/gen MC: rec vs gen pt, secondaries
- // tracking efficiency
+ // tracking efficiency / secondaries
AliFragFuncQATrackHistos* fQATrackHistosRecEffGen; //! tracking efficiency: generated primaries
AliFragFuncQATrackHistos* fQATrackHistosRecEffRec; //! tracking efficiency: reconstructed primaries
+ AliFragFuncQATrackHistos* fQATrackHistosSecRec; //! reconstructed secondaries
AliFragFuncHistos* fFFHistosRecEffGen; //! tracking efficiency: FF generated primaries
AliFragFuncHistos* fFFHistosRecEffRec; //! tracking efficiency: FF reconstructed primaries
+ AliFragFuncHistos* fFFHistosSecRec; //! secondary contamination: FF reconstructed secondaries
// momentum resolution
THnSparse* fhnResponseSinglePt; //! single track response pt
//== grid plugin setup variables
Bool_t kPluginUse = kTRUE; // do not change
Bool_t kPluginUseProductionMode = kFALSE; // use the plugin in production mode
-TString kPluginRootVersion = "v5-27-06b"; // *CHANGE ME IF MORE RECENT IN GRID*
+TString kPluginRootVersion = "v5-28-00a"; // *CHANGE ME IF MORE RECENT IN GRID*
TString kPluginAliRootVersion = "v4-19-15-AN"; // *CHANGE ME IF MORE RECENT IN GRID*
Bool_t kPluginMergeViaJDL = kTRUE; // merge via JDL
Bool_t kPluginFastReadOption = kFALSE; // use xrootd tweaks
}
*/
+
if(iPhysicsSelection && !iAODanalysis){
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
Int_t iTriggerHIC = 0;
rejectBkg = false; // for the moment...
}
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,rejectBkg);
- iPhysicsSelectionFlag = AliVEvent::kMB;
+
mgr->RegisterExtraFile("EventStat_temp.root");
mgr->AddStatisticsTask();
}
+ else{
+ iPhysicsSelectionFlag = AliVEvent::kMB;
+ }
if(iCentralitySelection){
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetCentralityCut(fCenLo,fCenUp);
taskCl->SetGhostEtamax(fTrackEtaWindow);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
kDefaultJetBackgroundBranchCut1 = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
if (iPWG4FastEmbedding) {
taskClEmb->SetBackgroundCalc(kTRUE);
taskClEmb->SetCentralityCut(fCenLo,fCenUp);
taskClEmb->SetGhostEtamax(fTrackEtaWindow);
+ if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
kDefaultJetBackgroundBranch_extra = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskClEmb->GetJetOutputBranch());
taskClEmb = AddTaskJetCluster("AODextraonly","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
taskClEmb->SetBackgroundCalc(kFALSE);
taskClEmb->SetCentralityCut(fCenLo,fCenUp);
taskClEmb->SetGhostEtamax(fTrackEtaWindow);
-
+ if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
+
taskClEmb = AddTaskJetCluster("AODextra","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1,kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
taskClEmb->SetCentralityCut(fCenLo,fCenUp);
taskClEmb->SetBackgroundBranch(kDefaultJetBackgroundBranch_extra.Data());
kJetSubtractBranches_extra += Form("%s ",taskClEmb->GetJetOutputBranch());
+ if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
taskClEmb = AddTaskJetCluster("AODextraonly","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1,kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
taskClEmb->SetCentralityCut(fCenLo,fCenUp);
+ if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
}
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.2,0,1, kDeltaAODJetName.Data(),0.15); // this one is for the background and random jets
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetCentralityCut(fCenLo,fCenUp);
taskCl->SetGhostEtamax(fTrackEtaWindow);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
}
else{
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1,kDeltaAODJetName.Data(),0.15); // this one is for the background jets
taskCl->SetBackgroundCalc(kTRUE);
kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
taskCl->SetGhostEtamax(fTrackEtaWindow);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetGhostEtamax(fTrackEtaWindow);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
}
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
taskCl->SetNRandomCones(1);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
kDefaultJetBranch = taskCl->GetJetOutputBranch();
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),2.0);
taskCl->SetCentralityCut(fCenLo,fCenUp);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranchCut1.Data());
kJetSubtractBranchesCut1 += Form("%s ",taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetGhostEtamax(0.9);
kDefaultJetBackgroundBranchMC = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
-
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
+
taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15); // this one is for the background and random jets
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetGhostEtamax(fTrackEtaWindow);
kDefaultJetBackgroundBranchMC2 = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch(),fTrackEtaWindow);
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
}
else{
taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetGhostEtamax(fTrackEtaWindow);
kDefaultJetBackgroundBranchMC2 = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
// pp background calcs...
}
taskCl->SetGhostEtamax(fTrackEtaWindow);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranchMC.Data());
kDefaultJetBranchMC = taskCl->GetJetOutputBranch();
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranchMC2.Data());
kDefaultJetBranchMC2 = taskCl->GetJetOutputBranch();
-
+ if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
}
//
// the random jets...
- taskjetSpectrum = AddTaskJetSpectrum2("clustersAOD_KT04_B0_Filter00256_Cut00150_Skip00RandomConeSkip00",
- "clustersAOD_KT04_B0_Filter00256_Cut00150_Skip00RandomCone_random",
+ taskjetSpectrum = AddTaskJetSpectrum2(
+ Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00RandomConeSkip00",kHighPtFilterMask),
+ Form("clustersAOD_KT04_B0_Filter%05d_Cut00150_Skip00RandomCone_random",kHighPtFilterMask),
kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
taskjetSpectrum->SetBranchBkgRec(bkgClusters.Data());
taskjetSpectrum->SetTrackEtaWindow(fTrackEtaWindow);
taskjetSpectrum->SetJetEtaWindow(fJetEtaWindow);
- taskjetSpectrum = AddTaskJetSpectrum2("clustersAOD_KT04_B0_Filter00256_Cut02000_Skip00RandomConeSkip00",
- "clustersAOD_KT04_B0_Filter00256_Cut02000_Skip00RandomCone_random",
+ taskjetSpectrum = AddTaskJetSpectrum2(
+ Form("clustersAOD_KT04_B0_Filter%05d_Cut02000_Skip00RandomConeSkip00",kHighPtFilterMask),
+ Form("clustersAOD_KT04_B0_Filter%05d_Cut02000_Skip00RandomCone_random",kHighPtFilterMask),
kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
taskjetSpectrum->SetBranchBkgRec(bkgClustersCut1.Data());
taskjetSpectrum->SetBranchBkgGen(bkgClustersCut1.Data());
// Anti-kT
taskFrag = AddTaskFragmentationFunction(1<<23,kHighPtFilterMask, 1);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
taskFrag = AddTaskFragmentationFunction(1<<23,kHighPtFilterMask, 2);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
taskFrag = AddTaskFragmentationFunction(1<<23,kHighPtFilterMask, 3);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
taskFrag = AddTaskFragmentationFunction(1<<23,kHighPtFilterMask, 4);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
// UA1
taskFrag = AddTaskFragmentationFunction(1<<0,kHighPtFilterMask, 1);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
taskFrag = AddTaskFragmentationFunction(1<<0,kHighPtFilterMask, 2);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
taskFrag = AddTaskFragmentationFunction(1<<0,kHighPtFilterMask, 3);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
taskFrag = AddTaskFragmentationFunction(1<<0,kHighPtFilterMask, 4);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
// SISCONE
/*
// Anti-kT B2 - B3
taskFrag = AddTaskFragmentationFunction(1<<26,kHighPtFilterMask, 1);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
+
+
taskFrag = AddTaskFragmentationFunction(1<<27,kHighPtFilterMask, 1);
if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
-
+ if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
}
if (!taskFrag) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskFragmentationFunction cannot run for this train conditions - EXCLUDED");
::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain");
return;
}
- mgr->StartAnalysis(mode, chain);
+ // mgr->StartAnalysis(mode, chain);
mgr->StartAnalysis(mode, chain,kNumberOfEvents);
}
return;
// Define production directory LFN
plugin->SetGridDataDir(kGridDatadir.Data());
// Set data search pattern
- if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.Jets.root");
+ if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root");
// else plugin->SetDataPattern(Form(" %s/*/*ESD.tag.root",kGridPassPattern.Data()));
else plugin->SetDataPattern(Form(" %s/*/*AliESDs.root",kGridPassPattern.Data()));
// ...then add run numbers to be considered