,fDiJetCDFCut(0)
,fDiJetKindBins(0)
,fFFRadius(0)
+ ,fFFMaxTrackPt(-1)
+ ,fFFMinnTracks(0)
,fFFBckgRadius(0)
,fBckgMode(0)
,fIJMode(0)
,fDiJetCDFCut(0)
,fDiJetKindBins(0)
,fFFRadius(0)
+ ,fFFMaxTrackPt(-1)
+ ,fFFMinnTracks(0)
,fFFBckgRadius(0)
,fBckgMode(0)
,fIJMode(0)
,fDiJetCDFCut(copy.fDiJetCDFCut)
,fDiJetKindBins(copy.fDiJetKindBins)
,fFFRadius(copy.fFFRadius)
+ ,fFFMaxTrackPt(copy.fFFMaxTrackPt)
+ ,fFFMinnTracks(copy.fFFMinnTracks)
,fFFBckgRadius(copy.fFFBckgRadius)
,fBckgMode(copy.fBckgMode)
,fIJMode(copy.fIJMode)
fDiJetCDFCut = o.fDiJetCDFCut;
fDiJetKindBins = o.fDiJetKindBins;
fFFRadius = o.fFFRadius;
+ fFFMaxTrackPt = o.fFFMaxTrackPt;
+ fFFMinnTracks = o.fFFMinnTracks;
fFFBckgRadius = o.fFFBckgRadius;
fBckgMode = o.fBckgMode;
fIJMode = o.fIJMode;
// get tracks in jet
TList* jettracklist = new TList();
Double_t sumPt = 0.;
+ Bool_t isBadJet = kFALSE;
Float_t leadTrackPt = 0.;
TLorentzVector* leadTrackV = new TLorentzVector();
+
if(GetFFRadius()<=0){
- GetJetTracksTrackrefs(jettracklist, jet);
+ GetJetTracksTrackrefs(jettracklist, jet, GetFFMaxTrackPt(), isBadJet);
} else {
if(fUseEmbeddedJetAxis){
- if(embeddedJet) GetJetTracksPointing(fTracksRecCuts, jettracklist, embeddedJet, GetFFRadius(), sumPt);
+ if(embeddedJet) GetJetTracksPointing(fTracksRecCuts, jettracklist, embeddedJet, GetFFRadius(), sumPt, GetFFMaxTrackPt(), isBadJet);
}
- else GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt);
+ else GetJetTracksPointing(fTracksRecCuts, jettracklist, jet, GetFFRadius(), sumPt, GetFFMaxTrackPt(), isBadJet);
}
+ if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;
+
+ std::cout<<" here, isBadJet "<<isBadJet<<std::endl;
+
+ if(isBadJet) continue;
+
if(ptFractionEmbedded>=fCutFractionPtEmbedded){ // if no embedding: ptFraction = cutFraction = 0
TList* jettracklist = new TList();
Double_t sumPt = 0.;
+ Bool_t isBadJet = kFALSE;
Float_t leadTrackPt = 0.;
TLorentzVector* leadTrackV = new TLorentzVector();
if(GetFFRadius()<=0){
- GetJetTracksTrackrefs(jettracklist, jet);
+ GetJetTracksTrackrefs(jettracklist, jet, GetFFMaxTrackPt(), isBadJet);
} else {
- GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt);
+ GetJetTracksPointing(fTracksGen, jettracklist, jet, GetFFRadius(), sumPt, GetFFMaxTrackPt(), isBadJet);
}
+ if(GetFFMinNTracks()>0 && jettracklist->GetSize()<=GetFFMinNTracks()) isBadJet = kTRUE;;
+ if(isBadJet) continue;
+
for(Int_t it=0; it<jettracklist->GetSize(); ++it){
AliVParticle* trackVP = dynamic_cast<AliVParticle*>(jettracklist->At(it));
if(fDJMode&1){
TList* jettracklist1 = new TList();
Double_t sumPt1 = 0.;
+ Bool_t isBadJet1 = kFALSE;
Float_t leadTrackPt1 = 0;
+
TList* jettracklist2 = new TList();
Double_t sumPt2 = 0.;
+ Bool_t isBadJet2 = kFALSE;
Float_t leadTrackPt2 = 0;
if(GetFFRadius()<=0)
{
- GetJetTracksTrackrefs(jettracklist1, jet1);
- GetJetTracksTrackrefs(jettracklist2, jet2);
+ GetJetTracksTrackrefs(jettracklist1, jet1, GetFFMaxTrackPt(), isBadJet1);
+ GetJetTracksTrackrefs(jettracklist2, jet2, GetFFMaxTrackPt(), isBadJet2);
}
else
{
- GetJetTracksPointing(fTracksRecCuts, jettracklist1, jet1, GetFFRadius(), sumPt1);
- GetJetTracksPointing(fTracksRecCuts, jettracklist2, jet2, GetFFRadius(), sumPt2);
+ GetJetTracksPointing(fTracksRecCuts, jettracklist1, jet1, GetFFRadius(), sumPt1, GetFFMaxTrackPt(), isBadJet1);
+ GetJetTracksPointing(fTracksRecCuts, jettracklist2, jet2, GetFFRadius(), sumPt2, GetFFMaxTrackPt(), isBadJet2);
}
- Int_t nTracks = jettracklist1->GetSize();
- if (jettracklist1->GetSize() < jettracklist2->GetSize()) nTracks = jettracklist2->GetSize();
+
+ if(GetFFMinNTracks()>0 && jettracklist1->GetSize()<=GetFFMinNTracks()) isBadJet1 = kTRUE;
+ if(GetFFMinNTracks()>0 && jettracklist1->GetSize()<=GetFFMinNTracks()) isBadJet2 = kTRUE;
+
+ if(!(isBadJet1 || isBadJet2)){ // good jets
+
+ Int_t nTracks = jettracklist1->GetSize();
+ if (jettracklist1->GetSize() < jettracklist2->GetSize()) nTracks = jettracklist2->GetSize();
- for(Int_t it=0; it<nTracks; ++it)
- {
- if (it < jettracklist1->GetSize())
- {
- AliVParticle *vp = (dynamic_cast<AliVParticle*> (jettracklist1->At(it)));
- Float_t trackPt1 = (vp?vp->Pt():0);
- Float_t jetPt1 = jet1->Pt();
-
- Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
+ for(Int_t it=0; it<nTracks; ++it)
+ {
+ if (it < jettracklist1->GetSize())
+ {
+
AliVParticle *vp = (dynamic_cast<AliVParticle*> (jettracklist1->At(it)));
+ Float_t trackPt1 = (vp?vp->Pt():0);
+ Float_t jetPt1 = jet1->Pt();
+
+ Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
- fFFDiJetHistosRecCuts->FillDiJetFF(1, trackPt1, jetPt1, jetBin, incrementJetPt);
- fFFDiJetHistosRecCuts->FillDiJetFF(0, trackPt1, jetPt1, jetBin, incrementJetPt);
-
- if (it == 0)
- {
- leadTrackPt1 = trackPt1;
-
- fFFDiJetHistosRecLeadingTrack->FillDiJetFF(1, leadTrackPt1, jetPt1, jetBin, kTRUE);
- fFFDiJetHistosRecLeadingTrack->FillDiJetFF(0, leadTrackPt1, jetPt1, jetBin, kTRUE);
- }
-
- fFFDiJetHistosRecLeading->FillDiJetFF(1, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
- fFFDiJetHistosRecLeading->FillDiJetFF(0, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
- }
-
- if (it < jettracklist2->GetSize())
- {
- Float_t trackPt2 = ((AliVParticle*)(jettracklist2->At(it)))->Pt();
- Float_t jetPt2 = jet2->Pt();
-
- Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
-
- fFFDiJetHistosRecCuts->FillDiJetFF(2, trackPt2, jetPt2, jetBin, incrementJetPt);
- fFFDiJetHistosRecCuts->FillDiJetFF(0, trackPt2, jetPt2, jetBin, incrementJetPt);
-
- if (it == 0)
- {
- leadTrackPt2 = trackPt2;
-
- fFFDiJetHistosRecLeadingTrack->FillDiJetFF(2, leadTrackPt2, jetPt2, jetBin, kTRUE);
- fFFDiJetHistosRecLeadingTrack->FillDiJetFF(0, leadTrackPt2, jetPt2, jetBin, kTRUE);
- }
-
- fFFDiJetHistosRecLeading->FillDiJetFF(2, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
- fFFDiJetHistosRecLeading->FillDiJetFF(0, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
- }
- } // End loop on tracks
+ fFFDiJetHistosRecCuts->FillDiJetFF(1, trackPt1, jetPt1, jetBin, incrementJetPt);
+ fFFDiJetHistosRecCuts->FillDiJetFF(0, trackPt1, jetPt1, jetBin, incrementJetPt);
+
+ if (it == 0)
+ {
+ leadTrackPt1 = trackPt1;
+
+ fFFDiJetHistosRecLeadingTrack->FillDiJetFF(1, leadTrackPt1, jetPt1, jetBin, kTRUE);
+ fFFDiJetHistosRecLeadingTrack->FillDiJetFF(0, leadTrackPt1, jetPt1, jetBin, kTRUE);
+ }
+
+ fFFDiJetHistosRecLeading->FillDiJetFF(1, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
+ fFFDiJetHistosRecLeading->FillDiJetFF(0, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
+ }
+
+ if (it < jettracklist2->GetSize())
+ {
+ Float_t trackPt2 = ((AliVParticle*)(jettracklist2->At(it)))->Pt();
+ Float_t jetPt2 = jet2->Pt();
+
+ Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
+
+ fFFDiJetHistosRecCuts->FillDiJetFF(2, trackPt2, jetPt2, jetBin, incrementJetPt);
+ fFFDiJetHistosRecCuts->FillDiJetFF(0, trackPt2, jetPt2, jetBin, incrementJetPt);
+
+ if (it == 0)
+ {
+ leadTrackPt2 = trackPt2;
+
+ fFFDiJetHistosRecLeadingTrack->FillDiJetFF(2, leadTrackPt2, jetPt2, jetBin, kTRUE);
+ fFFDiJetHistosRecLeadingTrack->FillDiJetFF(0, leadTrackPt2, jetPt2, jetBin, kTRUE);
+ }
+
+ fFFDiJetHistosRecLeading->FillDiJetFF(2, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
+ fFFDiJetHistosRecLeading->FillDiJetFF(0, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
+ }
+ } // End loop on tracks
+ }
delete jettracklist1;
delete jettracklist2;
if(fDJMode&1){
TList* jettracklist1 = new TList();
Double_t sumPt1 = 0.;
+ Bool_t isBadJet1 = kFALSE;
Float_t leadTrackPt1 = 0.;
-
+
TList* jettracklist2 = new TList();
Double_t sumPt2 = 0.;
+ Bool_t isBadJet2 = kFALSE;
Float_t leadTrackPt2 = 0.;
if(GetFFRadius()<=0)
{
- GetJetTracksTrackrefs(jettracklist1, jet1);
- GetJetTracksTrackrefs(jettracklist2, jet2);
+ GetJetTracksTrackrefs(jettracklist1, jet1, GetFFMaxTrackPt(), isBadJet1);
+ GetJetTracksTrackrefs(jettracklist2, jet2, GetFFMaxTrackPt(), isBadJet2);
}
else
{
- GetJetTracksPointing(fTracksGen, jettracklist1, jet1, GetFFRadius(), sumPt1);
- GetJetTracksPointing(fTracksGen, jettracklist2, jet2, GetFFRadius(), sumPt2);
+ GetJetTracksPointing(fTracksGen, jettracklist1, jet1, GetFFRadius(), sumPt1, GetFFMaxTrackPt(), isBadJet1);
+ GetJetTracksPointing(fTracksGen, jettracklist2, jet2, GetFFRadius(), sumPt2, GetFFMaxTrackPt(), isBadJet2);
}
- Int_t nTracks = jettracklist1->GetSize();
- if (jettracklist1->GetSize() < jettracklist2->GetSize()) nTracks = jettracklist2->GetSize();
- for(Int_t it=0; it<nTracks; ++it)
- {
- if (it < jettracklist1->GetSize())
- {
- Float_t trackPt1 = ((AliVParticle*)jettracklist1->At(it))->Pt();
- Float_t jetPt1 = jet1->Pt();
-
- Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
-
- fFFDiJetHistosGen->FillDiJetFF( 1, trackPt1, jetPt1, jetBin, incrementJetPt);
- fFFDiJetHistosGen->FillDiJetFF( 0, trackPt1, jetPt1, jetBin, incrementJetPt);
-
- if(it==0)
- {
- leadTrackPt1 = trackPt1;
-
- fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 1, leadTrackPt1, jetPt1, jetBin, kTRUE);
- fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 0, leadTrackPt1, jetPt1, jetBin, kTRUE);
- }
-
- fFFDiJetHistosGenLeading->FillDiJetFF( 1, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
- fFFDiJetHistosGenLeading->FillDiJetFF( 0, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
- }
-
- if (it < jettracklist2->GetSize())
- {
- Float_t trackPt2 = ((AliVParticle*)jettracklist2->At(it))->Pt();
- Float_t jetPt2 = jet2->Pt();
-
- Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
-
- fFFDiJetHistosGen->FillDiJetFF( 2, trackPt2, jetPt2, jetBin, incrementJetPt);
- fFFDiJetHistosGen->FillDiJetFF( 0, trackPt2, jetPt2, jetBin, incrementJetPt);
+ if(GetFFMinNTracks()>0 && jettracklist1->GetSize()<=GetFFMinNTracks()) isBadJet1 = kTRUE;
+ if(GetFFMinNTracks()>0 && jettracklist1->GetSize()<=GetFFMinNTracks()) isBadJet2 = kTRUE;
+
+ if(!(isBadJet1 || isBadJet2)){ // good jets
+
+ Int_t nTracks = jettracklist1->GetSize();
+ if (jettracklist1->GetSize() < jettracklist2->GetSize()) nTracks = jettracklist2->GetSize();
+
+ for(Int_t it=0; it<nTracks; ++it)
+ {
+ if (it < jettracklist1->GetSize())
+ {
+ Float_t trackPt1 = ((AliVParticle*)jettracklist1->At(it))->Pt();
+ Float_t jetPt1 = jet1->Pt();
+
+ Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
+
+ fFFDiJetHistosGen->FillDiJetFF( 1, trackPt1, jetPt1, jetBin, incrementJetPt);
+ fFFDiJetHistosGen->FillDiJetFF( 0, trackPt1, jetPt1, jetBin, incrementJetPt);
+
+ if(it==0)
+ {
+ leadTrackPt1 = trackPt1;
+
+ fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 1, leadTrackPt1, jetPt1, jetBin, kTRUE);
+ fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 0, leadTrackPt1, jetPt1, jetBin, kTRUE);
+ }
+
+ fFFDiJetHistosGenLeading->FillDiJetFF( 1, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
+ fFFDiJetHistosGenLeading->FillDiJetFF( 0, trackPt1, leadTrackPt1, jetBin, incrementJetPt);
+ }
+
+ if (it < jettracklist2->GetSize())
+ {
+ Float_t trackPt2 = ((AliVParticle*)jettracklist2->At(it))->Pt();
+ Float_t jetPt2 = jet2->Pt();
+
+ Bool_t incrementJetPt = (it==0) ? kTRUE : kFALSE;
+
+ fFFDiJetHistosGen->FillDiJetFF( 2, trackPt2, jetPt2, jetBin, incrementJetPt);
+ fFFDiJetHistosGen->FillDiJetFF( 0, trackPt2, jetPt2, jetBin, incrementJetPt);
- if (it==0)
- {
- leadTrackPt2 = trackPt2;
-
- fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 2, leadTrackPt2, jetPt2, jetBin, kTRUE);
- fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 0, leadTrackPt2, jetPt2, jetBin, kTRUE);
- }
+ if (it==0)
+ {
+ leadTrackPt2 = trackPt2;
+
+ fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 2, leadTrackPt2, jetPt2, jetBin, kTRUE);
+ fFFDiJetHistosGenLeadingTrack->FillDiJetFF( 0, leadTrackPt2, jetPt2, jetBin, kTRUE);
+ }
- fFFDiJetHistosGenLeading->FillDiJetFF( 2, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
- fFFDiJetHistosGenLeading->FillDiJetFF( 0, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
- }
- } // End loop on tracks
-
+ fFFDiJetHistosGenLeading->FillDiJetFF( 2, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
+ fFFDiJetHistosGenLeading->FillDiJetFF( 0, trackPt2, leadTrackPt2, jetBin, incrementJetPt);
+ }
+ } // End loop on tracks
+ }
+
delete jettracklist1;
delete jettracklist2;
}
for(Int_t ij=0; ij<nRecEffJets; ++ij){
AliAODJet* jet = (AliAODJet*)(fJetsRecEff->At(ij));
+ Bool_t isBadJetGenPrim = kFALSE;
+ Bool_t isBadJetGenSec = kFALSE;
+ Bool_t isBadJetRec = kFALSE;
+
if(ij==0){ // leading jet
+ // 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
+ GetJetTracksPointing(fTracksAODMCCharged, jettracklistGenPrim, jet, GetFFRadius(), sumPtGenLeadingJetRecEff, GetFFMaxTrackPt(), isBadJetGenPrim);
TList* jettracklistGenSec = new TList();
- GetJetTracksPointing(fTracksAODMCChargedSec, jettracklistGenSec, jet, GetFFRadius(), sumPtGenLeadingJetSec); // for efficiency: gen tracks from pointing with gen/rec jet
-
+ GetJetTracksPointing(fTracksAODMCChargedSec, jettracklistGenSec, jet, GetFFRadius(), sumPtGenLeadingJetSec, GetFFMaxTrackPt(), isBadJetGenSec);
+
+ // bin efficiency in jet pt bins using rec tracks
TList* jettracklistRec = new TList();
- GetJetTracksPointing(fTracksRecCuts,jettracklistRec, jet, GetFFRadius(), sumPtRecLeadingJetRecEff); // bin efficiency in jet pt bins using rec tracks
+ GetJetTracksPointing(fTracksRecCuts,jettracklistRec, jet, GetFFRadius(), sumPtRecLeadingJetRecEff, GetFFMaxTrackPt(), isBadJetRec);
Double_t jetEta = jet->Eta();
Double_t jetPhi = TVector2::Phi_0_2pi(jet->Phi());
+ if(GetFFMinNTracks()>0 && jettracklistGenPrim->GetSize()<=GetFFMinNTracks()) isBadJetGenPrim = kTRUE;
+ if(GetFFMinNTracks()>0 && jettracklistGenSec->GetSize()<=GetFFMinNTracks()) isBadJetGenSec = kTRUE;
+ if(GetFFMinNTracks()>0 && jettracklistRec->GetSize()<=GetFFMinNTracks()) isBadJetRec = kTRUE;
+
+ if(isBadJetRec) continue;
+
if(fQAMode&2) fQAJetHistosRecEffLeading->FillJetQA( jetEta, jetPhi, sumPtGenLeadingJetRecEff );
if(fFFMode) FillJetTrackHistosRecGen(fFFHistosRecEffGen,fFFHistosRecEffRec,sumPtGenLeadingJetRecEff,sumPtRecLeadingJetRecEff,
}
// ________________________________________________________________________________________________________________________________________________________
-void AliAnalysisTaskFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, const AliAODJet* jet, const Double_t radius,Double_t& sumPt)
+void AliAnalysisTaskFragmentationFunction::GetJetTracksPointing(TList* inputlist, TList* outputlist, const AliAODJet* jet,
+ const Double_t radius, Double_t& sumPt, const Double_t maxPt, Bool_t& isBadMaxPt)
{
// fill list of tracks in cone around jet axis
sumPt = 0;
+ isBadMaxPt = kFALSE;
+
+ std::cout<<" enter GetJetTracksPointing, maxPt "<<maxPt<<std::endl;
Double_t jetMom[3];
jet->PxPyPz(jetMom);
outputlist->Add(track);
sumPt += track->Pt();
+
+ if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
+ if(maxPt>0 && track->Pt()>maxPt) std::cout<<" found bad jet, track pt "<<track->Pt()<<" max Pt "<<maxPt<<std::endl;
}
}
-
+
+ std::cout<<" leave GetJetTracksPointing, maxPt "<<maxPt<<" isBadMaxPt "<<isBadMaxPt<<std::endl;
+
+
outputlist->Sort();
}
// ___________________________________________________________________________________________
-void AliAnalysisTaskFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet)
+void AliAnalysisTaskFragmentationFunction::GetJetTracksTrackrefs(TList* list, const AliAODJet* jet, const Double_t maxPt, Bool_t& isBadMaxPt)
{
// list of jet tracks from trackrefs
continue;
}
+ if(maxPt>0 && track->Pt()>maxPt) isBadMaxPt = kTRUE;
list->Add(track);
}
}
//__________________________________________________________________________________________________________________
-AliFragmentationFunctionCorrections::AliFragFuncCorrHistos::AliFragFuncCorrHistos(const AliFragFuncCorrHistos& copy)
+AliFragmentationFunctionCorrections::AliFragFuncCorrHistos::AliFragFuncCorrHistos(const AliFragmentationFunctionCorrections::AliFragFuncCorrHistos& copy)
: TObject()
,fArraySize(copy.fArraySize)
- ,fh1CorrFFTrackPt(copy.fh1CorrFFTrackPt)
- ,fh1CorrFFZ(copy.fh1CorrFFZ)
- ,fh1CorrFFXi(copy.fh1CorrFFXi)
+ ,fh1CorrFFTrackPt(0)
+ ,fh1CorrFFZ(0)
+ ,fh1CorrFFXi(0)
,fCorrLabel(copy.fCorrLabel)
{
// copy constructor
+
+ fh1CorrFFTrackPt = new TH1F*[copy.fArraySize];
+ fh1CorrFFZ = new TH1F*[copy.fArraySize];
+ fh1CorrFFXi = new TH1F*[copy.fArraySize];
+
for(Int_t i=0; i<copy.fArraySize; i++){
- fh1CorrFFTrackPt[i] = copy.fh1CorrFFTrackPt[i];
- fh1CorrFFZ[i] = copy.fh1CorrFFZ[i];
- fh1CorrFFXi[i] = copy.fh1CorrFFXi[i];
+ fh1CorrFFTrackPt[i] = new TH1F(*(copy.fh1CorrFFTrackPt[i]));
+ fh1CorrFFZ[i] = new TH1F(*(copy.fh1CorrFFZ[i]));
+ fh1CorrFFXi[i] = new TH1F(*(copy.fh1CorrFFXi[i]));
}
}
if(this!=&o){
TObject::operator=(o);
- fArraySize = o.fArraySize;
+ Int_t fArraySize_new = o.fArraySize;
fCorrLabel = o.fCorrLabel;
- for(Int_t i=0; i<o.fArraySize; i++){
- fh1CorrFFTrackPt[i] = o.fh1CorrFFTrackPt[i];
- fh1CorrFFZ[i] = o.fh1CorrFFZ[i];
- fh1CorrFFXi[i] = o.fh1CorrFFXi[i];
+ TH1F** fh1CorrFFTrackPt_new = new TH1F*[fArraySize_new];
+ TH1F** fh1CorrFFZ_new = new TH1F*[fArraySize_new];
+ TH1F** fh1CorrFFXi_new = new TH1F*[fArraySize_new];
+
+ for(Int_t i=0; i<fArraySize_new; i++){
+ fh1CorrFFTrackPt_new[i] = new TH1F(*(o.fh1CorrFFTrackPt[i]));
+ fh1CorrFFZ_new[i] = new TH1F(*(o.fh1CorrFFZ[i]));
+ fh1CorrFFXi_new[i] = new TH1F(*(o.fh1CorrFFXi[i]));
}
- }
+ // ---
+
+ if(fArraySize){
+ for(int i=0; i<fArraySize; i++) delete fh1CorrFFTrackPt[i];
+ for(int i=0; i<fArraySize; i++) delete fh1CorrFFZ[i];
+ for(int i=0; i<fArraySize; i++) delete fh1CorrFFXi[i];
+ }
+
+ if(fh1CorrFFTrackPt) delete[] fh1CorrFFTrackPt;
+ if(fh1CorrFFZ) delete[] fh1CorrFFZ;
+ if(fh1CorrFFXi) delete[] fh1CorrFFXi;
+
+ // ---
+
+ fArraySize = fArraySize_new;
+
+ fh1CorrFFTrackPt = fh1CorrFFTrackPt_new;
+ fh1CorrFFZ = fh1CorrFFZ_new;
+ fh1CorrFFXi = fh1CorrFFXi_new;
+
+ for(Int_t i=0; i<fArraySize; i++){
+ fh1CorrFFTrackPt[i] = fh1CorrFFTrackPt_new[i];
+ fh1CorrFFZ[i] = fh1CorrFFZ_new[i];
+ fh1CorrFFXi[i] = fh1CorrFFXi_new[i];
+ }
+ }
+
return *this;
}
if(type == kFlagPt) hist = fCorrFF[fNCorrectionLevels-2]->GetTrackPt(i); // level -2: before unfolding, level -1: unfolded
else if(type == kFlagZ) hist = fCorrFF[fNCorrectionLevels-2]->GetZ(i); // level -2: before unfolding, level -1: unfolded
else if(type == kFlagXi) hist = fCorrFF[fNCorrectionLevels-2]->GetXi(i); // level -2: before unfolding, level -1: unfolded
+ else{
+ Printf("%s%d unknown type",(char*)__FILE__,__LINE__);
+ return;
+ }
THnSparse* hnResponse = 0;
- if(type == kFlagPt) hnResponse = fhnResponsePt[i];
+ if(type == kFlagPt) hnResponse = fhnResponsePt[i];
else if(type == kFlagZ) hnResponse = fhnResponseZ[i];
else if(type == kFlagXi) hnResponse = fhnResponseXi[i];
-
+ else{
+ Printf("%s%d unknown type",(char*)__FILE__,__LINE__);
+ return;
+ }
TH1F* hPrior = 0;
if(type == kFlagPt && fh1FFTrackPtPrior[i] && ((TString(fh1FFTrackPtPrior[i]->GetName())).Length() > 0) ) hPrior = fh1FFTrackPtPrior[i];
THnSparse* hnUnfolded
= Unfold(hnHist,hnResponse,hnFlatEfficiency,nIter,useCorrelatedErrors,hnPrior);
- TH1F* hUnfolded = (TH1F*) hnUnfolded->Projection(0);
- if (hist)
+ TH1F* hUnfolded = (TH1F*) hnUnfolded->Projection(0);
+ if(hist)
hUnfolded->SetNameTitle(hist->GetName(),hist->GetTitle());
if(type == kFlagPt) fCorrFF[fNCorrectionLevels-1]->AddCorrHistos(i,hUnfolded,0,0);
if(type == kFlagXi) fCorrFF[fNCorrectionLevels-1]->AddCorrHistos(i,0,0,hUnfolded);
// backfolding: apply response matrix to unfolded spectrum
- TH1F* hBackFolded = ApplyResponse(hUnfolded,hnResponse);
- if (hist)
+ TH1F* hBackFolded = ApplyResponse(hUnfolded,hnResponse);
+ if(hist)
hBackFolded->SetNameTitle(histNameBackFolded,hist->GetTitle());
if(type == kFlagPt) fh1FFTrackPtBackFolded[i] = hBackFolded;
// ratio unfolded to original histo
TH1F* hRatioUnfolded = (TH1F*) hUnfolded->Clone(histNameRatioFolded);
hRatioUnfolded->Reset();
- if (hist)
+ if (hist)
hRatioUnfolded->Divide(hUnfolded,hist,1,1,"B");
if(type == kFlagPt) fh1FFRatioTrackPtFolded[i] = hRatioUnfolded;
UInt_t filterMask,
Float_t radius,
int kBackgroundMode,
- float PtTrackMin,
+ Int_t PtTrackMin,
TString BrOpt="",
TString BrOpt2="",
- Float_t radiusBckg=0.4)
+ TString BrOpt3="",
+ Float_t radiusBckg=0.4,
+ Int_t FFMaxTrackPt = -1,
+ Float_t FFMinNTracks = 0)
{
// adds task with given configuration for all centralities
eventClass,
BrOpt,
BrOpt2,
- radiusBckg);
+ BrOpt3,
+ radiusBckg
+ FFMaxTrackPt,
+ FFMinNTracks);
}
return ff;
UInt_t filterMask,
Float_t radius,
int kBackgroundMode,
- float PtTrackMin,
+ Int_t PtTrackMin,
Int_t eventClass=0,
TString BrOpt="",
TString BrOpt2="",
- Float_t radiusBckg=0.4)
+ TString BrOpt3="",
+ Float_t radiusBckg=0.4,
+ Int_t FFMaxTrackPt = -1,
+ Int_t FFMinNTracks = 0)
{
// Creates a fragmentation function task,
// configures it and adds it to the analysis manager.
cAdd += Form("%02d",(int)((radius+0.01)*10.));
cAdd += Form("_B%d",(int)((kBackgroundMode)));
cAdd += Form("_Filter%05d",filterMask);
- cAdd += Form("_Cut%05d",(int)((PtTrackMin)));
+ cAdd += Form("_Cut%05d",PtTrackMin);
cAdd += Form("%s",BrOpt.Data());
cAdd += Form("%s",BrOpt2.Data());
+
Printf("%s",cAdd.Data());
TString cAddb = "";
cAddb += Form("%02d",(int)((radiusBckg+0.01)*10.));
cAddb += Form("_B%d",(int)((kBackgroundMode)));
cAddb += Form("_Filter%05d",filterMask);
- cAddb += Form("_Cut%05d",(int)((PtTrackMin)));
+ cAddb += Form("_Cut%05d",PtTrackMin);
cAddb += Form("%s",BrOpt.Data());
cAddb += Form("%s",BrOpt2.Data());
+
Printf("%s",cAddb.Data());
TString cAddmc = "";
cAddmc += Form("%02d",(int)((radius+0.01)*10.));
cAddmc += Form("_B%d",(int)((kBackgroundMode)));
cAddmc += Form("_Filter%05d",filterMask);
- cAddmc += Form("_Cut%05d",(int)((PtTrackMin)));
+ cAddmc += Form("_Cut%05d",PtTrackMin);
+ cAddmc += Form("%s",BrOpt3.Data());
+
Printf("%s",cAddmc.Data());
// Set default parameters
// Cut selection
-
- if((int)PtTrackMin == 2000) task->SetTrackCuts(2.0, -0.9, 0.9, 0., 2*TMath::Pi());
- else if((int)PtTrackMin == 1000) task->SetTrackCuts(1.0, -0.9, 0.9, 0., 2*TMath::Pi());
- else task->SetTrackCuts(); // default : pt > 0.150 GeV, |eta|<0.9, full phi acc
+
+ if(PtTrackMin == 150) task->SetTrackCuts(); // default : pt > 0.150 GeV, |eta|<0.9, full phi acc
+ else if(PtTrackMin == 1000) task->SetTrackCuts(1.0, -0.9, 0.9, 0., 2*TMath::Pi());
+ else if(PtTrackMin == 2000) task->SetTrackCuts(2.0, -0.9, 0.9, 0., 2*TMath::Pi());
+ else task->SetTrackCuts(0.001*PtTrackMin,-0.9, 0.9, 0., 2*TMath::Pi());
- task->SetJetCuts(); // default: jet pt > 5 GeV, |eta|<0.5, full phi acc
- task->SetDiJetCuts(); // default: type of cut = 1 (cut in deltaPhi), deltaPhi = 0., cdf = 0.5, fraction of pt = 0.6
- task->SetKindSlices(); // default: kindSlice = 1 (inv mass)
- //if(radius <= 0.2) task->SetFFRadius(0.2); // R = 0.2
- //else task->SetFFRadius(); // default: R = 0.4
+ task->SetJetCuts(); // default: jet pt > 5 GeV, |eta|<0.5, full phi acc
+ task->SetDiJetCuts(); // default: type of cut = 1 (cut in deltaPhi), deltaPhi = 0., cdf = 0.5, fraction of pt = 0.6
+ task->SetKindSlices(); // default: kindSlice = 1 (inv mass)
task->SetFFRadius(radius);
- task->SetFFBckgRadius(); // default: R = 0.7
- task->SetBckgSubMethod(); // default: subMethod = O, 1 = leading jet removed for rho extraction, 2 = 2 leading jets removed
- task->SetIJMode(0); // default: ijMode = 1
- task->SetQAMode(); // default: qaMode = 3
- task->SetFFMode(); // default: ffMode = 1
+ task->SetFFBckgRadius(); // default: R = 0.7
+ task->SetBckgSubMethod(); // default: subMethod = O, 1 = leading jet removed for rho extraction, 2 = 2 leading jets removed
+ task->SetIJMode(0); // default: ijMode = 1
+ task->SetQAMode(); // default: qaMode = 3
+ task->SetFFMode(); // default: ffMode = 1
task->SetDJMode(0); // default: djMode = 1
task->SetEffMode(0); // default: effMode = 1
task->SetPhiCorrMode(0); // default: phiCorrMode = 1
task->SetDiJetHistoBins();
task->SetQADiJetHistoBins();
+ if(FFMaxTrackPt>0) task->SetFFMaxTrackPt(FFMaxTrackPt);
+ if(FFMinNTracks>0) task->SetFFMinNTracks(FFMinNTracks);
+
mgr->AddTask(task);
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
- AliAnalysisDataContainer *coutput_FragFunc = mgr->CreateContainer(
- Form("fracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass),
- TList::Class(),
- AliAnalysisManager::kOutputContainer,
- Form("%s:PWGJE_FragmentationFunction_%s_%s_%s_%s_cl%d",
- AliAnalysisManager::GetCommonFileName(), branchRecJets.Data(), branchGenJets. Data(), typeTracks.Data(), typeJets.Data(), eventClass));
+ TString strList(Form("fracfunc_%s_%s_%s_%s_cl%d", branchRecJets.Data(), branchGenJets.Data(), typeTracks.Data(), typeJets.Data(), eventClass));
+
+ TString strDir(Form("%s:PWGJE_FragmentationFunction_%s_%s_%s_%s_cl%d",
+ AliAnalysisManager::GetCommonFileName(), branchRecJets.Data(), branchGenJets. Data(),
+ typeTracks.Data(), typeJets.Data(), eventClass));
+
+
+ if(FFMaxTrackPt>0){
+ strList += Form("_FFMaxPt%d", FFMaxTrackPt);
+ strDir += Form("_FFMaxPt%d", FFMaxTrackPt);
+ }
+ if(FFMinNTracks>0){
+ strList += Form("_minNTr%d",FFMinNTracks);
+ strDir += Form("_minNTr%d",FFMinNTracks);
+ }
+
+ AliAnalysisDataContainer *coutput_FragFunc = mgr->CreateContainer(strList,TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ strDir);
mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff