placement.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2008-05-23
 * Last modified: 2016-07-06
 *
 * License:
 *
 * Description:
 *
 *  Placement.
 *
 */

#ifndef GEOMTOOLS_PLACEMENT_H
#define GEOMTOOLS_PLACEMENT_H 1

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

// This project:
#include <datatools/properties.h>
#include <datatools/bit_mask.h>
#include <geomtools/i_placement.h>
#include <geomtools/geomtools_config.h>

namespace geomtools {

  class stackable_data;

  class placement : public i_placement
  {

  public:

    class builder
    {
    public:

      enum init_flags {
        no_child_to_mother_gap = datatools::bit_mask::bit00, 
        no_rotation            = datatools::bit_mask::bit01  
      };

      enum child_to_mother_gap_mode {
        gap_undefined     = 0, 
        gap_center_to_min = 1, 
        gap_center_to_max = 2, 
        gap_min_to_min    = 3, 
        gap_min_to_max    = 4, 
        gap_max_to_min    = 5, 
        gap_max_to_max    = 6  
      };

      static child_to_mother_gap_mode get_gap_mode(const std::string & label_);

      static std::string get_gap_mode_label(child_to_mother_gap_mode);

      static bool needs_stackable_child(child_to_mother_gap_mode);

      builder(uint32_t flags_ = 0);

      bool has_mother_stackable() const;

      void set_mother_stackable(const stackable_data &);

      bool has_child_stackable() const;

      void set_child_stackable(const stackable_data &);

      bool use_child_to_mother_gap() const;

      bool allowed_rotation() const;

      void configure(uint32_t flags_ = 0);

      void reset();

      void build(const datatools::properties & config_,
                 placement & p_) const;

    protected:

      void _build(const datatools::properties & config_,
                  placement & p_) const;

    private:

      bool  _no_child_to_mother_gap_            = false;
      bool  _no_rotation_                       = false;
      const stackable_data * _mother_stackable_ = nullptr;
      const stackable_data * _child_stackable_  = nullptr;

    };

    bool is_valid() const;

    void invalidate();

    const vector_3d & get_translation() const;

    vector_3d & grab_translation();

    void set_translation(double, double, double);

    void set_translation_xyz(double, double, double);

    void set_translation(const vector_3d &);

    void set_translation_v(const vector_3d &);

    void translate(const vector_3d &);

    void translate(double dx_, double dy_, double dz_);

    bool is_simple_rotation() const;

    bool is_rotation_x() const;

    bool is_rotation_y() const;

    bool is_rotation_z() const;

    int get_rotation_axis() const;

    double get_rotation_angle() const;

    bool is_zyz_rotation() const;

    double get_phi() const;

    double get_theta() const;

    double get_delta() const;

    bool has_angles() const;

    const rotation_3d & get_rotation() const;

    const rotation_3d & get_inverse_rotation() const;

    // geomtools::i_placement interface:

    virtual size_t get_dimension() const;

    virtual size_t get_number_of_items() const;

    virtual void get_placement(int item_, placement & p_) const;

    virtual bool is_replica() const;

    virtual bool has_only_one_rotation() const;

    virtual size_t compute_index_map(std::vector<uint32_t> & map_,
                                     int item_) const;

    bool is_identity() const;

    void set_identity();

    void set_orientation(int axis_, double angle_);

    void set_orientation_axis_angle(int axis_, double angle_);

    void set_orientation(double phi_, double theta_, double delta_);

    void set_orientation_zyz(double phi_, double theta_, double delta_);

    void set_orientation(double angle0_, double angle1_, double angle2_, euler_angles_type euler_angle_);

    void set(double x_, double y_, double z_,
             double phi_, double theta_, double delta_);

    void set(double x_, double y_, double z_,
             double angle0_, double angle1_, double angle2_, euler_angles_type euler_angle_);

    void set(double x_, double y_, double z_,
             int axis_, double angle_);

    void set(const vector_3d & t_,
             double phi_, double theta_, double delta_);

    void set(const vector_3d & t_,
             double angle0_, double angle1_, double angle2_, euler_angles_type euler_angle_);


    void set(const vector_3d & t_,
             int axis_, double angle_);

    void set_orientation(const rotation_3d &);

    void set_orientation_xyz(double phi_, double theta_, double delta_);

    placement();

    placement(const vector_3d & translation_);

    placement(double x_,
              double y_,
              double z_);

    placement(const vector_3d & translation_,
              double phi_,
              double theta_,
              double delta_);

    placement(const vector_3d & translation_,
              int axis_,
              double angle_);

    placement(double x_,
              double y_,
              double z_,
              double phi_,
              double theta_,
              double delta_);

    placement(double x_,
              double y_,
              double z_,
              double angle0_,
              double angle1_,
              double angle2_,
              euler_angles_type euler_angles_);

    placement(const vector_3d & translation_,
              double angle0_,
              double angle1_,
              double angle2_,
              euler_angles_type euler_angles_);

    placement(double x_,
              double y_,
              double z_,
              int    axis_,
              double angle_);

    placement(const vector_3d & translation_,
              const rotation_3d & rotation_);

    virtual ~placement();

    virtual void reset();

    // Transformation methods:

    void mother_to_child(const vector_3d &, vector_3d &) const;

    vector_3d mother_to_child(const vector_3d &) const;

    void child_to_mother(const vector_3d &, vector_3d &) const;

    vector_3d child_to_mother(const vector_3d &) const;

    void mother_to_child_direction(const vector_3d &, vector_3d &) const;

    vector_3d mother_to_child_direction(const vector_3d &) const;

    void child_to_mother_direction(const vector_3d &, vector_3d &) const;

    vector_3d child_to_mother_direction(const vector_3d &) const;

    //void mother_to_child(const placement &, placement &) const;

    void child_to_mother(const placement &, placement &) const;


    void relocate(const placement &, placement &) const;

    void initialize(const datatools::properties & config_, uint32_t flags_ = 0);

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

    void dump(std::ostream      & out_    = std::clog,
               const std::string & title_  = "geomutils::placement",
               const std::string & indent_ = "") const;

    static bool from_string(const std::string &, placement &);

    static void to_string(std::string &, const placement &);

    void test() const;


  private:

    void _compute_orientation_();

    void _compute_orientation_xyz_(); // just for test

  private:

    vector_3d    _translation_;      
    int          _rotation_axis_;    
    double       _rotation_angle_;   
    double       _phi_, _theta_, _delta_; 
    rotation_3d  _rotation_;         
    rotation_3d  _inverse_rotation_; 

    DATATOOLS_SERIALIZATION_DECLARATION()

    
    DR_CLASS_RTTI()

  };

  std::ostream & operator<< (std::ostream & out_, const placement &);

} // end of namespace geomtools

#include <boost/serialization/export.hpp>
BOOST_CLASS_EXPORT_KEY2(geomtools::placement, "geomtools::placement")

// Activate reflection layer :
DR_CLASS_INIT(::geomtools::placement)

/*
// Class version:
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(geomtools::placement, 0)
*/

#endif // GEOMTOOLS_PLACEMENT_H

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