BeamlineRawInputDriver.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    BeamlineRawInputDriver.h
/// \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
////////////////////////////////////////////////////////////////////////////

#ifndef DAQ2RAWDIGIT_BEAMLINERAWINPUTDRIVER_H
#define DAQ2RAWDIGIT_BEAMLINERAWINPUTDRIVER_H

// framework
#include "art/Framework/Core/FileBlock.h"
#include "art/Framework/Core/ProductRegistryHelper.h"
#include "art/Framework/IO/Sources/SourceHelper.h"
#include "art/Framework/IO/Sources/put_product_in_principal.h"
#include "art/Framework/Principal/RunPrincipal.h"
#include "art/Framework/Principal/SubRunPrincipal.h"
#include "art/Framework/Principal/EventPrincipal.h"
#include "canvas/Persistency/Provenance/rootNames.h"
#include "canvas/Persistency/Provenance/SubRunID.h"
#include "canvas/Utilities/Exception.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// artdaq
#include "artdaq-core/Data/Fragment.hh"

// online
#include "LArIATFragments/LariatFragment.h"

// nova
#include "RawData/RawBeamline.h"
#include "DAQ2RawDigit/testbeam/BeamlineUnpack.h"

// stl
#include <string>
#include <libgen.h>

// root
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"

// -----------------------------------------------------------------------
namespace daq2raw {
  class BeamlineUnpack;
  class SpillWrapper;
  class BeamlineEvent;
}

// -----------------------------------------------------------------------
namespace rawdata {
  class BeamlineRawDigit;
  class BeamlineRawTrigger;
  class BeamlineRawWC;
}

// -----------------------------------------------------------------------
namespace daq2raw {

  // -----------------------------------------------------------------------
  /// Class to fill the constraints on a template argument to
  /// the class, art::Source
  class BeamlineRawInputDriver {

  public:

    // Required constructor
    BeamlineRawInputDriver(const fhicl::ParameterSet& pset,
                           art::ProductRegistryHelper& help,
                           const art::SourceHelper& pm);
    virtual ~BeamlineRawInputDriver() {};

    // Required by art::Source
    void closeCurrentFile();
    bool readFile(const std::string& filename,
                  art::FileBlock*& fileblock);
    bool readNext(art::RunPrincipal* const& inR,
                  art::SubRunPrincipal* const& inSR,
                  art::RunPrincipal*& outR,
                  art::SubRunPrincipal*& outSR,
                  art::EventPrincipal*& outE);

    // art
    void reconfigure(const fhicl::ParameterSet& pset);

  private:

    /// start a new run
    void commenceRun(art::RunPrincipal*& outRun);

    /// start a new subrun
    void commenceSubRun(art::SubRunPrincipal*& outSubRun);

    /// load the artdaq spill fragments from the input file
    LariatFragment* loadSpillFragments(TBranch* fragBranch, unsigned int index);

    /// load the artdaq TDU fragments from the input file
    std::vector<TDUFragment*> loadTDUFragments(TBranch* tduBranch, unsigned int index);

    /// get the lariat fragment from the artdaq fragments
    LariatFragment* getSpillFrag(const SpillWrapper* spillWrapper);

    /// make a new spill
    bool makeSpill(art::RunPrincipal* const& inRun,
                   art::SubRunPrincipal* const& inSubRun,
                   art::RunPrincipal*& outRun,
                   art::SubRunPrincipal*& outSubRun);

    /// make a new event and place the digits within
    void makeEvent(art::EventPrincipal*& outEvent);

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

    // file information
    std::string fCurrentFilename;
    std::unique_ptr<TFile> fCurrentFile;
    TBranch* fSpillBranch;
    TBranch* fTDUBranch;
    TBranch* fEventAuxBranch;
    unsigned int fNumSpillsInFile;
    int fSpillIndex;

    // running parameters
    bool fFilterEvents;
    const art::SourceHelper& fSourceHelper;
    BeamlineEvents* fBeamlineEvents;

    // run, subrun and event numbers
    art::RunNumber_t fRunNumber;
    art::SubRunNumber_t fSubRunNumber;

    // timestamp for event
    std::uint64_t fTimestamp;
  
    // algorithms
    std::unique_ptr<daq2raw::BeamlineUnpack> fBeamlineUnpack;

  }; // BeamlineRawInputDriver

} // namespace

#endif /* DAQ2RAWDIGIT_BEAMLINERAWINPUTDRIVER_H */