#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-16/ChannelInfo/BadChanList.h"

Public Member Functions
	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 Member Functions
bool	IsBadUncached (int plane, int cell)

bool	InDroppedDCM (int plane, int cell)

void	SetRandomBadChannels ()

void	LoadCosmicEff (int newrun, int newsubrun)

template<class T >
void	CountDCMHits (const std::vector< T > &digitcol)

Private Attributes
int	fApplyBadChan
	Option to activate the bad channels. More...

int	fMCRunNumber
	Run number for the MC. More...

int	fMCSubrunNumber
	Subrun number for the MC. More...

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. More...

bool	fNeedNewData

bool	fIsPerfect

bool	fAbortOnSmallRunNum

bool	fAbortIfNoSubrun

std::unordered_set< geo::OfflineChan >	fLowEfficiency
	set of low eff channels More...

std::unordered_set< geo::OfflineChan >	fRandomBCMap
	random bad channel map More...

std::string	fBadChanCSVFile

bool	fEventCheck
	do we check each event for dropped DCMs? More...

std::string	fRawDigitLabel
	what is the name of the raw digits ART object More...

std::string	fCellHitLabel

bool	fNewCosmicEffTable
	Use new-style table? More...

float	fRandomBadChannelFraction
	If >0, ignore DB and set this fraction bad at random. More...

std::vector< std::unordered_set< geo::OfflineChan > >	fBadChans
	Vector index is the subrun number, set contains all the bad channels. More...

std::vector< std::unordered_set< int > >	fDropOuts
	[subrun][tchan] More...

int	fRun

int	fSubRun

time_t	fMinVldTime
	Minimum time used in database request. More...

time_t	fMaxVldTime
	Maximum time used in database request. More...

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 More...

std::vector< std::string >	fKBCList

std::vector< geo::OfflineChan >	fKnownBadChannels

std::bitset< FD_NUM_PLANES *FD_NUM_CELLS >	fIsBadCache

bool	fIsBadCacheValid

Detailed Description

Interface to the run-by-run list of bad channels

Definition at line 39 of file BadChanList.h.

Constructor & Destructor Documentation

chaninfo::BadChanList::BadChanList	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 43 of file BadChanList_service.cc.

References fDCMHits, fFlatRand, fIsBadCache, fIsBadCacheValid, fIsPerfect, fMCRunNumber, fMCSubrunNumber, fNBadSR, fNeedNewData, fRandomBCMap, fValidityTagFarDet, fValidityTagNearDet, sim::GetRandomNumberSeed(), MECModelEnuComparisons::i, calib::j, postBeginSubRun(), preBeginEvent(), preBeginRun(), reconfigure(), art::ActivityRegistry::sPostBeginSubRun, art::ActivityRegistry::sPreBeginRun, and art::ActivityRegistry::sPreProcessEvent.

                                                      :
     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);    
   }

chaninfo::BadChanList::~BadChanList ( )

Definition at line 76 of file BadChanList_service.cc.

77 {

78 }

Member Function Documentation

int chaninfo::BadChanList::Apply ( art::PtrVector< rawdata::RawDigit > & rd )

Definition at line 692 of file BadChanList_service.cc.

References getBrightness::cell, visualisationForPaperMasterPlot::cmap, cmap::dataprov::CMap::GetCell(), cmap::dataprov::CMap::GetPlane(), update_sam_good_runs_metadata::good, MECModelEnuComparisons::i, IsBad(), NDAPDHVSetting::plane, art::PtrVector< T >::push_back(), art::PtrVector< T >::size(), and art::PtrVector< T >::swap().

