1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
19 /// \file MUONRecoCheck.C
20 /// \brief Utility macro to check the muon reconstruction.
22 /// Reconstructed tracks are compared to reference tracks. The reference tracks
23 /// are built from AliTrackReference for the hit in chamber (0..9) and from
24 /// kinematics (TreeK) for the vertex parameters.
26 /// \author Jean-Pierre Cussonneau, Subatech
29 #include "TClonesArray.h"
32 #include <TGeoManager.h>
36 #include "AliHeader.h"
39 #include "AliMagFMaps.h"
40 #include "AliTracker.h"
43 #include "AliMUONConstants.h"
44 #include "AliMUONTrack.h"
45 #include "AliMUONRecoCheck.h"
46 #include "AliMUONTrackParam.h"
47 #include "AliMUONTrackExtrap.h"
48 #include "AliMUONVTrackStore.h"
50 Int_t TrackCheck( Bool_t *compTrack);
52 void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root",
53 char * pathSim="./generated/", char * esdFileName="AliESDs.root")
57 Bool_t compTrackOK[10];
61 AliMUONTrack* trackOK(0x0);
63 Double_t sigmaCut = 4.; // 4 sigmas cut
64 Double_t maxChi2 = 999.;
65 AliMUONTrackParam *trackParam;
66 Double_t x1,y1,z1,pX1,pY1,pZ1,p1;
67 Double_t x2,y2,z2,pX2,pY2,pZ2,p2;
69 // File for histograms and histogram booking
70 TFile *histoFile = new TFile("MUONRecoCheck.root", "RECREATE");
72 TH1F *hReconstructible = new TH1F("hReconstructible"," Nb of reconstructible tracks ",15,-0.5,14.5);
73 TH1F *hReco = new TH1F("hReco"," Nb of reconstructed tracks / evt",15,-0.5,14.5);
74 TH1F *hNClusterComp = new TH1F("hNClusterComp"," Nb of compatible clusters / track ",15,-0.5,14.5);
75 TH1F *hTestTrack = new TH1F("hTestTrack"," Reconstruction requirement / track",15,-0.5,14.5);
76 TH1F *hTrackRefID = new TH1F("hTrackRefID"," track reference ID ",100,-0.5,99.5);
78 TH1F *hResMomVertex = new TH1F("hResMomVertex"," delta P vertex (GeV/c)",100,-10.,10);
79 TH1F *hResMomFirstCluster = new TH1F("hResMomFirstCluster"," delta P first cluster (GeV/c)",100,-10.,10);
81 // Import TGeo geometry (needed by AliMUONTrackExtrap::ExtrapToVertex)
83 TGeoManager::Import(geoFilename);
85 Error("MUONmass_ESD", "getting geometry from file %s failed", geoFilename);
91 // waiting for mag field in CDB
92 printf("Loading field map...\n");
93 AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
94 AliTracker::SetFieldMap(field, kFALSE);
95 // set the magnetic field for track extrapolations
96 AliMUONTrackExtrap::SetField(AliTracker::GetFieldMap());
98 AliMUONRecoCheck rc(esdFileName, pathSim);
100 Int_t nevents = rc.NumberOfEvents();
102 if (nevents < nEvent) nEvent = nevents;
105 Int_t nReconstructibleTracks = 0;
106 Int_t nReconstructedTracks = 0;
107 Int_t nReconstructibleTracksCheck = 0;
109 for (ievent=0; ievent<nEvent; ievent++)
111 if (!(ievent%10)) printf(" **** event # %d \n",ievent);
113 AliMUONVTrackStore* trackStore = rc.ReconstructedTracks(ievent);
114 AliMUONVTrackStore* trackRefStore = rc.ReconstructibleTracks(ievent);
116 hReconstructible->Fill(trackRefStore->GetSize());
117 hReco->Fill(trackStore->GetSize());
119 nReconstructibleTracks += trackRefStore->GetSize();
120 nReconstructedTracks += trackStore->GetSize();
122 TIter next(trackRefStore->CreateIterator());
123 AliMUONTrack* trackRef;
125 while ( ( trackRef = static_cast<AliMUONTrack*>(next()) ) )
130 for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++)
132 compTrackOK[ch] = kFALSE;
135 TIter next2(trackStore->CreateIterator());
136 AliMUONTrack* trackReco;
138 while ( ( trackReco = static_cast<AliMUONTrack*>(next2()) ) )
140 // check if trackRef is compatible with trackReco
141 if (trackReco->GetNClusters() > 1) {
143 // check cluster by cluster if trackReco contain info at each cluster
144 compTrack = trackRef->CompatibleTrack(trackReco,sigmaCut);
146 iTrack = TrackCheck(compTrack);
148 if (iTrack > testTrack)
151 for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++)
153 if (compTrack[ch]) nClusterOk++;
154 compTrackOK[ch] = compTrack[ch];
162 // check only parameters at the z position of the first trackRef
163 AliMUONTrackParam *refParam = (AliMUONTrackParam*) trackRef->GetTrackParamAtCluster()->First();
164 AliMUONTrackParam recoParam(*((AliMUONTrackParam*) trackReco->GetTrackParamAtCluster()->First()));
165 AliMUONTrackExtrap::ExtrapToZCov(&recoParam, refParam->GetZ());
167 if (refParam->CompatibleTrackParam(recoParam, sigmaCut, chi2)) {
169 if (chi2 < maxChi2) {
180 hTestTrack->Fill(testTrack);
181 trackID = trackRef->GetTrackID();
182 hTrackRefID->Fill(trackID);
184 if (testTrack == 4 || maxChi2 < 5.*sigmaCut*sigmaCut) { // tracking requirements verified, track is found
185 nReconstructibleTracksCheck++;
186 hNClusterComp->Fill(nClusterOk);
187 trackParam = trackRef->GetTrackParamAtVertex();
188 x1 = trackParam->GetNonBendingCoor();
189 y1 = trackParam->GetBendingCoor();
190 z1 = trackParam->GetZ();
191 pX1 = trackParam->Px();
192 pY1 = trackParam->Py();
193 pZ1 = trackParam->Pz();
194 p1 = trackParam->P();
196 // printf(" Ref. track at vertex: x,y,z: %f %f %f px,py,pz,p: %f %f %f %f \n",x1,y1,z1,pX1,pY1,pZ1,p1);
198 trackParam = new AliMUONTrackParam(*((AliMUONTrackParam*)(trackReco->GetTrackParamAtCluster()->First())));
199 AliMUONTrackExtrap::ExtrapToVertex(trackParam,x1,y1,z1,0.,0.);
200 x2 = trackParam->GetNonBendingCoor();
201 y2 = trackParam->GetBendingCoor();
202 z2 = trackParam->GetZ();
203 pX2 = trackParam->Px();
204 pY2 = trackParam->Py();
205 pZ2 = trackParam->Pz();
206 p2 = trackParam->P();
208 // printf(" Reconst. track at vertex: x,y,z: %f %f %f px,py,pz: %f %f %f %f \n",x2,y2,z2,pX2,pY2,pZ2,p2);
210 hResMomVertex->Fill(p2-p1);
212 trackParam = (AliMUONTrackParam*) trackRef->GetTrackParamAtCluster()->First();
213 x1 = trackParam->GetNonBendingCoor();
214 y1 = trackParam->GetBendingCoor();
215 z1 = trackParam->GetZ();
216 pX1 = trackParam->Px();
217 pY1 = trackParam->Py();
218 pZ1 = trackParam->Pz();
219 p1 = trackParam->P();
220 // printf(" Ref. track at 1st cluster: x,y,z: %f %f %f px,py,pz: %f %f %f \n",x1,y1,z1,pX1,pY1,pZ1);
221 trackParam = (AliMUONTrackParam*) trackOK->GetTrackParamAtCluster()->First();
222 x2 = trackParam->GetNonBendingCoor();
223 y2 = trackParam->GetBendingCoor();
224 z2 = trackParam->GetZ();
225 pX2 = trackParam->Px();
226 pY2 = trackParam->Py();
227 pZ2 = trackParam->Pz();
228 p2 = trackParam->P();
229 // printf(" Reconst. track at 1st cluster: x,y,z: %f %f %f px,py,pz: %f %f %f \n",x2,y2,z2,pX2,pY2,pZ2);
231 hResMomFirstCluster->Fill(p2-p1);
234 } // end loop track ref.
236 } // end loop on event
238 printf(" nb of reconstructible tracks: %d \n", nReconstructibleTracks);
239 printf(" nb of reconstructed tracks: %d \n", nReconstructedTracks);
240 printf(" nb of reconstructible tracks which are reconstructed: %d \n", nReconstructibleTracksCheck);
247 Int_t TrackCheck( Bool_t *compTrack)
249 // Apply reconstruction requirements
250 // Return number of validated conditions
251 // If all the tests are verified then TrackCheck = 4 (good track)
253 Int_t nCompClustersInLastStations = 0;
255 // apply reconstruction requirements
256 if (compTrack[0] || compTrack[1]) iTrack++; // at least one compatible cluster in st. 0
257 if (compTrack[2] || compTrack[3]) iTrack++; // at least one compatible cluster in st. 1
258 if (compTrack[4] || compTrack[5]) iTrack++; // at least one compatible cluster in st. 2
259 for (Int_t ch = 6; ch < AliMUONConstants::NTrackingCh(); ch++) {
260 if (compTrack[ch]) nCompClustersInLastStations++;
262 if (nCompClustersInLastStations > 2) iTrack++; // at least 3 compatible clusters in st. 3 & 4