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 **************************************************************************/
17 #include "TClonesArray.h"
20 #include <TGeoManager.h>
24 #include "AliHeader.h"
27 #include "AliMagFMaps.h"
28 #include "AliTracker.h"
31 #include "AliMUONConstants.h"
32 #include "AliMUONTrack.h"
33 #include "AliMUONRecoCheck.h"
34 #include "AliMUONTrackParam.h"
35 #include "AliMUONTrackExtrap.h"
37 #include "AliMUONVTrackStore.h"
39 Int_t TrackCheck( Bool_t *compTrack);
41 void MUONRecoCheck (Int_t nEvent = 1, char* geoFilename = "geometry.root",
42 char * filenameSim="galice_sim.root", char * filename="galice.root"){
44 // Utility macro to check the muon reconstruction. Reconstructed tracks are compared
45 // to reference tracks. The reference tracks are built from AliTrackReference for the
46 // hit in chamber (0..9) and from kinematics (TreeK) for the vertex parameters.
49 Bool_t compTrackOK[10];
53 AliMUONTrack* trackOK(0x0);
55 Double_t sigma2Cut = 16; // 4 sigmas cut, sigma2Cut = 4*4
56 AliMUONTrackParam *trackParam;
57 TClonesArray *trackParamAtHit;
58 Double_t x1,y1,z1,pX1,pY1,pZ1,p1;
59 Double_t x2,y2,z2,pX2,pY2,pZ2,p2;
61 // File for histograms and histogram booking
62 TFile *histoFile = new TFile("MUONRecoCheck.root", "RECREATE");
64 TH1F *hReconstructible = new TH1F("hReconstructible"," Nb of reconstructible tracks ",15,-0.5,14.5);
65 TH1F *hReco = new TH1F("hReco"," Nb of reconstructed tracks / evt",15,-0.5,14.5);
66 TH1F *hNHitComp = new TH1F("hNHitComp"," Nb of compatible hits / track ",15,-0.5,14.5);
67 TH1F *hTestTrack = new TH1F("hTestTrack"," Reconstruction requirement / track",15,-0.5,14.5);
68 TH1F *hTrackRefID = new TH1F("hTrackRefID"," track reference ID ",100,-0.5,99.5);
70 TH1F *hResMomVertex = new TH1F("hMomVertex"," delta P vertex (GeV/c)",100,-10.,10);
71 TH1F *hResMomFirstHit = new TH1F("hMomFirstHit"," delta P first hit (GeV/c)",100,-10.,10);
73 // Import TGeo geometry (needed by AliMUONTrackExtrap::ExtrapToVertex)
75 TGeoManager::Import(geoFilename);
77 Error("MUONmass_ESD", "getting geometry from file %s failed", geoFilename);
83 // waiting for mag field in CDB
84 printf("Loading field map...\n");
85 AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
86 AliTracker::SetFieldMap(field, kFALSE);
87 // set the magnetic field for track extrapolations
88 AliMUONTrackExtrap::SetField(AliTracker::GetFieldMap());
90 AliMUONRecoCheck rc(filename,filenameSim);
92 Int_t nevents = rc.NumberOfEvents();
94 if (nevents < nEvent) nEvent = nevents;
97 Int_t nReconstructibleTracks = 0;
98 Int_t nReconstructedTracks = 0;
99 Int_t nReconstructibleTracksCheck = 0;
101 for (ievent=0; ievent<nEvent; ievent++)
103 if (!(ievent%10)) printf(" **** event # %d \n",ievent);
105 AliMUONVTrackStore* trackStore = rc.ReconstructedTracks(ievent);
106 AliMUONVTrackStore* trackRefStore = rc.ReconstructibleTracks(ievent);
108 hReconstructible->Fill(trackRefStore->GetSize());
109 hReco->Fill(trackStore->GetSize());
111 nReconstructibleTracks += trackRefStore->GetSize();
112 nReconstructedTracks += trackStore->GetSize();
114 TIter next(trackRefStore->CreateIterator());
115 AliMUONTrack* trackRef;
117 while ( ( trackRef = static_cast<AliMUONTrack*>(next()) ) )
121 for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++)
123 compTrackOK[ch] = kFALSE;
126 TIter next2(trackStore->CreateIterator());
127 AliMUONTrack* trackReco;
129 while ( ( trackReco = static_cast<AliMUONTrack*>(next2()) ) )
131 // check if trackRef is compatible with trackReco
132 compTrack = trackRef->CompatibleTrack(trackReco,sigma2Cut);
134 iTrack = TrackCheck(compTrack);
136 if (iTrack > testTrack)
139 for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++)
141 if (compTrack[ch]) nHitOK++;
142 compTrackOK[ch] = compTrack[ch];
149 hTestTrack->Fill(testTrack);
150 trackID = trackRef->GetTrackID();
151 hTrackRefID->Fill(trackID);
153 if (testTrack == 4) { // tracking requirements verified, track is found
154 nReconstructibleTracksCheck++;
155 hNHitComp->Fill(nHitOK);
156 trackParam = trackRef->GetTrackParamAtVertex();
157 x1 = trackParam->GetNonBendingCoor();
158 y1 = trackParam->GetBendingCoor();
159 z1 = trackParam->GetZ();
160 pX1 = trackParam->Px();
161 pY1 = trackParam->Py();
162 pZ1 = trackParam->Pz();
163 p1 = trackParam->P();
165 // 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);
167 trackParam = new AliMUONTrackParam(*((AliMUONTrackParam*)(trackReco->GetTrackParamAtHit()->First())));
168 AliMUONTrackExtrap::ExtrapToVertex(trackParam,x1,y1,z1);
169 x2 = trackParam->GetNonBendingCoor();
170 y2 = trackParam->GetBendingCoor();
171 z2 = trackParam->GetZ();
172 pX2 = trackParam->Px();
173 pY2 = trackParam->Py();
174 pZ2 = trackParam->Pz();
175 p2 = trackParam->P();
177 // 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);
179 hResMomVertex->Fill(p2-p1);
181 trackParamAtHit = trackRef->GetTrackParamAtHit();
182 trackParam = (AliMUONTrackParam*) trackParamAtHit->First();
183 x1 = trackParam->GetNonBendingCoor();
184 y1 = trackParam->GetBendingCoor();
185 z1 = trackParam->GetZ();
186 pX1 = trackParam->Px();
187 pY1 = trackParam->Py();
188 pZ1 = trackParam->Pz();
189 p1 = trackParam->P();
190 // printf(" Ref. track at 1st hit: x,y,z: %f %f %f px,py,pz: %f %f %f \n",x1,y1,z1,pX1,pY1,pZ1);
191 trackParamAtHit = trackOK->GetTrackParamAtHit();
192 trackParam = (AliMUONTrackParam*) trackParamAtHit->First();
193 x2 = trackParam->GetNonBendingCoor();
194 y2 = trackParam->GetBendingCoor();
195 z2 = trackParam->GetZ();
196 pX2 = trackParam->Px();
197 pY2 = trackParam->Py();
198 pZ2 = trackParam->Pz();
199 p2 = trackParam->P();
200 // printf(" Reconst. track at 1st hit: x,y,z: %f %f %f px,py,pz: %f %f %f \n",x2,y2,z2,pX2,pY2,pZ2);
202 hResMomFirstHit->Fill(p2-p1);
205 } // end loop track ref.
207 } // end loop on event
211 printf(" nb of reconstructible tracks: %d \n", nReconstructibleTracks);
212 printf(" nb of reconstructed tracks: %d \n", nReconstructedTracks);
213 printf(" nb of reconstructible tracks which are reconstructed: %d \n", nReconstructibleTracksCheck);
220 Int_t TrackCheck( Bool_t *compTrack)
222 // Apply reconstruction requirements
223 // Return number of validated conditions
224 // If all the tests are verified then TrackCheck = 4 (good track)
226 Int_t hitsInLastStations = 0;
228 // apply reconstruction requirements
229 if (compTrack[0] || compTrack[1]) iTrack++; // at least one hit in st. 0
230 if (compTrack[2] || compTrack[3]) iTrack++; // at least one hit in st. 1
231 if (compTrack[4] || compTrack[5]) iTrack++; // at least one hit in st. 2
232 for (Int_t ch = 6; ch < AliMUONConstants::NTrackingCh(); ch++) {
233 if (compTrack[ch]) hitsInLastStations++;
235 if (hitsInLastStations > 2) iTrack++; // at least 3 hits in st. 3 & 4