ChannelMapAlg.h

Go to the documentation of this file.

#ifndef GEO_CHANNELMAPALG_H
#define GEO_CHANNELMAPALG_H
// vim: sw=2 expandtab :

// LArSoft  libraries
#include "larcorealg/Geometry/GeoObjectSorter.h"
#include "larcorealg/Geometry/GeometryData.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larcoreobj/SimpleTypesAndConstants/readout_types.h"

// ROOT libraries
#include "TVector3.h"

// C/C++ standard libraries
#include <cstddef>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>

namespace geo {

  class ChannelMapAlg {
  public:
    virtual ~ChannelMapAlg() = default;

    //--------------------------------------------------------------------------

    virtual void Initialize(GeometryData_t const& geodata) = 0;

    virtual void Uninitialize() = 0;


    //--------------------------------------------------------------------------

    virtual unsigned int Nchannels() const = 0;

    virtual unsigned int Nchannels(readout::ROPID const& ropid) const = 0;

    virtual bool HasChannel(raw::ChannelID_t channel) const
    {
      return raw::isValidChannelID(channel) ? channel < Nchannels() : false;
    }

    virtual std::vector<WireID> ChannelToWire(raw::ChannelID_t channel) const = 0;

    SigType_t SignalTypeForChannel(raw::ChannelID_t const channel) const;

  protected:
    virtual SigType_t SignalTypeForChannelImpl(raw::ChannelID_t const channel) const = 0;

  public:
    SigType_t SignalTypeForROPID(readout::ROPID const& ropid) const;

  protected:
    virtual SigType_t SignalTypeForROPIDImpl(readout::ROPID const& ropid) const;

  public:
    virtual std::set<PlaneID> const& PlaneIDs() const = 0;

    virtual raw::ChannelID_t PlaneWireToChannel(WireID const& wireID) const = 0;


    //--------------------------------------------------------------------------

    virtual unsigned int NOpChannels(unsigned int NOpDets) const;

    virtual unsigned int MaxOpChannel(unsigned int NOpDets) const;

    virtual unsigned int NOpHardwareChannels(unsigned int opDet) const;

    virtual bool IsValidOpChannel(unsigned int opChannel, unsigned int NOpDets) const;

    virtual unsigned int OpChannel(unsigned int detNum, unsigned int hwchannel = 0) const;

    virtual unsigned int OpDetFromOpChannel(unsigned int opChannel) const;

    virtual unsigned int HardwareChannelFromOpChannel(unsigned int opChannel) const;


    //--------------------------------------------------------------------------

    virtual double WireCoordinate(double YPos, double ZPos, PlaneID const& planeID) const = 0;

    virtual WireID NearestWireID(Point_t const& worldPos, PlaneID const& planeID) const = 0;


    //--------------------------------------------------------------------------

    virtual size_t NearestAuxDet(Point_t const& point,
                                 std::vector<AuxDetGeo> const& auxDets,
                                 double tolerance = 0) const;

    virtual size_t NearestSensitiveAuxDet(Point_t const& point,
                                          std::vector<AuxDetGeo> const& auxDets,
                                          double tolerance = 0) const;

    virtual size_t ChannelToAuxDet(std::vector<AuxDetGeo> const& auxDets,
                                   std::string const& detName,
                                   uint32_t const& channel) const;

    virtual std::pair<size_t, size_t> ChannelToSensitiveAuxDet(
      std::vector<AuxDetGeo> const& auxDets,
      std::string const& detName,
      uint32_t const& channel) const;


    //--------------------------------------------------------------------------

    virtual unsigned int NTPCsets(readout::CryostatID const& cryoid) const = 0;

    virtual unsigned int MaxTPCsets() const = 0;

    virtual bool HasTPCset(readout::TPCsetID const& tpcsetid) const = 0;

    virtual readout::TPCsetID TPCtoTPCset(TPCID const& tpcid) const = 0;

    virtual std::vector<TPCID> TPCsetToTPCs(readout::TPCsetID const& tpcsetid) const = 0;

    virtual TPCID FirstTPCinTPCset(readout::TPCsetID const& tpcsetid) const = 0;


    //--------------------------------------------------------------------------

    virtual unsigned int NROPs(readout::TPCsetID const& tpcsetid) const = 0;

    virtual unsigned int MaxROPs() const = 0;

