icarus::details::ROPandTPCsetBuildingAlg Class Reference

Extracts TPC sets and readout planes from a list of cryostats. More...

#include <ROPandTPCsetBuildingAlg.h>

Classes
struct	Results_t

Public Types
using	TPCColl_t = icarus::details::TPCColl_t
using	PlaneColl_t = icarus::details::PlaneColl_t
using	ResultsBase_t = std::tuple< std::vector< unsigned int >, readout::TPCsetDataContainer< TPCColl_t >, readout::TPCsetDataContainer< unsigned int >, readout::ROPDataContainer< PlaneColl_t >, geo::TPCDataContainer< readout::TPCsetID >, geo::PlaneDataContainer< readout::ROPID > >
	Full group of results of the algorithm. More...

Public Member Functions
	ROPandTPCsetBuildingAlg ()=default
	Construction: use default configuration. More...
	ROPandTPCsetBuildingAlg (std::string const &logCategory)
	Construction: specify the algorithm configuration. More...
Results_t	run (geo::GeometryData_t::CryostatList_t const &Cryostats)
	Runs the algorithm as configured from start to end. More...
template<typename Pred >
auto	groupPlanesAndTPCs (Pred standalonePlane) -> std::vector< std::vector< PlaneColl_t >>
template<typename PlaneColl >
auto	groupPlanesByDriftCoord (PlaneColl const &planes, double tolerance) -> std::vector< PlaneColl_t >

Private Member Functions
void	clear ()
	Destroys all the result data members. More...
template<typename Pred >
std::vector< std::vector < PlaneColl_t > >	groupPlanesAndTPCs (Pred standalonePlane)
	Extracts composition of all readout planes. More...
std::vector< std::vector < PlaneColl_t > >	groupPlanesAndTPCs ()
	Extracts composition of all readout planes. More...
std::vector< std::vector < std::vector< geo::TPCID > > >	extractTPCsetsFromROPs (std::vector< std::vector< PlaneColl_t >> const &planes)
	Extracts all the TPC sets covered by any of the plane groups. More...
void	fillTPCsInSet (std::vector< std::vector< std::vector< geo::TPCID >>> const &AllTPCsOnROPs)
	Extracts the final set of TPC sets. More...
readout::TPCsetDataContainer < std::vector< PlaneColl_t > >	groupPlanesIntoROPs (std::vector< std::vector< std::vector< geo::TPCID >>> const &AllTPCsOnROPs, std::vector< std::vector< PlaneColl_t >> &&AllPlanesInROPs)
	Assigns each of the readout planes to a TPC set. More...
void	fillPlanesInROP (readout::TPCsetDataContainer< std::vector< PlaneColl_t >> const &PlanesInProtoROPs)
	Builds final readout plane information. More...
void	fillTPCtoTPCsetMap ()
	Creates the map from each TPC to its TPC set. More...
void	fillPlaneToROPmap ()
	Creates the map from each wire plane to its readout plane. More...
std::vector< PlaneColl_t >	sortByNormalCoordinate (std::vector< PlaneColl_t > const &planes) const
	Returns the planes sorted by decreasing normal coordinate. More...
void	checkNormalDirection (std::vector< PlaneColl_t > const &planes) const
	Throws an exception if planes do not share the same normal direction. More...

Static Private Member Functions
template<typename PlaneColl >
static std::vector < std::vector< geo::PlaneGeo const * > >	groupPlanesByDriftCoord (PlaneColl const &planes, double tolerance=0.1)
	Returns the planes grouped by their drift coordinate. More...
static std::vector< geo::TPCID >	extractTPCIDs (std::vector< geo::PlaneGeo const * > const &planes)
	Returns a collection with a TPC ID for each plane in the list of planes. More...
static bool	isROPinTPCset (std::vector< geo::TPCID > const &ROPTPCIDs, std::vector< geo::TPCID > const &TPCsetTPCIDs)
	Returns whether all the TPCs covered by a ROP are in a given TPC set. More...
static readout::ROPID::ROPID_t	ROPnumberFromPlanes (PlaneColl_t const &planes)
	Returns ROP number matching the plane number shared by all planes. More...

Private Attributes
std::string	fLogCategory = "ROPandTPCsetBuildingAlg"
	Category to write messages into. More...
geo::GeometryData_t::CryostatList_t const *	fCryostats = nullptr
unsigned int	fMaxTPCsets = 0U
	Highest number of TPC sets in any cryostat. More...
unsigned int	fMaxROPs = 0U
	Highest number of ROPs in any TPC set. More...
Output
std::vector< unsigned int >	fTPCsetCount
	Output: number of TPC sets in each cryostat. More...
readout::TPCsetDataContainer < TPCColl_t >	fTPCsetTPCs
	Output: TPC's in each TPC set. More...
readout::TPCsetDataContainer < unsigned int >	fROPcount
	Output: number of readout planes in each TPC set. More...
readout::ROPDataContainer < PlaneColl_t >	fROPplanes
	Output: planes in each of the readout plane. More...
geo::TPCDataContainer < readout::TPCsetID >	fTPCtoTPCset
	Output: the TPC set each TPC belongs to. More...
geo::PlaneDataContainer < readout::ROPID >	fPlaneToROP
	Output: the ROP each wire plane belongs to. More...

Detailed Description

Extracts TPC sets and readout planes from a list of cryostats.

This algorithm parses the wire plane and TPC content of the cryostats and groups planes which share the same drift coordinate. Afterwards, it arranges them into LArSoft readout planes, defining at the same time the TPC sets that contain them.

Assignment of readout plane IDs

Readout planes closer to the cathode have lower ID.

Algorithm workflow

An example:

icarus::details::ROPandTPCsetBuildingAlg builder("BuildingAlg");
auto results = builder.run(Cryostats);

