← Back to branch summary

~chris-rogers/mice-emr/trunk

« back to all changes in this revision

Viewing changes to Software/mc/reconstruction/src/MapCppEMRPlaneHitsRecon.cc

  • Committer: Chris Rogers
  • Date: 2014-05-20 09:30:14 UTC
  • Revision ID: chris.rogers@stfc.ac.uk-20140520093014-he43dmwsewve273q
Fix uninitialised values

Show diffs side-by-side

added added

removed removed

Lines of Context:
Software/mc/reconstruction/src/MapCppEMRPlaneHitsRecon.cc
42
42
    if (__runid==_runid && __spillCount==_spillCount) {
43
43
      printf("\nINFO: Spill count correct!\n");
44
44
      if (__triggerCount==_triggerCount) {
45
 
        printf("INFO: Trigger count correct!\n\n");
 
45
         printf("INFO: Trigger count correct!\n\n");
46
46
      } else {
47
 
        printf("WARNING: Trigger count incorrect due to empty events!\n\n");
 
47
         printf("WARNING: Trigger count incorrect due to empty events!\n\n");
48
48
      }
49
49
    } else {
50
50
      printf("\nERROR: Spill count incorrect! Stop!!!\n\n");
100
100
    if (initial_trigger) {_triggerCount++; ___triggerCount++;}
101
101
    
102
102
    int nPlHits = evt->GetEMRPlaneHitArray().size();
103
 
 
 
103
    std::cout << "nPlHits " << nPlHits << std::endl;
104
104
    if (nPlHits>0){
105
105
      EMRPlaneHit *plHit = evt->GetEMRPlaneHitArray().at(0);
106
106
      _runid = plHit->GetRun();
113
113
      char line[400];
114
114
      bool trigger_found = false;
115
115
      while (fgets(line,400,tof_spectrum_events)) {
116
 
        char _beam[20];
117
 
        int _momatq9,__runid,__spillid,__triggerid;
118
 
        float _tof01,_P_e_tof01,_p_e_tof01,_P_mu_tof01,_p_mu_tof01,_P_pi_tof01,_p_pi_tof01;
119
 
        float _tof02,_P_e_tof02,_p_e_tof02,_P_mu_tof02,_p_mu_tof02,_P_pi_tof02,_p_pi_tof02;
120
 
        float _tof12,_P_e_tof12,_p_e_tof12,_P_mu_tof12,_p_mu_tof12,_P_pi_tof12,_p_pi_tof12;
121
 
        sscanf(line,"%*s %s %d %d %d %d %*s %f %f %f %f %f %f %f %*s %f %f %f %f %f %f %f %*s %f %f %f %f %f %f %f",
122
 
               _beam,&_momatq9,&__runid,&__spillid,&__triggerid,
123
 
               &_tof01,&_P_e_tof01,&_p_e_tof01,&_P_mu_tof01,&_p_mu_tof01,&_P_pi_tof01,&_p_pi_tof01,
124
 
               &_tof02,&_P_e_tof02,&_p_e_tof02,&_P_mu_tof02,&_p_mu_tof02,&_P_pi_tof02,&_p_pi_tof02,
125
 
               &_tof12,&_P_e_tof12,&_p_e_tof12,&_P_mu_tof12,&_p_mu_tof12,&_P_pi_tof12,&_p_pi_tof12);
126
 
            
127
 
        if (__runid==_runid && __spillid==_spillCount && __triggerid==iTrigger ) {
128
 
          trigger_found = true;
129
 
          break;
130
 
        }
 
116
             char _beam[20];
 
117
             int _momatq9,__runid,__spillid,__triggerid;
 
118
             float _tof01,_P_e_tof01,_p_e_tof01,_P_mu_tof01,_p_mu_tof01,_P_pi_tof01,_p_pi_tof01;
 
119
             float _tof02,_P_e_tof02,_p_e_tof02,_P_mu_tof02,_p_mu_tof02,_P_pi_tof02,_p_pi_tof02;
 
120
             float _tof12,_P_e_tof12,_p_e_tof12,_P_mu_tof12,_p_mu_tof12,_P_pi_tof12,_p_pi_tof12;
 
121
             sscanf(line,"%*s %s %d %d %d %d %*s %f %f %f %f %f %f %f %*s %f %f %f %f %f %f %f %*s %f %f %f %f %f %f %f",
 
122
                    _beam,&_momatq9,&__runid,&__spillid,&__triggerid,
 
123
                    &_tof01,&_P_e_tof01,&_p_e_tof01,&_P_mu_tof01,&_p_mu_tof01,&_P_pi_tof01,&_p_pi_tof01,
 
124
                    &_tof02,&_P_e_tof02,&_p_e_tof02,&_P_mu_tof02,&_p_mu_tof02,&_P_pi_tof02,&_p_pi_tof02,
 
125
                    &_tof12,&_P_e_tof12,&_p_e_tof12,&_P_mu_tof12,&_p_mu_tof12,&_P_pi_tof12,&_p_pi_tof12);
 
126
                 
 
127
             if (__runid==_runid && __spillid==_spillCount && __triggerid==iTrigger ) {
 
128
               trigger_found = true;
 
129
               break;
 
130
             }
131
131
      }
132
132
      fclose(tof_spectrum_events);
 
133
      printf(">>> run:%d spill:%d trigger:%d\n",_runid,_spillCount,iTrigger);
133
134
      if (initial_trigger && !trigger_found) continue;
134
 
      //printf(">>> run:%d spill:%d trigger:%d\n",_runid,_spillCount,iTrigger);
135
135
    }
136
136
 
137
137
    int nBarsTotal = 0;
147
147
      int nBars = plHit->GetEMRBarArray().size();
148
148
 
149
149
      for (int ibar=0; ibar<nBars; ibar++) {
150
 
        
151
 
        EMRBar *bar = plHit->GetEMRBarArray().at(ibar);
152
 
        int xBar = bar->GetBar();
153
 
 
154
 
        // skip calibration channel
155
 
        if (xBar==0) continue;
156
 
 
157
 
        int nBarHits = bar->GetEMRBarHitArray().size();
158
 
 
159
 
        for (int ibh=0; ibh<nBarHits; ibh++) {
160
 
 
161
 
          EMRBarHit barHit = bar->GetEMRBarHitArray().at(ibh);
162
 
          int xTot  = barHit.GetTot();
163
 
          int xDeltaT = barHit.GetDeltaT();
164
 
          int xHitTime = barHit.GetHitTime();
165
 
          double g4X = barHit.Get_g4_x_mm();
166
 
          double g4Y = barHit.Get_g4_y_mm();
167
 
          double g4Z = barHit.Get_g4_z_mm();
168
 
          double g4_edep_mev = barHit.Get_g4_edep_mev();
169
 
          double g4_time_ns = barHit.Get_g4_time_ns();
170
 
          double x = 0.0;
171
 
          double y = 0.0;
172
 
          double z = 0.0;
173
 
 
174
 
          EMRBarHit bHit;
175
 
          bHit.SetTot(xTot);
176
 
          bHit.SetDeltaT(xDeltaT);
177
 
          bHit.SetHitTime(xHitTime);
178
 
          bHit.SetX(x);
179
 
          bHit.SetY(y);
180
 
          bHit.SetZ(z);
181
 
          bHit.Set_g4_x_mm(g4X);
182
 
          bHit.Set_g4_y_mm(g4Y);
183
 
          bHit.Set_g4_z_mm(g4Z);
184
 
          bHit.Set_g4_edep_mev(g4_edep_mev);
185
 
          bHit.Set_g4_time_ns(g4_time_ns);
186
 
          // fill collection of pre-selected events
187
 
          _emr_dbb_events_tmp[iTrigger][xPlane][xBar].push_back(bHit);
188
 
        }
 
150
         
 
151
         EMRBar *bar = plHit->GetEMRBarArray().at(ibar);
 
152
         int xBar = bar->GetBar();
 
153
 
 
154
         // skip calibration channel
 
155
         if (xBar==0) continue;
 
156
 
 
157
         int nBarHits = bar->GetEMRBarHitArray().size();
 
158
 
 
159
         for (int ibh=0; ibh<nBarHits; ibh++) {
 
160
 
 
161
           EMRBarHit barHit = bar->GetEMRBarHitArray().at(ibh);
 
162
           int xTot  = barHit.GetTot();
 
163
           int xDeltaT = barHit.GetDeltaT();
 
164
           int xHitTime = barHit.GetHitTime();
 
165
           double g4X = barHit.Get_g4_x_mm();
 
166
           double g4Y = barHit.Get_g4_y_mm();
 
167
           double g4Z = barHit.Get_g4_z_mm();
 
168
           double g4_edep_mev = barHit.Get_g4_edep_mev();
 
169
           double g4_time_ns = barHit.Get_g4_time_ns();
 
170
           double x = 0.0;
 
171
           double y = 0.0;
 
172
           double z = 0.0;
 
173
 
 
174
           EMRBarHit bHit;
 
175
           bHit.SetTot(xTot);
 
176
           bHit.SetDeltaT(xDeltaT);
 
177
           bHit.SetHitTime(xHitTime);
 
178
           bHit.SetX(x);
 
179
           bHit.SetY(y);
 
180
           bHit.SetZ(z);
 
181
           bHit.Set_g4_x_mm(g4X);
 
182
           bHit.Set_g4_y_mm(g4Y);
 
183
           bHit.Set_g4_z_mm(g4Z);
 
184
           bHit.Set_g4_edep_mev(g4_edep_mev);
 
185
           bHit.Set_g4_time_ns(g4_time_ns);
 
186
           // fill collection of pre-selected events
 
187
           _emr_dbb_events_tmp[iTrigger][xPlane][xBar].push_back(bHit);
 
188
         }
189
189
      }
190
190
 
191
191
      int xOri = plHit->GetOrientation();
214
214
      int __runid(-1),__spillCount(-1),__triggerCount(-1);
215
215
      sscanf(line,"%*s %*s %*s %*s %*s %*s %d %*s %d %*s %d",&__runid,&__spillCount,&__triggerCount);
216
216
      if (__runid==_runid && __spillCount==_spillCount && __triggerCount==___triggerCount) {
217
 
        trigger_count_correct = true;
218
 
        break;
 
217
         trigger_count_correct = true;
 
218
         break;
219
219
      }
220
220
    }
