CryostatGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_CRYOSTATGEO_H
#define LARCOREALG_GEOMETRY_CRYOSTATGEO_H

// LArSoft libraries
#include "larcorealg/Geometry/BoxBoundedGeo.h"
#include "larcorealg/Geometry/GeoVectorLocalTransformation.h" // for LocalT...
#include "larcorealg/Geometry/LocalTransformationGeo.h"       // for LocalT...
#include "larcorealg/Geometry/OpDetGeo.h"
#include "larcorealg/Geometry/TPCGeo.h"
#include "larcorealg/Geometry/TransformationMatrix.h"
#include "larcorealg/Geometry/WireGeo.h"           // for WireGeo
#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 "Math/GenVector/DisplacementVector3D.h"
#include "Math/GenVector/PositionVector3D.h"
#include "Math/GenVector/Transform3D.h"
#include "TGeoVolume.h"

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

// forward declarations
class TGeoNode;

namespace geo {

  class GeoObjectSorter;

  //......................................................................
  class CryostatGeo : public geo::BoxBoundedGeo {

  public:
    using ID_t = CryostatID;

    using TPCList_t = std::vector<geo::TPCGeo>;

    using OpDetList_t = std::vector<geo::OpDetGeo>;

    using GeoNodePath_t = geo::WireGeo::GeoNodePath_t;

    using ElementIteratorBox = TPCList_t const&;


    struct CryostatGeoCoordinatesTag {};

    using LocalPoint_t = geo::Point3DBase_t<CryostatGeoCoordinatesTag>;

    using LocalVector_t = geo::Vector3DBase_t<CryostatGeoCoordinatesTag>;


    CryostatGeo(TGeoNode const& node,
                geo::TransformationMatrix&& trans,
                TPCList_t&& TPCs,
                OpDetList_t&& OpDets);


    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;

    std::string CryostatInfo(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); }

    ElementIteratorBox IterateElements() const;

    ElementIteratorBox IterateTPCs() const { return IterateElements(); }

    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 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 -----------------------------------------

    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);
    }

    // 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<ROOT::Math::Transform3D, LocalPoint_t, LocalVector_t>;

    LocalTransformation_t fTrans; 
    TPCList_t fTPCs;              
    OpDetList_t 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