Bug Summary

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