DDShapes.h

Go to the documentation of this file.

#ifndef Detector_Description_DDCMS_DDShapes_h
#define Detector_Description_DDCMS_DDShapes_h
 
#include "DetectorDescription/DDCMS/interface/DDFilteredView.h"
 
namespace cms {
 
  enum class DDSolidShape;
 
  namespace dd {
 
    DDSolidShape getCurrentShape(const cms::DDFilteredView &fview);
 
    class DDBox {
    public:
      DDBox(const cms::DDFilteredView &fview);
      DDBox(void) = delete;
 
      double halfX() const { return (dx_); }
      double halfY() const { return (dy_); }
      double halfZ() const { return (dz_); }
 
      const bool valid;  // Tells if DDBox contains valid values
 
    private:
      double dx_, dy_, dz_;
    };
 
    // A tube section
    class DDTubs {
    public:
      DDTubs(const cms::DDFilteredView &fview);
      DDTubs(void) = delete;
 
      double zhalf(void) const { return (zHalf_); }
      double rIn(void) const { return (rIn_); }
      double rOut(void) const { return (rOut_); }
      double startPhi(void) const { return (startPhi_); }
      double deltaPhi(void) const { return (deltaPhi_); }
 
      const bool valid;
 
    private:
      double zHalf_;
      double rIn_;
      double rOut_;
      double startPhi_;
      double deltaPhi_;
    };
 
    // A cone section
    class DDCons {
    public:
      DDCons(const cms::DDFilteredView &fview);
      DDCons(void) = delete;
 
      double zhalf(void) const { return (dz_); }
      double rInMinusZ(void) const { return (rmin1_); }
      double rOutMinusZ(void) const { return (rmax1_); }
      double rInPlusZ(void) const { return (rmin2_); }
      double rOutPlusZ(void) const { return (rmax2_); }
      double phiFrom(void) const { return (phi1_); }
      double deltaPhi(void) const { return (phi2_); }
 
      const bool valid;  // Tells if DDCons contains valid values
 
    private:
      double dz_;
      double rmin1_;
      double rmax1_;
      double rmin2_;
      double rmax2_;
      double phi1_;
      double phi2_;
    };
 
    // A simple trapezoid
    class DDTrap {
    public:
      DDTrap(const cms::DDFilteredView &fview);
      DDTrap(void) = delete;
 
      double halfZ(void) const { return (halfZ_); }
 
      double theta(void) const { return (theta_); }
 
      double phi(void) const { return (phi_); }
 
      double y1(void) const { return (y1_); }
 
      double x1(void) const { return (x1_); }
 
      double x2(void) const { return (x2_); }
 
      double y2(void) const { return (y2_); }
 
      double x3(void) const { return (x3_); }
 
      double x4(void) const { return (x4_); }
 
      double alpha1(void) const { return (alpha1_); }
 
      double alpha2(void) const { return (alpha2_); }
 
      const bool valid;
 
    private:
      double halfZ_;
      double theta_;
      double phi_;
      double x1_;
      double x2_;
      double y1_;
      double y2_;
      double x3_;
      double x4_;
      double alpha1_;
      double alpha2_;
    };
 
    // A pseudo-trapezoid, that is, a trapezoid with a cylinder.
    // This shape is obsolete. This commented-out code can be removed after we are sure
    // it won't be needed with DD4hep.
    // The code does not work correctly.
    /*
    class DDPseudoTrap {
    public:
      DDPseudoTrap(const cms::DDFilteredView &fview);
      DDPseudoTrap(void) = delete;
 
      double halfZ(void) const { return (dz_); }
      //
      double x1(void) const { return (minusX_); }
 
      double x2(void) const { return (plusX_); }
 
      double y1(void) const { return (minusY_); }
 
      double y2(void) const { return (plusY_); }
 
      double radius(void) const { return (rmax_); }
 
      bool atMinusZ(void) const { return (minusZSide_); }
 
      const bool valid;  // Tells if shape contains valid values
 
    private:
      double dz_;
      double minusX_;
      double plusX_;
      double minusY_;
      double plusY_;
      double rmax_;
      bool minusZSide_;
    };
    */
 
    class DDTruncTubs {
    public:
      DDTruncTubs(const cms::DDFilteredView &fview);
      DDTruncTubs(void) = delete;
 
      double zHalf(void) const { return (zHalf_); }
 
      double rIn(void) const { return (rIn_); }
 
      double rOut(void) const { return (rOut_); }
 
      double startPhi(void) const { return (startPhi_); }
 
      double deltaPhi(void) const { return (deltaPhi_); }
 
      double cutAtStart(void) const { return (cutAtStart_); }
 
      double cutAtDelta(void) const { return (cutAtDelta_); }
 
      bool cutInside(void) const { return (cutInside_); }
 
      const bool valid;
 
    private:
      double zHalf_;
      double rIn_;
      double rOut_;
      double startPhi_;
      double deltaPhi_;
      double cutAtStart_;
      double cutAtDelta_;
      bool cutInside_;
    };
  }  // namespace dd
}  // namespace cms
 
#endif