221
221
    if (!trigger_count_correct) {
240
240
    for (int iBar=1; iBar<=59; iBar++) {
241
241
      int nHits = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar].size();
242
242
      for (int iHit=0; iHit<nHits; iHit++) {
243
 
        EMRBarHit bHit = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar][iHit];
244
 
        int xTot = bHit.GetTot();/*dbb counts*/
245
 
        int hitTime = bHit.GetHitTime();/*dbb counts*/
246
 
        if (xTot>_secondary_trigger_minTot) hitTimeVector.push_back(hitTime);
 
243
           EMRBarHit bHit = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar][iHit];
 
244
         int xTot = bHit.GetTot();/*dbb counts*/
 
245
           int hitTime = bHit.GetHitTime();/*dbb counts*/
 
246
         if (xTot>_secondary_trigger_minTot) hitTimeVector.push_back(hitTime);
247
247
      }
248
248
    }
249
249
  }
281
281
  for (int iTrigger=0; iTrigger<_nTriggers; iTrigger++) {
282
282
    for (int iPlane=0; iPlane<48; iPlane++) {
283
283
      for (int iBar=1; iBar<=59; iBar++) {
284
 
        int nHits = _emr_dbb_events_tmp[iTrigger][iPlane][iBar].size();
285
 
        for (int iHit=0; iHit<nHits; iHit++) {
286
 
          EMRBarHit bHit = _emr_dbb_events_tmp[iTrigger][iPlane][iBar][iHit];
287
 
          _emr_dbb_events[0][iTrigger][iPlane][iBar].push_back(bHit);
288
 
          _g4_edep_mev_tmp[iTrigger] += bHit.Get_g4_edep_mev();
289
 
        }
 
284
         int nHits = _emr_dbb_events_tmp[iTrigger][iPlane][iBar].size();
 
285
         for (int iHit=0; iHit<nHits; iHit++) {
 
286
           EMRBarHit bHit = _emr_dbb_events_tmp[iTrigger][iPlane][iBar][iHit];
 
287
           _emr_dbb_events[0][iTrigger][iPlane][iBar].push_back(bHit);
 
288
           _g4_edep_mev_tmp[iTrigger] += bHit.Get_g4_edep_mev();
 
289
         }
290
290
      }
291
291
      if (iTrigger<_nTriggers-2) {
292
 
        fADCdata data;
293
 
        data._orientation = _emr_fadc_events_tmp[iTrigger][iPlane]._orientation;
294
 
        data._charge = _emr_fadc_events_tmp[iTrigger][iPlane]._charge;
295
 
        data._pedestal_area = _emr_fadc_events_tmp[iTrigger][iPlane]._pedestal_area;
296
 
        data._arrival_time = _emr_fadc_events_tmp[iTrigger][iPlane]._arrival_time;
297
 
        data._g4_edep_mev = _emr_fadc_events_tmp[iTrigger][iPlane]._g4_edep_mev;
298
 
        data._samples = _emr_fadc_events_tmp[iTrigger][iPlane]._samples;
299
 
        _emr_fadc_events[iTrigger][iPlane] = data;
 
292
         fADCdata data;
 
293
         data._orientation = _emr_fadc_events_tmp[iTrigger][iPlane]._orientation;
 
294
         data._charge = _emr_fadc_events_tmp[iTrigger][iPlane]._charge;
 
295
         data._pedestal_area = _emr_fadc_events_tmp[iTrigger][iPlane]._pedestal_area;
 
296
         data._arrival_time = _emr_fadc_events_tmp[iTrigger][iPlane]._arrival_time;
 
297
         data._g4_edep_mev = _emr_fadc_events_tmp[iTrigger][iPlane]._g4_edep_mev;
 
298
         data._samples = _emr_fadc_events_tmp[iTrigger][iPlane]._samples;
 
299
         _emr_fadc_events[iTrigger][iPlane] = data;
300
300
      }
301
301
    }
302
302
  }
