Print delegated to LocalTrigger and GlobalTrigger
[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
40 // MUON includes
41 #include "AliMUON.h"
42 #include "AliMUONData.h"
43 #include "AliMUONHit.h"
44 #include "AliMUONConstants.h"
45 #include "AliMUONDigit.h"
46 #include "AliMUONRawCluster.h"
47 #include "AliMUONGlobalTrigger.h"
48 #include "AliMUONLocalTrigger.h"
49 #include "AliMUONTrack.h"
50 #include "AliMUONTrackParam.h"
51 #include "AliMUONTriggerConstants.h"
52 #include "AliMUONTriggerCircuit.h"
53 #include "AliMUONTriggerCircuitNew.h"
54
55 #include "AliMpVSegmentation.h"
56 #include "AliMpIntPair.h"
57 #include "AliMpDEManager.h"
58 #include "AliMpSegFactory.h"
59 #endif
60
61 void MUONkine(Int_t event2Check=0, char * filename="galice.root")
62 {
63   // Stack of particle for each event
64   AliStack* stack;
65   // Creating Run Loader and openning file containing Hits
66   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
67   if (RunLoader ==0x0) {
68     printf(">>> Error : Error Opening %s file \n",filename);
69     return;
70   }
71
72   RunLoader->LoadKinematics("READ");
73   Int_t ievent, nevents;
74   nevents = RunLoader->GetNumberOfEvents();
75
76   for(ievent=0; ievent<nevents; ievent++) {  // Event loop
77     if (event2Check!=0) ievent=event2Check;
78     Int_t iparticle, nparticles;
79     // Getting event ievent
80     RunLoader->GetEvent(ievent); 
81     stack = RunLoader->Stack();
82     nparticles = (Int_t) stack->GetNtrack();
83     printf(">>> Event %d, Number of particles is %d \n",ievent, nparticles);
84     for(iparticle=0; iparticle<nparticles; iparticle++) {
85       stack->Particle(iparticle)->Print("");  
86     }
87     if (event2Check!=0) ievent=nevents;
88   }
89   RunLoader->UnloadKinematics();
90 }
91
92
93 void MUONhits(Int_t event2Check=0, char * filename="galice.root")
94 {
95   // Creating Run Loader and openning file containing Hits
96   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
97   if (RunLoader ==0x0) {
98     printf(">>> Error : Error Opening %s file \n",filename);
99     return;
100   }
101   // Loading MUON subsystem
102   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
103   MUONLoader->LoadHits("READ");  // Loading Tree of hits for MUON
104   AliMUONData muondata(MUONLoader,"MUON","MUON");  // Creating MUON data container
105   Int_t ievent, nevents;
106   nevents = RunLoader->GetNumberOfEvents();
107
108   for(ievent=0; ievent<nevents; ievent++) {  // Event loop
109     if (event2Check!=0) ievent=event2Check;
110     printf(">>> Event %d \n",ievent);
111     // Getting event ievent
112     RunLoader->GetEvent(ievent); 
113     muondata.SetTreeAddress("H");
114     Int_t itrack, ntracks;
115     ntracks = (Int_t) muondata.GetNtracks();
116     for (itrack=0; itrack<ntracks; itrack++) { // Track loop
117       //Getting List of Hits of Track itrack
118       muondata.GetTrack(itrack);
119       Int_t ihit, nhits;
120       nhits = (Int_t) muondata.Hits()->GetEntriesFast();
121       printf(">>> Track %d, Number of hits %d \n",itrack,nhits);
122       AliMUONHit* mHit;
123       for(ihit=0; ihit<nhits; ihit++) {
124         mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
125         mHit->Print("full");
126       }
127       muondata.ResetHits();
128     } // end track loop
129     if (event2Check!=0) ievent=nevents;
130   }  // end event loop
131   MUONLoader->UnloadHits();
132 }
133
134
135 void MUONdigits(Int_t event2Check=0, char * filename="galice.root")
136 {
137   // Creating Run Loader and openning file containing Hits
138   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
139   if (RunLoader ==0x0) {
140     printf(">>> Error : Error Opening %s file \n",filename);
141     return;
142   }
143   // Loading MUON subsystem
144   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
145   MUONLoader->LoadDigits("READ");
146   // Creating MUON data container
147   AliMUONData muondata(MUONLoader,"MUON","MUON");
148   
149   Int_t ievent, nevents;
150   nevents = RunLoader->GetNumberOfEvents();
151   AliMUONDigit * mDigit;
152   
153   for(ievent=0; ievent<nevents; ievent++) {
154     if (event2Check!=0) ievent=event2Check;
155     printf(">>> Event %d \n",ievent);
156     RunLoader->GetEvent(ievent);
157     
158     // Addressing
159     Int_t ichamber, nchambers;
160     nchambers = AliMUONConstants::NCh(); ;
161     muondata.SetTreeAddress("D,GLT");
162     
163     muondata.GetDigits();
164     // Loop on chambers
165     for( ichamber=0; ichamber<nchambers; ichamber++) {
166       Int_t idigit, ndigits;
167       TClonesArray* digits = muondata.Digits(ichamber);
168       digits->Sort();
169       ndigits = (Int_t)digits->GetEntriesFast();
170       for(idigit=0; idigit<ndigits; idigit++) {
171         mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
172         mDigit->Print("tracks");
173       } // end digit loop
174     } // end chamber loop
175     muondata.ResetDigits();
176     if (event2Check!=0) ievent=nevents;
177   }  // end event loop
178   MUONLoader->UnloadDigits();
179 }
180
181 void MUONsdigits(Int_t event2Check=0, char * filename="galice.root")
182 {
183   // Creating Run Loader and openning file containing Hits
184   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
185   if (RunLoader ==0x0) {
186     printf(">>> Error : Error Opening %s file \n",filename);
187     return;
188   }
189   // Loading MUON subsystem
190   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
191   MUONLoader->LoadSDigits("READ");
192   // Creating MUON data container
193   AliMUONData muondata(MUONLoader,"MUON","MUON");
194   
195   Int_t ievent, nevents;
196   nevents = RunLoader->GetNumberOfEvents();
197   AliMUONDigit * mDigit;
198   
199   for(ievent=0; ievent<nevents; ievent++) {
200     if (event2Check!=0) ievent=event2Check;
201     printf(">>> Event %d \n",ievent);
202     RunLoader->GetEvent(ievent);
203     
204     // Addressing
205     Int_t ichamber, nchambers;
206     nchambers = AliMUONConstants::NCh(); ;
207     muondata.SetTreeAddress("S");
208     
209     muondata.GetSDigits();
210     // Loop on chambers
211     for( ichamber=0; ichamber<nchambers; ichamber++) {
212       Int_t idigit, ndigits;
213       TClonesArray* digits = muondata.SDigits(ichamber);
214       ndigits = (Int_t)digits->GetEntriesFast();
215       for(idigit=0; idigit<ndigits; idigit++) {
216         mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
217         mDigit->Print("tracks");
218       } // end digit loop
219     } // end chamber loop
220     muondata.ResetSDigits();
221     if (event2Check!=0) ievent=nevents;
222   }  // end event loop
223   MUONLoader->UnloadSDigits();
224 }
225
226 void MUONoccupancy(Int_t event2Check=0,  Bool_t perDetEle =kFALSE, char * filename="galice.root") {
227   // Creating Run Loader and openning file containing Hits
228   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
229   if (RunLoader ==0x0) {
230     printf(">>> Error : Error Opening %s file \n",filename);
231     return;
232   }
233   // Loading MUON subsystem
234   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
235   MUONLoader->LoadDigits("READ");
236   // Creating MUON data container
237   AliMUONData muondata(MUONLoader,"MUON","MUON");
238   
239   Int_t ievent, nevents;
240   nevents = RunLoader->GetNumberOfEvents();
241   AliMUONDigit * mDigit =0x0;
242   AliMpVSegmentation * segbend = 0x0;
243   AliMpVSegmentation * segnonbend = 0x0;
244   AliMpIntPair pad(0,0);
245
246   Int_t dEoccupancy_bending[14][26];
247   Int_t dEoccupancy_nonbending[14][26];
248   Int_t cHoccupancy_bending[14];
249   Int_t cHoccupancy_nonbending[14];
250   Int_t totaloccupancy_bending =0;
251   Int_t totaloccupancy_nonbending =0;
252
253   Int_t dEchannels_bending[14][26];
254   Int_t dEchannels_nonbending[14][26];
255   Int_t cHchannels_bending[14];
256   Int_t cHchannels_nonbending[14];
257   Int_t totalchannels_bending =0;
258   Int_t totalchannels_nonbending =0;
259
260   Int_t ichamber, nchambers,idetele, detele, ix, iy;
261   nchambers = AliMUONConstants::NCh(); ;
262
263   AliMpSegFactory factory;
264
265   for (ichamber=0; ichamber<nchambers; ichamber++) {
266     cHchannels_bending[ichamber]=0;
267     cHchannels_nonbending[ichamber]=0;
268     for (idetele=0; idetele<26; idetele++) {
269       detele= 100*(ichamber +1)+idetele;
270       dEchannels_bending[ichamber][idetele]=0;
271       dEchannels_nonbending[ichamber][idetele]=0;
272       dEoccupancy_bending[ichamber][idetele]=0;
273       dEoccupancy_nonbending[ichamber][idetele]=0;
274       if ( AliMpDEManager::IsValidDetElemId(detele) ) {
275         
276         segbend    =  factory.CreateMpSegmentation(detele, 0);
277         segnonbend =  factory.CreateMpSegmentation(detele, 1);
278         if (AliMpDEManager::GetPlaneType(detele, 0) != kBendingPlane ) {
279           AliMpVSegmentation* tmp = segbend;
280           segbend    =  segnonbend;
281           segnonbend =  tmp;
282         }  
283           
284         for(ix=0; ix<=segbend->MaxPadIndexX(); ix++) {
285           for(iy=0; iy<=segbend->MaxPadIndexY(); iy++) {
286             pad.SetFirst(ix);
287             pad.SetSecond(iy);
288             if( segbend->HasPad(pad) )   {  
289               dEchannels_bending[ichamber][idetele]++;
290               cHchannels_bending[ichamber]++;
291               totalchannels_bending++;
292             }
293           }
294         }
295         for(ix=0; ix<=segnonbend->MaxPadIndexX(); ix++) {
296           for(iy=0; iy<=segnonbend->MaxPadIndexY(); iy++) {
297             pad.SetFirst(ix);
298             pad.SetSecond(iy);
299             if(segnonbend->HasPad(pad))  {
300               dEchannels_nonbending[ichamber][idetele]++;  
301               cHchannels_nonbending[ichamber]++;
302               totalchannels_nonbending++;
303             }
304           }
305         }
306         if (perDetEle) printf(">>> Detection element %4d has %5d channels in bending and %5d channels in nonbending \n",
307              detele, dEchannels_bending[ichamber][idetele], dEchannels_nonbending[ichamber][idetele] ); 
308       }
309     }
310     printf(">>> Chamber %2d has %6d channels in bending and %6d channels in nonbending \n",
311            ichamber+1,  cHchannels_bending[ichamber], cHchannels_nonbending[ichamber]);
312   }
313   printf(">>Spectrometer has  %7d channels in bending and %7d channels in nonbending \n",
314          totalchannels_bending, totalchannels_nonbending);
315
316   factory.DeleteSegmentations();
317
318   ievent=event2Check;
319   printf(">>> Event %d \n",ievent);
320   RunLoader->GetEvent(ievent);
321     
322   // Addressing
323   muondata.SetTreeAddress("D"); 
324   muondata.GetDigits();
325   // Loop on chambers
326   for( ichamber=0; ichamber<nchambers; ichamber++) {
327     cHoccupancy_bending[ichamber]   = 0;
328     cHoccupancy_nonbending[ichamber]= 0;
329     Int_t idigit, ndigits;
330     ndigits = (Int_t) muondata.Digits(ichamber)->GetEntriesFast();
331     for(idigit=0; idigit<ndigits; idigit++) {
332       mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber)->At(idigit));
333       Int_t detele = mDigit->DetElemId();
334       Int_t idetele = detele-(ichamber+1)*100;
335       if ( mDigit->Cathode() == 0 ) {
336
337         cHoccupancy_bending[ichamber]++;
338         dEoccupancy_bending[ichamber][idetele]++;
339         totaloccupancy_bending++;
340       }
341       else {
342         cHoccupancy_nonbending[ichamber]++;
343         dEoccupancy_nonbending[ichamber][idetele]++;
344         totaloccupancy_nonbending++;
345       }
346     } // end digit loop    
347
348     printf(">>> Chamber %2d  nChannels Bending %5d  nChannels NonBending %5d \n", 
349            ichamber+1, 
350            cHoccupancy_bending[ichamber],
351            cHoccupancy_nonbending[ichamber]);           
352     printf(">>> Chamber %2d  Occupancy Bending %5.2f %%  Occupancy NonBending %5.2f %% \n", 
353            ichamber+1, 
354            100.*((Float_t) cHoccupancy_bending[ichamber])/((Float_t) cHchannels_bending[ichamber]),
355            100.*((Float_t) cHoccupancy_nonbending[ichamber])/((Float_t) cHchannels_bending[ichamber])            );
356
357
358     for(Int_t idetele=0; idetele<26; idetele++) {
359       Int_t detele = idetele + 100*(ichamber+1);
360       if ( AliMpDEManager::IsValidDetElemId(detele) ) {
361         if (perDetEle) {
362           printf(">>> DetEle %4d nChannels Bending %5d  nChannels NonBending %5d \n", 
363                  idetele+100*(ichamber+1), 
364                  dEoccupancy_bending[ichamber][idetele],
365                  dEoccupancy_nonbending[ichamber][idetele]);  
366           printf(">>> DetEle %4d Occupancy Bending %5.2f %%  Occupancy NonBending %5.2f %% \n", 
367                  idetele+100*(ichamber+1), 
368                  100.*((Float_t) dEoccupancy_bending[ichamber][idetele])/((Float_t) dEchannels_bending[ichamber][idetele]),
369                  100.*((Float_t) dEoccupancy_nonbending[ichamber][idetele])/((Float_t) dEchannels_bending[ichamber][idetele]));  
370         }
371       }
372     }
373   } // end chamber loop
374   printf(">>> Muon Spectrometer  Occupancy Bending %5.2f %%  Occupancy NonBending %5.2f %% \n",  
375            100.*((Float_t) totaloccupancy_bending)/((Float_t) totalchannels_bending),
376          100.*((Float_t) totaloccupancy_nonbending)/((Float_t) totalchannels_nonbending)            );
377   muondata.ResetDigits();
378   //    } // end cathode loop
379   MUONLoader->UnloadDigits();
380 }
381
382 void MUONrecpoints(Int_t event2Check=0, char * filename="galice.root") {
383
384   // Creating Run Loader and openning file containing Hits
385   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
386   if (RunLoader ==0x0) {
387     printf(">>> Error : Error Opening %s file \n",filename);
388     return;
389   }
390   // Getting MUONloader
391   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
392   MUONLoader->LoadRecPoints("READ");
393   // Creating MUON data container
394   AliMUONData muondata(MUONLoader,"MUON","MUON");
395
396   Int_t ievent, nevents;
397   nevents = RunLoader->GetNumberOfEvents();
398   AliMUONRawCluster * mRecPoint = 0;
399   
400   for(ievent=0; ievent<nevents; ievent++) {
401     if (event2Check!=0) ievent=event2Check;
402     printf(">>> Event %d \n",ievent);
403     RunLoader->GetEvent(ievent);
404     // Addressing
405     Int_t ichamber, nchambers;
406     nchambers = AliMUONConstants::NTrackingCh();
407     muondata.SetTreeAddress("RC,TC"); 
408     char branchname[30];    
409     muondata.GetRawClusters();
410     // Loop on chambers
411     for( ichamber=0; ichamber<nchambers; ichamber++) {
412       sprintf(branchname,"MUONRawClusters%d",ichamber+1);
413       //printf(">>>  branchname %s\n",branchname);
414       Int_t irecpoint, nrecpoints;
415       nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
416       // printf(">>> Chamber %2d, Number of recpoints = %6d \n",ichamber+1, nrecpoints);
417       for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
418         mRecPoint = static_cast<AliMUONRawCluster*>(muondata.RawClusters(ichamber)->At(irecpoint));
419         mRecPoint->Print("full");
420       } // end recpoint loop
421     } // end chamber loop
422     muondata.ResetRawClusters();
423     if (event2Check!=0) ievent=nevents;
424   }  // end event loop
425   MUONLoader->UnloadRecPoints();
426 }
427
428 void MUONrectrigger (Int_t event2Check=0, char * filename="galice.root", Int_t WRITE = 0, Bool_t newTrigger=kFALSE)
429 {
430 // USAGE: newTrigger=kFALSE/kTRUE for old/new trigger version
431
432   // reads and dumps trigger objects from MUON.RecPoints.root
433   TClonesArray * globalTrigger;
434   TClonesArray * localTrigger;
435   
436   // Do NOT print out all the info if the loop runs over all events 
437   Int_t PRINTOUT = (event2Check == 0 ) ? 0 : 1 ;  
438
439   // Book a ntuple for more detailled studies
440   TNtuple *TgtupleGlo = new TNtuple("TgtupleGlo","Global Trigger Ntuple","ev:global:spapt:smapt:undefapt:uplpt:uphpt:upapt:lpapt");
441   TNtuple *TgtupleLoc = new TNtuple("TgtupleLoc","Local Trigger Ntuple","ev:LoCircuit:LoStripX:LoDev:StripY:LoLpt:LoHpt:LoApt:y11:y21:x11");
442
443   // counters
444   Int_t SPLowpt=0,SPHighpt=0,SPAllpt=0;
445   Int_t SMLowpt=0,SMHighpt=0,SMAllpt=0;
446   Int_t SULowpt=0,SUHighpt=0,SUAllpt=0;
447   Int_t USLowpt=0,USHighpt=0,USAllpt=0;
448   Int_t LSLowpt=0,LSHighpt=0,LSAllpt=0;
449
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);
454     return;
455   }
456
457   // Loading MUON subsystem
458   RunLoader->LoadgAlice();
459   AliMUON* pMUON = (AliMUON*)RunLoader->GetAliRun()->GetModule("MUON");
460   
461   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
462   MUONLoader->LoadDigits("READ");
463   // Creating MUON data container
464   AliMUONData muondata(MUONLoader,"MUON","MUON");
465   
466   
467   Int_t ievent, nevents;
468   nevents = RunLoader->GetNumberOfEvents();
469   
470   AliMUONGlobalTrigger *gloTrg(0x0);
471   AliMUONLocalTrigger *locTrg(0x0);
472   
473   for (ievent=0; ievent<nevents; ievent++) {
474     if (event2Check!=0) ievent=event2Check;
475     if (ievent%100==0 || event2Check) cout << "Processing event " << ievent << endl;
476     RunLoader->GetEvent(ievent);
477     
478     muondata.SetTreeAddress("D,GLT"); 
479     muondata.GetTriggerD();
480     
481     globalTrigger = muondata.GlobalTrigger();
482     localTrigger = muondata.LocalTrigger();
483     
484     Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
485     Int_t nlocals  = (Int_t) localTrigger->GetEntriesFast(); // up to 234
486     if (PRINTOUT) printf("###################################################\n");
487     if (PRINTOUT) printf("event %d nglobal %d nlocal %d \n",ievent,nglobals,nlocals);
488
489     for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
490       gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
491       
492       SPLowpt+=gloTrg->SinglePlusLpt() ;
493       SPHighpt+=gloTrg->SinglePlusHpt() ;
494       SPAllpt+=gloTrg->SinglePlusApt() ;
495       SMLowpt+=gloTrg->SingleMinusLpt();
496       SMHighpt+=gloTrg->SingleMinusHpt();
497       SMAllpt+=gloTrg->SingleMinusApt();
498       SULowpt+=gloTrg->SingleUndefLpt();
499       SUHighpt+=gloTrg->SingleUndefHpt();
500       SUAllpt+=gloTrg->SingleUndefApt();
501       USLowpt+=gloTrg->PairUnlikeLpt(); 
502       USHighpt+=gloTrg->PairUnlikeHpt();
503       USAllpt+=gloTrg->PairUnlikeApt();
504       LSLowpt+=gloTrg->PairLikeLpt(); 
505       LSHighpt+=gloTrg->PairLikeHpt();
506       LSAllpt+=gloTrg->PairLikeApt();
507       
508       if (PRINTOUT) gloTrg->Print("full");
509
510     } // end of loop on Global Trigger
511     
512     for (Int_t ilocal=0; ilocal<nlocals; ilocal++) { // Local Trigger
513       locTrg = static_cast<AliMUONLocalTrigger*>(localTrigger->At(ilocal));
514       if (PRINTOUT) locTrg->Print("full");
515       
516       if (!newTrigger) { // old trigger
517 //        printf("MUONCheck::rectrigger using OLD trigger \n");
518           AliMUONTriggerCircuit * circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
519           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()));
520
521       } else { // new trigger
522 //        printf("MUONCheck::rectrigger using NEW trigger \n");
523           AliMUONTriggerCircuitNew * circuit = &(pMUON->TriggerCircuitNew(locTrg->LoCircuit()-1));
524
525           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()));
526       }
527
528
529     } // end of loop on Local Trigger
530
531
532     // fill ntuple
533     //TNtuple *Tgtuple = new TNtuple("Tgtuple","Trigger Ntuple","ev:global:spapt:smapt:undefapt:uplpt:uphpt:upapt:lpapt");
534        TgtupleGlo->Fill(ievent,nglobals,gloTrg->SinglePlusApt(),gloTrg->SingleMinusApt(),gloTrg->SingleUndefApt(),gloTrg->PairUnlikeLpt(),gloTrg->PairUnlikeHpt(),gloTrg->PairUnlikeApt(),gloTrg->PairLikeApt());
535
536     muondata.ResetTrigger();
537     if (event2Check!=0) ievent=nevents;
538   } // end loop on event  
539   
540   // Print out summary if loop ran over all event
541   if (!event2Check){
542     printf("\n");
543     printf("===================================================\n");
544     printf("===================  SUMMARY  =====================\n");
545     printf("\n");
546     printf("Total number of events processed %d \n", (event2Check==0) ? nevents : 1);
547     printf("\n");
548     printf(" Global Trigger output       Low pt  High pt   All\n");
549     printf(" number of Single Plus      :\t");
550     printf("%i\t%i\t%i\t",SPLowpt,SPHighpt,SPAllpt);
551     printf("\n");
552     printf(" number of Single Minus     :\t");
553     printf("%i\t%i\t%i\t",SMLowpt,SMHighpt,SMAllpt);
554     printf("\n");
555     printf(" number of Single Undefined :\t"); 
556     printf("%i\t%i\t%i\t",SULowpt,SUHighpt,SUAllpt);
557     printf("\n");
558     printf(" number of UnlikeSign pair  :\t"); 
559     printf("%i\t%i\t%i\t",USLowpt,USHighpt,USAllpt);
560     printf("\n");
561     printf(" number of LikeSign pair    :\t");  
562     printf("%i\t%i\t%i\t",LSLowpt,LSHighpt, LSAllpt);
563     printf("\n");
564     printf("===================================================\n");
565   }
566   
567   if (WRITE){
568     TFile *myFile = new TFile("TriggerCheck.root", "RECREATE");  
569     TgtupleGlo->Write();
570     TgtupleLoc->Write();
571     myFile->Close();
572   }
573
574
575   MUONLoader->UnloadRecPoints();
576 }
577
578
579 void MUONrectracks (Int_t event2Check=0, char * filename="galice.root"){
580 // reads and dumps trigger objects from MUON.RecPoints.root
581   TClonesArray * RecTracks;
582   
583   // Creating Run Loader and openning file containing Hits
584   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
585   if (RunLoader ==0x0) {
586     printf(">>> Error : Error Opening %s file \n",filename);
587     return;
588   }
589   
590   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
591   MUONLoader->LoadTracks("READ");
592   // Creating MUON data container
593   AliMUONData muondata(MUONLoader,"MUON","MUON");
594   
595     Int_t ievent, nevents;
596   nevents = RunLoader->GetNumberOfEvents();
597   
598   //  AliMUONTrack * rectrack;
599   
600   for (ievent=0; ievent<nevents; ievent++) {
601     if (event2Check!=0) ievent=event2Check;
602     RunLoader->GetEvent(ievent);
603     
604     muondata.SetTreeAddress("RT");
605     muondata.GetRecTracks();
606     RecTracks = muondata.RecTracks();
607     
608     
609     Int_t nrectracks = (Int_t) RecTracks->GetEntriesFast(); //
610
611     printf(">>> Event %d, Number of Recconstructed tracks %d \n",ievent, nrectracks);
612     // loop over tracks
613
614     // setting pointer for tracks, triggertracks & trackparam at vertex
615     AliMUONTrack* recTrack = 0;
616     AliMUONTrackParam* trackParam = 0;
617
618     for (Int_t iRecTracks = 0; iRecTracks <  nrectracks;  iRecTracks++) {
619    //  // reading info from tracks
620        recTrack = (AliMUONTrack*) RecTracks->At(iRecTracks);
621        trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
622        trackParam->ExtrapToZ(0.0);
623       recTrack->Print("full");
624     } // end loop tracks
625
626     muondata.ResetRecTracks();
627     if (event2Check!=0) ievent=nevents;
628   } // end loop on event  
629   MUONLoader->UnloadTracks();
630 }
631