Bug Summary

File:plugins/monitoring/CDC_expert/JEventProcessor_CDC_expert.cc
Location:line 458, column 5
Description:Value stored to 'total_ped' is never read

Annotated Source Code

1// $Id$
2//
3// File: JEventProcessor_CDC_expert.cc
4// Created: Wed Oct 22
5// Creator: Naomi Jarvis
6
7
8#include <stdint.h>
9#include <vector>
10
11#include <TMath.h>
12
13
14#include "JEventProcessor_CDC_expert.h"
15#include <JANA/JApplication.h>
16
17
18using namespace std;
19using namespace jana;
20
21
22#include "CDC/DCDCHit.h"
23#include "CDC/DCDCDigiHit.h"
24#include "DAQ/Df125PulseIntegral.h"
25#include "DAQ/Df125PulsePedestal.h"
26#include "DAQ/Df125WindowRawData.h"
27#include "DAQ/Df125CDCPulse.h"
28
29#include <TDirectory.h>
30#include <TH2.h>
31#include <TH1.h>
32
33
34// root hist pointers
35
36
37
38static TH1D *cdc_e = NULL__null;
39static TH2D *cdc_e_vs_n = NULL__null;
40
41static TH1D *cdc_t = NULL__null;
42static TH2D *cdc_t_vs_n = NULL__null;
43
44
45static TH2D *cdc_e_ring[29];
46static TH2D *cdc_t_ring[29];
47
48
49static TH2D *cdc_e_vs_t;
50static TH2D *cdc_e_vs_t_ring[29];
51
52static TH2I *cdc_raw_int_vs_t;
53static TH2I *cdc_raw_int_vs_t_ring[29];
54
55
56static TH2I *cdc_o_badt;
57static TH2I *cdc_o_overflow;
58
59static TH2I *cdc_ped_ring[29];
60static TH1I *cdc_ped_badt;
61static TH1I *cdc_ped_overflow;
62
63static TH2I *cdc_windata_ped_ring[29];
64
65static TH2I *cdc_windata_ped_roc25;
66static TH2I *cdc_windata_ped_roc26;
67static TH2I *cdc_windata_ped_roc27;
68static TH2I *cdc_windata_ped_roc28;
69
70static TH2I *cdc_raw_t_ring[29];
71static TH1I *cdc_raw_t_badt;
72static TH1I *cdc_raw_t_overflow;
73
74static TH2I *cdc_raw_amp_ring[29];
75static TH1I *cdc_raw_amp_badt;
76static TH1I *cdc_raw_amp_overflow;
77
78
79
80static TH2I *cdc_raw_intpp_ring[29];
81static TH1I *cdc_raw_intpp_badt;
82static TH1I *cdc_raw_intpp_overflow;
83
84
85
86static TH2I *cdc_raw_int_ring[29];
87static TH1I *cdc_raw_int_badt;
88static TH1I *cdc_raw_int_overflow;
89
90// Some hists are only made if run number is
91// is > 3675. We need a flag to prevent any
92// attempt to fill them which results in a
93// seg. fault.
94bool hists3675 = false;
95
96
97//----------------------------------------------------------------------------------
98
99
100// Routine used to create our JEventProcessor
101extern "C"{
102 void InitPlugin(JApplication *app){
103 InitJANAPlugin(app);
104 app->AddProcessor(new JEventProcessor_CDC_expert());
105 }
106}
107
108
109//----------------------------------------------------------------------------------
110
111
112JEventProcessor_CDC_expert::JEventProcessor_CDC_expert() {
113}
114
115
116//----------------------------------------------------------------------------------
117
118
119JEventProcessor_CDC_expert::~JEventProcessor_CDC_expert() {
120}
121
122
123//----------------------------------------------------------------------------------
124
125jerror_t JEventProcessor_CDC_expert::init(void) {
126
127 // I moved all the histogram setup into the brun so that I can use different
128 // scales for the later runs using the new firmware. NSJ.
129
130 // japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
131 // japp->RootUnLock(); //RELEASE ROOT LOCK!!
132
133
134 return NOERROR;
135}
136
137
138//----------------------------------------------------------------------------------
139
140
141jerror_t JEventProcessor_CDC_expert::brun(JEventLoop *eventLoop, int32_t runnumber) {
142 // This is called whenever the run number changes
143
144
145
146 japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
147
148 // max values for histogram scales, modified fa250-format readout
149
150 // Int_t IMAX = 524288; //max for raw integral, fa250-format, 19 bits
151 Int_t IMAX = 400000; //max for raw integral
152 Int_t PMAX = 512; //max for pedestal, fa250-format max is 512
153 Int_t AMAX = 4096; //max for amplitude, fa250-format, 12 bits
154 Int_t RTMAX = 12000;
155 Int_t RTVSNMAX = 8192; //raw time vs straw histogram range ends at this value
156
157 Char_t rtunits[8] = "0.125ns"; //raw time is in units of sample/64 = ns/8
158
159 if (runnumber > 3675) { //new fa125 format firmware, from 11 Sept 2015
160
161 // raw quantities for read out (125 format) are
162 // time field max 2047 scaled x 1, units 0.8ns
163 // time qf field max 1
164 // overflow count field max 7
165 // pedestal field max 255 scaled x 1/4 initially
166 // max amplitude 9 bits, field max 511 scaled x 1/8
167 // integral field max 16383 scaled x 1/14
168
169
170 // max values for histogram scales, fa125-format readout
171
172 IMAX = 16384; //max for raw integral, fa125-format, 14 bits
173 PMAX = 256; //max for pedestal, fa125-format, 8 bits
174 AMAX = 512; //max for amplitude, fa125-format, 9 bits
175 RTMAX = 2048; //max for raw time, fa125-format, 11 bits
176 RTVSNMAX = 1024; //raw time vs straw histogram range ends at this value
177
178 sprintf(rtunits,"0.8ns"); //raw time is in units of sample/10 = 0.8ns
179
180 }
181
182
183 const Int_t EMAX = 21000; //max for E histograms, fC
184 // const Int_t EMAX = 21000000; //max for E histograms, fC
185 // E histograms filled with a_scale*gains*(integration-pedestal)
186
187 const Int_t TMAX = 2000; //max for t histograms, ns
188 // t histograms filled with t_scale*(raw-t - offset) + tmin
189
190
191 const Int_t NSTRAWS = 3522;
192 const Float_t HALF = 0.5;
193 const Float_t NSTRAWSPH = 3522.5;
194
195
196 // create root folder for cdc and cd to it, store main dir
197 TDirectory *main = gDirectory(TDirectory::CurrentDirectory());
198 gDirectory(TDirectory::CurrentDirectory())->mkdir("CDC_expert")->cd();
199
200
201
202 // book histograms
203
204 //number of straws in each ring, starts with 0 so that straws[1] is the number of straws in ring 1
205 const Int_t straws[29] = {0,42,42,54,54,66,66,80,80,93,93,106,106,123,123,135,135,146,146,158,158,170,170,182,182,197,197,209,209};
206
207
208 cdc_e = new TH1D("cdc_e","CDC charge (fC);charge (fC)",200,0,EMAX);
209 cdc_e_vs_n = new TH2D("cdc_e_vs_n","CDC charge (fC) vs straw number;straw;charge (fC)",NSTRAWS,HALF,NSTRAWSPH,100,0,EMAX);
210
211 cdc_e_vs_t = new TH2D("cdc_e_vs_t","CDC charge (fC) vs time (ns);time (ns);charge (fC)",150,-250,TMAX,100,0,EMAX);
212
213
214 cdc_t = new TH1D("cdc_t","CDC time (ns);time (ns)",300,-250,TMAX);
215 cdc_t_vs_n = new TH2D("cdc_t_vs_n","CDC time (ns) vs straw number;straw;time (ns)",NSTRAWS,HALF,NSTRAWSPH,150,-250,TMAX);
216
217
218
219
220 cdc_raw_int_vs_t = new TH2I("cdc_raw_int_vs_t",Form("CDC integral (ADC units), pedestal subtracted, vs raw time (units of %s);time (%s);integral, pedestal subtracted (ADC units)",rtunits,rtunits),(Int_t)256,0,RTVSNMAX,100,0,IMAX);
221
222
223
224 cdc_windata_ped_roc25 = new TH2I("cdc_windata_ped_roc25","CDC pedestal (ADC units) from raw window data vs slot*100+channel, ROC 25;slot*100 + channel;pedestal",1600,200+HALF,1800+HALF,(Int_t)PMAX/4,0,PMAX);
225 cdc_windata_ped_roc26 = new TH2I("cdc_windata_ped_roc26","CDC pedestal (ADC units) from raw window data vs slot*100+channel, ROC 26;slot*100 + channel;pedestal",1600,200+HALF,1800+HALF,(Int_t)PMAX/4,0,PMAX);
226 cdc_windata_ped_roc27 = new TH2I("cdc_windata_ped_roc27","CDC pedestal (ADC units) from raw window data vs slot*100+channel, ROC 27;slot*100 + channel;pedestal",1600,200+HALF,1800+HALF,(Int_t)PMAX/4,0,PMAX);
227 cdc_windata_ped_roc28 = new TH2I("cdc_windata_ped_roc28","CDC pedestal (ADC units) from raw window data vs slot*100+channel, ROC 28;slot*100 + channel;pedestal",1600,200+HALF,1800+HALF,(Int_t)PMAX/4,0,PMAX);
228
229
230
231 if (runnumber > 3675) { //new fa125 format firmware, from 11 Sept 2015
232
233 gDirectory(TDirectory::CurrentDirectory())->mkdir("bad_t","CDC Bad time flagged")->cd();
234
235 hists3675 = true;
236
237 cdc_o_badt = new TH2I("cdc_o_badt","CDC occupancy by straw,ring, events with bad time flagged;straw;ring",209,0.5,209.5,28,0.5,28.5);
238 cdc_ped_badt = new TH1I("cdc_ped_badt","CDC pedestal, events with bad time flagged;straw;pedestal",256,0,PMAX);
239 cdc_raw_t_badt = new TH1I("cdc_raw_t_badt",Form("CDC raw time (units of %s), events with bad time flagged;straw;raw time (%s)",rtunits,rtunits),256,0,RTMAX);
240 cdc_raw_amp_badt = new TH1I("cdc_raw_amp_badt","CDC amplitude (ADC units), events with bad time flagged;ADC units",256,0,AMAX);
241 cdc_raw_int_badt = new TH1I("cdc_raw_intpp_badt","CDC integral (ADC units), pedestal subtracted, events with bad time flagged;ADC units",100,0,IMAX);
242 cdc_raw_intpp_badt = new TH1I("cdc_raw_intpp_badt","CDC integral (ADC units), including pedestal, events with bad time flagged;ADC units",100,0,IMAX);
243
244 gDirectory(TDirectory::CurrentDirectory())->cd("../");
245 gDirectory(TDirectory::CurrentDirectory())->mkdir("overflows","CDC overflow flagged")->cd();
246
247 cdc_o_overflow = new TH2I("cdc_o_overflow","CDC overflow occupancy by straw,ring;straw;ring",209,0.5,209.5,28,0.5,28.5);
248 cdc_ped_overflow = new TH1I("cdc_ped_overflow","CDC pedestal, events with ADC overflow;pedestal",256,0,PMAX);
249 cdc_raw_t_overflow = new TH1I("cdc_raw_t_overflow",Form("CDC raw time (units of %s), events with ADC overflow;raw time (%s)",rtunits,rtunits),256,0,RTMAX);
250 cdc_raw_amp_overflow = new TH1I("cdc_raw_amp_overflow","CDC amplitude (ADC units), events with ADC overflow;ADC units",256,0,AMAX);
251 cdc_raw_int_overflow = new TH1I("cdc_raw_intpp_overflow","CDC integral (ADC units), pedestal subtracted, events with ADC overflow;ADC units",100,0,IMAX);
252 cdc_raw_intpp_overflow = new TH1I("cdc_raw_intpp_overflow","CDC integral (ADC units), including pedestal, events with ADC overflow;ADC units",100,0,IMAX);
253
254 gDirectory(TDirectory::CurrentDirectory())->cd("../");
255
256 }
257
258 Int_t i;
259
260
261 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_e_vs_t","CDC rings: charge vs time")->cd();
262
263 for (i=1; i<29; i++) {
264 cdc_e_vs_t_ring[i] = new TH2D(Form("cdc_e_vs_t_ring[%i]",i),"CDC charge (fC) vs time (ns);time (ns);charge (fC)",150,0,TMAX,100,0,EMAX);
265 }
266
267 gDirectory(TDirectory::CurrentDirectory())->cd("../");
268
269
270 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_int_vs_raw_t","CDC rings: integral vs raw time (pedestal subtracted)")->cd();
271
272 for (i=1; i<29; i++) {
273 cdc_raw_int_vs_t_ring[i] = new TH2I(Form("cdc_raw_int_vs_t_ring[%i]",i),Form("CDC integral (ADC units), pedestal subtracted, vs raw time (%s);raw time (%s);integral, pedestal subtracted (ADC units)",rtunits,rtunits),256,0,RTVSNMAX,100,0,IMAX);
274
275 }
276
277 gDirectory(TDirectory::CurrentDirectory())->cd("../");
278
279
280
281 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_e","CDC rings: charge vs straw")->cd();
282
283 for (i=1; i<29; i++) {
284 cdc_e_ring[i] = new TH2D(Form("cdc_e_ring[%i]",i),Form("CDC charge (fC), ring %i;straw;charge (fC)",i),straws[i],HALF,straws[i]+HALF,100,0,EMAX);
285 }
286
287 gDirectory(TDirectory::CurrentDirectory())->cd("../");
288 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings__t","CDC rings: time vs straw")->cd();
289
290 for (i=1; i<29; i++) {
291 cdc_t_ring[i] = new TH2D(Form("cdc_t_ring[%i]",i),Form("CDC time (ns), ring %i;straw;time (ns)",i),straws[i],HALF,straws[i]+HALF,150,0,TMAX);
292 }
293
294
295 gDirectory(TDirectory::CurrentDirectory())->cd("../");
296 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_pedestal","CDC rings: pedestal vs straw")->cd();
297
298 for (i=1; i<29; i++) {
299 cdc_ped_ring[i] = new TH2I(Form("cdc_ped_ring[%i]",i),Form("CDC pedestal (ADC units), ring %i;straw;pedestal",i),straws[i],HALF,straws[i]+HALF,(Int_t)PMAX/2,0,PMAX);
300 }
301
302 gDirectory(TDirectory::CurrentDirectory())->cd("../");
303 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_windata_pedestal","CDC rings: pedestal from raw window data vs straw")->cd();
304
305 for (i=1; i<29; i++) {
306 cdc_windata_ped_ring[i] = new TH2I(Form("cdc_windata_ped_ring[%i]",i),Form("CDC pedestal (ADC units) from raw window data, ring %i;straw;pedestal",i),straws[i],HALF,straws[i]+HALF,(Int_t)PMAX/2,0,PMAX);
307 }
308
309
310
311
312
313 gDirectory(TDirectory::CurrentDirectory())->cd("../");
314 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_raw_t","CDC rings: raw time vs straw")->cd();
315
316 for (i=1; i<29; i++) {
317 cdc_raw_t_ring[i] = new TH2I(Form("cdc_raw_t_ring[%i]",i),Form("CDC raw time (units of %s), ring %i;straw;raw time (%s)",rtunits,i,rtunits),straws[i],HALF,straws[i]+HALF,256,0,RTVSNMAX);
318 }
319
320
321 gDirectory(TDirectory::CurrentDirectory())->cd("../");
322 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_raw_amp","CDC rings: amplitude")->cd();
323
324 for (i=1; i<29; i++) {
325 cdc_raw_amp_ring[i] = new TH2I(Form("cdc_raw_amp_ring[%i]",i),Form("CDC amplitude (ADC units), ring %i",i),straws[i],HALF,straws[i]+HALF,256,0,AMAX);
326 }
327
328
329
330 gDirectory(TDirectory::CurrentDirectory())->cd("../");
331 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_raw_integral","CDC rings: integral vs straw (pedestal subtracted)")->cd();
332
333 for (i=1; i<29; i++) {
334 cdc_raw_int_ring[i] = new TH2I(Form("cdc_raw_int_ring[%i]",i),Form("CDC integral (ADC units), pedestal subtracted, ring %i",i),straws[i],HALF,straws[i]+HALF,100,0,IMAX);
335 }
336
337
338 gDirectory(TDirectory::CurrentDirectory())->cd("../");
339 gDirectory(TDirectory::CurrentDirectory())->mkdir("rings_raw_integral_incl_ped","CDC rings: integral vs straw (including pedestal)")->cd();
340
341 for (i=1; i<29; i++) {
342 cdc_raw_intpp_ring[i] = new TH2I(Form("cdc_raw_intpp_ring[%i]",i),Form("CDC integral (ADC units), including pedestal, ring %i",i),straws[i],HALF,straws[i]+HALF,100,0,IMAX);
343 }
344
345
346
347 // back to main dir
348 main->cd();
349
350 japp->RootUnLock(); //RELEASE ROOT LOCK!!
351
352 return NOERROR;
353}
354
355
356//----------------------------------------------------------------------------------
357
358
359jerror_t JEventProcessor_CDC_expert::evnt(JEventLoop *eventLoop, uint64_t eventnumber) {
360 // This is called for every event. Use of common resources like writing
361 // to a file or filling a histogram should be mutex protected. Using
362 // loop-Get(...) to get reconstructed objects (and thereby activating the
363 // reconstruction algorithm) should be done outside of any mutex lock
364 // since multiple threads may call this method at the same time.
365
366 float q,t; // dcdchits quantities charge, time
367
368 uint32_t qf,ocount; // time quality factor and overflow count from new firmware
369 uint32_t tr,p,a; // dcdcdigihits raw quantities: time, pedestal, amplitude, quality factor, overflow count
370 uint32_t integral; // dcdcdigihits integral, includes pedestal
371 uint32_t integ; // dcdcdigihits integral minus pedestal
372
373 uint16_t ring,straw; // ring and straw numbers from either dcdchits or dcdcdigihits
374 uint16_t n; // straw number, 1 to 3522
375
376 Bool_t PED_SUB; // if this is false, integration window info is missing, so don't plot integrals
377
378 uint32_t total_ped; //total pedestal during integration period
379 uint32_t nsamples_integral; ///< number of samples used in integral
380 uint32_t nsamples_pedestal; ///< number of samples used in pedestal
381
382 uint32_t rocid;
383 uint32_t slot;
384 uint32_t channel;
385
386
387 const uint16_t NPEDSAMPLES=16;
388
389 //add extra 0 at front to use offset[1] for ring 1
390 int straw_offset[29] = {0,0,42,84,138,192,258,324,404,484,577,670,776,882,1005,1128,1263,1398,1544,1690,1848,2006,2176,2346,2528,2710,2907,3104,3313};
391
392
393 //first set of histograms is for dcdchits, these are t and q after calibration
394 //second set is for dcdcdigihits, these are the raw quantities
395
396 // get hit data for cdc
397 vector<const DCDCHit*> hits;
398 eventLoop->Get(hits);
399
400 // get raw data for cdc
401 vector<const DCDCDigiHit*> digihits;
402 eventLoop->Get(digihits);
403
404 //get WRD data for new format (until it is linked to CDCPulse)
405 vector<const Df125WindowRawData*> wrdvector;
406 eventLoop->Get(wrdvector);
407
408 japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
409
410
411 for(uint32_t i=0; i<hits.size(); i++) {
412
413 const DCDCHit *hit = hits[i]; // avoids having to use the uglier “cdcdigihits[0]->” syntax
414
415 if(hit->q>0.0) {
416
417 q = hit->q; // in fC
418 t = hit->t; // in nanoseconds
419 ring = hit->ring;
420 straw = hit->straw;
421
422 n = straw_offset[ring] + straw;
423
424 if (q > 0.0) {
425 cdc_e->Fill(q);
426 cdc_e_vs_n->Fill(n,q);
427 }
428
429 //if (t > 0.0) {
430 cdc_t->Fill(t);
431 cdc_t_vs_n->Fill(n,t);
432 //}
433
434 cdc_e_vs_t->Fill(t,q);
435 cdc_e_vs_t_ring[ring]->Fill(t,q);
436
437 cdc_e_ring[ring]->Fill(straw,q);
438 cdc_t_ring[ring]->Fill(straw,t);
439 }
440 }
441
442
443 for(uint32_t i=0; i<digihits.size(); i++) {
444
445 const DCDCDigiHit *digihit = digihits[i]; // avoids having to use the uglier “cdcdigihits[0]->” syntax
446
447 // Get pointers to the underlying objects of interest
448 const Df125PulseIntegral *pi = NULL__null;
449 const Df125PulsePedestal *pp = NULL__null;
450 const Df125WindowRawData *windat = NULL__null;
451 const Df125CDCPulse *cp = NULL__null;
452
453
454 vector<uint16_t> samples;
455 uint32_t winped=0;
456
457 PED_SUB = kFALSE; //set this to true when we find the config params
458 total_ped = 0;
Value stored to 'total_ped' is never read
459
460 rocid = 0;
461 slot = 0;
462 channel = 0;
463 qf = 0;
464 ocount = 0;
465 a = 0;
466
467 //old firmware uses Df125PulseIntegral and Df125PulsePedestal
468 digihit->GetSingle(pi);
469 if (pi) {
470 rocid = pi->rocid;
471 slot = pi->slot;
472 channel = pi->channel;
473 pi->GetSingle(windat);
474 } else if (i < (uint32_t)wrdvector.size()) {
475 windat = wrdvector[i];
476 }
477
478 nsamples_integral = pi ? pi->nsamples_integral : 0;
479 nsamples_pedestal = pi ? pi->nsamples_pedestal : 0;
480
481 if ((nsamples_integral > 0) && (nsamples_pedestal > 0)) PED_SUB = kTRUE;
482
483 digihit->GetSingle(pp);
484 if(pp) a = pp->pulse_peak;
485
486 //new firmware uses Df125CDCPulseData
487 digihit->GetSingle(cp);
488 if (cp) {
489 rocid = cp->rocid;
490 slot = cp->slot;
491 channel = cp->channel;
492 a = cp->first_max_amp;
493 qf = cp->time_quality_bit;
494 ocount = cp->overflow_count;
495 }
496
497
498
499 if (windat) {
500
501 if (windat->samples.size()>=NPEDSAMPLES) {
502
503 winped = 0;
504
505 for (uint16_t j=0; j<NPEDSAMPLES; j++) winped += (uint32_t)windat->samples[j];
506
507 winped = (uint32_t)winped/16.0;
508
509 if (winped > 0) {
510
511 if (rocid == 25) cdc_windata_ped_roc25->Fill(100*slot + channel,winped);
512 if (rocid == 26) cdc_windata_ped_roc26->Fill(100*slot + channel,winped);
513 if (rocid == 27) cdc_windata_ped_roc27->Fill(100*slot + channel,winped);
514 if (rocid == 28) cdc_windata_ped_roc28->Fill(100*slot + channel,winped);
515
516 }
517
518 }//sample size
519 } //windat
520
521
522
523
524 if((digihit->pulse_integral>0)||(digihit->pulse_time>0)) {
525
526 ring = digihit->ring;
527 straw = digihit->straw;
528
529 p = digihit->pedestal;
530 tr = digihit->pulse_time; // raw time in 0.8 ns units
531 integral = digihit->pulse_integral; // pulse integral in fadc units, pedestal not subtracted
532
533 integ = 0;
534
535 //ok to use p for pedestal subtraction here because if fa250 algo fails with p=0, integral=0 and amplitude=0 also
536
537 if (PED_SUB) {
538 total_ped = p*nsamples_integral/nsamples_pedestal;
539 integ = integral - total_ped;
540 }
541
542 // straw_offset[ring] + straw;
543
544 if (PED_SUB) cdc_raw_int_vs_t->Fill(tr,integ);
545 if (PED_SUB) cdc_raw_int_vs_t_ring[ring]->Fill(tr,integ);
546
547 cdc_ped_ring[ring]->Fill(straw,p);
548 cdc_raw_t_ring[ring]->Fill(straw,tr);
549 cdc_raw_amp_ring[ring]->Fill(straw,a); //no ped subtraction in case scaling factors differ
550 if (PED_SUB) cdc_raw_int_ring[ring]->Fill(straw,integ);
551 cdc_raw_intpp_ring[ring]->Fill(straw,integral);
552 if (winped) cdc_windata_ped_ring[ring]->Fill(straw,winped);
553
554
555 if (cp && hists3675) {
556 if (qf==1) { // rough time flag is set
557 cdc_o_badt->Fill(straw,ring);
558 cdc_ped_badt->Fill(p);
559 cdc_raw_t_badt->Fill(tr);
560 cdc_raw_amp_badt->Fill(a);
561 if (PED_SUB) cdc_raw_int_badt->Fill(integ);
562 cdc_raw_intpp_badt->Fill(integral);
563 }
564
565
566 if (ocount>0) { // overflow samples present
567 cdc_o_overflow->Fill(straw,ring);
568 cdc_ped_overflow->Fill(p);
569 cdc_raw_t_overflow->Fill(tr);
570 cdc_raw_amp_overflow->Fill(a);
571 if (PED_SUB) cdc_raw_int_overflow->Fill(integ);
572 cdc_raw_intpp_overflow->Fill(integral);
573 }
574 }
575
576
577 }
578
579 }
580
581
582 japp->RootUnLock(); //RELEASE ROOT LOCK!!
583
584
585 return NOERROR;
586}
587
588
589//----------------------------------------------------------------------------------
590
591
592jerror_t JEventProcessor_CDC_expert::erun(void) {
593 // This is called whenever the run number changes, before it is
594 // changed to give you a chance to clean up before processing
595 // events from the next run number.
596 return NOERROR;
597}
598
599
600//----------------------------------------------------------------------------------
601
602
603jerror_t JEventProcessor_CDC_expert::fini(void) {
604 // Called before program exit after event processing is finished.
605 return NOERROR;
606}
607
608
609//----------------------------------------------------------------------------------
610//----------------------------------------------------------------------------------