// planes in each ROP
readout::ROPDataContainer<icarus::details::PlaneColl_t> ROPplanes
  = std::move(results.ROPplanes());

will run the algorithm on Cryostats and extract one of the results, the map of wire planes in each readout plane. It will use the default configuration of the algorithm, except for the message category being customized into "BuildingAlg".

Configuration

See the constructor documentation.

Definition at line 98 of file ROPandTPCsetBuildingAlg.h.

Member Typedef Documentation

using icarus::details::ROPandTPCsetBuildingAlg::PlaneColl_t = icarus::details::PlaneColl_t

Definition at line 104 of file ROPandTPCsetBuildingAlg.h.

using icarus::details::ROPandTPCsetBuildingAlg::ResultsBase_t = std::tuple< std::vector<unsigned int>, readout::TPCsetDataContainer<TPCColl_t>, readout::TPCsetDataContainer<unsigned int>, readout::ROPDataContainer<PlaneColl_t>, geo::TPCDataContainer<readout::TPCsetID>, geo::PlaneDataContainer<readout::ROPID> >

Full group of results of the algorithm.

Definition at line 115 of file ROPandTPCsetBuildingAlg.h.

using icarus::details::ROPandTPCsetBuildingAlg::TPCColl_t = icarus::details::TPCColl_t

Definition at line 103 of file ROPandTPCsetBuildingAlg.h.

Constructor & Destructor Documentation

icarus::details::ROPandTPCsetBuildingAlg::ROPandTPCsetBuildingAlg ( )

default

Construction: use default configuration.

icarus::details::ROPandTPCsetBuildingAlg::ROPandTPCsetBuildingAlg ( std::string const &  logCategory )

inline

Construction: specify the algorithm configuration.

Parameters

logCategory	message facility category to write messages into
usePlaneIDforROPID	whether to use ROPnumberFromPlanes() algorithm

Configuration

• logCategory (default: "ROPandTPCsetBuildingAlg"): name of the stream destination used for output messages via message facility

Definition at line 165 of file ROPandTPCsetBuildingAlg.h.

    : fLogCategory(logCategory)
    {}

Member Function Documentation

void icarus::details::ROPandTPCsetBuildingAlg::checkNormalDirection ( std::vector< PlaneColl_t > const &  planes ) const

private

Throws an exception if planes do not share the same normal direction.

Definition at line 979 of file ROPandTPCsetBuildingAlg.cxx.

{
  /*
   * Checks the normal direction of each plane in each ROP.
   * Throws an exception when it finds two inconsistent ones.
   */
  if (ROPs.empty()) return;
  
  auto iROP = ROPs.begin();
  assert(!iROP->empty()); // just be there already
  
  auto const& comp = lar::util::makeVector3DComparison(1.0e-4);
  
  geo::PlaneGeo const* const pFirstPlane = iROP->front();
  auto const normDir = pFirstPlane->GetNormalDirection<geo::Vector_t>();
  
  for (PlaneColl_t const& ROP: ROPs) {
    if (ROP.empty()) { // we do not accept this!
      throw cet::exception(fLogCategory)
        << "icarus::details::ROPandTPCsetBuildingAlg::checkNormalDirection(): "
        "ROP must contain planes.\n"
        ;
    }
    for (geo::PlaneGeo const* plane: ROP) {
      if (comp.equal(normDir, plane->GetNormalDirection<geo::Vector_t>()))
        continue;
      
      throw cet::exception(fLogCategory)
        << "icarus::details::ROPandTPCsetBuildingAlg::checkNormalDirection(): "
        " plane " << plane->ID()
        << " has normal " << plane->GetNormalDirection<geo::Vector_t>()
        << ", " << normDir << " (as for " << pFirstPlane->ID()
        << ") expected.\n"
        ;
        
    } // for all planes in ROP
  } // for all ROPs
  
} // icarus::details::ROPandTPCsetBuildingAlg::checkNormalDirection()

void icarus::details::ROPandTPCsetBuildingAlg::clear ( )

private

Destroys all the result data members.

Definition at line 442 of file ROPandTPCsetBuildingAlg.cxx.

                                                 {
  fTPCsetCount.clear();
  fTPCsetTPCs.reset();
  fROPcount.reset();
  fROPplanes.reset();
  fTPCtoTPCset.reset();
  fPlaneToROP.reset();
  fMaxTPCsets = 0U;
  fMaxROPs = 0U;
} // icarus::details::ROPandTPCsetBuildingAlg::clear()

std::vector< geo::TPCID > icarus::details::ROPandTPCsetBuildingAlg::extractTPCIDs ( std::vector< geo::PlaneGeo const * > const &  planes )

staticprivate

Returns a collection with a TPC ID for each plane in the list of planes.

Definition at line 1080 of file ROPandTPCsetBuildingAlg.cxx.

{
  return transformCollection(planes,
    [](geo::PlaneGeo const* plane){ return plane->ID().asTPCID(); }
    );
} // icarus::details::ROPandTPCsetBuildingAlg::extractTPCIDs()

std::vector< std::vector< std::vector< geo::TPCID > > > icarus::details::ROPandTPCsetBuildingAlg::extractTPCsetsFromROPs ( std::vector< std::vector< PlaneColl_t >> const &  planes )

private

Extracts all the TPC sets covered by any of the plane groups.

Parameters

groupedPlanes

wire planes, grouped by cryostat.

Returns

TPC sets as sets of TPC IDs

The return value is a container that for each cryostat (first index), hosts a list of TPC sets (second index: TPC set within the cryostat), each listing its TPC (third index: runs through all TPCs). The order of the TPC sets within a cryostat is undefined. This function also fills fMaxTPCsets.

The input parameter groupedPlanes follows the same structure as the argument AllTPCsOnROPs of groupPlanesIntoROPs().

