DriftPartitions.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_DRIFTPARTITIONS_H
#define LARCOREALG_GEOMETRY_DRIFTPARTITIONS_H

// LArSoft libraries
#include "larcorealg/Geometry/Decomposer.h"
#include "larcorealg/Geometry/Partitions.h"
#include "larcorealg/Geometry/SimpleGeo.h"
#include "larcorealg/Geometry/TPCGeo.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_vectors.h"

// ROOT libraries
#include "Math/GenVector/Cartesian2D.h"
#include "Math/GenVector/DisplacementVector2D.h"

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

namespace geo {

  class CryostatGeo;

  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