}
+//-------------------------------------------------------------------
+TObjArray* AliAnalyseLeadingTrackUE::GetAcceptedParticles(TObject* obj, TObject* arrayMC, Bool_t onlyprimaries, Int_t particleSpecies)
+{
+ // Returns an array of particles that pass the cuts, if arrayMC is given each reconstructed particle is replaced by its corresponding MC particles, depending on the parameter onlyprimaries only for primaries
+ // particleSpecies: -1 all particles are returned
+ // 0 (pions) 1 (kaons) 2 (protons) 3 (others) particles
+
+ Int_t nTracks = NParticles(obj);
+ TObjArray* tracks = new TObjArray;
+
+ // Loop over tracks or jets
+ for (Int_t ipart=0; ipart<nTracks; ++ipart) {
+ AliVParticle* part = ParticleWithCuts( obj, ipart, onlyprimaries, particleSpecies );
+ if (!part) continue;
+
+ if (arrayMC && arrayMC->InheritsFrom("TClonesArray") && obj->InheritsFrom("AliAODEvent")) {
+ Int_t label = ((AliAODTrack*)part)->GetLabel();
+ // re-define part as the matched MC particle
+ part = (AliAODMCParticle*)ParticleWithCuts(arrayMC, TMath::Abs(label),onlyprimaries, particleSpecies);
+ if (!part)continue;
+ }
+
+ tracks->Add(part);
+ }
+
+ return tracks;
+}
+
//-------------------------------------------------------------------
TObjArray* AliAnalyseLeadingTrackUE::GetMinMaxRegion(TList *transv1, TList *transv2)
{
//-------------------------------------------------------------------
-AliVParticle* AliAnalyseLeadingTrackUE::ParticleWithCuts(TObject* obj, Int_t ipart, Bool_t onlyprimaries)
+AliVParticle* AliAnalyseLeadingTrackUE::ParticleWithCuts(TObject* obj, Int_t ipart, Bool_t onlyprimaries, Int_t particleSpecies)
{
// Returns track or MC particle at position "ipart" if passes selection criteria
+ // particleSpecies: -1 all particles are returned
+ // 0 (pions) 1 (kaons) 2 (protons) 3 (others) particles
AliVParticle *part=0;
if (obj->InheritsFrom("TClonesArray")){ // AOD-MC PARTICLE
TMath::Abs(pdgCode)==321; // Kaon
if (!isHadron) return 0;
}
+ if (particleSpecies != -1) {
+ // find the primary mother
+ AliVParticle* mother = part;
+ while (!((AliAODMCParticle*)mother)->IsPhysicalPrimary())
+ {
+ if (((AliAODMCParticle*)mother)->GetMother() < 0)
+ {
+ mother = 0;
+ break;
+ }
+
+ mother = (AliVParticle*) arrayMC->At(((AliAODMCParticle*)mother)->GetMother());
+ if (!mother)
+ break;
+ }
+
+ if (mother)
+ {
+ Int_t pdgCode = ((AliAODMCParticle*)mother)->GetPdgCode();
+ if (particleSpecies == 0 && TMath::Abs(pdgCode)!=211)
+ return 0;
+ if (particleSpecies == 1 && TMath::Abs(pdgCode)!=321)
+ return 0;
+ if (particleSpecies == 2 && TMath::Abs(pdgCode)!=2212)
+ return 0;
+ if (particleSpecies == 3 && (TMath::Abs(pdgCode)==211 || TMath::Abs(pdgCode)==321 || TMath::Abs(pdgCode)==2212))
+ return 0;
+ }
+ }
}else if (obj->InheritsFrom("TObjArray")){ // list of AliVParticle
TObjArray *array = dynamic_cast<TObjArray*>(obj);
if (TMath::Abs(leadVect.DeltaPhi(partVect)) > k120rad ) region = -2; //backward
// skip leading particle
- if (leading == part)
+ if (leading == part)
continue;
if (!region)continue;
TObjArray* FindLeadingObjects(TObject* obj); // Looks for leading track or MC particle
TObjArray* GetMinMaxRegion(TList* transv1, TList* transv2); // Sorts the transverse regions in MIN and MAX
Int_t NParticles(TObject *obj); // Counts tracks or MC particles
- AliVParticle* ParticleWithCuts(TObject* obj, Int_t ipart, Bool_t onlyprimaries = kTRUE ); // Returns track or MC particle at position "ipart" if passes selection criteria
+ AliVParticle* ParticleWithCuts(TObject* obj, Int_t ipart, Bool_t onlyprimaries = kTRUE, Int_t particleSpecies = -1); // Returns track or MC particle at position "ipart" if passes selection criteria
void QSortTracks(TObjArray &a, Int_t first, Int_t last); // Sort by pT an array of AliVParticles
TObjArray* SortRegions(const AliVParticle* leading, TObject* obj, TObject* arrayMC, Bool_t onlyprimaries = kTRUE); // Assign particles to towards, away or transverse regions
+ TObjArray* GetAcceptedParticles(TObject* obj, TObject* arrayMC, Bool_t onlyprimaries = kTRUE, Int_t particleSpecies = -1);
Bool_t TriggerSelection(const TObject* obj); // Select good triggers with AliPhysicsSelection class
Bool_t VertexSelection(const TObject* obj, Int_t ntracks, Double_t zed); // Vertex selection: see implementation
// general configuration
fDebug(0),
fMode(0),
+fReduceMemoryFootprint(kFALSE),
// pointers to UE classes
fAnalyseUE(0x0),
fHistosUE(0x0),
}
+AliAnalysisTaskLeadingTrackUE::~AliAnalysisTaskLeadingTrackUE()
+{
+ // destructor
+
+ if (fListOfHistos && !AliAnalysisManager::GetAnalysisManager()->IsProofMode())
+ delete fListOfHistos;
+}
/************** INTERFACE METHODS *****************************/
//____________________________________________________________________
void AliAnalysisTaskLeadingTrackUE::AnalyseCorrectionMode()
{
-
// Run the analysis on MC to get the correction maps
+ //
+ // if fReduceMemoryFootprint step 3,4,5,7,9 are not filled
PostData(0,fListOfHistos);
if (fAnalyseUE->TriggerSelection(fInputHandler))
{
// PILEUP-CUT
- Bool_t select = kTRUE;
+ Bool_t select = kFALSE;
if (fSelectBit) select = AliAnalysisHelperJetTasks::TestSelectInfo(fSelectBit);
- if (!select)
+ if (select)
fHistosUE->FillEvent(fillId, -2);
else
{
// STEP 2
fHistosUE->Fill(fillId,AliUEHist::kCFStepVertex,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
-
+ // fill here for tracking efficiency
+ // loop over particle species
+ for (Int_t particleSpecies = 0; particleSpecies < 4; particleSpecies++)
+ {
+ TObjArray* primMCParticles = fAnalyseUE->GetAcceptedParticles(fArrayMC, 0x0, kTRUE, particleSpecies);
+ TObjArray* primRecoTracksMatched = fAnalyseUE->GetAcceptedParticles(fAOD, fArrayMC, kTRUE, particleSpecies);
+ TObjArray* allRecoTracksMatched = fAnalyseUE->GetAcceptedParticles(fAOD, fArrayMC, kFALSE, particleSpecies);
+
+ fHistosUE->FillTrackingEfficiency(primMCParticles, primRecoTracksMatched, allRecoTracksMatched, particleSpecies);
+
+ delete primMCParticles;
+ delete primRecoTracksMatched;
+ delete allRecoTracksMatched;
+ }
// Get Reconstructed leading particle *******************************
TObjArray *ltRECO = fAnalyseUE->FindLeadingObjects(fAOD);
// Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
// (MC-true leading particle and MC-true all particles)
// STEP 3
- fHistosUE->Fill(fillId,AliUEHist::kCFStepAnaTopology,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
+ if (!fReduceMemoryFootprint)
+ fHistosUE->Fill(fillId,AliUEHist::kCFStepAnaTopology,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
//Sort RECO particles w.r.t. MC-leading and return matched (primary) MC particle
// (you cannot sort tracks w.r.t. RECO-leading and plot it vs. MC-leading ...)
- TObjArray *regionSortedParticlesRECOLTMC = (TObjArray*)fAnalyseUE->SortRegions(leadingMC, fAOD, fArrayMC);
+ TObjArray *regionSortedParticlesRECOLTMC = (TObjArray*)fAnalyseUE->SortRegions(leadingMC, fAOD, fArrayMC, kTRUE);
TObjArray *regionsMinMaxRECOLTMC = (TObjArray*)fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesRECOLTMC->At(2),(TList*)regionSortedParticlesRECOLTMC->At(3));
// Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
// (MC leading particle and RECO-matched (quantities from MC particle) all particles)
// STEP 4
- fHistosUE->Fill(fillId,AliUEHist::kCFStepTrackedOnlyPrim,leadingMC,(TList*)regionSortedParticlesRECOLTMC->At(0),(TList*)regionSortedParticlesRECOLTMC->At(1),(TList*)regionsMinMaxRECOLTMC->At(0),(TList*)regionsMinMaxRECOLTMC->At(1));
+ if (!fReduceMemoryFootprint)
+ fHistosUE->Fill(fillId,AliUEHist::kCFStepTrackedOnlyPrim,leadingMC,(TList*)regionSortedParticlesRECOLTMC->At(0),(TList*)regionSortedParticlesRECOLTMC->At(1),(TList*)regionsMinMaxRECOLTMC->At(0),(TList*)regionsMinMaxRECOLTMC->At(1));
// comparing this step with step 3 (for all-tracks observables) you get the tracking efficiency
//Sort RECO particles w.r.t. MC-leading and return matched (primary+secondary) MC particle
// Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
// (MC leading particle and RECO-matched (quantities from MC particle) all particles)
// STEP 5
- fHistosUE->Fill(fillId,AliUEHist::kCFStepTracked,leadingMC,(TList*)regionSortedParticlesRECOLTMC2->At(0),(TList*)regionSortedParticlesRECOLTMC2->At(1),(TList*)regionsMinMaxRECOLTMC2->At(0),(TList*)regionsMinMaxRECOLTMC2->At(1));
+ if (!fReduceMemoryFootprint)
+ fHistosUE->Fill(fillId,AliUEHist::kCFStepTracked,leadingMC,(TList*)regionSortedParticlesRECOLTMC2->At(0),(TList*)regionSortedParticlesRECOLTMC2->At(1),(TList*)regionsMinMaxRECOLTMC2->At(0),(TList*)regionsMinMaxRECOLTMC2->At(1));
// comparing this step with step 3 (for all-tracks observables) you get the tracking efficiency
// SWITCH TO RECONSTRUCTED TRACKS ************************************
// STEP 8 for reduced efficiency study
FillReducedEfficiency(fillId, AliUEHist::kCFStepBiasStudy, ltRECO, kFALSE);
- FillReducedEfficiency(fillId, AliUEHist::kCFStepBiasStudy2, ltRECO, kTRUE);
+ if (!fReduceMemoryFootprint)
+ FillReducedEfficiency(fillId, AliUEHist::kCFStepBiasStudy2, ltRECO, kTRUE);
// count number of reco tracks above 150 MeV/c
Int_t nRecoTracks = 0;
// Trigger selection ************************************************
if (!fAnalyseUE->TriggerSelection(fInputHandler)) return;
// PILEUP-CUT
- Bool_t select = kTRUE;
+ Bool_t select = kFALSE;
if (fSelectBit) select = AliAnalysisHelperJetTasks::TestSelectInfo(fSelectBit);
- if (!select)
+ if (select)
{
fHistosUE->FillEvent(eventId, -2);
return;
{
public:
AliAnalysisTaskLeadingTrackUE(const char* name="AliAnalysisTaskLeadingTrackUE");
- virtual ~AliAnalysisTaskLeadingTrackUE() {if ( fListOfHistos ) delete fListOfHistos; }
+ virtual ~AliAnalysisTaskLeadingTrackUE();
// Implementation of interace methods
// general configuration
virtual void SetDebugLevel( Int_t level ) { fDebug = level; }
virtual void SetMode(Int_t mode) { fMode = mode; }
+ virtual void SetReduceMemoryFootprint(Bool_t flag) { fReduceMemoryFootprint = flag; }
// histogram settings
void SetPtRangeInHist( Int_t bin, Double_t min, Double_t max ) {
Int_t fDebug; // Debug flag
Int_t fMode; // fMode = 0: data-like analysis
// fMode = 1: corrections analysis
+ Bool_t fReduceMemoryFootprint; // reduce memory consumption by writing less debug histograms
// Pointers to external UE classes
AliAnalyseLeadingTrackUE* fAnalyseUE; //! points to class containing common analysis algorithms
TObject(),
fkRegions(4),
fEventHist(0),
+ fTrackHistEfficiency(0),
fEtaMin(0),
fEtaMax(0),
fPtMin(0),
for (Int_t i=0; i<=kNMultiplicityBins; i++)
multiplicityBins[i] = -0.5 + i;
multiplicityBins[kNMultiplicityBins] = 200;
+
+ // particle species
+ const Int_t kNSpeciesBins = 4; // pi, K, p, rest
+ Double_t speciesBins[] = { -0.5, 0.5, 1.5, 2.5, 3.5 };
trackBins[3] = multiplicityBins;
iTrackBin[3] = kNMultiplicityBins;
fEventHist->SetVarTitle(1, trackAxisTitle[3]);
SetStepNames(fEventHist);
+
+ iTrackBin[2] = kNSpeciesBins;
+
+ fTrackHistEfficiency = new AliCFContainer("fTrackHistEfficiency", "Tracking efficiency", 3, 3, iTrackBin);
+ fTrackHistEfficiency->SetBinLimits(0, trackBins[0]);
+ fTrackHistEfficiency->SetVarTitle(0, trackAxisTitle[0]);
+ fTrackHistEfficiency->SetBinLimits(1, trackBins[1]);
+ fTrackHistEfficiency->SetVarTitle(1, trackAxisTitle[1]);
+ fTrackHistEfficiency->SetBinLimits(2, speciesBins);
+ fTrackHistEfficiency->SetVarTitle(2, "particle species");
}
//_____________________________________________________________________________
TObject(),
fkRegions(4),
fEventHist(0),
+ fTrackHistEfficiency(0),
fEtaMin(0),
fEtaMax(0),
fPtMin(0),
fEventHist = 0;
}
+ if (fTrackHistEfficiency)
+ {
+ delete fTrackHistEfficiency;
+ fTrackHistEfficiency = 0;
+ }
+
if (fCache)
{
delete fCache;
if (fEventHist)
target.fEventHist = dynamic_cast<AliCFContainer*> (fEventHist->Clone());
+
+ if (fTrackHistEfficiency)
+ target.fTrackHistEfficiency = dynamic_cast<AliCFContainer*> (fTrackHistEfficiency->Clone());
}
//____________________________________________________________________
TObject* obj;
// collections of objects
- const Int_t kMaxLists = fkRegions+1;
+ const Int_t kMaxLists = fkRegions+2;
TList** lists = new TList*[kMaxLists];
for (Int_t i=0; i<kMaxLists; i++)
lists[i]->Add(entry->fTrackHist[i]);
lists[fkRegions]->Add(entry->fEventHist);
+ lists[fkRegions+1]->Add(entry->fTrackHistEfficiency);
count++;
}
fTrackHist[i]->Merge(lists[i]);
fEventHist->Merge(lists[fkRegions]);
+ fTrackHistEfficiency->Merge(lists[fkRegions+1]);
for (Int_t i=0; i<kMaxLists; i++)
delete lists[i];
vertexCorrectionObs->SetBinContent(i, vertexCorrection->Interpolate(xPos));
}
+ #if 0
new TCanvas;
vertexCorrection->DrawCopy();
vertexCorrectionObs->SetLineColor(2);
vertexCorrectionObs->DrawCopy("same");
+ #endif
CorrectTracks(kCFStepVertex, kCFStepTriggered, vertexCorrectionObs, 3);
CorrectEvents(kCFStepVertex, kCFStepTriggered, vertexCorrectionObs, 1);
}
//____________________________________________________________________
-TH1* AliUEHist::GetTrackEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2)
+TH1* AliUEHist::GetTrackEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2, Int_t source)
{
// creates a track-level efficiency by dividing step2 by step1
// projected to axis1 and axis2 (optional if >= 0)
+ //
+ // source: 0 = fTrackHist; 1 = fTrackHistEfficiency
// integrate over regions
// cache it for efficiency (usually more than one efficiency is requested)
- if (!fCache)
+
+ AliCFContainer* sourceContainer = 0;
+
+ if (source == 0)
{
- fCache = (AliCFContainer*) fTrackHist[0]->Clone();
- for (Int_t i = 1; i < fkRegions; i++)
- if (fTrackHist[i])
- fCache->Add(fTrackHist[i]);
+ if (!fCache)
+ {
+ fCache = (AliCFContainer*) fTrackHist[0]->Clone();
+ for (Int_t i = 1; i < fkRegions; i++)
+ if (fTrackHist[i])
+ fCache->Add(fTrackHist[i]);
+ }
+ sourceContainer = fCache;
}
-
+ else if (source == 1)
+ {
+ sourceContainer = fTrackHistEfficiency;
+ // step offset because we start with kCFStepAnaTopology
+ step1 = (CFStep) ((Int_t) step1 - (Int_t) kCFStepAnaTopology);
+ step2 = (CFStep) ((Int_t) step2 - (Int_t) kCFStepAnaTopology);
+ }
+ else
+ return 0;
+
// reset all limits and set the right ones except those in axis1 and axis2
- ResetBinLimits(fCache->GetGrid(step1));
- ResetBinLimits(fCache->GetGrid(step2));
+ ResetBinLimits(sourceContainer->GetGrid(step1));
+ ResetBinLimits(sourceContainer->GetGrid(step2));
if (fEtaMax > fEtaMin && axis1 != 0 && axis2 != 0)
{
- fCache->GetGrid(step1)->SetRangeUser(0, fEtaMin, fEtaMax);
- fCache->GetGrid(step2)->SetRangeUser(0, fEtaMin, fEtaMax);
+ sourceContainer->GetGrid(step1)->SetRangeUser(0, fEtaMin, fEtaMax);
+ sourceContainer->GetGrid(step2)->SetRangeUser(0, fEtaMin, fEtaMax);
}
if (fPtMax > fPtMin && axis1 != 1 && axis2 != 1)
{
- fCache->GetGrid(step1)->SetRangeUser(1, fPtMin, fPtMax);
- fCache->GetGrid(step2)->SetRangeUser(1, fPtMin, fPtMax);
+ sourceContainer->GetGrid(step1)->SetRangeUser(1, fPtMin, fPtMax);
+ sourceContainer->GetGrid(step2)->SetRangeUser(1, fPtMin, fPtMax);
}
TH1* measured = 0;
if (axis2 >= 0)
{
- generated = fCache->Project(axis1, axis2, step1);
- measured = fCache->Project(axis1, axis2, step2);
+ generated = sourceContainer->Project(axis1, axis2, step1);
+ measured = sourceContainer->Project(axis1, axis2, step2);
}
else
{
- generated = fCache->Project(axis1, step1);
- measured = fCache->Project(axis1, step2);
+ generated = sourceContainer->Project(axis1, step1);
+ measured = sourceContainer->Project(axis1, step2);
}
// check for bins with less than 100 entries, print warning
delete generated;
+ ResetBinLimits(sourceContainer->GetGrid(step1));
+ ResetBinLimits(sourceContainer->GetGrid(step2));
+
return measured;
}
return 0;
}
+
+//____________________________________________________________________
+void AliUEHist::CopyReconstructedData(AliUEHist* from)
+{
+ // copies those histograms extracted from ESD to this object
+
+ // TODO at present only the pointers are copied
+
+ for (Int_t region=0; region<4; region++)
+ {
+ if (!fTrackHist[region])
+ continue;
+
+ fTrackHist[region]->SetGrid(AliUEHist::kCFStepReconstructed, from->fTrackHist[region]->GetGrid(AliUEHist::kCFStepReconstructed));
+ fTrackHist[region]->SetGrid(AliUEHist::kCFStepBiasStudy, from->fTrackHist[region]->GetGrid(AliUEHist::kCFStepBiasStudy));
+ }
+
+ fEventHist->SetGrid(AliUEHist::kCFStepReconstructed, from->fEventHist->GetGrid(AliUEHist::kCFStepReconstructed));
+ fEventHist->SetGrid(AliUEHist::kCFStepBiasStudy, from->fEventHist->GetGrid(AliUEHist::kCFStepBiasStudy));
+}
AliCFContainer* GetTrackHist(Region region) { return fTrackHist[region]; }
AliCFContainer* GetEventHist() { return fEventHist; }
+ AliCFContainer* GetTrackHistEfficiency() { return fTrackHistEfficiency; }
void SetTrackHist(Region region, AliCFContainer* hist) { fTrackHist[region] = hist; }
void SetEventHist(AliCFContainer* hist) { fEventHist = hist; }
+ void CopyReconstructedData(AliUEHist* from);
+
TH1D* GetUEHist(CFStep step, Region region, Float_t ptLeadMin = -1, Float_t ptLeadMax = -1);
- TH1* GetTrackEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2 = -1);
+ TH1* GetTrackEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2 = -1, Int_t source = 1);
TH1* GetEventEfficiency(CFStep step1, CFStep step2, Int_t axis1, Int_t axis2 = -1, Float_t ptLeadMin = -1, Float_t ptLeadMax = -1);
TH1* GetBias(CFStep step1, CFStep step2, Int_t region, const char* axis, Float_t leadPtMin = 0, Float_t leadPtMax = 0);
AliCFContainer* fTrackHist[4]; // container for track level distributions in four regions (toward, away, min, max) and at four analysis steps
AliCFContainer* fEventHist; // container for event level distribution at four analysis steps
+ AliCFContainer* fTrackHistEfficiency; // container for tracking efficiency and contamination (all particles filled including leading one): axes: eta, pT, particle species
Float_t fEtaMin; // eta min for projections
Float_t fEtaMax; // eta max for projections
AliCFContainer* fCache; //! cache variable for GetTrackEfficiency
- ClassDef(AliUEHist, 2) // underlying event histogram container
+ ClassDef(AliUEHist, 3) // underlying event histogram container
};
#endif
FillRegion(AliUEHist::kAway, step, leading, away, multiplicity);
FillRegion(AliUEHist::kMin, step, leading, min, multiplicity);
FillRegion(AliUEHist::kMax, step, leading, max, multiplicity);
-
+
Double_t vars[2];
vars[0] = leading->Pt();
vars[1] = multiplicity;
}
}
+//____________________________________________________________________
+void AliUEHistograms::FillTrackingEfficiency(TObjArray* mc, TObjArray* recoPrim, TObjArray* recoAll, Int_t particleType)
+{
+ // fills the tracking efficiency objects
+ //
+ // mc: all primary MC particles
+ // recoPrim: reconstructed primaries (again MC particles)
+ // recoAll: reconstructed (again MC particles)
+ // particleType is: 0 for pion, 1 for kaon, 2 for proton, 3 for others
+
+ for (Int_t step=0; step<3; step++)
+ {
+ TObjArray* list = mc;
+ if (step == 1)
+ list = recoPrim;
+ else if (step == 2)
+ list = recoAll;
+
+ for (Int_t i=0; i<list->GetEntries(); i++)
+ {
+ AliVParticle* particle = (AliVParticle*) list->At(i);
+ Double_t vars[2];
+ vars[0] = particle->Eta();
+ vars[1] = particle->Pt();
+ vars[2] = particleType;
+
+ fNumberDensitypT->GetTrackHistEfficiency()->Fill(vars, step);
+ fSumpT->GetTrackHistEfficiency()->Fill(vars, step);
+ fNumberDensityPhi->GetTrackHistEfficiency()->Fill(vars, step);
+ }
+ }
+}
+
//____________________________________________________________________
void AliUEHistograms::FillEvent(Int_t eventType, Int_t step)
{
return count+1;
}
+
+void AliUEHistograms::CopyReconstructedData(AliUEHistograms* from)
+{
+ // copies those histograms extracted from ESD to this object
+
+ fNumberDensitypT->CopyReconstructedData(from->fNumberDensitypT);
+ fSumpT->CopyReconstructedData(from->fSumpT);
+ fNumberDensityPhi->CopyReconstructedData(from->fNumberDensityPhi);
+}
void Fill(Int_t eventType, AliUEHist::CFStep step, AliVParticle* leading, TList* toward, TList* away, TList* min, TList* max);
void Fill(AliVParticle* leadingMC, AliVParticle* leadingReco);
void FillEvent(Int_t eventType, Int_t step);
+ void FillTrackingEfficiency(TObjArray* mc, TObjArray* recoPrim, TObjArray* recoAll, Int_t particleType);
+
+ void CopyReconstructedData(AliUEHistograms* from);
AliUEHist* GetNumberDensitypT() { return fNumberDensitypT; }
AliUEHist* GetSumpT() { return fSumpT; }
ueana->SetDebugLevel(0); \r
ueana->SetPtRangeInHist(100, 0., 100.);\r
ueana->SetFilterBit(16); \r
+ //ueana->SetFilterBit(16+32); \r
ueana->SetTrackEtaCut(0.8);\r
ueana->SetLeadingTrackEtaCut(0.8);\r
- \r
+ ueana->SetEventSelectionBit(AliAnalysisHelperJetTasks::kIsPileUp);\r
+ //ueana->SetReduceMemoryFootprint(kTRUE);\r
+ \r
if (1)\r
{\r
file = TFile::Open("$ALICE_ROOT/PWG4/JetTasks/inputFiles/ue_trackingefficiency.root");\r
--- /dev/null
+const char* objectName = "PWG4_LeadingTrackUE/histosLeadingTrackUE";
+//const char* objectName = "PWG4_LeadingTrackUE/histosLeadingTrackUE_filterbit32";
+
+void SetRanges(TAxis* axis)
+{
+ if (strcmp(axis->GetTitle(), "leading p_{T} (GeV/c)") == 0)
+ axis->SetRangeUser(0, 10);
+
+ if (strcmp(axis->GetTitle(), "multiplicity") == 0)
+ axis->SetRangeUser(0, 10);
+}
+
+void SetRanges(TH1* hist)
+{
+ SetRanges(hist->GetXaxis());
+ SetRanges(hist->GetYaxis());
+ SetRanges(hist->GetZaxis());
+}
+
+void Prepare1DPlot(TH1* hist)
+{
+ hist->SetLineWidth(2);
+ hist->SetStats(kFALSE);
+
+ hist->GetXaxis()->SetLabelOffset(0.02);
+ hist->GetXaxis()->SetTitleOffset(1.3);
+ hist->GetYaxis()->SetTitleOffset(1.3);
+
+ SetRanges(hist);
+}
+
+void DrawRatio(TH1* corr, TH1* mc, const char* name)
+{
+ mc->SetLineColor(2);
+
+ TCanvas* canvas3 = new TCanvas(name, name, 600, 600);
+ canvas3->Range(0, 0, 1, 1);
+
+ TPad* pad1 = new TPad(Form("%s_1", name), "", 0, 0.5, 0.98, 0.98);
+ pad1->Draw();
+
+ TPad* pad2 = new TPad(Form("%s_2", name), "", 0, 0.02, 0.98, 0.5);
+ pad2->Draw();
+
+ pad1->SetRightMargin(0.01);
+ pad2->SetRightMargin(0.01);
+ pad1->SetTopMargin(0.05);
+ pad1->SetLeftMargin(0.13);
+ pad2->SetLeftMargin(0.13);
+ pad2->SetBottomMargin(0.22);
+
+ // no border between them
+ pad1->SetBottomMargin(0);
+ pad2->SetTopMargin(0);
+
+ pad1->cd();
+ pad1->SetGridx();
+ pad1->SetGridy();
+
+ TLegend* legend = new TLegend(0.15, 0.65, 0.55, 0.90);
+ legend->SetFillColor(0);
+ legend->AddEntry(corr, "Corrected");
+ legend->AddEntry(mc, "MC prediction");
+ legend->SetTextSize(0.08);
+
+ Prepare1DPlot(corr);
+
+ TH2F* dummy = new TH2F("dummy", "", 100, corr->GetXaxis()->GetBinLowEdge(1), corr->GetXaxis()->GetBinUpEdge(corr->GetNbinsX()), 1000, 0, TMath::Max(corr->GetMaximum(), mc->GetMaximum()) * 1.1);
+ dummy->SetStats(kFALSE);
+ dummy->SetXTitle(corr->GetXaxis()->GetTitle());
+ dummy->SetYTitle(corr->GetYaxis()->GetTitle());
+ dummy->GetYaxis()->SetTitleOffset(1);
+ Prepare1DPlot(dummy);
+
+ dummy->GetXaxis()->SetLabelSize(0.08);
+ dummy->GetYaxis()->SetLabelSize(0.08);
+ dummy->GetXaxis()->SetTitleSize(0.08);
+ dummy->GetYaxis()->SetTitleSize(0.08);
+ dummy->GetYaxis()->SetTitleOffset(0.8);
+ dummy->DrawCopy();
+
+ corr->Draw("SAME");
+ mc->Draw("SAME");
+
+ legend->Draw();
+
+ pad2->cd();
+ //pad2->SetBottomMargin(0.15);
+ //pad2->SetGridx();
+ //pad2->SetGridy();
+
+ TH1* ratio = (TH1*) mc->Clone("ratio");
+ ratio->Divide(corr);
+
+ Float_t minR = TMath::Min(0.91, ratio->GetMinimum() * 0.95);
+ Float_t maxR = TMath::Max(1.09, ratio->GetMaximum() * 1.05);
+
+ minR = 0.8;
+ maxR = 1.2;
+
+ TH1F dummy3("dummy3", ";;Ratio: MC / corr", 100, corr->GetXaxis()->GetBinLowEdge(1), corr->GetXaxis()->GetBinUpEdge(corr->GetNbinsX()));
+ dummy3.SetXTitle(corr->GetXaxis()->GetTitle());
+ Prepare1DPlot(&dummy3);
+ dummy3.SetStats(kFALSE);
+ for (Int_t i=1; i<=100; ++i)
+ dummy3.SetBinContent(i, 1);
+ dummy3.GetYaxis()->SetRangeUser(minR, maxR);
+ dummy3.SetLineWidth(2);
+ dummy3.GetXaxis()->SetLabelSize(0.08);
+ dummy3.GetYaxis()->SetLabelSize(0.08);
+ dummy3.GetXaxis()->SetTitleSize(0.08);
+ dummy3.GetYaxis()->SetTitleSize(0.08);
+ dummy3.GetYaxis()->SetTitleOffset(0.8);
+ dummy3.DrawCopy();
+
+ ratio->Draw("SAME");
+
+ canvas3->Modified();
+}
+
+void loadlibs()
+{
+ gSystem->Load("libANALYSIS");
+ gSystem->Load("libANALYSISalice");
+ gSystem->Load("libCORRFW");
+ gSystem->Load("libJETAN");
+ gSystem->Load("libPWG4JetTasks");
+}
+
+void CompareBias(const char* mcFile = "PWG4_JetTasksOutput.root", Int_t region)
+{
+ loadlibs();
+
+ TFile::Open(mcFile);
+ list = (TList*) gFile->Get(objectName);
+ AliUEHistograms* h = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+ h->SetEtaRange(-0.79, 0.79);
+ h->SetPtRange(0.51, 100);
+ h->SetCombineMinMax(kTRUE);
+
+ biasFromData = (TH1*) h->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepBiasStudy, AliUEHist::kCFStepReconstructed, region, "z")->Clone("biasFromData");
+ biasFromData2 = (TH1*) h->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepBiasStudy2, AliUEHist::kCFStepReconstructed, region, "z")->Clone("biasFromData2");
+ //biasFromData = (TH1*) h->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepReconstructed, AliUEHist::kCFStepRealLeading, region, "z")->Clone("biasFromData");
+ biasFromMC = (TH1*) h->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepReconstructed, AliUEHist::kCFStepTracked, region, "z")->Clone("biasFromMC");
+ //biasFromMC = (TH1*) h->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepReconstructed, AliUEHist::kCFStepRealLeading, region, "z")->Clone("biasFromMC");
+
+/* biasFromData->Draw();
+ biasFromMC->SetLineColor(2);
+ biasFromMC->Draw("SAME");
+ return;*/
+
+ DrawRatio(biasFromData, biasFromMC, "bias: data vs MC");
+ DrawRatio(biasFromData, biasFromData2, "bias: data vs data two step");
+}
+
+void CompareBiasWithData(const char* mcFile = "PWG4_JetTasksOutput.root", const char* dataFile = "esd.root")
+{
+ loadlibs();
+
+ file1 = TFile::Open(mcFile);
+ list = (TList*) file1->Get(objectName);
+ AliUEHistograms* h = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+ h->SetEtaRange(-0.79, 0.79);
+ h->SetPtRange(0.51, 100);
+
+ biasFromMC = (TH1*) h->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepReconstructed, AliUEHist::kCFStepTracked, "z")->Clone("biasFromMC");
+
+ file2 = TFile::Open(dataFile);
+ list = (TList*) file2->Get(objectName);
+ AliUEHistograms* h2 = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+ h2->SetEtaRange(-0.79, 0.79);
+ h2->SetPtRange(0.51, 100);
+
+ biasFromData = (TH1*) h2->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepBiasStudy, AliUEHist::kCFStepReconstructed, "z")->Clone("biasFromData");
+ biasFromData2 = (TH1*) h2->GetNumberDensitypT()->GetBias(AliUEHist::kCFStepBiasStudy2, AliUEHist::kCFStepReconstructed, "z")->Clone("biasFromData2");
+
+ DrawRatio(biasFromData, biasFromMC, "bias: data vs MC");
+ DrawRatio(biasFromData, biasFromData2, "bias: data vs data two step");
+}
+
+void Compare(const char* fileName1, const char* fileName2, Int_t step1, Int_t step2)
+{
+ loadlibs();
+
+ file1 = TFile::Open(fileName1);
+ list = (TList*) file1->Get(objectName);
+ AliUEHistograms* h = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+ h->SetEtaRange(-0.79, 0.79);
+ h->SetPtRange(0.51, 100);
+
+ file2 = TFile::Open(fileName2);
+ list = (TList*) file2->Get(objectName);
+ AliUEHistograms* h2 = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+ h2->SetEtaRange(-0.79, 0.79);
+ h2->SetPtRange(0.51, 100);
+
+ Int_t region = 0;
+
+ TH1* hist1 = h->GetNumberDensitypT()->GetUEHist(step1, region);
+ TH1* hist2 = h2->GetNumberDensitypT()->GetUEHist(step2, region);
+
+ DrawRatio(hist1, hist2, "compare");
+}
+
+void CompareRaw(const char* fileName1, const char* fileName2)
+{
+ loadlibs();
+
+ Compare(fileName1, fileName2, AliUEHist::kCFStepReconstructed, AliUEHist::kCFStepReconstructed);
+}
+
+void ProfileMultiplicity(const char* fileName = "PWG4_JetTasksOutput.root")
+{
+ loadlibs();
+
+ TFile::Open(fileName);
+ list = (TList*) gFile->Get(objectName);
+ AliUEHistograms* h = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+
+ new TCanvas;
+ h->GetCorrelationMultiplicity()->Draw("colz");
+ gPad->SetLogz();
+
+ new TCanvas;
+ h->GetCorrelationMultiplicity()->ProfileX()->DrawCopy()->Fit("pol1", "", "", 1, 10);
+}
+
+void SetupRanges(void* obj)
+{
+ ((AliUEHistograms*) obj)->SetEtaRange(-0.79, 0.79);
+ ((AliUEHistograms*) obj)->SetPtRange(0.51, 100);
+ ((AliUEHistograms*) obj)->SetCombineMinMax(kTRUE);
+}
+
+void DrawRatios(const char* name, void* correctedVoid, void* comparisonVoid, Int_t compareStep = -1, Int_t compareRegion = 2)
+{
+ AliUEHist* corrected = (AliUEHist*) correctedVoid;
+ AliUEHist* comparison = (AliUEHist*) comparisonVoid;
+
+ Int_t beginStep = AliUEHist::kCFStepAll;
+ Int_t endStep = AliUEHist::kCFStepReconstructed;
+
+ if (compareStep != -1)
+ {
+ beginStep = compareStep;
+ endStep = compareStep;
+ }
+
+ Int_t beginRegion = 0;
+ Int_t endRegion = 2;
+
+ if (compareRegion != -1)
+ {
+ beginRegion = compareRegion;
+ endRegion = compareRegion;
+ }
+
+ for (Int_t step=beginStep; step<=endStep; step++)
+ {
+ for (Int_t region=beginRegion; region <= endRegion; region++)
+ {
+ TH1* corrHist = corrected->GetUEHist(step, region);
+ TH1* mcHist = comparison->GetUEHist(step, region);
+
+ DrawRatio(corrHist, mcHist, Form("%s: step %d %s %s", name, step, corrected->GetStepTitle(step), corrected->GetRegionTitle(region)));
+ }
+ }
+}
+
+void DrawRatios(void* correctedVoid, void* comparisonVoid, Int_t compareStep = -1, Int_t compareRegion = 2)
+{
+ AliUEHistograms* corrected = (AliUEHistograms*) correctedVoid;
+ AliUEHistograms* comparison = (AliUEHistograms*) comparisonVoid;
+
+ DrawRatios("Number density", corrected->GetNumberDensitypT(), comparison->GetNumberDensitypT(), compareStep, compareRegion);
+ if (compareStep != -1)
+ {
+ DrawRatios("Pt sum", corrected->GetSumpT(), comparison->GetSumpT(), compareStep, compareRegion);
+ //DrawRatios("Phi correlation", corrected->GetNumberDensityPhi(), comparison->GetNumberDensityPhi(), compareStep, compareRegion);
+ }
+}
+
+void correctMC(const char* fileNameCorrections, const char* fileNameESD = 0, Int_t compareStep = -1, Int_t compareRegion = 2)
+{
+ // corrects the reconstructed step in fileNameESD with fileNameCorr
+ // if fileNameESD is 0 data from fileNameCorr is taken
+ // afterwards the corrected distributions are compared with the MC stored in fileNameESD
+
+ loadlibs();
+
+ TFile::Open(fileNameCorrections);
+ list = (TList*) gFile->Get(objectName);
+ AliUEHistograms* corr = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+
+ if (fileNameESD)
+ {
+ file2 = TFile::Open(fileNameESD);
+ list = (TList*) file2->Get(objectName);
+ }
+ AliUEHistograms* testSample = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+
+ // copy to esd object
+ AliUEHistograms* esd = new AliUEHistograms;
+ esd->CopyReconstructedData(testSample);
+
+ SetupRanges(corr);
+ SetupRanges(testSample);
+ SetupRanges(esd);
+
+ esd->Correct(corr);
+
+ DrawRatios(testSample, esd, compareStep, compareRegion);
+}
+
+// function to compare only final step for all regions and distributions
+
+void correctData(const char* fileNameCorrections, const char* fileNameESD, Int_t compareStep = -1, Int_t compareRegion = 2)
+{
+ // corrects fileNameESD with fileNameCorrections and compares the two
+
+ loadlibs();
+
+ TFile::Open(fileNameCorrections);
+ list = (TList*) gFile->Get(objectName);
+ AliUEHistograms* corr = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+
+ file2 = TFile::Open(fileNameESD);
+ list = (TList*) file2->Get(objectName);
+ AliUEHistograms* esd = (AliUEHistograms*) list->FindObject("AliUEHistograms");
+
+ SetupRanges(corr);
+ SetupRanges(esd);
+
+ esd->Correct(corr);
+
+ file3 = TFile::Open("corrected.root", "RECREATE");
+ esd->Write();
+ file3->Close();
+
+ DrawRatios(corr, esd, compareStep, compareRegion);
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff