#include <RandomChannelStatusService.h>

Inheritance diagram for detvar::RandomChannelStatusProvider:

Public Member Functions
bool	IsBad (raw::ChannelID_t chan) const override
	Returns whether the specified channel is bad in the current run. More...

bool	IsPresent (raw::ChannelID_t) const override
	Returns whether the specified channel is physical and connected to wire. More...

bool	IsNoisy (raw::ChannelID_t) const override
	Returns whether the specified channel is noisy in the current run. More...

std::set< raw::ChannelID_t >	GoodChannels () const override
	Returns a copy of set of good channel IDs for the current run. More...

std::set< raw::ChannelID_t >	BadChannels () const override
	Returns a copy of set of bad channel IDs for the current run. More...

std::set< raw::ChannelID_t >	NoisyChannels () const override
	Returns a copy of set of noisy channel IDs for the current run. More...

Public Member Functions inherited from lariov::ChannelStatusProvider
	ChannelStatusProvider ()=default
	Default constructor. More...

	ChannelStatusProvider (ChannelStatusProvider const &)=delete

	ChannelStatusProvider (ChannelStatusProvider &&)=delete

ChannelStatusProvider &	operator= (ChannelStatusProvider const &)=delete

ChannelStatusProvider &	operator= (ChannelStatusProvider &&)=delete

virtual	~ChannelStatusProvider ()=default
	Virtual destructor; destructs nothing. More...

virtual bool	IsGood (raw::ChannelID_t channel) const
	Returns whether the specified channel is physical and good. More...

virtual Status_t	Status (raw::ChannelID_t channel) const
	Returns a status integer with arbitrary meaning. More...

virtual bool	HasStatus (raw::ChannelID_t channel) const
	Returns whether the specified status is a valid one. More...

Protected Types
enum	EMode_t { kUnknown, kRandomAPAs, kRandomAPAsides, kRandomBoards, kRandomChips, kRandomChans }

Protected Member Functions
	RandomChannelStatusProvider (const fhicl::ParameterSet &pset)

void	MarkChansBad (unsigned int target)

void	MarkAPAsBad (unsigned int target)

void	MarkAPASidesBad (unsigned int target)

void	MarkBoardsOrChipsBad (EMode_t mode, unsigned int target)

void	MarkBoardBad (int board, const std::vector< std::vector< raw::ChannelID_t >> &chans)

void	MarkChipBad (int board, int chip, const geo::GeometryCore *geom, const std::vector< std::vector< raw::ChannelID_t >> &chans)

Protected Attributes
std::set< raw::ChannelID_t >	fBadChans

std::set< raw::ChannelID_t >	fGoodChans

Friends
class	RandomChannelStatusService

Additional Inherited Members
Public Types inherited from lariov::ChannelStatusProvider
using	Status_t = unsigned short
	type representing channel status More...

using	ChannelSet_t = std::set< raw::ChannelID_t >
	Type of set of channel IDs. More...

Static Public Member Functions inherited from lariov::ChannelStatusProvider
static bool	IsValidStatus (Status_t status)
	Returns whether the specified status is a valid one. More...

Static Public Attributes inherited from lariov::ChannelStatusProvider
static constexpr Status_t	InvalidStatus = std::numeric_limits<Status_t>::max()
	Value or invalid status. More...

Detailed Description

Definition at line 12 of file RandomChannelStatusService.h.

Member Enumeration Documentation

enum detvar::RandomChannelStatusProvider::EMode_t

protected

Enumerator
kUnknown
kRandomAPAs	"APAs"
kRandomAPAsides	"APAsides"
kRandomBoards	"boards"
kRandomChips	"chips"
kRandomChans	"channels"

Definition at line 36 of file RandomChannelStatusService.h.

                 {
       kUnknown,
       kRandomAPAs,     ///< "APAs"
       kRandomAPAsides, ///< "APAsides"
       kRandomBoards,   ///< "boards"
       kRandomChips,    ///< "chips"
       kRandomChans     ///< "channels"
     };

Constructor & Destructor Documentation

detvar::RandomChannelStatusProvider::RandomChannelStatusProvider ( const fhicl::ParameterSet & pset )

protected

Definition at line 174 of file RandomChannelStatusService_service.cc.

   {
     const double badfrac = pset.get<double>("BadChanFrac");
 
     EMode_t mode = kUnknown;
 
     const std::string modestr = pset.get<std::string>("Mode");
     if(modestr == "channels") mode = kRandomChans;
     if(modestr == "APAs")     mode = kRandomAPAs;
     if(modestr == "APAsides") mode = kRandomAPAsides;
     if(modestr == "boards")   mode = kRandomBoards;
     if(modestr == "chips")    mode = kRandomChips;
     if(mode == kUnknown){
       std::cout << "RandomChannelStatusService: unknown mode '"
                 << modestr << "'" << std::endl;
       abort();
     }
 
     art::ServiceHandle<geo::Geometry> geom;
 
     // TODO don't seem to be able to access the RandomNumberGenerator service
     // from here, let alone anything to do with seeds.
     //    const unsigned int seed = pset.get<unsigned int>("Seed", sim::GetRandomNumberSeed());
     //    auto& engine = createEngine(seed);
     //    CLHEP::RandFlat r(engine);
 
     const unsigned int target = badfrac*geom->Nchannels();
 
     switch(mode){
     case kRandomChans:    MarkChansBad(target);    break;
 
     case kRandomAPAs:     MarkAPAsBad(target);     break;
 
     case kRandomAPAsides: MarkAPASidesBad(target); break;
 
     case kRandomBoards:
     case kRandomChips:
       MarkBoardsOrChipsBad(mode, target);
       break;
 
     default:
       abort(); // impossible
     }
 
     // goodchans = allchans - badchans
     std::set<raw::ChannelID_t> allchans;
     for(geo::WireID wire: geom->IterateWireIDs())
       allchans.insert(geom->PlaneWireToChannel(wire));
 
     std::set_difference(allchans.begin(), allchans.end(),
                         fBadChans.begin(), fBadChans.end(),
                         std::inserter(fGoodChans, fGoodChans.begin()));
   }

Member Function Documentation

std::set<raw::ChannelID_t> detvar::RandomChannelStatusProvider::BadChannels ( ) const

inlineoverridevirtual

Returns a copy of set of bad channel IDs for the current run.

Implements lariov::ChannelStatusProvider.

Definition at line 28 of file RandomChannelStatusService.h.

     {
       return fBadChans;
     }

std::set<raw::ChannelID_t> detvar::RandomChannelStatusProvider::GoodChannels ( ) const

inlineoverridevirtual

Returns a copy of set of good channel IDs for the current run.

Implements lariov::ChannelStatusProvider.

Definition at line 23 of file RandomChannelStatusService.h.

     {
       return fGoodChans;
     }

bool detvar::RandomChannelStatusProvider::IsBad ( raw::ChannelID_t channel ) const

inlineoverridevirtual

Returns whether the specified channel is bad in the current run.

Implements lariov::ChannelStatusProvider.

Definition at line 15 of file RandomChannelStatusService.h.

     {
       return fBadChans.count(chan);
     }

bool detvar::RandomChannelStatusProvider::IsNoisy ( raw::ChannelID_t channel ) const

inlineoverridevirtual

Returns whether the specified channel is noisy in the current run.

Implements lariov::ChannelStatusProvider.

Definition at line 21 of file RandomChannelStatusService.h.

21 {return false;}

bool detvar::RandomChannelStatusProvider::IsPresent ( raw::ChannelID_t channel ) const

inlineoverridevirtual

Returns whether the specified channel is physical and connected to wire.

Implements lariov::ChannelStatusProvider.

Definition at line 20 of file RandomChannelStatusService.h.

20 {return true;}

void detvar::RandomChannelStatusProvider::MarkAPAsBad ( unsigned int target )

protected

Definition at line 256 of file RandomChannelStatusService_service.cc.

   {
     art::ServiceHandle<geo::Geometry> geom;
 
     std::map<readout::TPCsetID, std::set<raw::ChannelID_t>> tpcset_to_chans;
     for(const readout::TPCsetID& ts: geom->IterateTPCsetIDs()){
       // There is no version of IterateWireIDs over a TPCset. Use another layer
       // of indirection.
       for(geo::TPCID t: geom->TPCsetToTPCs(ts)){
         for(const geo::WireID& wire: geom->IterateWireIDs(t)){
           const raw::ChannelID_t chan = geom->PlaneWireToChannel(wire);
           tpcset_to_chans[ts].insert(chan);
         }
       }
     }
 
     RandomTPC tpcs(geom.get());
 
     while(fBadChans.size() < target){
       // Mark all the channels in this TPCset (both sides of an APA) bad
       const readout::TPCsetID t = tpcs.GetTPCset();
       for(raw::ChannelID_t chan: tpcset_to_chans[t]){
         fBadChans.insert(chan);
       }
 
       std::cout << "RandomChannelStatusService: Generated "
                 << fBadChans.size() << " bad channels of "
                 << target << " required" << std::endl;
     }
   }

void detvar::RandomChannelStatusProvider::MarkAPASidesBad ( unsigned int target )

protected

Definition at line 288 of file RandomChannelStatusService_service.cc.

   {
     art::ServiceHandle<geo::Geometry> geom;
 
     std::map<geo::TPCID, std::vector<raw::ChannelID_t>> tpc_to_chans;
     for(const geo::TPCID& t: geom->IterateTPCIDs()){
       // Geometry doesn't provide a way to directly iterate the channels in the
       // TPC. Instead iterate the wires and convert to channels
       for(const geo::WireID& wire: geom->IterateWireIDs(t)){
         const raw::ChannelID_t chan = geom->PlaneWireToChannel(wire);
         // But this also gives us wires that are actually attached to the other
         // face and just wrapped onto this face. So long as the order of the
         // vector returned from this function is meaningful, this should work
         // to keep just the ones we need.
         if(geom->ChannelToWire(chan)[0] == wire)
           tpc_to_chans[t].push_back(chan);
       }
     }
 
     RandomTPC tpcs(geom.get());
 
     while(fBadChans.size() < target){
       const geo::TPCID t = tpcs.GetTPC();
 
       // Mark all the channels in this TPC (ie APA side) bad
       for(raw::ChannelID_t chan: tpc_to_chans[t]){
         fBadChans.insert(chan);
       }
 
       std::cout << "RandomChannelStatusService: Generated "
                 << fBadChans.size() << " bad channels of "
                 << target << " required" << std::endl;
     }
   }

void detvar::RandomChannelStatusProvider::MarkBoardBad	(	int	board,
		const std::vector< std::vector< raw::ChannelID_t >> &	chans
	)

protected

Definition at line 358 of file RandomChannelStatusService_service.cc.

   {
     // Check we succesfully got a single side of an APA
     assert(chans[geo::kU].size() == 400);
     assert(chans[geo::kV].size() == 400);
     assert(chans[geo::kW].size() == 480);
 
     for(int i = 0; i < 40; ++i) fBadChans.insert(chans[geo::kU][board*40+i]);
     for(int i = 0; i < 40; ++i) fBadChans.insert(chans[geo::kV][board*40+i]);
     for(int i = 0; i < 48; ++i) fBadChans.insert(chans[geo::kW][board*48+i]);
   }

void detvar::RandomChannelStatusProvider::MarkBoardsOrChipsBad	(	EMode_t	mode,
		unsigned int	target
	)

protected

Definition at line 325 of file RandomChannelStatusService_service.cc.

   {
     art::ServiceHandle<geo::Geometry> geom;
 
     RandomTPC tpcs(geom.get());
 
     // Generate exactly the requested fraction of bad channels (rather than a
     // random sample with that probability). Should make results of studies
     // less noisy.
     while(fBadChans.size() < target){
       const geo::TPCID t = tpcs.GetTPC();
 
       const std::vector<std::vector<raw::ChannelID_t>> chans = ChannelsForTPC(geom.get(), t);
 
       // An APA has 20 boards total, 10 on each side. ie a side has 480 W wires
       // and 400+400 U+V wires.
       const int board = gRandom->Integer(10);
 
       if(mode == kRandomBoards) MarkBoardBad(board, chans);
 
       if(mode == kRandomChips){
         const int chip = 1+gRandom->Integer(8); // One of 8 chips
         MarkChipBad(board, chip, geom.get(), chans);
       }
 
       std::cout << "RandomChannelStatusService: Generated "
                 << fBadChans.size() << " bad channels of "
                 << target << " required" << std::endl;
     }
   }

void detvar::RandomChannelStatusProvider::MarkChansBad ( unsigned int target )

protected

Definition at line 229 of file RandomChannelStatusService_service.cc.

   {
     art::ServiceHandle<geo::Geometry> geom;
 
     // Geometry doesn't have a way to iterate directly over channels. Iterate
     // over the wires and convert them. Use a set to remove duplicates
     std::set<raw::ChannelID_t> allchans;
     for(geo::WireID wire: geom->IterateWireIDs())
       allchans.insert(geom->PlaneWireToChannel(wire));
 
     // But a vector is much easier to pick from randomly. This will be used for
     // the random chans mode.
     const std::vector<raw::ChannelID_t> vchans(allchans.begin(),
                                                allchans.end());
 
     // Generate exactly the requested fraction of bad channels (rather than a
     // random sample with that probability). Should make results of studies
     // less noisy.
     while(fBadChans.size() < target){
       // Insert a random element. There will be duplicates, but the set will
       // filter them out. Shouldn't be too inefficient for the low bad
       // channel fractions we'll use in practice.
       fBadChans.insert(vchans[gRandom->Integer(vchans.size())]);
     } // end while
   }

void detvar::RandomChannelStatusProvider::MarkChipBad	(	int	board,
		int	chip,
		const geo::GeometryCore *	geom,
		const std::vector< std::vector< raw::ChannelID_t >> &	chans
	)

protected

Definition at line 373 of file RandomChannelStatusService_service.cc.

   {
     // Check we succesfully got a single side of an APA
     assert(chans[geo::kU].size() == 400);
     assert(chans[geo::kV].size() == 400);
     assert(chans[geo::kW].size() == 480);
 
     // Knock out all the channels in this chip
     for(int chan = 0; chan <= 15; ++chan){
       geo::View_t view = geo::kUnknown;
       // TODO the table calls this a "spot". We're using it as an index into
       // the sorted list of channel IDs for this view (by Z coordinate). That
       // could be wrong, but the Geometry doesn't seem to have any coresponding
 
       // concept.
       int spot;
       ChipAndChannelToSpot(chip, chan, view, spot);
 
       // How many wires to add on between each board
       const int stride = (view == geo::kW) ? 48 : 40;
 
       assert(spot+board*stride <= int(chans[view].size()));
       fBadChans.insert(chans[view][spot+board*stride-1]);
     } // end for chan
   }