BeamlineRawInputDriver.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    BeamlineRawInputDriver.cxx
/// \brief   Implementation of the offline conversion for raw beamline
///          data for test beam experiment.
///          Provided as the templated argument to art::Source.
/// \author  Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
/// \date    November 2018
////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
// So, here's what going on.
// There are three functions: readNext, makeSpill, makeEvent
//  -- readNext is just a standard function called by the framework.
//     It _has_ to make new data (run, subrun, or event) and return true,
//     or return false, indiciating end of data.
//     Make and save new data products via the pointer references passed
//     to the function from the framework.
//  -- makeSpill initializes a new spill, extracts the raw data from
//     the file and reformats.
//     Occassionally this will not be able to fill the BeamlineEvents
//     object since the event was mis-formed.  readNext calls makeSpill
//     in a while loop until it receives the next spill with correctly
//     formatted data within, or it reaches the end of the data file.
//     A spill is saved as an art::subRun in the output file.
//  -- makeEvent saves the triggers from within each spill.
//     A trigger is saved as an art::Event in the output file.
// The logic is set up so that readNext always returns a new event until
// it reaches the end of the file.  Sometimes, we will need to start a new
// spill and correct extract the data as well, and this is also handled
// correctly.
////////////////////////////////////////////////////////////////////////////

#include "DAQ2RawDigit/testbeam/BeamlineRawInputDriver.h"

// -----------------------------------------------------------------------
daq2raw::BeamlineRawInputDriver::BeamlineRawInputDriver(const fhicl::ParameterSet& pset,
                                                        art::ProductRegistryHelper& helper,
                                                        const art::SourceHelper& pm) :
  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");

}

// -----------------------------------------------------------------------
void daq2raw::BeamlineRawInputDriver::reconfigure(const fhicl::ParameterSet& pset) {

  // 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");

}

// -----------------------------------------------------------------------
/// Close currently opened file
void daq2raw::BeamlineRawInputDriver::closeCurrentFile() {
  fCurrentFile.reset(nullptr);
  fBeamlineUnpack->EndSpill();
  fBeamlineEvents = nullptr;
}

// -----------------------------------------------------------------------
/// Get the lariat fragment from the spill wrapper
LariatFragment* daq2raw::BeamlineRawInputDriver::getSpillFrag(const SpillWrapper* spillWrapper) {

  // 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;

}

// -----------------------------------------------------------------------
/// Load the artdaq fragments
LariatFragment* daq2raw::BeamlineRawInputDriver::loadSpillFragments(TBranch* fragBranch,
                                                                    unsigned int index) {

  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;
}

// -----------------------------------------------------------------------
/// Load the TDU artdaq fragment
std::vector<TDUFragment*> daq2raw::BeamlineRawInputDriver::loadTDUFragments(TBranch* tduBranch,
                                                                            unsigned int index) {

  // 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;

}

// -----------------------------------------------------------------------
/// 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.
bool daq2raw::BeamlineRawInputDriver::readFile(const std::string& filename,
                                               art::FileBlock*& fileblock) {

  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;

}

// -----------------------------------------------------------------------
/// Read and fill Run, SubRun and/or Event as might be appropriate.
bool daq2raw::BeamlineRawInputDriver::readNext(art::RunPrincipal* const& inRun,
                                               art::SubRunPrincipal* const& inSubRun,
                                               art::RunPrincipal*& outRun,
                                               art::SubRunPrincipal*& outSubRun,
                                               art::EventPrincipal*& outEvent) {

  // - 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;

}

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

  // - 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;

}

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

  // - 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;

}

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

  // //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) {

  // 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;

}