DDSolid.h

Go to the documentation of this file.

#ifndef DDSolid_h
#define DDSolid_h

#include <stdexcept>
#include <iosfwd>
#include <vector>
#include <utility>

#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 DDSolidImpl;
class DDSolid;

class DDSolidFactory;
class DDStreamer;
//class DDBooleanImpl;

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();
  

  DDSolid(const DDName & name); 
  

  const std::vector<double> & parameters() const;// { return rep().parameters(); }
  
  double volume() const; // { return rep().volume(); }
  
  DDSolidShape shape() const; // { return rep().shape(); }
  
  //bool boolean() const; // { return rep().boolean(); }
  

  //DDSolidShape boolean( DDSolid & A, DDSolid & B, DDRotation &, DDTranslation &);

/*   static void clear(); */
  
private:
  DDSolid(const DDName &, DDI::Solid *);    
  DDSolid(const DDName &, DDSolidShape, const std::vector<double> &);
};

  struct Composites {
     Composites (const DDSolid & A, const DDSolid & B,
                const DDTranslation & T, const DDRotation & R)
           : a_(A), b_(B), t_(T), r_(R) { }
     const DDSolid a_, b_;
     const DDTranslation t_;
     const DDRotation r_;            
  }; 


class DDTrap : public DDSolid
{
public:
  DDTrap(const DDSolid & s);
  double halfZ() const;
  double theta() const;
  double phi() const;
  double y1() const;
  double x1() const;
  double x2() const;
  double alpha1() const;
  double y2() const;
  double x3() const;
  double x4() const;
  double alpha2() const;
};

class DDPseudoTrap : public DDSolid
{
public:
   DDPseudoTrap(const DDSolid & s);
   double halfZ() const;
   double x1() const;
   double x2() const;
   double y1() const;
   double y2() const;   
   double radius() const;
   bool atMinusZ() const;
};
  
class DDTruncTubs : public DDSolid
{
public:
  DDTruncTubs(const DDSolid & s);
  double zHalf() const;
  double rIn() const;
  double rOut() const;
  double startPhi() const;
  double deltaPhi() const;
  double cutAtStart() const;
  double cutAtDelta() const;
  bool cutInside() const;
};
class DDBox : public DDSolid
{
public:
  DDBox(const DDSolid & s);
  double halfX() const; 
  double halfY() const; 
  double halfZ() const; 
private:
  DDBox();
};

class DDShapelessSolid : public DDSolid

{
 public:
  DDShapelessSolid(const DDSolid & s);

 private:
  DDShapelessSolid();
};

class DDReflectionSolid : public DDSolid
{
public:
  DDReflectionSolid(const DDSolid & s);
  DDSolid unreflected() const;
private:
  DDReflectionSolid(); 
  DDI::Reflection * reflected_; 
}; 


class DDBooleanSolid : public DDSolid
{
public:
  DDBooleanSolid(const DDSolid & s);
  DDSolid solidA() const;
  DDSolid solidB() const;
  DDTranslation translation() const;
  DDRotation rotation() const;
private:
  DDBooleanSolid();
  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();

};
  
class DDPolycone : public DDPolySolid
{
 public:
  DDPolycone(const DDSolid & s);
  double startPhi() const;
  double deltaPhi() const;
  std::vector<double> zVec() const;
  std::vector<double> rVec() const;
  std::vector<double> rMinVec() const;
  std::vector<double> rMaxVec() const;

 private:
  DDPolycone();
};

class DDPolyhedra : public DDPolySolid
{
 public:
  DDPolyhedra(const DDSolid & s);
  int sides() const;
  double startPhi() const;
  double deltaPhi() const;
  std::vector<double> zVec() const;
  std::vector<double> rVec() const;
  std::vector<double> rMinVec() const;
  std::vector<double> rMaxVec() const;

 private:
  DDPolyhedra();
};

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

 private:
  DDTubs();
};

class DDCons : public DDSolid
{
 public:
  DDCons(const DDSolid & s);
  double zhalf() const;
  double rInMinusZ() const;
  double rOutMinusZ() const;
  double rInPlusZ() const;
  double rOutPlusZ() const;
  double phiFrom() const;
  double deltaPhi() const;

 private:
  DDCons();
};

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

 private:
  DDTorus
();
};

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

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

 private:
  DDIntersection();
};

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

 private:
  DDSubtraction();
};


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

 private:
  DDSphere();
};

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

 private:
  DDOrb();
};

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

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

 private:
  DDEllipsoid();
};

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

 private:
  DDParallelepiped();
};

// Solid generation function

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

};                                                                  
                          
