X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MFT%2FAliMuonForwardTrackAnalysis.cxx;h=ad3cfd10140939b2b0ec83c828ed6e47ba1f7d2d;hb=bbce5a6428f95b59044b19a1d70e8a30fc5274a0;hp=c7819451f770eb9d8213230968236585567bb25f;hpb=789c2e430bcf7316fd5f86d06afefe596889d5cf;p=u%2Fmrichter%2FAliRoot.git diff --git a/MFT/AliMuonForwardTrackAnalysis.cxx b/MFT/AliMuonForwardTrackAnalysis.cxx index c7819451f77..ad3cfd10140 100644 --- a/MFT/AliMuonForwardTrackAnalysis.cxx +++ b/MFT/AliMuonForwardTrackAnalysis.cxx @@ -13,6 +13,8 @@ #include "TMatrixD.h" #include "TTree.h" #include "TH1D.h" +#include "TH2D.h" +#include "TH3D.h" #include "AliLog.h" #include "TFile.h" #include "TParticle.h" @@ -24,6 +26,7 @@ #include "TDatabasePDG.h" #include "TGraph.h" #include "AliMuonForwardTrackAnalysis.h" +#include "TSystem.h" ClassImp(AliMuonForwardTrackAnalysis) @@ -36,8 +39,10 @@ AliMuonForwardTrackAnalysis::AliMuonForwardTrackAnalysis(): fInputTreeWithBranson(0x0), fInputTreeWithoutBranson(0x0), fMuonForwardTracksWithBranson(0), + fMuonForwardTracksWithBransonMix(0), fMuonForwardTrackPairsWithBranson(0), fMuonForwardTracksWithoutBranson(0), + fMuonForwardTracksWithoutBransonMix(0), fMuonForwardTrackPairsWithoutBranson(0), fMFTTrackWithBranson(0), fMFTTrackWithoutBranson(0), @@ -56,35 +61,33 @@ AliMuonForwardTrackAnalysis::AliMuonForwardTrackAnalysis(): fNPairsAnalyzedOfEvent(0), fNTracksAnalyzedOfEventAfterCut(0), fNPairsAnalyzedOfEventAfterCut(0), - fHistOffsetSingleMuonsX(0x0), - fHistOffsetSingleMuonsY(0x0), - fHistOffsetSingleMuons(0x0), - fHistWOffsetSingleMuons(0x0), - fHistErrorSingleMuonsX(0x0), - fHistErrorSingleMuonsY(0x0), + fHistXOffsetSingleMuonsVsEtaVsP(0x0), + fHistYOffsetSingleMuonsVsEtaVsP(0x0), + fHistOffsetSingleMuonsVsEtaVsP(0x0), + fHistWOffsetSingleMuonsVsEtaVsP(0x0), + fHistXOffsetSingleMuonsVsEtaVsPt(0x0), + fHistYOffsetSingleMuonsVsEtaVsPt(0x0), + fHistOffsetSingleMuonsVsEtaVsPt(0x0), + fHistWOffsetSingleMuonsVsEtaVsPt(0x0), + fHistXErrorSingleMuonsVsEtaVsP(0x0), + fHistYErrorSingleMuonsVsEtaVsP(0x0), + fHistXErrorSingleMuonsVsEtaVsPt(0x0), + fHistYErrorSingleMuonsVsEtaVsPt(0x0), fHistZOriginSingleMuonsMC(0x0), - fHistZROriginSingleMuonsMC(0x0), - fHistSingleMuonsPtRapidityMC(0x0), + fHistZROriginSingleMuonsMC(0x0), + fHistSingleMuonsPtRapidity(0x0), fHistSingleMuonsOffsetChi2(0x0), - fHistRapidityPtMuonPairs(0x0), - fHistMassMuonPairsVsPt(0), - fHistMassMuonPairsWithoutMFTVsPt(0), - fHistMassMuonPairsVsPtLSp(0), - fHistMassMuonPairsWithoutMFTVsPtLSp(0), - fHistMassMuonPairsVsPtLSm(0), - fHistMassMuonPairsWithoutMFTVsPtLSm(0), - fEvalDimuonVtxResolution(kFALSE), - fNMassBins(10), - fNPtDimuBins(1000), + fHistMassMuonPairsMCVsPt(0x0), + fHistDimuonVtxResolutionXVsPt(0x0), + fHistDimuonVtxResolutionYVsPt(0x0), + fHistDimuonVtxResolutionZVsPt(0x0), + fTrueMass(0.), fMassMin(0), - fMassMax(10), - fPtDimuMin(0), - fPtDimuMax(5), - fPtAxisDimuons(0), + fMassMax(9999), fSingleMuonAnalysis(1), fMuonPairAnalysis(1), - fMatchTrigger(0), fOption(0), + fTriggerLevel(0), fXVertResMC(50.e-4), fYVertResMC(50.e-4), fZVertResMC(50.e-4), @@ -92,30 +95,37 @@ AliMuonForwardTrackAnalysis::AliMuonForwardTrackAnalysis(): fPrimaryVtxY(0.), fPrimaryVtxZ(0.), fMaxNWrongClustersMC(999), - fPtMinSingleMuons(0), + fMinPtSingleMuons(0), + fMinEtaSingleMuons(-99999.), + fMaxEtaSingleMuons(+99999.), fUseBransonForCut(kFALSE), fUseBransonForKinematics(kFALSE), - fCutOnOffsetChi2(kFALSE), - fCenterOffset(0.), - fCenterChi2(0.), - fScaleOffset(250.), - fScaleChi2(1.5), - fRadiusCut(1.) + fCorrelateCutOnOffsetChi2(kFALSE), + fMaxChi2SingleMuons(1.e9), + fMaxOffsetSingleMuons(1.e9), + fMaxWOffsetMuonPairsAtPrimaryVtx(1.e9), + fMaxWOffsetMuonPairsAtPCA(1.e9), + fMaxDistancePrimaryVtxPCA(1.e9), + fMinPCAQuality(0.), + fMixing(kFALSE), + fNEventsToMix(10) { // default constructor - for (Int_t iPtBin=0; iPtBinIsOpen()) { AliError(Form("Error opening file %s", inputFileName)); return kFALSE; } - fInputTreeWithBranson = (TTree*) inputFile->Get("AliMuonForwardTracksWithBranson"); + + fInputTreeWithBranson = (TTree*) inputFile->Get("AliMuonForwardTracksWithBranson"); if (!fInputTreeWithBranson) { AliError("Error reading input tree"); return kFALSE; } - fInputTreeWithoutBranson = (TTree*) inputFile->Get("AliMuonForwardTracksWithoutBranson"); + + fInputTreeWithoutBranson = (TTree*) inputFile->Get("AliMuonForwardTracksWithoutBranson"); if (!fInputTreeWithoutBranson) { AliError("Error reading input tree"); return kFALSE; } - - if (fFirstEvent<0 || fLastEvent<0 || fFirstEvent>fLastEvent || fFirstEvent>=fInputTreeWithBranson->GetEntriesFast()) { + + if (fFirstEvent>=fInputTreeWithBranson->GetEntriesFast()) return kFALSE; + else if (fFirstEvent<0 || fLastEvent<0 || fFirstEvent>fLastEvent || fFirstEvent>=fInputTreeWithBranson->GetEntriesFast()) { fFirstEvent = 0; fLastEvent = fInputTreeWithBranson->GetEntriesFast()-1; } else { fLastEvent = TMath::Min(fLastEvent, Int_t(fInputTreeWithBranson->GetEntriesFast()-1)); } - + AliInfo(Form("Analysing events %d to %d", fFirstEvent, fLastEvent)); - + fMuonForwardTracksWithBranson = new TClonesArray("AliMuonForwardTrack",30); fInputTreeWithBranson->SetBranchAddress("tracks", &fMuonForwardTracksWithBranson); - + fMuonForwardTracksWithoutBranson = new TClonesArray("AliMuonForwardTrack",30); fInputTreeWithoutBranson->SetBranchAddress("tracks", &fMuonForwardTracksWithoutBranson); - + TGeoManager::Import(Form("%s/geometry.root",fInputDir.Data())); - + AliMUONTrackExtrap::SetField(); - + fMuonForwardTrackPairsWithBranson = new TClonesArray("AliMuonForwardTrackPair",10); fMuonForwardTrackPairsWithoutBranson = new TClonesArray("AliMuonForwardTrackPair",10); - fMuonForwardTrackPairsWithBranson->SetOwner(kTRUE); - fMuonForwardTrackPairsWithoutBranson->SetOwner(kTRUE); - - + fMuonForwardTrackPairsWithBranson -> SetOwner(kTRUE); + fMuonForwardTrackPairsWithoutBranson -> SetOwner(kTRUE); + return kTRUE; - + } - + //==================================================================================================================================================== Bool_t AliMuonForwardTrackAnalysis::LoadNextEvent() { if (fEv>fLastEvent) return kFALSE; if (fEv Clear(""); - fMuonForwardTracksWithoutBranson -> Clear(""); - fInputTreeWithBranson->GetEvent(fEv); - fInputTreeWithoutBranson->GetEvent(fEv); + + fMuonForwardTracksWithBranson -> Clear("C"); + fMuonForwardTracksWithoutBranson -> Clear("C"); + fMuonForwardTracksWithBranson -> Delete(); + fMuonForwardTracksWithoutBranson -> Delete(); + fInputTreeWithBranson -> GetEvent(fEv); + fInputTreeWithoutBranson -> GetEvent(fEv); + AliDebug(2,Form("**** analyzing event # %4d (%3d tracks) ****", fEv, fMuonForwardTracksWithBranson->GetEntriesFast())); + AliInfo(Form("**** analyzing event # %6d of %6d ****", fEv, fLastEvent)); + fPrimaryVtxX = gRandom->Gaus(0., fXVertResMC); fPrimaryVtxY = gRandom->Gaus(0., fYVertResMC); fPrimaryVtxZ = gRandom->Gaus(0., fZVertResMC); @@ -198,19 +214,72 @@ Bool_t AliMuonForwardTrackAnalysis::LoadNextEvent() { } if (fMuonPairAnalysis) { - if (fMuonForwardTrackPairsWithBranson) { - fMuonForwardTrackPairsWithBranson->Clear("C"); - fMuonForwardTrackPairsWithoutBranson->Clear("C"); + if (fMuonForwardTrackPairsWithBranson || fMuonForwardTrackPairsWithoutBranson) { + fMuonForwardTrackPairsWithBranson -> Clear("C"); + fMuonForwardTrackPairsWithoutBranson -> Clear("C"); + fMuonForwardTrackPairsWithBranson -> Delete(); + fMuonForwardTrackPairsWithoutBranson -> Delete(); } BuildMuonPairs(); fNPairsAnalyzedOfEvent = 0; fNPairsAnalyzedOfEventAfterCut = 0; - // fNPairsOfEvent = fMuonForwardTrackPairsWithBranson->GetEntriesFast(); - while (AnalyzeMuonPair()) continue; + fNPairsOfEvent = fMuonForwardTrackPairsWithBranson->GetEntriesFast(); + while (AnalyzeMuonPair(kSingleEvent)) continue; } AliDebug(2,Form("**** analyzed event # %4d (%3d tracks and %3d pairs analyzed) ****", fEv, fNTracksAnalyzedOfEventAfterCut, fNPairsAnalyzedOfEventAfterCut)); + + if (fMuonPairAnalysis && fMixing) { + for (fEvMix=fEv+1; fEvMix<=fEv+fNEventsToMix; fEvMix++) { + if (fEvMix<=fLastEvent) { + + if (fMuonForwardTracksWithBransonMix || fMuonForwardTracksWithoutBransonMix) { + fMuonForwardTracksWithBransonMix -> Delete(); + fMuonForwardTracksWithoutBransonMix -> Delete(); + delete fMuonForwardTracksWithBransonMix; + delete fMuonForwardTracksWithoutBransonMix; + } + + fMuonForwardTracksWithBranson -> Clear("C"); + fMuonForwardTracksWithoutBranson -> Clear("C"); + fMuonForwardTracksWithBranson -> Delete(); + fMuonForwardTracksWithoutBranson -> Delete(); + fInputTreeWithBranson -> GetEvent(fEvMix); + fInputTreeWithoutBranson -> GetEvent(fEvMix); + + fMuonForwardTracksWithBransonMix = new TClonesArray(*fMuonForwardTracksWithBranson); + fMuonForwardTracksWithoutBransonMix = new TClonesArray(*fMuonForwardTracksWithoutBranson); + + fMuonForwardTracksWithBranson -> Clear("C"); + fMuonForwardTracksWithoutBranson -> Clear("C"); + fMuonForwardTracksWithBranson -> Delete(); + fMuonForwardTracksWithoutBranson -> Delete(); + fInputTreeWithBranson -> GetEvent(fEv); + fInputTreeWithoutBranson -> GetEvent(fEv); + + AliDebug(2,Form("**** mixing event # %4d (%3d tracks) with event # %4d (%3d tracks) ****", + fEv, fMuonForwardTracksWithBranson->GetEntriesFast(), + fEvMix, fMuonForwardTracksWithBransonMix ->GetEntriesFast())); + if (fMuonForwardTrackPairsWithBranson || fMuonForwardTrackPairsWithoutBranson) { + fMuonForwardTrackPairsWithBranson -> Clear("C"); + fMuonForwardTrackPairsWithoutBranson -> Clear("C"); + fMuonForwardTrackPairsWithBranson -> Delete(); + fMuonForwardTrackPairsWithoutBranson -> Delete(); + } + BuildMuonPairsMix(); + fNPairsAnalyzedOfEvent = 0; + fNPairsAnalyzedOfEventAfterCut = 0; + fNPairsOfEvent = fMuonForwardTrackPairsWithBranson->GetEntriesFast(); + while (AnalyzeMuonPair(kMixedEvent)) continue; + AliDebug(2,Form("**** analyzed mixed event pair (%4d ; %4d) : %3d pairs analyzed ****", fEv, fEvMix, fNPairsAnalyzedOfEventAfterCut)); + + // delete fMuonForwardTracksWithBransonMix; + // delete fMuonForwardTracksWithoutBransonMix; + } + } + } + fEv++; return kTRUE; @@ -235,30 +304,33 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeSingleMuon() { if (fUseBransonForKinematics) fMFTTrack = fMFTTrackWithBranson; else fMFTTrack = fMFTTrackWithoutBranson; - if (fMatchTrigger && !fMFTTrack->GetMatchTrigger()) return kTRUE; + if (fMFTTrack->GetMatchTrigger() < fTriggerLevel) return kTRUE; fMCRefTrack = fMFTTrack->GetMCTrackRef(); - if (fOption!=kPionsKaons && !fMCRefTrack) return kTRUE; - if (fOption!=kPionsKaons && fMFTTrack->GetNWrongClustersMC()>fMaxNWrongClustersMC) return kTRUE; + if (fMaxNWrongClustersMC<6) { + if (!fMCRefTrack) return kTRUE; + if (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); - - TLorentzVector pMu; - Double_t mMu = TDatabasePDG::Instance()->GetParticle("mu-")->Mass(); - Double_t energy = TMath::Sqrt(param->P()*param->P() + mMu*mMu); - pMu.SetPxPyPzE(param->Px(), param->Py(), param->Pz(), energy); + fMFTTrack -> EvalKinem(fPrimaryVtxZ); TMatrixD cov(5,5); - cov = param->GetCovariances(); + cov = fMFTTrack->GetParamCovMatrix(); + + fHistXErrorSingleMuonsVsEtaVsP -> Fill(1.e4*TMath::Sqrt(cov(0,0)), fMFTTrack->Eta(), fMFTTrack->P()); + fHistYErrorSingleMuonsVsEtaVsP -> Fill(1.e4*TMath::Sqrt(cov(2,2)), fMFTTrack->Eta(), fMFTTrack->P()); + fHistXErrorSingleMuonsVsEtaVsPt -> Fill(1.e4*TMath::Sqrt(cov(0,0)), fMFTTrack->Eta(), fMFTTrack->Pt()); + fHistYErrorSingleMuonsVsEtaVsPt -> Fill(1.e4*TMath::Sqrt(cov(2,2)), fMFTTrack->Eta(), fMFTTrack->Pt()); - fHistErrorSingleMuonsX -> Fill(1.e4*TMath::Sqrt(cov(0,0))); - fHistErrorSingleMuonsY -> Fill(1.e4*TMath::Sqrt(cov(2,2))); + fHistXErrorSingleMuonsVsEtaVsP -> Fill(1.e4*TMath::Sqrt(cov(0,0)), fMFTTrack->Eta(), fMFTTrack->P()); + fHistYErrorSingleMuonsVsEtaVsP -> Fill(1.e4*TMath::Sqrt(cov(2,2)), fMFTTrack->Eta(), fMFTTrack->P()); + fHistXErrorSingleMuonsVsEtaVsPt -> Fill(1.e4*TMath::Sqrt(cov(0,0)), fMFTTrack->Eta(), fMFTTrack->Pt()); + fHistYErrorSingleMuonsVsEtaVsPt -> Fill(1.e4*TMath::Sqrt(cov(2,2)), fMFTTrack->Eta(), fMFTTrack->Pt()); Double_t dX = fMFTTrack->GetOffsetX(fPrimaryVtxX, fPrimaryVtxZ); Double_t dY = fMFTTrack->GetOffsetY(fPrimaryVtxY, fPrimaryVtxZ); @@ -268,12 +340,16 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeSingleMuon() { // AliDebug(2, Form("pdg code = %d\n", fMCRefTrack->GetPdgCode())); - fHistOffsetSingleMuonsX -> Fill(1.e4*dX); - fHistOffsetSingleMuonsY -> Fill(1.e4*dY); + fHistXOffsetSingleMuonsVsEtaVsP -> Fill(1.e4*dX, fMFTTrack->Eta(), fMFTTrack->P()); + fHistYOffsetSingleMuonsVsEtaVsP -> Fill(1.e4*dY, fMFTTrack->Eta(), fMFTTrack->P()); + fHistOffsetSingleMuonsVsEtaVsP -> Fill(1.e4*offset, fMFTTrack->Eta(), fMFTTrack->P()); + fHistWOffsetSingleMuonsVsEtaVsP -> Fill(weightedOffset, fMFTTrack->Eta(), fMFTTrack->P()); + fHistXOffsetSingleMuonsVsEtaVsPt -> Fill(1.e4*dX, fMFTTrack->Eta(), fMFTTrack->Pt()); + fHistYOffsetSingleMuonsVsEtaVsPt -> Fill(1.e4*dY, fMFTTrack->Eta(), fMFTTrack->Pt()); + fHistOffsetSingleMuonsVsEtaVsPt -> Fill(1.e4*offset, fMFTTrack->Eta(), fMFTTrack->Pt()); + fHistWOffsetSingleMuonsVsEtaVsPt -> Fill(weightedOffset, fMFTTrack->Eta(), fMFTTrack->Pt()); - if (fOption!=kPionsKaons) fHistSingleMuonsPtRapidityMC-> Fill(fMCRefTrack->Y(), fMCRefTrack->Pt()); - fHistOffsetSingleMuons -> Fill(1.e4*offset); - fHistWOffsetSingleMuons -> Fill(weightedOffset); + fHistSingleMuonsPtRapidity -> Fill(fMFTTrack->Rapidity(), fMFTTrack->Pt()); Double_t chi2OverNdf = fMFTTrack->GetGlobalChi2()/Double_t(fMFTTrack->GetNMFTClusters()+fMFTTrack->GetNMUONClusters()); fHistSingleMuonsOffsetChi2 -> Fill(1.e4*offset, chi2OverNdf); @@ -286,7 +362,7 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeSingleMuon() { //==================================================================================================================================================== -Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair() { +Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair(Int_t opt) { if (fNPairsAnalyzedOfEvent>=fNPairsOfEvent) return kFALSE; @@ -295,20 +371,13 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair() { fNPairsAnalyzedOfEvent++; - Bool_t passedCut = kFALSE; - if (fUseBransonForCut) passedCut = PassedCutMuonPair(fMFTTrackPairWithBranson); - else passedCut = PassedCutMuonPair(fMFTTrackPairWithoutBranson); - - if (!passedCut) return kTRUE; - if (fUseBransonForKinematics) fMFTTrackPair = fMFTTrackPairWithBranson; else fMFTTrackPair = fMFTTrackPairWithoutBranson; if ( fMFTTrackPair->GetTrack(0)->GetNWrongClustersMC()>fMaxNWrongClustersMC || fMFTTrackPair->GetTrack(1)->GetNWrongClustersMC()>fMaxNWrongClustersMC ) return kTRUE; - if (fOption==kResonanceOnly && !fMFTTrackPair->IsResonance()) return kTRUE; - + if (fOption==kResonanceOnly && !fMFTTrackPair->IsResonance()) return kTRUE; if (fOption==kResonanceOnly && fMFTTrackPair->GetCharge() != 0) return kTRUE; Double_t pca[3] = {0}; @@ -319,51 +388,39 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair() { fMFTTrackPair -> SetKinem(fPrimaryVtxZ); - Int_t ptBin = fPtAxisDimuons->FindBin(fMFTTrackPair->GetPt()); - - if (1<=ptBin && ptBin<=fNPtDimuBins) { - fHistMassMuonPairs[ptBin] -> Fill(fMFTTrackPair->GetMass()); - fHistMassMuonPairsWithoutMFT[ptBin] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ)); - if (fOption!=kPionsKaons) fHistMassMuonPairsMC[ptBin] -> Fill(fMFTTrackPair->GetMassMC()); - fHistWOffsetMuonPairsAtPrimaryVtx[ptBin] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ)); - fHistWOffsetMuonPairsAtPCA[ptBin] -> Fill(fMFTTrackPair->GetWeightedOffset(pca[0], pca[1], pca[2])); - fHistDistancePrimaryVtxPCA[ptBin] -> Fill(distancePrimaryVtxPCA*1.e4); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[ptBin] -> Fill(fMFTTrackPair->GetWeightedOffset(pca[0], pca[1], pca[2]), distancePrimaryVtxPCA*1.e4); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[ptBin]->Fill(pca[0]*1.e4); - fHistDimuonVtxResolutionY[ptBin]->Fill(pca[1]*1.e4); - fHistDimuonVtxResolutionZ[ptBin]->Fill(pca[2]*1.e4); - } - } - fHistMassMuonPairs[0] -> Fill(fMFTTrackPair->GetMass()); - fHistMassMuonPairsWithoutMFT[0] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ)); - if (fOption!=kPionsKaons) fHistMassMuonPairsMC[0] -> Fill(fMFTTrackPair->GetMassMC()); - fHistWOffsetMuonPairsAtPrimaryVtx[0] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ)); - fHistWOffsetMuonPairsAtPCA[0] -> Fill(fMFTTrackPair->GetWeightedOffset(pca[0], pca[1], pca[2])); - fHistDistancePrimaryVtxPCA[0] -> Fill(distancePrimaryVtxPCA*1.e4); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[0] -> Fill(fMFTTrackPair->GetWeightedOffset(pca[0], pca[1], pca[2]), distancePrimaryVtxPCA*1.e4); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[0]->Fill(pca[0]*1.e4); - fHistDimuonVtxResolutionY[0]->Fill(pca[1]*1.e4); - fHistDimuonVtxResolutionZ[0]->Fill(pca[2]*1.e4); - } + Bool_t passedCut = kFALSE; + if (fUseBransonForCut) passedCut = PassedCutMuonPair(fMFTTrackPairWithBranson); + else passedCut = PassedCutMuonPair(fMFTTrackPairWithoutBranson); + + if (!passedCut) return kTRUE; + + // --------------- Filling dimuon histograms -------------------------------- if (fMFTTrackPair->GetCharge() == 0) { - fHistMassMuonPairsVsPt -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); - fHistMassMuonPairsWithoutMFTVsPt -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); + if (fOption==kResonanceOnly && opt==kSingleEvent) fHistMassMuonPairsMCVsPt -> Fill(fMFTTrackPair->GetMassMC(), fMFTTrackPair->GetPt()); + fHistMassMuonPairsVsPt[opt] -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); + fHistMassMuonPairsWithoutMFTVsPt[opt] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[opt] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); + fHistWOffsetMuonPairsAtPCAVsPt[opt] -> Fill(fMFTTrackPair->GetWeightedOffsetAtPCA(), fMFTTrackPair->GetPt()); + fHistDistancePrimaryVtxPCAVsPt[opt] -> Fill(distancePrimaryVtxPCA*1.e4, fMFTTrackPair->GetPt()); + fHistPCAQualityVsPt[opt] -> Fill(fMFTTrackPair->GetPCAQuality(), fMFTTrackPair->GetPt()); + fHistPseudoProperDecayLengthVsPt[opt] -> Fill(GetPseudoProperDecayLength(fMFTTrackPair, fTrueMass), fMFTTrackPair->GetPt()); + if (fEvalDimuonVtxResolution && opt==kSingleEvent) { + fHistDimuonVtxResolutionXVsPt->Fill(pca[0]*1.e4, fMFTTrackPair->GetPt()); + fHistDimuonVtxResolutionYVsPt->Fill(pca[1]*1.e4, fMFTTrackPair->GetPt()); + fHistDimuonVtxResolutionZVsPt->Fill(pca[2]*1.e4, fMFTTrackPair->GetPt()); + } + fHistRapidityPtMuonPairs[opt] -> Fill(fMFTTrackPair->GetRapidity(), fMFTTrackPair->GetPt()); } else if (fMFTTrackPair->GetCharge() == -2) { - fHistMassMuonPairsVsPtLSm -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); - fHistMassMuonPairsWithoutMFTVsPtLSm -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); + fHistMassMuonPairsVsPtLSm[opt] -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); + fHistMassMuonPairsWithoutMFTVsPtLSm[opt] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); } else if (fMFTTrackPair->GetCharge() == 2) { - fHistMassMuonPairsVsPtLSp -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); - fHistMassMuonPairsWithoutMFTVsPtLSp -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); + fHistMassMuonPairsVsPtLSp[opt] -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); + fHistMassMuonPairsWithoutMFTVsPtLSp[opt] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); } - if (fOption!=kPionsKaons) fHistRapidityPtMuonPairs -> Fill(fMFTTrackPair->GetRapidityMC(), fMFTTrackPair->GetPt()); - else fHistRapidityPtMuonPairs -> Fill(fMFTTrackPair->GetRapidity(), fMFTTrackPair->GetPt()); - AliDebug(1, Form("mass = %f MC = %f", fMFTTrackPair->GetMass(), fMFTTrackPair->GetMassMC())); fNPairsAnalyzedOfEventAfterCut++; @@ -387,14 +444,79 @@ void AliMuonForwardTrackAnalysis::BuildMuonPairs() { AliMuonForwardTrack *track0_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson->At(iTrack); AliMuonForwardTrack *track1_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson->At(jTrack); - if (fMatchTrigger) if (!track0_WithBranson->GetMatchTrigger() || !track1_WithBranson->GetMatchTrigger()) continue; - if (fOption!=kPionsKaons && (!track0_WithBranson->GetMCTrackRef() || !track1_WithBranson->GetMCTrackRef())) continue; + if (track0_WithBranson->GetMatchTrigger()GetMatchTrigger()IsResonance()) { delete trackPairWithBranson; continue; } + if (fOption==kNoResonances && trackPairWithBranson->IsResonance()) { delete trackPairWithBranson; continue; } + + if (fOption==kCharmOnly && (!track0_WithBranson->IsFromCharm() || !track1_WithBranson->IsFromCharm())) { delete trackPairWithBranson; continue; } + + if (fOption==kBeautyOnly && (!track0_WithBranson->IsFromBeauty() || !track1_WithBranson->IsFromBeauty())) { delete trackPairWithBranson; continue; } + if (fOption==kBackground1mu && (!track0_WithBranson->IsFromBackground() && !track1_WithBranson->IsFromBackground())) { delete trackPairWithBranson; continue; } + if (fOption==kBackground2mu && (!track0_WithBranson->IsFromBackground() || !track1_WithBranson->IsFromBackground())) { delete trackPairWithBranson; continue; } + + delete trackPairWithBranson; + new ((*fMuonForwardTrackPairsWithBranson)[nMuonPairs]) AliMuonForwardTrackPair(track0_WithBranson, track1_WithBranson); new ((*fMuonForwardTrackPairsWithoutBranson)[nMuonPairs]) AliMuonForwardTrackPair(track0_WithoutBranson, track1_WithoutBranson); + + nMuonPairs++; - AliMuonForwardTrackPair *trackPairWithBranson = (AliMuonForwardTrackPair*) fMuonForwardTrackPairsWithBranson->At(nMuonPairs); - if (!(fOption==kResonanceOnly && !trackPairWithBranson->IsResonance())) nMuonPairs++; + } + } + +} + +//==================================================================================================================================================== + +void AliMuonForwardTrackAnalysis::BuildMuonPairsMix() { + + Int_t nMuonPairs = 0; + + for (Int_t iTrack=0; iTrackGetEntriesFast(); iTrack++) { + for (Int_t jTrack=0; jTrackGetEntriesFast(); jTrack++) { + + AliMuonForwardTrack *track0_WithBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithBranson -> At(iTrack); + AliMuonForwardTrack *track1_WithBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithBransonMix -> At(jTrack); + + AliMuonForwardTrack *track0_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson -> At(iTrack); + AliMuonForwardTrack *track1_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBransonMix -> At(jTrack); + + if (track0_WithBranson->GetMatchTrigger()GetMatchTrigger()IsResonance()) { delete trackPairWithBranson; continue; } + if (fOption==kNoResonances && trackPairWithBranson->IsResonance()) { delete trackPairWithBranson; continue; } + + if (fOption==kCharmOnly && (!track0_WithBranson->IsFromCharm() || !track1_WithBranson->IsFromCharm())) { delete trackPairWithBranson; continue; } + + if (fOption==kBeautyOnly && (!track0_WithBranson->IsFromBeauty() || !track1_WithBranson->IsFromBeauty())) { delete trackPairWithBranson; continue; } + + if (fOption==kBackground1mu && (!track0_WithBranson->IsFromBackground() && !track1_WithBranson->IsFromBackground())) { delete trackPairWithBranson; continue; } + if (fOption==kBackground2mu && (!track0_WithBranson->IsFromBackground() || !track1_WithBranson->IsFromBackground())) { delete trackPairWithBranson; continue; } + + delete trackPairWithBranson; + + new ((*fMuonForwardTrackPairsWithBranson)[nMuonPairs]) AliMuonForwardTrackPair(track0_WithBranson, track1_WithBranson); + new ((*fMuonForwardTrackPairsWithoutBranson)[nMuonPairs]) AliMuonForwardTrackPair(track0_WithoutBranson, track1_WithoutBranson); + + nMuonPairs++; } } @@ -405,20 +527,20 @@ void AliMuonForwardTrackAnalysis::BuildMuonPairs() { Bool_t AliMuonForwardTrackAnalysis::PassedCutSingleMuon(AliMuonForwardTrack *track) { - AliMUONTrackParam *param = track->GetTrackParamAtMFTCluster(0); - AliMUONTrackExtrap::ExtrapToZCov(param, fPrimaryVtxZ); - - if (track->Pt() EvalKinem(fPrimaryVtxZ); + if (track->Pt()Eta()Eta()>fMaxEtaSingleMuons) return kFALSE; - if (fCutOnOffsetChi2) { - Double_t offset = 1.e4*track->GetOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ); - Double_t chi2OverNdf = track->GetGlobalChi2() / Double_t(track->GetNMFTClusters()+track->GetNMUONClusters()); - offset /= fScaleOffset; - chi2OverNdf /= fScaleChi2; - offset -= fCenterOffset; - chi2OverNdf -= fCenterChi2; - // printf("cut on offset and chi2: returning %d\n", TMath::Sqrt(offset*offset + chi2OverNdf*chi2OverNdf)>fRadiusCut); - if (TMath::Sqrt(offset*offset + chi2OverNdf*chi2OverNdf) > fRadiusCut) return kFALSE; + Double_t offset = 1.e4*track->GetOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ); + Double_t chi2OverNdf = track->GetGlobalChi2() / Double_t(track->GetNMFTClusters()+track->GetNMUONClusters()); + offset /= fMaxOffsetSingleMuons; + chi2OverNdf /= fMaxChi2SingleMuons; + + if (fCorrelateCutOnOffsetChi2) { + if (TMath::Sqrt(offset*offset + chi2OverNdf*chi2OverNdf) > 1) return kFALSE; + } + else { + if (offset>1 || chi2OverNdf>1) return kFALSE; } return kTRUE; @@ -429,54 +551,109 @@ Bool_t AliMuonForwardTrackAnalysis::PassedCutSingleMuon(AliMuonForwardTrack *tra Bool_t AliMuonForwardTrackAnalysis::PassedCutMuonPair(AliMuonForwardTrackPair *pair) { - return PassedCutSingleMuon(pair->GetTrack(0)) && PassedCutSingleMuon(pair->GetTrack(1)); + if (!PassedCutSingleMuon(pair->GetTrack(0)) || !PassedCutSingleMuon(pair->GetTrack(1))) return kFALSE; + + if (pair->GetMass()>fMassMax || pair->GetMass()GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ) > fMaxWOffsetMuonPairsAtPrimaryVtx) return kFALSE; + if (pair->GetWeightedOffsetAtPCA() > fMaxWOffsetMuonPairsAtPCA) return kFALSE; + + Double_t pca[3] = {0}; + pair -> GetPointOfClosestApproach(pca); + Double_t distancePrimaryVtxPCA = TMath::Sqrt(TMath::Power(fPrimaryVtxX-pca[0],2)+ + TMath::Power(fPrimaryVtxY-pca[1],2)+ + TMath::Power(fPrimaryVtxZ-pca[2],2)); + + if (distancePrimaryVtxPCA > fMaxDistancePrimaryVtxPCA) return kFALSE; + if (pair->GetPCAQuality() < fMinPCAQuality) return kFALSE; + + return kTRUE; } //==================================================================================================================================================== +Double_t AliMuonForwardTrackAnalysis::GetPseudoProperDecayLength(AliMuonForwardTrackPair *pair, Double_t trueMass) { + + Double_t pca[3] = {0}; + pair -> GetPointOfClosestApproach(pca); + + TVector2 vecVertexPCA(pca[0]-fPrimaryVtxX, pca[1]-fPrimaryVtxY); + TVector2 dimuonPt(pair->GetPx(), pair->GetPy()); + TVector2 dimuonPtUnit = dimuonPt.Unit(); + + Double_t l_xy = vecVertexPCA*dimuonPtUnit; + Double_t pseudoProperDecayLength = (l_xy * trueMass / pair->GetPt()) * 1.e4 ; // in micron + + return pseudoProperDecayLength; + +} + +//==================================================================================================================================================== + void AliMuonForwardTrackAnalysis::Terminate(Char_t *outputFileName) { TFile *fileOut = new TFile(Form("%s/%s",fOutputDir.Data(),outputFileName), "recreate"); printf("Writing output objects to file %s\n", fileOut->GetName()); - fHistOffsetSingleMuonsX -> Write(); - fHistOffsetSingleMuonsY -> Write(); - fHistOffsetSingleMuons -> Write(); - fHistWOffsetSingleMuons -> Write(); - fHistErrorSingleMuonsX -> Write(); - fHistErrorSingleMuonsY -> Write(); - - fHistSingleMuonsPtRapidityMC -> Write(); - fHistSingleMuonsOffsetChi2 -> Write(); - - fHistZOriginSingleMuonsMC -> Write(); - fHistZROriginSingleMuonsMC -> Write(); - - for (Int_t iPtBin=0; iPtBin Write(); - fHistMassMuonPairsWithoutMFT[iPtBin] -> Write(); - fHistMassMuonPairsMC[iPtBin] -> Write(); - fHistWOffsetMuonPairsAtPrimaryVtx[iPtBin] -> Write(); - fHistWOffsetMuonPairsAtPCA[iPtBin] -> Write(); - fHistDistancePrimaryVtxPCA[iPtBin] -> Write(); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[iPtBin] -> Write(); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[iPtBin] -> Write(); - fHistDimuonVtxResolutionY[iPtBin] -> Write(); - fHistDimuonVtxResolutionZ[iPtBin] -> Write(); - } + // single muons + + fHistXOffsetSingleMuonsVsEtaVsP -> Write(); + fHistYOffsetSingleMuonsVsEtaVsP -> Write(); + fHistXOffsetSingleMuonsVsEtaVsPt -> Write(); + fHistYOffsetSingleMuonsVsEtaVsPt -> Write(); + + fHistXErrorSingleMuonsVsEtaVsP -> Write(); + fHistYErrorSingleMuonsVsEtaVsP -> Write(); + fHistXErrorSingleMuonsVsEtaVsPt -> Write(); + fHistYErrorSingleMuonsVsEtaVsPt -> Write(); + + fHistOffsetSingleMuonsVsEtaVsP -> Write(); + fHistOffsetSingleMuonsVsEtaVsPt -> Write(); + fHistWOffsetSingleMuonsVsEtaVsP -> Write(); + fHistWOffsetSingleMuonsVsEtaVsPt -> Write(); + + fHistSingleMuonsPtRapidity -> Write(); + fHistSingleMuonsOffsetChi2 -> Write(); + fHistZOriginSingleMuonsMC -> Write(); + fHistZROriginSingleMuonsMC -> Write(); + + // dimuons + + fHistMassMuonPairsVsPt[kSingleEvent] -> Write(); + fHistMassMuonPairsWithoutMFTVsPt[kSingleEvent] -> Write(); + fHistMassMuonPairsVsPtLSp[kSingleEvent] -> Write(); + fHistMassMuonPairsWithoutMFTVsPtLSp[kSingleEvent] -> Write(); + fHistMassMuonPairsVsPtLSm[kSingleEvent] -> Write(); + fHistMassMuonPairsWithoutMFTVsPtLSm[kSingleEvent] -> Write(); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[kSingleEvent] -> Write(); + fHistWOffsetMuonPairsAtPCAVsPt[kSingleEvent] -> Write(); + fHistDistancePrimaryVtxPCAVsPt[kSingleEvent] -> Write(); + fHistPCAQualityVsPt[kSingleEvent] -> Write(); + fHistPseudoProperDecayLengthVsPt[kSingleEvent] -> Write(); + fHistRapidityPtMuonPairs[kSingleEvent] -> Write(); + fHistMassMuonPairsMCVsPt -> Write(); + if (fEvalDimuonVtxResolution) { + fHistDimuonVtxResolutionXVsPt -> Write(); + fHistDimuonVtxResolutionYVsPt -> Write(); + fHistDimuonVtxResolutionZVsPt -> Write(); } - fHistMassMuonPairsVsPt -> Write(); - fHistMassMuonPairsWithoutMFTVsPt -> Write(); - fHistMassMuonPairsVsPtLSp -> Write(); - fHistMassMuonPairsWithoutMFTVsPtLSp -> Write(); - fHistMassMuonPairsVsPtLSm -> Write(); - fHistMassMuonPairsWithoutMFTVsPtLSm -> Write(); - - fHistRapidityPtMuonPairs -> Write(); + if (fMixing) { + fHistMassMuonPairsVsPt[kMixedEvent] -> Write(); + fHistMassMuonPairsWithoutMFTVsPt[kMixedEvent] -> Write(); + fHistMassMuonPairsVsPtLSp[kMixedEvent] -> Write(); + fHistMassMuonPairsWithoutMFTVsPtLSp[kMixedEvent] -> Write(); + fHistMassMuonPairsVsPtLSm[kMixedEvent] -> Write(); + fHistMassMuonPairsWithoutMFTVsPtLSm[kMixedEvent] -> Write(); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[kMixedEvent] -> Write(); + fHistWOffsetMuonPairsAtPCAVsPt[kMixedEvent] -> Write(); + fHistDistancePrimaryVtxPCAVsPt[kMixedEvent] -> Write(); + fHistPCAQualityVsPt[kMixedEvent] -> Write(); + fHistPseudoProperDecayLengthVsPt[kMixedEvent] -> Write(); + fHistRapidityPtMuonPairs[kMixedEvent] -> Write(); + } fileOut -> Close(); @@ -486,183 +663,202 @@ void AliMuonForwardTrackAnalysis::Terminate(Char_t *outputFileName) { void AliMuonForwardTrackAnalysis::BookHistos() { - fHistOffsetSingleMuonsX = new TH1D("fHistOffsetSingleMuonsX", "Offset for single muons along X", 200, -1000, 1000); - fHistOffsetSingleMuonsY = new TH1D("fHistOffsetSingleMuonsY", "Offset for single muons along Y", 200, -1000, 1000); - fHistErrorSingleMuonsX = new TH1D("fHistErrorSingleMuonsX", "Coordinate Error for single muons along X", 200, 0, 1000); - fHistErrorSingleMuonsY = new TH1D("fHistErrorSingleMuonsY", "Coordinate Error for single muons along Y", 200, 0, 1000); - fHistOffsetSingleMuons = new TH1D("fHistOffsetSingleMuons", "Offset for single muons", 200, 0, 2000); - fHistWOffsetSingleMuons = new TH1D("fHistWOffsetSingleMuons", "Weighted Offset for single muons", 300, 0, 15); + // -------------------- single muons + + fHistXOffsetSingleMuonsVsEtaVsP = new TH3D("fHistXOffsetSingleMuonsVsEtaVsP", "Offset for single muons along X vs #eta vs P", 200, -1000, 1000, 100, -4.5, -2., 100, 0, 100); + fHistYOffsetSingleMuonsVsEtaVsP = new TH3D("fHistYOffsetSingleMuonsVsEtaVsP", "Offset for single muons along Y vs #eta vs P", 200, -1000, 1000, 100, -4.5, -2., 100, 0, 100); + fHistXOffsetSingleMuonsVsEtaVsPt = new TH3D("fHistXOffsetSingleMuonsVsEtaVsPt", "Offset for single muons along X vs #eta vs p_{T}", 200, -1000, 1000, 100, -4.5, -2., 100, 0, 10); + fHistYOffsetSingleMuonsVsEtaVsPt = new TH3D("fHistYOffsetSingleMuonsVsEtaVsPt", "Offset for single muons along Y vs #eta vs p_{T}", 200, -1000, 1000, 100, -4.5, -2., 100, 0, 10); - fHistSingleMuonsPtRapidityMC = new TH2D("fHistSingleMuonsPtRapidityMC", "Phase Space for single muons", 100, -4.5, -2., 100, 0., 10.); + fHistXErrorSingleMuonsVsEtaVsP = new TH3D("fHistXErrorSingleMuonsVsEtaVsP", "Coordinate Error for single muons along X vs #eta vs P", 200, 0, 1000, 100, -4.5, -2., 100, 0, 100); + fHistYErrorSingleMuonsVsEtaVsP = new TH3D("fHistYErrorSingleMuonsVsEtaVsP", "Coordinate Error for single muons along Y vs #eta vs P", 200, 0, 1000, 100, -4.5, -2., 100, 0, 100); + fHistXErrorSingleMuonsVsEtaVsPt = new TH3D("fHistXErrorSingleMuonsVsEtaVsPt", "Coordinate Error for single muons along X vs #eta vs p_{T}", 200, 0, 1000, 100, -4.5, -2., 100, 0, 10); + fHistYErrorSingleMuonsVsEtaVsPt = new TH3D("fHistYErrorSingleMuonsVsEtaVsPt", "Coordinate Error for single muons along Y vs #eta vs p_{T}", 200, 0, 1000, 100, -4.5, -2., 100, 0, 10); + + fHistOffsetSingleMuonsVsEtaVsP = new TH3D("fHistOffsetSingleMuonsVsEtaVsP", "Offset for single muons vs #eta vs P", 200, 0, 2000, 100, -4.5, -2., 100, 0, 100); + fHistOffsetSingleMuonsVsEtaVsPt = new TH3D("fHistOffsetSingleMuonsVsEtaVsPt", "Offset for single muons vs #eta vs p_{T}", 200, 0, 2000, 100, -4.5, -2., 100, 0, 10); + fHistWOffsetSingleMuonsVsEtaVsP = new TH3D("fHistWOffsetSingleMuonsVsEtaVsP", "Weighted Offset for single muons vs #eta vs P", 300, 0, 15, 100, -4.5, -2., 100, 0, 100); + fHistWOffsetSingleMuonsVsEtaVsPt = new TH3D("fHistWOffsetSingleMuonsVsEtaVsPt", "Weighted Offset for single muons vs #eta vs p_{T}", 300, 0, 15, 100, -4.5, -2., 100, 0, 10); + + fHistSingleMuonsPtRapidity = new TH2D("fHistSingleMuonsPtRapidity", "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, 200, 0, 10); 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]"); - fHistErrorSingleMuonsX -> SetXTitle("Err. on track position at z_{vtx} (X) [#mum]"); - fHistErrorSingleMuonsY -> SetXTitle("Err. on track position at z_{vtx} (Y) [#mum]"); - fHistOffsetSingleMuons -> SetXTitle("Offset [#mum]"); - fHistWOffsetSingleMuons -> SetXTitle("Weighted Offset"); - - fHistSingleMuonsPtRapidityMC -> SetXTitle("y^{#mu}"); - fHistSingleMuonsPtRapidityMC -> SetYTitle("p_{T}^{#mu} [GeV/c]"); + // + + fHistXOffsetSingleMuonsVsEtaVsP -> SetXTitle("Offset(X) [#mum]"); + fHistYOffsetSingleMuonsVsEtaVsP -> SetXTitle("Offset(Y) [#mum]"); + fHistXOffsetSingleMuonsVsEtaVsPt -> SetXTitle("Offset(X) [#mum]"); + fHistYOffsetSingleMuonsVsEtaVsPt -> SetXTitle("Offset(Y) [#mum]"); + + fHistXErrorSingleMuonsVsEtaVsP -> SetXTitle("Err. on track position at z_{vtx} (X) [#mum]"); + fHistYErrorSingleMuonsVsEtaVsP -> SetXTitle("Err. on track position at z_{vtx} (Y) [#mum]"); + fHistXErrorSingleMuonsVsEtaVsPt -> SetXTitle("Err. on track position at z_{vtx} (X) [#mum]"); + fHistYErrorSingleMuonsVsEtaVsPt -> SetXTitle("Err. on track position at z_{vtx} (Y) [#mum]"); + + fHistOffsetSingleMuonsVsEtaVsP -> SetXTitle("Offset [#mum]"); + fHistOffsetSingleMuonsVsEtaVsPt -> SetXTitle("Offset [#mum]"); + fHistWOffsetSingleMuonsVsEtaVsP -> SetXTitle("Weighted Offset"); + fHistWOffsetSingleMuonsVsEtaVsPt -> SetXTitle("Weighted Offset"); + + fHistXOffsetSingleMuonsVsEtaVsP -> SetYTitle("#eta"); + fHistYOffsetSingleMuonsVsEtaVsP -> SetYTitle("#eta"); + fHistXOffsetSingleMuonsVsEtaVsPt -> SetYTitle("#eta"); + fHistYOffsetSingleMuonsVsEtaVsPt -> SetYTitle("#eta"); + + fHistXErrorSingleMuonsVsEtaVsP -> SetYTitle("#eta"); + fHistYErrorSingleMuonsVsEtaVsP -> SetYTitle("#eta"); + fHistXErrorSingleMuonsVsEtaVsPt -> SetYTitle("#eta"); + fHistYErrorSingleMuonsVsEtaVsPt -> SetYTitle("#eta"); + + fHistOffsetSingleMuonsVsEtaVsP -> SetYTitle("#eta"); + fHistOffsetSingleMuonsVsEtaVsPt -> SetYTitle("#eta"); + fHistWOffsetSingleMuonsVsEtaVsP -> SetYTitle("#eta"); + fHistWOffsetSingleMuonsVsEtaVsPt -> SetYTitle("#eta"); + + fHistXOffsetSingleMuonsVsEtaVsP -> SetZTitle("P [GeV/c]"); + fHistYOffsetSingleMuonsVsEtaVsP -> SetZTitle("P [GeV/c]"); + fHistXOffsetSingleMuonsVsEtaVsPt -> SetZTitle("p_{T} [GeV/c]"); + fHistYOffsetSingleMuonsVsEtaVsPt -> SetZTitle("p_{T} [GeV/c]"); + + fHistXErrorSingleMuonsVsEtaVsP -> SetZTitle("P [GeV/c]"); + fHistYErrorSingleMuonsVsEtaVsP -> SetZTitle("P [GeV/c]"); + fHistXErrorSingleMuonsVsEtaVsPt -> SetZTitle("p_{T} [GeV/c]"); + fHistYErrorSingleMuonsVsEtaVsPt -> SetZTitle("p_{T} [GeV/c]"); + + fHistOffsetSingleMuonsVsEtaVsP -> SetZTitle("P [GeV/c]"); + fHistOffsetSingleMuonsVsEtaVsPt -> SetZTitle("p_{T} [GeV/c]"); + fHistWOffsetSingleMuonsVsEtaVsP -> SetZTitle("P [GeV/c]"); + fHistWOffsetSingleMuonsVsEtaVsPt -> SetZTitle("p_{T} [GeV/c]"); + + fHistSingleMuonsPtRapidity -> SetXTitle("y^{#mu}"); + fHistSingleMuonsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]"); fHistSingleMuonsOffsetChi2 -> SetXTitle("Offset [#mum]"); fHistSingleMuonsOffsetChi2 -> SetYTitle("#chi^{2}/ndf"); fHistZOriginSingleMuonsMC -> SetXTitle("Z [cm]"); fHistZROriginSingleMuonsMC -> SetXTitle("Z [cm]"); - fHistZROriginSingleMuonsMC -> SetXTitle("R [cm]"); - - fHistOffsetSingleMuonsX -> Sumw2(); - fHistOffsetSingleMuonsY -> Sumw2(); - fHistErrorSingleMuonsX -> Sumw2(); - fHistErrorSingleMuonsY -> Sumw2(); - fHistOffsetSingleMuons -> Sumw2(); - fHistWOffsetSingleMuons -> Sumw2(); - - fHistZOriginSingleMuonsMC -> Sumw2(); - fHistZROriginSingleMuonsMC -> Sumw2(); - - fHistSingleMuonsPtRapidityMC -> Sumw2(); - fHistSingleMuonsOffsetChi2 -> Sumw2(); + fHistZROriginSingleMuonsMC -> SetYTitle("R [cm]"); + + // + + fHistXOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistYOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistXOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + fHistYOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + + fHistXErrorSingleMuonsVsEtaVsP -> Sumw2(); + fHistYErrorSingleMuonsVsEtaVsP -> Sumw2(); + fHistXErrorSingleMuonsVsEtaVsPt -> Sumw2(); + fHistYErrorSingleMuonsVsEtaVsPt -> Sumw2(); + + fHistOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + fHistWOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistWOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + + fHistSingleMuonsPtRapidity -> Sumw2(); + fHistSingleMuonsOffsetChi2 -> Sumw2(); + fHistZOriginSingleMuonsMC -> Sumw2(); + fHistZROriginSingleMuonsMC -> Sumw2(); + + // -------------------- muon pairs + + Int_t nBinsPt = 20; Double_t ptMin = 0., ptMax = 10.; // dimuon pt + + fHistMassMuonPairsVsPt[kSingleEvent] = new TH2D("fHistMassMuonPairsVsPt", "Dimuon Mass (MUON+MFT) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsWithoutMFTVsPt[kSingleEvent] = new TH2D("fHistMassMuonPairsWithoutMFTVsPt", "Dimuon Mass (MUON only) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsVsPtLSp[kSingleEvent] = new TH2D("fHistMassMuonPairsVsPtLSp", "Dimuon Mass (MUON+MFT) vs p_{T}^{#mu#mu} Like-Sign ++", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsWithoutMFTVsPtLSp[kSingleEvent] = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSp", "Dimuon Mass (MUON only) vs p_{T}^{#mu#mu} Like-Sign ++", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsVsPtLSm[kSingleEvent] = new TH2D("fHistMassMuonPairsVsPtLSm", "Dimuon Mass (MUON+MFT) vs p_{T}^{#mu#mu} Like-Sign --", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsWithoutMFTVsPtLSm[kSingleEvent] = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSm", "Dimuon Mass (MUON only) vs p_{T}^{#mu#mu} Like-Sign --", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[kSingleEvent] = new TH2D("fHistWOffsetMuonPairsAtPrimaryVtxVsPt", "Weighted Offset for Muon Pairs at Primary Vertex vs p_{T}^{#mu#mu}", 300, 0, 60, nBinsPt, ptMin, ptMax); + fHistWOffsetMuonPairsAtPCAVsPt[kSingleEvent] = new TH2D("fHistWOffsetMuonPairsAtPCAVsPt", "Weighted Offset for Muon Pairs at PCA vs p_{T}^{#mu#mu}", 300, 0, 60, nBinsPt, ptMin, ptMax); + fHistDistancePrimaryVtxPCAVsPt[kSingleEvent] = new TH2D("fHistDistancePrimaryVtxPCAVsPt", "Distance between PCA and primary vertex vs p_{T}^{#mu#mu}", 1000, 0, 50000, nBinsPt, ptMin, ptMax); + fHistPCAQualityVsPt[kSingleEvent] = new TH2D("fHistPCAQualityVsPt", "PCA Quality vs p_{T}^{#mu#mu}", 200, 0, 1, nBinsPt, ptMin, ptMax); + fHistPseudoProperDecayLengthVsPt[kSingleEvent] = new TH2D("fHistPseudoProperDecayLengthVsPt", "Pseudo proper decay length vs p_{T}^{#mu#mu}", 1000, -5000, 5000, nBinsPt, ptMin, ptMax); + + fHistMassMuonPairsVsPt[kMixedEvent] = new TH2D("fHistMassMuonPairsVsPtMix", "Dimuon Mass Mix (MUON+MFT) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsWithoutMFTVsPt[kMixedEvent] = new TH2D("fHistMassMuonPairsWithoutMFTVsPtMix", "Dimuon Mass Mix (MUON only) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsVsPtLSp[kMixedEvent] = new TH2D("fHistMassMuonPairsVsPtLSpMix", "Dimuon Mass Mix (MUON+MFT) vs p_{T}^{#mu#mu} Like-Sign ++", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsWithoutMFTVsPtLSp[kMixedEvent] = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSpMix", "Dimuon Mass Mix (MUON only) vs p_{T}^{#mu#mu} Like-Sign ++", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsVsPtLSm[kMixedEvent] = new TH2D("fHistMassMuonPairsVsPtLSmMix", "Dimuon Mass Mix (MUON+MFT) vs p_{T}^{#mu#mu} Like-Sign --", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistMassMuonPairsWithoutMFTVsPtLSm[kMixedEvent] = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSmMix", "Dimuon Mass Mix (MUON only) vs p_{T}^{#mu#mu} Like-Sign --", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[kMixedEvent] = new TH2D("fHistWOffsetMuonPairsAtPrimaryVtxVsPtMix", "Weighted Offset for Muon Pairs Mix at Primary Vertex vs p_{T}^{#mu#mu}", 300, 0, 60, nBinsPt, ptMin, ptMax); + fHistWOffsetMuonPairsAtPCAVsPt[kMixedEvent] = new TH2D("fHistWOffsetMuonPairsAtPCAVsPtMix", "Weighted Offset for Muon Pairs Mix at PCA vs p_{T}^{#mu#mu}", 300, 0, 60, nBinsPt, ptMin, ptMax); + fHistDistancePrimaryVtxPCAVsPt[kMixedEvent] = new TH2D("fHistDistancePrimaryVtxPCAVsPtMix", "Distance between PCA and primary vertex Mix vs p_{T}^{#mu#mu}", 1000, 0, 50000, nBinsPt, ptMin, ptMax); + fHistPCAQualityVsPt[kMixedEvent] = new TH2D("fHistPCAQualityVsPtMix", "PCA Quality Mix vs p_{T}^{#mu#mu}", 200, 0, 1, nBinsPt, ptMin, ptMax); + fHistPseudoProperDecayLengthVsPt[kMixedEvent] = new TH2D("fHistPseudoProperDecayLengthVsPtMix", "Pseudo proper decay length Mix vs p_{T}^{#mu#mu}", 1000, -5000, 5000, nBinsPt, ptMin, ptMax); + + fHistMassMuonPairsMCVsPt = new TH2D("fHistMassMuonPairsMCVsPt", "Dimuon Mass (MC) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); + fHistDimuonVtxResolutionXVsPt = new TH2D("fHistDimuonVtxResolutionXVsPt", "Dimuon Vtx offset along X w.r.t. true Vtx vs p_{T}^{#mu#mu}", 2000, -1000, 1000, nBinsPt, ptMin, ptMax); + fHistDimuonVtxResolutionYVsPt = new TH2D("fHistDimuonVtxResolutionYVsPt", "Dimuon Vtx offset along Y w.r.t. true Vtx vs p_{T}^{#mu#mu}", 2000, -1000, 1000, nBinsPt, ptMin, ptMax); + fHistDimuonVtxResolutionZVsPt = new TH2D("fHistDimuonVtxResolutionZVsPt", "Dimuon Vtx offset along Z w.r.t. true Vtx vs p_{T}^{#mu#mu}", 2000, -1000, 1000, nBinsPt, ptMin, ptMax); - //-------------------------------------------- - - for (Int_t iPtBin=0; iPtBin<=fNPtDimuBins+1; iPtBin++) { - - if (!iPtBin) { - 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); - fHistWOffsetMuonPairsAtPrimaryVtx[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairsAtPrimaryVtx_%d",iPtBin), - "Weighted Offset for Muon Pairs at Primary Vertex (All p_{T}^{#mu#mu})", - 300, 0, 60); - fHistWOffsetMuonPairsAtPCA[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairsAtPCA_%d",iPtBin), - "Weighted Offset for Muon Pairs at PCA (All p_{T}^{#mu#mu})", - 300, 0, 60); - fHistDistancePrimaryVtxPCA[iPtBin] = new TH1D(Form("fHistDistancePrimaryVtxPCA_%d",iPtBin), - "Distance between PCA and primary vertex (All p_{T}^{#mu#mu})", - 1000, 0, 50000); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[iPtBin] = new TH2D(Form("fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA_%d",iPtBin), - "DistancePrimaryVtxPCA vs WOffsetMuonPairsAtPCA (All p_{T}^{#mu#mu})", - 300, 0, 60, 1000, 0, 50000); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[iPtBin] = new TH1D(Form("fHistDimuonVtxResolutionX_%d",iPtBin), - "Dimuon Vtx offset along X (All p_{T}^{#mu#mu})", - 2000, -1000, 1000); - fHistDimuonVtxResolutionY[iPtBin] = new TH1D(Form("fHistDimuonVtxResolutionY_%d",iPtBin), - "Dimuon Vtx offset along Y (All p_{T}^{#mu#mu})", - 2000, -1000, 1000); - fHistDimuonVtxResolutionZ[iPtBin] = new TH1D(Form("fHistDimuonVtxResolutionZ_%d",iPtBin), - "Dimuon Vtx offset along Z (All p_{T}^{#mu#mu})", - 2000, -10000, 10000); - } - } - - else { - Double_t ptMin = fPtAxisDimuons->GetBinLowEdge(iPtBin); - Double_t ptMax = fPtAxisDimuons->GetBinUpEdge(iPtBin); - 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); - fHistWOffsetMuonPairsAtPrimaryVtx[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairsAtPrimaryVtx_%d",iPtBin), - Form("Weighted Offset for Muon Pairs at Primary Vertex (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)", - ptMin,ptMax), 300, 0, 60); - fHistWOffsetMuonPairsAtPCA[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairsAtPCA_%d",iPtBin), - Form("Weighted Offset for Muon Pairs at PCA (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)", - ptMin,ptMax), 300, 0, 60); - fHistDistancePrimaryVtxPCA[iPtBin] = new TH1D(Form("fHistDistancePrimaryVtxPCA_%d",iPtBin), - Form("Distance between PCA and primary vertex (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)", - ptMin,ptMax), 1000, 0, 50000); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[iPtBin] = new TH2D(Form("fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA_%d",iPtBin), - Form("DistancePrimaryVtxPCA vs WOffsetMuonPairsAtPCA (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)", - ptMin,ptMax), 300, 0, 60, 1000, 0, 50000); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[iPtBin] = new TH1D(Form("fHistDimuonVtxResolutionX_%d",iPtBin), - Form("Dimuon Vtx offset along X (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax), - 2000, -1000, 1000); - fHistDimuonVtxResolutionY[iPtBin] = new TH1D(Form("fHistDimuonVtxResolutionY_%d",iPtBin), - Form("Dimuon Vtx offset along Y (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax), - 2000, -1000, 1000); - fHistDimuonVtxResolutionZ[iPtBin] = new TH1D(Form("fHistDimuonVtxResolutionZ_%d",iPtBin), - Form("Dimuon Vtx offset along Z (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax), - 2000, -10000, 10000); - } - } - - fHistMassMuonPairs[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFT[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsMC[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]"); - fHistWOffsetMuonPairsAtPrimaryVtx[iPtBin] -> SetXTitle("Weighted Offset at Primary Vtx"); - fHistWOffsetMuonPairsAtPCA[iPtBin] -> SetXTitle("Weighted Offset at PCA"); - fHistDistancePrimaryVtxPCA[iPtBin] -> SetXTitle("PCA - Primary Vtx [#mum]"); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[iPtBin] -> SetXTitle("Weighted Offset at PCA"); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[iPtBin] -> SetYTitle("PCA - Primary Vtx [#mum]"); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[iPtBin] -> SetXTitle("Offset [#mum]"); - fHistDimuonVtxResolutionY[iPtBin] -> SetXTitle("Offset [#mum]"); - fHistDimuonVtxResolutionZ[iPtBin] -> SetXTitle("Offset [#mum]"); - } - - fHistMassMuonPairs[iPtBin] -> Sumw2(); - fHistMassMuonPairsWithoutMFT[iPtBin] -> Sumw2(); - fHistMassMuonPairsMC[iPtBin] -> Sumw2(); - fHistWOffsetMuonPairsAtPrimaryVtx[iPtBin] -> Sumw2(); - fHistWOffsetMuonPairsAtPCA[iPtBin] -> Sumw2(); - fHistDistancePrimaryVtxPCA[iPtBin] -> Sumw2(); - fHistDistancePrimaryVtxPCAvsWOffsetMuonPairsAtPCA[iPtBin] -> Sumw2(); - if (fEvalDimuonVtxResolution) { - fHistDimuonVtxResolutionX[iPtBin] -> Sumw2(); - fHistDimuonVtxResolutionY[iPtBin] -> Sumw2(); - fHistDimuonVtxResolutionZ[iPtBin] -> Sumw2(); - } - + for (Int_t i=0; i<2; i++) { + fHistMassMuonPairsVsPt[i] -> SetXTitle("Mass [GeV/c^{2}]"); + fHistMassMuonPairsWithoutMFTVsPt[i] -> SetXTitle("Mass [GeV/c^{2}]"); + fHistMassMuonPairsVsPtLSp[i] -> SetXTitle("Mass [GeV/c^{2}]"); + fHistMassMuonPairsWithoutMFTVsPtLSp[i] -> SetXTitle("Mass [GeV/c^{2}]"); + fHistMassMuonPairsVsPtLSm[i] -> SetXTitle("Mass [GeV/c^{2}]"); + fHistMassMuonPairsWithoutMFTVsPtLSm[i] -> SetXTitle("Mass [GeV/c^{2}]"); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[i] -> SetXTitle("Weighted Offset at Primary Vtx"); + fHistWOffsetMuonPairsAtPCAVsPt[i] -> SetXTitle("Weighted Offset at PCA"); + fHistDistancePrimaryVtxPCAVsPt[i] -> SetXTitle("PCA - Primary Vtx [#mum]"); + fHistPCAQualityVsPt[i] -> SetXTitle("PCA Quality"); + fHistPseudoProperDecayLengthVsPt[i] -> SetXTitle("l_{xy} [#mum]"); } - - fHistMassMuonPairsVsPt = new TH2D("fHistMassMuonPairsVsPt", "Dimuon Mass (MUON+MFT) vs p_{T}", fNMassBins, fMassMin, fMassMax, 20, 0., 10.); - fHistMassMuonPairsWithoutMFTVsPt = new TH2D("fHistMassMuonPairsWithoutMFTVsPt", "Dimuon Mass (MUON only) vs p_{T}", fNMassBins, fMassMin, fMassMax, 20, 0., 10.); - fHistMassMuonPairsVsPtLSp = new TH2D("fHistMassMuonPairsVsPtLSp", "Dimuon Mass (MUON+MFT) vs p_{T} Like sign ++", fNMassBins, fMassMin, fMassMax, 20, 0., 10.); - fHistMassMuonPairsWithoutMFTVsPtLSp = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSp", "Dimuon Mass (MUON only) vs p_{T} Like sign ++", fNMassBins, fMassMin, fMassMax, 20, 0., 10.); - fHistMassMuonPairsVsPtLSm = new TH2D("fHistMassMuonPairsVsPtLSm", "Dimuon Mass (MUON+MFT) vs p_{T} Like sign --", fNMassBins, fMassMin, fMassMax, 20, 0., 10.); - fHistMassMuonPairsWithoutMFTVsPtLSm = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSm", "Dimuon Mass (MUON only) vs p_{T} Like sign --", fNMassBins, fMassMin, fMassMax, 20, 0., 10.); - - fHistMassMuonPairsVsPt -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFTVsPt -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsWithoutMFTVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsVsPt -> Sumw2(); - fHistMassMuonPairsWithoutMFTVsPt -> Sumw2(); - fHistMassMuonPairsVsPtLSp -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFTVsPtLSp -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsVsPtLSp -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsWithoutMFTVsPtLSp -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsVsPtLSp -> Sumw2(); - fHistMassMuonPairsWithoutMFTVsPtLSp -> Sumw2(); - fHistMassMuonPairsVsPtLSm -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFTVsPtLSm -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsVsPtLSm -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsWithoutMFTVsPtLSm -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsVsPtLSm -> Sumw2(); - fHistMassMuonPairsWithoutMFTVsPtLSm -> 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(); + fHistMassMuonPairsMCVsPt -> SetXTitle("Mass [GeV/c^{2}]"); + fHistDimuonVtxResolutionXVsPt -> SetXTitle("Offset [#mum]"); + fHistDimuonVtxResolutionYVsPt -> SetXTitle("Offset [#mum]"); + fHistDimuonVtxResolutionZVsPt -> SetXTitle("Offset [#mum]"); + + for (Int_t i=0; i<2; i++) { + fHistMassMuonPairsVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistMassMuonPairsWithoutMFTVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistMassMuonPairsVsPtLSp[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistMassMuonPairsWithoutMFTVsPtLSp[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistMassMuonPairsVsPtLSm[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistMassMuonPairsWithoutMFTVsPtLSm[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistWOffsetMuonPairsAtPCAVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistDistancePrimaryVtxPCAVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistPCAQualityVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + fHistPseudoProperDecayLengthVsPt[i] -> SetYTitle("p_{T} [GeV/c]"); + } + fHistMassMuonPairsMCVsPt -> SetYTitle("p_{T} [GeV/c]"); + fHistDimuonVtxResolutionXVsPt -> SetYTitle("p_{T} [GeV/c]"); + fHistDimuonVtxResolutionYVsPt -> SetYTitle("p_{T} [GeV/c]"); + fHistDimuonVtxResolutionZVsPt -> SetYTitle("p_{T} [GeV/c]"); + + for (Int_t i=0; i<2; i++) { + fHistMassMuonPairsVsPt[i] -> Sumw2(); + fHistMassMuonPairsWithoutMFTVsPt[i] -> Sumw2(); + fHistMassMuonPairsVsPtLSp[i] -> Sumw2(); + fHistMassMuonPairsWithoutMFTVsPtLSp[i] -> Sumw2(); + fHistMassMuonPairsVsPtLSm[i] -> Sumw2(); + fHistMassMuonPairsWithoutMFTVsPtLSm[i] -> Sumw2(); + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[i] -> Sumw2(); + fHistWOffsetMuonPairsAtPCAVsPt[i] -> Sumw2(); + fHistDistancePrimaryVtxPCAVsPt[i] -> Sumw2(); + fHistPCAQualityVsPt[i] -> Sumw2(); + fHistPseudoProperDecayLengthVsPt[i] -> Sumw2(); + } + fHistMassMuonPairsMCVsPt -> Sumw2(); + fHistDimuonVtxResolutionXVsPt -> Sumw2(); + fHistDimuonVtxResolutionYVsPt -> Sumw2(); + fHistDimuonVtxResolutionZVsPt -> Sumw2(); + + fHistRapidityPtMuonPairs[kSingleEvent] = new TH2D("fHistRapidityPtMuonPairs", "Dimuon Phase Space (rec)", 20, -4.5, -2., 20, 0., 10.); + fHistRapidityPtMuonPairs[kSingleEvent] -> SetXTitle("Rapidity"); + fHistRapidityPtMuonPairs[kSingleEvent] -> SetYTitle("p_{T} [GeV/c]"); + fHistRapidityPtMuonPairs[kSingleEvent] -> Sumw2(); + + fHistRapidityPtMuonPairs[kMixedEvent] = new TH2D("fHistRapidityPtMuonPairsMix", "Dimuon Phase Space (rec)", 20, -4.5, -2., 20, 0., 10.); + fHistRapidityPtMuonPairs[kMixedEvent] -> SetXTitle("Rapidity"); + fHistRapidityPtMuonPairs[kMixedEvent] -> SetYTitle("p_{T} [GeV/c]"); + fHistRapidityPtMuonPairs[kMixedEvent] -> Sumw2(); }