DDSolid.h

Go to the documentation of this file.

#ifndef DETECTOR_DESCRIPTION_CORE_DD_SOLID_H
#define DETECTOR_DESCRIPTION_CORE_DD_SOLID_H
 
#include <cstddef>
#include <iosfwd>
#include <memory>
#include <vector>
 
#include "DetectorDescription/Core/interface/DDTranslation.h"
#include "DetectorDescription/Core/interface/DDBase.h"
#include "DetectorDescription/Core/interface/DDName.h"
#include "DetectorDescription/Core/interface/DDSolidShapes.h"
#include "DetectorDescription/Core/interface/DDTransform.h"
 
class DDSolid;
 
namespace DDI {
  class BooleanSolid;
  class MultiUnion;
  class Reflection;
  class Solid;
}  // namespace DDI
struct DDSolidFactory;
 
std::ostream& operator<<(std::ostream&, const DDSolid&);
 
 
class DDSolid : public DDBase<DDName, std::unique_ptr<DDI::Solid>> {
  friend std::ostream& operator<<(std::ostream&, const DDSolid&);
  friend struct DDSolidFactory;
 
public:
  DDSolid(void);
 
 
  DDSolid(const DDName& name);
 
  const std::vector<double>& parameters(void) const;
 
  double volume(void) const;
 
  DDSolidShape shape(void) const;
 
private:
  DDSolid(const DDName&, std::unique_ptr<DDI::Solid>);
  DDSolid(const DDName&, DDSolidShape, const std::vector<double>&);
};
 
 
class DDTrap : public DDSolid {
public:
  DDTrap(const DDSolid& s);
  DDTrap(void) = delete;
 
  double halfZ(void) const;
  double theta(void) const;
  double phi(void) const;
  double y1(void) const;
  double x1(void) const;
  double x2(void) const;
  double alpha1(void) const;
  double y2(void) const;
  double x3(void) const;
  double x4(void) const;
  double alpha2(void) const;
};
 
class DDPseudoTrap : public DDSolid {
public:
  DDPseudoTrap(const DDSolid& s);
  DDPseudoTrap(void) = delete;
 
  double halfZ(void) const;
  double x1(void) const;
  double x2(void) const;
  double y1(void) const;
  double y2(void) const;
  double radius(void) const;
  bool atMinusZ(void) const;
};
 
class DDTruncTubs : public DDSolid {
public:
  DDTruncTubs(const DDSolid& s);
  DDTruncTubs(void) = delete;
 
  double zHalf(void) const;
  double rIn(void) const;
  double rOut(void) const;
  double startPhi(void) const;
  double deltaPhi(void) const;
  double cutAtStart(void) const;
  double cutAtDelta(void) const;
  bool cutInside(void) const;
};
 
 
class DDBox : public DDSolid {
public:
  DDBox(const DDSolid& s);
  DDBox(void) = delete;
 
  double halfX(void) const;
  double halfY(void) const;
  double halfZ(void) const;
};
 
class DDShapelessSolid : public DDSolid {
public:
  DDShapelessSolid(const DDSolid& s);
  DDShapelessSolid(void) = delete;
};
 
class DDBooleanSolid : public DDSolid {
public:
  DDBooleanSolid(const DDSolid& s);
  DDBooleanSolid(void) = delete;
 
  DDSolid solidA(void) const;
  DDSolid solidB(void) const;
  DDTranslation translation(void) const;
  DDRotation rotation(void) const;
 
private:
  const DDI::BooleanSolid& boolean_;
};
 
class DDMultiUnionSolid : public DDSolid {
public:
  DDMultiUnionSolid(const DDSolid& s);
  DDMultiUnionSolid(void) = delete;
 
  const std::vector<DDSolid>& solids(void) const;
  const std::vector<DDTranslation>& translations(void) const;
  const std::vector<DDRotation>& rotations(void) const;
 
private:
  DDI::MultiUnion* union_;
};
 
class DDPolySolid : public DDSolid {
public:
  DDPolySolid(const DDSolid& s);
  DDPolySolid(void) = delete;
 
protected:
  virtual std::vector<double> getVec(const size_t& which, const size_t& offset = 0, const size_t& nVecs = 1) const;
};
 
class DDPolycone : public DDPolySolid {
public:
  DDPolycone(const DDSolid& s);
  DDPolycone(void) = delete;
 
  double startPhi(void) const;
  double deltaPhi(void) const;
  std::vector<double> zVec(void) const;
  std::vector<double> rVec(void) const;
  std::vector<double> rMinVec(void) const;
  std::vector<double> rMaxVec(void) const;
};
 
