phot::ICARUSPhotonMappingTransformations Class Reference

Photon library mapping for ICARUS geometry. More...

#include <ICARUSPhotonMappingTransformations.h>

Inheritance diagram for phot::ICARUSPhotonMappingTransformations:

Classes
struct	Config

Public Types
using	Parameters = art::ToolConfigTable< Config >
Public Types inherited from phot::IPhotonMappingTransformations
using	OpDetID_t = int
	Type describing a optical detector ID. More...
using	LibraryIndex_t = OpDetID_t
	Type describing a library index. FIXME former LibraryOpDetID_t. More...
using	LibraryIndexToOpDetMap = std::vector< OpDetID_t >
	Type describing the mapping of optical detectors into library indices. More...
using	OpDetToLibraryIndexMap = std::vector< LibraryIndex_t >
	Type describing the mapping of library indices into optical detectors. More...
template<typename LibDataColl >
using	MappedOpDetData_t = phot::OpDetVisibilityData< util::collection_reference_t< LibDataColl >, util::collection_reference_t< OpDetToLibraryIndexMap const > >
	Type of optical detector data collection. More...

Public Member Functions
	ICARUSPhotonMappingTransformations (Config const &config)
	Constructor. More...
	ICARUSPhotonMappingTransformations (Parameters const &config)
	Constructor: ignores the configuration. More...
template<typename OutputIndex , typename InputIndex , template< typename...> typename Container>
auto	invertMapping (Container< OutputIndex > const &directMap, std::size_t size, InputIndex invalidIndex) -> Container< InputIndex >
	Inverts a given mapping. More...
Geometry mapping interface
virtual geo::Point_t	detectorToLibrary (geo::Point_t const &location) const override
	Returns the representation within the library of a detector location. More...
Optical detector mapping interface
virtual LibraryIndex_t	opDetToLibraryIndex (geo::Point_t const &location, OpDetID_t opDetID) const override
	Returns the library index for the specified optical detector. More...
virtual OpDetID_t	libraryIndexToOpDet (geo::Point_t const &location, LibraryIndex_t libIndex) const override
	Returns the optical detector ID for the specified library index. More...
virtual OpDetToLibraryIndexMap const &	opDetsToLibraryIndices (geo::Point_t const &location) const override
	Returns a map of library indices as function of optical detectors. More...
virtual std::size_t	opDetMappingSize () const override
	Expected number of mappings of optical detector into library index. More...
virtual LibraryIndexToOpDetMap const &	libraryIndicesToOpDets (geo::Point_t const &location) const override
	Returns a map of identifiers of optical detectors for each library index, for the library appropriate around location More...
virtual std::size_t	libraryMappingSize (geo::Point_t const &location) const override
	Expected size of the mapping from library to optical detectors. More...
Public Member Functions inherited from phot::IPhotonMappingTransformations
virtual	~IPhotonMappingTransformations ()=default
template<typename Coll >
auto	applyOpDetMapping (OpDetToLibraryIndexMap const &opDetToLibraryMap, Coll &&source, util::collection_value_t< Coll > defaultValue) const -> MappedOpDetData_t< Coll >
template<typename Coll >
MappedOpDetData_t< Coll >	applyOpDetMapping (OpDetToLibraryIndexMap const &opDetToLibraryMap, Coll &&source, util::collection_value_t< Coll > defaultValue={}) const
	Remaps a collection indexed by library index into one indexed by optical detector IDs. More...
template<typename Coll >
auto	applyOpDetMapping (geo::Point_t const &location, Coll &&source, util::collection_value_t< Coll > defaultValue={}) const
	Remaps a collection indexed by library index into one indexed by optical detector IDs according to the mapping at location. More...

Protected Member Functions
geo::CryostatID	whichCryostat (geo::Point_t const &point) const
	Returns which cryostat better contain point. Never invalid so far. More...
OpDetToLibraryIndexMap const &	opDetsToLibraryIndicesImpl (geo::Point_t const &location) const
LibraryIndexToOpDetMap const &	libraryIndicesToOpDetsImpl (geo::Point_t const &location) const
void	prepareGeometryMapping ()
void	prepareLibraryMappings (LibraryIndexToOpDetMap const &libraryIndices)
void	prepareMappings (LibraryIndexToOpDetMap const &libraryIndices)
	Extracts the necessary information for mapping from the geometry. More...
