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