Implementation of new ClusterFinder
[u/mrichter/AliRoot.git] / RICH / AliRICH.h
1 #ifndef AliRICH_h
2 #define AliRICH_h
3
4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  * See cxx source for full Copyright notice                               */
6
7 #include <TObjArray.h>
8 #include <TClonesArray.h>
9 #include <TLorentzVector.h>
10 #include <AliDetector.h>
11 #include <AliHit.h>
12 #include <AliDigit.h>
13
14 #include "AliRICHConst.h"
15 #include "AliRICHChamber.h"
16
17 #include "AliRICHDigit.h"
18 #include "AliRICHSDigit.h"
19 #include "AliRICHRawCluster.h"
20
21 //__________________AliRICHhit______________________________________________________________________
22 //__________________________________________________________________________________________________
23 //__________________________________________________________________________________________________
24 class AliRICHhit : public AliHit
25 {
26 public:
27   inline   AliRICHhit();
28   inline   AliRICHhit(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *hits);
29   inline   AliRICHhit(Int_t track,Int_t iPID,Int_t iChamber,TLorentzVector x4,Float_t eloss);
30   virtual ~AliRICHhit()         {;}
31     
32   Int_t   C()                   {return fChamber;}
33   Int_t   Chamber()             {return fChamber;}
34   Int_t   Pid()                 {return fPid;}    
35   Int_t   Particle()            {return fPid;}
36   Float_t Theta()               {return fTheta;}
37   Float_t Phi()                 {return fPhi;}
38   Float_t Tlength()             {return fTlength;}
39   Float_t Eloss()               {return fEloss;}
40   Float_t Loss()                {return fLoss;}
41   Float_t PHfirst()             {return fPHfirst;}
42   Float_t PHlast()              {return fPHlast;}
43   Float_t MomX()                {return fMomX;}
44   Float_t MomY()                {return fMomY;}
45   Float_t MomZ()                {return fMomZ;}
46   Float_t CerenkovAngle()       {return fCerenkovAngle;}
47   Float_t MomFreoX()            {return fMomFreoX;}
48   Float_t MomFreoY()            {return fMomFreoY;}
49   Float_t MomFreoZ()            {return fMomFreoZ;}
50   void    Print(Option_t *option="")const;      //virtual
51 protected:
52   Int_t     fChamber;                      //chamber number
53   Int_t     fPid;                          //particle code
54   Float_t   fTheta,fPhi ;                  //incident theta phi angles in degrees
55   Float_t   fTlength;                      //track length inside the chamber
56   Float_t   fEloss;                        //ionisation energy loss in gas
57   Float_t   fPHfirst;                      //first padhit
58   Float_t   fPHlast;                       //last padhit
59   Float_t   fLoss;                         // did it hit the freon?
60   Float_t   fMomX,fMomY,fMomZ;             //momentum at photochatode entry point
61   Float_t   fNPads;                        // Pads hit
62   Float_t   fCerenkovAngle;                // Dummy cerenkov angle
63   Float_t   fMomFreoX,fMomFreoY,fMomFreoZ; //momentum at freon entry point
64   ClassDef(AliRICHhit,1)                   //RICH hit class
65 };//class AliRICHhit
66
67   //__________________________________________________________________________________________________
68 AliRICHhit::AliRICHhit()
69            :AliHit() 
70 {//default ctor  
71   fChamber=fPid=kBad;
72   fTheta=fPhi=fTlength=fEloss=fPHfirst=fPHlast=fLoss=kBad;
73   fMomX=fMomY=fMomZ=fNPads=fCerenkovAngle=fMomFreoX=fMomFreoY=fMomFreoZ=kBad;
74 }
75 //__________________________________________________________________________________________________
76 AliRICHhit::AliRICHhit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hit):
77             AliHit(shunt, track)
78 {//ctor
79   fChamber=vol[0];
80   fPid=(Int_t)hit[0];
81   fX=hit[1];fY=hit[2];fZ=hit[3];
82   fTheta=hit[4];fPhi=hit[5];
83   fTlength=hit[6];
84   fEloss=hit[7];
85   fPHfirst=(Int_t)hit[8];
86   fPHlast=(Int_t)hit[9];
87   fLoss=hit[13];
88   fMomX=hit[14];fMomY=hit[15];fMomZ=hit[16];
89   fNPads=hit[17];
90   fCerenkovAngle=hit[18];
91   fMomFreoX=hit[19];fMomFreoY=hit[20];fMomFreoZ=hit[21];
92 }
93 //__________________________________________________________________________________________________
94 AliRICHhit::AliRICHhit(Int_t track,Int_t iPID,Int_t iChamber,TLorentzVector x4,Float_t eloss):
95             AliHit(0, track)
96 {//ctor
97   fChamber=iChamber;
98   fPid=iPID;
99   fX=x4.X();fY=x4.Y();fZ=x4.Z();
100   fEloss=eloss;
101 }
102
103 //__________________AliRICHCerenkov_________________________________________________________________
104 //__________________________________________________________________________________________________
105 //__________________________________________________________________________________________________
106 class AliRICHCerenkov: public AliHit 
107 {
108 public:
109   inline   AliRICHCerenkov();
110   inline   AliRICHCerenkov(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *Cerenkovs);
111   virtual ~AliRICHCerenkov() {;}
112 public:
113   Int_t     fChamber;          //chamber number
114   Float_t   fTheta,fPhi;       //incident theta phi angles in degrees      
115   Float_t   fTlength;          //track length inside the chamber
116   Float_t   fEloss;            //ionisation energy loss in gas
117   Int_t     fPHfirst;          //first padhit
118   Int_t     fPHlast;           //last padhit
119   Int_t     fCMother;          //index of mother particle
120   Float_t   fLoss;             //nature of particle loss
121   Float_t   fIndex;            //index of photon
122   Float_t   fProduction;       //point of production
123   Float_t   fMomX,fMomY,fMomZ; //local Momentum
124   Float_t   fNPads;           // Pads hit
125   Float_t   fCerenkovAngle;   // Cerenkov Angle
126     
127   ClassDef(AliRICHCerenkov,1)  //RICH cerenkov class
128 };//class AliRICHCerenkov
129
130 //__________________________________________________________________________________________________
131 AliRICHCerenkov::AliRICHCerenkov()
132 {//ctor
133     fChamber=kBad;
134     fX=fY=fZ=fTheta=fPhi=fTlength=fEloss=kBad;
135     fPHfirst=fPHlast=fCMother=kBad;
136     fLoss=fIndex=fProduction=fMomX=fMomY=fMomZ=fNPads=fCerenkovAngle=kBad;
137 }
138 //__________________________________________________________________________________________________
139 AliRICHCerenkov::AliRICHCerenkov(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
140                 :AliHit(shunt, track)
141 {//ctor
142     fChamber=vol[0];
143     fX=hits[1];fY=hits[2];fZ=hits[3];
144     fTheta=hits[4];fPhi=hits[5];
145     fTlength=hits[6];
146     fEloss=hits[7];
147     fPHfirst=(Int_t)hits[8];fPHlast=(Int_t)hits[9];
148     fCMother=Int_t(hits[10]);
149     fIndex = hits[11];
150     fProduction = hits[12];  
151     fLoss=hits[13];
152     fMomX=hits[14];fMomY=hits[15];fMomZ=hits[16];
153     fNPads=hits[17];
154     fCerenkovAngle=hits[18];
155 }
156
157 //__________________AliRICHdigit____________________________________________________________________
158 //__________________________________________________________________________________________________
159 //__________________________________________________________________________________________________
160 class AliRICHdigit :public AliDigit
161 {
162 public:
163            AliRICHdigit() {fPadX=fPadY=fChamber=fTracks[0]=fTracks[1]=fTracks[2]=kBad;fQdc=kBad;}
164   inline   AliRICHdigit(Int_t iC,Int_t iX,Int_t iY,Double_t iQdc,Int_t iT1,Int_t iT2,Int_t iT3);
165   virtual ~AliRICHdigit() {;}  
166   inline   Int_t    Compare(const TObject *pObj) const;                               //virtual
167            Bool_t   IsSortable()                                  const{return kTRUE;}//virtual
168            Int_t    C()                                           const{return fChamber;}
169            Int_t    X()                                           const{return fPadX;}
170            Int_t    Y()                                           const{return fPadY;}
171            Int_t    Id()                                          const{return fChamber*1000000+fPadX*1000+fPadY;}
172            Double_t Q()                                           const{return fQdc;}
173            Int_t    T(Int_t i)                                    const{return fTracks[i];}
174            void  Print(Option_t *option)const;                                       //virtual
175 protected:
176   Int_t    fChamber;  //module number 
177   Int_t    fPadX;     //pad number along X
178   Int_t    fPadY;     //pad number along Y
179   Double_t fQdc;      //QDC value, fractions are permitted for summable procedure
180   ClassDef(AliRICHdigit,1) //RICH digit class       
181 };//class AliRICHdigit
182 //__________________________________________________________________________________________________
183 AliRICHdigit::AliRICHdigit(Int_t iC,Int_t iX,Int_t iY,Double_t q,Int_t iT0,Int_t iT1,Int_t iT2)
184 {
185   fChamber=iC;fPadX=iX;fPadY=iY;fQdc=q;
186   fTracks[0]=iT0;fTracks[1]=iT1;fTracks[2]=iT2;
187 }
188 //__________________________________________________________________________________________________
189 Int_t AliRICHdigit::Compare(const TObject *pObj)const
190 {
191   if(Id()==((AliRICHdigit*)pObj)->Id()) 
192     return 0;
193   else if(Id()>((AliRICHdigit*)pObj)->Id()) 
194     return 1;
195   else
196     return -1;
197
198 //__________________AliRICHcluster__________________________________________________________________
199 //__________________________________________________________________________________________________
200
201 enum ClusterStatus {kOK,kEdge,kShape,kSize,kRaw};
202
203 //__________________________________________________________________________________________________
204 class AliRICHcluster :public TObject
205 {
206 public:
207            AliRICHcluster()                                     {fSize=fQdc=0;fStatus=fChamber=fDimXY=kBad;fX=fY=kBad;fDigits=0;}
208   virtual ~AliRICHcluster() {delete fDigits;}  
209            Int_t    Size()                                      const{return fSize;}
210            Int_t    DimXY()                                     const{return fDimXY;}
211            Int_t    Chamber()                                   const{return fChamber/10;}
212            Int_t    Sector()                                    const{return fChamber-(fChamber/10)*10;} 
213            Int_t    Q()                                         const{return fQdc;}
214            Double_t X()                                         const{return fX;}
215            Double_t Y()                                         const{return fY;}
216            Int_t    Status()                                    const{return fStatus;}
217            void  SetStatus(Int_t status)                             {fStatus=status;}
218            void  Print(Option_t *option)const;                                                            //virtual
219    inline  void  AddDigit(AliRICHdigit *pDig);
220    inline  void  CoG();
221    TObjArray* Digits() const{return fDigits;}
222 protected:
223   Int_t         fSize;        //how many digits belong to this cluster    
224   Int_t         fDimXY;       //100*xdim+ydim box containing the cluster
225   Int_t         fQdc;         //QDC value
226   Int_t         fChamber;     //10*module number+sector number 
227   Double_t      fX;           //local x postion 
228   Double_t      fY;           //local y postion  
229   Int_t         fStatus;      //flag to mark the quality of the cluster   
230   TObjArray    *fDigits;      //! list of digits forming this cluster
231   ClassDef(AliRICHcluster,1)  //RICH digit class       
232 };//class AliRICHcluster
233 //__________________________________________________________________________________________________
234 void AliRICHcluster::AddDigit(AliRICHdigit *pDig)
235 {  
236   if(!fDigits) fDigits = new TObjArray;
237   fQdc+=(Int_t)pDig->Q(); fDigits->Add(pDig);
238   fSize++;
239 }
240 //__________________________________________________________________________________________________
241 void AliRICHcluster::CoG()
242 {
243    Int_t xmin=999,ymin=999;
244    Int_t xmax=0,ymax=0;   
245    Double_t x,y;      
246    for(Int_t iDig=0;iDig<Size();iDig++) {
247      AliRICHdigit *pDig=(AliRICHdigit*)fDigits->At(iDig);
248      Int_t padX = pDig->X();Int_t padY = pDig->Y();Double_t q=pDig->Q();
249      AliRICHParam::Pad2Loc(padX,padY,x,y);
250      fX += x*q;fY +=y*q;
251      if(padX<xmin) xmin = padX;if(padX>xmax) xmax = padX;if(padY<ymin) ymin = padY;if(padY>ymax) ymax = padY;//find box edges containing cluster
252    }
253    fX/=fQdc;fY/=fQdc;
254    fDimXY = 100*(xmax-xmin+1)+ymax-ymin+1;
255 }
256 //__________________AliRICH_________________________________________________________________________
257 //__________________________________________________________________________________________________
258 //__________________________________________________________________________________________________
259 class AliRICHParam;
260 class AliRICHSDigit;
261
262 class AliRICH : public AliDetector 
263 {
264 public:
265             AliRICH();                                            
266             AliRICH(const char *name, const char *title);         
267             AliRICH(const AliRICH& RICH):AliDetector(RICH) {;}   
268   virtual  ~AliRICH();                                            
269           
270   AliRICH&  operator=(const AliRICH&)                 {return *this;}
271   virtual Int_t   IsVersion()                                            const =0;            
272           void    Hits2SDigits();                                                                                 //virtual
273           void    SDigits2Digits();                                                                               //virtual
274           void    Digits2Reco();                                                                                  //virtual
275   
276   inline  void    CreateHits();    
277   inline  void    CreateSDigits();  
278   inline  void    CreateDigits();  
279   inline  void    CreateClusters();  
280   inline  void    AddHit(Int_t track, Int_t *vol, Float_t *hits);                                                 //virtual
281   inline  void    AddSDigit(Int_t iC,Int_t iX,Int_t iY,Double_t q,Int_t iT0,Int_t iT1=kBad,Int_t iT2=kBad);
282   inline  void    AddDigit (Int_t iC,Int_t iX,Int_t iY,Int_t iQ,Int_t iT0,Int_t iT1=kBad,Int_t iT2=kBad);     
283   inline  void    AddCluster(AliRICHcluster clus);
284           void    ResetHits()     {AliDetector::ResetHits();fNcerenkovs=0;if(fCerenkovs)fCerenkovs->Clear();fNspecials=0;if(fSpecials)fSpecials->Clear();}  //virtual
285           void    ResetSDigits()  {fNsdigits=0;  if(fSdigits)  fSdigits ->Clear();}                                 
286           void    ResetDigits()   {if(fDigitsNew)for(int i=0;i<kNCH;i++){fDigitsNew->At(i)->Clear();fNdigitsNew[i]=0;}}
287           void    ResetClusters() {if(fClusters) for(int i=0;i<kNCH;i++){fClusters ->At(i)->Clear();fNclusters[i]=0;}}
288                   //Hits provided by AliDetector
289   TClonesArray*   SDigits()             const{return fSdigits;}
290   TClonesArray*   Digits(Int_t iC)      const{if(fDigitsNew) return (TClonesArray *)fDigitsNew->At(iC-1);else return 0;}
291   TClonesArray*   Clusters(Int_t iC)    const{if(fClusters)  return (TClonesArray *)fClusters->At(iC-1);else return 0;}
292           
293   AliRICHChamber* C(Int_t iC)           const{return (AliRICHChamber*)fChambers->At(iC-1);}
294   AliRICHParam*   Param()               const{return fpParam;}
295   
296   //  AliRICHhit*     FirstHit(Int_t iTrkN)      {return (AliRICHhit*)AliDetector::FirstHit(iTrkN);}                   //virtual
297   //  AliRICHhit*     NextHit()                  {return (AliRICHhit*)AliDetector::NextHit();}                         //virtual 
298   
299           void    CreateChambers();         
300           void    CreateMaterials(); //virtual
301   virtual void    BuildGeometry();   //virtual
302   virtual void    CreateGeometry();  //virtual
303           Float_t AbsoCH4(Float_t x);
304           Float_t Fresnel(Float_t ene,Float_t pdoti, Bool_t pola);
305   
306   virtual void    StepManager()=0;
307           void    GenerateFeedbacks(Int_t iChamber,Float_t eloss);
308           void    Print(Option_t *option)const;//virtual
309           void    MakeBranch(Option_t *opt=" ");
310           void    SetTreeAddress();//virtual
311 // OLD staff OLD staff    
312   inline  void    AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs);
313   inline  void    AddSpecialOld(Int_t *);      
314   inline  void    AddDigitOld(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits);          
315   inline  void    AddClusterOld(Int_t iChamber, const AliRICHRawCluster& cluster);
316           
317   inline  void    CreateCerenkovsOld();  
318   inline  void    CreateSpecialsOld();   
319   inline  void    CreateDigitsOld();    
320   inline  void    CreateRawClustersOld();  
321           void    ResetDigitsOld()  {if(fDchambers)  for(int i=0;i<kNCH;i++){fDchambers->At(i)->Clear();fNdch[i]=0;}}   //virtual
322           void    ResetSpecialsOld(){fNspecials=0; if(fSpecials) fSpecials->Clear();}   
323           void    ResetRawClusters(){if(fRawClusters)for(int i=0;i<kNCH;i++){fRawClusters->At(i)->Clear();fNrawch[i]=0;}}
324   
325   TClonesArray*   DigitsOld(Int_t iC)   const{if(fDchambers) return (TClonesArray *)fDchambers->At(iC-1);else return 0;}
326   TClonesArray*   ClustersOld(Int_t iC) const{if(fRawClusters)return (TClonesArray *)fRawClusters->At(iC-1);else return 0;}
327   TClonesArray*   Specials()            const{return fSpecials;}
328   TClonesArray*   Cerenkovs()           const{return fCerenkovs;}
329   
330   
331             
332   AliRICHChamber& Chamber(Int_t id)      {return *((AliRICHChamber *) (*fChambers)[id]);}  
333   TObjArray     *Dchambers()                const{return fDchambers;}
334   Int_t         *Ndch()                          {return fNdch;}
335   TClonesArray  *DigitsAddress(Int_t id)    const{return ((TClonesArray *) (*fDchambers)[id]);}
336   TClonesArray  *RawClustAddress(Int_t id)  const{return ((TClonesArray *) (*fRawClusters)[id]);}    
337 //          Int_t DistancetoPrimitive(Int_t /*px*/, Int_t /*py*/)      {return 9999;}
338     
339 protected:  
340   AliRICHParam         *fpParam;             //main RICH parametrization     
341   TObjArray            *fChambers;           //list of RICH chambers
342                 //fHits and fDigits belong to AliDetector
343   TClonesArray         *fSdigits;            //! List of sdigits  
344   Int_t                 fNsdigits;           //Current number of sdigits
345   TObjArray            *fDigitsNew;          //! Each chamber holds it's one lists of digits
346   Int_t                 fNdigitsNew[kNCH];   //Array of current numbers of digits
347   TObjArray            *fClusters;           //! Each chamber holds it's one lists of clusters 
348   Int_t                 fNclusters[kNCH];    //Array of current numbers of raw clusters
349
350   TClonesArray         *fCerenkovs;          //! ??? List of cerenkovs
351   Int_t                 fNcerenkovs;         //??? Current number of cerenkovs
352   TClonesArray         *fSpecials;           //! ??? List of specials
353   Int_t                 fNspecials;          //??? Current number of specials  
354   TObjArray            *fDchambers;          //! Array of lists of digits  
355   Int_t                 fNdch[kNCH];         //Array of current numbers of digits
356   TObjArray            *fRawClusters;        //! Array of lists of raw clusters 
357   Int_t                 fNrawch[kNCH];       //Array of current numbers of raw clusters
358   Int_t fCkovNumber;                         // Number of Cerenkov photons
359   Int_t fFreonProd;                          // Cerenkovs produced in freon
360   Int_t fFeedbacks;                          // Number of feedback photons
361     
362   ClassDef(AliRICH,3)                        //Main RICH class 
363 };//class AliRICH  
364 //__________________________________________________________________________________________________
365 void AliRICH::AddHit(Int_t track, Int_t *vol, Float_t *hits)
366 {//Adds the current hit to the RICH hits list
367   TClonesArray &tmp=*fHits;
368   new(tmp[fNhits++])AliRICHhit(fIshunt,track,vol,hits);
369 }
370 //__________________________________________________________________________________________________
371 void AliRICH::AddSDigit(Int_t iC,Int_t iX,Int_t iY,Double_t q,Int_t iT0,Int_t iT1,Int_t iT2)
372 {//Adds the current Sdigit to the RICH list of Sdigits   
373   TClonesArray &tmp=*fSdigits;
374   new(tmp[fNsdigits++])AliRICHdigit(iC,iX,iY,q,iT0,iT1,iT2);
375
376 //__________________________________________________________________________________________________
377 void AliRICH::AddDigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1,Int_t iT2)
378 {//Adds the current digit to the corresponding RICH list of digits (individual list per chamber)
379   TClonesArray &tmp=*((TClonesArray*)fDigitsNew->At(iC-1));
380   new(tmp[fNdigitsNew[iC-1]++]) AliRICHdigit(iC,iX,iY,iAdc,iT0,iT1,iT2);
381 }
382 //__________________________________________________________________________________________________
383 void AliRICH::AddCluster(AliRICHcluster clus)
384 {//Adds the current cluster to the corresponding RICH list of clusters (individual list per chamber)
385   TClonesArray &tmp=*((TClonesArray*)fClusters->At(clus.Chamber()-1));
386   new(tmp[fNclusters[clus.Chamber()-1]++]) AliRICHcluster(clus);
387 }
388 //__________________________________________________________________________________________________
389 void AliRICH::CreateHits()
390 {
391   if(fHits) return;
392   if(GetDebug())Info("CreateHits","creating hits container.");
393   fHits=new TClonesArray("AliRICHhit",10000);   fNhits=0;
394 }
395 //__________________________________________________________________________________________________
396 void AliRICH::CreateSDigits()
397 {
398   if(fSdigits) return;
399   if(GetDebug())Info("CreateSDigits","creating sdigits container.");
400   fSdigits=new TClonesArray("AliRICHdigit",10000); fNsdigits=0;
401 }
402 //__________________________________________________________________________________________________
403 void AliRICH::CreateDigits()
404 {
405   if(fDigitsNew) return;
406   if(GetDebug())Info("CreateDigits","creating digits containers.");
407   fDigitsNew = new TObjArray(kNCH);  
408   for(Int_t i=0;i<kNCH;i++) {fDigitsNew->AddAt(new TClonesArray("AliRICHdigit",10000), i); fNdigitsNew[i]=0;}
409 }
410 //__________________________________________________________________________________________________
411 void AliRICH::CreateClusters()
412 {
413   if(fClusters) return;
414   if(GetDebug())Info("CreateClusters","creating clusters containers.");
415   fClusters = new TObjArray(kNCH);  
416   for(Int_t i=0;i<kNCH;i++) {fClusters->AddAt(new TClonesArray("AliRICHcluster",10000), i); fNclusters[i]=0;}
417 }
418
419
420
421 //__________________________________________________________________________________________________
422 void AliRICH::CreateCerenkovsOld()
423 {
424   if(fCerenkovs) return;
425   if(GetDebug())Info("CreateCerenkovs","creating cerenkovs container.");
426   fCerenkovs=new TClonesArray("AliRICHCerenkov",10000);   fNcerenkovs=0;
427 }
428 //__________________________________________________________________________________________________
429 void AliRICH::CreateSpecialsOld()
430 {
431   if(fSpecials) return;
432   if(GetDebug())Info("CreateSpecialsOld","creating SDigits special container.");
433   fSpecials=new TClonesArray("AliRICHSDigit",100000); fNspecials=0;
434 }
435 //__________________________________________________________________________________________________
436 void AliRICH::CreateDigitsOld()
437 {
438   if(fDchambers) return;
439   if(GetDebug())Info("CreateDigitsOld","creating digits containers.");
440   fDchambers = new TObjArray(kNCH);  
441   for(Int_t i=0;i<kNCH;i++) fDchambers->AddAt(new TClonesArray("AliRICHDigit",10000), i); 
442 }
443 //__________________________________________________________________________________________________
444 void AliRICH::CreateRawClustersOld()
445 {
446   if(fRawClusters) return;
447   if(GetDebug())Info("CreateClustersOld","creating clusters containers.");
448   fRawClusters = new TObjArray(kNCH);
449   for(Int_t i=0; i<kNCH ;i++) fRawClusters->AddAt(new TClonesArray("AliRICHRawCluster",10000), i); 
450 }
451 //__________________________________________________________________________________________________
452 void AliRICH::AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs)
453 {//Adds the current RICH cerenkov hit to the Cerenkovs list   
454   TClonesArray &tmp=*fCerenkovs;
455   new(tmp[fNcerenkovs++]) AliRICHCerenkov(fIshunt,track,vol,cerenkovs);
456 }
457 //__________________________________________________________________________________________________
458 void AliRICH::AddSpecialOld(Int_t *aiSDigit)
459 {// Adds the current Sdigit to the RICH list of Specials
460   TClonesArray &lSDigits = *fSpecials;
461   new(lSDigits[fNspecials++]) AliRICHSDigit(aiSDigit);
462 }
463 //__________________________________________________________________________________________________
464 void AliRICH::AddDigitOld(Int_t iChamber, Int_t *tracks, Int_t *charges, Int_t *digits)
465 {// Adds the current digit to the RICH list of S digits
466    TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(iChamber-1));
467    new(ldigits[fNdch[iChamber-1]++]) AliRICHDigit(tracks,charges,digits);
468 }
469 //__________________________________________________________________________________________________
470 void AliRICH::AddClusterOld(Int_t iChamber, const AliRICHRawCluster& c)
471 {// Add a RICH raw cluster to the list   
472   TClonesArray &tmp= *((TClonesArray*)fRawClusters->At(iChamber-1));
473   new(tmp[fNrawch[iChamber-1]++]) AliRICHRawCluster(c);
474 }
475 //__________________________________________________________________________________________________
476 #endif//#ifndef AliRICH_h