,fRandom(0)
+ ,fOnlyLeadingJets(kFALSE)
+
// PID framework
,fNumInclusivePIDtasks(0)
,fNumJetPIDtasks(0)
,fProNtracksLeadingJetRecSecS(0)
,fProNtracksLeadingJetRecSecSsc(0)
,fRandom(0)
+ ,fOnlyLeadingJets(kFALSE)
// PID framework
,fNumInclusivePIDtasks(0)
,fNumJetPIDtasks(0)
,fProNtracksLeadingJetRecSecS(copy.fProNtracksLeadingJetRecSecS)
,fProNtracksLeadingJetRecSecSsc(copy.fProNtracksLeadingJetRecSecSsc)
,fRandom(copy.fRandom)
+ ,fOnlyLeadingJets(copy.fOnlyLeadingJets)
// PID framework
,fNumInclusivePIDtasks(copy.fNumInclusivePIDtasks)
,fNumJetPIDtasks(copy.fNumJetPIDtasks)
fProNtracksLeadingJetRecSecS = o.fProNtracksLeadingJetRecSecS;
fProNtracksLeadingJetRecSecSsc = o.fProNtracksLeadingJetRecSecSsc;
fRandom = o.fRandom;
+ fOnlyLeadingJets = o.fOnlyLeadingJets;
// PID framework
fUseInclusivePIDtask = o.fUseInclusivePIDtask;
}
if(!fh1Xsec||!fh1Trials){
- Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
+ Printf("%s:%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__);
return kFALSE;
}
}
// Set seed for backg study
+ delete fRandom;
fRandom = new TRandom3();
fRandom->SetSeed(0);
// Load PID framework if desired
+ if(fDebug > 1) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects() -> Loading PID framework");
fUseJetPIDtask = fIDFFMode || fFFMode;
fUseInclusivePIDtask = fQAMode && (fQAMode&1);
}
if (fUseJetPIDtask) {
+ delete [] fJetPIDtask;
+ fJetPIDtask = 0x0;
+
if (fNumJetPIDtasks > 0) {
+ fJetPIDtask = new AliAnalysisTaskPID*[fNumJetPIDtasks];
+
for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
fJetPIDtask[i] = (AliAnalysisTaskPID*)tasks->FindObject(fNameJetPIDtask[i].Data());
}
}
else {
- Printf("ERROR: zero jet pid tasks!\n");
+ Printf("WARNING: zero jet pid tasks!\n");
fUseJetPIDtask = kFALSE;
}
}
if (fUseInclusivePIDtask) {
+ delete [] fInclusivePIDtask;
+ fInclusivePIDtask = 0x0;
+
if (fNumInclusivePIDtasks > 0) {
+ fInclusivePIDtask = new AliAnalysisTaskPID*[fNumInclusivePIDtasks];
+
for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
fInclusivePIDtask[i] = (AliAnalysisTaskPID*)tasks->FindObject(fNameInclusivePIDtask[i].Data());
}
}
else {
- Printf("ERROR: zero inclusive pid tasks!\n");
- fUseJetPIDtask = kFALSE;
+ Printf("WARNING: zero inclusive pid tasks!\n");
+ fUseInclusivePIDtask = kFALSE;
}
}
}
+ if(fDebug > 2) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects() -> Posting Output");
+
PostData(1, fCommonHistList);
+
+ if(fDebug > 2) Printf("AliAnalysisTaskIDFragmentationFunction::UserCreateOutputObjects() -> Done");
}
//_______________________________________________
return;
}
}
+
+
+ // Count events with trigger selection, note: Set centrality percentile fix to -1 for pp for PID framework
+ if (fUseJetPIDtask) {
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ fJetPIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSel);
+ }
+ }
+
+ if (fUseInclusivePIDtask) {
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ fInclusivePIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSel);
+ }
+ }
// *** vertex cut ***
AliAODVertex* primVtx = fAOD->GetPrimaryVertex();
if (fDebug > 1) Printf("%s:%d primary vertex selection: %d", (char*)__FILE__,__LINE__,nTracksPrim);
- if(!nTracksPrim){
+ if(nTracksPrim <= 0) {
if (fDebug > 1) Printf("%s:%d primary vertex selection: event REJECTED...",(char*)__FILE__,__LINE__);
fh1EvtSelection->Fill(3.);
PostData(1, fCommonHistList);
return;
}
+ TString primVtxName(primVtx->GetName());
+
+ if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
+ if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
+ fh1EvtSelection->Fill(5.);
+ PostData(1, fCommonHistList);
+ return;
+ }
+
+ // Count events with trigger selection and vtx cut, note: Set centrality percentile fix to -1 for pp for PID framework
+ if (fUseJetPIDtask) {
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ fJetPIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCut);
+ }
+ }
+
+ if (fUseInclusivePIDtask) {
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ fInclusivePIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCut);
+ }
+ }
+
fh1VertexZ->Fill(primVtx->GetZ());
if(TMath::Abs(primVtx->GetZ())>fMaxVertexZ){
return;
}
- TString primVtxName(primVtx->GetName());
-
- if(primVtxName.CompareTo("TPCVertex",TString::kIgnoreCase) == 1){
- if (fDebug > 1) Printf("%s:%d primary vertex selection: TPC vertex, event REJECTED...",(char*)__FILE__,__LINE__);
- fh1EvtSelection->Fill(5.);
- PostData(1, fCommonHistList);
- return;
+ // Count events with trigger selection and vtx cut, note: Set centrality percentile fix to -1 for pp for PID framework
+ if (fUseJetPIDtask) {
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ fJetPIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCutAndZvtxCut);
+ }
}
-
+
+ if (fUseInclusivePIDtask) {
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ fInclusivePIDtask[i]->IncrementEventCounter(fIsPP ? -1. : centPercent, AliAnalysisTaskPID::kTriggerSelAndVtxCutAndZvtxCut);
+ }
+ }
+
if (fDebug > 1) Printf("%s:%d event ACCEPTED ...",(char*)__FILE__,__LINE__);
fh1EvtSelection->Fill(0.);
fh1EvtCent->Fill(centPercent);
(char*)__FILE__,__LINE__,nTCutsEfficiency,nRecPartCutsEfficiency);
AliPIDResponse* pidResponse = 0x0;
+ Bool_t tuneOnDataTPC = kFALSE;
if (fUseJetPIDtask || fUseInclusivePIDtask) {
- if (!inputHandler)
+ if (!inputHandler) {
AliFatal("Input handler needed");
+ return;
+ }
else {
// PID response object
pidResponse = inputHandler->GetPIDResponse();
- if (!pidResponse)
+ if (!pidResponse) {
AliFatal("PIDResponse object was not created");
+ return;
+ }
+ else {
+ tuneOnDataTPC = pidResponse->IsTunedOnData() &&
+ ((pidResponse->GetTunedOnDataMask() & AliPIDResponse::kDetTPC) == AliPIDResponse::kDetTPC);
+ }
}
}
+ if(fDebug>2)Printf("%s:%d Starting processing...",(char*)__FILE__,__LINE__);
+
//____ analysis, fill histos ___________________________________________________
if(fQAMode){
if (TMath::Abs(chargeMC) < 0.01)
continue; // Reject neutral particles (only relevant, if mcID is not used)
- Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { mcID, pT, centPercent, -1, -1, -1, -1 };
+ Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { static_cast<Double_t>(mcID), pT, centPercent, -1, -1, -1, -1 };
for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
- valuesGenYield[fInclusivePIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
- fInclusivePIDtask[i]->FillGeneratedYield(valuesGenYield);
+ if (fInclusivePIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(part->Eta()))) {
+ valuesGenYield[fInclusivePIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
+ fInclusivePIDtask[i]->FillGeneratedYield(valuesGenYield);
+ }
}
- Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { mcID, pT, part->Eta(), chargeMC,
+ Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), pT, part->Eta(), chargeMC,
centPercent, -1, -1, -1 };// no jet pT etc since inclusive spectrum
for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
fInclusivePIDtask[i]->FillEfficiencyContainer(valuesEff, AliAnalysisTaskPID::kStepGenWithGenCuts);
// fill inclusive tracks XXX, they have the same track cuts!
AliAODTrack * inclusiveaod = dynamic_cast<AliAODTrack*>(fTracksRecCutsEfficiency->At(it));
if(inclusiveaod){
- Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod) :
- inclusiveaod->GetTPCsignal();
+ Double_t dEdxTPC = tuneOnDataTPC ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
+ : inclusiveaod->GetTPCsignal();
if (dEdxTPC <= 0)
continue;
+ Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
+ Bool_t survivedTPCnclCut = AliAnalysisTaskPID::TPCnclCut(inclusiveaod);
+
Int_t label = TMath::Abs(inclusiveaod->GetLabel());
// find MC track in our list, if available
continue;
// AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
- Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { mcID, gentrack->Pt(), gentrack->Eta(), gentrack->Charge() / 3.,
+ Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), gentrack->Pt(), gentrack->Eta(), gentrack->Charge() / 3.,
centPercent,
-1, -1, -1 };// no jet pT etc since inclusive spectrum
- for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
- fInclusivePIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
+ fInclusivePIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+ }
- Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { mcID, inclusiveaod->Pt(), inclusiveaod->Eta(),
- inclusiveaod->Charge(), centPercent,
+ Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), inclusiveaod->Pt(), inclusiveaod->Eta(),
+ static_cast<Double_t>(inclusiveaod->Charge()), centPercent,
-1, -1, -1 };// no jet pT etc since inclusive spectrum
- for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
- fInclusivePIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
+ fInclusivePIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+ }
}
}
}
AliAODTrack * inclusiveaod = dynamic_cast<AliAODTrack*>(fTracksRecCuts->At(it));
if(inclusiveaod){
if(fUseInclusivePIDtask){
- Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
- : inclusiveaod->GetTPCsignal();
+ Double_t dEdxTPC = tuneOnDataTPC ? pidResponse->GetTPCsignalTunedOnData(inclusiveaod)
+ : inclusiveaod->GetTPCsignal();
if (dEdxTPC <= 0)
continue;
+ Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(inclusiveaod, InputEvent());
+ Bool_t survivedTPCnclCut = AliAnalysisTaskPID::TPCnclCut(inclusiveaod);
+
Int_t label = TMath::Abs(inclusiveaod->GetLabel());
// find MC track in our list, if available
if (gentrack)
pdg = gentrack->GetPdgCode();
- for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
- fInclusivePIDtask[i]->ProcessTrack(inclusiveaod, pdg, centPercent, -1); // no jet pT since inclusive spectrum
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut())) {
+ if (fInclusivePIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(inclusiveaod->Eta())))
+ fInclusivePIDtask[i]->ProcessTrack(inclusiveaod, pdg, centPercent, -1); // no jet pT since inclusive spectrum
+ }
+ }
if (gentrack) {
Int_t mcID = AliAnalysisTaskPID::PDGtoMCID(pdg);
- Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, inclusiveaod->Pt(), inclusiveaod->Eta(),
- inclusiveaod->Charge(), centPercent,
+ Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), inclusiveaod->Pt(), inclusiveaod->Eta(),
+ static_cast<Double_t>(inclusiveaod->Charge()), centPercent,
-1, -1, -1 };
- for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
- fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
+ fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+ }
Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
- for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
- fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
- AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
- weight);
-
- if (gentrack->IsPhysicalPrimary()) {
- for (Int_t i = 0; i < fNumInclusivePIDtasks; i++)
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut()))
fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
- AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
+ AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
+ weight);
+ }
+
+ if (gentrack->IsPhysicalPrimary()) {
+ // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
+ Double_t valueGenAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), gentrack->Pt(), gentrack->Eta(),
+ gentrack->Charge() / 3., centPercent, -1, -1,
+ -1 };
+
+ Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { -1, gentrack->Pt(), inclusiveaod->Pt(),
+ gentrack->Charge() / 3., centPercent };
+
+ for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
+ if ((!fInclusivePIDtask[i]->GetUseTPCCutMIGeo() && !fInclusivePIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fInclusivePIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fInclusivePIDtask[i]->GetUseTPCnclCut())) {
+ fInclusivePIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
+ AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
+ fInclusivePIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
+ AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
+
+ fInclusivePIDtask[i]->FillPtResolution(mcID, valuePtResolution);
+ }
+ }
}
}
}
if(fQAMode&2 && (ij==0)) fQAJetHistosGenLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
- if((ij==0) || 1){ // leading jet //TODO all jets
+ if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
TList* jettracklist = new TList();
Double_t sumPt = 0.;
Bool_t isBadJet = kFALSE;
if (TMath::Abs(chargeMC) < 0.01)
continue; // Reject neutral particles (only relevant, if mcID is not used)
- Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { mcID, trackPt, centPercent, jetPt, z, xi, chargeMC };
+ Double_t valuesGenYield[AliAnalysisTaskPID::kGenYieldNumAxes] = { static_cast<Double_t>(mcID), trackPt, centPercent, jetPt, z, xi, chargeMC };
for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
- valuesGenYield[fJetPIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
- fJetPIDtask[i]->FillGeneratedYield(valuesGenYield);
+ if (fJetPIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(part->Eta()))) {
+ valuesGenYield[fJetPIDtask[i]->GetIndexOfChargeAxisGenYield()] = chargeMC;
+ fJetPIDtask[i]->FillGeneratedYield(valuesGenYield);
+ }
}
- Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { mcID, trackPt, part->Eta(), chargeMC,
+ Double_t valuesEff[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), trackPt, part->Eta(), chargeMC,
centPercent, jetPt, z, xi };
for (Int_t i = 0; i < fNumJetPIDtasks; i++)
fJetPIDtask[i]->FillEfficiencyContainer(valuesEff, AliAnalysisTaskPID::kStepGenWithGenCuts);
if(fQAMode&2) fQAJetHistosRecCuts->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt());
if(fQAMode&2 && (ij==0)) fQAJetHistosRecCutsLeading->FillJetQA( jet->Eta(), TVector2::Phi_0_2pi(jet->Phi()), jet->Pt() );
- if((ij==0) || 1){ // leading jet //TODO all jets
+ if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
Double_t ptFractionEmbedded = 0;
AliAODJet* embeddedJet = 0;
}
if (fUseJetPIDtask) {
- Double_t dEdxTPC = pidResponse->IsTunedOnData() ? pidResponse->GetTPCsignalTunedOnData(aodtrack)
- : aodtrack->GetTPCsignal();
+ Double_t dEdxTPC = tuneOnDataTPC ? pidResponse->GetTPCsignalTunedOnData(aodtrack)
+ : aodtrack->GetTPCsignal();
if (dEdxTPC <= 0)
continue;
+ Bool_t survivedTPCCutMIGeo = AliAnalysisTaskPID::TPCCutMIGeo(aodtrack, InputEvent());
+ Bool_t survivedTPCnclCut = AliAnalysisTaskPID::TPCnclCut(aodtrack);
+
Int_t label = TMath::Abs(aodtrack->GetLabel());
// Find MC track in our list, if available
Double_t z = -1., xi = -1.;
AliAnalysisTaskPID::GetJetTrackObservables(pT, jetPt, z, xi);
- Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { mcID, pT, aodtrack->Eta(), aodtrack->Charge(),
+ Double_t valueRecAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), pT, aodtrack->Eta(), static_cast<Double_t>(aodtrack->Charge()),
centPercent, jetPt, z, xi };
- for (Int_t i = 0; i < fNumJetPIDtasks; i++)
- fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
+ fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObs);
+ }
Double_t weight = IsSecondaryWithStrangeMotherMC(gentrack) ? GetMCStrangenessFactorCMS(gentrack) : 1.0;
- for (Int_t i = 0; i < fNumJetPIDtasks; i++)
- fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
- AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
- weight);
-
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
+ fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
+ AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsStrangenessScaled,
+ weight);
+ }
+
if (gentrack->IsPhysicalPrimary()) {
- for (Int_t i = 0; i < fNumJetPIDtasks; i++)
- fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts, AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
+ // AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
+ Double_t genPt = gentrack->Pt();
+ Double_t genZ = -1., genXi = -1.;
+ AliAnalysisTaskPID::GetJetTrackObservables(genPt, jetPt, genZ, genXi);
+ Double_t valueGenAllCuts[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), genPt, gentrack->Eta(),
+ gentrack->Charge() / 3., centPercent, jetPt, genZ,
+ genXi };
+
+ Double_t valuePtResolution[AliAnalysisTaskPID::kPtResNumAxes] = { jetPt, genPt, pT, gentrack->Charge() / 3., centPercent };
+
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut())) {
+ fJetPIDtask[i]->FillEfficiencyContainer(valueRecAllCuts,
+ AliAnalysisTaskPID::kStepRecWithRecCutsMeasuredObsPrimaries);
+ fJetPIDtask[i]->FillEfficiencyContainer(valueGenAllCuts,
+ AliAnalysisTaskPID::kStepRecWithRecCutsPrimaries);
+
+ fJetPIDtask[i]->FillPtResolution(mcID, valuePtResolution);
+ }
+ }
}
}
- for (Int_t i = 0; i < fNumJetPIDtasks; i++)
- fJetPIDtask[i]->ProcessTrack(aodtrack, pdg, centPercent, jetPt);
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut())) {
+ if (fJetPIDtask[i]->IsInAcceptedEtaRange(TMath::Abs(aodtrack->Eta())))
+ fJetPIDtask[i]->ProcessTrack(aodtrack, pdg, centPercent, jetPt);
+ }
+ }
- if (fIDFFMode) {
+ if (fIDFFMode && ((!fJetPIDtask[0]->GetUseTPCCutMIGeo() && !fJetPIDtask[0]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[0]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[0]->GetUseTPCnclCut()))) {
// NOTE: Just take particle fraction from first task (should anyway be the same for all tasks)
Int_t pidWeightedSpecies = fJetPIDtask[0]->GetRandomParticleTypeAccordingToParticleFractions(pT, jetPt,
centPercent, kTRUE);
// AliAODMCParticle->Charge() calls TParticlePDG->Charge(), which returns the charge in units of e0 / 3
- Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { mcID, genPt, gentrack->Eta(), gentrack->Charge() / 3.,
+ Double_t value[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), genPt, gentrack->Eta(), gentrack->Charge() / 3.,
centPercent, jetPt, genZ, genXi };
- for (Int_t i = 0; i < fNumJetPIDtasks; i++)
- fJetPIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
+ fJetPIDtask[i]->FillEfficiencyContainer(value, AliAnalysisTaskPID::kStepRecWithGenCuts);
+ }
- Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { mcID, measPt, aodtrack->Eta(), aodtrack->Charge(),
+ Double_t valueMeas[AliAnalysisTaskPID::kEffNumAxes] = { static_cast<Double_t>(mcID), measPt, aodtrack->Eta(), static_cast<Double_t>(aodtrack->Charge()),
centPercent, jetPt, measZ, measXi };
- for (Int_t i = 0; i < fNumJetPIDtasks; i++)
- fJetPIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+ for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
+ if ((!fJetPIDtask[i]->GetUseTPCCutMIGeo() && !fJetPIDtask[i]->GetUseTPCnclCut()) ||
+ (survivedTPCCutMIGeo && fJetPIDtask[i]->GetUseTPCCutMIGeo()) ||
+ (survivedTPCnclCut && fJetPIDtask[i]->GetUseTPCnclCut()))
+ fJetPIDtask[i]->FillEfficiencyContainer(valueMeas, AliAnalysisTaskPID::kStepRecWithGenCutsMeasuredObs);
+ }
}
}
}
delete jettracklist;
} // end: cut embedded ratio
- } // end: leading jet
+ } // end: leading jet or all jets
} // end: rec. jets after cuts
} // end: QA, FF and intra-jet
Bool_t isBadJetRec = kFALSE;
- if((ij==0) || 1){ // leading jet //TODO all jets
+ if((ij==0) || !fOnlyLeadingJets){ // leading jets or all jets
// for efficiency: gen tracks from pointing with gen/rec jet
TList* jettracklistGenPrim = new TList();
if (fUseJetPIDtask) {
for (Int_t i = 0; i < fNumJetPIDtasks; i++) {
fJetPIDtask[i]->PostOutputData();
- fJetPIDtask[i]->IncrementEventsProcessed(centPercent);
}
}
if (fUseInclusivePIDtask) {
for (Int_t i = 0; i < fNumInclusivePIDtasks; i++) {
fInclusivePIDtask[i]->PostOutputData();
- fInclusivePIDtask[i]->IncrementEventsProcessed(centPercent);
}
}
}
}
// _________________________________________________________________________________________________________
-void AliAnalysisTaskIDFragmentationFunction::SetProperties(THnSparse* h,const Int_t dim, const char** labels)
+void AliAnalysisTaskIDFragmentationFunction::SetProperties(THnSparse* h, Int_t dim, const char** labels)
{
// Set properties of THnSparse
// ________________________________________________________________________________________________________________________________________________________
void AliAnalysisTaskIDFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, const AliAODJet* jet,
- const Double_t radius, Double_t& sumPt, const Double_t minPtL, const Double_t maxPt, Bool_t& isBadPt)
+ Double_t radius, Double_t& sumPt, Double_t minPtL, Double_t maxPt, Bool_t& isBadPt)
{
// fill list of tracks in cone around jet axis
}
// _________________________________________________________________________________________________________________________________________________________________
-void AliAnalysisTaskIDFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet, const Double_t minPtL, const Double_t maxPt, Bool_t& isBadPt)
+void AliAnalysisTaskIDFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet, Double_t minPtL, Double_t maxPt, Bool_t& isBadPt)
{
// list of jet tracks from trackrefs
// _____________________________________________________________________________________________________________________________________________
void AliAnalysisTaskIDFragmentationFunction::FillSingleTrackHistosRecGen(AliFragFuncQATrackHistos* trackQAGen, AliFragFuncQATrackHistos* trackQARec, TList* tracksGen,
- const TArrayI& indexAODTr, const TArrayS& isRefGen, const Bool_t scaleStrangeness){
+ const TArrayI& indexAODTr, const TArrayS& isRefGen, Bool_t scaleStrangeness){
// fill QA for single track reconstruction efficiency
void AliAnalysisTaskIDFragmentationFunction::FillJetTrackHistosRec(AliFragFuncHistos* ffhistRec, AliAODJet* jet,
TList* jetTrackList, const TList* tracksGen, const TList* tracksRec, const TArrayI& indexAODTr,
- const TArrayS& isRefGen, TList* jetTrackListTR, const Bool_t scaleStrangeness,
+ const TArrayS& isRefGen, TList* jetTrackListTR, Bool_t scaleStrangeness,
Bool_t fillJS, TProfile* hProNtracksLeadingJet, TProfile** hProDelRPtSum, TProfile* hProDelR80pcPt)
{
// fill objects for jet track reconstruction efficiency or secondaries contamination
}
// ______________________________________________________________________________________________________________________________________________________
-Float_t AliAnalysisTaskIDFragmentationFunction::CalcJetArea(const Float_t etaJet, const Float_t rc) const
+Float_t AliAnalysisTaskIDFragmentationFunction::CalcJetArea(Float_t etaJet, Float_t rc) const
{
// calculate area of jet with eta etaJet and radius rc
normFactor = 0;
- Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
+ const Int_t nBckgClusters = fBckgJetsRec->GetEntries(); // not 'recCuts': use all clusters in full eta range
if(nBckgClusters<3) return; // need at least 3 clusters (skipping 2 highest)
}
//_____________________________________________________________________________________
-Double_t AliAnalysisTaskIDFragmentationFunction::GetMCStrangenessFactor(const Double_t pt) const
+Double_t AliAnalysisTaskIDFragmentationFunction::GetMCStrangenessFactor(Double_t pt) const
{
// factor strangeness data/MC as function of pt from UE analysis (Sara Vallero)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff