daq2raw::TestBeamRawInputDriver Class Reference

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

Inheritance diagram for daq2raw::TestBeamRawInputDriver:

Public Member Functions
	TestBeamRawInputDriver (fhicl::ParameterSet const &pset, art::ProductRegistryHelper &help, art::SourceHelper const &pm)
void	closeCurrentFile ()
	Close currently-open file. More...
void	readFile (std::string const &name, art::FileBlock *&fb)
bool	readNext (art::RunPrincipal *const &inR, art::SubRunPrincipal *const &inSR, art::RunPrincipal *&outR, art::SubRunPrincipal *&outSR, art::EventPrincipal *&outE)
void	reconfigure (const fhicl::ParameterSet &pset)

Protected Member Functions
std::string	getDetectorGDML (const int detid) const

Private Member Functions
void	readBeamline ()
	read in the beamline files corresponding to the time period of this input file 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...
BeamlineEvent *	loadBeamlineEvent (unsigned long long tduTime)
	find and load the beamline event which corresponds to a specific TDU timestamp 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::unique_ptr< daq2raw::BeamlineUnpack >	fBeamlineUnpack
	Algorithm to handle unpacking of beamline data. More...
std::unique_ptr< BeamlineEvents >	fBeamlineEvents
	Container to hold all beamline events before matching with detector data. More...
std::map< unsigned long long, BeamlineTriggerIndex >	fBeamlineIndex
	Container to index beamline file, spill, trigger and TDU information. More...
art::SourceHelper const &	fSourceHelper
	Class to help with {Run, SubRun, Event}Principal construction. More...
std::string	fCurrentFilename
	Hang on to the current filename. More...
art::SubRunID	fCurrentSubRunID
	Keep track of the current subRun details. More...
rawfileparser::RawFileParser	fParser
	Online raw file parsing utility. More...
size_t	fMaxEventSize
	Will not try to read an event bigger than this. More...
bool	fFilterCorruptedNanoslices
	Filter the corrupted nanaslices in the unpacking? More...
bool	fDoFillFlatDAQData
	Do we need to fill FlatDAQData object? More...
bool	fFilterBeamlineEvents
	Filter bad beamline events. More...

Detailed Description

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

Definition at line 117 of file TestBeamRawInputDriver.h.

Constructor & Destructor Documentation

daq2raw::TestBeamRawInputDriver::TestBeamRawInputDriver	(	fhicl::ParameterSet const &	pset,
		art::ProductRegistryHelper &	helper,
		art::SourceHelper const &	pm
	)

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.

Definition at line 51 of file TestBeamRawInputDriver.cxx.

References fCherenkovName, fConfigName, fDoFillFlatDAQData, fMuonStackName, fOtherDigitName, fPaddleDigitName, fParser, fSourceName, fToFName, fTriggerName, fWCDigitName, fWCName, art::InEvent, art::InRun, readBeamline(), reconfigure(), art::ProductRegistryHelper::reconstitutes(), and rawfileparser::RawFileParser::setDebug().

                                                                                   :
  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();

}

Member Function Documentation

void daq2raw::TestBeamRawInputDriver::closeCurrentFile

(

)

Close currently-open file.

Definition at line 119 of file TestBeamRawInputDriver.cxx.

References rawfileparser::RawFileParser::close(), and fParser.

                                                     {
  fParser.close();
}

std::string daq2raw::NOvAInputDriverBase::getDetectorGDML ( const int  detid ) const

protectedinherited

Definition at line 22 of file NOvAInputDriverBase.cxx.

References daq2raw::NOvAInputDriverBase::fGDMLBase, novadaq::cnv::kFARDET, novadaq::cnv::kNDOS, novadaq::cnv::kNEARDET, and novadaq::cnv::kTESTBEAM.

Referenced by daq2raw::DAQHit2Raw::beginRun(), daq2raw::NOvARawInputDriver::readNext(), daq2raw::NOvASocketInputDriver::readNext(), and readNext().

                                                                     {
    
    // get the base form of the geometry file for the current detector
    if(!fGDMLBase.empty()) return fGDMLBase;

    //\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("");
    if     (detid == novadaq::cnv::kNDOS)
      detFileBase = "ndos-2x3-4block_nomc-xtru-vacuum";
    else if     (detid == novadaq::cnv::kNEARDET)
      detFileBase = "neardet-3x3-8block-xtru-vacuum-stagger";
    else if(detid == novadaq::cnv::kFARDET)
      detFileBase = "fardet-12x12-28block-xtru-vacuum-stagger-pivoter";
    else if(detid == novadaq::cnv::kTESTBEAM)
      detFileBase = "testbeam-2x2-2block-xtru-vacuum-stagger";

    return detFileBase;
  }

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

