BeamlineUnpack.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    BeamlineUnpack.h
/// \brief   Methods to interface with the DAQ-formatted output file
///          for the beamline components of the test beam experiment.
/// \author  Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
/// \date    November 2018
////////////////////////////////////////////////////////////////////////////

#ifndef DAQ2RAW_BEAMLINEUNPACK_H
#define DAQ2RAW_BEAMLINEUNPACK_H

// framework
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "artdaq-core/Data/ContainerFragment.hh"
#include "artdaq-core/Data/Fragment.hh"
#include "cetlib_except/exception.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include <IFDH_service.h>

// online
#include "LArIATFragments/LariatFragment.h"
#include "LArIATFragments/TriggerFragment.h"
#include "LArIATFragments/V1742Fragment.h"
#include "LArIATFragments/TDCFragment.h"
#include "LArIATFragments/TDUFragment.h"

// nova
#include "RawData/RawBeamline.h"
#include "BeamlineUtils/BeamlineChannelMap.h"
#include "BeamlineUtils/BeamlineGeometry.h"
#include "BeamlineUtils/BeamlineMagneticField.h"

// root
#include "TBranch.h"

// stl
#include <algorithm>
#include <iostream>
#include <vector>
#include <tuple>
#include <string>
#include <ctype.h>

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

  // -----------------------------------------------------------------------
  /// Retrieves branch name where object resides, using art convention
  template <typename PROD> std::string getBranchName(const art::InputTag& tag) {
    std::ostringstream oss;
    oss << art::TypeID(typeid(PROD)).friendlyClassName()
        << '_'
        << tag.label()
        << '_'
        << tag.instance()
        << '_'
        << tag.process()
        << ".obj";
    return oss.str();
  }

  // -----------------------------------------------------------------------
  artdaq::Fragments* getFragments(TBranch* br, unsigned entry);

  // -----------------------------------------------------------------------
  class SpillWrapper {

  public:

  SpillWrapper(std::size_t nfragments) :
    nfragments_(nfragments),
      nfragments_processed_(0),
      size_(0)
        {}

    void add(const art::Event& evt, const art::InputTag& tag);
    void add(const artdaq::Fragment& frag);

    // Consider having get() throw an exception if ready() != true
    const uint8_t* get() const {return &*buffer_.begin(); } 

    std::size_t size() const {return size_; }

    bool ready() const { return (nfragments_processed_ == nfragments_) ? true : false; }

  private:

    const std::size_t nfragments_;
    std::vector<uint8_t> buffer_;

    std::size_t nfragments_processed_;
    std::size_t size_;

  };

  // -----------------------------------------------------------------------
  class BeamlineEvent {

  public:

    BeamlineEvent(unsigned int eventNum);
    ~BeamlineEvent();

    unsigned int EventNumber() const;

    bool GoodEvent() const;
    void SetBadEvent();
    void SetGoodEvent();

    void AddConfig(rawdata::RawBeamlineConfig config);
    void AddTimestamp(uint64_t timestamp);
    void AddTDUTime(uint64_t tduTime);
    void AddTrigger(std::vector<rawdata::RawBeamlineTrigger> trigger);
    void AddToF(std::vector<rawdata::RawBeamlineDigit> tof);
    void AddWC(std::vector<rawdata::RawBeamlineWC> wc);
    void AddCherenkov(std::vector<rawdata::RawBeamlineDigit> cherenkov);
    void AddMuonStack(std::vector<rawdata::RawBeamlineDigit> muonstack);
    void AddPaddleDigit(std::vector<rawdata::RawBeamlineDigit> paddle);
    void AddWCDigit(std::vector<rawdata::RawBeamlineDigit> mwpc);
    void AddOtherDigit(std::vector<rawdata::RawBeamlineDigit> other);

    rawdata::RawBeamlineConfig GetConfig() const;
    uint64_t GetTimestamp() const;
    uint64_t GetTDUTime() const;
    std::vector<rawdata::RawBeamlineTrigger> GetTrigger() const;
    std::vector<rawdata::RawBeamlineDigit> GetToF() const;
    std::vector<rawdata::RawBeamlineWC> GetWC() const;
    std::vector<rawdata::RawBeamlineDigit> GetCherenkov() const;
    std::vector<rawdata::RawBeamlineDigit> GetMuonStack() const;
    std::vector<rawdata::RawBeamlineDigit> GetPaddleDigit() const;
    std::vector<rawdata::RawBeamlineDigit> GetWCDigit() const;
    std::vector<rawdata::RawBeamlineDigit> GetOtherDigit() const;

  private:

    unsigned int fEventNumber;

    bool fGoodEvent;

    rawdata::RawBeamlineConfig fConfig;
    uint64_t fTimestamp;
    uint64_t fTDUTime;
    std::vector<rawdata::RawBeamlineTrigger> fTrigger;
    std::vector<rawdata::RawBeamlineDigit> fToF;
    std::vector<rawdata::RawBeamlineWC> fWC;
    std::vector<rawdata::RawBeamlineDigit> fCherenkov;
    std::vector<rawdata::RawBeamlineDigit> fMuonStack;
    std::vector<rawdata::RawBeamlineDigit> fPaddleDigit;
    std::vector<rawdata::RawBeamlineDigit> fWCDigit;
    std::vector<rawdata::RawBeamlineDigit> fOtherDigit;

  };

  // -----------------------------------------------------------------------
  class BeamlineEvents {

  public:

    BeamlineEvents();
    BeamlineEvents(unsigned int numEvents);
    ~BeamlineEvents();

    void AddEvent(BeamlineEvent* event);
    void AddEvents(std::vector<BeamlineEvent*> events);
    void FilterGoodEvents();
    BeamlineEvent* FindEvent(unsigned int event);
    BeamlineEvent* FindEvent(unsigned long long nova_timestamp);
    unsigned int NumEvents() const;
    std::vector<BeamlineEvent*> GetEvents() const;
    BeamlineEvent* GetNextEvent();
    bool IsNextEvent() const;

  private:

    unsigned int fEventIt;
    std::vector<BeamlineEvent*> fEvents;
    std::map<unsigned long long, BeamlineEvent*> fEvents_TDUIndex;

  };

  // -----------------------------------------------------------------------
  class BeamlineUnpack {

  public:

    BeamlineUnpack(const fhicl::ParameterSet& pset);
    ~BeamlineUnpack();

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

    // methods
    void EndSpill();
    void Unpack(const LariatFragment* spillFrag,
                const std::vector<TDUFragment*> tduFrag,
                unsigned int run = 0,
                std::string filename = "");

    // interface
    BeamlineEvents* GetBeamlineEvents() const;

  private:

    // services
    art::ServiceHandle<beamlineutil::BeamlineChannelMap> fChannelMap;
    art::ServiceHandle<beamlinegeo::BeamlineGeometry> fGeometry;
    art::ServiceHandle<beamlineutil::BeamlineMagneticField> fMagneticField;

    // configuration
    std::string fTriggerSource;
    bool fUnpackTrigger;
    bool fUnpackDigitizer;
    bool fUnpackWireChamber;
    bool fUnpackTDU;

    unsigned int fChannelsPerTDC;
    unsigned int fTDCsPerWC;
    unsigned int fTriggerLatency;
    int fTDUOffset;

    // methods
    std::vector<TriggerPattern::TriggerPattern_t>
      CleanTriggers(const TriggerFragment& triggerFrag);
    std::vector<TDUFragment*>
      CleanTDU(const std::vector<TDUFragment*>& tduFrags);
    void UnpackConfig(unsigned int run);
    void UnpackTrigger(const std::vector<TriggerPattern::TriggerPattern_t>& beamlineTriggers,
                       const std::vector<TDUFragment*>& beamlineTDUs,
                       std::string filename = "");
    void UnpackDigits(const std::vector<V1742Fragment>& frags);
    void UnpackWC(const TDCFragment& frag);

    // members
    BeamlineEvents* fBeamlineEvents;

  };

} // namespace

#endif