void	dumpMapping () const
	Writes the current mapping information into the console. Debug stuff. More...

Static Protected Member Functions
template<typename OutputIndex , typename InputIndex , template< typename...> typename Container>
static Container< InputIndex >	invertMapping (Container< OutputIndex > const &directMap, std::size_t size, InputIndex invalidIndex)
	Inverts a given mapping. More...

Protected Attributes
bool	fDumpMapping = false
	Whether to dump mapping on initialization. More...
geo::GeometryCore const *	fGeom = nullptr
	Detector geometry service provider. Not really used. More...
std::vector< geo::Vector_t >	fTranslations
	Translation of the point. More...
geo::Length_t	fSwitchPoint
	Switch coordinate on x axis [cm]. More...
unsigned int	fNOpDetChannels
std::vector< int >	fChannelShifts
	Amount of channel number shifting indexed by cryostat. Not really used. More...
std::vector < LibraryIndexToOpDetMap >	fLibraryIndexToOpDetMaps
	Library to detector channel mappings, indexed by cryostat number. More...
LibraryIndexToOpDetMap	fInvalidLibraryIndexToOpDetMap
	A library-to-detector mapping for invalid points. More...
std::vector < OpDetToLibraryIndexMap >	fOpDetToLibraryIndexMaps
	Detector channel to library mappings, indexed by cryostat number. More...
OpDetToLibraryIndexMap	fInvalidOpDetToLibraryIndexMap
	A detector-to-library mapping for invalid points. More...

Additional Inherited Members
Static Public Attributes inherited from phot::IPhotonMappingTransformations
static constexpr OpDetID_t	InvalidOpDetID = std::numeric_limits<OpDetID_t>::max()
	Value used to identify an invalid optical detector. More...
static constexpr LibraryIndex_t	InvalidLibraryIndex = std::numeric_limits<LibraryIndex_t>::max()
	Value used for an invalid library index. More...

Detailed Description

Photon library mapping for ICARUS geometry.

This is an implementation of phot::IPhotonMappingTransformation interface to exploit ICARUS detector symmetries.

The current implementation only exploits the fact that the two cryostats are identical, and ignores the symmetry respect to the cathode within each of the cryostats.

The required library is expected to cover the first 180 PMT channels (the ones pertaining the first cryostat, C:0), and the full volume of the TPC.

When requested a point in the first cryostat (C:0), the point is used directly in the visibility library to get visibility on PMT channels 0 to 179 (the lower half). The mapping then maps the remaining PMT channels (180 to 359) to be invalid and with default value of 0.

When requested a point in the other cryostat (C:1), the point is translated into the first one to get visibility of PMT channels 0 to 179 (the lower half). The mapping then translates those channels into the range 180 to 359, and maps the remaining PMT channels (0 to 179) to be invalid and with default value of 0.

Note that the content of the library for channels 180 to 359 is always ignored, and it may well be absent.

Definition at line 58 of file ICARUSPhotonMappingTransformations.h.

Member Typedef Documentation

using phot::ICARUSPhotonMappingTransformations::Parameters = art::ToolConfigTable<Config>

Definition at line 82 of file ICARUSPhotonMappingTransformations.h.

Constructor & Destructor Documentation

phot::ICARUSPhotonMappingTransformations::ICARUSPhotonMappingTransformations

(

Config const &

config

)

Constructor.

Definition at line 31 of file ICARUSPhotonMappingTransformations.cxx.

  : fDumpMapping(config.DumpMapping())
  , fGeom(lar::providerFrom<geo::Geometry>())
  , fNOpDetChannels(fGeom? fGeom->NOpDets(): 0)
{
  LibraryIndexToOpDetMap libraryIndices;
  if (!config.CryostatChannelRemap(libraryIndices)) {
    assert(fNOpDetChannels > 0U); // if no mapping is specified, we need to know
    unsigned int nCryoChannels = fGeom->Cryostat(0U).NOpDet();
    libraryIndices.resize(nCryoChannels);
    std::iota(libraryIndices.begin(), libraryIndices.end(), 0U);
  }
  prepareMappings(libraryIndices);
  
} // phot::ICARUSPhotonMappingTransformations::ICARUSPhotonMappingTransformations()

