BadChanList_service.cc

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////
/// \brief   Interface to the run-by-run list of bad channels
/// \author  betancourt@physics.umn.edu
//////////////////////////////////////////////////////////////////////////
#include "ChannelInfo/BadChanList.h"

#include <sys/stat.h>
#include <sstream>

// NOvA includes
#include "CMap/service/CMapService.h"
#include "CMap/service/DetectorService.h"
#include "Geometry/Geometry.h"
#include "SummaryData/DataRunNumInMC.h"
#include "SummaryData/RunData.h"

//#include "NovaDatabase/Table.h"
#ifdef NOVACMAKE
#include "Database/cxx/include/Table.h"
#else
#include "Database/Table.h"
#endif
#include "RunHistory/service/RunHistoryService.h"
#include "Simulation/Simulation.h"

// Framework includes
#include "art/Framework/Principal/SubRun.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "art/Framework/Services/Optional/RandomNumberGenerator.h"
#include "cetlib/search_path.h"
#include "cetlib_except/exception.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include "CLHEP/Random/RanluxEngine.h"

#include "TString.h"

namespace chaninfo {

  //------------------------------------------------------------
  BadChanList::BadChanList(fhicl::ParameterSet const& pset,
                           art::ActivityRegistry &reg) :
    fNewCosmicEffTable(false)
  {
    fRandomBCMap.clear();
    fNeedNewData = true;
    fValidityTagNearDet = "";
    fValidityTagFarDet = "";
    fMCRunNumber = -1;
    fMCSubrunNumber = -1;
    fNBadSR = -1; // unknown yet
    fIsPerfect = false;
    fIsBadCacheValid = false;
    fIsBadCache.reset();

    //treat every DCM as occupied at initialization. 
    for(int i = 0; i < 12; i++) { // re-initialize every event
      for(int j = 0; j < 14; j++) { // just keep array sized 12 x 14; for ND we just won't use it all
        fDCMHits[i][j] = 1;
      }
    }

    CLHEP::RanluxEngine rle(sim::GetRandomNumberSeed());
    fFlatRand = std::unique_ptr<CLHEP::RandFlat>(new CLHEP::RandFlat(rle));

    this->reconfigure(pset);
    reg.sPreBeginRun.watch(this, &BadChanList::preBeginRun);
    reg.sPostBeginSubRun.watch(this, &BadChanList::postBeginSubRun);
    reg.sPreProcessEvent.watch(this, &BadChanList::preBeginEvent);    
  }

  //----------------------------------------------------------

  BadChanList::~BadChanList()
  {
  }

  //----------------------------------------------------------
  void BadChanList::preBeginRun(art::Run const & run)
  {
    fRun = run.run();
    if (fMCRunNumber > 0) {
      fRun = fMCRunNumber;
    }

    if (fRun >= 1000000)
      fIsPerfect=true;
    else if (fRun < 10000) {
      if (fAbortOnSmallRunNum){
        LOG_DEBUG("BadChanList") <<"Bad Channels found a run number below 10000.  This should never happen and is dangerous.";
        std::abort();
      }
      else
        fIsPerfect=true;
    }
    else
      fIsPerfect=false;
    
    fNeedNewData = true;
    
    LOG_DEBUG("BadChanList")
    << "Run in BCL is: " << fRun << " " << fNeedNewData;
    
    fNBadSR = -1;

  }

  //----------------------------------------------------------
  void BadChanList::postBeginSubRun(art::SubRun const & subrun)
  {
    art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    if (rh->NSubruns() == 0) {
      LOG_DEBUG("BadChanList") << "RunHistory thinks there are no subruns in this run.";
      if (fAbortIfNoSubrun)
        std::abort();
    }

    int sr = subrun.subRun();

    if (fMCRunNumber > 0) {
      sr = fMCSubrunNumber;
    }

    fSubRun = sr;

    fNBadSR = -1;

    // As per Teresa Lackey on Slack #nova-offline, 2019-06-10, confirmed by
    // Jon Paley, the badness status of a channel can only change at subrun
    // boundaries, or perhaps even less often.  Therefore invalidate the cache
    // at subrun boundaries.  Since most production jobs process only one subrun,
    // trying to invalidate less often doesn't have much impact.
    fIsBadCacheValid = false;
  }

  //----------------------------------------------------------
  template<class T> void BadChanList::CountDCMHits(const std::vector<T>& digitcol)
  {
    for(int i = 0; i < 12; i++) { // re-initialize every event
      for(int j = 0; j < 14; j++) { // just keep array sized 12 x 14; for ND we just won't use it all
        fDCMHits[i][j] = 0;
      }
    }
    int dib, dcm;
    art::ServiceHandle<geo::Geometry> geom;
    daqchannelmap::DAQChannelMap* daqmap = daqchannelmap::DAQChannelMap::getInstance(geom->DetId());
    for(const T& digit: digitcol){
      // count the number of raw digit hits in each DCM
      dcm = daqmap->getDCM(digit.DaqChannel());
      dib = daqmap->getDiBlock(digit.DaqChannel());
      fDCMHits[dcm-1][dib-1]++;
    }
  }

  //----------------------------------------------------------
  void BadChanList::preBeginEvent(art::Event const & event)
  {
    if(fEventCheck) {  // check for dropped DCMs every event
      art::Handle< std::vector<rawdata::RawDigit> > digitcol;
      event.getByLabel(fRawDigitLabel, digitcol);

      // We prefer to use the raw digits, but if they've been dropped from the
      // file we will try the CellHits instead.
      if(digitcol.failedToGet()){
        art::Handle<std::vector<rb::CellHit>> chitcol;
        event.getByLabel(fCellHitLabel, chitcol);
        if(!chitcol.failedToGet()){
          CountDCMHits(*chitcol);
        }
      }
      else{
        CountDCMHits(*digitcol);
      }
    } // end looking for dropped DCMs

    if(!fIsBadCacheValid){
      // turn off event checking here, turn it back on when we're done
      // building cache
      bool fEventCheck_save = fEventCheck;
      fEventCheck = false;

      art::ServiceHandle<geo::Geometry> geom;
      const unsigned int nplane = geom->NPlanes();

      LOG_INFO("BadChanList") << "Initializing bad cell cache for " << nplane << " planes";

      if(nplane > FD_NUM_PLANES)
        LOG_ERROR("BadChanList") << "Too many planes " << nplane;

      for(unsigned int p = 0; p < nplane && p < FD_NUM_PLANES; p++){
        const unsigned int ncell = geom->Plane(p)->Ncells();
        if(ncell > FD_NUM_CELLS)
          LOG_ERROR("BadChanList") << p << ", too many cells: " << ncell;

        for(unsigned int c = 0; c < ncell && c < FD_NUM_CELLS; c++)
          fIsBadCache[p*FD_NUM_CELLS + c] = IsBadUncached(p, c);
      }
      fIsBadCacheValid = true;
      fEventCheck = fEventCheck_save;
    }
  }

