Shapes.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================

#ifndef DD4HEP_GEOMETRY_SOLIDS_H
#define DD4HEP_GEOMETRY_SOLIDS_H

// Framework include files
#include "DD4hep/Handle.h"
#include "DD4hep/Objects.h"

// C/C++ include files
#include <vector>


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated" // Code that causes warning goes here
#endif
// ROOT include files
#include "TGeoCone.h"
#include "TGeoParaboloid.h"
#include "TGeoPgon.h"
#include "TGeoPcon.h"
#include "TGeoSphere.h"
#include "TGeoArb8.h"
#include "TGeoTrd2.h"
#include "TGeoTube.h"
#include "TGeoEltu.h"
#include "TGeoHype.h"
#include "TGeoTorus.h"
#include "TGeoHalfSpace.h"
#include "TGeoCompositeShape.h"
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

namespace DD4hep {

  namespace Geometry {

    // Forward declarations

    std::string toStringSolid(const TGeoShape* shape, int precision=2);


    template <typename T> class Solid_type: public Handle<T> {
    protected:
      typedef T Implementation;
      void _setDimensions(double* param);
      void _assign(T* n, const std::string& nam, const std::string& tit, bool cbbox);

    public:

      Solid_type() = default;
      Solid_type(const Solid_type& e) = default;
      Solid_type(T* p) : Handle<T>(p) {  }
      Solid_type(const Handle<T>& e) : Handle<T>(e) {  }
      template <typename Q> Solid_type(const Handle<Q>& e) : Handle<T>(e) {  }
      Solid_type& operator=(const Solid_type& copy) = default;

      const char* name() const;
      const char* type() const;
      operator T*() const {
        return this->m_element;
      }
      T* operator->() const {
        return this->m_element;
      }
      std::string toString(int precision=2) const   {
        return toStringSolid(this->m_element,precision);
      }
    };
    typedef Solid_type<TGeoShape> Solid;


    class Box: public Solid_type<TGeoBBox> {
    protected:
      void make(double x_val, double y_val, double z_val);

    public:
      Box() = default;
      Box(const Box& e) = default;
      template <typename Q> Box(const Q* p) : Solid_type<TGeoBBox>(p) { }
      template <typename Q> Box(const Handle<Q>& e) : Solid_type<TGeoBBox>(e) { }
      Box(double x_val, double y_val, double z_val) {  make(x_val, y_val, z_val);  }
      template <typename X, typename Y, typename Z>
      Box(const X& x_val, const Y& y_val, const Z& z_val)  {
        make(_toDouble(x_val), _toDouble(y_val), _toDouble(z_val));
      }
      Box& operator=(const Box& copy) = default;
      Box& setDimensions(double x_val, double y_val, double z_val);
      double x() const;
      double y() const;
      double z() const;
    };


    class HalfSpace: public Solid_type<TGeoHalfSpace> {
    protected:
      void make(const double* const point, const double* const normal);

    public:
      HalfSpace() = default;
      HalfSpace(const HalfSpace& e) = default;
      template <typename Q> HalfSpace(const Q* p) : Solid_type<TGeoHalfSpace>(p) { }
      template <typename Q> HalfSpace(const Handle<Q>& e) : Solid_type<TGeoHalfSpace>(e) { }
      HalfSpace(const double* const point, const double* const normal) { make(point,normal);  }
      HalfSpace& operator=(const HalfSpace& copy) = default;
    };


    class Polycone: public Solid_type<TGeoPcon> {
    public:
      Polycone() = default;
      Polycone(const Polycone& e) = default;
      template <typename Q> Polycone(const Q* p) : Solid_type<TGeoPcon>(p) {  }
      template <typename Q> Polycone(const Handle<Q>& e) : Solid_type<TGeoPcon>(e) { }
      Polycone(double start, double delta);

      Polycone(double start, double delta, const std::vector<double>& rmin, const std::vector<double>& rmax,
               const std::vector<double>& z);
      Polycone& operator=(const Polycone& copy) = default;

      void addZPlanes(const std::vector<double>& rmin, const std::vector<double>& rmax, const std::vector<double>& z);
    };


    class ConeSegment: public Solid_type<TGeoConeSeg> {
    public:
      ConeSegment() = default;
      ConeSegment(const ConeSegment& e) = default;
      template <typename Q> ConeSegment(const Q* p) : Solid_type<TGeoConeSeg>(p) {  }
      template <typename Q> ConeSegment(const Handle<Q>& e) : Solid_type<TGeoConeSeg>(e) {  }
      ConeSegment(double dz, double rmin1, double rmax1, double rmin2, double rmax2, double phi1 = 0.0, double phi2 = 2.0 * M_PI);
      ConeSegment& operator=(const ConeSegment& copy) = default;

