RemoveBadChannels_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 "RecoBase/CellHit.h"
#include "RunHistory/service/RunHistoryService.h"

#include <string>

namespace calhit
{
  namespace
  {
    struct RemoveBadChannelsParams
    {
      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> cellHitLabel
      {
        Name("CellHitLabel"),
        Comment("Where to find CellHits.")
      };
    };
  }

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

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

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

  protected:
    const RemoveBadChannelsParams fParams;
    const art::ProductToken<std::vector<rb::CellHit>> fCellHitToken;
  };

  //......................................................................
  RemoveBadChannels::RemoveBadChannels(const Parameters& params)
    : fParams(params()),
      fCellHitToken(consumes<std::vector<rb::CellHit>>(fParams.cellHitLabel()))
  {
    produces<std::vector<rb::CellHit>>();
    produces<int, art::InRun>();
    produces<int, art::InSubRun>();
  }

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

  //......................................................................
  void RemoveBadChannels::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 RemoveBadChannels::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("RemoveBadChannels") << __PRETTY_FUNCTION__ << " writing subrun diblock mask " << std::hex << tmask << std::dec << " to subrun." << std::endl;
      subrun.put(std::move(mask));
    }
  }

  //......................................................................
  void RemoveBadChannels::produce(art::Event& evt)
  {
    // get the CellHit list
    art::Handle< std::vector<rb::CellHit>> hitcol;
    evt.getByToken(fCellHitToken, hitcol);
    if (!hitcol.isValid()) {
      mf::LogError("RemoveBadChannels") << "Cannot find " << fParams.cellHitLabel() << ". Perhaps you want RemoveBadChannelsFilter instead?";
      abort();
    }

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

    // No valid handle -- 
    if (!hitcol.isValid()) {
      mf::LogError("RemoveBadChannels") << "Cannot find " << fParams.cellHitLabel() << ". Bailing.";
      abort();
    }

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

    // 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 rb::CellHit& hit: *hitcol){
        if(!bcl->IsBad(hit.Plane(),
                       hit.Cell())){
          cellhitcol->push_back(hit);
        }
      }
    }
    else{
      for(const rb::CellHit hit: *hitcol){
        cellhitcol->push_back(hit);
      }
    }

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

  DEFINE_ART_MODULE(RemoveBadChannels)

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