TestBeamRawInputDriver.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    TestBeamRawInputDriver.cxx
/// \brief   Implementation of the offline conversion of both
///          test beam data streams (beamline and detector).
///          Provided as the templated argument to art::Source.
/// \author  Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
/// \date    December 2018
////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
/// So, how does this work?  Good question.
///
/// We have two data streams: detector and beamline.
/// Anticipate both beamline and detector files will be data collected
/// over period of ~O(1 hour) (similar to ND), but they will obviously
/// not necessarily overlap.
/// The detector files contain beamline triggers and other (e.g. cosmic)
/// triggers.  Beamline triggers will line up with triggers in the
/// beamline files.  Other trigger streams are saved in separate output
/// files, so only need to worry about beamline triggers here.
///
/// Demonstration (| = trigger):
///
///    |      ||      |            |       |     |
///   ----------------------------------------  ------- Detector data
///   --------------------  --------------------------- Beamline data
///    |      ||      |            |       |     |
///
/// This module is designed to run over a single detector file and assumes
/// the beamline data files which align with this in time are in the
/// working directory.  No checks on this are performed nor are any
/// attempts made to look up files in this module.
///
/// In order to match and merge the two streams into the same art::Event,
/// the following is performed:
///  -- perform an initial scan through the beamline data files to index
///     the file name, spill number and trigger number for each TDU
///     timestamp;
///  -- read in the given detector data file and convert to NOvASoft
///     data formatting;
///  -- convert the detector data into NOvASoft-formatted offline data
///     products;
///  -- for each event, compare TDU timestamp with the timestamps of the
///     beamline events and find corresponding beamline information;
///  -- save all the NOvASoft data products within an art::Event.
////////////////////////////////////////////////////////////////////////////

#include "DAQ2RawDigit/testbeam/TestBeamRawInputDriver.h"

//------------------------------------------------------------------------------
daq2raw::TestBeamRawInputDriver::TestBeamRawInputDriver(fhicl::ParameterSet const &pset,
                                                        art::ProductRegistryHelper &helper,
                                                        art::SourceHelper const &pm) :
  NOvAInputDriverBase(pset.get<std::string>("GDMLFileBase","")),
  fBeamlineUnpack(new BeamlineUnpack(pset.get<fhicl::ParameterSet>("BeamlineUnpack"))),
  fSourceHelper(pm),
  fCurrentFilename(),
  fCurrentSubRunID(-1, -1),
  fParser() {

  this->reconfigure(pset);

  fParser.setDebug(false);

  // Declare everything to be put in the art record
  helper.reconstitutes<sumdata::RunData,                         art::InRun>  (fSourceName);
  helper.reconstitutes<rawdata::DAQHeader,                       art::InEvent>(fSourceName);
  helper.reconstitutes<std::vector<rawdata::RawDigit>,           art::InEvent>(fSourceName);
  helper.reconstitutes<std::vector<rawdata::RawTrigger>,         art::InEvent>(fSourceName);
  helper.reconstitutes<std::vector<rawdata::RawSumDropMB>,       art::InEvent>(fSourceName);
  helper.reconstitutes<std::vector<rawdata::RawSumDCM>,          art::InEvent>(fSourceName);
  if (fDoFillFlatDAQData)
    helper.reconstitutes<std::vector<rawdata::FlatDAQData>,        art::InEvent>(fSourceName);
  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);

  // Read in all the beamline data
  this->readBeamline();

}

//------------------------------------------------------------------------------
void daq2raw::TestBeamRawInputDriver::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");

  // running options
  fMaxEventSize              = pset.get<size_t>("maxEventSizeK", 65536) * 1024;
  fFilterCorruptedNanoslices = pset.get<bool>("FilterCorruptedNanoslices");
  fDoFillFlatDAQData         = pset.get<bool>("DoFillFlatDAQData");
  fFilterBeamlineEvents      = pset.get<bool>("FilterBeamlineEvents");

}

//------------------------------------------------------------------------------
/// Close currently-open file.
void daq2raw::TestBeamRawInputDriver::closeCurrentFile() {
  fParser.close();
}

// -----------------------------------------------------------------------
/// Read in all the beamline triggers from the beamline data files.
/// Expect all files relevant for this detector data to have been found
/// and placed in this working directory.
void daq2raw::TestBeamRawInputDriver::readBeamline() {

  fBeamlineEvents.reset(new BeamlineEvents(0));

  // get files in working directory
  TString pwd(gSystem->pwd());
  TSystemDirectory dir(pwd, pwd);
  TList* files = dir.GetListOfFiles();
  if (!files)
    return;

  // loop over files in working directory
  TSystemFile* file;
  TString file_name;
  TIter next(files);
  while ((file = (TSystemFile*)next())) {

    file_name = file->GetName();
    if (!file_name.BeginsWith("novabeamline_") or !file_name.EndsWith(".root"))
      continue;
    mf::LogVerbatim("TestBeamRawInputDriver::readBeamline")
      << "Reading in beamline file " << file_name << std::endl;
    BeamlineFileIndex bl_file(file_name.Data());

    // get artdaq::Fragments branch
    TFile* inFile = TFile::Open(file_name, "READ");
    TTree* eventTree = reinterpret_cast<TTree*>(inFile->Get(art::rootNames::eventTreeName().c_str()));
    TBranch* spillBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputSpillTag).data());
    TBranch* tduBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputTDUTag).data());

    // ensure we have the same number of spills in each component
    unsigned int numSpillsInFile = 0;
    if (spillBranch->GetEntries() != tduBranch->GetEntries())
      throw cet::exception("TestBeamRawInputDriver::readBeamline")
        << "In file " << file_name << ", "
        << "number of spills recorded in spill branch (" << spillBranch->GetEntries() << ") "
        << "does not match number of spills recorded in TDU branch (" << tduBranch->GetEntries() << ")."
        << std::endl;
    else {
      numSpillsInFile = spillBranch->GetEntries();
      mf::LogVerbatim("TestBeamRawInputDriver::readBeamline")
        << "Number of spills in file " << file_name << ": "
        << numSpillsInFile << std::endl;
    }

    // loop through spills in the file
    for (unsigned int spillIt = 0; spillIt < numSpillsInFile; ++spillIt) {

      BeamlineSpillIndex bl_spill(bl_file, spillIt);

      // load the artdaq fragments
      LariatFragment* spillFrag = loadSpillFragments(spillBranch, spillIt);
      std::vector<TDUFragment*> tduFrags = loadTDUFragments(tduBranch, spillIt);

      // configure beamline unpack alg?

      // fill all novasoft data products
      try {
        fBeamlineUnpack->Unpack(spillFrag, tduFrags);
      }
      catch (cet::exception& e) {
        mf::LogWarning("TestBeamRawInputDriver::readBeamline")
          << "Unpacking " << file_name << ", spill " << spillIt << std::endl
          << e.what() << std::endl
          << "EXCEPTION CAUGHT: ignoring this spill." << std::endl;
        continue;
      }

      // get the beamline events
      BeamlineEvents* beamlineEvents = fBeamlineUnpack->GetBeamlineEvents();
      mf::LogVerbatim("TestBeamRawInputDriver::readBeamline")
        << "Number of spills in file " << file_name << ", spill " << spillIt << ": "
        << beamlineEvents->NumEvents() << std::endl;

      // loop through triggers in this spill
      for (unsigned int triggerIt = 0; triggerIt < beamlineEvents->NumEvents(); ++triggerIt) {

        BeamlineTriggerIndex bl_trigger(bl_spill, triggerIt);

        BeamlineEvent* beamlineEvent = beamlineEvents->FindEvent(triggerIt);
        fBeamlineIndex.insert(std::make_pair(beamlineEvent->GetTDUTime(), bl_trigger));

      } // trigger

      delete spillFrag;
      for (std::vector<TDUFragment*>::const_iterator tduIt = tduFrags.begin();
           tduIt != tduFrags.end(); ++tduIt)
        delete *tduIt;
      fBeamlineUnpack->EndSpill();

    } // spill

    inFile->Close();

  } // file

  mf::LogVerbatim("TestBeamRawInputDriver::readBeamline")
    << "Contents of the beamline index map:" << std::endl;
  for (std::map<unsigned long long, BeamlineTriggerIndex>::const_iterator blIndexIt = fBeamlineIndex.begin();
       blIndexIt != fBeamlineIndex.end(); ++blIndexIt)
    mf::LogVerbatim("TestBeamRawInputDriver::readBeamline")
      << "NOvA time " << blIndexIt->first
      << " corresponds to file " << blIndexIt->second.File
      << ", spill " << blIndexIt->second.Spill
      << " and trigger " << blIndexIt->second.Trigger << "." << std::endl;

  return;

}

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

  // get the spill data
  mf::LogVerbatim("TestBeamRawInputDriver") << "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("TestBeamRawInputDriver") << "Spill is "
                                            << spillWrapper->size()
                                            << " bytes, starting at "    
                                            << static_cast<const void*>(spillDataPtr);

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

  return spillFrag;

}

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

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

  if ((*fragments).size() > 1)
    throw cet::exception("TestBeamRawInputDriver")
      << "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("TestBeamRawInputDriver")
      << "Spill construction failed; spill is incomplete." << std::endl;

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

  delete spillWrapper;
  return spillFrag;
}

