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 "AliMUONLoader.h"
  53 #include "AliMUON.h"
  54 #include "AliMUONChamberTrigger.h"
  55 #include "AliMUONClusterFinderVS.h"
  56 #include "AliMUONClusterInput.h"
  57 #include "AliMUONConstants.h"
  58 #include "AliMUONDigit.h"
  59 #include "AliMUONGlobalTrigger.h"
  60 #include "AliMUONHit.h"
  61 #include "AliMUONHitMapA1.h"
  62 #include "AliMUONLocalTrigger.h"
  63 #include "AliMUONMerger.h"
  64 #include "AliMUONPadHit.h"
  65 #include "AliMUONRawCluster.h"
  66 #include "AliMUONTransientDigit.h"
  67 #include "AliMUONTriggerCircuit.h"
  68 #include "AliMUONTriggerDecision.h"
  69 #include "AliRun.h"
  70
  71
  72 // Defaults parameters for Z positions of chambers
  73 // taken from values for "stations" in AliMUON::AliMUON
  74 //     const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
  75 // and from array "dstation" in AliMUONv1::CreateGeometry
  76 //          Float_t dstation[5]={20., 20., 20, 20., 20.};
  77 //     for tracking chambers,
  78 //          according to (Z1 = zch - dstation) and  (Z2 = zch + dstation)
  79 //          for the first and second chambers in the station, respectively,
  80 // and from "DTPLANES" in AliMUONv1::CreateGeometry
  81 //           const Float_t DTPLANES = 15.;
  82 //     for trigger chambers,
  83 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
  84 //          for the first and second chambers in the station, respectively
  85
  86 ClassImp(AliMUON)
  87 //__________________________________________________________________
  88 AliMUON::AliMUON()
  89 {
  90 // Default Constructor
  91 //
  92     fNCh             = 0;
  93     fNTrackingCh     = 0;
  94     fIshunt          = 0;
  95     fChambers        = 0;
  96     fTriggerCircuits = 0;
  97     fAccMin          = 0.;
  98     fAccMax          = 0.;
  99     fAccCut          = kFALSE;
 100     fMerger          = 0;
 101     fFileName        = 0;
 102     fMUONData        = 0;
 103 }
 104 //__________________________________________________________________
 105 AliMUON::AliMUON(const char *name, const char *title)
 106   : AliDetector(name,title)
 107 {
 108 //Begin_Html
 109 /*
 110 <img src="gif/alimuon.gif">
 111 */
 112 //End_Html
 113   fMUONData  = 0x0;
 114   fIshunt     =  0;
 115
 116   fNCh             = AliMUONConstants::NCh();
 117   fNTrackingCh     = AliMUONConstants::NTrackingCh();
 118
 119   SetMarkerColor(kRed);//
 120 //
 121 // Creating List of Chambers
 122     Int_t ch;
 123     fChambers = new TObjArray(AliMUONConstants::NCh());
 124     // Loop over stations
 125     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
 126       // Loop over 2 chambers in the station
 127       for (Int_t stCH = 0; stCH < 2; stCH++) {
 128         //
 129         //
 130         //    Default Parameters for Muon Tracking Stations
 131         ch = 2 * st + stCH;
 132         if (ch < AliMUONConstants::NTrackingCh()) {
 133           fChambers->AddAt(new AliMUONChamber(ch),ch);
 134         } else {
 135           fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
 136         }
 137         AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
 138         chamber->SetGid(0);
 139         // Default values for Z of chambers
 140         chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
 141         //
 142         chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
 143         //          Set chamber inner and outer radius to default
 144         chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
 145         chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
 146         //
 147       } // Chamber stCH (0, 1) in
 148     }     // Station st (0...)
 149
 150     fMaxStepGas=0.01;
 151     fMaxStepAlu=0.1;
 152     fMaxDestepGas=-1;
 153     fMaxDestepAlu=-1;
 154
 155     fMaxIterPad   = 0;
 156     fCurIterPad   = 0;
 157
 158     fAccMin          = 0.;
 159     fAccMax          = 0.;
 160     fAccCut          = kFALSE;
 161
 162     // cp new design of AliMUONTriggerDecision
 163     fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
 164     for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
 165       fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
 166     }
 167     fMerger = 0;
 168 }
 169 //____________________________________________________________________
 170 AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
 171 {
 172 // Dummy copy constructor
 173     ;
 174
 175 }
 176 //____________________________________________________________________
 177 AliMUON::~AliMUON()
 178 {
 179 // Destructor
 180   if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
 181   fIshunt  = 0;
 182   if (fMerger) delete fMerger;
 183 }
 184 //____________________________________________________________________
 185 void AliMUON::BuildGeometry()
 186 {
 187 // Geometry for event display
 188   for (Int_t i=0; i<7; i++) {
 189     for (Int_t j=0; j<2; j++) {
 190       Int_t id=2*i+j+1;
 191       this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
 192     }
 193   }
 194 }
 195 //___________________________________________________________________
 196 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
 197 {
 198   return 9999;
 199 }
 200 //__________________________________________________________________
 201 void  AliMUON::SetTreeAddress()
 202 {
 203   GetMUONData()->SetLoader(fLoader);
 204   GetMUONData()->SetTreeAddress("H,D,RC");
 205 }
 206
 207 //____________________________________________________________________
 208 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
 209 {
 210 // Set the pad size for chamber id and cathode isec
 211     Int_t i=2*(id-1);
 212     ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
 213     ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
 214 }
 215
 216 //___________________________________________
 217 void AliMUON::SetChambersZ(const Float_t *Z)
 218 {
 219   // Set Z values for all chambers (tracking and trigger)
 220   // from the array pointed to by "Z"
 221     for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
 222         ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
 223     return;
 224 }
 225 //_________________________________________________________________
 226 void AliMUON::SetChambersZToDefault()
 227 {
 228   // Set Z values for all chambers (tracking and trigger)
 229   // to default values
 230   SetChambersZ(AliMUONConstants::DefaultChamberZ());
 231   return;
 232 }
 233 //_________________________________________________________________
 234 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
 235 {
 236 // Set the inverse charge slope for chamber id
 237     Int_t i=2*(id-1);    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
 238     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
 239     ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
 240     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
 241 }
 242 //__________________________________________________________________
 243 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
 244 {
 245 // Set sigma of charge spread for chamber id
 246     Int_t i=2*(id-1);
 247     ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
 248     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
 249 }
 250 //___________________________________________________________________
 251 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
 252 {
 253 // Set integration limits for charge spread
 254     Int_t i=2*(id-1);
 255     ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
 256     ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
 257 }
 258
 259 //__________________________________________________________________
 260 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
 261 {
 262 // Set maximum number for ADCcounts (saturation)
 263     Int_t i=2*(id-1);
 264     ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
 265     ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
 266 }
 267 //__________________________________________________________________
 268 void AliMUON::SetMaxStepGas(Float_t p1)
 269 {
 270 // Set stepsize in gas
 271   fMaxStepGas=p1;
 272 }
 273 //__________________________________________________________________
 274 void AliMUON::SetMaxStepAlu(Float_t p1)
 275 {
 276 // Set step size in Alu
 277     fMaxStepAlu=p1;
 278 }
 279 //__________________________________________________________________
 280 void AliMUON::SetMaxDestepGas(Float_t p1)
 281 {
 282 // Set maximum step size in Gas
 283     fMaxDestepGas=p1;
 284 }
 285 //__________________________________________________________________
 286 void AliMUON::SetMaxDestepAlu(Float_t p1)
 287 {
 288 // Set maximum step size in Alu
 289   fMaxDestepAlu=p1;
 290 }
 291 //___________________________________________________________________
 292 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
 293 {
 294 // Set acceptance cuts
 295   fAccCut=acc;
 296   fAccMin=angmin*TMath::Pi()/180;
 297   fAccMax=angmax*TMath::Pi()/180;
 298   Int_t ch;
 299   if (acc) {
 300     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
 301       // Loop over 2 chambers in the station
 302       for (Int_t stCH = 0; stCH < 2; stCH++) {
 303         ch = 2 * st + stCH;
 304         //         Set chamber inner and outer radius according to acceptance cuts
 305         Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
 306         Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
 307       } // chamber loop
 308     } // station loop
 309   }
 310 }
 311 //____________________________________________________________________
 312 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
 313 {
 314 // Set the segmentation for chamber id cathode isec
 315     ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
 316
 317 }
 318 //____________________________________________________________________
 319 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
 320 {
 321 // Set the response for chamber id
 322     ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
 323 }
 324 //____________________________________________________________________
 325 void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
 326 {
 327 // Set ClusterFinder for chamber id
 328     ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
 329 }
 330 //____________________________________________________________________
 331 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
 332 {
 333 // Set number of segmented cathods for chamber id
 334     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
 335 }
 336 //_____________________________________________________________________
 337 void AliMUON::SDigits2Digits()
 338 {
 339
 340 // write TreeD here
 341
 342     if (!fMerger) {
 343       if (gAlice->GetDebug()>0) {
 344         cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
 345         cerr<<" no merging, just digitization of 1 event will be done"<<endl;
 346       }
 347       fMerger = new AliMUONMerger();
 348     }
 349     fMerger->Init();
 350     fMerger->Digitise();
 351     char hname[30];
 352     //    sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
 353     fLoader->TreeD()->Write(hname,TObject::kOverwrite);
 354     fLoader->TreeD()->Reset();
 355 }
 356
 357 //_______________________________________________________________________
 358 AliLoader* AliMUON::MakeLoader(const char* topfoldername)
 359 {
 360 //builds standard getter (AliLoader type)
 361 //if detector wants to use castomized getter, it must overload this method
 362
 363  if (GetDebug())
 364    Info("MakeLoader",
 365         "Creating standard getter for detector %s. Top folder is %s.",
 366          GetName(),topfoldername);
 367
 368  fLoader   = new AliLoader(GetName(),topfoldername);
 369  fMUONData = new AliMUONData(fLoader,GetName(),GetName());
 370  return fLoader;
 371 }
 372
 373 //_______________________________________________________________________
 374 void AliMUON::Trigger(Int_t nev){
 375 // call the Trigger Algorithm and fill TreeR
 376
 377   Int_t singlePlus[3]  = {0,0,0};
 378   Int_t singleMinus[3] = {0,0,0};
 379   Int_t singleUndef[3] = {0,0,0};
 380   Int_t pairUnlike[3]  = {0,0,0};
 381   Int_t pairLike[3]    = {0,0,0};
 382
 383   ResetTrigger();
 384   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
 385   decision->Trigger();
 386   decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
 387                              pairUnlike, pairLike);
 388
 389   // add a local trigger in the list
 390   GetMUONData()->AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
 391   Int_t i;
 392
 393   for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) {
 394     if(decision->GetITrigger(icirc)==1) {
 395       Int_t localtr[7]={0,0,0,0,0,0,0};
 396       Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
 397       decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
 398       localtr[0] = icirc;
 399       localtr[1] = decision->GetStripX11(icirc);
 400       localtr[2] = decision->GetDev(icirc);
 401       localtr[3] = decision->GetStripY11(icirc);
 402       for (i=0; i<2; i++) {    // convert the Lut output in 1 digit
 403         localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
 404         localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
 405         localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
 406       }
 407       GetMUONData()->AddLocalTrigger(localtr);  // add a local trigger in the list
 408     }
 409   }
 410
 411   delete decision;
 412
 413   //  fLoader->TreeR()->Fill();
 414   GetMUONData()->Fill("GLT"); //Filling Global and Local Trigger GLT
 415   //  char hname[30];
 416   //  sprintf(hname,"TreeR%d",nev);
 417   //  fLoader->TreeR()->Write(hname,TObject::kOverwrite);
 418     //  fLoader->TreeR()->Reset();
 419   fLoader->WriteRecPoints("OVERWRITE");
 420
 421   printf("\n End of trigger for event %d", nev);
 422 }
 423
 424 //____________________________________________________________________
 425 void AliMUON::Digits2Reco()
 426 {
 427   FindClusters();
 428   Int_t nev = gAlice->GetHeader()->GetEvent();
 429   GetMUONData()->Fill("RC"); //Filling Reconstructed Cluster
 430   fLoader->WriteRecPoints("OVERWRITE");
 431   GetMUONData()->ResetRawClusters();
 432   Info("Digits2Reco","End of cluster finding for event %d", nev);
 433 }
 434 //____________________________________________________________________
 435 void AliMUON::FindClusters()
 436 {
 437 //
 438 //  Perform cluster finding
 439 //
 440     TClonesArray *dig1, *dig2;
 441     Int_t ndig, k;
 442     dig1 = new TClonesArray("AliMUONDigit",1000);
 443     dig2 = new TClonesArray("AliMUONDigit",1000);
 444     AliMUONDigit *digit;
 445 // Loop on chambers and on cathode planes
 446 //
 447     ResetRawClusters();
 448     TClonesArray * muonDigits;
 449
 450     for (Int_t ich = 0; ich < 10; ich++) {
 451       //PH      AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
 452         AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
 453         AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
 454
 455         ResetDigits();
 456         GetMUONData()->GetCathode(0);
 457         //TClonesArray *
 458         muonDigits = GetMUONData()->Digits(ich);
 459         ndig=muonDigits->GetEntriesFast();
 460         printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
 461         TClonesArray &lhits1 = *dig1;
 462         Int_t n = 0;
 463         for (k = 0; k < ndig; k++) {
 464             digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
 465             if (rec->TestTrack(digit->Track(0)))
 466                 new(lhits1[n++]) AliMUONDigit(*digit);
 467         }
 468         GetMUONData()->ResetDigits();
 469         GetMUONData()->GetCathode(1);
 470         muonDigits =  GetMUONData()->Digits(ich);
 471         ndig=muonDigits->GetEntriesFast();
 472         printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
 473         TClonesArray &lhits2 = *dig2;
 474         n=0;
 475
 476         for (k=0; k<ndig; k++) {
 477             digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
 478             if (rec->TestTrack(digit->Track(0)))
 479             new(lhits2[n++]) AliMUONDigit(*digit);
 480         }
 481
 482         if (rec) {
 483             AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
 484             rec->FindRawClusters();
 485         }
 486         dig1->Delete();
 487         dig2->Delete();
 488     } // for ich
 489     delete dig1;
 490     delete dig2;
 491 }
 492 //______________________________________________________________________
 493 #ifdef never
 494 void AliMUON::Streamer(TBuffer &R__b)_
 495 {
 496    // Stream an object of class AliMUON.
 497       AliMUONChamber        *iChamber;
 498       AliMUONTriggerCircuit *iTriggerCircuit;
 499       AliSegmentation       *segmentation;
 500       AliMUONResponse       *response;
 501       TClonesArray          *digitsaddress;
 502       TClonesArray          *rawcladdress;
 503       Int_t i;
 504       if (R__b.IsReading()) {
 505           Version_t R__v = R__b.ReadVersion(); if (R__v) { }
 506           AliDetector::Streamer(R__b);
 507           R__b >> fNPadHits;
 508           R__b >> fPadHits; // diff
 509           R__b >> fNLocalTrigger;
 510           R__b >> fLocalTrigger;
 511           R__b >> fNGlobalTrigger;
 512           R__b >> fGlobalTrigger;
 513           R__b >> fDchambers;
 514           R__b >> fRawClusters;
 515           R__b.ReadArray(fNdch);
 516           R__b.ReadArray(fNrawch);
 517           R__b >> fAccCut;
 518           R__b >> fAccMin;
 519           R__b >> fAccMax;
 520           R__b >> fChambers;
 521           R__b >> fTriggerCircuits;
 522           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
 523               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
 524               iTriggerCircuit->Streamer(R__b);
 525           }
 526 // Stream chamber related information
 527           for (i =0; i<AliMUONConstants::NCh(); i++) {
 528               iChamber=(AliMUONChamber*) (*fChambers)[i];
 529               iChamber->Streamer(R__b);
 530               if (iChamber->Nsec()==1) {
 531                   segmentation=iChamber->SegmentationModel(1);
 532                   if (segmentation)
 533                       segmentation->Streamer(R__b);
 534               } else {
 535                   segmentation=iChamber->SegmentationModel(1);
 536                   if (segmentation)
 537                       segmentation->Streamer(R__b);
 538                   if (segmentation)
 539                       segmentation=iChamber->SegmentationModel(2);
 540                   segmentation->Streamer(R__b);
 541               }
 542               response=iChamber->ResponseModel();
 543               if (response)
 544                   response->Streamer(R__b);
 545               digitsaddress=(TClonesArray*) (*fDchambers)[i];
 546               digitsaddress->Streamer(R__b);
 547               if (i < AliMUONConstants::NTrackingCh()) {
 548                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
 549                   rawcladdress->Streamer(R__b);
 550               }
 551           }
 552
 553       } else {
 554           R__b.WriteVersion(AliMUON::IsA());
 555           AliDetector::Streamer(R__b);
 556           R__b << fNPadHits;
 557           R__b << fPadHits; // diff
 558           R__b << fNLocalTrigger;
 559           R__b << fLocalTrigger;
 560           R__b << fNGlobalTrigger;
 561           R__b << fGlobalTrigger;
 562           R__b << fDchambers;
 563           R__b << fRawClusters;
 564           R__b.WriteArray(fNdch, AliMUONConstants::NCh());
 565           R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
 566
 567           R__b << fAccCut;
 568           R__b << fAccMin;
 569           R__b << fAccMax;
 570
 571           R__b << fChambers;
 572           R__b << fTriggerCircuits;
 573           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
 574               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
 575               iTriggerCircuit->Streamer(R__b);
 576           }
 577           for (i =0; i<AliMUONConstants::NCh(); i++) {
 578               iChamber=(AliMUONChamber*) (*fChambers)[i];
 579               iChamber->Streamer(R__b);
 580               if (iChamber->Nsec()==1) {
 581                   segmentation=iChamber->SegmentationModel(1);
 582                   if (segmentation)
 583                       segmentation->Streamer(R__b);
 584               } else {
 585                   segmentation=iChamber->SegmentationModel(1);
 586                   if (segmentation)
 587                       segmentation->Streamer(R__b);
 588                   segmentation=iChamber->SegmentationModel(2);
 589                   if (segmentation)
 590                       segmentation->Streamer(R__b);
 591               }
 592               response=iChamber->ResponseModel();
 593               if (response)
 594                   response->Streamer(R__b);
 595               digitsaddress=(TClonesArray*) (*fDchambers)[i];
 596               digitsaddress->Streamer(R__b);
 597               if (i < AliMUONConstants::NTrackingCh()) {
 598                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
 599                   rawcladdress->Streamer(R__b);
 600               }
 601           }
 602       }
 603 }
 604 #endif
 605 //_______________________________________________________________________
 606 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters)
 607 {
 608 // to be removed
 609     // Initialise the pad iterator
 610     // Return the address of the first padhit for hit
 611     TClonesArray *theClusters = clusters;
 612     Int_t nclust = theClusters->GetEntriesFast();
 613     if (nclust && hit->PHlast() > 0) {
 614         AliMUON::fMaxIterPad=hit->PHlast();
 615         AliMUON::fCurIterPad=hit->PHfirst();
 616         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
 617     } else {
 618         return 0;
 619     }
 620 }
 621 //_______________________________________________________________________
 622 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
 623 {
 624   // To be removed
 625 // Get next pad (in iterator)
 626 //
 627     AliMUON::fCurIterPad++;
 628     if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
 629         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
 630     } else {
 631         return 0;
 632     }
 633 }
 634 //_______________________________________________________________________
 635
 636 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
 637 {
 638 //
 639 //  Return rawcluster (icluster) for chamber ichamber and cathode icathod
 640 //  Obsolete ??
 641     TClonesArray *muonRawCluster  = GetMUONData()->RawClusters(ichamber);
 642     ResetRawClusters();
 643     TTree *treeR = fLoader->TreeR();
 644     Int_t nent=(Int_t)treeR->GetEntries();
 645     treeR->GetEvent(nent-2+icathod-1);
 646     //treeR->GetEvent(icathod);
 647     //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
 648
 649     AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
 650     //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
 651
 652     return  mRaw;
 653 }
 654 //________________________________________________________________________
 655 void   AliMUON::SetMerger(AliMUONMerger* merger)
 656 {
 657 // Set pointer to merger
 658     fMerger = merger;
 659 }
 660 //________________________________________________________________________
 661 AliMUONMerger*  AliMUON::Merger()
 662 {
 663 // Return pointer to merger
 664     return fMerger;
 665 }
 666 //________________________________________________________________________
 667 AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
 668 {
 669 // copy operator
 670 // dummy version
 671     return *this;
 672 }
 673