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