geo_domain_indirect.h

Go to the documentation of this file.

#ifndef _RHEOLEF_DOMAIN_H
#define _RHEOLEF_DOMAIN_H

#include "rheolef/geo.h"
#include "rheolef/domain_indirect.h"

namespace rheolef {

typedef geo domain;

template <class T, class M>
class geo_domain_indirect_base_rep : public geo_abstract_rep<T,M> {
public:
    typedef geo_abstract_rep<T,M>                     base;
    typedef typename base::size_type                  size_type;
    typedef typename base::node_type                  node_type;
    typedef typename base::variant_type               variant_type;
    typedef typename base::const_reference            const_reference;
    typedef typename base::const_iterator             const_iterator;
    typedef typename base::const_iterator_by_variant  const_iterator_by_variant;
    typedef typename base::iterator_by_variant        iterator_by_variant;
    typedef typename base::coordinate_type            coordinate_type;


    geo_domain_indirect_base_rep ();
    geo_domain_indirect_base_rep (const geo_domain_indirect_base_rep<T,M>&);
    geo_domain_indirect_base_rep (const domain_indirect_basic<M>& indirect, const geo_basic<T,M>& omega);


    const domain_indirect_basic<M>& get_indirect()        const { return _indirect; }
    const geo_basic<T,M>&           get_background_geo()  const { return _omega; }


    size_type variant() const { return geo_abstract_base_rep<T>::geo_domain_indirect; }
    std::string name() const { return _indirect.name(); }
    std::string familyname() const { return _indirect.name(); }
    size_type serial_number() const { return _omega.serial_number(); }
    size_type dimension() const { return _omega.dimension(); }
    size_type map_dimension() const { return _indirect.map_dimension(); }
    coordinate_type coordinate_system() const { return _omega.coordinate_system(); }
    const basis_basic<T>& get_piola_basis() const { return _omega.get_piola_basis(); }

    size_type n_node() const { return _omega.n_node(); }
    const node_type& node (size_type inod) const { return _omega.node (inod); }
    const array<node_type,M>& get_nodes() const { return _omega.get_nodes(); }
    const node_type& xmin () const { return _omega.xmin (); }
    const node_type& xmax () const { return _omega.xmax (); }


    const distributor& geo_element_ownership (size_type dim) const;
    const_reference get_geo_element (size_type dim, size_type ige) const;
    size_type neighbour (size_type ie, size_type loc_iside) const;
    void neighbour_guard() const;


    size_type n_domain_indirect() const;
    bool have_domain_indirect(const std::string& name) const;
    const domain_indirect_basic<M>& get_domain_indirect (size_type i) const;
    const domain_indirect_basic<M>& get_domain_indirect (const std::string& name) const;
    void  insert_domain_indirect (const domain_indirect_basic<M>& dom) const;
    const_iterator_by_variant begin_by_variant (variant_type variant) const;
    const_iterator_by_variant   end_by_variant (variant_type variant) const;
    const node_type& dis_node (size_type dis_inod) const;
    size_type dis_inod2dis_iv (size_type dis_inod) const;
    node_type piola (const geo_element& K, const node_type& hat_x) const;
    void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const;
    const geo_size&      sizes() const;
    const geo_size&  ios_sizes() const;
    odiststream& put (odiststream& ops) const;
    void set_nodes (const array<node_type,M>&);
    void reset_order (size_type order);
    bool check(bool verbose) const;
    size_type seq_locate(
                const point_basic<T>&     x,
                size_type                 dis_ie_guest = std::numeric_limits<size_type>::max()) const;
    size_type dis_locate(
                const point_basic<T>&     x,
                size_type                 dis_ie_guest = std::numeric_limits<size_type>::max()) const;
    size_type seq_trace_move (
                const point_basic<T>&     x,
                const point_basic<T>&     v,
                      point_basic<T>&     y) const;
    size_type dis_trace_move  (
                const point_basic<T>&     x,
                const point_basic<T>&     v,
                      point_basic<T>&     y) const;
    void locate (
                const array<point_basic<T>,M>& x,
                      array<size_type,M>&      dis_ie,
                bool do_check = false) const;
    void trace_ray_boundary (
                const array<point_basic<T>,M>&     x,
                const array<point_basic<T>,M>&     v,
                      array<size_type, M>&         dis_ie,
                      array<point_basic<T>,M>&     y,
                bool do_check = false) const;
    void trace_move (
                const array<point_basic<T>,M>&     x,
                const array<point_basic<T>,M>&     v,
                      array<size_type, M>&         dis_ie,
                      array<point_basic<T>,M>&     y) const;

protected:
    domain_indirect_basic<M>   _indirect;
    geo_basic<T,M>             _omega;
};
template <class T, class M>
inline
geo_domain_indirect_base_rep<T,M>::geo_domain_indirect_base_rep()
  : geo_abstract_rep<T,M>(),   
    _indirect(),
    _omega()
{
}
template <class T, class M>
inline
geo_domain_indirect_base_rep<T,M>::geo_domain_indirect_base_rep(
 const geo_domain_indirect_base_rep<T,M>& dom)
  : geo_abstract_rep<T,M>(dom),   
    _indirect(dom._indirect),
    _omega(dom._omega)
{
}
template <class T, class M>
inline
geo_domain_indirect_base_rep<T,M>::geo_domain_indirect_base_rep (const domain_indirect_basic<M>& indirect, const geo_basic<T,M>& omega)
  : geo_abstract_rep<T,M>(),   
    _indirect (indirect),
    _omega (omega)
{
}
template <class T, class M>
class geo_domain_indirect_rep {};

template <class T>
class geo_domain_indirect_rep<T,sequential> : public geo_domain_indirect_base_rep<T,sequential> {
public:
    typedef geo_domain_indirect_base_rep<T,sequential>  base;
    typedef typename base::size_type                    size_type;
    typedef typename base::node_type                    node_type;