    virtual bool HasROP(readout::ROPID const& ropid) const = 0;

    virtual readout::ROPID WirePlaneToROP(PlaneID const& planeid) const = 0;

    virtual std::vector<PlaneID> ROPtoWirePlanes(readout::ROPID const& ropid) const = 0;

    virtual PlaneID FirstWirePlaneInROP(readout::ROPID const& ropid) const = 0;

    virtual std::vector<TPCID> ROPtoTPCs(readout::ROPID const& ropid) const = 0;

    virtual readout::ROPID ChannelToROP(raw::ChannelID_t channel) const = 0;

    virtual raw::ChannelID_t FirstChannelInROP(readout::ROPID const& ropid) const = 0;


    //--------------------------------------------------------------------------
    virtual GeoObjectSorter const& Sorter() const = 0;

    //--------------------------------------------------------------------------

    std::vector<std::vector<std::vector<raw::ChannelID_t>>> const& FirstChannelInNextPlane() const
    {
      return fFirstChannelInThisPlane;
    }

    std::vector<std::vector<std::vector<raw::ChannelID_t>>> const& FirstChannelInThisPlane() const
    {
      return fFirstChannelInNextPlane;
    }


    //--------------------------------------------------------------------------

  protected:
    template <typename T>
    using TPCInfoMap_t = std::vector<std::vector<T>>;

    template <typename T>
    using PlaneInfoMap_t = TPCInfoMap_t<std::vector<T>>;

    // These 3D vectors are used in initializing the Channel map.
    // Only a 1D vector is really needed so far, but these are more general.
    PlaneInfoMap_t<raw::ChannelID_t> fFirstChannelInThisPlane;
    PlaneInfoMap_t<raw::ChannelID_t> fFirstChannelInNextPlane;

    std::map<std::string, size_t>
      fADNameToGeo; 
    std::map<size_t, std::vector<size_t>>
      fADChannelToSensitiveGeo; 


    template <typename T>
    T const& AccessElement(TPCInfoMap_t<T> const& map, TPCID const& id) const
    {
      return map[id.Cryostat][id.TPC];
    }

    template <typename T>
    size_t AccessElementSize(TPCInfoMap_t<T> const& map, CryostatID const& id) const
    {
      return map[id.Cryostat].size();
    }

    template <typename T>
    bool isValidElement(TPCInfoMap_t<T> const& map, CryostatID const& id) const
    {
      return id.Cryostat < map.size();
    }
    template <typename T>
    bool isValidElement(TPCInfoMap_t<T> const& map, TPCID const& id) const
    {
      return isValidElement(map, id.asCryostatID()) && (id.TPC < map[id.Cryostat].size());
    }

    template <typename T>
    T const& AccessElement(PlaneInfoMap_t<T> const& map, PlaneID const& id) const
    {
      return map[id.Cryostat][id.TPC][id.Plane];
    }

    template <typename T>
    size_t AccessElementSize(PlaneInfoMap_t<T> const& map, TPCID const& id) const
    {
      return map[id.Cryostat][id.TPC].size();
    }

    template <typename T>
    bool isValidElement(PlaneInfoMap_t<T> const& map, CryostatID const& id) const
    {
      return id.Cryostat < map.size();
    }
    template <typename T>
    bool isValidElement(PlaneInfoMap_t<T> const& map, TPCID const& id) const
    {
      return isValidElement(map, id.asCryostatID()) && (id.TPC < map[id.Cryostat].size());
    }
    template <typename T>
    bool isValidElement(PlaneInfoMap_t<T> const& map, PlaneID const& id) const
    {
      return isValidElement(map, id.asTPCID()) && (id.Plane < AccessSize(map, id.asTPCID()));
    }

    template <typename T>
    T const* GetElementPtr(PlaneInfoMap_t<T> const& map, PlaneID const& id) const
    {
      if (id.Cryostat >= map.size()) return nullptr;
      auto const& cryo_map = map[id.Cryostat];
      if (id.TPC >= cryo_map.size()) return nullptr;
      auto const& TPC_map = cryo_map[id.TPC];
      if (id.Plane >= TPC_map.size()) return nullptr;
      auto const& plane_map = TPC_map[id.Plane];
      return &plane_map;
    } // GetElementPtr()

  };
}
#endif // GEO_CHANNELMAPALG_H