phot::ICARUSPhotonMappingTransformations::ICARUSPhotonMappingTransformations ( Parameters const &  config )

inline

Constructor: ignores the configuration.

Definition at line 89 of file ICARUSPhotonMappingTransformations.h.

      : ICARUSPhotonMappingTransformations(config())
      {}

Member Function Documentation

geo::Point_t phot::ICARUSPhotonMappingTransformations::detectorToLibrary ( geo::Point_t const &  location ) const

overridevirtual

Returns the representation within the library of a detector location.

Parameters

location

position in world coordinates [cm]

Returns

a vector expressing location in the library space

The returned vector is shifted as it were on the first cryostat.

No exception is ever thrown.

Implements phot::IPhotonMappingTransformations.

Definition at line 50 of file ICARUSPhotonMappingTransformations.cxx.

{
  geo::CryostatID onCryo = whichCryostat(location);
  return onCryo? location + fTranslations[onCryo.Cryostat]: location;
} // phot::ICARUSPhotonMappingTransformations::detectorToLibrary()

void phot::ICARUSPhotonMappingTransformations::dumpMapping ( ) const

protected

Writes the current mapping information into the console. Debug stuff.

Definition at line 315 of file ICARUSPhotonMappingTransformations.cxx.

                                                               {
  mf::LogInfo log("ICARUSPhotonMappingTransformations");
  
  log << "ICARUSPhotonMappingTransformations mapping";
  
  log << "\nMapping of geometry: '" << fGeom->DetectorName() << "':"
    << "\n  - " << fGeom->Ncryostats() << " cryostats"
    << "\n  - optical channels: " << fNOpDetChannels
    << "\n  - maximum optical detector channel number: " << fGeom->MaxOpChannel()
    << "\n"
    ;
  
  log << "\nThe switch point is at x=" << fSwitchPoint << " cm.";
  
  constexpr unsigned int PageBreak = 12;
  
  for (auto const& cryo: fGeom->IterateCryostats()) {
    
    auto const c = cryo.ID().Cryostat;
    
    log << "\n" << cryo.ID() << ":"
      << "\n  * optical detectors:        " << cryo.NOpDet()
      << "\n  * channel -> library shift: " << fChannelShifts[c]
      << "\n  * translation:              " << fTranslations[c];
    
    unsigned int pager;
    
    // print library to detector mapping
    auto const& libOpDetIDmap = fLibraryIndexToOpDetMaps[c];
    log
      << "\n  * mapping [library index @" << cryo.ID()
        << "] => [optical detector] (" << libOpDetIDmap.size()
        << " entries):";
      ;
    pager = PageBreak;
    for (auto [ i, opDetID ]: util::enumerate(libOpDetIDmap)) {
      if (++pager >= PageBreak) {
        pager = 0;
        log << "\n    ";
      }
      log << "  [" << i << "] => [" << channelIndex(opDetID) << "];";
    } // for
    
    // print detector to library mapping
    auto const& opDetLibMap = fOpDetToLibraryIndexMaps[c];
    pager = PageBreak;
    log
      << "\n  * mapping [optical detector] => [library index @"
        << cryo.ID() << "] (" << opDetLibMap.size() << " entries):";
      ;
    pager = PageBreak;
    for (std::size_t i = 0; i < opDetLibMap.size(); ++i) {
      if (++pager >= PageBreak) {
        pager = 0;
        log << "\n    ";
      }
      log << "  [" << i << "] => [" << libraryIndex(opDetLibMap[i]) << "];";
    }
    
  } // for cryostats
  
  {
    log << "\n"
      << "\nMapping [library index] => [no optical detector] ("
      << fInvalidLibraryIndexToOpDetMap.size() << " entries):";
    unsigned int pager = PageBreak;
    for (std::size_t i = 0; i < fInvalidLibraryIndexToOpDetMap.size(); ++i) {
      if (++pager >= PageBreak) {
        pager = 0;
        log << "\n    ";
      }
      log << "  [" << i << "] => ["
        << libraryIndex(fInvalidLibraryIndexToOpDetMap[i]) << "];";
    } // for
    log << "\n";
  } // anonymous scope block
  
  {
    log << "\n"
      << "\nMapping [optical detector] => [no library] ("
      << fInvalidOpDetToLibraryIndexMap.size() << " entries):";
    unsigned int pager = PageBreak;
    for (std::size_t i = 0; i < fInvalidOpDetToLibraryIndexMap.size(); ++i) {
      if (++pager >= PageBreak) {
        pager = 0;
        log << "\n    ";
      }
      log << "  [" << i << "] => ["
        << channelIndex(fInvalidOpDetToLibraryIndexMap[i]) << "];";
    } // for
    log << "\n";
  } // // anonymous scope block
  
} // phot::ICARUSPhotonMappingTransformations::dumpMapping()

