LocalTransformation.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_LOCALTRANSFORMATION_H
#define LARCOREALG_GEOMETRY_LOCALTRANSFORMATION_H


// ROOT libraries
// (none)

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


// forward declarations
class TGeoNode;


namespace geo {
  
  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<TGeoNode const*> const& path, size_t depth)
      : fGeoMatrix(transformationFromPath(path, depth)) {}
    
    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; }
    
    
    static TransformationMatrix_t transformationFromPath
      (std::vector<TGeoNode const*> const& path, size_t depth);
    
    
      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<>
  
  
} // namespace geo


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

#include "LocalTransformation.tcc"

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


#endif // LARCOREALG_GEOMETRY_LOCALTRANSFORMATION_H