  //-----------------------------------------------------------
  int BadChanList::NBadInSubRun(int isr)
  {
    art::ServiceHandle<nova::dbi::RunHistoryService> rh;

    if (isr > rh->NSubruns()) return 0;
    
    if (fNeedNewData) LoadNewData();

    art::ServiceHandle<geo::Geometry> geom;
    int detId = geom->DetId();
    daqchannelmap::DAQChannelMap* daqmap = daqchannelmap::DAQChannelMap::getInstance(detId);

    if(fNBadSR >= 0) return fNBadSR;

    // Otherwise, look up the answer
    int nbad=0;
    int fRun_save = fRun;
    int fSubRun_save = fSubRun;
    fRun = rh->RunNumber();
    fSubRun = isr;

    // turn off event checking here, turn it back on when we're done
    // counting bad channels
    bool fEventCheck_save = fEventCheck;
    fEventCheck = false;

    for (int idb=0; idb<rh->NDiBlocks(); ++idb) {
      nova::dbi::RunHistory::DiBlock dblk = rh->GetDiBlock(idb,false);

      if (!rh->IsGoodDiBlock(dblk.num)) continue;

      for (unsigned int idcm=0; idcm<dblk.dcm.size(); ++idcm) {
        for (unsigned int ifeb=0; ifeb<dblk.dcm[idcm].feb.size(); ++ifeb) {
          if (dblk.dcm[idcm].feb[ifeb].hasAPD) {
            for (int ipix=0; ipix<=31; ++ipix) {
            //for (int ipix=1; ipix<=32; ++ipix) {
              daqchannelmap::dchan daqChan = daqmap->encodeDChan(detId,
                                                                 dblk.num,
                                                                 idcm+1,
                                                                 ifeb,
                                                                 ipix);
              daqchannelmap::lchan logChan = daqmap->encodeLChan(daqChan);

              int plane = daqmap->getPlane(logChan);
              int cell = daqmap->getCell(logChan);
              if (IsBad(plane,cell)) ++nbad;
            } // end loop over pixels
          } // end if hasAPD
        } // end loop over FEBs
      } // end loop over DCMs
    } // end loop over DiBlocks

    fEventCheck = fEventCheck_save;
    fNBadSR = nbad;

    fRun = fRun_save;
    fSubRun = fSubRun_save;

    return fNBadSR;
  }

  //-----------------------------------------------------------
  void BadChanList::SetRandomBadChannels()
  {
    if (!fRandomBCMap.empty()) return;

    LOG_ERROR("BadChanList")<< " RANDOM BAD CHANNELS at rate "
              << fRandomBadChannelFraction;

    fLowEfficiency.clear();

    art::ServiceHandle<geo::Geometry> geom;
    for(unsigned int plane: geom->GetPlanesByView()){
      const unsigned int nCells = geom->Plane(plane)->Ncells();
      
      for(unsigned int cell = 0; cell < nCells; ++cell){
        geo::OfflineChan chan(plane, cell);
        if(fFlatRand->fire() < fRandomBadChannelFraction){
          fRandomBCMap.insert(chan);
        }
      }
    }
  }

  //-----------------------------------------------------------
  void BadChanList::LoadCosmicEff(int newrun, int newsubrun)
  {
    fLowEfficiency.clear();

    nova::dbi::Table tblEff(fNewCosmicEffTable ?
                            "/ChannelInfo/CosmicEffNew.xml" :
                            "/ChannelInfo/CosmicEff.xml");
    tblEff.SetValidityRange("detector", "ndos");
    tblEff.SetValiditySQL(TString::Format("(beginrun<%d or (beginrun=%d and beginsubrun<=%d)) and "
                                          "(endrun>%d or (endrun=%d and endsubrun>=%d))",
                                          newrun, newrun, newsubrun, newrun, newrun, newsubrun).Data());
    //    }

    // Only ask for the bad channels. We won't get any "good" ones back, so
    // they won't go in the map, which is fine.
    tblEff.SetValidityRange("good", false);

    tblEff.SetVerbosity(100);
    const bool ok = tblEff.Load();
    if(!ok){
      // No safe way to handle this
      LOG_DEBUG("BadChanList") << "Couldn't load efficiencies channels from DB. Aborting" << std::endl;
     std::abort(); 
    }
    int planeIdx = tblEff.GetColIndex("plane");
    int cellIdx = tblEff.GetColIndex("cell");
    int goodIdx = tblEff.GetColIndex("good");

    for(int i = 0; i < tblEff.NRow(); ++i){
      int plane, cell;
      bool good;
      bool ok = tblEff.GetRow(i)->Col(planeIdx).Get(plane);
      ok = ok && tblEff.GetRow(i)->Col(cellIdx).Get(cell);
      ok = ok && tblEff.GetRow(i)->Col(goodIdx).Get(good);
      if(!ok) std::abort();
      geo::OfflineChan chan(plane, cell);
      if(!good) fLowEfficiency.insert(chan);
    }
  }