template<typename OutputIndex , typename InputIndex , template< typename...> typename Container>

static Container<InputIndex> phot::ICARUSPhotonMappingTransformations::invertMapping ( Container< OutputIndex > const &  directMap, std::size_t  size, InputIndex  invalidIndex  )

staticprotected

Inverts a given mapping.

Template Parameters

OutputIndex	the output index of the mapping to invert
IndexIndex	the input index of the mapping to invert
Container	container used for the mapping (be it std::vector)

Parameters

directMap	the mapping (input index to output index) to be inverted
size	the total number of output indices (some may be not mapped)
invalidIndex	input index to associate to unmapped output indices

Returns

a mapping (output index to input index) reversing directMap

The resulting, "inverse" mapping has exactly size entries. If the input mapping maps out beyond that, those indices are not mapped back.

template<typename OutputIndex , typename InputIndex , template< typename...> typename Container>

auto phot::ICARUSPhotonMappingTransformations::invertMapping	(	Container< OutputIndex > const &	directMap,
		std::size_t	size,
		InputIndex	invalidIndex
	)		-> Container<InputIndex>

Inverts a given mapping.

Template Parameters

OutputIndex	the output index of the mapping to invert
IndexIndex	the input index of the mapping to invert
Container	type of container used for the mapping (be it std::vector)

Parameters

directMap	the mapping (input index to output index) to be inverted
size	the total number of output indices (some may be not mapped)
invalidIndex	the input index to associate to unmapped output indices

Returns

a mapping (output index to input index) reversing directMap

The resulting, "inverse" mapping has exactly size entries. If the input mapping maps out beyond that, those indices are not mapped back.

Definition at line 332 of file ICARUSPhotonMappingTransformations.h.

                           {
  
  OutputIndex const endOutputIndex = size;
  
  Container<InputIndex> inverseMap(size, invalidIndex);
  for (std::size_t i = 0U; i < directMap.size(); ++i) {
    OutputIndex o = directMap[i];
    if (o < endOutputIndex) inverseMap[o] = i;
  }
  return inverseMap;
}

virtual OpDetID_t phot::ICARUSPhotonMappingTransformations::libraryIndexToOpDet ( geo::Point_t const &  location, LibraryIndex_t  libIndex  ) const

inlineoverridevirtual

Returns the optical detector ID for the specified library index.

Parameters

location	where the scintillation source is in world frame [cm]
libIndex	library index to be mapped

Returns

optical detector corresponding to libIndex (as used, e.g., in geo::GeometryCore::OpDetGeoFromOpDet()), or InvalidOpDetID

Exceptions

std::out_of_range

if input library index can't be handled TODO not implemented this way (yet?)

See Also

opDetToLibraryIndex(), libraryIndicesToOpDets()

Implements phot::IPhotonMappingTransformations.

Definition at line 145 of file ICARUSPhotonMappingTransformations.h.

      { return libraryIndicesToOpDetsImpl(location)[libIndex]; }

virtual LibraryIndexToOpDetMap const& phot::ICARUSPhotonMappingTransformations::libraryIndicesToOpDets ( geo::Point_t const &  location ) const

inlineoverridevirtual

Returns a map of identifiers of optical detectors for each library index, for the library appropriate around location

Parameters

location

where the scintillation source is in world frame [cm]

Returns

optical detector identifiers for all library indices

See Also

opDetsToLibraryIndices(), libraryIndexToOpDet()

