NovaDDTHitProducer_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       NovaDDTHitProducer
// Module Type: producer
// File:        NovaDDTHitProducer_module.cc
//
// Generated at Tue May  8 11:50:49 2012 by Chris Green using artmod
// from art v1_00_12.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "artdaq-core/Data/Fragment.hh"

#include "DAQDataFormats/RawMicroSlice.h"
#include "DAQDataFormats/RawMilliBlock.h"
#include "DAQDataFormats/RawMilliBlockHeader.h"
#include "DAQDataFormats/RawMilliSlice.h"
#include "DAQDataFormats/RawNanoSlice.h"
#include "DAQChannelMap/DAQChannelMap.h"

#include "DDTBaseDataProducts/DAQHit.h"
#include "DDTBaseDataProducts/EventHeader.h"
#include "DDTCore/WaveformProcessor.h"

using daqdataformats::RawMilliSlice;
using daqdataformats::RawMicroSlice;
using daqdataformats::RawNanoSlice;

class NovaDDTHitProducer;

class NovaDDTHitProducer : public art::EDProducer {
public:
  explicit NovaDDTHitProducer(fhicl::ParameterSet const & p);
  virtual ~NovaDDTHitProducer();

  virtual void produce(art::Event & e);

private:
  size_t populateMilliBlock(void const * image, RawMilliBlock & mb, novaddt::EventHeader* evt_header);
  bool   passes_MCS_filter(daqdataformats::RawNanoSlice* fNano) const;
  art::ServiceHandle<novaddt::WaveformProcessor> wpr;

  std::string const raw_label_;

  bool offline_;
};


NovaDDTHitProducer::NovaDDTHitProducer(fhicl::ParameterSet const & p)
  :
  raw_label_(p.get<std::string>("raw_label"))
  , offline_(p.get<bool>("offline_mode", false))
{
  produces<std::vector<novaddt::DAQHit>>("AllHits");
  produces<novaddt::EventHeader>("DDTdaq");
  // produces<std::vector<novaddt::DAQHit>>("MCSHits");
#ifdef NEED_MILLIBLOCK_IN_EVENT
  produces<RawMilliBlock>();
#endif
}

NovaDDTHitProducer::~NovaDDTHitProducer()
{
}

size_t NovaDDTHitProducer::populateMilliBlock
(void const * image, RawMilliBlock & mb, novaddt::EventHeader* evt_header)
{
  // This code follows the code in Ron R's getMilliBlock, but omits the part
  // where the data is read out of the shared memory.  Instead, the data is
  // assumed to be here in *image.
  size_t total_bytes = 0;
  std::vector<RawMilliSlice>  rms_vec;
  RawMilliSlice         rms_tmp(daqdataformats::rawmillihdr::MILLISLICEHEADER_SIZE);
  mb.set_ovrwrt(false);
  RawMilliBlockHeader const * rmbhp =
    reinterpret_cast<RawMilliBlockHeader const *>(image);
  RawMilliBlockHeader const & rmbh(*rmbhp);
  assert(rmbh.millislice_count > 0);
  rms_vec.reserve(rmbh.millislice_count);
  if (rmbh.flags.overflowCorruption == 1) {
    mb.set_ovrwrt(true);
    return 0;
  }

  void * msdataptr = const_cast<void *>(reinterpret_cast<void const *>(rmbhp + 1));
  uint32_t retrieved_millislice = 0;
  for (; retrieved_millislice < rmbh.millislice_count; ++retrieved_millislice) {
    rms_vec.push_back(rms_tmp);
    msdataptr = rms_vec.at(retrieved_millislice).readData(msdataptr);
    // the readData method figures how much data to copy, puts it
    // into the millislice, and returns the pointer advanced to the end
    // of that data.
    total_bytes += rms_vec.at(retrieved_millislice).sizeofdata() * sizeof(uint32_t);
  }
  assert(retrieved_millislice > 0);
  mb.set(rmbh.seqNum, rmbh.timeStart, rmbh.timeEnd, rmbh.flags.truncated);
  
  // This code will add the EventHeader to the live data stream events as well
  evt_header->totalBytes = total_bytes;
  evt_header->eventNumber = rmbh.seqNum;
  evt_header->timeStart = rmbh.timeStart;
  evt_header->missingData = rmbh.flags.incomplete;
  evt_header->datablockCount = rmbh.millislice_count;

  mb.slices.swap(rms_vec);    // swap vectors to get data into the mb.

  return total_bytes;
} // populateMilliBlock