class DDPolyhedra : public DDPolySolid {
public:
  DDPolyhedra(const DDSolid& s);
  DDPolyhedra(void) = delete;
 
  int sides(void) const;
  double startPhi(void) const;
  double deltaPhi(void) const;
  std::vector<double> zVec(void) const;
  std::vector<double> rVec(void) const;
  std::vector<double> rMinVec(void) const;
  std::vector<double> rMaxVec(void) const;
};
 
class DDExtrudedPolygon : public DDPolySolid {
public:
  DDExtrudedPolygon(const DDSolid& s);
  DDExtrudedPolygon(void) = delete;
 
  std::vector<double> xVec(void) const;
  std::vector<double> yVec(void) const;
  std::vector<double> zVec(void) const;
  std::vector<double> zxVec(void) const;
  std::vector<double> zyVec(void) const;
  std::vector<double> zscaleVec(void) const;
 
private:
  auto xyPointsSize(void) const -> std::size_t;
  auto zSectionsSize(void) const -> std::size_t;
};
 
class DDTubs : public DDSolid {
public:
  DDTubs(const DDSolid& s);
  DDTubs(void) = delete;
 
  double zhalf(void) const;
  double rIn(void) const;
  double rOut(void) const;
  double startPhi(void) const;
  double deltaPhi(void) const;
};
 
class DDCutTubs : public DDSolid {
public:
  DDCutTubs(const DDSolid& s);
  DDCutTubs(void) = delete;
 
  double zhalf(void) const;
  double rIn(void) const;
  double rOut(void) const;
  double startPhi(void) const;
  double deltaPhi(void) const;
  std::array<double, 3> lowNorm(void) const;
  std::array<double, 3> highNorm(void) const;
};
 
class DDCons : public DDSolid {
public:
  DDCons(const DDSolid& s);
  DDCons(void) = delete;
 
  double zhalf(void) const;
  double rInMinusZ(void) const;
  double rOutMinusZ(void) const;
  double rInPlusZ(void) const;
  double rOutPlusZ(void) const;
  double phiFrom(void) const;
  double deltaPhi(void) const;
};
 
class DDTorus : public DDSolid {
public:
  DDTorus(const DDSolid& s);
  DDTorus(void) = delete;
 
  double rMin(void) const;
  double rMax(void) const;
  double rTorus(void) const;
  double startPhi(void) const;
  double deltaPhi(void) const;
};
 
class DDUnion : public DDBooleanSolid {
public:
  DDUnion(const DDSolid& s);
  DDUnion(void) = delete;
};
 
class DDMultiUnion : public DDMultiUnionSolid {
public:
  DDMultiUnion(const DDSolid& s);
  DDMultiUnion(void) = delete;
};
 
class DDIntersection : public DDBooleanSolid {
public:
  DDIntersection(const DDSolid& s);
  DDIntersection(void) = delete;
};
 
class DDSubtraction : public DDBooleanSolid {
public:
  DDSubtraction(const DDSolid& s);
  DDSubtraction(void) = delete;
};
 
class DDSphere : public DDSolid {
public:
  DDSphere(const DDSolid& s);
  DDSphere(void) = delete;
 
  double innerRadius(void) const;
  double outerRadius(void) const;
  double startPhi(void) const;
  double deltaPhi(void) const;
  double startTheta(void) const;
  double deltaTheta(void) const;
};
 
class DDOrb : public DDSolid {
public:
  DDOrb(const DDSolid& s);
  DDOrb(void) = delete;
 
  double radius(void) const;
};
 
class DDEllipticalTube : public DDSolid {
public:
  DDEllipticalTube(const DDSolid& s);
  DDEllipticalTube(void) = delete;
 
  double xSemiAxis(void) const;
  double ySemiAxis(void) const;
  double zHeight(void) const;
};
 
class DDEllipsoid : public DDSolid {
public:
  DDEllipsoid(const DDSolid& s);
  DDEllipsoid(void) = delete;
 
  double xSemiAxis(void) const;
  double ySemiAxis(void) const;
  double zSemiAxis(void) const;
  double zBottomCut(void) const;
  double zTopCut(void) const;
};
 
class DDParallelepiped : public DDSolid {
public:
  DDParallelepiped(const DDSolid& s);
  DDParallelepiped(void) = delete;
 
  double xHalf(void) const;
  double yHalf(void) const;
  double zHalf(void) const;
  double alpha(void) const;
  double theta(void) const;
  double phi(void) const;
};
 