// -----------------------------------------------------------------------
/// Load the TDU artdaq fragment
std::vector<TDUFragment*> daq2raw::TestBeamRawInputDriver::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("TestBeamRawInputDriver")
      << "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;

}

// -----------------------------------------------------------------------
/// Find and load the beamline event which corresponds to a specific
/// TDU timestamp
daq2raw::BeamlineEvent* daq2raw::TestBeamRawInputDriver::loadBeamlineEvent(unsigned long long tduTime) {

  BeamlineTriggerIndex bl_index;

  if (fBeamlineIndex.count(tduTime))
    bl_index = fBeamlineIndex[tduTime];
  else if (fBeamlineIndex.count(tduTime-1))
    bl_index = fBeamlineIndex[tduTime-1];
  else if (fBeamlineIndex.count(tduTime+1))
    bl_index = fBeamlineIndex[tduTime+1];
  else if (fBeamlineIndex.count(tduTime+2))
    bl_index = fBeamlineIndex[tduTime+2];
  else if (fBeamlineIndex.count(tduTime-2))
    bl_index = fBeamlineIndex[tduTime-2];
  else {
    mf::LogWarning("TestBeamRawInputDriver::loadBeamlineEvent")
      << "No beamline event with TDU timestamp " << tduTime << " found." << std::endl;
    return nullptr;
  }

  // open the input file and get the branches
  TFile* inFile = TFile::Open(bl_index.File.c_str(), "READ");
  TTree* eventTree = reinterpret_cast<TTree*>(inFile->Get(art::rootNames::eventTreeName().c_str()));
  TBranch* eventAuxBranch = eventTree->GetBranch("EventAuxiliary");
  TBranch* spillBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputSpillTag).data());
  TBranch* tduBranch = eventTree->GetBranch(getBranchName<artdaq::Fragments>(fInputTDUTag).data());

  // load the artdaq fragments
  LariatFragment* spillFrag = loadSpillFragments(spillBranch, bl_index.Spill);
  std::vector<TDUFragment*> tduFrags = loadTDUFragments(tduBranch, bl_index.Spill);

  // find run number for unpacking the magnetic field
  art::EventAuxiliary eventAux;
  art::EventAuxiliary* eventAuxPtr = &eventAux;
  eventAuxBranch->SetAddress(&eventAuxPtr);
  eventAuxBranch->GetEntry(bl_index.Spill);
  unsigned int beamline_run = eventAux.run();

  // configure beamline unpack alg?

  // unpack and retrieve the beamline events
  fBeamlineUnpack->Unpack(spillFrag, tduFrags, beamline_run, bl_index.File);
  BeamlineEvents* beamlineEvents = fBeamlineUnpack->GetBeamlineEvents();

  // find the trigger
  // Make a new pointer to this on heap so all the other events
  // can be cleaned up at the end of this function.
  // It is the responsibility of the eventual user of this data
  // to clean up when done.
  BeamlineEvent* beamlineEvent
    = new BeamlineEvent(*beamlineEvents->FindEvent(bl_index.Trigger));

  // tidy up
  inFile->Close();
  delete spillFrag;
  for (std::vector<TDUFragment*>::const_iterator tduIt = tduFrags.begin();
       tduIt != tduFrags.end(); ++tduIt)
    delete *tduIt;
  fBeamlineUnpack->EndSpill();

  mf::LogVerbatim("TestBeamRawInputDriver::loadBeamlineEvent")
    << "Found matching beamline event from file "
    << bl_index.File << ", spill "
    << bl_index.Spill << " and trigger "
    << bl_index.Trigger << std::endl;

  return beamlineEvent;

}

//------------------------------------------------------------------------------
/// 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.
void daq2raw::TestBeamRawInputDriver::readFile(std::string const &name,
                                               art::FileBlock* &fb) {

  fCurrentFilename = name;

  int fd = fParser.open(fCurrentFilename.c_str());
  if (fd == -1) { // Failure
    throw art::Exception(art::errors::FileOpenError)
      << "Unable to open file "
      << name
      << " due to system error, \""
      << strerror(errno)
      << "\"\n";
  }

  fb = new art::FileBlock(art::FileFormatVersion(1, "NOvARawInput 2011a"),
                          fCurrentFilename);
}

//------------------------------------------------------------------------------
/// Read and fill Run, SubRun and/or Event as might be
/// appropriate.
bool daq2raw::TestBeamRawInputDriver::readNext(art::RunPrincipal* const &inR,
                                               art::SubRunPrincipal* const &inSR,
                                               art::RunPrincipal* &outR,
                                               art::SubRunPrincipal* &outSR,
                                               art::EventPrincipal* &outE) {

  ////////////////////////////////////
  // Unpack the data.

  // NOTE: As of OnlineUnpack.cxx r1.9, the histogram pointers required
  // in the constructor are *not* filled. In the event that one *does*
  // want this kind of information, the data to be histogrammed should
  // be put into event products (not necessarily written out to file)
  // and turned into histograms by a downstream analyzer. This will
  // enable easy management of different histograms for diferent runs,
  // subruns, etc, etc and trivial control of whether histograns are
  // actually wanted or not.
  daq2raw::OnlineUnpack up(nullptr, nullptr, nullptr, &fCurrentFilename);
  up.fFilterCorruptedNanoslices = fFilterCorruptedNanoslices;

  /// Define data structures, which will be filled by OnlineUnpack::ProcessRawEvent
  std::unique_ptr<std::vector<rawdata::RawDigit> > digits(new std::vector<rawdata::RawDigit>);
  rawdata::RawTrigger   raw_trigger;
  rawdata::RawSumDropMB raw_sumDropMB;
  rawdata::RawSumDCM    raw_sumDCM;
  rawdata::FlatDAQData  flat_daq_data;
  rawdata::DAQHeader    daq_header;

  /// Fill the data structures for this event.
  if (!up.ProcessRawEvent(fParser,
                          digits.get(),
                          &raw_trigger,
                          &raw_sumDropMB,
                          &raw_sumDCM,
                          &flat_daq_data,
                          &daq_header))
    return false;

  // Get the actual timestamp here - use the current time as the
  // default, maybe the default should really be a ridiculous value
  struct timespec ts;

  novadaq::timeutils::
    convertNovaTimeToUnixTime(raw_trigger.fTriggerTimingMarker_TimeStart, ts);

  // Find the corresponding beamline event which matches this
  // detector trigger.
  BeamlineEvent* beamlineEvent
    = loadBeamlineEvent(raw_trigger.fTriggerTimingMarker_TimeStart);
  // // Consider leaving this event if there is no corresponding beamline data
  // if (!beamlineEvent)
  //   return true;

  // art::Timestamp has the seconds since the beginning of the epoch
  // in the upper 32 bits and the fractional seconds in the lower 32
  // bits.
  art::Timestamp tstamp = (ts.tv_sec << 32) | ts.tv_nsec;

  ////////////////////////////////////
  // Assemble new principals as required.
  art::SubRunID newID(up.getRunNumber(), up.getSubrunNumber());
  if (inR == nullptr || fCurrentSubRunID.runID() != newID.runID()) { // New Run fragment
    outR = fSourceHelper.makeRunPrincipal(up.getRunNumber(), tstamp);

    // get the base form of the geometry file for the current detector
    //\todo at some point we should query a database to get this, especially
    //\todo when we have instances of only part of a detector working
    std::string detFileBase = getDetectorGDML(up.getDetId());
    std::unique_ptr<sumdata::RunData> rundata
      (new sumdata::RunData(novadaq::cnv::DetId(up.getDetId()),
                            detFileBase,
                            geo::GeometryBase::ExtractGDML(detFileBase+".gdml", false)));
    art::put_product_in_principal(std::move(rundata),
                                  *outR,
                                  fSourceName); // Module label
  }
  if (inSR == nullptr || fCurrentSubRunID != newID) { // New SubRun fragment
    outSR = fSourceHelper.makeSubRunPrincipal(up.getRunNumber(),
                                              up.getSubrunNumber(),
                                              tstamp);
    fCurrentSubRunID = newID;
  }
  outE = fSourceHelper.makeEventPrincipal(up.getRunNumber(),
                                          up.getSubrunNumber(),
                                          up.getEventNumber(),
                                          tstamp);

  ////////////////////////////////////
  // Add the event products to the event:

  // Digitized data:
  art::put_product_in_principal(std::move(digits), *outE, fSourceName);

  // Trigger data:
  std::unique_ptr<std::vector<rawdata::RawTrigger> > rtcol(new std::vector<rawdata::RawTrigger>);
  rtcol->push_back(raw_trigger); // Read one, product is a vector.
  art::put_product_in_principal(std::move(rtcol),
                                *outE,
                                fSourceName);

  // RawSumDropMB data:
  std::unique_ptr<std::vector<rawdata::RawSumDropMB> > rtcol_MB(new std::vector<rawdata::RawSumDropMB>);
  rtcol_MB->push_back(raw_sumDropMB); // Read one, product is a vector.
  art::put_product_in_principal(std::move(rtcol_MB),
                                *outE,
                                fSourceName);

  // RawSumDCM data:
  std::unique_ptr<std::vector<rawdata::RawSumDCM> > rtcol_DCM(new std::vector<rawdata::RawSumDCM>);
  rtcol_DCM->push_back(raw_sumDCM); // Read one, product is a vector.
  art::put_product_in_principal(std::move(rtcol_DCM),
                                *outE,
                                fSourceName);

  // DAQ header:
  std::unique_ptr<rawdata::DAQHeader > daqcol(new rawdata::DAQHeader(daq_header));
  art::put_product_in_principal(std::move(daqcol),
                                *outE,
                                fSourceName);

  /// Put FlatDAQData object
  if(fDoFillFlatDAQData) {
    std::unique_ptr<std::vector<rawdata::FlatDAQData> > flatcol(new std::vector<rawdata::FlatDAQData>);
    flatcol->push_back(flat_daq_data); // Read one, product is a vector.
    art::put_product_in_principal(std::move(flatcol),
                                  *outE,
                                  fSourceName);
  }

  ////////////////////////////////////
  // Beamline data products:
  rawdata::RawBeamlineConfig bl_config;
  std::vector<rawdata::RawBeamlineTrigger> bl_trigger;
  std::vector<rawdata::RawBeamlineDigit> bl_tof;
  std::vector<rawdata::RawBeamlineWC> bl_wc;
  std::vector<rawdata::RawBeamlineDigit> bl_cherenkov;
  std::vector<rawdata::RawBeamlineDigit> bl_muonstack;
  std::vector<rawdata::RawBeamlineDigit> bl_paddledigit;
  std::vector<rawdata::RawBeamlineDigit> bl_wcdigit;
  std::vector<rawdata::RawBeamlineDigit> bl_otherdigit;

  if (beamlineEvent) {
    bl_config = beamlineEvent->GetConfig();
    bl_trigger = beamlineEvent->GetTrigger();
    bl_tof = beamlineEvent->GetToF();
    bl_wc = beamlineEvent->GetWC();
    bl_cherenkov = beamlineEvent->GetCherenkov();
    bl_muonstack = beamlineEvent->GetMuonStack();
    delete beamlineEvent;
  }

  art::put_product_in_principal
    (std::make_unique<rawdata::RawBeamlineConfig>(bl_config), *outE, fSourceName, fConfigName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineTrigger> >(bl_trigger), *outE, fSourceName, fTriggerName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(bl_tof), *outE, fSourceName, fToFName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineWC> >(bl_wc), *outE, fSourceName, fWCName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(bl_cherenkov), *outE, fSourceName, fCherenkovName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(bl_muonstack), *outE, fSourceName, fMuonStackName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(bl_paddledigit), *outE, fSourceName, fPaddleDigitName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(bl_wcdigit), *outE, fSourceName, fWCDigitName);
  art::put_product_in_principal
    (std::make_unique<std::vector<rawdata::RawBeamlineDigit> >(bl_otherdigit), *outE, fSourceName, fOtherDigitName);


  return true;
}