We use this mapping when we have information from the visibility library appropriate for a source at the specified location: this information is addressed via a "library index" with the reduced range (i.e. 0 to 179) and we need to know which are the optical detector channels that visibility covers.

For ICARUS, this mapping is expected to be straightforward:

• [ 0, 179 ] => [ 0, 179 ] if location is in the first cryostat (C:0)
• [ 0, 179 ] => [ 180, 359 ] if location is in the other one (C:1)

The specified location is used to provide context in a similar fashion as detectorToLibrary() does. It can be used to choose the correct mapping among the available ones.

The returned value is a mapping object (see LibraryIndexToOpDetMap documentation for the interface). If a library index does not map to any optical detector in the library at location (which is unusual!), the optical detector ID corresponding to it is InvalidOpDetID.

Implements phot::IPhotonMappingTransformations.

Definition at line 199 of file ICARUSPhotonMappingTransformations.h.

      { return libraryIndicesToOpDetsImpl(location); }

auto phot::ICARUSPhotonMappingTransformations::libraryIndicesToOpDetsImpl ( geo::Point_t const &  location ) const

protected

Definition at line 69 of file ICARUSPhotonMappingTransformations.cxx.

{
  geo::CryostatID onCryo = whichCryostat(location);
  return onCryo
    ? fLibraryIndexToOpDetMaps[onCryo.Cryostat]: fInvalidLibraryIndexToOpDetMap;
} // phot::ICARUSPhotonMappingTransformations::libraryIndicesToOpDetsImpl()

virtual std::size_t phot::ICARUSPhotonMappingTransformations::libraryMappingSize ( geo::Point_t const &  location ) const

inlineoverridevirtual

Expected size of the mapping from library to optical detectors.

Parameters

location

where the scintillation source is in world frame [cm]

Returns

the expected size of the mapping from library indices to optical detectors

See Also

libraryIndicesToOpDets()

This is effectively the size of the mapping returned by libraryIndicesToOpDets(). It represents how many library indices are provided by the library for the specified location, that is 180.

Implements phot::IPhotonMappingTransformations.

Definition at line 214 of file ICARUSPhotonMappingTransformations.h.

      { return libraryIndicesToOpDets(location).size();}

virtual std::size_t phot::ICARUSPhotonMappingTransformations::opDetMappingSize ( ) const

inlineoverridevirtual

Expected number of mappings of optical detector into library index.

Returns

the expected size of the mapping of optical detectors

See Also

opDetsToLibraryIndices()

This is effectively the number of available optical detectors, as well as the size of the mapping as returned by opDetsToLibraryIndices().

Implements phot::IPhotonMappingTransformations.

Definition at line 168 of file ICARUSPhotonMappingTransformations.h.

      { return opDetsToLibraryIndicesImpl(geo::origin()).size(); }

virtual OpDetToLibraryIndexMap const& phot::ICARUSPhotonMappingTransformations::opDetsToLibraryIndices ( geo::Point_t const &  location ) const

inlineoverridevirtual

Returns a map of library indices as function of optical detectors.

Parameters

location

where the scintillation source is in world frame [cm]

Returns

library indices for all optical detectors

See Also

opDetToLibraryIndex(), opDetsToLibraryIndices()

Implements phot::IPhotonMappingTransformations.

Definition at line 156 of file ICARUSPhotonMappingTransformations.h.

      { return opDetsToLibraryIndicesImpl(location); }

auto phot::ICARUSPhotonMappingTransformations::opDetsToLibraryIndicesImpl ( geo::Point_t const &  location ) const

protected

Definition at line 59 of file ICARUSPhotonMappingTransformations.cxx.

{
  geo::CryostatID onCryo = whichCryostat(location);
  return onCryo
    ? fOpDetToLibraryIndexMaps[onCryo.Cryostat]: fInvalidOpDetToLibraryIndexMap;
} // phot::ICARUSPhotonMappingTransformations::opDetsToLibraryIndicesImpl()

virtual LibraryIndex_t phot::ICARUSPhotonMappingTransformations::opDetToLibraryIndex ( geo::Point_t const &  location, OpDetID_t  opDetID  ) const

inlineoverridevirtual

Returns the library index for the specified optical detector.

Parameters