private

get the lariat fragment from the artdaq fragments

Get the lariat fragment from the spill wrapper.

Definition at line 239 of file TestBeamRawInputDriver.cxx.

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

Referenced by loadSpillFragments().

                                                                                            {

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

}

daq2raw::BeamlineEvent * daq2raw::TestBeamRawInputDriver::loadBeamlineEvent ( unsigned long long  tduTime )

private

find and load the beamline event which corresponds to a specific TDU timestamp

Find and load the beamline event which corresponds to a specific TDU timestamp

Definition at line 322 of file TestBeamRawInputDriver.cxx.

References allTimeWatchdog::endl, art::rootNames::eventTreeName(), fBeamlineIndex, fBeamlineUnpack, daq2raw::BeamlineFileIndex::File, daq2raw::BeamlineEvents::FindEvent(), fInputSpillTag, fInputTDUTag, inFile, loadSpillFragments(), loadTDUFragments(), art::EventAuxiliary::run(), daq2raw::BeamlineSpillIndex::Spill, and daq2raw::BeamlineTriggerIndex::Trigger.

Referenced by readNext().

                                                                                                 {

  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;

}

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

private

load the artdaq spill fragments from the input file

Load the artdaq fragments.

Definition at line 264 of file TestBeamRawInputDriver.cxx.

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

