NovaDDTRawInputDriver.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file  NovaDDTRawInputDriver.cxx
/// \brief Source to convert raw binary files to DDT root files
///
/// \author janzirn@fnal.gov
////////////////////////////////////////////////////////////////////////

//NOvA includes
#include "DDTCore/NovaDDTRawInputDriver.h"
#include "DDTCore/OnlineUnpack.h"
#include "DDTBaseDataProducts/DAQHit.h"
#include "DDTBaseDataProducts/EventHeader.h"

#include "NovaTimingUtilities/TimingUtilities.h"
#include "NovaDAQConventions/DAQConventions.h"

// Framework includes
#include "art/Framework/IO/Sources/put_product_in_principal.h"
#include "canvas/Utilities/Exception.h"
#include "art/Framework/Core/ProductRegistryHelper.h"
#include "art/Framework/Principal/EventPrincipal.h"
#include "art/Framework/Principal/RunPrincipal.h"
#include "art/Framework/Principal/SubRunPrincipal.h"
#include "art/Framework/Core/FileBlock.h"
#include "fhiclcpp/ParameterSet.h"


namespace novaddt{

  //------------------------------------------------------------------------------
  // Required constructor.
  NovaDDTRawInputDriver::NovaDDTRawInputDriver(fhicl::ParameterSet const &pset,
                                         art::ProductRegistryHelper &helper,
                                         art::SourceHelper const &pm) 
    : fSourceHelper(pm)
    , fCurrentFilename()
    , fCurrentSubRunID(-1, -1) ///< Has to be distinguished from the ones that are acually used
    , fParser()
    , fMaxEventSize(pset.get<size_t>("maxEventSizeK", 65536) * 1024)
    , fFilterCorruptedNanoslices(pset.get<bool>("FilterCorruptedNanoslices"))
  {
    // Declare products that *may* be in the event (or run, or subRun)
    // here. Note the use of "reconstitutes" vs "produces": this is what
    // allows us to specify module label, process name and (optionally)
    // instance label for each product.
    helper.reconstitutes<novaddt::EventHeader, art::InEvent>("DDTdaq");
    helper.reconstitutes<std::vector<novaddt::DAQHit>,        art::InEvent>("DDTdaq");
    // Turn off printf messages in the parser.
    fParser.setDebug(false);
  }

  //------------------------------------------------------------------------------
  // Required function: close currently-open file.
  void NovaDDTRawInputDriver::closeCurrentFile() {
    fParser.close(); // Ignore error return
  }

  // Required function: 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 NovaDDTRawInputDriver::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, "NovaDDTRawInput 2015a"),
                            fCurrentFilename);
  }

  // Required function: read and fill Run, SubRun and/or Event as might be
  // appropriate.
  bool NovaDDTRawInputDriver::readNext(art::RunPrincipal* const &inR,
                                    art::SubRunPrincipal* const &inSR,
                                    art::RunPrincipal* &outR,
                                    art::SubRunPrincipal* &outSR,
                                    art::EventPrincipal* &outE)
  {
    ////////////////////////////////////
    // Unpack the data.

    /// Define data structures, which will be filled by OnlineUnpack::ProcessRawEvent
    std::unique_ptr<std::vector<novaddt::DAQHit> > hits(new std::vector<novaddt::DAQHit>);
    novaddt::EventHeader                   evt_header;

    novaddt::OnlineUnpack up(&fCurrentFilename);
    up.fFilterCorruptedNanoslices = fFilterCorruptedNanoslices;

    /// Fill the data structures for this event.
    if (!up.ProcessRawEvent(fParser, hits.get(), &evt_header)) return false;

    // TODO
    // Get the actual timestamp here - use the current time as the
    // default, maybe the default should really be a ridiculous value
    // The below code is from daq2raw digit, DDT never implimented a trigger
    // object, ironic, so we can't read the triggered time
    // Use dummy timestamp, just like the streamer reader.
    /*
    struct timespec ts;

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

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

    art::Timestamp tstamp;

    ////////////////////////////////////
    // Assemble new principals as required.

    art::SubRunID newID(up.getRunNumber(), up.getSubrunNumber());

    if (inR == nullptr || fCurrentSubRunID.runID() != newID.runID()) { // New Run
      outR = fSourceHelper.makeRunPrincipal(up.getRunNumber(), tstamp);

    }

    if (inR == nullptr || fCurrentSubRunID != newID) { // New SubRun
      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(hits), *outE, "DDTdaq");

    // MilliBlock header:
    std::unique_ptr<novaddt::EventHeader > mbhead(new novaddt::EventHeader(evt_header));
    art::put_product_in_principal(std::move(mbhead), *outE, "DDTdaq");

    return true;
  }

}// end of namespace