location	where the scintillation source is in world frame [cm]
opDetID	optical detector identifier (as used, e.g., in geo::GeometryCore::OpDetGeoFromOpDet())

Returns

index corresponding to opDetID, or InvalidLibraryIndex

Exceptions

std::out_of_range

if input optical detector ID can't be handled TODO not implemented this way (yet?)

See Also

opDetFromLibrary()

The mapping reduces the optical detector ID to the corresponding one in the first cryostat.

Implements phot::IPhotonMappingTransformations.

Definition at line 132 of file ICARUSPhotonMappingTransformations.h.

      { return opDetsToLibraryIndicesImpl(location)[opDetID]; }

void phot::ICARUSPhotonMappingTransformations::prepareGeometryMapping ( )

protected

Definition at line 78 of file ICARUSPhotonMappingTransformations.cxx.

                                                                    {
  
  /*
   * geometry transformation:
   * 1. determine the switch coordinate (on x axis) between cryostats
   * 2. determine the amount of shift required
   */
  
  //
  // (1) geometry transformation
  //
  // (1.1) determine the switch coordinate (on x axis) between cryostats
  
  geo::Length_t const C0endX = fGeom->Cryostat(0U).MaxX();
  geo::Length_t const C1startX = fGeom->Cryostat(1U).MinX();
  if (C0endX > C1startX) {
    throw std::runtime_error(
      "phot::ICARUSPhotonMappingTransformations::prepareGeometryMapping(): "
      "C:0 ends at x=" + std::to_string(C0endX)
      + ", C:1 starts at x=" + std::to_string(C1startX)
      + "... this algorithm does not understand this geometry."
      );
  }
  fSwitchPoint = (C0endX + C1startX) / 2.0; // pick the middle point
  MF_LOG_DEBUG("ICARUSPhotonMappingTransformations")
    << "Switching from cryostat 0 to 1 when x > " << fSwitchPoint << " cm";
  
  // (1.2) determine the amount of shift required
  geo::Point_t const refPoint = fGeom->Cryostat(0).BoundingBox().Min();
  for (geo::CryostatGeo const& cryo: fGeom->IterateCryostats()) {
    fTranslations.push_back(refPoint - cryo.BoundingBox().Min());
  } // for all cryostats
  
} // phot::ICARUSPhotonMappingTransformations::prepareGeometryMapping()

void phot::ICARUSPhotonMappingTransformations::prepareLibraryMappings ( LibraryIndexToOpDetMap const &  libraryIndices )

protected

Definition at line 116 of file ICARUSPhotonMappingTransformations.cxx.

