DriftPartitions.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_DRIFTPARTITIONS_H
#define LARCOREALG_GEOMETRY_DRIFTPARTITIONS_H

// LArSoft libraries
#include "larcorealg/Geometry/Partitions.h"
#include "larcorealg/Geometry/TPCGeo.h"
#include "larcorealg/Geometry/Decomposer.h"

// C/C++ standard libraries
#include <vector>
#include <string>
#include <functional> // std::less()
#include <algorithm> // std::upper_bound()
#include <utility> // std::forward()
#include <memory> // std::unique_ptr()
#include <type_traits> // std::decay_t<>, std::declval()


namespace geo {
  
  namespace part {
    
    //--------------------------------------------------------------------------
    template <>
    struct PartitionDataDescriber<geo::TPCGeo> {
      template <typename Stream>
      PartitionDataDescriber(
        Stream&& out, geo::TPCGeo const* pTPC,
        std::string indent = "", std::string firstIndent = ""
        );
    }; // PartitionDataDescriber(TPCGeo)
    
    //--------------------------------------------------------------------------
    
  } // namespace part
  
  
  namespace details {
    
    //--------------------------------------------------------------------------
    template <typename T>
    auto static_less(T a, T b)
      { return std::less<T>()(a, b); }
    
    //--------------------------------------------------------------------------
    template <
      typename T, typename Key,
      Key KeyExtractor(T const&),
      bool KeyComparer(Key, Key) = static_less<Key>
      >
    struct Comparer;
    
    //--------------------------------------------------------------------------
    
  } // namespace details
  
  
  // --- BEGIN -----------------------------------------------------------------

  class DriftPartitions {
    
      public:
    using TPCPartition_t = geo::part::Partition<geo::TPCGeo const>;
    
    using Range_t = lar::util::simple_geo::Range<double>;
    
    struct DriftVolume_t {
      std::unique_ptr<TPCPartition_t> partition;
      Range_t driftCoverage;
      
      DriftVolume_t
        (std::unique_ptr<TPCPartition_t>&& part, Range_t const& cover)
        : partition(std::move(part)), driftCoverage(cover) {}
      
      bool coversDrift(double drift) const
        { return driftCoverage.contains(drift); }
      
      static double Position(DriftVolume_t const& part)
        { return part.driftCoverage.lower; }
      
      using Comparer_t
        = details::Comparer<DriftVolume_t, double, DriftVolume_t::Position>;
      
    }; // DriftPartitions::DriftVolume_t
    
    
    using Position_t = geo::Point_t;
    
    using Direction_t = geo::Vector_t;
    
    using Projection_t
      = ROOT::Math::DisplacementVector2D<ROOT::Math::Cartesian2D<double>>;
    
    using DriftDir_t = Direction_t;
    
    using Decomposer_t = geo::Decomposer<Direction_t, Position_t, Projection_t>;
    
    
    std::vector<DriftVolume_t> volumes;
    Decomposer_t decomposer; 
    
    explicit DriftPartitions(Decomposer_t const& decomp): decomposer(decomp) {}
    
    
    double driftCoord(Position_t const& pos) const
      { return decomposer.PointNormalComponent(pos); }
    
    DriftVolume_t const* driftVolumeAt(Position_t const& pos) const
      { return driftVolumeAt(driftCoord(pos)); }
    
    DriftVolume_t const* driftVolumeAt(double drift) const;
    
    geo::TPCGeo const* TPCat(Position_t const& pos) const;
    
    
    template <typename Stream>
    void print(Stream&& out) const;
    
    void addPartition(std::unique_ptr<TPCPartition_t>&& part);
    
    
      private:
    
    std::vector<DriftVolume_t>::iterator volumeAfter(double pos);
    
    std::vector<DriftVolume_t>::const_iterator volumeAfter(double pos) const;
    
    Range_t computeCoverage(TPCPartition_t const& TPCpart) const;
    
  }; // class DriftPartitions
  
  
  //----------------------------------------------------------------------------
  DriftPartitions buildDriftVolumes(geo::CryostatGeo const& cryo);
  
  
  // --- END -------------------------------------------------------------------
  
} // namespace geo


//------------------------------------------------------------------------------
//---  inline and template implementation
//---  
//------------------------------------------------------------------------------
namespace geo {
  namespace details {
    
    //--------------------------------------------------------------------------
    // TODO use SorterByKey instead?
    template <
      typename T, typename Key,
      Key KeyExtractor(T const&),
      bool KeyComparer(Key, Key) /* = static_less<Key> */
      >
    struct Comparer {
      using Key_t = Key; 
      using Object_t = T; 
      
      bool operator() (Key_t a, Key_t b) const { return key_comp(a, b); }
      bool operator() (Object_t const& a, Key_t b) const
        { return this->operator() (key(a), b); }
      bool operator() (Key_t a, Object_t const& b) const
        { return this->operator() (a, key(b)); }
      bool operator() (Object_t const& a, Object_t const& b) const
        { return this->operator() (key(a), b); }
      
        private:
      static auto key(T const& v) { return KeyExtractor(v); }
      static auto key_comp(Key_t a, Key_t b) { return KeyComparer(a, b); }
      
    }; // struct Comparer<>
    
    //--------------------------------------------------------------------------
    
  } // namespace details
} // namespace geo


//------------------------------------------------------------------------------
template <typename Stream>
geo::part::PartitionDataDescriber<geo::TPCGeo>::PartitionDataDescriber(
  Stream&& out, geo::TPCGeo const* pTPC,
  std::string indent /* = "" */, std::string firstIndent /* = "" */
  )
{
  out << firstIndent;
  if (!pTPC) {
    out << "no TPC";
    return;
  }
  // verbosity: 2 => ID, size, drift information;
  // 5: also number of wires and active volume
  pTPC->PrintTPCInfo(std::forward<Stream>(out), indent, 2U);
} // geo::part::PartitionDataDescriber<TPCGeo>::PartitionDataDescriber()


//------------------------------------------------------------------------------
//--- geo::DriftPartitions
//---
inline auto geo::DriftPartitions::volumeAfter(double pos)
  -> std::vector<DriftVolume_t>::iterator
{
  return std::upper_bound
    (volumes.begin(), volumes.end(), pos, DriftVolume_t::Comparer_t());
} // geo::DriftPartitions::volumeAfter()

inline auto geo::DriftPartitions::volumeAfter(double pos) const
  -> std::vector<DriftVolume_t>::const_iterator
{
  return std::upper_bound
    (volumes.begin(), volumes.end(), pos, DriftVolume_t::Comparer_t());
} // geo::DriftPartitions::volumeAfter()


//------------------------------------------------------------------------------
template <typename Stream>
void geo::DriftPartitions::print(Stream&& out) const {
  
  out << volumes.size() << " drift volume partitions:";
  for (auto const& driftVol: volumes) {
    out << "\n[" << driftVol.driftCoverage.lower
      << " -- " << driftVol.driftCoverage.upper << "]: "
      << driftVol.partition->describe("  ", "");
  } // for
  out << "\n";
} // geo::DriftPartitions::print()


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

#endif // LARCOREALG_GEOMETRY_DRIFTPARTITIONS_H