  //-----------------------------------------------------------
  void BadChanList::reconfigure(fhicl::ParameterSet pset)
  {
    fApplyBadChan            = pset.get<int>("ApplyBadChan");
    fMCRunNumber             = pset.get<int>("MCRunNumber");
    fMCSubrunNumber          = pset.get<int>("MCSubrunNumber");
    fNewCosmicEffTable       = pset.get<bool>("NewCosmicEffTable");
    fRandomBadChannelFraction= pset.get<float>("RandomBadChannelFraction");
    fBadChanCSVFile          = pset.get<std::string>("BadChanCSVFile");
    fValidityTagNearDet      = pset.get<std::string>("ValidityTagNearDet");
    fValidityTagFarDet       = pset.get<std::string>("ValidityTagFarDet");
    fAbortIfNoneFound        = pset.get<bool>("AbortIfNoneFound");
    fAbortOnSmallRunNum      = pset.get<bool>("AbortOnSmallRunNum");
    fAbortIfNoSubrun         = pset.get<bool>("AbortIfNoSubrun");
    fEventCheck              = pset.get<bool>("EventCheck");
    fRawDigitLabel           = pset.get<std::string>("RawDigitLabel");
    fCellHitLabel            = pset.get<std::string>("CellHitLabel");
    fApplyFEBDropout         = pset.get<bool>("ApplyFEBDropout");
    fFEBDropoutTag           = pset.get<std::string>("FEBDropoutTag");
    fVldRunGrouping          = pset.get<int>("VldRunGrouping");
    fPedestalThresholdLow    = pset.get<int>("PedestalThresholdLow");
    fPedestalThresholdHigh   = pset.get<int>("PedestalThresholdHigh");
    
    bool applyKBC = pset.get<bool>("ApplyKnownBadChannels");
  
    if (!fValidityTagNearDet.empty()) {
      float tagNum = atof(fValidityTagNearDet.substr(1).c_str());
      if (tagNum < 9.0) {
        LOG_ERROR("BadChanList")<<"This version of Bad Channels requires tag >= 9.0";           
        std::abort();
      }
    }

    if (!fValidityTagFarDet.empty()) {
      float tagNum = atof(fValidityTagFarDet.substr(1).c_str());
      if (tagNum < 9.0) {
        LOG_ERROR("BadChanList")<<"This version of Bad Channels requires tag >= 9.0";           
       std::abort();
      }
    }

    fKBCList.clear();
    if (applyKBC) 
      fKBCList = pset.get<std::vector<std::string> >("KnownBadChannels");       
     
  }

