~durga/maus/rel

« back to all changes in this revision

Viewing changes to src/map/MapCppEMRPlaneHits/MapCppEMRPlaneHits.cc

• browse files at revision 710
• compare with another revision
• download diff
• download tarball
• view history from revision 710

Show diffs side-by-side

added

removed

src/map/MapCppEMRPlaneHits/MapCppEMRPlaneHits.cc

18

18

#include "Utils/CppErrorHandler.hh"

19

19

#include "Utils/JsonWrapper.hh"

20

20

#include "Utils/DAQChannelMap.hh"

 

21

#include "Utils/Exception.hh"

21

22

#include "Interface/dataCards.hh"

22

23

#include "API/PyWrapMapBase.hh"

23

 

#include "Converter/DataConverters/CppJsonSpillConverter.hh"

24

 

#include "Converter/DataConverters/JsonCppSpillConverter.hh"

25

24

 

26

25

#include "src/map/MapCppEMRPlaneHits/MapCppEMRPlaneHits.hh"

27

26

 

58

57

  _number_of_planes = configJSON["EMRnumberOfPlanes"].asInt();

59

58

  _number_of_bars = configJSON["EMRnumberOfBars"].asInt();

60

59

 

61

 

  _tot_noise_low = configJSON["EMRtotNoiseLow"].asInt();

62

 

  _tot_noise_up = configJSON["EMRtotNoiseUp"].asInt();

63

60

  _deltat_signal_low = configJSON["EMRdeltatSignalLow"].asInt();

64

61

  _deltat_signal_up = configJSON["EMRdeltatSignalUp"].asInt();

65

 

  _deltat_noise_low = configJSON["EMRdeltatNoiseLow"].asInt();

66

 

  _deltat_noise_up = configJSON["EMRdeltatNoiseUp"].asInt();

67

62

 

68

63

  // Load EMR channel map

69

64

  map_file_name = JsonWrapper::GetProperty(configJSON,

113

108

 

114

109

  EMRDaq emr_data = spill->GetDAQData()->GetEMRDaq();

115

110

  int nPartEvents = emr_data.GetV1731NumPartEvents();

116

 

//  std::cerr << "nPartEvts: " << nPartEvents << std::endl;

117

 

 

118

 

  // Create DBB and fADC arrays with n+2 events (1 per trigger + noise + decays)

119

 

  EMRDBBEventVector emr_dbb_events_tmp = get_dbb_data_tmp(nPartEvents+2);

120

 

  EMRfADCEventVector emr_fadc_events_tmp = get_fadc_data_tmp(nPartEvents+2);

121

 

 

122

 

  // Fill the fADC and DBB array with DAQ information

 

111

 

 

112

  // Check the Recon event array and EMR Spill Data are initialised, and if not make it so

 

113

  if (!spill->GetReconEvents()) {

 

114

    ReconEventPArray* recEvts = new ReconEventPArray();

 

115

    spill->SetReconEvents(recEvts);

 

116

  }

 

117

  if (!spill->GetEMRSpillData()) {

 

118

    EMRSpillData* emrData = new EMRSpillData();

 

119

    spill->SetEMRSpillData(emrData);

 

120

  }

 

121

 

 

122

  // Create DBB and fADC arrays with n+1 events (1 per trigger + spill data)

 

123

  EMRDBBEventVector emr_dbb_events_tmp = get_dbb_data_tmp(nPartEvents + 1);

 

124

  EMRfADCEventVector emr_fadc_events_tmp = get_fadc_data_tmp(nPartEvents + 1);

 

125

 

 

126

  // Fill the fADC, DBB and spill array with DAQ information

123

127

  processDBB(emr_data, nPartEvents, emr_dbb_events_tmp, emr_fadc_events_tmp);

124

128

  processFADC(emr_data, nPartEvents, emr_fadc_events_tmp);

125

129

 

126

 

  // Fill the Recon event array with Spill information (1 per trigger + noise + decays)

127

 

  fill(spill, nPartEvents+2, emr_dbb_events_tmp, emr_fadc_events_tmp);

 

130

  // Fill the Recon event array with Spill information (1 per trigger + decays)

 

131

  fill(spill, nPartEvents, emr_dbb_events_tmp, emr_fadc_events_tmp);

128

132

}

129

