1#ifndef _RHEOLEF_SPACE_H
2#define _RHEOLEF_SPACE_H
103#include "rheolef/geo.h"
104#include "rheolef/geo_domain.h"
105#include "rheolef/space_constitution.h"
110template <
class T,
class M>
class field_basic;
111template <
class T,
class M>
class space_mult_list;
112template <
class T,
class M>
class space_component;
113template <
class T,
class M>
class space_component_const;
131 template<
class Archive>
140#ifdef _RHEOLEF_HAVE_MPI
148 template <>
struct is_mpi_datatype<
rheolef::space_pair_type> : mpl::true_ { };
158template <
class T,
class M>
173 std::string prod_valued);
216 template <
class Function>
219 template <
class Function>
222 template <
class Function>
279template <
class T,
class M>
284 parent_subgeo_owner_guard();
285 if (! _parent_subgeo_owner_reattribution_required) {
286 ext_dis_idofs = Set();
289 _parent_subgeo_owner.get_dis_indexes (ext_dis_idofs);
309 std::string prod_valued);
326 const std::set<size_type>& ext_iu_set()
const;
327 const std::set<size_type>& ext_ib_set()
const;
330#ifdef _RHEOLEF_HAVE_MPI
344 std::string prod_valued);
353 const communicator&
comm()
const {
return base::comm(); }
355 bool dis_is_blocked (
size_type dis_idof)
const;
361 const std::set<size_type>&
ext_iu_set()
const {
return _ext_iu_set; }
362 const std::set<size_type>&
ext_ib_set()
const {
return _ext_ib_set; }
367 void freeze_body()
const;
381template <
class T,
class M = rheo_default_memory_model>
404 std::string approx =
"",
405 std::string prod_valued =
"scalar");
414 void block (std::string dom_name);
415 void unblock(std::string dom_name);
419 void block_n (std::string dom_name);
420 void unblock_n(std::string dom_name);
425 const communicator& comm()
const;
433 const std::string& valued()
const;
438 std::string get_approx()
const;
439 std::string name()
const;
441 void dis_idof (
const geo_element& K, std::vector<size_type>& dis_idof)
const;
448 bool dis_is_blocked (
size_type dis_idof)
const;
458 template <
class Function>
459 T momentum (
const Function&
f,
size_type idof)
const;
461 template <
class Function>
464 template <
class Function>
473 const std::set<size_type>&
ext_iu_set()
const {
return base::data().ext_iu_set(); }
474 const std::set<size_type>&
ext_ib_set()
const {
return base::data().ext_ib_set(); }
481 return are_compatible (V1.data(), V2.data()); }
487 { base::data().get_parent_subgeo_owner_dis_indexes (ext_dis_idofs); }
489 {
return base::data().get_parent_subgeo_owner (dis_idof); }
497 std::string prod_valued)
498 :
base (new_macro(
rep(omega, approx, prod_valued)))
506 :
base (new_macro(
rep(omega, b)))
513 :
base (new_macro(
rep(constit)))
527 return base::data().ownership();
534 return base::data().ios_ownership();
541 return base::data().comm();
548 return base::data().ndof();
555 return base::data().dis_ndof();
562 return base::data().get_geo();
569 return base::data().get_basis();
576 return base::data().get_constitution();
583 return base::data().size();
590 return base::data().valued();
597 return base::data().valued_tag();
604 return base::data().operator[] (i_comp);
611 return base::data().operator[] (i_comp);
618 return get_basis().degree();
625 return get_basis().name();
632 return base::data().name();
639 return base::data().dis_idof (K, dis_idof);
646 return base::data().idof2ios_dis_idof (idof);
653 return base::data().ios_idof2dis_idof (ios_idof);
660 return base::data().iu_ownership();
667 return base::data().ib_ownership();
674 return base::data().is_blocked (idof);
681 return base::data().dis_iub (idof);
688 return base::data().dis_is_blocked (dis_idof);
695 return base::data().dis_idof2dis_iub (dis_idof);
702 return base::data().block (
get_geo().get_domain_indirect(dom_name));
709 return base::data().unblock (
get_geo().get_domain_indirect(dom_name));
716 return base::data().block (dom);
723 return base::data().unblock (dom);
730 return base::data().block_n (
get_geo().get_domain_indirect(dom_name));
737 return base::data().unblock_n (
get_geo().get_domain_indirect(dom_name));
744 return base::data().block_n (dom);
751 return base::data().unblock_n (dom);
758 return base::data().xdof (idof);
765 return base::data().get_xdofs();
768template <
class Function>
773 return base::data().momentum (
f, idof);
776template <
class Function>
781 return base::data().vector_momentum (
f, idof);
784template <
class Function>
788 return base::data().tensor_momentum (
f, idof);
792#ifdef _RHEOLEF_HAVE_MPI
808 std::string approx =
"",
809 std::string prod_valued =
"scalar");
818 void block (std::string dom_name);
819 void unblock(std::string dom_name);
823 void block_n (std::string dom_name);
824 void unblock_n(std::string dom_name);
829 const communicator& comm()
const;
837 const std::string& valued()
const;
842 std::string get_approx()
const;
843 std::string name()
const;
845 void dis_idof (
const geo_element& K, std::vector<size_type>& dis_idof)
const;
853 bool dis_is_blocked (
size_type dis_idof)
const;
863 template <
class Function>
864 T momentum (
const Function&
f,
size_type idof)
const;
866 template <
class Function>
869 template <
class Function>
878 const std::set<size_type>&
ext_iu_set()
const {
return base::data().ext_iu_set(); }
879 const std::set<size_type>&
ext_ib_set()
const {
return base::data().ext_ib_set(); }
886 return are_compatible (V1.data(), V2.data()); }
892 { base::data().get_parent_subgeo_owner_dis_indexes (ext_dis_idofs); }
894 {
return base::data().get_parent_subgeo_owner (dis_idof); }
903 std::string prod_valued)
904 :
base (new_macro(
rep(omega, approx, prod_valued)))
912 :
base (new_macro(
rep(omega, b)))
919 :
base (new_macro(
rep(constit)))
933 return base::data().ownership();
940 return base::data().ios_ownership();
947 return base::data().comm();
954 return base::data().ndof();
961 return base::data().dis_ndof();
968 return base::data().get_geo();
975 return base::data().get_basis();
982 return base::data().get_constitution();
989 return base::data().size();
996 return base::data().valued();
1003 return base::data().valued_tag();
1010 return base::data().operator[] (i_comp);
1017 return base::data().operator[] (i_comp);
1024 return get_basis().degree();
1031 return get_basis().name();
1038 return base::data().name();
1045 return base::data().dis_idof (K, dis_idof);
1052 return base::data().idof2ios_dis_idof (idof);
1059 return base::data().ios_idof2dis_idof (ios_idof);
1066 return base::data().iu_ownership();
1073 return base::data().ib_ownership();
1080 return base::data().is_blocked (idof);
1087 return base::data().dis_iub (idof);
1094 return base::data().dis_is_blocked (dis_idof);
1101 return base::data().dis_idof2dis_iub (dis_idof);
1108 return base::data().block (
get_geo().get_domain_indirect(dom_name));
1115 return base::data().unblock (
get_geo().get_domain_indirect(dom_name));
1122 base::data().block (dom);
1129 base::data().unblock (dom);
1136 return base::data().block_n (
get_geo().get_domain_indirect(dom_name));
1143 return base::data().unblock_n (
get_geo().get_domain_indirect(dom_name));
1150 base::data().block_n (dom);
1157 base::data().unblock_n (dom);
1164 return base::data().xdof (idof);
1171 return base::data().get_xdofs();
1174template <
class Function>
1179 return base::data().momentum (
f, idof);
1182template <
class Function>
1187 return base::data().vector_momentum (
f, idof);
1190template <
class Function>
1194 return base::data().tensor_momentum (
f, idof);
1199#define _RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof(M) \
1202disarray<typename space_basic<T,M>::size_type, M> \
1203space_basic<T,M>::build_dom_dis_idof2bgd_dis_idof ( \
1204 const space_basic<T,M>& Wh, \
1205 const std::string& dom_name) const \
1207 return base::data().build_dom_dis_idof2bgd_dis_idof (Wh.data(), dom_name); \
1211disarray<typename space_basic<T,M>::size_type, M> \
1212space_basic<T,M>::build_dom_dis_idof2bgd_dis_idof ( \
1213 const space_basic<T,M>& Wh, \
1214 const geo_basic<T,M>& bgd_gamma) const \
1216 return base::data().build_dom_dis_idof2bgd_dis_idof (Wh.data(), bgd_gamma); \
1220#ifdef _RHEOLEF_HAVE_MPI
1224#undef _RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof
field::size_type size_type
see the disarray page for the full documentation
rep::base::size_type size_type
see the distributor page for the full documentation
size_type dis_size() const
global and local sizes
size_type size(size_type iproc) const
const communicator_type & comm() const
the finite element boundary domain
generic mesh with rerefence counting
see the geo_element page for the full documentation
see the smart_pointer page for the full documentation
space_base_rep(const space_mult_list< T, M > &)
space_base_rep(const space_constitution< T, M > &constit)
disarray< point_basic< T >, M > _normal
void dis_idof(const geo_element &K, std::vector< size_type > &dis_idof) const
friend bool are_compatible(const space_base_rep< T, M > &V1, const space_base_rep< T, M > &V2)
void base_freeze_body() const
const basis_basic< T > & get_basis() const
const space_constitution< T, M > & get_constitution() const
size_type dis_ndof() const
const point_basic< T > & xdof(size_type idof) const
size_type dis_iub(size_type idof) const
space_constitution< T, M > _constit
bool _parent_subgeo_owner_reattribution_required
valued_type valued_tag() const
void block(const domain_indirect_basic< M > &dom)
e.g. "P1(square)", for field_expr<Expr> checks
virtual ~space_base_rep()
bool _parent_subgeo_owner_initialized
disarray< size_type, M > build_dom_dis_idof2bgd_dis_idof(const space_base_rep< T, M > &Wh, const std::string &dom_name) const
void get_parent_subgeo_owner_dis_indexes(Set &ext_dis_idofs) const
disarray< point_basic< T >, M > _xdof
space_base_rep(const geo_basic< T, M > &omega, const basis_basic< T > &b)
const disarray< point_basic< T >, M > & get_xdofs() const
disarray< size_type, M > _parent_subgeo_owner
tensor_basic< T > tensor_momentum(const Function &f, size_type idof) const
void unblock_n(const domain_indirect_basic< M > &dom)
space_constant::valued_type valued_type
size_type get_parent_subgeo_owner(size_type dis_idof) const
distributor _iu_ownership
point_basic< T > vector_momentum(const Function &f, size_type idof) const
disarray< int, M > _has_nt_basis
virtual void freeze_body() const
space_pair_type::size_type size_type
T momentum(const Function &f, size_type idof) const
space_base_rep(const geo_basic< T, M > &omega, std::string approx, std::string prod_valued)
bool parent_subgeo_owner_guard() const
bool is_blocked(size_type idof) const
void block_n(const domain_indirect_basic< M > &dom)
const distributor & iu_ownership() const
void unblock(const domain_indirect_basic< M > &dom)
space_component< T, M > operator[](size_type i_comp)
distributor _ib_ownership
void freeze_guard() const
void no_freeze_check() const
void parent_subgeo_owner_check() const
const distributor & ib_ownership() const
disarray< size_type, M > build_dom_dis_idof2bgd_dis_idof(const space_base_rep< T, M > &Wh, const geo_basic< T, M > &bgd_gamma) const
const std::string & valued() const
const geo_basic< T, M > & get_geo() const
void freeze_check() const
disarray< space_pair_type, M > _idof2blk_dis_iub
const distributor & ownership() const
bool operator==(const space_base_rep< T, M > &V2) const
const communicator & comm() const
disarray< size_type, distributed > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, distributed > &Wh, const std::string &dom_name) const
const std::set< size_type > & ext_ib_set() const
disarray< size_type, distributed > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, distributed > &Wh, const geo_basic< T, distributed > &bgd_gamma) const
void get_parent_subgeo_owner_dis_indexes(Set &ext_dis_idofs) const
friend bool are_compatible(const space_basic< T, distributed > &V1, const space_basic< T, distributed > &V2)
size_type get_parent_subgeo_owner(size_type dis_idof) const
rep::valued_type valued_type
smart_pointer< rep > base
space_rep< T, distributed > rep
static space_basic< T, distributed > real()
const std::set< size_type > & ext_iu_set() const
static space_basic< T, sequential > real()
disarray< size_type, sequential > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, sequential > &Wh, const geo_basic< T, sequential > &bgd_gamma) const
const std::set< size_type > & ext_ib_set() const
void get_parent_subgeo_owner_dis_indexes(Set &ext_dis_idofs) const
disarray< size_type, sequential > build_dom_dis_idof2bgd_dis_idof(const space_basic< T, sequential > &Wh, const std::string &dom_name) const
space_rep< T, sequential > rep
size_type get_parent_subgeo_owner(size_type dis_idof) const
friend bool are_compatible(const space_basic< T, sequential > &V1, const space_basic< T, sequential > &V2)
rep::valued_type valued_type
smart_pointer< rep > base
const std::set< size_type > & ext_iu_set() const
const basis_basic< T > & get_basis() const
void block(const domain_indirect_basic< M > &dom)
const valued_type & valued_tag() const
void unblock_n(const domain_indirect_basic< M > &dom)
void block_n(const domain_indirect_basic< M > &dom)
void unblock(const domain_indirect_basic< M > &dom)
const std::string & valued() const
const geo_basic< T, M > & get_geo() const
space_base_rep< T, distributed > base
void append_external_dof(const geo_basic< T, distributed > &dom, std::set< size_type > &ext_dof_set) const
const std::set< size_type > & ext_ib_set() const
size_type idof2ios_dis_idof(size_type idof) const
disarray< size_type, distributed > _ios_idof2dis_idof
const distributor & ios_ownership() const
base::size_type size_type
disarray< size_type, distributed > _idof2ios_dis_idof
size_type ios_idof2dis_idof(size_type ios_idof) const
std::set< size_type > _ext_ib_set
const std::set< size_type > & ext_iu_set() const
std::set< size_type > _ext_iu_set
const communicator & comm() const
size_type idof2ios_dis_idof(size_type idof) const
const distributor & ios_ownership() const
base::size_type size_type
size_type dis_idof2dis_iub(size_type dis_idof) const
bool dis_is_blocked(size_type dis_idof) const
size_type ios_idof2dis_idof(size_type ios_idof) const
space_base_rep< T, sequential > base
space_basic< Float > space
void get_geo(istream &in, my_geo &omega)
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
This file is part of Rheolef.
bool operator!=(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
space_constant::valued_type valued_tag() const
#define _RHEOLEF_space_build_dom_dis_idof2bgd_dis_idof(M)
friend std::ostream & operator<<(std::ostream &os, const space_pair_type &x)
disarray< size_t >::size_type size_type
void set_dis_iub(size_type dis_iub)
void set_blocked(bool blk)
size_type dis_iub() const
void serialize(Archive &ar, const unsigned int version)
space_pair_type(bool blk, size_type dis_iub)