MUON/AliMUONData.cxx

   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 /// AliMUONData class
  19 ///
  20 /// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
  21 /// The classe makes the lik between the MUON data lists and the event trees from loaders
  22 ///
  23 /// Gines Martinez, Subatech,  September 2003
  24 ///
  25
  26 #include "AliMUONData.h"
  27
  28 #include "AliLog.h"
  29 #include "AliMUONConstants.h"
  30 #include "AliMUONHit.h"
  31 #include "AliMUONDigit.h"
  32 #include "AliMUONGlobalTrigger.h"
  33 #include "AliMUONLocalTrigger.h"
  34 #include "AliMUONRegionalTrigger.h"
  35 #include "AliMUONRawCluster.h"
  36 #include "AliMUONTrack.h"
  37 #include "AliMUONTriggerTrack.h"
  38 #include "AliRunLoader.h"
  39 #include "TArrayI.h"
  40 #include "TString.h"
  41
  42 /// \cond CLASSIMP
  43 ClassImp(AliMUONData)
  44 /// \endcond
  45
  46 //_____________________________________________________________________________
  47   AliMUONData::AliMUONData():
  48     TNamed(),
  49     fLoader(0x0),
  50     fHits(0x0),
  51     fDigits(0x0),
  52     fSDigits(0x0),
  53     fRawClusters(0x0),
  54     fGlobalTrigger(0x0),
  55     fLocalTrigger(0x0),
  56     fRegionalTrigger(0x0),
  57     fRecTracks(0x0),
  58     fRecTriggerTracks(0x0),
  59     fNhits(0),
  60     fNdigits(0x0),
  61     fNSdigits(0x0),
  62     fNrawclusters(0x0),
  63     fNglobaltrigger(0),
  64     fNlocaltrigger(0),
  65     fNregionaltrigger(0),
  66     fNrectracks(0),
  67     fNrectriggertracks(0),
  68     fSplitLevel(0),
  69     fCurrentEvent(-1)
  70 {
  71   // Default constructor
  72 }
  73 //_____________________________________________________________________________
  74 AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
  75   TNamed(name,title),
  76     fLoader(loader),
  77     fHits(0x0),
  78     fDigits(0x0),
  79     fSDigits(0x0),
  80     fRawClusters(0x0),
  81     fGlobalTrigger(0x0),
  82     fLocalTrigger(0x0),
  83     fRegionalTrigger(0x0),
  84     fRecTracks(0x0),
  85     fRecTriggerTracks(0x0),
  86     fNhits(0),
  87     fNdigits(0x0),
  88     fNSdigits(0x0),
  89     fNrawclusters(0x0),
  90     fNglobaltrigger(0),
  91     fNlocaltrigger(0),
  92     fNregionaltrigger(0),
  93     fNrectracks(0),
  94     fNrectriggertracks(0),
  95     fSplitLevel(0),
  96     fCurrentEvent(-1)
  97 {
  98 /// Standard constructor
  99 }
 100
 101 //_____________________________________________________________________________
 102 AliMUONData::~AliMUONData()
 103 {
 104 /// Destructor for AliMUONData
 105   if (fHits) {
 106     fHits->Delete();
 107     delete fHits;
 108   }
 109
 110   if (fDigits) {
 111     fDigits->Delete();
 112     delete fDigits;
 113   }
 114   if (fSDigits) {
 115     fSDigits->Delete();
 116     delete fSDigits;
 117   }
 118   if (fRawClusters) {
 119     fRawClusters->Delete();
 120     delete fRawClusters;
 121   }
 122   if (fGlobalTrigger){
 123     fGlobalTrigger->Delete();
 124     delete fGlobalTrigger;
 125   }
 126   if (fRegionalTrigger){
 127     fRegionalTrigger->Delete();
 128     delete fRegionalTrigger;
 129   }
 130   if (fLocalTrigger){
 131     fLocalTrigger->Delete();
 132     delete fLocalTrigger;
 133   }
 134   if (fRecTracks){
 135     fRecTracks->Delete();
 136     delete fRecTracks;
 137   }
 138   if (fRecTriggerTracks){
 139     fRecTriggerTracks->Delete();
 140     delete fRecTriggerTracks;
 141   }
 142 }
 143 //____________________________________________________________________________
 144 void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t detElemId,
 145                          Int_t idpart, Float_t X, Float_t Y, Float_t Z,
 146                          Float_t tof, Float_t momentum, Float_t theta,
 147                          Float_t phi, Float_t length, Float_t destep,
 148                          Float_t Xref,Float_t Yref,Float_t Zref)
 149 {
 150  // Add new hit to the hit list
 151
 152   TClonesArray &lhits = *fHits;
 153   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId,
 154                                   idpart, X, Y, Z,
 155                                   tof, momentum, theta,
 156                                   phi, length, destep,
 157                                   Xref,Yref,Zref);
 158 }
 159 //_____________________________________________________________________________
 160 void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
 161 {
 162 /// Add a MUON digit to the list of Digits of the detection plane id
 163
 164   TClonesArray &ldigits = * Digits(id) ;
 165   new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
 166 }
 167 //_____________________________________________________________________________
 168 void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
 169 {
 170 /// Add a MUON Sdigit to the list of SDigits of the detection plane id
 171
 172   TClonesArray &lSdigits = * SDigits(id) ;
 173   new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
 174 }
 175
 176 //_____________________________________________________________________________
 177 void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
 178 {
 179 /// Add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
 180
 181   TClonesArray &globalTrigger = *fGlobalTrigger;
 182   new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
 183 }
 184
 185 //____________________________________________________________________________
 186 void AliMUONData::AddRegionalTrigger(const  AliMUONRegionalTrigger& trigger)
 187 {
 188 /// add a MUON regional Trigger to the list
 189   TClonesArray &regionalTrigger = *fRegionalTrigger;
 190   new(regionalTrigger[fNregionaltrigger++]) AliMUONRegionalTrigger(trigger);
 191 }
 192 //____________________________________________________________________________
 193 void AliMUONData::AddLocalTrigger(const  AliMUONLocalTrigger& trigger)
 194 {
 195 /// add a MUON Local Trigger to the list
 196
 197   TClonesArray &localTrigger = *fLocalTrigger;
 198   new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
 199 }
 200
 201 //_____________________________________________________________________________
 202 void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
 203 {
 204 /// Add a MUON rawcluster to the list in the detection plane id
 205
 206   TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
 207   new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
 208 }
 209 //_____________________________________________________________________________
 210 void AliMUONData::AddRecTrack(const AliMUONTrack& track)
 211 {
 212 /// Add a MUON rectrack
 213
 214   TClonesArray &lrectracks = *fRecTracks;
 215   new(lrectracks[fNrectracks++]) AliMUONTrack(track);
 216 }
 217 //_____________________________________________________________________________
 218 void AliMUONData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
 219 {
 220 /// Add a MUON triggerrectrack
 221
 222   TClonesArray &lrectriggertracks = *fRecTriggerTracks;
 223   new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
 224 }
 225 //____________________________________________________________________________
 226 TClonesArray*  AliMUONData::Digits(Int_t DetectionPlane) const
 227 {
 228 /// Getting List of Digits
 229
 230   if (fDigits)
 231     return ( (TClonesArray*) fDigits->At(DetectionPlane) );
 232   else
 233     return NULL;
 234 }
 235 //____________________________________________________________________________
 236 TClonesArray*  AliMUONData::SDigits(Int_t DetectionPlane) const
 237 {
 238 /// Getting List of SDigits
 239
 240   if (fSDigits)
 241     return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
 242   else
 243     return NULL;
 244 }
 245 //____________________________________________________________________________
 246 Bool_t   AliMUONData::IsRawClusterBranchesInTree()
 247 {
 248 /// Checking if there are RawCluster Branches In TreeR
 249
 250   if (TreeR()==0x0) {
 251     AliError("No treeR in memory");
 252     return kFALSE;
 253   }
 254   else {
 255      char branchname[30];
 256      sprintf(branchname,"%sRawClusters1",GetName());
 257      TBranch * branch = 0x0;
 258      branch = TreeR()->GetBranch(branchname);
 259      if (branch)  return kTRUE;
 260      else return kFALSE;
 261   }
 262 }
 263 //____________________________________________________________________________
 264 Bool_t   AliMUONData::IsDigitsBranchesInTree()
 265 {
 266 /// Checking if there are RawCluster Branches In TreeR
 267
 268   if (TreeD()==0x0) {
 269     AliError("No treeD in memory");
 270     return kFALSE;
 271   }
 272   else {
 273      char branchname[30];
 274      sprintf(branchname,"%sDigits1",GetName());
 275      TBranch * branch = 0x0;
 276      branch = TreeD()->GetBranch(branchname);
 277      if (branch)  return kTRUE;
 278      else return kFALSE;
 279   }
 280 }
 281 //____________________________________________________________________________
 282 Bool_t   AliMUONData::IsTriggerBranchesInTree()
 283 {
 284 /// Checking if there are Trigger Branches In TreeR
 285  if (TreeR()==0x0) {
 286     AliError("No treeR in memory");
 287     return kFALSE;
 288   }
 289   else {
 290      char branchname[30];
 291      sprintf(branchname,"%sLocalTrigger",GetName());
 292      TBranch * branch = 0x0;
 293      branch = TreeR()->GetBranch(branchname);
 294      if (branch)  return kTRUE;
 295      else return kFALSE;
 296   }
 297 }
 298 //____________________________________________________________________________
 299 Bool_t   AliMUONData::IsTriggerBranchesInTreeD()
 300 {
 301 /// Checking if there are Trigger Branches In TreeR
 302  if (TreeD()==0x0) {
 303     AliError("No treeD in memory");
 304     return kFALSE;
 305   }
 306   else {
 307      char branchname[30];
 308      sprintf(branchname,"%sLocalTrigger",GetName());
 309      TBranch * branch = 0x0;
 310      branch = TreeD()->GetBranch(branchname);
 311      if (branch)  return kTRUE;
 312      else return kFALSE;
 313   }
 314 }
 315
 316 //____________________________________________________________________________
 317 Bool_t   AliMUONData::IsTrackBranchesInTree()
 318 {
 319 /// Checking if there are Track Branches In TreeT
 320   if (TreeT()==0x0) {
 321     AliError("No treeT in memory");
 322     return kFALSE;
 323   }
 324   else {
 325      char branchname[30];
 326      sprintf(branchname,"%sTrack",GetName());
 327      TBranch * branch = 0x0;
 328      branch = TreeT()->GetBranch(branchname);
 329      if (branch)  return kTRUE;
 330      else return kFALSE;
 331   }
 332 }
 333 //____________________________________________________________________________
 334 Bool_t   AliMUONData::IsTriggerTrackBranchesInTree()
 335 {
 336 /// Checking if there are TriggerTrack Branches In TreeT
 337   if (TreeT()==0x0) {
 338     AliError("No treeT in memory");
 339     return kFALSE;
 340   }
 341   else {
 342      char branchname[30];
 343      sprintf(branchname,"%sTriggerTrack",GetName());
 344      TBranch * branch = 0x0;
 345      branch = TreeT()->GetBranch(branchname);
 346      if (branch)  return kTRUE;
 347      else return kFALSE;
 348   }
 349 }
 350 //____________________________________________________________________________
 351 void AliMUONData::Fill(Option_t* option)
 352 {
 353 /// Method to fill the trees
 354   const char *cH   = strstr(option,"H");
 355   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
 356   const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
 357   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
 358   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
 359   const char *cTC = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
 360   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
 361   const char *cRL = strstr(option,"RL");   // Reconstructed Trigger Track in TreeT
 362
 363   //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
 364
 365   char branchname[30];
 366   TBranch * branch = 0x0;
 367
 368   // Filling TreeH
 369   if ( TreeH() && cH )
 370   {
 371     TreeH()->Fill();
 372   }
 373
 374   // Filling TreeD
 375
 376   if ( TreeD() && cD && cGLT )
 377   {
 378     // Writing digits and (global+local) trigger at once.
 379     TreeD()->Fill();
 380   }
 381   else
 382   {
 383     if ( TreeD() && cD )
 384     {
 385       if ( IsTriggerBranchesInTreeD() )
 386       {
 387         for (int i=0; i<AliMUONConstants::NCh(); i++)
 388         {
 389           sprintf(branchname,"%sDigits%d",GetName(),i+1);
 390           branch = TreeD()->GetBranch(branchname);
 391           branch->Fill();
 392         }
 393       }
 394       else
 395       {
 396         TreeD()->Fill();
 397       }
 398     }
 399
 400     if ( TreeD() && cGLT )
 401     {
 402       if ( IsDigitsBranchesInTree() )
 403       {
 404         sprintf(branchname,"%sLocalTrigger",GetName());
 405         branch = TreeD()->GetBranch(branchname);
 406         branch->Fill();
 407         sprintf(branchname,"%sRegionalTrigger",GetName());
 408         branch = TreeD()->GetBranch(branchname);
 409         branch->Fill();
 410         sprintf(branchname,"%sGlobalTrigger",GetName());
 411         branch = TreeD()->GetBranch(branchname);
 412         branch->Fill();
 413
 414       }
 415       else
 416       {
 417         TreeD()->Fill();
 418       }
 419     }
 420   } // end of TreeD() handling.
 421
 422   // Filling TreeS
 423   if ( TreeS() && cS)
 424   {
 425     TreeS()->Fill();
 426   }
 427
 428   // Filling TreeR
 429
 430   if ( TreeR() && cRC && cTC )
 431   {
 432     TreeR()->Fill();
 433   }
 434   else
 435   {
 436     if ( TreeR()  && cRC )
 437     {
 438       if ( IsTriggerBranchesInTree() )
 439       {
 440       // Branch per branch filling
 441         for (int i=0; i<AliMUONConstants::NTrackingCh(); i++)
 442         {
 443           sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 444           branch = TreeR()->GetBranch(branchname);
 445           branch->Fill();
 446         }
 447       }
 448       else
 449       {
 450         TreeR()->Fill();
 451       }
 452     }
 453
 454     if ( TreeR()  && cTC)
 455     {
 456       if (IsRawClusterBranchesInTree())
 457       {
 458         // Branch per branch filling
 459         sprintf(branchname,"%sLocalTrigger",GetName());
 460         branch = TreeR()->GetBranch(branchname);
 461         branch->Fill();
 462         sprintf(branchname,"%sRegionalTrigger",GetName());
 463         branch = TreeR()->GetBranch(branchname);
 464         branch->Fill();
 465         sprintf(branchname,"%sGlobalTrigger",GetName());
 466         branch = TreeR()->GetBranch(branchname);
 467         branch->Fill();
 468       }
 469       else
 470       {
 471         TreeR()->Fill();
 472       }
 473     }
 474   }
 475
 476   // Filling TreeT
 477
 478   if ( TreeT() && cRT && cRL )
 479   {
 480     TreeT()->Fill();
 481   }
 482   else
 483   {
 484     if ( TreeT() && cRT )
 485     {
 486       if (IsTriggerTrackBranchesInTree())
 487       {
 488         sprintf(branchname,"%sTrack",GetName());
 489         branch = TreeT()->GetBranch(branchname);
 490         branch->Fill();
 491       }
 492       else
 493       {
 494         TreeT()->Fill();
 495       }
 496     }
 497
 498     if ( TreeT() && cRL )
 499     {
 500       if (IsTrackBranchesInTree())
 501       {
 502         sprintf(branchname,"%sTriggerTrack",GetName());
 503         branch = TreeT()->GetBranch(branchname);
 504         branch->Fill();
 505       }
 506       else
 507       {
 508         TreeT()->Fill();
 509       }
 510     }
 511   }
 512 }
 513
 514 //_____________________________________________________________________________
 515 void AliMUONData::MakeBranch(Option_t* option)
 516 {
 517 /// Create Tree branches for the MUON.
 518
 519   const Int_t kBufferSize = 4000;
 520   char branchname[30];
 521
 522
 523   const char *cH   = strstr(option,"H");
 524   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
 525   const char *cS   = strstr(option,"S");   // Digits branches in TreeS
 526   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
 527   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
 528   const char *cTC  = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
 529   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
 530   const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
 531                                            //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
 532
 533   TBranch * branch = 0x0;
 534
 535   // Creating Branches for Hits
 536   if (TreeH() && cH) {
 537
 538     if (fHits == 0x0)  {
 539       fHits = new TClonesArray("AliMUONHit",1000);
 540       //        if (gAlice->GetMCApp())
 541       //          gAlice->GetMCApp()->AddHitList (fHits);
 542     }
 543
 544     fNhits = 0;
 545     sprintf(branchname,"%sHits",GetName());
 546     branch = TreeH()->GetBranch(branchname);
 547     if (branch) {
 548       AliInfo(Form("MakeBranch","Branch %s is already in tree.",branchname));
 549       return ;
 550     }
 551     branch = TreeH()->Branch(branchname,&fHits,kBufferSize);
 552     //Info("MakeBranch","Making Branch %s for hits \n",branchname);
 553   }
 554
 555   //Creating Branches for Digits
 556   TTree* treeD = 0x0;
 557   if ( cD || cGLT )
 558   {
 559     treeD = TreeD();
 560   }
 561
 562   if ( treeD && cD )
 563   {
 564     // one branch for digits per chamber
 565     if (fDigits  == 0x0)
 566     {
 567       fDigits  = new TObjArray(AliMUONConstants::NCh());
 568       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++)
 569       {
 570         TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
 571         tca->SetOwner();
 572         fDigits->AddAt(tca,iDetectionPlane);
 573       }
 574     }
 575     if (fNdigits == 0x0)
 576     {
 577       fNdigits = new Int_t[AliMUONConstants::NCh()];
 578       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++)
 579       {
 580         fNdigits[iDetectionPlane]=0;
 581       }
 582     }
 583     for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++)
 584     {
 585       sprintf(branchname,"%sDigits%d",GetName(),iDetectionPlane+1);
 586       branch = treeD->GetBranch(branchname);
 587       if (branch)
 588       {
 589         AliInfo(Form("Branch %s is already in tree.",branchname));
 590         return;
 591       }
 592       TClonesArray * digits = Digits(iDetectionPlane);
 593       branch = treeD->Branch(branchname, &digits, kBufferSize,1);
 594     }
 595   }
 596
 597   if ( treeD && cGLT )
 598   {
 599     //
 600     // one branch for global trigger
 601     //
 602     sprintf(branchname,"%sGlobalTrigger",GetName());
 603
 604     if (fGlobalTrigger == 0x0)
 605     {
 606       fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
 607       fNglobaltrigger = 0;
 608     }
 609     branch = treeD->GetBranch(branchname);
 610     if (branch)
 611     {
 612       AliInfo(Form("Branch GlobalTrigger is already in treeD."));
 613       return ;
 614     }
 615     branch = treeD->Branch(branchname, &fGlobalTrigger, kBufferSize);
 616
 617   //
 618     // one branch for regional trigger
 619     //
 620     sprintf(branchname,"%sRegionalTrigger",GetName());
 621     branch = 0x0;
 622
 623     if (fRegionalTrigger == 0x0)
 624     {
 625       fRegionalTrigger  = new TClonesArray("AliMUONRegionalTrigger",16);
 626       fNregionaltrigger = 0;
 627     }
 628     branch = treeD->GetBranch(branchname);
 629     if (branch)
 630     {
 631       AliInfo(Form("Branch RegionalTrigger is already in treeD."));
 632       return;
 633     }
 634     branch = treeD->Branch(branchname, &fRegionalTrigger, kBufferSize);
 635
 636
 637     //
 638     // one branch for local trigger
 639     //
 640     sprintf(branchname,"%sLocalTrigger",GetName());
 641     branch = 0x0;
 642
 643     if (fLocalTrigger == 0x0)
 644     {
 645       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 646       fNlocaltrigger = 0;
 647     }
 648     branch = treeD->GetBranch(branchname);
 649     if (branch)
 650     {
 651       AliInfo(Form("Branch LocalTrigger is already in treeD."));
 652       return;
 653     }
 654     branch = treeD->Branch(branchname, &fLocalTrigger, kBufferSize);
 655   }
 656
 657   //Creating Branches for SDigits
 658   if (TreeS() && cS ) {
 659     // one branch for Sdigits per chamber
 660     if (fSDigits  == 0x0) {
 661       fSDigits  = new TObjArray(AliMUONConstants::NCh());
 662       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 663         TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
 664         tca->SetOwner();
 665         fSDigits->AddAt(tca,iDetectionPlane);
 666       }
 667     }
 668     if (fNSdigits == 0x0) {
 669       fNSdigits = new Int_t[AliMUONConstants::NCh()];
 670       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 671         fNSdigits[iDetectionPlane]=0;
 672       }
 673     }
 674     for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 675       sprintf(branchname,"%sSDigits%d",GetName(),iDetectionPlane+1);
 676       branch = 0x0;
 677       branch = TreeS()->GetBranch(branchname);
 678       if (branch) {
 679         AliInfo(Form("Branch %s is already in tree.",branchname));
 680         return;
 681       }
 682       TClonesArray * sdigits = SDigits(iDetectionPlane);
 683       branch = TreeS()->Branch(branchname, &sdigits, kBufferSize,1);
 684       //Info("MakeBranch","Making Branch %s for sdigits in detection plane %d\n",branchname,iDetectionPlane+1);
 685     }
 686   }
 687
 688   if (TreeR() && cRC ) {
 689     //  one branch for raw clusters per tracking detection plane
 690     //
 691     Int_t i;
 692     if (fRawClusters == 0x0) {
 693       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
 694       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
 695         TClonesArray * tca = new TClonesArray("AliMUONRawCluster",1000);
 696         tca->SetOwner();
 697         fRawClusters->AddAt(tca,i);
 698       }
 699     }
 700
 701     if (fNrawclusters == 0x0) {
 702       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
 703       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
 704         fNrawclusters[i]=0;
 705       }
 706     }
 707
 708     for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
 709       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 710       branch = 0x0;
 711       branch = TreeR()->GetBranch(branchname);
 712       if (branch) {
 713         AliInfo(Form("Branch %s is already in tree.",branchname));
 714         return;
 715       }
 716       branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize);
 717       //Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
 718     }
 719   }
 720
 721   if (TreeR() && cTC ) {
 722     //
 723     // one branch for global trigger
 724     //
 725     sprintf(branchname,"%sGlobalTrigger",GetName());
 726     branch = 0x0;
 727
 728     if (fGlobalTrigger == 0x0) {
 729       fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
 730       fNglobaltrigger = 0;
 731     }
 732     branch = TreeR()->GetBranch(branchname);
 733     if (branch) {
 734       AliInfo(Form("Branch GlobalTrigger is already in treeR."));
 735       return ;
 736     }
 737     branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize);
 738     //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
 739
 740   //
 741     // one branch for regional trigger
 742     //
 743     sprintf(branchname,"%sRegionalTrigger",GetName());
 744     branch = 0x0;
 745
 746     if (fRegionalTrigger == 0x0) {
 747       fRegionalTrigger  = new TClonesArray("AliMUONRegionalTrigger",16);
 748       fNregionaltrigger = 0;
 749     }
 750     branch = TreeR()->GetBranch(branchname);
 751     if (branch) {
 752       AliInfo(Form("Branch RegionalTrigger is already in treeR."));
 753       return;
 754     }
 755     branch = TreeR()->Branch(branchname, &fRegionalTrigger, kBufferSize);
 756
 757     //
 758     // one branch for local trigger
 759     //
 760     sprintf(branchname,"%sLocalTrigger",GetName());
 761     branch = 0x0;
 762
 763     if (fLocalTrigger == 0x0) {
 764       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 765       fNlocaltrigger = 0;
 766     }
 767     branch = TreeR()->GetBranch(branchname);
 768     if (branch) {
 769       AliInfo(Form("Branch LocalTrigger is already in treeR."));
 770       return;
 771     }
 772     branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize);
 773     //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
 774   }
 775
 776   if (TreeT() && cRT ) {
 777     if (fRecTracks == 0x0)  fRecTracks = new TClonesArray("AliMUONTrack",100);
 778     fNrectracks = 0;
 779     sprintf(branchname,"%sTrack",GetName());
 780     branch = TreeT()->GetBranch(branchname);
 781     if (branch) {
 782       AliInfo(Form("Branch %s is already in tree.",GetName()));
 783       return ;
 784     }
 785     branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
 786     //Info("MakeBranch","Making Branch %s for tracks \n",branchname);
 787   }
 788   // trigger tracks
 789   if (TreeT() && cRL ) {
 790     if (fRecTriggerTracks == 0x0)  fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
 791     fNrectriggertracks = 0;
 792     sprintf(branchname,"%sTriggerTrack",GetName());
 793     branch = TreeT()->GetBranch(branchname);
 794     if (branch) {
 795       AliInfo(Form("Branch %s is already in tree.",GetName()));
 796       return ;
 797     }
 798     branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
 799     //Info("MakeBranch","Making Branch %s for trigger tracks \n",branchname);
 800   }
 801 }
 802 //____________________________________________________________________________
 803 TClonesArray*  AliMUONData::RawClusters(Int_t DetectionPlane)
 804 {
 805 /// Getting Raw Clusters
 806
 807   if (fRawClusters)
 808     return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
 809   else
 810     return NULL;
 811 }
 812
 813 //____________________________________________________________________________
 814 TClonesArray*
 815 AliMUONData::LocalTrigger() const
 816 {
 817 /// Getting local trigger
 818
 819   return fLocalTrigger;
 820 }
 821
 822 //____________________________________________________________________________
 823 TClonesArray*
 824 AliMUONData::RegionalTrigger() const
 825 {
 826 /// Getting regional trigger
 827
 828   return fRegionalTrigger;
 829 }
 830
 831 //____________________________________________________________________________
 832 Int_t
 833 AliMUONData::GetNtracks() const
 834 {
 835 /// Get number of entries in hits three
 836
 837   Int_t ntrk = 0;
 838   if (fLoader && fLoader->TreeH())
 839     ntrk = (Int_t) fLoader->TreeH()->GetEntries();
 840   return ntrk;
 841 }
 842
 843 //____________________________________________________________________________
 844 void
 845 AliMUONData::GetDigits() const
 846 {
 847 /// Load the digits from TreeD for the current event.
 848
 849   Int_t event = fLoader->GetRunLoader()->GetEventNumber();
 850   if ( fCurrentEvent != event )
 851   {
 852     if (fLoader->TreeD()) {
 853       fLoader->TreeD()->GetEvent(0);
 854       fCurrentEvent = event;
 855     }
 856   }
 857 }
 858
 859 //____________________________________________________________________________
 860 TClonesArray*
 861 AliMUONData::GlobalTrigger() const
 862 {
 863 /// Return the global trigger
 864
 865   return fGlobalTrigger;
 866 }
 867
 868 //____________________________________________________________________________
 869 void AliMUONData::ResetDigits()
 870 {
 871 /// Reset number of digits and the digits array for this detector
 872
 873     if (fDigits == 0x0) return;
 874     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
 875       if ((*fDigits)[i])    ((TClonesArray*)fDigits->At(i))->Clear("C");
 876       if (fNdigits)  fNdigits[i]=0;
 877     }
 878 }
 879 //____________________________________________________________________________
 880 void AliMUONData::ResetSDigits()
 881 {
 882 /// Reset number of Sdigits and the Sdigits array for this detector
 883
 884     if (fSDigits == 0x0) return;
 885     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
 886       if ((*fSDigits)[i])    ((TClonesArray*)fSDigits->At(i))->Clear();
 887       if (fNSdigits)  fNSdigits[i]=0;
 888     }
 889 }
 890 //______________________________________________________________________________
 891 void AliMUONData::ResetHits()
 892 {
 893 /// Reset number of clusters and the cluster array for this detector
 894
 895   fNhits   = 0;
 896   if (fHits) fHits->Clear();
 897 }
 898 //_______________________________________________________________________________
 899 void AliMUONData::ResetRawClusters()
 900 {
 901 /// Reset number of raw clusters and the raw clust array for this detector
 902
 903   for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
 904     if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
 905     if (fNrawclusters)  fNrawclusters[i]=0;
 906   }
 907 }
 908 //_______________________________________________________________________________
 909 void AliMUONData::ResetTrigger()
 910 {
 911 /// Reset Local and Global Trigger
 912
 913   fNglobaltrigger = 0;
 914   if (fGlobalTrigger) fGlobalTrigger->Clear();
 915   fNregionaltrigger = 0;
 916   if (fRegionalTrigger) fRegionalTrigger->Clear();
 917   fNlocaltrigger = 0;
 918   if (fLocalTrigger) fLocalTrigger->Clear();
 919
 920 }
 921 //____________________________________________________________________________
 922 void AliMUONData::ResetRecTracks()
 923 {
 924 /// Reset tracks information
 925
 926   fNrectracks = 0;
 927   if (fRecTracks) fRecTracks->Delete(); // necessary to delete in case of memory allocation
 928 }
 929 //____________________________________________________________________________
 930 void AliMUONData::ResetRecTriggerTracks()
 931 {
 932 /// Reset tracks information
 933
 934   fNrectriggertracks = 0;
 935   if (fRecTriggerTracks) fRecTriggerTracks->Delete(); // necessary to delete in case of memory allocation
 936 }
 937 //_____________________________________________________________________________
 938 void AliMUONData::SetTreeAddress(Option_t* option)
 939 {
 940 /// Setting Addresses to the events trees
 941
 942   const char *cH   = strstr(option,"H");
 943   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
 944   const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
 945   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
 946   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
 947   const char *cTC = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
 948   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
 949   const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
 950                                            //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
 951
 952   // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
 953   char branchname[30];
 954   TBranch * branch = 0x0;
 955
 956   AliDebug(1,Form("option=%s",option));
 957   //
 958   // Branch address for hit tree
 959   if ( TreeH() && cH ) {
 960     if (fHits == 0x0) {
 961       fHits     = new TClonesArray("AliMUONHit",1000);
 962       //        if (gAlice->GetMCApp())
 963       //  gAlice->GetMCApp()->AddHitList (fHits);  Moved to AliMUON
 964     }
 965     fNhits =0;
 966   }
 967   if (TreeH() && fHits && cH) {
 968     sprintf(branchname,"%sHits",GetName());
 969     branch = TreeH()->GetBranch(branchname);
 970     if (branch) {
 971       //      Info("SetTreeAddress","(%s) Setting for Hits",GetName());
 972       branch->SetAddress(&fHits);
 973     }
 974     else { //can be invoked before branch creation
 975       //AliWarning(Form("(%s) Failed for Hits. Can not find branch in tree.",GetName()));
 976     }
 977   }
 978
 979   //
 980   // Branch address for digit tree
 981   if ( TreeD() ) {
 982     if (fDigits == 0x0 && cD) {
 983       fDigits = new TObjArray(AliMUONConstants::NCh());
 984       fNdigits= new Int_t[AliMUONConstants::NCh()];
 985       for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
 986         fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
 987         fNdigits[i]=0;
 988       }
 989     }
 990     if (fLocalTrigger == 0x0 && cGLT) {
 991       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 992     }
 993     if (fRegionalTrigger == 0x0 && cGLT) {
 994       fRegionalTrigger  = new TClonesArray("AliMUONRegionalTrigger",16);
 995     }
 996     if (fGlobalTrigger== 0x0 && cGLT) {
 997       fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
 998     }
 999   }