Referenced by comi::Leana::analyze(), evd::RawDataDrawer::GetRawDigits(), evd::RawDataDrawer::GetRawDigitsMulti(), evtsum::EventSummary::MakeOutput(), and comi::Cana::produce().

   {
     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 chaninfo::BadChanList::Apply ( std::vector< art::Ptr< rawdata::RawDigit > > & rd )

Definition at line 675 of file BadChanList_service.cc.

References getBrightness::cell, visualisationForPaperMasterPlot::cmap, cmap::dataprov::CMap::GetCell(), cmap::dataprov::CMap::GetPlane(), update_sam_good_runs_metadata::good, MECModelEnuComparisons::i, IsBad(), and NDAPDHVSetting::plane.

   {
     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 chaninfo::BadChanList::Apply ( std::vector< const rawdata::RawDigit * > & rd )

Definition at line 709 of file BadChanList_service.cc.

References getBrightness::cell, visualisationForPaperMasterPlot::cmap, chaninfo::DEFINE_ART_SERVICE(), cmap::dataprov::CMap::GetCell(), cmap::dataprov::CMap::GetPlane(), update_sam_good_runs_metadata::good, MECModelEnuComparisons::i, IsBad(), and NDAPDHVSetting::plane.

   {
     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;
   }

template<class T >

void chaninfo::BadChanList::CountDCMHits ( const std::vector< T > & digitcol )

private

Definition at line 139 of file BadChanList_service.cc.

References febshutoff_auto::dcm, geo::GeometryBase::DetId(), fDCMHits, geom(), daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getInstance(), MECModelEnuComparisons::i, calib::j, and T.

Referenced by preBeginEvent().

   {
     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]++;
     }
   }

bool chaninfo::BadChanList::InDroppedDCM	(	int	plane,
		int	cell
	)

private

Definition at line 560 of file BadChanList_service.cc.

References getBrightness::cell, geo::GeometryBase::DetId(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), fDCMHits, fEventCheck, geom(), daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getInstance(), LOG_DEBUG, and NDAPDHVSetting::plane.

Referenced by IsBad(), and IsBadUncached().

   {
     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 chaninfo::BadChanList::IsBad	(	int	plane,
		int	cell
	)

Definition at line 552 of file BadChanList_service.cc.

References getBrightness::cell, chaninfo::FD_NUM_CELLS, fIsBadCache, and InDroppedDCM().

Referenced by calib::PEResponse::analyze(), Apply(), chaninfo::BadChanValidate::BadChansFromDB(), trk::KalmanTrack::CheckTrack(), trk::KalmanGeoHelper::CountMissedCellsOnLine(), dt::ViewMerger::CountUnexplainedOnLine(), evd::GeometryDrawer::DrawCells2D(), chaninfo::CosmicEff::endJob(), rsim::RecordNoiseSpectrumFile::endSubRun(), LightLevels::endSubRun(), trk::KalmanTrack::FilterTracker(), geo::LiveGeometry::GetBCInfo(), calib::HasXYAdjacents(), dt::DiscreteTracker::HighActivity(), NBadInSubRun(), trk::KalmanTrack::produce(), calhit::RemoveBadChannels::produce(), calhit::CalHit::produce(), hough::MultiHoughT::Scrub(), earms::ElasticArmsHS::Scrub(), vdt::VertexDT::Scrub(), fuzz::FuzzyKVertex::Scrub(), and dt::View::View().

   {
     if(InDroppedDCM(plane, cell)) return true;
 
     return fIsBadCache[plane*FD_NUM_CELLS + cell];
   }

bool chaninfo::BadChanList::IsBadUncached	(	int	plane,
		int	cell
	)

private

Definition at line 577 of file BadChanList_service.cc.

References ana::assert(), getBrightness::cell, febshutoff_auto::chan, confusionMatrixTree::count, febshutoff_auto::dcm, geo::GeometryBase::DetId(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), fApplyBadChan, fApplyFEBDropout, fBadChanCSVFile, fBadChans, fDropOuts, APDHVSetting::feb, fIsPerfect, fKnownBadChannels, fMaxVldTime, fMinVldTime, fNeedNewData, fPedestalThresholdHigh, fPedestalThresholdLow, fRandomBadChannelFraction, fRandomBCMap, fRun, fSubRun, geom(), daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), nova::dbi::RunHistory::GetPedestal(), nova::dbi::RunHistory::HasAPD(), InDroppedDCM(), novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, LoadNewData(), LOG_DEBUG, LOG_WARNING, nova::dbi::RunHistory::NSubruns(), NDAPDHVSetting::plane, rh, SetRandomBadChannels(), and sr.

Referenced by preBeginEvent().

   {
     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 chaninfo::BadChanList::IsLowEfficiency	(	int	plane,
		int	cell
	)

Definition at line 665 of file BadChanList_service.cc.

References febshutoff_auto::chan, fApplyBadChan, and fLowEfficiency.

Referenced by trk::KalmanTrack::CheckTrack(), trk::KalmanGeoHelper::CountMissedCellsOnLine(), dt::ViewMerger::CountUnexplainedOnLine(), trk::KalmanTrack::FilterTracker(), and dt::View::View().

   {
     if(!fApplyBadChan) return false;
 
     const geo::OfflineChan chan(plane, cell);
     return fLowEfficiency.count(chan);
   }

void chaninfo::BadChanList::LoadCosmicEff	(	int	newrun,
		int	newsubrun
	)

private

Definition at line 291 of file BadChanList_service.cc.

References getBrightness::cell, febshutoff_auto::chan, nova::dbi::Row::Col(), allTimeWatchdog::endl, fLowEfficiency, fNewCosmicEffTable, genie::utils::style::Format(), nova::dbi::Column::Get(), nova::dbi::Table::GetColIndex(), nova::dbi::Table::GetRow(), update_sam_good_runs_metadata::good, MECModelEnuComparisons::i, nova::dbi::Table::Load(), LOG_DEBUG, nova::dbi::Table::NRow(), NDAPDHVSetting::plane, nova::dbi::Table::SetValidityRange(), nova::dbi::Table::SetValiditySQL(), and nova::dbi::Table::SetVerbosity().

   {
     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 chaninfo::BadChanList::LoadNewData ( )

Definition at line 379 of file BadChanList_service.cc.

Referenced by IsBadUncached(), and NBadInSubRun().

   {
     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;
   }

int chaninfo::BadChanList::NBadInSubRun ( int i )

Definition at line 206 of file BadChanList_service.cc.

References getBrightness::cell, nova::dbi::RunHistory::DiBlock::dcm, geo::GeometryBase::DetId(), runNovaSAM::detId, daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), fEventCheck, fNBadSR, fNeedNewData, fRun, fSubRun, geom(), daqchannelmap::DAQChannelMap::getCell(), nova::dbi::RunHistory::GetDiBlock(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPlane(), IsBad(), nova::dbi::RunHistory::IsGoodDiBlock(), LoadNewData(), nova::dbi::RunHistory::NDiBlocks(), nova::dbi::RunHistory::NSubruns(), nova::dbi::RunHistory::DiBlock::num, NDAPDHVSetting::plane, rh, and nova::dbi::RunHistory::RunNumber().

Referenced by chaninfo::PedestalThresholdValidation::analyze(), and caf::CAFMaker::produce().

   {
     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 chaninfo::BadChanList::postBeginSubRun ( art::SubRun const & subrun )

Definition at line 111 of file BadChanList_service.cc.

References fAbortIfNoSubrun, fIsBadCacheValid, fMCRunNumber, fMCSubrunNumber, fNBadSR, fSubRun, LOG_DEBUG, nova::dbi::RunHistory::NSubruns(), rh, sr, and art::SubRun::subRun().

Referenced by BadChanList().

   {
     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;
   }

void chaninfo::BadChanList::preBeginEvent ( art::Event const & evt )

Definition at line 158 of file BadChanList_service.cc.

References plot_validation_datamc::c, CountDCMHits(), art::Handle< T >::failedToGet(), fCellHitLabel, chaninfo::FD_NUM_CELLS, chaninfo::FD_NUM_PLANES, fEventCheck, fIsBadCache, fIsBadCacheValid, fRawDigitLabel, geom(), IsBadUncached(), LOG_ERROR, LOG_INFO, geo::PlaneGeo::Ncells(), geo::GeometryBase::NPlanes(), and geo::GeometryBase::Plane().

Referenced by BadChanList().

   {
     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;
     }
   }

void chaninfo::BadChanList::preBeginRun ( art::Run const & run )

Definition at line 81 of file BadChanList_service.cc.

References fAbortOnSmallRunNum, fIsPerfect, fMCRunNumber, fNBadSR, fNeedNewData, fRun, LOG_DEBUG, and art::Run::run().

Referenced by BadChanList().

   {
     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 chaninfo::BadChanList::reconfigure ( fhicl::ParameterSet p )

Definition at line 332 of file BadChanList_service.cc.

References fAbortIfNoneFound, fAbortIfNoSubrun, fAbortOnSmallRunNum, fApplyBadChan, fApplyFEBDropout, fBadChanCSVFile, fCellHitLabel, fEventCheck, fFEBDropoutTag, fKBCList, fMCRunNumber, fMCSubrunNumber, fNewCosmicEffTable, fPedestalThresholdHigh, fPedestalThresholdLow, fRandomBadChannelFraction, fRawDigitLabel, fValidityTagFarDet, fValidityTagNearDet, fVldRunGrouping, fhicl::ParameterSet::get(), LOG_ERROR, and string.

Referenced by BadChanList().

   {
     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 chaninfo::BadChanList::SetRandomBadChannels ( )

private

Definition at line 268 of file BadChanList_service.cc.

References getBrightness::cell, febshutoff_auto::chan, fFlatRand, fLowEfficiency, fRandomBadChannelFraction, fRandomBCMap, geom(), geo::GeometryBase::GetPlanesByView(), LOG_ERROR, geo::PlaneGeo::Ncells(), geo::GeometryBase::Plane(), and NDAPDHVSetting::plane.

Referenced by IsBadUncached().

   {
     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);
         }
       }
     }
   }