310
310
 
311
311
    for (int iPlane=0; iPlane<48; iPlane++) {
312
312
      for (int iBar=1; iBar<=59; iBar++) {
313
 
        int nHits = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar].size();
314
 
 
315
 
        for (int iHit=0; iHit<nHits; iHit++) {
316
 
          EMRBarHit bHit = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar][iHit];
317
 
          int hitTime = bHit.GetHitTime();/*dbb counts*/
318
 
          int xTot = bHit.GetTot();/*dbb counts*/
319
 
          int deltat = hitTimeGroup.at(iHitTimeGroup) - hitTime;
320
 
 
321
 
          if (deltat>=0 && deltat<_secondary_hits_bunching_width) {
322
 
            _emr_dbb_events[0][secondaryEventsTrigId+iHitTimeGroup+1][iPlane][iBar].push_back(bHit);        
323
 
 
324
 
            // cout << iPlane << " " << iBar << " " << iHit << " " << bHit.GetTot() << " " << deltat << " " << hitTime << endl;
325
 
            // nHitsTot++;
326
 
          } 
327
 
        }
 
313
         int nHits = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar].size();
 
314
 
 
315
         for (int iHit=0; iHit<nHits; iHit++) {
 
316
           EMRBarHit bHit = _emr_dbb_events_tmp[secondaryEventsTrigId][iPlane][iBar][iHit];
 
317
           int hitTime = bHit.GetHitTime();/*dbb counts*/
 
318
           int xTot = bHit.GetTot();/*dbb counts*/
 
319
           int deltat = hitTimeGroup.at(iHitTimeGroup) - hitTime;
 
320
 
 
321
           if (deltat>=0 && deltat<_secondary_hits_bunching_width) {
 
322
             _emr_dbb_events[0][secondaryEventsTrigId+iHitTimeGroup+1][iPlane][iBar].push_back(bHit);             
 
323
 
 
324
             // cout << iPlane << " " << iBar << " " << iHit << " " << bHit.GetTot() << " " << deltat << " " << hitTime << endl;
 
325
             // nHitsTot++;
 
326
           } 
 
327
         }