133

 

130

134

void MapCppEMRPlaneHits::processDBB(MAUS::EMRDaq EMRdaq,

164

168

        int xBar   = emr_key->bar();

165

169

//        std::cerr << *emr_key << " --> lt: " << lt << "  tt: " << tt << endl;

166

170

 

167

 

        // Set the spill number for the noise and decay events

168

 

        if (iHit == 0) { // Set the spill information only when processing the very first hit.

169

 

          emr_fadc_events_tmp[nPartEvents][xPlane]._spill = xSpill;

170

 

          emr_fadc_events_tmp[nPartEvents+1][xPlane]._spill = xSpill;

171

 

        }

172

 

 

173

 

        // Loop over the trigger and tries to associate the hit to one of them

 

171

        // Loop over the trigger and try to associate the hit to one of them

174

172

        bool matched = false;

175

173

        for (int iPe = 0; iPe < nPartEvents; iPe++) {

176

174

          DBBHit this_trigger = dbb.GetDBBTriggersArrayElement(iPe);

178

176

//           int tr_tt = this_trigger.GetTTime();

179

177

//           int xCh   = this_trigger.GetChannel();

180

178

 

181

 

          if (iHit == 0) { // Set the plane information only when processing the very first hit.

 

179

          if (iHit == 0) { // Set the spill/trigger only when processing the very first hit

182

180

            emr_fadc_events_tmp[iPe][xPlane]._time  = tr_lt;

183

181

            emr_fadc_events_tmp[iPe][xPlane]._spill = xSpill;

184

182

          }

185

183

 

186

 

          int delta_t = lt - tr_lt;

187

 

          int tot = tt - lt;

 

184

          int xDeltaT = lt - tr_lt;

 

185

          int xTot = tt - lt;

188

186

 

189

187

          // Set bar hit

190

188

          EMRBarHit bHit;

191

 

          bHit.SetTot(tot);

 

189

          bHit.SetTot(xTot);

 

190

          bHit.SetHitTime(lt);

192

191

 

193

 

          // Discriminate noise and decays from events signal

194

 

          if (delta_t > _deltat_signal_low && delta_t < _deltat_signal_up) {

195

 

            bHit.SetDeltaT(delta_t - _deltat_signal_low);

 

192

          // Discriminate primary hits (close to the trigger) from the rest

 

193

          if (xDeltaT > _deltat_signal_low && xDeltaT < _deltat_signal_up) {

 

194

              bHit.SetDeltaT(xDeltaT - _deltat_signal_low);

196

195

//            std::cerr << "*---> " << *emr_key << " --> trigger_Id: " << iPe

197

196

//                    << "  tot: " << tt-lt

198

197

//                    << "  delta: " << delta_t - _deltat_signal_low

199

198

//                    << "(" << delta_t << ")" << std::endl;

200

199

            emr_dbb_events_tmp[iPe][xPlane][xBar].push_back(bHit);

201

200

            matched = true;

202

 

          } else if (delta_t > _deltat_noise_low && delta_t < _deltat_noise_up &&

203

 

                   tot > _tot_noise_low && tot < _tot_noise_up ) {

204

 

            bHit.SetDeltaT(delta_t - _deltat_signal_low);

 

201

          } else if (iPe == nPartEvents-1 && !matched) {

 

202

            bHit.SetDeltaT(0);

205

203

            emr_dbb_events_tmp[nPartEvents][xPlane][xBar].push_back(bHit);

206

 

            matched = true;

207

 

          } else if (iPe == nPartEvents-1 && !matched) {

208

 

            bHit.SetDeltaT(0); // tt -lt is irrelevant for decay products

209

 

            emr_dbb_events_tmp[nPartEvents+1][xPlane][xBar].push_back(bHit);

210

204

          }

211

205

        }

212

 

      }/* else {std::cerr << "WARNING!!! unknow EMR DBB channel " << daq_key << std::endl;}*/

 

206

      } // else {std::cerr << "WARNING!!! unknow EMR DBB channel " << daq_key << std::endl;}

213

207

    }

214

208

  }

215

209

}

232

226

      int xCh   = fADChit.GetChannel();

233

227

      int xArea = fADChit.GetPulseArea();

234

228

      int xPos  = fADChit.GetPositionMin();

 