/* //! Creates a cone or a cone-section (refere to \b Geant4 documentation) */
/* /\** The center of the cone or cone-section (for positioning) is the center of */
/*     coordinates of its definition (x=y=z=0). */
/* *\/     */
/* DDSolid *      DDcons(const DDName & name, */
/*                      double zhalf, */
/*           double rInMinusZ, */
/*           double rOutMinusZ, */
/*           double rInPlusZ, */
/*           double rOutPlusZ, */
/*           double startPhi, */
/*           double deltaPhi); */

/* //! Creates a torus or a toroidal-section (refere to \b Geant4 documentation) */
/* /\** The center of the torus or toroidal-section (for positioning) is the center of */
/*     coordinates of its definition (x=y=z=0). */
/* *\/     */
/* DDSolid *      DDtorus(const DDName & name, */
/*             double rMin, */
/*             double rMax, */
/*             double rTorus, */
/*             double startPhi, */
/*             double deltaPhi); */

/* //! Creates a tube or a tube-section (refere to \b Geant4 documentation) */
/* /\** The center of the tube or tube-section (for positioning) is the center of */
/*     coordinates of its definition (x=y=z=0). */
/* *\/     */
/* DDSolid *      DDtubs(const DDName & name, */
/*                      double zhalf, */
/*           double rIn, double rOut,                  */
/*           double startPhi,  */
/*           double deltaPhi); */
             

/* //! Creates a trapezoid (refere to \b Geant3 or \b Geant4 documentation) */
/* /\** The center of the tube or tube-section (for positioning) is the center of */
/*     coordinates of its definition (x=y=z=0). */
/* *\/     */
/* DDSolid *      DDtrap(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); */
             
/* //! Creates a shapeless solid */
/* /\** When used in a mother-volume this type of solid forms an assembly */
/*     in the \b Geant4 sense */
/* *\/     */
/* DDSolid * DDshapeless(const DDName & name); */

/* /\* */
/* DDSolid      DDunion(const DDName & name, */
/*                      const DDSolid & a = DDSolid(),  */
/*                      const DDSolid & b = DDSolid() ); */
/* *\/ */

/* //! Creates a boolean solid - the union of 2 compound solids */
/* /\** \arg \c name unique name */
/*     \arg \c a first compound of the union */
/*     \arg \c b second comound of the union */
/*     \arg \c r relative rotation of \c b towards \c a */
/*     \arg \c t relative translation of \c b towards \c a */
/* *\/                                                                    */
/* DDSolid *     DDunion(const DDName & name, */
/*                      const DDSolid & a,  */
/*                      const DDSolid & b, */
/*           const DDRotation &r =DDRotation(), */
/*           const DDTranslation &t =DDTranslation()); */

/* //! Creates a boolean solid - the union of 2 compound solids */
/* /\** \arg \c name unique name */
/*     \arg \c a first compound of the subtraction */
/*     \arg \c b second comound of the subtraction */
/*     \arg \c r relative rotation of \c b towards \c a */
/*     \arg \c t relative translation of \c b towards \c a */
/*     \c b is subtracted from \c a . */
/* *\/                                                                    */
/* DDSolid *     DDsubtraction(const DDName & name, */
/*                            const DDSolid & a,  */
/*                            const DDSolid & b, */
/*                 const DDRotation &r =DDRotation(), */
/*                 const DDTranslation &t =DDTranslation());  */
             
/* //! Creates a boolean solid - the intersection of 2 compound solids */
/* /\** \arg \c name unique name */
/*     \arg \c a first compound of the intersection */
/*     \arg \c b second comound of the intersection */
/*     \arg \c r relative rotation of \c b towards \c a */
/*     \arg \c t relative translation of \c b towards \c a */
/*     The resulting solid is the common volume of \c a and \c b . */
/* *\/                                                                    */
/* DDSolid *     DDintersection(const DDName & name, */
/*                             const DDSolid & a,  */
/*                             const DDSolid & b, */
/*                  const DDRotation &r =DDRotation(), */
/*                  const DDTranslation &t =DDTranslation());  */
             

/* //! Creates a cone or a cone-section (refere to \b Geant4 documentation) */
/* /\** The center of the cone or cone-section (for positioning) is the center of */
/*     coordinates of its definition (x=y=z=0). */
/* *\/     */
/* DDSolid *      DDcons(const DDName & name, */
/*                      double zhalf, */
/*           double rInMinusZ, */
/*           double rOutMinusZ, */
/*           double rInPlusZ, */
/*           double rOutPlusZ, */
/*           double startPhi, */
/*           double deltaPhi); */
            
#endif