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