Member Data Documentation

bool chaninfo::BadChanList::fAbortIfNoneFound

private

Option to throw an exception if no channel rate state rows are returned from dB.

Definition at line 90 of file BadChanList.h.

Referenced by LoadNewData(), and reconfigure().

bool chaninfo::BadChanList::fAbortIfNoSubrun

private

Definition at line 98 of file BadChanList.h.

Referenced by postBeginSubRun(), and reconfigure().

bool chaninfo::BadChanList::fAbortOnSmallRunNum

private

Definition at line 96 of file BadChanList.h.

Referenced by preBeginRun(), and reconfigure().

int chaninfo::BadChanList::fApplyBadChan

private

Option to activate the bad channels.

Definition at line 79 of file BadChanList.h.

Referenced by IsBadUncached(), IsLowEfficiency(), and reconfigure().

bool chaninfo::BadChanList::fApplyFEBDropout

private

Definition at line 131 of file BadChanList.h.

Referenced by IsBadUncached(), LoadNewData(), and reconfigure().

std::string chaninfo::BadChanList::fBadChanCSVFile

private

Definition at line 103 of file BadChanList.h.

Referenced by IsBadUncached(), LoadNewData(), and reconfigure().

std::vector<std::unordered_set<geo::OfflineChan> > chaninfo::BadChanList::fBadChans

private

Vector index is the subrun number, set contains all the bad channels.

Definition at line 115 of file BadChanList.h.

Referenced by IsBadUncached(), and LoadNewData().

std::string chaninfo::BadChanList::fCellHitLabel

private

Definition at line 108 of file BadChanList.h.

Referenced by preBeginEvent(), and reconfigure().

int chaninfo::BadChanList::fDCMHits[12][14]

private

count hits in each DCM each event to look for dropped DCMs

Definition at line 135 of file BadChanList.h.

Referenced by BadChanList(), CountDCMHits(), and InDroppedDCM().

std::vector<std::unordered_set<int> > chaninfo::BadChanList::fDropOuts

private

[subrun][tchan]

Definition at line 116 of file BadChanList.h.

Referenced by IsBadUncached(), and LoadNewData().

bool chaninfo::BadChanList::fEventCheck

private

do we check each event for dropped DCMs?

Definition at line 105 of file BadChanList.h.

Referenced by InDroppedDCM(), NBadInSubRun(), preBeginEvent(), and reconfigure().

std::string chaninfo::BadChanList::fFEBDropoutTag

private

Definition at line 129 of file BadChanList.h.

Referenced by LoadNewData(), and reconfigure().

std::unique_ptr<CLHEP::RandFlat> chaninfo::BadChanList::fFlatRand

private

Definition at line 133 of file BadChanList.h.

Referenced by BadChanList(), and SetRandomBadChannels().

std::bitset<FD_NUM_PLANES*FD_NUM_CELLS> chaninfo::BadChanList::fIsBadCache

private

Definition at line 145 of file BadChanList.h.

Referenced by BadChanList(), IsBad(), and preBeginEvent().

bool chaninfo::BadChanList::fIsBadCacheValid

private

Definition at line 146 of file BadChanList.h.

Referenced by BadChanList(), postBeginSubRun(), and preBeginEvent().

bool chaninfo::BadChanList::fIsPerfect

private

Definition at line 94 of file BadChanList.h.

Referenced by BadChanList(), IsBadUncached(), LoadNewData(), and preBeginRun().

