CryostatGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_CRYOSTATGEO_H
#define LARCOREALG_GEOMETRY_CRYOSTATGEO_H

// LArSoft libraries
#include "larcorealg/Geometry/TPCGeo.h"
#include "larcorealg/Geometry/OpDetGeo.h"
#include "larcorealg/Geometry/BoxBoundedGeo.h"
#include "larcorealg/Geometry/GeoObjectSorter.h"
#include "larcorealg/Geometry/geo_vectors_utils.h" // geo::vect
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_vectors.h" // geo::Point_t

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

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

// forward declarations
class TGeoNode;

namespace geo {

  //......................................................................
  class CryostatGeo: public geo::BoxBoundedGeo {
    
    using TPCList_t = std::vector<TPCGeo>;
    
      public:
    
    using GeoNodePath_t = geo::WireGeo::GeoNodePath_t;
    

    struct CryostatGeoCoordinatesTag {};
    
    using LocalPoint_t = geo::Point3DBase_t<CryostatGeoCoordinatesTag>;
    
    using LocalVector_t = geo::Vector3DBase_t<CryostatGeoCoordinatesTag>;
    
    
    
    CryostatGeo(std::vector<const TGeoNode*>& path, int depth);
    
    
    
    double            HalfWidth()                               const;
    double            HalfHeight()                              const;
    double            HalfLength()                              const;
    double            Width()                                   const { return 2. * HalfWidth(); }
    double            Height()                                  const { return 2. * HalfHeight(); }
    double            Length()                                  const { return 2. * HalfLength(); }
    double            Mass()                                    const { return fVolume->Weight(); }
    const TGeoVolume* Volume()                                  const { return fVolume;           }
    
    geo::BoxBoundedGeo const& Boundaries() const
      { return BoundingBox(); }
    
    void Boundaries(double* boundaries) const;
    
    
    geo::Point_t GetCenter() const
      { return Boundaries().Center(); }
    
    geo::BoxBoundedGeo const& BoundingBox() const
      { return static_cast<geo::BoxBoundedGeo const&>(*this); }
    
    geo::CryostatID const& ID() const { return fID; }
    
    
    template <typename Stream>
    void PrintCryostatInfo
      (Stream&& out, std::string indent = "", unsigned int verbosity = 1) const;
    
    static constexpr unsigned int MaxVerbosity = 3;
    
    
    
    // BEGIN TPC access --------------------------------------------------------
    
    unsigned int      NTPC()                                    const { return fTPCs.size();      }
    unsigned int      NElements()                               const { return fTPCs.size();      }
    
    bool HasTPC(unsigned int itpc) const { return itpc < NTPC(); }
    
    bool HasElement(unsigned int itpc) const { return HasTPC(itpc); }
    
    bool HasTPC(geo::TPCID const& tpcid) const { return HasTPC(tpcid.TPC); }
    bool HasElement(geo::TPCID const& tpcid) const { return HasTPC(tpcid); }
    
    const TPCGeo&     TPC(unsigned int itpc)                    const;
    
    const TPCGeo&     TPC(TPCID const& tpcid)                   const
      { return TPC(tpcid.TPC); }
    const TPCGeo&     GetElement(TPCID const& tpcid)            const
      { return TPC(tpcid); }
    
    
    auto const& TPCs() const { return fTPCs; }
    
    TPCGeo const*     TPCPtr(unsigned int itpc)                    const
      { return HasTPC(itpc)? &(fTPCs[itpc]): nullptr; }
    
    TPCGeo const*     TPCPtr(TPCID const& tpcid)                   const
      { return TPCPtr(tpcid.TPC); }
    TPCGeo const*     GetElementPtr(TPCID const& tpcid)            const
      { return TPCPtr(tpcid); }
    
    geo::TPCID::TPCID_t FindTPCAtPosition
      (double const worldLoc[3], double const wiggle) const;
    
    geo::TPCID PositionToTPCID
      (geo::Point_t const& point, double wiggle) const;
    
    TPCGeo const& PositionToTPC
      (geo::Point_t const& point, double wiggle) const;
    TPCGeo const& PositionToTPC
      (double const  worldLoc[3], double wiggle) const
      { return PositionToTPC(geo::vect::makePointFromCoords(worldLoc), wiggle); }
    
    geo::TPCGeo const* PositionToTPCptr
      (geo::Point_t const& point, double wiggle) const;
    
