Hall C ROOT/C++ Analyzer (hcana)
Loading...
Searching...
No Matches
THcScintillatorPlane.cxx
Go to the documentation of this file.
1
9#include "TMath.h"
10#include "THcScintillatorPlane.h"
11#include "THcScintPlaneCluster.h"
12#include "TClonesArray.h"
13#include "THcSignalHit.h"
14#include "THcHodoHit.h"
15#include "THcGlobals.h"
16#include "THcParmList.h"
17#include "THcHitList.h"
18#include "THcHodoscope.h"
19#include "TClass.h"
20#include "THcRawAdcHit.h"
21#include "THcRawTdcHit.h"
22
23#include <cstring>
24#include <cstdio>
25#include <cstdlib>
26#include <iostream>
27
28using namespace std;
29
30ClassImp(THcScintillatorPlane)
31
32//______________________________________________________________________________
33THcScintillatorPlane::THcScintillatorPlane( const char* name,
34 const char* description,
35 const Int_t planenum,
36 THaDetectorBase* parent )
37: THaSubDetector(name,description,parent),
38 fParentHitList(0), fCluster(0),frPosAdcErrorFlag(0), frNegAdcErrorFlag(0),
39 frPosTDCHits(0), frNegTDCHits(0), frPosADCHits(0), frNegADCHits(0),
40 frPosADCSums(0), frNegADCSums(0), frPosADCPeds(0), frNegADCPeds(0),
41 fHodoHits(0), frPosTdcTimeRaw(0), frPosAdcPedRaw(0),
42 frPosAdcPulseIntRaw(0), frPosAdcPulseAmpRaw(0),
43 frPosAdcPulseTimeRaw(0), frPosTdcTime(0), frPosAdcPed(0),
44 frPosAdcPulseInt(0), frPosAdcPulseAmp(0), frPosAdcPulseTime(0),
45 frNegTdcTimeRaw(0), frNegAdcPedRaw(0), frNegAdcPulseIntRaw(0),
46 frNegAdcPulseAmpRaw(0), frNegAdcPulseTimeRaw(0), frNegTdcTime(0),
47 frNegAdcPed(0), frNegAdcPulseInt(0), frNegAdcPulseAmp(0),
48 frNegAdcPulseTime(0), fPosCenter(0), fHodoPosMinPh(0),
49 fHodoNegMinPh(0), fHodoPosPhcCoeff(0), fHodoNegPhcCoeff(0),
50 fHodoPosTimeOffset(0), fHodoNegTimeOffset(0), fHodoVelLight(0),
51 fHodoPosInvAdcOffset(0), fHodoNegInvAdcOffset(0),
52 fHodoPosAdcTimeWindowMin(0), fHodoPosAdcTimeWindowMax(0),
53 fHodoNegAdcTimeWindowMin(0), fHodoNegAdcTimeWindowMax(0),
54 fHodoPosInvAdcLinear(0), fHodoNegInvAdcLinear(0),
55 fHodoPosInvAdcAdc(0), fHodoNegInvAdcAdc(0), fHodoVelFit(0),
56 fHodoCableFit(0), fHodo_LCoeff(0), fHodoPos_c1(0), fHodoNeg_c1(0),
57 fHodoPos_c2(0), fHodoNeg_c2(0), fHodoSigma(0), fPosPedSum(0),
58 fPosPedSum2(0), fPosPedLimit(0), fPosPedCount(0), fNegPedSum(0),
59 fNegPedSum2(0), fNegPedLimit(0), fNegPedCount(0), fPosPed(0),
60 fPosSig(0), fPosThresh(0), fNegPed(0), fNegSig(0), fNegThresh(0)
61{
62 // Normal constructor with name and description
63 fHodoHits = new TClonesArray("THcHodoHit",16);
64
65 fCluster = new TClonesArray("THcScintPlaneCluster", 10);
66
67 frPosAdcErrorFlag = new TClonesArray("THcSignalHit", 16);
68 frNegAdcErrorFlag = new TClonesArray("THcSignalHit", 16);
69
70 frPosTDCHits = new TClonesArray("THcSignalHit",16);
71 frNegTDCHits = new TClonesArray("THcSignalHit",16);
72 frPosADCHits = new TClonesArray("THcSignalHit",16);
73 frNegADCHits = new TClonesArray("THcSignalHit",16);
74 frPosADCSums = new TClonesArray("THcSignalHit",16);
75 frNegADCSums = new TClonesArray("THcSignalHit",16);
76 frPosADCPeds = new TClonesArray("THcSignalHit",16);
77 frNegADCPeds = new TClonesArray("THcSignalHit",16);
78
79 frPosTdcTimeRaw = new TClonesArray("THcSignalHit", 16);
80 frPosAdcPedRaw = new TClonesArray("THcSignalHit", 16);
81 frPosAdcPulseIntRaw = new TClonesArray("THcSignalHit", 16);
82 frPosAdcPulseAmpRaw = new TClonesArray("THcSignalHit", 16);
83 frPosAdcPulseTimeRaw = new TClonesArray("THcSignalHit", 16);
84
85 frPosTdcTime = new TClonesArray("THcSignalHit", 16);
86 frPosAdcPed = new TClonesArray("THcSignalHit", 16);
87 frPosAdcPulseInt = new TClonesArray("THcSignalHit", 16);
88 frPosAdcPulseAmp = new TClonesArray("THcSignalHit", 16);
89 frPosAdcPulseTime = new TClonesArray("THcSignalHit", 16);
90
91 frNegTdcTimeRaw = new TClonesArray("THcSignalHit", 16);
92 frNegAdcPedRaw = new TClonesArray("THcSignalHit", 16);
93 frNegAdcPulseIntRaw = new TClonesArray("THcSignalHit", 16);
94 frNegAdcPulseAmpRaw = new TClonesArray("THcSignalHit", 16);
95 frNegAdcPulseTimeRaw = new TClonesArray("THcSignalHit", 16);
96
97 frNegTdcTime = new TClonesArray("THcSignalHit", 16);
98 frNegAdcPed = new TClonesArray("THcSignalHit", 16);
99 frNegAdcPulseInt = new TClonesArray("THcSignalHit", 16);
100 frNegAdcPulseAmp = new TClonesArray("THcSignalHit", 16);
101 frNegAdcPulseTime = new TClonesArray("THcSignalHit", 16);
102
103 frPosAdcSampPedRaw = new TClonesArray("THcSignalHit", 16);
104 frPosAdcSampPulseIntRaw = new TClonesArray("THcSignalHit", 16);
105 frPosAdcSampPulseAmpRaw = new TClonesArray("THcSignalHit", 16);
106 frPosAdcSampPulseTimeRaw = new TClonesArray("THcSignalHit", 16);
107 frPosAdcSampPed = new TClonesArray("THcSignalHit", 16);
108 frPosAdcSampPulseInt = new TClonesArray("THcSignalHit", 16);
109 frPosAdcSampPulseAmp = new TClonesArray("THcSignalHit", 16);
110 frPosAdcSampPulseTime = new TClonesArray("THcSignalHit", 16);
111
112 frNegAdcSampPedRaw = new TClonesArray("THcSignalHit", 16);
113 frNegAdcSampPulseIntRaw = new TClonesArray("THcSignalHit", 16);
114 frNegAdcSampPulseAmpRaw = new TClonesArray("THcSignalHit", 16);
115 frNegAdcSampPulseTimeRaw = new TClonesArray("THcSignalHit", 16);
116 frNegAdcSampPed = new TClonesArray("THcSignalHit", 16);
117 frNegAdcSampPulseInt = new TClonesArray("THcSignalHit", 16);
118 frNegAdcSampPulseAmp = new TClonesArray("THcSignalHit", 16);
119 frNegAdcSampPulseTime = new TClonesArray("THcSignalHit", 16);
120
121 fPlaneNum = planenum;
122 fTotPlanes = planenum;
123 fNScinHits = 0;
124}
125
126//______________________________________________________________________________
127THcScintillatorPlane::~THcScintillatorPlane()
128{
129 // Destructor
130 if( fIsSetup )
131 RemoveVariables();
132 delete frPosAdcErrorFlag; frPosAdcErrorFlag = NULL;
133 delete frNegAdcErrorFlag; frNegAdcErrorFlag = NULL;
134
135 delete fCluster; fCluster = NULL;
136
137 delete fHodoHits;
138 delete frPosTDCHits;
139 delete frNegTDCHits;
140 delete frPosADCHits;
141 delete frNegADCHits;
142 delete frPosADCSums;
143 delete frNegADCSums;
144 delete frPosADCPeds;
145 delete frNegADCPeds;
146
147 delete frPosTdcTimeRaw;
148 delete frPosAdcPedRaw;
149 delete frPosAdcPulseIntRaw;
150 delete frPosAdcPulseAmpRaw;
151 delete frPosAdcPulseTimeRaw;
152
153 delete frPosTdcTime;
154 delete frPosAdcPed;
155 delete frPosAdcPulseInt;
156 delete frPosAdcPulseAmp;
157 delete frPosAdcPulseTime;
158
159 delete frNegTdcTimeRaw;
160 delete frNegAdcPedRaw;
161 delete frNegAdcPulseIntRaw;
162 delete frNegAdcPulseAmpRaw;
163 delete frNegAdcPulseTimeRaw;
164
165 delete frNegTdcTime;
166 delete frNegAdcPed;
167 delete frNegAdcPulseInt;
168 delete frNegAdcPulseAmp;
169 delete frNegAdcPulseTime;
170
171 delete frPosAdcSampPedRaw; frPosAdcSampPedRaw = NULL;
172 delete frPosAdcSampPulseIntRaw; frPosAdcSampPulseIntRaw = NULL;
173 delete frPosAdcSampPulseAmpRaw; frPosAdcSampPulseAmpRaw = NULL;
174 delete frPosAdcSampPulseTimeRaw; frPosAdcSampPulseTimeRaw = NULL;
175 delete frPosAdcSampPed; frPosAdcSampPed = NULL;
176 delete frPosAdcSampPulseInt; frPosAdcSampPulseInt = NULL;
177 delete frPosAdcSampPulseAmp; frPosAdcSampPulseAmp = NULL;
178 delete frPosAdcSampPulseTime; frPosAdcSampPulseTime = NULL;
179
180 delete frNegAdcSampPedRaw; frNegAdcSampPedRaw = NULL;
181 delete frNegAdcSampPulseIntRaw; frNegAdcSampPulseIntRaw = NULL;
182 delete frNegAdcSampPulseAmpRaw; frNegAdcSampPulseAmpRaw = NULL;
183 delete frNegAdcSampPulseTimeRaw; frNegAdcSampPulseTimeRaw = NULL;
184 delete frNegAdcSampPed; frNegAdcSampPed = NULL;
185 delete frNegAdcSampPulseInt; frNegAdcSampPulseInt = NULL;
186 delete frNegAdcSampPulseAmp; frNegAdcSampPulseAmp = NULL;
187 delete frNegAdcSampPulseTime; frNegAdcSampPulseTime = NULL;
188
189 delete [] fPosCenter; fPosCenter = 0;
190
191 delete [] fHodoPosMinPh; fHodoPosMinPh = NULL;
192 delete [] fHodoNegMinPh; fHodoNegMinPh = NULL;
193 delete [] fHodoPosPhcCoeff; fHodoPosPhcCoeff = NULL;
194 delete [] fHodoNegPhcCoeff; fHodoNegPhcCoeff = NULL;
195 delete [] fHodoPosTimeOffset; fHodoPosTimeOffset = NULL;
196 delete [] fHodoNegTimeOffset; fHodoNegTimeOffset = NULL;
197 delete [] fHodoPosInvAdcOffset; fHodoPosInvAdcOffset = NULL;
198 delete [] fHodoNegInvAdcOffset; fHodoNegInvAdcOffset = NULL;
199 delete [] fHodoPosInvAdcLinear; fHodoPosInvAdcLinear = NULL;
200 delete [] fHodoNegInvAdcLinear; fHodoNegInvAdcLinear = NULL;
201 delete [] fHodoPosAdcTimeWindowMax; fHodoPosAdcTimeWindowMax = NULL;
202 delete [] fHodoPosAdcTimeWindowMin; fHodoPosAdcTimeWindowMin = NULL;
203 delete [] fHodoNegAdcTimeWindowMax; fHodoNegAdcTimeWindowMax = NULL;
204 delete [] fHodoNegAdcTimeWindowMin; fHodoNegAdcTimeWindowMin = NULL;
205 delete [] fHodoNegInvAdcLinear; fHodoNegInvAdcLinear = NULL;
206 delete [] fHodoPosInvAdcAdc; fHodoPosInvAdcAdc = NULL;
207 delete [] fHodoNegInvAdcAdc; fHodoNegInvAdcAdc = NULL;
208 delete [] fHodoVelFit; fHodoVelFit = NULL;
209 delete [] fHodoCableFit; fHodoCableFit = NULL;
210 delete [] fHodo_LCoeff; fHodo_LCoeff = NULL;
211 delete [] fHodoPos_c1; fHodoPos_c1 = NULL;
212 delete [] fHodoNeg_c1; fHodoNeg_c1 = NULL;
213 delete [] fHodoPos_c2; fHodoPos_c2 = NULL;
214 delete [] fHodoNeg_c2; fHodoNeg_c2 = NULL;
215
216
217 delete [] fHodoVelLight; fHodoVelLight = NULL;
218 delete [] fHodoSigma; fHodoSigma = NULL;
219
220 delete [] fPosPedSum; fPosPedSum = 0;
221 delete [] fPosPedSum2; fPosPedSum2 = 0;
222 delete [] fPosPedLimit; fPosPedLimit = 0;
223 delete [] fPosPedCount; fPosPedCount = 0;
224 delete [] fNegPedSum; fNegPedSum = 0;
225 delete [] fNegPedSum2; fNegPedSum2 = 0;
226 delete [] fNegPedLimit; fNegPedLimit = 0;
227 delete [] fNegPedCount; fNegPedCount = 0;
228 delete [] fPosPed; fPosPed = 0;
229 delete [] fNegPed; fNegPed = 0;
230 delete [] fPosThresh; fPosThresh = 0;
231 delete [] fNegThresh; fNegThresh = 0;
232}
233
234//______________________________________________________________________________
235THaAnalysisObject::EStatus THcScintillatorPlane::Init( const TDatime& date )
236{
237
238 // cout << "THcScintillatorPlane::Init called " << GetName() << endl;
239
240 if( IsZombie())
241 return fStatus = kInitError;
242
243 // How to get information for parent
244 // if( GetParent() )
245 // fOrigin = GetParent()->GetOrigin();
246
247 EStatus status;
248 if( (status=THaSubDetector::Init( date )) )
249 return fStatus = status;
250
251 // Get the Hodoscope hitlist
252 // Can't seem to cast to THcHitList. What to do if we want to use
253 // THcScintillatorPlane as a subdetector to other than THcHodoscope?
254 // fParentHitList = static_cast<THcHodoscope*>(GetParent())->GetHitList();
255
256 return fStatus = kOK;
257
258}
259
260//_____________________________________________________________________________
261Int_t THcScintillatorPlane::ReadDatabase( const TDatime& date )
262{
263
264 // See what file it looks for
265
266 // static const char* const here = "ReadDatabase()";
267 char prefix[2];
268
269 prefix[0]=tolower(GetParent()->GetPrefix()[0]);
270 prefix[1]='\0';
271
272 // need this further down so read them first! GN
273 string parname = "scin_" + string(GetName()) + "_nr";
274 DBRequest list_1[] = {
275 {parname.c_str(), &fNelem, kInt},
276 {0}
277 };
278 gHcParms->LoadParmValues(list_1, prefix);
279
280 // Based on the signs of these quantities in the .pos file the correspondence
281 // should be bot=>left and top=>right when comparing x and y-type scintillators
282 char tmpleft[6], tmpright[6];
283 if (fPlaneNum==1 || fPlaneNum==3) {
284 strcpy(tmpleft,"left");
285 strcpy(tmpright,"right");
286 }
287 else {
288 strcpy(tmpleft,"bot");
289 strcpy(tmpright,"top");
290 }
291
292 delete [] fPosCenter; fPosCenter = new Double_t[fNelem];
293
294 DBRequest list[]={
295 {Form("scin_%s_zpos",GetName()), &fZpos, kDouble},
296 {Form("scin_%s_dzpos",GetName()), &fDzpos, kDouble},
297 {Form("scin_%s_size",GetName()), &fSize, kDouble},
298 {Form("scin_%s_spacing",GetName()), &fSpacing, kDouble},
299 {Form("scin_%s_%s",GetName(),tmpleft), &fPosLeft,kDouble},
300 {Form("scin_%s_%s",GetName(),tmpright), &fPosRight,kDouble},
301 {Form("scin_%s_offset",GetName()), &fPosOffset, kDouble},
302 {Form("scin_%s_center",GetName()), fPosCenter,kDouble,fNelem},
303 {"tofusinginvadc", &fTofUsingInvAdc, kInt, 0, 1},
304 {"hodo_adc_mode", &fADCMode, kInt, 0, 1},
305 {"hodo_pedestal_scale", &fADCPedScaleFactor, kDouble, 0, 1},
306 {"hodo_adc_diag_cut", &fADCDiagCut, kInt, 0, 1},
307 {"cosmicflag", &fCosmicFlag, kInt, 0, 1},
308 {"hodo_debug_adc", &fDebugAdc, kInt, 0, 1},
309 {"hodo_SampThreshold", &fSampThreshold, kDouble,0,1},
310 {"hodo_SampNSA", &fSampNSA, kInt,0,1},
311 {"hodo_SampNSAT", &fSampNSAT, kInt,0,1},
312 {"hodo_SampNSB", &fSampNSB, kInt,0,1},
313 {"hodo_OutputSampWaveform", &fOutputSampWaveform, kInt,0,1},
314 {"hodo_UseSampWaveform", &fUseSampWaveform, kInt,0,1},
315 {0}
316 };
317
318 fDebugAdc = 0; // Set ADC debug parameter to false unless set in parameter file
319 fTofUsingInvAdc = 1;
320 //fADCMode = kADCStandard;
321 fADCMode = kADCDynamicPedestal;
322 fADCPedScaleFactor = 1.0;
323 fADCDiagCut = 50.0;
324 fCosmicFlag=0;
325
326 fSampThreshold = 5.;
327 fSampNSA = 0; // use value stored in event 125 info
328 fSampNSB = 0; // use value stored in event 125 info
329 fSampNSAT = 2; // default value in THcRawHit::SetF250Params
330 fOutputSampWaveform = 0; // 0= no output , 1 = output Sample Waveform
331 fUseSampWaveform = 0; // 0= do not use , 1 = use Sample Waveform
332
333 gHcParms->LoadParmValues((DBRequest*)&list,prefix);
334 if (fCosmicFlag==1) cout << " setup for cosmics in scint plane"<< endl;
335 // cout << " cosmic flag = " << fCosmicFlag << endl;
336 // fetch the parameter from the temporary list
337
338 // Retrieve parameters we need from parent class
339 // Common for all planes
340
341 THcHodoscope* parent = (THcHodoscope*)GetParent();
342 fHodoSlop= parent->GetHodoSlop(fPlaneNum-1);
343 fTdcOffset= parent->GetTdcOffset(fPlaneNum-1);
344 fAdcTdcOffset= parent->GetAdcTdcOffset(fPlaneNum-1);
345 fScinTdcMin=parent->GetTdcMin();
346 fScinTdcMax=parent->GetTdcMax();
347 fScinTdcToTime=parent->GetTdcToTime();
348 fTofTolerance=parent->GetTofTolerance();
349 fBetaNominal=parent->GetBetaNominal();
350 fStartTimeCenter=parent->GetStartTimeCenter();
351 fStartTimeSlop=parent->GetStartTimeSlop();
352 // Parameters for this plane
353 fHodoPosMinPh = new Double_t[fNelem];
354 fHodoNegMinPh = new Double_t[fNelem];
355 fHodoPosPhcCoeff = new Double_t[fNelem];
356 fHodoNegPhcCoeff = new Double_t[fNelem];
357 fHodoPosTimeOffset = new Double_t[fNelem];
358 fHodoNegTimeOffset = new Double_t[fNelem];
359 fHodoVelLight = new Double_t[fNelem];
360 fHodoPosInvAdcOffset = new Double_t[fNelem];
361 fHodoNegInvAdcOffset = new Double_t[fNelem];
362 fHodoPosInvAdcLinear = new Double_t[fNelem];
363 fHodoNegInvAdcLinear = new Double_t[fNelem];
364 fHodoPosAdcTimeWindowMin = new Double_t[fNelem];
365 fHodoNegAdcTimeWindowMin = new Double_t[fNelem];
366 fHodoPosAdcTimeWindowMax = new Double_t[fNelem];
367 fHodoNegAdcTimeWindowMax = new Double_t[fNelem];
368 fHodoPosInvAdcAdc = new Double_t[fNelem];
369 fHodoNegInvAdcAdc = new Double_t[fNelem];
370 fHodoSigma = new Double_t[fNelem];
371
372 //New Time-Walk Calibration Parameters
373 fHodoVelFit=new Double_t [fNelem];
374 fHodoCableFit=new Double_t [fNelem];
375 fHodo_LCoeff=new Double_t [fNelem];
376 fHodoPos_c1=new Double_t [fNelem];
377 fHodoNeg_c1=new Double_t [fNelem];
378 fHodoPos_c2=new Double_t [fNelem];
379 fHodoNeg_c2=new Double_t [fNelem];
380
381 for(Int_t j=0;j<(Int_t) fNelem;j++) {
382 Int_t index=parent->GetScinIndex(fPlaneNum-1,j);
383 fHodoPosAdcTimeWindowMin[j] = parent->GetHodoPosAdcTimeWindowMin(index);
384 fHodoPosAdcTimeWindowMax[j] = parent->GetHodoPosAdcTimeWindowMax(index);
385 fHodoNegAdcTimeWindowMin[j] = parent->GetHodoNegAdcTimeWindowMin(index);
386 fHodoNegAdcTimeWindowMax[j] = parent->GetHodoNegAdcTimeWindowMax(index);
387 fHodoPosMinPh[j] = parent->GetHodoPosMinPh(index);
388 fHodoNegMinPh[j] = parent->GetHodoNegMinPh(index);
389 fHodoPosPhcCoeff[j] = parent->GetHodoPosPhcCoeff(index);
390 fHodoNegPhcCoeff[j] = parent->GetHodoNegPhcCoeff(index);
391 fHodoPosTimeOffset[j] = parent->GetHodoPosTimeOffset(index);
392 fHodoNegTimeOffset[j] = parent->GetHodoNegTimeOffset(index);
393 fHodoPosInvAdcOffset[j] = parent->GetHodoPosInvAdcOffset(index);
394 fHodoNegInvAdcOffset[j] = parent->GetHodoNegInvAdcOffset(index);
395 fHodoPosInvAdcLinear[j] = parent->GetHodoPosInvAdcLinear(index);
396 fHodoNegInvAdcLinear[j] = parent->GetHodoNegInvAdcLinear(index);
397 fHodoPosInvAdcAdc[j] = parent->GetHodoPosInvAdcAdc(index);
398 fHodoNegInvAdcAdc[j] = parent->GetHodoNegInvAdcAdc(index);
399 fHodoVelLight[j] = parent->GetHodoVelLight(index);
400 //Get Time-Walk correction param
401 fHodoVelFit[j] = parent->GetHodoVelFit(index);
402 fHodoCableFit[j] = parent->GetHodoCableFit(index);
403 fHodo_LCoeff[j] = parent->GetHodoLCoeff(index);
404 fHodoPos_c1[j] = parent->GetHodoPos_c1(index);
405 fHodoNeg_c1[j] = parent->GetHodoNeg_c1(index);
406 fHodoPos_c2[j] = parent->GetHodoPos_c2(index);
407 fHodoNeg_c2[j] = parent->GetHodoNeg_c2(index);
408
409 Double_t possigma = parent->GetHodoPosSigma(index);
410 Double_t negsigma = parent->GetHodoNegSigma(index);
411 fHodoSigma[j] = TMath::Sqrt(possigma*possigma+negsigma*negsigma)/2.0;
412
413
414
415
416 }
417
418 fTdc_Thrs = parent->GetTDCThrs();
419 // cout <<" plane num = "<<fPlaneNum<<endl;
420 // cout <<" nelem = "<<fNelem<<endl;
421 // cout <<" zpos = "<<fZpos<<endl;
422 // cout <<" dzpos = "<<fDzpos<<endl;
423 // cout <<" spacing = "<<fSpacing<<endl;
424 // cout <<" size = "<<fSize<<endl;
425 // cout <<" hodoslop = "<<fHodoSlop<<endl;
426 // cout <<"PosLeft = "<<fPosLeft<<endl;
427 // cout <<"PosRight = "<<fPosRight<<endl;
428 // cout <<"PosOffset = "<<fPosOffset<<endl;
429 // cout <<"PosCenter[0] = "<<fPosCenter[0]<<endl;
430
431 // Think we will make special methods to pass most
432 // How generic do we want to make this class?
433 // The way we get parameter data is going to be pretty specific to
434 // our parameter file naming conventions. But on the other hand,
435 // the Hall A analyzer read database is pretty specific.
436 // Is there any way for this class to know which spectrometer he
437 // belongs too?
438
439 // Create arrays to hold results here
440 InitializePedestals();
441
442
443 fNumGoodPosAdcHits = vector<Int_t> (fNelem, 0.0);
444 fNumGoodNegAdcHits = vector<Int_t> (fNelem, 0.0);
445 fNumGoodPosTdcHits = vector<Int_t> (fNelem, 0.0);
446 fNumGoodNegTdcHits = vector<Int_t> (fNelem, 0.0);
447
448 fGoodPosAdcPed = vector<Double_t> (fNelem, 0.0);
449 fGoodNegAdcPed = vector<Double_t> (fNelem, 0.0);
450 fGoodPosAdcMult = vector<Double_t> (fNelem, 0.0);
451 fGoodNegAdcMult = vector<Double_t> (fNelem, 0.0);
452 fGoodPosAdcHitUsed = vector<Double_t> (fNelem, 0.0);
453 fGoodNegAdcHitUsed = vector<Double_t> (fNelem, 0.0);
454 fGoodPosAdcPulseAmp = vector<Double_t> (fNelem, 0.0);
455 fGoodNegAdcPulseAmp = vector<Double_t> (fNelem, 0.0);
456 fGoodPosAdcPulseInt = vector<Double_t> (fNelem, 0.0);
457 fGoodNegAdcPulseInt = vector<Double_t> (fNelem, 0.0);
458 fGoodPosAdcPulseTime = vector<Double_t> (fNelem, 0.0);
459 fGoodNegAdcPulseTime = vector<Double_t> (fNelem, 0.0);
460 fGoodPosAdcTdcDiffTime = vector<Double_t> (fNelem, 0.0);
461 fGoodNegAdcTdcDiffTime = vector<Double_t> (fNelem, 0.0);
462
463 fGoodPosTdcTimeUnCorr = vector<Double_t> (fNelem, 0.0);
464 fGoodNegTdcTimeUnCorr = vector<Double_t> (fNelem, 0.0);
465 fGoodPosTdcTimeCorr = vector<Double_t> (fNelem, 0.0);
466 fGoodNegTdcTimeCorr = vector<Double_t> (fNelem, 0.0);
467 fGoodPosTdcTimeTOFCorr = vector<Double_t> (fNelem, 0.0);
468 fGoodNegTdcTimeTOFCorr = vector<Double_t> (fNelem, 0.0);
469 fGoodPosTdcTimeWalkCorr = vector<Double_t> (fNelem, 0.0);
470 fGoodNegTdcTimeWalkCorr = vector<Double_t> (fNelem, 0.0);
471 fGoodDiffDistTrack = vector<Double_t> (fNelem, 0.0);
472 return kOK;
473}
474//_____________________________________________________________________________
475Int_t THcScintillatorPlane::DefineVariables( EMode mode )
476{
481 // cout << "THcScintillatorPlane::DefineVariables called " << GetName() << endl;
482
483 if( mode == kDefine && fIsSetup ) return kOK;
484 fIsSetup = ( mode == kDefine );
485
486 // Register variables in global list
487
488 if (fDebugAdc) {
489 RVarDef vars[] = {
490 {"posAdcErrorFlag", "Error Flag for When FPGA Fails", "frPosAdcErrorFlag.THcSignalHit.GetData()"},
491 {"negAdcErrorFlag", "Error Flag for When FPGA Fails", "frNegAdcErrorFlag.THcSignalHit.GetData()"},
492
493 {"posTdcTimeRaw", "List of positive raw TDC values.", "frPosTdcTimeRaw.THcSignalHit.GetData()"},
494 {"posAdcPedRaw", "List of positive raw ADC pedestals", "frPosAdcPedRaw.THcSignalHit.GetData()"},
495 {"posAdcPulseIntRaw", "List of positive raw ADC pulse integrals.", "frPosAdcPulseIntRaw.THcSignalHit.GetData()"},
496 {"posAdcPulseAmpRaw", "List of positive raw ADC pulse amplitudes.", "frPosAdcPulseAmpRaw.THcSignalHit.GetData()"},
497 {"posAdcPulseTimeRaw", "List of positive raw ADC pulse times.", "frPosAdcPulseTimeRaw.THcSignalHit.GetData()"},
498
499 {"posTdcTime", "List of positive TDC values.", "frPosTdcTime.THcSignalHit.GetData()"},
500 {"posAdcPed", "List of positive ADC pedestals", "frPosAdcPed.THcSignalHit.GetData()"},
501 {"posAdcPulseInt", "List of positive ADC pulse integrals.", "frPosAdcPulseInt.THcSignalHit.GetData()"},
502 {"posAdcPulseAmp", "List of positive ADC pulse amplitudes.", "frPosAdcPulseAmp.THcSignalHit.GetData()"},
503 {"posAdcPulseTime", "List of positive ADC pulse times.", "frPosAdcPulseTime.THcSignalHit.GetData()"},
504
505 {"posAdcSampPedRaw", "Positive Raw Samp ADC pedestals", "frPosAdcSampPedRaw.THcSignalHit.GetData()"},
506 {"posAdcSampPulseIntRaw", "Positive Raw Samp ADC pulse integrals", "frPosAdcSampPulseIntRaw.THcSignalHit.GetData()"},
507 {"posAdcSampPulseAmpRaw", "Positive Raw Samp ADC pulse amplitudes", "frPosAdcSampPulseAmpRaw.THcSignalHit.GetData()"},
508 {"posAdcSampPulseTimeRaw", "Positive Raw Samp ADC pulse times", "frPosAdcSampPulseTimeRaw.THcSignalHit.GetData()"},
509 {"posAdcSampPed", "Positive Samp ADC pedestals", "frPosAdcSampPed.THcSignalHit.GetData()"},
510 {"posAdcSampPulseInt", "Positive Samp ADC pulse integrals", "frPosAdcSampPulseInt.THcSignalHit.GetData()"},
511 {"posAdcSampPulseAmp", "Positive Samp ADC pulse amplitudes", "frPosAdcSampPulseAmp.THcSignalHit.GetData()"},
512 {"posAdcSampPulseTime", "Positive Samp ADC pulse times", "frPosAdcSampPulseTime.THcSignalHit.GetData()"},
513
514 {"negTdcTimeRaw", "List of negative raw TDC values.", "frNegTdcTimeRaw.THcSignalHit.GetData()"},
515 {"negAdcPedRaw", "List of negative raw ADC pedestals", "frNegAdcPedRaw.THcSignalHit.GetData()"},
516 {"negAdcPulseIntRaw", "List of negative raw ADC pulse integrals.", "frNegAdcPulseIntRaw.THcSignalHit.GetData()"},
517 {"negAdcPulseAmpRaw", "List of negative raw ADC pulse amplitudes.", "frNegAdcPulseAmpRaw.THcSignalHit.GetData()"},
518 {"negAdcPulseTimeRaw", "List of negative raw ADC pulse times.", "frNegAdcPulseTimeRaw.THcSignalHit.GetData()"},
519
520 {"negTdcTime", "List of negative TDC values.", "frNegTdcTime.THcSignalHit.GetData()"},
521 {"negAdcPed", "List of negative ADC pedestals", "frNegAdcPed.THcSignalHit.GetData()"},
522 {"negAdcPulseInt", "List of negative ADC pulse integrals.", "frNegAdcPulseInt.THcSignalHit.GetData()"},
523 {"negAdcPulseAmp", "List of negative ADC pulse amplitudes.", "frNegAdcPulseAmp.THcSignalHit.GetData()"},
524 {"negAdcPulseTime", "List of negative ADC pulse times.", "frNegAdcPulseTime.THcSignalHit.GetData()"},
525
526 {"negAdcSampPedRaw", "Negative Raw Samp ADC pedestals", "frNegAdcSampPedRaw.THcSignalHit.GetData()"},
527 {"negAdcSampPulseIntRaw", "Negative Raw Samp ADC pulse integrals", "frNegAdcSampPulseIntRaw.THcSignalHit.GetData()"},
528 {"negAdcSampPulseAmpRaw", "Negative Raw Samp ADC pulse amplitudes", "frNegAdcSampPulseAmpRaw.THcSignalHit.GetData()"},
529 {"negAdcSampPulseTimeRaw", "Negative Raw Samp ADC pulse times", "frNegAdcSampPulseTimeRaw.THcSignalHit.GetData()"},
530 {"negAdcSampPed", "Negative Samp ADC pedestals", "frNegAdcSampPed.THcSignalHit.GetData()"},
531 {"negAdcSampPulseInt", "Negative Samp ADC pulse integrals", "frNegAdcSampPulseInt.THcSignalHit.GetData()"},
532 {"negAdcSampPulseAmp", "Negative Samp ADC pulse amplitudes", "frNegAdcSampPulseAmp.THcSignalHit.GetData()"},
533 {"negAdcSampPulseTime", "Negative Samp ADC pulse times", "frNegAdcSampPulseTime.THcSignalHit.GetData()"},
534
535 {"totNumPosAdcHits", "Total Number of Positive ADC Hits", "fTotNumPosAdcHits"}, // Hodo+ raw ADC multiplicity Int_t
536 {"totNumNegAdcHits", "Total Number of Negative ADC Hits", "fTotNumNegAdcHits"}, // Hodo- raw ADC multiplicity ""
537 {"totNumAdcHits", "Total Number of PMTs Hit (as measured by ADCs)", "fTotNumAdcHits"}, // Hodo raw ADC multiplicity ""
538
539 {"totNumPosTdcHits", "Total Number of Positive TDC Hits", "fTotNumPosTdcHits"}, // Hodo+ raw TDC multiplicity ""
540 {"totNumNegTdcHits", "Total Number of Negative TDC Hits", "fTotNumNegTdcHits"}, // Hodo- raw TDC multiplicity ""
541 {"totNumTdcHits", "Total Number of PMTs Hits (as measured by TDCs)", "fTotNumTdcHits"}, // Hodo raw TDC multiplicity ""
542 { 0 }
543 };
544 DefineVarsFromList( vars, mode);
545 } //end debug statement
546
547 if (fOutputSampWaveform==1) {
548 RVarDef vars[] = {
549 {"adcNegSampWaveform", "FADC Neg ADCSample Waveform", "fNegAdcSampWaveform"},
550 {"adcPosSampWaveform", "FADC Pos ADCSample Waveform", "fPosAdcSampWaveform"},
551 { 0 }
552 };
553 DefineVarsFromList( vars, mode);
554 }
555
556 RVarDef vars[] = {
557 {"nhits", "Number of paddle hits (passed TDC && ADC Min and Max cuts for either end)", "GetNScinHits() "},
558
559 {"posTdcCounter", "List of positive TDC counter numbers.", "frPosTdcTimeRaw.THcSignalHit.GetPaddleNumber()"}, //Hodo+ raw TDC occupancy
560 {"posAdcCounter", "List of positive ADC counter numbers.", "frPosAdcPulseIntRaw.THcSignalHit.GetPaddleNumber()"}, //Hodo+ raw ADC occupancy
561 {"negTdcCounter", "List of negative TDC counter numbers.", "frNegTdcTimeRaw.THcSignalHit.GetPaddleNumber()"}, //Hodo- raw TDC occupancy
562 {"negAdcCounter", "List of negative ADC counter numbers.", "frNegAdcPulseIntRaw.THcSignalHit.GetPaddleNumber()"}, //Hodo- raw ADC occupancy
563
564 {"fptime", "Time at focal plane", "GetFpTime()"},
565
566 {"numGoodPosAdcHits", "Number of Good Positive ADC Hits Per PMT", "fNumGoodPosAdcHits"}, // Hodo+ good ADC occupancy - vector<Int_t>
567 {"numGoodNegAdcHits", "Number of Good Negative ADC Hits Per PMT", "fNumGoodNegAdcHits"}, // Hodo- good ADC occupancy - vector <Int_t>
568
569 {"numGoodPosTdcHits", "Number of Good Positive TDC Hits Per PMT", "fNumGoodPosTdcHits"}, // Hodo+ good TDC occupancy - vector<Int_t>
570 {"numGoodNegTdcHits", "Number of Good Negative TDC Hits Per PMT", "fNumGoodNegTdcHits"}, // Hodo- good TDC occupancy - vector <Int_t>
571
572
573 {"totNumGoodPosAdcHits", "Total Number of Good Positive ADC Hits", "fTotNumGoodPosAdcHits"}, // Hodo+ good ADC multiplicity - Int_t
574 {"totNumGoodNegAdcHits", "Total Number of Good Negative ADC Hits", "fTotNumGoodNegAdcHits"}, // Hodo- good ADC multiplicity - Int_t
575 {"totNumGoodAdcHits", "TotalNumber of Good ADC Hits Per PMT", "fTotNumGoodAdcHits"}, // Hodo good ADC multiplicity - Int_t
576
577 {"totNumGoodPosTdcHits", "Total Number of Good Positive TDC Hits", "fTotNumGoodPosTdcHits"}, // Hodo+ good TDC multiplicity - Int_t
578 {"totNumGoodNegTdcHits", "Total Number of Good Negative TDC Hits", "fTotNumGoodNegTdcHits"}, // Hodo- good TDC multiplicity - Int_t
579 {"totNumGoodTdcHits", "TotalNumber of Good TDC Hits Per PMT", "fTotNumGoodTdcHits"}, // Hodo good TDC multiplicity - Int_t
580
581
582
583 // {"GoodPaddle", "List of Paddle Numbers (passed TDC && ADC Min and Max cuts for either end)", "fHodoHits.THcHodoHit.GetPaddleNumber()"},
584
585 {"GoodPosAdcPed", "List of Positive ADC pedestals (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcPed"}, //vector<Double_t>
586 {"GoodNegAdcPed", "List of Negative ADC pedestals (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcPed"}, //vector<Double_t>
587 {"GoodPosAdcMult", "List of Positive ADC Mult (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcMult"}, //vector<Double_t>
588 {"GoodNegAdcMult", "List of Negative ADC Mult (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcMult"}, //vector<Double_t>
589 {"GoodPosAdcHitUsed", "List of Positive ADC Hit Used (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcHitUsed"}, //vector<Double_t>
590 {"GoodNegAdcHitUsed", "List of Negative ADC Hit Used (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcHitUsed"}, //vector<Double_t>
591
592 {"GoodNegTdcTimeUnCorr", "List of negative TDC values (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegTdcTimeUnCorr"}, //Units ns
593 {"GoodNegTdcTimeCorr", "List of negative corrected TDC values (corrected for PMT offset and ADC)", "fGoodNegTdcTimeCorr"},
594 {"GoodNegTdcTimeTOFCorr", "List of negative corrected TDC values (corrected for TOF)", "fGoodNegTdcTimeTOFCorr"},
595 {"GoodNegTdcTimeWalkCorr", "List of negative corrected TDC values (corrected for Time-Walk)", "fGoodNegTdcTimeWalkCorr"},
596 {"GoodNegAdcPulseInt", "List of negative ADC values (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcPulseInt"},
597 {"GoodPosTdcTimeUnCorr", "List of positive TDC values (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosTdcTimeUnCorr"},
598 {"GoodPosTdcTimeCorr", "List of positive corrected TDC values (corrected for PMT offset and ADC)", "fGoodPosTdcTimeCorr"},
599 {"GoodPosTdcTimeTOFCorr", "List of positive corrected TDC values (corrected for TOF)", "fGoodPosTdcTimeTOFCorr"},
600 {"GoodPosTdcTimeWalkCorr", "List of positive corrected TDC values (corrected for Time-Walk)", "fGoodPosTdcTimeWalkCorr"},
601 {"GoodPosAdcPulseInt", "List of positive ADC values (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcPulseInt"},
602 {"GoodPosAdcPulseAmp", "List of positive ADC peak amp (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcPulseAmp"},
603 {"GoodNegAdcPulseAmp", "List of Negative ADC peak amp (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcPulseAmp"},
604 {"GoodPosAdcPulseTime", "List of positive ADC time (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcPulseTime"},
605 {"GoodNegAdcPulseTime", "List of Negative ADC time (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcPulseTime"},
606 {"GoodPosAdcTdcDiffTime", "List of positive TDC - ADC time (passed TDC && ADC Min and Max cuts for either end)", "fGoodPosAdcTdcDiffTime"},
607 {"GoodNegAdcTdcDiffTime", "List of Negative TDC - ADC time (passed TDC && ADC Min and Max cuts for either end)", "fGoodNegAdcTdcDiffTime"},
608 {"DiffDisTrack", "Difference between track and scintillator position (cm)", "fHitDistance"},
609 {"DiffDisTrackCorr", "TW Corrected Dist Difference between track and scintillator position (cm)", "fGoodDiffDistTrack"},
610 {"TrackXPos", "Track X position at plane (cm)", "fTrackXPosition"},
611 {"TrackYPos", "Track Y position at plane (cm)", "fTrackYPosition"},
612 {"ScinXPos", "Scint Average Y position at plane (cm)", "fScinXPos"},
613 {"ScinYPos", "Scint Average Xposition at plane (cm)", "fScinYPos"},
614 {"NumClus", "Number of clusters", "fNumberClusters"},
615 {"Clus.Pos", "Position of each paddle clusters", "fCluster.THcScintPlaneCluster.GetClusterPosition()"},
616 {"Clus.Size", "Size of each paddle clusters", "fCluster.THcScintPlaneCluster.GetClusterSize()"},
617 {"Clus.Flag", "Flag of each paddle clusters", "fCluster.THcScintPlaneCluster.GetClusterFlag()"},
618 {"Clus.UsedFlag", "USed Flag of each paddle clusters", "fCluster.THcScintPlaneCluster.GetClusterUsedFlag()"},
619 {"PosTdcRefTime", "Reference time of Pos TDC", "fPosTdcRefTime"},
620 {"NegTdcRefTime", "Reference time of Neg TDC", "fNegTdcRefTime"},
621 {"PosAdcRefTime", "Reference time of Pos ADC", "fPosAdcRefTime"},
622 {"NegAdcRefTime", "Reference time of Neg aDC", "fNegAdcRefTime"},
623 {"PosTdcRefDiffTime", "Reference Diff time of Pos TDC", "fPosTdcRefDiffTime"},
624 {"NegTdcRefDiffTime", "Reference Diff time of Neg TDC", "fNegTdcRefDiffTime"},
625 {"PosAdcRefDiffTime", "Reference Diff time of Pos ADC", "fPosAdcRefDiffTime"},
626 {"NegAdcRefDiffTime", "Reference Diff time of Neg aDC", "fNegAdcRefDiffTime"},
627 //{"ngoodhits", "Number of paddle hits (passed tof tolerance and used to determine the focal plane time )", "GetNGoodHits() "},
628 { 0 }
629 };
630
631 return DefineVarsFromList(vars, mode);
632
633}
634//_____________________________________________________________________________
635void THcScintillatorPlane::Clear( Option_t* )
636{
641 //cout << " Calling THcScintillatorPlane::Clear " << GetName() << endl;
642 // Clears the hit lists
643 fCluster->Clear();
644
645 frPosAdcErrorFlag->Clear();
646 frNegAdcErrorFlag->Clear();
647
648 fHodoHits->Clear();
649 frPosTDCHits->Clear();
650 frNegTDCHits->Clear();
651 frPosADCHits->Clear();
652 frNegADCHits->Clear();
653
654 frPosTdcTimeRaw->Clear();
655 frPosAdcPedRaw->Clear();
656 frPosAdcPulseIntRaw->Clear();
657 frPosAdcPulseAmpRaw->Clear();
658 frPosAdcPulseTimeRaw->Clear();
659
660 frPosTdcTime->Clear();
661 frPosAdcPed->Clear();
662 frPosAdcPulseInt->Clear();
663 frPosAdcPulseAmp->Clear();
664 frPosAdcPulseTime->Clear();
665
666 frPosAdcSampPedRaw->Clear();
667 frPosAdcSampPulseIntRaw->Clear();
668 frPosAdcSampPulseAmpRaw->Clear();
669 frPosAdcSampPulseTimeRaw->Clear();
670 frPosAdcSampPed->Clear();
671 frPosAdcSampPulseInt->Clear();
672 frPosAdcSampPulseAmp->Clear();
673 frPosAdcSampPulseTime->Clear();
674
675 frNegTdcTimeRaw->Clear();
676 frNegAdcPedRaw->Clear();
677 frNegAdcPulseIntRaw->Clear();
678 frNegAdcPulseAmpRaw->Clear();
679 frNegAdcPulseTimeRaw->Clear();
680
681 frNegTdcTime->Clear();
682 frNegAdcPed->Clear();
683 frNegAdcPulseInt->Clear();
684 frNegAdcPulseAmp->Clear();
685 frNegAdcPulseTime->Clear();
686
687 frNegAdcSampPedRaw->Clear();
688 frNegAdcSampPulseIntRaw->Clear();
689 frNegAdcSampPulseAmpRaw->Clear();
690 frNegAdcSampPulseTimeRaw->Clear();
691 frNegAdcSampPed->Clear();
692 frNegAdcSampPulseInt->Clear();
693 frNegAdcSampPulseAmp->Clear();
694 frNegAdcSampPulseTime->Clear();
695
696
697 //Clear occupancies
698 for (UInt_t ielem = 0; ielem < fNumGoodPosAdcHits.size(); ielem++)
699 fNumGoodPosAdcHits.at(ielem) = 0;
700 for (UInt_t ielem = 0; ielem < fNumGoodNegAdcHits.size(); ielem++)
701 fNumGoodNegAdcHits.at(ielem) = 0;
702
703 for (UInt_t ielem = 0; ielem < fNumGoodPosTdcHits.size(); ielem++)
704 fNumGoodPosTdcHits.at(ielem) = 0;
705 for (UInt_t ielem = 0; ielem < fNumGoodNegTdcHits.size(); ielem++)
706 fNumGoodNegTdcHits.at(ielem) = 0;
707
708 //Clear Ped/Amps/Int/Time
709 for (UInt_t ielem = 0; ielem < fGoodPosAdcPed.size(); ielem++) {
710 fGoodPosAdcPed.at(ielem) = 0.0;
711 fGoodPosAdcMult.at(ielem) = 0.0;
712 fGoodPosAdcHitUsed.at(ielem) = 0.0;
713 fGoodPosAdcPulseInt.at(ielem) = 0.0;
714 fGoodPosAdcPulseAmp.at(ielem) = 0.0;
715 fGoodPosAdcPulseTime.at(ielem) = kBig;
716 fGoodPosAdcTdcDiffTime.at(ielem) = kBig;
717 }
718 for (UInt_t ielem = 0; ielem < fGoodNegAdcPed.size(); ielem++) {
719 fGoodNegAdcPed.at(ielem) = 0.0;
720 fGoodNegAdcMult.at(ielem) = 0.0;
721 fGoodNegAdcHitUsed.at(ielem) = 0.0;
722 fGoodNegAdcPulseInt.at(ielem) = 0.0;
723 fGoodNegAdcPulseAmp.at(ielem) = 0.0;
724 fGoodNegAdcPulseTime.at(ielem) = kBig;
725 fGoodNegAdcTdcDiffTime.at(ielem) = kBig;
726 }
727
728 //Clear Good TDC Variables
729 for (UInt_t ielem = 0; ielem < fGoodPosTdcTimeUnCorr.size(); ielem++) {
730 fGoodPosTdcTimeUnCorr.at(ielem) = kBig;
731 fGoodPosTdcTimeCorr.at(ielem) = kBig;
732 fGoodPosTdcTimeTOFCorr.at(ielem) = kBig;
733 fGoodPosTdcTimeWalkCorr.at(ielem) = kBig;
734 }
735
736 for (UInt_t ielem = 0; ielem < fGoodNegTdcTimeUnCorr.size(); ielem++) {
737 fGoodNegTdcTimeUnCorr.at(ielem) = kBig;
738 fGoodNegTdcTimeCorr.at(ielem) = kBig;
739 fGoodNegTdcTimeTOFCorr.at(ielem) = kBig;
740 fGoodNegTdcTimeWalkCorr.at(ielem) = kBig;
741 }
742
743 for (UInt_t ielem = 0; ielem < fGoodDiffDistTrack.size(); ielem++) {
744 fGoodDiffDistTrack.at(ielem) = kBig;
745 }
746
747 fpTime = -1.e4;
748 fHitDistance = kBig;
749 fScinYPos = kBig;
750 fScinXPos = kBig;
751 fTrackXPosition = kBig;
752 fTrackYPosition = kBig;
753 fNumberClusters=0;
754 fPosTdcRefTime = kBig;
755 fPosAdcRefTime = kBig;
756 fNegTdcRefTime = kBig;
757 fNegAdcRefTime = kBig;
758 fPosTdcRefDiffTime = kBig;
759 fPosAdcRefDiffTime = kBig;
760 fNegTdcRefDiffTime = kBig;
761 fNegAdcRefDiffTime = kBig;
762}
763
764//_____________________________________________________________________________
765Int_t THcScintillatorPlane::Decode( const THaEvData& evdata )
766{
769 cout << " Calling THcScintillatorPlane::Decode " << GetName() << endl;
770
771 return 0;
772}
773//_____________________________________________________________________________
774Int_t THcScintillatorPlane::CoarseProcess( TClonesArray& tracks )
775{
779 cout <<"*******************************\n";
780 cout <<"NOW IN THcScintilatorPlane::CoarseProcess!!!!\n";
781 cout <<"*******************************\n";
782 // HitCount();
783
784 return 0;
785}
786
787//_____________________________________________________________________________
788Int_t THcScintillatorPlane::FineProcess( TClonesArray& tracks )
789{
792 return 0;
793}
794
795
796//_____________________________________________________________________________
797Int_t THcScintillatorPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
798{
815 //raw
816 fPosTdcRefTime = kBig;
817 fPosAdcRefTime = kBig;
818 fNegTdcRefTime = kBig;
819 fNegAdcRefTime = kBig;
820 fPosTdcRefDiffTime = kBig;
821 fPosAdcRefDiffTime = kBig;
822 fNegTdcRefDiffTime = kBig;
823 fNegAdcRefDiffTime = kBig;
824 Int_t nrPosTDCHits=0;
825 Int_t nrNegTDCHits=0;
826 Int_t nrPosADCHits=0;
827 Int_t nrNegADCHits=0;
828 UInt_t nrPosAdcHits = 0;
829 UInt_t nrNegAdcHits = 0;
830 UInt_t nrPosTdcHits = 0;
831 UInt_t nrNegTdcHits = 0;
832 UInt_t nrSampPosAdcHits = 0;
833 UInt_t nrSampNegAdcHits = 0;
834 fPosAdcSampWaveform.clear();
835 fNegAdcSampWaveform.clear();
836 frPosTDCHits->Clear();
837 frNegTDCHits->Clear();
838 frPosADCHits->Clear();
839 frNegADCHits->Clear();
840 frPosADCSums->Clear();
841 frNegADCSums->Clear();
842 frPosADCPeds->Clear();
843 frNegADCPeds->Clear();
844
845
846 frPosTdcTimeRaw->Clear();
847 frPosAdcPedRaw->Clear();
848 frPosAdcPulseIntRaw->Clear();
849 frPosAdcPulseAmpRaw->Clear();
850 frPosAdcPulseTimeRaw->Clear();
851
852 frPosTdcTime->Clear();
853 frPosAdcPed->Clear();
854 frPosAdcPulseInt->Clear();
855 frPosAdcPulseAmp->Clear();
856 frPosAdcPulseTime->Clear();
857
858 frPosAdcSampPedRaw->Clear();
859 frPosAdcSampPulseIntRaw->Clear();
860 frPosAdcSampPulseAmpRaw->Clear();
861 frPosAdcSampPulseTimeRaw->Clear();
862 frPosAdcSampPed->Clear();
863 frPosAdcSampPulseInt->Clear();
864 frPosAdcSampPulseAmp->Clear();
865 frPosAdcSampPulseTime->Clear();
866
867 frNegTdcTimeRaw->Clear();
868 frNegAdcPedRaw->Clear();
869 frNegAdcPulseIntRaw->Clear();
870 frNegAdcPulseAmpRaw->Clear();
871 frNegAdcPulseTimeRaw->Clear();
872
873 frNegTdcTime->Clear();
874 frNegAdcPed->Clear();
875 frNegAdcPulseInt->Clear();
876 frNegAdcPulseAmp->Clear();
877 frNegAdcPulseTime->Clear();
878
879 frNegAdcSampPedRaw->Clear();
880 frNegAdcSampPulseIntRaw->Clear();
881 frNegAdcSampPulseAmpRaw->Clear();
882 frNegAdcSampPulseTimeRaw->Clear();
883 frNegAdcSampPed->Clear();
884 frNegAdcSampPulseInt->Clear();
885 frNegAdcSampPulseAmp->Clear();
886 frNegAdcSampPulseTime->Clear();
887
888 //stripped
889 fNScinHits=0;
890
891 fTotNumGoodPosAdcHits = 0;
892 fTotNumGoodNegAdcHits = 0;
893 fTotNumGoodAdcHits = 0;
894
895 fTotNumPosAdcHits = 0;
896 fTotNumNegAdcHits = 0;
897 fTotNumAdcHits = 0;
898
899
900 fTotNumPosTdcHits = 0;
901 fTotNumNegTdcHits = 0;
902 fTotNumTdcHits = 0;
903
904 fTotNumGoodPosTdcHits = 0;
905 fTotNumGoodNegTdcHits = 0;
906 fTotNumGoodTdcHits = 0;
907
908
909 fHodoHits->Clear();
910 Int_t nrawhits = rawhits->GetLast()+1;
911 // cout << "THcScintillatorPlane::ProcessHits " << fPlaneNum << " " << nexthit << "/" << nrawhits << endl;
912 Int_t ihit = nexthit;
913
914 // cout << "THcScintillatorPlane: " << GetName() << " raw hits = " << nrawhits << endl;
915
916 // A THcRawHodoHit contains all the information (tdc and adc for both
917 // pmts) for a single paddle for a single trigger. The tdc information
918 // might include multiple hits if it uses a multihit tdc.
919 // Use "ihit" as the index over THcRawHodoHit objects. Use
920 // "thit" to index over multiple tdc hits within an "ihit".
921 Bool_t problem_flag=kFALSE;
922
923 while(ihit < nrawhits) {
924
925 THcRawHodoHit* hit = (THcRawHodoHit *) rawhits->At(ihit);
926 if(hit->fPlane > fPlaneNum) {
927 break;
928 }
929 Int_t padnum=hit->fCounter;
930
931 Int_t index=padnum-1;
932
933
934 THcRawTdcHit& rawPosTdcHit = hit->GetRawTdcHitPos();
935 if (rawPosTdcHit.GetNHits() >0 && rawPosTdcHit.HasRefTime()) {
936 if (fPosTdcRefTime == kBig) {
937 fPosTdcRefTime=rawPosTdcHit.GetRefTime() ;
938 fPosTdcRefDiffTime=rawPosTdcHit.GetRefDiffTime() ;
939 }
940 if (fPosTdcRefTime != rawPosTdcHit.GetRefTime()) {
941 // cout << "THcScintillatorPlane: " << GetName() << " reftime problem at paddle num = " << padnum << " TDC pos hits = " << rawPosTdcHit.GetNHits() << endl;
942 problem_flag=kTRUE;
943 }
944 }
945 // cout << " paddle num = " << padnum << " TDC Pos hits = " << rawPosTdcHit.GetNHits() << endl;
946 for (UInt_t thit=0; thit<rawPosTdcHit.GetNHits(); ++thit) {
947 ((THcSignalHit*) frPosTdcTimeRaw->ConstructedAt(nrPosTdcHits))->Set(padnum, rawPosTdcHit.GetTimeRaw(thit));
948 ((THcSignalHit*) frPosTdcTime->ConstructedAt(nrPosTdcHits))->Set(padnum, rawPosTdcHit.GetTime(thit));
949 ++nrPosTdcHits;
950 fTotNumTdcHits++;
951 fTotNumPosTdcHits++;
952 }
953 THcRawTdcHit& rawNegTdcHit = hit->GetRawTdcHitNeg();
954 if (rawNegTdcHit.GetNHits() >0 && rawNegTdcHit.HasRefTime()) {
955 if (fNegTdcRefTime == kBig) {
956 fNegTdcRefTime=rawNegTdcHit.GetRefTime() ;
957 fNegTdcRefDiffTime=rawNegTdcHit.GetRefDiffTime() ;
958 }
959 if (fNegTdcRefTime != rawNegTdcHit.GetRefTime()) {
960 // cout << "THcScintillatorPlane: " << GetName()<< " Neg TDC reftime problem at paddle num = " << padnum << " TDC neg hits = " << rawNegTdcHit.GetNHits() << endl;
961 problem_flag=kTRUE;
962 }
963 }
964 // cout << " paddle num = " << padnum << " TDC Neg hits = " << rawNegTdcHit.GetNHits() << endl;
965 for (UInt_t thit=0; thit<rawNegTdcHit.GetNHits(); ++thit) {
966 ((THcSignalHit*) frNegTdcTimeRaw->ConstructedAt(nrNegTdcHits))->Set(padnum, rawNegTdcHit.GetTimeRaw(thit));
967 ((THcSignalHit*) frNegTdcTime->ConstructedAt(nrNegTdcHits))->Set(padnum, rawNegTdcHit.GetTime(thit));
968 ++nrNegTdcHits;
969 fTotNumTdcHits++;
970 fTotNumNegTdcHits++;
971 }
972
973 THcRawAdcHit& rawPosAdcHit = hit->GetRawAdcHitPos();
974
975 if ( (rawPosAdcHit.GetNPulses() >0 || rawPosAdcHit.GetNSamples() >0) && rawPosAdcHit.HasRefTime()) {
976 if (fPosAdcRefTime == kBig ) {
977 fPosAdcRefTime=rawPosAdcHit.GetRefTime() ;
978 fPosAdcRefDiffTime=rawPosAdcHit.GetRefDiffTime() ;
979 }
980 if (fPosAdcRefTime != rawPosAdcHit.GetRefTime()) {
981 // cout << "THcScintillatorPlane: " << GetName()<< " Pos ADC reftime problem at paddle num = " << padnum << " ADC pos hits = " << rawPosAdcHit.GetNPulses() << endl;
982 problem_flag=kTRUE;
983 }
984 }
985 // cout << " paddle num = " << padnum << " ADC Pos hits = " << rawPosAdcHit.GetNPulses() << endl;
986 if ( fUseSampWaveform == 0 ) {
987
988 for (UInt_t thit=0; thit<rawPosAdcHit.GetNPulses(); ++thit) {
989 ((THcSignalHit*) frPosAdcPedRaw->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPedRaw());
990 ((THcSignalHit*) frPosAdcPed->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPed());
991
992 ((THcSignalHit*) frPosAdcPulseIntRaw->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPulseIntRaw(thit));
993 ((THcSignalHit*) frPosAdcPulseInt->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPulseInt(thit));
994
995 ((THcSignalHit*) frPosAdcPulseAmpRaw->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPulseAmpRaw(thit));
996
997 ((THcSignalHit*) frPosAdcPulseAmp->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPulseAmp(thit));
998
999 ((THcSignalHit*) frPosAdcPulseTimeRaw->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPulseTimeRaw(thit));
1000 ((THcSignalHit*) frPosAdcPulseTime->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetPulseTime(thit)+fAdcTdcOffset);
1001
1002 if (rawPosAdcHit.GetPulseAmpRaw(thit) > 0) ((THcSignalHit*) frPosAdcErrorFlag->ConstructedAt(nrPosAdcHits))->Set(padnum, 0);
1003 if (rawPosAdcHit.GetPulseAmpRaw(thit) <= 0) ((THcSignalHit*) frPosAdcErrorFlag->ConstructedAt(nrPosAdcHits))->Set(padnum, 1);
1004 if (rawPosAdcHit.GetPulseAmpRaw(thit) <= 0 && rawPosAdcHit.GetNSamples() >0) ((THcSignalHit*) frPosAdcErrorFlag->ConstructedAt(nrPosAdcHits))->Set(padnum, 2);
1005
1006 ++nrPosAdcHits;
1007 fTotNumAdcHits++;
1008 fTotNumPosAdcHits++;
1009 }
1010 }
1011 //
1012 // cout << " paddle num = " << padnum << "Pos ADC GetNSamples = " << rawPosAdcHit.GetNSamples() << endl;
1013 if (rawPosAdcHit.GetNSamples()>0 ) {
1014 rawPosAdcHit.SetSampThreshold(fSampThreshold);
1015 if (fSampNSA == 0) fSampNSA=rawPosAdcHit.GetF250_NSA();
1016 if (fSampNSB == 0) fSampNSB=rawPosAdcHit.GetF250_NSB();
1017 rawPosAdcHit.SetF250Params(fSampNSA,fSampNSB,4); // Set NPED =4
1018 if (fSampNSAT != 2) rawPosAdcHit.SetSampNSAT(fSampNSAT);
1019 rawPosAdcHit.SetSampIntTimePedestalPeak();
1020 fPosAdcSampWaveform.push_back(float(padnum));
1021 fPosAdcSampWaveform.push_back(float(rawPosAdcHit.GetNSamples()));
1022 for (UInt_t thit = 0; thit < rawPosAdcHit.GetNSamples(); thit++) {
1023 fPosAdcSampWaveform.push_back(rawPosAdcHit.GetSample(thit)); // ped subtracted sample (mV)
1024 }
1025 for (UInt_t thit = 0; thit < rawPosAdcHit.GetNSampPulses(); thit++) {
1026 ((THcSignalHit*) frPosAdcSampPedRaw->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPedRaw());
1027 ((THcSignalHit*) frPosAdcSampPed->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPed());
1028
1029 ((THcSignalHit*) frPosAdcSampPulseIntRaw->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseIntRaw(thit));
1030 ((THcSignalHit*) frPosAdcSampPulseInt->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseInt(thit));
1031
1032 ((THcSignalHit*) frPosAdcSampPulseAmpRaw->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseAmpRaw(thit));
1033 ((THcSignalHit*) frPosAdcSampPulseAmp->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseAmp(thit));
1034 ((THcSignalHit*) frPosAdcSampPulseTimeRaw->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseTimeRaw(thit));
1035 ((THcSignalHit*) frPosAdcSampPulseTime->ConstructedAt(nrSampPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseTime(thit)+fAdcTdcOffset);
1036 //
1037 if ( rawPosAdcHit.GetNPulses() ==0 || fUseSampWaveform ==1 ) {
1038 ((THcSignalHit*) frPosAdcPedRaw->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPedRaw());
1039 ((THcSignalHit*) frPosAdcPed->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPed());
1040
1041 ((THcSignalHit*) frPosAdcPulseIntRaw->ConstructedAt(nrPosAdcHits))->Set(padnum,rawPosAdcHit.GetSampPulseIntRaw(thit));
1042 ((THcSignalHit*) frPosAdcPulseInt->ConstructedAt(nrPosAdcHits))->Set(padnum,rawPosAdcHit.GetSampPulseInt(thit));
1043
1044 ((THcSignalHit*) frPosAdcPulseAmpRaw->ConstructedAt(nrPosAdcHits))->Set(padnum,rawPosAdcHit.GetSampPulseAmpRaw(thit));
1045 ((THcSignalHit*) frPosAdcPulseAmp->ConstructedAt(nrPosAdcHits))->Set(padnum,rawPosAdcHit.GetSampPulseAmp(thit) );
1046
1047 ((THcSignalHit*) frPosAdcPulseTimeRaw->ConstructedAt(nrPosAdcHits))->Set(padnum,rawPosAdcHit.GetSampPulseTimeRaw(thit) );
1048 ((THcSignalHit*) frPosAdcPulseTime->ConstructedAt(nrPosAdcHits))->Set(padnum, rawPosAdcHit.GetSampPulseTime(thit)+fAdcTdcOffset);
1049 ((THcSignalHit*) frPosAdcErrorFlag->ConstructedAt(nrPosAdcHits))->Set(padnum, 3);
1050 if (fUseSampWaveform ==1) ((THcSignalHit*) frPosAdcErrorFlag->ConstructedAt(nrPosAdcHits))->Set(padnum, 0);
1051
1052 ++nrPosAdcHits;
1053 fTotNumPosAdcHits++;
1054 fTotNumAdcHits++;
1055 }
1056 ++nrSampPosAdcHits;
1057 }
1058 }
1059
1060
1061 THcRawAdcHit& rawNegAdcHit = hit->GetRawAdcHitNeg();
1062
1063 // cout << " paddle num = " << padnum << " ADC Neg hits = " << rawNegAdcHit.GetNPulses() << endl;
1064 if ( (rawNegAdcHit.GetNPulses()>0 || rawNegAdcHit.GetNSamples()>0) && rawNegAdcHit.HasRefTime()) {
1065 if (fNegAdcRefTime == kBig) {
1066 fNegAdcRefTime=rawNegAdcHit.GetRefTime() ;
1067 fNegAdcRefDiffTime=rawNegAdcHit.GetRefDiffTime() ;
1068 }
1069 if (fNegAdcRefTime != rawNegAdcHit.GetRefTime()) {
1070 cout << "THcScintillatorPlane: " << GetName()<< " Neg ADC reftime problem at paddle num = " << padnum << " TDC pos hits = " << rawNegAdcHit.GetNPulses() << endl;
1071 problem_flag=kTRUE;
1072 }
1073 }
1074
1075 if ( fUseSampWaveform == 0 ) {
1076 for (UInt_t thit=0; thit<rawNegAdcHit.GetNPulses(); ++thit) {
1077 // cout << "neg adc thit = " << thit << endl;
1078
1079 ((THcSignalHit*) frNegAdcPedRaw->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPedRaw());
1080 ((THcSignalHit*) frNegAdcPed->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPed());
1081
1082 ((THcSignalHit*) frNegAdcPulseIntRaw->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPulseIntRaw(thit));
1083 ((THcSignalHit*) frNegAdcPulseInt->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPulseInt(thit));
1084
1085 ((THcSignalHit*) frNegAdcPulseAmpRaw->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPulseAmpRaw(thit));
1086 ((THcSignalHit*) frNegAdcPulseAmp->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPulseAmp(thit));
1087 ((THcSignalHit*) frNegAdcPulseTimeRaw->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPulseTimeRaw(thit));
1088 ((THcSignalHit*) frNegAdcPulseTime->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetPulseTime(thit)+fAdcTdcOffset);
1089
1090 if (rawNegAdcHit.GetPulseAmpRaw(thit) > 0) ((THcSignalHit*) frNegAdcErrorFlag->ConstructedAt(nrNegAdcHits))->Set(padnum, 0);
1091 if (rawNegAdcHit.GetPulseAmpRaw(thit) <= 0) ((THcSignalHit*) frNegAdcErrorFlag->ConstructedAt(nrNegAdcHits))->Set(padnum, 1);
1092 if (rawNegAdcHit.GetPulseAmpRaw(thit) <= 0 && rawNegAdcHit.GetNSamples() >0) ((THcSignalHit*) frNegAdcErrorFlag->ConstructedAt(nrNegAdcHits))->Set(padnum, 2);
1093
1094 ++nrNegAdcHits;
1095 fTotNumAdcHits++;
1096 fTotNumNegAdcHits++;
1097 }
1098 }
1099
1100 // cout << " paddle num = " << padnum << "Neg ADC GetNSamples = " << rawNegAdcHit.GetNSamples() << endl;
1101 if (rawNegAdcHit.GetNSamples()>0 ) {
1102 rawNegAdcHit.SetSampThreshold(fSampThreshold);
1103 if (fSampNSA == 0) fSampNSA=rawNegAdcHit.GetF250_NSA();
1104 if (fSampNSB == 0) fSampNSB=rawNegAdcHit.GetF250_NSB();
1105 rawNegAdcHit.SetF250Params(fSampNSA,fSampNSB,4); // Set NPED =4
1106 if (fSampNSAT != 2) rawNegAdcHit.SetSampNSAT(fSampNSAT);
1107 rawNegAdcHit.SetSampIntTimePedestalPeak();
1108 fNegAdcSampWaveform.push_back(float(padnum));
1109 fNegAdcSampWaveform.push_back(float(rawNegAdcHit.GetNSamples()));
1110 for (UInt_t thit = 0; thit < rawNegAdcHit.GetNSamples(); thit++) {
1111 fNegAdcSampWaveform.push_back(rawNegAdcHit.GetSample(thit)); // ped subtracted sample (mV)
1112 }
1113 for (UInt_t thit = 0; thit < rawNegAdcHit.GetNSampPulses(); thit++) {
1114 ((THcSignalHit*) frNegAdcSampPedRaw->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPedRaw());
1115 ((THcSignalHit*) frNegAdcSampPed->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPed());
1116 ((THcSignalHit*) frNegAdcSampPulseIntRaw->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseIntRaw(thit));
1117 ((THcSignalHit*) frNegAdcSampPulseInt->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseInt(thit));
1118
1119 ((THcSignalHit*) frNegAdcSampPulseAmpRaw->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseAmpRaw(thit));
1120 ((THcSignalHit*) frNegAdcSampPulseAmp->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseAmp(thit));
1121 ((THcSignalHit*) frNegAdcSampPulseTimeRaw->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseTimeRaw(thit));
1122 ((THcSignalHit*) frNegAdcSampPulseTime->ConstructedAt(nrSampNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseTime(thit));
1123 //
1124 if ( rawNegAdcHit.GetNPulses() ==0 || fUseSampWaveform ==1 ) {
1125 ((THcSignalHit*) frNegAdcPedRaw->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPedRaw());
1126 ((THcSignalHit*) frNegAdcPed->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPed());
1127
1128 ((THcSignalHit*) frNegAdcPulseIntRaw->ConstructedAt(nrNegAdcHits))->Set(padnum,rawNegAdcHit.GetSampPulseIntRaw(thit));
1129 ((THcSignalHit*) frNegAdcPulseInt->ConstructedAt(nrNegAdcHits))->Set(padnum,rawNegAdcHit.GetSampPulseInt(thit));
1130
1131 ((THcSignalHit*) frNegAdcPulseAmpRaw->ConstructedAt(nrNegAdcHits))->Set(padnum,rawNegAdcHit.GetSampPulseAmpRaw(thit));
1132 ((THcSignalHit*) frNegAdcPulseAmp->ConstructedAt(nrNegAdcHits))->Set(padnum,rawNegAdcHit.GetSampPulseAmp(thit) );
1133
1134 ((THcSignalHit*) frNegAdcPulseTimeRaw->ConstructedAt(nrNegAdcHits))->Set(padnum,rawNegAdcHit.GetSampPulseTimeRaw(thit) );
1135 ((THcSignalHit*) frNegAdcPulseTime->ConstructedAt(nrNegAdcHits))->Set(padnum, rawNegAdcHit.GetSampPulseTime(thit));
1136 ((THcSignalHit*) frNegAdcErrorFlag->ConstructedAt(nrNegAdcHits))->Set(padnum, 3);
1137 if (fUseSampWaveform ==1) ((THcSignalHit*) frNegAdcErrorFlag->ConstructedAt(nrNegAdcHits))->Set(padnum, 0);
1138 ++nrNegAdcHits;
1139 fTotNumNegAdcHits++;
1140 fTotNumAdcHits++;
1141 }
1142 ++nrSampNegAdcHits;
1143 }
1144 }
1145
1146 // cout << " Finding tdc hit " << endl;
1147 // Need to be finding first hit in TDC range, not the first hit overall
1148 if (hit->GetRawTdcHitPos().GetNHits() > 0)
1149 ((THcSignalHit*) frPosTDCHits->ConstructedAt(nrPosTDCHits++))->Set(padnum, hit->GetRawTdcHitPos().GetTime()+fTdcOffset);
1150 if (hit->GetRawTdcHitNeg().GetNHits() > 0)
1151 ((THcSignalHit*) frNegTDCHits->ConstructedAt(nrNegTDCHits++))->Set(padnum, hit->GetRawTdcHitNeg().GetTime()+fTdcOffset);
1152 // Should we make lists of offset corrected ADC Pulse times here too? For now
1153 // the frNegAdcPulseTime frPosAdcPulseTime have that offset correction.
1154 //
1155 Bool_t badcraw_pos=kFALSE;
1156 Bool_t badcraw_neg=kFALSE;
1157 Double_t adcped_pos=-999;
1158 Double_t adcped_neg=-999;
1159 Int_t adcmult_pos=0;
1160 Int_t adcmult_neg=0;
1161 Int_t adchitused_pos=0;
1162 Int_t adchitused_neg=0;
1163 Double_t adcint_pos=-999;
1164 Double_t adcint_neg=-999;
1165 Double_t adcamp_pos=-kBig;
1166 Double_t adcamp_neg=-kBig;
1167 Double_t adctime_pos=kBig;
1168 Double_t adctime_neg=kBig;
1169 Double_t adctdcdifftime_pos=kBig;
1170 Double_t adctdcdifftime_neg=kBig;
1171 Double_t good_ielem_posadc = -1;
1172 Double_t good_ielem_negadc = -1;
1173 Bool_t btdcraw_pos=kFALSE;
1174 Bool_t btdcraw_neg=kFALSE;
1175 // Determine good tdc pos and neg times
1176 Int_t tdc_pos=-999;
1177 Int_t tdc_neg=-999;
1178 Double_t good_ielem_postdc = -1;
1179 Double_t good_ielem_negtdc = -1;
1180 for(UInt_t thit=0; thit<hit->GetRawTdcHitPos().GetNHits(); thit++) {
1181 tdc_pos = hit->GetRawTdcHitPos().GetTime(thit)+fTdcOffset;
1182 if(tdc_pos >= fScinTdcMin && tdc_pos <= fScinTdcMax) {
1183 btdcraw_pos = kTRUE;
1184 good_ielem_postdc = thit;
1185 break;
1186 }
1187 }
1188 for(UInt_t thit=0; thit<hit->GetRawTdcHitNeg().GetNHits(); thit++) {
1189 tdc_neg = hit->GetRawTdcHitNeg().GetTime(thit)+fTdcOffset;
1190 if(tdc_neg >= fScinTdcMin && tdc_neg <= fScinTdcMax) {
1191 btdcraw_neg = kTRUE;
1192 good_ielem_negtdc = thit;
1193 break;
1194 }
1195 }
1196 //
1197 if(fADCMode == kADCDynamicPedestal) {
1198 Int_t good_ielem_negadc_test2=-1;
1199 Int_t good_ielem_posadc_test2=-1;
1200 //Loop Here over all hits per event for neg side of plane
1201 if (good_ielem_negtdc != -1) {
1202 Double_t max_adcamp_test=-1000.;
1203 Double_t max_adctdcdiff_test=1000.;
1204 for (UInt_t ielem=0;ielem<rawNegAdcHit.GetNPulses();ielem++) {
1205 Double_t pulseAmp = rawNegAdcHit.GetPulseAmp(ielem);
1206 Double_t pulseTime = rawNegAdcHit.GetPulseTime(ielem)+fAdcTdcOffset;
1207 Double_t TdcAdcTimeDiff = tdc_neg*fScinTdcToTime-pulseTime;
1208 if (rawNegAdcHit.GetPulseAmpRaw(ielem) <= 0)pulseAmp= 200.;
1209 Bool_t pulseTimeCut =( TdcAdcTimeDiff > fHodoNegAdcTimeWindowMin[index]) && (TdcAdcTimeDiff < fHodoNegAdcTimeWindowMax[index]);
1210 if (pulseTimeCut && pulseAmp>max_adcamp_test) {
1211 good_ielem_negadc = ielem;
1212 max_adcamp_test=pulseAmp;
1213 }
1214 if (abs(TdcAdcTimeDiff) < max_adctdcdiff_test) {
1215 good_ielem_negadc_test2 = ielem;
1216 max_adctdcdiff_test=abs(TdcAdcTimeDiff);
1217 }
1218 }
1219 }
1220
1221 //
1222 if ( good_ielem_negadc == -1 && good_ielem_negadc_test2 != -1) good_ielem_negadc=good_ielem_negadc_test2;
1223 if ( good_ielem_negadc == -1 && good_ielem_negadc_test2 == -1 && rawNegAdcHit.GetNPulses()>0) {
1224 good_ielem_negadc=0;
1225 }
1226 //
1227 if (good_ielem_negadc != -1 && good_ielem_negadc<rawNegAdcHit.GetNPulses()) {
1228 adcped_neg = rawNegAdcHit.GetPed();
1229 adcmult_neg = rawNegAdcHit.GetNPulses();
1230 adchitused_neg = good_ielem_negadc+1;
1231 adcint_neg = rawNegAdcHit.GetPulseInt(good_ielem_negadc);
1232 adcamp_neg = rawNegAdcHit.GetPulseAmp(good_ielem_negadc);
1233 if (rawNegAdcHit.GetPulseAmpRaw(good_ielem_negadc) <= 0) adcamp_neg= 200.;
1234 adctime_neg = rawNegAdcHit.GetPulseTime(good_ielem_negadc)+fAdcTdcOffset;
1235 badcraw_neg = kTRUE;
1236 adctdcdifftime_neg=tdc_neg*fScinTdcToTime-adctime_neg;
1237 }
1238 //
1239 //Loop Here over all hits per event for pos side of plane
1240 if (good_ielem_postdc != -1) {
1241 Double_t max_adcamp_test=-1000.;
1242 Double_t max_adctdcdiff_test=1000.;
1243 //
1244 for (UInt_t ielem=0;ielem<rawPosAdcHit.GetNPulses();ielem++) {
1245 Double_t pulseAmp = rawPosAdcHit.GetPulseAmp(ielem);
1246 Double_t pulseTime = rawPosAdcHit.GetPulseTime(ielem)+fAdcTdcOffset;
1247 Double_t TdcAdcTimeDiff = tdc_pos*fScinTdcToTime-pulseTime;
1248 Bool_t pulseTimeCut =( TdcAdcTimeDiff > fHodoPosAdcTimeWindowMin[index]) && (TdcAdcTimeDiff < fHodoPosAdcTimeWindowMax[index]);
1249 if (rawPosAdcHit.GetPulseAmpRaw(ielem) <= 0)pulseAmp= 200.;
1250 if (pulseTimeCut && pulseAmp>max_adcamp_test) {
1251 good_ielem_posadc = ielem;
1252 max_adcamp_test=pulseAmp;
1253 }
1254 if (abs(TdcAdcTimeDiff) < max_adctdcdiff_test) {
1255 good_ielem_posadc_test2 = ielem;
1256 max_adctdcdiff_test=abs(TdcAdcTimeDiff);
1257 }
1258 }
1259 } //
1260 if ( good_ielem_posadc == -1 && good_ielem_posadc_test2 != -1) good_ielem_posadc=good_ielem_posadc_test2;
1261 if ( good_ielem_posadc == -1 && good_ielem_posadc_test2 == -1 && rawPosAdcHit.GetNPulses()>0) good_ielem_posadc=0;
1262 if (good_ielem_posadc != -1 && good_ielem_posadc<rawPosAdcHit.GetNPulses()) {
1263 adcped_pos = rawPosAdcHit.GetPed();
1264 adcmult_pos = rawPosAdcHit.GetNPulses();
1265 adchitused_pos = good_ielem_posadc+1;
1266 adcint_pos = rawPosAdcHit.GetPulseInt(good_ielem_posadc);
1267 adcamp_pos = rawPosAdcHit.GetPulseAmp(good_ielem_posadc);
1268 if (rawPosAdcHit.GetPulseAmpRaw(good_ielem_posadc) <= 0) adcamp_pos= 200.;
1269 adctime_pos = rawPosAdcHit.GetPulseTime(good_ielem_posadc)+fAdcTdcOffset;
1270 badcraw_pos = kTRUE;
1271 adctdcdifftime_pos=tdc_pos*fScinTdcToTime-adctime_pos;
1272 //
1273 }
1274 } else if (fADCMode == kADCSampleIntegral) {
1275 adcint_pos = hit->GetRawAdcHitPos().GetSampleIntRaw() - fPosPed[index];
1276 adcint_neg = hit->GetRawAdcHitNeg().GetSampleIntRaw() - fNegPed[index];
1277 badcraw_pos = badcraw_neg = kTRUE;
1278 } else if (fADCMode == kADCSampIntDynPed) {
1279 adcint_pos = hit->GetRawAdcHitPos().GetSampleInt();
1280 adcint_neg = hit->GetRawAdcHitNeg().GetSampleInt();
1281 badcraw_pos = badcraw_neg = kTRUE;
1282 } else {
1283 adcint_pos = hit->GetRawAdcHitPos().GetPulseIntRaw()-fPosPed[index];
1284 adcint_neg = hit->GetRawAdcHitNeg().GetPulseIntRaw()-fNegPed[index];
1285 badcraw_pos = badcraw_neg = kTRUE;
1286 }
1287 if (adcint_pos >= fADCDiagCut) {
1288 ((THcSignalHit*) frPosADCHits->ConstructedAt(nrPosADCHits))->Set(padnum, adcint_pos);
1289 Double_t samplesum=hit->GetRawAdcHitPos().GetSampleIntRaw();
1290 Double_t pedestal=hit->GetRawAdcHitPos().GetPedRaw();
1291 ((THcSignalHit*) frPosADCSums->ConstructedAt(nrPosADCHits))->Set(padnum, samplesum);
1292 ((THcSignalHit*) frPosADCPeds->ConstructedAt(nrPosADCHits++))->Set(padnum, pedestal);
1293 }
1294 if (adcint_neg >= fADCDiagCut) {
1295 ((THcSignalHit*) frNegADCHits->ConstructedAt(nrNegADCHits))->Set(padnum, adcint_neg);
1296 Double_t samplesum=hit->GetRawAdcHitNeg().GetSampleIntRaw();
1297 Double_t pedestal=hit->GetRawAdcHitNeg().GetPedRaw();
1298 ((THcSignalHit*) frNegADCSums->ConstructedAt(nrNegADCHits))->Set(padnum, samplesum);
1299 ((THcSignalHit*) frNegADCPeds->ConstructedAt(nrNegADCHits++))->Set(padnum, pedestal);
1300 }
1301 //
1302 if((btdcraw_pos && badcraw_pos) || (btdcraw_neg && badcraw_neg )) {
1303 if (good_ielem_posadc != -1) {
1304 //good adc multiplicity
1305 fTotNumGoodPosAdcHits++;
1306 fTotNumGoodAdcHits++;
1307 //good adc occupancy
1308 fNumGoodPosAdcHits.at(padnum-1) = padnum;
1309 fGoodPosAdcPed.at(padnum-1) = adcped_pos;
1310 fGoodPosAdcMult.at(padnum-1) = adcmult_pos;
1311 fGoodPosAdcHitUsed.at(padnum-1) = adchitused_pos;
1312 fGoodPosAdcPulseInt.at(padnum-1) = adcint_pos;
1313 fGoodPosAdcPulseAmp.at(padnum-1) = adcamp_pos;
1314 fGoodPosAdcPulseTime.at(padnum-1) = adctime_pos;
1315 fGoodPosAdcTdcDiffTime.at(padnum-1) = adctdcdifftime_pos;
1316 }
1317 if (good_ielem_negadc != -1) {
1318 //good adc multiplicity
1319 fTotNumGoodNegAdcHits++;
1320 fTotNumGoodAdcHits++;
1321 //good adc occupancy
1322 fNumGoodNegAdcHits.at(padnum-1) = padnum;
1323 fGoodNegAdcPed.at(padnum-1) = adcped_neg;
1324 fGoodNegAdcMult.at(padnum-1) = adcmult_neg;
1325 fGoodNegAdcHitUsed.at(padnum-1) = adchitused_neg;
1326 fGoodNegAdcPulseInt.at(padnum-1) = adcint_neg;
1327 fGoodNegAdcPulseAmp.at(padnum-1) = adcamp_neg;
1328 fGoodNegAdcPulseTime.at(padnum-1) = adctime_neg;
1329 fGoodNegAdcTdcDiffTime.at(padnum-1) = adctdcdifftime_neg;
1330 }
1331
1332 //DEFINE THE "GOOD +TDC Multiplicities and Occupancies"
1333 if (good_ielem_postdc != -1) {
1334 fTotNumGoodPosTdcHits++;
1335 fTotNumGoodTdcHits++;
1336 //good tdc occupancy
1337 fNumGoodPosTdcHits.at(padnum-1) = padnum;
1338 }
1339
1340 //DEFINE THE "GOOD -TDC Multiplicities and Occupancies"
1341 if (good_ielem_negtdc != -1) {
1342 fTotNumGoodNegTdcHits++;
1343 fTotNumGoodTdcHits++;
1344 //good tdc occupancy
1345 fNumGoodNegTdcHits.at(padnum-1) = padnum;
1346 }
1347 new( (*fHodoHits)[fNScinHits]) THcHodoHit(tdc_pos, tdc_neg,
1348 adcint_pos, adcint_neg,
1349 hit->fCounter, this);
1350 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCpeak(adcamp_pos);
1351 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCpeak(adcamp_neg);
1352 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCtime(adctime_pos);
1353 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCtime(adctime_neg);
1354
1355 //CALCULATE TIME-WALK CORRECTIONS HERE!!!!
1356 //Define GoodTdcUnCorrTime
1357 if(btdcraw_pos&&badcraw_pos) {
1358 fGoodPosTdcTimeUnCorr.at(padnum-1) = tdc_pos*fScinTdcToTime;
1359 //tw_corr_pos = fHodoPos_c1[padnum-1]/pow(adcamp_pos/fTdc_Thrs,fHodoPos_c2[padnum-1]) - fHodoPos_c1[padnum-1]/pow(200./fTdc_Thrs, fHodoPos_c2[padnum-1]);
1360
1361 tw_corr_pos = 1./pow(adcamp_pos/fTdc_Thrs,fHodoPos_c2[padnum-1]) - 1./pow(200./fTdc_Thrs, fHodoPos_c2[padnum-1]);
1362
1363 fGoodPosTdcTimeWalkCorr.at(padnum-1) = tdc_pos*fScinTdcToTime -tw_corr_pos;
1364 }
1365 if(btdcraw_neg&&badcraw_neg) {
1366 fGoodNegTdcTimeUnCorr.at(padnum-1) = tdc_neg*fScinTdcToTime;
1367
1368 //tw_corr_neg = fHodoNeg_c1[padnum-1]/pow(adcamp_neg/fTdc_Thrs,fHodoNeg_c2[padnum-1]) - fHodoNeg_c1[padnum-1]/pow(200./fTdc_Thrs, fHodoNeg_c2[padnum-1]);
1369
1370 tw_corr_neg = 1./pow(adcamp_neg/fTdc_Thrs,fHodoNeg_c2[padnum-1]) - 1./pow(200./fTdc_Thrs, fHodoNeg_c2[padnum-1]);
1371
1372 fGoodNegTdcTimeWalkCorr.at(padnum-1) = tdc_neg*fScinTdcToTime -tw_corr_neg;
1373
1374 }
1375
1376
1377 // Do corrections if valid TDC on both ends of bar
1378 if( (btdcraw_pos && btdcraw_neg) && (badcraw_pos && badcraw_neg) ) {
1379 // Do the pulse height correction to the time. (Position dependent corrections later)
1380 Double_t adc_timec_pos= adctime_pos;
1381 Double_t adc_timec_neg= adctime_neg;
1382 Double_t timec_pos, timec_neg;
1383 if(fTofUsingInvAdc) {
1384 timec_pos = tdc_pos*fScinTdcToTime
1385 - fHodoPosInvAdcOffset[index]
1386 - fHodoPosInvAdcAdc[index]/TMath::Sqrt(TMath::Max(20.0*.020,adcint_pos));
1387 timec_neg = tdc_neg*fScinTdcToTime
1388 - fHodoNegInvAdcOffset[index]
1389 - fHodoNegInvAdcAdc[index]/TMath::Sqrt(TMath::Max(20.0*.020,adcint_neg));
1390 } else { // FADC style
1391 timec_pos = tdc_pos*fScinTdcToTime -tw_corr_pos + fHodo_LCoeff[index];
1392 timec_neg = tdc_neg*fScinTdcToTime -tw_corr_neg- 2*fHodoCableFit[index] + fHodo_LCoeff[index];
1393 adc_timec_pos = adc_timec_pos -tw_corr_pos + fHodo_LCoeff[index];
1394 adc_timec_neg = adc_timec_neg -tw_corr_neg- 2*fHodoCableFit[index] + fHodo_LCoeff[index];
1395 }
1396
1397 Double_t TWCorrDiff = fGoodNegTdcTimeWalkCorr.at(padnum-1) - 2*fHodoCableFit[index] - fGoodPosTdcTimeWalkCorr.at(padnum-1);
1398
1399 Double_t fHitDistCorr = 0.5*TWCorrDiff*fHodoVelFit[index];
1400
1401
1402
1403 fGoodDiffDistTrack.at(index) = fHitDistCorr;
1404
1405 Double_t vellight=fHodoVelLight[index]; //read from hodo_cuts.param, where it is set fixed to 15.0
1406
1407 Double_t dist_from_center=0.5*(timec_neg-timec_pos)*vellight;
1408 Double_t scint_center=0.5*(fPosLeft+fPosRight);
1409 Double_t hit_position=scint_center+dist_from_center;
1410 hit_position=TMath::Min(hit_position,fPosLeft);
1411 hit_position=TMath::Max(hit_position,fPosRight);
1412 Double_t scin_corrected_time, postime, negtime;
1413 Double_t adc_postime=adc_timec_pos;
1414 Double_t adc_negtime=adc_timec_neg;
1415 if(fTofUsingInvAdc) {
1416 timec_pos -= (fPosLeft-hit_position)/
1417 fHodoPosInvAdcLinear[index];
1418 timec_neg -= (hit_position-fPosRight)/
1419 fHodoNegInvAdcLinear[index];
1420 scin_corrected_time = 0.5*(timec_pos+timec_neg);
1421 if (fCosmicFlag) {
1422 postime = timec_pos + (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1423 negtime = timec_neg + (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1424 } else {
1425 postime = timec_pos - (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1426 negtime = timec_neg - (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1427 }
1428 } else {
1429 scin_corrected_time = 0.5*(timec_neg+timec_pos);
1430 timec_pos= scin_corrected_time;
1431 timec_neg= scin_corrected_time;
1432 Double_t adc_time_corrected = 0.5*(adc_timec_pos+adc_timec_neg);
1433 if (fCosmicFlag) {
1434 postime = timec_pos + (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1435 negtime = timec_neg + (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1436 adc_postime = adc_time_corrected + (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1437 adc_negtime = adc_time_corrected + (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1438 } else {
1439 postime = timec_pos - (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1440 negtime = timec_neg - (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1441 adc_postime = adc_time_corrected - (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1442 adc_negtime = adc_time_corrected - (fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
1443 }
1444 }
1445 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPaddleCenter(fPosCenter[index]);
1446 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetCorrectedTimes(timec_pos,timec_neg,
1447 postime, negtime,
1448 scin_corrected_time);
1449 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCpeak(adcamp_pos);
1450 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCpeak(adcamp_neg);
1451 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCCorrtime(adc_postime);
1452 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCCorrtime(adc_negtime);
1453 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetCalcPosition(fHitDistCorr); //
1454
1455 fGoodPosTdcTimeCorr.at(padnum-1) = timec_pos;
1456 fGoodNegTdcTimeCorr.at(padnum-1) = timec_neg;
1457 fGoodPosTdcTimeTOFCorr.at(padnum-1) = postime;
1458 fGoodNegTdcTimeTOFCorr.at(padnum-1) = negtime;
1459 } else {
1460 Double_t timec_pos,timec_neg;
1461 timec_pos=tdc_pos;
1462 timec_neg=tdc_neg;
1463 if(btdcraw_pos&& badcraw_pos) {
1464 if(fTofUsingInvAdc) {
1465 timec_pos = tdc_pos*fScinTdcToTime
1466 - fHodoPosInvAdcOffset[index]
1467 - fHodoPosInvAdcAdc[index]/TMath::Sqrt(TMath::Max(20.0*.020,adcint_pos));
1468 } else { // FADC style
1469 timec_pos = tdc_pos*fScinTdcToTime -tw_corr_pos + fHodo_LCoeff[index];
1470 }
1471 }
1472 if(btdcraw_neg && badcraw_neg) {
1473 if(fTofUsingInvAdc) {
1474 timec_neg = tdc_neg*fScinTdcToTime
1475 - fHodoNegInvAdcOffset[index]
1476 - fHodoNegInvAdcAdc[index]/TMath::Sqrt(TMath::Max(20.0*.020,adcint_neg));
1477 } else { // FADC style
1478 timec_neg = tdc_neg*fScinTdcToTime -tw_corr_neg- 2*fHodoCableFit[index] + fHodo_LCoeff[index];
1479 }
1480 }
1481 Double_t adc_neg=0.,adc_pos=0.;
1482 if (badcraw_neg) adc_neg=adcamp_neg;
1483 if (badcraw_pos) adc_pos=adcamp_pos;
1484 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPaddleCenter(fPosCenter[index]);
1485 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetCorrectedTimes(timec_pos,timec_neg);
1486 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCpeak(adc_neg); // needed for new TWCOrr
1487 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCpeak(adc_pos); // needed for new TWCOrr
1488 if (badcraw_neg) {
1489 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCtime(adctime_neg);
1490 } else {
1491 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetNegADCtime(-999.);
1492 }
1493 if (badcraw_pos) {
1494 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCtime(adctime_pos);
1495 } else {
1496 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetPosADCtime(-999.);
1497 }
1498 ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetCalcPosition(kBig); //
1499 fGoodPosTdcTimeCorr.at(padnum-1) = timec_pos;
1500 fGoodNegTdcTimeCorr.at(padnum-1) = timec_neg;
1501 fGoodPosTdcTimeTOFCorr.at(padnum-1) = kBig;
1502 fGoodNegTdcTimeTOFCorr.at(padnum-1) = kBig;
1503 }
1504 // if ( ((THcHodoHit*) fHodoHits->At(fNScinHits))->GetPosTOFCorrectedTime() != ((THcHodoHit*) fHodoHits->At(fNScinHits))->GetPosTOFCorrectedTime()) cout << " ihit = " << ihit << " scinhit = " << fNScinHits << " plane = " << fPlaneNum << " padnum = " << padnum << " " << tdc_pos<< " "<< tdc_neg<< " " << ((THcHodoHit*) fHodoHits->At(fNScinHits))->GetPosTOFCorrectedTime() << endl;
1505 fNScinHits++; // One or more good time counter
1506 //
1507 }
1508 ihit++; // Raw hit counter
1509 }
1510 // cout << "THcScintillatorPlane: ihit = " << ihit << endl;
1511 if (problem_flag) {
1512 cout << "THcScintillatorPlane::ProcessHits " << fPlaneNum << " " << nexthit << "/" << nrawhits << endl;
1513cout << " Ref problem end *******" << endl;
1514 }
1515 return(ihit);
1516}
1517
1518//_____________________________________________________________________________
1519Int_t THcScintillatorPlane::AccumulatePedestals(TClonesArray* rawhits, Int_t nexthit)
1520{
1525 Int_t nrawhits = rawhits->GetLast()+1;
1526 // cout << "THcScintillatorPlane::AcculatePedestals " << fPlaneNum << " " << nexthit << "/" << nrawhits << endl;
1527
1528 Int_t ihit = nexthit;
1529 while(ihit < nrawhits) {
1530 THcRawHodoHit* hit = (THcRawHodoHit *) rawhits->At(ihit);
1531 if(hit->fPlane > fPlaneNum) {
1532 break;
1533 }
1534 Int_t element = hit->fCounter - 1; // Should check if in range
1535 Int_t adcpos = hit->GetRawAdcHitPos().GetPulseIntRaw();
1536 Int_t adcneg = hit->GetRawAdcHitNeg().GetPulseIntRaw();
1537
1538 if(adcpos <= fPosPedLimit[element]) {
1539 fPosPedSum[element] += adcpos;
1540 fPosPedSum2[element] += adcpos*adcpos;
1541 fPosPedCount[element]++;
1542 if(fPosPedCount[element] == fMinPeds/5) {
1543 fPosPedLimit[element] = 100 + fPosPedSum[element]/fPosPedCount[element];
1544 }
1545 }
1546 if(adcneg <= fNegPedLimit[element]) {
1547 fNegPedSum[element] += adcneg;
1548 fNegPedSum2[element] += adcneg*adcneg;
1549 fNegPedCount[element]++;
1550 if(fNegPedCount[element] == fMinPeds/5) {
1551 fNegPedLimit[element] = 100 + fNegPedSum[element]/fNegPedCount[element];
1552 }
1553 }
1554 ihit++;
1555 }
1556
1557 fNPedestalEvents++;
1558
1559 return(ihit);
1560}
1561
1562//_____________________________________________________________________________
1563void THcScintillatorPlane::CalculatePedestals( )
1564{
1570 for(UInt_t i=0; i<fNelem;i++) {
1571
1572 // Positive tubes
1573 fPosPed[i] = ((Double_t) fPosPedSum[i]) / TMath::Max(1, fPosPedCount[i]);
1574 fPosThresh[i] = fPosPed[i] + 15;
1575
1576 // Negative tubes
1577 fNegPed[i] = ((Double_t) fNegPedSum[i]) / TMath::Max(1, fNegPedCount[i]);
1578 fNegThresh[i] = fNegPed[i] + 15;
1579
1580 // cout <<"Pedestals "<< i+1 << " " << fPosPed[i] << " " << fNegPed[i] << endl;
1581 }
1582 // cout << " " << endl;
1583
1584}
1585
1586//_____________________________________________________________________________
1587void THcScintillatorPlane::InitializePedestals( )
1588{
1594 fNPedestalEvents = 0;
1595 fMinPeds = 500; // In engine, this is set in parameter file
1596 fPosPedSum = new Int_t [fNelem];
1597 fPosPedSum2 = new Int_t [fNelem];
1598 fPosPedLimit = new Int_t [fNelem];
1599 fPosPedCount = new Int_t [fNelem];
1600 fNegPedSum = new Int_t [fNelem];
1601 fNegPedSum2 = new Int_t [fNelem];
1602 fNegPedLimit = new Int_t [fNelem];
1603 fNegPedCount = new Int_t [fNelem];
1604
1605 fPosPed = new Double_t [fNelem];
1606 fNegPed = new Double_t [fNelem];
1607 fPosThresh = new Double_t [fNelem];
1608 fNegThresh = new Double_t [fNelem];
1609 for(UInt_t i=0;i<fNelem;i++) {
1610 fPosPedSum[i] = 0;
1611 fPosPedSum2[i] = 0;
1612 fPosPedLimit[i] = 1000; // In engine, this are set in parameter file
1613 fPosPedCount[i] = 0;
1614 fNegPedSum[i] = 0;
1615 fNegPedSum2[i] = 0;
1616 fNegPedLimit[i] = 1000; // In engine, this are set in parameter file
1617 fNegPedCount[i] = 0;
1618 }
1619}
1620//____________________________________________________________________________
1621ClassImp(THcScintillatorPlane)
Int_t
int Int_t
UInt_t
unsigned int UInt_t
kBig
const Data_t kBig
pedestal
uint32_t pedestal
Bool_t
bool Bool_t
kFALSE
const Bool_t kFALSE
Double_t
double Double_t
kTRUE
const Bool_t kTRUE
Option_t
const char Option_t
index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
mode
Option_t Option_t TPoint TPoint const char mode
ClassImp
ClassImp(VDC::AnalyticTTDConv) using namespace std
gHcParms
R__EXTERN class THcParmList * gHcParms
Definition THcGlobals.h:11
Form
char * Form(const char *fmt,...)
TClonesArray::Clear
void Clear(Option_t *option="") override
TClonesArray::ConstructedAt
TObject * ConstructedAt(Int_t idx)
THaAnalysisObject::DefineVarsFromList
static Int_t DefineVarsFromList(const void *list, EType type, EMode mode, const char *def_prefix, const TObject *obj, const char *prefix, const char *here, const char *comment_subst="")
THaAnalysisObject::GetPrefix
const char * GetPrefix() const
THaAnalysisObject::RemoveVariables
Int_t RemoveVariables()
THaEvData
THaSubDetector::GetParent
THaDetectorBase * GetParent() const
THcHodoHit
Class representing a single hit for the Hodoscopes.
Definition THcHodoHit.h:16
THcHodoscope
Generic hodoscope consisting of multiple planes with multiple paddles with phototubes on both ends.
Definition THcHodoscope.h:37
THcHodoscope::GetHodoNegInvAdcOffset
Double_t GetHodoNegInvAdcOffset(Int_t iii) const
Definition THcHodoscope.h:79
THcHodoscope::GetStartTimeSlop
Double_t GetStartTimeSlop() const
Definition THcHodoscope.h:102
THcHodoscope::GetTDCThrs
Double_t GetTDCThrs() const
Definition THcHodoscope.h:99
THcHodoscope::GetHodoPosMinPh
Double_t GetHodoPosMinPh(Int_t iii) const
Definition THcHodoscope.h:73
THcHodoscope::GetHodoPos_c2
Double_t GetHodoPos_c2(Int_t iii) const
Definition THcHodoscope.h:97
THcHodoscope::GetHodoPosAdcTimeWindowMin
Double_t GetHodoPosAdcTimeWindowMin(Int_t iii) const
Definition THcHodoscope.h:85
THcHodoscope::GetHodoPosPhcCoeff
Double_t GetHodoPosPhcCoeff(Int_t iii) const
Definition THcHodoscope.h:71
THcHodoscope::GetTdcMin
Double_t GetTdcMin() const
Definition THcHodoscope.h:66
THcHodoscope::GetHodoPosAdcTimeWindowMax
Double_t GetHodoPosAdcTimeWindowMax(Int_t iii) const
Definition THcHodoscope.h:84
THcHodoscope::GetHodoPosInvAdcOffset
Double_t GetHodoPosInvAdcOffset(Int_t iii) const
Definition THcHodoscope.h:78
THcHodoscope::GetHodoPosInvAdcLinear
Double_t GetHodoPosInvAdcLinear(Int_t iii) const
Definition THcHodoscope.h:80
THcHodoscope::GetHodoNeg_c2
Double_t GetHodoNeg_c2(Int_t iii) const
Definition THcHodoscope.h:98
THcHodoscope::GetHodoLCoeff
Double_t GetHodoLCoeff(Int_t iii) const
Definition THcHodoscope.h:92
THcHodoscope::GetHodoNegSigma
Double_t GetHodoNegSigma(Int_t iii) const
Definition THcHodoscope.h:124
THcHodoscope::GetHodoVelLight
Double_t GetHodoVelLight(Int_t iii) const
Definition THcHodoscope.h:77
THcHodoscope::GetHodoNegAdcTimeWindowMax
Double_t GetHodoNegAdcTimeWindowMax(Int_t iii) const
Definition THcHodoscope.h:86
THcHodoscope::GetHodoPosInvAdcAdc
Double_t GetHodoPosInvAdcAdc(Int_t iii) const
Definition THcHodoscope.h:82
THcHodoscope::GetHodoPos_c1
Double_t GetHodoPos_c1(Int_t iii) const
Definition THcHodoscope.h:95
THcHodoscope::GetHodoNeg_c1
Double_t GetHodoNeg_c1(Int_t iii) const
Definition THcHodoscope.h:96
THcHodoscope::GetHodoNegMinPh
Double_t GetHodoNegMinPh(Int_t iii) const
Definition THcHodoscope.h:74
THcHodoscope::GetAdcTdcOffset
Double_t GetAdcTdcOffset(Int_t ip) const
Definition THcHodoscope.h:117
THcHodoscope::GetHodoVelFit
Double_t GetHodoVelFit(Int_t iii) const
Definition THcHodoscope.h:90
THcHodoscope::GetTdcMax
Double_t GetTdcMax() const
Definition THcHodoscope.h:67
THcHodoscope::GetHodoNegInvAdcLinear
Double_t GetHodoNegInvAdcLinear(Int_t iii) const
Definition THcHodoscope.h:81
THcHodoscope::GetStartTimeCenter
Double_t GetStartTimeCenter() const
Definition THcHodoscope.h:101
THcHodoscope::GetScinIndex
Int_t GetScinIndex(Int_t nPlane, Int_t nPaddle)
Definition THcHodoscope.cxx:2271
THcHodoscope::GetHodoNegAdcTimeWindowMin
Double_t GetHodoNegAdcTimeWindowMin(Int_t iii) const
Definition THcHodoscope.h:87
THcHodoscope::GetHodoSlop
Double_t GetHodoSlop(Int_t ip)
Definition THcHodoscope.h:113
THcHodoscope::GetHodoPosSigma
Double_t GetHodoPosSigma(Int_t iii) const
Definition THcHodoscope.h:123
THcHodoscope::GetHodoNegTimeOffset
Double_t GetHodoNegTimeOffset(Int_t iii) const
Definition THcHodoscope.h:76
THcHodoscope::GetHodoNegInvAdcAdc
Double_t GetHodoNegInvAdcAdc(Int_t iii) const
Definition THcHodoscope.h:83
THcHodoscope::GetTdcToTime
Double_t GetTdcToTime() const
Definition THcHodoscope.h:69
THcHodoscope::GetHodoCableFit
Double_t GetHodoCableFit(Int_t iii) const
Definition THcHodoscope.h:91
THcHodoscope::GetHodoPosTimeOffset
Double_t GetHodoPosTimeOffset(Int_t iii) const
Definition THcHodoscope.h:75
THcHodoscope::GetTofTolerance
Double_t GetTofTolerance() const
Definition THcHodoscope.h:68
THcHodoscope::GetHodoNegPhcCoeff
Double_t GetHodoNegPhcCoeff(Int_t iii) const
Definition THcHodoscope.h:72
THcHodoscope::GetTdcOffset
Int_t GetTdcOffset(Int_t ip) const
Definition THcHodoscope.h:116
THcHodoscope::GetBetaNominal
Double_t GetBetaNominal() const
Definition THcHodoscope.h:70
THcParmList::LoadParmValues
Int_t LoadParmValues(const DBRequest *list, const char *prefix="")
Retrieve parameter values from the parameter cache.
Definition THcParmList.cxx:522
THcRawAdcHit
Class representing a single raw ADC hit.
Definition THcRawAdcHit.h:7
THcRawAdcHit::GetSampPulseIntRaw
Int_t GetSampPulseIntRaw(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:223
THcRawAdcHit::GetNSampPulses
UInt_t GetNSampPulses() const
Definition THcRawAdcHit.h:142
THcRawAdcHit::GetSampPulseInt
Double_t GetSampPulseInt(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:182
THcRawAdcHit::GetPedRaw
Int_t GetPedRaw() const
Gets raw signal pedestal. In channels.
Definition THcRawAdcHit.h:157
THcRawAdcHit::GetSampPulseAmpRaw
Int_t GetSampPulseAmpRaw(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:228
THcRawAdcHit::GetSampPulseTime
Double_t GetSampPulseTime(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:209
THcRawAdcHit::GetNPulses
UInt_t GetNPulses() const
Gets number of set pulses.
Definition THcRawAdcHit.h:137
THcRawAdcHit::GetF250_NSB
Int_t GetF250_NSB() const
Definition THcRawAdcHit.h:29
THcRawAdcHit::GetNSamples
UInt_t GetNSamples() const
Gets number of set samples.
Definition THcRawAdcHit.h:147
THcRawAdcHit::GetSampPedRaw
Int_t GetSampPedRaw() const
Definition THcRawAdcHit.h:162
THcRawAdcHit::HasRefTime
Bool_t HasRefTime() const
Definition THcRawAdcHit.h:355
THcRawAdcHit::SetSampNSAT
void SetSampNSAT(Int_t nsat)
Definition THcRawAdcHit.cxx:297
THcRawAdcHit::SetSampThreshold
void SetSampThreshold(Double_t thres)
Definition THcRawAdcHit.cxx:292
THcRawAdcHit::GetPulseAmp
Double_t GetPulseAmp(UInt_t iPulse=0) const
Gets pedestal subtracted pulse amplitude. In channels.
Definition THcRawAdcHit.h:188
THcRawAdcHit::GetRefTime
Int_t GetRefTime() const
Definition THcRawAdcHit.h:339
THcRawAdcHit::GetSample
Double_t GetSample(UInt_t iSample=0) const
Definition THcRawAdcHit.h:331
THcRawAdcHit::SetSampIntTimePedestalPeak
void SetSampIntTimePedestalPeak()
Definition THcRawAdcHit.cxx:313
THcRawAdcHit::GetPulseAmpRaw
Int_t GetPulseAmpRaw(UInt_t iPulse=0) const
Gets raw pulse amplitude. In channels.
Definition THcRawAdcHit.h:303
THcRawAdcHit::GetPed
Double_t GetPed() const
Gets sample pedestal. In channels.
Definition THcRawAdcHit.h:167
THcRawAdcHit::GetPulseTimeRaw
Int_t GetPulseTimeRaw(UInt_t iPulse=0) const
Gets raw pulse time. In subsamples.
Definition THcRawAdcHit.h:313
THcRawAdcHit::GetSampPulseAmp
Double_t GetSampPulseAmp(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:194
THcRawAdcHit::GetPulseTime
Double_t GetPulseTime(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:200
THcRawAdcHit::GetSampleInt
Double_t GetSampleInt() const
Gets pedestal subtracted integral of samples. In channels.
Definition THcRawAdcHit.h:245
THcRawAdcHit::GetPulseIntRaw
Int_t GetPulseIntRaw(UInt_t iPulse=0) const
Gets raw pulse integral. In channels.
Definition THcRawAdcHit.h:293
THcRawAdcHit::GetSampPulseTimeRaw
Int_t GetSampPulseTimeRaw(UInt_t iPulse=0) const
Definition THcRawAdcHit.h:218
THcRawAdcHit::GetSampPed
Double_t GetSampPed() const
Definition THcRawAdcHit.h:172
THcRawAdcHit::GetRefDiffTime
Int_t GetRefDiffTime() const
Definition THcRawAdcHit.h:347
THcRawAdcHit::GetF250_NSA
Int_t GetF250_NSA() const
Definition THcRawAdcHit.h:28
THcRawAdcHit::SetF250Params
void SetF250Params(Int_t NSA, Int_t NSB, Int_t NPED)
Sets F250 parameters used for pedestal subtraction.
Definition THcRawAdcHit.cxx:424
THcRawAdcHit::GetSampleIntRaw
Int_t GetSampleIntRaw() const
Gets raw integral of sTimeFacamples. In channels.
Definition THcRawAdcHit.h:234
THcRawAdcHit::GetPulseInt
Double_t GetPulseInt(UInt_t iPulse=0) const
Gets pedestal subtracted pulse integral. In channels.
Definition THcRawAdcHit.h:177
THcRawHit::fPlane
Int_t fPlane
Definition THcRawHit.h:52
THcRawHit::fCounter
Int_t fCounter
Definition THcRawHit.h:53
THcRawHodoHit
Class representing a single raw hit for a hodoscope paddle.
Definition THcRawHodoHit.h:9
THcRawHodoHit::GetRawAdcHitPos
THcRawAdcHit & GetRawAdcHitPos()
Definition THcRawHodoHit.cxx:228
THcRawHodoHit::GetRawAdcHitNeg
THcRawAdcHit & GetRawAdcHitNeg()
Definition THcRawHodoHit.cxx:233
THcRawHodoHit::GetRawTdcHitNeg
THcRawTdcHit & GetRawTdcHitNeg()
Definition THcRawHodoHit.cxx:243
THcRawHodoHit::GetRawTdcHitPos
THcRawTdcHit & GetRawTdcHitPos()
Definition THcRawHodoHit.cxx:238
THcRawTdcHit
Class representing a single raw TDC hit.
Definition THcRawTdcHit.h:7
THcRawTdcHit::GetRefTime
Int_t GetRefTime() const
Gets reference time. In channels.
Definition THcRawTdcHit.cxx:174
THcRawTdcHit::GetTimeRaw
Int_t GetTimeRaw(UInt_t iHit=0) const
Gets raw TDC time. In channels.
Definition THcRawTdcHit.cxx:148
THcRawTdcHit::GetTime
Int_t GetTime(UInt_t iHit=0) const
Gets TDC time. In channels.
Definition THcRawTdcHit.cxx:165
THcRawTdcHit::GetNHits
UInt_t GetNHits() const
Gets the number of set hits.
Definition THcRawTdcHit.cxx:204
THcRawTdcHit::HasRefTime
Bool_t HasRefTime() const
Queries whether reference time has been set.
Definition THcRawTdcHit.cxx:199
THcRawTdcHit::GetRefDiffTime
Int_t GetRefDiffTime() const
Definition THcRawTdcHit.cxx:186
THcScintillatorPlane
A single plane of scintillators.
Definition THcScintillatorPlane.h:24
THcScintillatorPlane::frPosAdcSampPulseInt
TClonesArray * frPosAdcSampPulseInt
Definition THcScintillatorPlane.h:127
THcScintillatorPlane::fGoodPosAdcPulseTime
vector< Double_t > fGoodPosAdcPulseTime
Definition THcScintillatorPlane.h:180
THcScintillatorPlane::fGoodNegAdcHitUsed
vector< Double_t > fGoodNegAdcHitUsed
Definition THcScintillatorPlane.h:172
THcScintillatorPlane::frPosAdcPulseAmpRaw
TClonesArray * frPosAdcPulseAmpRaw
Definition THcScintillatorPlane.h:101
THcScintillatorPlane::fGoodNegTdcTimeTOFCorr
vector< Double_t > fGoodNegTdcTimeTOFCorr
Definition THcScintillatorPlane.h:196
THcScintillatorPlane::frNegAdcSampPulseInt
TClonesArray * frNegAdcSampPulseInt
Definition THcScintillatorPlane.h:135
THcScintillatorPlane::fGoodPosAdcPulseInt
vector< Double_t > fGoodPosAdcPulseInt
Definition THcScintillatorPlane.h:177
THcScintillatorPlane::fGoodPosTdcTimeUnCorr
vector< Double_t > fGoodPosTdcTimeUnCorr
Definition THcScintillatorPlane.h:190
THcScintillatorPlane::fGoodNegAdcTdcDiffTime
vector< Double_t > fGoodNegAdcTdcDiffTime
Definition THcScintillatorPlane.h:184
THcScintillatorPlane::FineProcess
virtual Int_t FineProcess(TClonesArray &tracks)
Definition THcScintillatorPlane.cxx:788
THcScintillatorPlane::frPosAdcSampPulseIntRaw
TClonesArray * frPosAdcSampPulseIntRaw
Definition THcScintillatorPlane.h:123
THcScintillatorPlane::frPosAdcSampPulseAmp
TClonesArray * frPosAdcSampPulseAmp
Definition THcScintillatorPlane.h:128
THcScintillatorPlane::Clear
virtual void Clear(Option_t *opt="")
Definition THcScintillatorPlane.cxx:635
THcScintillatorPlane::frNegAdcPulseTimeRaw
TClonesArray * frNegAdcPulseTimeRaw
Definition THcScintillatorPlane.h:114
THcScintillatorPlane::frNegAdcSampPulseTimeRaw
TClonesArray * frNegAdcSampPulseTimeRaw
Definition THcScintillatorPlane.h:133
THcScintillatorPlane::fNegAdcSampWaveform
vector< Double_t > fNegAdcSampWaveform
Definition THcScintillatorPlane.h:186
THcScintillatorPlane::fGoodNegAdcPulseAmp
vector< Double_t > fGoodNegAdcPulseAmp
Definition THcScintillatorPlane.h:175
THcScintillatorPlane::frPosAdcPulseTimeRaw
TClonesArray * frPosAdcPulseTimeRaw
Definition THcScintillatorPlane.h:102
THcScintillatorPlane::THcScintillatorPlane
THcScintillatorPlane(const char *name, const char *description, Int_t planenum, THaDetectorBase *parent=NULL)
THcScintillatorPlane::fNumGoodNegTdcHits
vector< Int_t > fNumGoodNegTdcHits
Definition THcScintillatorPlane.h:162
THcScintillatorPlane::kADCDynamicPedestal
static const Int_t kADCDynamicPedestal
Definition THcScintillatorPlane.h:229
THcScintillatorPlane::ReadDatabase
virtual Int_t ReadDatabase(const TDatime &date)
Definition THcScintillatorPlane.cxx:261
THcScintillatorPlane::frNegAdcSampPedRaw
TClonesArray * frNegAdcSampPedRaw
Definition THcScintillatorPlane.h:130
THcScintillatorPlane::fGoodPosAdcPed
vector< Double_t > fGoodPosAdcPed
Definition THcScintillatorPlane.h:165
THcScintillatorPlane::fGoodPosAdcPulseAmp
vector< Double_t > fGoodPosAdcPulseAmp
Definition THcScintillatorPlane.h:174
THcScintillatorPlane::fNumGoodPosAdcHits
vector< Int_t > fNumGoodPosAdcHits
Definition THcScintillatorPlane.h:158
THcScintillatorPlane::ProcessHits
virtual Int_t ProcessHits(TClonesArray *rawhits, Int_t nexthit)
Definition THcScintillatorPlane.cxx:797
THcScintillatorPlane::frNegAdcSampPulseTime
TClonesArray * frNegAdcSampPulseTime
Definition THcScintillatorPlane.h:137
THcScintillatorPlane::frNegAdcPulseIntRaw
TClonesArray * frNegAdcPulseIntRaw
Definition THcScintillatorPlane.h:112
THcScintillatorPlane::frPosAdcSampPedRaw
TClonesArray * frPosAdcSampPedRaw
Definition THcScintillatorPlane.h:122
THcScintillatorPlane::Decode
virtual Int_t Decode(const THaEvData &)
Definition THcScintillatorPlane.cxx:765
THcScintillatorPlane::fNumGoodPosTdcHits
vector< Int_t > fNumGoodPosTdcHits
Definition THcScintillatorPlane.h:161
THcScintillatorPlane::frPosAdcSampPulseTime
TClonesArray * frPosAdcSampPulseTime
Definition THcScintillatorPlane.h:129
THcScintillatorPlane::fNumGoodNegAdcHits
vector< Int_t > fNumGoodNegAdcHits
Definition THcScintillatorPlane.h:159
THcScintillatorPlane::frPosAdcSampPulseAmpRaw
TClonesArray * frPosAdcSampPulseAmpRaw
Definition THcScintillatorPlane.h:124
THcScintillatorPlane::kADCSampleIntegral
static const Int_t kADCSampleIntegral
Definition THcScintillatorPlane.h:230
THcScintillatorPlane::AccumulatePedestals
virtual Int_t AccumulatePedestals(TClonesArray *rawhits, Int_t nexthit)
Definition THcScintillatorPlane.cxx:1519
THcScintillatorPlane::DefineVariables
virtual Int_t DefineVariables(EMode mode=kDefine)
Definition THcScintillatorPlane.cxx:475
THcScintillatorPlane::fGoodDiffDistTrack
vector< Double_t > fGoodDiffDistTrack
Definition THcScintillatorPlane.h:201
THcScintillatorPlane::fGoodPosTdcTimeWalkCorr
vector< Double_t > fGoodPosTdcTimeWalkCorr
Definition THcScintillatorPlane.h:199
THcScintillatorPlane::frNegAdcPulseAmpRaw
TClonesArray * frNegAdcPulseAmpRaw
Definition THcScintillatorPlane.h:113
THcScintillatorPlane::frPosAdcErrorFlag
TClonesArray * frPosAdcErrorFlag
Definition THcScintillatorPlane.h:84
THcScintillatorPlane::frNegAdcSampPulseAmp
TClonesArray * frNegAdcSampPulseAmp
Definition THcScintillatorPlane.h:136
THcScintillatorPlane::frPosAdcSampPulseTimeRaw
TClonesArray * frPosAdcSampPulseTimeRaw
Definition THcScintillatorPlane.h:125
THcScintillatorPlane::fGoodNegAdcPed
vector< Double_t > fGoodNegAdcPed
Definition THcScintillatorPlane.h:166
THcScintillatorPlane::fGoodPosAdcTdcDiffTime
vector< Double_t > fGoodPosAdcTdcDiffTime
Definition THcScintillatorPlane.h:183
THcScintillatorPlane::fGoodNegTdcTimeUnCorr
vector< Double_t > fGoodNegTdcTimeUnCorr
Definition THcScintillatorPlane.h:194
THcScintillatorPlane::fGoodNegTdcTimeCorr
vector< Double_t > fGoodNegTdcTimeCorr
Definition THcScintillatorPlane.h:195
THcScintillatorPlane::fGoodNegAdcPulseInt
vector< Double_t > fGoodNegAdcPulseInt
Definition THcScintillatorPlane.h:178
THcScintillatorPlane::fGoodPosAdcHitUsed
vector< Double_t > fGoodPosAdcHitUsed
Definition THcScintillatorPlane.h:171
THcScintillatorPlane::frNegAdcSampPulseIntRaw
TClonesArray * frNegAdcSampPulseIntRaw
Definition THcScintillatorPlane.h:131
THcScintillatorPlane::fGoodPosAdcMult
vector< Double_t > fGoodPosAdcMult
Definition THcScintillatorPlane.h:168
THcScintillatorPlane::fGoodNegAdcPulseTime
vector< Double_t > fGoodNegAdcPulseTime
Definition THcScintillatorPlane.h:181
THcScintillatorPlane::fGoodPosTdcTimeCorr
vector< Double_t > fGoodPosTdcTimeCorr
Definition THcScintillatorPlane.h:191
THcScintillatorPlane::fGoodNegAdcMult
vector< Double_t > fGoodNegAdcMult
Definition THcScintillatorPlane.h:169
THcScintillatorPlane::kADCSampIntDynPed
static const Int_t kADCSampIntDynPed
Definition THcScintillatorPlane.h:231
THcScintillatorPlane::CoarseProcess
virtual Int_t CoarseProcess(TClonesArray &tracks)
Definition THcScintillatorPlane.cxx:774
THcScintillatorPlane::frNegAdcSampPulseAmpRaw
TClonesArray * frNegAdcSampPulseAmpRaw
Definition THcScintillatorPlane.h:132
THcScintillatorPlane::frNegAdcErrorFlag
TClonesArray * frNegAdcErrorFlag
Definition THcScintillatorPlane.h:85
THcScintillatorPlane::fGoodNegTdcTimeWalkCorr
vector< Double_t > fGoodNegTdcTimeWalkCorr
Definition THcScintillatorPlane.h:200
THcScintillatorPlane::frPosAdcPulseIntRaw
TClonesArray * frPosAdcPulseIntRaw
Definition THcScintillatorPlane.h:100
THcScintillatorPlane::fPosAdcSampWaveform
vector< Double_t > fPosAdcSampWaveform
Definition THcScintillatorPlane.h:187
THcScintillatorPlane::fGoodPosTdcTimeTOFCorr
vector< Double_t > fGoodPosTdcTimeTOFCorr
Definition THcScintillatorPlane.h:192
TNamed::GetName
const char * GetName() const override
TObjArray::At
TObject * At(Int_t idx) const override
TObjArray::GetLast
Int_t GetLast() const override
TObject::IsZombie
R__ALWAYS_INLINE Bool_t IsZombie() const
abs
RVec< PromoteType< T > > abs(const RVec< T > &v)
pow
RVec< PromoteTypes< T0, T1 > > pow(const RVec< T0 > &v, const T1 &y)
TMath::Min
Double_t Min(Double_t a, Double_t b)
TMath::Sqrt
Double_t Sqrt(Double_t x)
TMath::Max
Double_t Max(Double_t a, Double_t b)
std
STL namespace.