      ConeSegment& setDimensions(double dz, double rmin1, double rmax1,
                                 double rmin2, double rmax2, double phi1 = 0.0, double phi2 = 2.0 * M_PI);
    };

    class MyConeSeg: public TGeoConeSeg {
    public:
      MyConeSeg() : TGeoConeSeg() { }
      virtual ~MyConeSeg() { }
      double GetRmin() const {        return GetRmin1();      }
      double GetRmax() const {        return GetRmax1();      }
    };


    class Tube: public Solid_type< /*TGeoTubeSeg */MyConeSeg> {
    protected:
      void make(const std::string& nam, double rmin, double rmax, double z, double startPhi, double deltaPhi);

    public:
      Tube() = default;
      Tube(const Tube& e) = default;
      template <typename Q> Tube(const Q* p) : Solid_type<MyConeSeg>(p) {  }
      template <typename Q> Tube(const Handle<Q>& e) : Solid_type<MyConeSeg>(e) {  }
      Tube(double rmin, double rmax, double z)
      {   make("", rmin, rmax, z, 0, 2*M_PI);               }
      Tube(double rmin, double rmax, double z, double deltaPhi)
      {   make("", rmin, rmax, z, 0, deltaPhi);             }
      Tube(double rmin, double rmax, double z, double startPhi, double deltaPhi)
      {   make("", rmin, rmax, z, startPhi, deltaPhi);      }
      Tube(const std::string& nam, double rmin, double rmax, double z)
      {   make(nam, rmin, rmax, z, 0, 2*M_PI);              }
      Tube(const std::string& nam, double rmin, double rmax, double z, double deltaPhi)
      {  make(nam, rmin, rmax, z, 0, deltaPhi);             }
      template <typename RMIN, typename RMAX, typename Z, typename DELTAPHI>
      Tube(const RMIN& rmin, const RMAX& rmax, const Z& z, const DELTAPHI& deltaPhi)
      {  make("", _toDouble(rmin), _toDouble(rmax), _toDouble(z), 0, _toDouble(deltaPhi));   }
      Tube& operator=(const Tube& copy) = default;
      Tube& setDimensions(double rmin, double rmax, double z, double startPhi=0.0, double deltaPhi=2*M_PI);
    };


    class EllipticalTube: public Solid_type<TGeoEltu> {
    protected:
      void make(double a, double b, double dz);

    public:
      EllipticalTube() = default;
      EllipticalTube(const EllipticalTube& e) = default;
      template <typename Q> EllipticalTube(const Q* p) : Solid_type<TGeoEltu>(p) {   }
      template <typename Q> EllipticalTube(const Handle<Q>& e) : Solid_type<TGeoEltu>(e) {   }
      EllipticalTube(double a, double b, double dz) {  make(a, b, dz);  }
      template <typename A, typename B, typename DZ>
      EllipticalTube(const A& a, const B& b, const DZ& dz)
      {  make(_toDouble(a), _toDouble(b), _toDouble(dz));   }
      EllipticalTube& operator=(const EllipticalTube& copy) = default;
      EllipticalTube& setDimensions(double a, double b, double dz);
    };


    class Cone: public Solid_type<TGeoCone> {
    protected:
      void make(double z, double rmin1, double rmax1, double rmin2, double rmax2);
    public:
      Cone() = default;
      Cone(const Cone& e) = default;
      template <typename Q> Cone(const Q* p) : Solid_type<TGeoCone>(p) { }
      template <typename Q> Cone(const Handle<Q>& e) : Solid_type<TGeoCone>(e) { }
      Cone(double z, double rmin1, double rmax1, double rmin2, double rmax2)
      {     make(z, rmin1, rmax1, rmin2, rmax2);                                 }
      template <typename Z, typename RMIN1, typename RMAX1, typename RMIN2, typename RMAX2>
      Cone(const Z& z, const RMIN1& rmin1, const RMAX1& rmax1, const RMIN2& rmin2, const RMAX2& rmax2)
      {     make(_toDouble(z), _toDouble(rmin1), _toDouble(rmax1), _toDouble(rmin2), _toDouble(rmax2)); }
      Cone& operator=(const Cone& copy) = default;
      Cone& setDimensions(double z, double rmin1, double rmax1, double rmin2, double rmax2);
    };


    class Trap: public Solid_type<TGeoTrap> {
    private:
      void make(double pz, double py, double px, double pLTX);
    public:
      Trap() = default;
      Trap(const Trap& e) = default;
      template <typename Q> Trap(const Q* p) : Solid_type<TGeoTrap>(p) { }
      template <typename Q> Trap(const Handle<Q>& e) : Solid_type<TGeoTrap>(e) { }
      Trap(double z, double theta, double phi,
           double y1, double x1, double x2, double alpha1,
           double y2, double x3, double x4, double alpha2);
      Trap(double pz, double py, double px, double pLTX)  {  make(pz,py,px,pLTX);  }
      template <typename PZ,typename PY,typename PX,typename PLTX> Trap(PZ pz, PY py, PX px, PLTX pLTX)
      { make(_toDouble(pz),_toDouble(py),_toDouble(px),_toDouble(pLTX)); }
      Trap& operator=(const Trap& copy) = default;
      Trap& setDimensions(double z, double theta, double phi, 
                          double y1, double x1, double x2, double alpha1, 
                          double y2, double x3, double x4, double alpha2);
    };


    class Trapezoid: public Solid_type<TGeoTrd2> {
    private:
      void make(double x1, double x2, double y1, double y2, double z);

    public:
      Trapezoid() = default;
      Trapezoid(const Trapezoid& e) = default;
      template <typename Q> Trapezoid(const Q* p) : Solid_type<TGeoTrd2>(p) { }
      template <typename Q> Trapezoid(const Handle<Q>& e) : Solid_type<TGeoTrd2>(e) { }
      Trapezoid(double x1, double x2, double y1, double y2, double z);
      template <typename X1,typename X2,typename Y1,typename Y2,typename Z>
      Trapezoid(X1 x1, X2 x2, Y1 y1, Y2 y2, Z z)
      { make(_toDouble(x1),_toDouble(x2),_toDouble(y1),_toDouble(y2),_toDouble(z)); }
      Trapezoid& operator=(const Trapezoid& copy) = default;
      Trapezoid& setDimensions(double x1, double x2, double y1, double y2, double z);
    };


    class Torus: public Solid_type<TGeoTorus> {
    private:
      void make(double r, double rmin, double rmax, double phi, double delta_phi);
    public:
      Torus() = default;
      Torus(const Torus& e) = default;
      template <typename Q> Torus(const Q* p) : Solid_type<TGeoTorus>(p) { }
      template <typename Q> Torus(const Handle<Q>& e) : Solid_type<TGeoTorus>(e) {  }
      template<typename R, typename RMIN, typename RMAX, typename PHI, typename DELTA_PHI>
      Torus(R r, RMIN rmin, RMAX rmax, PHI phi=M_PI, DELTA_PHI delta_phi = 2.*M_PI)
      {   make(_toDouble(r),_toDouble(rmin),_toDouble(rmax),_toDouble(phi),_toDouble(delta_phi));  }
      Torus(double r, double rmin, double rmax, double phi=M_PI, double delta_phi = 2.*M_PI)
      {   make(r,rmin,rmax,phi,delta_phi);  }
      Torus& operator=(const Torus& copy) = default;
      Torus& setDimensions(double r, double rmin, double rmax, double phi, double delta_phi);
    };


    class Sphere: public Solid_type<TGeoSphere> {
    public:
      Sphere() = default;
      Sphere(const Sphere& e) = default;
      template <typename Q> Sphere(const Q* p) : Solid_type<TGeoSphere>(p) { }
      template <typename Q> Sphere(const Handle<Q>& e) : Solid_type<TGeoSphere>(e) {  }
      Sphere(double rmin, double rmax, double theta = 0., double delta_theta = M_PI, double phi = 0.0, double delta_phi = 2. * M_PI);
      Sphere& operator=(const Sphere& copy) = default;
      Sphere& setDimensions(double rmin, double rmax, double theta, double delta_theta, double phi, double delta_phi);
    };


    class Paraboloid: public Solid_type<TGeoParaboloid> {
    public:
      Paraboloid() = default;
      Paraboloid(const Paraboloid& e) = default;
      template <typename Q> Paraboloid(const Q* p) : Solid_type<TGeoParaboloid>(p) { }
      template <typename Q> Paraboloid(const Handle<Q>& e) : Solid_type<TGeoParaboloid>(e) { }
      Paraboloid(double r_low, double r_high, double delta_z);
      Paraboloid& operator=(const Paraboloid& copy) = default;
      Paraboloid& setDimensions(double r_low, double r_high, double delta_z);
    };


    class Hyperboloid: public Solid_type<TGeoHype> {
    public:
      Hyperboloid() = default;
      Hyperboloid(const Hyperboloid& e) = default;
      template <typename Q> Hyperboloid(const Q* p) : Solid_type<TGeoHype>(p) {  }
      template <typename Q> Hyperboloid(const Handle<Q>& e) : Solid_type<TGeoHype>(e) {   }
      Hyperboloid(double rin, double stin, double rout, double stout, double dz);
      Hyperboloid& operator=(const Hyperboloid& copy) = default;
      Hyperboloid& setDimensions(double rin, double stin, double rout, double stout, double dz);
    };


