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