: 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)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff