DAQHit2Raw_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief  A module to produce rawdata::RawDigits from NOvADDT DAQHits
/// \author Gavin S. Davies - gsdavies@iastate.edu
/// \date   March 14 2013
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/FileBlock.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/Handle.h"

#include "CMap/service/CMapService.h"
#include "DAQChannelMap/DAQChannelMapConstants.h"
#include "DAQ2RawDigit/NOvAInputDriverBase.h"
#include "DDTBaseDataProducts/HitList.h"
#include "NovaDAQConventions/DAQConventions.h"
#include "RawData/DAQHeader.h"
#include "RawData/RawDigit.h"
#include "RawData/RawTrigger.h"
#include "SummaryData/RunData.h"

#include <boost/algorithm/string.hpp>

#include <string>
#include <vector>

#ifdef DARWINBUILD
 #include <libgen.h>
#endif

namespace daq2raw {
  class DAQHit2Raw;
}

// using unsigned long long rather than uint64_t to ensure consistent behavior on OSX and LINUX

class daq2raw::DAQHit2Raw : public daq2raw::NOvAInputDriverBase, public art::EDProducer {
public:
  explicit DAQHit2Raw(fhicl::ParameterSet const & p);
  virtual ~DAQHit2Raw();
  
  void produce(art::Event & e) override;

  void beginRun(art::Run &run);

  void respondToOpenInputFile(const art::FileBlock& fb);
  
private:
  std::string fDAQHitInput;
  bool        fAddRunInfo;

  std::string fileName;
  int         fDetId;
  
protected:

  int getDetIdFromFilename(const char* filename);

  void FillRawDigits(const novaddt::HitList & hitlist,
                     std::unique_ptr<std::vector<rawdata::RawDigit> >& rawlist
                     );

  void PopulateRawTrig(rawdata::RawTrigger & rawtrig,
                       art::Event const & evt
                       );

};

//-------------------------------------------------------------------------
daq2raw::DAQHit2Raw::DAQHit2Raw(fhicl::ParameterSet const & p)
  : fDAQHitInput(p.get< std::string >("DAQHitInput")),
    fAddRunInfo(p.get<  bool        >("AddRunInfo"))
{
  produces<rawdata::DAQHeader,                art::InEvent>();
  produces< std::vector<rawdata::RawDigit>,   art::InEvent>();
  produces< std::vector<rawdata::RawTrigger>, art::InEvent>();
  if (fAddRunInfo)
    produces<sumdata::RunData,                  art::InRun>();
}

//-------------------------------------------------------------------------
daq2raw::DAQHit2Raw::~DAQHit2Raw() 
{
}

//-------------------------------------------------------------------------
void daq2raw::DAQHit2Raw::respondToOpenInputFile(const art::FileBlock& fb)
{
  fileName = basename((char*)fb.fileName().c_str());
}

//-------------------------------------------------------------------------
void daq2raw::DAQHit2Raw::beginRun(art::Run& run)
{
  if(fAddRunInfo)
  {
    int detector = getDetIdFromFilename(fileName.c_str());
    std::string detFileBase = daq2raw::NOvAInputDriverBase::getDetectorGDML(detector);
    std::unique_ptr<sumdata::RunData> rundata(new sumdata::RunData(novadaq::cnv::DetId(detector), detFileBase));
    run.put(std::move(rundata));
  }
}

//-------------------------------------------------------------------------
void daq2raw::DAQHit2Raw::produce(art::Event & e)
{
  // get the vector of DAQHits (HitList)
  art::Handle<novaddt::HitList> hlcol;
  e.getByLabel(fDAQHitInput,hlcol);

  novaddt::HitList hitlist;
  for(unsigned int i = 0; i < hlcol->size(); ++i){
    hitlist.push_back((*hlcol)[i]);
  }
  
  //////////////////////////////////////////////
  // Define data structures that we want to fill
  
  // Digitized data
  std::unique_ptr<std::vector<rawdata::RawDigit> > digits(new std::vector<rawdata::RawDigit>);
  // Trigger data:
  std::unique_ptr<std::vector<rawdata::RawTrigger> > rtcol(new std::vector<rawdata::RawTrigger>);
  // DAQ header:
  //  std::unique_ptr<rawdata::DAQHeader > daqcol(new rawdata::DAQHeader(daq_header)); 
  
  
  // Write digitized data into the event
  rawdata::RawDigit rawdig;
  FillRawDigits(hitlist, digits);

  e.put(std::move(digits)); // Put RawDigits into event
  
  // Write the raw trigger into the event
  rawdata::RawTrigger rawtrig;
  PopulateRawTrig(rawtrig, e);
  rtcol->push_back(rawtrig);
  
  e.put(std::move(rtcol)); // Put RawTrigger into event
  
  //Write the DAQHeader - for now don't bother
  //e.put(std::move(daqcol), "daq"); // Module label
  
}

