// Also it is implemented a simple matching between tracks
// to look for the extrapolation of them to ACORDE modules
//
-// Create some histograms and one tree with the information
+// Create some fHistograms and one tree with the information
// of the matching tracks
//
// Author: Mario RodrÃguez Cahuantzi
AliAnalysisTaskAcorde::AliAnalysisTaskAcorde(const char *name)
: AliAnalysisTask(name, ""),
fESD(0),
- cosmicTree(0),
- nTracks(0),
- nMatchTracks(0),
- minTPCclusters(30),
- minTrackDist(1000.),
- minCutDir(0.95),
- xAco(0),
- yAco(0),
- zAco(0),
- trigger(0),
- ActiveTriggerDetector(0),
- nSingleTracks(0),
- nMatchedTracks(0),
- histo(0),
- ntracks(0),
- acordeHitsAll(0),
- acordeMultiAll(0),
- acordeHitsTPC(0),
- acordeMultiTPC(0),
- nTracksMatched(0),
+ fCosmicTree(0),
+ fnTracks(0),
+ fNMatchTracks(0),
+ fkMinTPCclusters(30),
+ fkMinTrackDist(1000.),
+ fkMinCutDir(0.95),
+ fXAco(0),
+ fYAco(0),
+ fZAco(0),
+ fTrigger(0),
+ fActiveTriggerDetector(0),
+ fNSingleTracks(0),
+ fNMatchedTracks(0),
+ fHisto(0),
+ fNTracks(0),
+ fAcordeHitsAll(0),
+ fAcordeMultiAll(0),
+ fAcordeHitsTPC(0),
+ fAcordeMultiTPC(0),
+ fNTracksMatched(0),
fTracksToAcorde(0)
{
// destructor --> avoid watchdog mails?
delete fESD;
- delete histo;
- delete cosmicTree;
+ delete fHisto;
+ delete fCosmicTree;
}
//________________________________________________________________________
void AliAnalysisTaskAcorde::ConnectInputData(Option_t *)
void AliAnalysisTaskAcorde::CreateOutputObjects()
{
- // creates one TList with some histograms
+ // creates one TList with some fHistograms
- histo = new TList();
+ fHisto = new TList();
- nTracksMatched = new TH1F("nTracksMatched","nTracksMatched from matching algorithm implemented",300,1,300);
- ntracks = new TH1F("ntracks","nTracks distribution",500,1,500);
- acordeHitsAll = new TH1F("acordeHitsAll","Hits of ACORDE from ESD",60,-0.5,59.5);
- acordeHitsTPC = new TH1F("acordeHitsAllTPC","Hits of ACORDE from ESD (if ntracks>0)",61,0,60);
- acordeMultiAll = new TH1F("acordeMultiAll","Multiplicity of ACORDE modules from ESD",60,-0.5,59.5);
- acordeMultiTPC = new TH1F("acordeMultiAllTPC","Multiplicity of ACORDE modules from ESD (id ntracks>0)",61,0,60);
+ fNTracksMatched = new TH1F("fNTracksMatched","fNTracksMatched from matching algorithm implemented",300,1,300);
+ fNTracks = new TH1F("fNTracks","fnTracks distribution",500,1,500);
+ fAcordeHitsAll = new TH1F("fAcordeHitsAll","Hits of ACORDE from ESD",60,-0.5,59.5);
+ fAcordeHitsTPC = new TH1F("fAcordeHitsAllTPC","Hits of ACORDE from ESD (if fNTracks>0)",61,0,60);
+ fAcordeMultiAll = new TH1F("fAcordeMultiAll","Multiplicity of ACORDE modules from ESD",60,-0.5,59.5);
+ fAcordeMultiTPC = new TH1F("fAcordeMultiAllTPC","Multiplicity of ACORDE modules from ESD (id fNTracks>0)",61,0,60);
fTracksToAcorde = new TH2F("fTracksToAcorde","Extrapolated tracks to ACORDE x:z",1200,-600,600,1200,-600,600);
- histo->Add(nTracksMatched);
- histo->Add(ntracks);
- histo->Add(acordeHitsAll);
- histo->Add(acordeHitsTPC);
- histo->Add(acordeMultiAll);
- histo->Add(acordeMultiTPC);
- histo->Add(fTracksToAcorde);
+ fHisto->Add(fNTracksMatched);
+ fHisto->Add(fNTracks);
+ fHisto->Add(fAcordeHitsAll);
+ fHisto->Add(fAcordeHitsTPC);
+ fHisto->Add(fAcordeMultiAll);
+ fHisto->Add(fAcordeMultiTPC);
+ fHisto->Add(fTracksToAcorde);
// Create Tree branches
// Called just once
- cosmicTree = new TTree("cosmicTree","cosmicTreeMRC");
- cosmicTree->Branch("nTracks",&nTracks,"nTracks/I");
- cosmicTree->Branch("nMatchTracks",&nMatchTracks,"nMatchTracks/I");
- cosmicTree->Branch("xAco",&xAco,"xAco/F");
- cosmicTree->Branch("yAco",&yAco,"yAco/F");
- cosmicTree->Branch("zAco",&zAco,"zAco/F");
- cosmicTree->Branch("trigger",&trigger,"trigger/I");
+ fCosmicTree = new TTree("fCosmicTree","fCosmicTreeMRC");
+ fCosmicTree->Branch("fnTracks",&fnTracks,"fnTracks/I");
+ fCosmicTree->Branch("fNMatchTracks",&fNMatchTracks,"fNMatchTracks/I");
+ fCosmicTree->Branch("fXAco",&fXAco,"fXAco/F");
+ fCosmicTree->Branch("fYAco",&fYAco,"fYAco/F");
+ fCosmicTree->Branch("fZAco",&fZAco,"fZAco/F");
+ fCosmicTree->Branch("fTrigger",&fTrigger,"fTrigger/I");
}
{
if (acordeESD->GetHitChannel(imod))
{
- acordeHitsAll->Fill(imod);
+ fAcordeHitsAll->Fill(imod);
contMulti++;
}
- }acordeMultiAll->Fill(contMulti);
+ }fAcordeMultiAll->Fill(contMulti);
for(Int_t imod=0;imod<60;imod++)
{
if (acordeESD->GetHitChannel(imod))
{
- acordeHitsTPC->Fill(imod);
+ fAcordeHitsTPC->Fill(imod);
contMultiTPC++;
}
- }acordeMultiTPC->Fill(contMultiTPC);
+ }fAcordeMultiTPC->Fill(contMultiTPC);
- // Assingment of the type of Trigger to cosmicTree
+ // Assingment of the type of Trigger to fCosmicTree
- ActiveTriggerDetector = fESD->GetFiredTriggerClasses();
+ fActiveTriggerDetector = fESD->GetFiredTriggerClasses();
- if (ActiveTriggerDetector.Contains("C0SCO")) trigger=0;
- if (ActiveTriggerDetector.Contains("C0SH2")) trigger=1;
- if (ActiveTriggerDetector.Contains("C0AMU")) trigger=2;
- if (ActiveTriggerDetector.Contains("C0LSR")) trigger=3;
- if (ActiveTriggerDetector.Contains("C0SCO1")) trigger=4;
- if (ActiveTriggerDetector.Contains("C0OBE")) trigger=5;
- if (ActiveTriggerDetector.Contains("C0PCO")) trigger=6;
- if (ActiveTriggerDetector.Contains("C0OB3")) trigger=7;
- if (ActiveTriggerDetector.Contains("C0OCP")) trigger=8;
- if (ActiveTriggerDetector.Contains("C0ASL")) trigger=9;
+ if (fActiveTriggerDetector.Contains("C0SCO")) fTrigger=0;
+ if (fActiveTriggerDetector.Contains("C0SH2")) fTrigger=1;
+ if (fActiveTriggerDetector.Contains("C0AMU")) fTrigger=2;
+ if (fActiveTriggerDetector.Contains("C0LSR")) fTrigger=3;
+ if (fActiveTriggerDetector.Contains("C0SCO1")) fTrigger=4;
+ if (fActiveTriggerDetector.Contains("C0OBE")) fTrigger=5;
+ if (fActiveTriggerDetector.Contains("C0PCO")) fTrigger=6;
+ if (fActiveTriggerDetector.Contains("C0OB3")) fTrigger=7;
+ if (fActiveTriggerDetector.Contains("C0OCP")) fTrigger=8;
+ if (fActiveTriggerDetector.Contains("C0ASL")) fTrigger=9;
// Begins the matching analysis between tracks
- nTracks = fESD->GetNumberOfTracks();
- if (nTracks<=0) return;
- ntracks->Fill(nTracks);
+ fnTracks = fESD->GetNumberOfTracks();
+ if (fnTracks<=0) return;
+ fNTracks->Fill(fnTracks);
- fPair = new TArrayI(nTracks);
- nSingleTracks=0;
- nMatchedTracks=0;
+ fPair = new TArrayI(fnTracks);
+ fNSingleTracks=0;
+ fNMatchedTracks=0;
Int_t muons = 0;
TFile *curfile = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
- for (Int_t iTrack=0; iTrack<nTracks; iTrack++)
+ for (Int_t iTrack=0; iTrack<fnTracks; iTrack++)
{
- // Special case: nTracks == 1
- if (nTracks ==1)
+ // Special case: fnTracks == 1
+ if (fnTracks ==1)
{
AliESDtrack *singleTrack = fESD->GetTrack(iTrack);
if (!singleTrack || !singleTrack->GetOuterParam() || !singleTrack->GetInnerParam()) continue;
- if (singleTrack->GetTPCNcls()<minTPCclusters) continue;
+ if (singleTrack->GetTPCNcls()<fkMinTPCclusters) continue;
Float_t vertX = singleTrack->Xv();
Float_t vertZ = singleTrack->Zv();
if (TMath::Abs(vertX)>165 || TMath::Abs(vertZ)>245) continue; // far away from the VERTEX
if (singleTrack->E()< 1) continue; // less than 1 GeV
if (singleTrack->P()< 1) continue; // less than 1 GeV
- nMatchTracks=0;
- nSingleTracks = nTracks;
+ fNMatchTracks=0;
+ fNSingleTracks = fnTracks;
muons = 1;
- } // nTracks ==1
- else if (nTracks>1) // nTracks > 1
+ } // fnTracks ==1
+ else if (fnTracks>1) // fnTracks > 1
{
AliESDtrack *track0 = fESD->GetTrack(iTrack);
(*fPair)[iTrack]=-1;
if (!track0 || !track0->GetOuterParam() || !track0->GetInnerParam()) continue;
- Double_t track0_dir[3];
- track0->GetDirection(track0_dir);
- Float_t minDist = minTrackDist;
+ Double_t trackdir0[3];
+ track0->GetDirection(trackdir0);
+ Float_t minDist = fkMinTrackDist;
const AliExternalTrackParam * trackIn = track0->GetInnerParam();
const AliExternalTrackParam * trackOut = track0->GetOuterParam();
if (!trackIn || !trackOut) continue;
- if (nTracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue; // Filter TPC-Laser
+ if (fnTracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue; // Filter TPC-Laser
- if (track0->GetTPCNcls()<minTPCclusters) continue;
+ if (track0->GetTPCNcls()<fkMinTPCclusters) continue;
- for (Int_t jTrack=iTrack; jTrack<nTracks; ++jTrack)
+ for (Int_t jTrack=iTrack; jTrack<fnTracks; ++jTrack)
{
AliESDtrack *track1 = fESD->GetTrack(jTrack);
if (!track1 || !track1->GetOuterParam() || !track1->GetInnerParam()) continue;
- Double_t track1_dir[3];
- track1->GetDirection(track1_dir);
- if (track1->GetTPCNcls()<minTPCclusters) continue;
- Float_t direction = track0_dir[0]*track1_dir[0] + track0_dir[1]*track1_dir[1] + track0_dir[2]*track1_dir[2];
- if (TMath::Abs(direction)<minCutDir) continue; // direction vector product
+ Double_t trackdir1[3];
+ track1->GetDirection(trackdir1);
+ if (track1->GetTPCNcls()<fkMinTPCclusters) continue;
+ Float_t direction = trackdir0[0]*trackdir1[0] + trackdir0[1]*trackdir1[1] + trackdir0[2]*trackdir1[2];
+ if (TMath::Abs(direction)<fkMinCutDir) continue; // direction vector product
Float_t dvertex0[3];
Float_t dvertex1[3];
}
- } // nTracks > 1
+ } // fnTracks > 1
} // Loop over all the tracks
// Matching tracks
- for (Int_t itrack=0;itrack<nTracks;itrack++)
+ for (Int_t itrack=0;itrack<fnTracks;itrack++)
{
- AliESDtrack *UpTrack = 0;
- AliESDtrack *DownTrack = 0;
+ AliESDtrack *upTrack = 0;
+ AliESDtrack *downTrack = 0;
- AliESDtrack *Track0 = fESD->GetTrack(itrack);
- if (!Track0 || !Track0->GetOuterParam() || !Track0->GetInnerParam() ) continue;
+ AliESDtrack *track0 = fESD->GetTrack(itrack);
+ if (!track0 || !track0->GetOuterParam() || !track0->GetInnerParam() ) continue;
Double_t mxyz[3];
- Track0->GetOuterParam()->GetXYZ(mxyz);
+ track0->GetOuterParam()->GetXYZ(mxyz);
- UpTrack = Track0;
+ upTrack = track0;
if ((*fPair)[itrack]>0)
{
- AliESDtrack *Track1 = fESD->GetTrack((*fPair)[itrack]);
- if (!Track1 || !Track1->GetOuterParam() || !Track1->GetInnerParam()) continue;
+ AliESDtrack *track1 = fESD->GetTrack((*fPair)[itrack]);
+ if (!track1 || !track1->GetOuterParam() || !track1->GetInnerParam()) continue;
Float_t dvertex0[3];
Float_t dvertex1[3];
- dvertex0[0] = Track0->Xv();
- dvertex0[1] = Track0->Yv();
- dvertex0[2] = Track0->Zv();
+ dvertex0[0] = track0->Xv();
+ dvertex0[1] = track0->Yv();
+ dvertex0[2] = track0->Zv();
- dvertex1[0] = Track1->Xv();
- dvertex1[1] = Track1->Yv();
- dvertex1[2] = Track1->Zv();
+ dvertex1[0] = track1->Xv();
+ dvertex1[1] = track1->Yv();
+ dvertex1[2] = track1->Zv();
Float_t distTracks = TMath::Sqrt((dvertex0[0]-dvertex1[0])*(dvertex0[0]-dvertex1[0]) + (dvertex0[1]-dvertex1[1])*(dvertex0[1]-dvertex1[1]) + (dvertex0[2]-dvertex1[2])*(dvertex0[2]-dvertex1[2]) );
if (distTracks>2.5) continue;
- if (Track1->GetOuterParam())
+ if (track1->GetOuterParam())
{
Double_t nxyz[3];
- Track1->GetOuterParam()->GetXYZ(nxyz);
+ track1->GetOuterParam()->GetXYZ(nxyz);
if (nxyz[1]>mxyz[1])
{
- UpTrack = Track1;
- }else DownTrack = Track1;
+ upTrack = track1;
+ }else downTrack = track1;
}
const Double_t kRL3 = 510; // radious of L3 magnet
- const Double_t kxAcorde = 850.; // radios of "ACORDE" above the magnet
+ const Double_t kfXAcorde = 850.; // radios of "ACORDE" above the magnet
Double_t agxyz[3];
- AliExternalTrackParam *upper = (AliExternalTrackParam *)(UpTrack->GetOuterParam()->Clone());
+ AliExternalTrackParam *upper = (AliExternalTrackParam *)(upTrack->GetOuterParam()->Clone());
Bool_t isOk = upper->PropagateTo(kRL3,fESD->GetMagneticField());
upper->GetXYZ(agxyz);
if (isOk) upper->Rotate(alpha);
- if (isOk) isOk = upper->PropagateTo(kxAcorde,0);
+ if (isOk) isOk = upper->PropagateTo(kfXAcorde,0);
TVectorD rgxyz(3);
AliExternalTrackParam *param = (AliExternalTrackParam *)upper;
param->GetXYZ(rgxyz.GetMatrixArray());
- xAco = rgxyz[0];
- yAco = rgxyz[1];
- zAco = rgxyz[2];
- fTracksToAcorde->Fill(xAco,zAco);
+ fXAco = rgxyz[0];
+ fYAco = rgxyz[1];
+ fZAco = rgxyz[2];
+ fTracksToAcorde->Fill(fXAco,fZAco);
// Count how many tracks have been matched
- nMatchedTracks++;
- } else nSingleTracks++;
+ fNMatchedTracks++;
+ } else fNSingleTracks++;
}
- if ( (nMatchedTracks+nSingleTracks) <= nTracks ) muons=nMatchedTracks+nSingleTracks;
- nTracksMatched->Fill(muons);
+ if ( (fNMatchedTracks+fNSingleTracks) <= fnTracks ) muons=fNMatchedTracks+fNSingleTracks;
+ fNTracksMatched->Fill(muons);
- nMatchTracks = nSingleTracks + nMatchedTracks;
+ fNMatchTracks = fNSingleTracks + fNMatchedTracks;
// Fills the tree
- cosmicTree->Fill();
+ fCosmicTree->Fill();
// Post output data.
- PostData(0,cosmicTree);
- PostData(1,histo);
+ PostData(0,fCosmicTree);
+ PostData(1,fHisto);
}
//________________________________________________________________________
c1->Divide(2,2);
c1->cd(1);
- acordeHitsAll->Draw();
+ fAcordeHitsAll->Draw();
c1->cd(2)->SetLogy();
- acordeMultiAll->Draw();
+ fAcordeMultiAll->Draw();
c1->cd(3)->SetLogy();
- //nTracksMatched->Draw();
- ntracks->Draw();
+ //fNTracksMatched->Draw();
+ fNTracks->Draw();
c1->cd(4);
fTracksToAcorde->Draw();
// Also it is implemented a simple matching between tracks\r
// to look for the extrapolation of them to ACORDE modules\r
//\r
-// Create some histograms and one tree with the information\r
+// Create some fHistograms and one tree with the information\r
// of the matching tracks\r
//\r
// Author: Mario RodrÃguez Cahuantzi\r
//\r
/////////////////////////////////////////////////////////////////////////////\r
\r
-#ifndef AliAnalysisTaskAcorde_cxx\r
-#define AliAnalysisTaskAcorde_cxx\r
+#ifndef ALIANALYSISTASKACORDE_H\r
+#define ALIANALYSISTASKACORDE_H\r
\r
class TH2F;\r
class TH1F;\r
virtual ~AliAnalysisTaskAcorde(); //! Destructor fo task\r
\r
virtual void ConnectInputData(Option_t *); //! Connects input data to class analysis\r
- virtual void CreateOutputObjects(); //! Creates output object (cosmicTree)\r
+ virtual void CreateOutputObjects(); //! Creates output object (fCosmicTree)\r
virtual void Exec(Option_t *option); //! Execution class\r
virtual void Terminate(Option_t *); //! Terminate class \r
\r
\r
AliESDEvent *fESD; //! ESD object\r
TArrayI *fPair; //! Pair track connected (up & down)\r
- TTree *cosmicTree; //! TTree with some information of matched tracks\r
- Int_t nTracks; //! # of recontructed tracks\r
- Int_t nMatchTracks; //! # of matched tracks\r
+ TTree *fCosmicTree; //! TTree with some information of matched tracks\r
+ Int_t fnTracks; //! # of recontructed tracks\r
+ Int_t fNMatchTracks; //! # of matched tracks\r
\r
\r
// Cut definitions\r
\r
- const Int_t minTPCclusters; //! cut in clusters\r
- const Float_t minTrackDist; //! cut in distance\r
- const Float_t minCutDir; //! minimum cut\r
+ const Int_t fkMinTPCclusters; //! cut in clusters\r
+ const Float_t fkMinTrackDist; //! cut in distance\r
+ const Float_t fkMinCutDir; //! minimum cut\r
\r
- Float_t xAco; //! x-coordinate of extrapolated track to ACORDE\r
- Float_t yAco; //! y-coordinate of extrapolated track to ACORDE\r
- Float_t zAco; //! z-coordinate of extrapolated track to ACORDE\r
- Int_t trigger; //! trigger label\r
- TString ActiveTriggerDetector; //! detector string \r
+ Float_t fXAco; //! x-coordinate of extrapolated track to ACORDE\r
+ Float_t fYAco; //! y-coordinate of extrapolated track to ACORDE\r
+ Float_t fZAco; //! z-coordinate of extrapolated track to ACORDE\r
+ Int_t fTrigger; //! fTrigger label\r
+ TString fActiveTriggerDetector; //! detector string \r
\r
- Int_t nSingleTracks; //! no. of single track\r
- Int_t nMatchedTracks; //! no. of matched track\r
+ Int_t fNSingleTracks; //! no. of single track\r
+ Int_t fNMatchedTracks; //! no. of matched track\r
\r
\r
- TList *histo; //! list of histograms\r
- TH1F *acordeHitsAll; //! hits of acorde\r
- TH1F *acordeMultiAll; //! multi. of acorde modules\r
- TH1F *acordeHitsTPC; //! hits of acorde (if track)\r
- TH1F *acordeMultiTPC; //! multi. of acorde modules (if track)\r
- TH1F *nTracksMatched; //! matched tracks\r
- TH1F *ntracks; //! no. of tracks\r
+ TList *fHisto; //! list of fHistograms\r
+ TH1F *fAcordeHitsAll; //! hits of acorde\r
+ TH1F *fAcordeMultiAll; //! multi. of acorde modules\r
+ TH1F *fAcordeHitsTPC; //! hits of acorde (if track)\r
+ TH1F *fAcordeMultiTPC; //! multi. of acorde modules (if track)\r
+ TH1F *fNTracksMatched; //! matched tracks\r
+ TH1F *fNTracks; //! no. of tracks\r
TH2F *fTracksToAcorde; //! tracks extrapolated to acorde.\r
\r
AliAnalysisTaskAcorde(const AliAnalysisTaskAcorde&); // not implemented\r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff