PHOS/AliPHOS.h

   1 #ifndef PHOS_H
   2 #define PHOS_H
   3 ////////////////////////////////////////////////
   4 //  Manager and hits classes for set:PHOS     //
   5 ////////////////////////////////////////////////
   6
   7 // --- ROOT system ---
   8 #include <TArray.h>
   9 #include <TRandom.h>
  10 #include <TH2.h>
  11 #include <TVector3.h>
  12
  13 // --- galice header files ---
  14 #include "AliDetector.h"
  15 #include "AliHit.h"
  16 #include "AliRun.h"
  17
  18 class AliPHOSgamma : public TObject {
  19
  20   public:
  21                         virtual ~AliPHOSgamma(void) {}
  22                         AliPHOSgamma(void) {}
  23                         AliPHOSgamma(const AliPHOSgamma &g) { *this=g; }
  24                         AliPHOSgamma(Float_t X,  Float_t Y,  Float_t E,
  25                                      Float_t Px, Float_t Py, Float_t Pz,
  26                                      Int_t Ipart) :
  27                           fX(X),   fY(Y),   fE(E),
  28                           fPx(Px), fPy(Py), fPz(Pz),
  29                           fIpart(Ipart)
  30                         {}
  31
  32     Float_t             fX;             // cm. x-coordinate (in beam direction)
  33     Float_t             fY;             // cm. y-coordinate (around beam)
  34
  35     Float_t             fE;             // GeV. energy
  36
  37     Float_t             fPx;            // GeV. Gamma momentum Px
  38     Float_t             fPy;            // GeV. Gamma momentum Py
  39     Float_t             fPz;            // GeV. Gamma momentum Pz
  40
  41     Int_t               fIpart;         // Current particle number (GEANT particle code)
  42
  43     void                Print(Option_t *options=NULL);
  44     AliPHOSgamma       &operator=(const AliPHOSgamma &g);
  45
  46  private:
  47
  48     ClassDef(AliPHOSgamma,1)            // Gamma particle in PHOS cradle
  49 };
  50
  51 //______________________________________________________________________________
  52
  53 class AliPHOShit : public AliHit {
  54
  55 public:
  56   Int_t     fVolume[5];  //array of volumes
  57   Float_t   fELOS;       //ELOS
  58
  59 public:
  60   AliPHOShit() {}
  61   AliPHOShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
  62   virtual ~AliPHOShit() {}
  63
  64   ClassDef(AliPHOShit,1)  //Hits object for set:PHOS
  65 };
  66
  67 //______________________________________________________________________________
  68
  69
  70 class AliPHOSCradle : public TObject {
  71
  72   public:
  73
  74     virtual            ~AliPHOSCradle(void);
  75                         AliPHOSCradle(void);
  76                         AliPHOSCradle(int   Geometry           ,
  77                                       float CrystalSideSize    ,
  78                                       float CrystalLength      ,
  79                                       float WrapThickness      ,
  80                                       float AirThickness       ,
  81                                       float PIN_SideSize       ,
  82                                       float PIN_Length         ,
  83                                       float Radius             ,
  84                                       float CPV_Thickness      ,
  85                                       float CPV_PHOS_Distance  ,
  86                                       int   Nz                 ,
  87                                       int   Nphi               ,
  88                                       float Angle );
  89
  90     void                AddCPVHit(float x, float y);
  91
  92     Float_t             GetCrystalSideSize     (void) const {return fCrystalSideSize;}
  93     Float_t             GetCellSideSize        (void) const {return fCrystalSideSize+2*fWrapThickness+2*fAirThickness;}
  94     Float_t             GetCrystalLength       (void) const {return fCrystalLength;}
  95     Float_t             GetWrapThickness       (void) const {return fWrapThickness;}
  96     Float_t             GetAirThickness        (void) const {return fAirThickness;}
  97     Float_t             GetPIN_SideSize        (void) const {return fPIN_SideSize;}
  98     Float_t             GetPIN_Length          (void) const {return fPIN_Length;}
  99     Float_t             GetRadius              (void) const {return fRadius;}
 100     Float_t             GetCPV_PHOS_Distance   (void) const {return fCPV_PHOS_Distance;}
 101     Float_t             GetCPV_Thikness        (void) const {return fCPV_Thickness;}
 102     Int_t               GetNz                  (void) const {return fNz;}
 103     Int_t               GetNphi                (void) const {return fNphi;}
 104     Float_t             GetPhi                 (void) const {return fPhi;}
 105
 106     void                Clear(Option_t *opt="");                            // Clear all data.
 107     void                Print(Option_t *opt="");
 108     void                Distortion(const TH2F *Noise=NULL, const TH2F *Stochastic=NULL, const TH2F *Calibration=NULL);
 109     TH2F               *CreateHistForDistortion(const char *name, const char *title, Int_t Nx, Int_t Ny,
 110                                                  Float_t MU_mu, Float_t MU_sigma, Float_t SIGMA_mu, Float_t SIGMA_sigma);
 111     Float_t             GetDistortedValue(const TH2F *h, UInt_t n);
 112
 113     void                Reconstruction(Float_t signal_step, UInt_t min_signal_reject);
 114
 115     void                GetXY(const TVector3 &p,const TVector3 &v,float R,float &x,float &y,float &l) const;
 116
 117     TObjArray          &GetGammasReconstructed (void)       {return fGammasReconstructed;}
 118     TObjArray          &GetParticles           (void)       {return fParticles;}
 119
 120     TH2F                fCellEnergy;                            // GeV. Energy in cells
 121     TH2S                fChargedTracksInPIN;                    // amount. hits in PIN
 122
 123     TArrayF             fCPV_hitsX;                             // cm. X-hits in CPV detector. (0 - cradle center)
 124     TArrayF             fCPV_hitsY;                             // cm. Y-hits in CPV detector. (0 - cradle center)
 125
 126   private:
 127
 128     Int_t               fGeometry;                              // Geometry type: 1 or 2
 129     Float_t             fCrystalSideSize;                       // cm.
 130     Float_t             fCrystalLength;                         // cm.
 131     Float_t             fWrapThickness;                         // cm.
 132     Float_t             fAirThickness;                          // cm.
 133     Float_t             fPIN_SideSize;                          // cm.
 134     Float_t             fPIN_Length;                            // cm.
 135
 136     Float_t             fRadius;                                // cm. Distance to PHOS
 137
 138     Float_t             fCPV_PHOS_Distance;                     // cm. Distance from CPV to PHOS.
 139     Float_t             fCPV_Thickness;                         // cm. CPV thikness.
 140
 141     Int_t               fNz;                                    // Cells amount in beam direction
 142     Int_t               fNphi;                                  // Cells amount around beam
 143
 144     Float_t             fPhi;                                   // degree. Position of CRADLE center
 145
 146     TObjArray           fGammasReconstructed;                   // List of reconstructed gammas
 147     TObjArray           fParticles;                             // List of particles in the direction of this cradle
 148
 149     TRandom             r;                                      //! Random number class, do not stream
 150
 151 //  friend class AliPHOS;
 152
 153     ClassDef(AliPHOSCradle,1)   // PHOS cradle
 154 };
 155
 156 class AliPHOS : public AliDetector {
 157
 158  public:
 159
 160     enum {CradlesBranch_Bit=1};
 161
 162                         AliPHOS();
 163                         AliPHOS(const char *name, const char *title);
 164   virtual              ~AliPHOS();
 165   virtual void          AddHit(Int_t, Int_t*, Float_t*);
 166   virtual void          BuildGeometry();
 167   virtual void          CreateGeometry() {}
 168   virtual void          CreateMaterials();
 169   Int_t                 DistancetoPrimitive(Int_t px, Int_t py);
 170   void                  FinishEvent(void);
 171
 172   virtual void          Init();
 173   virtual Int_t         IsVersion() const =0;
 174   void                  MakeBranch(Option_t *option);
 175   void                  SetTreeAddress(void);
 176   void                  FinishRun(void);
 177   void                  ResetDigits(void);
 178   void                  Print(Option_t *opt="");
 179   AliPHOSCradle        *GetCradleOfTheParticle(const TVector3 &p,const TVector3 &v) const;
 180   AliPHOSCradle        &GetCradle(int n) {return *(AliPHOSCradle*)fCradles->operator[](n);}
 181   //  AliPHOSCradle        &GetCradle(int n) {return *((AliPHOSCradle*) (*fCradles)[n]) ;}
 182   void                  Reconstruction(Float_t signal_step, UInt_t min_signal_reject);
 183   virtual void          SetFlags(Float_t p1,Float_t p2=0,Float_t p3=0,Float_t p4=0,
 184                                Float_t p5=0,Float_t p6=0,Float_t p7=0,Float_t p8=0,Float_t p9=0);
 185   virtual void          SetCell(Float_t p1,Float_t p2=0,Float_t p3=0,Float_t p4=0,
 186                                Float_t p5=0,Float_t p6=0,Float_t p7=0,Float_t p8=0,Float_t p9=0);
 187   virtual void          SetRadius(Float_t radius);
 188   virtual void          SetCradleSize(Int_t nz, Int_t nphi, Int_t ncradles);
 189   virtual void          SetCradleA(Float_t angle);
 190   virtual void          SetCPV(Float_t p1,Float_t p2=0,Float_t p3=0,Float_t p4=0,
 191                                Float_t p5=0,Float_t p6=0,Float_t p7=0,Float_t p8=0,Float_t p9=0);
 192   virtual void          SetExtra(Float_t p1,Float_t p2=0,Float_t p3=0,Float_t p4=0,
 193                                Float_t p5=0,Float_t p6=0,Float_t p7=0,Float_t p8=0,Float_t p9=0);
 194   virtual void          SetTextolitWall(Float_t dx, Float_t dy, Float_t dz);
 195   virtual void          SetInnerAir(Float_t dx, Float_t dy, Float_t dz);
 196   virtual void          SetFoam(Float_t dx, Float_t dy, Float_t dz, Float_t dr);
 197   virtual void          StepManager()=0;
 198   virtual void          DefPars();
 199   virtual void          AddPHOSCradles();
 200
 201
 202
 203   virtual Int_t GetPHOS_IDTMED_PbWO4         (void){return gAlice->Idtmed()[700-1];}
 204   virtual Int_t GetPHOS_IDTMED_CPV           (void){return gAlice->Idtmed()[701-1];}
 205   virtual Int_t GetPHOS_IDTMED_Al            (void){return gAlice->Idtmed()[702-1];}
 206   virtual Int_t GetPHOS_IDTMED_Tyvek         (void){return gAlice->Idtmed()[703-1];}
 207   virtual Int_t GetPHOS_IDTMED_PIN           (void){return gAlice->Idtmed()[706-1];}
 208   virtual Int_t GetPHOS_IDTMED_AIR           (void){return gAlice->Idtmed()[799-1];}
 209
 210
 211   virtual Int_t   &GetPHOS_Ndiv_magic    (void) {return PHOS_Ndiv_magic;}
 212   virtual Float_t  GetCrystalSideSize    (void) const {return PHOScell[0]; }
 213   virtual Float_t  GetCrystalLength      (void) const {return PHOScell[1]; }
 214   virtual Float_t  GetWrapThickness      (void) const {return PHOScell[2]; }
 215   virtual Float_t  GetAirThickness       (void) const {return PHOScell[3]; }
 216   virtual Float_t  GetPIN_SideSize       (void) const {return PHOScell[4]; }
 217   virtual Float_t  GetPIN_Length         (void) const {return PHOScell[5]; }
 218   virtual Float_t  GetRadius             (void) const {return PHOSradius;  }
 219   virtual Float_t  GetCPV_Thickness      (void) const {return PHOSCPV[0];  }
 220   virtual Float_t  GetCPV_PHOS_Distance  (void) const {return PHOSCPV[1];  }
 221   virtual Int_t    GetNz                 (void) const {return PHOSsize[0]; }
 222   virtual Int_t    GetNphi               (void) const {return PHOSsize[1]; }
 223   virtual Int_t    GetCradlesAmount      (void) const {return PHOSsize[2]; }
 224   virtual Float_t  GetAngleBetweenCradles(void) const {return PHOScradlesA;}
 225   virtual Float_t  GetPHOS_flag          (Int_t n) const {return PHOSflags[n];}
 226   virtual Float_t  GetPHOSextra          (Int_t n) const {return PHOSextra[n];}
 227   virtual Float_t  GetPHOSFoam           (Int_t n) const {return PHOSFTI[n];}
 228   virtual Float_t  GetPHOStxwall         (Int_t n) const {return PHOSTXW[n];}
 229   virtual Float_t  GetPHOSAir            (Int_t n) const {return PHOSAIR[n];}
 230   virtual Float_t &GetCradleAngle        (Int_t n) {return PHOSangle[n];}
 231
 232
 233   TObjArray            *fCradles;               //!  Cradles in PHOS
 234   Int_t                 fDebugLevel;
 235
 236   TTree                *fTreePHOS;              //! Pointer to PHOS tree.
 237
 238 private:
 239
 240   TString               fBranchNameOfCradles;   //
 241   TString               fTreeName;              // Name of PHOS tree: "PHOS"
 242
 243 #define MAXCRAD 100
 244
 245   Float_t PHOSflags[9], PHOScell[9], PHOSradius, PHOSCPV[9];
 246   Int_t   PHOSsize[3];
 247   Float_t PHOScradlesA,PHOSTXW[3],PHOSAIR[3],PHOSFTI[4],PHOSextra[9],
 248         PHOSangle[MAXCRAD];
 249   Int_t   PHOS_Ndiv_magic;
 250
 251  ClassDef(AliPHOS,1)  //Hits manager for set:PHOS
 252 };
 253
 254 #endif
 255