{
  
  /*
   * 2. library transformation
   *    1. determine the range of PMT channels in the two cryostats
   *    2. determine the shift amount (hint: 180)
   *    3. fill the maps with the shift
   */
  
  //
  // (2) library transformation
  //
  // (2.1) determine the range of PMT channels in the two cryostats
  /*
   * This algorithm is a bit cumbersome, but with the complications of optical
   * detector geometry in LArSoft (which are usually irrelevant for ICARUS)
   * it's a safer way.
   * In short: we test for each possible channel in which cryostat its optical
   * detector is, and extract ranges of channel numbers for each cryostat.
   * In the end, the result is pretty much known:
   * 0-179 on C:0 and 180-359 for C:1.
   */
  std::vector<lar::util::MinMaxCollector<OpDetID_t>> opDetChannelRangeByCryostat
    (fGeom->Ncryostats());
  lar::util::MinMaxCollector<OpDetID_t> opDetChannelRange;
  
  unsigned int const maxOpChannel = fGeom->MaxOpChannel();
  for (unsigned int channel = 0; channel < maxOpChannel; ++channel) {
    
    geo::OpDetGeo const& opDet = fGeom->OpDetGeoFromOpChannel(channel);
    auto const& opDetID = opDet.ID();
    
    if (opDetID.isValid) {
      opDetChannelRange.add(OpDetID_t(channel));
      opDetChannelRangeByCryostat[opDetID.Cryostat].add(OpDetID_t(channel));
    }
    
  } // for all channels
  
  // (2.2) determine the shift amount (hint: 180)
  fChannelShifts.clear();
  for (geo::CryostatGeo const& cryo: fGeom->IterateCryostats()) {
    
    // sanity checks
    geo::CryostatID const cid = cryo.ID();
    
    auto const& channelRange = opDetChannelRangeByCryostat[cid.Cryostat];
    if (!channelRange.has_data()) {
      throw std::runtime_error(
        "phot::ICARUSPhotonMappingTransformations::prepareLibraryMappings(): "
        + cid.toString() + " ends up with no optical channels??"
        );
    }
    
    auto const nChannels = channelRange.max() + 1 - channelRange.min();
    if ((unsigned int) nChannels != cryo.NOpDet()) {
      throw std::runtime_error(
        "phot::ICARUSPhotonMappingTransformations::prepareLibraryMappings(): "
        + cid.toString() + " expected to have "
        + std::to_string(cryo.NOpDet()) + " optical channels, we end up with "
        + std::to_string(nChannels) + " ("
        + std::to_string(channelRange.min()) + " - "
        + std::to_string(channelRange.max()) + ")"
        );
    } // if
    
    // relative shift with respect to the first cryostat:
    fChannelShifts.push_back
      (channelRange.min() - opDetChannelRangeByCryostat.front().min());
    
  } // for cryostats
  
  
  // (2.3) fill the maps with the shift
  
  // (2.3.1) std::vector<LibraryIndexToOpDetMap> fLibraryIndexToOpDetMaps
  //         mapping library index => optical detector ID
  //         indexed by cryostat number of the source
  // 
  // For ICARUS, this mapping is expected to be straightforward:
  //  * [ 0, 179 ] => [ 0, 179 ] if `location` is in the first cryostat (C:0)
  //  * [ 0, 179 ] => [ 180, 359 ] if `location` is in the other one (C:1)
  //
  fLibraryIndexToOpDetMaps.clear();
  for (geo::CryostatGeo const& cryo: fGeom->IterateCryostats()) {
    
    // this is the library for sources in cryostat `cryo`;
    // it is positioned at `cryo.ID().Cryostat` in `fLibOpDetIDmaps`;
    // the library is expected to have only 180 entries,
    // one per optical detector within `cryo`
    
    auto const nChannels = cryo.NOpDet();
    if (libraryIndices.size() != nChannels) {
      throw std::runtime_error(
        "phot::ICARUSPhotonMappingTransformations::prepareLibraryMappings(): "
        "the internal mapping should cover " + std::to_string(nChannels)
        + " channels but it covers " + std::to_string(libraryIndices.size())
        + " instead."
        );
    }
    
    auto const nFirst = fChannelShifts[cryo.ID().Cryostat];
    LibraryIndexToOpDetMap libraryIndexToOpDetMap { libraryIndices }; // copy
    for (auto& c: libraryIndexToOpDetMap) c += nFirst;
    
    fLibraryIndexToOpDetMaps.push_back(std::move(libraryIndexToOpDetMap));
    
  } // for channel range
  
  // if the position is invalid, no library data is actually present,
  // and the mapping is moot; we choose the rank of this mootness to be the same
  // as the first valid mapping
  fInvalidLibraryIndexToOpDetMap.clear();
  fInvalidLibraryIndexToOpDetMap.resize
    (fLibraryIndexToOpDetMaps.front().size(), InvalidOpDetID);
  
  // (2.3.2) std::vector<OpDetToLibraryIndexMap> fOpDetToLibraryIndexMaps
  //         mapping detector optical ID => library index
  //         
  // For ICARUS, this mapping is expected to be:
  //  * if `location` is in the first cryostat (C:0):
  //      * [ 0, 179 ]   => [ 0, 179 ]
  //      * [ 180, 359 ] => invalid indices
  //  * if `location` is in the second cryostat (C:1):
  //      * [ 0, 179 ]   => invalid indices
  //      * [ 180, 359 ] => [ 0, 179 ]
  // 
  fOpDetToLibraryIndexMaps.clear();
  for (auto const& libToOpDetMap: fLibraryIndexToOpDetMaps) {
    
    fOpDetToLibraryIndexMaps.push_back
      (invertMapping(libToOpDetMap, maxOpChannel, InvalidLibraryIndex));
    
  } // for each library mapping
  
  fInvalidOpDetToLibraryIndexMap.clear();
  fInvalidOpDetToLibraryIndexMap.resize(maxOpChannel, InvalidLibraryIndex);
  
} // phot::ICARUSPhotonMappingTransformations::prepareMappings()