328
328
      }
329
329
    }
330
330
 
345
345
    for (int iPlane=0; iPlane<48; iPlane++) {
346
346
      int nHits = 0;
347
347
      for (int iBar=1; iBar<=59; iBar++) {
348
 
        nHits = nHits + _emr_dbb_events[0][iTrigger][iPlane][iBar].size();
 
348
           nHits = nHits + _emr_dbb_events[0][iTrigger][iPlane][iBar].size();
349
349
      }
350
350
      if (nHits && iPlane%2==0) xPlaneHits++;
351
351
      if (nHits && iPlane%2==1) yPlaneHits++;
356
356
 
357
357
    // hits selection
358
358
    if (iTrigger<_nTriggers-2 && 
359
 
        (xPlaneHits<_primary_trigger_minXhits || 
360
 
         yPlaneHits<_primary_trigger_minYhits || 
361
 
         (xPlaneHits+yPlaneHits)<_primary_trigger_minNhits)) continue;
 
359
         (xPlaneHits<_primary_trigger_minXhits || 
 
360
          yPlaneHits<_primary_trigger_minYhits || 
 
361
          (xPlaneHits+yPlaneHits)<_primary_trigger_minNhits)) continue;
362
362
    if (iTrigger>=_nTriggers && 
363
 
        (xPlaneHits<_secondary_trigger_minXhits || 
364
 
         yPlaneHits<_secondary_trigger_minYhits || 
365
 
         (xPlaneHits+yPlaneHits)<_secondary_trigger_minNhits)) continue;
 
