DDSolid.h

Go to the documentation of this file.

#ifndef DDSolid_h
#define DDSolid_h

#include <stddef.h>
#include <iosfwd>
#include <vector>

#include "DetectorDescription/Base/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;
class DDStreamer;
namespace DDI {
class BooleanSolid;
class Reflection;
class Solid;
}  // namespace DDI
struct DDSolidFactory;

std::ostream & operator<<( std::ostream &, const DDSolid & );


class DDSolid : public DDBase<DDName, DDI::Solid*>
{
  friend std::ostream & operator<<( std::ostream &, const DDSolid & );
  friend struct DDSolidFactory;
  friend class DDDToPersFactory;
  friend class DDPersToDDDFactory;
  friend class DDStreamer;
    
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 &, DDI::Solid * );    
  DDSolid( const DDName &, DDSolidShape, const std::vector<double> & );
};


class DDTrap : public DDSolid
{
public:
  DDTrap( const DDSolid & s );
  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;
  
private:
  DDTrap( void );
};

class DDPseudoTrap : public DDSolid
{
public:
  DDPseudoTrap( const DDSolid & s );
  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;

private:
  DDPseudoTrap( void );
};
  
class DDTruncTubs : public DDSolid
{
public:
  DDTruncTubs( const DDSolid & s );
  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;

private:
  DDTruncTubs( void );
};


class DDBox : public DDSolid
{
public:
  DDBox( const DDSolid & s );
  double halfX( void ) const; 
  double halfY( void ) const; 
  double halfZ( void ) const; 

private:
  DDBox( void );
};

class DDShapelessSolid : public DDSolid
{
public:
  DDShapelessSolid( const DDSolid & s );

private:
  DDShapelessSolid( void );
};

class DDReflectionSolid : public DDSolid
{
public:
  DDReflectionSolid( const DDSolid & s );
  DDSolid unreflected( void ) const;

private:
  DDReflectionSolid( void ); 
  DDI::Reflection * reflected_; 
}; 

class DDBooleanSolid : public DDSolid
{
public:
  DDBooleanSolid( const DDSolid & s );
  DDSolid solidA( void ) const;
  DDSolid solidB( void ) const;
  DDTranslation translation( void ) const;
  DDRotation rotation( void ) const;

private:
  DDBooleanSolid( void );
  DDI::BooleanSolid * boolean_;  
};

class DDPolySolid : public DDSolid
{
public:
  DDPolySolid( const DDSolid & s );

protected:
  virtual std::vector<double> getVec( const size_t& which, const size_t& offset = 0, const size_t& nVecs = 1 ) const;
  DDPolySolid( void );
};
  
class DDPolycone : public DDPolySolid
{
public:
  DDPolycone( const DDSolid & s );
  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;

private:
  DDPolycone( void );
};

class DDPolyhedra : public DDPolySolid
{
public:
  DDPolyhedra( const DDSolid & s );
  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;

private:
  DDPolyhedra( void );
};

class DDExtrudedPolygon : public DDPolySolid
{
public:
  DDExtrudedPolygon( const DDSolid & s );
  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:
  DDExtrudedPolygon( void );
};

class DDTubs : public DDSolid
{
public:
  DDTubs( const DDSolid & s );
  double zhalf( void ) const;
  double rIn( void ) const;
  double rOut( void ) const;
  double startPhi( void ) const;
  double deltaPhi( void ) const;

private:
  DDTubs( void );
};

class DDCutTubs : public DDSolid
{
public:
  DDCutTubs( const DDSolid & s );
  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;

private:
  DDCutTubs( void );
};

class DDCons : public DDSolid
{
public:
  DDCons( const DDSolid & s );
  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;

private:
  DDCons( void );
};

class DDTorus : public DDSolid
{
public:
  DDTorus( const DDSolid & s );
  double rMin( void ) const;
  double rMax( void ) const;
  double rTorus( void ) const;
  double startPhi( void ) const;
  double deltaPhi( void ) const;

private:
  DDTorus( void );
};

class DDUnion : public DDBooleanSolid
{
public:
  DDUnion( const DDSolid & s );
  
private:
  DDUnion( void );
};

class DDIntersection : public DDBooleanSolid
{
public:
  DDIntersection( const DDSolid & s );

private:
  DDIntersection( void );
};

class DDSubtraction : public DDBooleanSolid
{
public:
  DDSubtraction( const DDSolid & s );

private:
  DDSubtraction( void );
};

class DDSphere : public DDSolid
{
public:
  DDSphere( const DDSolid & s );
  double innerRadius( void ) const;
  double outerRadius( void ) const;
  double startPhi( void ) const;
  double deltaPhi( void ) const;
  double startTheta( void ) const;
  double deltaTheta( void ) const;

private:
  DDSphere( void );
};

class DDOrb : public DDSolid
{
public:
  DDOrb( const DDSolid & s );
  double radius( void ) const;

private:
  DDOrb( void );
};

class DDEllipticalTube : public DDSolid
{
public:
  DDEllipticalTube( const DDSolid & s );
  double xSemiAxis( void ) const;
  double ySemiAxis( void ) const;
  double zHeight( void ) const;
  
private:
  DDEllipticalTube( void );
};

class DDEllipsoid : public DDSolid
{
public:
  DDEllipsoid( const DDSolid & s );
  double xSemiAxis( void ) const;
  double ySemiAxis( void ) const;
  double zSemiAxis( void ) const;
  double zBottomCut( void ) const;
  double zTopCut( void ) const;

private:
  DDEllipsoid( void );
};

class DDParallelepiped : public DDSolid
{
public:
  DDParallelepiped( const DDSolid & s );
  double xHalf( void ) const;
  double yHalf( void ) const;
  double zHalf( void ) const;
  double alpha( void ) const;
  double theta( void ) const;
  double phi( void ) const;

private:
  DDParallelepiped( void );
};

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