polyhedra.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-10-08
 * Last modified: 2015-03-19
 *
 * License:
 *
 * Description:
 *   Polyhedra 3D shape with regular polygon sections
 *   See also: http://en.wikipedia.org/wiki/Frustum
 *
 * History:
 *
 */

#ifndef GEOMTOOLS_POLYHEDRA_H
#define GEOMTOOLS_POLYHEDRA_H 1

// Standard library:
#include <iostream>
#include <string>
#include <map>

// This project:
#include <geomtools/i_shape_3d.h>
#include <geomtools/i_stackable.h>

namespace geomtools {

  // Forward class declaration:
  class composite_surface;
  class right_polygonal_frustrum;

  class polyhedra : public i_shape_3d,
                    public i_stackable
  {
  public:

    static const std::string & polyhedra_label();

    static const size_t MIN_NUMBER_OF_SIDES = 3;

    enum faces_mask_type {
      FACE_NONE         = face_identifier::FACE_BITS_NONE,
      FACE_INNER_SIDE   = datatools::bit_mask::bit00,
      FACE_OUTER_SIDE   = datatools::bit_mask::bit01,
      FACE_BOTTOM       = datatools::bit_mask::bit02,
      FACE_TOP          = datatools::bit_mask::bit03,
      FACE_ALL          = (FACE_INNER_SIDE
                           | FACE_OUTER_SIDE
                           | FACE_BOTTOM
                           | FACE_TOP)
    };

    enum datafile_column_mode {
      RMIN_RMAX    = 0, 
      IGNORE_RMIN  = 1, 
      RMIN_AS_RMAX = 2  
    };

    /*
     * The polyhedra is defined by a list of (z, rmin, rmax) triplets
     * the radius are the distance from center to corners (OA, OB...).
     * Caution: the Geant4 and GDML use the tangential radius (radius of the inscribed
     * circles == apothem == OT) and not the distance from Z-axis to the corners.
     *
     * Example with a 'n_sides==6' polyhedra:
     *
     *         C           B
     *          +_________+
     *         /           \
     *        /            .+ T
     *       /          .    \
     *    D +        +        + A
     *       \      O        /
     *        \             /
     *         \___________/
     *         +           +
     *        E             F
     *
     */
    struct r_min_max
    {
      double rmin, rmax;
    };

    // Type alias
    typedef std::map<double, r_min_max> rz_col_type;

    struct frustrum_data {
      // Bottom parameters:
      double z1, a1, b1;
      // Top parameters:
      double z2, a2, b2;
    };

    bool is_extruded () const;

    double get_xmin () const;

    double get_xmax () const;

    double get_ymin () const;

    double get_ymax () const;

    double get_zmin () const;

    double get_zmax () const;

    double get_r_max () const;

    vector_3d get_corner (int zplane_index_,
                          int corner_index_,
                          bool inner_ = false) const;

    void set_n_sides (size_t n_sides_);

    size_t get_n_sides () const;

    unsigned int number_of_frustra() const;

    void get_frustrum_data(size_t i_, frustrum_data &) const;

    const rz_col_type & points () const;

    polyhedra ();

    virtual ~polyhedra ();

    virtual std::string get_shape_name () const;

    bool is_valid () const;

    void add (double z_, double rmax_, bool compute_ = true);

    void add (double z_, double rmin_, double rmax_, bool compute_ = true);

    virtual void initialize (const datatools::properties & setup_, const handle_dict_type * = 0);

    virtual void reset ();

    void initialize (const std::string & filename_, int mode_ = RMIN_RMAX);

    bool has_top_face() const;

    bool has_bottom_face() const;

    bool has_inner_face() const;

    bool has_angle_faces() const;

    void compute_top_face(composite_surface & top_, placement &) const;

    void compute_bottom_face(composite_surface & bottom_, placement &) const;

    void compute_frustrum(right_polygonal_frustrum & f_, placement &, int index_) const;

    void compute_inner_face(composite_surface & in_, placement &, int index_) const;

    void compute_outer_face(composite_surface & on_, placement &, int index_) const;

    void compute_inner_face(composite_surface & in_, placement &) const;

    void compute_outer_face(composite_surface & in_, placement &) const;

    virtual unsigned int compute_faces(face_info_collection_type &) const;

    void compute_inner_polyhedra (polyhedra & ip_);

    void compute_outer_polyhedra (polyhedra & op_);

    virtual double get_volume (uint32_t flags_ = 0) const;

    virtual double get_surface (uint32_t mask_ = FACE_ALL) const;

    double get_z_min () const;

    double get_z_max () const;

    double get_xy_max () const;

    double get_parameter ( const std::string & flag_ ) const;

    virtual bool is_inside (const vector_3d &,
                            double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual bool is_outside (const vector_3d &,
                             double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual face_identifier on_surface(const vector_3d &,
                                       const face_identifier & a_surface_mask = face_identifier::face_bits_any(),
                                       double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual vector_3d get_normal_on_surface (const vector_3d & position_,
                                             const face_identifier & ) const;

    virtual bool find_intercept(const vector_3d & from_,
                                const vector_3d & direction_,
                                face_intercept_info & intercept_,
                                double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual void tree_dump(std::ostream & out_         = std::clog,
                            const std::string & title_  = "",
                            const std::string & indent_ = "",
                            bool inherit_          = false) const;

    enum polyhedra_wires_rendering_option_type {
      WR_POLYHEDRA_NO_BOTTOM_FACE      = (WR_BASE_LAST << 1),           
      WR_POLYHEDRA_NO_TOP_FACE         = (WR_BASE_LAST << 2),           
      WR_POLYHEDRA_NO_INNER_FACE       = (WR_BASE_LAST << 3),           
      WR_POLYHEDRA_NO_OUTER_FACE       = (WR_BASE_LAST << 4),           
      // WR_POLYHEDRA_NO_START_ANGLE_FACE = (WR_BASE_LAST << 5),           //!< Do not render the start angle face
      // WR_POLYHEDRA_NO_STOP_ANGLE_FACE  = (WR_BASE_LAST << 6),           //!< Do not render the stop angle face
      WR_POLYHEDRA_LAST                = (WR_POLYHEDRA_NO_OUTER_FACE),  
      WR_POLYHEDRA_MASK                = (WR_POLYHEDRA_NO_BOTTOM_FACE
                                         | WR_POLYHEDRA_NO_TOP_FACE
                                         | WR_POLYHEDRA_NO_INNER_FACE
                                         | WR_POLYHEDRA_NO_OUTER_FACE
                                         // | WR_POLYHEDRA_NO_START_ANGLE_FACE
                                         // | WR_POLYHEDRA_NO_STOP_ANGLE_FACE
                                          ) 
    };

    virtual void generate_wires_self(wires_type & wires_,
                                     uint32_t options_ = 0) const;

    friend std::ostream & operator<< (std::ostream &, const polyhedra &);

    friend std::istream & operator>> (std::istream &, polyhedra &);

  protected:

    virtual void _build_bounding_data();

    void _set_defaults();

    virtual void _at_lock();

  private:

    void _compute_surfaces_();

    void _compute_volume_();

    void _compute_limits_();

    void _compute_misc_();

    void _compute_all_();

  private:

    // Parameters:
    size_t      _n_sides_; 
    rz_col_type _points_;  

    // Working data:
    bool    _computed_; 
    boost::logic::tribool _has_top_face_;
    boost::logic::tribool _has_bottom_face_;
    boost::logic::tribool _has_inner_face_;
    double  _top_surface_;
    double  _bottom_surface_;
    double  _outer_side_surface_;
    double  _inner_side_surface_;
    double  _outer_volume_;
    double  _inner_volume_;
    double  _volume_;
    double  _z_min_;
    double  _z_max_;
    double  _r_max_;
    double  _xy_max_;
    bool    _extruded_;

    // Registration interface :
    GEOMTOOLS_OBJECT_3D_REGISTRATION_INTERFACE(polyhedra)

  };

} // end of namespace geomtools

#endif // GEOMTOOLS_POLYHEDRA_H

/*
** Local Variables: --
** mode: c++ --
** c-file-style: "gnu" --
** tab-width: 2 --
** End: --
*/