// Solid generation functions
//
struct DDSolidFactory {
 
  static DDSolid box(const DDName& name, double xHalf, double yHalf, double zHalf);
 
 
  static DDSolid polycone(const DDName& name,
                          double startPhi,
                          double deltaPhi,
                          const std::vector<double>& z,
                          const std::vector<double>& rmin,
                          const std::vector<double>& rmax);
 
 
  static DDSolid polycone(
      const DDName& name, double startPhi, double deltaPhi, const std::vector<double>& z, const std::vector<double>& r);
 
 
  static DDSolid polyhedra(const DDName& name,
                           int sides,
                           double startPhi,
                           double deltaPhi,
                           const std::vector<double>& z,
                           const std::vector<double>& rmin,
                           const std::vector<double>& rmax);
 
 
  static DDSolid polyhedra(const DDName& name,
                           int sides,
                           double startPhi,
                           double deltaPhi,
                           const std::vector<double>& z,
                           const std::vector<double>& r);
 
  static DDSolid unionSolid(
      const DDName& name, const DDSolid& a, const DDSolid& b, const DDTranslation& t, const DDRotation& r);
 
  static DDSolid multiUnionSolid(const DDName& name,
                                 const std::vector<DDSolid>& a,
                                 const std::vector<DDTranslation>& t,
                                 const std::vector<DDRotation>& r);
 
  static DDSolid intersection(
      const DDName& name, const DDSolid& a, const DDSolid& b, const DDTranslation& t, const DDRotation& r);
 
  static DDSolid subtraction(
      const DDName& name, const DDSolid& a, const DDSolid& b, const DDTranslation& t, const DDRotation& r);
 
  static DDSolid trap(const DDName& name,
                      double pDz,
                      double pTheta,
                      double pPhi,
                      double pDy1,
                      double pDx1,
                      double pDx2,
                      double pAlp1,
                      double pDy2,
                      double pDx3,
                      double pDx4,
                      double pAlp2);
 
  static DDSolid pseudoTrap(const DDName& name,
                            double pDx1,    
                            double pDx2,    
                            double pDy1,    
                            double pDy2,    
                            double pDz,     
                            double radius,  
                            bool atMinusZ); 
  static DDSolid truncTubs(const DDName& name,
                           double zHalf,      
                           double rIn,        
                           double rOut,       
                           double startPhi,   
                           double deltaPhi,   
                           double cutAtStart, 
                           double cutAtDelta, 
                           bool cutInside);
 
  static DDSolid tubs(const DDName& name, double zhalf, double rIn, double rOut, double startPhi, double deltaPhi);
 
  static DDSolid cuttubs(const DDName& name,
                         double zhalf,
                         double rIn,
                         double rOut,
                         double startPhi,
                         double deltaPhi,
                         double lx,
                         double ly,
                         double lz,
                         double tx,
                         double ty,
                         double tz);
 
  static DDSolid cons(const DDName& name,
                      double zhalf,
                      double rInMinusZ,
                      double rOutMinusZ,
                      double rInPlusZ,
                      double rOutPlusZ,
                      double phiFrom,
                      double deltaPhi);
 
  static DDSolid torus(const DDName& name, double rMin, double rMax, double rTorus, double startPhi, double deltaPhi);
 
  static DDSolid sphere(const DDName& name,
                        double innerRadius,
                        double outerRadius,
                        double startPhi,
                        double deltaPhi,
                        double startTheta,
                        double deltaTheta);
 
  static DDSolid orb(const DDName& name, double radius);
 
  static DDSolid ellipticalTube(const DDName& name, double xSemiAxis, double ySemiAxis, double zHeight);
 
  static DDSolid ellipsoid(const DDName& name,
                           double xSemiAxis,
                           double ySemiAxis,
                           double zSemiAxis,
                           double zBottomCut = 0.,
                           double zTopCut = 0.);
 
  static DDSolid parallelepiped(
      const DDName& name, double xHalf, double yHalf, double zHalf, double alpha, double theta, double phi);
 
  static DDSolid extrudedpolygon(const DDName& name,
                                 const std::vector<double>& x,
                                 const std::vector<double>& y,
                                 const std::vector<double>& z,
                                 const std::vector<double>& zx,
                                 const std::vector<double>& zy,
                                 const std::vector<double>& zscale);
 
  static DDSolid shapeless(const DDName& name);
 
  static DDSolid reflection(const DDName& name, const DDSolid& s);
};
 
#endif