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/Exceptions.h" // geo::InvalidWireIDError
#include "larcorealg/Geometry/GeoObjectSorter.h"
#include "larcoreobj/SimpleTypesAndConstants/readout_types.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t

// Framework libraries
#include "cetlib_except/exception.h"

// ROOT libraries
#include "TVector3.h"

// C/C++ standard libraries
#include <vector>
#include <map>
#include <set>
#include <memory> // std::unique_ptr<>


namespace geo{
  
  // forward-declaration from geometry
  struct GeometryData_t;
  class AuxDetGeo;
  
  
  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;
    
    geo::SigType_t SignalTypeForChannel(raw::ChannelID_t const channel) const;

  protected:

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

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

  protected:

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

  public:

    virtual std::set<geo::PlaneID> const& PlaneIDs() const = 0;
    
    virtual raw::ChannelID_t PlaneWireToChannel(geo::WireID const& wireID) const
      { 
        return PlaneWireToChannel
          (wireID.Plane, wireID.Wire, wireID.TPC, wireID.Cryostat);
      }
    
    virtual raw::ChannelID_t PlaneWireToChannel(unsigned int plane,
                                                unsigned int wire,
                                                unsigned int tpc,
                                                unsigned int cstat) 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,
                                  geo::PlaneID const& planeID) const
      {
        return WireCoordinate
          (YPos, ZPos, planeID.Plane, planeID.TPC, planeID.Cryostat);
      }
    
    virtual double WireCoordinate(double YPos,
                                  double ZPos,
                                  unsigned int PlaneNo,
                                  unsigned int TPCNo,
                                  unsigned int cstat) const = 0;
    
    
    virtual geo::WireID NearestWireID
      (const TVector3& worldPos, geo::PlaneID const& planeID) const
      {
        return
          NearestWireID(worldPos, planeID.Plane, planeID.TPC, planeID.Cryostat);
      }
    
    virtual geo::WireID NearestWireID(const TVector3& worldPos,
                                      unsigned int    PlaneNo,
                                      unsigned int    TPCNo,
                                      unsigned int    cstat)   const = 0;
    
    unsigned int                     NearestWire(const TVector3& worldPos,
                                            geo::PlaneID const& planeID)  const;
    
    unsigned int NearestWire(const TVector3& worldPos,
                             unsigned int    PlaneNo,
                             unsigned int    TPCNo,
                             unsigned int    cstat) const
      { return NearestWire(worldPos, geo::PlaneID(cstat, TPCNo, PlaneNo)); }
    
    
    
    //--------------------------------------------------------------------------
 
    virtual size_t NearestAuxDet
      (const double* point, std::vector<geo::AuxDetGeo*> const& auxDets) const;
    
    virtual size_t NearestSensitiveAuxDet
      (const double* point, std::vector<geo::AuxDetGeo*> const& auxDets) const;
    
    virtual size_t ChannelToAuxDet(std::vector<geo::AuxDetGeo*> const& auxDets,
                                   std::string                  const& detName,
                                   uint32_t                     const& channel
                                   ) const;
    
    virtual std::pair<size_t, size_t> ChannelToSensitiveAuxDet(
      std::vector<geo::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(geo::TPCID const& tpcid) const = 0;
    
    virtual std::vector<geo::TPCID> TPCsetToTPCs
      (readout::TPCsetID const& tpcsetid) const = 0;
    
    virtual geo::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
      (geo::PlaneID const& planeid) const = 0;
    
    virtual std::vector<geo::PlaneID> ROPtoWirePlanes
      (readout::ROPID const& ropid) const = 0;
    
    virtual geo::PlaneID FirstWirePlaneInROP
      (readout::ROPID const& ropid) const = 0;
    
    virtual std::vector<geo::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 geo::GeoObjectSorter const& Sorter() const = 0;

    //--------------------------------------------------------------------------
    
    const std::vector<std::vector<std::vector<raw::ChannelID_t>>> FirstChannelInNextPlane() const
      { return fFirstChannelInThisPlane; }
    
    const std::vector<std::vector<std::vector<raw::ChannelID_t>>> 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, geo::TPCID const& id) const
     { return map[id.Cryostat][id.TPC]; }
   
   template <typename T>
   size_t AccessElementSize
     (TPCInfoMap_t<T> const& map, geo::CryostatID const& id) const
     { return map[id.Cryostat].size(); }
   
   template <typename T>
   bool isValidElement
     (TPCInfoMap_t<T> const& map, geo::CryostatID const& id) const
     { return id.Cryostat < map.size(); }
   template <typename T>
   bool isValidElement(TPCInfoMap_t<T> const& map, geo::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, geo::PlaneID const& id) const
     { return map[id.Cryostat][id.TPC][id.Plane]; }
   
   template <typename T>
   size_t AccessElementSize
     (PlaneInfoMap_t<T> const& map, geo::TPCID const& id) const
     { return map[id.Cryostat][id.TPC].size(); }
   
   template <typename T>
   bool isValidElement
     (PlaneInfoMap_t<T> const& map, geo::CryostatID const& id) const
     { return id.Cryostat < map.size(); }
   template <typename T>
   bool isValidElement(PlaneInfoMap_t<T> const& map, geo::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, geo::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, geo::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