Definition at line 553 of file ROPandTPCsetBuildingAlg.cxx.

{
  
  // output: for each cryostat (first index),
  // a list of TPC sets (second index: TPC set within the cryostat)
  // each listing its TPC (third index: runs through all TPCs):
  std::vector<std::vector<std::vector<geo::TPCID>>> AllTPCsOnROPs;
  
  //
  // output
  //
  unsigned int& MaxTPCsets = fMaxTPCsets;
  
  MaxTPCsets = 0U;
  
  // extract the information one cryostat at a time
  for (std::vector<PlaneColl_t> const& planeGroupsInCryostat: groupedPlanes) {
    
    //
    // for each readout plane, collect the set of TPCs that contain its planes;
    // keep them as IDs since they are easier to procure.
    // Should these be sorted?
    // (yes) because the set is the same regardless the order of TPCs => set
    // (no) because we want to preserve the original order => vector
    //
    std::vector<std::vector<geo::TPCID>> TPCsOnROPs
      = transformCollection(planeGroupsInCryostat, extractTPCIDs);
    
    // reduce the duplicate TPC sets and merge overlapping sets
//     auto const iUniqueTPCend = std::unique(TPCsOnROPs.begin(), TPCsOnROPs.end());
//     TPCsOnROPs.erase(iUniqueTPCend, TPCsOnROPs.end());
    
    TPCsOnROPs = icarus::details::stableMerge(TPCsOnROPs);
    
    //
    // save the results of the cryostat to detector-level data collection
    //
    MaxTPCsets
      = std::max(MaxTPCsets, static_cast<unsigned int>(TPCsOnROPs.size()));
    AllTPCsOnROPs.push_back(std::move(TPCsOnROPs));
    
  } // for cryostats
  mf::LogTrace("ICARUSChannelMapAlg")
    << "The maximum number of TPC sets in any cryostat is " << MaxTPCsets;
  
  return AllTPCsOnROPs;
  
} // icarus::details::ROPandTPCsetBuildingAlg::extractTPCsetsFromROPs()

void icarus::details::ROPandTPCsetBuildingAlg::fillPlanesInROP ( readout::TPCsetDataContainer< std::vector< PlaneColl_t >> const &  PlanesInProtoROPs )

private

Builds final readout plane information.

Parameters

PlanesInProtoROPs

plane-to-ROP assignments in each TPC set

This function fills fROPcount and fROPplanes.

It requires fMaxROPs, fTPCsetTPCs and fTPCsetCount to have been computed already.

Definition at line 757 of file ROPandTPCsetBuildingAlg.cxx.

  {
  //
  // sort out the readout plane assignments into the final sets
  // (deliver G3 and G4: see `buildReadoutPlanes()`)
  //
  
  assert(!fTPCsetTPCs.empty());
  assert(!fTPCsetCount.empty());
  assert(fMaxROPs > 0U);
  
  //
  // prepare the input
  //
  auto const& TPCsetTPCs = fTPCsetTPCs;
  auto const& TPCsetCount = fTPCsetCount;
  
  //
  // prepare the output
  //
  // this is the actual number of readout planes in each TPC set: goal (G3)
  fROPcount.resize(TPCsetTPCs.dimSize<0U>(), TPCsetTPCs.dimSize<1U>(), 0U);
  fROPplanes.resize
    (TPCsetTPCs.dimSize<0U>(), TPCsetTPCs.dimSize<1U>(), fMaxROPs); // goal (G4)
  
  auto& ROPcount = fROPcount;
  auto& ROPplanes = fROPplanes;
  
  // assign the preferred numbers according to the first TPC set;
  // before that, sort the planes in that TPC set by local drift coordinate
  // (possibly different from the one used for the clustering by the verse)
  std::vector<PlaneColl_t> const sortedTPCset0
    = sortByNormalCoordinate(PlanesInProtoROPs[{ 0, 0 }]);
  
  icarus::details::ROPnumberDispatcher ROPIDdispatcher
    { sortedTPCset0, fLogCategory };
  
  // (double) loop through all TPC sets:
  for (auto [ c, nTPCsets ]: util::enumerate(TPCsetCount)) {
    readout::CryostatID const cryoid
      { static_cast<readout::CryostatID::CryostatID_t>(c) };
    for (readout::TPCsetID::TPCsetID_t s = 0; s < nTPCsets; ++s) {
      readout::TPCsetID const tpcsetid { cryoid, s };
      
      // all the ROPs in this TPC set, with their wire plane content:
      std::vector<PlaneColl_t> const& ROPs = PlanesInProtoROPs[tpcsetid];
      
      ROPcount[tpcsetid] = ROPs.size();
      
      ROPIDdispatcher.setTPCset(tpcsetid);
      
      for (PlaneColl_t const& planes: ROPs) {
        
        readout::ROPID ropid = ROPIDdispatcher.assignID(planes);
        {
          mf::LogTrace log(fLogCategory);
          log << "Readout plane " << ropid << " assigned with " << planes.size()
            << " planes:";
          for (geo::PlaneGeo const* plane: planes)
            log << " (" << plane->ID() << ")";
        }
        if (!ROPplanes[ropid].empty()) {
          //
          // If this happens, it may be that the geometry is not compatible
          // with the algorithm, or just a bug.
          // Enabling the debug stream will show which planes are assigned
          // each time, including the two conflicting assignments.
          //
          throw cet::exception(fLogCategory)
            << "Logic error: ROPID " << ropid
            << " has already been assigned!\n";
        }
        ROPplanes[ropid] = std::move(planes);
        
      } // for all ROPs in the TPC set
    } // for all TPC sets in cryostat
  } // for all cryostats
  
} // icarus::details::ROPandTPCsetBuildingAlg::fillPlanesInROP()

