AuxDetGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_AUXDETGEO_H
#define LARCOREALG_GEOMETRY_AUXDETGEO_H

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

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

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

class TGeoNode;


namespace geo {
  
  class AuxDetGeo {
  public:

    struct AuxDetGeoCoordinatesTag {};
    
    using LocalPoint_t = geo::Point3DBase_t<AuxDetGeoCoordinatesTag>;
    
    using LocalVector_t = geo::Vector3DBase_t<AuxDetGeoCoordinatesTag>;
    
    
    AuxDetGeo(std::vector<const TGeoNode*>& path, 
              int                           depth);
    
    ~AuxDetGeo();
    
    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;
    
    
    double Length()                  const { return fLength;      }
    double HalfWidth1()                const { return fHalfWidth1;  }
    double HalfWidth2()                const { return fHalfWidth2;  }
    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); }
    
    
    
    std::string Name() const { return fTotalVolume->GetName(); }
    
    
    std::size_t FindSensitiveVolume(geo::Point_t const& point)  const;
    std::size_t FindSensitiveVolume(double const worldLoc[3])  const;

    AuxDetSensitiveGeo const& PositionToSensitiveVolume
      (geo::Point_t const& point, size_t& sv) const;
    AuxDetSensitiveGeo const& PositionToSensitiveVolume
      (double const worldLoc[3], size_t& sv) const;
    AuxDetSensitiveGeo const& SensitiveVolume(size_t sv) const { return *fSensitive[sv];   }
    size_t                    NSensitiveVolume()         const { return fSensitive.size(); }
    
    
    void                      SortSubVolumes(geo::GeoObjectSorter const& sorter);

    
    template <typename Stream>
    void PrintAuxDetInfo
      (Stream&& out, std::string indent = "", unsigned int verbosity = 1) const;
    
    static constexpr unsigned int MaxVerbosity = 4;
    
    
  private:
    
    using LocalTransformation_t
      = geo::LocalTransformationGeo<TGeoHMatrix, LocalPoint_t, LocalVector_t>;
    
    
    void FindAuxDetSensitive(std::vector<const TGeoNode*>& path,
                             unsigned int                  depth);
    void MakeAuxDetSensitive(std::vector<const TGeoNode*>& path,
                             int                           depth);

    const TGeoVolume*                    fTotalVolume; 
    LocalTransformation_t                fTrans;       
    double                               fLength;      
    double                               fHalfWidth1;  
    double                               fHalfWidth2;  
    double                               fHalfHeight;  
    std::vector<AuxDetSensitiveGeo*> fSensitive;   
    
    void InitShapeSize();
  };
}


//------------------------------------------------------------------------------
//--- template implementation
//---
template <typename Stream>
void geo::AuxDetGeo::PrintAuxDetInfo(
  Stream&& out,
  std::string indent /* = "" */,
  unsigned int verbosity /* = 1 */
) const {
  
  //----------------------------------------------------------------------------
  out << "\"" << Name() << "\"";
  
  if (verbosity-- <= 0) return; // 0
  
  //----------------------------------------------------------------------------
  out << " centered at " << GetCenter() << " cm";
  
  if (verbosity-- <= 0) return; // 1
  
  //----------------------------------------------------------------------------
  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; // 2
  
  //----------------------------------------------------------------------------
  out << "\n" << indent
    << "with ";
  switch (NSensitiveVolume()) {
    case 0:  out << "no sensitive volume"; break;
    case 1:  out << "1 sensitive volume"; break;
    default: out << NSensitiveVolume() << " sensitive volumes"; break;
  } // switch
  
  if (verbosity-- <= 0) return; // 3
  
  //----------------------------------------------------------------------------
  out << ", normal facing " << GetNormalVector();
  
//  if (verbosity-- <= 0) return; // 4
  
  //----------------------------------------------------------------------------
  
} // geo::AuxDetGeo::PrintAuxDetInfo()


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

#endif // LARCOREALG_GEOMETRY_AUXDETGEO_H