363
         (xPlaneHits<_secondary_trigger_minXhits || 
 
364
          yPlaneHits<_secondary_trigger_minYhits || 
 
365
          (xPlaneHits+yPlaneHits)<_secondary_trigger_minNhits)) continue;
366
366
 
367
367
    _has_primary_tmp[iTrigger] = 1;
368
368
    
371
371
      int xBarMax = 0;
372
372
      int xHitMax = 0;
373
373
      for (int iBar=1; iBar<=59; iBar++) {
374
 
        int nHits = _emr_dbb_events[0][iTrigger][iPlane][iBar].size();
375
 
        
376
 
        for (int iHit=0; iHit<nHits; iHit++) {
377
 
          EMRBarHit bHit = _emr_dbb_events[0][iTrigger][iPlane][iBar][iHit];
378
 
          int xTot = bHit.GetTot();
379
 
          if (xTot > xTotMax) {
380
 
            xTotMax = xTot;
381
 
            xHitMax = iHit;
382
 
            xBarMax = iBar;
383
 
          }
384
 
        }
 
374
           int nHits = _emr_dbb_events[0][iTrigger][iPlane][iBar].size();
 
375
         
 
376
           for (int iHit=0; iHit<nHits; iHit++) {
 
377
             EMRBarHit bHit = _emr_dbb_events[0][iTrigger][iPlane][iBar][iHit];
 
378
             int xTot = bHit.GetTot();
 
379
             if (xTot > xTotMax) {
 
380
               xTotMax = xTot;
 
381
               xHitMax = iHit;
 
382
             xBarMax = iBar;
 
383
             }
 
384
           }
385
385
      }
386
386
 
387
387
      for (int iBar=1; iBar<=59; iBar++) {
388
 
        int nHits = _emr_dbb_events[0][iTrigger][iPlane][iBar].size();
389
 
        for (int iHit=0; iHit<nHits; iHit++) {
390
 
          EMRBarHit bHit = _emr_dbb_events[0][iTrigger][iPlane][iBar][iHit];
391
 
          if (iBar==xBarMax && iHit==xHitMax && bHit.GetTot()>_secondary_trigger_minTot){
392
 
            _emr_dbb_events[1][iTrigger][iPlane][iBar].push_back(bHit);
393
 
          }
394
 
        }
 
388
               int nHits = _emr_dbb_events[0][iTrigger][iPlane][iBar].size();
 
389
               for (int iHit=0; iHit<nHits; iHit++) {
 
390
                 EMRBarHit bHit = _emr_dbb_events[0][iTrigger][iPlane][iBar][iHit];
 
391
                 if (iBar==xBarMax && iHit==xHitMax && bHit.GetTot()>_secondary_trigger_minTot){
 
392
                   _emr_dbb_events[1][iTrigger][iPlane][iBar].push_back(bHit);
 
393
                 }
 
394
               }
395
395
      }