void icarus::details::ROPandTPCsetBuildingAlg::fillPlaneToROPmap ( )

private

Creates the map from each wire plane to its readout plane.

This function fills fPlaneToROP.

It requires fCryostats and fROPplanes to have been computed already.

Definition at line 890 of file ROPandTPCsetBuildingAlg.cxx.

                                                             {
  
  //
  // invert the TPC sets map content
  //
  
  assert(!fCryostats->empty());
  assert(!fROPplanes.empty());
  
  //
  // prepare the input
  //
  auto const& Cryostats = *fCryostats;
  auto const& ROPplanes = fROPplanes;
  
  //
  // output
  //
  auto const [ NCryostats, MaxTPCs, MaxPlanes ]
    = geo::details::extractMaxGeometryElements<3U>(Cryostats);

  MF_LOG_TRACE(fLogCategory)
    << "Detected " << NCryostats << " cryostats."
    << "\nDetected at most " << MaxTPCs << " TPCs per cryostat."
    << "\nDetected at most " << MaxPlanes << " planes per TPC."
    ;
  fPlaneToROP.resize(NCryostats, MaxTPCs, MaxPlanes, {});
  
  for (auto c
    : util::counter<geo::CryostatID::CryostatID_t>(ROPplanes.dimSize<0>())
    )
  {
    geo::CryostatID const cid { c };
    for (auto s: util::counter<readout::TPCsetID::TPCsetID_t>(ROPplanes.dimSize<1>()))
    {
      readout::TPCsetID const sid { cid, s };
      for (auto r: util::counter<readout::ROPID::ROPID_t>(ROPplanes.dimSize<2>()))
      {
        readout::ROPID const rid { sid, r };
      
        for (geo::PlaneGeo const* plane: ROPplanes[rid]) {
          assert(plane && plane->ID());
          fPlaneToROP[plane->ID()] = rid;
          MF_LOG_TRACE(fLogCategory) << plane->ID() << " => " << rid;
        } // for planes in readout plane
      
      } // for readout planes in TPC set
      
    } // for TPC sets in cryostat
    
  } // for cryostats
  
} // icarus::details::ROPandTPCsetBuildingAlg::fillPlaneToROPmap()

void icarus::details::ROPandTPCsetBuildingAlg::fillTPCsInSet ( std::vector< std::vector< std::vector< geo::TPCID >>> const &  AllTPCsOnROPs )

private

Extracts the final set of TPC sets.

Parameters

AllTPCsOnROPs

groups of TPC IDs planes in a readout planes belong to

The function collects sets of TPCs from all the ROP's. It fills fTPCsetCount and fTPCsetTPCs. It requires fMaxTPCsets to have been already set. The input argument AllTPCsOnROPs is a vector with index the number of cryostat. For each cryostat, a list of readout planes is presented (unsorted and unlabelled), in each of which the list of TPCs the planes in the readout planes belong to is stored.

Definition at line 605 of file ROPandTPCsetBuildingAlg.cxx.

{
  /*
   * extract the final set of TPC sets by collecting sets of TPCs
   * from all the ROP's
   * (deliver G1 and G2)
   */
  
  //
  // input check
  //
  assert(fCryostats);
  geo::GeometryData_t::CryostatList_t const& Cryostats = *fCryostats;
  
  unsigned int const MaxTPCsets = fMaxTPCsets;
  
  //
  // output
  //
  // actual size of each TPC set: goal (G1)
  fTPCsetCount.clear();
  fTPCsetCount.resize(AllTPCsOnROPs.size(), 0U);
  std::vector<unsigned int>& TPCsetCount = fTPCsetCount;
  
  fTPCsetTPCs.resize(AllTPCsOnROPs.size(), MaxTPCsets); // goal (G2)
  readout::TPCsetDataContainer<std::vector<geo::TPCGeo const*>>& TPCsetTPCs
    = fTPCsetTPCs;
  
  //
  // algorithm
  //
  for (auto&& [ c, TPCsets ]: util::enumerate(AllTPCsOnROPs)) {
    geo::CryostatGeo const& cryo = Cryostats[c];
    TPCsetCount[c] = TPCsets.size();
    mf::LogTrace("ICARUSChannelMapAlg")
      << "Cryostat " << cryo.ID() << " has " << TPCsetCount[c] << " TPC sets";
    for (auto&& [ s, TPCIDs ]: util::enumerate(TPCsets)) {
      
      // convert the IDs into pointers to the TPC objects
      readout::TPCsetID const tpcsetid
        { cryo.ID(), static_cast<readout::TPCsetID::TPCsetID_t>(s) };
      TPCsetTPCs[tpcsetid] = transformCollection(
        TPCIDs, [&cryo](geo::TPCID const& tpcid){ return &(cryo.TPC(tpcid)); }
        );
      
      { // local block for debug output
        auto const& TPCs = TPCsetTPCs[tpcsetid];
        mf::LogTrace log("ICARUSChannelMapAlg");
        log << tpcsetid << " has " << TPCs.size() << " TPCs:";
        for (geo::TPCGeo const* tpc: TPCs) log << " " << tpc->ID() << ";";
      } // local block for debug output
      
    } // for TPC sets
  } // for cryostats
} // icarus::details::ROPandTPCsetBuildingAlg::fillTPCsInSet()

void icarus::details::ROPandTPCsetBuildingAlg::fillTPCtoTPCsetMap ( )

private

Creates the map from each TPC to its TPC set.

This function fills fTPCtoTPCset.

It requires fCryostats and fTPCsetTPCs to have been computed already.