  //----------------------------------------------------------
  void BadChanList::LoadNewData()
  {
    if (fIsPerfect) return;

    art::ServiceHandle<geo::Geometry> geom;

    if (!fKBCList.empty()) {
      
      fKnownBadChannels.clear();
      art::ServiceHandle<cmap::CMap> cmap;
      
      int idet = geom->DetId();
      int db, dcm, feb, detId;
      for (auto k : fKBCList) {
        sscanf(k.c_str(),"%d-%02d-%02d-%02d",&detId,&db,&dcm,&feb);
        if (detId == idet) {
          LOG_DEBUG("BadChanList")<< k << " is known to be bad, all associated channels masked off.";
          for (int ipix=0; ipix<32; ++ipix) {
            daqchannelmap::dchan daqChan = cmap->Map()->encodeDChan(idet,db,dcm,feb,ipix);
            daqchannelmap::dchan logChan = cmap->Map()->encodeLChan(daqChan);         
            int plane = cmap->Map()->getPlane(logChan);
            int cell = cmap->Map()->getCell(logChan);
            fKnownBadChannels.push_back(geo::OfflineChan(plane,cell));
          }
        }
      }
    }

    fBadChans.clear();
    fDropOuts.clear();

    nova::dbi::Table BCTable("/ChannelInfo/ChanRateState.xml");
    BCTable.SetVerbosity(100);
    BCTable.SetDetector(geom->DetId());
    if (geom->DetId() == novadaq::cnv::kNEARDET) {
      if (fValidityTagNearDet != "")
        BCTable.SetTag(fValidityTagNearDet);
    }
    else if (geom->DetId() == novadaq::cnv::kFARDET) {
      if (fValidityTagFarDet != "")
        BCTable.SetTag(fValidityTagFarDet);
    }
    
    
    const int stateIdx = BCTable.GetColIndex("state");
    
    nova::dbi::Table FEBDOTable("/ChannelInfo/FEBDropout.xml");
    FEBDOTable.SetVerbosity(100);
    FEBDOTable.SetDetector(geom->DetId());
    if (fFEBDropoutTag != "")
      FEBDOTable.SetTag(fFEBDropoutTag);
    const int FEBStateIdx = FEBDOTable.GetColIndex("state");
    
    if (!fBadChanCSVFile.empty())
    {
      BCTable.LoadFromCSV(fBadChanCSVFile);
      LOG_ERROR("BadChanList") << "Read " << BCTable.NRow() 
                               << " BadChannel rows from "
                               << fBadChanCSVFile;
    }
    else
    {
      if (fMCRunNumber > 0)
      {
        nova::dbi::RunHistory rh(fMCRunNumber,geom->DetId());
        fMinVldTime = rh.RunNumber()*10000 + 1;
        fMaxVldTime = fMinVldTime + rh.NSubruns()*100;
      }
      else if (geom->DetId() == novadaq::cnv::kFARDET ||
               geom->DetId() == novadaq::cnv::kNEARDET)
      {
        art::ServiceHandle<nova::dbi::RunHistoryService> rh;
        int minrun = int(rh->RunNumber()/fVldRunGrouping)*fVldRunGrouping;
        fMinVldTime = minrun*10000 + 1;
        fMaxVldTime = fMinVldTime - 1 + fVldRunGrouping*10000;
      }
      
      BCTable.SetDataTypeMask(nova::dbi::kMCOnly|nova::dbi::kDataOnly);
      BCTable.SetMinTSVld(fMinVldTime);
      BCTable.SetMaxTSVld(fMaxVldTime);
      
      if (!BCTable.Load()) {
        LOG_ERROR("BadChanList") <<"Bad Channels table failed to load data!";
        std::abort();
      }
      if (BCTable.NRow() == 0) {
        LOG_ERROR("BadChanList") << "******** WARNING: BadChanList_service found no bad channels!";
        if (fAbortIfNoneFound) {
          LOG_ERROR("BadChanList") << "Bad Channels table is empty, this should never happen!";
          std::abort();
        }
      }
      
      if (fApplyFEBDropout && (geom->DetId() == novadaq::cnv::kNEARDET)) {
        FEBDOTable.SetMinTSVld(fMinVldTime-480);
        FEBDOTable.SetMaxTSVld(fMaxVldTime+480);
        FEBDOTable.Load();
        if (FEBDOTable.NRow() == 0) {
          LOG_WARNING("BadChanList") << "******** BadChanList_service found no FEB dropout data!";
        }
      }
    }

    BCTable.FillChanRowMap();
    FEBDOTable.FillChanRowMap();

    art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    daqchannelmap::DAQChannelMap* daqcmap = daqchannelmap::DAQChannelMap::getInstance(geom->DetId());
    fBadChans.resize(rh->NSubruns());
    fDropOuts.resize(rh->NSubruns());

    for(int subrun = 0; subrun < rh->NSubruns(); ++subrun){
      const time_t evtTime = fRun*10000 + subrun*100 + 1;

      for(unsigned int plane = 0; plane < geom->NPlanes(); ++plane){
        const geo::PlaneGeo* geoplane = geom->Plane(plane);
        for(unsigned int cell = 0; cell < geoplane->Ncells(); ++cell){
          const geo::OfflineChan chan(plane, cell);

          // get validity row for this timestamp
          nova::dbi::Row* row = BCTable.GetVldRow(chan.ToDBValidityChan(),
                                                  evtTime);

          if(row){
            // there is an entry for this timestamp (expected behavior), so
            // make sure that the state is "ok" (==0)
            int state;
            const bool ok = row->Col(stateIdx).Get(state);
            if(!ok) std::abort();
            if(state != 0) {
              fBadChans[subrun].insert(geo::OfflineChan(plane, cell));
            }
          } // end if row

          // Now the drop-out table

          // TODO - one could loop over all the FEBs more efficiently than
          // this, but it doesn't really matter since this is once per run.

          daqchannelmap::lchan logChan = daqcmap->encodeLChan(geom->DetId(),
                                                              plane, cell);
          daqchannelmap::dchan daqChan = daqcmap->encodeDChan(logChan);

          const int db = daqcmap->getDiBlock(daqChan);
          const int dcm = daqcmap->getDCM(daqChan);
          const int feb = daqcmap->getFEB(daqChan);

          const int tchan = db*1000+(dcm-1)*64+feb;

          row = FEBDOTable.GetVldRow(tchan, evtTime);

          if(row){
            int state;
            const bool ok = row->Col(FEBStateIdx).Get(state);
            if(!ok) std::abort();
            // a state of "1" means the FEB is live at this point
            if(state != 1) fDropOuts[subrun].insert(tchan);
          }
        } // end for cell
      } // end for plane
    } // end for subrun

    auto info = LOG_INFO("BadChanList");
    for(int sr = 0; sr < rh->NSubruns(); ++sr){
      info << "Subrun " << sr << ": "
           << fBadChans[sr].size() << " bad channels, "
           << fDropOuts[sr].size() << " DCM dropouts.\n";
    }

    fNeedNewData = false;
  }

