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