CMSSW_4_4_3_patch1/src/DetectorDescription/Core/interface/DDSolid.h

Go to the documentation of this file.

#ifndef DDSolid_h
#define DDSolid_h

#include <iosfwd>
#include <vector>

#include "DetectorDescription/Core/interface/DDName.h"
#include "DetectorDescription/Core/interface/DDBase.h"
#include "DetectorDescription/Core/interface/DDSolidShapes.h"
#include "DetectorDescription/Core/interface/DDTransform.h"
#include "DetectorDescription/Base/interface/DDTranslation.h"

namespace DDI { class Solid; }
namespace DDI { class Reflection; }
namespace DDI { class BooleanSolid; }

class DDSolid;
class DDSolidFactory;
class DDStreamer;

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


class DDSolid : public DDBase<DDName, DDI::Solid*>
{
  friend std::ostream & operator<<( std::ostream &, const DDSolid & );
  friend class 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 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 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 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 shapeless( const DDName & name );

  static DDSolid reflection( const DDName & name,
                             const DDSolid & s );
};                                                                                                  
                                      
#endif