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

  public:
    using ID_t = CryostatID;

    using TPCList_t = std::vector<TPCGeo>;

    using OpDetList_t = std::vector<OpDetGeo>;

    using GeoNodePath_t = WireGeo::GeoNodePath_t;

    using ElementIteratorBox = TPCList_t const&;


    struct CryostatGeoCoordinatesTag {};

    using LocalPoint_t = Point3DBase_t<CryostatGeoCoordinatesTag>;

    using LocalVector_t = Vector3DBase_t<CryostatGeoCoordinatesTag>;


    CryostatGeo(TGeoNode const* node,
                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; }

    BoxBoundedGeo const& Boundaries() const { return BoundingBox(); }

    void Boundaries(double* boundaries) const;

    Point_t GetCenter() const { return Boundaries().Center(); }

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

    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(TPCID const& tpcid) const { return HasTPC(tpcid.TPC); }
    bool HasElement(TPCID const& tpcid) const { return HasTPC(tpcid); }

    TPCGeo const& TPC(unsigned int itpc) const;

    TPCGeo const& TPC(TPCID const& tpcid) const { return TPC(tpcid.TPC); }
    TPCGeo const& 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); }

    TPCID PositionToTPCID(Point_t const& point, double wiggle) const;

    TPCGeo const& PositionToTPC(Point_t const& point, double wiggle) const;
    TPCGeo const& PositionToTPC(double const worldLoc[3], double wiggle) const
    {
      return PositionToTPC(vect::makePointFromCoords(worldLoc), wiggle);
    }

    TPCGeo const* PositionToTPCptr(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(); }

    OpDetGeo const& OpDet(unsigned int iopdet) const;

    unsigned int GetClosestOpDet(Point_t const& point) const;
    unsigned int GetClosestOpDet(double const* point) const;

    OpDetGeo const* GetClosestOpDetPtr(Point_t const& point) const;

    std::string OpDetGeoName() const { return fOpDetGeoName; }

    // END Optical detector access ---------------------------------------------

    // BEGIN Coordinate transformation -----------------------------------------

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

    // END Coordinate transformation -------------------------------------------

    void SortSubVolumes(GeoObjectSorter const& sorter);

    void UpdateAfterSorting(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 =
      LocalTransformationGeo<ROOT::Math::Transform3D, LocalPoint_t, LocalVector_t>;

    LocalTransformation_t fTrans; 
    TPCList_t fTPCs;              
    OpDetList_t fOpDets;          
    TGeoVolume* fVolume;          
    std::string fOpDetGeoName{"volOpDetSensitive"}; 
    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 and " << NOpDet() << " optical detectors";

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

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

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

#endif // LARCOREALG_GEOMETRY_CRYOSTATGEO_H