WireReadoutGeom.h

Go to the documentation of this file.

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


// LArSoft libraries
#include "larcorealg/Geometry/Iterable.h"
#include "larcorealg/Geometry/PlaneGeo.h"
#include "larcorealg/Geometry/WireGeo.h"
#include "larcorealg/Geometry/WireReadoutGeometryBuilder.h"
#include "larcorealg/Geometry/WireReadoutSorter.h"
#include "larcorealg/Geometry/details/ReadoutIterationPolicy.h"
#include "larcorealg/Geometry/details/ToGeometryElement.h"
#include "larcorealg/Geometry/details/ZeroIDs.h"
#include "larcorealg/Geometry/fwd.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_vectors.h"
#include "larcoreobj/SimpleTypesAndConstants/readout_types.h"

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

namespace geo {

  class WireReadoutGeom
    : Iterable<details::ReadoutIterationPolicy, details::ToReadoutGeometryElement> {
    using Iteration = Iterable<details::ReadoutIterationPolicy, details::ToReadoutGeometryElement>;

  public:
    explicit WireReadoutGeom(GeometryCore const* geom,
                             std::unique_ptr<WireReadoutGeometryBuilder> builder,
                             std::unique_ptr<WireReadoutSorter> sorter);
    virtual ~WireReadoutGeom();

    using Segment = std::pair<Point_t, Point_t>;
    static auto const& start(Segment const& s) { return s.first; }
    static auto const& finish(Segment const& s) { return s.second; }

    //--------------------------------------------------------------------------
    // Iteration facilities
    using Iteration::begin;
    using Iteration::end;
    using Iteration::Iterate;


    bool HasPlane(PlaneID const& planeid) const;
    bool HasElement(PlaneID const& planeid) const { return HasPlane(planeid); }


    //
    // group features
    //

    unsigned int MaxPlanes() const;


    unsigned int Nplanes(TPCID const& tpcid = details::tpc_zero) const;
    unsigned int NElements(TPCID const& tpcid) const { return Nplanes(tpcid); }
    unsigned int NSiblingElements(PlaneID const& planeid) const { return Nplanes(planeid); }

    unsigned int Nviews() const;

    std::set<View_t> const& Views() const { return allViews; }

    std::set<View_t> Views(TPCID const& tpcid) const;


    PlaneGeo const& FirstPlane(TPCID const& tpcid) const;


    PlaneGeo const& Plane(TPCID const& tpcid, View_t view) const;
    PlaneGeo const& Plane(PlaneID const& planeid) const;
    PlaneGeo const& GetElement(PlaneID const& planeid) const { return Plane(planeid); }


    PlaneGeo const* PlanePtr(PlaneID const& planeid) const;
    PlaneGeo const* GetElementPtr(PlaneID const& planeid) const { return PlanePtr(planeid); }

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

    unsigned int MaxWires() const;


    unsigned int Nwires(PlaneID const& planeid) const;
    unsigned int NElements(PlaneID const& planeid) const;
    unsigned int NSiblingElements(WireID const& wireid) const { return Nwires(wireid); }


    //
    // access
    //


    bool HasWire(WireID const& wireid) const;
    bool HasElement(WireID const& wireid) const { return HasWire(wireid); }


    WireGeo const* WirePtr(WireID const& wireid) const;
    WireGeo const* GetElementPtr(WireID const& wireid) const { return WirePtr(wireid); }


    WireGeo const& Wire(WireID const& wireid) const;
    WireGeo const& GetElement(WireID const& wireid) const { return Wire(wireid); }

    //
    // simple geometry queries
    //

    void WireEndPoints(WireID const& wireid, double* xyzStart, double* xyzEnd) const;


    Segment WireEndPoints(WireID const& wireid) const
    {
      WireGeo const& wire = Wire(wireid);
      return {wire.GetStart(), wire.GetEnd()};
    }


    //
    // single object features
    //


    double WireAngleToVertical(View_t view, TPCID const& tpcid) const;


    //
    // wire intersections
    //


    bool WireIDsIntersect(WireID const& wid1, WireID const& wid2, Point_t& intersection) const;


    std::optional<WireIDIntersection> WireIDsIntersect(WireID const& wid1,
                                                       WireID const& wid2) const;



    //
    // access
    //


    PlaneID ThirdPlane(PlaneID const& pid1, PlaneID const& pid2) const;

    double ThirdPlaneSlope(PlaneID const& pid1,
                           double slope1,
                           PlaneID const& pid2,
                           double slope2,
                           PlaneID const& output_plane) const;

    double ThirdPlaneSlope(PlaneID const& pid1,
                           double slope1,
                           PlaneID const& pid2,
                           double slope2) const;


    double ThirdPlaneSlope(PlaneID::PlaneID_t plane1,
                           double slope1,
                           PlaneID::PlaneID_t plane2,
                           double slope2,
                           TPCID const& tpcid) const
    {
      return ThirdPlaneSlope(PlaneID(tpcid, plane1), slope1, PlaneID(tpcid, plane2), slope2);
    }

    double ThirdPlane_dTdW(PlaneID const& pid1,
                           double slope1,
                           PlaneID const& pid2,
                           double slope2,
                           PlaneID const& output_plane) const;

    double ThirdPlane_dTdW(PlaneID const& pid1,
                           double slope1,
                           PlaneID const& pid2,
                           double slope2) const;

    static double ComputeThirdPlaneSlope(double angle1,
                                         double slope1,
                                         double angle2,
                                         double slope2,
                                         double angle_target);

    static double ComputeThirdPlane_dTdW(double angle1,
                                         double pitch1,
                                         double dTdW1,
                                         double angle2,
                                         double pitch2,
                                         double dTdW2,
                                         double angle_target,
                                         double pitch_target);


    //......................................................................
    double Plane0Pitch(TPCID const& tpcid, unsigned int p1) const;
    double PlanePitch(TPCID const& tpcid, unsigned int p1 = 0, unsigned int p2 = 1) const;

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

    virtual unsigned int Nchannels() const = 0;

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

    std::vector<raw::ChannelID_t> ChannelsInTPCs() const;

    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;

    View_t View(raw::ChannelID_t const channel) const;

    View_t View(readout::ROPID const& ropid) const;

    SigType_t SignalType(PlaneID const& pid) const;

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

    SigType_t SignalType(readout::ROPID const& ropid) const;

    raw::ChannelID_t NearestChannel(Point_t const& worldLoc, PlaneID const& planeid) const;

    std::optional<WireIDIntersection> ChannelsIntersect(raw::ChannelID_t c1,
                                                        raw::ChannelID_t c2) const;

    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;

    unsigned int NOpChannels() const;

    unsigned int MaxOpChannel() const;

    bool IsValidOpChannel(int opChannel) 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;

    OpDetGeo const& OpDetGeoFromOpChannel(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 unsigned int NTPCsets(readout::CryostatID const& cryoid) const = 0;

    virtual unsigned int MaxTPCsets() const = 0;

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

    readout::TPCsetID FindTPCsetAtPosition(Point_t const& worldLoc) const;

    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;


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

    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:
    virtual SigType_t SignalTypeForChannelImpl(raw::ChannelID_t const channel) const = 0;

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

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

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


    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()


    // 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;

  private:
    bool WireIDIntersectionCheck(WireID const& wid1, WireID const& wid2) const;

    void ResetDriftDirection(TPCID const& tpcid);

    void UpdateAfterSorting(TPCGeo const& tpc, std::vector<PlaneGeo>& planes);

    void SortPlanes(TPCID const& tpcid, std::vector<PlaneGeo>& planes) const;
    void SortSubVolumes(std::vector<PlaneGeo>& planes, Compare<WireGeo> compareWires) const;

    std::map<TPCID, std::vector<PlaneGeo>> fPlanes;
    std::map<TPCID, std::vector<double>> fPlane0Pitch; 

    // cached values
    std::set<View_t> allViews; 

    GeometryCore const* fGeom;
  };

}
#endif // LARCOREALG_GEOMETRY_WIREREADOUTGEOM_H