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