AuxDetGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_AUXDETGEO_H
#define LARCOREALG_GEOMETRY_AUXDETGEO_H

// LArSoft libraries
#include "larcorealg/CoreUtils/RealComparisons.h"
#include "larcorealg/Geometry/AuxDetSensitiveGeo.h"
#include "larcorealg/Geometry/GeoVectorLocalTransformation.h"
#include "larcorealg/Geometry/LocalTransformationGeo.h"
#include "larcorealg/Geometry/TransformationMatrix.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_vectors.h"

// ROOT libraries
#include "Math/GenVector/DisplacementVector3D.h"
#include "Math/GenVector/PositionVector3D.h"
#include "TGeoVolume.h"

// C/C++ libraries
#include <stddef.h>
#include <string>
#include <type_traits>
#include <vector>

class TGeoNode;

namespace geo {

  class GeoObjectSorter;

  class AuxDetGeo {
  public:
    using AuxDetSensitiveList_t = std::vector<geo::AuxDetSensitiveGeo>;


    struct AuxDetGeoCoordinatesTag {};

    using LocalPoint_t = geo::Point3DBase_t<AuxDetGeoCoordinatesTag>;

    using LocalVector_t = geo::Vector3DBase_t<AuxDetGeoCoordinatesTag>;


    AuxDetGeo(TGeoNode const& node,
              geo::TransformationMatrix&& trans,
              AuxDetSensitiveList_t&& sensitive);

    geo::Point_t GetCenter(double localz = 0.0) const;

    geo::Vector_t GetNormalVector() 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::Point_t toWorldCoords(LocalPoint_t const& local) const
    {
      return fTrans.toWorldCoords(local);
    }

    geo::Vector_t toWorldCoords(LocalVector_t const& local) const
    {
      return fTrans.toWorldCoords(local);
    }

    LocalPoint_t toLocalCoords(geo::Point_t const& world) const
    {
      return fTrans.toLocalCoords(world);
    }

    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;

    AuxDetSensitiveGeo const& PositionToSensitiveVolume(geo::Point_t const& point,
                                                        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;

    std::string AuxDetInfo(std::string indent = "", unsigned int verbosity = 1) const;

    static constexpr unsigned int MaxVerbosity = 4;

  private:
    using LocalTransformation_t =
      geo::LocalTransformationGeo<geo::TransformationMatrix, LocalPoint_t, LocalVector_t>;

    const TGeoVolume* fTotalVolume; 
    LocalTransformation_t fTrans;   
    double fLength;                 
    double fHalfWidth1;             
    double fHalfWidth2;             
    double fHalfHeight;             
    std::vector<AuxDetSensitiveGeo> fSensitive; 

    void InitShapeSize();
  }; // class AuxDetGeo

  static_assert(std::is_move_assignable_v<geo::AuxDetGeo>);
  static_assert(std::is_move_constructible_v<geo::AuxDetGeo>);

}

//------------------------------------------------------------------------------
//--- 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();

} // geo::AuxDetGeo::PrintAuxDetInfo()

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

#endif // LARCOREALG_GEOMETRY_AUXDETGEO_H