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"
110 template <
class T,
class M>
class field_basic;
111 template <
class T,
class M>
class space_mult_list;
112 template <
class T,
class M>
class space_component;
113 template <
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_ { };
158 template <
class T,
class M>
173 std::string prod_valued);
197 std::string
name()
const;
216 template <
class Function>
219 template <
class Function>
222 template <
class Function>
279 std::string prod_valued);
296 const std::set<size_type>& ext_iu_set()
const;
297 const std::set<size_type>& ext_ib_set()
const;
300 #ifdef _RHEOLEF_HAVE_MPI
302 class space_rep<
T,distributed> :
public space_base_rep<T,distributed> {
307 typedef space_base_rep<T,distributed> base;
312 space_rep (
const geo_basic<T,distributed>& omega,
314 std::string prod_valued);
315 space_rep (
const geo_basic<T,distributed>& omega,
316 const basis_basic<T>&
b);
317 space_rep (
const space_constitution<T,distributed>& constit);
318 space_rep (
const space_mult_list<T,distributed>&);
323 const communicator& comm()
const {
return base::comm(); }
328 const distributor& ios_ownership()
const {
return _ios_idof2dis_idof.ownership(); }
329 size_type idof2ios_dis_idof (
size_type idof)
const { base::freeze_guard();
return _idof2ios_dis_idof [idof]; }
330 size_type ios_idof2dis_idof (
size_type ios_idof)
const { base::freeze_guard();
return _ios_idof2dis_idof [ios_idof]; }
331 const std::set<size_type>& ext_iu_set()
const {
return _ext_iu_set; }
332 const std::set<size_type>& ext_ib_set()
const {
return _ext_ib_set; }
335 template <
class T1,
class M1>
friend class field_basic;
337 void freeze_body()
const;
338 void append_external_dof (
const geo_basic<T,distributed>& dom, std::set<size_type>& ext_dof_set)
const;
340 disarray<size_type,distributed> _idof2ios_dis_idof;
341 disarray<size_type,distributed> _ios_idof2dis_idof;
343 mutable std::set<size_type> _ext_iu_set;
344 mutable std::set<size_type> _ext_ib_set;
351 template <
class T,
class M = rheo_default_memory_model>
374 std::string approx =
"",
375 std::string prod_valued =
"scalar");
384 void block (std::string dom_name);
385 void unblock(std::string dom_name);
389 void block_n (std::string dom_name);
390 void unblock_n(std::string dom_name);
403 const std::string& valued()
const;
408 std::string get_approx()
const;
409 std::string
name()
const;
428 template <
class Function>
431 template <
class Function>
434 template <
class Function>
443 const std::set<size_type>&
ext_iu_set()
const {
return base::data().ext_iu_set(); }
444 const std::set<size_type>&
ext_ib_set()
const {
return base::data().ext_ib_set(); }
451 return are_compatible (V1.
data(), V2.
data()); }
459 std::string prod_valued)
460 :
base (new_macro(
rep(omega, approx, prod_valued)))
475 :
base (new_macro(
rep(constit)))
489 return base::data().ownership();
496 return base::data().ios_ownership();
503 return base::data().comm();
510 return base::data().ndof();
517 return base::data().dis_ndof();
524 return base::data().get_geo();
531 return base::data().get_basis();
538 return base::data().get_constitution();
545 return base::data().size();
552 return base::data().valued();
559 return base::data().valued_tag();
566 return base::data().operator[] (i_comp);
573 return base::data().operator[] (i_comp);
580 return get_basis().degree();
587 return get_basis().name();
594 return base::data().name();
601 return base::data().dis_idof (K,
dis_idof);
608 return base::data().idof2ios_dis_idof (idof);
615 return base::data().ios_idof2dis_idof (ios_idof);
622 return base::data().iu_ownership();
629 return base::data().ib_ownership();
636 return base::data().is_blocked (idof);
643 return base::data().dis_iub (idof);
650 return base::data().dis_is_blocked (
dis_idof);
657 return base::data().dis_idof2dis_iub (
dis_idof);
664 return base::data().block (
get_geo().get_domain_indirect(dom_name));
671 return base::data().unblock (
get_geo().get_domain_indirect(dom_name));
678 return base::data().block (dom);
685 return base::data().unblock (dom);
692 return base::data().block_n (
get_geo().get_domain_indirect(dom_name));
699 return base::data().unblock_n (
get_geo().get_domain_indirect(dom_name));
706 return base::data().block_n (dom);
713 return base::data().unblock_n (dom);
720 return base::data().xdof (idof);
727 return base::data().get_xdofs();
730 template <
class Function>
735 return base::data().momentum (
f, idof);
738 template <
class Function>
743 return base::data().vector_momentum (
f, idof);
746 template <
class Function>
750 return base::data().tensor_momentum (
f, idof);
754 #ifdef _RHEOLEF_HAVE_MPI
770 std::string approx =
"",
771 std::string prod_valued =
"scalar");
780 void block (std::string dom_name);
781 void unblock(std::string dom_name);
785 void block_n (std::string dom_name);
786 void unblock_n(std::string dom_name);
791 const communicator& comm()
const;
799 const std::string& valued()
const;
804 std::string get_approx()
const;
805 std::string
name()
const;
825 template <
class Function>
828 template <
class Function>
831 template <
class Function>
840 const std::set<size_type>& ext_iu_set()
const {
return base::data().ext_iu_set(); }
841 const std::set<size_type>& ext_ib_set()
const {
return base::data().ext_ib_set(); }
845 bool operator== (
const space_basic<T,distributed>& V2)
const {
return base::data().operator==(V2.data()); }
847 friend bool are_compatible (
const space_basic<T,distributed>& V1,
const space_basic<T,distributed>& V2) {
848 return are_compatible (V1.data(), V2.data()); }
854 space_basic<T,distributed>::space_basic (
855 const geo_basic<T,distributed>& omega,
857 std::string prod_valued)
858 : base (new_macro(rep(omega, approx, prod_valued)))
863 space_basic<T,distributed>::space_basic (
864 const geo_basic<T,distributed>& omega,
865 const basis_basic<T>&
b)
866 : base (new_macro(rep(omega,
b)))
871 space_basic<T,distributed>::space_basic (
872 const space_constitution<T,distributed>& constit)
873 : base (new_macro(rep(constit)))
878 space_basic<T,distributed>::space_basic (
const space_mult_list<T,distributed>&
expr)
879 : base (new_macro(rep(
expr)))
885 space_basic<T,distributed>::ownership()
const
887 return base::data().ownership();
892 space_basic<T,distributed>::ios_ownership()
const
894 return base::data().ios_ownership();
899 space_basic<T,distributed>::comm()
const
901 return base::data().comm();
908 return base::data().ndof();
915 return base::data().dis_ndof();
919 const geo_basic<T,distributed>&
922 return base::data().get_geo();
926 const basis_basic<T>&
927 space_basic<T,distributed>::get_basis()
const
929 return base::data().get_basis();
933 const space_constitution<T,distributed>&
934 space_basic<T,distributed>::get_constitution()
const
936 return base::data().get_constitution();
941 space_basic<T,distributed>::size()
const
943 return base::data().size();
948 space_basic<T,distributed>::valued()
const
950 return base::data().valued();
957 return base::data().valued_tag();
961 space_component<T,distributed>
962 space_basic<T,distributed>::operator[] (
size_type i_comp)
964 return base::data().operator[] (i_comp);
968 space_component_const<T,distributed>
969 space_basic<T,distributed>::operator[] (
size_type i_comp)
const
971 return base::data().operator[] (i_comp);
976 space_basic<T,distributed>::degree()
const
978 return get_basis().degree();
983 space_basic<T,distributed>::get_approx()
const
985 return get_basis().name();
992 return base::data().name();
999 return base::data().dis_idof (K,
dis_idof);
1004 space_basic<T,distributed>::idof2ios_dis_idof (
size_type idof)
const
1006 return base::data().idof2ios_dis_idof (idof);
1011 space_basic<T,distributed>::ios_idof2dis_idof (
size_type ios_idof)
const
1013 return base::data().ios_idof2dis_idof (ios_idof);
1018 space_basic<T,distributed>::iu_ownership()
const
1020 return base::data().iu_ownership();
1025 space_basic<T,distributed>::ib_ownership()
const
1027 return base::data().ib_ownership();
1032 space_basic<T,distributed>::is_blocked (
size_type idof)
const
1034 return base::data().is_blocked (idof);
1039 space_basic<T,distributed>::dis_iub (
size_type idof)
const
1041 return base::data().dis_iub (idof);
1048 return base::data().dis_is_blocked (
dis_idof);
1055 return base::data().dis_idof2dis_iub (
dis_idof);
1060 space_basic<T,distributed>::block (std::string dom_name)
1062 return base::data().block (
get_geo().get_domain_indirect(dom_name));
1067 space_basic<T,distributed>::unblock (std::string dom_name)
1069 return base::data().unblock (
get_geo().get_domain_indirect(dom_name));
1074 space_basic<T,distributed>::block (
const domain_indirect_basic<distributed>& dom)
1076 base::data().block (dom);
1081 space_basic<T,distributed>::unblock (
const domain_indirect_basic<distributed>& dom)
1083 base::data().unblock (dom);
1088 space_basic<T,distributed>::block_n (std::string dom_name)
1090 return base::data().block_n (
get_geo().get_domain_indirect(dom_name));
1095 space_basic<T,distributed>::unblock_n (std::string dom_name)
1097 return base::data().unblock_n (
get_geo().get_domain_indirect(dom_name));
1102 space_basic<T,distributed>::block_n (
const domain_indirect_basic<distributed>& dom)
1104 base::data().block_n (dom);
1109 space_basic<T,distributed>::unblock_n (
const domain_indirect_basic<distributed>& dom)
1111 base::data().unblock_n (dom);
1116 space_basic<T,distributed>::xdof (
size_type idof)
const
1118 return base::data().xdof (idof);
1122 const disarray<point_basic<T>,distributed>&
1123 space_basic<T,distributed>::get_xdofs()
const
1125 return base::data().get_xdofs();
1128 template <
class Function>
1133 return base::data().momentum (
f, idof);
1136 template <
class Function>
1139 space_basic<T,distributed>::vector_momentum (
const Function&
f,
size_type idof)
const
1141 return base::data().vector_momentum (
f, idof);
1144 template <
class Function>
1146 space_basic<T,distributed>::tensor_momentum (
const Function&
f,
size_type idof)
const
1148 return base::data().tensor_momentum (
f, idof);
1153 #define _RHEOLEF_space_build_indirect_array(M) \
1156 disarray<typename space_basic<T,M>::size_type, M> \
1157 space_basic<T,M>::build_indirect_array ( \
1158 const space_basic<T,M>& Wh, \
1159 const std::string& dom_name) const \
1161 return base::data().build_indirect_array (Wh.data(), dom_name); \
1165 disarray<typename space_basic<T,M>::size_type, M> \
1166 space_basic<T,M>::build_indirect_array ( \
1167 const space_basic<T,M>& Wh, \
1168 const geo_basic<T,M>& bgd_gamma) const \
1170 return base::data().build_indirect_array (Wh.data(), bgd_gamma); \
1174 #ifdef _RHEOLEF_HAVE_MPI
1178 #undef _RHEOLEF_space_build_indirect_array
field::size_type size_type
see the disarray page for the full documentation
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
see the geo_element page for the full documentation
see the smart_pointer page for the full documentation
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
disarray< size_type, M > build_indirect_array(const space_base_rep< T, M > &Wh, const std::string &dom_name) const
size_type dis_ndof() const
size_type dis_iub(size_type idof) const
void no_freeze_guard() const
space_constitution< T, M > _constit
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()
const geo_basic< T, M > & get_geo() const
const disarray< point_basic< T >, M > & get_xdofs() const
const point_basic< T > & xdof(size_type idof) const
disarray< point_basic< T >, M > _xdof
void unblock_n(const domain_indirect_basic< M > &dom)
const std::string & valued() const
space_constant::valued_type valued_type
distributor _iu_ownership
disarray< int, M > _has_nt_basis
virtual void freeze_body() const
const distributor & ownership() const
space_pair_type::size_type size_type
T momentum(const Function &f, size_type idof) const
bool is_blocked(size_type idof) const
void block_n(const domain_indirect_basic< M > &dom)
const space_constitution< T, M > & get_constitution() const
const distributor & iu_ownership() const
tensor_basic< T > tensor_momentum(const Function &f, size_type idof) const
void unblock(const domain_indirect_basic< M > &dom)
space_component< T, M > operator[](size_type i_comp)
distributor _ib_ownership
point_basic< T > vector_momentum(const Function &f, size_type idof) const
void freeze_guard() const
const communicator & comm() const
const distributor & ib_ownership() const
disarray< space_pair_type, M > _idof2blk_dis_iub
bool operator==(const space_base_rep< T, M > &V2) const
const basis_basic< T > & get_basis() const
disarray< size_type, sequential > build_indirect_array(const space_basic< T, sequential > &Wh, const std::string &dom_name) const
const std::set< size_type > & ext_ib_set() const
disarray< size_type, sequential > build_indirect_array(const space_basic< T, sequential > &Wh, const geo_basic< T, sequential > &bgd_gamma) const
space_rep< T, sequential > rep
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
static space_basic< T, sequential > real()
const std::set< size_type > & ext_iu_set() const
const valued_type & valued_tag() const
void block(const domain_indirect_basic< M > &dom)
const geo_basic< T, M > & get_geo() const
void unblock_n(const domain_indirect_basic< M > &dom)
const std::string & valued() const
void block_n(const domain_indirect_basic< M > &dom)
void unblock(const domain_indirect_basic< M > &dom)
const basis_basic< T > & get_basis() const
size_type idof2ios_dis_idof(size_type idof) const
base::size_type size_type
size_type dis_idof2dis_iub(size_type dis_idof) const
const distributor & ios_ownership() 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)")
valued_type valued_tag(const std::string &name)
void dis_idof(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_idof_tab)
size_type dis_ndof(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
size_type ndof(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
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_indirect_array(M)
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)
friend std::ostream & operator<<(std::ostream &os, const space_pair_type &x)
space_pair_type(bool blk, size_type dis_iub)