Referenced by loadBeamlineEvent(), and readBeamline().

                                                                                        {

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

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

private

load the artdaq TDU fragments from the input file

Load the TDU artdaq fragment.

Definition at line 290 of file TestBeamRawInputDriver.cxx.

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

Referenced by loadBeamlineEvent(), and readBeamline().

                                                                                                {

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

}

void daq2raw::TestBeamRawInputDriver::readBeamline ( )

private

read in the beamline files corresponding to the time period of this input file

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.

Definition at line 127 of file TestBeamRawInputDriver.cxx.

References dir, e, allTimeWatchdog::endl, art::rootNames::eventTreeName(), fBeamlineEvents, fBeamlineIndex, fBeamlineUnpack, file, ConvertToSnowGlobesInput::file_name, compareCafs::files, daq2raw::BeamlineEvents::FindEvent(), fInputSpillTag, fInputTDUTag, daq2raw::BeamlineEvent::GetTDUTime(), inFile, loadSpillFragments(), loadTDUFragments(), make_pair(), next(), daq2raw::BeamlineEvents::NumEvents(), and g4zmq::pwd().

Referenced by TestBeamRawInputDriver().

                                                 {

  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;

}

void daq2raw::TestBeamRawInputDriver::readFile	(	std::string const &	name,
		art::FileBlock *&	fb
	)

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 397 of file TestBeamRawInputDriver.cxx.

References errno, fCurrentFilename, fd, art::errors::FileOpenError, fParser, and rawfileparser::RawFileParser::open().

                                                                  {

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

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

Define data structures, which will be filled by OnlineUnpack::ProcessRawEvent

Fill the data structures for this event.

Put FlatDAQData object

Definition at line 419 of file TestBeamRawInputDriver.cxx.

References novadaq::timeutils::convertNovaTimeToUnixTime(), geo::GeometryBase::ExtractGDML(), fCherenkovName, fConfigName, fCurrentFilename, fCurrentSubRunID, fDoFillFlatDAQData, daq2raw::OnlineUnpack::fFilterCorruptedNanoslices, fFilterCorruptedNanoslices, fMuonStackName, fOtherDigitName, fPaddleDigitName, fParser, fSourceHelper, fSourceName, fToFName, fTriggerName, rawdata::RawTrigger::fTriggerTimingMarker_TimeStart, fWCDigitName, fWCName, daq2raw::BeamlineEvent::GetCherenkov(), daq2raw::BeamlineEvent::GetConfig(), daq2raw::NOvAInputDriverBase::getDetectorGDML(), daq2raw::OnlineUnpack::getDetId(), daq2raw::OnlineUnpack::getEventNumber(), daq2raw::BeamlineEvent::GetMuonStack(), daq2raw::OnlineUnpack::getRunNumber(), daq2raw::OnlineUnpack::getSubrunNumber(), daq2raw::BeamlineEvent::GetToF(), daq2raw::BeamlineEvent::GetTrigger(), daq2raw::BeamlineEvent::GetWC(), loadBeamlineEvent(), art::SourceHelper::makeEventPrincipal(), art::SourceHelper::makeRunPrincipal(), art::SourceHelper::makeSubRunPrincipal(), daq2raw::OnlineUnpack::ProcessRawEvent(), art::put_product_in_principal(), art::SubRunID::runID(), and msf_helper::timespec.

                                                                         {

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

void daq2raw::TestBeamRawInputDriver::reconfigure

(

const fhicl::ParameterSet &

pset

)

Definition at line 90 of file TestBeamRawInputDriver.cxx.

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

Referenced by TestBeamRawInputDriver().

                                                                             {

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

}

Member Data Documentation

std::unique_ptr<BeamlineEvents> daq2raw::TestBeamRawInputDriver::fBeamlineEvents

private

Container to hold all beamline events before matching with detector data.

Definition at line 171 of file TestBeamRawInputDriver.h.

Referenced by readBeamline().

std::map<unsigned long long, BeamlineTriggerIndex> daq2raw::TestBeamRawInputDriver::fBeamlineIndex

private

Container to index beamline file, spill, trigger and TDU information.

Definition at line 173 of file TestBeamRawInputDriver.h.

Referenced by loadBeamlineEvent(), and readBeamline().

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

private

Algorithm to handle unpacking of beamline data.

Definition at line 170 of file TestBeamRawInputDriver.h.

Referenced by loadBeamlineEvent(), and readBeamline().

std::string daq2raw::TestBeamRawInputDriver::fCherenkovName

private

Definition at line 162 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fConfigName

private

Definition at line 158 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fCurrentFilename

private

Hang on to the current filename.

Definition at line 176 of file TestBeamRawInputDriver.h.

Referenced by readFile(), and readNext().

art::SubRunID daq2raw::TestBeamRawInputDriver::fCurrentSubRunID

private

Keep track of the current subRun details.

Definition at line 177 of file TestBeamRawInputDriver.h.

Referenced by readNext().

bool daq2raw::TestBeamRawInputDriver::fDoFillFlatDAQData

private

Do we need to fill FlatDAQData object?

Definition at line 181 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

bool daq2raw::TestBeamRawInputDriver::fFilterBeamlineEvents

private

Filter bad beamline events.

Definition at line 182 of file TestBeamRawInputDriver.h.

Referenced by reconfigure().

bool daq2raw::TestBeamRawInputDriver::fFilterCorruptedNanoslices

private

Filter the corrupted nanaslices in the unpacking?

Definition at line 180 of file TestBeamRawInputDriver.h.

Referenced by readNext(), and reconfigure().

art::InputTag daq2raw::TestBeamRawInputDriver::fInputSpillTag

private

Definition at line 156 of file TestBeamRawInputDriver.h.

Referenced by loadBeamlineEvent(), readBeamline(), and reconfigure().

art::InputTag daq2raw::TestBeamRawInputDriver::fInputTDUTag

private

Definition at line 157 of file TestBeamRawInputDriver.h.

Referenced by loadBeamlineEvent(), readBeamline(), and reconfigure().

size_t daq2raw::TestBeamRawInputDriver::fMaxEventSize

private

Will not try to read an event bigger than this.

Definition at line 179 of file TestBeamRawInputDriver.h.

Referenced by reconfigure().

std::string daq2raw::TestBeamRawInputDriver::fMuonStackName

private

Definition at line 163 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fOtherDigitName

private

Definition at line 166 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fPaddleDigitName

private

Definition at line 164 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

rawfileparser::RawFileParser daq2raw::TestBeamRawInputDriver::fParser

private

Online raw file parsing utility.

Definition at line 178 of file TestBeamRawInputDriver.h.

Referenced by closeCurrentFile(), readFile(), readNext(), and TestBeamRawInputDriver().

art::SourceHelper const& daq2raw::TestBeamRawInputDriver::fSourceHelper

private

Class to help with {Run, SubRun, Event}Principal construction.

Definition at line 175 of file TestBeamRawInputDriver.h.

Referenced by readNext().

std::string daq2raw::TestBeamRawInputDriver::fSourceName

private

Definition at line 168 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fToFName

private

Definition at line 160 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fTriggerName

private

Definition at line 159 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fWCDigitName

private

Definition at line 165 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

std::string daq2raw::TestBeamRawInputDriver::fWCName

private

Definition at line 161 of file TestBeamRawInputDriver.h.

Referenced by readNext(), reconfigure(), and TestBeamRawInputDriver().

---

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

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