torus.h

Go to the documentation of this file.

/* Author(s):     F. Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2016-02-18
 * Last modified: 2016-02-19
 *
 * License:
 *
 * Description:
 *   3D solid torus sector
 *
 * History:
 *
 */

#ifndef GEOMTOOLS_TORUS_H
#define GEOMTOOLS_TORUS_H 1

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

// Third party:
// - Bayeux/datatools:
#include <datatools/object_configuration_description.h>

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

namespace datatools {
  // Forward class declaration:
  class properties;
}

namespace geomtools {

  // Forward class declarations:
  class toroid_nappe;
  class disk;

  class torus : public i_shape_3d,
                public i_stackable
  {
  public:

    enum faces_mask_type {
      FACE_NONE      = face_identifier::FACE_BITS_NONE,
      FACE_INSIDE    = datatools::bit_mask::bit00,
      FACE_OUTSIDE   = datatools::bit_mask::bit01,
      FACE_START_PHI = datatools::bit_mask::bit02,
      FACE_STOP_PHI  = datatools::bit_mask::bit03,
      FACE_ALL    = (FACE_INSIDE
                     | FACE_OUTSIDE
                     | FACE_START_PHI
                     | FACE_STOP_PHI)
    };

    static const std::string & torus_label();

    void compute_inside_outside_face(faces_mask_type face_id_,
                                     toroid_nappe & face_,
                                     placement & face_placement_) const;

    void compute_start_stop_phi_face(faces_mask_type face_id_,
                                     disk & face_,
                                     placement & face_placement_) const;

    virtual unsigned int compute_faces(face_info_collection_type & faces) 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_sweep_radius() const;

    void set_sweep_radius(double);

    bool has_inside_radius() const;

    double get_inside_radius () const;

    void set_inside_radius (double);

    double get_outside_radius () const;

    void set_outside_radius (double);

    void set(double sweep_radius_, double outside_radius_, double inside_radius_, double start_phi_, double delta_phi_);

    void set(double sweep_radius_, double outside_radius_, double inside_radius_ = 0.0);

    void set_phi(double start_phi_, double delta_phi_);

    bool has_partial_phi() const;

    bool has_start_phi() const;

    void set_start_phi(double);

    double get_start_phi() const;

    bool has_delta_phi() const;

    void set_delta_phi(double);

    double get_delta_phi() const;

    torus();

    torus(double sweep_radius_, double outside_radius_, double inside_radius_);

    torus(double sweep_radius_, double outside_radius_, double inside_radius_, double start_phi_, double delta_phi_);

    virtual ~torus();

    virtual std::string get_shape_name () const;

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

    bool is_valid () const;

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

    virtual void reset();

    virtual double get_surface (uint32_t mask_ = FACE_ALL) const;

    virtual double get_volume (uint32_t flags_ = 0) 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 & a_position,
                                            const face_identifier & a_surface_bit) const;

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

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

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

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

    enum torus_wires_rendering_option_type {
      WR_TORUS_NO_INSIDE_FACE    = (WR_BASE_LAST << 1),    
      WR_TORUS_NO_OUTSIDE_FACE   = (WR_BASE_LAST << 2),    
      WR_TORUS_NO_START_PHI_FACE = (WR_BASE_LAST << 3),    
      WR_TORUS_NO_STOP_PHI_FACE  = (WR_BASE_LAST << 3),    
      WR_TORUS_LAST              = (WR_TORUS_NO_STOP_PHI_FACE),  
      WR_TORUS_MASK              = (WR_TORUS_NO_INSIDE_FACE
                                    | WR_TORUS_NO_OUTSIDE_FACE
                                    | WR_TORUS_NO_START_PHI_FACE
                                    | WR_TORUS_NO_STOP_PHI_FACE) 
    };

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

    static void init_ocd(datatools::object_configuration_description &);

  protected:

    void _set_defaults();

    virtual void _build_bounding_data();

  private:

    double _sweep_radius_;   
    double _inside_radius_;  
    double _outside_radius_; 
    angular_range _phi_domain_; 

    // Registration interface :
    GEOMTOOLS_OBJECT_3D_REGISTRATION_INTERFACE(torus)

  };

} // end of namespace geomtools

// @arg geomtools::torus the name the class
DOCD_CLASS_DECLARATION(geomtools::torus)

#endif // GEOMTOOLS_TORUS_H

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