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 // Macro for checking aliroot output and associated files contents
20 // Gines Martinez, Subatech June 2003
22 #if !defined(__CINT__) || defined(__MAKECINT__)
25 #include "TClonesArray.h"
29 #include "TParticle.h"
35 #include "AliRunLoader.h"
36 #include "AliHeader.h"
37 #include "AliLoader.h"
39 #include "AliTracker.h"
40 #include "AliMagFMaps.h"
44 #include "AliMUONData.h"
45 #include "AliMUONHit.h"
46 #include "AliMUONConstants.h"
47 #include "AliMUONDigit.h"
48 #include "AliMUONRawCluster.h"
49 #include "AliMUONGlobalTrigger.h"
50 #include "AliMUONLocalTrigger.h"
51 #include "AliMUONTrack.h"
52 #include "AliMUONTrackParam.h"
53 #include "AliMUONTrackExtrap.h"
54 #include "AliMUONTriggerCircuit.h"
55 #include "AliMUONTriggerCrateStore.h"
57 #include "AliMpVSegmentation.h"
58 #include "AliMpIntPair.h"
59 #include "AliMpDEManager.h"
60 #include "AliMpSegFactory.h"
63 void MUONkine(Int_t event2Check=0, char * filename="galice.root")
65 // Stack of particle for each event
67 // Creating Run Loader and openning file containing Hits
68 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
69 if (RunLoader ==0x0) {
70 printf(">>> Error : Error Opening %s file \n",filename);
74 RunLoader->LoadKinematics("READ");
75 Int_t ievent, nevents;
76 nevents = RunLoader->GetNumberOfEvents();
78 for(ievent=0; ievent<nevents; ievent++) { // Event loop
79 if (event2Check!=0) ievent=event2Check;
80 Int_t iparticle, nparticles;
81 // Getting event ievent
82 RunLoader->GetEvent(ievent);
83 stack = RunLoader->Stack();
84 nparticles = (Int_t) stack->GetNtrack();
85 printf(">>> Event %d, Number of particles is %d \n",ievent, nparticles);
86 for(iparticle=0; iparticle<nparticles; iparticle++) {
87 stack->Particle(iparticle)->Print("");
89 if (event2Check!=0) ievent=nevents;
91 RunLoader->UnloadKinematics();
95 void MUONhits(Int_t event2Check=0, char * filename="galice.root")
97 // Creating Run Loader and openning file containing Hits
98 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
99 if (RunLoader ==0x0) {
100 printf(">>> Error : Error Opening %s file \n",filename);
103 // Loading MUON subsystem
104 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
105 MUONLoader->LoadHits("READ"); // Loading Tree of hits for MUON
106 AliMUONData muondata(MUONLoader,"MUON","MUON"); // Creating MUON data container
107 Int_t ievent, nevents;
108 nevents = RunLoader->GetNumberOfEvents();
110 for(ievent=0; ievent<nevents; ievent++) { // Event loop
111 if (event2Check!=0) ievent=event2Check;
112 printf(">>> Event %d \n",ievent);
113 // Getting event ievent
114 RunLoader->GetEvent(ievent);
115 muondata.SetTreeAddress("H");
116 Int_t itrack, ntracks;
117 ntracks = (Int_t) muondata.GetNtracks();
118 for (itrack=0; itrack<ntracks; itrack++) { // Track loop
119 //Getting List of Hits of Track itrack
120 muondata.GetTrack(itrack);
122 nhits = (Int_t) muondata.Hits()->GetEntriesFast();
123 printf(">>> Track %d, Number of hits %d \n",itrack,nhits);
125 for(ihit=0; ihit<nhits; ihit++) {
126 mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
129 muondata.ResetHits();
131 if (event2Check!=0) ievent=nevents;
133 MUONLoader->UnloadHits();
137 void MUONdigits(Int_t event2Check=0, char * filename="galice.root")
139 // Creating Run Loader and openning file containing Hits
140 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
141 if (RunLoader ==0x0) {
142 printf(">>> Error : Error Opening %s file \n",filename);
145 // Loading MUON subsystem
146 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
147 MUONLoader->LoadDigits("READ");
148 // Creating MUON data container
149 AliMUONData muondata(MUONLoader,"MUON","MUON");
151 Int_t ievent, nevents;
152 nevents = RunLoader->GetNumberOfEvents();
153 AliMUONDigit * mDigit;
155 for(ievent=0; ievent<nevents; ievent++) {
156 if (event2Check!=0) ievent=event2Check;
157 printf(">>> Event %d \n",ievent);
158 RunLoader->GetEvent(ievent);
161 Int_t ichamber, nchambers;
162 nchambers = AliMUONConstants::NCh(); ;
163 muondata.SetTreeAddress("D,GLT");
165 muondata.GetDigits();
167 for( ichamber=0; ichamber<nchambers; ichamber++) {
168 Int_t idigit, ndigits;
169 TClonesArray* digits = muondata.Digits(ichamber);
171 ndigits = (Int_t)digits->GetEntriesFast();
172 for(idigit=0; idigit<ndigits; idigit++) {
173 mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
174 mDigit->Print("tracks");
176 } // end chamber loop
177 muondata.ResetDigits();
178 if (event2Check!=0) ievent=nevents;
180 MUONLoader->UnloadDigits();
183 void MUONsdigits(Int_t event2Check=0, char * filename="galice.root")
185 // Creating Run Loader and openning file containing Hits
186 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
187 if (RunLoader ==0x0) {
188 printf(">>> Error : Error Opening %s file \n",filename);
191 // Loading MUON subsystem
192 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
193 MUONLoader->LoadSDigits("READ");
194 // Creating MUON data container
195 AliMUONData muondata(MUONLoader,"MUON","MUON");
197 Int_t ievent, nevents;
198 nevents = RunLoader->GetNumberOfEvents();
199 AliMUONDigit * mDigit;
201 for(ievent=0; ievent<nevents; ievent++) {
202 if (event2Check!=0) ievent=event2Check;
203 printf(">>> Event %d \n",ievent);
204 RunLoader->GetEvent(ievent);
207 Int_t ichamber, nchambers;
208 nchambers = AliMUONConstants::NCh(); ;
209 muondata.SetTreeAddress("S");
211 muondata.GetSDigits();
213 for( ichamber=0; ichamber<nchambers; ichamber++) {
214 Int_t idigit, ndigits;
215 TClonesArray* digits = muondata.SDigits(ichamber);
216 ndigits = (Int_t)digits->GetEntriesFast();
217 for(idigit=0; idigit<ndigits; idigit++) {
218 mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
219 mDigit->Print("tracks");
221 } // end chamber loop
222 muondata.ResetSDigits();
223 if (event2Check!=0) ievent=nevents;
225 MUONLoader->UnloadSDigits();
229 void MUONoccupancy(Int_t event2Check=0, Bool_t perDetEle =kFALSE, char * filename="galice.root") {
230 // Creating Run Loader and openning file containing Hits
231 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
232 if (RunLoader ==0x0) {
233 printf(">>> Error : Error Opening %s file \n",filename);
236 // Loading MUON subsystem
237 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
238 MUONLoader->LoadDigits("READ");
239 // Creating MUON data container
240 AliMUONData muondata(MUONLoader,"MUON","MUON");
242 Int_t ievent, nevents;
243 nevents = RunLoader->GetNumberOfEvents();
244 AliMUONDigit * mDigit =0x0;
245 AliMpVSegmentation * segbend = 0x0;
246 AliMpVSegmentation * segnonbend = 0x0;
247 AliMpIntPair pad(0,0);
249 Int_t dEoccupancy_bending[14][26];
250 Int_t dEoccupancy_nonbending[14][26];
251 Int_t cHoccupancy_bending[14];
252 Int_t cHoccupancy_nonbending[14];
253 Int_t totaloccupancy_bending =0;
254 Int_t totaloccupancy_nonbending =0;
256 Int_t dEchannels_bending[14][26];
257 Int_t dEchannels_nonbending[14][26];
258 Int_t cHchannels_bending[14];
259 Int_t cHchannels_nonbending[14];
260 Int_t totalchannels_bending =0;
261 Int_t totalchannels_nonbending =0;
263 Int_t ichamber, nchambers,idetele, detele, ix, iy;
264 nchambers = AliMUONConstants::NCh(); ;
266 AliMpSegFactory factory;
268 for (ichamber=0; ichamber<nchambers; ichamber++) {
269 cHchannels_bending[ichamber]=0;
270 cHchannels_nonbending[ichamber]=0;
271 for (idetele=0; idetele<26; idetele++) {
272 detele= 100*(ichamber +1)+idetele;
273 dEchannels_bending[ichamber][idetele]=0;
274 dEchannels_nonbending[ichamber][idetele]=0;
275 dEoccupancy_bending[ichamber][idetele]=0;
276 dEoccupancy_nonbending[ichamber][idetele]=0;
277 if ( AliMpDEManager::IsValidDetElemId(detele) ) {
279 segbend = factory.CreateMpSegmentation(detele, 0);
280 segnonbend = factory.CreateMpSegmentation(detele, 1);
281 if (AliMpDEManager::GetPlaneType(detele, 0) != kBendingPlane ) {
282 AliMpVSegmentation* tmp = segbend;
283 segbend = segnonbend;
287 for(ix=0; ix<=segbend->MaxPadIndexX(); ix++) {
288 for(iy=0; iy<=segbend->MaxPadIndexY(); iy++) {
291 if( segbend->HasPad(pad) ) {
292 dEchannels_bending[ichamber][idetele]++;
293 cHchannels_bending[ichamber]++;
294 totalchannels_bending++;
298 for(ix=0; ix<=segnonbend->MaxPadIndexX(); ix++) {
299 for(iy=0; iy<=segnonbend->MaxPadIndexY(); iy++) {
302 if(segnonbend->HasPad(pad)) {
303 dEchannels_nonbending[ichamber][idetele]++;
304 cHchannels_nonbending[ichamber]++;
305 totalchannels_nonbending++;
309 if (perDetEle) printf(">>> Detection element %4d has %5d channels in bending and %5d channels in nonbending \n",
310 detele, dEchannels_bending[ichamber][idetele], dEchannels_nonbending[ichamber][idetele] );
313 printf(">>> Chamber %2d has %6d channels in bending and %6d channels in nonbending \n",
314 ichamber+1, cHchannels_bending[ichamber], cHchannels_nonbending[ichamber]);
316 printf(">>Spectrometer has %7d channels in bending and %7d channels in nonbending \n",
317 totalchannels_bending, totalchannels_nonbending);
319 factory.DeleteSegmentations();
322 printf(">>> Event %d \n",ievent);
323 RunLoader->GetEvent(ievent);
326 muondata.SetTreeAddress("D");
327 muondata.GetDigits();
329 for( ichamber=0; ichamber<nchambers; ichamber++) {
330 cHoccupancy_bending[ichamber] = 0;
331 cHoccupancy_nonbending[ichamber]= 0;
332 Int_t idigit, ndigits;
333 ndigits = (Int_t) muondata.Digits(ichamber)->GetEntriesFast();
334 for(idigit=0; idigit<ndigits; idigit++) {
335 mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber)->At(idigit));
336 Int_t detele = mDigit->DetElemId();
337 Int_t idetele = detele-(ichamber+1)*100;
338 if ( mDigit->Cathode() == 0 ) {
340 cHoccupancy_bending[ichamber]++;
341 dEoccupancy_bending[ichamber][idetele]++;
342 totaloccupancy_bending++;
345 cHoccupancy_nonbending[ichamber]++;
346 dEoccupancy_nonbending[ichamber][idetele]++;
347 totaloccupancy_nonbending++;
351 printf(">>> Chamber %2d nChannels Bending %5d nChannels NonBending %5d \n",
353 cHoccupancy_bending[ichamber],
354 cHoccupancy_nonbending[ichamber]);
355 printf(">>> Chamber %2d Occupancy Bending %5.2f %% Occupancy NonBending %5.2f %% \n",
357 100.*((Float_t) cHoccupancy_bending[ichamber])/((Float_t) cHchannels_bending[ichamber]),
358 100.*((Float_t) cHoccupancy_nonbending[ichamber])/((Float_t) cHchannels_bending[ichamber]) );
361 for(Int_t idetele=0; idetele<26; idetele++) {
362 Int_t detele = idetele + 100*(ichamber+1);
363 if ( AliMpDEManager::IsValidDetElemId(detele) ) {
365 printf(">>> DetEle %4d nChannels Bending %5d nChannels NonBending %5d \n",
366 idetele+100*(ichamber+1),
367 dEoccupancy_bending[ichamber][idetele],
368 dEoccupancy_nonbending[ichamber][idetele]);
369 printf(">>> DetEle %4d Occupancy Bending %5.2f %% Occupancy NonBending %5.2f %% \n",
370 idetele+100*(ichamber+1),
371 100.*((Float_t) dEoccupancy_bending[ichamber][idetele])/((Float_t) dEchannels_bending[ichamber][idetele]),
372 100.*((Float_t) dEoccupancy_nonbending[ichamber][idetele])/((Float_t) dEchannels_bending[ichamber][idetele]));
376 } // end chamber loop
377 printf(">>> Muon Spectrometer Occupancy Bending %5.2f %% Occupancy NonBending %5.2f %% \n",
378 100.*((Float_t) totaloccupancy_bending)/((Float_t) totalchannels_bending),
379 100.*((Float_t) totaloccupancy_nonbending)/((Float_t) totalchannels_nonbending) );
380 muondata.ResetDigits();
381 // } // end cathode loop
382 MUONLoader->UnloadDigits();
385 void MUONrecpoints(Int_t event2Check=0, char * filename="galice.root") {
387 // Creating Run Loader and openning file containing Hits
388 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
389 if (RunLoader ==0x0) {
390 printf(">>> Error : Error Opening %s file \n",filename);
393 // Getting MUONloader
394 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
395 MUONLoader->LoadRecPoints("READ");
396 // Creating MUON data container
397 AliMUONData muondata(MUONLoader,"MUON","MUON");
399 Int_t ievent, nevents;
400 nevents = RunLoader->GetNumberOfEvents();
401 AliMUONRawCluster * mRecPoint = 0;
403 for(ievent=0; ievent<nevents; ievent++) {
404 if (event2Check!=0) ievent=event2Check;
405 printf(">>> Event %d \n",ievent);
406 RunLoader->GetEvent(ievent);
408 Int_t ichamber, nchambers;
409 nchambers = AliMUONConstants::NTrackingCh();
410 muondata.SetTreeAddress("RC,TC");
412 muondata.GetRawClusters();
414 for( ichamber=0; ichamber<nchambers; ichamber++) {
415 sprintf(branchname,"MUONRawClusters%d",ichamber+1);
416 //printf(">>> branchname %s\n",branchname);
417 Int_t irecpoint, nrecpoints;
418 nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
419 // printf(">>> Chamber %2d, Number of recpoints = %6d \n",ichamber+1, nrecpoints);
420 for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
421 mRecPoint = static_cast<AliMUONRawCluster*>(muondata.RawClusters(ichamber)->At(irecpoint));
422 mRecPoint->Print("full");
423 } // end recpoint loop
424 } // end chamber loop
425 muondata.ResetRawClusters();
426 if (event2Check!=0) ievent=nevents;
428 MUONLoader->UnloadRecPoints();
431 void MUONrectrigger (Int_t event2Check=0, char * filename="galice.root", Int_t WRITE = 0, Bool_t readFromRP = 0)
434 // reads and dumps trigger objects from MUON.RecPoints.root
435 TClonesArray * globalTrigger;
436 TClonesArray * localTrigger;
438 // Do NOT print out all the info if the loop runs over all events
439 Int_t PRINTOUT = (event2Check == 0 ) ? 0 : 1 ;
441 // Book a ntuple for more detailled studies
442 TNtuple *TgtupleGlo = new TNtuple("TgtupleGlo","Global Trigger Ntuple","ev:global:slpt:shpt:uplpt:uphpt:lplpt:lplpt");
443 TNtuple *TgtupleLoc = new TNtuple("TgtupleLoc","Local Trigger Ntuple","ev:LoCircuit:LoStripX:LoDev:StripY:LoLpt:LoHpt:y11:y21:x11");
446 Int_t SLowpt=0,SHighpt=0;
447 Int_t USLowpt=0,USHighpt=0;
448 Int_t LSLowpt=0,LSHighpt=0;
450 // Creating Run Loader and openning file containing Hits
451 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
452 if (RunLoader ==0x0) {
453 printf(">>> Error : Error Opening %s file \n",filename);
457 AliMUONTriggerCrateStore* crateManager = new AliMUONTriggerCrateStore();
458 crateManager->ReadFromFile();
460 AliMpSegFactory* segFactory = new AliMpSegFactory();
462 AliMUONGeometryTransformer* transformer = new AliMUONGeometryTransformer(kFALSE);
463 transformer->ReadGeometryData("volpath.dat", "geometry.root");
465 TClonesArray* triggerCircuit = new TClonesArray("AliMUONTriggerCircuit", 234);
467 for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++) {
468 AliMUONTriggerCircuit* c = new AliMUONTriggerCircuit();
469 c->SetSegFactory(segFactory);
470 c->SetTransformer(transformer);
471 c->Init(i,*crateManager);
472 TClonesArray& circuit = *triggerCircuit;
473 new(circuit[circuit.GetEntriesFast()])AliMUONTriggerCircuit(*c);
478 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
480 cout << " reading from digits \n";
481 MUONLoader->LoadDigits("READ");
482 sprintf(fileName,"TriggerCheckFromDigits.root");
484 cout << " reading from RecPoints \n";
485 MUONLoader->LoadRecPoints("READ");
486 sprintf(fileName,"TriggerCheckFromRP.root");
489 // Creating MUON data container
490 AliMUONData muondata(MUONLoader,"MUON","MUON");
493 Int_t ievent, nevents;
494 nevents = RunLoader->GetNumberOfEvents();
496 AliMUONGlobalTrigger *gloTrg(0x0);
497 AliMUONLocalTrigger *locTrg(0x0);
499 for (ievent=0; ievent<nevents; ievent++) {
500 if (event2Check!=0) ievent=event2Check;
501 if (ievent%100==0 || event2Check) cout << "Processing event " << ievent << endl;
502 RunLoader->GetEvent(ievent);
505 muondata.SetTreeAddress("D,GLT");
506 muondata.GetTriggerD();
508 muondata.SetTreeAddress("RC,TC");
509 muondata.GetTrigger();
512 globalTrigger = muondata.GlobalTrigger();
513 localTrigger = muondata.LocalTrigger();
515 Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
516 Int_t nlocals = (Int_t) localTrigger->GetEntriesFast(); // up to 234
517 if (PRINTOUT) printf("###################################################\n");
518 if (PRINTOUT) printf("event %d nglobal %d nlocal %d \n",ievent,nglobals,nlocals);
520 for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
521 gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
523 SLowpt+=gloTrg->SingleLpt() ;
524 SHighpt+=gloTrg->SingleHpt() ;
525 USLowpt+=gloTrg->PairUnlikeLpt();
526 USHighpt+=gloTrg->PairUnlikeHpt();
527 LSLowpt+=gloTrg->PairLikeLpt();
528 LSHighpt+=gloTrg->PairLikeHpt();
530 if (PRINTOUT) gloTrg->Print("full");
532 } // end of loop on Global Trigger
534 for (Int_t ilocal=0; ilocal<nlocals; ilocal++) { // Local Trigger
535 locTrg = static_cast<AliMUONLocalTrigger*>(localTrigger->At(ilocal));
536 if (PRINTOUT) locTrg->Print("full");
538 AliMUONTriggerCircuit* circuit = (AliMUONTriggerCircuit*)triggerCircuit->At(locTrg->LoCircuit()-1);
540 TgtupleLoc->Fill(ievent,locTrg->LoCircuit(),locTrg->LoStripX(),locTrg->LoDev(),locTrg->LoStripY(),locTrg->LoLpt(),locTrg->LoHpt(),circuit->GetY11Pos(locTrg->LoStripX()),circuit->GetY21Pos(locTrg->LoStripX()+locTrg->LoDev()+1),circuit->GetX11Pos(locTrg->LoStripY()));
541 } // end of loop on Local Trigger
544 TgtupleGlo->Fill(ievent,nglobals,gloTrg->SingleLpt(),gloTrg->SingleHpt(),gloTrg->PairUnlikeLpt(),gloTrg->PairUnlikeHpt(),gloTrg->PairLikeLpt(),gloTrg->PairLikeHpt());
546 muondata.ResetTrigger();
547 if (event2Check!=0) ievent=nevents;
548 } // end loop on event
550 // Print out summary if loop ran over all event
554 printf("=============================================\n");
555 printf("================ SUMMARY ==================\n");
557 printf("Total number of events processed %d \n", (event2Check==0) ? nevents : 1);
559 printf(" Global Trigger output Low pt High pt\n");
560 printf(" number of Single :\t");
561 printf("%i\t%i\t",SLowpt,SHighpt);
563 printf(" number of UnlikeSign pair :\t");
564 printf("%i\t%i\t",USLowpt,USHighpt);
566 printf(" number of LikeSign pair :\t");
567 printf("%i\t%i\t",LSLowpt,LSHighpt);
569 printf("=============================================\n");
574 TFile *myFile = new TFile(fileName, "RECREATE");
580 MUONLoader->UnloadRecPoints();
585 delete triggerCircuit;
590 void MUONrectracks (Int_t event2Check=0, char * filename="galice.root"){
591 // reads and dumps trigger objects from MUON.RecPoints.root
592 TClonesArray * RecTracks;
594 // Creating Run Loader and openning file containing Hits
595 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
596 if (RunLoader ==0x0) {
597 printf(">>> Error : Error Opening %s file \n",filename);
600 // waiting for mag field in CDB
601 printf("Loading field map...\n");
602 if (!AliTracker::GetFieldMap()) {
603 AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
604 AliTracker::SetFieldMap(field, kFALSE);
606 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
607 MUONLoader->LoadTracks("READ");
608 // Creating MUON data container
609 AliMUONData muondata(MUONLoader,"MUON","MUON");
611 Int_t ievent, nevents;
612 nevents = RunLoader->GetNumberOfEvents();
614 // AliMUONTrack * rectrack;
616 for (ievent=0; ievent<nevents; ievent++) {
617 if (event2Check!=0) ievent=event2Check;
618 RunLoader->GetEvent(ievent);
620 muondata.SetTreeAddress("RT");
621 muondata.GetRecTracks();
622 RecTracks = muondata.RecTracks();
625 Int_t nrectracks = (Int_t) RecTracks->GetEntriesFast(); //
627 printf(">>> Event %d, Number of Recconstructed tracks %d \n",ievent, nrectracks);
630 // setting pointer for tracks, triggertracks & trackparam at vertex
631 AliMUONTrack* recTrack = 0;
632 AliMUONTrackParam* trackParam = 0;
634 // set the magnetic field for track extrapolations
635 AliMUONTrackExtrap::SetField(AliTracker::GetFieldMap());
636 for (Int_t iRecTracks = 0; iRecTracks < nrectracks; iRecTracks++) {
637 // // reading info from tracks
638 recTrack = (AliMUONTrack*) RecTracks->At(iRecTracks);
639 trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
640 AliMUONTrackExtrap::ExtrapToZ(trackParam,0.);
641 recTrack->Print("full");
644 muondata.ResetRecTracks();
645 if (event2Check!=0) ievent=nevents;
646 } // end loop on event
647 MUONLoader->UnloadTracks();