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 "AliMUONTriggerCircuit.h"
54 #include "AliMUONTriggerCrateStore.h"
56 #include "AliMpVSegmentation.h"
57 #include "AliMpIntPair.h"
58 #include "AliMpDEManager.h"
59 #include "AliMpSegFactory.h"
62 void MUONkine(Int_t event2Check=0, char * filename="galice.root")
64 // Stack of particle for each event
66 // Creating Run Loader and openning file containing Hits
67 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
68 if (RunLoader ==0x0) {
69 printf(">>> Error : Error Opening %s file \n",filename);
73 RunLoader->LoadKinematics("READ");
74 Int_t ievent, nevents;
75 nevents = RunLoader->GetNumberOfEvents();
77 for(ievent=0; ievent<nevents; ievent++) { // Event loop
78 if (event2Check!=0) ievent=event2Check;
79 Int_t iparticle, nparticles;
80 // Getting event ievent
81 RunLoader->GetEvent(ievent);
82 stack = RunLoader->Stack();
83 nparticles = (Int_t) stack->GetNtrack();
84 printf(">>> Event %d, Number of particles is %d \n",ievent, nparticles);
85 for(iparticle=0; iparticle<nparticles; iparticle++) {
86 stack->Particle(iparticle)->Print("");
88 if (event2Check!=0) ievent=nevents;
90 RunLoader->UnloadKinematics();
94 void MUONhits(Int_t event2Check=0, char * filename="galice.root")
96 // Creating Run Loader and openning file containing Hits
97 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
98 if (RunLoader ==0x0) {
99 printf(">>> Error : Error Opening %s file \n",filename);
102 // Loading MUON subsystem
103 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
104 MUONLoader->LoadHits("READ"); // Loading Tree of hits for MUON
105 AliMUONData muondata(MUONLoader,"MUON","MUON"); // Creating MUON data container
106 Int_t ievent, nevents;
107 nevents = RunLoader->GetNumberOfEvents();
109 for(ievent=0; ievent<nevents; ievent++) { // Event loop
110 if (event2Check!=0) ievent=event2Check;
111 printf(">>> Event %d \n",ievent);
112 // Getting event ievent
113 RunLoader->GetEvent(ievent);
114 muondata.SetTreeAddress("H");
115 Int_t itrack, ntracks;
116 ntracks = (Int_t) muondata.GetNtracks();
117 for (itrack=0; itrack<ntracks; itrack++) { // Track loop
118 //Getting List of Hits of Track itrack
119 muondata.GetTrack(itrack);
121 nhits = (Int_t) muondata.Hits()->GetEntriesFast();
122 printf(">>> Track %d, Number of hits %d \n",itrack,nhits);
124 for(ihit=0; ihit<nhits; ihit++) {
125 mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
128 muondata.ResetHits();
130 if (event2Check!=0) ievent=nevents;
132 MUONLoader->UnloadHits();
136 void MUONdigits(Int_t event2Check=0, char * filename="galice.root")
138 // Creating Run Loader and openning file containing Hits
139 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
140 if (RunLoader ==0x0) {
141 printf(">>> Error : Error Opening %s file \n",filename);
144 // Loading MUON subsystem
145 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
146 MUONLoader->LoadDigits("READ");
147 // Creating MUON data container
148 AliMUONData muondata(MUONLoader,"MUON","MUON");
150 Int_t ievent, nevents;
151 nevents = RunLoader->GetNumberOfEvents();
152 AliMUONDigit * mDigit;
154 for(ievent=0; ievent<nevents; ievent++) {
155 if (event2Check!=0) ievent=event2Check;
156 printf(">>> Event %d \n",ievent);
157 RunLoader->GetEvent(ievent);
160 Int_t ichamber, nchambers;
161 nchambers = AliMUONConstants::NCh(); ;
162 muondata.SetTreeAddress("D,GLT");
164 muondata.GetDigits();
166 for( ichamber=0; ichamber<nchambers; ichamber++) {
167 Int_t idigit, ndigits;
168 TClonesArray* digits = muondata.Digits(ichamber);
170 ndigits = (Int_t)digits->GetEntriesFast();
171 for(idigit=0; idigit<ndigits; idigit++) {
172 mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
173 mDigit->Print("tracks");
175 } // end chamber loop
176 muondata.ResetDigits();
177 if (event2Check!=0) ievent=nevents;
179 MUONLoader->UnloadDigits();
182 void MUONsdigits(Int_t event2Check=0, char * filename="galice.root")
184 // Creating Run Loader and openning file containing Hits
185 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
186 if (RunLoader ==0x0) {
187 printf(">>> Error : Error Opening %s file \n",filename);
190 // Loading MUON subsystem
191 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
192 MUONLoader->LoadSDigits("READ");
193 // Creating MUON data container
194 AliMUONData muondata(MUONLoader,"MUON","MUON");
196 Int_t ievent, nevents;
197 nevents = RunLoader->GetNumberOfEvents();
198 AliMUONDigit * mDigit;
200 for(ievent=0; ievent<nevents; ievent++) {
201 if (event2Check!=0) ievent=event2Check;
202 printf(">>> Event %d \n",ievent);
203 RunLoader->GetEvent(ievent);
206 Int_t ichamber, nchambers;
207 nchambers = AliMUONConstants::NCh(); ;
208 muondata.SetTreeAddress("S");
210 muondata.GetSDigits();
212 for( ichamber=0; ichamber<nchambers; ichamber++) {
213 Int_t idigit, ndigits;
214 TClonesArray* digits = muondata.SDigits(ichamber);
215 ndigits = (Int_t)digits->GetEntriesFast();
216 for(idigit=0; idigit<ndigits; idigit++) {
217 mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
218 mDigit->Print("tracks");
220 } // end chamber loop
221 muondata.ResetSDigits();
222 if (event2Check!=0) ievent=nevents;
224 MUONLoader->UnloadSDigits();
228 void MUONoccupancy(Int_t event2Check=0, Bool_t perDetEle =kFALSE, char * filename="galice.root") {
229 // Creating Run Loader and openning file containing Hits
230 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
231 if (RunLoader ==0x0) {
232 printf(">>> Error : Error Opening %s file \n",filename);
235 // Loading MUON subsystem
236 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
237 MUONLoader->LoadDigits("READ");
238 // Creating MUON data container
239 AliMUONData muondata(MUONLoader,"MUON","MUON");
241 Int_t ievent, nevents;
242 nevents = RunLoader->GetNumberOfEvents();
243 AliMUONDigit * mDigit =0x0;
244 AliMpVSegmentation * segbend = 0x0;
245 AliMpVSegmentation * segnonbend = 0x0;
246 AliMpIntPair pad(0,0);
248 Int_t dEoccupancy_bending[14][26];
249 Int_t dEoccupancy_nonbending[14][26];
250 Int_t cHoccupancy_bending[14];
251 Int_t cHoccupancy_nonbending[14];
252 Int_t totaloccupancy_bending =0;
253 Int_t totaloccupancy_nonbending =0;
255 Int_t dEchannels_bending[14][26];
256 Int_t dEchannels_nonbending[14][26];
257 Int_t cHchannels_bending[14];
258 Int_t cHchannels_nonbending[14];
259 Int_t totalchannels_bending =0;
260 Int_t totalchannels_nonbending =0;
262 Int_t ichamber, nchambers,idetele, detele, ix, iy;
263 nchambers = AliMUONConstants::NCh(); ;
265 AliMpSegFactory factory;
267 for (ichamber=0; ichamber<nchambers; ichamber++) {
268 cHchannels_bending[ichamber]=0;
269 cHchannels_nonbending[ichamber]=0;
270 for (idetele=0; idetele<26; idetele++) {
271 detele= 100*(ichamber +1)+idetele;
272 dEchannels_bending[ichamber][idetele]=0;
273 dEchannels_nonbending[ichamber][idetele]=0;
274 dEoccupancy_bending[ichamber][idetele]=0;
275 dEoccupancy_nonbending[ichamber][idetele]=0;
276 if ( AliMpDEManager::IsValidDetElemId(detele) ) {
278 segbend = factory.CreateMpSegmentation(detele, 0);
279 segnonbend = factory.CreateMpSegmentation(detele, 1);
280 if (AliMpDEManager::GetPlaneType(detele, 0) != kBendingPlane ) {
281 AliMpVSegmentation* tmp = segbend;
282 segbend = segnonbend;
286 for(ix=0; ix<=segbend->MaxPadIndexX(); ix++) {
287 for(iy=0; iy<=segbend->MaxPadIndexY(); iy++) {
290 if( segbend->HasPad(pad) ) {
291 dEchannels_bending[ichamber][idetele]++;
292 cHchannels_bending[ichamber]++;
293 totalchannels_bending++;
297 for(ix=0; ix<=segnonbend->MaxPadIndexX(); ix++) {
298 for(iy=0; iy<=segnonbend->MaxPadIndexY(); iy++) {
301 if(segnonbend->HasPad(pad)) {
302 dEchannels_nonbending[ichamber][idetele]++;
303 cHchannels_nonbending[ichamber]++;
304 totalchannels_nonbending++;
308 if (perDetEle) printf(">>> Detection element %4d has %5d channels in bending and %5d channels in nonbending \n",
309 detele, dEchannels_bending[ichamber][idetele], dEchannels_nonbending[ichamber][idetele] );
312 printf(">>> Chamber %2d has %6d channels in bending and %6d channels in nonbending \n",
313 ichamber+1, cHchannels_bending[ichamber], cHchannels_nonbending[ichamber]);
315 printf(">>Spectrometer has %7d channels in bending and %7d channels in nonbending \n",
316 totalchannels_bending, totalchannels_nonbending);
318 factory.DeleteSegmentations();
321 printf(">>> Event %d \n",ievent);
322 RunLoader->GetEvent(ievent);
325 muondata.SetTreeAddress("D");
326 muondata.GetDigits();
328 for( ichamber=0; ichamber<nchambers; ichamber++) {
329 cHoccupancy_bending[ichamber] = 0;
330 cHoccupancy_nonbending[ichamber]= 0;
331 Int_t idigit, ndigits;
332 ndigits = (Int_t) muondata.Digits(ichamber)->GetEntriesFast();
333 for(idigit=0; idigit<ndigits; idigit++) {
334 mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber)->At(idigit));
335 Int_t detele = mDigit->DetElemId();
336 Int_t idetele = detele-(ichamber+1)*100;
337 if ( mDigit->Cathode() == 0 ) {
339 cHoccupancy_bending[ichamber]++;
340 dEoccupancy_bending[ichamber][idetele]++;
341 totaloccupancy_bending++;
344 cHoccupancy_nonbending[ichamber]++;
345 dEoccupancy_nonbending[ichamber][idetele]++;
346 totaloccupancy_nonbending++;
350 printf(">>> Chamber %2d nChannels Bending %5d nChannels NonBending %5d \n",
352 cHoccupancy_bending[ichamber],
353 cHoccupancy_nonbending[ichamber]);
354 printf(">>> Chamber %2d Occupancy Bending %5.2f %% Occupancy NonBending %5.2f %% \n",
356 100.*((Float_t) cHoccupancy_bending[ichamber])/((Float_t) cHchannels_bending[ichamber]),
357 100.*((Float_t) cHoccupancy_nonbending[ichamber])/((Float_t) cHchannels_bending[ichamber]) );
360 for(Int_t idetele=0; idetele<26; idetele++) {
361 Int_t detele = idetele + 100*(ichamber+1);
362 if ( AliMpDEManager::IsValidDetElemId(detele) ) {
364 printf(">>> DetEle %4d nChannels Bending %5d nChannels NonBending %5d \n",
365 idetele+100*(ichamber+1),
366 dEoccupancy_bending[ichamber][idetele],
367 dEoccupancy_nonbending[ichamber][idetele]);
368 printf(">>> DetEle %4d Occupancy Bending %5.2f %% Occupancy NonBending %5.2f %% \n",
369 idetele+100*(ichamber+1),
370 100.*((Float_t) dEoccupancy_bending[ichamber][idetele])/((Float_t) dEchannels_bending[ichamber][idetele]),
371 100.*((Float_t) dEoccupancy_nonbending[ichamber][idetele])/((Float_t) dEchannels_bending[ichamber][idetele]));
375 } // end chamber loop
376 printf(">>> Muon Spectrometer Occupancy Bending %5.2f %% Occupancy NonBending %5.2f %% \n",
377 100.*((Float_t) totaloccupancy_bending)/((Float_t) totalchannels_bending),
378 100.*((Float_t) totaloccupancy_nonbending)/((Float_t) totalchannels_nonbending) );
379 muondata.ResetDigits();
380 // } // end cathode loop
381 MUONLoader->UnloadDigits();
384 void MUONrecpoints(Int_t event2Check=0, char * filename="galice.root") {
386 // Creating Run Loader and openning file containing Hits
387 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
388 if (RunLoader ==0x0) {
389 printf(">>> Error : Error Opening %s file \n",filename);
392 // Getting MUONloader
393 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
394 MUONLoader->LoadRecPoints("READ");
395 // Creating MUON data container
396 AliMUONData muondata(MUONLoader,"MUON","MUON");
398 Int_t ievent, nevents;
399 nevents = RunLoader->GetNumberOfEvents();
400 AliMUONRawCluster * mRecPoint = 0;
402 for(ievent=0; ievent<nevents; ievent++) {
403 if (event2Check!=0) ievent=event2Check;
404 printf(">>> Event %d \n",ievent);
405 RunLoader->GetEvent(ievent);
407 Int_t ichamber, nchambers;
408 nchambers = AliMUONConstants::NTrackingCh();
409 muondata.SetTreeAddress("RC,TC");
411 muondata.GetRawClusters();
413 for( ichamber=0; ichamber<nchambers; ichamber++) {
414 sprintf(branchname,"MUONRawClusters%d",ichamber+1);
415 //printf(">>> branchname %s\n",branchname);
416 Int_t irecpoint, nrecpoints;
417 nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
418 // printf(">>> Chamber %2d, Number of recpoints = %6d \n",ichamber+1, nrecpoints);
419 for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
420 mRecPoint = static_cast<AliMUONRawCluster*>(muondata.RawClusters(ichamber)->At(irecpoint));
421 mRecPoint->Print("full");
422 } // end recpoint loop
423 } // end chamber loop
424 muondata.ResetRawClusters();
425 if (event2Check!=0) ievent=nevents;
427 MUONLoader->UnloadRecPoints();
430 void MUONrectrigger (Int_t event2Check=0, char * filename="galice.root", Int_t WRITE = 0, Bool_t readFromRP = 0)
433 // reads and dumps trigger objects from MUON.RecPoints.root
434 TClonesArray * globalTrigger;
435 TClonesArray * localTrigger;
437 // Do NOT print out all the info if the loop runs over all events
438 Int_t PRINTOUT = (event2Check == 0 ) ? 0 : 1 ;
440 // Book a ntuple for more detailled studies
441 TNtuple *TgtupleGlo = new TNtuple("TgtupleGlo","Global Trigger Ntuple","ev:global:slpt:shpt:uplpt:uphpt:lplpt:lplpt");
442 TNtuple *TgtupleLoc = new TNtuple("TgtupleLoc","Local Trigger Ntuple","ev:LoCircuit:LoStripX:LoDev:StripY:LoLpt:LoHpt:y11:y21:x11");
445 Int_t SLowpt=0,SHighpt=0;
446 Int_t USLowpt=0,USHighpt=0;
447 Int_t LSLowpt=0,LSHighpt=0;
449 // Creating Run Loader and openning file containing Hits
450 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
451 if (RunLoader ==0x0) {
452 printf(">>> Error : Error Opening %s file \n",filename);
456 AliMUONTriggerCrateStore* crateManager = new AliMUONTriggerCrateStore();
457 crateManager->ReadFromFile();
459 AliMpSegFactory* segFactory = new AliMpSegFactory();
461 AliMUONGeometryTransformer* transformer = new AliMUONGeometryTransformer(kFALSE);
462 transformer->ReadGeometryData("volpath.dat", "geometry.root");
464 TClonesArray* triggerCircuit = new TClonesArray("AliMUONTriggerCircuit", 234);
466 for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++) {
467 AliMUONTriggerCircuit* c = new AliMUONTriggerCircuit();
468 c->SetSegFactory(segFactory);
469 c->SetTransformer(transformer);
470 c->Init(i,*crateManager);
471 TClonesArray& circuit = *triggerCircuit;
472 new(circuit[circuit.GetEntriesFast()])AliMUONTriggerCircuit(*c);
477 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
479 cout << " reading from digits \n";
480 MUONLoader->LoadDigits("READ");
481 sprintf(fileName,"TriggerCheckFromDigits.root");
483 cout << " reading from RecPoints \n";
484 MUONLoader->LoadRecPoints("READ");
485 sprintf(fileName,"TriggerCheckFromRP.root");
488 // Creating MUON data container
489 AliMUONData muondata(MUONLoader,"MUON","MUON");
492 Int_t ievent, nevents;
493 nevents = RunLoader->GetNumberOfEvents();
495 AliMUONGlobalTrigger *gloTrg(0x0);
496 AliMUONLocalTrigger *locTrg(0x0);
498 for (ievent=0; ievent<nevents; ievent++) {
499 if (event2Check!=0) ievent=event2Check;
500 if (ievent%100==0 || event2Check) cout << "Processing event " << ievent << endl;
501 RunLoader->GetEvent(ievent);
504 muondata.SetTreeAddress("D,GLT");
505 muondata.GetTriggerD();
507 muondata.SetTreeAddress("RC,TC");
508 muondata.GetTrigger();
511 globalTrigger = muondata.GlobalTrigger();
512 localTrigger = muondata.LocalTrigger();
514 Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
515 Int_t nlocals = (Int_t) localTrigger->GetEntriesFast(); // up to 234
516 if (PRINTOUT) printf("###################################################\n");
517 if (PRINTOUT) printf("event %d nglobal %d nlocal %d \n",ievent,nglobals,nlocals);
519 for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
520 gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
522 SLowpt+=gloTrg->SingleLpt() ;
523 SHighpt+=gloTrg->SingleHpt() ;
524 USLowpt+=gloTrg->PairUnlikeLpt();
525 USHighpt+=gloTrg->PairUnlikeHpt();
526 LSLowpt+=gloTrg->PairLikeLpt();
527 LSHighpt+=gloTrg->PairLikeHpt();
529 if (PRINTOUT) gloTrg->Print("full");
531 } // end of loop on Global Trigger
533 for (Int_t ilocal=0; ilocal<nlocals; ilocal++) { // Local Trigger
534 locTrg = static_cast<AliMUONLocalTrigger*>(localTrigger->At(ilocal));
535 if (PRINTOUT) locTrg->Print("full");
537 AliMUONTriggerCircuit* circuit = (AliMUONTriggerCircuit*)triggerCircuit->At(locTrg->LoCircuit()-1);
539 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()));
540 } // end of loop on Local Trigger
543 TgtupleGlo->Fill(ievent,nglobals,gloTrg->SingleLpt(),gloTrg->SingleHpt(),gloTrg->PairUnlikeLpt(),gloTrg->PairUnlikeHpt(),gloTrg->PairLikeLpt(),gloTrg->PairLikeHpt());
545 muondata.ResetTrigger();
546 if (event2Check!=0) ievent=nevents;
547 } // end loop on event
549 // Print out summary if loop ran over all event
553 printf("=============================================\n");
554 printf("================ SUMMARY ==================\n");
556 printf("Total number of events processed %d \n", (event2Check==0) ? nevents : 1);
558 printf(" Global Trigger output Low pt High pt\n");
559 printf(" number of Single :\t");
560 printf("%i\t%i\t",SLowpt,SHighpt);
562 printf(" number of UnlikeSign pair :\t");
563 printf("%i\t%i\t",USLowpt,USHighpt);
565 printf(" number of LikeSign pair :\t");
566 printf("%i\t%i\t",LSLowpt,LSHighpt);
568 printf("=============================================\n");
573 TFile *myFile = new TFile(fileName, "RECREATE");
579 MUONLoader->UnloadRecPoints();
584 delete triggerCircuit;
589 void MUONrectracks (Int_t event2Check=0, char * filename="galice.root"){
590 // reads and dumps trigger objects from MUON.RecPoints.root
591 TClonesArray * RecTracks;
593 // Creating Run Loader and openning file containing Hits
594 AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
595 if (RunLoader ==0x0) {
596 printf(">>> Error : Error Opening %s file \n",filename);
599 // waiting for mag field in CDB
600 printf("Loading field map...\n");
601 if (!AliTracker::GetFieldMap()) {
602 AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
603 AliTracker::SetFieldMap(field, kFALSE);
605 AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
606 MUONLoader->LoadTracks("READ");
607 // Creating MUON data container
608 AliMUONData muondata(MUONLoader,"MUON","MUON");
610 Int_t ievent, nevents;
611 nevents = RunLoader->GetNumberOfEvents();
613 // AliMUONTrack * rectrack;
615 for (ievent=0; ievent<nevents; ievent++) {
616 if (event2Check!=0) ievent=event2Check;
617 RunLoader->GetEvent(ievent);
619 muondata.SetTreeAddress("RT");
620 muondata.GetRecTracks();
621 RecTracks = muondata.RecTracks();
624 Int_t nrectracks = (Int_t) RecTracks->GetEntriesFast(); //
626 printf(">>> Event %d, Number of Recconstructed tracks %d \n",ievent, nrectracks);
629 // setting pointer for tracks, triggertracks & trackparam at vertex
630 AliMUONTrack* recTrack = 0;
631 AliMUONTrackParam* trackParam = 0;
633 for (Int_t iRecTracks = 0; iRecTracks < nrectracks; iRecTracks++) {
634 // // reading info from tracks
635 recTrack = (AliMUONTrack*) RecTracks->At(iRecTracks);
636 trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
637 trackParam->ExtrapToZ(0.0);
638 recTrack->Print("full");
641 muondata.ResetRecTracks();
642 if (event2Check!=0) ievent=nevents;
643 } // end loop on event
644 MUONLoader->UnloadTracks();