396
396
    }
397
397
  }
403
403
  if (reconEvents->size() == 0) {
404
404
    for (int iTrigger=0; iTrigger<_nTriggers+_nSeconTrig; iTrigger++)
405
405
      reconEvents->push_back(new ReconEvent);
406
 
  }
 
406
  } 
407
407
 
408
 
  // cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>_spillCount=" << _spillCount << endl;
 
408
  cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>_spillCount=" << _spillCount << endl;
409
409
 
410
410
  //printf("run:%d spill:%d triggers:%d\n",_runid,_spillCount,_nTriggers-2);
411
411
 
412
412
  for (int iTrigger=0; iTrigger<_nTriggers+_nSeconTrig; iTrigger++) {
413
413
 
414
 
    // cout << ">>>>>>>>>>>>>>>>>>>>>>>iTrigger=" << iTrigger << endl;
 
414
    cout << ">>>>>>>>>>>>>>>>>>>>>>>iTrigger=" << iTrigger << endl;
415
415
    
416
416
    EMREvent *evt = new EMREvent;
417
417
 
437
437
      plHit->SetSamples(xSamples);
438
438
      plHit->Set_g4_edep_mev(g4_edep_mev);
439
439
 
440
 
      // cout << "------------------------xPlane=" << xPlane << endl;
441
 
      // cout << "xCharge=" << xCharge << endl;
442
 
      // cout << "g4_edep_mev=" << g4_edep_mev << endl;
443
 
 
444
440
      EMRBarArray barArray;
445
441
      EMRBarArray barArrayPrimary;
446
442
      EMRBarArray barArraySecondary;
447
443
      for (int i=0; i<3; i++) {
448
 
        for (int ibar=1; ibar<=59; ibar++) {
449
 
          int nHits = _emr_dbb_events[i][iTrigger][xPlane][ibar].size();
450
 
          if(nHits) {
451
 
            EMRBar *bar = new EMRBar;
452
 
            bar->SetBar(ibar);
453
 
            bar->SetEMRBarHitArray( _emr_dbb_events[i][iTrigger][xPlane][ibar] );
454
 
            if (i==0) barArray.push_back(bar);
455
 
            if (i==1) barArrayPrimary.push_back(bar);
456
 
            if (i==2) barArraySecondary.push_back(bar);
457
 
          }
458
 
        }
 
444
         for (int ibar=1; ibar<=59; ibar++) {
 
445
           int nHits = _emr_dbb_events[i][iTrigger][xPlane][ibar].size();
 
446
           if(nHits) {
 
447
             EMRBar *bar = new EMRBar;
 
448
             bar->SetBar(ibar);
 
449
             bar->SetEMRBarHitArray( _emr_dbb_events[i][iTrigger][xPlane][ibar] );
 
450
             if (i==0) barArray.push_back(bar);
 
451
             if (i==1) barArrayPrimary.push_back(bar);
 
452
             if (i==2) barArraySecondary.push_back(bar);
 
453
           }
 
454
         }
459
455
      }
460
 
      
461
 
      // cout << "barArray.size()=" << barArray.size() << endl;
462
 
      // cout << "barArrayPrimary.size()=" << barArrayPrimary.size() << endl;
463
 
      // cout << "barArraySecondary.size()=" << barArraySecondary.size() << endl;
464
456
 
465
457
      plHit->SetEMRBarArray(barArray);
466
458
      plHit->SetEMRBarArrayPrimary(barArrayPrimary);
467
459
      plHit->SetEMRBarArraySecondary(barArraySecondary);
468
 
      if ( barArray.size() || barArrayPrimary.size() || barArraySecondary.size() || xCharge) {
469
 
        plArray.push_back(plHit);
 
460
      if ( barArray.size() || barArrayPrimary.size() || barArraySecondary.size() || xCharge) {     
 
461
        cout << "------------------------xPlane=" << xPlane << endl;
 
462
        cout << "xCharge=" << xCharge << endl;
 
463
        cout << "g4_edep_mev=" << g4_edep_mev << endl;
 
464
        cout << "barArray.size()=" << barArray.size() << endl;
 
465
        cout << "barArrayPrimary.size()=" << barArrayPrimary.size() << endl;
 
466
        cout << "barArraySecondary.size()=" << barArraySecondary.size() << endl;
 
467
         plArray.push_back(plHit);
470
468
      }
471
469
    }
472
470
    evt->SetEMRPlaneHitArray(plArray);
533
531
    for (int iTrigger=0; iTrigger<_nTriggers+_nSeconTrig; iTrigger++) {
534
532
      _emr_dbb_events[i][iTrigger].resize(48);  // number of planes
535
533
      for (int iplane=0; iplane<48; iplane++) {
536
 
        _emr_dbb_events[i][iTrigger][iplane].resize(60); // number of bars in a plane
 
534
         _emr_dbb_events[i][iTrigger][iplane].resize(60); // number of bars in a plane
537
535
      }
538
536
    }
539
537
  }
