RICH/AliRICH.h

   1 #ifndef RICH_H
   2 #define RICH_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 ////////////////////////////////////////////////
   9 //  Manager and hits classes for set:RICH     //
  10 ////////////////////////////////////////////////
  11 #include "AliDetector.h"
  12 #include "AliHit.h"
  13 #include "AliRICHConst.h"
  14 #include "AliDigit.h"
  15 #include <TVector.h>
  16 #include <TObjArray.h>
  17 #include <TFile.h>
  18 #include <TTree.h>
  19 #include <TRotMatrix.h>
  20
  21 static const int NCH=7;
  22 typedef enum {mip, cerenkov} Response_t;
  23
  24 class AliRICHcluster;
  25 class AliRICHchamber;
  26 class AliRICHRecCluster;
  27 class AliRICHCerenkov;
  28
  29 //----------------------------------------------
  30 //----------------------------------------------
  31 //
  32 // Chamber segmentation virtual base class
  33 //
  34 class AliRICHsegmentation :
  35 public TObject {
  36
  37  public:
  38
  39     // Set Chamber Segmentation Parameters
  40     virtual void    SetPADSIZ(Float_t p1, Float_t p2)  =0;
  41     virtual void    SetDAnod(Float_t D)                =0;
  42     // Transform from pad (wire) to real coordinates and vice versa
  43     virtual Float_t GetAnod(Float_t xhit)              =0;
  44     virtual void    GetPadIxy(Float_t x ,Float_t y ,Int_t   &ix,Int_t   &iy)=0;
  45     virtual void    GetPadCxy(Int_t   ix,Int_t   iy,Float_t &x ,Float_t &y )=0;
  46     //
  47     // Initialisation
  48     virtual void Init(AliRICHchamber*)                 =0;
  49     //
  50     // Get member data
  51     virtual Float_t Dpx()                              =0;
  52     virtual Float_t Dpy()                              =0;
  53     virtual Int_t Npx()                                =0;
  54     virtual Int_t Npy()                                =0;
  55     //
  56     // Iterate over pads
  57     virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy) =0;
  58     virtual void  NextPad()=0;
  59     virtual Int_t MorePads()                           =0;
  60     // Get next neighbours
  61     virtual void Neighbours
  62         (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])     =0;
  63     // Provisory RecCluster coordinates reconstructor
  64     virtual void FitXY(AliRICHRecCluster* Cluster,TClonesArray* RICHdigits)    =0;
  65     //
  66     // Current pad cursor during disintegration
  67     virtual Int_t  Ix()                                =0;
  68     virtual Int_t  Iy()                                =0;
  69     virtual Int_t  ISector()                           =0;
  70     //
  71     // Signal Generation Condition during Stepping
  72     virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) = 0;
  73     virtual void  SigGenInit(Float_t x, Float_t y, Float_t z) = 0;
  74     virtual void  IntegrationLimits
  75         (Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2)  = 0;
  76     //
  77     // Identification
  78     virtual char* YourName()                           =0;
  79     ClassDef(AliRICHsegmentation,1)
  80         };
  81 //----------------------------------------------
  82 //
  83 // Chamber response virtual base class
  84 //
  85 class AliRICHresponse :
  86 public TObject {
  87  public:
  88     //
  89     // Configuration methods
  90     virtual void   SetRSIGM(Float_t p1)                          =0;
  91     virtual void   SetMUCHSP(Float_t p1)                         =0;
  92     virtual void   SetMUSIGM(Float_t p1, Float_t p2)             =0;
  93     virtual void   SetMAXADC(Float_t p1)                         =0;
  94     //
  95     // Get member data
  96     virtual Float_t Chslope()                                    =0;
  97     virtual Float_t ChwX()                                       =0;
  98     virtual Float_t ChwY()                                       =0;
  99     virtual Float_t Nsigma()                                     =0;
 100     virtual Float_t adc_satm()                                   =0;
 101     //
 102     // Chamber response methods
 103     // Pulse height from scored quantity (eloss)
 104     virtual Float_t IntPH(Float_t eloss=0)                       =0;
 105   //    virtual Float_t IntPH()                                      =0;
 106     virtual Int_t FeedBackPhotons(Float_t *source, Float_t qtot) =0;
 107     // Charge disintegration
 108     virtual Float_t IntXY(AliRICHsegmentation *)                 =0;
 109     //
 110     // Identification
 111     virtual char* YourName()                                     =0;
 112     // Mathieson parameters
 113     virtual void   SetSqrtKx3(Float_t p1)                        =0;
 114     virtual void   SetKx2(Float_t p1)                            =0;
 115     virtual void   SetKx4(Float_t p1)                            =0;
 116     virtual void   SetSqrtKy3(Float_t p1)                        =0;
 117     virtual void   SetKy2(Float_t p1)                            =0;
 118     virtual void   SetKy4(Float_t p1)                            =0;
 119     virtual void   SetPitch(Float_t p1)                          =0;
 120     ClassDef(AliRICHresponse,1)
 121         };
 122
 123 //----------------------------------------------
 124 class AliRICHchamber :
 125 public TObject
 126 {
 127
 128  public:
 129
 130 //Rotation matrices for each chamber
 131
 132     TRotMatrix *fChamberMatrix;
 133     Float_t fChamberTrans[3];
 134
 135  public:
 136     AliRICHchamber();
 137     ~AliRICHchamber(){}
 138 //
 139 // Set and get GEANT id
 140     Int_t   GetGid()         {return fGid;}
 141     void    SetGid(Int_t id) {fGid=id;}
 142 //
 143 // Initialisation and z-Position
 144     void    Init();
 145     void    SetZPOS(Float_t p1) {fzPos=p1;}
 146     Float_t ZPosition()         {return fzPos;}
 147 //
 148
 149 // Set inner radius of sensitive volume
 150     void SetRInner(Float_t rmin) {frMin=rmin;}
 151 // Set outer radius of sensitive volum
 152     void SetROuter(Float_t rmax) {frMax=rmax;}
 153
 154 // Return inner radius of sensitive volume
 155     Float_t RInner()            {return frMin;}
 156 // Return outer radius of sensitive volum
 157     Float_t ROuter()            {return frMax;}
 158
 159 //Transformation from Global to local coordinates, chamber-dependant
 160     void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]);
 161
 162 //Setting chamber specific rotation matrices
 163
 164     void SetChamberTransform(Float_t Trans1,Float_t Trans2,Float_t Trans3,TRotMatrix *Matrix)
 165
 166         {
 167             fChamberMatrix=Matrix;
 168             fChamberTrans[0]=Trans1;
 169             fChamberTrans[1]=Trans2;
 170             fChamberTrans[2]=Trans3;
 171         }
 172
 173 // Configure response model
 174     void    ResponseModel(Response_t res, AliRICHresponse* thisResponse);
 175
 176     //
 177 // Configure segmentation model
 178     void    SegmentationModel(Int_t i, AliRICHsegmentation* thisSegmentation) {
 179         (*fSegmentation)[i-1] = thisSegmentation;
 180     }
 181 //
 182 //  Get reference to response model
 183     AliRICHresponse*     GetResponseModel(Response_t res);
 184 //
 185 //  Get reference to segmentation model
 186     AliRICHsegmentation*  GetSegmentationModel(Int_t isec) {
 187         return (AliRICHsegmentation *) (*fSegmentation)[isec-1];
 188     }
 189     Int_t Nsec()              {return fnsec;}
 190     void  SetNsec(Int_t nsec) {fnsec=nsec;}
 191 //
 192 // Member function forwarding to the segmentation and response models
 193 //
 194 // Calculate pulse height from energy loss
 195     Float_t IntPH(Float_t eloss) {return ((AliRICHresponse*) (*fResponse)[0])->IntPH(eloss);}
 196     Float_t IntPH()              {return ((AliRICHresponse*) (*fResponse)[1])->IntPH(); }
 197 //
 198 // Ask segmentation if signal should be generated
 199     Int_t   SigGenCond(Float_t x, Float_t y, Float_t z)
 200         {
 201             if (fnsec==1) {
 202                 return ((AliRICHsegmentation*) (*fSegmentation)[0])
 203                     ->SigGenCond(x, y, z) ;
 204             } else {
 205                 return (((AliRICHsegmentation*) (*fSegmentation)[0])
 206                         ->SigGenCond(x, y, z)) ||
 207                     (((AliRICHsegmentation*) (*fSegmentation)[1])
 208                      ->SigGenCond(x, y, z)) ;
 209           }
 210         }
 211 //
 212 // Initialisation of segmentation for hit
 213     void    SigGenInit(Float_t x, Float_t y, Float_t z)
 214         {
 215
 216             if (fnsec==1) {
 217                 ((AliRICHsegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
 218             } else {
 219                 ((AliRICHsegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
 220                 ((AliRICHsegmentation*) (*fSegmentation)[1])->SigGenInit(x, y, z) ;
 221             }
 222         }
 223
 224 // Configuration forwarding
 225 //
 226     void   SetRSIGM(Float_t p)
 227         {
 228             ((AliRICHresponse*) (*fResponse)[0])->SetRSIGM(p);
 229             ((AliRICHresponse*) (*fResponse)[1])->SetRSIGM(p);
 230         }
 231     void   SetMUCHSP(Float_t p)
 232         {
 233             ((AliRICHresponse*) (*fResponse)[0])->SetMUCHSP(p);
 234             ((AliRICHresponse*) (*fResponse)[1])->SetMUCHSP(p);
 235         }
 236     void   SetMUSIGM(Float_t p1, Float_t p2)
 237         {
 238             ((AliRICHresponse*) (*fResponse)[0])->SetMUSIGM(p1,p2);
 239             ((AliRICHresponse*) (*fResponse)[1])->SetMUSIGM(p1,p2);
 240         }
 241     void   SetMAXADC(Float_t p)
 242         {
 243             ((AliRICHresponse*) (*fResponse)[0])->SetMAXADC(p);
 244             ((AliRICHresponse*) (*fResponse)[1])->SetMAXADC(p);
 245         }
 246     void   SetSqrtKx3(Float_t p)
 247         {
 248             ((AliRICHresponse*) (*fResponse)[0])->SetSqrtKx3(p);
 249             ((AliRICHresponse*) (*fResponse)[1])->SetSqrtKx3(p);
 250         }
 251     void   SetKx2(Float_t p)
 252         {
 253             ((AliRICHresponse*) (*fResponse)[0])->SetKx2(p);
 254             ((AliRICHresponse*) (*fResponse)[1])->SetKx2(p);
 255         }
 256     void   SetKx4(Float_t p)
 257         {
 258             ((AliRICHresponse*) (*fResponse)[0])->SetKx4(p);
 259             ((AliRICHresponse*) (*fResponse)[1])->SetKx4(p);
 260         }
 261     void   SetSqrtKy3(Float_t p)
 262         {
 263             ((AliRICHresponse*) (*fResponse)[0])->SetSqrtKy3(p);
 264             ((AliRICHresponse*) (*fResponse)[1])->SetSqrtKy3(p);
 265         }
 266     void   SetKy2(Float_t p)
 267         {
 268             ((AliRICHresponse*) (*fResponse)[0])->SetKy2(p);
 269             ((AliRICHresponse*) (*fResponse)[1])->SetKy2(p);
 270         }
 271     void   SetKy4(Float_t p)
 272         {
 273             ((AliRICHresponse*) (*fResponse)[0])->SetKy4(p);
 274             ((AliRICHresponse*) (*fResponse)[1])->SetKy4(p);
 275         }
 276
 277     void   SetPitch(Float_t p)
 278         {
 279             ((AliRICHresponse*) (*fResponse)[0])->SetPitch(p);
 280             ((AliRICHresponse*) (*fResponse)[1])->SetPitch(p);
 281         }
 282
 283     void   SetPADSIZ(Int_t isec, Float_t p1, Float_t p2) {
 284         ((AliRICHsegmentation*) (*fSegmentation)[isec-1])->SetPADSIZ(p1,p2);
 285     }
 286 //
 287 // Cluster formation method
 288     void   DisIntegration(Float_t, Float_t, Float_t, Int_t&x, Float_t newclust[6][500], Response_t res);
 289     ClassDef(AliRICHchamber,1)
 290
 291         private:
 292
 293 // Maximum and Minimum Chamber size
 294     Float_t frMin;
 295     Float_t frMax;
 296 // GEANT volume if for sensitive volume of this chamber
 297     Int_t   fGid;
 298 // z-position of this chamber
 299     Float_t fzPos;
 300 // The segmentation models for the cathode planes
 301 // fnsec=1: one plane segmented, fnsec=2: both planes are segmented.
 302     Int_t   fnsec;
 303     TObjArray           *fSegmentation;
 304     TObjArray           *fResponse;
 305
 306 };
 307
 308
 309
 310 class AliRICHcluster : public TObject {
 311 public:
 312
 313     Int_t     fHitNumber;    // Hit number
 314     Int_t     fCathode;      // Cathode number
 315     Int_t     fQ  ;          // Total charge
 316     Int_t     fPadX  ;       // Pad number along X
 317     Int_t     fPadY  ;       // Pad number along Y
 318     Int_t     fQpad  ;       // Charge per pad
 319     Int_t     fRSec  ;       // R -sector of pad
 320
 321 public:
 322     AliRICHcluster() {
 323         fHitNumber=fQ=fPadX=fPadY=fQpad=fRSec=0;
 324     }
 325     AliRICHcluster(Int_t *clhits);
 326     virtual ~AliRICHcluster() {;}
 327
 328     ClassDef(AliRICHcluster,1)  //Cluster object for set:RICH
 329         };
 330
 331
 332         class AliRICHreccluster : public TObject {
 333 public:
 334
 335             Int_t     fTracks[3];      //labels of overlapped tracks
 336
 337             Int_t       fQ  ;          // Q of cluster (in ADC counts)
 338             Float_t     fX  ;          // X of cluster
 339             Float_t     fY  ;          // Y of cluster
 340
 341         public:
 342             AliRICHreccluster() {
 343                 fTracks[0]=fTracks[1]=fTracks[2]=0;
 344                 fQ=0; fX=fY=0;
 345             }
 346             virtual ~AliRICHreccluster() {;}
 347
 348             ClassDef(AliRICHreccluster,1)  //Cluster object for set:RICH
 349                 };
 350
 351 //_____________________________________________________________________________
 352
 353 class AliRICHdigit : public TObject {
 354  public:
 355     Int_t     fPadX;        // Pad number along x
 356     Int_t     fPadY ;       // Pad number along y
 357     Int_t     fSignal;      // Signal amplitude
 358
 359
 360     Int_t     fTcharges[10];  // charge per track making this digit (up to 10)
 361     Int_t     fTracks[10];    // tracks making this digit (up to 10)
 362
 363
 364
 365  public:
 366     AliRICHdigit() {}
 367     AliRICHdigit(Int_t *digits);
 368     AliRICHdigit(Int_t *tracks, Int_t *charges, Int_t *digits);
 369     virtual ~AliRICHdigit() {}
 370
 371
 372     ClassDef(AliRICHdigit,1)  //Digits for set:RICH
 373         };
 374 //_____________________________________________________________________________
 375
 376 class AliRICHlist : public AliRICHdigit {
 377  public:
 378
 379     Int_t          fRpad;       // r_pos of pad
 380     Int_t          fChamber;       // chamber number of pad
 381     TObjArray     *fTrackList;
 382
 383
 384  public:
 385     AliRICHlist() {fTrackList=0;}
 386     AliRICHlist(Int_t ich, Int_t *digits);
 387     virtual ~AliRICHlist() {}
 388
 389     TObjArray  *TrackList()   {return fTrackList;}
 390
 391     ClassDef(AliRICHlist,1)  //Digits for set:RICH
 392         };
 393 //___________________________________________
 394
 395
 396 //___________________________________________
 397
 398 class AliRICHhit : public AliHit {
 399  public:
 400     Int_t     fChamber;       // Chamber number
 401     Float_t   fParticle;      // Geant3 particle type
 402     Float_t   fTheta ;        // Incident theta angle in degrees
 403     Float_t   fPhi   ;        // Incident phi angle in degrees
 404     Float_t   fTlength;       // Track length inside the chamber
 405     Float_t   fEloss;         // ionisation energy loss in gas
 406     Int_t     fPHfirst;       // first padhit
 407     Int_t     fPHlast;        // last padhit
 408  public:
 409     AliRICHhit() {}
 410     AliRICHhit(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *hits);
 411     virtual ~AliRICHhit() {}
 412
 413     ClassDef(AliRICHhit,1)  //Hits object for set:RICH
 414         };
 415
 416 //------------------------------------------------
 417 // Cerenkov photon  object
 418 //------------------------------------------------
 419
 420 class AliRICHCerenkov: public AliHit {
 421  public:
 422     Int_t     fChamber;       // Chamber number
 423     Float_t   fTheta ;        // Incident theta angle in degrees
 424     Float_t   fPhi   ;        // Incident phi angle in degrees
 425     Float_t   fTlength;       // Track length inside the chamber
 426     Int_t     fPHfirst;       // first padhit
 427     Int_t     fPHlast;        // last padhit
 428  public:
 429     AliRICHCerenkov() {}
 430     AliRICHCerenkov(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *Cerenkovs);
 431     virtual ~AliRICHCerenkov() {}
 432
 433     ClassDef(AliRICHCerenkov,1)  //Cerenkovs object for set:RICH
 434         };
 435
 436 //--------------------------------------------------
 437
 438 class AliRICH : public  AliDetector {
 439  public:
 440     AliRICH();
 441     AliRICH(const char *name, const char *title);
 442     virtual       ~AliRICH();
 443     virtual void   AddHit(Int_t, Int_t*, Float_t*);
 444     virtual void   AddCerenkov(Int_t, Int_t*, Float_t*);
 445     virtual void   AddCluster(Int_t*);
 446     virtual void   AddDigits(Int_t, Int_t*, Int_t*, Int_t*);
 447     virtual void   AddRecCluster(Int_t iCh, Int_t iCat,
 448                                  AliRICHRecCluster* Cluster);
 449     virtual void   BuildGeometry();
 450     virtual void   CreateGeometry() {}
 451     virtual void   CreateMaterials() {}
 452     virtual void   StepManager();
 453     Int_t          DistancetoPrimitive(Int_t px, Int_t py);
 454     virtual Int_t  IsVersion() const =0;
 455 //
 456     TClonesArray  *Clusters() {return fClusters;}
 457     TClonesArray  *Cerenkovs() {return fCerenkovs;}
 458     virtual void   MakeBranch(Option_t *opt=" ");
 459     void           SetTreeAddress();
 460     virtual void   ResetHits();
 461     virtual void   ResetDigits();
 462     virtual void   ResetRecClusters();
 463     virtual void   ReconstructClusters();
 464     virtual void   Digitise(Int_t,Option_t *opt=" ",Text_t *name=" ");
 465 //
 466 // Configuration Methods (per station id)
 467 //
 468 // Set Chamber Segmentation Parameters
 469 // id refers to the station and isec to the cathode plane
 470     virtual void   SetPADSIZ(Int_t id, Int_t isec, Float_t p1, Float_t p2);
 471
 472 // Set Signal Generation Parameters
 473     virtual void   SetRSIGM(Int_t id, Float_t p1);
 474     virtual void   SetMUCHSP(Int_t id, Float_t p1);
 475     virtual void   SetMUSIGM(Int_t id, Float_t p1, Float_t p2);
 476     virtual void   SetMAXADC(Int_t id, Float_t p1);
 477 // Set Segmentation and Response Model
 478     virtual void   SetSegmentationModel(Int_t id, Int_t isec, AliRICHsegmentation *segmentation);
 479     virtual void   SetResponseModel(Int_t id, Response_t res, AliRICHresponse *response);
 480     virtual void   SetNsec(Int_t id, Int_t nsec);
 481 // Set Stepping Parameters
 482     virtual void   SetSMAXAR(Float_t p1);
 483     virtual void   SetSMAXAL(Float_t p1);
 484     virtual void   SetDMAXAR(Float_t p1);
 485     virtual void   SetDMAXAL(Float_t p1);
 486     virtual void   SetRICHACC(Bool_t acc=0, Float_t angmin=2, Float_t angmax=9);
 487 // Response Simulation
 488     virtual void   MakePadHits(Float_t xhit,Float_t yhit,Float_t eloss,Int_t id,Response_t res);
 489 // Return reference to Chamber #id
 490     virtual AliRICHchamber& Chamber(Int_t id) {return *((AliRICHchamber *) (*fChambers)[id]);}
 491 // Retrieve pad hits for a given Hit
 492     virtual AliRICHcluster* FirstPad(AliRICHhit *, TClonesArray *);
 493     virtual AliRICHcluster* NextPad(TClonesArray *);
 494 // Return pointers to digits
 495     TObjArray            *Dchambers() {return fDchambers;}
 496     Int_t                *Ndch() {return fNdch;}
 497     virtual TClonesArray *DigitsAddress(Int_t id) {return ((TClonesArray *) (*fDchambers)[id]);}
 498 // Return pointers to reconstructed clusters
 499     virtual TObjArray *RecClusters(Int_t iCh, Int_t iCat)
 500         {return ( (TObjArray*) (*fRecClusters)[iCh+iCat*10]);}
 501
 502
 503  protected:
 504     TObjArray            *fChambers;           // List of Tracking Chambers
 505     Int_t                fNclusters;           // Number of clusters
 506     Int_t                fNcerenkovs;          // Number of cerenkovs
 507     TClonesArray         *fClusters;           // List of clusters
 508     TObjArray            *fDchambers;          // List of digits
 509     TObjArray            *fRecClusters;        // List of clusters
 510     TClonesArray         *fCerenkovs;          // List of cerenkovs
 511     Int_t                *fNdch;               // Number of digits
 512     Text_t               *fFileName;           // Filename for event mixing
 513
 514
 515     TObjArray            *fRawClusters;            // List of raw clusters
 516     Int_t                *fNrawch;                 // Number of raw clusters
 517     TObjArray            *fCathCorrel;             // List of correlated clusters
 518     Int_t                *fNcorch;                 // Number of correl clusters
 519     TTree                *fTreeC;                  // Cathode correl index tree
 520
 521 //
 522     Bool_t   fAccCut;          //Transport acceptance cut
 523     Float_t  fAccMin;          //Minimum acceptance cut used during transport
 524     Float_t  fAccMax;          //Minimum acceptance cut used during transport
 525 //
 526
 527 //  Stepping Parameters
 528     Float_t fMaxStepGas;      // Maximum step size inside the chamber gas
 529     Float_t fMaxStepAlu;      // Maximum step size inside the chamber aluminum
 530     Float_t fMaxDestepGas;    // Maximum relative energy loss in gas
 531     Float_t fMaxDestepAlu;    // Maximum relative energy loss in aluminum
 532
 533  protected:
 534
 535     ClassDef(AliRICH,1)  //Hits manager for set:RICH
 536         };
 537 //___________________________________________
 538 class AliRICHRecCluster : public TObject {
 539  public:
 540     AliRICHRecCluster() ;
 541     AliRICHRecCluster(Int_t FirstDigit,Int_t Ichamber, Int_t Icathod) ;
 542     virtual ~AliRICHRecCluster();
 543     virtual void  AddDigit(Int_t Digit);
 544     virtual Int_t FirstDigitIndex();
 545     virtual Int_t NextDigitIndex();
 546     virtual Int_t InvalidDigitIndex() {return -1;}
 547
 548     virtual Int_t NDigits();
 549     virtual void  Finish();    // Nothing yet ...
 550     virtual Int_t GetCathod()  {return fCathod;}
 551     virtual Int_t GetChamber() {return fChamber;}
 552
 553  public:
 554     Float_t fX; // reconstructed x
 555     Float_t fY; // reconstructed y
 556
 557  protected:
 558     TArrayI *fDigits;    // List of digits indexes for that cluster
 559     Int_t fNdigit;       // Number of digits indexes stored;
 560     Int_t fCathod;       // Number of the cathod to be used;
 561     Int_t fChamber;      // Number of the chamber to be used;
 562     Int_t fCurrentDigit; // Current Digit inside an iteration
 563
 564     ClassDef(AliRICHRecCluster,1)  //Cluster object for set:RICH
 565         };
 566 //___________________________________________
 567 #endif
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582