Float_t GetMeasuredFraction(CorrectionType correctionType, Float_t ptCutOff, Float_t eta = -100, Bool_t debug = kFALSE);
TH1* GetMeasuredEventFraction(CorrectionType correctionType, Int_t multCut);
- void ReduceInformation();
+ void ReduceInformation();
protected:
AliCorrection* fTrack2ParticleCorrection; //-> handles the track-to-particle correction (only track level (vtx_z, eta, pt))
fOutput(0),
fOption(opt),
fAnalysisMode(AliPWG0Helper::kTPC),
+ fTrigger(AliPWG0Helper::kMB1),
fSignMode(0),
fOnlyPrimaries(kFALSE),
fEsdTrackCuts(0),
Printf("WARNING: sigma-vertex analysis enabled. This will produce weird results in the AliESDtrackCuts histograms");
}
- fVertexCorrelation = new TH2F("fVertexCorrelation", "fVertexCorrelation;MC z-vtx;ESD z-vtx", 80, -20, 20, 80, -20, 20);
+ fVertexCorrelation = new TH2F("fVertexCorrelation", "fVertexCorrelation;MC z-vtx;ESD z-vtx", 120, -30, 30, 120, -30, 30);
+ fOutput->Add(fVertexCorrelation);
fVertexProfile = new TProfile("fVertexProfile", "fVertexProfile;MC z-vtx;MC z-vtx - ESD z-vtx", 40, -20, 20);
+ fOutput->Add(fVertexProfile);
fVertexShiftNorm = new TH1F("fVertexShiftNorm", "fVertexShiftNorm;(MC z-vtx - ESD z-vtx) / #sigma_{ESD z-vtx};Entries", 200, -100, 100);
-
+ fOutput->Add(fVertexShiftNorm);
+
fEtaCorrelation = new TH2F("fEtaCorrelation", "fEtaCorrelation;MC #eta;ESD #eta", 120, -3, 3, 120, -3, 3);
+ fOutput->Add(fEtaCorrelation);
fEtaProfile = new TProfile("fEtaProfile", "fEtaProfile;MC #eta;MC #eta - ESD #eta", 120, -3, 3);
+ fOutput->Add(fEtaProfile);
fMultAll = new TH1F("fMultAll", "fMultAll", 500, -0.5, 499.5);
+ fOutput->Add(fMultAll);
fMultVtx = new TH1F("fMultVtx", "fMultVtx", 500, -0.5, 499.5);
+ fOutput->Add(fMultVtx);
fMultTr = new TH1F("fMultTr", "fMultTr", 500, -0.5, 499.5);
+ fOutput->Add(fMultTr);
for (Int_t i=0; i<8; i++)
+ {
fDeltaPhi[i] = new TH1F(Form("fDeltaPhi_%d", i), ";#Delta phi;Entries", 2000, -0.1, 0.1);
+ fOutput->Add(fDeltaPhi[i]);
+ }
fEventStats = new TH2F("fEventStats", "fEventStats;event type;status;count", 2, -0.5, 1.5, 4, -0.5, 3.5);
+ fOutput->Add(fEventStats);
fEventStats->GetXaxis()->SetBinLabel(1, "INEL");
fEventStats->GetXaxis()->SetBinLabel(2, "NSD");
Printf("WARNING: Processing only primaries. For systematical studies only!");
// trigger definition
- Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2);
+ Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), fTrigger);
if (!eventTriggered)
Printf("No trigger");
if (eventVertex)
fdNdEtaAnalysisMC->FillTrack(vtxMC[2], eta, pt);
+ // TODO this value might be needed lower for the SPD study (only used for control histograms anyway)
if (TMath::Abs(eta) < 1 && pt > 0.2)
nAccepted++;
}
if (label < 0)
{
- Printf("WARNING: cannot find corresponding mc part for track(let) %d with label %d.", i, label);
+ Printf("WARNING: cannot find corresponding mc particle for track(let) %d with label %d.", i, label);
continue;
}
if (fSigmaVertexPrim)
fSigmaVertexPrim->Write();
+ fVertexCorrelation = dynamic_cast<TH2F*> (fOutput->FindObject("fVertexCorrelation"));
if (fVertexCorrelation)
fVertexCorrelation->Write();
+ fVertexProfile = dynamic_cast<TProfile*> (fOutput->FindObject("fVertexProfile"));
if (fVertexProfile)
fVertexProfile->Write();
+ fVertexShiftNorm = dynamic_cast<TH1F*> (fOutput->FindObject("fVertexShiftNorm"));
if (fVertexShiftNorm)
fVertexShiftNorm->Write();
+ fEtaCorrelation = dynamic_cast<TH2F*> (fOutput->FindObject("fEtaCorrelation"));
if (fEtaCorrelation)
fEtaCorrelation->Write();
+ fEtaProfile = dynamic_cast<TProfile*> (fOutput->FindObject("fEtaProfile"));
if (fEtaProfile)
fEtaProfile->Write();
+ fMultAll = dynamic_cast<TH1F*> (fOutput->FindObject("fMultAll"));
if (fMultAll)
fMultAll->Write();
+ fMultTr = dynamic_cast<TH1F*> (fOutput->FindObject("fMultTr"));
if (fMultTr)
fMultTr->Write();
-
+
+ fMultVtx = dynamic_cast<TH1F*> (fOutput->FindObject("fMultVtx"));
if (fMultVtx)
fMultVtx->Write();
for (Int_t i=0; i<8; ++i)
+ {
+ fDeltaPhi[i] = dynamic_cast<TH1F*> (fOutput->FindObject(Form("fDeltaPhi_%d", i)));
if (fDeltaPhi[i])
fDeltaPhi[i]->Write();
+ }
+ fEventStats = dynamic_cast<TH2F*> (fOutput->FindObject("fEventStats"));
if (fEventStats)
fEventStats->Write();
void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
void SetOnlyPrimaries(Bool_t flag = kTRUE) { fOnlyPrimaries = flag; }
+ void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+
+ void SetOption(const char* opt) { fOption = opt; }
protected:
Bool_t SignOK(TParticlePDG* particle);
TString fOption; // option string
AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
+ AliPWG0Helper::Trigger fTrigger; // trigger used in the analysis
Int_t fSignMode; // if 0 process all particles, if +-1 process only particles with that sign
Bool_t fOnlyPrimaries; // only process primaries (syst. studies)
fOutput(0),
fOption(opt),
fAnalysisMode(AliPWG0Helper::kTPC),
+ fTrigger(AliPWG0Helper::kMB1),
fReadMC(kFALSE),
fUseMCVertex(kFALSE),
fUseMCKine(kFALSE),
fEvents(0),
fVertexResolution(0),
fdNdEtaAnalysis(0),
+ fdNdEtaAnalysisNSD(0),
fdNdEtaAnalysisTr(0),
fdNdEtaAnalysisTrVtx(0),
fdNdEtaAnalysisTracks(0),
// Disable all branches and enable only the needed ones
//tree->SetBranchStatus("*", 0);
- tree->SetBranchStatus("fTriggerMask", 1);
- tree->SetBranchStatus("fSPDVertex*", 1);
- // PrimaryVertex also needed
+ tree->SetBranchStatus("TriggerMask", 1);
+ tree->SetBranchStatus("SPDVertex*", 1);
+ tree->SetBranchStatus("PrimaryVertex*", 1);
+ tree->SetBranchStatus("TPCVertex*", 1);
if (fAnalysisMode == AliPWG0Helper::kSPD) {
- tree->SetBranchStatus("fSPDMult*", 1);
- //AliPWG0Helper::SetBranchStatusRecursive(tree, "AliMultiplicity", kTRUE);
+ tree->SetBranchStatus("AliMultiplicity*", 1);
}
-
+
if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS) {
- AliESDtrackCuts::EnableNeededBranches(tree);
- tree->SetBranchStatus("fTracks.fLabel", 1);
- //AliPWG0Helper::SetBranchStatusRecursive(tree, "Tracks", kTRUE);
+ //AliESDtrackCuts::EnableNeededBranches(tree);
+ tree->SetBranchStatus("Tracks*", 1);
}
AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
fOutput->Add(fPartEta[i]);
}
- fEvents = new TH1F("dndeta_check_vertex", "dndeta_check_vertex", 40, -20, 20);
+ fEvents = new TH1F("dndeta_check_vertex", "dndeta_check_vertex", 160, -40, 40);
fOutput->Add(fEvents);
fVertexResolution = new TH1F("dndeta_vertex_resolution_z", "dndeta_vertex_resolution_z", 1000, 0, 10);
fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta", fAnalysisMode);
fOutput->Add(fdNdEtaAnalysis);
+ fdNdEtaAnalysisNSD = new dNdEtaAnalysis("dndetaNSD", "dndetaNSD", fAnalysisMode);
+ fOutput->Add(fdNdEtaAnalysisNSD);
+
fdNdEtaAnalysisTr = new dNdEtaAnalysis("dndetaTr", "dndetaTr", fAnalysisMode);
fOutput->Add(fdNdEtaAnalysisTr);
}
// trigger definition
- Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2);
+ Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), fTrigger);
// get the ESD vertex
const AliESDVertex* vtxESD = AliPWG0Helper::GetVertex(fESD, fAnalysisMode);
TArrayF vtxMC(3);
genHeader->PrimaryVertex(vtxMC);
+ // get process type; NB: this only works for Pythia
+ Int_t processType = AliPWG0Helper::GetPythiaEventProcessType(header);
+ AliDebug(AliLog::kDebug+1, Form("Found pythia process type %d", processType));
+
+ if (processType<0)
+ AliDebug(AliLog::kError, Form("Unknown Pythia process type %d.", processType));
+
// loop over mc particles
Int_t nPrim = stack->GetNprimary();
fdNdEtaAnalysis->FillTrack(vtxMC[2], eta, pt);
fVertex->Fill(particle->Vx(), particle->Vy(), particle->Vz());
+ if (processType != 92 && processType != 93)
+ fdNdEtaAnalysisNSD->FillTrack(vtxMC[2], eta, pt);
+
if (eventTriggered)
{
fdNdEtaAnalysisTr->FillTrack(vtxMC[2], eta, pt);
}
fdNdEtaAnalysis->FillEvent(vtxMC[2], nAcceptedParticles);
+ if (processType != 92 && processType != 93)
+ fdNdEtaAnalysisNSD->FillEvent(vtxMC[2], nAcceptedParticles);
+
if (eventTriggered)
{
fdNdEtaAnalysisTr->FillEvent(vtxMC[2], nAcceptedParticles);
if (fReadMC)
{
fdNdEtaAnalysis = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndeta"));
+ fdNdEtaAnalysisNSD = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaNSD"));
fdNdEtaAnalysisTr = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaTr"));
fdNdEtaAnalysisTrVtx = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaTrVtx"));
fdNdEtaAnalysisTracks = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaTracks"));
}
fdNdEtaAnalysis->Finish(0, -1, AlidNdEtaCorrection::kNone);
+ fdNdEtaAnalysisNSD->Finish(0, -1, AlidNdEtaCorrection::kNone);
fdNdEtaAnalysisTr->Finish(0, -1, AlidNdEtaCorrection::kNone);
fdNdEtaAnalysisTrVtx->Finish(0, -1, AlidNdEtaCorrection::kNone);
fdNdEtaAnalysisTracks->Finish(0, -1, AlidNdEtaCorrection::kNone);
TFile* fout = new TFile("analysis_mc.root","RECREATE");
fdNdEtaAnalysis->SaveHistograms();
+ fdNdEtaAnalysisNSD->SaveHistograms();
fdNdEtaAnalysisTr->SaveHistograms();
fdNdEtaAnalysisTrVtx->SaveHistograms();
fdNdEtaAnalysisTracks->SaveHistograms();
void SetReadMC(Bool_t flag = kTRUE) { fReadMC = flag; }
void SetUseMCVertex(Bool_t flag = kTRUE) { fUseMCVertex = flag; }
void SetUseMCKine(Bool_t flag = kTRUE) { fUseMCKine = flag; }
+ void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+
+ void SetOption(const char* opt) { fOption = opt; }
protected:
AliESDEvent *fESD; //! ESD object
TString fOption; // option string
AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
+ AliPWG0Helper::Trigger fTrigger; // trigger that is used
Bool_t fReadMC; // if true reads MC data (to build correlation maps)
Bool_t fUseMCVertex; // the MC vtx is used instead of the ESD vertex (for syst. check)
// Gathered from MC (when fReadMC is set)
dNdEtaAnalysis* fdNdEtaAnalysis; //! contains the dndeta from the full sample
+ dNdEtaAnalysis* fdNdEtaAnalysisNSD; //! contains the dndeta for the NSD sample
dNdEtaAnalysis* fdNdEtaAnalysisTr; //! contains the dndeta from the triggered events
dNdEtaAnalysis* fdNdEtaAnalysisTrVtx; //! contains the dndeta from the triggered events with vertex
dNdEtaAnalysis* fdNdEtaAnalysisTracks; //! contains the dndeta from the triggered events with vertex counted from the mc particles associated to the tracks (comparing this to the raw values from the esd shows the effect of the detector resolution)
}
//____________________________________________________________________
-void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, Int_t multCut)
+void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, const char* tag)
{
//
// correct with the given correction values and calculate dNdEta and pT distribution
// TODO put tag somewhere which corrections have been applied
- if (multCut > 1)
- {
- Printf("ERROR: A bigger multiplicity cut than 1 is not possible in the current implementation");
- return;
- }
+ Printf("\n\nCorrecting dN/deta spectrum >>> %s <<<. Correction type: %d, pt cut: %.2f.", tag, (Int_t) correctionType, ptCut);
// set corrections to 1
fData->SetCorrectionToUnity();
if (correction && correctionType != AlidNdEtaCorrection::kNone)
{
+ /* Printf("FAKE: Rebinning. For test only");
+ correction->GetVertexRecoCorrection()->GetEventCorrection()->Rebin(2, 1);
+ correction->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->Rebin(2, 1);
+ correction->GetTriggerBiasCorrectionNSD()->GetEventCorrection()->Rebin(2, 1);
+ fData->GetEventCorrection()->Rebin(2, 1);*/
+
TH3F* trackCorr = fData->GetTrackCorrection()->GetCorrectionHistogram();
TH2F* eventCorr = fData->GetEventCorrection()->GetCorrectionHistogram();
trackCorr->Multiply(correction->GetVertexRecoCorrection()->GetTrackCorrection()->GetCorrectionHistogram());
eventCorr->Multiply(correction->GetVertexRecoCorrection()->GetEventCorrection()->GetCorrectionHistogram());
- // set bin with multiplicity 0 to 1 (correction has no meaning in this bin)
+ // set bin with multiplicity 0 to unity (correction has no meaning in this bin)
for (Int_t i=0; i<=eventCorr->GetNbinsX()+1; i++)
eventCorr->SetBinContent(i, 1, 1);
}
//new TCanvas; correctedEvents->DrawCopy("TEXT");
// start above 0 mult. bin with integration
- TH1* vertexDist = measuredEvents->ProjectionX("vertexdist_measured", 2);
+ TH1* vertexDist = correctedEvents->ProjectionX("vertexdist_measured", 2);
//new TCanvas; vertexDist->DrawCopy();
Int_t allEventsWithVertex = (Int_t) vertexDist->Integral(0, vertexDist->GetNbinsX()+1); // include under/overflow!
// multiply with trigger correction if set above
events *= fData->GetEventCorrection()->GetCorrectionHistogram()->GetBinContent(i, 1);
- Printf("Bin %d, alpha is %.2f, number of events with 0 mult. are %.2f", i, alpha, events);
+ Printf("Bin %d, alpha is %.2f, number of events with 0 mult.: %.2f", i, alpha, events);
correctedEvents->SetBinContent(i, 1, events);
}
continue;
collections[0]->Add(entry->fData);
- collections[2]->Add(entry->fMult);
- collections[3]->Add(entry->fPtDist);
+ collections[1]->Add(entry->fMult);
+ collections[2]->Add(entry->fPtDist);
for (Int_t i=0; i<kVertexBinning; ++i)
{
void FillEvent(Float_t vtx, Float_t n);
void FillTriggeredEvent(Float_t n);
- void Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, Int_t multCut = 0);
+ void Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, const char* tag = "");
void DrawHistograms(Bool_t simple = kFALSE);
void LoadHistograms(const Char_t* dir = 0);
{
TFile* file = TFile::Open("analysis_esd.root");
TH1* histESD = (TH1*) file->Get("dndeta/dNdEta_corrected");
+ TH1* histESDnsd = (TH1*) file->Get("dndetaNSD/dNdEta_corrected");
TH1* histESDNoPt = (TH1*) file->Get("dndeta/dNdEta");
TH1* histESDMB = (TH1*) file->Get("dndetaTr/dNdEta_corrected");
TH1* histESDMBNoPt = (TH1*) file->Get("dndetaTr/dNdEta");
TH1* histESDMBTracksNoPt = (TH1*) file->Get("dndetaTracks/dNdEta");
Prepare1DPlot(histESD);
+ Prepare1DPlot(histESDnsd);
Prepare1DPlot(histESDMB);
Prepare1DPlot(histESDMBVtx);
Prepare1DPlot(histESDMBTracksNoPt);
histESD->SetLineWidth(0);
+ histESDnsd->SetLineWidth(0);
histESDMB->SetLineWidth(0);
histESDMBVtx->SetLineWidth(0);
histESDMBVtxNoPt->SetLineWidth(0);
histESD->SetMarkerColor(1);
+ histESDnsd->SetMarkerColor(6);
histESDMB->SetMarkerColor(2);
histESDMBVtx->SetMarkerColor(3);
histESD->SetLineColor(1);
+ histESDnsd->SetLineColor(6);
histESDMB->SetLineColor(2);
histESDMBVtx->SetLineColor(3);
histESDMBTracksNoPt->SetMarkerColor(4);
histESD->SetMarkerStyle(20);
+ histESDnsd->SetMarkerStyle(29);
histESDMB->SetMarkerStyle(21);
histESDMBVtx->SetMarkerStyle(22);
histESDMBVtxNoPt->SetMarkerStyle(22);
histESDMBTracksNoPt->SetMarkerStyle(23);
- TH2F* dummy = new TH2F("dummy", "", 100, -1.5, 1.5, 1000, 0, histESDMBVtx->GetMaximum() * 1.1);
- Prepare1DPlot(dummy);
- dummy->SetStats(kFALSE);
- dummy->SetXTitle("#eta");
- dummy->SetYTitle("dN_{ch}/d#eta");
- dummy->GetYaxis()->SetTitleOffset(1);
-
Float_t etaLimit = 1.2999;
histESDMBVtx->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
histESDMB->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
histESD->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
+ histESDnsd->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
histESDNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
histESDMBNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
histESDMBVtxNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
histESDMBTracksNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
+ Float_t max = TMath::Max(histESDMBVtx->GetMaximum(), histESDMB->GetMaximum());
+ max = TMath::Max(max, histESD->GetMaximum());
+
+ TH2F* dummy = new TH2F("dummy", "", 100, -1.5, 1.5, 1000, 0, max * 1.1);
+ Prepare1DPlot(dummy);
+ dummy->SetStats(kFALSE);
+ dummy->SetXTitle("#eta");
+ dummy->SetYTitle("dN_{ch}/d#eta");
+ dummy->GetYaxis()->SetTitleOffset(1);
+
TCanvas* canvas = new TCanvas("dNdEta1", "dNdEta1", 500, 500);
dummy->DrawCopy();
TFile* file2 = TFile::Open("analysis_mc.root");
TH1* histMC = (TH1*) file2->Get("dndeta/dNdEta_corrected")->Clone("cloned");
+ TH1* histMCnsd = (TH1*) file2->Get("dndetaNSD/dNdEta_corrected");
+ // FAKE
+ if (!histMCnsd)
+ histMCnsd = histMC;
TH1* histMCTr = (TH1*) file2->Get("dndetaTr/dNdEta_corrected")->Clone("cloned2");
TH1* histMCTrVtx = (TH1*) file2->Get("dndetaTrVtx/dNdEta_corrected")->Clone("cloned3");
fdNdEtaAnalysis->LoadHistograms();
dNdEtaAnalysis* fdNdEtaAnalysis2 = (dNdEtaAnalysis*) fdNdEtaAnalysis->Clone();
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: full inelastic");
TH1* histMCPtCut = (TH1*) fdNdEtaAnalysis->GetdNdEtaHistogram(0)->Clone("histMCPtCut");
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
fdNdEtaAnalysis->LoadHistograms();
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: minimum bias");
TH1* histMCTrPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
fdNdEtaAnalysis->LoadHistograms();
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: MB with trigger");
TH1* histMCTrVtxPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
fdNdEtaAnalysis->LoadHistograms();
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: Tracks w/o resolution effect");
TH1* histMCTracksPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
TCanvas* canvas2 = new TCanvas("dNdEta2", "dNdEta2", 500, 500);
Prepare1DPlot(histMC);
+ Prepare1DPlot(histMCnsd);
Prepare1DPlot(histMCTr);
Prepare1DPlot(histMCTrVtx);
Prepare1DPlot(histMCTracksPtCut);
histMC->SetLineColor(1);
+ histMCnsd->SetLineColor(6);
histMCTr->SetLineColor(2);
histMCTrVtx->SetLineColor(3);
TH2* dummy2 = (TH2F*) dummy->Clone("dummy2");
Prepare1DPlot(dummy2);
- dummy2->GetYaxis()->SetRangeUser(0, histESDMBVtx->GetMaximum() * 1.1);
+ dummy2->GetYaxis()->SetRangeUser(0, max * 1.1);
dummy2->DrawCopy();
histMC->Draw("SAME");
+ histMCnsd->Draw("SAME");
histMCTr->Draw("SAME");
histMCTrVtx->Draw("SAME");
histESD->Draw("SAME");
+ histESDnsd->Draw("SAME");
histESDMB->Draw("SAME");
histESDMBVtx->Draw("SAME");
histESDNoPt->Draw("SAME");
canvas2->SaveAs("dNdEta2.eps");
}
+ new TCanvas;
+ dummy2->DrawCopy();
+ histMCnsd->Draw("SAME");
+ histESDnsd->Draw("SAME");
+
TH1* ratio = (TH1*) histMC->Clone("ratio");
TH1* ratioNoPt = (TH1*) histMCPtCut->Clone("ratioNoPt");
pad2->cd();
pad2->SetBottomMargin(0.15);
- Float_t min = TMath::Min(0.961, ratio->GetMinimum() * 0.95);
- Float_t max = TMath::Max(1.049, ratio->GetMaximum() * 1.05);
+ Float_t minR = TMath::Min(0.961, ratio->GetMinimum() * 0.95);
+ Float_t maxR = TMath::Max(1.049, ratio->GetMaximum() * 1.05);
TH1F dummy3("dummy3", ";#eta;Ratio: MC / ESD", 1, -1.5, 1.5);
dummy3.SetStats(kFALSE);
dummy3.SetBinContent(1, 1);
- dummy3.GetYaxis()->SetRangeUser(min, max);
+ dummy3.GetYaxis()->SetRangeUser(minR, maxR);
dummy3.SetLineWidth(2);
dummy3.GetXaxis()->SetLabelSize(0.06);
dummy3.GetYaxis()->SetLabelSize(0.06);
Printf("esd contains %f entries in |vtx-z| < 10, pt > 0.3", hist2->Integral(hist2->GetXaxis()->FindBin(-9.9), hist2->GetXaxis()->FindBin(9.9), 1, hist2->GetNbinsY(), hist2->GetZaxis()->FindBin(0.301), hist2->GetNbinsZ()));
AliPWG0Helper::CreateDividedProjections(hist1, hist2);
+ AliPWG0Helper::CreateDividedProjections(hist1, hist2, "x");
+
+ hist1->GetXaxis()->SetRange(hist1->GetXaxis()->FindBin(-10), hist2->GetXaxis()->FindBin(10));
+ hist2->GetXaxis()->SetRange(hist1->GetXaxis()->FindBin(-10), hist2->GetXaxis()->FindBin(10));
+ AliPWG0Helper::CreateDividedProjections(hist1, hist2, "y");
new TCanvas; gROOT->FindObject("mc_yx_div_esd_yx")->Draw("COLZ");
new TCanvas; gROOT->FindObject("mc_zx_div_esd_zx")->Draw("COLZ");
new TCanvas; gROOT->FindObject("mc_zy_div_esd_zy")->Draw("COLZ");
+ new TCanvas; gROOT->FindObject("mc_x_div_esd_x")->Draw("COLZ");
+ new TCanvas; gROOT->FindObject("mc_y_div_esd_y")->Draw("COLZ");
}
void CompareMeasured2Measured(const char* dataInput = "analysis_esd_raw.root", const char* dataInput2 = "analysis_esd_raw.root")
}
+void DrawTrackletOrigin()
+{
+ TFile::Open("correction_map.root");
+
+ Int_t colors[] = {1,2,3,4,6,7,8,102};
+
+ Int_t maxHists = 8;
+ TH1* hist[8];
+
+ const char* titles[] = { "PP", "SS", "PP'", "PS", "PS*", "SP", "SS'", "" };
+
+ TLegend* legend = new TLegend(0.75, 0.6, 0.95, 0.95);
+
+ Int_t total = 0;
+ for (Int_t i=0; i<maxHists; i++)
+ {
+ hist[i] = (TH1*) gFile->Get(Form("fDeltaPhi_%d", i));
+ //hist[i]->Rebin(20);
+ hist[i]->SetStats(kFALSE);
+ hist[i]->SetLineColor(colors[i]);
+ hist[i]->GetXaxis()->SetRangeUser(-0.2, 0.2);
+ hist[i]->Draw(((i == 0) ? "" : "SAME"));
+
+ total += hist[i]->GetEntries();
+
+ if (i != 7)
+ legend->AddEntry(hist[i], titles[i]);
+ }
+
+ legend->Draw();
+ gPad->SetLogy();
+
+ Printf("Total: %d", total);
+ for (Int_t i=0; i<maxHists; i++)
+ Printf("Histogram %d (%s) containts %.2f %% of the entries", i, titles[i], 100.0 * hist[i]->GetEntries() / total);
+
+ printf("| Delta phi | Acc. %% | ");
+ for (Int_t i=0; i<maxHists; i++)
+ printf("%3s %% | ", titles[i]);
+ Printf("");
+
+ for (Float_t f = 0.01; f < 0.09; f += 0.01)
+ {
+ Int_t integralBegin = hist[0]->GetXaxis()->FindBin(-f);
+ Int_t integralEnd = hist[0]->GetXaxis()->FindBin(f);
+
+ Int_t total2 = 0;
+ for (Int_t i=0; i<maxHists; i++)
+ total2 += (Int_t) hist[i]->Integral(integralBegin, integralEnd);
+
+ printf("| %.2f | %6.2f | ", f, 100.0 * total2 / total);
+
+ for (Int_t i=0; i<maxHists; i++)
+ printf("%6.2f | ", (hist[i]->GetEntries() > 0) ? (100.0 * hist[i]->Integral(integralBegin, integralEnd) / hist[i]->GetEntries()) : -1.0);
+ Printf("");
+ }
+}
-void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE, Bool_t mc = kTRUE, const char* option = "")
+void run(Int_t runWhat, Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Int_t aProof = kFALSE, Bool_t mc = kTRUE, const char* option = "")
{
+ // runWhat options: 0 = AlidNdEtaTask
+ // 1 = AlidNdEtaCorrectionTask
+ //
+ // aProof option: 0 no proof
+ // 1 proof with chain
+ // 2 proof with dataset
+
+ TString taskName;
+ if (runWhat == 0)
+ {
+ taskName = "AlidNdEtaTask";
+ }
+ else if (runWhat == 1)
+ {
+ taskName = "AlidNdEtaCorrectionTask";
+ if (!mc)
+ {
+ Printf("%s needs MC. Exiting...", taskName.Data());
+ return;
+ }
+ }
+ else
+ {
+ Printf("Do not know what to run. Exiting...");
+ return;
+ }
+
+ Printf("Processing task: %s", taskName.Data());
+
+ if (nRuns < 0)
+ nRuns = 1234567890;
+
if (aProof)
{
TProof::Open("lxb6046");
+ //gProof->SetParallel(1);
// Enable the needed package
- gProof->UploadPackage("STEERBase");
+ /*gProof->UploadPackage("STEERBase");
gProof->EnablePackage("STEERBase");
gProof->UploadPackage("ESD");
gProof->EnablePackage("ESD");
gProof->UploadPackage("AOD");
gProof->EnablePackage("AOD");
gProof->UploadPackage("ANALYSIS");
- gProof->EnablePackage("ANALYSIS");
- gProof->UploadPackage("PWG0base");
- gProof->EnablePackage("PWG0base");
+ gProof->EnablePackage("ANALYSIS");*/
+
+ gProof->UploadPackage("$ALICE_ROOT/AF-v4-12");
+ gProof->EnablePackage("$ALICE_ROOT/AF-v4-12");
+
+ gProof->UploadPackage("$ALICE_ROOT/PWG0base");
+ gProof->EnablePackage("$ALICE_ROOT/PWG0base");
}
else
{
gSystem->Load("libPWG0base");
}
- // Create chain of input files
- gROOT->LoadMacro("../CreateESDChain.C");
- chain = CreateESDChain(data, nRuns, offset);
-
// Create the analysis manager
mgr = new AliAnalysisManager;
- TString taskName("AlidNdEtaTask.cxx+");
+ TString compileTaskName;
+ compileTaskName.Form("%s.cxx+", taskName.Data());
if (aDebug)
- taskName += "+g";
+ compileTaskName += "+g";
// Create, add task
if (aProof) {
- gProof->Load(taskName);
+ gProof->Load(compileTaskName);
} else
- gROOT->Macro(taskName);
-
- task = new AlidNdEtaTask(option);
+ gROOT->Macro(compileTaskName);
AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD;
- task->SetAnalysisMode(analysisMode);
+ AliPWG0Helper::Trigger trigger = AliPWG0Helper::kMB1;
+
+ AliPWG0Helper::PrintConf(analysisMode, trigger);
+ AliESDtrackCuts* esdTrackCuts = 0;
if (analysisMode != AliPWG0Helper::kSPD)
{
// selection of esd tracks
gROOT->ProcessLine(".L ../CreateStandardCuts.C");
- AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
+ esdTrackCuts = CreateTrackCuts(analysisMode);
if (!esdTrackCuts)
{
printf("ERROR: esdTrackCuts could not be created\n");
return;
}
+ }
+
+ if (runWhat == 0)
+ {
+ task = new AlidNdEtaTask(option);
- task->SetTrackCuts(esdTrackCuts);
+ if (mc)
+ task->SetReadMC();
+
+ //task->SetUseMCVertex();
+ //task->SetUseMCKine();
}
+ else if (runWhat == 1)
+ {
+ task = new AlidNdEtaCorrectionTask(option);
- if (mc)
- task->SetReadMC();
+ //task->SetOnlyPrimaries();
+ }
- //task->SetUseMCVertex();
- //task->SetUseMCKine();
+ task->SetTrigger(trigger);
+ task->SetAnalysisMode(analysisMode);
+ task->SetTrackCuts(esdTrackCuts);
mgr->AddTask(task);
// Enable debug printouts
if (aDebug)
+ {
mgr->SetDebugLevel(2);
+ AliLog::SetClassDebugLevel(taskName, AliLog::kDebug+2);
+ }
+ else
+ AliLog::SetClassDebugLevel(taskName, AliLog::kWarning);
// Run analysis
mgr->InitAnalysis();
mgr->PrintStatus();
- mgr->StartAnalysis((aProof) ? "proof" : "local", chain);
+ if (aProof == 2)
+ {
+ // process dataset
+
+ mgr->StartAnalysis("proof", data, nRuns, offset);
+ }
+ else
+ {
+ // Create chain of input files
+ gROOT->LoadMacro("../CreateESDChain.C");
+ chain = CreateESDChain(data, nRuns, offset);
+
+ mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain);
+ }
}
void loadlibs()
return;
}
- dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
+ dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaNSD", "dndetaNSD");
fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
- fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL, 1);
+ fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kNSD, "ESD -> NSD");
//fdNdEtaAnalysis->DrawHistograms(kTRUE);
TFile* file2 = TFile::Open(dataOutput, "RECREATE");
fdNdEtaAnalysis->SaveHistograms();
file->cd();
+ dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
+ fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
+ fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL, "ESD -> full inelastic");
+ //fdNdEtaAnalysis->DrawHistograms(kTRUE);
+ file2->cd();
+ fdNdEtaAnalysis->SaveHistograms();
+
+ file->cd();
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
- fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco, 1);
+ fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco, "ESD -> minimum bias");
//fdNdEtaAnalysis->DrawHistograms(kTRUE);
file2->cd();
fdNdEtaAnalysis->SaveHistograms();
file->cd();
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
- fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle, 1);
+ fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle, "ESD -> MB with trigger");
//fdNdEtaAnalysis->DrawHistograms(kTRUE);
file2->cd();
fdNdEtaAnalysis->SaveHistograms();
file->cd();
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "ESD raw");
//fdNdEtaAnalysis->DrawHistograms(kTRUE);
file2->cd();
fdNdEtaAnalysis->SaveHistograms();
+++ /dev/null
-void runCorrection(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE, const char* option = ""){
- if (aProof)
- {
- TProof::Open("lxb6046");
-
- // Enable the needed package
- gProof->UploadPackage("STEERBase");
- gProof->EnablePackage("STEERBase");
- gProof->UploadPackage("ESD");
- gProof->EnablePackage("ESD");
- gProof->UploadPackage("AOD");
- gProof->EnablePackage("AOD");
- gProof->UploadPackage("ANALYSIS");
- gProof->EnablePackage("ANALYSIS");
- gProof->UploadPackage("PWG0base");
- gProof->EnablePackage("PWG0base");
- }
- else
- {
- gSystem->Load("libVMC");
- gSystem->Load("libTree");
- gSystem->Load("libSTEERBase");
- gSystem->Load("libESD");
- gSystem->Load("libAOD");
- gSystem->Load("libANALYSIS");
- gSystem->Load("libPWG0base");
- }
-
- // Create chain of input files
- gROOT->LoadMacro("../CreateESDChain.C");
- chain = CreateESDChain(data, nRuns, offset);
-
- // Create the analysis manager
- mgr = new AliAnalysisManager;
-
- TString taskName("AlidNdEtaCorrectionTask.cxx+");
- if (aDebug)
- taskName += "+g";
-
- // Create, add task
- if (aProof) {
- gProof->Load(taskName);
- } else
- gROOT->Macro(taskName);
-
- task = new AlidNdEtaCorrectionTask(option);
-
- AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD;
- task->SetAnalysisMode(analysisMode);
-
- //task->SetOnlyPrimaries();
-
- if (analysisMode != AliPWG0Helper::kSPD)
- {
- // selection of esd tracks
- gROOT->ProcessLine(".L ../CreateStandardCuts.C");
- AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
- if (!esdTrackCuts)
- {
- printf("ERROR: esdTrackCuts could not be created\n");
- return;
- }
-
- task->SetTrackCuts(esdTrackCuts);
- }
-
- mgr->AddTask(task);
-
- // Enable MC event handler
- AliMCEventHandler* handler = new AliMCEventHandler;
- handler->SetReadTR(kFALSE);
- mgr->SetMCtruthEventHandler(handler);
-
- // Add ESD handler
- AliESDInputHandler* esdH = new AliESDInputHandler;
- mgr->SetInputEventHandler(esdH);
-
- // Attach input
- cInput = mgr->CreateContainer("cInput", TChain::Class(), AliAnalysisManager::kInputContainer);
- mgr->ConnectInput(task, 0, cInput);
-
- // Attach output
- cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer);
- mgr->ConnectOutput(task, 0, cOutput);
-
- // Enable debug printouts
- if (aDebug)
- {
- mgr->SetDebugLevel(2);
- AliLog::SetClassDebugLevel("AlidNdEtaCorrectionTask", AliLog::kDebug+2);
- }
- else
- AliLog::SetClassDebugLevel("AlidNdEtaCorrectionTask", AliLog::kWarning);
-
- // Run analysis
- mgr->InitAnalysis();
- mgr->PrintStatus();
-
- //aProof = kFALSE;
-
- mgr->StartAnalysis((aProof) ? "proof" : "local", chain);
-}
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff