detvar Namespace Reference

Classes
class	RandomChannelStatusProvider
class	RandomChannelStatusService
class	RandomTPC
class	SortChansByZ

Functions
void	ChipAndChannelToSpot (int chip, int chan, geo::View_t &view, int &wire)
template<class T , class It_t >
std::vector< T >	VectorViaSet (It_t begin, It_t end)
std::vector< std::vector< raw::ChannelID_t > >	ChannelsForTPC (const geo::GeometryCore *geom, geo::TPCID tpc)

Function Documentation

std::vector<std::vector<raw::ChannelID_t> > detvar::ChannelsForTPC	(	const geo::GeometryCore *	geom,
		geo::TPCID	tpc
	)

Definition at line 147 of file RandomChannelStatusService_service.cc.

  {
    // No good way of enumerating all the unique channels, or selecting them by
    // index. Have to figure them out from the wires.
    std::set<raw::ChannelID_t> chanset[3];
    for(geo::WireID wire: geom->IterateWireIDs(tpc)){
      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)
        chanset[geom->View(chan)].insert(chan);
    }
    // We'll want to index by channel number within the APAs. Sort spatially as
    // our best guess as to that mapping.
    std::vector<std::vector<raw::ChannelID_t>> chans;
    for(int i = 0; i < 3; ++i){
      chans.emplace_back(chanset[i].begin(), chanset[i].end());
      SortChansByZ scz;
      std::sort(chans.back().begin(), chans.back().end(), scz);
    }
    return chans;
  }

void detvar::ChipAndChannelToSpot	(	int	chip,
		int	chan,
		geo::View_t &	view,
		int &	wire
	)

Definition at line 15 of file RandomChannelStatusService_service.cc.

  {
    // Ultimately this logic should be contained in some ChannelMap service

    assert(chip >= 1 && chip <= 8);
    assert(chan >= 0 && chan <= 15);

    int wireMin = -1; // smallest value in block
    int chipMin = -1, chanMin = -1; // position of smallest value
    int height = -1; // height of block
    int chipSign = 0, chanSign = 0; // which way the numbers count

    if(chip == 1 || chip == 2){
      wireMin = 1; chipMin = 2; chipSign = -1; chanSign = -1;
      /**/ if(chan <= 4){view = geo::kU; chanMin =  4; height = 5;}
      else if(chan <= 9){view = geo::kV; chanMin =  9; height = 5;}
      else/*          */{view = geo::kW; chanMin = 15; height = 6;}
    }

    if(chip == 3 || chip == 4){
      wireMin = 2; chipMin = 4; chipSign = -1; chanSign = +1;
      /**/ if(chan <=  5){view = geo::kW; chanMin =  0; height = 6;}
      else if(chan <= 10){view = geo::kV; chanMin =  6; height = 5;}
      else/*           */{view = geo::kU; chanMin = 11; height = 5;}
    }

    if(chip == 5 || chip == 6){
      chipMin = 5; chipSign = +1; chanSign = -1;
      /**/ if(chan <= 4){view = geo::kU; wireMin = 21; chanMin =  4; height = 5;}
      else if(chan <= 9){view = geo::kV; wireMin = 21; chanMin =  9; height = 5;}
      else/*          */{view = geo::kW; wireMin = 25; chanMin = 15; height = 6;}
    }

    if(chip == 7 || chip == 8){
      chipMin = 7; chipSign = +1; chanSign = +1;
      /**/ if(chan <=  5){view = geo::kW; wireMin = 26; chanMin =  0; height = 6;}
      else if(chan <= 10){view = geo::kV; wireMin = 22; chanMin =  6; height = 5;}
      else/*           */{view = geo::kU; wireMin = 22; chanMin = 11; height = 5;}
    }

    assert(wireMin >= 0 && chipMin >= 0 && chanMin >= 0 && height >= 0 && chipSign != 0 && chanSign != 0);

    // Compute the wire number inside the block
    wire = wireMin+2*((chan-chanMin)*chanSign + (chip-chipMin)*height*chipSign);

    assert(wire >= 1 && wire <= 48);
  }

template<class T , class It_t >

std::vector<T> detvar::VectorViaSet	(	It_t	begin,
		It_t	end
	)

For whatever reason the iterators in Geometry can't be used to initialize a vector directly

Definition at line 65 of file RandomChannelStatusService_service.cc.

  {
    const std::set<T> s(begin, end);
    return std::vector<T>(s.begin(), s.end());
  }