std::vector<std::string> chaninfo::BadChanList::fKBCList

private

Definition at line 137 of file BadChanList.h.

Referenced by LoadNewData(), and reconfigure().

std::vector<geo::OfflineChan> chaninfo::BadChanList::fKnownBadChannels

private

Definition at line 138 of file BadChanList.h.

Referenced by IsBadUncached(), and LoadNewData().

std::unordered_set<geo::OfflineChan> chaninfo::BadChanList::fLowEfficiency

private

set of low eff channels

Definition at line 100 of file BadChanList.h.

Referenced by IsLowEfficiency(), LoadCosmicEff(), and SetRandomBadChannels().

time_t chaninfo::BadChanList::fMaxVldTime

private

Maximum time used in database request.

Definition at line 123 of file BadChanList.h.

Referenced by IsBadUncached(), and LoadNewData().

int chaninfo::BadChanList::fMCRunNumber

private

Run number for the MC.

Definition at line 80 of file BadChanList.h.

Referenced by BadChanList(), LoadNewData(), postBeginSubRun(), preBeginRun(), and reconfigure().

int chaninfo::BadChanList::fMCSubrunNumber

private

Subrun number for the MC.

Definition at line 81 of file BadChanList.h.

Referenced by BadChanList(), postBeginSubRun(), and reconfigure().

time_t chaninfo::BadChanList::fMinVldTime

private

Minimum time used in database request.

Definition at line 121 of file BadChanList.h.

Referenced by IsBadUncached(), and LoadNewData().

int chaninfo::BadChanList::fNBadSR

private

Definition at line 83 of file BadChanList.h.

Referenced by BadChanList(), NBadInSubRun(), postBeginSubRun(), and preBeginRun().

bool chaninfo::BadChanList::fNeedNewData

private

Definition at line 92 of file BadChanList.h.

Referenced by BadChanList(), IsBadUncached(), LoadNewData(), NBadInSubRun(), and preBeginRun().

bool chaninfo::BadChanList::fNewCosmicEffTable

private

Use new-style table?

Definition at line 110 of file BadChanList.h.

Referenced by LoadCosmicEff(), and reconfigure().

int chaninfo::BadChanList::fPedestalThresholdHigh

private

Definition at line 88 of file BadChanList.h.

Referenced by IsBadUncached(), and reconfigure().

int chaninfo::BadChanList::fPedestalThresholdLow

private

Definition at line 87 of file BadChanList.h.

Referenced by IsBadUncached(), and reconfigure().

float chaninfo::BadChanList::fRandomBadChannelFraction

private

If >0, ignore DB and set this fraction bad at random.

Definition at line 112 of file BadChanList.h.

Referenced by IsBadUncached(), reconfigure(), and SetRandomBadChannels().

std::unordered_set<geo::OfflineChan> chaninfo::BadChanList::fRandomBCMap

private

random bad channel map

Definition at line 101 of file BadChanList.h.

Referenced by BadChanList(), IsBadUncached(), and SetRandomBadChannels().

std::string chaninfo::BadChanList::fRawDigitLabel

private

what is the name of the raw digits ART object

Definition at line 107 of file BadChanList.h.

Referenced by preBeginEvent(), and reconfigure().

int chaninfo::BadChanList::fRun

private

Definition at line 118 of file BadChanList.h.

Referenced by IsBadUncached(), LoadNewData(), NBadInSubRun(), and preBeginRun().

int chaninfo::BadChanList::fSubRun

private

Definition at line 119 of file BadChanList.h.

Referenced by IsBadUncached(), NBadInSubRun(), and postBeginSubRun().

std::string chaninfo::BadChanList::fValidityTagFarDet

private

Definition at line 128 of file BadChanList.h.

Referenced by BadChanList(), LoadNewData(), and reconfigure().

std::string chaninfo::BadChanList::fValidityTagNearDet

private

Definition at line 127 of file BadChanList.h.

Referenced by BadChanList(), LoadNewData(), and reconfigure().

int chaninfo::BadChanList::fVldRunGrouping

private

Definition at line 85 of file BadChanList.h.

Referenced by LoadNewData(), and reconfigure().

The documentation for this class was generated from the following files:

/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-16/ChannelInfo/BadChanList.h
/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-16/ChannelInfo/BadChanList_service.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation