6d43344fa8c2ad5a9795c69890387d658155955c
[u/mrichter/AliRoot.git] / MUON / MUONCheck.C
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
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  **************************************************************************/
15
16 /* $Id$ */
17
18 //
19 // Macro for checking aliroot output and associated files contents
20 // Gines Martinez, Subatech June 2003
21 //
22 #if !defined(__CINT__) || defined(__MAKECINT__)
23 // ROOT includes
24 #include "TBranch.h"
25 #include "TClonesArray.h"
26 #include "TFile.h"
27 #include "TH1.h"
28 #include "TMath.h"
29 #include "TParticle.h"
30 #include "TTree.h"
31 #include "TNtuple.h"
32
33 // STEER includes
34 #include "AliRun.h"
35 #include "AliRunLoader.h"
36 #include "AliHeader.h"
37 #include "AliLoader.h"
38 #include "AliStack.h"
39 #include "AliTracker.h"
40 #include "AliMagFMaps.h"
41
42 // MUON includes
43 #include "AliMUON.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 "AliMUONTriggerConstants.h"
54 #include "AliMUONTriggerCircuitNew.h"
55 #include "AliMUONTriggerCrateStore.h"
56
57 #include "AliMpVSegmentation.h"
58 #include "AliMpIntPair.h"
59 #include "AliMpDEManager.h"
60 #include "AliMpSegFactory.h"
61 #endif
62
63 void MUONkine(Int_t event2Check=0, char * filename="galice.root")
64 {
65   // Stack of particle for each event
66   AliStack* stack;
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);
71     return;
72   }
73
74   RunLoader->LoadKinematics("READ");
75   Int_t ievent, nevents;
76   nevents = RunLoader->GetNumberOfEvents();
77
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("");  
88     }
89     if (event2Check!=0) ievent=nevents;
90   }
91   RunLoader->UnloadKinematics();
92 }
93
94
95 void MUONhits(Int_t event2Check=0, char * filename="galice.root")
96 {
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);
101     return;
102   }
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();
109
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);
121       Int_t ihit, nhits;
122       nhits = (Int_t) muondata.Hits()->GetEntriesFast();
123       printf(">>> Track %d, Number of hits %d \n",itrack,nhits);
124       AliMUONHit* mHit;
125       for(ihit=0; ihit<nhits; ihit++) {
126         mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
127         mHit->Print("full");
128       }
129       muondata.ResetHits();
130     } // end track loop
131     if (event2Check!=0) ievent=nevents;
132   }  // end event loop
133   MUONLoader->UnloadHits();
134 }
135
136
137 void MUONdigits(Int_t event2Check=0, char * filename="galice.root")
138 {
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);
143     return;
144   }
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");
150   
151   Int_t ievent, nevents;
152   nevents = RunLoader->GetNumberOfEvents();
153   AliMUONDigit * mDigit;
154   
155   for(ievent=0; ievent<nevents; ievent++) {
156     if (event2Check!=0) ievent=event2Check;
157     printf(">>> Event %d \n",ievent);
158     RunLoader->GetEvent(ievent);
159     
160     // Addressing
161     Int_t ichamber, nchambers;
162     nchambers = AliMUONConstants::NCh(); ;
163     muondata.SetTreeAddress("D,GLT");
164     
165     muondata.GetDigits();
166     // Loop on chambers
167     for( ichamber=0; ichamber<nchambers; ichamber++) {
168       Int_t idigit, ndigits;
169       TClonesArray* digits = muondata.Digits(ichamber);
170       digits->Sort();
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");
175       } // end digit loop
176     } // end chamber loop
177     muondata.ResetDigits();
178     if (event2Check!=0) ievent=nevents;
179   }  // end event loop
180   MUONLoader->UnloadDigits();
181 }
182
183 void MUONsdigits(Int_t event2Check=0, char * filename="galice.root")
184 {
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);
189     return;
190   }
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");
196   
197   Int_t ievent, nevents;
198   nevents = RunLoader->GetNumberOfEvents();
199   AliMUONDigit * mDigit;
200   
201   for(ievent=0; ievent<nevents; ievent++) {
202     if (event2Check!=0) ievent=event2Check;
203     printf(">>> Event %d \n",ievent);
204     RunLoader->GetEvent(ievent);
205     
206     // Addressing
207     Int_t ichamber, nchambers;
208     nchambers = AliMUONConstants::NCh(); ;
209     muondata.SetTreeAddress("S");
210     
211     muondata.GetSDigits();
212     // Loop on chambers
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");
220       } // end digit loop
221     } // end chamber loop
222     muondata.ResetSDigits();
223     if (event2Check!=0) ievent=nevents;
224   }  // end event loop
225   MUONLoader->UnloadSDigits();
226
227 }
228
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);
234     return;
235   }
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");
241   
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);
248
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;
255
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;
262
263   Int_t ichamber, nchambers,idetele, detele, ix, iy;
264   nchambers = AliMUONConstants::NCh(); ;
265
266   AliMpSegFactory factory;
267
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) ) {
278         
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;
284           segnonbend =  tmp;
285         }  
286           
287         for(ix=0; ix<=segbend->MaxPadIndexX(); ix++) {
288           for(iy=0; iy<=segbend->MaxPadIndexY(); iy++) {
289             pad.SetFirst(ix);
290             pad.SetSecond(iy);
291             if( segbend->HasPad(pad) )   {  
292               dEchannels_bending[ichamber][idetele]++;
293               cHchannels_bending[ichamber]++;
294               totalchannels_bending++;
295             }
296           }
297         }
298         for(ix=0; ix<=segnonbend->MaxPadIndexX(); ix++) {
299           for(iy=0; iy<=segnonbend->MaxPadIndexY(); iy++) {
300             pad.SetFirst(ix);
301             pad.SetSecond(iy);
302             if(segnonbend->HasPad(pad))  {
303               dEchannels_nonbending[ichamber][idetele]++;  
304               cHchannels_nonbending[ichamber]++;
305               totalchannels_nonbending++;
306             }
307           }
308         }
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] ); 
311       }
312     }
313     printf(">>> Chamber %2d has %6d channels in bending and %6d channels in nonbending \n",
314            ichamber+1,  cHchannels_bending[ichamber], cHchannels_nonbending[ichamber]);
315   }
316   printf(">>Spectrometer has  %7d channels in bending and %7d channels in nonbending \n",
317          totalchannels_bending, totalchannels_nonbending);
318
319   factory.DeleteSegmentations();
320
321   ievent=event2Check;
322   printf(">>> Event %d \n",ievent);
323   RunLoader->GetEvent(ievent);
324     
325   // Addressing
326   muondata.SetTreeAddress("D"); 
327   muondata.GetDigits();
328   // Loop on chambers
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 ) {
339
340         cHoccupancy_bending[ichamber]++;
341         dEoccupancy_bending[ichamber][idetele]++;
342         totaloccupancy_bending++;
343       }
344       else {
345         cHoccupancy_nonbending[ichamber]++;
346         dEoccupancy_nonbending[ichamber][idetele]++;
347         totaloccupancy_nonbending++;
348       }
349     } // end digit loop    
350
351     printf(">>> Chamber %2d  nChannels Bending %5d  nChannels NonBending %5d \n", 
352            ichamber+1, 
353            cHoccupancy_bending[ichamber],
354            cHoccupancy_nonbending[ichamber]);           
355     printf(">>> Chamber %2d  Occupancy Bending %5.2f %%  Occupancy NonBending %5.2f %% \n", 
356            ichamber+1, 
357            100.*((Float_t) cHoccupancy_bending[ichamber])/((Float_t) cHchannels_bending[ichamber]),
358            100.*((Float_t) cHoccupancy_nonbending[ichamber])/((Float_t) cHchannels_bending[ichamber])            );
359
360
361     for(Int_t idetele=0; idetele<26; idetele++) {
362       Int_t detele = idetele + 100*(ichamber+1);
363       if ( AliMpDEManager::IsValidDetElemId(detele) ) {
364         if (perDetEle) {
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]));  
373         }
374       }
375     }
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();
383 }
384
385 void MUONrecpoints(Int_t event2Check=0, char * filename="galice.root") {
386
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);
391     return;
392   }
393   // Getting MUONloader
394   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
395   MUONLoader->LoadRecPoints("READ");
396   // Creating MUON data container
397   AliMUONData muondata(MUONLoader,"MUON","MUON");
398
399   Int_t ievent, nevents;
400   nevents = RunLoader->GetNumberOfEvents();
401   AliMUONRawCluster * mRecPoint = 0;
402   
403   for(ievent=0; ievent<nevents; ievent++) {
404     if (event2Check!=0) ievent=event2Check;
405     printf(">>> Event %d \n",ievent);
406     RunLoader->GetEvent(ievent);
407     // Addressing
408     Int_t ichamber, nchambers;
409     nchambers = AliMUONConstants::NTrackingCh();
410     muondata.SetTreeAddress("RC,TC"); 
411     char branchname[30];    
412     muondata.GetRawClusters();
413     // Loop on chambers
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;
427   }  // end event loop
428   MUONLoader->UnloadRecPoints();
429 }
430
431 void MUONrectrigger (Int_t event2Check=0, char * filename="galice.root", Int_t WRITE = 0)
432 {
433
434   // reads and dumps trigger objects from MUON.RecPoints.root
435   TClonesArray * globalTrigger;
436   TClonesArray * localTrigger;
437   
438   // Do NOT print out all the info if the loop runs over all events 
439   Int_t PRINTOUT = (event2Check == 0 ) ? 0 : 1 ;  
440
441   // Book a ntuple for more detailled studies
442   TNtuple *TgtupleGlo = new TNtuple("TgtupleGlo","Global Trigger Ntuple","ev:global:spapt:smapt:undefapt:uplpt:uphpt:upapt:lpapt");
443   TNtuple *TgtupleLoc = new TNtuple("TgtupleLoc","Local Trigger Ntuple","ev:LoCircuit:LoStripX:LoDev:StripY:LoLpt:LoHpt:LoApt:y11:y21:x11");
444
445   // counters
446   Int_t SPLowpt=0,SPHighpt=0,SPAllpt=0;
447   Int_t SMLowpt=0,SMHighpt=0,SMAllpt=0;
448   Int_t SULowpt=0,SUHighpt=0,SUAllpt=0;
449   Int_t USLowpt=0,USHighpt=0,USAllpt=0;
450   Int_t LSLowpt=0,LSHighpt=0,LSAllpt=0;
451
452   // Creating Run Loader and openning file containing Hits
453   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
454   if (RunLoader ==0x0) {
455     printf(">>> Error : Error Opening %s file \n",filename);
456     return;
457   }
458
459   AliMUONTriggerCrateStore* crateManager = new AliMUONTriggerCrateStore();   
460   crateManager->ReadFromFile();
461
462   AliMpSegFactory* segFactory = new AliMpSegFactory();
463     
464   AliMUONGeometryTransformer* transformer = new AliMUONGeometryTransformer(kFALSE);
465   transformer->ReadGeometryData("volpath.dat", "geometry.root");
466
467   TClonesArray*  triggerCircuit = new TClonesArray("AliMUONTriggerCircuitNew", 234);
468
469   for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)  {
470       AliMUONTriggerCircuitNew* c = new AliMUONTriggerCircuitNew();
471       c->SetSegFactory(segFactory);
472       c->SetTransformer(transformer);
473       c->Init(i,*crateManager);
474       TClonesArray& circuit = *triggerCircuit;
475       new(circuit[circuit.GetEntriesFast()])AliMUONTriggerCircuitNew(*c);
476       delete c;
477   }
478   
479   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
480   MUONLoader->LoadDigits("READ");
481   // Creating MUON data container
482   AliMUONData muondata(MUONLoader,"MUON","MUON");
483   
484   
485   Int_t ievent, nevents;
486   nevents = RunLoader->GetNumberOfEvents();
487   
488   AliMUONGlobalTrigger *gloTrg(0x0);
489   AliMUONLocalTrigger *locTrg(0x0);
490   
491   for (ievent=0; ievent<nevents; ievent++) {
492     if (event2Check!=0) ievent=event2Check;
493     if (ievent%100==0 || event2Check) cout << "Processing event " << ievent << endl;
494     RunLoader->GetEvent(ievent);
495     
496     muondata.SetTreeAddress("D,GLT"); 
497     muondata.GetTriggerD();
498     
499     globalTrigger = muondata.GlobalTrigger();
500     localTrigger = muondata.LocalTrigger();
501     
502     Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
503     Int_t nlocals  = (Int_t) localTrigger->GetEntriesFast(); // up to 234
504     if (PRINTOUT) printf("###################################################\n");
505     if (PRINTOUT) printf("event %d nglobal %d nlocal %d \n",ievent,nglobals,nlocals);
506
507     for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
508       gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
509       
510       SPLowpt+=gloTrg->SinglePlusLpt() ;
511       SPHighpt+=gloTrg->SinglePlusHpt() ;
512       SPAllpt+=gloTrg->SinglePlusApt() ;
513       SMLowpt+=gloTrg->SingleMinusLpt();
514       SMHighpt+=gloTrg->SingleMinusHpt();
515       SMAllpt+=gloTrg->SingleMinusApt();
516       SULowpt+=gloTrg->SingleUndefLpt();
517       SUHighpt+=gloTrg->SingleUndefHpt();
518       SUAllpt+=gloTrg->SingleUndefApt();
519       USLowpt+=gloTrg->PairUnlikeLpt(); 
520       USHighpt+=gloTrg->PairUnlikeHpt();
521       USAllpt+=gloTrg->PairUnlikeApt();
522       LSLowpt+=gloTrg->PairLikeLpt(); 
523       LSHighpt+=gloTrg->PairLikeHpt();
524       LSAllpt+=gloTrg->PairLikeApt();
525       
526       if (PRINTOUT) gloTrg->Print("full");
527
528     } // end of loop on Global Trigger
529     
530     for (Int_t ilocal=0; ilocal<nlocals; ilocal++) { // Local Trigger
531       locTrg = static_cast<AliMUONLocalTrigger*>(localTrigger->At(ilocal));
532       if (PRINTOUT) locTrg->Print("full");
533       
534       AliMUONTriggerCircuitNew* circuit = (AliMUONTriggerCircuitNew*)triggerCircuit->At(locTrg->LoCircuit()-1); 
535       
536       TgtupleLoc->Fill(ievent,locTrg->LoCircuit(),locTrg->LoStripX(),locTrg->LoDev(),locTrg->LoStripY(),locTrg->LoLpt(),locTrg->LoHpt(),locTrg->LoApt(),circuit->GetY11Pos(locTrg->LoStripX()),circuit->GetY21Pos(locTrg->LoStripX()+locTrg->LoDev()+1),circuit->GetX11Pos(locTrg->LoStripY()));
537     } // end of loop on Local Trigger
538
539
540     // fill ntuple
541     //TNtuple *Tgtuple = new TNtuple("Tgtuple","Trigger Ntuple","ev:global:spapt:smapt:undefapt:uplpt:uphpt:upapt:lpapt");
542        TgtupleGlo->Fill(ievent,nglobals,gloTrg->SinglePlusApt(),gloTrg->SingleMinusApt(),gloTrg->SingleUndefApt(),gloTrg->PairUnlikeLpt(),gloTrg->PairUnlikeHpt(),gloTrg->PairUnlikeApt(),gloTrg->PairLikeApt());
543
544     muondata.ResetTrigger();
545     if (event2Check!=0) ievent=nevents;
546   } // end loop on event  
547   
548   // Print out summary if loop ran over all event
549   if (!event2Check){
550
551     printf("\n");
552     printf("===================================================\n");
553     printf("===================  SUMMARY  =====================\n");
554     printf("\n");
555     printf("Total number of events processed %d \n", (event2Check==0) ? nevents : 1);
556     printf("\n");
557     printf(" Global Trigger output       Low pt  High pt   All\n");
558     printf(" number of Single Plus      :\t");
559     printf("%i\t%i\t%i\t",SPLowpt,SPHighpt,SPAllpt);
560     printf("\n");
561     printf(" number of Single Minus     :\t");
562     printf("%i\t%i\t%i\t",SMLowpt,SMHighpt,SMAllpt);
563     printf("\n");
564     printf(" number of Single Undefined :\t"); 
565     printf("%i\t%i\t%i\t",SULowpt,SUHighpt,SUAllpt);
566     printf("\n");
567     printf(" number of UnlikeSign pair  :\t"); 
568     printf("%i\t%i\t%i\t",USLowpt,USHighpt,USAllpt);
569     printf("\n");
570     printf(" number of LikeSign pair    :\t");  
571     printf("%i\t%i\t%i\t",LSLowpt,LSHighpt, LSAllpt);
572     printf("\n");
573     printf("===================================================\n");
574     fflush(stdout);
575   }
576   
577   if (WRITE){
578     TFile *myFile = new TFile("TriggerCheck.root", "RECREATE");  
579     TgtupleGlo->Write();
580     TgtupleLoc->Write();
581     myFile->Close();
582   }
583
584   MUONLoader->UnloadRecPoints();
585
586   delete crateManager;
587   delete segFactory;
588   delete transformer;
589   delete triggerCircuit;
590   
591 }
592
593
594 void MUONrectracks (Int_t event2Check=0, char * filename="galice.root"){
595 // reads and dumps trigger objects from MUON.RecPoints.root
596   TClonesArray * RecTracks;
597   
598   // Creating Run Loader and openning file containing Hits
599   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
600   if (RunLoader ==0x0) {
601     printf(">>> Error : Error Opening %s file \n",filename);
602     return;
603   }
604     // waiting for mag field in CDB 
605   printf("Loading field map...\n");
606   if (!AliTracker::GetFieldMap()) {
607     AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
608     AliTracker::SetFieldMap(field, kFALSE);
609   }
610   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
611   MUONLoader->LoadTracks("READ");
612   // Creating MUON data container
613   AliMUONData muondata(MUONLoader,"MUON","MUON");
614   
615     Int_t ievent, nevents;
616   nevents = RunLoader->GetNumberOfEvents();
617   
618   //  AliMUONTrack * rectrack;
619   
620   for (ievent=0; ievent<nevents; ievent++) {
621     if (event2Check!=0) ievent=event2Check;
622     RunLoader->GetEvent(ievent);
623     
624     muondata.SetTreeAddress("RT");
625     muondata.GetRecTracks();
626     RecTracks = muondata.RecTracks();
627     
628     
629     Int_t nrectracks = (Int_t) RecTracks->GetEntriesFast(); //
630
631     printf(">>> Event %d, Number of Recconstructed tracks %d \n",ievent, nrectracks);
632     // loop over tracks
633
634     // setting pointer for tracks, triggertracks & trackparam at vertex
635     AliMUONTrack* recTrack = 0;
636     AliMUONTrackParam* trackParam = 0;
637
638     for (Int_t iRecTracks = 0; iRecTracks <  nrectracks;  iRecTracks++) {
639    //  // reading info from tracks
640        recTrack = (AliMUONTrack*) RecTracks->At(iRecTracks);
641        trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
642        trackParam->ExtrapToZ(0.0);
643       recTrack->Print("full");
644     } // end loop tracks
645
646     muondata.ResetRecTracks();
647     if (event2Check!=0) ievent=nevents;
648   } // end loop on event  
649   MUONLoader->UnloadTracks();
650 }
651