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, Bool_t readFromRP = 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:splpt:smlpt:undeflpt:sphpt:smhpt:undefhpt:uplpt:uphpt");
 443   TNtuple *TgtupleLoc = new TNtuple("TgtupleLoc","Local Trigger Ntuple","ev:LoCircuit:LoStripX:LoDev:StripY:LoLpt:LoHpt:y11:y21:x11");
 444
 445   // counters
 446   Int_t SPLowpt=0,SPHighpt=0;
 447   Int_t SMLowpt=0,SMHighpt=0;
 448   Int_t SULowpt=0,SUHighpt=0;
 449   Int_t USLowpt=0,USHighpt=0;
 450   Int_t LSLowpt=0,LSHighpt=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   Char_t fileName[30];
 480   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
 481   if (!readFromRP) {
 482       cout << " reading from digits \n";
 483       MUONLoader->LoadDigits("READ");
 484       sprintf(fileName,"TriggerCheckFromDigits.root");
 485   } else {
 486       cout << " reading from RecPoints \n";
 487       MUONLoader->LoadRecPoints("READ");
 488       sprintf(fileName,"TriggerCheckFromRP.root");
 489   }
 490
 491   // Creating MUON data container
 492   AliMUONData muondata(MUONLoader,"MUON","MUON");
 493
 494
 495   Int_t ievent, nevents;
 496   nevents = RunLoader->GetNumberOfEvents();
 497
 498   AliMUONGlobalTrigger *gloTrg(0x0);
 499   AliMUONLocalTrigger *locTrg(0x0);
 500
 501   for (ievent=0; ievent<nevents; ievent++) {
 502     if (event2Check!=0) ievent=event2Check;
 503     if (ievent%100==0 || event2Check) cout << "Processing event " << ievent << endl;
 504     RunLoader->GetEvent(ievent);
 505
 506     if (!readFromRP) {
 507         muondata.SetTreeAddress("D,GLT");
 508         muondata.GetTriggerD();
 509     } else {
 510         muondata.SetTreeAddress("RC,TC");
 511         muondata.GetTrigger();
 512     }
 513
 514     globalTrigger = muondata.GlobalTrigger();
 515     localTrigger = muondata.LocalTrigger();
 516
 517     Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
 518     Int_t nlocals  = (Int_t) localTrigger->GetEntriesFast(); // up to 234
 519     if (PRINTOUT) printf("###################################################\n");
 520     if (PRINTOUT) printf("event %d nglobal %d nlocal %d \n",ievent,nglobals,nlocals);
 521
 522     for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
 523       gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
 524
 525       SPLowpt+=gloTrg->SinglePlusLpt() ;
 526       SPHighpt+=gloTrg->SinglePlusHpt() ;
 527       SMLowpt+=gloTrg->SingleMinusLpt();
 528       SMHighpt+=gloTrg->SingleMinusHpt();
 529       SULowpt+=gloTrg->SingleUndefLpt();
 530       SUHighpt+=gloTrg->SingleUndefHpt();
 531       USLowpt+=gloTrg->PairUnlikeLpt();
 532       USHighpt+=gloTrg->PairUnlikeHpt();
 533       LSLowpt+=gloTrg->PairLikeLpt();
 534       LSHighpt+=gloTrg->PairLikeHpt();
 535
 536       if (PRINTOUT) gloTrg->Print("full");
 537
 538     } // end of loop on Global Trigger
 539
 540     for (Int_t ilocal=0; ilocal<nlocals; ilocal++) { // Local Trigger
 541       locTrg = static_cast<AliMUONLocalTrigger*>(localTrigger->At(ilocal));
 542       if (PRINTOUT) locTrg->Print("full");
 543
 544       AliMUONTriggerCircuitNew* circuit = (AliMUONTriggerCircuitNew*)triggerCircuit->At(locTrg->LoCircuit()-1);
 545
 546       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()));
 547     } // end of loop on Local Trigger
 548
 549     // fill ntuple
 550     TgtupleGlo->Fill(ievent,nglobals,gloTrg->SinglePlusLpt(),gloTrg->SingleMinusLpt(),gloTrg->SingleUndefLpt(),gloTrg->SinglePlusHpt(),gloTrg->SingleMinusHpt(),gloTrg->SingleUndefHpt(),gloTrg->PairUnlikeLpt(),gloTrg->PairUnlikeHpt());
 551
 552     muondata.ResetTrigger();
 553     if (event2Check!=0) ievent=nevents;
 554   } // end loop on event
 555
 556   // Print out summary if loop ran over all event
 557   if (!event2Check){
 558
 559     printf("\n");
 560     printf("=============================================\n");
 561     printf("================  SUMMARY  ==================\n");
 562     printf("\n");
 563     printf("Total number of events processed %d \n", (event2Check==0) ? nevents : 1);
 564     printf("\n");
 565     printf(" Global Trigger output       Low pt  High pt\n");
 566     printf(" number of Single Plus      :\t");
 567     printf("%i\t%i\t",SPLowpt,SPHighpt);
 568     printf("\n");
 569     printf(" number of Single Minus     :\t");
 570     printf("%i\t%i\t",SMLowpt,SMHighpt);
 571     printf("\n");
 572     printf(" number of Single Undefined :\t");
 573     printf("%i\t%i\t",SULowpt,SUHighpt);
 574     printf("\n");
 575     printf(" number of UnlikeSign pair  :\t");
 576     printf("%i\t%i\t",USLowpt,USHighpt);
 577     printf("\n");
 578     printf(" number of LikeSign pair    :\t");
 579     printf("%i\t%i\t",LSLowpt,LSHighpt);
 580     printf("\n");
 581     printf("=============================================\n");
 582     fflush(stdout);
 583   }
 584
 585   if (WRITE){
 586       TFile *myFile = new TFile(fileName, "RECREATE");
 587       TgtupleGlo->Write();
 588       TgtupleLoc->Write();
 589       myFile->Close();
 590   }
 591
 592   MUONLoader->UnloadRecPoints();
 593
 594   delete crateManager;
 595   delete segFactory;
 596   delete transformer;
 597   delete triggerCircuit;
 598
 599 }
 600
 601
 602 void MUONrectracks (Int_t event2Check=0, char * filename="galice.root"){
 603 // reads and dumps trigger objects from MUON.RecPoints.root
 604   TClonesArray * RecTracks;
 605
 606   // Creating Run Loader and openning file containing Hits
 607   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
 608   if (RunLoader ==0x0) {
 609     printf(">>> Error : Error Opening %s file \n",filename);
 610     return;
 611   }
 612     // waiting for mag field in CDB
 613   printf("Loading field map...\n");
 614   if (!AliTracker::GetFieldMap()) {
 615     AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
 616     AliTracker::SetFieldMap(field, kFALSE);
 617   }
 618   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
 619   MUONLoader->LoadTracks("READ");
 620   // Creating MUON data container
 621   AliMUONData muondata(MUONLoader,"MUON","MUON");
 622
 623     Int_t ievent, nevents;
 624   nevents = RunLoader->GetNumberOfEvents();
 625
 626   //  AliMUONTrack * rectrack;
 627
 628   for (ievent=0; ievent<nevents; ievent++) {
 629     if (event2Check!=0) ievent=event2Check;
 630     RunLoader->GetEvent(ievent);
 631
 632     muondata.SetTreeAddress("RT");
 633     muondata.GetRecTracks();
 634     RecTracks = muondata.RecTracks();
 635
 636
 637     Int_t nrectracks = (Int_t) RecTracks->GetEntriesFast(); //
 638
 639     printf(">>> Event %d, Number of Recconstructed tracks %d \n",ievent, nrectracks);
 640     // loop over tracks
 641
 642     // setting pointer for tracks, triggertracks & trackparam at vertex
 643     AliMUONTrack* recTrack = 0;
 644     AliMUONTrackParam* trackParam = 0;
 645
 646     for (Int_t iRecTracks = 0; iRecTracks <  nrectracks;  iRecTracks++) {
 647    //  // reading info from tracks
 648        recTrack = (AliMUONTrack*) RecTracks->At(iRecTracks);
 649        trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
 650        trackParam->ExtrapToZ(0.0);
 651       recTrack->Print("full");
 652     } // end loop tracks
 653
 654     muondata.ResetRecTracks();
 655     if (event2Check!=0) ievent=nevents;
 656   } // end loop on event
 657   MUONLoader->UnloadTracks();
 658 }
 659