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