void NovaDDTHitProducer::produce(art::Event & e)
{
  // If we want to test offline the hits should already exist so we can just return here
  if (offline_) return;
  
  typedef novaddt::DAQHit Hit;
  // Obtain the fragments from the event.
  art::Handle<artdaq::Fragments> handle;
  e.getByLabel(raw_label_, handle);
  // Sanity check.
  assert(handle->size() == 1);
  // Now initialize a RawMilliBlock with the fragment payload.
  // Not quite -- do the work to do so, but the data on the heap has to be
  // just the HitData, and we don't want to do two copies. So we interrupt
  // the work at a key point, to make and push_back DAQHits.
  std::unique_ptr<RawMilliBlock> mbp(new RawMilliBlock);
  novaddt::EventHeader           evt_header;

  size_t total_bytes =
    populateMilliBlock(&*(handle->front().dataBegin()), *mbp, &evt_header);
  std::unique_ptr<std::vector<Hit>> hits(new std::vector<Hit>);
  std::unique_ptr<novaddt::EventHeader > mbhead(new novaddt::EventHeader(evt_header));

  // std::unique_ptr<std::vector<Hit>> MCShits(new std::vector<Hit>);


  size_t const nanoSliceSize = 12;  // Each nano-slice is *at least* 12 bytes
  hits->reserve(total_bytes / nanoSliceSize); // definitely enough.
  // Now code taken from A. Norman's GetDAQHits-SHM
  // First Loop over the MilliBlock to get the millislices

  // for (auto & millislice : mbp->slices)  {
  for (unsigned n = 0; n != mbp->slices.size(); ++n)
  {  
    // Now for each millislice we loop over the microslices
    // I would LOVE to do this without the weird floating micro slice but...
    for (uint32_t imicro = 0; mbp->slices.at(n).setFloatingMicroSlice(imicro); ++imicro) {
      RawMicroSlice * theSlice = mbp->slices.at(n).getFloatingMicroSlice();
      for (uint32_t inano = 0; inano < theSlice->getNumNanoSlices(); ++inano) {
        theSlice->setFloatingNanoSlice(inano);
        //new way
        daqdataformats::RawMilliSlice* theMilli = &mbp->slices.at(n);
        daqdataformats::RawNanoSlice* theNano = theSlice->getFloatingNanoSlice();
        int detID = theMilli->getHeader()->getDetId();
        wpr->setup(theSlice, theNano);
        hits->emplace_back( detID,
                            daqchannelmap::DAQChannelMap::getInstance(detID)
                            ->encodeDChan(detID,
                                          theMilli->getHeader()->getDiblockId(),
                                          theMilli->getHeader()->getDCMId(),
                                          theNano->getHeader()->getFEBId(),
                                          theNano->getHeader()->getPixelAddr()),  
                            wpr->getADC(), 
                            wpr->getTDC() );

        // if (passes_MCS_filter(theNano))
        //   {
        //     MCShits->emplace_back( detID,
        //                         daqchannelmap::DAQChannelMap::getInstance(detID)
        //                         ->encodeDChan(detID,
        //                                       theMilli->getHeader()->getDiblockId(),
        //                                       theMilli->getHeader()->getDCMId(),
        //                                       theNano->getHeader()->getFEBId(),
        //                                       theNano->getHeader()->getPixelAddr()),  
        //                         wpr->getADC(), 
        //                         wpr->getTDC() );
        //   }

         //old way
        //hits->emplace_back(&mbp->slices.at(n),
        //                   theSlice->getFloatingNanoSlice());
      } // Loop over microslices (imicro, as ranged using setFloatingNanoSlice)
    } // Loop over microslices (inano, as ranged using setFloatingMicroSlice)
  } // Loop over millislices {millislice ranged over mb.slices}
  e.put(std::move(hits),"AllHits");
  e.put(std::move(mbhead),"DDTdaq");
  // e.put(std::move(MCShits),"MCSHits");
#ifdef NEED_MILLIBLOCK_IN_EVENT
  e.put(std::move(mbp));
#endif
}
bool NovaDDTHitProducer::passes_MCS_filter(daqdataformats::RawNanoSlice* fNano) const
{
  //check that multipoint can be used
  const uint32_t version = fNano->getHeader()->getVersion();
  static daqdataformats::NanoSliceVersionConvention conv;
  const unsigned int nSamples = conv.getNSamples(version);
  const unsigned int nPretrig = conv.getNPretriggeredSamples(version);

  //MCS filter will not work under this case, use normal way:
  if (nPretrig<3 || nSamples <= nPretrig || version==0) return false;

  //I require all the ADC values monotonously increase before trigger:
  for (unsigned i = 1; i!= nPretrig; ++i) {
    int16_t adc_pre = fNano->getValue(i-1); 
    int16_t adc_cur = fNano->getValue(i);
    if (adc_pre > adc_cur) return false; 
  } 

  return true;

}

DEFINE_ART_MODULE(NovaDDTHitProducer)