AuxDetSensitiveGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_AUXDETSENSITIVEGEO_H
#define LARCOREALG_GEOMETRY_AUXDETSENSITIVEGEO_H

// LArSoft libraries
#include "larcorealg/Geometry/LocalTransformationGeo.h"
#include "larcorealg/CoreUtils/RealComparisons.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

// ROOT libraries
#include "TGeoVolume.h"
#include "TGeoMatrix.h" // TGeoHMatrix

// C/C++ standard libraries
#include <vector>


class TGeoNode;

namespace geo {
  
  class AuxDetSensitiveGeo {
  public:

    struct AuxDetSensitiveGeoCoordinatesTag {};
    
    using LocalPoint_t = geo::Point3DBase_t<AuxDetSensitiveGeoCoordinatesTag>;
    
    using LocalVector_t = geo::Vector3DBase_t<AuxDetSensitiveGeoCoordinatesTag>;
    
    
    AuxDetSensitiveGeo(std::vector<const TGeoNode*> const& path, 
                       int                           depth);
    AuxDetSensitiveGeo(const TGeoVolume* volume, TGeoHMatrix const& rotation);
    AuxDetSensitiveGeo(const TGeoVolume* volume, TGeoHMatrix&& rotation);
    
    void GetCenter(double* xyz, double localz=0.0)    const;
    
    geo::Point_t GetCenter(double localz = 0.0) const;
    
    geo::Vector_t GetNormalVector() const;

    void GetNormalVector(double* xyzDir) const;

    //box geometry
    double Length()                  const { return fLength;      }
    double HalfLength()              const { return Length() / 2.0; }
    double HalfWidth1()              const { return fHalfWidth1;  }
    double HalfWidth2()              const { return fHalfWidth2;  }
    double HalfCenterWidth()         const { return (HalfWidth1() + HalfWidth2()) / 2.0;  }
    double HalfHeight()              const { return fHalfHeight;  }
    const TGeoVolume* TotalVolume()  const { return fTotalVolume; }
    
    geo::Length_t DistanceToPoint(geo::Point_t const& point) const
      { return (point - GetCenter()).R(); }
    geo::Length_t DistanceToPoint(double const* point) const;
    
    
    void LocalToWorld(const double* auxdet, double* world) const
      { fTrans.LocalToWorld(auxdet, world); }
      
    geo::Point_t toWorldCoords(LocalPoint_t const& local) const
      { return fTrans.toWorldCoords(local); }
    
    void LocalToWorldVect(const double* auxdet, double* world) const
      { fTrans.LocalToWorldVect(auxdet, world); }
    
    geo::Vector_t toWorldCoords(LocalVector_t const& local) const
      { return fTrans.toWorldCoords(local); }
    
    void WorldToLocal(const double* world, double* auxdet) const
      { fTrans.WorldToLocal(world, auxdet); }
    
    LocalPoint_t toLocalCoords(geo::Point_t const& world) const
      { return fTrans.toLocalCoords(world); }
    
    void WorldToLocalVect(const double* world, double* auxdet) const
      { fTrans.WorldToLocalVect(world, auxdet); }
    
    LocalVector_t toLocalCoords(geo::Vector_t const& world) const
      { return fTrans.toLocalCoords(world); }
    
    
    
    template <typename Stream>
    void PrintAuxDetInfo
      (Stream&& out, std::string indent = "", unsigned int verbosity = 0) const;
    
    static constexpr unsigned int MaxVerbosity = 2;
    
  private:
    
    using LocalTransformation_t
      = geo::LocalTransformationGeo<TGeoHMatrix, LocalPoint_t, LocalVector_t>;
    
    LocalTransformation_t         fTrans;       
    const TGeoVolume*             fTotalVolume; 
    double                        fLength;      
    double                        fHalfWidth1;  
    double                        fHalfWidth2;  
    double                        fHalfHeight;  
    
    void InitShapeSize();
    
  }; // class AuxDetSensitiveGeo
  
} // namespace geo


//------------------------------------------------------------------------------
//--- template implementation
//---
template <typename Stream>
void geo::AuxDetSensitiveGeo::PrintAuxDetInfo(
  Stream&& out,
  std::string indent /* = "" */,
  unsigned int verbosity /* = 0 */
) const {
  
  //----------------------------------------------------------------------------
  out << "centered at " << GetCenter() << " cm";
  
  if (verbosity-- <= 0) return; // 0
  
  //----------------------------------------------------------------------------
  lar::util::RealComparisons<double> coordIs(1e-4);
  out << ", size ( " << (2.0 * HalfWidth1());
  if (coordIs.nonEqual(HalfWidth1(), HalfWidth2()))
    out << "/" << (2.0 * HalfWidth2());
  out << " x " << (2.0 * HalfHeight()) << " x " << Length() << " ) cm";
  
  if (verbosity-- <= 0) return; // 1
  
  //----------------------------------------------------------------------------
  out << ", normal facing " << GetNormalVector();
  
//  if (verbosity-- <= 0) return; // 2
  
  //----------------------------------------------------------------------------
  
} // geo::AuxDetSensitiveGeo::PrintAuxDetInfo()


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

#endif // LARCOREALG_GEOMETRY_AUXDETSENSITIVEGEO_H