    unsigned int MaxPlanes() const;
    
    unsigned int MaxWires() const;
    
    // END TPC access ----------------------------------------------------------
    
    
    // BEGIN Optical detector access -------------------------------------------
    
    unsigned int      NOpDet()                                  const { return fOpDets.size();    }
    
    const OpDetGeo&   OpDet(unsigned int iopdet)                const;
    
    unsigned int GetClosestOpDet(geo::Point_t const& point) const;
    unsigned int GetClosestOpDet(double const* point) const;
    
    geo::OpDetGeo const* GetClosestOpDetPtr(geo::Point_t const& point) const;
    
    std::string  OpDetGeoName()                                 const { return fOpDetGeoName; }

    // END Optical detector access ---------------------------------------------
    
    // BEGIN Coordinate transformation -----------------------------------------
    
    void LocalToWorld(const double* cryo, double* world) const
      { fTrans.LocalToWorld(cryo, world); }
      
    template <typename Point>
    [[deprecated("use toWorldCoords() instead")]]
    Point LocalToWorld(Point const& local) const
      { return fTrans.LocalToWorld(local); }
    
    geo::Point_t toWorldCoords(LocalPoint_t const& local) const
      { return fTrans.toWorldCoords(local); }
    
    void LocalToWorldVect(const double* cryo, double* world) const
      { fTrans.LocalToWorldVect(cryo, world); }
    
    geo::Vector_t toWorldCoords(LocalVector_t const& local) const
      { return fTrans.toWorldCoords(local); }
    
    void WorldToLocal(const double* world, double* cryo) const
      { fTrans.WorldToLocal(world, cryo); }
    
    template <typename Point>
    [[deprecated("use toLocalCoords() instead")]]
    Point WorldToLocal(Point const& world) const
      { return fTrans.WorldToLocal(world); }
    
    LocalPoint_t toLocalCoords(geo::Point_t const& world) const
      { return fTrans.toLocalCoords(world); }
    
    void WorldToLocalVect(const double* world, double* cryo) const
      { fTrans.WorldToLocalVect(world, cryo); }
    
    LocalVector_t toLocalCoords(geo::Vector_t const& world) const
      { return fTrans.toLocalCoords(world); }
    
    // END Coordinate transformation -------------------------------------------
    
    
    void              SortSubVolumes(geo::GeoObjectSorter const& sorter);

    
    void UpdateAfterSorting(geo::CryostatID cryoid);
    
  private:

    void FindTPC(std::vector<const TGeoNode*>& path,
                 unsigned int depth);
    void MakeTPC(std::vector<const TGeoNode*>& path,
                 int depth);
    
    void FindOpDet(std::vector<const TGeoNode*>& path,
                   unsigned int depth);
    void MakeOpDet(std::vector<const TGeoNode*>& path,
                   int depth);

    void InitCryoBoundaries();
    

  private:
    
    using LocalTransformation_t
      = geo::LocalTransformationGeo<TGeoHMatrix, LocalPoint_t, LocalVector_t>;
    
    LocalTransformation_t  fTrans;          
    TPCList_t              fTPCs;           
    std::vector<OpDetGeo>  fOpDets;         
    TGeoVolume*            fVolume;         
    std::string            fOpDetGeoName;   
    geo::CryostatID        fID;             
    
  };
}


//------------------------------------------------------------------------------
//--- template implementation
//---
template <typename Stream>
void geo::CryostatGeo::PrintCryostatInfo(
  Stream&& out,
  std::string indent /* = "" */,
  unsigned int verbosity /* = 1 */
) const {
  
  //----------------------------------------------------------------------------
  out << "Cryostat " << 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
    << "hosts " << NTPC() << " TPCs (largest number of planes: " << MaxPlanes()
      << ", of wires: " << MaxWires() << ") and "
      << NOpDet() << " optical detectors"
    ;
  
  if (verbosity-- <= 0) return; // 2
  
  //----------------------------------------------------------------------------
  // print also the containing box
  geo::BoxBoundedGeo const& box = BoundingBox();
  out << "\n" << indent
    << "bounding box: " << box.Min() << " -- " << box.Max();
  
//  if (verbosity-- <= 0) return; // 3
  
  //----------------------------------------------------------------------------
} // geo::CryostatGeo::PrintCryostatInfo()


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


#endif // LARCOREALG_GEOMETRY_CRYOSTATGEO_H