TPCGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_TPCGEO_H
#define LARCOREALG_GEOMETRY_TPCGEO_H

// LArSoft libraries
#include "larcorealg/Geometry/BoxBoundedGeo.h"
#include "larcorealg/Geometry/GeoObjectSorter.h"
#include "larcorealg/Geometry/LocalTransformationGeo.h"
#include "larcorealg/Geometry/TransformationMatrix.h"
#include "larcorealg/Geometry/geo_vectors_utils.h" // geo::vect
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

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

// C/C++ standard library
#include <set>
#include <vector>

class TGeoNode;

namespace geo {

  //......................................................................
  class TPCGeo : public BoxBoundedGeo {
  public:
    using ID_t = TPCID;


    struct TPCGeoCoordinatesTag {};

    using LocalPoint_t = Point3DBase_t<TPCGeoCoordinatesTag>;

    using LocalVector_t = Vector3DBase_t<TPCGeoCoordinatesTag>;


    // Construct a representation of a single plane of the detector
    TPCGeo(TGeoNode const* tpc_node,
           std::size_t hash_value,
           TransformationMatrix&& trans,
           DriftAxis driftAxis,
           double driftDistance);


    DriftAxis DriftAxisWithSign() const { return fDriftAxis; }
    geo::DriftSign DriftSign() const { return DriftAxisWithSign().sign; }

    Point_t GetCathodeCenter() const;

    Vector_t DriftDir() const { return fDriftDir; }

    double DriftDistance() const;

    double ActiveHalfWidth() const { return fActiveHalfWidth; }
    double ActiveWidth() const { return 2.0 * ActiveHalfWidth(); }
    double ActiveHalfHeight() const { return fActiveHalfHeight; }
    double ActiveHeight() const { return 2.0 * ActiveHalfHeight(); }
    double ActiveLength() const { return fActiveLength; }
    double ActiveHalfLength() const { return fActiveLength / 2.0; }
    double HalfWidth() const { return fHalfWidth; }
    double Width() const { return 2.0 * HalfWidth(); }
    double HalfHeight() const { return fHalfHeight; }
    double Height() const { return 2.0 * HalfHeight(); }
    double Length() const { return fLength; }
    double HalfLength() const { return fLength / 2.0; }
    double ActiveMass() const { return fActiveVolume->Weight(); }
    const TGeoVolume* ActiveVolume() const { return fActiveVolume; }
    const TGeoVolume* TotalVolume() const { return fTotalVolume; }

    decltype(auto) WidthDir() const { return fWidthDir; }

    decltype(auto) HeightDir() const { return fHeightDir; }

    decltype(auto) LengthDir() const { return fLengthDir; }



    Point_t GetCenter() const { return toWorldCoords(LocalPoint_t{}); }

    Point_t GetActiveVolumeCenter() const { return fActiveCenter; }

    Point_t GetFrontFaceCenter() const;

    BoxBoundedGeo const& BoundingBox() const { return *this; }

    BoxBoundedGeo const& ActiveBoundingBox() const { return fActiveBox; }

    TPCID const& ID() const { return fID; }



    Point_t toWorldCoords(LocalPoint_t const& local) const { return fTrans.toWorldCoords(local); }

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

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

    LocalVector_t toLocalCoords(Vector_t const& world) const { return fTrans.toLocalCoords(world); }


    void UpdateAfterSorting(TPCID tpcid);

    template <typename Stream>
    void PrintTPCInfo(Stream&& out, std::string indent = "", unsigned int verbosity = 1) const;

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

    static constexpr unsigned int MaxVerbosity = 6;

    static bool CoordinateContained(double c, double min, double max, double wiggle = 1.)
    {
      return (c >= (min > 0 ? min / wiggle : min * wiggle)) &&
             (c <= (max < 0 ? max / wiggle : max * wiggle));
    }

    static bool CoordinateContained(double c, double const* range, double wiggle = 1.)
    {
      return CoordinateContained(c, range[0], range[1], wiggle);
    }

    std::size_t Hash() const { return fHash; }
    static TGeoNode const* NodeForActiveVolume(TGeoNode const* tpc);

  private:
    using LocalTransformation_t =
      LocalTransformationGeo<ROOT::Math::Transform3D, LocalPoint_t, LocalVector_t>;

    std::size_t fHash;            
    LocalTransformation_t fTrans; 

    DriftAxis fDriftAxis;
    Vector_t fDriftDir;
    double fDriftDistance;

    TGeoVolume* fActiveVolume{nullptr}; 
    TGeoVolume* fTotalVolume{nullptr};  
    Point_t fActiveCenter;              

    double fActiveHalfWidth;  
    double fActiveHalfHeight; 
    double fActiveLength;     
    double fHalfWidth;        
    double fHalfHeight;       
    double fLength;           

    Vector_t fWidthDir{Xaxis()};  
    Vector_t fHeightDir{Yaxis()}; 
    Vector_t fLengthDir{Zaxis()}; 

    BoxBoundedGeo fActiveBox; 

    TPCID fID; 

    void InitTPCBoundaries();
  };
}

//------------------------------------------------------------------------------
//--- template implementation
//---
//------------------------------------------------------------------------------
template <typename Stream>
void geo::TPCGeo::PrintTPCInfo(Stream&& out,
                               std::string indent /* = "" */,
                               unsigned int verbosity /* = 1 */
) const
{

  //----------------------------------------------------------------------------
  out << "TPC " << std::string(ID());

  if (verbosity-- <= 0) return; // 0

  //----------------------------------------------------------------------------
  out << " (" << Width() << " x " << Height() << " x " << Length() << ") cm^3 at " << GetCenter();

  if (verbosity-- <= 0) return; // 1

  //----------------------------------------------------------------------------
  out << "\n"
      << indent << "drift direction " << DriftDir() << " from cathode around " << GetCathodeCenter()
      << " through " << DriftDistance() << " cm";

  if (verbosity-- <= 0) return; // 2

  if (verbosity-- <= 0) return; // 3

  //----------------------------------------------------------------------------
  out << "\n"
      << indent << "active volume (" << ActiveWidth() << " x " << ActiveHeight() << " x "
      << ActiveLength() << ") cm^3, front face at " << GetFrontFaceCenter() << " cm;"
      << "\n"
      << indent << "main directions:"
      << " width " << WidthDir() << " height " << HeightDir() << " length " << LengthDir();

  if (verbosity-- <= 0) return; // 4

  //----------------------------------------------------------------------------
  // print also the containing box
  BoxBoundedGeo const& box = BoundingBox();
  out << "\n" << indent << "bounding box: " << box.Min() << " -- " << box.Max();

  //----------------------------------------------------------------------------
  // print also the active box
  BoxBoundedGeo const& activeBox = ActiveBoundingBox();
  out << "\n" << indent << "active volume box: " << activeBox.Min() << " -- " << activeBox.Max();

  //----------------------------------------------------------------------------
} // geo::TPCGeo::PrintTPCInfo()

#endif // LARCOREALG_GEOMETRY_TPCGEO_H