MUON/AliMUON.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18
  19 ///////////////////////////////////////////////
  20 //  Manager and hits classes for set:MUON     //
  21 ////////////////////////////////////////////////
  22
  23 #include "Riostream.h"
  24
  25 #include <AliPDG.h>
  26 #include <TBRIK.h>
  27 #include <TCanvas.h>
  28 #include <TDirectory.h>
  29 #include <TFile.h>
  30 #include <TGeometry.h>
  31 #include <TMinuit.h>
  32 #include <TNode.h>
  33 #include <TNtuple.h>
  34 #include <TObjArray.h>
  35 #include <TObject.h>
  36 #include <TObjectTable.h>
  37 #include <TPad.h>
  38 #include <TParticle.h>
  39 #include <TROOT.h>
  40 #include <TRandom.h>
  41 #include <TRotMatrix.h>
  42 #include <TTUBE.h>
  43 #include <TTUBE.h>
  44 #include <TTree.h>
  45 #include <TVector.h>
  46 #include <TVirtualMC.h>
  47
  48 #include "AliConst.h"
  49 #include "AliHeader.h"
  50 #include "AliHitMap.h"
  51 #include "AliLoader.h"
  52 #include "AliRunDigitizer.h"
  53 #include "AliMC.h"
  54 #include "AliMUONLoader.h"
  55 #include "AliMUON.h"
  56 #include "AliMUONChamberTrigger.h"
  57 #include "AliMUONClusterFinderAZ.h"
  58 #include "AliMUONConstants.h"
  59 #include "AliMUONDigit.h"
  60 #include "AliMUONGlobalTrigger.h"
  61 #include "AliMUONHit.h"
  62 #include "AliMUONHitMapA1.h"
  63 #include "AliMUONLocalTrigger.h"
  64 #include "AliMUONMerger.h"
  65 #include "AliMUONPadHit.h"
  66 #include "AliMUONRawCluster.h"
  67 #include "AliMUONTransientDigit.h"
  68 #include "AliMUONTriggerCircuit.h"
  69 #include "AliMUONTriggerDecision.h"
  70 #include "AliMUONVGeometryBuilder.h"
  71 #include "AliRun.h"
  72 #include "AliMUONDigitizerv2.h"
  73 #include "AliMUONSDigitizerv1.h"
  74
  75
  76 // Defaults parameters for Z positions of chambers
  77 // taken from values for "stations" in AliMUON::AliMUON
  78 //     const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
  79 // and from array "dstation" in AliMUONv1::CreateGeometry
  80 //          Float_t dstation[5]={20., 20., 20, 20., 20.};
  81 //     for tracking chambers,
  82 //          according to (Z1 = zch - dstation) and  (Z2 = zch + dstation)
  83 //          for the first and second chambers in the station, respectively,
  84 // and from "DTPLANES" in AliMUONv1::CreateGeometry
  85 //           const Float_t DTPLANES = 15.;
  86 //     for trigger chambers,
  87 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
  88 //          for the first and second chambers in the station, respectively
  89
  90 ClassImp(AliMUON)
  91 //__________________________________________________________________
  92 AliMUON::AliMUON()
  93 {
  94 // Default Constructor
  95 //
  96     fNCh             = 0;
  97     fNTrackingCh     = 0;
  98     fIshunt          = 0;
  99     fChambers        = 0;
 100     fGeometryBuilders = 0;
 101     fTriggerCircuits = 0;
 102     fAccMin          = 0.;
 103     fAccMax          = 0.;
 104     fAccCut          = kFALSE;
 105     fMerger          = 0;
 106     fMUONData        = 0;
 107     fSplitLevel      = 0;
 108 }
 109 //__________________________________________________________________
 110 AliMUON::AliMUON(const char *name, const char *title)
 111   : AliDetector(name,title)
 112 {
 113 //Begin_Html
 114 /*
 115 <img src="gif/alimuon.gif">
 116 */
 117 //End_Html
 118   fMUONData  = 0x0;
 119   fSplitLevel= 0;
 120   fIshunt     =  0;
 121
 122   fNCh             = AliMUONConstants::NCh();
 123   fNTrackingCh     = AliMUONConstants::NTrackingCh();
 124
 125   SetMarkerColor(kRed);//
 126 //
 127 // Creating List of Chambers
 128     Int_t ch;
 129     fChambers = new TObjArray(AliMUONConstants::NCh());
 130     fGeometryBuilders = new TObjArray(AliMUONConstants::NCh());
 131
 132     // Loop over stations
 133     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
 134       // Loop over 2 chambers in the station
 135       for (Int_t stCH = 0; stCH < 2; stCH++) {
 136         //
 137         //
 138         //    Default Parameters for Muon Tracking Stations
 139         ch = 2 * st + stCH;
 140         if (ch < AliMUONConstants::NTrackingCh()) {
 141           fChambers->AddAt(new AliMUONChamber(ch),ch);
 142         } else {
 143           fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
 144         }
 145         AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
 146         //chamber->SetGid(0);
 147         // Default values for Z of chambers
 148         chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
 149         //
 150         chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
 151         //          Set chamber inner and outer radius to default
 152         chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
 153         chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
 154         //
 155       } // Chamber stCH (0, 1) in
 156     }     // Station st (0...)
 157
 158     // Negatives values are ignored by geant3 CONS200 in the calculation of the tracking parameters
 159     fMaxStepGas=0.1;
 160     fMaxStepAlu=0.1;
 161     fMaxDestepGas=-1;
 162     fMaxDestepAlu=-1;
 163
 164     fMaxIterPad   = 0;
 165     fCurIterPad   = 0;
 166
 167     fAccMin          = 0.;
 168     fAccMax          = 0.;
 169     fAccCut          = kFALSE;
 170
 171     // cp new design of AliMUONTriggerDecision
 172     fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
 173     for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
 174       fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
 175     }
 176     fMerger = 0;
 177 }
 178 //____________________________________________________________________
 179 AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
 180 {
 181 // Dummy copy constructor
 182     ;
 183
 184 }
 185 //____________________________________________________________________
 186 AliMUON::~AliMUON()
 187 {
 188 // Destructor
 189   if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
 190   fIshunt  = 0;
 191   if (fMerger) delete fMerger;
 192
 193   if (fGeometryBuilders){
 194     fGeometryBuilders->Delete();
 195     delete fGeometryBuilders;
 196   }
 197   if (fChambers){
 198     fChambers->Delete();
 199     delete fChambers;
 200   }
 201   if (fTriggerCircuits){
 202     fTriggerCircuits->Delete();
 203     delete fTriggerCircuits;
 204   }
 205   delete fMUONData;
 206 }
 207 //_____________________________________________________________________________
 208 void AliMUON::AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder)
 209 {
 210 // Adds the geometry builder to the list
 211 // ---
 212
 213   fGeometryBuilders->Add(geomBuilder);
 214 }
 215 //____________________________________________________________________
 216 void AliMUON::BuildGeometry()
 217 {
 218 // Geometry for event display
 219   for (Int_t i=0; i<7; i++) {
 220     for (Int_t j=0; j<2; j++) {
 221       Int_t id=2*i+j+1;
 222       this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
 223     }
 224   }
 225 }
 226 //___________________________________________________________________
 227 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
 228 {
 229   return 9999;
 230 }
 231 //__________________________________________________________________
 232 void  AliMUON::SetTreeAddress()
 233 {
 234   GetMUONData()->SetLoader(fLoader);
 235   //  GetMUONData()->MakeBranch("D,S,RC");
 236   //  GetMUONData()->SetTreeAddress("H,D,S,RC");
 237   GetMUONData()->SetTreeAddress("H");
 238   if (fHits !=  GetMUONData()->Hits())  {
 239     if ( gAlice->GetMCApp() )
 240       if ( gAlice->GetMCApp()->GetHitLists() ) {
 241         fHits = GetMUONData()->Hits();
 242         gAlice->GetMCApp()->AddHitList(fHits); // For purifyKine, only necessary when Hit list is created in AliMUONData
 243       }
 244   }
 245   fHits = GetMUONData()->Hits(); // Added by Ivana to use the methods FisrtHit, NextHit of AliDetector
 246 }
 247
 248 //____________________________________________________________________
 249 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
 250 {
 251 // Set the pad size for chamber id and cathode isec
 252     Int_t i=2*(id-1);
 253     ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
 254     ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
 255 }
 256
 257 //___________________________________________
 258 void AliMUON::SetChambersZ(const Float_t *Z)
 259 {
 260   // Set Z values for all chambers (tracking and trigger)
 261   // from the array pointed to by "Z"
 262     for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
 263         ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
 264     return;
 265 }
 266 //_________________________________________________________________
 267 void AliMUON::SetChambersZToDefault()
 268 {
 269   // Set Z values for all chambers (tracking and trigger)
 270   // to default values
 271   SetChambersZ(AliMUONConstants::DefaultChamberZ());
 272   return;
 273 }
 274 //_________________________________________________________________
 275 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
 276 {
 277 // Set the inverse charge slope for chamber id
 278     Int_t i=2*(id-1);    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
 279     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
 280     ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
 281     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
 282 }
 283 //__________________________________________________________________
 284 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
 285 {
 286 // Set sigma of charge spread for chamber id
 287     Int_t i=2*(id-1);
 288     ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
 289     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
 290 }
 291 //___________________________________________________________________
 292 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
 293 {
 294 // Set integration limits for charge spread
 295     Int_t i=2*(id-1);
 296     ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
 297     ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
 298 }
 299
 300 //__________________________________________________________________
 301 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
 302 {
 303 // Set maximum number for ADCcounts (saturation)
 304     Int_t i=2*(id-1);
 305     ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
 306     ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
 307 }
 308 //__________________________________________________________________
 309 void AliMUON::SetMaxStepGas(Float_t p1)
 310 {
 311 // Set stepsize in gas
 312   fMaxStepGas=p1;
 313 }
 314 //__________________________________________________________________
 315 void AliMUON::SetMaxStepAlu(Float_t p1)
 316 {
 317 // Set step size in Alu
 318     fMaxStepAlu=p1;
 319 }
 320 //__________________________________________________________________
 321 void AliMUON::SetMaxDestepGas(Float_t p1)
 322 {
 323 // Set maximum step size in Gas
 324     fMaxDestepGas=p1;
 325 }
 326 //__________________________________________________________________
 327 void AliMUON::SetMaxDestepAlu(Float_t p1)
 328 {
 329 // Set maximum step size in Alu
 330   fMaxDestepAlu=p1;
 331 }
 332 //___________________________________________________________________
 333 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
 334 {
 335 // Set acceptance cuts
 336   fAccCut=acc;
 337   fAccMin=angmin*TMath::Pi()/180;
 338   fAccMax=angmax*TMath::Pi()/180;
 339   Int_t ch;
 340   if (acc) {
 341     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
 342       // Loop over 2 chambers in the station
 343       for (Int_t stCH = 0; stCH < 2; stCH++) {
 344         ch = 2 * st + stCH;
 345         //         Set chamber inner and outer radius according to acceptance cuts
 346         Chamber(ch).SetRInner(TMath::Abs(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin)));
 347         Chamber(ch).SetROuter(TMath::Abs(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax)));
 348       } // chamber loop
 349     } // station loop
 350   }
 351 }
 352
 353 //____________________________________________________________________
 354 Float_t  AliMUON::GetMaxStepGas() const
 355 {
 356 // Return stepsize in gas
 357
 358   return fMaxStepGas;
 359 }
 360
 361 //____________________________________________________________________
 362 Float_t  AliMUON::GetMaxStepAlu() const
 363 {
 364 // Return step size in Alu
 365
 366   return fMaxStepAlu;
 367 }
 368
 369 //____________________________________________________________________
 370 Float_t  AliMUON::GetMaxDestepGas() const
 371 {
 372 // Return maximum step size in Gas
 373
 374   return fMaxDestepGas;
 375 }
 376
 377 //____________________________________________________________________
 378 Float_t  AliMUON::GetMaxDestepAlu() const
 379 {
 380 // Return maximum step size in Gas
 381
 382   return fMaxDestepAlu;
 383 }
 384 //____________________________________________________________________
 385 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
 386 {
 387 // Set the segmentation for chamber id cathode isec
 388     ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
 389
 390 }
 391 //____________________________________________________________________
 392 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
 393 {
 394 // Set the response for chamber id
 395     ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
 396 }
 397 //____________________________________________________________________
 398 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
 399 {
 400 // Set number of segmented cathods for chamber id
 401     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
 402 }
 403 //____________________________________________________________________
 404 AliDigitizer* AliMUON::CreateDigitizer(AliRunDigitizer* manager) const
 405 {
 406   return new AliMUONDigitizerv2(manager);
 407 }
 408 //_____________________________________________________________________
 409 void AliMUON::SDigits2Digits()
 410 {
 411
 412 // write TreeD here
 413
 414     if (!fMerger) {
 415       if (gAlice->GetDebug()>0) {
 416         cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
 417         cerr<<" no merging, just digitization of 1 event will be done"<<endl;
 418       }
 419       fMerger = new AliMUONMerger();
 420     }
 421     fMerger->Init();
 422     fMerger->Digitise();
 423     char hname[30];
 424     //    sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
 425     fLoader->TreeD()->Write(hname,TObject::kOverwrite);
 426     fLoader->TreeD()->Reset();
 427 }
 428
 429 //_____________________________________________________________________
 430 void AliMUON::Hits2SDigits()
 431 {
 432   // Adaption of AliMUONSDigitizerv1 to be excuted by the AliSimulation framework
 433   AliRunLoader* runLoader = fLoader->GetRunLoader();
 434   AliRunDigitizer   * manager = new AliRunDigitizer(1,1);
 435   manager->SetInputStream(0,runLoader->GetFileName(),AliConfig::GetDefaultEventFolderName());
 436   AliMUONDigitizer * dMUON   = new AliMUONSDigitizerv1(manager);
 437   fLoader->LoadHits("READ");
 438   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 439     runLoader->GetEvent(iEvent);
 440     dMUON->Exec("");
 441   }
 442   fLoader->UnloadHits();
 443 }
 444 //_______________________________________________________________________
 445 AliLoader* AliMUON::MakeLoader(const char* topfoldername)
 446 {
 447 //builds standard getter (AliLoader type)
 448 //if detector wants to use castomized getter, it must overload this method
 449
 450  if (GetDebug())
 451    Info("MakeLoader",
 452         "Creating standard getter for detector %s. Top folder is %s.",
 453          GetName(),topfoldername);
 454  fLoader   = new AliLoader(GetName(),topfoldername);
 455  fMUONData = new AliMUONData(fLoader,GetName(),GetName());
 456  fMUONData->SetSplitLevel(fSplitLevel);
 457  return fLoader;
 458 }
 459
 460 //______________________________________________________________________
 461 #ifdef never
 462 void AliMUON::Streamer(TBuffer &R__b)_
 463 {
 464    // Stream an object of class AliMUON.
 465       AliMUONChamber        *iChamber;
 466       AliMUONTriggerCircuit *iTriggerCircuit;
 467       AliSegmentation       *segmentation;
 468       AliMUONResponse       *response;
 469       TClonesArray          *digitsaddress;
 470       TClonesArray          *rawcladdress;
 471       Int_t i;
 472       if (R__b.IsReading()) {
 473           Version_t R__v = R__b.ReadVersion(); if (R__v) { }
 474           AliDetector::Streamer(R__b);
 475           R__b >> fNPadHits;
 476           R__b >> fPadHits; // diff
 477           R__b >> fNLocalTrigger;
 478           R__b >> fLocalTrigger;
 479           R__b >> fNGlobalTrigger;
 480           R__b >> fGlobalTrigger;
 481           R__b >> fDchambers;
 482           R__b >> fRawClusters;
 483           R__b.ReadArray(fNdch);
 484           R__b.ReadArray(fNrawch);
 485           R__b >> fAccCut;
 486           R__b >> fAccMin;
 487           R__b >> fAccMax;
 488           R__b >> fChambers;
 489           R__b >> fTriggerCircuits;
 490           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
 491               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
 492               iTriggerCircuit->Streamer(R__b);
 493           }
 494 // Stream chamber related information
 495           for (i =0; i<AliMUONConstants::NCh(); i++) {
 496               iChamber=(AliMUONChamber*) (*fChambers)[i];
 497               iChamber->Streamer(R__b);
 498               if (iChamber->Nsec()==1) {
 499                   segmentation=iChamber->SegmentationModel(1);
 500                   if (segmentation)
 501                       segmentation->Streamer(R__b);
 502               } else {
 503                   segmentation=iChamber->SegmentationModel(1);
 504                   if (segmentation)
 505                       segmentation->Streamer(R__b);
 506                   if (segmentation)
 507                       segmentation=iChamber->SegmentationModel(2);
 508                   segmentation->Streamer(R__b);
 509               }
 510               response=iChamber->ResponseModel();
 511               if (response)
 512                   response->Streamer(R__b);
 513               digitsaddress=(TClonesArray*) (*fDchambers)[i];
 514               digitsaddress->Streamer(R__b);
 515               if (i < AliMUONConstants::NTrackingCh()) {
 516                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
 517                   rawcladdress->Streamer(R__b);
 518               }
 519           }
 520
 521       } else {
 522           R__b.WriteVersion(AliMUON::IsA());
 523           AliDetector::Streamer(R__b);
 524           R__b << fNPadHits;
 525           R__b << fPadHits; // diff
 526           R__b << fNLocalTrigger;
 527           R__b << fLocalTrigger;
 528           R__b << fNGlobalTrigger;
 529           R__b << fGlobalTrigger;
 530           R__b << fDchambers;
 531           R__b << fRawClusters;
 532           R__b.WriteArray(fNdch, AliMUONConstants::NCh());
 533           R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
 534
 535           R__b << fAccCut;
 536           R__b << fAccMin;
 537           R__b << fAccMax;
 538
 539           R__b << fChambers;
 540           R__b << fTriggerCircuits;
 541           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
 542               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
 543               iTriggerCircuit->Streamer(R__b);
 544           }
 545           for (i =0; i<AliMUONConstants::NCh(); i++) {
 546               iChamber=(AliMUONChamber*) (*fChambers)[i];
 547               iChamber->Streamer(R__b);
 548               if (iChamber->Nsec()==1) {
 549                   segmentation=iChamber->SegmentationModel(1);
 550                   if (segmentation)
 551                       segmentation->Streamer(R__b);
 552               } else {
 553                   segmentation=iChamber->SegmentationModel(1);
 554                   if (segmentation)
 555                       segmentation->Streamer(R__b);
 556                   segmentation=iChamber->SegmentationModel(2);
 557                   if (segmentation)
 558                       segmentation->Streamer(R__b);
 559               }
 560               response=iChamber->ResponseModel();
 561               if (response)
 562                   response->Streamer(R__b);
 563               digitsaddress=(TClonesArray*) (*fDchambers)[i];
 564               digitsaddress->Streamer(R__b);
 565               if (i < AliMUONConstants::NTrackingCh()) {
 566                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
 567                   rawcladdress->Streamer(R__b);
 568               }
 569           }
 570       }
 571 }
 572 #endif
 573 //_______________________________________________________________________
 574 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters)
 575 {
 576 // to be removed
 577     // Initialise the pad iterator
 578     // Return the address of the first padhit for hit
 579     TClonesArray *theClusters = clusters;
 580     Int_t nclust = theClusters->GetEntriesFast();
 581     if (nclust && hit->PHlast() > 0) {
 582         AliMUON::fMaxIterPad=hit->PHlast();
 583         AliMUON::fCurIterPad=hit->PHfirst();
 584         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
 585     } else {
 586         return 0;
 587     }
 588 }
 589 //_______________________________________________________________________
 590 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
 591 {
 592   // To be removed
 593 // Get next pad (in iterator)
 594 //
 595     AliMUON::fCurIterPad++;
 596     if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
 597         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
 598     } else {
 599         return 0;
 600     }
 601 }
 602 //_______________________________________________________________________
 603
 604 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
 605 {
 606 //
 607 //  Return rawcluster (icluster) for chamber ichamber and cathode icathod
 608 //  Obsolete ??
 609     TClonesArray *muonRawCluster  = GetMUONData()->RawClusters(ichamber);
 610     ResetRawClusters();
 611     TTree *treeR = fLoader->TreeR();
 612     Int_t nent=(Int_t)treeR->GetEntries();
 613     treeR->GetEvent(nent-2+icathod-1);
 614     //treeR->GetEvent(icathod);
 615     //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
 616
 617     AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
 618     //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
 619
 620     return  mRaw;
 621 }
 622 //________________________________________________________________________
 623 void   AliMUON::SetMerger(AliMUONMerger* merger)
 624 {
 625 // Set pointer to merger
 626     fMerger = merger;
 627 }
 628 //________________________________________________________________________
 629 AliMUONMerger*  AliMUON::Merger()
 630 {
 631 // Return pointer to merger
 632     return fMerger;
 633 }
 634 //________________________________________________________________________
 635 AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
 636 {
 637 // copy operator
 638 // dummy version
 639     return *this;
 640 }