TObject(),
fInputDir(0),
fOutputDir(0),
- fInputTree(0),
- fMuonForwardTracks(0),
- fMuonForwardTrackPairs(0),
+ fInputTreeWithBranson(0x0),
+ fInputTreeWithoutBranson(0x0),
+ fMuonForwardTracksWithBranson(0),
+ fMuonForwardTrackPairsWithBranson(0),
+ fMuonForwardTracksWithoutBranson(0),
+ fMuonForwardTrackPairsWithoutBranson(0),
+ fMFTTrackWithBranson(0),
+ fMFTTrackWithoutBranson(0),
fMFTTrack(0),
+ fMFTTrackPairWithBranson(0),
+ fMFTTrackPairWithoutBranson(0),
fMFTTrackPair(0),
fMCRefTrack(0),
fEv(0),
fNTracksAnalyzed(0),
fNPairsOfEvent(0),
fNPairsAnalyzedOfEvent(0),
+ fNTracksAnalyzedOfEventAfterCut(0),
+ fNPairsAnalyzedOfEventAfterCut(0),
fHistOffsetSingleMuonsX(0x0),
fHistOffsetSingleMuonsY(0x0),
fHistOffsetSingleMuons(0x0),
fHistWOffsetSingleMuons(0x0),
fHistErrorSingleMuonsX(0x0),
fHistErrorSingleMuonsY(0x0),
- fHistOffsetSingleMuonsX_vsPtRapidity(0x0),
- fHistOffsetSingleMuonsY_vsPtRapidity(0x0),
- fHistSingleMuonsPtRapidity(0x0),
+ fHistZOriginSingleMuonsMC(0x0),
+ fHistZROriginSingleMuonsMC(0x0),
+ fHistSingleMuonsPtRapidityMC(0x0),
fHistSingleMuonsOffsetChi2(0x0),
- fHistWOffsetMuonPairs(0x0),
- fHistMassMuonPairs(0x0),
- fHistMassMuonPairsWithoutMFT(0x0),
- fHistMassMuonPairsMC(0x0),
- fHistRapidityPtMuonPairsMC(0x0),
+ fHistSingleMuonsOffsetChi2_BeforeMFT(0x0),
+ fHistSingleMuonsOffsetChi2_AfterMFT(0x0),
fGraphSingleMuonsOffsetChi2(0x0),
- fNMassBins(1000),
+ fHistRapidityPtMuonPairs(0x0),
+ fNMassBins(10),
+ fNPtDimuBins(1000),
fMassMin(0),
fMassMax(10),
+ fPtDimuMin(0),
+ fPtDimuMax(5),
+ fPtAxisDimuons(0),
fSingleMuonAnalysis(1),
fMuonPairAnalysis(1),
fMatchTrigger(0),
fXVertResMC(50.e-4),
fYVertResMC(50.e-4),
fZVertResMC(50.e-4),
+ fPrimaryVtxX(0.),
+ fPrimaryVtxY(0.),
+ fPrimaryVtxZ(0.),
fMaxNWrongClustersMC(999),
- fPtMinSingleMuons(0)
+ fPtMinSingleMuons(0),
+ fUseBransonForCut(kFALSE),
+ fUseBransonForKinematics(kFALSE),
+ fCutOnOffsetChi2(kFALSE),
+ fCenterOffset(0.),
+ fCenterChi2(0.),
+ fScaleOffset(250.),
+ fScaleChi2(2.5),
+ fRadiusCut(1.)
{
// default constructor
- for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
- for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
- fHistOffsetSingleMuonsX_tmp[rapBin][ptBin] = 0x0;
- fHistOffsetSingleMuonsY_tmp[rapBin][ptBin] = 0x0;
- }
+ for (Int_t iPtBin=0; iPtBin<fNMaxPtBinsDimuons+1; iPtBin++) {
+ fHistWOffsetMuonPairs[iPtBin] = NULL;
+ fHistMassMuonPairs[iPtBin] = NULL;
+ fHistMassMuonPairsWithoutMFT[iPtBin] = NULL;
+ fHistMassMuonPairsMC[iPtBin] = NULL;
}
}
Bool_t AliMuonForwardTrackAnalysis::Init(Char_t *inputFileName) {
+ fPtAxisDimuons = new TAxis(fNPtDimuBins, fPtDimuMin, fPtDimuMax);
+
BookHistos();
TFile *inputFile = new TFile(Form("%s/%s",fInputDir.Data(),inputFileName));
AliError(Form("Error opening file %s", inputFileName));
return kFALSE;
}
- fInputTree = (TTree*) inputFile->Get("AliMuonForwardTracks");
- if (!fInputTree) {
+ fInputTreeWithBranson = (TTree*) inputFile->Get("AliMuonForwardTracksWithBranson");
+ if (!fInputTreeWithBranson) {
+ AliError("Error reading input tree");
+ return kFALSE;
+ }
+ fInputTreeWithoutBranson = (TTree*) inputFile->Get("AliMuonForwardTracksWithoutBranson");
+ if (!fInputTreeWithoutBranson) {
AliError("Error reading input tree");
return kFALSE;
}
- if (fFirstEvent<0 || fLastEvent<0 || fFirstEvent>fLastEvent || fFirstEvent>=fInputTree->GetEntries()) {
+ if (fFirstEvent<0 || fLastEvent<0 || fFirstEvent>fLastEvent || fFirstEvent>=fInputTreeWithBranson->GetEntries()) {
fFirstEvent = 0;
- fLastEvent = fInputTree->GetEntries()-1;
+ fLastEvent = fInputTreeWithBranson->GetEntries()-1;
}
else {
- fLastEvent = TMath::Min(fLastEvent, Int_t(fInputTree->GetEntries()-1));
+ fLastEvent = TMath::Min(fLastEvent, Int_t(fInputTreeWithBranson->GetEntries()-1));
}
AliInfo(Form("Analysing events %d to %d", fFirstEvent, fLastEvent));
- fMuonForwardTracks = new TClonesArray("AliMuonForwardTrack");
- fInputTree->SetBranchAddress("tracks", &fMuonForwardTracks);
+ fMuonForwardTracksWithBranson = new TClonesArray("AliMuonForwardTrack");
+ fInputTreeWithBranson->SetBranchAddress("tracks", &fMuonForwardTracksWithBranson);
+
+ fMuonForwardTracksWithoutBranson = new TClonesArray("AliMuonForwardTrack");
+ fInputTreeWithoutBranson->SetBranchAddress("tracks", &fMuonForwardTracksWithoutBranson);
TGeoManager::Import(Form("%s/geometry.root",fInputDir.Data()));
AliMUONTrackExtrap::SetField();
- fMuonForwardTrackPairs = new TClonesArray("AliMuonForwardTrackPair");
+ fMuonForwardTrackPairsWithBranson = new TClonesArray("AliMuonForwardTrackPair");
+ fMuonForwardTrackPairsWithoutBranson = new TClonesArray("AliMuonForwardTrackPair");
return kTRUE;
if (fEv>fLastEvent) return kFALSE;
if (fEv<fFirstEvent) { fEv++; return kTRUE; }
- fMuonForwardTracks -> Clear();
- fInputTree->GetEvent(fEv);
- AliInfo(Form("**** analyzing event # %4d (%3d tracks) ****", fEv, fMuonForwardTracks->GetEntries()));
+ fMuonForwardTracksWithBranson -> Delete();
+ fMuonForwardTracksWithoutBranson -> Delete();
+ fInputTreeWithBranson->GetEvent(fEv);
+ fInputTreeWithoutBranson->GetEvent(fEv);
+ AliInfo(Form("**** analyzing event # %4d (%3d tracks) ****", fEv, fMuonForwardTracksWithBranson->GetEntries()));
+
+ fPrimaryVtxX = gRandom->Gaus(0., fXVertResMC);
+ fPrimaryVtxY = gRandom->Gaus(0., fYVertResMC);
+ fPrimaryVtxZ = gRandom->Gaus(0., fZVertResMC);
if (fSingleMuonAnalysis) {
fNTracksAnalyzedOfEvent = 0;
- fNTracksOfEvent = fMuonForwardTracks->GetEntries();
+ fNTracksAnalyzedOfEventAfterCut = 0;
+ fNTracksOfEvent = fMuonForwardTracksWithBranson->GetEntries();
while (AnalyzeSingleMuon()) continue;
}
if (fMuonPairAnalysis) {
- if (fMuonForwardTrackPairs) {
- fMuonForwardTrackPairs->Clear();
+ if (fMuonForwardTrackPairsWithBranson) {
+ fMuonForwardTrackPairsWithBranson->Delete();
+ fMuonForwardTrackPairsWithoutBranson->Delete();
}
BuildMuonPairs();
fNPairsAnalyzedOfEvent = 0;
- fNPairsOfEvent = fMuonForwardTrackPairs->GetEntries();
+ fNPairsAnalyzedOfEventAfterCut = 0;
+ fNPairsOfEvent = fMuonForwardTrackPairsWithBranson->GetEntries();
while (AnalyzeMuonPair()) continue;
}
+ AliInfo(Form("**** analyzed event # %4d (%3d tracks and %3d pairs analyzed) ****", fEv, fNTracksAnalyzedOfEventAfterCut, fNPairsAnalyzedOfEventAfterCut));
+
fEv++;
return kTRUE;
if (fNTracksAnalyzedOfEvent>=fNTracksOfEvent) return kFALSE;
- fMFTTrack = (AliMuonForwardTrack*) fMuonForwardTracks->At(fNTracksAnalyzedOfEvent);
+ fMFTTrackWithBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithBranson->At(fNTracksAnalyzedOfEvent);
+ fMFTTrackWithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson->At(fNTracksAnalyzedOfEvent);
+
fNTracksAnalyzedOfEvent++;
+
+ Bool_t passedCut = kFALSE;
+ if (fUseBransonForCut) passedCut = PassedCutSingleMuon(fMFTTrackWithBranson);
+ else passedCut = PassedCutSingleMuon(fMFTTrackWithoutBranson);
+ if (!passedCut) return kTRUE;
+
+ if (fUseBransonForKinematics) fMFTTrack = fMFTTrackWithBranson;
+ else fMFTTrack = fMFTTrackWithoutBranson;
if (fMatchTrigger && !fMFTTrack->GetMatchTrigger()) return kTRUE;
fMCRefTrack = fMFTTrack->GetMCTrackRef();
- if (!fMCRefTrack) return kTRUE;
- if (fMFTTrack->GetNWrongClustersMC()>fMaxNWrongClustersMC) return kTRUE;
+ if (fOption!=kPionsKaons && !fMCRefTrack) return kTRUE;
+ if (fOption!=kPionsKaons && fMFTTrack->GetNWrongClustersMC()>fMaxNWrongClustersMC) return kTRUE;
- Double_t xOrig=gRandom->Gaus(0., fXVertResMC);
- Double_t yOrig=gRandom->Gaus(0., fYVertResMC);
-// Double_t xOrig = 0.;
-// Double_t yOrig = 0.;
- Double_t zOrig=gRandom->Gaus(0., fZVertResMC);
+ 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, zOrig);
+ 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);
- if (fMFTTrack->Pt()<fPtMinSingleMuons) return kTRUE;
-
TMatrixD cov(5,5);
cov = param->GetCovariances();
fHistErrorSingleMuonsX -> Fill(1.e4*TMath::Sqrt(cov(0,0)));
fHistErrorSingleMuonsY -> Fill(1.e4*TMath::Sqrt(cov(2,2)));
- Double_t dX = fMFTTrack->GetOffsetX(xOrig, zOrig);
- Double_t dY = fMFTTrack->GetOffsetY(yOrig, zOrig);
+ Double_t dX = fMFTTrack->GetOffsetX(fPrimaryVtxX, fPrimaryVtxZ);
+ Double_t dY = fMFTTrack->GetOffsetY(fPrimaryVtxY, fPrimaryVtxZ);
- Double_t offset = fMFTTrack->GetOffset(xOrig, yOrig, zOrig);
- Double_t weightedOffset = fMFTTrack->GetWeightedOffset(xOrig, yOrig, zOrig);
+ Double_t offset = fMFTTrack->GetOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ);
+ Double_t weightedOffset = fMFTTrack->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ);
// AliDebug(2, Form("pdg code = %d\n", fMCRefTrack->GetPdgCode()));
fHistOffsetSingleMuonsX -> Fill(1.e4*dX);
fHistOffsetSingleMuonsY -> Fill(1.e4*dY);
- Int_t rapBin = fHistOffsetSingleMuonsX_vsPtRapidity->GetXaxis()->FindBin(pMu.Rapidity());
- Int_t ptBin = fHistOffsetSingleMuonsX_vsPtRapidity->GetYaxis()->FindBin(pMu.Pt());
- // AliDebug(1, Form("pt = %f (%d), rap = %f (%d)\n", pMu.Pt(), pMu.Rapidity(), ptBin, rapBin));
- if (0<rapBin && rapBin<=fNRapBinsOffsetSingleMuons && 0<ptBin && ptBin<=fNPtBinsOffsetSingleMuons) {
- fHistOffsetSingleMuonsX_tmp[rapBin-1][ptBin-1]->Fill(1.e4*dX);
- fHistOffsetSingleMuonsY_tmp[rapBin-1][ptBin-1]->Fill(1.e4*dY);
- }
- fHistSingleMuonsPtRapidity -> Fill(pMu.Rapidity(), pMu.Pt());
+
+ if (fOption!=kPionsKaons) fHistSingleMuonsPtRapidityMC-> Fill(fMCRefTrack->Y(), fMCRefTrack->Pt());
fHistOffsetSingleMuons -> Fill(1.e4*offset);
fHistWOffsetSingleMuons -> Fill(weightedOffset);
Double_t chi2OverNdf = fMFTTrack->GetGlobalChi2()/Double_t(fMFTTrack->GetNMFTClusters()+fMFTTrack->GetNMUONClusters());
fHistSingleMuonsOffsetChi2 -> Fill(1.e4*offset, chi2OverNdf);
+ if (fMCRefTrack) {
+ if (-1.*fMCRefTrack->Vz()<5.) fHistSingleMuonsOffsetChi2_BeforeMFT -> Fill(1.e4*offset, chi2OverNdf);
+ else fHistSingleMuonsOffsetChi2_AfterMFT -> Fill(1.e4*offset, chi2OverNdf);
+ }
+
fGraphSingleMuonsOffsetChi2 -> SetPoint(fGraphSingleMuonsOffsetChi2->GetN(),1.e4*offset, chi2OverNdf);
fNTracksAnalyzed++;
+ fNTracksAnalyzedOfEventAfterCut++;
return kTRUE;
if (fNPairsAnalyzedOfEvent>=fNPairsOfEvent) return kFALSE;
- fMFTTrackPair = (AliMuonForwardTrackPair*) fMuonForwardTrackPairs->At(fNPairsAnalyzedOfEvent);
+ fMFTTrackPairWithBranson = (AliMuonForwardTrackPair*) fMuonForwardTrackPairsWithBranson->At(fNPairsAnalyzedOfEvent);
+ fMFTTrackPairWithoutBranson = (AliMuonForwardTrackPair*) fMuonForwardTrackPairsWithoutBranson->At(fNPairsAnalyzedOfEvent);
- if (fOption==kResonanceOnly && !fMFTTrackPair->IsResonance()) {
- fNPairsAnalyzedOfEvent++;
- return kTRUE;
- }
+ fNPairsAnalyzedOfEvent++;
- Double_t xOrig=gRandom->Gaus(0., fXVertResMC);
- Double_t yOrig=gRandom->Gaus(0., fYVertResMC);
- Double_t zOrig=gRandom->Gaus(0., fZVertResMC);
- AliDebug(1, Form("origin = (%f, %f, %f)", xOrig, yOrig, zOrig));
+ Bool_t passedCut = kFALSE;
+ if (fUseBransonForCut) passedCut = PassedCutMuonPair(fMFTTrackPairWithBranson);
+ else passedCut = PassedCutMuonPair(fMFTTrackPairWithoutBranson);
- fHistMassMuonPairs -> Fill(fMFTTrackPair->GetMass(zOrig));
- fHistWOffsetMuonPairs -> Fill(fMFTTrackPair->GetWeightedOffset(xOrig, yOrig, zOrig));
- fHistMassMuonPairsWithoutMFT -> Fill(fMFTTrackPair->GetMassWithoutMFT(xOrig, yOrig, zOrig));
- fHistMassMuonPairsMC -> Fill(fMFTTrackPair->GetMassMC());
- fHistRapidityPtMuonPairsMC -> Fill(fMFTTrackPair->GetRapidityMC(), fMFTTrackPair->GetPtMC());
+ if (!passedCut) return kTRUE;
- AliDebug(1, Form("mass = %f MC = %f", fMFTTrackPair->GetMass(zOrig), fMFTTrackPair->GetMassMC()));
+ if (fUseBransonForKinematics) fMFTTrackPair = fMFTTrackPairWithBranson;
+ else fMFTTrackPair = fMFTTrackPairWithoutBranson;
- fNPairsAnalyzedOfEvent++;
+ if ( fMFTTrackPair->GetTrack(0)->GetNWrongClustersMC()>fMaxNWrongClustersMC ||
+ fMFTTrackPair->GetTrack(1)->GetNWrongClustersMC()>fMaxNWrongClustersMC ) return kTRUE;
+
+ if (fOption==kResonanceOnly && !fMFTTrackPair->IsResonance()) return kTRUE;
+
+ fMFTTrackPair -> SetKinem(fPrimaryVtxZ);
+
+ Int_t ptBin = fPtAxisDimuons->FindBin(fMFTTrackPair->GetPtMC());
+
+ if (1<=ptBin && ptBin<=fNPtDimuBins) {
+ fHistMassMuonPairs[ptBin] -> Fill(fMFTTrackPair->GetMass());
+ fHistWOffsetMuonPairs[ptBin] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ fHistMassMuonPairsWithoutMFT[ptBin] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ if (fOption!=kPionsKaons) fHistMassMuonPairsMC[ptBin] -> Fill(fMFTTrackPair->GetMassMC());
+ }
+ fHistMassMuonPairs[0] -> Fill(fMFTTrackPair->GetMass());
+ fHistWOffsetMuonPairs[0] -> Fill(fMFTTrackPair->GetWeightedOffset(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ fHistMassMuonPairsWithoutMFT[0] -> Fill(fMFTTrackPair->GetMassWithoutMFT(fPrimaryVtxX, fPrimaryVtxY, fPrimaryVtxZ));
+ if (fOption!=kPionsKaons) fHistMassMuonPairsMC[0] -> Fill(fMFTTrackPair->GetMassMC());
+
+ if (fOption!=kPionsKaons) fHistRapidityPtMuonPairs -> Fill(fMFTTrackPair->GetRapidityMC(), fMFTTrackPair->GetPtMC());
+ else if (fMFTTrackPair->IsKinemSet()) fHistRapidityPtMuonPairs -> Fill(fMFTTrackPair->GetRapidity(), fMFTTrackPair->GetPt());
+
+ AliDebug(1, Form("mass = %f MC = %f", fMFTTrackPair->GetMass(), fMFTTrackPair->GetMassMC()));
+
+ fNPairsAnalyzedOfEventAfterCut++;
return kTRUE;
void AliMuonForwardTrackAnalysis::BuildMuonPairs() {
- for (Int_t iTrack=0; iTrack<fMuonForwardTracks->GetEntries(); iTrack++) {
+ for (Int_t iTrack=0; iTrack<fMuonForwardTracksWithBranson->GetEntries(); iTrack++) {
for (Int_t jTrack=0; jTrack<iTrack; jTrack++) {
- AliMuonForwardTrack *track0 = (AliMuonForwardTrack*) fMuonForwardTracks->At(iTrack);
- AliMuonForwardTrack *track1 = (AliMuonForwardTrack*) fMuonForwardTracks->At(jTrack);
+ AliMuonForwardTrack *track0_WithBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithBranson->At(iTrack);
+ AliMuonForwardTrack *track1_WithBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithBranson->At(jTrack);
+
+ AliMuonForwardTrack *track0_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson->At(iTrack);
+ AliMuonForwardTrack *track1_WithoutBranson = (AliMuonForwardTrack*) fMuonForwardTracksWithoutBranson->At(jTrack);
- if (fMatchTrigger) if (!track0->GetMatchTrigger() || !track1->GetMatchTrigger()) continue;
- if (!track0->GetMCTrackRef() || !track1->GetMCTrackRef()) continue;
- if (track0->GetNWrongClustersMC()>fMaxNWrongClustersMC || track1->GetNWrongClustersMC()>fMaxNWrongClustersMC) continue;
- if (track0->Pt()<fPtMinSingleMuons || track1->Pt()<fPtMinSingleMuons) continue;
+ if (fMatchTrigger) if (!track0_WithBranson->GetMatchTrigger() || !track1_WithBranson->GetMatchTrigger()) continue;
+ if (fOption!=kPionsKaons && (!track0_WithBranson->GetMCTrackRef() || !track1_WithBranson->GetMCTrackRef())) continue;
- AliMuonForwardTrackPair *trackPair = new AliMuonForwardTrackPair(track0, track1);
- if (fOption==kResonanceOnly && !trackPair->IsResonance()) {
- delete trackPair;
+ AliMuonForwardTrackPair *trackPairWithBranson = new AliMuonForwardTrackPair(track0_WithBranson, track1_WithBranson);
+ AliMuonForwardTrackPair *trackPairWithoutBranson = new AliMuonForwardTrackPair(track0_WithoutBranson, track1_WithoutBranson);
+ if (fOption==kResonanceOnly && !trackPairWithBranson->IsResonance()) {
+ delete trackPairWithBranson;
+ delete trackPairWithoutBranson;
continue;
}
- new ((*fMuonForwardTrackPairs)[fMuonForwardTrackPairs->GetEntries()]) AliMuonForwardTrackPair(*trackPair);
-
+// if (fMFTTrackPairWithBranson) fMFTTrackPairWithBranson -> SetKinem(fPrimaryVtxZ);
+// if (fMFTTrackPairWithoutBranson) fMFTTrackPairWithoutBranson -> SetKinem(fPrimaryVtxZ);
+ new ((*fMuonForwardTrackPairsWithBranson)[fMuonForwardTrackPairsWithBranson->GetEntries()]) AliMuonForwardTrackPair(*trackPairWithBranson);
+ new ((*fMuonForwardTrackPairsWithoutBranson)[fMuonForwardTrackPairsWithoutBranson->GetEntries()]) AliMuonForwardTrackPair(*trackPairWithoutBranson);
}
}
//====================================================================================================================================================
-void AliMuonForwardTrackAnalysis::Terminate(Char_t *outputFileName) {
+Bool_t AliMuonForwardTrackAnalysis::PassedCutSingleMuon(AliMuonForwardTrack *track) {
- for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
- for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
- Int_t binMin_x = fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->FindBin(-3*fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMS());
- Int_t binMax_x = fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->FindBin(+3*fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMS());
- for (Int_t bin=1; bin<=fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetNbinsX(); bin++) {
- if (bin<binMin_x || bin>binMax_x) fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->SetBinContent(bin, 0);
- }
- Int_t binMin_y = fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->FindBin(-3*fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMS());
- Int_t binMax_y = fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->FindBin(+3*fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMS());
- for (Int_t bin=1; bin<=fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetNbinsX(); bin++) {
- if (bin<binMin_y || bin>binMax_y) fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->SetBinContent(bin, 0);
- }
- fHistOffsetSingleMuonsX_vsPtRapidity->SetBinContent(rapBin+1, ptBin+1, fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMS());
- fHistOffsetSingleMuonsX_vsPtRapidity->SetBinError(rapBin+1, ptBin+1, fHistOffsetSingleMuonsX_tmp[rapBin][ptBin]->GetRMSError());
- fHistOffsetSingleMuonsY_vsPtRapidity->SetBinContent(rapBin+1, ptBin+1, fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMS());
- fHistOffsetSingleMuonsY_vsPtRapidity->SetBinError(rapBin+1, ptBin+1, fHistOffsetSingleMuonsY_tmp[rapBin][ptBin]->GetRMSError());
- }
+ AliMUONTrackParam *param = track->GetTrackParamAtMFTCluster(0);
+ AliMUONTrackExtrap::ExtrapToZCov(param, fPrimaryVtxZ);
+
+ if (track->Pt()<fPtMinSingleMuons) 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;
}
+ return kTRUE;
+
+}
+
+//====================================================================================================================================================
+
+Bool_t AliMuonForwardTrackAnalysis::PassedCutMuonPair(AliMuonForwardTrackPair *pair) {
+
+ return PassedCutSingleMuon(pair->GetTrack(0)) && PassedCutSingleMuon(pair->GetTrack(1));
+
+}
+
+//====================================================================================================================================================
+
+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());
fHistErrorSingleMuonsX -> Write();
fHistErrorSingleMuonsY -> Write();
- fHistOffsetSingleMuonsX_vsPtRapidity -> Write();
- fHistOffsetSingleMuonsY_vsPtRapidity -> Write();
-
-// for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
-// for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
-// fHistOffsetSingleMuonsX_tmp[rapBin][ptBin] -> Write();
-// fHistOffsetSingleMuonsY_tmp[rapBin][ptBin] -> Write();
-// }
-// }
-
- fHistSingleMuonsPtRapidity -> Write();
+ fHistSingleMuonsPtRapidityMC -> Write();
fHistSingleMuonsOffsetChi2 -> Write();
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> Write();
+ fHistSingleMuonsOffsetChi2_AfterMFT -> Write();
fGraphSingleMuonsOffsetChi2 -> Write();
- fHistWOffsetMuonPairs -> Write();
- fHistMassMuonPairs -> Write();
- fHistMassMuonPairsWithoutMFT -> Write();
- fHistMassMuonPairsMC -> Write();
- fHistRapidityPtMuonPairsMC -> Write();
+ fHistZOriginSingleMuonsMC -> Write();
+ fHistZROriginSingleMuonsMC -> Write();
+
+ for (Int_t iPtBin=0; iPtBin<fNPtDimuBins+1; iPtBin++) {
+ fHistWOffsetMuonPairs[iPtBin] -> Write();
+ fHistMassMuonPairs[iPtBin] -> Write();
+ fHistMassMuonPairsWithoutMFT[iPtBin] -> Write();
+ fHistMassMuonPairsMC[iPtBin] -> Write();
+ }
+
+ fHistRapidityPtMuonPairs -> Write();
fileOut -> Close();
fHistOffsetSingleMuons = new TH1D("fHistOffsetSingleMuons", "Offset for single muons", 200, 0, 2000);
fHistWOffsetSingleMuons = new TH1D("fHistWOffsetSingleMuons", "Weighted Offset for single muons", 300, 0, 15);
- fHistOffsetSingleMuonsX_vsPtRapidity = new TH2D("fHistOffsetSingleMuonsX_vsPtRapidity", "Offset for single muons along X",
- 10, -4, -2.5, 10, 0.5, 5.5);
- fHistOffsetSingleMuonsY_vsPtRapidity = new TH2D("fHistOffsetSingleMuonsY_vsPtRapidity", "Offset for single muons along Y",
- 10, -4, -2.5, 10, 0.5, 5.5);
-
- for (Int_t rapBin=0; rapBin<fNRapBinsOffsetSingleMuons; rapBin++) {
- for (Int_t ptBin=0; ptBin<fNPtBinsOffsetSingleMuons; ptBin++) {
- fHistOffsetSingleMuonsX_tmp[rapBin][ptBin] = new TH1D(Form("fHistOffsetSingleMuonsX_tmp_%02d_%02d",rapBin,ptBin), "", 1000, -1000, 1000);
- fHistOffsetSingleMuonsY_tmp[rapBin][ptBin] = new TH1D(Form("fHistOffsetSingleMuonsY_tmp_%02d_%02d",rapBin,ptBin), "", 1000, -1000, 1000);
- }
- }
-
- fHistSingleMuonsPtRapidity = new TH2D("fHistSingleMuonsPtRapidity", "Phase Space for single muons", 10, -4, -2.5, 10, 0.5, 5.5);
+ fHistSingleMuonsPtRapidityMC = new TH2D("fHistSingleMuonsPtRapidityMC", "Phase Space for single muons", 100, -4.5, -2., 100, 0., 10.);
fHistSingleMuonsOffsetChi2 = new TH2D("fHistSingleMuonsOffsetChi2", "Offset vs #chi^{2}/ndf for single muons", 400, 0, 4000, 100, 0, 20);
+ fHistSingleMuonsOffsetChi2_BeforeMFT = new TH2D("fHistSingleMuonsOffsetChi2_BeforeMFT",
+ "Offset vs #chi^{2}/ndf for single muons with origin before MFT", 400, 0, 4000, 100, 0, 20);
+ fHistSingleMuonsOffsetChi2_AfterMFT = new TH2D("fHistSingleMuonsOffsetChi2_AfterMFT",
+ "Offset vs #chi^{2}/ndf for single muons with origin after MFT", 400, 0, 4000, 100, 0, 20);
+
+ fHistZOriginSingleMuonsMC = new TH1D("fHistZOriginSingleMuonsMC", "Z origin for single muons (from MC)", 1000, 0., 500.);
+ fHistZROriginSingleMuonsMC = new TH2D("fHistZROriginSingleMuonsMC", "Z-R origin for single muons (from MC)", 1000, 0., 500., 1000, 0., 100.);
fHistOffsetSingleMuonsX -> SetXTitle("Offset(X) [#mum]");
fHistOffsetSingleMuonsY -> SetXTitle("Offset(Y) [#mum]");
fHistOffsetSingleMuons -> SetXTitle("Offset [#mum]");
fHistWOffsetSingleMuons -> SetXTitle("Weighted Offset");
- fHistOffsetSingleMuonsX_vsPtRapidity -> SetXTitle("y^{#mu}");
- fHistOffsetSingleMuonsY_vsPtRapidity -> SetXTitle("y^{#mu}");
- fHistOffsetSingleMuonsX_vsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
- fHistOffsetSingleMuonsY_vsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
-
- fHistSingleMuonsPtRapidity -> SetXTitle("y^{#mu}");
- fHistSingleMuonsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
+ fHistSingleMuonsPtRapidityMC -> SetXTitle("y^{#mu}");
+ fHistSingleMuonsPtRapidityMC -> SetYTitle("p_{T}^{#mu} [GeV/c]");
fHistSingleMuonsOffsetChi2 -> SetXTitle("Offset [#mum]");
fHistSingleMuonsOffsetChi2 -> SetYTitle("#chi^{2}/ndf");
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> SetXTitle("Offset [#mum]");
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> SetYTitle("#chi^{2}/ndf");
+ fHistSingleMuonsOffsetChi2_AfterMFT -> SetXTitle("Offset [#mum]");
+ fHistSingleMuonsOffsetChi2_AfterMFT -> SetYTitle("#chi^{2}/ndf");
+
+ fHistZOriginSingleMuonsMC -> SetXTitle("Z [cm]");
+ fHistZROriginSingleMuonsMC -> SetXTitle("Z [cm]");
+ fHistZROriginSingleMuonsMC -> SetXTitle("R [cm]");
fHistOffsetSingleMuonsX -> Sumw2();
fHistOffsetSingleMuonsY -> Sumw2();
fHistOffsetSingleMuons -> Sumw2();
fHistWOffsetSingleMuons -> Sumw2();
- fHistOffsetSingleMuonsX_vsPtRapidity -> Sumw2();
- fHistOffsetSingleMuonsY_vsPtRapidity -> Sumw2();
- fHistSingleMuonsPtRapidity -> Sumw2();
- fHistSingleMuonsOffsetChi2 -> Sumw2();
+ fHistZOriginSingleMuonsMC -> Sumw2();
+ fHistZROriginSingleMuonsMC -> Sumw2();
+
+ fHistSingleMuonsPtRapidityMC -> Sumw2();
+ fHistSingleMuonsOffsetChi2 -> Sumw2();
+ fHistSingleMuonsOffsetChi2_BeforeMFT -> Sumw2();
+ fHistSingleMuonsOffsetChi2_AfterMFT -> Sumw2();
//--------------------------------------------
- fGraphSingleMuonsOffsetChi2 = new TGraph("fGraphSingleMuonsOffsetChi2");
+ fGraphSingleMuonsOffsetChi2 = new TGraph();
fGraphSingleMuonsOffsetChi2 -> SetName("fGraphSingleMuonsOffsetChi2");
+ fGraphSingleMuonsOffsetChi2 -> SetTitle("fGraphSingleMuonsOffsetChi2");
//--------------------------------------------
- fHistWOffsetMuonPairs = new TH1D("fHistWOffsetMuonPairs", "Weighted Offset for Muon Pairs", 300, 0, 60);
- fHistMassMuonPairs = new TH1D("fHistMassMuonPairs", "Dimuon Mass (MUON+MFT)", fNMassBins, fMassMin, fMassMax);
- fHistMassMuonPairsWithoutMFT = new TH1D("fHistMassMuonPairsWithoutMFT", "Dimuon Mass (MUON only)", fNMassBins, fMassMin, fMassMax);
- fHistMassMuonPairsMC = new TH1D("fHistMassMuonPairsMC", "Dimuon Mass (MC)", fNMassBins, fMassMin, fMassMax);
- fHistRapidityPtMuonPairsMC = new TH2D("fHistRapidityPtMuonPairsMC", "Dimuon Phase Space (MC)", 100, -4.5, -2., 100, 0., 10.);
-
- fHistWOffsetMuonPairs -> SetXTitle("Weighted Offset");
- fHistMassMuonPairs -> SetXTitle("Mass [GeV/c^{2}]");
- fHistMassMuonPairsWithoutMFT -> SetXTitle("Mass [GeV/c^{2}]");
- fHistMassMuonPairsMC -> SetXTitle("Mass [GeV/c^{2}]");
- fHistRapidityPtMuonPairsMC -> SetXTitle("Rapidity");
- fHistRapidityPtMuonPairsMC -> SetYTitle("p_{T} [GeV/c]");
-
- fHistWOffsetMuonPairs -> Sumw2();
- fHistMassMuonPairs -> Sumw2();
- fHistMassMuonPairsWithoutMFT -> Sumw2();
- fHistMassMuonPairsMC -> Sumw2();
- fHistRapidityPtMuonPairsMC -> Sumw2();
+ for (Int_t iPtBin=0; iPtBin<=fNPtDimuBins+1; iPtBin++) {
+
+ if (!iPtBin) {
+ fHistWOffsetMuonPairs[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairs_%d",iPtBin),
+ "Weighted Offset for Muon Pairs (All p_{T}^{#mu#mu})",
+ 300, 0, 60);
+ fHistMassMuonPairs[iPtBin] = new TH1D(Form("fHistMassMuonPairs_%d",iPtBin),
+ "Dimuon Mass (MUON+MFT) (All p_{T}^{#mu#mu})",
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsWithoutMFT[iPtBin] = new TH1D(Form("fHistMassMuonPairsWithoutMFT_%d",iPtBin),
+ "Dimuon Mass (MUON only) (All p_{T}^{#mu#mu})",
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsMC[iPtBin] = new TH1D(Form("fHistMassMuonPairsMC_%d",iPtBin),
+ "Dimuon Mass (MC) (All p_{T}^{#mu#mu})",
+ fNMassBins, fMassMin, fMassMax);
+ }
+
+ else {
+ Double_t ptMin = fPtAxisDimuons->GetBinLowEdge(iPtBin);
+ Double_t ptMax = fPtAxisDimuons->GetBinUpEdge(iPtBin);
+ fHistWOffsetMuonPairs[iPtBin] = new TH1D(Form("fHistWOffsetMuonPairs_%d",iPtBin),
+ Form("Weighted Offset for Muon Pairs ( %3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ 300, 0, 60);
+ fHistMassMuonPairs[iPtBin] = new TH1D(Form("fHistMassMuonPairs_%d",iPtBin),
+ Form("Dimuon Mass (MUON+MFT) (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsWithoutMFT[iPtBin] = new TH1D(Form("fHistMassMuonPairsWithoutMFT_%d",iPtBin),
+ Form("Dimuon Mass (MUON only) (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ fNMassBins, fMassMin, fMassMax);
+ fHistMassMuonPairsMC[iPtBin] = new TH1D(Form("fHistMassMuonPairsMC_%d",iPtBin),
+ Form("Dimuon Mass (MC) (%3.1f < p_{T}^{#mu#mu} < %3.1f GeV/c)",ptMin,ptMax),
+ fNMassBins, fMassMin, fMassMax);
+ }
+
+ fHistWOffsetMuonPairs[iPtBin] -> SetXTitle("Weighted Offset");
+ fHistMassMuonPairs[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]");
+ fHistMassMuonPairsWithoutMFT[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]");
+ fHistMassMuonPairsMC[iPtBin] -> SetXTitle("Mass [GeV/c^{2}]");
+
+ fHistWOffsetMuonPairs[iPtBin] -> Sumw2();
+ fHistMassMuonPairs[iPtBin] -> Sumw2();
+ fHistMassMuonPairsWithoutMFT[iPtBin] -> Sumw2();
+ fHistMassMuonPairsMC[iPtBin] -> Sumw2();
+
+ }
+
+ if (fOption==kPionsKaons) fHistRapidityPtMuonPairs = new TH2D("fHistRapidityPtMuonPairs", "Dimuon Phase Space (rec)", 20, -4.5, -2., 20, 0., 10.);
+ else fHistRapidityPtMuonPairs = new TH2D("fHistRapidityPtMuonPairs", "Dimuon Phase Space (MC)", 100, -4.5, -2., 100, 0., 10.);
+ fHistRapidityPtMuonPairs -> SetXTitle("Rapidity");
+ fHistRapidityPtMuonPairs -> SetYTitle("p_{T} [GeV/c]");
+ fHistRapidityPtMuonPairs -> Sumw2();
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff