ResizeDetector_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       ResizeDetector
// Module Type: producer
// File:        ResizeDetector_module.cc
//
// Generated at Mon Jan  6 16:42:53 2014 by Brian_Rebel using artmod
// from cetpkgsupport v1_04_02.
// Module to create a RawDigit list for only those diblocks that are instrumented
////////////////////////////////////////////////////////////////////////

#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 "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "art_root_io/TFileService.h"
#include "fhiclcpp/ParameterSet.h"

#include <memory>
#include <string>

#include "DAQChannelMap/DAQChannelMap.h"
#include "RawData/RawDigit.h"
#include "Geometry/Geometry.h"

#include "TH1.h"

namespace calib {
  class ResizeDetector;
}

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

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

  void beginJob() override;

  void reconfigure(fhicl::ParameterSet const & p);

private:

  std::string fRawDigitLabel; ///< module producing raw digits
  uint32_t    fMaxDiBlock;    ///< maximum diblock from which to use digits

  TH1F*       fDiBlocks;      ///< diblocks of the digits put into the vector
  TH1F*       fPlanes;        ///< planes of the digits put into the vector

};

//------------------------------------------------------------------
calib::ResizeDetector::ResizeDetector(fhicl::ParameterSet const & p)
  : EDProducer(p)
{
  this->reconfigure(p);

  produces< std::vector<rawdata::RawDigit> >();
}

//------------------------------------------------------------------
calib::ResizeDetector::~ResizeDetector()
{
  // Clean up dynamic memory and other resources here.
}

//------------------------------------------------------------------
void calib::ResizeDetector::beginJob()
{
  art::ServiceHandle<art::TFileService> tfs;

  fDiBlocks = tfs->make<TH1F>("diblocks", ";DiBlock;Digits", 14, 1., 15.);
  fPlanes   = tfs->make<TH1F>("planes",   ";Plane;Digits", 1000, 0, 1000);

  return;
}

//------------------------------------------------------------------
void calib::ResizeDetector::produce(art::Event & e)
{

  std::unique_ptr< std::vector<rawdata::RawDigit> > resizedDetDigits(new std::vector<rawdata::RawDigit>);

  art::Handle< std::vector<rawdata::RawDigit> > inputDigits;
  e.getByLabel(fRawDigitLabel, inputDigits);

  // Create geometry service handle to pass detector type to getInstance
  // to grab correct daqchannelmap class instance.
  art::ServiceHandle<geo::Geometry> geo;

  daqchannelmap::DAQChannelMap *cm = daqchannelmap::DAQChannelMap::getInstance(geo->DetId());

  uint32_t diBlock(UINT_MAX);
  uint32_t plane(UINT_MAX);

  for(size_t d = 0; d < inputDigits->size(); ++d){
    rawdata::RawDigit const& rd = inputDigits->at(d);
    diBlock = cm->getDiBlock(cm->encodeDChan(rd.Channel()));
    plane   = cm->getPlane(rd.Channel());

    if(diBlock <= fMaxDiBlock){
      resizedDetDigits->push_back(inputDigits->at(d));
      fDiBlocks->Fill(diBlock);
      fPlanes->Fill(plane);
    }
  }

  e.put(std::move(resizedDetDigits));

}

//------------------------------------------------------------------
void calib::ResizeDetector::reconfigure(fhicl::ParameterSet const & p)
{
  fRawDigitLabel = p.get< std::string >("RawDigitLabel", "daq");
  fMaxDiBlock    = p.get< uint32_t    >("MaxDiBlock",    2); 
}

DEFINE_ART_MODULE(calib::ResizeDetector)