//---------------------------------------------------------------------------
int daq2raw::DAQHit2Raw::getDetIdFromFilename(const char* filename)
{
  fDetId = novadaq::cnv::kUNKNOWN_DET;
  
  if     (boost::find_first(filename, "ndos") || boost::find_first(filename, "NDOS")){
    fDetId = novadaq::cnv::kNDOS;
  }
  else if(boost::find_first(filename, "fardet") || boost::find_first(filename, "FarDet")){
    fDetId = novadaq::cnv::kFARDET;
  }
  else if(boost::find_first(filename, "neardet") || boost::find_first(filename, "NearDet")){
    fDetId = novadaq::cnv::kNEARDET;
  }
  return fDetId;
}

//---------------------------------------------------------------------------
void daq2raw::DAQHit2Raw::PopulateRawTrig(rawdata::RawTrigger & rawtrig,
                                          art::Event const & evt
                                          )
{
  // Say this is MC:
  rawtrig.fTriggerMask_MCBit = 1;

  // Units of DDT data are 5ms = 5*10^6ns
  // This will need to be addressed in EventDisplay
  // rawtrig.fTriggerRange_TriggerLength = fClocktick*fNumClockticksInSpill/5.e6;
  // Hard-code for testing purposes
  rawtrig.fTriggerRange_TriggerLength = 62.5*8000/5.e6;

  // Set the trigger time such that it increments by 0.1 seconds
  // every event (to mimic calibration triggers, though not beam
  // triggers).  Also, add one "day" per subrun and one "year" per
  // run, just to keep the times in different files different.
  // I'm not making these FHICL parameters because we will want
  // to do this properly (e.g., have each MC file representing a
  // specific timestamp drawn to match real data).
  //
  // The TDC ticks run at 64 MHz

  static const unsigned long long ticksPerYear  = (unsigned long long)(64000000) * 31556926;
  static const unsigned long long ticksPerDay   = (unsigned long long)(64000000) * 86400;
  static const unsigned long long ticksPerEvent = (unsigned long long)(64000000) / 10; // 10 Hz trigger

  rawtrig.fTriggerTimingMarker_TimeStart =
    evt.run() * ticksPerYear +
    evt.subRun() * ticksPerDay +
    evt.event() * ticksPerEvent;

}

//------------------------------------------------------------------------
void daq2raw::DAQHit2Raw::FillRawDigits(const novaddt::HitList & hitlist,
                                        std::unique_ptr<std::vector<rawdata::RawDigit> >& rawlist
                                        )
{
  art::ServiceHandle<cmap::CMap> cmap;

  // Loop over all hits in the HitList
  const int nHits = hitlist.size();
  for(int idx = 0; idx< nHits; idx++){
    // instance of each DAQHit
    const novaddt::DAQHit dhit = hitlist[idx];

    const daqchannelmap::lchan lchan = cmap->Map()->encodeLChan(novadaq::cnv::DetId(fDetId), 
                                                         dhit.Plane().val, 
                                                         dhit.Cell().val);
    
    // instance of RawDigit
    rawdata::RawDigit rawdig;

    // Fill RawDigits
    rawdig.SetChannel(lchan);
    rawdig.SetTDC(dhit.TDC().val);
    rawdig.SetADC(0,dhit.ADC().val);
    rawdig.SetMC();
    
    rawlist->push_back(rawdig);
  }

}

DEFINE_ART_MODULE(daq2raw::DAQHit2Raw)