fNTracksAnalyzed(0),
fNPairsOfEvent(0),
fNPairsAnalyzedOfEvent(0),
+ fNTracksAnalyzedOfEventAfterCut(0),
+ fNPairsAnalyzedOfEventAfterCut(0),
fHistOffsetSingleMuonsX(0x0),
fHistOffsetSingleMuonsY(0x0),
fHistOffsetSingleMuons(0x0),
fHistWOffsetSingleMuons(0x0),
fHistErrorSingleMuonsX(0x0),
fHistErrorSingleMuonsY(0x0),
- fHistOffsetSingleMuonsX_vsPtRapidity(0x0),
- fHistOffsetSingleMuonsY_vsPtRapidity(0x0),
- fHistSingleMuonsPtRapidity(0x0),
+ fHistZOriginSingleMuonsMC(0x0),
+ fHistZROriginSingleMuonsMC(0x0),
+ fHistSingleMuonsPtRapidityMC(0x0),
fHistSingleMuonsOffsetChi2(0x0),
- fHistWOffsetMuonPairs(0x0),
- fHistMassMuonPairs(0x0),
- fHistMassMuonPairsWithoutMFT(0x0),
- fHistMassMuonPairsMC(0x0),
- fHistRapidityPtMuonPairsMC(0x0),
+ fHistSingleMuonsOffsetChi2_BeforeMFT(0x0),
+ fHistSingleMuonsOffsetChi2_AfterMFT(0x0),
fGraphSingleMuonsOffsetChi2(0x0),
- fNMassBins(1000),
+ fHistRapidityPtMuonPairs(0x0),
+ fNMassBins(10),
+ fNPtDimuBins(1000),
fMassMin(0),
fMassMax(10),
+ fPtDimuMin(0),
+ fPtDimuMax(5),
+ fPtAxisDimuons(0),
fSingleMuonAnalysis(1),
fMuonPairAnalysis(1),
fMatchTrigger(0),
fUseBransonForKinematics(kFALSE),
fCutOnOffsetChi2(kFALSE),
fCenterOffset(0.),
- fCenterChi2(1.),
+ fCenterChi2(0.),
fScaleOffset(250.),
- fScaleChi2(4.5),
+ fScaleChi2(2.5),
fRadiusCut(1.)
{
// default constructor
- for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
- for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
- fHistOffsetSingleMuonsX_tmp[rapBin][ptBin] = 0x0;
- fHistOffsetSingleMuonsY_tmp[rapBin][ptBin] = 0x0;
- }
+ for (Int_t iPtBin=0; iPtBin<fNMaxPtBinsDimuons+1; iPtBin++) {
+ fHistWOffsetMuonPairs[iPtBin] = NULL;
+ fHistMassMuonPairs[iPtBin] = NULL;
+ fHistMassMuonPairsWithoutMFT[iPtBin] = NULL;
+ fHistMassMuonPairsMC[iPtBin] = NULL;
}
}
Bool_t AliMuonForwardTrackAnalysis::Init(Char_t *inputFileName) {
+ fPtAxisDimuons = new TAxis(fNPtDimuBins, fPtDimuMin, fPtDimuMax);
+
BookHistos();
TFile *inputFile = new TFile(Form("%s/%s",fInputDir.Data(),inputFileName));
if (fSingleMuonAnalysis) {
fNTracksAnalyzedOfEvent = 0;
+ fNTracksAnalyzedOfEventAfterCut = 0;
fNTracksOfEvent = fMuonForwardTracksWithBranson->GetEntries();
while (AnalyzeSingleMuon()) continue;
}
}
BuildMuonPairs();
fNPairsAnalyzedOfEvent = 0;
+ fNPairsAnalyzedOfEventAfterCut = 0;
fNPairsOfEvent = fMuonForwardTrackPairsWithBranson->GetEntries();
while (AnalyzeMuonPair()) continue;
}
+ AliInfo(Form("**** analyzed event # %4d (%3d tracks and %3d pairs analyzed) ****", fEv, fNTracksAnalyzedOfEventAfterCut, fNPairsAnalyzedOfEventAfterCut));
+
fEv++;
return kTRUE;
if (fMatchTrigger && !fMFTTrack->GetMatchTrigger()) return kTRUE;
fMCRefTrack = fMFTTrack->GetMCTrackRef();
- if (!fMCRefTrack) return kTRUE;
- if (fMFTTrack->GetNWrongClustersMC()>fMaxNWrongClustersMC) return kTRUE;
+ if (fOption!=kPionsKaons && !fMCRefTrack) return kTRUE;
+ if (fOption!=kPionsKaons && fMFTTrack->GetNWrongClustersMC()>fMaxNWrongClustersMC) return kTRUE;
+
+ if (fMCRefTrack) {
+ fHistZOriginSingleMuonsMC -> Fill(-1.*fMCRefTrack->Vz());
+ fHistZROriginSingleMuonsMC -> Fill(-1.*fMCRefTrack->Vz(), TMath::Sqrt(fMCRefTrack->Vx()*fMCRefTrack->Vx()+fMCRefTrack->Vy()*fMCRefTrack->Vy()));
+ }
AliMUONTrackParam *param = fMFTTrack->GetTrackParamAtMFTCluster(0);
AliMUONTrackExtrap::ExtrapToZCov(param, fPrimaryVtxZ);
fHistOffsetSingleMuonsX -> Fill(1.e4*dX);
fHistOffsetSingleMuonsY -> Fill(1.e4*dY);
- Int_t rapBin = fHistOffsetSingleMuonsX_vsPtRapidity->GetXaxis()->FindBin(pMu.Rapidity());
- Int_t ptBin = fHistOffsetSingleMuonsX_vsPtRapidity->GetYaxis()->FindBin(pMu.Pt());
- // AliDebug(1, Form("pt = %f (%d), rap = %f (%d)\n", pMu.Pt(), pMu.Rapidity(), ptBin, rapBin));
- if (0<rapBin && rapBin<=fNRapBinsOffsetSingleMuons && 0<ptBin && ptBin<=fNPtBinsOffsetSingleMuons) {
- fHistOffsetSingleMuonsX_tmp[rapBin-1][ptBin-1]->Fill(1.e4*dX);
- fHistOffsetSingleMuonsY_tmp[rapBin-1][ptBin-1]->Fill(1.e4*dY);
- }
- fHistSingleMuonsPtRapidity -> Fill(pMu.Rapidity(), pMu.Pt());
+
+ if (fOption!=kPionsKaons) fHistSingleMuonsPtRapidityMC-> Fill(fMCRefTrack->Y(), fMCRefTrack->Pt());
fHistOffsetSingleMuons -> Fill(1.e4*offset);
fHistWOffsetSingleMuons -> Fill(weightedOffset);
Double_t chi2OverNdf = fMFTTrack->GetGlobalChi2()/Double_t(fMFTTrack->GetNMFTClusters()+fMFTTrack->GetNMUONClusters());
fHistSingleMuonsOffsetChi2 -> Fill(1.e4*offset, chi2OverNdf);
+ if (fMCRefTrack) {
+ if (-1.*fMCRefTrack->Vz()<5.) fHistSingleMuonsOffsetChi2_BeforeMFT -> Fill(1.e4*offset, chi2OverNdf);
+ else fHistSingleMuonsOffsetChi2_AfterMFT -> Fill(1.e4*offset, chi2OverNdf);
+ }
+
fGraphSingleMuonsOffsetChi2 -> SetPoint(fGraphSingleMuonsOffsetChi2->GetN(),1.e4*offset, chi2OverNdf);
fNTracksAnalyzed++;
+ fNTracksAnalyzedOfEventAfterCut++;
return kTRUE;
if (fOption==kResonanceOnly && !fMFTTrackPair->IsResonance()) return kTRUE;
- fHistMassMuonPairs -> Fill(fMFTTrackPair->GetMass(fPrimaryVtxZ));
- fHistWOffsetMuonPairs -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
- fHistMassMuonPairsWithoutMFT -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
- fHistMassMuonPairsMC -> Fill(fMFTTrackPair->GetMassMC());
- fHistRapidityPtMuonPairsMC -> Fill(fMFTTrackPair->GetRapidityMC(), fMFTTrackPair->GetPtMC());
+ fMFTTrackPair -> SetKinem(fPrimaryVtxZ);
+
+ Int_t ptBin = fPtAxisDimuons->FindBin(fMFTTrackPair->GetPtMC());
- AliDebug(1, Form("mass = %f MC = %f", fMFTTrackPair->GetMass(fPrimaryVtxZ), fMFTTrackPair->GetMassMC()));
+ if (1<=ptBin && ptBin<=fNPtDimuBins) {
+ fHistMassMuonPairs[ptBin] -> Fill(fMFTTrackPair->GetMass());
+ fHistWOffsetMuonPairs[ptBin] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ fHistMassMuonPairsWithoutMFT[ptBin] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ if (fOption!=kPionsKaons) fHistMassMuonPairsMC[ptBin] -> Fill(fMFTTrackPair->GetMassMC());
+ }
+ fHistMassMuonPairs[0] -> Fill(fMFTTrackPair->GetMass());
+ fHistWOffsetMuonPairs[0] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ fHistMassMuonPairsWithoutMFT[0] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ if (fOption!=kPionsKaons) fHistMassMuonPairsMC[0] -> Fill(fMFTTrackPair->GetMassMC());
+
+ if (fOption!=kPionsKaons) fHistRapidityPtMuonPairs -> Fill(fMFTTrackPair->GetRapidityMC(), fMFTTrackPair->GetPtMC());
+ else if (fMFTTrackPair->IsKinemSet()) fHistRapidityPtMuonPairs -> Fill(fMFTTrackPair->GetRapidity(), fMFTTrackPair->GetPt());
+
+ AliDebug(1, Form("mass = %f MC = %f", fMFTTrackPair->GetMass(), fMFTTrackPair->GetMassMC()));
+
+ fNPairsAnalyzedOfEventAfterCut++;
return kTRUE;
AliMuonForwardTrack *track1_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson->At(jTrack);
if (fMatchTrigger) if (!track0_WithBranson->GetMatchTrigger() || !track1_WithBranson->GetMatchTrigger()) continue;
- if (!track0_WithBranson->GetMCTrackRef() || !track1_WithBranson->GetMCTrackRef()) continue;
+ if (fOption!=kPionsKaons && (!track0_WithBranson->GetMCTrackRef() || !track1_WithBranson->GetMCTrackRef())) continue;
AliMuonForwardTrackPair *trackPairWithBranson = new AliMuonForwardTrackPair(track0_WithBranson, track1_WithBranson);
AliMuonForwardTrackPair *trackPairWithoutBranson = new AliMuonForwardTrackPair(track0_WithoutBranson, track1_WithoutBranson);
delete trackPairWithoutBranson;
continue;
}
+// if (fMFTTrackPairWithBranson) fMFTTrackPairWithBranson -> SetKinem(fPrimaryVtxZ);
+// if (fMFTTrackPairWithoutBranson) fMFTTrackPairWithoutBranson -> SetKinem(fPrimaryVtxZ);
new ((*fMuonForwardTrackPairsWithBranson)[fMuonForwardTrackPairsWithBranson->GetEntries()]) AliMuonForwardTrackPair(*trackPairWithBranson);
new ((*fMuonForwardTrackPairsWithoutBranson)[fMuonForwardTrackPairsWithoutBranson->GetEntries()]) AliMuonForwardTrackPair(*trackPairWithoutBranson);
}
void AliMuonForwardTrackAnalysis::Terminate(Char_t *outputFileName) {
- for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
- for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
- Int_t binMin_x = fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->FindBin(-3*fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMS());
- Int_t binMax_x = fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->FindBin(+3*fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMS());
- for (Int_t bin=1; bin<=fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetNbinsX(); bin++) {
- if (bin<binMin_x || bin>binMax_x) fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->SetBinContent(bin, 0);
- }
- Int_t binMin_y = fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->FindBin(-3*fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMS());
- Int_t binMax_y = fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->FindBin(+3*fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMS());
- for (Int_t bin=1; bin<=fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetNbinsX(); bin++) {
- if (bin<binMin_y || bin>binMax_y) fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->SetBinContent(bin, 0);
- }
- fHistOffsetSingleMuonsX_vsPtRapidity->SetBinContent(rapBin+1, ptBin+1, fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMS());
- fHistOffsetSingleMuonsX_vsPtRapidity->SetBinError(rapBin+1, ptBin+1, fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMSError());
- fHistOffsetSingleMuonsY_vsPtRapidity->SetBinContent(rapBin+1, ptBin+1, fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMS());
- fHistOffsetSingleMuonsY_vsPtRapidity->SetBinError(rapBin+1, ptBin+1, fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMSError());
- }
- }
-
TFile *fileOut = new TFile(Form("%s/%s",fOutputDir.Data(),outputFileName), "recreate");
printf("Writing output objects to file %s\n", fileOut->GetName());
fHistErrorSingleMuonsX -> Write();
fHistErrorSingleMuonsY -> Write();
- fHistOffsetSingleMuonsX_vsPtRapidity -> Write();
- fHistOffsetSingleMuonsY_vsPtRapidity -> Write();
-
-// for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
-// for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
-// fHistOffsetSingleMuonsX_tmp[rapBin][ptBin] -> Write();
-// fHistOffsetSingleMuonsY_tmp[rapBin][ptBin] -> Write();
-// }
-// }
-
- fHistSingleMuonsPtRapidity -> Write();
+ fHistSingleMuonsPtRapidityMC -> Write();
fHistSingleMuonsOffsetChi2 -> Write();
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> Write();
+ fHistSingleMuonsOffsetChi2_AfterMFT -> Write();
fGraphSingleMuonsOffsetChi2 -> Write();
- fHistWOffsetMuonPairs -> Write();
- fHistMassMuonPairs -> Write();
- fHistMassMuonPairsWithoutMFT -> Write();
- fHistMassMuonPairsMC -> Write();
- fHistRapidityPtMuonPairsMC -> Write();
+ fHistZOriginSingleMuonsMC -> Write();
+ fHistZROriginSingleMuonsMC -> Write();
+
+ for (Int_t iPtBin=0; iPtBin<fNPtDimuBins+1; iPtBin++) {
+ fHistWOffsetMuonPairs[iPtBin] -> Write();
+ fHistMassMuonPairs[iPtBin] -> Write();
+ fHistMassMuonPairsWithoutMFT[iPtBin] -> Write();
+ fHistMassMuonPairsMC[iPtBin] -> Write();
+ }
+
+ fHistRapidityPtMuonPairs -> Write();
fileOut -> Close();
fHistOffsetSingleMuons = new TH1D("fHistOffsetSingleMuons", "Offset for single muons", 200, 0, 2000);
fHistWOffsetSingleMuons = new TH1D("fHistWOffsetSingleMuons", "Weighted Offset for single muons", 300, 0, 15);
- fHistOffsetSingleMuonsX_vsPtRapidity = new TH2D("fHistOffsetSingleMuonsX_vsPtRapidity", "Offset for single muons along X",
- 10, -4, -2.5, 10, 0.5, 5.5);
- fHistOffsetSingleMuonsY_vsPtRapidity = new TH2D("fHistOffsetSingleMuonsY_vsPtRapidity", "Offset for single muons along Y",
- 10, -4, -2.5, 10, 0.5, 5.5);
-
- for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
- for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
- fHistOffsetSingleMuonsX_tmp[rapBin][ptBin] = new TH1D(Form("fHistOffsetSingleMuonsX_tmp_%02d_%02d",rapBin,ptBin), "", 1000, -1000, 1000);
- fHistOffsetSingleMuonsY_tmp[rapBin][ptBin] = new TH1D(Form("fHistOffsetSingleMuonsY_tmp_%02d_%02d",rapBin,ptBin), "", 1000, -1000, 1000);
- }
- }
-
- fHistSingleMuonsPtRapidity = new TH2D("fHistSingleMuonsPtRapidity", "Phase Space for single muons", 10, -4, -2.5, 10, 0.5, 5.5);
+ fHistSingleMuonsPtRapidityMC = new TH2D("fHistSingleMuonsPtRapidityMC", "Phase Space for single muons", 100, -4.5, -2., 100, 0., 10.);
fHistSingleMuonsOffsetChi2 = new TH2D("fHistSingleMuonsOffsetChi2", "Offset vs #chi^{2}/ndf for single muons", 400, 0, 4000, 100, 0, 20);
+ fHistSingleMuonsOffsetChi2_BeforeMFT = new TH2D("fHistSingleMuonsOffsetChi2_BeforeMFT",
+ "Offset vs #chi^{2}/ndf for single muons with origin before MFT", 400, 0, 4000, 100, 0, 20);
+ fHistSingleMuonsOffsetChi2_AfterMFT = new TH2D("fHistSingleMuonsOffsetChi2_AfterMFT",
+ "Offset vs #chi^{2}/ndf for single muons with origin after MFT", 400, 0, 4000, 100, 0, 20);
+
+ fHistZOriginSingleMuonsMC = new TH1D("fHistZOriginSingleMuonsMC", "Z origin for single muons (from MC)", 1000, 0., 500.);
+ fHistZROriginSingleMuonsMC = new TH2D("fHistZROriginSingleMuonsMC", "Z-R origin for single muons (from MC)", 1000, 0., 500., 1000, 0., 100.);
fHistOffsetSingleMuonsX -> SetXTitle("Offset(X) [#mum]");
fHistOffsetSingleMuonsY -> SetXTitle("Offset(Y) [#mum]");
fHistOffsetSingleMuons -> SetXTitle("Offset [#mum]");
fHistWOffsetSingleMuons -> SetXTitle("Weighted Offset");
- fHistOffsetSingleMuonsX_vsPtRapidity -> SetXTitle("y^{#mu}");
- fHistOffsetSingleMuonsY_vsPtRapidity -> SetXTitle("y^{#mu}");
- fHistOffsetSingleMuonsX_vsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
- fHistOffsetSingleMuonsY_vsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
-
- fHistSingleMuonsPtRapidity -> SetXTitle("y^{#mu}");
- fHistSingleMuonsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
+ fHistSingleMuonsPtRapidityMC -> SetXTitle("y^{#mu}");
+ fHistSingleMuonsPtRapidityMC -> SetYTitle("p_{T}^{#mu} [GeV/c]");
fHistSingleMuonsOffsetChi2 -> SetXTitle("Offset [#mum]");
fHistSingleMuonsOffsetChi2 -> SetYTitle("#chi^{2}/ndf");
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> SetXTitle("Offset [#mum]");
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> SetYTitle("#chi^{2}/ndf");
+ fHistSingleMuonsOffsetChi2_AfterMFT -> SetXTitle("Offset [#mum]");
+ fHistSingleMuonsOffsetChi2_AfterMFT -> SetYTitle("#chi^{2}/ndf");
+
+ fHistZOriginSingleMuonsMC -> SetXTitle("Z [cm]");
+ fHistZROriginSingleMuonsMC -> SetXTitle("Z [cm]");
+ fHistZROriginSingleMuonsMC -> SetXTitle("R [cm]");
fHistOffsetSingleMuonsX -> Sumw2();
fHistOffsetSingleMuonsY -> Sumw2();
fHistOffsetSingleMuons -> Sumw2();
fHistWOffsetSingleMuons -> Sumw2();
- fHistOffsetSingleMuonsX_vsPtRapidity -> Sumw2();
- fHistOffsetSingleMuonsY_vsPtRapidity -> Sumw2();
- fHistSingleMuonsPtRapidity -> Sumw2();
- fHistSingleMuonsOffsetChi2 -> Sumw2();
+ fHistZOriginSingleMuonsMC -> Sumw2();
+ fHistZROriginSingleMuonsMC -> Sumw2();
+
+ fHistSingleMuonsPtRapidityMC -> Sumw2();
+ fHistSingleMuonsOffsetChi2 -> Sumw2();
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> Sumw2();
+ fHistSingleMuonsOffsetChi2_AfterMFT -> Sumw2();
//--------------------------------------------
//--------------------------------------------
- fHistWOffsetMuonPairs = new TH1D("fHistWOffsetMuonPairs", "Weighted Offset for Muon Pairs", 300, 0, 60);
- fHistMassMuonPairs = new TH1D("fHistMassMuonPairs", "Dimuon Mass (MUON+MFT)", fNMassBins, fMassMin, fMassMax);
- fHistMassMuonPairsWithoutMFT = new TH1D("fHistMassMuonPairsWithoutMFT", "Dimuon Mass (MUON only)", fNMassBins, fMassMin, fMassMax);
- fHistMassMuonPairsMC = new TH1D("fHistMassMuonPairsMC", "Dimuon Mass (MC)", fNMassBins, fMassMin, fMassMax);
- fHistRapidityPtMuonPairsMC = new TH2D("fHistRapidityPtMuonPairsMC", "Dimuon Phase Space (MC)", 100, -4.5, -2., 100, 0., 10.);
-
- fHistWOffsetMuonPairs -> SetXTitle("Weighted Offset");
- fHistMassMuonPairs -> SetXTitle("Mass [GeV/c^{2}]");
- fHistMassMuonPairsWithoutMFT -> SetXTitle("Mass [GeV/c^{2}]");
- fHistMassMuonPairsMC -> SetXTitle("Mass [GeV/c^{2}]");
- fHistRapidityPtMuonPairsMC -> SetXTitle("Rapidity");
- fHistRapidityPtMuonPairsMC -> SetYTitle("p_{T} [GeV/c]");
-
- fHistWOffsetMuonPairs -> Sumw2();
- fHistMassMuonPairs -> Sumw2();
- fHistMassMuonPairsWithoutMFT -> Sumw2();
- fHistMassMuonPairsMC -> Sumw2();
- fHistRapidityPtMuonPairsMC -> Sumw2();
+ for (Int_t iPtBin=0; iPtBin<=fNPtDimuBins+1; iPtBin++) {
+
+ if (!iPtBin) {
+ fHistWOffsetMuonPairs[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairs_%d",iPtBin),
+ "Weighted Offset for Muon Pairs (All p_{T}^{#mu#mu})",
+ 300, 0, 60);
+ fHistMassMuonPairs[iPtBin] = new TH1D(Form("fHistMassMuonPairs_%d",iPtBin),
+ "Dimuon Mass (MUON+MFT) (All p_{T}^{#mu#mu})",
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsWithoutMFT[iPtBin] = new TH1D(Form("fHistMassMuonPairsWithoutMFT_%d",iPtBin),
+ "Dimuon Mass (MUON only) (All p_{T}^{#mu#mu})",
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsMC[iPtBin] = new TH1D(Form("fHistMassMuonPairsMC_%d",iPtBin),
+ "Dimuon Mass (MC) (All p_{T}^{#mu#mu})",
+ fNMassBins, fMassMin, fMassMax);
+ }
+
+ else {
+ Double_t ptMin = fPtAxisDimuons->GetBinLowEdge(iPtBin);
+ Double_t ptMax = fPtAxisDimuons->GetBinUpEdge(iPtBin);
+ fHistWOffsetMuonPairs[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairs_%d",iPtBin),
+ Form("Weighted Offset for Muon Pairs ( %3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ 300, 0, 60);
+ fHistMassMuonPairs[iPtBin] = new TH1D(Form("fHistMassMuonPairs_%d",iPtBin),
+ Form("Dimuon Mass (MUON+MFT) (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsWithoutMFT[iPtBin] = new TH1D(Form("fHistMassMuonPairsWithoutMFT_%d",iPtBin),
+ Form("Dimuon Mass (MUON only) (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsMC[iPtBin] = new TH1D(Form("fHistMassMuonPairsMC_%d",iPtBin),
+ Form("Dimuon Mass (MC) (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ fNMassBins, fMassMin, fMassMax);
+ }
+
+ fHistWOffsetMuonPairs[iPtBin] -> SetXTitle("Weighted Offset");
+ fHistMassMuonPairs[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]");
+ fHistMassMuonPairsWithoutMFT[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]");
+ fHistMassMuonPairsMC[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]");
+
+ fHistWOffsetMuonPairs[iPtBin] -> Sumw2();
+ fHistMassMuonPairs[iPtBin] -> Sumw2();
+ fHistMassMuonPairsWithoutMFT[iPtBin] -> Sumw2();
+ fHistMassMuonPairsMC[iPtBin] -> Sumw2();
+
+ }
+
+ if (fOption==kPionsKaons) fHistRapidityPtMuonPairs = new TH2D("fHistRapidityPtMuonPairs", "Dimuon Phase Space (rec)", 20, -4.5, -2., 20, 0., 10.);
+ else fHistRapidityPtMuonPairs = new TH2D("fHistRapidityPtMuonPairs", "Dimuon Phase Space (MC)", 100, -4.5, -2., 100, 0., 10.);
+ fHistRapidityPtMuonPairs -> SetXTitle("Rapidity");
+ fHistRapidityPtMuonPairs -> SetYTitle("p_{T} [GeV/c]");
+ fHistRapidityPtMuonPairs -> Sumw2();
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff