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 // AliMUONData classes
  18 // Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
  19 // The classe makes the lik between the MUON data lists and the event trees from loaders
  20 // Gines Martinez, Subatech,  September 2003
  21 //
  22
  23 //Root includes
  24 #include "TNamed.h"
  25 //AliRoot include
  26 #include "AliRun.h"
  27 #include "AliMC.h"
  28 #include "AliLoader.h"
  29 #include "AliMUONConstants.h"
  30 #include "AliMUONData.h"
  31 #include "AliMUONDigit.h"
  32 #include "AliMUONHit.h"
  33 #include "AliMUONLocalTrigger.h"
  34 #include "AliMUONGlobalTrigger.h"
  35 #include "AliMUONRawCluster.h"
  36 #include "AliMUONTrack.h"
  37 #include "AliMUONTriggerTrack.h"
  38 ClassImp(AliMUONData)
  39
  40 //_____________________________________________________________________________
  41   AliMUONData::AliMUONData():
  42     TNamed(),
  43     fLoader(0x0),
  44     fHits(0x0),
  45     fDigits(0x0),
  46     fSDigits(0x0),
  47     fRawClusters(0x0),
  48     fGlobalTrigger(0x0),
  49     fLocalTrigger(0x0),
  50     fRecTracks(0x0),
  51     fRecTriggerTracks(0x0),
  52     fNhits(0),
  53     fNdigits(0x0),
  54     fNSdigits(0x0),
  55     fNrawclusters(0x0),
  56     fNglobaltrigger(0),
  57     fNlocaltrigger(0),
  58     fNrectracks(0),
  59     fNrectriggertracks(0),
  60     fSplitLevel(0)
  61 {
  62   // Default constructor
  63 }
  64 //_____________________________________________________________________________
  65 AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
  66   TNamed(name,title),
  67     fLoader(loader),
  68     fHits(0x0),
  69     fDigits(0x0),
  70     fSDigits(0x0),
  71     fRawClusters(0x0),
  72     fGlobalTrigger(0x0),
  73     fLocalTrigger(0x0),
  74     fRecTracks(0x0),
  75     fRecTriggerTracks(0x0),
  76     fNhits(0),
  77     fNdigits(0x0),
  78     fNSdigits(0x0),
  79     fNrawclusters(0x0),
  80     fNglobaltrigger(0),
  81     fNlocaltrigger(0),
  82     fNrectracks(0),
  83     fNrectriggertracks(0),
  84     fSplitLevel(0)
  85 {
  86   // Constructor for AliMUONData
  87
  88 //   fHits          = new TClonesArray("AliMUONHit",1000);
  89 //   fNhits         = 0;
  90 //   fDigits        = new TObjArray(AliMUONConstants::NCh());
  91 //   fNdigits       = new Int_t[AliMUONConstants::NCh()];
  92 //   for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
  93 //     fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane);
  94 //     fNdigits[iDetectionPlane]=0;
  95 //   }
  96 //   fRawClusters   = new TObjArray(AliMUONConstants::NTrackingCh());
  97 //   fNrawclusters  = new Int_t[AliMUONConstants::NTrackingCh()];
  98 //   for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NTrackingCh();iDetectionPlane++) {
  99 //     fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),iDetectionPlane);
 100 //     fNrawclusters[iDetectionPlane]=0;
 101 //   }
 102 //   fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
 103 //   fNglobaltrigger =0;
 104 //   fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 105 //   fNlocaltrigger = 0;
 106 //   fRecTracks     = new TClonesArray("AliMUONTrack", 100);
 107 //   fNrectracks    = 0; // really needed or GetEntriesFast sufficient ????
 108
 109
 110 }
 111
 112 //_____________________________________________________________________________
 113 AliMUONData::AliMUONData(const AliMUONData& rMUONData):TNamed(rMUONData)
 114 {
 115 // Protected copy constructor
 116
 117   Fatal("AliMUONData", "Not implemented.");
 118 }
 119
 120 //_____________________________________________________________________________
 121 AliMUONData::~AliMUONData()
 122 {
 123   // Destructor for AliMUONData
 124   if (fHits) {
 125     fHits->Delete();
 126     delete fHits;
 127   }
 128   if (fDigits) {
 129     fDigits->Delete();
 130     delete fDigits;
 131   }
 132   if (fSDigits) {
 133     fSDigits->Delete();
 134     delete fSDigits;
 135   }
 136   if (fRawClusters) {
 137     fRawClusters->Delete();
 138     delete fRawClusters;
 139   }
 140   if (fGlobalTrigger){
 141     fGlobalTrigger->Delete();
 142     delete fGlobalTrigger;
 143   }
 144   if (fLocalTrigger){
 145     fLocalTrigger->Delete();
 146     delete fLocalTrigger;
 147   }
 148   if (fRecTracks){
 149     fRecTracks->Delete();
 150     delete fRecTracks;
 151   }
 152   if (fRecTriggerTracks){
 153     fRecTriggerTracks->Delete();
 154     delete fRecTriggerTracks;
 155   }
 156   //detructor
 157 }
 158
 159 //_____________________________________________________________________________
 160 AliMUONData& AliMUONData::operator=(const AliMUONData& rhs)
 161 {
 162 // Protected assignement operator
 163
 164   if (this == &rhs) return *this;
 165
 166   Fatal("operator=", "Not implemented.");
 167
 168   return *this;
 169 }
 170
 171
 172 //_____________________________________________________________________________
 173 void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
 174 {
 175   //
 176   // Add a MUON digit to the list of Digits of the detection plane id
 177   //
 178   TClonesArray &ldigits = * Digits(id) ;
 179   new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
 180 }
 181 //_____________________________________________________________________________
 182 void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
 183 {
 184   //
 185   // Add a MUON digit to the list of Digits of the detection plane id
 186   //
 187   TClonesArray &ldigits = * Digits(id) ;
 188   new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
 189 }
 190 //_____________________________________________________________________________
 191 void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *Sdigits)
 192 {
 193   //
 194   // Add a MUON Sdigit to the list of SDigits of the detection plane id
 195   //
 196   TClonesArray &lSdigits = * SDigits(id) ;
 197   new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,Sdigits);
 198 }
 199 //_____________________________________________________________________________
 200 void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
 201 {
 202   //
 203   // Add a MUON Sdigit to the list of SDigits of the detection plane id
 204   //
 205   TClonesArray &lSdigits = * SDigits(id) ;
 206   new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
 207 }
 208 //_____________________________________________________________________________
 209 void AliMUONData::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
 210                                    Int_t *singleUndef,
 211                                    Int_t *pairUnlike, Int_t *pairLike)
 212 {
 213   // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
 214   TClonesArray &globalTrigger = *fGlobalTrigger;
 215   new(globalTrigger[fNglobaltrigger++])
 216     AliMUONGlobalTrigger(singlePlus, singleMinus,  singleUndef, pairUnlike, pairLike);
 217 }
 218 //_____________________________________________________________________________
 219 void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
 220 {
 221   // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
 222   TClonesArray &globalTrigger = *fGlobalTrigger;
 223   new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
 224 }
 225 //_____________________________________________________________________________
 226 void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber,
 227                          Int_t idpart, Float_t X, Float_t Y, Float_t Z,
 228                          Float_t tof, Float_t momentum, Float_t theta,
 229                          Float_t phi, Float_t length, Float_t destep)
 230 {
 231   // Add new hit to the hit list
 232   TClonesArray &lhits = *fHits;
 233   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
 234                                   idpart, X, Y, Z,
 235                                   tof, momentum, theta,
 236                                   phi, length, destep);
 237 }
 238 //____________________________________________________________________________
 239 void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber,
 240                          Int_t idpart, Float_t X, Float_t Y, Float_t Z,
 241                          Float_t tof, Float_t momentum, Float_t theta,
 242                          Float_t phi, Float_t length, Float_t destep,
 243                          Float_t Xref,Float_t Yref,Float_t Zref)
 244 {
 245  // Add new hit to the hit list
 246   TClonesArray &lhits = *fHits;
 247   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
 248                                   idpart, X, Y, Z,
 249                                   tof, momentum, theta,
 250                                   phi, length, destep,
 251                                   Xref,Yref,Zref);
 252 }
 253 //____________________________________________________________________________
 254 void AliMUONData::AddHit(const AliMUONHit& hit)
 255 {
 256   TClonesArray &lhits = *fHits;
 257   new(lhits[fNhits++]) AliMUONHit(hit);
 258 }
 259 //____________________________________________________________________________
 260 void AliMUONData::AddLocalTrigger(Int_t *localtr)
 261 {
 262   // add a MUON Local Trigger to the list
 263   TClonesArray &localTrigger = *fLocalTrigger;
 264   new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr);
 265 }
 266 //____________________________________________________________________________
 267 void AliMUONData::AddLocalTrigger(const  AliMUONLocalTrigger& trigger)
 268 {
 269   // add a MUON Local Trigger to the list
 270   TClonesArray &localTrigger = *fLocalTrigger;
 271   new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
 272 }
 273 //_____________________________________________________________________________
 274 void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
 275 {
 276   //
 277   // Add a MUON rawcluster to the list in the detection plane id
 278   //
 279   TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
 280   new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
 281 }
 282 //_____________________________________________________________________________
 283 void AliMUONData::AddRecTrack(const AliMUONTrack& track)
 284 {
 285   //
 286   // Add a MUON rectrack
 287   //
 288   TClonesArray &lrectracks = *fRecTracks;
 289   new(lrectracks[fNrectracks++]) AliMUONTrack(track);
 290   //  printf("TTTTTT %d ,\n",((AliMUONTrack*)fRecTracks->At(fNrectracks-1))->GetNTrackHits());
 291 }
 292 //_____________________________________________________________________________
 293 void AliMUONData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
 294 {
 295   //
 296   // Add a MUON triggerrectrack
 297   //
 298   TClonesArray &lrectriggertracks = *fRecTriggerTracks;
 299   new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
 300   //  printf("TTTTTT %d ,\n",((AliMUONTrack*)fRecTracks->At(fNrectracks-1))->GetNTrackHits());
 301 }
 302
 303 //____________________________________________________________________________
 304 TClonesArray*  AliMUONData::Digits(Int_t DetectionPlane)
 305 {
 306   //Getting List of Digits
 307   if (fDigits)
 308     return ( (TClonesArray*) fDigits->At(DetectionPlane) );
 309   else
 310     return NULL;
 311 }
 312 //____________________________________________________________________________
 313 TClonesArray*  AliMUONData::SDigits(Int_t DetectionPlane)
 314 {
 315   //Getting List of SDigits
 316   if (fSDigits)
 317     return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
 318   else
 319     return NULL;
 320 }
 321 //____________________________________________________________________________
 322 Bool_t   AliMUONData::IsRawClusterBranchesInTree()
 323 {
 324   // Checking if there are RawCluster Branches In TreeR
 325   if (TreeR()==0x0) {
 326     Error("TreeR","No treeR in memory");
 327     return kFALSE;
 328   }
 329   else {
 330      char branchname[30];
 331      sprintf(branchname,"%sRawClusters1",GetName());
 332      TBranch * branch = 0x0;
 333      branch = TreeR()->GetBranch(branchname);
 334      if (branch)  return kTRUE;
 335      else return kFALSE;
 336   }
 337 }
 338 //____________________________________________________________________________
 339 Bool_t   AliMUONData::IsTriggerBranchesInTree()
 340 {
 341   // Checking if there are Trigger Branches In TreeR
 342  if (TreeR()==0x0) {
 343     Error("TreeR","No treeR in memory");
 344     return kFALSE;
 345   }
 346   else {
 347      char branchname[30];
 348      sprintf(branchname,"%sLocalTrigger",GetName());
 349      TBranch * branch = 0x0;
 350      branch = TreeR()->GetBranch(branchname);
 351      if (branch)  return kTRUE;
 352      else return kFALSE;
 353   }
 354 }
 355 //____________________________________________________________________________
 356 Bool_t   AliMUONData::IsTrackBranchesInTree()
 357 {
 358   // Checking if there are Track Branches In TreeT
 359   if (TreeT()==0x0) {
 360     Error("TreeT","No treeT in memory");
 361     return kFALSE;
 362   }
 363   else {
 364      char branchname[30];
 365      sprintf(branchname,"%sTrack",GetName());
 366      TBranch * branch = 0x0;
 367      branch = TreeT()->GetBranch(branchname);
 368      if (branch)  return kTRUE;
 369      else return kFALSE;
 370   }
 371 }
 372 //____________________________________________________________________________
 373 Bool_t   AliMUONData::IsTriggerTrackBranchesInTree()
 374 {
 375   // Checking if there are TriggerTrack Branches In TreeT
 376   if (TreeT()==0x0) {
 377     Error("TreeT","No treeT in memory");
 378     return kFALSE;
 379   }
 380   else {
 381      char branchname[30];
 382      sprintf(branchname,"%sTriggerTrack",GetName());
 383      TBranch * branch = 0x0;
 384      branch = TreeT()->GetBranch(branchname);
 385      if (branch)  return kTRUE;
 386      else return kFALSE;
 387   }
 388 }
 389 //____________________________________________________________________________
 390 void AliMUONData::Fill(Option_t* option)
 391 {
 392   // Method to fill the trees
 393   const char *cH   = strstr(option,"H");
 394   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
 395   const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
 396   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
 397   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
 398   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
 399   const char *cRL = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
 400
 401   //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
 402
 403   char branchname[30];
 404   TBranch * branch = 0x0;
 405
 406   //
 407   // Filling TreeH
 408   if ( TreeH() && cH ) {
 409     TreeH()->Fill();
 410   }
 411   //
 412   // Filling TreeD
 413   if ( TreeD() && cD) {
 414     TreeD()->Fill();
 415   }
 416   // Filling TreeS
 417   if ( TreeS() && cS) {
 418     TreeS()->Fill();
 419   }
 420
 421   //
 422   // filling rawclusters
 423   if ( TreeR()  && cRC ) {
 424     if ( IsTriggerBranchesInTree() ) {
 425       // Branch per branch filling
 426       for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
 427         sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 428         branch = TreeR()->GetBranch(branchname);
 429         branch->Fill();
 430       }
 431     }
 432     else  TreeR()->Fill();
 433   }
 434
 435  //
 436   // filling trigger
 437   if ( TreeR()  && cGLT) {
 438     if (IsRawClusterBranchesInTree()) {
 439       // Branch per branch filling
 440       sprintf(branchname,"%sLocalTrigger",GetName());
 441       branch = TreeR()->GetBranch(branchname);
 442       branch->Fill();
 443       sprintf(branchname,"%sGlobalTrigger",GetName());
 444       branch = TreeR()->GetBranch(branchname);
 445       branch->Fill();
 446     }
 447     else  TreeR()->Fill();
 448   }
 449   //
 450   // filling tracks
 451   if ( TreeT() && cRT ) {
 452     if (IsTriggerTrackBranchesInTree()) {
 453         sprintf(branchname,"%sTrack",GetName());
 454         branch = TreeT()->GetBranch(branchname);
 455         branch->Fill();
 456     }
 457     else  TreeT()->Fill();
 458   }
 459   // filling trigger tracks
 460   if ( TreeT() && cRL ) {
 461     if (IsTrackBranchesInTree()) {
 462         sprintf(branchname,"%sTriggerTrack",GetName());
 463         branch = TreeT()->GetBranch(branchname);
 464         branch->Fill();
 465     }
 466     else TreeT()->Fill();
 467   }
 468 //   if ( TreeT() && cRL ) {
 469 //     sprintf(branchname,"%sTrackTrig",GetName());
 470 //     TreeT()->Fill();
 471 //   }
 472 }
 473 //_____________________________________________________________________________
 474 void AliMUONData::MakeBranch(Option_t* option)
 475 {
 476   //
 477   // Create Tree branches for the MUON.
 478   //
 479   const Int_t kBufferSize = 4000;
 480   char branchname[30];
 481
 482
 483   const char *cH   = strstr(option,"H");
 484   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
 485   const char *cS   = strstr(option,"S");   // Digits branches in TreeS
 486   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
 487   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
 488   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
 489   const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
 490   //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
 491
 492   TBranch * branch = 0x0;
 493
 494   // Creating Branches for Hits
 495   if (TreeH() && cH) {
 496
 497     if (fHits == 0x0)  {
 498         fHits = new TClonesArray("AliMUONHit",1000);
 499 //      if (gAlice->GetMCApp())
 500 //        gAlice->GetMCApp()->AddHitList (fHits);
 501     }
 502
 503     fNhits = 0;
 504     sprintf(branchname,"%sHits",GetName());
 505     branch = TreeH()->GetBranch(branchname);
 506     if (branch) {
 507       Info("MakeBranch","Branch %s is already in tree.",GetName());
 508       return ;
 509     }
 510     branch = TreeH()->Branch(branchname,&fHits,kBufferSize);
 511     //Info("MakeBranch","Making Branch %s for hits \n",branchname);
 512   }
 513
 514   //Creating Branches for Digits
 515   if (TreeD() && cD ) {
 516     // one branch for digits per chamber
 517     if (fDigits  == 0x0) {
 518       fDigits  = new TObjArray(AliMUONConstants::NCh());
 519       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 520         TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
 521         tca->SetOwner();
 522         fDigits->AddAt(tca,iDetectionPlane);
 523       }
 524     }
 525     if (fNdigits == 0x0) {
 526       fNdigits = new Int_t[AliMUONConstants::NCh()];
 527       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 528         fNdigits[iDetectionPlane]=0;
 529       }
 530     }
 531     for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 532       sprintf(branchname,"%sDigits%d",GetName(),iDetectionPlane+1);
 533       branch = 0x0;
 534       branch = TreeD()->GetBranch(branchname);
 535       if (branch) {
 536         Info("MakeBranch","Branch %s is already in tree.",GetName());
 537         return;
 538       }
 539       TClonesArray * digits = Digits(iDetectionPlane);
 540       branch = TreeD()->Branch(branchname, &digits, kBufferSize,1);
 541       //Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
 542       }
 543   }
 544
 545   //Creating Branches for SDigits
 546   if (TreeS() && cS ) {
 547     // one branch for Sdigits per chamber
 548     if (fSDigits  == 0x0) {
 549       fSDigits  = new TObjArray(AliMUONConstants::NCh());
 550       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 551         TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
 552         tca->SetOwner();
 553         fSDigits->AddAt(tca,iDetectionPlane);
 554       }
 555     }
 556     if (fNSdigits == 0x0) {
 557       fNSdigits = new Int_t[AliMUONConstants::NCh()];
 558       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 559         fNSdigits[iDetectionPlane]=0;
 560       }
 561     }
 562     for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
 563       sprintf(branchname,"%sSDigits%d",GetName(),iDetectionPlane+1);
 564       branch = 0x0;
 565       branch = TreeS()->GetBranch(branchname);
 566       if (branch) {
 567         Info("MakeBranch","Branch %s is already in tree.",GetName());
 568         return;
 569       }
 570       TClonesArray * Sdigits = SDigits(iDetectionPlane);
 571       branch = TreeS()->Branch(branchname, &Sdigits, kBufferSize,1);
 572       //Info("MakeBranch","Making Branch %s for Sdigits in detection plane %d\n",branchname,iDetectionPlane+1);
 573       }
 574   }
 575
 576   if (TreeR() && cRC ) {
 577     //  one branch for raw clusters per tracking detection plane
 578     //
 579     Int_t i;
 580     if (fRawClusters == 0x0) {
 581       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
 582       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
 583         TClonesArray * tca = new TClonesArray("AliMUONRawCluster",1000);
 584         tca->SetOwner();
 585         fRawClusters->AddAt(tca,i);
 586       }
 587     }
 588
 589     if (fNrawclusters == 0x0) {
 590       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
 591       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
 592         fNrawclusters[i]=0;
 593       }
 594     }
 595
 596     for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
 597       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 598       branch = 0x0;
 599       branch = TreeR()->GetBranch(branchname);
 600       if (branch) {
 601         Info("MakeBranch","Branch %s is already in tree.",GetName());
 602         return;
 603       }
 604       branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize);
 605       //Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
 606     }
 607   }
 608
 609   if (TreeR() && cGLT ) {
 610     //
 611     // one branch for global trigger
 612     //
 613     sprintf(branchname,"%sGlobalTrigger",GetName());
 614     branch = 0x0;
 615
 616     if (fGlobalTrigger == 0x0) {
 617       fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
 618       fNglobaltrigger = 0;
 619     }
 620     branch = TreeR()->GetBranch(branchname);
 621     if (branch) {
 622       Info("MakeBranch","Branch %s is already in tree.",GetName());
 623       return ;
 624     }
 625     branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize);
 626     //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
 627
 628     //
 629     // one branch for local trigger
 630     //
 631     sprintf(branchname,"%sLocalTrigger",GetName());
 632     branch = 0x0;
 633
 634     if (fLocalTrigger == 0x0) {
 635       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 636       fNlocaltrigger = 0;
 637     }
 638     branch = TreeR()->GetBranch(branchname);
 639     if (branch) {
 640       Info("MakeBranch","Branch %s is already in tree.",GetName());
 641       return;
 642     }
 643     branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize);
 644     //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
 645   }
 646
 647   if (TreeT() && cRT ) {
 648     if (fRecTracks == 0x0)  fRecTracks = new TClonesArray("AliMUONTrack",100);
 649     fNrectracks = 0;
 650     sprintf(branchname,"%sTrack",GetName());
 651     branch = TreeT()->GetBranch(branchname);
 652     if (branch) {
 653       Info("MakeBranch","Branch %s is already in tree.",GetName());
 654       return ;
 655     }
 656     branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
 657     //Info("MakeBranch","Making Branch %s for tracks \n",branchname);
 658   }
 659 // trigger tracks
 660   if (TreeT() && cRL ) {
 661     if (fRecTriggerTracks == 0x0)  fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
 662     fNrectriggertracks = 0;
 663     sprintf(branchname,"%sTriggerTrack",GetName());
 664     branch = TreeT()->GetBranch(branchname);
 665     if (branch) {
 666       Info("MakeBranch","Branch %s is already in tree.",GetName());
 667       return ;
 668     }
 669     branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
 670     //Info("MakeBranch","Making Branch %s for trigger tracks \n",branchname);
 671   }
 672 }
 673 //____________________________________________________________________________
 674 TClonesArray*  AliMUONData::RawClusters(Int_t DetectionPlane)
 675 {
 676   // Getting Raw Clusters
 677   if (fRawClusters)
 678     return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
 679   else
 680     return NULL;
 681 }
 682 //____________________________________________________________________________
 683 TClonesArray*  AliMUONData::LocalTrigger()
 684 {
 685   // Getting Local Trigger
 686   if (fLocalTrigger)
 687     return ( (TClonesArray*) fLocalTrigger );
 688   else
 689     return NULL;
 690 }
 691 //____________________________________________________________________________
 692 TClonesArray*  AliMUONData::GlobalTrigger()
 693 {
 694   // Getting Global Trigger
 695   if (fGlobalTrigger)
 696     return ( (TClonesArray*) fGlobalTrigger );
 697   else
 698     return NULL;
 699 }
 700 //____________________________________________________________________________
 701 void AliMUONData::ResetDigits()
 702 {
 703     //
 704     // Reset number of digits and the digits array for this detector
 705     //
 706     if (fDigits == 0x0) return;
 707     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
 708       if ((*fDigits)[i])    ((TClonesArray*)fDigits->At(i))->Clear();
 709       if (fNdigits)  fNdigits[i]=0;
 710     }
 711 }
 712 //____________________________________________________________________________
 713 void AliMUONData::ResetSDigits()
 714 {
 715     //
 716     // Reset number of Sdigits and the Sdigits array for this detector
 717     //
 718     if (fSDigits == 0x0) return;
 719     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
 720       if ((*fSDigits)[i])    ((TClonesArray*)fSDigits->At(i))->Clear();
 721       if (fNSdigits)  fNSdigits[i]=0;
 722     }
 723 }
 724 //______________________________________________________________________________
 725 void AliMUONData::ResetHits()
 726 {
 727   // Reset number of clusters and the cluster array for this detector
 728   fNhits   = 0;
 729   if (fHits) fHits->Clear();
 730 }
 731 //_______________________________________________________________________________
 732 void AliMUONData::ResetRawClusters()
 733 {
 734     // Reset number of raw clusters and the raw clust array for this detector
 735     //
 736   for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
 737     if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
 738     if (fNrawclusters)  fNrawclusters[i]=0;
 739   }
 740 }
 741 //_______________________________________________________________________________
 742 void AliMUONData::ResetTrigger()
 743 {
 744   //  Reset Local and Global Trigger
 745   fNglobaltrigger = 0;
 746   if (fGlobalTrigger) fGlobalTrigger->Clear();
 747   fNlocaltrigger = 0;
 748   if (fLocalTrigger) fLocalTrigger->Clear();
 749 }
 750 //____________________________________________________________________________
 751 void AliMUONData::ResetRecTracks()
 752 {
 753   // Reset tracks information
 754   fNrectracks = 0;
 755   if (fRecTracks) fRecTracks->Clear();
 756 }
 757 //____________________________________________________________________________
 758 void AliMUONData::ResetRecTriggerTracks()
 759 {
 760   // Reset tracks information
 761   fNrectriggertracks = 0;
 762   if (fRecTriggerTracks) fRecTriggerTracks->Clear();
 763 }
 764 //_____________________________________________________________________________
 765 void AliMUONData::SetTreeAddress(Option_t* option)
 766 {
 767   //Setting Addresses to the events trees
 768   const char *cH   = strstr(option,"H");
 769   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
 770   const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
 771   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
 772   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
 773   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
 774   const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
 775   //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
 776
 777   // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
 778   char branchname[30];
 779   TBranch * branch = 0x0;
 780
 781   //
 782   // Branch address for hit tree
 783   if ( TreeH() && cH ) {
 784       if (fHits == 0x0) {
 785         fHits     = new TClonesArray("AliMUONHit",1000);
 786         //      if (gAlice->GetMCApp())
 787         //  gAlice->GetMCApp()->AddHitList (fHits);  Moved to AliMUON
 788     }
 789     fNhits =0;
 790   }
 791   if (TreeH() && fHits && cH) {
 792     sprintf(branchname,"%sHits",GetName());
 793     branch = TreeH()->GetBranch(branchname);
 794     if (branch) {
 795       //      Info("SetTreeAddress","(%s) Setting for Hits",GetName());
 796       branch->SetAddress(&fHits);
 797     }
 798     else { //can be invoked before branch creation
 799       Warning("SetTreeAddress","(%s) Failed for Hits. Can not find branch in tree.",GetName());
 800     }
 801   }
 802
 803   //
 804   // Branch address for digit tree
 805   if ( TreeD() && cD) {
 806     if (fDigits == 0x0) {
 807       fDigits = new TObjArray(AliMUONConstants::NCh());
 808       fNdigits= new Int_t[AliMUONConstants::NCh()];
 809       for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
 810         fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
 811         fNdigits[i]=0;
 812       }
 813     }
 814   }
 815
 816   if (TreeD() && fDigits && cD) {
 817     for (int i=0; i<AliMUONConstants::NCh(); i++) {
 818       sprintf(branchname,"%sDigits%d",GetName(),i+1);
 819       if (fDigits) {
 820         branch = TreeD()->GetBranch(branchname);
 821         TClonesArray * digits = Digits(i);
 822         if (branch) {
 823           branch->SetAddress( &digits );
 824         }
 825         else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
 826       }
 827     }
 828   }
 829   //
 830   // Branch address for Sdigit tree
 831   if ( TreeS() && cS) {
 832     if (fSDigits == 0x0) {
 833       fSDigits = new TObjArray(AliMUONConstants::NCh());
 834       fNSdigits= new Int_t[AliMUONConstants::NCh()];
 835       for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
 836         fSDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
 837         fNSdigits[i]=0;
 838       }
 839     }
 840   }
 841
 842   if (TreeS() && fSDigits && cS) {
 843     for (int i=0; i<AliMUONConstants::NCh(); i++) {
 844       sprintf(branchname,"%sSDigits%d",GetName(),i+1);
 845       if (fSDigits) {
 846         branch = TreeS()->GetBranch(branchname);
 847         TClonesArray * Sdigits = SDigits(i);
 848         if (branch) branch->SetAddress( &Sdigits );
 849         else Warning("SetTreeAddress","(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i);
 850       }
 851     }
 852   }
 853
 854   //
 855   // Branch address for rawclusters, globaltrigger and local trigger tree
 856   if (TreeR() ) {
 857     if (fRawClusters == 0x0 && cRC) {
 858       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
 859       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
 860       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
 861         fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
 862         fNrawclusters[i]=0;
 863       }
 864     }
 865     if (fLocalTrigger == 0x0 && cGLT) {
 866       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 867     }
 868     if (fGlobalTrigger== 0x0 && cGLT) {
 869         fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
 870     }
 871
 872   }
 873   if ( TreeR()  && fRawClusters && cRC) {
 874     for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
 875       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 876       if (fRawClusters) {
 877         branch = TreeR()->GetBranch(branchname);
 878         if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
 879         else Warning("SetTreeAddress","(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i);
 880       }
 881     }
 882   }
 883   if ( TreeR()  && fLocalTrigger && cGLT) {
 884     sprintf(branchname,"%sLocalTrigger",GetName());
 885     branch = TreeR()->GetBranch(branchname);
 886     if (branch) branch->SetAddress(&fLocalTrigger);
 887     else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
 888   }
 889   if ( TreeR() && fGlobalTrigger && cGLT) {
 890     sprintf(branchname,"%sGlobalTrigger",GetName());
 891     branch = TreeR()->GetBranch(branchname);
 892     if (branch) branch->SetAddress(&fGlobalTrigger);
 893     else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
 894   }
 895
 896   if ( TreeT() ) {
 897     if (fRecTracks == 0x0 && cRT)  {
 898       fRecTracks  = new TClonesArray("AliMUONTrack",100);
 899     }
 900
 901   }
 902   if ( TreeT() && fRecTracks && cRT ) {
 903     sprintf(branchname,"%sTrack",GetName());
 904     branch = TreeT()->GetBranch(branchname);
 905     if (branch) branch->SetAddress(&fRecTracks);
 906     else Warning("SetTreeAddress","(%s) Failed for Tracks. Can not find branch in tree.",GetName());
 907   }
 908 // trigger tracks
 909   if ( TreeT() ) {
 910     if (fRecTriggerTracks == 0x0 && cRL)  {
 911       fRecTriggerTracks  = new TClonesArray("AliMUONTriggerTrack",100);
 912     }
 913
 914   }
 915   if ( TreeT() && fRecTriggerTracks && cRL ) {
 916     sprintf(branchname,"%sTriggerTrack",GetName());
 917     branch = TreeT()->GetBranch(branchname);
 918     if (branch) branch->SetAddress(&fRecTriggerTracks);
 919     else Warning("SetTreeAddress","(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName());
 920   }
 921
 922
 923 }
 924 //_____________________________________________________________________________