583
581
 
584
582
      // find primary hit
585
583
      for (int iBar=1; iBar<=59; iBar++) {
586
 
        if (Hit0Found) break;
587
 
        if (_emr_dbb_events[1][iTrigger][iPlane][iBar].size()) {
588
 
          Hit0 = _emr_dbb_events[1][iTrigger][iPlane][iBar][0];
589
 
          Hit0Found = true;
590
 
          x0 = iPlane;
591
 
          barid = iBar;
592
 
        }
 
584
         if (Hit0Found) break;
 
585
           if (_emr_dbb_events[1][iTrigger][iPlane][iBar].size()) {
 
586
             Hit0 = _emr_dbb_events[1][iTrigger][iPlane][iBar][0];
 
587
           Hit0Found = true;
 
588
           x0 = iPlane;
 
589
           barid = iBar;
 
590
         }
593
591
      }
594
592
 
595
593
      if (!Hit0Found) continue;
596
594
 
597
595
      // look backwards for hits
598
596
      for (int aPlane=iPlane-1; aPlane>=0; aPlane=aPlane-2 ) {
599
 
        if (Hit1Found) break;
600
 
        for (int aBar=1; aBar<=59; aBar++) {
601
 
          if (_emr_dbb_events[1][iTrigger][aPlane][aBar].size()) {
602
 
            if (!Hit1Found) {
603
 
              Hit1Found = true;
604
 
              x1 = aPlane;
605
 
              y1 = aBar;
606
 
            }
607
 
          }
608
 
        }
 
597
         if (Hit1Found) break;
 
598
         for (int aBar=1; aBar<=59; aBar++) {
 
599
           if (_emr_dbb_events[1][iTrigger][aPlane][aBar].size()) {
 
600
             if (!Hit1Found) {
 
601
               Hit1Found = true;
 
602
               x1 = aPlane;
 
603
               y1 = aBar;
 
604
             }
 
605
           }
 
606
         }
609
607
      }
610
608
      
611
609
      // look forward for hits
612
610
      for (int bPlane=iPlane+1; bPlane<48; bPlane=bPlane+2 ) {
613
 
        if (Hit1Found && Hit2Found) break;
614
 
        for (int bBar=1; bBar<=59; bBar++) {
615
 
          if (_emr_dbb_events[1][iTrigger][bPlane][bBar].size()) {
616
 
            if (Hit2Found && !Hit1Found) {
617
 
              Hit1Found = true;
618
 
              x1 = bPlane;
619
 
              y1 = bBar;
620
 
            }
621
 
            if (!Hit2Found) {
622
 
              Hit2Found = true;
623
 
              x2 = bPlane;
624
 
              y2 = bBar;
625
 
            }
626
 
          }
627
 
        }
 
611
         if (Hit1Found && Hit2Found) break;
 
612
         for (int bBar=1; bBar<=59; bBar++) {
 
613
           if (_emr_dbb_events[1][iTrigger][bPlane][bBar].size()) {
 
614
             if (Hit2Found && !Hit1Found) {
 
615
               Hit1Found = true;
 
616
               x1 = bPlane;
 
617
               y1 = bBar;
 
618
             }
 
619
             if (!Hit2Found) {
 
620
               Hit2Found = true;
 
621
               x2 = bPlane;
 
622
               y2 = bBar;
 
623
             }
 
624
           }
 
625
         }
628
626
      }
