CalHit_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief   This module creates CellHit object
/// \author  ??
////////////////////////////////////////////////////////////////////////

// Framework includes
#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Core/ModuleMacros.h"

#include "Calibrator/Calibrator.h"
#include "ChannelInfo/BadChanList.h"
#include "RawData/RawDigit.h"
#include "RecoBase/CellHit.h"
#include "RunHistory/service/RunHistoryService.h"

#include <string>

namespace calhit
{
  namespace
  {
    struct CalHitParams
    {
      template<class T> using Atom = fhicl::Atom<T>;
      template<class T> using Table = fhicl::Table<T>;
      using Comment = fhicl::Comment;
      using Name = fhicl::Name;

      Atom<bool> removeBadChans
      {
        Name("RemoveBadChans"),
        Comment("Whether or not to remove hits on bad channels.")
      };

      Atom<std::string> rawDataLabel
      {
        Name("RawDataLabel"),
        Comment("Where to find RawDigits.")
      };
    };
  }

  /// Create CellHits from RawDigits
  class CalHit : public art::EDProducer
  {
  public:
    // Allows 'nova --print-description' to work
    using Parameters = art::EDProducer::Table<CalHitParams>;

    explicit CalHit(const Parameters& params);
    virtual ~CalHit();

    virtual void beginRun(art::Run& run);
    virtual void beginSubRun(art::SubRun& subrun);
    void produce(art::Event& evt);

  protected:
    const CalHitParams fParams;
    const art::ProductToken<std::vector<rawdata::RawDigit>> fRawDigitToken;
  };

  //......................................................................
  CalHit::CalHit(const Parameters& params)
    : fParams(params()),
      fRawDigitToken(consumes<std::vector<rawdata::RawDigit>>(fParams.rawDataLabel()))
  {
    produces<std::vector<rb::CellHit>>();
    produces<int, art::InRun>();
    produces<int, art::InSubRun>();
  }

  //......................................................................
  CalHit::~CalHit()
  {
  }

  //......................................................................
  void CalHit::beginRun(art::Run& run)
  {
    art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    // if use subrun-level dB masks, don't do this
    if (! rh->GetDiBlockMaskFromCondb()) {
      std::unique_ptr<int> mask(new int(rh->GoodDiBlockMask(0,true)));
      std::cout << __PRETTY_FUNCTION__ << " writing run diblock mask " << std::hex << *mask << std::dec << " to run." << std::endl;
      run.put(std::move(mask));
    }
  }

  //......................................................................
  void CalHit::beginSubRun(art::SubRun& subrun)
  {
    art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    // do this if we are using subrun-level dB masks
    if (rh->GetDiBlockMaskFromCondb()) {
      int sr = subrun.subRun();
      int tmask = rh->GoodDiBlockMask(sr,false);
      std::unique_ptr<int> mask(new int(tmask));
      LOG_DEBUG("CalHit") << __PRETTY_FUNCTION__ << " writing subrun diblock mask " << std::hex << tmask << std::dec << " to subrun." << std::endl;
      subrun.put(std::move(mask));
    }
  }

  //......................................................................
  void CalHit::produce(art::Event& evt)
  {
    // get the RawDigit list
    art::Handle< std::vector<rawdata::RawDigit>> digitcol;
    evt.getByToken(fRawDigitToken, digitcol);

    // define the unique_ptr holding the collection of rb::CellHits to be made
    auto cellhitcol = std::make_unique<std::vector<rb::CellHit>>();

    // Expect most of the cells to be good. Don't want to waste time resizing
    // the array
    cellhitcol->reserve(digitcol->size());

    // Get a Calibrator instance for this event
    art::ServiceHandle<calib::Calibrator> cal;

    // Make a CellHit for every (non-bad) RawDigit and write it out

    // Make the hits and write them out
    if(fParams.removeBadChans()){
      art::ServiceHandle<chaninfo::BadChanList> bcl;
      art::ServiceHandle<cmap::CMap> cmap;

      for(const rawdata::RawDigit& dig: *digitcol){
        if(!bcl->IsBad(cmap->GetPlane(&dig),
                       cmap->GetCell(&dig))){
          cellhitcol->push_back(cal->MakeCellHit(&dig));
        }
      }
    }
    else{
      for(const rawdata::RawDigit& dig: *digitcol){
        cellhitcol->push_back(cal->MakeCellHit(&dig));
      }
    }

    evt.put(std::move(cellhitcol));
  }

  DEFINE_ART_MODULE(CalHit)

} // end namespace calhit
//////////////////////////////////////////////////////////////////////////