LocalTransformation.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_LOCALTRANSFORMATION_H
#define LARCOREALG_GEOMETRY_LOCALTRANSFORMATION_H

// ROOT libraries
class TGeoNode;

// C/C++ standard libraries
#include <cstdlib>     // std::size_t
#include <type_traits> // std::enable_if_t<>, std::decay_t<>
#include <utility>     // std::move(), std::forward()
#include <vector>

// forward declarations
class TGeoNode;

namespace geo {

  namespace details {
    template <typename Dest, typename Src>
    struct TransformationMatrixConverter;
  } // namespace details

  struct GeoNodePathEntry {
    TGeoNode const* node;
    std::size_t hash_value;
  };

  using GeoNodeIterator_t = std::vector<GeoNodePathEntry>::const_iterator;

  template <typename StoredMatrix, typename ITER>
  static StoredMatrix transformationFromPath(ITER begin, ITER end);

  template <typename StoredMatrix>
  static StoredMatrix transformationFromPath(std::vector<GeoNodePathEntry> const& path,
                                             size_t depth);

  template <typename StoredMatrix>
  class LocalTransformation {
  public:
    using TransformationMatrix_t = StoredMatrix;


    LocalTransformation(TransformationMatrix_t const& matrix) : fGeoMatrix(matrix) {}
    LocalTransformation(TransformationMatrix_t&& matrix) : fGeoMatrix(std::move(matrix)) {}

    LocalTransformation(std::vector<GeoNodePathEntry> const& path, size_t depth)
      : fGeoMatrix(transformationFromPath<StoredMatrix>(path.begin(), path.begin() + depth + 1))
    {}

    LocalTransformation(std::vector<GeoNodePathEntry> const& path)
      : LocalTransformation(path, path.size())
    {}

    template <typename ITER>
    LocalTransformation(ITER begin, ITER end)
      : fGeoMatrix(transformationFromPath<StoredMatrix>(begin, end))
    {}

    void LocalToWorld(double const* local, double* world) const;

    // @{
    template <typename DestPoint,
              typename SrcPoint,
              typename = std::enable_if_t<!std::is_same<SrcPoint, DestPoint>::value>>
    DestPoint LocalToWorld(SrcPoint const& local) const
    {
      return LocalToWorldImpl<DestPoint>(local);
    }
    template <typename Point>
    Point LocalToWorld(Point const& local) const
    {
      return LocalToWorldImpl<Point>(local);
    }
    // @}

    void LocalToWorldVect(double const* local, double* world) const;


    template <typename DestVector,
              typename SrcVector,
              typename = std::enable_if_t<!std::is_same<SrcVector, DestVector>::value>>
    DestVector LocalToWorldVect(SrcVector const& local) const
    {
      return LocalToWorldVectImpl<DestVector>(local);
    }
    template <typename Vector>
    Vector LocalToWorldVect(Vector const& local) const
    {
      return LocalToWorldVectImpl<Vector>(local);
    }

    void WorldToLocal(double const* world, double* local) const;


    template <typename DestPoint,
              typename SrcPoint,
              typename = std::enable_if_t<!std::is_same<SrcPoint, DestPoint>::value>>
    DestPoint WorldToLocal(SrcPoint const& world) const
    {
      return WorldToLocalImpl<DestPoint>(world);
    }
    template <typename Point>
    Point WorldToLocal(Point const& world) const
    {
      return WorldToLocalImpl<Point>(world);
    }

    void WorldToLocalVect(const double* world, double* local) const;


    template <typename DestVector,
              typename SrcVector,
              typename = std::enable_if_t<!std::is_same<SrcVector, DestVector>::value>>
    DestVector WorldToLocalVect(SrcVector const& world) const
    {
      return WorldToLocalVectImpl<DestVector>(world);
    }
    template <typename Vector>
    Vector WorldToLocalVect(Vector const& world) const
    {
      return WorldToLocalVectImpl<Vector>(world);
    }

    TransformationMatrix_t const& Matrix() const { return fGeoMatrix; }

  protected:
    TransformationMatrix_t fGeoMatrix; 

    template <typename DestPoint, typename SrcPoint>
    DestPoint LocalToWorldImpl(SrcPoint const& local) const;

    template <typename DestVector, typename SrcVector>
    DestVector LocalToWorldVectImpl(SrcVector const& local) const;

    template <typename DestPoint, typename SrcPoint>
    DestPoint WorldToLocalImpl(SrcPoint const& world) const;

    template <typename DestVector, typename SrcVector>
    DestVector WorldToLocalVectImpl(SrcVector const& world) const;

  }; // class LocalTransformation<>

  template <typename Dest, typename Src>
  decltype(auto) convertTransformationMatrix(Src&& trans)
  {
    return details::TransformationMatrixConverter<std::decay_t<Dest>, std::decay_t<Src>>::convert(
      std::forward<Src>(trans));
  }

} // namespace geo

//------------------------------------------------------------------------------
// template implementation

#include "LocalTransformation.tcc"

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

#endif // LARCOREALG_GEOMETRY_LOCALTRANSFORMATION_H