  //----------------------------------------------------------
  bool BadChanList::IsBad(int plane, int cell)
  {
    if(InDroppedDCM(plane, cell)) return true;

    return fIsBadCache[plane*FD_NUM_CELLS + cell];
  }

  //----------------------------------------------------------
  bool BadChanList::InDroppedDCM(int plane, int cell)
  {
    if(!fEventCheck) return false;

    static art::ServiceHandle<geo::Geometry> geom;
    daqchannelmap::DAQChannelMap* daqmap = daqchannelmap::DAQChannelMap::getInstance(geom->DetId());
    uint32_t dchan = daqmap->encodeDChan(daqmap->encodeLChan(geom->DetId(), plane, cell));
    if(fDCMHits[daqmap->getDCM(dchan)-1][daqmap->getDiBlock(dchan)-1]==0) {
      //***
      LOG_DEBUG("BadChanList") << "Dropped DCM";
      //***
      return true;
    }
    return false;
  }

  //----------------------------------------------------------
  bool BadChanList::IsBadUncached(int plane, int cell)
  {
    if(!fApplyBadChan) return false;
    if (fIsPerfect) return false;

    geo::OfflineChan chan(plane,cell);

    for (auto kbc : fKnownBadChannels) {
      if (kbc == chan) {
        //***
        LOG_DEBUG("BadChanList") << "BadChanList_service: known bad channel!";
        //***
        return true;
      }
    }

    if(fRandomBadChannelFraction > 0){
      SetRandomBadChannels();
      return fRandomBCMap.count(chan);
    }
    
    if (fNeedNewData) LoadNewData();
    
    static art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    static art::ServiceHandle<geo::Geometry> geom;

    const int sr = fSubRun%rh->NSubruns();
    const time_t evtTime = fRun*10000 + sr*100 + 1;
    
      // check if event time within validity range, i.e. sane
    if ( fBadChanCSVFile.empty() && (evtTime < fMinVldTime || evtTime > fMaxVldTime)){
      throw cet::exception("BadChanList")
      << "Event time is outside the validity range of the database request. "
      << fMinVldTime << " " << evtTime << " " << fMaxVldTime
      << " Database request does not contain complete information, "
      << "which could lead to unpredictable behavior.";
    }

    if(InDroppedDCM(plane, cell)) return true;
    
      // check with RH whether this channel was instrumented, part of the partition, or masked
    if (!rh->HasAPD(chan)) {
      //***
      LOG_DEBUG("BadChanList") << "Mmissing APD";
      //***
      return true;
    }    
      // for now, just deal with dB tables for the FarDet and NearDet
    if (geom->DetId() == novadaq::cnv::kFARDET ||
        geom->DetId() == novadaq::cnv::kNEARDET) {

      assert((unsigned int)sr < fBadChans.size());
      if(fBadChans[sr].count(chan)) return true;

      if (fApplyFEBDropout) {
        daqchannelmap::DAQChannelMap* daqcmap = daqchannelmap::DAQChannelMap::getInstance(geom->DetId());
        daqchannelmap::lchan logChan = daqcmap->encodeLChan(geom->DetId(),plane,cell);
        daqchannelmap::dchan daqChan = daqcmap->encodeDChan(logChan);
        
        int db = daqcmap->getDiBlock(daqChan);
        int dcm = daqcmap->getDCM(daqChan);
        int feb = daqcmap->getFEB(daqChan);
        
        int tchan = db*1000+(dcm-1)*64+feb;

        assert((unsigned int)sr < fDropOuts.size());
        if(fDropOuts[sr].count(tchan)) return true;
      }
    }

    // check if we should mask off channels with too low or too high of a pedestal
    if (fPedestalThresholdLow > 0) {
      bool pedok;
      int ped = rh->GetPedestal(chan,pedok);
      if (pedok) {
        if (ped < fPedestalThresholdLow ||
            ped > fPedestalThresholdHigh)
          return true;
      }
      else {
        LOG_WARNING("BadChanList") << "******** Failed to get a pedestal for found channel (" << plane << "," << cell << ")";
      }
    }
    // If we can't find anything wrong with it then it must not be bad
    return false;
  }