    class PolyhedraRegular: public Solid_type<TGeoPgon> {
    protected:
      void _create(int nsides, double rmin, double rmax, double zpos, double zneg, double start, double delta);
    public:
      PolyhedraRegular() = default;
      PolyhedraRegular(const PolyhedraRegular& e) = default;
      template <typename Q> PolyhedraRegular(const Q* p) : Solid_type<TGeoPgon>(p) {  }
      template <typename Q> PolyhedraRegular(const Handle<Q>& e) : Solid_type<TGeoPgon>(e) {  }
      PolyhedraRegular(int nsides, double rmin, double rmax, double zlen);
      PolyhedraRegular(int nsides, double rmin, double rmax, double zplanes[2]);
      PolyhedraRegular(int nsides, double phi_start, double rmin, double rmax, double zlen);
      PolyhedraRegular& operator=(const PolyhedraRegular& copy) = default;
    };


    class EightPointSolid: public Solid_type<TGeoArb8> {
    private:
      void make(double dz, const double* vtx);
    public:
      EightPointSolid() = default;
      EightPointSolid(const EightPointSolid& e) = default;
      template <typename Q> EightPointSolid(const Q* p) : Solid_type<TGeoArb8>(p) { }
      template <typename Q> EightPointSolid(const Handle<Q>& e) : Solid_type<TGeoArb8>(e) {}
      EightPointSolid(double dz, const double* vertices) { make(dz,vertices);  }
      EightPointSolid& operator=(const EightPointSolid& copy) = default;
    };


    class BooleanSolid: public Solid_type<TGeoCompositeShape> {
    protected:
      BooleanSolid() = default;
      BooleanSolid(const BooleanSolid& b) = default;
      
    public:
      template <typename Q>
      BooleanSolid(const Handle<Q>& e) : Solid_type<TGeoCompositeShape>(e) { }
      BooleanSolid& operator=(const BooleanSolid& copy) = default;
    };


    class SubtractionSolid: public BooleanSolid {
    public:
      SubtractionSolid() = default;
      SubtractionSolid(const SubtractionSolid& e) = default;
      template <typename Q> SubtractionSolid(const Handle<Q>& e) : BooleanSolid(e) {  }
      SubtractionSolid(const Solid& shape1, const Solid& shape2);
      SubtractionSolid(const Solid& shape1, const Solid& shape2, const Position& pos);
      SubtractionSolid(const Solid& shape1, const Solid& shape2, const RotationZYX& rot);
      SubtractionSolid(const Solid& shape1, const Solid& shape2, const Rotation3D& rot);
      SubtractionSolid(const Solid& shape1, const Solid& shape2, const Transform3D& pos);
      SubtractionSolid& operator=(const SubtractionSolid& copy) = default;
    };


    class UnionSolid: public BooleanSolid {
    public:
      UnionSolid() = default;
      UnionSolid(const UnionSolid& e) = default;
      template <typename Q> UnionSolid(const Handle<Q>& e) : BooleanSolid(e) { }
      UnionSolid(const Solid& shape1, const Solid& shape2);
      UnionSolid(const Solid& shape1, const Solid& shape2, const Position& pos);
      UnionSolid(const Solid& shape1, const Solid& shape2, const RotationZYX& rot);
      UnionSolid(const Solid& shape1, const Solid& shape2, const Rotation3D& rot);
      UnionSolid(const Solid& shape1, const Solid& shape2, const Transform3D& pos);
      UnionSolid& operator=(const UnionSolid& copy) = default;
    };


    class IntersectionSolid: public BooleanSolid {
    public:
      IntersectionSolid() = default;
      IntersectionSolid(const IntersectionSolid& e) = default;
      template <typename Q> IntersectionSolid(const Handle<Q>& e) : BooleanSolid(e) { }
      IntersectionSolid(const Solid& shape1, const Solid& shape2);
      IntersectionSolid(const Solid& shape1, const Solid& shape2, const Position& pos);
      IntersectionSolid(const Solid& shape1, const Solid& shape2, const RotationZYX& rot);
      IntersectionSolid(const Solid& shape1, const Solid& shape2, const Rotation3D& rot);
      IntersectionSolid(const Solid& shape1, const Solid& shape2, const Transform3D& pos);
      IntersectionSolid& operator=(const IntersectionSolid& copy) = default;
    };

  } /* End namespace Geometry           */
} /* End namespace DD4hep             */
#endif    /* DD4HEP_GEOMETRY_SOLIDS_H         */