629
627
      
630
628
      // look backwards for the second hit if nothing found in the forward direction
631
629
      for (int aPlane=iPlane-1; aPlane>=0; aPlane=aPlane-2 ) {
632
 
        if (Hit1Found && Hit2Found) break;
633
 
        if (aPlane==x1) continue;
634
 
        for (int aBar=1; aBar<=59; aBar++) {
635
 
          if (_emr_dbb_events[1][iTrigger][aPlane][aBar].size()) {
636
 
            if (Hit1Found && !Hit2Found) {
637
 
              Hit2Found = true;
638
 
              x2 = aPlane;
639
 
              y2 = aBar;
640
 
            }
641
 
          }
642
 
        }
 
630
         if (Hit1Found && Hit2Found) break;
 
631
         if (aPlane==x1) continue;
 
632
         for (int aBar=1; aBar<=59; aBar++) {
 
633
           if (_emr_dbb_events[1][iTrigger][aPlane][aBar].size()) {
 
634
             if (Hit1Found && !Hit2Found) {
 
635
               Hit2Found = true;
 
636
               x2 = aPlane;
 
637
               y2 = aBar;
 
638
             }
 
639
           }
 
640
         }
643
641
      }      
644
642
 
645
643
      if (Hit1Found && Hit2Found) {
646
 
        a = ((double)y2-(double)y1)/((double)x2-(double)x1);
647
 
        b = ((double)y1*(double)x2-(double)y2*(double)x1)/((double)x2-(double)x1);
648
 
        y0 = a*(double)x0+b;
 
644
         a = ((double)y2-(double)y1)/((double)x2-(double)x1);
 
645
         b = ((double)y1*(double)x2-(double)y2*(double)x1)/((double)x2-(double)x1);
 
646
         y0 = a*(double)x0+b;
649
647
      }
650
648
 
651
649
      if (Hit1Found && !Hit2Found) {
652
 
        y0 = y1;
 
650
         y0 = y1;
653
651
      }
654
652
 
655
653
      if (!Hit1Found && Hit2Found) {
656
 
        y0 = y2;
 
654
         y0 = y2;
657
655
      }
658
656
      
659
657
      if (iPlane%2==0) {
660
 
        _emr_dbb_events[1][iTrigger][x0][barid][0].SetX(barid);
661
 
        _emr_dbb_events[1][iTrigger][x0][barid][0].SetY(y0);
 
658
         _emr_dbb_events[1][iTrigger][x0][barid][0].SetX(barid);
 
659
         _emr_dbb_events[1][iTrigger][x0][barid][0].SetY(y0);
662
660
      }
663
661
      if (iPlane%2==1) {
664
 
        _emr_dbb_events[1][iTrigger][x0][barid][0].SetX(y0);
665
 
        _emr_dbb_events[1][iTrigger][x0][barid][0].SetY(barid);
 
662
         _emr_dbb_events[1][iTrigger][x0][barid][0].SetX(y0);
 
663
         _emr_dbb_events[1][iTrigger][x0][barid][0].SetY(barid);
666
664
      }
667
665
      _emr_dbb_events[1][iTrigger][x0][barid][0].SetZ(x0);
668
666
      
669
667
 
670
668
      // cout << x1 << ":" << x2 << "::"<< y1 << ":"<< y2 << "::"<< a << ":"<< b << " - "
671
 
      //           << Hit0.GetX() << " " << Hit0.GetY() << " " << Hit0.GetZ() << endl;
 
669
      //             << Hit0.GetX() << " " << Hit0.GetY() << " " << Hit0.GetZ() << endl;
672
670
      
673
671
    }
674
672
    // cout << endl;