Separating well and badly reconstructed pileup vertices. Adding statistics of associa...
[u/mrichter/AliRoot.git] / ITS / AliITSsimulationSSD.h
1 #ifndef ALIITSSIMULATIONSSD_H
2 #define ALIITSSIMULATIONSSD_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 // Simulation class for SSD                                //
10 /////////////////////////////////////////////////////////////
11
12 #include "AliITSsimulation.h"
13 #include "AliITSsegmentationSSD.h" // function used in inline functions
14
15 class AliITSMapA2;
16 class AliITSpList;
17 class AliITSTableSSD;
18 //class AliITSdcsSSD;
19 class AliITSsegmentationSSD;
20 class AliITSCalibrationSSD;
21 class TF1;
22
23 class AliITSsimulationSSD: public AliITSsimulation {
24
25  public:
26     AliITSsimulationSSD(); // Default constructor
27     AliITSsimulationSSD(const AliITSsimulationSSD &source); // copy constructor
28     // operator =
29     AliITSsimulationSSD& operator=(const AliITSsimulationSSD &source);
30     //    virtual AliITSsimulation& operator=(const AliITSsimulation &source);
31     //Standard Constructor
32     AliITSsimulationSSD(AliITSDetTypeSim* dettyp);
33     //Destructor
34     virtual ~AliITSsimulationSSD();
35     // Get a pointer to the segmentation object
36     virtual AliITSsegmentation* GetSegmentationModel(Int_t /*dt*/){return fDetType->GetSegmentationModel(2);}
37     // set pointer to segmentation objec
38     virtual void SetSegmentationModel(Int_t /*dt*/, AliITSsegmentation *seg){fDetType->SetSegmentationModel(2,seg);}
39     // Initilize variables for this simulation
40     void Init();
41     // Initilize variables for this simulation
42     //void Init(AliITSsegmentationSSD *seg,AliITSCalibrationSSD *resp);
43     // Create maps to build the lists of tracks for each summable digit
44     void InitSimulationModule(Int_t module,Int_t events);
45     // Digitize module from the sum of summable digits.
46     void FinishSDigitiseModule();
47     //Digitizes all of the hits in a module
48     void DigitiseModule(AliITSmodule *mod,Int_t dummy0,Int_t dummy1);
49     // Computes the Summable Digits
50     void SDigitiseModule(AliITSmodule *mod,Int_t module,Int_t dummy);
51     // Computes the Charge on each Strip/ Analog/summable digits
52     void HitsToAnalogDigits(AliITSmodule *mod,AliITSpList *pList);
53     //Computes the signal from one hit
54     void HitToDigit(Int_t module,Double_t x0,Double_t y0,Double_t z0, 
55                     Double_t x,Double_t y,Double_t z,Double_t de,
56                     AliITSTableSSD *tav);
57     //returns a pointer to the SSD segmentation.
58     /*AliITSsegmentationSSD *GetSegmentation() {
59         return (AliITSsegmentationSSD*) fSegmentation;}
60     */
61     //Returns the ionization energy for Si in GeV.
62     Double_t GetIonizeE() const {return fIonE;}
63     //Sets the ionization energy for Si in GeV.
64     void SetIonizeE(Double_t e=3.62E-09){fIonE = e;}
65     //Returns the Diffusion constant h in cm**2/sec
66     Double_t GetDiffConst(Int_t i) const {return fDifConst[i];}
67     //Sets the Diffusion constant h in cm**2/sec
68     void SetDiffConst(Double_t h=11.0,Double_t e=30.0)
69         {fDifConst[0] = h;fDifConst[1]=e;}
70     //Returns the Drift velocity for the side i
71     Double_t GetDriftVelocity(Int_t i) const {return fDriftVel[i];}
72     //Sets the Drift velocity for the P and N sides
73     void SetDriftVelocity(Double_t v0=0.86E+06,Double_t v1=2.28E+06)
74         {fDriftVel[0] = v0;fDriftVel[1] = v1;}
75
76
77     //  Decide whether to use or not the Lorentz drift 
78     void SetLorentzDrift(Bool_t b=kFALSE)
79       {fLorentz=b; if(fLorentz) SetTanLorAngle();};
80     // Set the Lorentz angles
81     Bool_t SetTanLorAngle();
82     // Getter for the Lorentz angles
83     Double_t GetTanLorAngleP() const {return fTanLorAngP;};
84     Double_t GetTanLorAngleN() const {return fTanLorAngN;};
85     //
86
87
88     // Standard ascii class print function
89     void Print(ostream *os);
90     // Standard ascii class read function
91     void Read(istream *is);
92     virtual void Print(Option_t *option="") const {TObject::Print(option);}
93     virtual Int_t Read(const char *name) {return TObject::Read(name);}
94     // Data members
95  protected:
96
97     //    AliITSdcsSSD *fDCS;   // Class containing detector controle paramters
98
99  private:
100     // Return the Response class
101     //    AliITSCalibrationSSD* GetResp(){return (AliITSCalibrationSSD*)fResponse;}
102     // Return the Segmentation class
103     //AliITSsegmentationSSD* GetSeg(){
104     //  return (AliITSsegmentationSSD*)fSegmentation;}
105     // returns the number of steps needed to proplerly distribute the charge
106     // in a step
107     Int_t NumOfSteps(Double_t x,Double_t y,Double_t z,
108                      Double_t  &dex,Double_t &dey,Double_t &dez);
109     // Keepts track and orders tracks for a give strip.
110     void GetList(Int_t trk,Int_t ht,Int_t mod,AliITSpList *pLt,
111                  AliITSTableSSD *tav);
112     // sets thresholds and fills digits
113     void ChargeToSignal(Int_t module,const AliITSpList *pList);
114     // Writes Summable Digits to a root file for later use.
115     void WriteSDigits(AliITSpList *pList);
116     // ReadSDigits and create Digits
117     void SDigitToDigit(Int_t module,AliITSpList *pList);
118     // Fills fMapA2 from pList AliITSpList
119     void FillMapFrompList(AliITSpList *pList);
120     // Diffuses the charge onto neighboring strips.
121     void    IntegrateGaussian(Int_t k,Double_t par,Double_t av,Double_t sigma, 
122                               Double_t inf, Double_t sup,
123                               AliITSTableSSD *tav);
124      // Applies noise to strips randomly
125     void    ApplyNoise(AliITSpList *pList,Int_t mod);
126      // Applies posible signal coupling between strips
127     void    ApplyCoupling(AliITSpList *pList,Int_t mod);
128     // Kill dead channels
129     void ApplyDeadChannels(Int_t mod);
130     // Computes the integral of a gaussian using Error Function
131     Float_t F(Float_t av, Float_t x, Float_t s);
132     // returns, from the segmentation, the number of stips
133     Int_t GetNStrips() {AliITSsegmentationSSD* seg = (AliITSsegmentationSSD*)GetSegmentationModel(2);return seg->Npx();}
134     // returns, from the segmentation, the strip pitch
135     Float_t GetStripPitch() {AliITSsegmentationSSD* seg = (AliITSsegmentationSSD*)GetSegmentationModel(2);return seg->Dpx(0);}
136
137     AliITSMapA2 *fMapA2;      //! Map of ionization, used localy only
138     Double_t    fIonE;        // ionization energy of Si in GeV
139     Double_t    fDifConst[2]; // Diffusion constants [h,e] in cm**2/sec
140     Double_t    fDriftVel[2]; // Drift velocities [P,N sides] cm/sec
141
142     TF1         *fTimeResponse; // signal time response function
143
144    Bool_t        fLorentz;      // kTRUE if Lorentz drift has been allowed 
145    Double_t      fTanLorAngP;    //! Tangent of the Lorentz Angle for holes 
146    Double_t      fTanLorAngN;    //! Tangent of the Lorentz Angle for electrons
147
148
149     ClassDef(AliITSsimulationSSD,3) // SSD signal simulation class
150
151 };
152 // Input and output functions for standard C++ input/output.
153 ostream &operator<<(ostream &os,AliITSsimulationSSD &source);
154 istream &operator>>(istream &is,AliITSsimulationSSD &source);
155 #endif