BadChanList.h

Go to the documentation of this file.

/// 
/// \brief   Interface to the run-by-run list of bad channels
/// \author  betancourt@physics.umn.edu, jpaley@anl.gov
/// \date
///
#ifndef CHANINFO_BADCHANLIST_H
#define CHANINFO_BADCHANLIST_H

#include <vector>
#include <map>
#include <string>
#include <ctime>

// NOvA includes
#include "RawData/RawDigit.h"
#include "GeometryObjects/OfflineChan.h"
#include "NovaDAQConventions/DAQConventions.h"
#include "DAQChannelMap/DAQChannelMap.h"

//Framework includes
#include "art/Framework/Services/Registry/ActivityRegistry.h"
#include "art/Framework/Services/Registry/ServiceMacros.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "canvas/Persistency/Common/Ptr.h"
//#include "art/Persistency/Provenance/Timestamp.h"
#include "fhiclcpp/ParameterSet.h"
#include "CLHEP/Random/RandFlat.h"

namespace nova{namespace dbi{class Table;}}

namespace chaninfo {

  const size_t FD_NUM_PLANES = 896;
  const size_t FD_NUM_CELLS = 384;

  ///
  /// Interface to the run-by-run list of bad channels
  ///
  class BadChanList {
  public:
    // Get a BadChanList instance here
    BadChanList(fhicl::ParameterSet const& pset, art::ActivityRegistry &reg);
    ~BadChanList();

    void preBeginRun(art::Run const& run);
    void postBeginSubRun(art::SubRun const& subrun);
    void preBeginEvent ( art::Event const & evt);
    
    int  Apply(art::PtrVector<rawdata::RawDigit>& rd);
    int  Apply(std::vector< art::Ptr<rawdata::RawDigit> >& rd);
    int  Apply(std::vector< const rawdata::RawDigit*>&);

    bool IsBad(int plane, int cell);
    bool IsLowEfficiency(int plane, int cell);
    void reconfigure(fhicl::ParameterSet p);

    void LoadNewData();

    int NBadInSubRun(int i);

  private:
    // This does the real work, and IsBad usually returns a cached value
    bool IsBadUncached(int plane, int cell);

    // If fEventCheck, return true if the DCM containing this channel has no hits in this
    // event and false otherwise.  Otherwise, return false.  This is an effective check
    // for dropped DCMS at the FD.  It seems suspect for the ND, which is quiet enough
    // to have validly empty DCMs.
    bool InDroppedDCM(int plane, int cell);

    void SetRandomBadChannels();

    void LoadCosmicEff(int newrun, int newsubrun);

    // T = RawDigit or CellHit
    template<class T> void CountDCMHits(const std::vector<T>& digitcol);

    // private data members for BadChanList class
    int                                  fApplyBadChan;           ///< Option to activate the bad channels   
    int                                  fMCRunNumber;            ///< Run number for the MC
    int                                  fMCSubrunNumber;         ///< Subrun number for the MC

    int                                  fNBadSR;

    int                                  fVldRunGrouping;

    int                                  fPedestalThresholdLow;
    int                                  fPedestalThresholdHigh;

    bool                                 fAbortIfNoneFound; ///< Option to throw an exception if no channel rate state rows are returned from dB.

    bool                                 fNeedNewData;

    bool                                 fIsPerfect;

    bool                                 fAbortOnSmallRunNum;

    bool                                 fAbortIfNoSubrun;

    std::unordered_set<geo::OfflineChan> fLowEfficiency; ///< set of low eff channels
    std::unordered_set<geo::OfflineChan> fRandomBCMap;   ///< random bad channel map

    std::string                          fBadChanCSVFile;

    bool                                 fEventCheck;    ///< do we check each event for dropped DCMs?

    std::string                          fRawDigitLabel;  ///< what is the name of the raw digits ART object
    std::string                          fCellHitLabel;

    bool fNewCosmicEffTable; ///< Use new-style table?

    float fRandomBadChannelFraction; ///< If >0, ignore DB and set this fraction bad at random

    /// Vector index is the subrun number, set contains all the bad channels
    std::vector<std::unordered_set<geo::OfflineChan>> fBadChans;
    std::vector<std::unordered_set<int>> fDropOuts; ///< [subrun][tchan]

    int fRun;
    int fSubRun;

    time_t fMinVldTime;                 ///<  Minimum time used in database request

    time_t fMaxVldTime;                 ///<  Maximum time used in database request



    std::string fValidityTagNearDet;
    std::string fValidityTagFarDet;
    std::string fFEBDropoutTag;

    bool fApplyFEBDropout;

    std::unique_ptr<CLHEP::RandFlat> fFlatRand;

    int fDCMHits[12][14]; ///< count hits in each DCM each event to look for dropped DCMs

    std::vector<std::string> fKBCList;
    std::vector<geo::OfflineChan> fKnownBadChannels;
    
    // Cache the answers to IsBad here. Regenerate on each subrun change. It
    // requires that we don't ever build a detector bigger than the Far Detector
    // (or for some reason number some kind of virtual plane or cells higher
    // than its planes and cells). For simplicity, always allocate enough memory
    // for the FD, since that's only 42kB.
    std::bitset<FD_NUM_PLANES*FD_NUM_CELLS> fIsBadCache;
    bool fIsBadCacheValid;
  };
}
DECLARE_ART_SERVICE(chaninfo::BadChanList, LEGACY)
#endif
////////////////////////////////////////////////////////////////////////