Definition at line 840 of file ROPandTPCsetBuildingAlg.cxx.

                                                              {
  
  //
  // invert the TPC sets map content
  //
  
  assert(!fCryostats->empty());
  assert(!fTPCsetTPCs.empty());
  
  //
  // prepare the input
  //
  auto const& Cryostats = *fCryostats;
  auto const& TPCsetTPCs = fTPCsetTPCs;
  
  //
  // output
  //
  auto const [ NCryostats, MaxTPCs ]
    = geo::details::extractMaxGeometryElements<2U>(Cryostats);

  MF_LOG_TRACE(fLogCategory)
    << "Detected " << NCryostats << " cryostats."
    << "\nDetected at most " << MaxTPCs << " TPCs per cryostat."
    ;
  fTPCtoTPCset.resize(NCryostats, MaxTPCs, {});
  
  for (auto c
    : util::counter<geo::CryostatID::CryostatID_t>(TPCsetTPCs.dimSize<0>())
    )
  {
    geo::CryostatID const cid { c };
    for (auto s: util::counter<readout::TPCsetID::TPCsetID_t>(TPCsetTPCs.dimSize<1>()))
    {
      readout::TPCsetID const sid { cid, s };
      
      for (geo::TPCGeo const* TPC: TPCsetTPCs[sid]) {
        assert(TPC && TPC->ID());
        fTPCtoTPCset[TPC->ID()] = sid;
        MF_LOG_TRACE(fLogCategory) << TPC->ID() << " => " << sid;
      } // for TPCs in TPC set
      
    } // for TPC sets in cryostat
    
  } // for cryostats
  
} // icarus::details::ROPandTPCsetBuildingAlg::fillTPCtoTPCsetMap()

template<typename Pred >

std::vector<std::vector<PlaneColl_t> > icarus::details::ROPandTPCsetBuildingAlg::groupPlanesAndTPCs ( Pred  standalonePlane )

private

Extracts composition of all readout planes.

Template Parameters

Pred	type of the predicate pred with one geo::PlaneGeo argument

Parameters

standalonePlane

predicate to determine if a plane is stand-alone

Returns

readout plane composition

This function returns a list: for each cryostat (first index), a list of TPC sets (second index: TPC set within the cryostat) each listing its TPC (third index: runs through all TPCs).

If standalonePlane is specified, it is a functor that returns whether its argument, a geo::PlaneGeo object, should not be grouped at all (i.e., standalonePlane(plane) returns false if the plane can be grouped to others). Each plane for which standalonePlane evaluates true has their own "group" of one plane.

auto icarus::details::ROPandTPCsetBuildingAlg::groupPlanesAndTPCs ( )

private

Extracts composition of all readout planes.

Returns

readout plane composition

This function returns a list: for each cryostat (first index), a list of TPC sets (second index: TPC set within the cryostat) each listing its TPC (third index: runs through all TPCs).

Definition at line 545 of file ROPandTPCsetBuildingAlg.cxx.

{ return groupPlanesAndTPCs([](geo::PlaneGeo const&){ return false; }); }

template<typename Pred >

auto icarus::details::ROPandTPCsetBuildingAlg::groupPlanesAndTPCs

(

Pred

standalonePlane

)

-> std::vector<std::vector<PlaneColl_t>>

Definition at line 457 of file ROPandTPCsetBuildingAlg.cxx.

{
  /*
   * extract the composition of all the readout planes
   * and the TPCs each of them spans
   */
  
  //
  // input check
  //
  assert(fCryostats);
  geo::GeometryData_t::CryostatList_t const& Cryostats = *fCryostats;
  
  //
  // output
  //
  
  // for each cryostat (first index),
  // a list of readout plane candidates
  //   (second index: readout plane within the cryostat)
  // each listing its wire planes (third index: runs through all wire planes):
  std::vector<std::vector<PlaneColl_t>> AllPlanesInROPs;
  
  // debug
  auto logPlanes = [this](PlaneColl_t const& planes)
    {
      mf::LogTrace log(fLogCategory);
      log << "New group of " << planes.size() << " planes:";
      for (geo::PlaneGeo const* plane: planes)
        log << " <" << plane->ID() << ">";
    };
  
  //
  // the algorithm
  //
  // extract the information one cryostat at a time
  for (geo::CryostatGeo const& cryo: Cryostats) {
    
    //
    // connect all wire planes with the same drift direction to build
    // readout plane sets
    //
    std::vector<geo::PlaneGeo const*> planes;
    for (geo::TPCGeo const& tpc: cryo.IterateTPCs()) {
      for (geo::PlaneGeo const& plane: tpc.IteratePlanes()) {
        planes.push_back(&plane);
      } // for planes
    } // for TPCs
    
    std::vector<PlaneColl_t> protoGroups = groupPlanesByDriftCoord(planes);
    
    //
    // Are all the planes in the groups expected to be grouped?
    // if not, add them as their own group before the group.
    // We could have filtered out the planes not to be grouped before grouping,
    // which makes a lot of sense but complicates the sorting afterwards.
    //
    std::vector<PlaneColl_t> groupedPlanes;
    for (PlaneColl_t const& protoGroup: protoGroups) {
      if (protoGroup.empty()) continue;
      PlaneColl_t group;
      for (geo::PlaneGeo const* plane: protoGroup) {
        if (standalonePlane(*plane)) {
          groupedPlanes.push_back({ plane });
          logPlanes(groupedPlanes.back());
        }
        else group.push_back(plane);
      }
      if (!group.empty()) {
        groupedPlanes.push_back(std::move(group));
        logPlanes(groupedPlanes.back());
      }
    } // for protogroups
    
    //
    // save the results of the cryostat to detector-level data collection
    //
    AllPlanesInROPs.push_back(std::move(groupedPlanes));
    
  } // for cryostats
  
  return AllPlanesInROPs;
  
} // icarus::details::ROPandTPCsetBuildingAlg::groupPlanesAndTPCs()

template<typename PlaneColl >

