1 | #ifndef __MTrigger__
|
---|
2 | #define __MTrigger__
|
---|
3 |
|
---|
4 | #define CASE_SHOW 0
|
---|
5 | #define CASE_NSB 1
|
---|
6 | #define CASE_STAR 2
|
---|
7 |
|
---|
8 | // class MTrigger
|
---|
9 | //
|
---|
10 | // implemented by Harald Kornmayer
|
---|
11 | //
|
---|
12 | // This is a class to simulate the trigger.
|
---|
13 | // It assumes a special response of the PMT for one single Photo-electron.
|
---|
14 | //
|
---|
15 | //
|
---|
16 | //
|
---|
17 | #include <iostream>
|
---|
18 | #include <math.h>
|
---|
19 |
|
---|
20 | #include "TROOT.h"
|
---|
21 | #include "TObject.h"
|
---|
22 | #include "TRandom.h"
|
---|
23 | #include "TH1.h"
|
---|
24 |
|
---|
25 | #include "Mdefine.h"
|
---|
26 | #include "MMcEvt.hxx"
|
---|
27 |
|
---|
28 | #include "MGeomCam.h"
|
---|
29 |
|
---|
30 | #include "MTriggerDefine.h"
|
---|
31 |
|
---|
32 |
|
---|
33 | //==========
|
---|
34 | // MTrigger FIXME: some explanations are rather outdated!!
|
---|
35 | //
|
---|
36 | // The simulation of the Trigger for MonteCarlo Events is using this
|
---|
37 | // class. So all methods concerning the trigger should be done inside this
|
---|
38 | // class.
|
---|
39 | //
|
---|
40 | // For a better understanding of the behavior of the trigger is here small
|
---|
41 | // abstract of the trigger. This may change in the future.
|
---|
42 | //
|
---|
43 | //
|
---|
44 | // We now from the camera program (This is the surrounding of the class
|
---|
45 | // MTrigger.) that one photo electron leaves at time t the photo cathode
|
---|
46 | // of the pixel number iPix).
|
---|
47 | //
|
---|
48 | // At the end of the PMT, the preamp, the optical fiber transmission we
|
---|
49 | // get a signal of a given shape. After some discussion with Eckart the
|
---|
50 | // standard response function looks like this :
|
---|
51 | //
|
---|
52 | // It is a gaussian Signal with a given FWHM.
|
---|
53 | //
|
---|
54 | // So whenever a photo electron leaves the photo cathod, on has to add
|
---|
55 | // the standard response function to the analog signal of the pixel.
|
---|
56 | //
|
---|
57 | // Each pixel of the camera has such an summed-up analog signal.
|
---|
58 | //
|
---|
59 | // This is the input of the discriminator for the pixels. The output of
|
---|
60 | // the discriminator is a digital signal. The response of the diskriminator
|
---|
61 | // is not fixed at the moment. There are discussion about this topic.
|
---|
62 | //
|
---|
63 | // At the moment the response is very simple. Whenever the analog signal
|
---|
64 | // is crossing a defined threshold from below to above, a digital signal
|
---|
65 | // with a given length is created.
|
---|
66 | //
|
---|
67 | // Now one can start with the simulation of different trigger levels.
|
---|
68 | //
|
---|
69 | // The TriggerLevelZero is a very easy one. It is just looking if there
|
---|
70 | // are more than N digital signals at level ON (=1). If this is the case,
|
---|
71 | // a TriggerLevelZero signal is created.
|
---|
72 | //
|
---|
73 | //
|
---|
74 | //
|
---|
75 | class MTrigger {
|
---|
76 |
|
---|
77 | private:
|
---|
78 | Int_t pixnum;
|
---|
79 | //
|
---|
80 | // then for all pixels the shape of all the analog signals
|
---|
81 | //
|
---|
82 | Bool_t *used; // a boolean to indicated if the pixels is used in this event
|
---|
83 | Int_t *nphotshow; // count the photo electrons per pixel coming from showers
|
---|
84 | Int_t *nphotnsb; // count the photo electrons per pixel coming from NSB
|
---|
85 | Int_t *nphotstar; // count the photo electrons per pixel coming from stars
|
---|
86 |
|
---|
87 | Float_t **a_sig ; // the analog signal for pixels
|
---|
88 |
|
---|
89 | Float_t *baseline; // for the baseline shift
|
---|
90 |
|
---|
91 | //
|
---|
92 | // then for all pixels the shape of the digital signal
|
---|
93 | //
|
---|
94 | Bool_t *dknt ; // a boolean to indicated if the pixels has passed the diskrminator
|
---|
95 | Float_t **d_sig ; // the digital signal for all pixels
|
---|
96 |
|
---|
97 | //
|
---|
98 | // and the sum of all digital signals
|
---|
99 | //
|
---|
100 | Float_t sum_d_sig[TRIGGER_TIME_SLICES] ;
|
---|
101 |
|
---|
102 | //
|
---|
103 | // first the data for the response function
|
---|
104 | //
|
---|
105 | Float_t fwhm_resp ; // fwhm of the phe_response function
|
---|
106 | Float_t ampl_resp ; // amplitude of the phe_response function (in mV)
|
---|
107 | Float_t sing_resp[RESPONSE_SLICES_TRIG] ; // the shape of the phe_response function
|
---|
108 | Float_t peak_time ; // the time from the start of the response
|
---|
109 | // function to the maximum peak
|
---|
110 |
|
---|
111 | TH1F *histPmt ;
|
---|
112 | Float_t histMean ; // Mean value of the distribution of Razmik (stored in histPmt)
|
---|
113 | TRandom *GenElec ; // RandomGenerator for the Electronic Noise
|
---|
114 |
|
---|
115 | Float_t *noise;
|
---|
116 |
|
---|
117 | //
|
---|
118 | // some values for the trigger settings
|
---|
119 | //
|
---|
120 |
|
---|
121 | Float_t *chan_thres ; // the threshold (in mV) for each individuel pixels
|
---|
122 | Float_t gate_leng ; // the length of the digital signal if analog signal is above threshold
|
---|
123 |
|
---|
124 | Float_t overlaping_time; // Minimum coincidence time
|
---|
125 |
|
---|
126 | Float_t trigger_multi ; // Number of Pixels requested for a Trigger
|
---|
127 | Int_t trigger_geometry ; // 0 means a pixel with trigger_multi-1 neighbours
|
---|
128 | // 1 means trigger_multi neighbours
|
---|
129 | // 2 means trigger_multi closed neighbours
|
---|
130 | //
|
---|
131 | // The lookup table for the next neighbours
|
---|
132 | //
|
---|
133 |
|
---|
134 | Int_t *NN[6] ;
|
---|
135 |
|
---|
136 | //
|
---|
137 | // The lookup table for trigger cells
|
---|
138 | //
|
---|
139 |
|
---|
140 | Int_t *TC[TRIGGER_CELLS] ;
|
---|
141 |
|
---|
142 | //
|
---|
143 | // some information about the different TriggerLevels in each Event
|
---|
144 | //
|
---|
145 |
|
---|
146 | Int_t nZero ; // how many ZeroLevel Trigger in one Event
|
---|
147 | Bool_t SlicesZero[TRIGGER_TIME_SLICES] ; // Times Slices at which the ZeroLevel Triggers occur
|
---|
148 |
|
---|
149 | Int_t nFirst ; // how many FirstLevel Trigger in one Event
|
---|
150 | Int_t SlicesFirst[5] ; // Times Slices at which the FirstLevel Triggers occur
|
---|
151 | Int_t PixelsFirst[5] ; // Pixel which fires the trigger
|
---|
152 |
|
---|
153 | Int_t nSecond ; // how many SecondLevel Trigger in one Event
|
---|
154 | Int_t SlicesSecond[5] ; // Times Slices at which the SecondLevel Triggers occur
|
---|
155 | Int_t PixelsSecond[5] ; // Pixel which fires the trigger
|
---|
156 |
|
---|
157 | Float_t Fill( Int_t, Float_t, Int_t ) ;
|
---|
158 |
|
---|
159 | Bool_t PassNextNeighbour( Bool_t m[], Bool_t *n) ;
|
---|
160 |
|
---|
161 | void OverlapingTime( Bool_t m[], Bool_t *n, Int_t ifSli);
|
---|
162 | // n[] will have pixels of m[] that are on for the required overlaping time
|
---|
163 |
|
---|
164 | Bool_t fGainFluctuations;
|
---|
165 | void InitGainFluctuations();
|
---|
166 |
|
---|
167 | public:
|
---|
168 |
|
---|
169 | MTrigger(int pix=577) ;
|
---|
170 |
|
---|
171 | MTrigger(int pix, MGeomCam *camgeom,
|
---|
172 | float gate, float overt, float ampl, float fwhm, int ct_id=0) ;
|
---|
173 |
|
---|
174 | MTrigger(int pix,
|
---|
175 | float gate, float overt, float ampl, float fwhm) ;
|
---|
176 |
|
---|
177 | ~MTrigger() ;
|
---|
178 |
|
---|
179 | void SetSeed(UInt_t seed) {GenElec->SetSeed(seed);}
|
---|
180 |
|
---|
181 | void Reset() ;
|
---|
182 |
|
---|
183 | void ClearZero() ;
|
---|
184 |
|
---|
185 | void ClearFirst() ;
|
---|
186 |
|
---|
187 | Float_t FillShow( Int_t, Float_t ) ;
|
---|
188 |
|
---|
189 | Float_t FillNSB( Int_t, Float_t ) ;
|
---|
190 |
|
---|
191 | Float_t FillStar( Int_t, Float_t ) ;
|
---|
192 |
|
---|
193 | void AddNSB( Int_t pix, Float_t resp[TRIGGER_TIME_SLICES]);
|
---|
194 |
|
---|
195 | void SetElecNoise(Float_t factor=0.3);
|
---|
196 |
|
---|
197 | void ElecNoise(Float_t factor = 0.3) ;
|
---|
198 |
|
---|
199 | void SetResponseShape();
|
---|
200 |
|
---|
201 | void SetMultiplicity (Int_t multi);
|
---|
202 |
|
---|
203 | void SetTopology (Int_t topo);
|
---|
204 |
|
---|
205 | void SetThreshold (Float_t thres[]);
|
---|
206 |
|
---|
207 | void SetFwhm(Float_t fwhm);
|
---|
208 |
|
---|
209 | void SetAmpl(Float_t ampl){
|
---|
210 | ampl_resp=ampl;
|
---|
211 | }
|
---|
212 |
|
---|
213 | void SetGainFluctuations(Bool_t x) { fGainFluctuations = x; }
|
---|
214 |
|
---|
215 | void CheckThreshold (float *thres, int cells);
|
---|
216 |
|
---|
217 | void ReadThreshold (char name[]);
|
---|
218 |
|
---|
219 | void ReadParam(char name[]);
|
---|
220 |
|
---|
221 | Float_t GetMultiplicity (){
|
---|
222 | return(trigger_multi);
|
---|
223 | }
|
---|
224 |
|
---|
225 | Int_t GetTopology (){
|
---|
226 | return(trigger_geometry);
|
---|
227 | }
|
---|
228 |
|
---|
229 | Float_t GetThreshold (Int_t il){
|
---|
230 | return(chan_thres[il]);
|
---|
231 | }
|
---|
232 |
|
---|
233 | void GetResponse( Float_t * resp) ;
|
---|
234 |
|
---|
235 | void GetMapDiskriminator(Byte_t *map);
|
---|
236 |
|
---|
237 | void Diskriminate() ;
|
---|
238 |
|
---|
239 | void ShowSignal (MMcEvt *McEvt) ;
|
---|
240 |
|
---|
241 | Int_t ZeroLevel() ;
|
---|
242 |
|
---|
243 | Int_t FirstLevel() ;
|
---|
244 |
|
---|
245 | Float_t GetFirstLevelTime( Int_t il ) ;
|
---|
246 |
|
---|
247 | Int_t GetFirstLevelPixel( Int_t il ) ;
|
---|
248 |
|
---|
249 | Float_t GetAmplitude() {
|
---|
250 | return ampl_resp ;
|
---|
251 | }
|
---|
252 |
|
---|
253 | Float_t GetFwhm() {
|
---|
254 | return fwhm_resp ;
|
---|
255 | }
|
---|
256 |
|
---|
257 | Bool_t GetGainFluctuations() { return fGainFluctuations; }
|
---|
258 |
|
---|
259 | } ;
|
---|
260 |
|
---|
261 | #endif
|
---|
262 |
|
---|