daq2raw::BeamlineRawInputDriver Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-09-26/DAQ2RawDigit/testbeam/BeamlineRawInputDriver.h"

Public Member Functions
	BeamlineRawInputDriver (const fhicl::ParameterSet &pset, art::ProductRegistryHelper &help, const art::SourceHelper &pm)
virtual	~BeamlineRawInputDriver ()
void	closeCurrentFile ()
	Close currently opened file. More...
bool	readFile (const std::string &filename, art::FileBlock *&fileblock)
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. More...
void	reconfigure (const fhicl::ParameterSet &pset)

Private Member Functions
void	commenceRun (art::RunPrincipal *&outRun)
	start a new run More...
void	commenceSubRun (art::SubRunPrincipal *&outSubRun)
	start a new subrun More...
LariatFragment *	loadSpillFragments (TBranch *fragBranch, unsigned int index)
	load the artdaq spill fragments from the input file More...
std::vector< TDUFragment * >	loadTDUFragments (TBranch *tduBranch, unsigned int index)
	load the artdaq TDU fragments from the input file More...
LariatFragment *	getSpillFrag (const SpillWrapper *spillWrapper)
	get the lariat fragment from the artdaq fragments More...
bool	makeSpill (art::RunPrincipal *const &inRun, art::SubRunPrincipal *const &inSubRun, art::RunPrincipal *&outRun, art::SubRunPrincipal *&outSubRun)
	make a new spill More...
void	makeEvent (art::EventPrincipal *&outEvent)
	make a new event and place the digits within More...

Private Attributes
art::InputTag	fInputSpillTag
art::InputTag	fInputTDUTag
std::string	fConfigName
std::string	fTriggerName
std::string	fToFName
std::string	fWCName
std::string	fCherenkovName
std::string	fMuonStackName
std::string	fPaddleDigitName
std::string	fWCDigitName
std::string	fOtherDigitName
std::string	fSourceName
std::string	fCurrentFilename
std::unique_ptr< TFile >	fCurrentFile
TBranch *	fSpillBranch
TBranch *	fTDUBranch
TBranch *	fEventAuxBranch
unsigned int	fNumSpillsInFile
int	fSpillIndex
bool	fFilterEvents
const art::SourceHelper &	fSourceHelper
BeamlineEvents *	fBeamlineEvents
art::RunNumber_t	fRunNumber
art::SubRunNumber_t	fSubRunNumber
std::uint64_t	fTimestamp
std::unique_ptr< daq2raw::BeamlineUnpack >	fBeamlineUnpack

Detailed Description

Class to fill the constraints on a template argument to the class, art::Source

Definition at line 66 of file BeamlineRawInputDriver.h.

Constructor & Destructor Documentation

daq2raw::BeamlineRawInputDriver::BeamlineRawInputDriver	(	const fhicl::ParameterSet &	pset,
		art::ProductRegistryHelper &	help,
		const art::SourceHelper &	pm
	)

Definition at line 36 of file BeamlineRawInputDriver.cxx.