229

      int xEqType = fADChit.GetEquipType();

235

230

 

236

 

      DAQChannelKey daq_key(xLDC, xGeo, xCh, 121, "emr");

 

231

      DAQChannelKey daq_key(xLDC, xGeo, xCh, xEqType, "emr");

237

232

//      std::cerr << daq_key << std::endl;

238

233

      EMRChannelKey *emr_key = _emrMap.find(&daq_key);

239

234

      if (emr_key) {

254

249

                              EMRDBBEventVector emr_dbb_events_tmp,

255

250

                              EMRfADCEventVector emr_fadc_events_tmp) const {

256

251

 

257

 

  int recPartEvents = spill->GetReconEventSize();

 

252

  // Set the EMR recon events and the spill data

258

253

  ReconEventPArray *recEvts =  spill->GetReconEvents();

259

 

 

260

 

  // Resize the recon event to harbour all the EMR noise+decays

261

 

  while (recPartEvents < nPartEvents) {

262

 

    recEvts->push_back(new ReconEvent);

263

 

    recPartEvents++;

264

 

  }

265

 

 

266

 

//  std::cerr << spill->GetReconEventSize() << std::endl;

267

 

 

268

 

  for (int iPe = 0; iPe < nPartEvents; iPe++) {

 

254

  EMRSpillData *emrData = spill->GetEMRSpillData();

 

255

 

 

256

  for (int iPe = 0; iPe < nPartEvents + 1; iPe++) {

269

257

    EMREvent *evt = new EMREvent;

270

258

    EMRPlaneHitArray plArray;

271

259

 

273

261

      EMRPlaneHit *plHit = new EMRPlaneHit;

274

262

      plHit->SetPlane(iPlane);

275

263

      plHit->SetTrigger(iPe);

276

 

 

277

264

      fADCdata xPlData = emr_fadc_events_tmp[iPe][iPlane];

278

265

      int xOri     = xPlData._orientation;

279

266

      int xCharge  = xPlData._charge;

280

267

      int xTime    = xPlData._time;

281

268

      int xSpill   = xPlData._spill;

282

269

      int xDeltaT  = xPlData._deltat;

283

 

 

284

270

      plHit->SetOrientation(xOri);

285

271

      plHit->SetCharge(xCharge);

286

272

      plHit->SetTime(xTime);

287

273

      plHit->SetSpill(xSpill);

288

274

      plHit->SetDeltaT(xDeltaT);

289

 

 

290

275

      EMRBarArray barArray;

291

276

 

292

277

      for (int iBar = 0; iBar < _number_of_bars; iBar++) {

304

289

      plHit->SetEMRBarArray(barArray);

305

290

      if ( barArray.size() || xCharge ) {

306

291

        plArray.push_back(plHit);

307

 

//        std::cerr << "Ev: " << iPe <<  --> pos: " << xTime << "  area: " << xCharge

308

 

//                  << "  nBarHits: " << barArray.size() << std::endl;

309

292

      } else {

310

293

        delete plHit;

311

294

      }

312

295

    }

313

296

 

314

 

    evt->SetEMRPlaneHitArray(plArray);

315

 

    recEvts->at(iPe)->SetEMREvent(evt);

316

 

    recEvts->at(iPe)->SetPartEventNumber(iPe);

 

297

    if (iPe < nPartEvents) {

 

298

      evt->SetEMRPlaneHitArray(plArray);

 

299

 

 

300

      int nRecEvents = spill->GetReconEventSize();

 

301

      if (nRecEvents > iPe) {

 

302

        recEvts->at(iPe)->SetEMREvent(evt);

 

303

      } else {

 

304

        ReconEvent *recEvt = new ReconEvent;

 

305

        recEvt->SetPartEventNumber(iPe);

 

306

        recEvt->SetEMREvent(evt);

 

307

        recEvts->push_back(recEvt);

 

308

      }

 

309

    } else {

 

310

      emrData->SetEMRPlaneHitArray(plArray);

 

311

    }

317

312

  }

 

313

 

318

314

  spill->SetReconEvents(recEvts);

 

315

  spill->SetEMRSpillData(emrData);

319

316

}

320

317

 

321

318

EMRDBBEventVector MapCppEMRPlaneHits::get_dbb_data_tmp(int nPartEvts) const {

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1