  //----------------------------------------------------------
  bool BadChanList::IsLowEfficiency(int plane, int cell)
  {
    if(!fApplyBadChan) return false;

    const geo::OfflineChan chan(plane, cell);
    return fLowEfficiency.count(chan);
  }

  //--------------------------------------------------------
  
  int BadChanList::Apply(std::vector< art::Ptr<rawdata::RawDigit> >& rd)
  {
    art::ServiceHandle<cmap::CMap> cmap;
    int ch;
    std::vector< art::Ptr<rawdata::RawDigit> > good;
    for(unsigned int i=0; i<rd.size(); ++i) {
      int plane = cmap->GetPlane(rd[i].get());
      int cell =  cmap->GetCell(rd[i].get());
      if(!IsBad(plane,cell)) good.push_back(rd[i]);
    }
    rd.swap(good);
    ch=rd.size();
    return ch;
  }
  
  //--------------------------------------------------------
  
  int BadChanList::Apply(art::PtrVector<rawdata::RawDigit>& rd)
  {
    art::ServiceHandle<cmap::CMap> cmap;
    int ch;
    art::PtrVector<rawdata::RawDigit> good;
    for(unsigned int i=0; i<rd.size(); ++i) {
      int plane = cmap->GetPlane(rd[i].get());
      int cell =  cmap->GetCell(rd[i].get());
      if(!IsBad(plane,cell)) good.push_back(rd[i]);
    }
    rd.swap(good);
    ch=rd.size();
    return ch;
  }

  //--------------------------------------------------------

  int BadChanList::Apply( std::vector<const rawdata::RawDigit*>& rd)
  {
    art::ServiceHandle<cmap::CMap> cmap;
    int ch;
    std::vector<const rawdata::RawDigit*> good;
    for(unsigned int i=0; i<rd.size(); ++i) {
      int plane = cmap->GetPlane(rd[i]);
      int cell =  cmap->GetCell(rd[i]);
      if(!IsBad(plane,cell)) good.push_back(rd[i]);
    }
    rd.swap(good);
    ch=rd.size();
    return ch;
  }



  DEFINE_ART_SERVICE(BadChanList)

}
////////////////////////////////////////////////////////////////////////