static std::vector<std::vector<geo::PlaneGeo const*> > icarus::details::ROPandTPCsetBuildingAlg::groupPlanesByDriftCoord ( PlaneColl const &  planes, double  tolerance = 0.1  )

staticprivate

Returns the planes grouped by their drift coordinate.

Template Parameters

PlaneColl

a geo::PlaneGeo collection (forward-iterable)

Parameters

planes	collection of the wire planes to be grouped
tolerance	maximum distance in drift for planes in a single group

Returns

a collection of groups of (pointers to) planes

The planes in the input collection are split into groups which share the same drift coordinate. The tolerance parameter defines how different that coordinate can be for planes to be grouped together. The result is expressed as a collection of collections of planes: each element of the outer collection is a group of constant pointers to geo::PlaneGeo objects representing all the planes with the same drift coordinate. The sorting algorithm is guaranteed to be stable, i.e. if any two planes A and B have the same drift coordinate and in the planes collection A is before B, in the resulting group A will also be before B.

In the current ICARUS geometry description the drift direction is on x axis, and x is the drift coordinate.

template<typename PlaneColl >

auto icarus::details::ROPandTPCsetBuildingAlg::groupPlanesByDriftCoord	(	PlaneColl const &	planes,
		double	tolerance
	)		-> std::vector<PlaneColl_t>

Definition at line 1023 of file ROPandTPCsetBuildingAlg.cxx.

{
  std::map<double, PlaneColl_t> groupedByDrift;
  
  geo::Vector_t const driftDir = geo::Xaxis();
  
  /*
   * we can't std::sort by drift coordinate because that would break the
   * stability of the sorting (we are guaranteeing that if plane _A_, drift
   * coordinate _x_, is before plane _B_, drift coordinate _x - epsilon_,
   * and _epsilon_ is smaller than `tolerance`, then in the group plane _A_
   * should still be of plane _B_.
   */
  for (geo::PlaneGeo const* plane: planes) {
    
    double const planeD = plane->GetCenter<geo::Point_t>().Dot(driftDir);
    // find the group before the plane
    
    auto iGroup = groupedByDrift.lower_bound(planeD);
    
    //
    // if the group we found is compatible with the plane, we add it in;
    // the key is the upper limit of the group coordinate range
    //
    if ((iGroup != groupedByDrift.end())
      && (iGroup->first - planeD <= tolerance))
    {
      iGroup->second.push_back(plane);
      continue;
    }
    //
    // the plane has a drift coordinate too small to join the group we found;
    // or we did not find any; so we create a new group centered on this plane;
    // the key is the right end of the allowed range, to simplify both search
    // and check
    //
    groupedByDrift.emplace_hint
      (iGroup, planeD + tolerance / 2.0, PlaneColl_t({ plane }));
    
  } // for
  
  //
  // moving the groups into the result structure; they'll be sorted by
  // increasing nominal drift coordinate
  //
  std::vector<PlaneColl_t> groups;
  groups.reserve(groupedByDrift.size());
  for (auto&& group: groupedByDrift)
    groups.push_back(std::move(std::get<1U>(group)));
  return groups;
  
} // icarus::details::ROPandTPCsetBuildingAlg::groupPlanesByDriftCoord()

auto icarus::details::ROPandTPCsetBuildingAlg::groupPlanesIntoROPs ( std::vector< std::vector< std::vector< geo::TPCID >>> const &  AllTPCsOnROPs, std::vector< std::vector< PlaneColl_t >> &&  AllPlanesInROPs  )

private

Assigns each of the readout planes to a TPC set.

Parameters

AllTPCsOnROPs	groups of TPC IDs planes in a readout planes belong to
AllPlanesInROPs	planes grouped by ROP

Returns

a map of readout planes in each TPC set, each with plane content

This function fills MaxROPs. In addition, it returns the list by TPC set of the groups of sensitive planes into each readout plane in the set. It requires fTPCsetTPCs to have been computed already.

The input argument AllTPCsOnROPs is a vector with index the number of cryostat. For each cryostat, a list of readout planes is presented (unsorted and unlabelled), in each of which the list of TPCs the planes in the readout planes belong to is stored.

Definition at line 663 of file ROPandTPCsetBuildingAlg.cxx.

