Splitting of the ITS libraries (M.Masera & E.Crescio)
[u/mrichter/AliRoot.git] / ITS / AliITSsimulationSPD.h
1 #ifndef ALIITSSIMULATIONSPD_H
2 #define ALIITSSIMULATIONSPD_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  * See cxx source for full Copyright notice                               */
5
6 /*
7 $Id$
8 */
9 ////////////////////////////////////////////////////////////////////////
10 // Version: 0                                                         //
11 // Written by Rocco Caliandro                                         //
12 // from a model developed with T. Virgili and R.A. Fini               //
13 // June 15 2000                                                       //
14 //                                                                    //
15 // AliITSsimulationSPD is the simulation of SPDs                      //
16 ////////////////////////////////////////////////////////////////////////
17
18 #include "AliITSresponseSPD.h"
19 #include "AliITSsegmentationSPD.h"
20 #include "AliITSsimulation.h"
21
22 class AliITSMapA2;
23 class AliITSpList;
24 class AliITSmodule;
25
26 //-------------------------------------------------------------------
27
28 class AliITSsimulationSPD : public AliITSsimulation {
29
30  public:        
31     AliITSsimulationSPD(); // Default constructor
32     // Standard constructor
33     AliITSsimulationSPD(AliITSsegmentation *seg, AliITSresponse *res);
34     virtual ~AliITSsimulationSPD();// destructor
35     AliITSsimulationSPD(const AliITSsimulationSPD &source); // copy constructo
36     // assignment operator
37     AliITSsimulationSPD& operator=(const AliITSsimulationSPD &source);
38     virtual AliITSsimulation& operator=(const AliITSsimulation &source);
39     // Initilizes the variables
40     void Init();
41     // Initilizes the variables with replacement segmentation/response class
42     void Init(AliITSsegmentationSPD *seg, AliITSresponseSPD *resp);
43
44     // Sum digitize module
45     // Create maps to build the lists of tracks for each summable digit
46     void InitSimulationModule(Int_t module,Int_t events);
47     // Digitize module from the sum of summable digits.
48     void FinishSDigitiseModule();
49     void SDigitiseModule(AliITSmodule *mod, Int_t dummy0,Int_t dummy1);
50     // digitize module. Also need to digitize modules with only noise.
51     void DigitiseModule(AliITSmodule *mod,Int_t dummy0, Int_t dummy1);
52     // sum digits to Digits.
53     void SDigitsToDigits(Int_t module,AliITSpList *pList);
54     // updates the Map of signal, adding the energy  (ene) released by
55     // the current track
56     void UpdateMapSignal(Int_t row,Int_t col,Int_t trk,Int_t hit,Int_t mod,
57                          Double_t ene,AliITSpList *pList);
58     // updates the Map of noise, adding the energy  (ene) give my noise
59     void UpdateMapNoise(Int_t row,Int_t col,Int_t mod,Double_t ene,
60                         AliITSpList *pList);
61     // Loops over all hits to produce Analog/floting point digits. This
62     // is also the first task in producing standard digits.
63     void HitsToAnalogDigits(AliITSmodule *mod,Int_t *frowpixel,
64                             Int_t *fcolpixel,Double_t *fenepixel,
65                             AliITSpList *pList);
66     //  Steering function to determine the digits associated to a given
67     // hit (hitpos)
68     // The digits are created by charge sharing (ChargeSharing) and by
69     // capacitive coupling (SetCoupling). At all the created digits is
70     // associated the track number of the hit (ntrack)
71     void HitToDigit(AliITSmodule *mod, Int_t hitpos,Int_t *frowpixel,
72                     Int_t *fcolpixel, Double_t *fenepixel,AliITSpList *pList);
73     //  Take into account the geometrical charge sharing when the track
74     //  crosses more than one pixel.
75     void ChargeSharing(Float_t x1l,Float_t z1l,Float_t x2l,Float_t z2l,
76                        Int_t c1,Int_t r1,Int_t c2,Int_t r2,Float_t etot,
77                        Int_t &npixel,Int_t *frowpixel,Int_t *fcolpixel,
78                        Double_t *fenepixel);
79     //  Take into account the coupling between adiacent pixels.
80     //  The parameters probcol and probrow are the fractions of the
81     //  signal in one pixel shared in the two adjacent pixels along
82     //  the column and row direction, respectively. Now done in a statistical
83     //  way and not "mechanical" as in the Old version.
84     void SetCoupling(Int_t row,Int_t col,Int_t ntrack,Int_t idhit,Int_t module,
85                      AliITSpList *pList);
86     //  Take into account the coupling between adiacent pixels.
87     //  The parameters probcol and probrow are the fractions of the
88     //  signal in one pixel shared in the two adjacent pixels along
89     //  the column and row direction, respectively.
90     void SetCouplingOld(Int_t row,Int_t col,Int_t ntrack,Int_t idhit,
91                         Int_t module,AliITSpList *pList);
92     // The pixels are fired if the energy deposited inside them is above
93     // the threshold parameter ethr. Fired pixed are interpreted as digits
94     // and stored in the file digitfilename. One also needs to write out
95     // cases when there is only noise (nhits==0).
96     void CreateDigit(Int_t module,AliITSpList *pList);
97     //  Set the electronic noise and threshold non-uniformities to all the
98     //  pixels in a detector.
99     //  The parameter fSigma is the squared sum of the sigma due to noise
100     //  and the sigma of the threshold distribution among pixels.
101     void SetFluctuations(AliITSpList *pList,Int_t module);
102     //  Apply a mask to the SPD module. 1% of the pixel channels are
103     //  masked. When the database will be ready, the masked pixels
104     //  should be read from it.
105     void SetMask();
106     // Create Histograms
107     void CreateHistograms();
108     // Reset histograms for this detector
109     void ResetHistograms();
110     // Fills the Summable digits Tree
111     void WriteSDigits(AliITSpList *pList);
112     // Fills fMap2A from the pList of Summable digits
113     void FillMapFrompList(AliITSpList *pList);
114     // get hist array
115     TObjArray*  GetHistArray() {return fHis;}
116
117  private:
118     // Getters for data kept in fSegmentation and fResponse.
119     // Returns the Threshold in electrons
120     Double_t GetThreshold(){Double_t a=0.0,b=0.0;
121     ((AliITSresponseSPD*)fResponse)->Thresholds(a,b); return a;}
122     // Returns the threshold and rms noise.
123     void GetThresholds(Double_t &t,Double_t &s){
124     ((AliITSresponseSPD*)fResponse)->Thresholds(t,s);}
125     // Returns the couplings Columb and Row.
126     void GetCouplings(Double_t &cc,Double_t &cr){
127         ((AliITSresponseSPD*)fResponse)->GetCouplingParam(cc,cr);}
128     // Returns the number of pixels in x
129     Int_t GetNPixelsX(){return ((AliITSsegmentationSPD*)fSegmentation)->Npx();}
130     // Returns the number of pixels in z
131     Int_t GetNPixelsZ(){return ((AliITSsegmentationSPD*)fSegmentation)->Npz();}
132
133  private:
134     AliITSMapA2  *fMapA2;   //! MapA2 for Local internal use only
135     TObjArray    *fHis;     //! just in case for histogramming for Local
136                             // internal use only
137
138     ClassDef(AliITSsimulationSPD,1)  // Simulation of SPD clusters
139
140 };
141
142 #endif