}
else if (analysisMode == AliPWG0Helper::kSPD)
{
- static Float_t binLimitsPtTmp[] = {-0.5, 0.5};
+ static Float_t binLimitsPtTmp[] = {-0.5, 100.0};
binLimitsPt = (Float_t*) binLimitsPtTmp;
nBinsPt = 1;
}
// divides generated by measured to get the correction
//
-// if (!fhCorr) {
-// fhCorr = (TH1*)fhGene->Clone("correction");
-// fhCorr->SetTitle(Form("%s correction",GetTitle()));
-// fhCorr->Reset();
-// }
-
if (!fhMeas || !fhGene || !fhCorr) {
AliDebug(AliLog::kError, "measured or generated histograms not available");
return;
//____________________________________________________________________
AliTPCClusterHistograms::AliTPCClusterHistograms()
: TNamed(),
- fhQmaxVsRow(0),
+ fTimeStart(0),
+ fTimeStop(0),
+ fhQmaxVsRow(0),
fhQtotVsRow(0),
fhQtotProfileVsRow(0),
fhQmaxProfileVsRow(0),
+ fhQtotVsDistanceToEdge(0),
+ fhQtotProfileVsDistanceToEdge(0),
fhNClustersYVsRow(0),
fhNClustersZVsRow(0),
fhSigmaYVsRow(0),
fhTrackMeanQtotPerClusterVsTheta(0),
fhMeanNTracksVsTime(),
fhNEventsVsTime(),
+ fDetector(0),
fIsIROC(kFALSE),
- fEdgeSuppression(kFALSE)
+ fEdgeSuppression(kFALSE),
+ fNClustersInEvent(0),
+ fQtotInEvent(0),
+ fMaxQtotInEvent(0),
+ fKeepEvent(0),
+ fWhyKeepEvent(),
+ fCommentToHistograms()
{
// default constructor
}
//____________________________________________________________________
AliTPCClusterHistograms::AliTPCClusterHistograms(Int_t detector, const Char_t* comment, Int_t timeStart, Int_t timeStop, Bool_t edgeSuppression)
: TNamed(),
- fhQmaxVsRow(0),
+ fTimeStart(0),
+ fTimeStop(0),
+ fhQmaxVsRow(0),
fhQtotVsRow(0),
fhQtotProfileVsRow(0),
fhQmaxProfileVsRow(0),
- fhNClustersYVsRow(0),
+ fhQtotVsDistanceToEdge(0),
+ fhQtotProfileVsDistanceToEdge(0),
+ fhNClustersYVsRow(0),
fhNClustersZVsRow(0),
fhSigmaYVsRow(0),
fhSigmaZVsRow(0),
fhTrackQtotPerClusterVsTheta(0),
fhTrackMeanQtotPerClusterVsPhi(0),
fhTrackMeanQtotPerClusterVsTheta(0),
- fhMeanNTracksVsTime(0),
- fhNEventsVsTime(0),
+ fhMeanNTracksVsTime(),
+ fhNEventsVsTime(),
+ fDetector(0),
fIsIROC(kFALSE),
- fEdgeSuppression(edgeSuppression)
+ fEdgeSuppression(edgeSuppression),
+ fNClustersInEvent(0),
+ fQtotInEvent(0),
+ fMaxQtotInEvent(0),
+ fKeepEvent(0),
+ fWhyKeepEvent(),
+ fCommentToHistograms()
{
// constructor
}
//____________________________________________________________________
-AliTPCClusterHistograms::AliTPCClusterHistograms(const AliTPCClusterHistograms& c) : TNamed(c)
+AliTPCClusterHistograms::AliTPCClusterHistograms(const AliTPCClusterHistograms& c) : TNamed(c),
+ fTimeStart(0),
+ fTimeStop(0),
+ fhQmaxVsRow(0),
+ fhQtotVsRow(0),
+ fhQtotProfileVsRow(0),
+ fhQmaxProfileVsRow(0),
+ fhQtotVsDistanceToEdge(0),
+ fhQtotProfileVsDistanceToEdge(0),
+ fhNClustersYVsRow(0),
+ fhNClustersZVsRow(0),
+ fhSigmaYVsRow(0),
+ fhSigmaZVsRow(0),
+ fhQmaxProfileYVsRow(0),
+ fhQtotProfileYVsRow(0),
+ fhSigmaYProfileYVsRow(0),
+ fhSigmaZProfileYVsRow(0),
+ fhQmaxProfileZVsRow(0),
+ fhQtotProfileZVsRow(0),
+ fhSigmaYProfileZVsRow(0),
+ fhSigmaZProfileZVsRow(0),
+ fhMeanQtotVsTime(0),
+ fhQtotVsTime(0),
+ fhMeanNClustersVsTime(0),
+ fhNClustersVsTime(0),
+ fhTrackQtotPerCluster(0),
+ fhTrackQtotPerClusterVsPhi(0),
+ fhTrackQtotPerClusterVsTheta(0),
+ fhTrackMeanQtotPerClusterVsPhi(0),
+ fhTrackMeanQtotPerClusterVsTheta(0),
+ fhMeanNTracksVsTime(),
+ fhNEventsVsTime(),
+ fDetector(0),
+ fIsIROC(kFALSE),
+ fEdgeSuppression(kFALSE),
+ fNClustersInEvent(0),
+ fQtotInEvent(0),
+ fMaxQtotInEvent(0),
+ fKeepEvent(0),
+ fWhyKeepEvent(),
+ fCommentToHistograms()
{
// copy constructor
((AliTPCClusterHistograms &)c).Copy(*this);
virtual void SetDebugLevel(Int_t level) {fDebug = level;}
private:
+ AliAnalysisTaskESDfilter(const AliAnalysisTaskESDfilter&);
+ AliAnalysisTaskESDfilter& operator=(const AliAnalysisTaskESDfilter&);
+
Int_t fDebug; // Debug flag
TTree* fTree; //! chained files
AliESDEvent* fESD; //! ESD
//____________________________________________________________________
AliMultiplicityCorrection::AliMultiplicityCorrection(const Char_t* name, const Char_t* title) :
- TNamed(name, title), fLastChi2MC(0), fLastChi2MCLimit(0), fLastChi2Residuals(0), fRatioAverage(0)
+ TNamed(name, title),
+ fCurrentESD(0),
+ fCurrentCorrelation(0),
+ fCurrentEfficiency(0),
+ fLastBinLimit(0),
+ fLastChi2MC(0),
+ fLastChi2MCLimit(0),
+ fLastChi2Residuals(0),
+ fRatioAverage(0)
{
//
// named constructor
static Int_t UnfoldWithBayesian(TH1* correlation, TH1* aEfficiency, TH1* measured, TH1* initialConditions, TH1* aResult, Float_t regPar, Int_t nIterations);
static Int_t UnfoldWithMinuit(TH1* correlation, TH1* aEfficiency, TH1* measured, TH1* initialConditions, TH1* result, Bool_t check);
- TH1* fCurrentESD; //! static variable to be accessed by MINUIT
- TH1* fCurrentCorrelation; //! static variable to be accessed by MINUIT
- TH1* fCurrentEfficiency; //! static variable to be accessed by MINUIT
+ TH1* fCurrentESD; //! current input esd
+ TH1* fCurrentCorrelation; //! current correlation
+ TH1* fCurrentEfficiency; //! current efficiency
// static variable to be accessed by MINUIT
static TMatrixD* fgCorrelationMatrix; //! contains fCurrentCorrelation in matrix form
Int_t ptBin = ptProj->FindBin(ptCutOff);
//printf("GetMeasuredFraction: bin range %d %d\n", ptBin, ptProj->GetNbinsX());
- Float_t abovePtCut = ptProj->Integral(ptBin, ptProj->GetNbinsX());
- Float_t all = ptProj->Integral();
+ Float_t abovePtCut = ptProj->Integral(ptBin, ptProj->GetNbinsX()+1);
+ Float_t all = ptProj->Integral(1, ptProj->GetNbinsX()+1);
if (all == 0)
return -1;
{
// control hist
fMult->Fill(inputCount);
+ fdNdEtaAnalysisESD->FillTriggeredEvent(inputCount);
+
if (vtxESD)
{
// control hist
dNdEtaAnalysis::dNdEtaAnalysis() :
TNamed(),
fData(0),
+ fMult(0),
fPtDist(0)
{
// default constructor
for (Int_t i=0; i<kVertexBinning; ++i)
{
- fdNdEtaNotEventCorrected[i] = 0;
fdNdEta[i] = 0;
fdNdEtaPtCutOffCorrected[i] = 0;
}
dNdEtaAnalysis::dNdEtaAnalysis(Char_t* name, Char_t* title, AliPWG0Helper::AnalysisMode analysisMode) :
TNamed(name, title),
fData(0),
+ fMult(0),
fPtDist(0)
{
// constructor
Bool_t oldStatus = TH1::AddDirectoryStatus();
TH1::AddDirectory(kFALSE);
+ fMult = new TH1F("TriggeredMultiplicity", "Triggered Events;raw multiplicity;entries", 1000, -0.5, 999.5);
+
fdNdEta[0] = new TH1F("dNdEta", "dN_{ch}/d#eta;#eta;dN_{ch}/d#eta", 40, -2, 2);
- fdNdEtaNotEventCorrected[0] = dynamic_cast<TH1F*> (fdNdEta[0]->Clone(Form("%s_noteventcorrected", fdNdEta[0]->GetName())));
fdNdEtaPtCutOffCorrected[0] = dynamic_cast<TH1F*> (fdNdEta[0]->Clone(Form("%s_corrected", fdNdEta[0]->GetName())));
for (Int_t i=1; i<kVertexBinning; ++i)
{
fdNdEta[i] = dynamic_cast<TH1F*> (fdNdEta[0]->Clone(Form("%s_%d", fdNdEta[0]->GetName(), i)));
- fdNdEtaNotEventCorrected[i] = dynamic_cast<TH1F*> (fdNdEtaNotEventCorrected[0]->Clone(Form("%s_%d", fdNdEta[0]->GetName(), i)));
fdNdEtaPtCutOffCorrected[i] = dynamic_cast<TH1F*> (fdNdEtaPtCutOffCorrected[0]->Clone(Form("%s_%d", fdNdEtaPtCutOffCorrected[0]->GetName(), i)));
}
fData = 0;
}
+ if (fMult)
+ {
+ delete fMult;
+ fMult = 0;
+ }
+
for (Int_t i=0; i<kVertexBinning; ++i)
{
- if (fdNdEtaNotEventCorrected[i])
- {
- delete fdNdEtaNotEventCorrected[i];
- fdNdEtaNotEventCorrected[i] = 0;
- }
if (fdNdEta[i])
{
delete fdNdEta[i];
dNdEtaAnalysis& target = (dNdEtaAnalysis &) c;
target.fData = dynamic_cast<AliCorrection*> (fData->Clone());
+ target.fMult = dynamic_cast<TH1F*> (fMult->Clone());
for (Int_t i=0; i<kVertexBinning; ++i)
{
- target.fdNdEtaNotEventCorrected[i] = dynamic_cast<TH1F*> (fdNdEtaNotEventCorrected[i]->Clone());
target.fdNdEta[i] = dynamic_cast<TH1F*> (fdNdEta[i]->Clone());
target.fdNdEtaPtCutOffCorrected[i] = dynamic_cast<TH1F*> (fdNdEtaPtCutOffCorrected[i]->Clone());
}
fData->GetEventCorrection()->FillMeas(vtx, n);
}
+//____________________________________________________________________
+void dNdEtaAnalysis::FillTriggeredEvent(Float_t n)
+{
+ // fills a triggered event into the histograms
+
+ fMult->Fill(n);
+}
+
//____________________________________________________________________
void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, Int_t multCut)
{
{
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)
+ for (Int_t i=0; i<=eventCorr->GetNbinsX()+1; i++)
+ eventCorr->SetBinContent(i, 1, 1);
}
switch (correctionType)
printf("INFO: No correction applied\n");
fData->Multiply();
+
+ if (correctionType >= AlidNdEtaCorrection::kVertexReco)
+ {
+ // There are no events with vertex that have 0 multiplicity, therefore
+ // populate bin with 0 multiplicity with the following idea:
+ // alpha = triggered events with vertex at a given vertex position / all triggered events with vertex
+ // triggered events without vertex and 0 multiplicity at a given vertex position = alpha * all triggered events with 0 multiplicity
+ // afterwards we still correct for the trigger efficiency
+
+ TH2* measuredEvents = fData->GetEventCorrection()->GetMeasuredHistogram();
+ TH2* correctedEvents = fData->GetEventCorrection()->GetGeneratedHistogram();
+
+ //new TCanvas; correctedEvents->DrawCopy("TEXT");
+
+ // start above 0 mult. bin with integration
+ TH1* vertexDist = measuredEvents->ProjectionX("vertexdist_measured", 2);
+ //new TCanvas; vertexDist->DrawCopy();
+
+ Int_t allEventsWithVertex = (Int_t) vertexDist->Integral(0, vertexDist->GetNbinsX()+1); // include under/overflow!
+ Int_t triggeredEventsWith0Mult = (Int_t) fMult->GetBinContent(1);
+
+ Printf("%d triggered events with 0 mult. -- %d triggered events with vertex", triggeredEventsWith0Mult, allEventsWithVertex);
+
+ for (Int_t i = 1; i <= measuredEvents->GetNbinsX(); i++)
+ {
+ Double_t alpha = vertexDist->GetBinContent(i) / allEventsWithVertex;
+ Double_t events = alpha * triggeredEventsWith0Mult;
+
+ // 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);
+
+ correctedEvents->SetBinContent(i, 1, events);
+ }
+
+ //new TCanvas; correctedEvents->DrawCopy("TEXT");
+ }
+
fData->PrintInfo(ptCut);
TH3F* dataHist = fData->GetTrackCorrection()->GetGeneratedHistogram();
// integrate multiplicity axis out (include under/overflow bins!!!)
TH2F* tmp = fData->GetEventCorrection()->GetGeneratedHistogram();
- // multiplicity cut correction
- // correct for not-measured events with too small multiplicity
- // the measured result is not used up to a multiplicity of multCut (the bin at multCut is the first that is used!)
- TH1D* vertexHistUncorrected = tmp->ProjectionX("_px", tmp->GetYaxis()->FindBin(multCut), tmp->GetNbinsY() + 1, "e");
- TH1D* vertexHist = (TH1D*) vertexHistUncorrected->Clone("vertexHist");
-
- Printf("Using %d events (above a cut of %d)", (Int_t) vertexHistUncorrected->Integral(), multCut);
- if (correction && correctionType >= AlidNdEtaCorrection::kVertexReco)
- {
- TH1* eventFraction = correction->GetMeasuredEventFraction(correctionType, multCut);
- vertexHist->Divide(eventFraction);
- Printf("Multiplicity cut correction: Corrected from %d events to %d events", (Int_t) vertexHistUncorrected->Integral(), (Int_t) vertexHist->Integral());
- }
+ TH1D* vertexHist = (TH1D*) tmp->ProjectionX("_px", 0, tmp->GetNbinsY() + 1, "e");
// create pt hist
{
if (ptCut > 0)
ptLowBin = dataHist->GetZaxis()->FindBin(ptCut);
- dataHist->GetZaxis()->SetRange(ptLowBin, dataHist->GetZaxis()->GetNbins());
- printf("range %d %d\n", ptLowBin, dataHist->GetZaxis()->GetNbins());
+ dataHist->GetZaxis()->SetRange(ptLowBin, dataHist->GetZaxis()->GetNbins()+1);
+ printf("pt range %d %d\n", ptLowBin, dataHist->GetZaxis()->GetNbins()+1);
TH2D* vtxVsEta = dynamic_cast<TH2D*> (dataHist->Project3D("yx2e"));
dataHist->GetZaxis()->SetRange(0, 0);
return;
}
- //new TCanvas; vtxVsEta->DrawCopy();
+ //new TCanvas; vtxVsEta->DrawCopy("COLZ");
//vtxVsEta->Rebin2D(1, 4);
const Float_t vertexRange = 9.99;
//printf("vertexBinGlobalBegin = %d, vertexBinWidth = %d\n", vertexBinGlobalBegin, vertexBinWidth);
for (Int_t vertexPos=0; vertexPos<kVertexBinning; ++vertexPos)
{
-
Int_t vertexBinBegin = vertexBinGlobalBegin;
Int_t vertexBinEnd = vertexBinGlobalBegin + vertexBinWidth * (kVertexBinning-1);
//printf("vertexBinBegin = %d, vertexBinEnd = %d\n", vertexBinBegin, vertexBinEnd);
- Float_t totalEventsUncorrected = vertexHistUncorrected->Integral(vertexBinBegin, vertexBinEnd - 1);
- if (totalEventsUncorrected == 0)
- {
- printf("WARNING: No events (uncorrected) for hist %d %d %d\n", vertexPos, vertexBinBegin, vertexBinEnd);
- continue;
- }
-
Float_t totalEvents = vertexHist->Integral(vertexBinBegin, vertexBinEnd - 1);
if (totalEvents == 0)
{
Int_t bin = fdNdEta[vertexPos]->FindBin(vtxVsEta->GetYaxis()->GetBinCenter(iEta));
if (bin > 0 && bin < fdNdEta[vertexPos]->GetNbinsX())
{
- Float_t dndeta = sum / totalEventsUncorrected;
- Float_t error = TMath::Sqrt(sumError2) / totalEventsUncorrected;
-
- dndeta = dndeta / fdNdEta[vertexPos]->GetBinWidth(bin);
- error = error / fdNdEta[vertexPos]->GetBinWidth(bin);
-
- fdNdEtaNotEventCorrected[vertexPos]->SetBinContent(bin, dndeta);
- fdNdEtaNotEventCorrected[vertexPos]->SetBinError(bin, error);
-
- dndeta = sum / totalEvents;
- error = TMath::Sqrt(sumError2) / totalEvents;
+ Float_t dndeta = sum / totalEvents;
+ Float_t error = TMath::Sqrt(sumError2) / totalEvents;
dndeta = dndeta / fdNdEta[vertexPos]->GetBinWidth(bin);
error = error / fdNdEta[vertexPos]->GetBinWidth(bin);
else
printf("dNdEtaAnalysis::SaveHistograms: UNEXPECTED: fData is 0\n");
+ if (fMult)
+ {
+ fMult->Write();
+ }
+ else
+ printf("dNdEtaAnalysis::SaveHistograms: UNEXPECTED: fMult is 0\n");
+
if (fPtDist)
fPtDist ->Write();
else
for (Int_t i=0; i<kVertexBinning; ++i)
{
- if (fdNdEtaNotEventCorrected[i])
- fdNdEtaNotEventCorrected[i]->Write();
- else
- printf("dNdEtaAnalysis::SaveHistograms: UNEXPECTED: fdNdEtaNotEventCorrected[%d] is 0\n", i);
-
if (fdNdEta[i])
fdNdEta[i]->Write();
else
gDirectory->cd(dir);
fData->LoadHistograms();
+ fMult = dynamic_cast<TH1F*> (gDirectory->Get(fMult->GetName()));
for (Int_t i=0; i<kVertexBinning; ++i)
{
- if (dynamic_cast<TH1F*> (gDirectory->Get(fdNdEtaNotEventCorrected[i]->GetName())))
- fdNdEtaNotEventCorrected[i] = dynamic_cast<TH1F*> (gDirectory->Get(fdNdEtaNotEventCorrected[i]->GetName()));
-
fdNdEta[i] = dynamic_cast<TH1F*> (gDirectory->Get(fdNdEta[i]->GetName()));
fdNdEtaPtCutOffCorrected[i] = dynamic_cast<TH1F*> (gDirectory->Get(fdNdEtaPtCutOffCorrected[i]->GetName()));
}
void dNdEtaAnalysis::DrawHistograms(Bool_t simple)
{
// draws the histograms
-
+
if (!simple)
{
if (fData)
legend->Draw();
}
}
-
+
if (kVertexBinning == 3)
{
TH1* clone = dynamic_cast<TH1*> (fdNdEtaPtCutOffCorrected[1]->Clone("clone"));
TH1* clone2 = dynamic_cast<TH1*> (fdNdEtaPtCutOffCorrected[2]->Clone("clone2"));
-
+
if (clone && clone2)
{
TCanvas* canvas4 = new TCanvas(Form("%s_dNdEtaAnalysisVtxRatios", GetName()), Form("%s_dNdEtaAnalysisVtxRatios", GetName()), 450, 450);
-
+
clone->Divide(fdNdEtaPtCutOffCorrected[0]);
clone->GetYaxis()->SetRangeUser(0.95, 1.05);
clone->DrawCopy();
-
+
clone2->Divide(fdNdEtaPtCutOffCorrected[0]);
clone2->DrawCopy("SAME");
TObject* obj;
// sub collections
- const Int_t nCollections = 3 * kVertexBinning + 2; // 2 standalone hists, two arrays of size kVertexBinning
+ const Int_t nCollections = 2 * kVertexBinning + 3; // 3 standalone hists, 3 arrays of size kVertexBinning
TList* collections[nCollections];
for (Int_t i=0; i<nCollections; ++i)
collections[i] = new TList;
continue;
collections[0]->Add(entry->fData);
- collections[1]->Add(entry->fPtDist);
+ collections[2]->Add(entry->fMult);
+ collections[3]->Add(entry->fPtDist);
for (Int_t i=0; i<kVertexBinning; ++i)
{
- collections[2+i]->Add(entry->fdNdEta[i]);
- collections[2+kVertexBinning+i]->Add(entry->fdNdEtaPtCutOffCorrected[i]);
- collections[2+2*kVertexBinning+i]->Add(entry->fdNdEtaNotEventCorrected[i]);
+ collections[3+i]->Add(entry->fdNdEta[i]);
+ collections[3+kVertexBinning+i]->Add(entry->fdNdEtaPtCutOffCorrected[i]);
}
++count;
}
fData->Merge(collections[0]);
- fPtDist->Merge(collections[1]);
+ fMult->Merge(collections[1]);
+ fPtDist->Merge(collections[2]);
+
for (Int_t i=0; i<kVertexBinning; ++i)
{
- fdNdEta[i]->Merge(collections[2+i]);
- fdNdEtaPtCutOffCorrected[i]->Merge(collections[2+kVertexBinning+i]);
- fdNdEtaNotEventCorrected[i]->Merge(collections[2+kVertexBinning+i]);
+ fdNdEta[i]->Merge(collections[3+i]);
+ fdNdEtaPtCutOffCorrected[i]->Merge(collections[3+kVertexBinning+i]);
}
for (Int_t i=0; i<nCollections; ++i)
void FillTrack(Float_t vtx, Float_t eta, Float_t pt);
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);
protected:
AliCorrection* fData; // we store the data in an AliCorrection
+ TH1F* fMult; // (raw) multiplicity distribution of triggered events
TH1F* fPtDist; // pt distribution
- TH1F* fdNdEtaNotEventCorrected[kVertexBinning]; // dndeta results for different vertex bins (0 = full range)
- TH1F* fdNdEta[kVertexBinning]; // dndeta results for different vertex bins (0 = full range), mult cut off corrected
- TH1F* fdNdEtaPtCutOffCorrected[kVertexBinning]; // dndeta results for different vertex bins (0 = full range), mult + pt cut off corrected
+ TH1F* fdNdEta[kVertexBinning]; // dndeta results for different vertex bins (0 = full range)
+ TH1F* fdNdEtaPtCutOffCorrected[kVertexBinning]; // dndeta results for different vertex bins (0 = full range), pt cut off corrected
ClassDef(dNdEtaAnalysis, 1)
};
TH1* histESDMBVtxNoPt = (TH1*) file->Get("dndetaTrVtx/dNdEta");
TH1* histESDMBTracksNoPt = (TH1*) file->Get("dndetaTracks/dNdEta");
- TH1* histESDNoEvCorr = (TH1*) file->Get("dndeta/dNdEta_noteventcorrected");
-
Prepare1DPlot(histESD);
Prepare1DPlot(histESDMB);
Prepare1DPlot(histESDMBVtx);
Prepare1DPlot(histESDMBVtxNoPt);
Prepare1DPlot(histESDMBTracksNoPt);
- Prepare1DPlot(histESDNoEvCorr);
-
histESD->SetLineWidth(0);
histESDMB->SetLineWidth(0);
histESDMBVtx->SetLineWidth(0);
histESDMBVtxNoPt->SetMarkerColor(3);
histESDMBTracksNoPt->SetMarkerColor(4);
- histESDNoEvCorr->SetMarkerColor(6);
-
histESD->SetMarkerStyle(20);
histESDMB->SetMarkerStyle(21);
histESDMBVtx->SetMarkerStyle(22);
histESDMBVtxNoPt->SetMarkerStyle(22);
histESDMBTracksNoPt->SetMarkerStyle(23);
- histESDNoEvCorr->SetMarkerStyle(29);
-
TH2F* dummy = new TH2F("dummy", "", 100, -1.5, 1.5, 1000, 0, histESDMBVtx->GetMaximum() * 1.1);
Prepare1DPlot(dummy);
dummy->SetStats(kFALSE);
fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
TH1* histMCPtCut = (TH1*) fdNdEtaAnalysis->GetdNdEtaHistogram(0)->Clone("histMCPtCut");
- fdNdEtaAnalysis2->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
- TH1* histMCPtCutNoEvCorr = (TH1*) fdNdEtaAnalysis2->GetdNdEtaHistogram(0)->Clone("histMCPtCutNoEvCorr");
-
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
fdNdEtaAnalysis->LoadHistograms();
fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
fdNdEtaAnalysis->LoadHistograms();
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
TH1* histMCTrVtxPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
fdNdEtaAnalysis->LoadHistograms();
- fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
+ fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
TH1* histMCTracksPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
TCanvas* canvas2 = new TCanvas("dNdEta2", "dNdEta2", 500, 500);
Prepare1DPlot(histMCTrVtx);
Prepare1DPlot(histMCPtCut);
- Prepare1DPlot(histMCPtCutNoEvCorr);
Prepare1DPlot(histMCTrPtCut);
Prepare1DPlot(histMCTrVtxPtCut);
if (histMCTracksPtCut)
histMCTrVtxPtCut->SetLineColor(3);
if (histMCTracksPtCut)
histMCTracksPtCut->SetLineColor(4);
- histMCPtCutNoEvCorr->SetLineColor(6);
TH2* dummy2 = (TH2F*) dummy->Clone("dummy2");
Prepare1DPlot(dummy2);
histESDMBNoPt->Draw("SAME");
histESDMBVtxNoPt->Draw("SAME");
histESDMBTracksNoPt->Draw("SAME");
- histESDNoEvCorr->Draw("SAME");
histMCPtCut->Draw("SAME");
- histMCPtCutNoEvCorr->Draw("SAME");
histMCTrPtCut->Draw("SAME");
histMCTrVtxPtCut->Draw("SAME");
if (histMCTracksPtCut)
canvas->SaveAs(Form("%s.eps", canvas->GetName()));
}
-void CompareRawTrackPlots(const char* fileName1, const char* fileName2, Float_t ptCut = 0.0)
+void CompareRawTrackPlots(const char* fileName1, const char* fileName2, Float_t ptCut = 0.0, Int_t multCut = 1)
{
loadlibs();
TH3* track1 = fdNdEtaAnalysis->GetData()->GetTrackCorrection()->GetMeasuredHistogram()->Clone("track1");
TH3* track2 = fdNdEtaAnalysis2->GetData()->GetTrackCorrection()->GetMeasuredHistogram()->Clone("track2");
- // normalize to number of events;
TH2* event1 = fdNdEtaAnalysis->GetData()->GetEventCorrection()->GetMeasuredHistogram();
TH2* event2 = fdNdEtaAnalysis2->GetData()->GetEventCorrection()->GetMeasuredHistogram();
- Int_t event1Count = event1->Integral();
- Int_t event2Count = event2->Integral();
- track1->Scale(1.0 / event1Count);
- track2->Scale(1.0 / event2Count);
+ Int_t event1Count = event1->Integral(event1->GetXaxis()->FindBin(-9.9), event1->GetXaxis()->FindBin(9.9), multCut, event1->GetNbinsY() + 1);
+ Int_t event2Count = event2->Integral(event2->GetXaxis()->FindBin(-9.9), event2->GetXaxis()->FindBin(9.9), multCut, event1->GetNbinsY() + 1);
Float_t nTrack1 = track1->Integral(track1->GetXaxis()->FindBin(-9.9), track1->GetXaxis()->FindBin(9.9), track1->GetYaxis()->FindBin(-0.79), track1->GetYaxis()->FindBin(0.79), track1->GetZaxis()->FindBin(ptCut), track1->GetZaxis()->GetNbins());
Float_t nTrack2 = track2->Integral(track2->GetXaxis()->FindBin(-9.9), track2->GetXaxis()->FindBin(9.9), track2->GetYaxis()->FindBin(-0.79), track2->GetYaxis()->FindBin(0.79), track2->GetZaxis()->FindBin(ptCut), track2->GetZaxis()->GetNbins());
+ Printf("%d tracks in %d events in first sample; %d tracks in %d events in second sample", (Int_t) nTrack1, event1Count, (Int_t) nTrack2, event2Count);
+
+ // normalize to number of events;
+ nTrack1 /= event1Count;
+ nTrack2 /= event2Count;
+
Printf("There are %.2f tracks/event in the first sample and %.2f tracks/event in the second sample. %.2f %% difference (with pt cut at %.2f GeV/c)", nTrack1, nTrack2, 100.0 * (nTrack1 - nTrack2) / nTrack1, ptCut);
gROOT->cd();
new TCanvas; pt->DrawCopy();
gPad->SetGridx(); gPad->SetGridy();
}
+
+ event1_x = event1->ProjectionX("event1_x");
+ event1_y = event1->ProjectionY("event1_y");
+ event2_x = event2->ProjectionX("event2_x");
+ event2_y = event2->ProjectionY("event2_y");
+
+ new TCanvas; event1_x->DrawCopy(); event2_x->SetLineColor(2); event2_x->DrawCopy("SAME");
+
+ event1_x->Divide(event2_x);
+ event1_y->Divide(event2_y);
+
+ new TCanvas; event1_x->DrawCopy();
+ new TCanvas; event1_y->DrawCopy();
+
+ event1->Divide(event2);
+ new TCanvas;
+ event1->Draw("COLZ");
+ event1->SetMinimum(0.5);
+ event1->SetMaximum(2);
+
+
}
void MagnitudeOfCorrection(const char* fileName, const char* dirName = "dndeta", Float_t ptCut = 0.3)
+/* $Id$ */
+
//
// plots for the note about multplicity measurements
//
if (mc)
task->SetReadMC();
+ //task->SetUseMCVertex();
+
mgr->AddTask(task);
if (mc) {
// Create the analysis manager
mgr = new AliAnalysisManager;
- // selection of esd tracks
- gROOT->ProcessLine(".L CreateCuts.C");
- AliESDtrackCuts* esdTrackCuts = CreateTrackCuts();
- if (!esdTrackCuts)
- {
- printf("ERROR: esdTrackCuts could not be created\n");
- return;
- }
-
TString taskName("AlidNdEtaCorrectionTask.cxx+");
if (aDebug)
taskName += "+g";