    geo_domain_indirect_rep () : base() {}
    geo_domain_indirect_rep (const geo_domain_indirect_rep<T,sequential>& x) : base(x) {}
    geo_domain_indirect_rep (const domain_indirect_basic<sequential>& indirect, const geo_basic<T,sequential>& omega)
        : base(indirect,omega) {}
    geo_abstract_rep<T,sequential>* clone() const;
};
template <class T>
inline
geo_abstract_rep<T,sequential>*
geo_domain_indirect_rep<T,sequential>::clone() const
{
  typedef geo_domain_indirect_rep<T,sequential> rep;
  return new_macro(rep(*this));
}
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
class geo_domain_indirect_rep<T,distributed> : public geo_domain_indirect_base_rep<T,distributed> {
public:
    typedef geo_domain_indirect_base_rep<T,distributed> base;
    typedef typename base::size_type                    size_type;
    typedef typename base::node_type                    node_type;
    typedef typename base::const_reference              const_reference;

    geo_domain_indirect_rep() : base() {}
    geo_domain_indirect_rep (const geo_domain_indirect_rep<T,distributed>& x) : base(x) {}
    geo_domain_indirect_rep (const domain_indirect_basic<distributed>& indirect, const geo_basic<T,distributed>& omega)
        : base(indirect,omega) {}
    geo_abstract_rep<T,distributed>* clone() const;


    distributor geo_element_ios_ownership (size_type dim) const;
    const_reference dis_get_geo_element (size_type map_dim, size_type dis_ige) const;
    size_type             ige2ios_dis_ige (size_type dim, size_type     ige) const;
    size_type         dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const;
    size_type             ios_ige2dis_ige (size_type dim, size_type ios_ige) const;
    void set_ios_permutation (
        boost::array<size_type,reference_element::max_variant>& loc_ndof_by_variant,
        array<size_type,distributed>&                           idof2ios_dis_idof) const;
};
template <class T>
inline
geo_abstract_rep<T,distributed>*
geo_domain_indirect_rep<T,distributed>::clone() const
{
  typedef geo_domain_indirect_rep<T,distributed> rep;
  return new_macro(rep(*this));
}
#endif // _RHEOLEF_HAVE_MPI
#define _RHEOLEF_geo_cstor(M)                                   \
template<class T>                                               \
inline                                                          \
geo_basic<T,M>::geo_basic (                                     \
    const domain_indirect_basic<M>& dom,                                \
    const geo_basic<T,M>& omega)                                \
 : base (new_macro((geo_domain_indirect_rep<T,M>)(dom,omega)))  \
{                                                               \
}
#define _RHEOLEF_geo_dmn_by_idx(M)                              \
template<class T>                                               \
inline                                                          \
geo_basic<T,M>                                                  \
geo_basic<T,M>::get_domain (size_type i) const                  \
{                                                               \
    const domain_indirect_basic<M>& dm = base::data().get_domain_indirect (i); \
    return geo_basic<T,M> (dm, *this);                          \
}
#define _RHEOLEF_geo_dmn_by_name(M)                             \
template<class T>                                               \
inline                                                          \
geo_basic<T,M>                                                  \
geo_basic<T,M>::operator[] (const std::string& name) const      \
{                                                               \
    const domain_indirect_basic<M>& dm = base::data().get_domain_indirect (name); \
    return geo_basic<T,M> (dm, *this);                          \
}
_RHEOLEF_geo_cstor(sequential)
_RHEOLEF_geo_dmn_by_idx(sequential)
_RHEOLEF_geo_dmn_by_name(sequential)

#ifdef _RHEOLEF_HAVE_MPI
_RHEOLEF_geo_cstor(distributed)
_RHEOLEF_geo_dmn_by_idx(distributed)
_RHEOLEF_geo_dmn_by_name(distributed)
#endif // _RHEOLEF_HAVE_MPI

#undef _RHEOLEF_geo_cstor
#undef _RHEOLEF_geo_dmn_by_idx
#undef _RHEOLEF_geo_dmn_by_name

} // namespace rheolef
#endif // _RHEOLEF_DOMAIN_H