TRD/AliTRDsimpleMC.h

   1 #ifndef ALITRDSIMPLEMC_H
   2 #define ALITRDSIMPLEMC_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 //                                                                           //
  10 //  Simple TRD Monte Carlo class                                             //
  11 //                                                                           //
  12 ///////////////////////////////////////////////////////////////////////////////
  13
  14 #include "AliMC.h"
  15 #include "AliMCProcess.h"
  16
  17 class AliTRDv1;
  18
  19 class AliTRDsimpleMC : public AliMC {
  20
  21  public:
  22
  23   enum {
  24       kPdgElectron = 11
  25     , kPdgPion     = 211
  26   };
  27
  28   AliTRDsimpleMC();
  29   AliTRDsimpleMC(const char *name, const char *title);
  30   AliTRDsimpleMC(const AliTRDsimpleMC &m);
  31
  32   virtual ~AliTRDsimpleMC();
  33   AliTRDsimpleMC &operator=(const AliTRDsimpleMC &m);
  34
  35   virtual void          Copy(TObject &m);
  36
  37   //
  38   // Methods for building / management of geometry
  39   //
  40
  41   // Functions from GCONS
  42   virtual void          Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,
  43                                Float_t &dens, Float_t &radl, Float_t &absl,
  44                                Float_t* ubuf, Int_t& nbuf)                                { };
  45
  46   // Detector composition
  47   virtual void          Material(Int_t& kmat, const char* name, Float_t a,
  48                                  Float_t z, Float_t dens, Float_t radl, Float_t absl,
  49                                  Float_t* buf, Int_t nwbuf)                               { };
  50   virtual void          Mixture(Int_t& kmat, const char *name, Float_t *a,
  51                                 Float_t *z, Float_t dens, Int_t nlmat, Float_t *wmat)     { };
  52   virtual void          Medium(Int_t& kmed, const char *name, Int_t nmat,
  53                                Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd,
  54                                Float_t stemax, Float_t deemax, Float_t epsil,
  55                                Float_t stmin, Float_t* ubuf, Int_t nbuf)                  { };
  56   virtual void          Matrix(Int_t& krot, Float_t thetaX, Float_t phiX,
  57                                Float_t thetaY, Float_t phiY, Float_t thetaZ,
  58                                Float_t phiZ)                                              { };
  59   virtual void          Gstpar(Int_t itmed, const char *param, Float_t parval)            { };
  60
  61   // Functions from GGEOM
  62   virtual Int_t         Gsvolu(const char *name, const char *shape, Int_t nmed,
  63                                Float_t *upar, Int_t np)                                   { return 0; };
  64   virtual void          Gsdvn(const char *name, const char *mother, Int_t ndiv,
  65                               Int_t iaxis)                                                { };
  66   virtual void          Gsdvn2(const char *name, const char *mother, Int_t ndiv,
  67                                Int_t iaxis, Float_t c0i, Int_t numed)                     { };
  68   virtual void          Gsdvt(const char *name, const char *mother, Float_t step,
  69                               Int_t iaxis, Int_t numed, Int_t ndvmx)                      { };
  70   virtual void          Gsdvt2(const char *name, const char *mother, Float_t step,
  71                                Int_t iaxis, Float_t c0, Int_t numed, Int_t ndvmx)         { };
  72   virtual void          Gsord(const char *name, Int_t iax)                                { };
  73   virtual void          Gspos(const char *name, Int_t nr, const char *mother,
  74                               Float_t x, Float_t y, Float_t z, Int_t irot,
  75                               const char *konly="ONLY")                                   { };
  76   virtual void          Gsposp(const char *name, Int_t nr, const char *mother,
  77                                Float_t x, Float_t y, Float_t z, Int_t irot,
  78                                const char *konly, Float_t *upar, Int_t np)                { };
  79   virtual void          Gsbool(const char* onlyVolName, const char* manyVolName) {}
  80
  81   virtual void          SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov,
  82                                     Float_t *absco, Float_t *effic, Float_t *rindex)      { };
  83
  84   // Functions for drawing
  85   virtual void          DrawOneSpec(const char* name)                                     { };
  86   virtual void          Gsatt(const char* name, const char* att, Int_t val)               { };
  87   virtual void          Gdraw(const char*,Float_t theta = 30, Float_t phi = 30,
  88                               Float_t psi = 0, Float_t u0 = 10, Float_t v0 = 10,
  89                               Float_t ul = 0.01, Float_t vl = 0.01)                       { };
  90
  91   // Euclid
  92   virtual void          WriteEuclid(const char *a, const char *b, Int_t c, Int_t d)       { };
  93
  94   // Get methods
  95   virtual Int_t         VolId(const Text_t* volName) const;
  96   virtual const char   *VolName(Int_t id) const                                           { return " "; };
  97   virtual Int_t         NofVolumes() const                                                { return 0; };
  98   virtual Int_t         VolId2Mate(Int_t id) const                                        { return 0; };
  99
 100   //
 101   // Methods for physics management
 102   //
 103
 104   // Set methods
 105   virtual void          SetCut(const char* cutName, Float_t cutValue)                     { };
 106   virtual void          SetProcess(const char* flagName, Int_t flagValue)                 { };
 107   virtual Float_t       Xsec(char *a, Float_t b, Int_t c, Int_t d)                        { return 0.0; };
 108
 109   // Particle table usage
 110   virtual Int_t         IdFromPDG(Int_t id) const                                         { return 0;   };
 111   virtual Int_t         PDGFromId(Int_t pdg) const                                        { return 0;   };
 112   virtual void          DefineParticles()                                                 { };
 113
 114   //
 115   // Methods for step management
 116   //
 117
 118   // Action methods
 119   virtual void          StopTrack() { };
 120   virtual void          StopEvent() { };
 121
 122   // Set methods
 123   virtual void          SetMaxStep(Float_t step)                                          { fMaxStep = step; };
 124   virtual void          SetMaxNStep(Int_t n)                                              { };
 125   virtual void          SetUserDecay(Int_t d)                                             { };
 126
 127   virtual void          NewTrack(Int_t iTrack, Int_t pdg, Double_t px, Double_t py, Double_t pz);
 128
 129   // Tracking volume(s)
 130   virtual Int_t         CurrentVolID(Int_t& copyNo) const;
 131   virtual Int_t         CurrentVolOffID(Int_t off, Int_t& copyNo) const;
 132   virtual const char*   CurrentVolName() const                                            { return ""; };
 133   virtual const char*   CurrentVolOffName(Int_t off) const                                { return ""; };
 134   virtual Int_t         CurrentMaterial(Float_t &a, Float_t &z,
 135                                         Float_t &dens, Float_t &radl,
 136                                         Float_t &absl) const                              { return 0;  };
 137   virtual Int_t         CurrentEvent() const                                              { return 0;  };
 138   virtual void          Gmtod(Float_t* xm, Float_t* xd, Int_t iflag)                      { };
 139   virtual void          Gdtom(Float_t* xd, Float_t* xm, Int_t iflag)                      { } ;
 140   virtual Float_t       MaxStep() const                                                   { return fMaxStep; };
 141   virtual Int_t         GetNStep() const                                                  { return fNStep;   };
 142   virtual Int_t         GetMaxNStep() const                                               { return 0;  };
 143   virtual Int_t         GetMedium() const                                                 { return 0;  };
 144
 145   // Dynamic properties
 146   virtual void          TrackPosition(TLorentzVector& position) const;
 147   virtual void          TrackMomentum(TLorentzVector& momentum) const;
 148   virtual Float_t       TrackStep() const                                                 { return fTrackStep; };
 149   virtual Float_t       TrackLength() const                                               { return 0.0; };
 150   virtual Float_t       TrackTime() const                                                 { return 0.0; };
 151   virtual Float_t       Edep() const                                                      { return 0.0; };
 152
 153   // Static properties
 154   virtual Int_t         TrackPid() const                                                  { return fTrackPid;    };
 155   virtual Float_t       TrackCharge() const                                               { return fTrackCharge; };
 156   virtual Float_t       TrackMass() const                                                 { return fTrackMass;   };
 157   virtual Float_t       Etot() const                                                      { return fTrackEtot;   };
 158
 159   // Track status
 160   virtual Bool_t        IsNewTrack() const                                                { return kFALSE; };
 161   virtual Bool_t        IsTrackInside() const                                             { return kFALSE; };
 162   virtual Bool_t        IsTrackEntering() const                                           { return fTrackEntering; };
 163   virtual Bool_t        IsTrackExiting() const                                            { return kFALSE; };
 164   virtual Bool_t        IsTrackOut() const                                                { return kFALSE; };
 165   virtual Bool_t        IsTrackDisappeared() const                                        { return kFALSE; };
 166   virtual Bool_t        IsTrackStop() const                                               { return kFALSE; };
 167   virtual Bool_t        IsTrackAlive() const                                              { return kFALSE; };
 168
 169   // Secondaries
 170   virtual Int_t         NSecondaries() const                                              { return 0; };
 171   virtual void          GetSecondary(Int_t isec, Int_t& particleId,
 172                                      TLorentzVector& position,
 173                                      TLorentzVector& momentum)                            { };
 174   virtual AliMCProcess  ProdProcess(Int_t isec) const                                     { return kPNoProcess; };
 175   virtual Int_t         StepProcesses(TArrayI &proc) const                                { return 0; };
 176
 177   //
 178   // Other (then geometry/step/run management) methods
 179   //
 180
 181   // Geant3 specific methods
 182   virtual void          Gdopt(const char *c1,const char*c2)                               { };
 183   virtual void          SetClipBox(const char* cc,Float_t a=-9999,Float_t b=0,
 184                                    Float_t c=-9999,Float_t d=0,
 185                                    Float_t e=-9999,Float_t f=0)                           { };
 186   virtual void          DefaultRange()                                                    { };
 187   virtual void          Gdhead(Int_t, const char *c, Float_t a=0)                         { };
 188   virtual void          Gdman(Float_t a, Float_t b, const char *c)                        { };
 189   virtual void          SetColors()                                                       { };
 190   virtual void          Gtreve()                                                          { };
 191   virtual void          GtreveRoot()                                                      { };
 192   virtual void          Gckmat(Int_t, char*)                                              { };
 193   virtual void          InitLego()                                                        { };
 194   virtual void          Gfpart(Int_t a, char *b, Int_t &c, Float_t &d,
 195                                Float_t &e, Float_t &g)                                    { };
 196   virtual void          Gspart(Int_t a, const char *b, Int_t c, Float_t d,
 197                                Float_t e, Float_t g)                                      { };
 198
 199   // Control Methods
 200   virtual void          Init()                                                            { };
 201   virtual void          FinishGeometry()                                                  { };
 202   virtual void          BuildPhysics()                                                    { };
 203   virtual void          ProcessEvent();
 204   virtual void          ProcessRun(Int_t nevent)                                          { };
 205   virtual AliMCGeomType     GetMCGeomType() const { return kGeant3; }
 206
 207   // External Decayer
 208   virtual void          SetExternalDecayer(AliDecayer* decayer)                           { };
 209   virtual AliDecayer   *Decayer() const                                                   { return 0; };
 210
 211  protected:
 212
 213   enum {
 214       kVolDrRg
 215     , kVolAmRg
 216     , kVolDrCh
 217   };
 218
 219   Float_t         fMaxStep;            //  Maximum step size
 220   Int_t           fNStep;              //  Number of steps
 221   Int_t           fTrack;              //  Track number
 222   Double_t        fTrackPx;            //  Track px
 223   Double_t        fTrackPy;            //  Track py
 224   Double_t        fTrackPz;            //  Track pz
 225   Double_t        fTrackPtot;          //  Track total momentum
 226   Double_t        fTrackEtot;          //  Track total energy
 227   Double_t        fTrackX;             //  Track x position
 228   Double_t        fTrackY;             //  Track y position
 229   Double_t        fTrackZ;             //  Track z position
 230   Double_t        fX0;                 //  X position of the beginning of the chamber
 231   Double_t        fTrackStep;          //  Track step size
 232   Int_t           fTrackPid;           //  Track PID
 233   Float_t         fTrackCharge;        //  Track charge
 234   Float_t         fTrackMass;          //  Track particle mass
 235   Bool_t          fTrackEntering;      //  Track entering chamber
 236
 237   AliTRDv1       *fTRD;                //! TRD detector object
 238
 239   ClassDef(AliTRDsimpleMC,1)           //  Simple TRD Monte Carlo class
 240
 241 };
 242 #endif