References fCherenkovName, fConfigName, fMuonStackName, fOtherDigitName, fPaddleDigitName, fSourceName, fToFName, fTriggerName, fWCDigitName, fWCName, art::InEvent, reconfigure(), and art::ProductRegistryHelper::reconstitutes().

                                                                                   :
  fCurrentFilename(""),
  fCurrentFile(nullptr),
  fSpillBranch(nullptr),
  fTDUBranch(nullptr),
  fEventAuxBranch(nullptr),
  fNumSpillsInFile(0),
  fSpillIndex(0),
  fSourceHelper(pm),
  fBeamlineEvents(nullptr),
  fBeamlineUnpack(new BeamlineUnpack(pset.get<fhicl::ParameterSet>("BeamlineUnpack"))) {

  this->reconfigure(pset);

  // Declare everything to be put in the art record
  //helper.reconstitutes<rawdata::BeamlineDAQHeader,               art::InEvent>("daq");
  helper.reconstitutes<rawdata::RawBeamlineConfig, art::InEvent>              (fSourceName, fConfigName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineTrigger>, art::InEvent>(fSourceName, fTriggerName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent>  (fSourceName, fToFName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineWC>, art::InEvent>     (fSourceName, fWCName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent>  (fSourceName, fCherenkovName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent>  (fSourceName, fMuonStackName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent>  (fSourceName, fPaddleDigitName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent>  (fSourceName, fWCDigitName);
  helper.reconstitutes<std::vector<rawdata::RawBeamlineDigit>, art::InEvent>  (fSourceName, fOtherDigitName);
  //helper.reconstitutes<sumdata::BeamlineRunData,                 art::InRun  >("daq");

}

virtual daq2raw::BeamlineRawInputDriver::~BeamlineRawInputDriver ( )

inlinevirtual

Definition at line 74 of file BeamlineRawInputDriver.h.

References shutoffs::filename, and allTimeWatchdog::index.

{};

Member Function Documentation

void daq2raw::BeamlineRawInputDriver::closeCurrentFile

(

)

Close currently opened file.

Definition at line 94 of file BeamlineRawInputDriver.cxx.

References fBeamlineEvents, fBeamlineUnpack, and fCurrentFile.

                                                     {
  fCurrentFile.reset(nullptr);
  fBeamlineUnpack->EndSpill();
  fBeamlineEvents = nullptr;
}

void daq2raw::BeamlineRawInputDriver::commenceRun ( art::RunPrincipal *&  outRun )

private

start a new run

Definition at line 416 of file BeamlineRawInputDriver.cxx.

Referenced by makeSpill().

                                                                        {

  // //fFragmentToDigitAlg.InitializeRun(outRun, fRunNumber, fTimestamp);
  // fFragmentToDigitAlg.InitializeRun(fRunNumber, fTimestamp);

  // // grab the geometry object to see what geometry we are using
  // art::ServiceHandle<geo::Geometry> geo;
  // // std::unique_ptr<sumdata::RunData> runcol(new sumdata::RunData(geo->DetectorName()));
  // sumdata::RunData runcol = sumdata::RunData(geo->DetectorName());
  // art::put_product_in_principal(std::make_unique<sumdata::RunData>(runcol),
  //                            *outRun,
  //                            fSourceName);

  return;

}

void daq2raw::BeamlineRawInputDriver::commenceSubRun ( art::SubRunPrincipal *&  outSubRun )

private

start a new subrun

Definition at line 434 of file BeamlineRawInputDriver.cxx.

Referenced by makeSpill().

                                                                                 {

  // std::initializer_list<std::string> subrun_params = {
  //   "end_f_mc7sc1"
  // };

  // std::vector<std::string> subrunparams(subrun_params);
    
  // auto subrunValues = fDatabaseUtility->GetIFBeamValues(subrunparams,
  //                                                    static_cast <int> (fRunNumber),
  //                                                    static_cast <int> (fSubRunNumber));

  // LOG_VERBATIM("EventBuilderInput") << subrunValues["end_f_mc7sc1"];

  // size_t              endMC7SC1              = this->castToSizeT_(subrunValues["end_f_mc7sc1"]);
  // bool                v1751CaenEnableReadout = this->castToSizeT_(fConfigValues["v1751_config_caen_enablereadout"]);
  // size_t              asicCollectionFilter   = this->castToSizeT_(fConfigValues["larasic_config_larasic_collection_filter"]);
  // size_t              asicCollectionGain     = this->castToSizeT_(fConfigValues["larasic_config_larasic_collection_gain"]);
  // bool                asicEnableReadout      = this->castToSizeT_(fConfigValues["larasic_config_larasic_enablereadout"]);
  // bool                asicPulserOn           = this->castToSizeT_(fConfigValues["larasic_config_larasic_pulseron"]);
  // bool                asicChannelScan        = this->castToSizeT_(fConfigValues["larasic_config_larasic_channelscan"]);
  // size_t              v1740RecordLength      = this->castToSizeT_(fConfigValues["v1740_config_caen_recordlength"]);

  // std::unique_ptr<ldp::ConditionsSummary> conditionsSummary(new ldp::ConditionsSummary(ndMC7SC1,
  //                                                                                   v1751CaenEnableReadout,
  //                                                                                   asicCollectionFilter,
  //                                                                                   asicCollectionGain,
  //                                                                                   asicEnableReadout,
  //                                                                                   asicPulserOn,
  //                                                                                   asicChannelScan,
  //                                                                                   v1740RecordLength));

  // art::put_product_in_principal(std::move(conditionsSummary), *outSubRun, fSourceName);

  // return;

}

LariatFragment * daq2raw::BeamlineRawInputDriver::getSpillFrag ( const SpillWrapper *  spillWrapper )

private

get the lariat fragment from the artdaq fragments

Get the lariat fragment from the spill wrapper.

Definition at line 102 of file BeamlineRawInputDriver.cxx.

References daq2raw::SpillWrapper::get(), and daq2raw::SpillWrapper::size().

Referenced by loadSpillFragments().

                                                                                            {

  // get the spill data
  mf::LogVerbatim("BeamlineRawInputDriver") << "Spill construction complete\n"
                                            << "Spill starts at "
                                            << static_cast<const void*>(spillWrapper->get())
                                            << ", can pass this pointer to the LariatFragment constructor\n"
                                            << "Spill appears to be " << spillWrapper->size() << " bytes\n";

  const uint8_t* spillDataPtr(spillWrapper->get());

  mf::LogVerbatim("BeamlineRawInputDriver") << "Spill is "
                                            << spillWrapper->size()
                                            << " bytes, starting at "    
                                            << static_cast<const void*>(spillDataPtr);

  // make a lariat fragment
  LariatFragment* lariatFrag = new LariatFragment((char*)spillDataPtr, spillWrapper->size());

  return lariatFrag;

}

LariatFragment * daq2raw::BeamlineRawInputDriver::loadSpillFragments ( TBranch *  fragBranch, unsigned int  index  )

private

load the artdaq spill fragments from the input file

Load the artdaq fragments.

Definition at line 127 of file BeamlineRawInputDriver.cxx.

References daq2raw::SpillWrapper::add(), allTimeWatchdog::endl, daq2raw::getFragments(), getSpillFrag(), and daq2raw::SpillWrapper::ready().

Referenced by makeSpill().

                                                                                        {

  SpillWrapper* spillWrapper = new SpillWrapper(1);
  artdaq::Fragments* fragments = getFragments(fragBranch, index);

  if ((*fragments).size() > 1)
    throw cet::exception("BeamlineRawInputDriver")
      << "artdaq::Fragment SPILL vector contains more than one fragment.";

  const artdaq::Fragment& fragment = fragments->at(0);
  spillWrapper->add(fragment);

  if (!spillWrapper->ready())
    throw cet::exception("BeamlineRawInputDriver")
      << "Spill construction failed; spill is incomplete." << std::endl;

  // load the lariat fragment
  LariatFragment* lariatFrag = getSpillFrag(spillWrapper);

  delete spillWrapper;
  return lariatFrag;
}

std::vector< TDUFragment * > daq2raw::BeamlineRawInputDriver::loadTDUFragments ( TBranch *  tduBranch, unsigned int  index  )

private

load the artdaq TDU fragments from the input file

Load the TDU artdaq fragment.

Definition at line 153 of file BeamlineRawInputDriver.cxx.

References elec2geo::block, and daq2raw::getFragments().

Referenced by makeSpill().

                                                                                                {

  // container of tdu fragments to be read in from the
  // artdaq branch
  std::vector<TDUFragment*> tduFrags;

  artdaq::Fragments* fragments = getFragments(tduBranch, index);

  if ((*fragments).size() > 1)
    throw cet::exception("BeamlineRawInputDriver")
      << "artdaq::Fragment TDU vector contains more than one fragment.";

  for (artdaq::Fragments::const_iterator fragIt = fragments->begin(); fragIt != fragments->end(); ++fragIt) {

    artdaq::ContainerFragment cont_frag(*fragIt);

    for (size_t block = 0; block < cont_frag.block_count(); ++block) {
      const artdaq::Fragment frag = *cont_frag[block];
      TDUFragment* tduFrag = new TDUFragment(reinterpret_cast<const char*>(frag.dataBeginBytes()));
      tduFrags.push_back(tduFrag);
    }

  }

  return tduFrags;

}

void daq2raw::BeamlineRawInputDriver::makeEvent ( art::EventPrincipal *&  outEvent )

private

make a new event and place the digits within

Definition at line 364 of file BeamlineRawInputDriver.cxx.

References allTimeWatchdog::endl, daq2raw::BeamlineEvent::EventNumber(), fBeamlineEvents, fCherenkovName, fConfigName, fMuonStackName, fOtherDigitName, fPaddleDigitName, fRunNumber, fSourceHelper, fSourceName, fSubRunNumber, fToFName, fTriggerName, fWCDigitName, fWCName, daq2raw::BeamlineEvent::GetCherenkov(), daq2raw::BeamlineEvent::GetConfig(), daq2raw::BeamlineEvent::GetMuonStack(), daq2raw::BeamlineEvents::GetNextEvent(), daq2raw::BeamlineEvent::GetOtherDigit(), daq2raw::BeamlineEvent::GetPaddleDigit(), daq2raw::BeamlineEvent::GetToF(), daq2raw::BeamlineEvent::GetTrigger(), daq2raw::BeamlineEvent::GetWC(), daq2raw::BeamlineEvent::GetWCDigit(), art::SourceHelper::makeEventPrincipal(), and art::put_product_in_principal().

Referenced by readNext().

                                                                          {

  // - makeEvent
  // Extracts the offline-formatted data from the trigger and
  // places the data products inside a new art::Event.

  // get the next event
  const BeamlineEvent* beamlineEvent = fBeamlineEvents->GetNextEvent();

  mf::LogVerbatim("BeamlineRawInputDriver::makeEvent") << "Processing event "
                                                       << beamlineEvent->EventNumber() << std::endl;

  // make event principal
  outEvent = fSourceHelper.makeEventPrincipal
    (fRunNumber, fSubRunNumber, beamlineEvent->EventNumber(), art::Timestamp());

  // get the RawData objects for this event
  rawdata::RawBeamlineConfig config = beamlineEvent->GetConfig();
  std::vector<rawdata::RawBeamlineTrigger> trigger = beamlineEvent->GetTrigger();
  std::vector<rawdata::RawBeamlineDigit> tof = beamlineEvent->GetToF();
  std::vector<rawdata::RawBeamlineWC> wc = beamlineEvent->GetWC();
  std::vector<rawdata::RawBeamlineDigit> cherenkov = beamlineEvent->GetCherenkov();
  std::vector<rawdata::RawBeamlineDigit> muonstack = beamlineEvent->GetMuonStack();
  std::vector<rawdata::RawBeamlineDigit> paddledigit = beamlineEvent->GetPaddleDigit();
  std::vector<rawdata::RawBeamlineDigit> wcdigit = beamlineEvent->GetWCDigit();
  std::vector<rawdata::RawBeamlineDigit> otherdigit = beamlineEvent->GetOtherDigit();

  // put the RawData objects into the art::Event
  art::put_product_in_principal
    (std::make_unique<rawdata::RawBeamlineConfig>(config), *outEvent, fSourceName, fConfigName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineTrigger> >(trigger), *outEvent, fSourceName, fTriggerName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(tof), *outEvent, fSourceName, fToFName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineWC> >(wc), *outEvent, fSourceName, fWCName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(cherenkov), *outEvent, fSourceName, fCherenkovName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(muonstack), *outEvent, fSourceName, fMuonStackName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(paddledigit), *outEvent, fSourceName, fPaddleDigitName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(wcdigit), *outEvent, fSourceName, fWCDigitName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(otherdigit), *outEvent, fSourceName, fOtherDigitName);

  return;

}

bool daq2raw::BeamlineRawInputDriver::makeSpill ( art::RunPrincipal *const &  inRun, art::SubRunPrincipal *const &  inSubRun, art::RunPrincipal *&  outRun, art::SubRunPrincipal *&  outSubRun  )

private

make a new spill

Definition at line 271 of file BeamlineRawInputDriver.cxx.

References commenceRun(), commenceSubRun(), e, allTimeWatchdog::endl, fBeamlineEvents, fBeamlineUnpack, fCurrentFilename, fEventAuxBranch, fFilterEvents, daq2raw::BeamlineEvents::FilterGoodEvents(), fNumSpillsInFile, fRunNumber, fSourceHelper, fSpillBranch, fSpillIndex, fSubRunNumber, fTDUBranch, fTimestamp, loadSpillFragments(), loadTDUFragments(), art::SourceHelper::makeRunPrincipal(), art::SourceHelper::makeSubRunPrincipal(), daq2raw::BeamlineEvents::NumEvents(), art::RunPrincipal::run(), art::EventAuxiliary::run(), art::SubRunPrincipal::subRun(), art::EventAuxiliary::subRun(), and submit_nova_art::timestamp.

Referenced by readNext().

                                                                                {

  // - makeSpill
  // Initializes a new spill, retrieves the data from the raw file
  // for this spill and reformats into NOvASoft-formatted data.
  // - returns: true/false indicating whether or not there are more
  // spills in the file.  Assumed true apart from at the start of
  // function, which checks.

  ++fSpillIndex;

  if (fSpillIndex >= (int)fNumSpillsInFile)
    return false; // done with file

  art::EventAuxiliary eventAux;
  art::EventAuxiliary* eventAuxPtr = &eventAux;
  fEventAuxBranch->SetAddress(&eventAuxPtr);
  fEventAuxBranch->GetEntry(fSpillIndex);
  fRunNumber = eventAux.run();
  fSubRunNumber = eventAux.subRun();

  mf::LogVerbatim("BeamlineRawInputDriver::makeSpill")
    << "\n////////////////////////////////////\n"
    << "// Run:    "    << fRunNumber << "\n"
    << "// SubRun: "    << fSubRunNumber << "\n"
    << "////////////////////////////////////\n";

  // load the artdaq fragments
  LariatFragment* lariatFrag = loadSpillFragments(fSpillBranch, fSpillIndex);
  std::vector<TDUFragment*> tduFrags = loadTDUFragments(fTDUBranch, fSpillIndex);

  // fill all novasoft data products
  try {
    fBeamlineUnpack->Unpack(lariatFrag, tduFrags, fRunNumber, fCurrentFilename);
  }

  // fBeamlineUnpack throws exceptions if it cannot unpack everything successfully
  // TEMPORARY? : catch these exceptions and carry on running
  catch (cet::exception& e) {
    mf::LogWarning("BeamlineRawInputDriver::readNext")
      << e.what() << std::endl
      << "EXCEPTION CAUGHT: Ignore this spill, move on to next one." << std::endl;
    fBeamlineUnpack->EndSpill();
    fBeamlineEvents = nullptr;
    delete lariatFrag;
    return true;
  }

  // get the beamline events
  fBeamlineEvents = fBeamlineUnpack->GetBeamlineEvents();

  // filter the beamline events to only contain good events
  if (fFilterEvents)
    fBeamlineEvents->FilterGoodEvents();

  mf::LogVerbatim("BeamlineRawInputDriver::readNext")
    << "After filtering, number of events " << fBeamlineEvents->NumEvents() << std::endl;

  // art requires a new event to be made each time
  if (fBeamlineEvents->NumEvents() == 0) {
    fBeamlineUnpack->EndSpill();
    fBeamlineEvents = nullptr;
    return true;
  }

  mf::LogVerbatim("BeamlineRawInputDriver::makeSpill")
    << "Initializing new spill " << fSpillIndex << std::endl;

  art::Timestamp timestamp = fTimestamp;

  // make new run/subrun principals
  if (!inRun or (inRun->run() != fRunNumber)) {
    outRun = fSourceHelper.makeRunPrincipal(fRunNumber, timestamp);
    this->commenceRun(outRun);
  }

  if (!inSubRun or (inSubRun->subRun() != fSubRunNumber)) {
    outSubRun = fSourceHelper.makeSubRunPrincipal(fRunNumber, fSubRunNumber, timestamp);
    this->commenceSubRun(outSubRun);
  }

  mf::LogVerbatim("BeamlineRawInputDriver::readNext") << "Number of triggers in spill " << fSpillIndex
                                                      << ": " << fBeamlineEvents->NumEvents() << std::endl;

  delete lariatFrag;
  return true;

}

bool daq2raw::BeamlineRawInputDriver::readFile	(	const std::string &	filename,
		art::FileBlock *&	fileblock
	)

Open the file, "name" and construct and return a new FileBlock object. MUST be successful or throw: art::Exception(art::errors::FileOpenError) or art::Exception(art::errors::FileReadError) are good candidates.

Definition at line 187 of file BeamlineRawInputDriver.cxx.

References allTimeWatchdog::endl, art::rootNames::eventTreeName(), fCurrentFile, fCurrentFilename, fEventAuxBranch, shutoffs::filename, art::errors::FileOpenError, fInputSpillTag, fInputTDUTag, fNumSpillsInFile, fSpillBranch, fSpillIndex, and fTDUBranch.

                                                                         {

  fCurrentFilename = filename;
  mf::LogVerbatim("BeamlineRawInputDriver::readFile")
    << "Reading new file " << fCurrentFilename << std::endl;

  // get the artdaq::Fragments branches
  fCurrentFile.reset(new TFile(filename.data()));
  TTree* eventTree = reinterpret_cast<TTree*>(fCurrentFile->Get(art::rootNames::eventTreeName().c_str()));
  fSpillBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputSpillTag).data());
  fTDUBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputTDUTag).data());

  // get event auxiliary branch, for run/subrun info
  fEventAuxBranch = eventTree->GetBranch("EventAuxiliary");

  // ensure we have the same number of spills in each component
  if (fSpillBranch->GetEntries() != fTDUBranch->GetEntries())
    throw cet::exception("BeamlineRawInputDriver::readFile")
      << "Number of spills recorded in spill branch (" << fSpillBranch->GetEntries() << ") "
      << "does not match number of spills recorded in TDU branch (" << fTDUBranch->GetEntries() << ")."
      << std::endl;
  else {
    fNumSpillsInFile = fSpillBranch->GetEntries();
    mf::LogVerbatim("BeamlineRawInputDriver::readFile") << "Number of spills in file: "
                                                        << fNumSpillsInFile << std::endl;
  }

  // new fileblock
  fileblock = new art::FileBlock(art::FileFormatVersion(), filename);
  if (fileblock == nullptr) {
    throw art::Exception(art::errors::FileOpenError)
      << "Unable to open file " << filename << "." << std::endl;
  }

  // get database parameters?

  // configure beamline unpack alg?

  // start new spill index
  fSpillIndex = -1;

  return true;

}

bool daq2raw::BeamlineRawInputDriver::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.

Definition at line 235 of file BeamlineRawInputDriver.cxx.

References fBeamlineEvents, fBeamlineUnpack, daq2raw::BeamlineEvents::IsNextEvent(), makeEvent(), and makeSpill().

                                                                             {

  // - readNext
  // Make a new art::Event (new trigger) and save in output file
  // each time it is called.
  // Also determines when a new subRun (new spill) is needed
  // and handles this.
  // - returns: true/false, indicating whether or not we have
  // reached the end of the file.

  // MW, 3-12-2019
  // I think this logic is fine and will only save subruns when events exist in them.
  // This is the correct way to implement this, I believe:
  // https://cdcvs.fnal.gov/redmine/projects/art/wiki/Writing_your_own_input_sources
  // ``` outE should always be provided unless the function returns false, indicating no data. ```

  bool moreSpills = true;
  while ((!fBeamlineEvents or !fBeamlineEvents->IsNextEvent()) and moreSpills) {
    fBeamlineUnpack->EndSpill();
    moreSpills = this->makeSpill(inRun, inSubRun, outRun, outSubRun);
  }

  if (!moreSpills)
    return false;

  this->makeEvent(outEvent);

  return true;

}

void daq2raw::BeamlineRawInputDriver::reconfigure

(

const fhicl::ParameterSet &

pset

)

Definition at line 68 of file BeamlineRawInputDriver.cxx.

References fCherenkovName, fConfigName, fFilterEvents, fInputSpillTag, fInputTDUTag, fMuonStackName, fOtherDigitName, fPaddleDigitName, fSourceName, fToFName, fTriggerName, fWCDigitName, fWCName, and fhicl::ParameterSet::get().

Referenced by BeamlineRawInputDriver().

                                                                             {

  // output module label
  fSourceName = pset.get<std::string>("SourceName");

  // beamline unpack config
  fhicl::ParameterSet beamline_config = pset.get<fhicl::ParameterSet>("BeamlineUnpackConfig");
  fInputSpillTag   = beamline_config.get<art::InputTag>("InputSpillTag");
  fInputTDUTag     = beamline_config.get<art::InputTag>("InputTDUTag");
  fConfigName      = beamline_config.get<std::string>("ConfigName");
  fTriggerName     = beamline_config.get<std::string>("TriggerName");
  fToFName         = beamline_config.get<std::string>("ToFName");
  fWCName          = beamline_config.get<std::string>("WCName");
  fCherenkovName   = beamline_config.get<std::string>("CherenkovName");
  fMuonStackName   = beamline_config.get<std::string>("MuonStackName");
  fPaddleDigitName = beamline_config.get<std::string>("PaddleDigitName");
  fWCDigitName     = beamline_config.get<std::string>("WCDigitName");
  fOtherDigitName  = beamline_config.get<std::string>("OtherDigitName");

  // parameters
  fFilterEvents = pset.get<bool>("FilterEvents");

}

Member Data Documentation

BeamlineEvents* daq2raw::BeamlineRawInputDriver::fBeamlineEvents

private

Definition at line 142 of file BeamlineRawInputDriver.h.

Referenced by closeCurrentFile(), makeEvent(), makeSpill(), and readNext().

std::unique_ptr<daq2raw::BeamlineUnpack> daq2raw::BeamlineRawInputDriver::fBeamlineUnpack

private

Definition at line 152 of file BeamlineRawInputDriver.h.

Referenced by closeCurrentFile(), makeSpill(), and readNext().

std::string daq2raw::BeamlineRawInputDriver::fCherenkovName

private

Definition at line 122 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

std::string daq2raw::BeamlineRawInputDriver::fConfigName

private

Definition at line 118 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

std::unique_ptr<TFile> daq2raw::BeamlineRawInputDriver::fCurrentFile

private

Definition at line 132 of file BeamlineRawInputDriver.h.

Referenced by closeCurrentFile(), and readFile().

std::string daq2raw::BeamlineRawInputDriver::fCurrentFilename

private

Definition at line 131 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and readFile().

TBranch* daq2raw::BeamlineRawInputDriver::fEventAuxBranch

private

Definition at line 135 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and readFile().

bool daq2raw::BeamlineRawInputDriver::fFilterEvents

private

Definition at line 140 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and reconfigure().

art::InputTag daq2raw::BeamlineRawInputDriver::fInputSpillTag

private

Definition at line 116 of file BeamlineRawInputDriver.h.

Referenced by readFile(), and reconfigure().

art::InputTag daq2raw::BeamlineRawInputDriver::fInputTDUTag

private

Definition at line 117 of file BeamlineRawInputDriver.h.

Referenced by readFile(), and reconfigure().

std::string daq2raw::BeamlineRawInputDriver::fMuonStackName

private

Definition at line 123 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

unsigned int daq2raw::BeamlineRawInputDriver::fNumSpillsInFile

private

Definition at line 136 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and readFile().

std::string daq2raw::BeamlineRawInputDriver::fOtherDigitName

private

Definition at line 126 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

std::string daq2raw::BeamlineRawInputDriver::fPaddleDigitName

private

Definition at line 124 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

art::RunNumber_t daq2raw::BeamlineRawInputDriver::fRunNumber

private

Definition at line 145 of file BeamlineRawInputDriver.h.

Referenced by makeEvent(), and makeSpill().

const art::SourceHelper& daq2raw::BeamlineRawInputDriver::fSourceHelper

private

Definition at line 141 of file BeamlineRawInputDriver.h.

Referenced by makeEvent(), and makeSpill().

std::string daq2raw::BeamlineRawInputDriver::fSourceName

private

Definition at line 128 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

TBranch* daq2raw::BeamlineRawInputDriver::fSpillBranch

private

Definition at line 133 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and readFile().

int daq2raw::BeamlineRawInputDriver::fSpillIndex

private

Definition at line 137 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and readFile().

art::SubRunNumber_t daq2raw::BeamlineRawInputDriver::fSubRunNumber

private

Definition at line 146 of file BeamlineRawInputDriver.h.

Referenced by makeEvent(), and makeSpill().

TBranch* daq2raw::BeamlineRawInputDriver::fTDUBranch

private

Definition at line 134 of file BeamlineRawInputDriver.h.

Referenced by makeSpill(), and readFile().

std::uint64_t daq2raw::BeamlineRawInputDriver::fTimestamp

private

Definition at line 149 of file BeamlineRawInputDriver.h.

Referenced by makeSpill().

std::string daq2raw::BeamlineRawInputDriver::fToFName

private

Definition at line 120 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

std::string daq2raw::BeamlineRawInputDriver::fTriggerName

private

Definition at line 119 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

std::string daq2raw::BeamlineRawInputDriver::fWCDigitName

private

Definition at line 125 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

std::string daq2raw::BeamlineRawInputDriver::fWCName

private

Definition at line 121 of file BeamlineRawInputDriver.h.

Referenced by BeamlineRawInputDriver(), makeEvent(), and reconfigure().

---

The documentation for this class was generated from the following files:

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-09-26/DAQ2RawDigit/testbeam/BeamlineRawInputDriver.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-09-26/DAQ2RawDigit/testbeam/BeamlineRawInputDriver.cxx