void phot::ICARUSPhotonMappingTransformations::prepareMappings ( LibraryIndexToOpDetMap const &  libraryIndices )

protected

Extracts the necessary information for mapping from the geometry.

Definition at line 260 of file ICARUSPhotonMappingTransformations.cxx.

{
  
  /*
   * 1. geometry transformation:
   *    1. determine the switch coordinate (on x axis) between cryostats
   *    2. determine the amount of shift required
   * 2. library transformation
   *    1. determine the range of PMT channels in the two cryostats
   *    2. determine the shift amount (hint: 180)
   *    3. fill the maps with the shift
   */
  
  mf::LogInfo("ICARUSPhotonMappingTransformations")
    << "Photon visibility mapping tool: 'ICARUSPhotonMappingTransformations'";
    
  //
  // (1) geometry transformation
  //
  prepareGeometryMapping();
  
  //
  // (2) library transformation
  //
  prepareLibraryMappings(libraryIndices);
  
  // debug:
  if (fDumpMapping) dumpMapping();
  
} // phot::ICARUSPhotonMappingTransformations::prepareMappings()

geo::CryostatID phot::ICARUSPhotonMappingTransformations::whichCryostat ( geo::Point_t const &  point ) const

inlineprotected

Returns which cryostat better contain point. Never invalid so far.

Definition at line 262 of file ICARUSPhotonMappingTransformations.h.

      { return geo::CryostatID{ (point.X() > fSwitchPoint)? 1U: 0U }; }

Member Data Documentation

std::vector<int> phot::ICARUSPhotonMappingTransformations::fChannelShifts

protected

Amount of channel number shifting indexed by cryostat. Not really used.

Total number of optical detector channels.

Definition at line 247 of file ICARUSPhotonMappingTransformations.h.

bool phot::ICARUSPhotonMappingTransformations::fDumpMapping = false

protected

Whether to dump mapping on initialization.

Definition at line 226 of file ICARUSPhotonMappingTransformations.h.

geo::GeometryCore const* phot::ICARUSPhotonMappingTransformations::fGeom = nullptr

protected

Detector geometry service provider. Not really used.

Definition at line 233 of file ICARUSPhotonMappingTransformations.h.

LibraryIndexToOpDetMap phot::ICARUSPhotonMappingTransformations::fInvalidLibraryIndexToOpDetMap

protected

A library-to-detector mapping for invalid points.

Definition at line 251 of file ICARUSPhotonMappingTransformations.h.

OpDetToLibraryIndexMap phot::ICARUSPhotonMappingTransformations::fInvalidOpDetToLibraryIndexMap

protected

A detector-to-library mapping for invalid points.

Definition at line 255 of file ICARUSPhotonMappingTransformations.h.

std::vector<LibraryIndexToOpDetMap> phot::ICARUSPhotonMappingTransformations::fLibraryIndexToOpDetMaps

protected

Library to detector channel mappings, indexed by cryostat number.

Definition at line 249 of file ICARUSPhotonMappingTransformations.h.

unsigned int phot::ICARUSPhotonMappingTransformations::fNOpDetChannels

protected

Definition at line 245 of file ICARUSPhotonMappingTransformations.h.

std::vector<OpDetToLibraryIndexMap> phot::ICARUSPhotonMappingTransformations::fOpDetToLibraryIndexMaps

protected

Detector channel to library mappings, indexed by cryostat number.

Definition at line 253 of file ICARUSPhotonMappingTransformations.h.

geo::Length_t phot::ICARUSPhotonMappingTransformations::fSwitchPoint

protected

Switch coordinate on x axis [cm].

Definition at line 240 of file ICARUSPhotonMappingTransformations.h.

std::vector<geo::Vector_t> phot::ICARUSPhotonMappingTransformations::fTranslations

protected

Translation of the point.

Definition at line 239 of file ICARUSPhotonMappingTransformations.h.

---

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

• ICARUSPhotonMappingTransformations.h
• ICARUSPhotonMappingTransformations.cxx