X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MFT%2FAliMuonForwardTrackAnalysis.cxx;h=ad3cfd10140939b2b0ec83c828ed6e47ba1f7d2d;hb=1e2f6079da524992e3c7792ebe1ac258a008aa0f;hp=65c9bd8cf26f349cf53a68c84d1ea24915dd4fe0;hpb=cabfe25ba7e600d86db05bf247a6ea4714257647;p=u%2Fmrichter%2FAliRoot.git diff --git a/MFT/AliMuonForwardTrackAnalysis.cxx b/MFT/AliMuonForwardTrackAnalysis.cxx index 65c9bd8cf26..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,29 +61,23 @@ 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), fHistSingleMuonsPtRapidity(0x0), fHistSingleMuonsOffsetChi2(0x0), - fHistRapidityPtMuonPairs(0x0), fHistMassMuonPairsMCVsPt(0x0), - fHistMassMuonPairsVsPt(0x0), - fHistMassMuonPairsWithoutMFTVsPt(0x0), - fHistMassMuonPairsVsPtLSp(0x0), - fHistMassMuonPairsWithoutMFTVsPtLSp(0x0), - fHistMassMuonPairsVsPtLSm(0x0), - fHistMassMuonPairsWithoutMFTVsPtLSm(0x0), - fHistWOffsetMuonPairsAtPrimaryVtxVsPt(0x0), - fHistWOffsetMuonPairsAtPCAVsPt(0x0), - fHistDistancePrimaryVtxPCAVsPt(0x0), - fHistPCAQualityVsPt(0x0), - fHistPseudoProperDecayLengthVsPt(0x0), fHistDimuonVtxResolutionXVsPt(0x0), fHistDimuonVtxResolutionYVsPt(0x0), fHistDimuonVtxResolutionZVsPt(0x0), @@ -96,7 +95,9 @@ AliMuonForwardTrackAnalysis::AliMuonForwardTrackAnalysis(): fPrimaryVtxY(0.), fPrimaryVtxZ(0.), fMaxNWrongClustersMC(999), - fPtMinSingleMuons(0), + fMinPtSingleMuons(0), + fMinEtaSingleMuons(-99999.), + fMaxEtaSingleMuons(+99999.), fUseBransonForCut(kFALSE), fUseBransonForKinematics(kFALSE), fCorrelateCutOnOffsetChi2(kFALSE), @@ -105,11 +106,28 @@ AliMuonForwardTrackAnalysis::AliMuonForwardTrackAnalysis(): fMaxWOffsetMuonPairsAtPrimaryVtx(1.e9), fMaxWOffsetMuonPairsAtPCA(1.e9), fMaxDistancePrimaryVtxPCA(1.e9), - fMinPCAQuality(0.) + fMinPCAQuality(0.), + fMixing(kFALSE), + fNEventsToMix(10) { // default constructor + for (Int_t i=0; i<2; i++) { + fHistRapidityPtMuonPairs[i] = 0; + fHistMassMuonPairsVsPt[i] = 0; + fHistMassMuonPairsWithoutMFTVsPt[i] = 0; + fHistMassMuonPairsVsPtLSp[i] = 0; + fHistMassMuonPairsWithoutMFTVsPtLSp[i] = 0; + fHistMassMuonPairsVsPtLSm[i] = 0; + fHistMassMuonPairsWithoutMFTVsPtLSm[i] = 0; + fHistWOffsetMuonPairsAtPrimaryVtxVsPt[i] = 0; + fHistWOffsetMuonPairsAtPCAVsPt[i] = 0; + fHistDistancePrimaryVtxPCAVsPt[i] = 0; + fHistPCAQualityVsPt[i] = 0; + fHistPseudoProperDecayLengthVsPt[i] = 0; + } + } //==================================================================================================================================================== @@ -117,62 +135,69 @@ AliMuonForwardTrackAnalysis::AliMuonForwardTrackAnalysis(): Bool_t AliMuonForwardTrackAnalysis::Init(Char_t *inputFileName) { BookHistos(); - + TFile *inputFile = new TFile(Form("%s/%s",fInputDir.Data(),inputFileName)); if (!inputFile || !inputFile->IsOpen()) { 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); 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)); @@ -189,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; + 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; @@ -239,19 +317,20 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeSingleMuon() { 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); @@ -261,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()); - fHistSingleMuonsPtRapidity -> Fill(pMu.Rapidity(), pMu.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); @@ -279,7 +362,7 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeSingleMuon() { //==================================================================================================================================================== -Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair() { +Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair(Int_t opt) { if (fNPairsAnalyzedOfEvent>=fNPairsOfEvent) return kFALSE; @@ -314,28 +397,28 @@ Bool_t AliMuonForwardTrackAnalysis::AnalyzeMuonPair() { // --------------- Filling dimuon histograms -------------------------------- if (fMFTTrackPair->GetCharge() == 0) { - if (fOption==kResonanceOnly) fHistMassMuonPairsMCVsPt -> Fill(fMFTTrackPair->GetMassMC(), fMFTTrackPair->GetPt()); - fHistMassMuonPairsVsPt -> Fill(fMFTTrackPair->GetMass(), fMFTTrackPair->GetPt()); - fHistMassMuonPairsWithoutMFTVsPt -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); - fHistWOffsetMuonPairsAtPrimaryVtxVsPt -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ), fMFTTrackPair->GetPt()); - fHistWOffsetMuonPairsAtPCAVsPt -> Fill(fMFTTrackPair->GetWeightedOffsetAtPCA(), fMFTTrackPair->GetPt()); - fHistDistancePrimaryVtxPCAVsPt -> Fill(distancePrimaryVtxPCA*1.e4, fMFTTrackPair->GetPt()); - fHistPCAQualityVsPt -> Fill(fMFTTrackPair->GetPCAQuality(), fMFTTrackPair->GetPt()); - if (fOption==kResonanceOnly) fHistPseudoProperDecayLengthVsPt->Fill(GetPseudoProperDecayLength(fMFTTrackPair, fTrueMass), fMFTTrackPair->GetPt()); - if (fEvalDimuonVtxResolution) { + 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 -> Fill(fMFTTrackPair->GetRapidityMC(), 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()); } AliDebug(1, Form("mass = %f MC = %f", fMFTTrackPair->GetMass(), fMFTTrackPair->GetMassMC())); @@ -363,11 +446,77 @@ void AliMuonForwardTrackAnalysis::BuildMuonPairs() { 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++; + + } + } + +} + +//==================================================================================================================================================== + +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); - AliMuonForwardTrackPair *trackPairWithBranson = (AliMuonForwardTrackPair*) fMuonForwardTrackPairsWithBranson->At(nMuonPairs); - if (!(fOption==kResonanceOnly && !trackPairWithBranson->IsResonance())) nMuonPairs++; + 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++; } } @@ -378,10 +527,9 @@ 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; Double_t offset = 1.e4*track->GetOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ); Double_t chi2OverNdf = track->GetGlobalChi2() / Double_t(track->GetNMFTClusters()+track->GetNMUONClusters()); @@ -432,9 +580,9 @@ Double_t AliMuonForwardTrackAnalysis::GetPseudoProperDecayLength(AliMuonForwardT TVector2 vecVertexPCA(pca[0]-fPrimaryVtxX, pca[1]-fPrimaryVtxY); TVector2 dimuonPt(pair->GetPx(), pair->GetPy()); - dimuonPt.Unit(); + TVector2 dimuonPtUnit = dimuonPt.Unit(); - Double_t l_xy = vecVertexPCA*dimuonPt; + Double_t l_xy = vecVertexPCA*dimuonPtUnit; Double_t pseudoProperDecayLength = (l_xy * trueMass / pair->GetPt()) * 1.e4 ; // in micron return pseudoProperDecayLength; @@ -449,36 +597,63 @@ void AliMuonForwardTrackAnalysis::Terminate(Char_t *outputFileName) { printf("Writing output objects to file %s\n", fileOut->GetName()); - fHistOffsetSingleMuonsX -> Write(); - fHistOffsetSingleMuonsY -> Write(); - fHistErrorSingleMuonsX -> Write(); - fHistErrorSingleMuonsY -> Write(); - fHistOffsetSingleMuons -> Write(); - fHistWOffsetSingleMuons -> Write(); - - fHistSingleMuonsPtRapidity -> Write(); - fHistSingleMuonsOffsetChi2 -> Write(); - fHistZOriginSingleMuonsMC -> Write(); - fHistZROriginSingleMuonsMC -> Write(); - - fHistMassMuonPairsVsPt -> Write(); - fHistMassMuonPairsWithoutMFTVsPt -> Write(); - fHistMassMuonPairsVsPtLSp -> Write(); - fHistMassMuonPairsWithoutMFTVsPtLSp -> Write(); - fHistMassMuonPairsVsPtLSm -> Write(); - fHistMassMuonPairsWithoutMFTVsPtLSm -> Write(); - fHistMassMuonPairsMCVsPt -> Write(); - fHistWOffsetMuonPairsAtPrimaryVtxVsPt -> Write(); - fHistWOffsetMuonPairsAtPCAVsPt -> Write(); - fHistDistancePrimaryVtxPCAVsPt -> Write(); - fHistPCAQualityVsPt -> Write(); - if (fOption==kResonanceOnly) fHistPseudoProperDecayLengthVsPt->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(); } - 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(); @@ -490,24 +665,72 @@ void AliMuonForwardTrackAnalysis::BookHistos() { // -------------------- single muons - 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); + 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); + + 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"); + // + + 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]"); @@ -516,92 +739,126 @@ void AliMuonForwardTrackAnalysis::BookHistos() { fHistZOriginSingleMuonsMC -> SetXTitle("Z [cm]"); fHistZROriginSingleMuonsMC -> SetXTitle("Z [cm]"); - fHistZROriginSingleMuonsMC -> SetXTitle("R [cm]"); + fHistZROriginSingleMuonsMC -> SetYTitle("R [cm]"); + + // + + fHistXOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistYOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistXOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + fHistYOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + + fHistXErrorSingleMuonsVsEtaVsP -> Sumw2(); + fHistYErrorSingleMuonsVsEtaVsP -> Sumw2(); + fHistXErrorSingleMuonsVsEtaVsPt -> Sumw2(); + fHistYErrorSingleMuonsVsEtaVsPt -> Sumw2(); - fHistOffsetSingleMuonsX -> Sumw2(); - fHistOffsetSingleMuonsY -> Sumw2(); - fHistErrorSingleMuonsX -> Sumw2(); - fHistErrorSingleMuonsY -> Sumw2(); - fHistOffsetSingleMuons -> Sumw2(); - fHistWOffsetSingleMuons -> Sumw2(); + fHistOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistOffsetSingleMuonsVsEtaVsPt -> Sumw2(); + fHistWOffsetSingleMuonsVsEtaVsP -> Sumw2(); + fHistWOffsetSingleMuonsVsEtaVsPt -> Sumw2(); - fHistSingleMuonsPtRapidity -> Sumw2(); - fHistSingleMuonsOffsetChi2 -> Sumw2(); - fHistZOriginSingleMuonsMC -> Sumw2(); - fHistZROriginSingleMuonsMC -> Sumw2(); + fHistSingleMuonsPtRapidity -> Sumw2(); + fHistSingleMuonsOffsetChi2 -> Sumw2(); + fHistZOriginSingleMuonsMC -> Sumw2(); + fHistZROriginSingleMuonsMC -> Sumw2(); // -------------------- muon pairs Int_t nBinsPt = 20; Double_t ptMin = 0., ptMax = 10.; // dimuon pt - fHistMassMuonPairsVsPt = new TH2D("fHistMassMuonPairsVsPt", "Dimuon Mass (MUON+MFT) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistMassMuonPairsWithoutMFTVsPt = new TH2D("fHistMassMuonPairsWithoutMFTVsPt", "Dimuon Mass (MUON only) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistMassMuonPairsVsPtLSp = new TH2D("fHistMassMuonPairsVsPtLSp", "Dimuon Mass (MUON+MFT) vs p_{T}^{#mu#mu} Like-Sign ++", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistMassMuonPairsWithoutMFTVsPtLSp = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSp", "Dimuon Mass (MUON only) vs p_{T}^{#mu#mu} Like-Sign ++", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistMassMuonPairsVsPtLSm = new TH2D("fHistMassMuonPairsVsPtLSm", "Dimuon Mass (MUON+MFT) vs p_{T}^{#mu#mu} Like-Sign --", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistMassMuonPairsWithoutMFTVsPtLSm = new TH2D("fHistMassMuonPairsWithoutMFTVsPtLSm", "Dimuon Mass (MUON only) vs p_{T}^{#mu#mu} Like-Sign --", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistMassMuonPairsMCVsPt = new TH2D("fHistMassMuonPairsMCVsPt", "Dimuon Mass (MC) vs p_{T}^{#mu#mu}", 1000, 0, 10, nBinsPt, ptMin, ptMax); - fHistWOffsetMuonPairsAtPrimaryVtxVsPt = new TH2D("fHistWOffsetMuonPairsAtPrimaryVtxVsPt", "Weighted Offset for Muon Pairs at Primary Vertex vs p_{T}^{#mu#mu}", 300, 0, 60, nBinsPt, ptMin, ptMax); - fHistWOffsetMuonPairsAtPCAVsPt = new TH2D("fHistWOffsetMuonPairsAtPCAVsPt", "Weighted Offset for Muon Pairs at PCA vs p_{T}^{#mu#mu}", 300, 0, 60, nBinsPt, ptMin, ptMax); - fHistDistancePrimaryVtxPCAVsPt = new TH2D("fHistDistancePrimaryVtxPCA_%d", "Distance between PCA and primary vertex vs p_{T}^{#mu#mu}", 1000, 0, 50000, nBinsPt, ptMin, ptMax); - fHistPCAQualityVsPt = new TH2D("fHistPCAQualityVsPt", "PCA Quality vs p_{T}^{#mu#mu}", 200, 0, 1, nBinsPt, ptMin, ptMax); - fHistPseudoProperDecayLengthVsPt = new TH2D("fHistPseudoProperDecayLengthVsPt", "Pseudo proper decay length vs p_{T}^{#mu#mu}", 1000, -5000, 5000, nBinsPt, ptMin, ptMax); + 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); - fHistMassMuonPairsVsPt -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFTVsPt -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsVsPtLSp -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFTVsPtLSp -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsVsPtLSm -> SetXTitle("Mass [GeV/c^{2}]"); - fHistMassMuonPairsWithoutMFTVsPtLSm -> SetXTitle("Mass [GeV/c^{2}]"); + 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]"); + } fHistMassMuonPairsMCVsPt -> SetXTitle("Mass [GeV/c^{2}]"); - fHistWOffsetMuonPairsAtPrimaryVtxVsPt -> SetXTitle("Weighted Offset at Primary Vtx"); - fHistWOffsetMuonPairsAtPCAVsPt -> SetXTitle("Weighted Offset at PCA"); - fHistDistancePrimaryVtxPCAVsPt -> SetXTitle("PCA - Primary Vtx [#mum]"); - fHistPCAQualityVsPt -> SetXTitle("PCA Quality"); - fHistPseudoProperDecayLengthVsPt -> SetXTitle("l_{xy} [#mum]"); fHistDimuonVtxResolutionXVsPt -> SetXTitle("Offset [#mum]"); fHistDimuonVtxResolutionYVsPt -> SetXTitle("Offset [#mum]"); fHistDimuonVtxResolutionZVsPt -> SetXTitle("Offset [#mum]"); - fHistMassMuonPairsVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsWithoutMFTVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsVsPtLSp -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsWithoutMFTVsPtLSp -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsVsPtLSm -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsWithoutMFTVsPtLSm -> SetYTitle("p_{T} [GeV/c]"); + 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]"); - fHistWOffsetMuonPairsAtPrimaryVtxVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistWOffsetMuonPairsAtPCAVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistDistancePrimaryVtxPCAVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistPCAQualityVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistPseudoProperDecayLengthVsPt -> SetYTitle("p_{T} [GeV/c]"); fHistDimuonVtxResolutionXVsPt -> SetYTitle("p_{T} [GeV/c]"); fHistDimuonVtxResolutionYVsPt -> SetYTitle("p_{T} [GeV/c]"); fHistDimuonVtxResolutionZVsPt -> SetYTitle("p_{T} [GeV/c]"); - fHistMassMuonPairsVsPt -> Sumw2(); - fHistMassMuonPairsWithoutMFTVsPt -> Sumw2(); - fHistMassMuonPairsVsPtLSp -> Sumw2(); - fHistMassMuonPairsWithoutMFTVsPtLSp -> Sumw2(); - fHistMassMuonPairsVsPtLSm -> Sumw2(); - fHistMassMuonPairsWithoutMFTVsPtLSm -> Sumw2(); + 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(); - fHistWOffsetMuonPairsAtPrimaryVtxVsPt -> Sumw2(); - fHistWOffsetMuonPairsAtPCAVsPt -> Sumw2(); - fHistDistancePrimaryVtxPCAVsPt -> Sumw2(); - fHistPCAQualityVsPt -> Sumw2(); - fHistPseudoProperDecayLengthVsPt -> Sumw2(); fHistDimuonVtxResolutionXVsPt -> Sumw2(); fHistDimuonVtxResolutionYVsPt -> Sumw2(); fHistDimuonVtxResolutionZVsPt -> Sumw2(); - fHistRapidityPtMuonPairs = new TH2D("fHistRapidityPtMuonPairs", "Dimuon Phase Space (rec)", 20, -4.5, -2., 20, 0., 10.); - fHistRapidityPtMuonPairs -> SetXTitle("Rapidity"); - fHistRapidityPtMuonPairs -> SetYTitle("p_{T} [GeV/c]"); - fHistRapidityPtMuonPairs -> 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(); }