1000
1001   if (TreeD() && fDigits && cD) {
1002     for (int i=0; i<AliMUONConstants::NCh(); i++) {
1003       sprintf(branchname,"%sDigits%d",GetName(),i+1);
1004       if (fDigits) {
1005         branch = TreeD()->GetBranch(branchname);
1006         TClonesArray * digits = Digits(i);
1007         if (branch) {
1008           branch->SetAddress( &digits );
1009         }
1010         else AliWarning(Form("(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i));
1011       }
1012     }
1013   }
1014   if ( TreeD()  && fLocalTrigger && cGLT) {
1015     sprintf(branchname,"%sLocalTrigger",GetName());
1016     branch = TreeD()->GetBranch(branchname);
1017     if (branch) branch->SetAddress(&fLocalTrigger);
1018     else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeD.",GetName()));
1019   }
1020  if ( TreeD()  && fRegionalTrigger && cGLT) {
1021     sprintf(branchname,"%sRegionalTrigger",GetName());
1022     branch = TreeD()->GetBranch(branchname);
1023     if (branch) branch->SetAddress(&fRegionalTrigger);
1024     else AliWarning(Form("(%s) Failed for RegionalTrigger. Can not find branch in treeD.",GetName()));
1025   }
1026   if ( TreeD() && fGlobalTrigger && cGLT) {
1027     sprintf(branchname,"%sGlobalTrigger",GetName());
1028     branch = TreeD()->GetBranch(branchname);
1029     if (branch) branch->SetAddress(&fGlobalTrigger);
1030     else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeD.",GetName()));
1031   }
1032
1033   //
1034   // Branch address for Sdigit tree
1035   if ( TreeS() && cS)
1036   {
1037     if (fSDigits == 0x0)
1038     {
1039       AliDebug(1,"Creating fSDigits TObjArray");
1040       fSDigits = new TObjArray(AliMUONConstants::NCh());
1041       fNSdigits= new Int_t[AliMUONConstants::NCh()];
1042       for (Int_t i=0; i<AliMUONConstants::NCh() ;i++)
1043       {
1044         TClonesArray* a = new TClonesArray("AliMUONDigit",10000);
1045         fSDigits->AddAt(a,i);
1046         AliDebug(1,Form("fSDigits[%d]=%p",i,a));
1047         fNSdigits[i]=0;
1048       }
1049     }
1050     else
1051     {
1052       AliDebug(1,Form("fSDigits already there = %p",fSDigits));
1053     }
1054   }
1055
1056   if (TreeS() && fSDigits && cS) {
1057     AliDebug(1,"Setting branch addresses");
1058     for (int i=0; i<AliMUONConstants::NCh(); i++) {
1059       sprintf(branchname,"%sSDigits%d",GetName(),i+1);
1060       if (fSDigits) {
1061         AliDebug(1,Form("TreeS=%p for ich=%d branchname=%s",
1062                         TreeS(),i,branchname));
1063         branch = TreeS()->GetBranch(branchname);
1064         TClonesArray * sdigits = SDigits(i);
1065         if (branch) branch->SetAddress( &sdigits );
1066         else AliWarning(Form("(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i));
1067       }
1068     }
1069   }
1070
1071   //
1072   // Branch address for rawclusters, globaltrigger and local trigger tree
1073   if (TreeR() ) {
1074     if (fRawClusters == 0x0 && cRC) {
1075       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
1076       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
1077       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
1078         fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
1079         fNrawclusters[i]=0;
1080       }
1081     }
1082     if (fLocalTrigger == 0x0 && cTC) {
1083       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
1084     }
1085    if (fRegionalTrigger == 0x0 && cTC) {
1086       fRegionalTrigger  = new TClonesArray("AliMUONRegionalTrigger",16);
1087     }
1088     if (fGlobalTrigger== 0x0 && cTC) {
1089       fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
1090     }
1091
1092   }
1093   if ( TreeR()  && fRawClusters && cRC && !strstr(cRC,"RCC")) {
1094     for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
1095       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
1096       if (fRawClusters) {
1097         branch = TreeR()->GetBranch(branchname);
1098         if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
1099         else AliWarning(Form("(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i));
1100       }
1101     }
1102   }
1103   if ( TreeR()  && fLocalTrigger && cTC) {
1104     sprintf(branchname,"%sLocalTrigger",GetName());
1105     branch = TreeR()->GetBranch(branchname);
1106     if (branch) branch->SetAddress(&fLocalTrigger);
1107     else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeR.",GetName()));
1108   }
1109
1110   if ( TreeR()  && fRegionalTrigger && cTC) {
1111     sprintf(branchname,"%sRegionalTrigger",GetName());
1112     branch = TreeR()->GetBranch(branchname);
1113     if (branch) branch->SetAddress(&fRegionalTrigger);
1114     else AliWarning(Form("(%s) Failed for RegionalTrigger. Can not find branch in treeR.",GetName()));
1115   }
1116
1117   if ( TreeR() && fGlobalTrigger && cTC) {
1118     sprintf(branchname,"%sGlobalTrigger",GetName());
1119     branch = TreeR()->GetBranch(branchname);
1120     if (branch) branch->SetAddress(&fGlobalTrigger);
1121     else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeR.",GetName()));
1122   }
1123
1124   if ( TreeT() ) {
1125     if (fRecTracks == 0x0 && cRT)  {
1126       fRecTracks  = new TClonesArray("AliMUONTrack",100);
1127     }
1128
1129   }
1130   if ( TreeT() && fRecTracks && cRT ) {
1131     sprintf(branchname,"%sTrack",GetName());
1132     branch = TreeT()->GetBranch(branchname);
1133     if (branch) branch->SetAddress(&fRecTracks);
1134     else AliWarning(Form("(%s) Failed for Tracks. Can not find branch in tree.",GetName()));
1135   }
1136   // trigger tracks
1137   if ( TreeT() ) {
1138     if (fRecTriggerTracks == 0x0 && cRL)  {
1139       fRecTriggerTracks  = new TClonesArray("AliMUONTriggerTrack",100);
1140     }
1141
1142   }
1143   if ( TreeT() && fRecTriggerTracks && cRL ) {
1144     sprintf(branchname,"%sTriggerTrack",GetName());
1145     branch = TreeT()->GetBranch(branchname);
1146     if (branch) branch->SetAddress(&fRecTriggerTracks);
1147     else AliWarning(Form("(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName()));
1148   }
1149
1150
1151 }
1152
1153 //_____________________________________________________________________________
1154 void
1155 AliMUONData::Print(Option_t* opt) const
1156 {
1157 /// Dump object on screen
1158
1159   TString options(opt);
1160   options.ToUpper();
1161
1162   if ( options.Contains("D") )
1163   {
1164     for ( Int_t ich = 0; ich < AliMUONConstants::NCh(); ++ich)
1165     {
1166       TClonesArray* digits = Digits(ich);
1167       Int_t ndigits = digits->GetEntriesFast();
1168       for ( Int_t id = 0; id < ndigits; ++id )
1169       {
1170         AliMUONDigit* digit =
1171           static_cast<AliMUONDigit*>(digits->UncheckedAt(id));
1172         digit->Print();
1173       }
1174     }
1175   }
1176
1177   if ( options.Contains("S") )
1178   {
1179     for ( Int_t ich = 0; ich < AliMUONConstants::NCh(); ++ich)
1180     {
1181       TClonesArray* digits = SDigits(ich);
1182       Int_t ndigits = digits->GetEntriesFast();
1183       for ( Int_t id = 0; id < ndigits; ++id )
1184       {
1185         AliMUONDigit* digit =
1186         static_cast<AliMUONDigit*>(digits->UncheckedAt(id));
1187         digit->Print();
1188       }
1189     }
1190   }
1191
1192 }