BeamlineRawInputDriver.cxx
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////////
2 /// \file BeamlineRawInputDriver.cxx
3 /// \brief Implementation of the offline conversion for raw beamline
4 /// data for test beam experiment.
5 /// Provided as the templated argument to art::Source.
6 /// \author Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
7 /// \date November 2018
8 ////////////////////////////////////////////////////////////////////////////
9 
10 ////////////////////////////////////////////////////////////////////////////
11 // So, here's what going on.
12 // There are three functions: readNext, makeSpill, makeEvent
13 // -- readNext is just a standard function called by the framework.
14 // It _has_ to make new data (run, subrun, or event) and return true,
15 // or return false, indiciating end of data.
16 // Make and save new data products via the pointer references passed
17 // to the function from the framework.
18 // -- makeSpill initializes a new spill, extracts the raw data from
19 // the file and reformats.
20 // Occassionally this will not be able to fill the BeamlineEvents
21 // object since the event was mis-formed. readNext calls makeSpill
22 // in a while loop until it receives the next spill with correctly
23 // formatted data within, or it reaches the end of the data file.
24 // A spill is saved as an art::subRun in the output file.
25 // -- makeEvent saves the triggers from within each spill.
26 // A trigger is saved as an art::Event in the output file.
27 // The logic is set up so that readNext always returns a new event until
28 // it reaches the end of the file. Sometimes, we will need to start a new
29 // spill and correct extract the data as well, and this is also handled
30 // correctly.
31 ////////////////////////////////////////////////////////////////////////////
32 
34 
35 // -----------------------------------------------------------------------
38  const art::SourceHelper& pm) :
39  fCurrentFilename(""),
40  fCurrentFile(nullptr),
41  fSpillBranch(nullptr),
42  fTDUBranch(nullptr),
43  fEventAuxBranch(nullptr),
44  fNumSpillsInFile(0),
45  fSpillIndex(0),
46  fSourceHelper(pm),
47  fBeamlineEvents(nullptr),
48  fBeamlineUnpack(new BeamlineUnpack(pset.get<fhicl::ParameterSet>("BeamlineUnpack"))) {
49 
50  this->reconfigure(pset);
51 
52  // Declare everything to be put in the art record
53  //helper.reconstitutes<rawdata::BeamlineDAQHeader, art::InEvent>("daq");
55  helper.reconstitutes<std::vector<rawdata::RawBeamlineTrigger>, art::InEvent>(fSourceName, fTriggerName);
56  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent> (fSourceName, fToFName);
57  helper.reconstitutes<std::vector<rawdata::RawBeamlineWC>, art::InEvent> (fSourceName, fWCName);
58  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent> (fSourceName, fCherenkovName);
59  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent> (fSourceName, fMuonStackName);
60  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent> (fSourceName, fPaddleDigitName);
61  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent> (fSourceName, fWCDigitName);
62  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent> (fSourceName, fOtherDigitName);
63  //helper.reconstitutes<sumdata::BeamlineRunData, art::InRun >("daq");
64 
65 }
66 
67 // -----------------------------------------------------------------------
69 
70  // output module label
71  fSourceName = pset.get<std::string>("SourceName");
72 
73  // beamline unpack config
74  fhicl::ParameterSet beamline_config = pset.get<fhicl::ParameterSet>("BeamlineUnpackConfig");
75  fInputSpillTag = beamline_config.get<art::InputTag>("InputSpillTag");
76  fInputTDUTag = beamline_config.get<art::InputTag>("InputTDUTag");
77  fConfigName = beamline_config.get<std::string>("ConfigName");
78  fTriggerName = beamline_config.get<std::string>("TriggerName");
79  fToFName = beamline_config.get<std::string>("ToFName");
80  fWCName = beamline_config.get<std::string>("WCName");
81  fCherenkovName = beamline_config.get<std::string>("CherenkovName");
82  fMuonStackName = beamline_config.get<std::string>("MuonStackName");
83  fPaddleDigitName = beamline_config.get<std::string>("PaddleDigitName");
84  fWCDigitName = beamline_config.get<std::string>("WCDigitName");
85  fOtherDigitName = beamline_config.get<std::string>("OtherDigitName");
86 
87  // parameters
88  fFilterEvents = pset.get<bool>("FilterEvents");
89 
90 }
91 
92 // -----------------------------------------------------------------------
93 /// Close currently opened file
95  fCurrentFile.reset(nullptr);
96  fBeamlineUnpack->EndSpill();
97  fBeamlineEvents = nullptr;
98 }
99 
100 // -----------------------------------------------------------------------
101 /// Get the lariat fragment from the spill wrapper
102 LariatFragment* daq2raw::BeamlineRawInputDriver::getSpillFrag(const SpillWrapper* spillWrapper) {
103 
104  // get the spill data
105  mf::LogVerbatim("BeamlineRawInputDriver") << "Spill construction complete\n"
106  << "Spill starts at "
107  << static_cast<const void*>(spillWrapper->get())
108  << ", can pass this pointer to the LariatFragment constructor\n"
109  << "Spill appears to be " << spillWrapper->size() << " bytes\n";
110 
111  const uint8_t* spillDataPtr(spillWrapper->get());
112 
113  mf::LogVerbatim("BeamlineRawInputDriver") << "Spill is "
114  << spillWrapper->size()
115  << " bytes, starting at "
116  << static_cast<const void*>(spillDataPtr);
117 
118  // make a lariat fragment
119  LariatFragment* lariatFrag = new LariatFragment((char*)spillDataPtr, spillWrapper->size());
120 
121  return lariatFrag;
122 
123 }
124 
125 // -----------------------------------------------------------------------
126 /// Load the artdaq fragments
127 LariatFragment* daq2raw::BeamlineRawInputDriver::loadSpillFragments(TBranch* fragBranch,
128  unsigned int index) {
129 
130  SpillWrapper* spillWrapper = new SpillWrapper(1);
131  artdaq::Fragments* fragments = getFragments(fragBranch, index);
132 
133  if ((*fragments).size() > 1)
134  throw cet::exception("BeamlineRawInputDriver")
135  << "artdaq::Fragment SPILL vector contains more than one fragment.";
136 
137  const artdaq::Fragment& fragment = fragments->at(0);
138  spillWrapper->add(fragment);
139 
140  if (!spillWrapper->ready())
141  throw cet::exception("BeamlineRawInputDriver")
142  << "Spill construction failed; spill is incomplete." << std::endl;
143 
144  // load the lariat fragment
145  LariatFragment* lariatFrag = getSpillFrag(spillWrapper);
146 
147  delete spillWrapper;
148  return lariatFrag;
149 }
150 
151 // -----------------------------------------------------------------------
152 /// Load the TDU artdaq fragment
153 std::vector<TDUFragment*> daq2raw::BeamlineRawInputDriver::loadTDUFragments(TBranch* tduBranch,
154  unsigned int index) {
155 
156  // container of tdu fragments to be read in from the
157  // artdaq branch
158  std::vector<TDUFragment*> tduFrags;
159 
160  artdaq::Fragments* fragments = getFragments(tduBranch, index);
161 
162  if ((*fragments).size() > 1)
163  throw cet::exception("BeamlineRawInputDriver")
164  << "artdaq::Fragment TDU vector contains more than one fragment.";
165 
166  for (artdaq::Fragments::const_iterator fragIt = fragments->begin(); fragIt != fragments->end(); ++fragIt) {
167 
168  artdaq::ContainerFragment cont_frag(*fragIt);
169 
170  for (size_t block = 0; block < cont_frag.block_count(); ++block) {
171  const artdaq::Fragment frag = *cont_frag[block];
172  TDUFragment* tduFrag = new TDUFragment(reinterpret_cast<const char*>(frag.dataBeginBytes()));
173  tduFrags.push_back(tduFrag);
174  }
175 
176  }
177 
178  return tduFrags;
179 
180 }
181 
182 // -----------------------------------------------------------------------
183 /// Open the file, "name" and construct and return a
184 /// new FileBlock object. MUST be successful or throw:
185 /// art::Exception(art::errors::FileOpenError) or
186 /// art::Exception(art::errors::FileReadError) are good candidates.
188  art::FileBlock*& fileblock) {
189 
191  mf::LogVerbatim("BeamlineRawInputDriver::readFile")
192  << "Reading new file " << fCurrentFilename << std::endl;
193 
194  // get the artdaq::Fragments branches
195  fCurrentFile.reset(new TFile(filename.data()));
196  TTree* eventTree = reinterpret_cast<TTree*>(fCurrentFile->Get(art::rootNames::eventTreeName().c_str()));
197  fSpillBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputSpillTag).data());
198  fTDUBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputTDUTag).data());
199 
200  // get event auxiliary branch, for run/subrun info
201  fEventAuxBranch = eventTree->GetBranch("EventAuxiliary");
202 
203  // ensure we have the same number of spills in each component
204  if (fSpillBranch->GetEntries() != fTDUBranch->GetEntries())
205  throw cet::exception("BeamlineRawInputDriver::readFile")
206  << "Number of spills recorded in spill branch (" << fSpillBranch->GetEntries() << ") "
207  << "does not match number of spills recorded in TDU branch (" << fTDUBranch->GetEntries() << ")."
208  << std::endl;
209  else {
210  fNumSpillsInFile = fSpillBranch->GetEntries();
211  mf::LogVerbatim("BeamlineRawInputDriver::readFile") << "Number of spills in file: "
213  }
214 
215  // new fileblock
216  fileblock = new art::FileBlock(art::FileFormatVersion(), filename);
217  if (fileblock == nullptr) {
219  << "Unable to open file " << filename << "." << std::endl;
220  }
221 
222  // get database parameters?
223 
224  // configure beamline unpack alg?
225 
226  // start new spill index
227  fSpillIndex = -1;
228 
229  return true;
230 
231 }
232 
233 // -----------------------------------------------------------------------
234 /// Read and fill Run, SubRun and/or Event as might be appropriate.
236  art::SubRunPrincipal* const& inSubRun,
237  art::RunPrincipal*& outRun,
238  art::SubRunPrincipal*& outSubRun,
239  art::EventPrincipal*& outEvent) {
240 
241  // - readNext
242  // Make a new art::Event (new trigger) and save in output file
243  // each time it is called.
244  // Also determines when a new subRun (new spill) is needed
245  // and handles this.
246  // - returns: true/false, indicating whether or not we have
247  // reached the end of the file.
248 
249  // MW, 3-12-2019
250  // I think this logic is fine and will only save subruns when events exist in them.
251  // This is the correct way to implement this, I believe:
252  // https://cdcvs.fnal.gov/redmine/projects/art/wiki/Writing_your_own_input_sources
253  // ``` outE should always be provided unless the function returns false, indicating no data. ```
254 
255  bool moreSpills = true;
256  while ((!fBeamlineEvents or !fBeamlineEvents->IsNextEvent()) and moreSpills) {
257  fBeamlineUnpack->EndSpill();
258  moreSpills = this->makeSpill(inRun, inSubRun, outRun, outSubRun);
259  }
260 
261  if (!moreSpills)
262  return false;
263 
264  this->makeEvent(outEvent);
265 
266  return true;
267 
268 }
269 
270 // -----------------------------------------------------------------------
272  art::SubRunPrincipal* const& inSubRun,
273  art::RunPrincipal*& outRun,
274  art::SubRunPrincipal*& outSubRun) {
275 
276  // - makeSpill
277  // Initializes a new spill, retrieves the data from the raw file
278  // for this spill and reformats into NOvASoft-formatted data.
279  // - returns: true/false indicating whether or not there are more
280  // spills in the file. Assumed true apart from at the start of
281  // function, which checks.
282 
283  ++fSpillIndex;
284 
285  if (fSpillIndex >= (int)fNumSpillsInFile)
286  return false; // done with file
287 
288  art::EventAuxiliary eventAux;
289  art::EventAuxiliary* eventAuxPtr = &eventAux;
290  fEventAuxBranch->SetAddress(&eventAuxPtr);
291  fEventAuxBranch->GetEntry(fSpillIndex);
292  fRunNumber = eventAux.run();
293  fSubRunNumber = eventAux.subRun();
294 
295  mf::LogVerbatim("BeamlineRawInputDriver::makeSpill")
296  << "\n////////////////////////////////////\n"
297  << "// Run: " << fRunNumber << "\n"
298  << "// SubRun: " << fSubRunNumber << "\n"
299  << "////////////////////////////////////\n";
300 
301  // load the artdaq fragments
302  LariatFragment* lariatFrag = loadSpillFragments(fSpillBranch, fSpillIndex);
303  std::vector<TDUFragment*> tduFrags = loadTDUFragments(fTDUBranch, fSpillIndex);
304 
305  // fill all novasoft data products
306  try {
307  fBeamlineUnpack->Unpack(lariatFrag, tduFrags, fRunNumber, fCurrentFilename);
308  }
309 
310  // fBeamlineUnpack throws exceptions if it cannot unpack everything successfully
311  // TEMPORARY? : catch these exceptions and carry on running
312  catch (cet::exception& e) {
313  mf::LogWarning("BeamlineRawInputDriver::readNext")
314  << e.what() << std::endl
315  << "EXCEPTION CAUGHT: Ignore this spill, move on to next one." << std::endl;
316  fBeamlineUnpack->EndSpill();
317  fBeamlineEvents = nullptr;
318  delete lariatFrag;
319  return true;
320  }
321 
322  // get the beamline events
323  fBeamlineEvents = fBeamlineUnpack->GetBeamlineEvents();
324 
325  // filter the beamline events to only contain good events
326  if (fFilterEvents)
328 
329  mf::LogVerbatim("BeamlineRawInputDriver::readNext")
330  << "After filtering, number of events " << fBeamlineEvents->NumEvents() << std::endl;
331 
332  // art requires a new event to be made each time
333  if (fBeamlineEvents->NumEvents() == 0) {
334  fBeamlineUnpack->EndSpill();
335  fBeamlineEvents = nullptr;
336  return true;
337  }
338 
339  mf::LogVerbatim("BeamlineRawInputDriver::makeSpill")
340  << "Initializing new spill " << fSpillIndex << std::endl;
341 
343 
344  // make new run/subrun principals
345  if (!inRun or (inRun->run() != fRunNumber)) {
346  outRun = fSourceHelper.makeRunPrincipal(fRunNumber, timestamp);
347  this->commenceRun(outRun);
348  }
349 
350  if (!inSubRun or (inSubRun->subRun() != fSubRunNumber)) {
351  outSubRun = fSourceHelper.makeSubRunPrincipal(fRunNumber, fSubRunNumber, timestamp);
352  this->commenceSubRun(outSubRun);
353  }
354 
355  mf::LogVerbatim("BeamlineRawInputDriver::readNext") << "Number of triggers in spill " << fSpillIndex
356  << ": " << fBeamlineEvents->NumEvents() << std::endl;
357 
358  delete lariatFrag;
359  return true;
360 
361 }
362 
363 // -----------------------------------------------------------------------
365 
366  // - makeEvent
367  // Extracts the offline-formatted data from the trigger and
368  // places the data products inside a new art::Event.
369 
370  // get the next event
371  const BeamlineEvent* beamlineEvent = fBeamlineEvents->GetNextEvent();
372 
373  mf::LogVerbatim("BeamlineRawInputDriver::makeEvent") << "Processing event "
374  << beamlineEvent->EventNumber() << std::endl;
375 
376  // make event principal
378  (fRunNumber, fSubRunNumber, beamlineEvent->EventNumber(), art::Timestamp());
379 
380  // get the RawData objects for this event
381  rawdata::RawBeamlineConfig config = beamlineEvent->GetConfig();
382  std::vector<rawdata::RawBeamlineTrigger> trigger = beamlineEvent->GetTrigger();
383  std::vector<rawdata::RawBeamlineDigit> tof = beamlineEvent->GetToF();
384  std::vector<rawdata::RawBeamlineWC> wc = beamlineEvent->GetWC();
385  std::vector<rawdata::RawBeamlineDigit> cherenkov = beamlineEvent->GetCherenkov();
386  std::vector<rawdata::RawBeamlineDigit> muonstack = beamlineEvent->GetMuonStack();
387  std::vector<rawdata::RawBeamlineDigit> paddledigit = beamlineEvent->GetPaddleDigit();
388  std::vector<rawdata::RawBeamlineDigit> wcdigit = beamlineEvent->GetWCDigit();
389  std::vector<rawdata::RawBeamlineDigit> otherdigit = beamlineEvent->GetOtherDigit();
390 
391  // put the RawData objects into the art::Event
393  (std::make_unique<rawdata::RawBeamlineConfig>(config), *outEvent, fSourceName, fConfigName);
395  (std::make_unique<std::vector<rawdata::RawBeamlineTrigger> >(trigger), *outEvent, fSourceName, fTriggerName);
397  (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(tof), *outEvent, fSourceName, fToFName);
399  (std::make_unique<std::vector<rawdata::RawBeamlineWC> >(wc), *outEvent, fSourceName, fWCName);
401  (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(cherenkov), *outEvent, fSourceName, fCherenkovName);
403  (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(muonstack), *outEvent, fSourceName, fMuonStackName);
405  (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(paddledigit), *outEvent, fSourceName, fPaddleDigitName);
407  (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(wcdigit), *outEvent, fSourceName, fWCDigitName);
409  (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(otherdigit), *outEvent, fSourceName, fOtherDigitName);
410 
411  return;
412 
413 }
414 
415 // -----------------------------------------------------------------------
417 
418  // //fFragmentToDigitAlg.InitializeRun(outRun, fRunNumber, fTimestamp);
419  // fFragmentToDigitAlg.InitializeRun(fRunNumber, fTimestamp);
420 
421  // // grab the geometry object to see what geometry we are using
422  // art::ServiceHandle<geo::Geometry> geo;
423  // // std::unique_ptr<sumdata::RunData> runcol(new sumdata::RunData(geo->DetectorName()));
424  // sumdata::RunData runcol = sumdata::RunData(geo->DetectorName());
425  // art::put_product_in_principal(std::make_unique<sumdata::RunData>(runcol),
426  // *outRun,
427  // fSourceName);
428 
429  return;
430 
431 }
432 
433 // -----------------------------------------------------------------------
435 
436  // std::initializer_list<std::string> subrun_params = {
437  // "end_f_mc7sc1"
438  // };
439 
440  // std::vector<std::string> subrunparams(subrun_params);
441 
442  // auto subrunValues = fDatabaseUtility->GetIFBeamValues(subrunparams,
443  // static_cast <int> (fRunNumber),
444  // static_cast <int> (fSubRunNumber));
445 
446  // LOG_VERBATIM("EventBuilderInput") << subrunValues["end_f_mc7sc1"];
447 
448  // size_t endMC7SC1 = this->castToSizeT_(subrunValues["end_f_mc7sc1"]);
449  // bool v1751CaenEnableReadout = this->castToSizeT_(fConfigValues["v1751_config_caen_enablereadout"]);
450  // size_t asicCollectionFilter = this->castToSizeT_(fConfigValues["larasic_config_larasic_collection_filter"]);
451  // size_t asicCollectionGain = this->castToSizeT_(fConfigValues["larasic_config_larasic_collection_gain"]);
452  // bool asicEnableReadout = this->castToSizeT_(fConfigValues["larasic_config_larasic_enablereadout"]);
453  // bool asicPulserOn = this->castToSizeT_(fConfigValues["larasic_config_larasic_pulseron"]);
454  // bool asicChannelScan = this->castToSizeT_(fConfigValues["larasic_config_larasic_channelscan"]);
455  // size_t v1740RecordLength = this->castToSizeT_(fConfigValues["v1740_config_caen_recordlength"]);
456 
457  // std::unique_ptr<ldp::ConditionsSummary> conditionsSummary(new ldp::ConditionsSummary(ndMC7SC1,
458  // v1751CaenEnableReadout,
459  // asicCollectionFilter,
460  // asicCollectionGain,
461  // asicEnableReadout,
462  // asicPulserOn,
463  // asicChannelScan,
464  // v1740RecordLength));
465 
466  // art::put_product_in_principal(std::move(conditionsSummary), *outSubRun, fSourceName);
467 
468  // return;
469 
470 }
std::unique_ptr< daq2raw::BeamlineUnpack > fBeamlineUnpack
RunNumber_t run() const
MaybeLogger_< ELseverityLevel::ELsev_info, true > LogVerbatim
void reconfigure(const fhicl::ParameterSet &pset)
EventPrincipal * makeEventPrincipal(EventAuxiliary const &eventAux, std::shared_ptr< History > &&history) const
bool readNext(art::RunPrincipal *const &inR, art::SubRunPrincipal *const &inSR, art::RunPrincipal *&outR, art::SubRunPrincipal *&outSR, art::EventPrincipal *&outE)
Read and fill Run, SubRun and/or Event as might be appropriate.
bool makeSpill(art::RunPrincipal *const &inRun, art::SubRunPrincipal *const &inSubRun, art::RunPrincipal *&outRun, art::SubRunPrincipal *&outSubRun)
make a new spill
rawdata::RawBeamlineConfig GetConfig() const
std::enable_if_t< P::branch_type==InEvent||P::branch_type==InResults > put_product_in_principal(std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={})
std::size_t size() const
std::vector< rawdata::RawBeamlineTrigger > GetTrigger() const
std::vector< rawdata::RawBeamlineDigit > GetCherenkov() const
void commenceRun(art::RunPrincipal *&outRun)
start a new run
std::vector< rawdata::RawBeamlineWC > GetWC() const
std::string const & eventTreeName()
unsigned int EventNumber() const
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
BeamlineEvent * GetNextEvent()
Definition: config.py:1
string filename
Definition: shutoffs.py:106
Implementation of the offline conversion for raw beamline data for test beam experiment. Provided as the templated argument to art::Source.
artdaq::Fragments * getFragments(TBranch *br, unsigned entry)
bool readFile(const std::string &filename, art::FileBlock *&fileblock)
const art::SourceHelper & fSourceHelper
TypeLabel const & reconstitutes(std::string const &modLabel, std::string const &instanceName={})
std::vector< rawdata::RawBeamlineDigit > GetToF() const
const XML_Char const XML_Char * data
Definition: expat.h:268
std::vector< TDUFragment * > loadTDUFragments(TBranch *tduBranch, unsigned int index)
load the artdaq TDU fragments from the input file
block
print "ROW IS " print row
Definition: elec2geo.py:31
void closeCurrentFile()
Close currently opened file.
LariatFragment * getSpillFrag(const SpillWrapper *spillWrapper)
get the lariat fragment from the artdaq fragments
T get(std::string const &key) const
Definition: ParameterSet.h:231
std::vector< rawdata::RawBeamlineDigit > GetWCDigit() const
RunPrincipal * makeRunPrincipal(RunAuxiliary const &runAux) const
BeamlineRawInputDriver(const fhicl::ParameterSet &pset, art::ProductRegistryHelper &help, const art::SourceHelper &pm)
RunNumber_t run() const
Definition: RunPrincipal.h:53
void makeEvent(art::EventPrincipal *&outEvent)
make a new event and place the digits within
LariatFragment * loadSpillFragments(TBranch *fragBranch, unsigned int index)
load the artdaq spill fragments from the input file
void commenceSubRun(art::SubRunPrincipal *&outSubRun)
start a new subrun
SubRunNumber_t subRun() const
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
SubRunNumber_t subRun() const
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
std::unique_ptr< TFile > fCurrentFile
const uint8_t * get() const
std::vector< rawdata::RawBeamlineDigit > GetOtherDigit() const
SubRunPrincipal * makeSubRunPrincipal(SubRunAuxiliary const &subRunAux) const
std::vector< rawdata::RawBeamlineDigit > GetMuonStack() const
Float_t e
Definition: plot.C:35
void add(const art::Event &evt, const art::InputTag &tag)
std::vector< rawdata::RawBeamlineDigit > GetPaddleDigit() const
unsigned int NumEvents() const