AliDebug(1, "Starting Event...");
for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
- fClustersPerPlane[iPlane]->Clear();
+ fClustersPerPlane[iPlane]->Delete();
}
AliDebug(1, "... done!");
StartEvent();
Bool_t isDigAvailableForNewCluster = kTRUE;
+ TClonesArray *myDigitList = 0;
+
for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
AliDebug(1, Form("Plane %02d", iPlane));
- TClonesArray *myDigitList = (TClonesArray*) pDigitList->At(iPlane);
+ myDigitList = (TClonesArray*) pDigitList->At(iPlane);
AliDebug(1, Form("myDigitList->GetEntries() = %d", myDigitList->GetEntries()));
AliDebug(1, Form("Found %d clusters in plane %02d", fClustersPerPlane[iPlane]->GetEntries(), iPlane));
+ myDigitList -> Delete();
+
} // end of cycle over the planes
}
#include "TRandom.h"
#include "TLorentzVector.h"
#include "TDatabasePDG.h"
+#include "TGraph.h"
#include "AliMuonForwardTrackAnalysis.h"
ClassImp(AliMuonForwardTrackAnalysis)
fHistOffsetSingleMuonsX_vsPtRapidity(0x0),
fHistOffsetSingleMuonsY_vsPtRapidity(0x0),
fHistSingleMuonsPtRapidity(0x0),
+ fHistSingleMuonsOffsetChi2(0x0),
fHistWOffsetMuonPairs(0x0),
fHistMassMuonPairs(0x0),
fHistMassMuonPairsWithoutMFT(0x0),
fHistMassMuonPairsMC(0x0),
fHistRapidityPtMuonPairsMC(0x0),
+ fGraphSingleMuonsOffsetChi2(0x0),
fNMassBins(1000),
fMassMin(0),
fMassMax(10),
fMuonPairAnalysis(1),
fMatchTrigger(0),
fOption(0),
- fXVertResMC(150.e-4),
- fYVertResMC(150.e-4),
- fZVertResMC(100.e-4),
+ fXVertResMC(50.e-4),
+ fYVertResMC(50.e-4),
+ fZVertResMC(50.e-4),
fMaxNWrongClustersMC(999),
fPtMinSingleMuons(0)
{
if (fNTracksAnalyzedOfEvent>=fNTracksOfEvent) return kFALSE;
- fMFTTrack = (AliMuonForwardTrack*) fMuonForwardTracks->At(fNTracksAnalyzedOfEvent);
+ fMFTTrack = (AliMuonForwardTrack*) fMuonForwardTracks->At(fNTracksAnalyzedOfEvent);
fNTracksAnalyzedOfEvent++;
if (fMatchTrigger && !fMFTTrack->GetMatchTrigger()) return kTRUE;
fMCRefTrack = fMFTTrack->GetMCTrackRef();
if (fMFTTrack->GetNWrongClustersMC()>fMaxNWrongClustersMC) return kTRUE;
Double_t xOrig=gRandom->Gaus(0., fXVertResMC);
- Double_t yOrig=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);
AliMUONTrackParam *param = fMFTTrack->GetTrackParamAtMFTCluster(0);
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());
- fHistOffsetSingleMuons -> Fill(1.e4*offset);
- fHistWOffsetSingleMuons -> Fill(weightedOffset);
+ fHistSingleMuonsPtRapidity -> Fill(pMu.Rapidity(), pMu.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);
+ fGraphSingleMuonsOffsetChi2 -> SetPoint(fGraphSingleMuonsOffsetChi2->GetN(),1.e4*offset, chi2OverNdf);
fNTracksAnalyzed++;
}
Double_t xOrig=gRandom->Gaus(0., fXVertResMC);
- Double_t yOrig=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));
// }
fHistSingleMuonsPtRapidity -> Write();
+ fHistSingleMuonsOffsetChi2 -> Write();
+
+ fGraphSingleMuonsOffsetChi2 -> Write();
fHistWOffsetMuonPairs -> Write();
fHistMassMuonPairs -> Write();
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", 100, 0, 2000);
+ 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",
}
fHistSingleMuonsPtRapidity = new TH2D("fHistSingleMuonsPtRapidity", "Phase Space for single muons", 10, -4, -2.5, 10, 0.5, 5.5);
+ fHistSingleMuonsOffsetChi2 = new TH2D("fHistSingleMuonsOffsetChi2", "Offset vs #chi^{2}/ndf for single muons", 400, 0, 4000, 100, 0, 20);
fHistOffsetSingleMuonsX -> SetXTitle("Offset(X) [#mum]");
fHistOffsetSingleMuonsY -> SetXTitle("Offset(Y) [#mum]");
fHistSingleMuonsPtRapidity -> SetXTitle("y^{#mu}");
fHistSingleMuonsPtRapidity -> SetYTitle("p_{T}^{#mu} [GeV/c]");
+ fHistSingleMuonsOffsetChi2 -> SetXTitle("Offset [#mum]");
+ fHistSingleMuonsOffsetChi2 -> SetYTitle("#chi^{2}/ndf");
fHistOffsetSingleMuonsX -> Sumw2();
fHistOffsetSingleMuonsY -> Sumw2();
fHistOffsetSingleMuonsX_vsPtRapidity -> Sumw2();
fHistOffsetSingleMuonsY_vsPtRapidity -> Sumw2();
fHistSingleMuonsPtRapidity -> Sumw2();
+ fHistSingleMuonsOffsetChi2 -> Sumw2();
//--------------------------------------------
+ fGraphSingleMuonsOffsetChi2 = new TGraph("fGraphSingleMuonsOffsetChi2");
+ fGraphSingleMuonsOffsetChi2 -> SetName("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);
#include "AliMUONTrackParam.h"
#include "AliMUONTrackExtrap.h"
#include "TDatabasePDG.h"
+#include "TGraph.h"
//====================================================================================================================================================
TH2D *fHistOffsetSingleMuonsX_vsPtRapidity, *fHistOffsetSingleMuonsY_vsPtRapidity, *fHistSingleMuonsPtRapidity; //!
TH1D *fHistOffsetSingleMuonsX_tmp[fNRapBinsOffsetSingleMuons][fNPtBinsOffsetSingleMuons]; //!
TH1D *fHistOffsetSingleMuonsY_tmp[fNRapBinsOffsetSingleMuons][fNPtBinsOffsetSingleMuons]; //!
+ TH2D *fHistSingleMuonsOffsetChi2; //!
TH1D *fHistWOffsetMuonPairs, *fHistMassMuonPairs, *fHistMassMuonPairsWithoutMFT, *fHistMassMuonPairsMC; //!
TH2D *fHistRapidityPtMuonPairsMC;
+ TGraph *fGraphSingleMuonsOffsetChi2; //!
+
Int_t fNMassBins;
Double_t fMassMin, fMassMax;
//================================================================================================================================
void AliMuonForwardTrackFinder(Int_t run=0,
+ Double_t zVertexError=0.010,
Int_t matching=0,
const Char_t *readDir= ".",
const Char_t *outDir = ".",
// finder -> SetRAbsorberCut(26.4);
finder -> SetLowPtCut(0.0);
// finder -> SetLowPtCut(0.5);
- finder -> SetVertexError(0.015, 0.015, 0.010);
+ finder -> SetVertexError(0.015, 0.015, zVertexError);
finder -> SetMatchingMode(matching); // 0 -> real matching 1 -> ideal matching
- finder -> SetMinResearchRadiusAtLastPlane(0.0);
+// finder -> SetMinResearchRadiusAtPlane(4, 0.0);
+ finder -> SetMinResearchRadiusAtPlane(4, 0.50);
+ finder -> SetMinResearchRadiusAtPlane(3, 0.05);
while (finder->LoadNextTrack()) continue;
fOutputEventTree(0),
fMuonForwardTracks(0),
fMatchingMode(-1),
- fMinResearchRadiusAtLastPlane(0),
fGRPData(0),
fRunInfo(0)
fIsPlaneMandatory[iPlane] = kFALSE;
+ fMinResearchRadiusAtPlane[iPlane] = 0.;
+
}
// fNextTrack = 0;
fRunLoader -> LoadKinematics();
fStack = fRunLoader->Stack();
fNextTrack = fTrackStore->CreateIterator();
- fMuonForwardTracks->Clear();
+ fMuonForwardTracks->Delete();
fEv++;
fCountRealTracksAnalyzed++;
- fCandidateTracks -> Clear();
+ fCandidateTracks -> Delete();
fLabelMC = -1;
fDistanceFromGoodClusterAndTrackAtLastPlane = -1.;
AliMuonForwardTrack *newTrack = (AliMuonForwardTrack*) fCandidateTracks->UncheckedAt(0);
new ((*fMuonForwardTracks)[fMuonForwardTracks->GetEntries()]) AliMuonForwardTrack(*newTrack);
AliDebug(1, "...track added!\n");
- fCandidateTracks->Clear();
+ fCandidateTracks->Delete();
fCountRealTracksAnalyzedOfEvent++;
fCountRealTracksAnalyzedWithFinalCandidates++;
PrintParticleHistory();
// -------------------------------------------------------------------------------------------
- fCandidateTracks->Clear();
+ fCandidateTracks->Delete();
fFinalBestCandidate = NULL;
fCountRealTracksAnalyzedOfEvent++;
Double_t researchRadiusFront = TMath::Sqrt(squaredError_X_Front + squaredError_Y_Front);
Double_t researchRadiusBack = TMath::Sqrt(squaredError_X_Back + squaredError_Y_Back);
- if (planeId==fNPlanesMFT-1 && 0.5*(researchRadiusFront+researchRadiusBack)<fMinResearchRadiusAtLastPlane) {
- corrFact = fMinResearchRadiusAtLastPlane/(0.5*(researchRadiusFront+researchRadiusBack));
+ if (0.5*(researchRadiusFront+researchRadiusBack)<fMinResearchRadiusAtPlane[planeId]) {
+ corrFact = fMinResearchRadiusAtPlane[planeId]/(0.5*(researchRadiusFront+researchRadiusBack));
}
if (fIsCurrentMuonTrackable) {
// fOutputQAFile->cd();
void AliMuonForwardTrackFinder::SeparateFrontBackClusters() {
for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
- fMFTClusterArrayFront[iPlane]->Clear();
- fMFTClusterArrayBack[iPlane] ->Clear();
+ fMFTClusterArrayFront[iPlane]->Delete();
+ fMFTClusterArrayBack[iPlane] ->Delete();
for (Int_t iCluster=0; iCluster<fMFTClusterArray[iPlane]->GetEntries(); iCluster++) {
AliMFTCluster *cluster = (AliMFTCluster*) fMFTClusterArray[iPlane]->At(iCluster);
if (TMath::Abs(cluster->GetZ())<TMath::Abs(fSegmentation->GetPlane(iPlane)->GetZCenter())) {
Bool_t IsMother(const Char_t *nameMother);
void SetMatchingMode(Int_t matchingMode) { fMatchingMode = matchingMode; }
- void SetMinResearchRadiusAtLastPlane(Double_t minResearchRadius) { fMinResearchRadiusAtLastPlane = minResearchRadius; }
+ void SetMinResearchRadiusAtPlane(Int_t plane, Double_t radius) { if (plane>=0 && plane<fNMaxPlanes) fMinResearchRadiusAtPlane[plane] = radius; }
void FillOutputTree();
void WriteOutputTree();
TClonesArray *fMuonForwardTracks; //! array of AliMuonForwardTrack
Int_t fMatchingMode;
- Double_t fMinResearchRadiusAtLastPlane;
+ Double_t fMinResearchRadiusAtPlane[fNMaxPlanes];
AliGRPObject *fGRPData; //! Data from the GRP/GRP/Data CDB folder
AliRunInfo *fRunInfo; //!
enum PDCProc_t {kGenBox,
kGenMuonLMR,
+ kGenParamJpsi,
kGenPionKaon,
kGenCorrHF,
kPythia6,
const Char_t* pprRunName[] = {"kGenBox",
"kGenMuonLMR",
+ "kGenParamJpsi",
"kGenPionKaon",
"kGenCorrHF",
"kPythia6",
else if (proc == kHijing2500Cocktail) gener = Hijing2500Cocktail();
else if (proc == kGenBox) gener = GenBox();
else if (proc == kGenMuonLMR) gener = GenMuonLMR();
+ else if (proc == kGenParamJpsi) gener = GenParamJpsi();
else if (proc == kGenCorrHF) gener = GenCorrHF();
else if (proc == kGenPionKaon) gener = GenParamPionKaon();
AliGenMUONLMR *gener = new AliGenMUONLMR();
gener->SetMomentumRange(0,999);
gener->SetPtRange(0,100.);
+ gener->SetYRange(-4.0, -2.5);
gener->SetPhiRange(0., 360.);
- gener->SetThetaRange(0., 180.);
- gener->SetChildThetaRange(170.0,179.0);
- gener->SetYRange(-4.5, -2.0);
+ gener->SetChildThetaRange(170.0,178.0);
gener->SetOrigin(0.0, 0.0, 0.0); // vertex position
gener->SetSigma(0.0, 0.0, 0.0); // vertex position smearing
gener->SetVertexSmear(kPerEvent);
enum {kEta2Body, kEtaDalitz, kRho2Body, kOmega2Body, kOmegaDalitz, kPhi2Body, kEtaPrimeDalitz, kPionLMR, kKaonLMR};
- gener->GenerateSingleProcess(kPhi2Body, 500);
+ gener->GenerateSingleProcess(kPhi2Body, 100);
+ gener->SetCutOnChild(1);
+
+ return gener;
+
+}
+
+//====================================================================================================================================================
+
+AliGenerator* GenParamJpsi() {
+
+ AliGenParam *gener = new AliGenParam(5, AliGenMUONlib::kJpsi);
+ gener->SetMomentumRange(0,999);
+ gener->SetPtRange(0,100.);
+ gener->SetYRange(-4.0, -2.5);
+ gener->SetPhiRange(0., 360.);
+ gener->SetChildThetaRange(170.0,178.0);
+ gener->SetOrigin(0.0, 0.0, 0.0); // vertex position
+ gener->SetSigma(0.0, 0.0, 0.0); // Sigma in (X,Y,Z) (cm) on IP position
+ gener->SetVertexSmear(kPerEvent);
+ gener->SetForceDecay(kDiMuon);
+ gener->SetTrackingFlag(1);
gener->SetCutOnChild(1);
return gener;