-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathE15190ReaderData.cpp
294 lines (271 loc) · 22.5 KB
/
E15190ReaderData.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
#include <E15190Reader.h>
//____________________________________________________
void E15190Reader::BuildCalibratedEvent()
{
if(fIsNWA) {
HTNeutronWallData * NWA = fNWA->Get();
//Filling calibrated data structures
fNWACalibratedData.fmulti=0;
for(int i=0; i<NWA->fmulti; i++)
{
if(1) {
fNWACalibratedData.fnumbar[fNWACalibratedData.fmulti] =NWA->fnumbar[i];
fNWACalibratedData.fLeft[fNWACalibratedData.fmulti] =NWA->fLeft[i];
fNWACalibratedData.fRight[fNWACalibratedData.fmulti] =NWA->fRight[i];
fNWACalibratedData.ffastLeft[fNWACalibratedData.fmulti] =NWA->ffastLeft[i];
fNWACalibratedData.ffastRight[fNWACalibratedData.fmulti] =NWA->ffastRight[i];
fNWACalibratedData.fTimeLeft[fNWACalibratedData.fmulti] =NWA->fTimeLeft[i];
fNWACalibratedData.fTimeRight[fNWACalibratedData.fmulti] =NWA->fTimeRight[i];
// fNWACalibratedData.fGeoMean[fNWACalibratedData.fmulti] =NWA->fGeoMean[i];
// fNWACalibratedData.ffastGeoMean[fNWACalibratedData.fmulti] =NWA->ffastGeoMean[i];
// fNWACalibratedData.fTimeMean[fNWACalibratedData.fmulti] =GetNWATimeMean(NWA->fnumbar[i],NWA->fTimeLeft[i],NWA->fTimeRight[i]);
// fNWACalibratedData.fMatchedLeft[fNWACalibratedData.fmulti] =GetNWALeftMatched(NWA->fLeft[i], NWA->fnumbar[i]);
// fNWACalibratedData.fMatchedRight[fNWACalibratedData.fmulti]=GetNWARightMatched(NWA->fRight[i], NWA->fnumbar[i]);
// fNWACalibratedData.fMatchedGeoMean[fNWACalibratedData.fmulti]=sqrt(fNWACalibratedData.fMatchedLeft[fNWACalibratedData.fmulti]*fNWACalibratedData.fMatchedRight[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fXcm[fNWACalibratedData.fmulti] =GetNWAXcm(NWA->fnumbar[i],NWA->fTimeLeft[i],NWA->fTimeRight[i]);
// fNWACalibratedData.fCalGeoMean[fNWACalibratedData.fmulti] =GetNWAPulseHeightCalibrated(NWA->fGeoMean[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.fFlattenedGeoMean[fNWACalibratedData.fmulti] =GetNWAPSDFlattened(NWA->fGeoMean[i],NWA->ffastGeoMean[i],NWA->fnumbar[i]);
// fNWACalibratedData.fLeftSaturationCorrected[fNWACalibratedData.fmulti]=GetNWALeftSaturationCorrected(NWA->fLeft[i],NWA->fRight[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.fRightSaturationCorrected[fNWACalibratedData.fmulti]=GetNWARightSaturationCorrected(NWA->fLeft[i],NWA->fRight[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.ffastLeftSaturationCorrected[fNWACalibratedData.fmulti]=GetNWAfastLeftSaturationCorrected(NWA->ffastLeft[i],NWA->ffastRight[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.ffastRightSaturationCorrected[fNWACalibratedData.fmulti]=GetNWAfastRightSaturationCorrected(NWA->ffastLeft[i],NWA->ffastRight[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.fPSDLeft[fNWACalibratedData.fmulti] =GetNWALeftPSDResidual(fNWACalibratedData.fLeftSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.ffastLeftSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.fRightSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.ffastRightSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.fPSDRight[fNWACalibratedData.fmulti] =GetNWARightPSDResidual(fNWACalibratedData.fLeftSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.ffastLeftSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.fRightSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.ffastRightSaturationCorrected[fNWACalibratedData.fmulti],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
// fNWACalibratedData.fTheta[fNWACalibratedData.fmulti] =GetNWATheta(NWA->fnumbar[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fPhi[fNWACalibratedData.fmulti] =GetNWAPhi(NWA->fnumbar[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fThetaRan[fNWACalibratedData.fmulti] =GetNWAThetaRan(NWA->fnumbar[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fPhiRan[fNWACalibratedData.fmulti] =GetNWAPhiRan(NWA->fnumbar[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fDistcm[fNWACalibratedData.fmulti] =GetNWADistance(NWA->fnumbar[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fDistRancm[fNWACalibratedData.fmulti] =GetNWADistanceRan(NWA->fnumbar[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti]);
// fNWACalibratedData.fIsGamma[fNWACalibratedData.fmulti] =IsNWAGamma(NWA->fGeoMean[i],NWA->ffastGeoMean[i],NWA->fnumbar[i],NWA->fLeft[i],NWA->fRight[i]);
// fNWACalibratedData.fGeoMeanSaturationCorrected[fNWACalibratedData.fmulti] =GetNWASaturationCorrected(NWA->fLeft[i],NWA->fRight[i],fNWACalibratedData.fXcm[fNWACalibratedData.fmulti],NWA->fnumbar[i]);
fNWACalibratedData.fmulti++;
}
}
}
if(fIsNWB) {
HTNeutronWallData * NWB = fNWB->Get();
fNWBCalibratedData.fmulti=0;
for(int i=0; i<NWB->fmulti; i++)
{
if(1) {
fNWBCalibratedData.fnumbar[fNWBCalibratedData.fmulti] =NWB->fnumbar[i];
fNWBCalibratedData.fLeft[fNWBCalibratedData.fmulti] =NWB->fLeft[i];
fNWBCalibratedData.fRight[fNWBCalibratedData.fmulti] =NWB->fRight[i];
fNWBCalibratedData.ffastLeft[fNWBCalibratedData.fmulti] =NWB->ffastLeft[i];
fNWBCalibratedData.ffastRight[fNWBCalibratedData.fmulti] =NWB->ffastRight[i];
fNWBCalibratedData.fTimeLeft[fNWBCalibratedData.fmulti] =NWB->fTimeLeft[i];
fNWBCalibratedData.fTimeRight[fNWBCalibratedData.fmulti] =NWB->fTimeRight[i];
// fNWBCalibratedData.fGeoMean[fNWBCalibratedData.fmulti] =NWB->fGeoMean[i];
// fNWBCalibratedData.ffastGeoMean[fNWBCalibratedData.fmulti] =NWB->ffastGeoMean[i];
// fNWBCalibratedData.fTimeMean[fNWBCalibratedData.fmulti] =GetNWBTimeMean(NWB->fnumbar[i],NWB->fTimeLeft[i],NWB->fTimeRight[i]);
// fNWBCalibratedData.fMatchedLeft[fNWBCalibratedData.fmulti] =GetNWBLeftMatched(NWB->fLeft[i], NWB->fnumbar[i]);
// fNWBCalibratedData.fMatchedRight[fNWBCalibratedData.fmulti]=GetNWBRightMatched(NWB->fRight[i], NWB->fnumbar[i]);
// fNWBCalibratedData.fMatchedGeoMean[fNWBCalibratedData.fmulti]=sqrt(fNWBCalibratedData.fMatchedLeft[fNWBCalibratedData.fmulti]*fNWBCalibratedData.fMatchedRight[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti] =GetNWBXcm(NWB->fnumbar[i],NWB->fTimeLeft[i],NWB->fTimeRight[i]);
// fNWBCalibratedData.fCalGeoMean[fNWBCalibratedData.fmulti] =GetNWBPulseHeightCalibrated(NWB->fGeoMean[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.fFlattenedGeoMean[fNWBCalibratedData.fmulti] =GetNWBPSDFlattened(NWB->fGeoMean[i],NWB->ffastGeoMean[i],NWB->fnumbar[i]);
// fNWBCalibratedData.fLeftSaturationCorrected[fNWBCalibratedData.fmulti]=GetNWBLeftSaturationCorrected(NWB->fLeft[i],NWB->fRight[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.fRightSaturationCorrected[fNWBCalibratedData.fmulti]=GetNWBRightSaturationCorrected(NWB->fLeft[i],NWB->fRight[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.ffastLeftSaturationCorrected[fNWBCalibratedData.fmulti]=GetNWBfastLeftSaturationCorrected(NWB->ffastLeft[i],NWB->ffastRight[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.ffastRightSaturationCorrected[fNWBCalibratedData.fmulti]=GetNWBfastRightSaturationCorrected(NWB->ffastLeft[i],NWB->ffastRight[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.fPSDLeft[fNWBCalibratedData.fmulti] =GetNWBLeftPSDResidual(fNWBCalibratedData.fLeftSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.ffastLeftSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.fRightSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.ffastRightSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.fPSDRight[fNWBCalibratedData.fmulti] =GetNWBRightPSDResidual(fNWBCalibratedData.fLeftSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.ffastLeftSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.fRightSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.ffastRightSaturationCorrected[fNWBCalibratedData.fmulti],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
// fNWBCalibratedData.fTheta[fNWBCalibratedData.fmulti] =GetNWBTheta(NWB->fnumbar[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fPhi[fNWBCalibratedData.fmulti] =GetNWBPhi(NWB->fnumbar[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fThetaRan[fNWBCalibratedData.fmulti] =GetNWBThetaRan(NWB->fnumbar[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fPhiRan[fNWBCalibratedData.fmulti] =GetNWBPhiRan(NWB->fnumbar[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fDistcm[fNWBCalibratedData.fmulti] =GetNWBDistance(NWB->fnumbar[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fDistRancm[fNWBCalibratedData.fmulti] =GetNWBDistanceRan(NWB->fnumbar[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti]);
// fNWBCalibratedData.fIsGamma[fNWBCalibratedData.fmulti] =IsNWBGamma(NWB->fGeoMean[i],NWB->ffastGeoMean[i],NWB->fnumbar[i],NWB->fLeft[i],NWB->fRight[i]);
// fNWBCalibratedData.fGeoMeanSaturationCorrected[fNWBCalibratedData.fmulti] =GetNWBSaturationCorrected(NWB->fLeft[i],NWB->fRight[i],fNWBCalibratedData.fXcm[fNWBCalibratedData.fmulti],NWB->fnumbar[i]);
fNWBCalibratedData.fmulti++;
}
}
}
if(fIsFA) {
HTForwardArrayData * ForwardArray = fForwardArray->Get();
fForwardArrayCalibratedData.fmulti=0;
for(int i=0; i<ForwardArray->fmulti; i++)
{
if(1) {
fForwardArrayCalibratedData.fnumdet[fForwardArrayCalibratedData.fmulti] = ForwardArray->fnumdet[i];
fForwardArrayCalibratedData.fE[fForwardArrayCalibratedData.fmulti] = ForwardArray->fE[i];
fForwardArrayCalibratedData.fTime[fForwardArrayCalibratedData.fmulti] = ForwardArray->fTime[i]-GetFATimeOffset(ForwardArray->fnumdet[i])+GetFATimePulseHeightCorrection(ForwardArray->fnumdet[i], ForwardArray->fE[i]);
fForwardArrayCalibratedData.fmulti++;
}
}
//FA tmean and tmin are here calculated. They correspond, respectively to the minimum FA time of the matched times and the
//time average between any other time which differs for less than 3ns with the minumum
fForwardArrayCalibratedData.fTimeMin = fForwardArrayCalibratedData.fmulti>0 ? *std::min_element(fForwardArrayCalibratedData.fTime, fForwardArrayCalibratedData.fTime+fForwardArrayCalibratedData.fmulti) : -9999;
double TempTimeMin = 300;
for(int i=0; i<fForwardArrayCalibratedData.fmulti; i++) {
if (fForwardArrayCalibratedData.fTime[i]>300||fForwardArrayCalibratedData.fTime[i]<-500||fForwardArrayCalibratedData.fE[i]<500) continue;
TempTimeMin = std::min(TempTimeMin,fForwardArrayCalibratedData.fTime[i]);
}
if (TempTimeMin<300) {
fForwardArrayCalibratedData.fTimeMin = TempTimeMin;
}
double ttolerance=3; //time mean is found within the elements that differ for less than 3 ns from the minimum
int tgood=0; //number of FA elements giving a time within the tolerance limit
fForwardArrayCalibratedData.fTimeMean=0;
for(int i=0; i<fForwardArrayCalibratedData.fmulti; i++) {
if(fabs(fForwardArrayCalibratedData.fTime[i]-fForwardArrayCalibratedData.fTimeMin) < ttolerance) {
fForwardArrayCalibratedData.fTimeMean+=fForwardArrayCalibratedData.fTime[i];
tgood++;
}
}
fForwardArrayCalibratedData.fTimeMean= fForwardArrayCalibratedData.fmulti>0 ? fForwardArrayCalibratedData.fTimeMean/tgood : -9999;
// let's store the original fTime, not the corrected ones
for(int i=0; i<ForwardArray->fmulti; i++) {
fForwardArrayCalibratedData.fTime[i] = ForwardArray->fTime[i];
}
}
if(fIsVW) {
HTVetoWallData * VetoWall = fVetoWall->Get();
fVetoWallCalibratedData.fmulti=0;
for(int i=0; i<VetoWall->fmulti; i++)
{
if(1) {
fVetoWallCalibratedData.fnumbar[fVetoWallCalibratedData.fmulti] =VetoWall->fnumbar[i];
fVetoWallCalibratedData.fTop[fVetoWallCalibratedData.fmulti] =VetoWall->fTop[i];
fVetoWallCalibratedData.fBottom[fVetoWallCalibratedData.fmulti] =VetoWall->fBottom[i];
fVetoWallCalibratedData.fTimeTop[fVetoWallCalibratedData.fmulti] =VetoWall->fTimeTop[i];
fVetoWallCalibratedData.fTimeBottom[fVetoWallCalibratedData.fmulti] =VetoWall->fTimeBottom[i];
// fVetoWallCalibratedData.fGeoMean[fVetoWallCalibratedData.fmulti] =VetoWall->fGeoMean[i];
// fVetoWallCalibratedData.fGeoMeanMatched[fVetoWallCalibratedData.fmulti] =GetVWGeoMeanMatched(VetoWall->fGeoMean[i], VetoWall->fnumbar[i]);
// fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti] =GetVWYcm(VetoWall->fnumbar[i], VetoWall->fTimeBottom[i], VetoWall->fTimeTop[i]);
// fVetoWallCalibratedData.fTheta[fVetoWallCalibratedData.fmulti] =GetVWTheta(VetoWall->fnumbar[i], fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti]);
// fVetoWallCalibratedData.fPhi[fVetoWallCalibratedData.fmulti] =GetVWPhi(VetoWall->fnumbar[i], fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti]);
// fVetoWallCalibratedData.fThetaRan[fVetoWallCalibratedData.fmulti] =GetVWThetaRan(VetoWall->fnumbar[i], fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti]);
// fVetoWallCalibratedData.fPhiRan[fVetoWallCalibratedData.fmulti] =GetVWPhiRan(VetoWall->fnumbar[i], fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti]);
// fVetoWallCalibratedData.fDistcm[fVetoWallCalibratedData.fmulti] =GetVWDistance(VetoWall->fnumbar[i], fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti]);
// fVetoWallCalibratedData.fDistRancm[fVetoWallCalibratedData.fmulti] =GetVWDistanceRan(VetoWall->fnumbar[i], fVetoWallCalibratedData.fYcm[fVetoWallCalibratedData.fmulti]);
fVetoWallCalibratedData.fmulti++;
}
}
}
if(fIsHiRA) {
//Analysis of the HiRA detector
fHiRACalibratedData.fmulti=0;
//Creation of a buffer of calibrated data for the event
for(int i=0; i<NUM_TEL; i++)
{
fHiRACalibratedDataBuffer.fmultistripf=0;
fHiRACalibratedDataBuffer.fmultistripb=0;
fHiRACalibratedDataBuffer.fmulticsi=0;
HTHiRAData * HiRA = fHiRA[i]->Get();
for(int j=0; j<HiRA->fEF.fmulti; j++) {
if(IsStripfBad(i,HiRA->fEF.fnumstrip[j])) continue;
fHiRACalibratedDataBuffer.fnumstripf[fHiRACalibratedDataBuffer.fmultistripf]=HiRA->fEF.fnumstrip[j];
fHiRACalibratedDataBuffer.fEnergySifHi[fHiRACalibratedDataBuffer.fmultistripf]=HiRA->fEF.fEnergyHi[j];
fHiRACalibratedDataBuffer.fEnergySifLo[fHiRACalibratedDataBuffer.fmultistripf]=HiRA->fEF.fEnergyLo[j];
fHiRACalibratedDataBuffer.fTimeSif[fHiRACalibratedDataBuffer.fmultistripf]=HiRA->fEF.fTime[j];
fHiRACalibratedDataBuffer.fEnergySifMatched[fHiRACalibratedDataBuffer.fmultistripf]=GetSifHiLowMatched(HiRA->fEF.fEnergyHi[j], HiRA->fEF.fEnergyLo[j], i, HiRA->fEF.fnumstrip[j]);
fHiRACalibratedDataBuffer.fEnergySifCal[fHiRACalibratedDataBuffer.fmultistripf]=GetSifHiLowMatchedEMeV(HiRA->fEF.fEnergyHi[j], HiRA->fEF.fEnergyLo[j], i, HiRA->fEF.fnumstrip[j]);
fHiRACalibratedDataBuffer.fmultistripf++;
}
for(int j=0; j<HiRA->fEB.fmulti; j++) {
if(IsStripbBad(i,HiRA->fEB.fnumstrip[j])) continue;
fHiRACalibratedDataBuffer.fnumstripb[fHiRACalibratedDataBuffer.fmultistripb]=HiRA->fEB.fnumstrip[j];
fHiRACalibratedDataBuffer.fEnergySibHi[fHiRACalibratedDataBuffer.fmultistripb]=HiRA->fEB.fEnergyHi[j];
fHiRACalibratedDataBuffer.fEnergySibLo[fHiRACalibratedDataBuffer.fmultistripb]=HiRA->fEB.fEnergyLo[j];
fHiRACalibratedDataBuffer.fTimeSib[fHiRACalibratedDataBuffer.fmultistripb]=HiRA->fEB.fTime[j];
fHiRACalibratedDataBuffer.fEnergySibMatched[fHiRACalibratedDataBuffer.fmultistripb]=GetSibHiLowMatched(HiRA->fEB.fEnergyHi[j], HiRA->fEB.fEnergyLo[j], i, HiRA->fEB.fnumstrip[j]);
fHiRACalibratedDataBuffer.fEnergySibCal[fHiRACalibratedDataBuffer.fmultistripb]=GetSibHiLowMatchedEMeV(HiRA->fEB.fEnergyHi[j], HiRA->fEB.fEnergyLo[j], i, HiRA->fEB.fnumstrip[j]);
fHiRACalibratedDataBuffer.fmultistripb++;
}
for(int j=0; j<HiRA->fCsI.fmulti; j++) {
fHiRACalibratedDataBuffer.fnumcsi[fHiRACalibratedDataBuffer.fmulticsi]=HiRA->fCsI.fnumcsi[j];
fHiRACalibratedDataBuffer.fEnergycsi[fHiRACalibratedDataBuffer.fmulticsi]=HiRA->fCsI.fEnergy[j];
fHiRACalibratedDataBuffer.fTimecsi[fHiRACalibratedDataBuffer.fmulticsi]=HiRA->fCsI.fTime[j];
fHiRACalibratedDataBuffer.fEnergycsiCal[fHiRACalibratedDataBuffer.fmulticsi]=GetCsIEMeV(HiRA->fCsI.fEnergy[j], i, HiRA->fCsI.fnumcsi[j]);
fHiRACalibratedDataBuffer.fmulticsi++;
}
//Pixelization for the current telescope
fHiRAPixelizationModule->Pixelization(i,&fHiRACalibratedDataBuffer,&fHiRACalibratedData);
}
//Particle Identification
if(fHiRAIdentificationLoaded) {
fHiRAIdentifiationModule->PerformIdentification(&fHiRACalibratedData);
}
//Geometry and Energy
for(int i=0; i<fHiRACalibratedData.fmulti; i++) {
fHiRACalibratedData.fTheta[i]=GetThetaPixel(fHiRACalibratedData.fnumtel[i], fHiRACalibratedData.fnumstripf[i], fHiRACalibratedData.fnumstripb[i]);
fHiRACalibratedData.fPhi[i]=GetPhiPixel(fHiRACalibratedData.fnumtel[i], fHiRACalibratedData.fnumstripf[i], fHiRACalibratedData.fnumstripb[i]);
fHiRACalibratedData.fEnergycsiCal[i]=GetCsIEMeV(fHiRACalibratedData.fEnergycsi[i],fHiRACalibratedData.fnumtel[i],fHiRACalibratedData.fnumcsi[i],fHiRACalibratedData.fZ[i],fHiRACalibratedData.fA[i]);
fHiRACalibratedData.fEnergycsiCalProtons[i]=GetCsIEMeV(fHiRACalibratedData.fEnergycsi[i],fHiRACalibratedData.fnumtel[i],fHiRACalibratedData.fnumcsi[i], 1, 1);
fHiRACalibratedData.fKinEnergy[i]=fHiRACalibratedDataBuffer.fEnergySifMatched[i]+fHiRACalibratedData.fEnergycsiCal[i];
fHiRACalibratedData.fBeta[i]=-9999;
fHiRACalibratedData.fMomentum[i]=-9999;
}
}
if(fIsMB) {
HTMicroballData * Microball = fMicroball->Get();
//Filling calibrated data structures
fMicroballCalibratedData.fmulti=0;
for(int i=0; i<Microball->fmulti; i++)
{
if(!IsMBDetectorBad(Microball->fnumring[i], Microball->fnumdet[i]) && IsMBHit(Microball->fnumring[i], Microball->fnumdet[i],Microball->fFast[i],Microball->fTail[i],Microball->fTime[i])) {
fMicroballCalibratedData.fnumring[fMicroballCalibratedData.fmulti] =Microball->fnumring[i];
fMicroballCalibratedData.fnumdet[fMicroballCalibratedData.fmulti] =Microball->fnumdet[i];
fMicroballCalibratedData.fTail[fMicroballCalibratedData.fmulti] =Microball->fTail[i];
fMicroballCalibratedData.fFast[fMicroballCalibratedData.fmulti] =Microball->fFast[i];
fMicroballCalibratedData.fTime[fMicroballCalibratedData.fmulti] =Microball->fTime[i];
// fMicroballCalibratedData.fTheta[fMicroballCalibratedData.fmulti] =GetMBTheta(Microball->fnumring[i], Microball->fnumdet[i]);
// fMicroballCalibratedData.fPhi[fMicroballCalibratedData.fmulti] =GetMBPhi(Microball->fnumring[i], Microball->fnumdet[i]);
// fMicroballCalibratedData.fThetaRan[fMicroballCalibratedData.fmulti]=GetMBThetaRandom(Microball->fnumring[i], Microball->fnumdet[i]);
// fMicroballCalibratedData.fPhiRan[fMicroballCalibratedData.fmulti] =GetMBPhiRandom(Microball->fnumring[i], Microball->fnumdet[i]);
fMicroballCalibratedData.fmulti++;
}
//Microball Event Varaibles
// fMicroballCalibratedData.fb =GetMBImpactParameter(fMicroballCalibratedData.fmulti);
// fMicroballCalibratedData.fbhat =GetMBbhat(fMicroballCalibratedData.fmulti);
}
}
if(fIsTDC) {
fTDCAdditionalChannels->FillOutputBranches();
}
}
//____________________________________________________
void E15190Reader::BuildCalibratedTree(const char * file_name, Long64_t evt_amount)
{
// this method constructs a calibrated data tree
TFile * FileOut = new TFile(file_name, "RECREATE");
if(FileOut->IsZombie()) {
printf("Error: Cannot create file %s\n", file_name);
return;
}
// Initializing output TTree
TTree * TreeOut = new TTree ("E15190", "Calibrated Data");
if(fIsTDC) fTDCAdditionalChannels->SetOutputTree(TreeOut);
if(fIsMB) TreeOut->Branch("uBall.","MicroballCalibratedData",&fMicroballCalibratedData,32000,2);
if(fIsHiRA) TreeOut->Branch("HiRA.","HiRACalibratedData",&fHiRACalibratedData,32000,2);
if(fIsFA) TreeOut->Branch("ForwardArray.","ForwardArrayCalibratedData",&fForwardArrayCalibratedData,32000,2);
if(fIsVW) TreeOut->Branch("VetoWall.","VetoWallCalibratedData",&fVetoWallCalibratedData,32000,2);
if(fIsNWA) TreeOut->Branch("NWA.","NeutronWallCalibratedData",&fNWACalibratedData,32000,2);
if(fIsNWB) TreeOut->Branch("NWB.","NeutronWallCalibratedData",&fNWBCalibratedData,32000,2);
TreeOut->GetUserInfo()->Add(fBeam);
TreeOut->GetUserInfo()->Add(fBeamEnergy);
TreeOut->GetUserInfo()->Add(fTarget);
TreeOut->SetAutoSave(5000000);
Long64_t nentries=fChain->GetEntries();
if(evt_amount!=0) {
nentries=evt_amount;
}
Long64_t jentry=0;
std::cout << "found " << nentries << " entries\n";
fStartTime = clock(); // initializing start time
for(;fE15190Reader->Next() && jentry<nentries; jentry++)
{
if(jentry%100000==0) {
PrintPercentage(jentry,nentries);
}
BuildCalibratedEvent();
TreeOut->Fill();
}
//Save Output Tree to file
TreeOut->AutoSave();
// closing output file
FileOut->Close();
}