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 $Log$
  17 Revision 1.35  2000/10/24 19:46:21  morsch
  18 BuildGeometry updated for slats in station 3-4.
  19
  20 Revision 1.34  2000/10/18 11:42:06  morsch
  21 - AliMUONRawCluster contains z-position.
  22 - Some clean-up of useless print statements during initialisations.
  23
  24 Revision 1.33  2000/10/09 14:01:57  morsch
  25 Unused variables removed.
  26
  27 Revision 1.32  2000/10/06 09:08:10  morsch
  28 Built geometry includes slat geometry for event display.
  29
  30 Revision 1.31  2000/10/02 21:28:08  fca
  31 Removal of useless dependecies via forward declarations
  32
  33 Revision 1.30  2000/10/02 16:58:29  egangler
  34 Cleaning of the code :
  35 -> coding conventions
  36 -> void Streamers
  37 -> some useless includes removed or replaced by "class" statement
  38
  39 Revision 1.29  2000/07/28 13:49:38  morsch
  40 SetAcceptance defines inner and outer chamber radii according to angular acceptance.
  41 Can be used for simple acceptance studies.
  42
  43 Revision 1.28  2000/07/22 16:43:15  morsch
  44 Same comment as before, but now done correctly I hope (sorry it's Saturday evening)
  45
  46 Revision 1.27  2000/07/22 16:36:50  morsch
  47 Change order of indices in creation (new) of xhit and yhit
  48
  49 Revision 1.26  2000/07/03 11:54:57  morsch
  50 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  51 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  52
  53 Revision 1.25  2000/06/29 12:34:09  morsch
  54 AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
  55 it usable with any other geometry class. The link to the object to which it belongs is
  56 established via an index. This assumes that there exists a global geometry manager
  57 from which the pointer to the parent object can be obtained (in our case gAlice).
  58
  59 Revision 1.24  2000/06/28 15:16:35  morsch
  60 (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
  61 to allow development of slat-muon chamber simulation and reconstruction code in the MUON
  62 framework. The changes should have no side effects (mostly dummy arguments).
  63 (2) Hit disintegration uses 3-dim hit coordinates to allow simulation
  64 of chambers with overlapping modules (MakePadHits, Disintegration).
  65
  66 Revision 1.23  2000/06/28 12:19:17  morsch
  67 More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
  68 cluster and hit reconstruction algorithms in AliMUONClusterFinderVS.
  69 AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
  70 It requires two cathode planes. Small modifications in the code will make it usable for
  71 one cathode plane and, hence, more general (for test beam data).
  72 AliMUONClusterFinder is now obsolete.
  73
  74 Revision 1.22  2000/06/28 08:06:10  morsch
  75 Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
  76 algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
  77 It also naturally takes care of the TMinuit instance.
  78
  79 Revision 1.21  2000/06/27 08:54:41  morsch
  80 Problems with on constant array sizes (in hitMap, nmuon, xhit, yhit) corrected.
  81
  82 Revision 1.20  2000/06/26 14:02:38  morsch
  83 Add class AliMUONConstants with MUON specific constants using static memeber data and access methods.
  84
  85 Revision 1.19  2000/06/22 13:40:51  morsch
  86 scope problem on HP, "i" declared once
  87 pow changed to TMath::Power (PH, AM)
  88
  89 Revision 1.18  2000/06/15 07:58:48  morsch
  90 Code from MUON-dev joined
  91
  92 Revision 1.14.4.17  2000/06/14 14:36:46  morsch
  93 - add TriggerCircuit (PC)
  94 - add GlobalTrigger and LocalTrigger and specific methods (PC)
  95
  96 Revision 1.14.4.16  2000/06/09 21:20:28  morsch
  97 Most coding rule violations corrected
  98
  99 Revision 1.14.4.15  2000/05/02 09:54:32  morsch
 100 RULE RN17 violations corrected
 101
 102 Revision 1.14.4.12  2000/04/26 12:25:02  morsch
 103 Code revised by P. Crochet:
 104 - Z position of TriggerChamber changed according to A.Tournaire Priv.Comm.
 105 - ToF included in the method MakePadHits
 106 - inner radius of flange between beam shielding and trigger corrected
 107 - Trigger global volume updated (according to the new geometry)
 108
 109 Revision 1.14.4.11  2000/04/19 19:42:08  morsch
 110 Some changes of variable names curing viols and methods concerning
 111 correlated clusters removed.
 112
 113 Revision 1.14.4.10  2000/03/22 16:44:07  gosset
 114 Memory leak suppressed in function Digitise:
 115 p_adr->Delete() instead of Clear (I.Chevrot and A.Baldisseri)
 116
 117 Revision 1.14.4.9  2000/03/20 18:15:25  morsch
 118 Positions of trigger chambers corrected (P.C.)
 119
 120 Revision 1.14.4.8  2000/02/21 15:38:01  morsch
 121 Call to AddHitList introduced to make this version compatible with head.
 122
 123 Revision 1.14.4.7  2000/02/20 07:45:53  morsch
 124 Bugs in Trigger part of BuildGeomemetry corrected (P.C)
 125
 126 Revision 1.14.4.6  2000/02/17 14:28:54  morsch
 127 Trigger included into initialization and digitization
 128
 129 Revision 1.14.4.5  2000/02/15 10:02:58  morsch
 130 Log messages of previous revisions added
 131
 132 Revision 1.14.4.2  2000/02/04 10:57:34  gosset
 133 Z position of the chambers:
 134 it was the Z position of the stations;
 135 it is now really the Z position of the chambers.
 136    !!!! WARNING: THE CALLS TO "AliMUONChamber::SetZPOS"
 137    !!!!                   AND "AliMUONChamber::ZPosition"
 138    !!!! HAVE TO BE CHANGED TO "AliMUONChamber::"SetZ"
 139    !!!!                   AND "AliMUONChamber::Z"
 140
 141 Revision 1.14.4.3  2000/02/04 16:19:04  gosset
 142 Correction for mis-spelling of NCH
 143
 144 Revision 1.14.4.4  2000/02/15 09:43:38  morsch
 145 Log message added
 146
 147 */
 148
 149
 150 ///////////////////////////////////////////////
 151 //  Manager and hits classes for set:MUON     //
 152 ////////////////////////////////////////////////
 153
 154 #include <TTUBE.h>
 155 #include <TBRIK.h>
 156 #include <TRotMatrix.h>
 157 #include <TGeometry.h>
 158 #include <TNode.h>
 159 #include <TTree.h>
 160 #include <TRandom.h>
 161 #include <TObject.h>
 162 #include <TVector.h>
 163 #include <TObjArray.h>
 164 #include <TMinuit.h>
 165 #include <TParticle.h>
 166 #include <TROOT.h>
 167 #include <TFile.h>
 168 #include <TNtuple.h>
 169 #include <TCanvas.h>
 170 #include <TPad.h>
 171 #include <TDirectory.h>
 172 #include <TObjectTable.h>
 173 #include <AliPDG.h>
 174 #include <TTUBE.h>
 175
 176 #include "AliMUON.h"
 177 #include "AliMUONHit.h"
 178 #include "AliMUONPadHit.h"
 179 #include "AliMUONDigit.h"
 180 #include "AliMUONTransientDigit.h"
 181 #include "AliMUONRawCluster.h"
 182 #include "AliMUONLocalTrigger.h"
 183 #include "AliMUONGlobalTrigger.h"
 184 #include "AliMUONTriggerCircuit.h"
 185 #include "AliHitMap.h"
 186 #include "AliMUONHitMapA1.h"
 187 #include "AliMUONChamberTrigger.h"
 188 #include "AliMUONConstants.h"
 189 #include "AliMUONClusterFinderVS.h"
 190 #include "AliMUONTriggerDecision.h"
 191 #include "AliRun.h"
 192 #include "AliMC.h"
 193 #include "AliMUONClusterInput.h"
 194 #include "iostream.h"
 195 #include "AliCallf77.h"
 196 #include "AliConst.h"
 197
 198 // Defaults parameters for Z positions of chambers
 199 // taken from values for "stations" in AliMUON::AliMUON
 200 //     const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
 201 // and from array "dstation" in AliMUONv1::CreateGeometry
 202 //          Float_t dstation[5]={20., 20., 20, 20., 20.};
 203 //     for tracking chambers,
 204 //          according to (Z1 = zch - dstation) and  (Z2 = zch + dstation)
 205 //          for the first and second chambers in the station, respectively,
 206 // and from "DTPLANES" in AliMUONv1::CreateGeometry
 207 //           const Float_t DTPLANES = 15.;
 208 //     for trigger chambers,
 209 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
 210 //          for the first and second chambers in the station, respectively
 211
 212 ClassImp(AliMUON)
 213 //___________________________________________
 214 AliMUON::AliMUON()
 215 {
 216    fIshunt       = 0;
 217    fHits         = 0;
 218    fPadHits      = 0;
 219    fNPadHits     = 0;
 220    fDchambers    = 0;
 221    fTriggerCircuits = 0;     // cp new design of AliMUONTriggerDecision
 222    fNdch         = 0;
 223    fRawClusters  = 0;
 224    fNrawch       = 0;
 225    fGlobalTrigger   = 0;
 226    fNLocalTrigger   = 0;
 227    fLocalTrigger    = 0;
 228    fNLocalTrigger   = 0;
 229    fAccMin          = 0.;
 230    fAccMax          = 0.;
 231    fAccCut          = kFALSE;
 232 }
 233
 234 //___________________________________________
 235 AliMUON::AliMUON(const char *name, const char *title)
 236        : AliDetector(name,title)
 237 {
 238 //Begin_Html
 239 /*
 240 <img src="gif/alimuon.gif">
 241 */
 242 //End_Html
 243
 244    fHits     = new TClonesArray("AliMUONHit",1000);
 245    gAlice->AddHitList(fHits);
 246    fPadHits = new TClonesArray("AliMUONPadHit",10000);
 247    fNPadHits  =  0;
 248    fIshunt     =  0;
 249
 250    fNdch      = new Int_t[AliMUONConstants::NCh()];
 251
 252    fDchambers = new TObjArray(AliMUONConstants::NCh());
 253
 254    Int_t i;
 255
 256    for (i=0; i<AliMUONConstants::NCh() ;i++) {
 257        (*fDchambers)[i] = new TClonesArray("AliMUONDigit",10000);
 258        fNdch[i]=0;
 259    }
 260
 261    fNrawch      = new Int_t[AliMUONConstants::NTrackingCh()];
 262
 263    fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
 264
 265    for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
 266        (*fRawClusters)[i] = new TClonesArray("AliMUONRawCluster",10000);
 267        fNrawch[i]=0;
 268    }
 269
 270    fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
 271    fNGlobalTrigger = 0;
 272    fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
 273    fNLocalTrigger = 0;
 274
 275    SetMarkerColor(kRed);
 276 //
 277 //
 278 //
 279 //
 280
 281     Int_t ch;
 282
 283     fChambers = new TObjArray(AliMUONConstants::NCh());
 284
 285     // Loop over stations
 286     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
 287       // Loop over 2 chambers in the station
 288         for (Int_t stCH = 0; stCH < 2; stCH++) {
 289 //
 290 //
 291 //    Default Parameters for Muon Tracking Stations
 292
 293
 294             ch = 2 * st + stCH;
 295 //
 296             if (ch < AliMUONConstants::NTrackingCh()) {
 297                 (*fChambers)[ch] = new AliMUONChamber(ch);
 298             } else {
 299                 (*fChambers)[ch] = new AliMUONChamberTrigger(ch);
 300             }
 301
 302             AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
 303
 304             chamber->SetGid(0);
 305             // Default values for Z of chambers
 306             chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
 307 //
 308             chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
 309 //          Set chamber inner and outer radius to default
 310             chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
 311             chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
 312 //
 313         } // Chamber stCH (0, 1) in
 314     }     // Station st (0...)
 315     fMaxStepGas=0.01;
 316     fMaxStepAlu=0.1;
 317     fMaxDestepGas=-1;
 318     fMaxDestepAlu=-1;
 319 //
 320    fMaxIterPad   = 0;
 321    fCurIterPad   = 0;
 322 //
 323    fAccMin          = 0.;
 324    fAccMax          = 0.;
 325    fAccCut          = kFALSE;
 326
 327    // cp new design of AliMUONTriggerDecision
 328    fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
 329    for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
 330      (*fTriggerCircuits)[circ] = new AliMUONTriggerCircuit();
 331    }
 332    // cp new design of AliMUONTriggerDecision
 333
 334 }
 335
 336 //___________________________________________
 337 AliMUON::AliMUON(const AliMUON& rMUON)
 338 {
 339 // Dummy copy constructor
 340     ;
 341
 342 }
 343
 344 AliMUON::~AliMUON()
 345 {
 346     printf("Calling AliMUON destructor !!!\n");
 347
 348     Int_t i;
 349     fIshunt  = 0;
 350     delete fHits;
 351     delete fPadHits;
 352
 353     delete fGlobalTrigger;
 354     fNGlobalTrigger = 0;
 355
 356     delete fLocalTrigger;
 357     fNLocalTrigger = 0;
 358
 359     for (i=0;i<AliMUONConstants::NCh();i++) {
 360         delete (*fDchambers)[i];
 361         fNdch[i]=0;
 362     }
 363     delete fDchambers;
 364
 365     for (i=0;i<AliMUONConstants::NTrackingCh();i++) {
 366         delete (*fRawClusters)[i];
 367         fNrawch[i]=0;
 368     }
 369     delete fRawClusters;
 370
 371     for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
 372         delete (*fTriggerCircuits)[circ];
 373     }
 374     delete fTriggerCircuits;
 375 }
 376
 377 //___________________________________________
 378 void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
 379 {
 380   TClonesArray &lhits = *fHits;
 381   new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
 382 }
 383 //___________________________________________
 384 void AliMUON::AddPadHit(Int_t *clhits)
 385 {
 386    TClonesArray &lclusters = *fPadHits;
 387    new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
 388 }
 389 //_____________________________________________________________________________
 390 void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
 391 {
 392     //
 393     // Add a MUON digit to the list
 394     //
 395
 396     TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
 397     new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
 398 }
 399
 400 //_____________________________________________________________________________
 401 void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
 402 {
 403     //
 404     // Add a MUON digit to the list
 405     //
 406
 407     TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
 408     new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
 409 }
 410
 411 //___________________________________________
 412 void AliMUON::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
 413                                Int_t *singleUndef,
 414                                Int_t *pairUnlike, Int_t *pairLike)
 415 {
 416 // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
 417   TClonesArray &globalTrigger = *fGlobalTrigger;
 418   new(globalTrigger[fNGlobalTrigger++])
 419     AliMUONGlobalTrigger(singlePlus, singleMinus,  singleUndef, pairUnlike,
 420                          pairLike);
 421 }
 422 //___________________________________________
 423 void AliMUON::AddLocalTrigger(Int_t *localtr)
 424 {
 425 // add a MUON Local Trigger to the list
 426   TClonesArray &localTrigger = *fLocalTrigger;
 427   new(localTrigger[fNLocalTrigger++]) AliMUONLocalTrigger(localtr);
 428 }
 429
 430 //___________________________________________
 431 void AliMUON::BuildGeometry()
 432 {
 433     TNode *node, *nodeF, *top, *nodeS;
 434     const int kColorMUON  = kBlue;
 435     const int kColorMUON2 = kYellow;
 436     const int kColorMUON3 = kBlue;
 437     //
 438     top=gAlice->GetGeometry()->GetNode("alice");
 439 // MUON
 440 //
 441 //  z-Positions of Chambers
 442     const Float_t kCz[7]={511., 686., 971., 1245., 1445., 1600, 1700.};
 443 //  inner diameter (Xlenght for trigger chamber -> active area)
 444     const Float_t kDmin[7]={ 35.,  47.,  67.,   86.,  100., 544., 544.};
 445 //  outer diameter (Ylenght for trigger chamber -> active area)
 446     const Float_t kDmax[7]={183., 245., 346.,  520.,  520., 612., 612.};
 447
 448     TRotMatrix* rot000 = new TRotMatrix("Rot000"," ", 90,  0, 90, 90, 0, 0);
 449     TRotMatrix* rot090 = new TRotMatrix("Rot090"," ", 90, 90, 90,180, 0, 0);
 450     TRotMatrix* rot180 = new TRotMatrix("Rot180"," ", 90,180, 90,270, 0, 0);
 451     TRotMatrix* rot270 = new TRotMatrix("Rot270"," ", 90,270, 90,  0, 0, 0);
 452
 453     Float_t rmin, rmax, dx, dy, dz, dr, xpos, ypos, zpos;
 454     Float_t dzc1=4.;           // tracking chambers
 455     Float_t dzc2=15.;          // trigger chambers
 456     Float_t hole=102.;          // x-y hole around beam pipe for trig. chambers
 457     Float_t zscale;            // scaling parameter trigger chambers
 458     Float_t halfx, halfy;
 459     char nameChamber[9], nameSense[9], nameFrame[9], nameNode[9];
 460     char nameSense1[9], nameSense2[9];
 461     for (Int_t i=0; i<7; i++) {
 462         for (Int_t j=0; j<2; j++) {
 463             Int_t id=2*i+j+1;
 464             if (i<5) {               // tracking chambers
 465                 if (j==0) {
 466                     zpos=kCz[i]-dzc1;
 467                 } else {
 468                     zpos=kCz[i]+dzc1;
 469                 }
 470             } else {
 471                 if (j==0) {
 472                     zpos=kCz[i];
 473                 } else {
 474                     zpos=kCz[i]+dzc2;
 475                 }
 476             }
 477             sprintf(nameChamber,"C_MUON%d",id);
 478             sprintf(nameSense,"S_MUON%d",id);
 479             sprintf(nameSense1,"S1_MUON%d",id);
 480             sprintf(nameSense2,"S2_MUON%d",id);
 481             sprintf(nameFrame,"F_MUON%d",id);
 482             if (i<2) {                        // tracking chambers
 483                 rmin = kDmin[i]/2.-3;
 484                 rmax = kDmax[i]/2.+3;
 485                 new TTUBE(nameChamber,"Mother","void",rmin,rmax,0.25,1.);
 486                 rmin = kDmin[i]/2.;
 487                 rmax = kDmax[i]/2.;
 488                 new TTUBE(nameSense,"Sens. region","void",rmin,rmax,0.25, 1.);
 489                 dx=(rmax-rmin)/2;
 490                 dy=3.;
 491                 dz=0.25;
 492                 TBRIK* frMUON = new TBRIK(nameFrame,"Frame","void",dx,dy,dz);
 493                 top->cd();
 494                 sprintf(nameNode,"MUON%d",100+id);
 495                 node = new TNode(nameNode,"ChamberNode",nameChamber,0,0,zpos,"");
 496                 node->SetLineColor(kColorMUON);
 497                 fNodes->Add(node);
 498                 node->cd();
 499                 sprintf(nameNode,"MUON%d",200+id);
 500                 node = new TNode(nameNode,"Sens. Region Node",nameSense,0,0,0,"");
 501                 node->SetLineColor(kColorMUON);
 502                 node->cd();
 503                 dr=dx+rmin;
 504                 sprintf(nameNode,"MUON%d",300+id);
 505                 nodeF = new TNode(nameNode,"Frame0",frMUON,dr, 0, 0,rot000,"");
 506                 nodeF->SetLineColor(kColorMUON);
 507                 node->cd();
 508                 sprintf(nameNode,"MUON%d",400+id);
 509                 nodeF = new TNode(nameNode,"Frame1",frMUON,0 ,dr,0,rot090,"");
 510                 nodeF->SetLineColor(kColorMUON);
 511                 node->cd();
 512                 sprintf(nameNode,"MUON%d",500+id);
 513                 nodeF = new TNode(nameNode,"Frame2",frMUON,-dr,0,0,rot180,"");
 514                 nodeF->SetLineColor(kColorMUON);
 515                 node  ->cd();
 516                 sprintf(nameNode,"MUON%d",600+id);
 517                 nodeF = new TNode(nameNode,"Frame3",frMUON,0,-dr,0,rot270,"");
 518                 nodeF->SetLineColor(kColorMUON);
 519             } else if (i >= 2 || i <= 4) {
 520                 Int_t nslats;
 521                 Int_t npcb[7]={0, 0, 0, 0, 0, 0, 0};
 522                 if (i==2) {
 523                     nslats = 4;
 524                     npcb[0] = 3; npcb[1] = 4;  npcb[2] = 3; npcb[3] = 2;
 525                 } else if (i==3) {
 526                     nslats = 6;
 527                     npcb[0] = 4; npcb[1] = 5;  npcb[2] = 5; npcb[3] = 4;
 528                     npcb[4] = 3; npcb[5] = 2;
 529                 } else {
 530                     nslats = 7;
 531                     npcb[0] = 7; npcb[1] = 7;  npcb[2] = 6; npcb[3] = 6;
 532                     npcb[4] = 5; npcb[5] = 4;  npcb[6] = 2;
 533                 }
 534
 535                 char nameSlat[9];
 536
 537                 Float_t xpos=2.;
 538                 Float_t ypos1=-0.75+20.;
 539                 Float_t ypos2= 0.75-20.;
 540                 if (i!=2) {
 541                     ypos1=ypos2=0.;
 542                 }
 543
 544                 new TBRIK(nameChamber,"Mother","void",340,340,5.);
 545                 top->cd();
 546                 sprintf(nameNode,"MUON%d",100+id);
 547                 node = new TNode(nameNode,"Chambernode",nameChamber,0,0,zpos,"");
 548                 node->SetLineColor(kBlack);
 549                 fNodes->Add(node);
 550                 TNode* nodeSlat;
 551                 Int_t color;
 552
 553                 for (Int_t j=0; j<nslats; j++)
 554                 {
 555                     sprintf(nameSlat,"SLAT%d",100*id+j);
 556                     new TBRIK(nameSlat,"Slat Module","void",20.*npcb[j],20.,0.25);
 557                     node->cd();
 558                     xpos=20.*npcb[j]+2;
 559
 560                     if (j==0 && i!=2) xpos+=37.5;
 561                     if (j==0 && i==2) xpos+=40;
 562
 563                     color =  TMath::Even(j) ? kColorMUON2 : kColorMUON3;
 564
 565                     sprintf(nameNode,"SLAT%d",100*id+j);
 566                     nodeSlat =
 567                         new TNode(nameNode,"Slat Module",nameSlat,xpos,ypos1,0,"");
 568                     nodeSlat->SetLineColor(color);
 569
 570                     node->cd();
 571                     sprintf(nameNode,"SLAT%d",100*id+j+7);
 572                     nodeSlat =
 573                         new TNode(nameNode,"Slat Module",nameSlat,-xpos,ypos1,0,"");
 574                     nodeSlat->SetLineColor(color);
 575
 576                     if (i==2 || (i!=2 && j!=0)) {
 577
 578                         if (i==2) {
 579                             color =  TMath::Even(j) ? kColorMUON3 : kColorMUON2;
 580                         } else {
 581                             color =  TMath::Even(j) ? kColorMUON2 : kColorMUON3;
 582                         }
 583
 584
 585                         sprintf(nameNode,"SLAT%d",100*id+j+14);
 586                         nodeSlat =
 587                             new TNode(nameNode,"Slat Module",nameSlat,xpos,ypos2,0,"");
 588                         nodeSlat->SetLineColor(color);
 589
 590                         node->cd();
 591                         sprintf(nameNode,"SLAT%d",100*id+j+21);
 592                         nodeSlat =
 593                             new TNode(nameNode,"Slat Module",nameSlat,-xpos,ypos2,0,"");
 594                         nodeSlat->SetLineColor(color);
 595                     }
 596
 597                     ypos1+=38.5;
 598                     ypos2-=38.5;
 599                 }
 600
 601             } else {
 602                 zscale=zpos/kCz[5];
 603                 Float_t xsize=kDmin[i]*zscale;
 604                 Float_t ysize=kDmax[i]*zscale;
 605                 Float_t holeScaled=hole*zscale;
 606
 607                 halfx=xsize/2.+3.;
 608                 halfy=ysize/2.+3.;
 609                 new TBRIK(nameChamber,"Mother","void",halfx,halfy,0.25);
 610                 top->cd();
 611                 sprintf(nameNode,"MUON%d",100+id);
 612                 node = new TNode(nameNode,"Chambernode",nameChamber,0,0,zpos,"");
 613                 node->SetLineColor(kColorMUON2);
 614                 fNodes->Add(node);
 615
 616 // up/down of beam pipe
 617                 halfx=xsize/2.;
 618                 halfy=(ysize/2.-holeScaled/2.)/2.;
 619                 new TBRIK(nameSense,"Sens. region","void",halfx,halfy,0.25);
 620
 621                 node->cd();
 622                 ypos=holeScaled/2.+((ysize/2.-holeScaled/2.)/2.);
 623                 sprintf(nameNode,"MUON%d",200+id);
 624                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense,0,ypos,0,"");
 625                 nodeS->SetLineColor(kColorMUON2);
 626
 627                 node->cd();
 628                 ypos=-1.*ypos;
 629                 sprintf(nameNode,"MUON%d",300+id);
 630                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense,0,ypos,0,"");
 631                 nodeS->SetLineColor(kColorMUON2);
 632
 633 // left/right of beam pipe
 634                 halfx=(xsize/2.-holeScaled/2.)/2.;
 635                 halfy=holeScaled/2.;
 636                 new TBRIK(nameSense1,"Sens. region","void",halfx,halfy,0.25);
 637
 638                 node->cd();
 639                 xpos=holeScaled/2.+((xsize/2.-holeScaled/2.)/2.);
 640                 sprintf(nameNode,"MUON%d",400+id);
 641                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense1,xpos,0,0,"");
 642                 nodeS->SetLineColor(kColorMUON2);
 643
 644                 node->cd();
 645                 xpos=-1.*xpos;
 646                 sprintf(nameNode,"MUON%d",500+id);
 647                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense1,xpos,0,0,"");
 648                 nodeS->SetLineColor(kColorMUON2);
 649
 650 // missing corners
 651                 halfx=17.*zscale/2.;
 652                 halfy=halfx;
 653                 new TBRIK(nameSense2,"Sens. region","void",halfx,halfy,0.25);
 654
 655                 node->cd();
 656                 xpos=holeScaled/2.-halfx;
 657                 ypos=xpos;
 658                 sprintf(nameNode,"MUON%d",600+id);
 659                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense2,xpos,ypos,0,"");
 660                 nodeS->SetLineColor(kColorMUON2);
 661
 662                 node->cd();
 663                 ypos=-1.*xpos;
 664                 sprintf(nameNode,"MUON%d",700+id);
 665                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense2,xpos,ypos,0,"");
 666                 nodeS->SetLineColor(kColorMUON2);
 667
 668                 node->cd();
 669                 xpos=-1.*xpos;
 670                 sprintf(nameNode,"MUON%d",800+id);
 671                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense2,xpos,ypos,0,"");
 672                 nodeS->SetLineColor(kColorMUON2);
 673
 674                 node->cd();
 675                 ypos=-1.*xpos;
 676                 sprintf(nameNode,"MUON%d",900+id);
 677                 nodeS = new TNode(nameNode,"Sens. Region Node",nameSense2,xpos,ypos,0,"");
 678                 nodeS->SetLineColor(kColorMUON2);
 679             }
 680         }
 681     }
 682 }
 683
 684
 685 //___________________________________________
 686 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
 687 {
 688    return 9999;
 689 }
 690
 691 //___________________________________________
 692 void AliMUON::MakeBranch(Option_t* option)
 693 {
 694     // Create Tree branches for the MUON.
 695     const Int_t kBufferSize = 4000;
 696     char branchname[30];
 697     sprintf(branchname,"%sCluster",GetName());
 698
 699     AliDetector::MakeBranch(option);
 700
 701     if (fPadHits   && gAlice->TreeH()) {
 702         gAlice->TreeH()->Branch(branchname,&fPadHits, kBufferSize);
 703         printf("Making Branch %s for clusters\n",branchname);
 704     }
 705
 706 // one branch for digits per chamber
 707     Int_t i;
 708
 709     for (i=0; i<AliMUONConstants::NCh() ;i++) {
 710         sprintf(branchname,"%sDigits%d",GetName(),i+1);
 711
 712         if (fDchambers   && gAlice->TreeD()) {
 713             gAlice->TreeD()->Branch(branchname,&((*fDchambers)[i]), kBufferSize);
 714             printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
 715         }
 716     }
 717
 718     printf("Make Branch - TreeR address %p\n",gAlice->TreeR());
 719
 720 // one branch for raw clusters per chamber
 721     for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
 722         sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 723
 724         if (fRawClusters   && gAlice->TreeR()) {
 725             gAlice->TreeR()->Branch(branchname,&((*fRawClusters)[i]), kBufferSize);
 726             printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
 727         }
 728     }
 729
 730 // one branch for global trigger
 731     sprintf(branchname,"%sGlobalTrigger",GetName());
 732     if (fGlobalTrigger && gAlice->TreeR()) {
 733         gAlice->TreeR()->Branch(branchname,&fGlobalTrigger,kBufferSize);
 734         printf("Making Branch %s for Global Trigger\n",branchname);
 735     }
 736 // one branch for local trigger
 737     sprintf(branchname,"%sLocalTrigger",GetName());
 738     if (fLocalTrigger && gAlice->TreeR()) {
 739         gAlice->TreeR()->Branch(branchname,&fLocalTrigger,kBufferSize);
 740         printf("Making Branch %s for Local Trigger\n",branchname);
 741     }
 742
 743 }
 744
 745 //___________________________________________
 746 void AliMUON::SetTreeAddress()
 747 {
 748   // Set branch address for the Hits and Digits Tree.
 749   char branchname[30];
 750   AliDetector::SetTreeAddress();
 751
 752   TBranch *branch;
 753   TTree *treeH = gAlice->TreeH();
 754   TTree *treeD = gAlice->TreeD();
 755   TTree *treeR = gAlice->TreeR();
 756
 757   if (treeH) {
 758     if (fPadHits) {
 759       branch = treeH->GetBranch("MUONCluster");
 760       if (branch) branch->SetAddress(&fPadHits);
 761     }
 762   }
 763
 764   if (treeD) {
 765       for (int i=0; i<AliMUONConstants::NCh(); i++) {
 766           sprintf(branchname,"%sDigits%d",GetName(),i+1);
 767           if (fDchambers) {
 768               branch = treeD->GetBranch(branchname);
 769               if (branch) branch->SetAddress(&((*fDchambers)[i]));
 770           }
 771       }
 772   }
 773
 774   // printf("SetTreeAddress --- treeR address  %p \n",treeR);
 775
 776   if (treeR) {
 777       for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
 778           sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
 779           if (fRawClusters) {
 780               branch = treeR->GetBranch(branchname);
 781               if (branch) branch->SetAddress(&((*fRawClusters)[i]));
 782           }
 783       }
 784
 785       if (fLocalTrigger) {
 786         branch = treeR->GetBranch("MUONLocalTrigger");
 787         if (branch) branch->SetAddress(&fLocalTrigger);
 788       }
 789       if (fGlobalTrigger) {
 790         branch = treeR->GetBranch("MUONGlobalTrigger");
 791         if (branch) branch->SetAddress(&fGlobalTrigger);
 792       }
 793   }
 794 }
 795 //___________________________________________
 796 void AliMUON::ResetHits()
 797 {
 798   // Reset number of clusters and the cluster array for this detector
 799   AliDetector::ResetHits();
 800   fNPadHits = 0;
 801   if (fPadHits) fPadHits->Clear();
 802 }
 803
 804 //____________________________________________
 805 void AliMUON::ResetDigits()
 806 {
 807     //
 808     // Reset number of digits and the digits array for this detector
 809     //
 810     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
 811         if ((*fDchambers)[i])    ((TClonesArray*)(*fDchambers)[i])->Clear();
 812         if (fNdch)  fNdch[i]=0;
 813     }
 814 }
 815 //____________________________________________
 816 void AliMUON::ResetRawClusters()
 817 {
 818     //
 819     // Reset number of raw clusters and the raw clust array for this detector
 820     //
 821     for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
 822         if ((*fRawClusters)[i])    ((TClonesArray*)(*fRawClusters)[i])->Clear();
 823         if (fNrawch)  fNrawch[i]=0;
 824     }
 825 }
 826
 827 //____________________________________________
 828 void AliMUON::ResetTrigger()
 829 {
 830   //  Reset Local and Global Trigger
 831   fNGlobalTrigger = 0;
 832   if (fGlobalTrigger) fGlobalTrigger->Clear();
 833   fNLocalTrigger = 0;
 834   if (fLocalTrigger) fLocalTrigger->Clear();
 835 }
 836
 837 //____________________________________________
 838 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
 839 {
 840     Int_t i=2*(id-1);
 841     ((AliMUONChamber*) (*fChambers)[i])  ->SetPadSize(isec,p1,p2);
 842     ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
 843 }
 844
 845 //___________________________________________
 846 void AliMUON::SetChambersZ(const Float_t *Z)
 847 {
 848   // Set Z values for all chambers (tracking and trigger)
 849   // from the array pointed to by "Z"
 850     for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
 851         ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
 852     return;
 853 }
 854
 855 //___________________________________________
 856 void AliMUON::SetChambersZToDefault()
 857 {
 858   // Set Z values for all chambers (tracking and trigger)
 859   // to default values
 860   SetChambersZ(AliMUONConstants::DefaultChamberZ());
 861   return;
 862 }
 863
 864 //___________________________________________
 865 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
 866 {
 867     Int_t i=2*(id-1);
 868     ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
 869     ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
 870 }
 871
 872 //___________________________________________
 873 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
 874 {
 875     Int_t i=2*(id-1);
 876     ((AliMUONChamber*) (*fChambers)[i])->SetChargeSpread(p1,p2);
 877     ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSpread(p1,p2);
 878 }
 879
 880 //___________________________________________
 881 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
 882 {
 883     Int_t i=2*(id-1);
 884     ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
 885     ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
 886 }
 887
 888 //___________________________________________
 889 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
 890 {
 891     Int_t i=2*(id-1);
 892     ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
 893     ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
 894 }
 895
 896 //___________________________________________
 897 void AliMUON::SetMaxStepGas(Float_t p1)
 898 {
 899      fMaxStepGas=p1;
 900 }
 901
 902 //___________________________________________
 903 void AliMUON::SetMaxStepAlu(Float_t p1)
 904 {
 905     fMaxStepAlu=p1;
 906 }
 907
 908 //___________________________________________
 909 void AliMUON::SetMaxDestepGas(Float_t p1)
 910 {
 911     fMaxDestepGas=p1;
 912 }
 913
 914 //___________________________________________
 915 void AliMUON::SetMaxDestepAlu(Float_t p1)
 916 {
 917     fMaxDestepAlu=p1;
 918 }
 919 //___________________________________________
 920 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
 921 {
 922    fAccCut=acc;
 923    fAccMin=angmin*TMath::Pi()/180;
 924    fAccMax=angmax*TMath::Pi()/180;
 925    Int_t ch;
 926    if (acc) {
 927        for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
 928            // Loop over 2 chambers in the station
 929            for (Int_t stCH = 0; stCH < 2; stCH++) {
 930                ch = 2 * st + stCH;
 931 //         Set chamber inner and outer radius according to acceptance cuts
 932                Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
 933                Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
 934            } // chamber loop
 935        } // station loop
 936    }
 937 }
 938 //___________________________________________
 939 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
 940 {
 941     ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
 942
 943 }
 944 //___________________________________________
 945 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
 946 {
 947     ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
 948 }
 949
 950 void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
 951 {
 952     ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
 953 }
 954
 955 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
 956 {
 957     ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
 958 }
 959
 960
 961 //___________________________________________
 962
 963
 964
 965 void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
 966                           Float_t eloss, Float_t tof,  Int_t idvol)
 967 {
 968 //
 969 //  Calls the charge disintegration method of the current chamber and adds
 970 //  the simulated cluster to the root treee
 971 //
 972     Int_t clhits[7];
 973     Float_t newclust[6][500];
 974     Int_t nnew;
 975
 976
 977 //
 978 //  Integrated pulse height on chamber
 979
 980
 981     clhits[0]=fNhits+1;
 982 //
 983 //
 984 //    if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
 985
 986
 987     ((AliMUONChamber*) (*fChambers)[idvol])
 988         ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
 989     Int_t ic=0;
 990 //    if (idvol == 6) printf("\n nnew  %d \n", nnew);
 991 //
 992 //  Add new clusters
 993     for (Int_t i=0; i<nnew; i++) {
 994         if (Int_t(newclust[3][i]) > 0) {
 995             ic++;
 996 // Cathode plane
 997             clhits[1] = Int_t(newclust[5][i]);
 998 //  Cluster Charge
 999             clhits[2] = Int_t(newclust[0][i]);
1000 //  Pad: ix
1001             clhits[3] = Int_t(newclust[1][i]);
1002 //  Pad: iy
1003             clhits[4] = Int_t(newclust[2][i]);
1004 //  Pad: charge
1005             clhits[5] = Int_t(newclust[3][i]);
1006 //  Pad: chamber sector
1007             clhits[6] = Int_t(newclust[4][i]);
1008
1009             AddPadHit(clhits);
1010         }
1011     }
1012 }
1013
1014 //----------------------------------------------------------------------
1015
1016 void AliMUON::Digitise(Int_t nev,Int_t bgrEvent,Option_t *option,Option_t *opt,Text_t *filename)
1017 {
1018     // keep galice.root for signal and name differently the file for
1019     // background when add! otherwise the track info for signal will be lost !
1020
1021     static Bool_t first=kTRUE;
1022     static TFile *file;
1023     char *addBackground = strstr(option,"Add");
1024
1025
1026     AliMUONChamber*   iChamber;
1027     AliSegmentation*  segmentation;
1028
1029
1030     Int_t trk[50];
1031     Int_t chtrk[50];
1032     TObjArray *list=new TObjArray;
1033     static TClonesArray *pAddress=0;
1034     if(!pAddress) pAddress=new TClonesArray("TVector",1000);
1035     Int_t digits[5];
1036
1037     AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
1038     AliHitMap** hitMap= new AliHitMap* [AliMUONConstants::NCh()];
1039     for (Int_t i=0; i<AliMUONConstants::NCh(); i++) {hitMap[i]=0;}
1040     if (addBackground ) {
1041         if(first) {
1042             fFileName=filename;
1043             cout<<"filename"<<fFileName<<endl;
1044             file=new TFile(fFileName);
1045             cout<<"I have opened "<<fFileName<<" file "<<endl;
1046             fHits2     = new TClonesArray("AliMUONHit",1000  );
1047             fPadHits2 = new TClonesArray("AliMUONPadHit",10000);
1048         }
1049         first=kFALSE;
1050         file->cd();
1051         //file->ls();
1052         // Get Hits Tree header from file
1053         if(fHits2) fHits2->Clear();
1054         if(fPadHits2) fPadHits2->Clear();
1055         if(fTrH1) delete fTrH1;
1056         fTrH1=0;
1057
1058         char treeName[20];
1059         sprintf(treeName,"TreeH%d",bgrEvent);
1060         fTrH1 = (TTree*)gDirectory->Get(treeName);
1061         //printf("fTrH1 %p of treename %s for event %d \n",fTrH1,treeName,bgrEvent);
1062
1063         if (!fTrH1) {
1064             printf("ERROR: cannot find Hits Tree for event:%d\n",bgrEvent);
1065         }
1066         // Set branch addresses
1067         TBranch *branch;
1068         char branchname[20];
1069         sprintf(branchname,"%s",GetName());
1070         if (fTrH1 && fHits2) {
1071             branch = fTrH1->GetBranch(branchname);
1072             if (branch) branch->SetAddress(&fHits2);
1073         }
1074         if (fTrH1 && fPadHits2) {
1075             branch = fTrH1->GetBranch("MUONCluster");
1076             if (branch) branch->SetAddress(&fPadHits2);
1077         }
1078 // test
1079         //Int_t ntracks1 =(Int_t)fTrH1->GetEntries();
1080         //printf("background - ntracks1 - %d\n",ntracks1);
1081     }
1082     //
1083     // loop over cathodes
1084     //
1085     AliHitMap* hm;
1086     Int_t countadr=0;
1087     for (int icat=0; icat<2; icat++) {
1088         Int_t counter=0;
1089         Int_t * nmuon = new Int_t [AliMUONConstants::NCh()];
1090         for (Int_t i =0; i<AliMUONConstants::NCh(); i++) {
1091             iChamber=(AliMUONChamber*) (*fChambers)[i];
1092             if (iChamber->Nsec()==1 && icat==1) {
1093                 continue;
1094             } else {
1095                 segmentation=iChamber->SegmentationModel(icat+1);
1096             }
1097             hitMap[i] = new AliMUONHitMapA1(segmentation, list);
1098             nmuon[i]=0;
1099         }
1100         //printf("Start loop over tracks \n");
1101 //
1102 //   Loop over tracks
1103 //
1104
1105         TTree *treeH = gAlice->TreeH();
1106         Int_t ntracks =(Int_t) treeH->GetEntries();
1107         Int_t jj;
1108
1109         Float_t ** xhit = new Float_t * [AliMUONConstants::NCh()];
1110         for (jj=0; jj<AliMUONConstants::NCh(); jj++) xhit[jj] = new Float_t[2];
1111         Float_t ** yhit = new Float_t * [AliMUONConstants::NCh()];
1112         for (jj=0; jj<AliMUONConstants::NCh(); jj++) yhit[jj] = new Float_t[2];
1113
1114         for (Int_t track=0; track<ntracks; track++) {
1115             gAlice->ResetHits();
1116             treeH->GetEvent(track);
1117 //
1118 //   Loop over hits
1119             for(AliMUONHit* mHit=(AliMUONHit*)pMUON->FirstHit(-1);
1120                 mHit;
1121                 mHit=(AliMUONHit*)pMUON->NextHit())
1122             {
1123                 Int_t   nch   = mHit->fChamber-1;  // chamber number
1124                 if (nch > AliMUONConstants::NCh()-1) continue;
1125 //              if (nch > 9) continue;
1126                 iChamber = &(pMUON->Chamber(nch));
1127                 // new 17.07.99
1128                 if (addBackground) {
1129
1130                     if (mHit->fParticle == kMuonPlus
1131                         || mHit->fParticle == kMuonMinus) {
1132                         xhit[nch][nmuon[nch]]=mHit->X();
1133                         yhit[nch][nmuon[nch]]=mHit->Y();
1134                         nmuon[nch]++;
1135                         if (nmuon[nch] >2) printf("nmuon %d\n",nmuon[nch]);
1136                     }
1137                 }
1138
1139
1140
1141
1142 //
1143 // Loop over pad hits
1144                 for (AliMUONPadHit* mPad=
1145                          (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHits);
1146                      mPad;
1147                      mPad=(AliMUONPadHit*)pMUON->NextPad(fPadHits))
1148                 {
1149                     Int_t cathode  = mPad->fCathode;    // cathode number
1150                     Int_t ipx      = mPad->fPadX;       // pad number on X
1151                     Int_t ipy      = mPad->fPadY;       // pad number on Y
1152                     Int_t iqpad    = Int_t(mPad->fQpad);// charge per pad
1153 //                  printf("\n Pad: %d %d %d %d", ipx, ipy, cathode,nch);
1154 //
1155 //
1156
1157                     if (cathode != (icat+1)) continue;
1158                     // fill the info array
1159 //                  Float_t thex, they, thez;
1160                     segmentation=iChamber->SegmentationModel(cathode);
1161 //                  segmentation->GetPadC(ipx,ipy,thex,they,thez);
1162 //                  Float_t rpad=TMath::Sqrt(thex*thex+they*they);
1163 //                  if (rpad < rmin || iqpad ==0 || rpad > rmax) continue;
1164
1165                     new((*pAddress)[countadr++]) TVector(2);
1166                     TVector &trinfo=*((TVector*) (*pAddress)[countadr-1]);
1167                     trinfo(0)=(Float_t)track;
1168                     trinfo(1)=(Float_t)iqpad;
1169
1170                     digits[0]=ipx;
1171                     digits[1]=ipy;
1172                     digits[2]=iqpad;
1173                     digits[3]=iqpad;
1174                     if (mHit->fParticle == kMuonPlus ||
1175                         mHit->fParticle == kMuonMinus) {
1176                         digits[4]=mPad->fHitNumber;
1177                     } else digits[4]=-1;
1178
1179                     AliMUONTransientDigit* pdigit;
1180                     // build the list of fired pads and update the info
1181                     if (!hitMap[nch]->TestHit(ipx, ipy)) {
1182
1183                         list->AddAtAndExpand(
1184                             new AliMUONTransientDigit(nch,digits),counter);
1185
1186                         hitMap[nch]->SetHit(ipx, ipy, counter);
1187                         counter++;
1188                         pdigit=(AliMUONTransientDigit*)list->At(list->GetLast());
1189                         // list of tracks
1190                         TObjArray *trlist=(TObjArray*)pdigit->TrackList();
1191                         trlist->Add(&trinfo);
1192                     } else {
1193                         pdigit=(AliMUONTransientDigit*) hitMap[nch]->GetHit(ipx, ipy);
1194                         // update charge
1195                         (*pdigit).fSignal+=iqpad;
1196                         (*pdigit).fPhysics+=iqpad;
1197                         // update list of tracks
1198                         TObjArray* trlist=(TObjArray*)pdigit->TrackList();
1199                         Int_t lastEntry=trlist->GetLast();
1200                         TVector *pTrack=(TVector*)trlist->At(lastEntry);
1201                         TVector &ptrk=*pTrack;
1202                         Int_t lastTrack  = Int_t(ptrk(0));
1203                         Int_t lastCharge = Int_t(ptrk(1));
1204                         if (lastTrack==track) {
1205                             lastCharge+=iqpad;
1206                             trlist->RemoveAt(lastEntry);
1207                             trinfo(0)=lastTrack;
1208                             trinfo(1)=lastCharge;
1209                             trlist->AddAt(&trinfo,lastEntry);
1210                         } else {
1211                             trlist->Add(&trinfo);
1212                         }
1213                         // check the track list
1214                         Int_t nptracks=trlist->GetEntriesFast();
1215                         if (nptracks > 2) {
1216                             for (Int_t tr=0;tr<nptracks;tr++) {
1217                                 TVector *ppTrack=(TVector*)trlist->At(tr);
1218                                 TVector &pptrk=*ppTrack;
1219                                 trk[tr]   = Int_t(pptrk(0));
1220                                 chtrk[tr] = Int_t(pptrk(1));
1221                             }
1222                         } // end if nptracks
1223                     } //  end if pdigit
1224                 } //end loop over clusters
1225             } // hit loop
1226         } // track loop
1227
1228         // open the file with background
1229
1230         if (addBackground) {
1231             ntracks =(Int_t)fTrH1->GetEntries();
1232 //
1233 //   Loop over tracks
1234 //
1235             for (Int_t track=0; track<ntracks; track++) {
1236
1237                 if (fHits2)       fHits2->Clear();
1238                 if (fPadHits2)   fPadHits2->Clear();
1239
1240                 fTrH1->GetEvent(track);
1241 //
1242 //   Loop over hits
1243                 AliMUONHit* mHit;
1244                 for(int i=0;i<fHits2->GetEntriesFast();++i)
1245                 {
1246                     mHit=(AliMUONHit*) (*fHits2)[i];
1247                     Int_t   nch   = mHit->fChamber-1;  // chamber number
1248                     if (nch >9) continue;
1249                     iChamber = &(pMUON->Chamber(nch));
1250 //                  Int_t rmin = (Int_t)iChamber->RInner();
1251 //                  Int_t rmax = (Int_t)iChamber->ROuter();
1252                     Float_t xbgr=mHit->X();
1253                     Float_t ybgr=mHit->Y();
1254                     Bool_t cond=kFALSE;
1255
1256                     for (Int_t imuon =0; imuon < nmuon[nch]; imuon++) {
1257                         Float_t dist= (xbgr-xhit[nch][imuon])*(xbgr-xhit[nch][imuon])
1258                             +(ybgr-yhit[nch][imuon])*(ybgr-yhit[nch][imuon]);
1259                         if (dist<100) cond=kTRUE;
1260                     }
1261                     if (!cond) continue;
1262
1263 //
1264 // Loop over pad hits
1265                     for (AliMUONPadHit* mPad=
1266                              (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHits2);
1267                          mPad;
1268                          mPad=(AliMUONPadHit*)pMUON->NextPad(fPadHits2))
1269                     {
1270                         //                  mPad = (AliMUONPadHit*) (*fPadHits2)[j];
1271                         Int_t cathode  = mPad->fCathode;    // cathode number
1272                         Int_t ipx      = mPad->fPadX;       // pad number on X
1273                         Int_t ipy      = mPad->fPadY;       // pad number on Y
1274                         Int_t iqpad    = Int_t(mPad->fQpad);// charge per pad
1275
1276                         if (cathode != (icat+1)) continue;
1277                         printf("\n Pad: %d %d %d", ipx, ipy, cathode);
1278
1279 //                      Float_t thex, they, thez;
1280 //                      segmentation=iChamber->SegmentationModel(cathode);
1281 //                      segmentation->GetPadC(ipx,ipy,thex,they,thez);
1282 //                      Float_t rpad=TMath::Sqrt(thex*thex+they*they);
1283 //                      if (rpad < rmin || iqpad ==0 || rpad > rmax) continue;
1284                         new((*pAddress)[countadr++]) TVector(2);
1285                         TVector &trinfo=*((TVector*) (*pAddress)[countadr-1]);
1286                         trinfo(0)=-1;  // tag background
1287                         trinfo(1)=-1;
1288
1289                         digits[0]=ipx;
1290                         digits[1]=ipy;
1291                         digits[2]=iqpad;
1292                         digits[3]=0;
1293                         digits[4]=-1;
1294
1295                         AliMUONTransientDigit* pdigit;
1296                         // build the list of fired pads and update the info
1297                         if (!hitMap[nch]->TestHit(ipx, ipy)) {
1298                             list->AddAtAndExpand(new AliMUONTransientDigit(nch,digits),counter);
1299
1300                             hitMap[nch]->SetHit(ipx, ipy, counter);
1301                             counter++;
1302
1303                             pdigit=(AliMUONTransientDigit*)list->At(list->GetLast());
1304                             // list of tracks
1305                             TObjArray *trlist=(TObjArray*)pdigit->
1306                                 TrackList();
1307                             trlist->Add(&trinfo);
1308                         } else {
1309                             pdigit=(AliMUONTransientDigit*) hitMap[nch]->GetHit(ipx, ipy);
1310                             // update charge
1311                             (*pdigit).fSignal+=iqpad;
1312
1313                             // update list of tracks
1314                             TObjArray* trlist=(TObjArray*)pdigit->
1315                                 TrackList();
1316                             Int_t lastEntry=trlist->GetLast();
1317                             TVector *pTrack=(TVector*)trlist->
1318                                 At(lastEntry);
1319                             TVector &ptrk=*pTrack;
1320                             Int_t lastTrack=Int_t(ptrk(0));
1321                             if (lastTrack==-1) {
1322                                 continue;
1323                             } else {
1324                                 trlist->Add(&trinfo);
1325                             }
1326                                 // check the track list
1327                             Int_t nptracks=trlist->GetEntriesFast();
1328                             if (nptracks > 0) {
1329                                 for (Int_t tr=0;tr<nptracks;tr++) {
1330                                     TVector *ppTrack=(TVector*)trlist->At(tr);
1331                                     TVector &pptrk=*ppTrack;
1332                                     trk[tr]=Int_t(pptrk(0));
1333                                     chtrk[tr]=Int_t(pptrk(1));
1334                                 }
1335                             } // end if nptracks
1336                         } //  end if pdigit
1337                     } //end loop over clusters
1338                 } // hit loop
1339             } // track loop
1340             //Int_t nentr2=list->GetEntriesFast();
1341             //printf(" \n counter2, nentr2 %d %d \n",counter,nentr2);
1342             TTree *fAli=gAlice->TreeK();
1343             TFile *file=NULL;
1344
1345             if (fAli) file =fAli->GetCurrentFile();
1346             file->cd();
1347         } // if addBackground
1348         delete [] xhit;
1349         delete [] yhit;
1350
1351         Int_t tracks[10];
1352         Int_t charges[10];
1353         Int_t nentries=list->GetEntriesFast();
1354
1355         for (Int_t nent=0;nent<nentries;nent++) {
1356             AliMUONTransientDigit *address=(AliMUONTransientDigit*)list->At(nent);
1357             if (address==0) continue;
1358             Int_t ich=address->fChamber;
1359             Int_t q=address->fSignal;
1360             iChamber=(AliMUONChamber*) (*fChambers)[ich];
1361 //
1362 //  Digit Response (noise, threshold, saturation, ...)
1363 //              if (address->fPhysics !=0 ) address->fPhysics+=(Int_t)Noise;
1364             AliMUONResponse * response=iChamber->ResponseModel();
1365             q=response->DigitResponse(q);
1366
1367             if (!q) continue;
1368
1369             digits[0]=address->fPadX;
1370             digits[1]=address->fPadY;
1371             digits[2]=q;
1372             digits[3]=address->fPhysics;
1373             digits[4]=address->fHit;
1374
1375             TObjArray* trlist=(TObjArray*)address->TrackList();
1376             Int_t nptracks=trlist->GetEntriesFast();
1377             //printf("nptracks, trlist   %d  %p\n",nptracks,trlist);
1378
1379             // this was changed to accomodate the real number of tracks
1380             if (nptracks > 10) {
1381                 cout<<"Attention - nptracks > 10 "<<nptracks<<endl;
1382                 nptracks=10;
1383             }
1384             if (nptracks > 2) {
1385                 printf("Attention - nptracks > 2  %d \n",nptracks);
1386                 printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,digits[0],digits[1],q);
1387             }
1388             for (Int_t tr=0;tr<nptracks;tr++) {
1389                 TVector *ppP=(TVector*)trlist->At(tr);
1390                 if(!ppP ) printf("ppP - %p\n",ppP);
1391                 TVector &pp  =*ppP;
1392                 tracks[tr]=Int_t(pp(0));
1393                 charges[tr]=Int_t(pp(1));
1394                 //printf("tracks, charges - %d %d\n",tracks[tr],charges[tr]);
1395             }      //end loop over list of tracks for one pad
1396             // Sort list of tracks according to charge
1397             if (nptracks > 1) {
1398                 SortTracks(tracks,charges,nptracks);
1399             }
1400             if (nptracks < 10 ) {
1401                 for (Int_t i=nptracks; i<10; i++) {
1402                     tracks[i]=0;
1403                     charges[i]=0;
1404                 }
1405             }
1406
1407             // fill digits
1408             pMUON->AddDigits(ich,tracks,charges,digits);
1409             // delete trlist;
1410         }
1411         //cout<<"I'm out of the loops for digitisation"<<endl;
1412         //      gAlice->GetEvent(nev);
1413         gAlice->TreeD()->Fill();
1414         pMUON->ResetDigits();
1415         list->Delete();
1416
1417
1418         for(Int_t ii=0;ii<AliMUONConstants::NCh();++ii) {
1419             if (hitMap[ii]) {
1420                 hm=hitMap[ii];
1421                 delete hm;
1422                 hitMap[ii]=0;
1423             }
1424         }
1425         delete [] nmuon;
1426     } //end loop over cathodes
1427     delete [] hitMap;
1428     char hname[30];
1429     sprintf(hname,"TreeD%d",nev);
1430     gAlice->TreeD()->Write(hname);
1431     // reset tree
1432     gAlice->TreeD()->Reset();
1433     delete list;
1434
1435     pAddress->Delete();
1436     // gObjectTable->Print();
1437 }
1438
1439 void AliMUON::SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr)
1440 {
1441   //
1442   // Sort the list of tracks contributing to a given digit
1443   // Only the 3 most significant tracks are acctually sorted
1444   //
1445
1446   //
1447   //  Loop over signals, only 3 times
1448   //
1449
1450   Int_t qmax;
1451   Int_t jmax;
1452   Int_t idx[3] = {-2,-2,-2};
1453   Int_t jch[3] = {-2,-2,-2};
1454   Int_t jtr[3] = {-2,-2,-2};
1455   Int_t i,j,imax;
1456
1457   if (ntr<3) imax=ntr;
1458   else imax=3;
1459   for(i=0;i<imax;i++){
1460     qmax=0;
1461     jmax=0;
1462
1463     for(j=0;j<ntr;j++){
1464
1465       if((i == 1 && j == idx[i-1])
1466          ||(i == 2 && (j == idx[i-1] || j == idx[i-2]))) continue;
1467
1468       if(charges[j] > qmax) {
1469         qmax = charges[j];
1470         jmax=j;
1471       }
1472     }
1473
1474     if(qmax > 0) {
1475       idx[i]=jmax;
1476       jch[i]=charges[jmax];
1477       jtr[i]=tracks[jmax];
1478     }
1479
1480   }
1481
1482   for(i=0;i<3;i++){
1483     if (jtr[i] == -2) {
1484          charges[i]=0;
1485          tracks[i]=0;
1486     } else {
1487          charges[i]=jch[i];
1488          tracks[i]=jtr[i];
1489     }
1490   }
1491
1492 }
1493
1494 //___________________________________________
1495 void AliMUON::Trigger(Int_t nev){
1496 // call the Trigger Algorithm and fill TreeR
1497
1498   Int_t singlePlus[3]  = {0,0,0};
1499   Int_t singleMinus[3] = {0,0,0};
1500   Int_t singleUndef[3] = {0,0,0};
1501   Int_t pairUnlike[3]  = {0,0,0};
1502   Int_t pairLike[3]    = {0,0,0};
1503
1504   ResetTrigger();
1505   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
1506   decision->Trigger();
1507   decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
1508                              pairUnlike, pairLike);
1509 // add a local trigger in the list
1510   AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
1511   Int_t i;
1512
1513   for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) {
1514       if(decision->GetITrigger(icirc)==1) {
1515           Int_t localtr[7]={0,0,0,0,0,0,0};
1516           Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
1517           decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
1518           localtr[0] = icirc;
1519           localtr[1] = decision->GetStripX11(icirc);
1520           localtr[2] = decision->GetDev(icirc);
1521           localtr[3] = decision->GetStripY11(icirc);
1522           for (i=0; i<2; i++) {    // convert the Lut output in 1 digit
1523               localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
1524               localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
1525               localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
1526           }
1527           AddLocalTrigger(localtr);  // add a local trigger in the list
1528       }
1529   }
1530   delete decision;
1531
1532   gAlice->TreeR()->Fill();
1533   ResetTrigger();
1534   char hname[30];
1535   sprintf(hname,"TreeR%d",nev);
1536   gAlice->TreeR()->Write(hname);
1537   gAlice->TreeR()->Reset();
1538   printf("\n End of trigger for event %d", nev);
1539 }
1540
1541
1542 //____________________________________________
1543 void AliMUON::FindClusters(Int_t nev,Int_t lastEntry)
1544 {
1545     TClonesArray *dig1, *dig2;
1546     Int_t ndig, k;
1547     dig1 = new TClonesArray("AliMUONDigit",1000);
1548     dig2 = new TClonesArray("AliMUONDigit",1000);
1549     AliMUONDigit *digit;
1550 //
1551 // Loop on chambers and on cathode planes
1552 //
1553
1554     for (Int_t ich=0;ich<10;ich++) {
1555         AliMUONChamber* iChamber=(AliMUONChamber*) (*fChambers)[ich];
1556         AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
1557         gAlice->ResetDigits();
1558         gAlice->TreeD()->GetEvent(lastEntry);
1559         TClonesArray *muonDigits  = this->DigitsAddress(ich);
1560         ndig=muonDigits->GetEntriesFast();
1561         printf("\n 1 Found %d digits in %p %d", ndig, muonDigits,ich);
1562         TClonesArray &lhits1 = *dig1;
1563         Int_t n=0;
1564         for (k=0; k<ndig; k++) {
1565             digit=(AliMUONDigit*) muonDigits->UncheckedAt(k);
1566             if (rec->TestTrack(digit->fTracks[0]))
1567                 new(lhits1[n++]) AliMUONDigit(*digit);
1568         }
1569         gAlice->ResetDigits();
1570         gAlice->TreeD()->GetEvent(lastEntry+1);
1571         muonDigits  = this->DigitsAddress(ich);
1572         ndig=muonDigits->GetEntriesFast();
1573         printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
1574         TClonesArray &lhits2 = *dig2;
1575         n=0;
1576
1577         for (k=0; k<ndig; k++) {
1578             digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
1579             if (rec->TestTrack(digit->fTracks[0]))
1580             new(lhits2[n++]) AliMUONDigit(*digit);
1581         }
1582
1583         if (rec) {
1584             AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
1585             rec->FindRawClusters();
1586         }
1587         dig1->Delete();
1588         dig2->Delete();
1589     } // for ich
1590     gAlice->TreeR()->Fill();
1591     ResetRawClusters();
1592     char hname[30];
1593     sprintf(hname,"TreeR%d",nev);
1594     gAlice->TreeR()->Write(hname);
1595     gAlice->TreeR()->Reset();
1596     printf("\n End of cluster finding for event %d", nev);
1597
1598     delete dig1;
1599     delete dig2;
1600     //gObjectTable->Print();
1601 }
1602
1603
1604 void AliMUON::Streamer(TBuffer &R__b)
1605 {
1606    // Stream an object of class AliMUON.
1607       AliMUONChamber        *iChamber;
1608       AliMUONTriggerCircuit *iTriggerCircuit;
1609       AliSegmentation       *segmentation;
1610       AliMUONResponse       *response;
1611       TClonesArray          *digitsaddress;
1612       TClonesArray          *rawcladdress;
1613       Int_t i;
1614       if (R__b.IsReading()) {
1615           Version_t R__v = R__b.ReadVersion(); if (R__v) { }
1616           AliDetector::Streamer(R__b);
1617           R__b >> fNPadHits;
1618           R__b >> fPadHits; // diff
1619           R__b >> fNLocalTrigger;
1620           R__b >> fLocalTrigger;
1621           R__b >> fNGlobalTrigger;
1622           R__b >> fGlobalTrigger;
1623           R__b >> fDchambers;
1624           R__b >> fRawClusters;
1625           R__b.ReadArray(fNdch);
1626           R__b.ReadArray(fNrawch);
1627           R__b >> fAccCut;
1628           R__b >> fAccMin;
1629           R__b >> fAccMax;
1630           R__b >> fChambers;
1631           R__b >> fTriggerCircuits;
1632           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1633               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1634               iTriggerCircuit->Streamer(R__b);
1635           }
1636 // Stream chamber related information
1637           for (i =0; i<AliMUONConstants::NCh(); i++) {
1638               iChamber=(AliMUONChamber*) (*fChambers)[i];
1639               iChamber->Streamer(R__b);
1640               if (iChamber->Nsec()==1) {
1641                   segmentation=iChamber->SegmentationModel(1);
1642                   if (segmentation)
1643                       segmentation->Streamer(R__b);
1644               } else {
1645                   segmentation=iChamber->SegmentationModel(1);
1646                   if (segmentation)
1647                       segmentation->Streamer(R__b);
1648                   if (segmentation)
1649                       segmentation=iChamber->SegmentationModel(2);
1650                   segmentation->Streamer(R__b);
1651               }
1652               response=iChamber->ResponseModel();
1653               if (response)
1654                   response->Streamer(R__b);
1655               digitsaddress=(TClonesArray*) (*fDchambers)[i];
1656               digitsaddress->Streamer(R__b);
1657               if (i < AliMUONConstants::NTrackingCh()) {
1658                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1659                   rawcladdress->Streamer(R__b);
1660               }
1661           }
1662
1663       } else {
1664           R__b.WriteVersion(AliMUON::IsA());
1665           AliDetector::Streamer(R__b);
1666           R__b << fNPadHits;
1667           R__b << fPadHits; // diff
1668           R__b << fNLocalTrigger;
1669           R__b << fLocalTrigger;
1670           R__b << fNGlobalTrigger;
1671           R__b << fGlobalTrigger;
1672           R__b << fDchambers;
1673           R__b << fRawClusters;
1674           R__b.WriteArray(fNdch, AliMUONConstants::NCh());
1675           R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
1676
1677           R__b << fAccCut;
1678           R__b << fAccMin;
1679           R__b << fAccMax;
1680
1681           R__b << fChambers;
1682           R__b << fTriggerCircuits;
1683           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1684               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1685               iTriggerCircuit->Streamer(R__b);
1686           }
1687           for (i =0; i<AliMUONConstants::NCh(); i++) {
1688               iChamber=(AliMUONChamber*) (*fChambers)[i];
1689               iChamber->Streamer(R__b);
1690               if (iChamber->Nsec()==1) {
1691                   segmentation=iChamber->SegmentationModel(1);
1692                   if (segmentation)
1693                       segmentation->Streamer(R__b);
1694               } else {
1695                   segmentation=iChamber->SegmentationModel(1);
1696                   if (segmentation)
1697                       segmentation->Streamer(R__b);
1698                   segmentation=iChamber->SegmentationModel(2);
1699                   if (segmentation)
1700                       segmentation->Streamer(R__b);
1701               }
1702               response=iChamber->ResponseModel();
1703               if (response)
1704                   response->Streamer(R__b);
1705               digitsaddress=(TClonesArray*) (*fDchambers)[i];
1706               digitsaddress->Streamer(R__b);
1707               if (i < AliMUONConstants::NTrackingCh()) {
1708                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1709                   rawcladdress->Streamer(R__b);
1710               }
1711           }
1712       }
1713 }
1714 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters)
1715 {
1716 //
1717     // Initialise the pad iterator
1718     // Return the address of the first padhit for hit
1719     TClonesArray *theClusters = clusters;
1720     Int_t nclust = theClusters->GetEntriesFast();
1721     if (nclust && hit->fPHlast > 0) {
1722         AliMUON::fMaxIterPad=hit->fPHlast;
1723         AliMUON::fCurIterPad=hit->fPHfirst;
1724         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1725     } else {
1726         return 0;
1727     }
1728 }
1729
1730 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
1731 {
1732     AliMUON::fCurIterPad++;
1733     if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
1734         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1735     } else {
1736         return 0;
1737     }
1738 }
1739
1740
1741 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
1742 {
1743     TClonesArray *muonRawCluster  = RawClustAddress(ichamber);
1744     ResetRawClusters();
1745     TTree *treeR = gAlice->TreeR();
1746     Int_t nent=(Int_t)treeR->GetEntries();
1747     treeR->GetEvent(nent-2+icathod-1);
1748     //treeR->GetEvent(icathod);
1749     //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
1750
1751     AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
1752     //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
1753
1754     return  mRaw;
1755 }
1756
1757 AliMUON& AliMUON::operator = (const AliMUON& rhs)
1758 {
1759 // copy operator
1760 // dummy version
1761     return *this;
1762 }
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781