{
  /*
   * assigns each of the readout planes to a TPC set
   */
  
  //
  // input check
  //
  assert(fCryostats);
  geo::GeometryData_t::CryostatList_t const& Cryostats = *fCryostats;
  
  assert(!fTPCsetTPCs.empty());
  readout::TPCsetDataContainer<TPCColl_t> const& TPCsetTPCs = fTPCsetTPCs;
  
  //
  // output
  //
  readout::TPCsetDataContainer<std::vector<PlaneColl_t>> PlanesInProtoROPs
    (TPCsetTPCs.dimSize<0U>(), TPCsetTPCs.dimSize<1U>());
  unsigned int& MaxROPs = fMaxROPs;
  
  
  unsigned int nErrors = 0U; // count errors, then bail out at the end
  // we still don't know the maximum number of ROPs in a TPC set
  MaxROPs = 0U;
  for (auto&& [ c, ROPs ]: util::enumerate(AllPlanesInROPs)) {
    // find which TPC set number each ROP belongs to;
    // brute force approach: check the content of each TPC set until we find
    // one that matched; then we are happy.
    // We assume that each ROP has one plane from *each* of the TPC's in a set.
    geo::CryostatGeo const& cryo = Cryostats[c];
    std::vector<std::vector<geo::TPCID>> const& TPCsets = AllTPCsOnROPs[c];
    for (std::vector<geo::PlaneGeo const*>& ROPplanes: ROPs) {
      std::vector<geo::TPCID> const ROPTPCIDs = extractTPCIDs(ROPplanes);
      
      // find the TPC set
      readout::TPCsetID tpcsetid; // destination set, invalid by default
      for (auto&& [ s, TPCset ]: util::enumerate(TPCsets)) {
        // here is where we assume the ROP has one plane per TOC in the TPC set;
        // we are also gambling that the order is the same
        if (!isROPinTPCset(ROPTPCIDs, TPCset)) continue;
        tpcsetid = { cryo.ID(), static_cast<readout::TPCsetID::TPCsetID_t>(s) };
        break;
      } // for all sets
      
      if (!tpcsetid) { // long error message to help debugging
        mf::LogError log(fLogCategory);
        log << "Candidate ROP did not match any TPC set.";
        log << "\nROP planes:";
        for (geo::PlaneGeo const* plane: ROPplanes)
          log << " (" << plane->ID() << ")";
        log << "\nAvailable TPC sets (" << TPCsets.size() << "):";
        for (auto&& [ s, TPCset ]: util::enumerate(TPCsets)) {
          readout::TPCsetID const tpcsetid
            { cryo.ID(), static_cast<readout::TPCsetID::TPCsetID_t>(s) };
          log << "\n - " << tpcsetid << ", " << TPCset.size() << " TPC's:";
          for (geo::TPCID const& tpcid: TPCset) log << " (" << tpcid << ")";
        } // for TPC sets
        ++nErrors;
        continue;
      } // if no TPC set matched
      
      // we have found the (first) TPC set matching the set of TPCs in ROP;
      // we store (move) the information into the proper cell
      auto& TPCsetROPs = PlanesInProtoROPs[tpcsetid];
      TPCsetROPs.push_back(std::move(ROPplanes));
      MaxROPs = std::max(MaxROPs, static_cast<unsigned int>(TPCsetROPs.size()));
      
    } // for TPC sets
  } // for cryostats
  
  AllPlanesInROPs.clear(); // we have already depleted it anyway
  
  if (nErrors > 0) {
    throw cet::exception(fLogCategory)
      << "Encountered " << nErrors
      << " errors while assigning TPC sets to ROPs (see error messages above)\n"
      ;
  } // if errors
  
  mf::LogTrace(fLogCategory)
    << "The maximum number of readout planes in any TPC set is " << MaxROPs;
  
  return PlanesInProtoROPs;
  
} // icarus::details::ROPandTPCsetBuildingAlg::groupPlanesIntoROPs()

bool icarus::details::ROPandTPCsetBuildingAlg::isROPinTPCset ( std::vector< geo::TPCID > const &  ROPTPCIDs, std::vector< geo::TPCID > const &  TPCsetTPCIDs  )

staticprivate

Returns whether all the TPCs covered by a ROP are in a given TPC set.

Definition at line 1111 of file ROPandTPCsetBuildingAlg.cxx.

  {
  
  for (geo::TPCID const& ROPTPC: ROPTPCIDs) {
    bool found = false;
    for (geo::TPCID const& TPC: TPCsetTPCIDs) {
      if (TPC != ROPTPC) continue;
      found = true;
      break;
    } // for all TPCs in set
    if (found) continue;
    return false;
  } // for all TPCs in ROP
  return true;
} // icarus::details::ROPandTPCsetBuildingAlg::isROPinTPCset()

readout::ROPID::ROPID_t icarus::details::ROPandTPCsetBuildingAlg::ROPnumberFromPlanes ( PlaneColl_t const &  planes )

staticprivate

Returns ROP number matching the plane number shared by all planes.

Returns

a ROP number, or readout::ROPID::getInvalidID() on failure

The algorithms verifies that all elements in planes have an ID() with the same plane number (geo::PlaneID::Plane), and returns it. If the plane list is empty or if not all planes in the list have the same plane number, readout::ROPID::getInvalidID() is returned.

Definition at line 1091 of file ROPandTPCsetBuildingAlg.cxx.

{
  readout::ROPID::ROPID_t r = readout::ROPID::getInvalidID();
  for (geo::PlaneGeo const* plane: planes) {
    if (!plane) continue;
    
    auto const fromPlane
      = static_cast<readout::ROPID::ROPID_t>(plane->ID().Plane);
    
    if (r == readout::ROPID::getInvalidID())
      r = fromPlane;
    else if (r != fromPlane)
      return readout::ROPID::getInvalidID();
    
  } // for
  return r;
} // icarus::details::ROPandTPCsetBuildingAlg::ROPnumberFromPlanes()

auto icarus::details::ROPandTPCsetBuildingAlg::run

(

geo::GeometryData_t::CryostatList_t const &

Cryostats

)

Runs the algorithm as configured from start to end.

Returns

the results of the algorithm

Results are in the form of a tuple that can be used to construct variables with structured binding declarations, or saved to extract the results one by one (see Results_t for the interface).

Definition at line 353 of file ROPandTPCsetBuildingAlg.cxx.

