RICH/AliRICHChamber.h

   1 #ifndef ALIRICHCHAMBER_H
   2 #define ALIRICHCHAMBER_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /* $Id$ */
   8
   9 #include <TObjArray.h>
  10 #include <TRotMatrix.h>
  11
  12 #include "AliRICHTresholdMap.h"
  13 #include "AliSegmentation.h"
  14 #include "AliRICHGeometry.h"
  15 #include "AliRICHResponse.h"
  16
  17 class AliRICHClusterFinder;
  18
  19 typedef enum {kMip, kCerenkov} ResponseType;
  20
  21 class AliRICHChamber : public TObject
  22 {
  23  public:
  24
  25   Int_t                fIndexMap[50];   //indeces of tresholds
  26   AliRICHTresholdMap*  fTresh;          //map of tresholds
  27
  28  public:
  29     AliRICHChamber();
  30     AliRICHChamber(const AliRICHChamber & Chamber);
  31     ~AliRICHChamber(){}
  32 //
  33 // Set and get GEANT id
  34     Int_t   GetGid()         {return fGid;}
  35     void    SetGid(Int_t id) {fGid=id;}
  36 //
  37 // Initialisation and z-Position
  38     void    Init(Int_t id);
  39     // Set inner radius of sensitive volume
  40     void SetRInner(Float_t rmin) {frMin=rmin;}
  41 // Set outer radius of sensitive volum
  42     void SetROuter(Float_t rmax) {frMax=rmax;}
  43
  44 // Return inner radius of sensitive volume
  45     Float_t RInner()            {return frMin;}
  46 // Return outer radius of sensitive volum
  47     Float_t ROuter()            {return frMax;}
  48
  49     void    SetZPOS(Float_t p1) {fzPos=p1;}
  50     Float_t ZPosition()         {return fzPos;}
  51
  52 //
  53 //Transformation from Global to local coordinates, chamber-dependant
  54     void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]);
  55     void GlobaltoLocal(Float_t pos[3],Float_t localpos[3]);
  56
  57 //Generate pad dependent tresholds
  58
  59     void GenerateTresholds();
  60
  61
  62 //Setting chamber specific rotation matrices
  63
  64     void SetChamberTransform(Float_t Trans1,Float_t Trans2,Float_t Trans3,TRotMatrix *Matrix)
  65
  66         {
  67             fChamberMatrix=Matrix;
  68             fChamberTrans[0]=Trans1;
  69             fChamberTrans[1]=Trans2;
  70             fChamberTrans[2]=Trans3;
  71         }
  72
  73     TRotMatrix * GetRotMatrix() {return fChamberMatrix;}
  74
  75 //Configure geometry model
  76     void    GeometryModel(AliRICHGeometry* thisGeometry){
  77       fGeometry=thisGeometry;
  78     }
  79
  80
  81 // Configure response model
  82     void    ResponseModel(AliRICHResponse* thisResponse);
  83
  84     //
  85 // Configure segmentation model
  86     void    SetSegmentationModel(AliSegmentation* thisSegmentation) {
  87         fSegmentation = thisSegmentation;
  88     }
  89     void    SetReconstructionModel(AliRICHClusterFinder *thisReconstruction) {
  90         fReconstruction = thisReconstruction;
  91     }
  92
  93 //
  94 //  Get reference to response model
  95     AliRICHResponse* GetResponseModel();
  96 //
  97 //  Get reference to segmentation model
  98     AliSegmentation*  GetSegmentationModel() {
  99         return fSegmentation;
 100     }
 101
 102 //  Get reference to geometry model
 103     AliRICHGeometry*  GetGeometryModel() {
 104         return fGeometry;
 105     }
 106
 107
 108     AliSegmentation*  GetSegmentationModel(Int_t i) {
 109         return fSegmentation;
 110     }
 111
 112     //
 113     AliRICHClusterFinder* &GetReconstructionModel() {return fReconstruction;}
 114
 115 // Member function forwarding to the segmentation and response models
 116 //
 117 // Calculate pulse height from energy loss
 118     Float_t IntPH(Float_t eloss, Float_t yhit) {return fResponse->IntPH(eloss,yhit);}
 119     Float_t IntPH(Float_t yhit)              {return fResponse->IntPH(yhit);}
 120 //
 121 // Ask segmentation if signal should be generated
 122     Int_t   SigGenCond(Float_t x, Float_t y, Float_t z)
 123         {
 124             return fSegmentation->SigGenCond(x, y, z);
 125         }
 126
 127 // Ask segmentation sector
 128     Int_t   Sector(Float_t x, Float_t y)
 129         {
 130             return fSegmentation->Sector(x, y);
 131         }
 132
 133 //
 134 // Initialisation of segmentation for hit
 135     void   SigGenInit(Float_t x, Float_t y, Float_t z)
 136         {
 137             fSegmentation->SigGenInit(x, y, z) ;
 138         }
 139 // Configuration forwarding
 140 //
 141     void   SetSigmaIntegration(Float_t p)
 142         {
 143             fResponse->SetSigmaIntegration(p);
 144         }
 145     void   SetChargeSlope(Float_t p)
 146         {
 147             fResponse->SetChargeSlope(p);
 148         }
 149     void   SetChargeSpread(Float_t p1, Float_t p2)
 150         {
 151             fResponse->SetChargeSpread(p1,p2);
 152         }
 153     void   SetMaxAdc(Float_t p)
 154         {
 155             fResponse->SetMaxAdc(p);
 156         }
 157     void   SetSqrtKx3(Float_t p)
 158         {
 159             fResponse->SetSqrtKx3(p);
 160         }
 161     void   SetKx2(Float_t p)
 162         {
 163             fResponse->SetKx2(p);
 164         }
 165     void   SetKx4(Float_t p)
 166         {
 167             fResponse->SetKx4(p);
 168         }
 169     void   SetSqrtKy3(Float_t p)
 170         {
 171             fResponse->SetSqrtKy3(p);
 172         }
 173     void   SetKy2(Float_t p)
 174         {
 175             fResponse->SetKy2(p);
 176         }
 177     void   SetKy4(Float_t p)
 178         {
 179             fResponse->SetKy4(p);
 180         }
 181
 182     void   SetPitch(Float_t p)
 183         {
 184             fResponse->SetPitch(p);
 185         }
 186
 187     void   SetWireSag(Int_t p)
 188         {
 189             fResponse->SetWireSag(p);
 190         }
 191
 192     void   SetVoltage(Int_t p)
 193         {
 194             fResponse->SetVoltage(p);
 195         }
 196
 197     void   SetPadSize(Float_t p1, Float_t p2)
 198         {
 199             fSegmentation->SetPadSize(p1,p2);
 200         }
 201     void   SetGapThickness(Float_t thickness)
 202       {
 203         fGeometry->SetGapThickness(thickness);
 204       }
 205     void   SetProximityGapThickness(Float_t thickness)
 206       {
 207         fGeometry->SetProximityGapThickness(thickness);
 208       }
 209     void   SetQuartzLength(Float_t length)
 210       {
 211         fGeometry->SetQuartzLength(length);
 212       }
 213     void   SetQuartzWidth(Float_t width)
 214       {
 215         fGeometry->SetQuartzWidth(width);
 216       }
 217     void   SetQuartzThickness(Float_t thickness)
 218       {
 219         fGeometry->SetQuartzThickness(thickness);
 220       }
 221     void   SetOuterFreonLength(Float_t length)
 222       {
 223         fGeometry->SetOuterFreonLength(length);
 224       }
 225     void   SetOuterFreonWidth(Float_t width)
 226       {
 227         fGeometry->SetOuterFreonWidth(width);
 228       }
 229     void   SetInnerFreonLength(Float_t length)
 230       {
 231         fGeometry->SetInnerFreonLength(length);
 232       }
 233     void   SetInnerFreonWidth(Float_t width)
 234       {
 235         fGeometry->SetInnerFreonWidth(width);
 236       }
 237     void   SetFreonThickness(Float_t thickness)
 238       {
 239         fGeometry->SetFreonThickness(thickness);
 240       }
 241
 242     AliRICHChamber& operator=(const AliRICHChamber& rhs);
 243
 244 //
 245 // Cluster formation method
 246     void   DisIntegration(Float_t eloss, Float_t xhit, Float_t yhit, Int_t&x, Float_t newclust[6][500], ResponseType res);
 247  private:
 248 // GEANT volume if for sensitive volume of this
 249     Float_t frMin;                 // Minimum Chamber size
 250     Float_t frMax;                 // Maximum Chamber size
 251     Int_t   fGid;                  // Id tag
 252     Float_t fzPos;                 // z-position of this chamber
 253
 254     TRotMatrix *fChamberMatrix;          //Rotation matrices for each chamber
 255     Float_t fChamberTrans[3];            //Translaction vectors for each chamber
 256
 257     AliSegmentation               *fSegmentation;          //Segmentation model for each chamber
 258     AliRICHResponse               *fResponse;              //Response model for each chamber
 259     AliRICHGeometry               *fGeometry;              //Geometry model for each chamber
 260     AliRICHClusterFinder          *fReconstruction;        //Reconstruction model for each chamber
 261     ClassDef(AliRICHChamber,1)
 262 };
 263 #endif
 264
 265
 266
 267