{
  /*
   *  The goals:
   *  (G1) number of actual TPC sets per cryostat
   *  (G2) composition in TPC's of each TPC set
   *  (G3) number of actual ROP's in each TPC set
   *  (G4) composition in readout planes of each ROP
   *
   *  The plan:
   *  
   *  1. extract the composition of all the readout planes
   *     and the TPCs each of them spans
   *  2. extract the final set of TPC sets by collecting sets of TPCs
   *     from all the ROP's
   *  3. assign each of the readout planes to a TPC set
   *  4. sort out the readout plane assignments into the final sets
   */
  
  //
  // input and setup
  //
  mf::LogDebug(fLogCategory)
    << "Building TPC sets and readout planes from " << Cryostats.size()
    << " cryostats";
  
  fCryostats = &Cryostats;
  
  //
  // output
  //
  clear();
  
  //
  // 1. extract the composition of all the readout planes
  //    and the TPCs they span
  //
  auto standaloneHorizontalWires = [](geo::PlaneGeo const& plane)
    { return std::abs(plane.ThetaZ()) < 1e-3; };
  
  std::vector<std::vector<PlaneColl_t>> AllPlanesInROPs
    = groupPlanesAndTPCs(standaloneHorizontalWires);
  
  std::vector<std::vector<std::vector<geo::TPCID>>> const AllTPCsInTPCsets
    = extractTPCsetsFromROPs(AllPlanesInROPs);
  
  //
  // 2. extract the final set of TPC sets by collecting sets of TPCs
  //    from all the ROP's
  //
  fillTPCsInSet(AllTPCsInTPCsets);
  
  //
  // 3. assign each of the readout planes to a TPC set
  //
  readout::TPCsetDataContainer<std::vector<PlaneColl_t>> const PlanesInProtoROPs
    = groupPlanesIntoROPs(AllTPCsInTPCsets, std::move(AllPlanesInROPs));
  
  //
  // 4. sort out the readout plane assignments into the final sets
  //
  fillPlanesInROP(PlanesInProtoROPs);
  
  //
  // 5. invert the maps
  //
  fillTPCtoTPCsetMap();
  fillPlaneToROPmap();
  
  //
  // output
  //
  assert(!fTPCsetCount.empty());
  assert(!fTPCsetTPCs .empty());
  assert(!fROPcount   .empty());
  assert(!fTPCtoTPCset.empty());
  assert(!fPlaneToROP .empty());
  return ResultsBase_t{
    std::move(fTPCsetCount),
    std::move(fTPCsetTPCs ),
    std::move(fROPcount   ),
    std::move(fROPplanes  ),
    std::move(fTPCtoTPCset),
    std::move(fPlaneToROP )
    };
} // icarus::details::ROPandTPCsetBuildingAlg::run()

auto icarus::details::ROPandTPCsetBuildingAlg::sortByNormalCoordinate ( std::vector< PlaneColl_t > const &  planes ) const

private

Returns the planes sorted by decreasing normal coordinate.

Definition at line 947 of file ROPandTPCsetBuildingAlg.cxx.

{
  /*
   * The `ROPs` are sorted in order of decreasing normal plane coordinate.
   * 
   * 1. consistency of normal direction is first verified
   * 2. the ROPs are sorted so that the center of the first sorted plane,
   *    projected on the normal direction of a reference plane, is the largest
   *    (plane closest to the cathode); sorting is stable.
   * 
   */
  assert(!ROPs.empty()); // don't waste our time!
  
  checkNormalDirection(ROPs); // throws on error
  
  geo::PlaneGeo const* const pRefPlane = ROPs.front().front();
  auto sortedROPs { ROPs };
  std::stable_sort(sortedROPs.begin(), sortedROPs.end(),
    [pRefPlane](PlaneColl_t const& A, PlaneColl_t const& B) -> bool
    {
      return
        pRefPlane->DistanceFromPlane(A.front()->GetCenter<geo::Point_t>())
        > pRefPlane->DistanceFromPlane(B.front()->GetCenter<geo::Point_t>());
    }
    );
  
  return sortedROPs;
} // icarus::details::ROPandTPCsetBuildingAlg::sortByNormalCoordinate()

Member Data Documentation

geo::GeometryData_t::CryostatList_t const* icarus::details::ROPandTPCsetBuildingAlg::fCryostats = nullptr

private

Definition at line 192 of file ROPandTPCsetBuildingAlg.h.

std::string icarus::details::ROPandTPCsetBuildingAlg::fLogCategory = "ROPandTPCsetBuildingAlg"

private

Category to write messages into.

Definition at line 187 of file ROPandTPCsetBuildingAlg.h.

unsigned int icarus::details::ROPandTPCsetBuildingAlg::fMaxROPs = 0U

private

Highest number of ROPs in any TPC set.

Definition at line 223 of file ROPandTPCsetBuildingAlg.h.

unsigned int icarus::details::ROPandTPCsetBuildingAlg::fMaxTPCsets = 0U

private

Highest number of TPC sets in any cryostat.

Definition at line 220 of file ROPandTPCsetBuildingAlg.h.

geo::PlaneDataContainer<readout::ROPID> icarus::details::ROPandTPCsetBuildingAlg::fPlaneToROP

private

Output: the ROP each wire plane belongs to.

Definition at line 214 of file ROPandTPCsetBuildingAlg.h.

readout::TPCsetDataContainer<unsigned int> icarus::details::ROPandTPCsetBuildingAlg::fROPcount

private

Output: number of readout planes in each TPC set.

Definition at line 205 of file ROPandTPCsetBuildingAlg.h.

readout::ROPDataContainer<PlaneColl_t> icarus::details::ROPandTPCsetBuildingAlg::fROPplanes

private

Output: planes in each of the readout plane.

Definition at line 208 of file ROPandTPCsetBuildingAlg.h.

std::vector<unsigned int> icarus::details::ROPandTPCsetBuildingAlg::fTPCsetCount

private

Output: number of TPC sets in each cryostat.

Definition at line 199 of file ROPandTPCsetBuildingAlg.h.

readout::TPCsetDataContainer<TPCColl_t> icarus::details::ROPandTPCsetBuildingAlg::fTPCsetTPCs

private

Output: TPC's in each TPC set.

Definition at line 202 of file ROPandTPCsetBuildingAlg.h.

geo::TPCDataContainer<readout::TPCsetID> icarus::details::ROPandTPCsetBuildingAlg::fTPCtoTPCset

private

Output: the TPC set each TPC belongs to.

Definition at line 211 of file ROPandTPCsetBuildingAlg.h.

---

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

• ROPandTPCsetBuildingAlg.h
• ROPandTPCsetBuildingAlg.cxx