Rheolef  7.1
an efficient C++ finite element environment
basis_fem_vector.cc
Go to the documentation of this file.
1 //
22 // vectors
23 //
24 #include "basis_fem_vector.h"
25 #include "rheolef/rheostream.h"
26 
27 namespace rheolef {
28 
29 using namespace std;
30 
31 // =========================================================================
32 // basis members
33 // =========================================================================
34 template<class T>
36 {
37 }
38 template<class T>
40  : basis_rep<T>(sopt),
41  _n_comp(0),
42  _scalar_basis(scalar_basis),
43  _scalar_value(),
44  _vector_value()
45 {
48  base::_piola_fem = _scalar_basis.get_piola_fem();
49  check_macro (base::option().dimension() != std::numeric_limits<basis_option::size_type>::max(),
50  "vector(basis): basis.option.map_dimension should be initialized for component number");
53 }
54 #ifdef TO_CLEAN
55 template<class T>
58 {
59  const size_type unset = std::numeric_limits<basis_option::size_type>::max();
60  return (base::option().dimension() == unset) ? map_d : base::option().dimension();
61 }
62 #endif // TO_CLEAN
63 template<class T>
64 void
66 {
67  for (size_type map_d = 0; map_d < 4; ++map_d) {
68  for (size_type subgeo_variant = 0; subgeo_variant < reference_element::max_variant; ++subgeo_variant) {
69  base::_ndof_on_subgeo [map_d][subgeo_variant] = _n_comp*_scalar_basis.ndof_on_subgeo (map_d, subgeo_variant);
70  base::_nnod_on_subgeo [map_d][subgeo_variant] = _scalar_basis.nnod_on_subgeo (map_d, subgeo_variant);
71  }
72  }
74  reference_element hat_K (variant);
75  for (size_type subgeo_d = 0; subgeo_d < 5; ++subgeo_d) {
76  base::_first_idof_by_dimension [variant][subgeo_d] = _n_comp*_scalar_basis.first_idof_by_dimension (hat_K, subgeo_d);
77  base::_first_inod_by_dimension [variant][subgeo_d] = _scalar_basis.first_inod_by_dimension (hat_K, subgeo_d);
78  }
79  }
80 }
81 template<class T>
82 void
84 {
85 }
86 template<class T>
87 const Eigen::Matrix<point_basic<T>,Eigen::Dynamic,1>&
89 {
90  return _scalar_basis.hat_node (hat_K);
91 }
92 template<class T>
93 void
95  reference_element hat_K,
96  const point_basic<T>& hat_x,
97  Eigen::Matrix<point_basic<T>,Eigen::Dynamic,1>& value) const
98 {
99  base::_initialize_data_guard (hat_K);
100  _scalar_basis.evaluate (hat_K, hat_x, _scalar_value);
101  size_type loc_comp_ndof = _scalar_value.size();
102  size_type loc_ndof = _n_comp*loc_comp_ndof;
103  value.resize (loc_ndof);
104  value.fill (point_basic<T>()); // do not remove !
105  for (size_type loc_comp_idof = 0; loc_comp_idof < loc_comp_ndof; ++loc_comp_idof) {
106  for (size_type i_comp = 0; i_comp < _n_comp; ++i_comp) {
107  size_type loc_idof = _n_comp*loc_comp_idof + i_comp;
108  value[loc_idof][i_comp] = _scalar_value[loc_comp_idof];
109  }
110  }
111 }
112 template<class T>
113 void
115  reference_element hat_K,
116  const point_basic<T>& hat_x,
117  Eigen::Matrix<tensor_basic<T>,Eigen::Dynamic,1>& value) const
118 {
119  base::_initialize_data_guard (hat_K);
120  _scalar_basis.grad_evaluate (hat_K, hat_x, _vector_value);
121  size_type loc_comp_ndof = _vector_value.size();
122  size_type loc_ndof = _n_comp*loc_comp_ndof;
123  value.resize (loc_ndof);
124  value.fill (tensor_basic<T>()); // do not remove !
125  for (size_type loc_comp_idof = 0; loc_comp_idof < loc_comp_ndof; ++loc_comp_idof) {
126  for (size_type i_comp = 0; i_comp < _n_comp; ++i_comp) {
127  size_type loc_idof = _n_comp*loc_comp_idof + i_comp;
128  for (size_type j_comp = 0; j_comp < _n_comp; ++j_comp) {
129  value[loc_idof] (i_comp,j_comp) = _vector_value[loc_comp_idof][j_comp];
130  }
131  }
132  }
133 }
134 template<class T>
135 void
137  reference_element hat_K,
138  const Eigen::Matrix<point_basic<T>,Eigen::Dynamic,1>& f_xnod,
139  Eigen::Matrix<T,Eigen::Dynamic,1>& dof) const
140 {
141  base::_initialize_data_guard (hat_K);
142  size_type loc_comp_ndof = _scalar_basis.ndof (hat_K);
143  size_type loc_comp_nnod = _scalar_basis.nnod (hat_K);
144  size_type loc_ndof = _n_comp*loc_comp_ndof;
145  Eigen::Matrix<T,Eigen::Dynamic,1> f_comp_xnod (loc_comp_nnod); // TODO: class working array
146  Eigen::Matrix<T,Eigen::Dynamic,1> comp_dof (loc_comp_ndof); // TODO: class working array
147  dof.resize (loc_ndof);
148  for (size_type i_comp = 0; i_comp < _n_comp; ++i_comp) {
149  for (size_type loc_comp_inod = 0; loc_comp_inod < loc_comp_nnod; ++loc_comp_inod) {
150  f_comp_xnod [loc_comp_inod] = f_xnod [loc_comp_inod] [i_comp];
151  }
152  _scalar_basis.compute_dofs (hat_K, f_comp_xnod, comp_dof);
153  for (size_type loc_comp_idof = 0; loc_comp_idof < loc_comp_ndof; ++loc_comp_idof) {
154  size_type loc_idof = _n_comp*loc_comp_idof + i_comp;
155  dof [loc_idof] = comp_dof [loc_comp_idof];
156  }
157  }
158 }
159 // ----------------------------------------------------------------------------
160 // instanciation in library
161 // ----------------------------------------------------------------------------
162 #define _RHEOLEF_instanciation(T) \
163 template class basis_fem_vector<T>;
164 
166 
167 }// namespace rheolef
rheolef::basis_fem_vector::_compute_dofs
void _compute_dofs(reference_element hat_K, const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > &f_xnod, Eigen::Matrix< T, Eigen::Dynamic, 1 > &dof) const
Definition: basis_fem_vector.cc:136
rheolef::basis_fem_vector::_n_comp
size_type _n_comp
Definition: basis_fem_vector.h:101
rheolef::basis_fem_vector::family_index
size_type family_index() const
Definition: basis_fem_vector.h:61
rheolef::basis_fem_vector::basis_fem_vector
basis_fem_vector(const basis_basic< T > &scalar_basis, const basis_option &sopt)
Definition: basis_fem_vector.cc:39
rheolef::point_basic
Definition: point.h:87
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
rheolef::space_constant::n_component
size_type n_component(valued_type valued_tag, size_type d, coordinate_type sys_coord)
Definition: space_constant.cc:136
rheolef::_RHEOLEF_instanciation
_RHEOLEF_instanciation(Float, sequential, std::allocator< Float >) _RHEOLEF_instanciation(Float
rheolef::value
rheolef::std value
rheolef::tensor_basic
Definition: tensor.h:90
rheolef::basis_fem_vector::evaluate
void evaluate(reference_element hat_K, const point_basic< T > &hat_x, Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > &value) const
Definition: basis_fem_vector.cc:94
rheolef::basis_fem_vector::_scalar_basis
basis_basic< T > _scalar_basis
Definition: basis_fem_vector.h:102
rheolef::basis_option
see the basis_option page for the full documentation
Definition: basis_option.h:93
rheolef::basis_fem_vector::~basis_fem_vector
~basis_fem_vector()
Definition: basis_fem_vector.cc:35
rheolef::basis_rep::size_type
reference_element::size_type size_type
Definition: basis.h:214
rheolef::basis_basic
Definition: basis.h:206
rheolef::reference_element
see the reference_element page for the full documentation
Definition: reference_element.h:66
mkgeo_ball.variant
variant
Definition: mkgeo_ball.sh:149
rheolef::basis_rep::_piola_fem
piola_fem< T > _piola_fem
Definition: basis.h:394
rheolef::basis_fem_vector::hat_node
const Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > & hat_node(reference_element hat_K) const
Definition: basis_fem_vector.cc:88
rheolef::basis_rep::_sopt
basis_option _sopt
Definition: basis.h:393
dimension
const size_t dimension
Definition: edge.icc:64
rheolef::basis_rep::_name
std::string _name
Definition: basis.h:392
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::basis_option::dimension
size_type dimension() const
Definition: basis_option.h:138
Float
see the Float page for the full documentation
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition: reference_element.h:82
rheolef::basis_option::set_valued_tag
void set_valued_tag(valued_type v)
Definition: basis_option.h:149
rheolef::basis_fem_vector::_initialize_cstor_sizes
void _initialize_cstor_sizes() const
Definition: basis_fem_vector.cc:65
rheolef::space_constant::vector
Definition: space_constant.h:137
rheolef::basis_rep::standard_naming
static std::string standard_naming(std::string family_name, size_t degree, const basis_option &sopt)
Definition: basis_rep.cc:44
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::basis_fem_vector::family_name
std::string family_name() const
Definition: basis_fem_vector.h:60
basis_fem_vector.h
rheolef::basis_fem_vector::grad_evaluate
void grad_evaluate(reference_element hat_K, const point_basic< T > &hat_x, Eigen::Matrix< tensor_basic< T >, Eigen::Dynamic, 1 > &value) const
Definition: basis_fem_vector.cc:114
rheolef::basis_rep::option
const basis_option & option() const
Definition: basis.h:238
rheolef::basis_fem_vector::_initialize_data
void _initialize_data(reference_element hat_K) const
Definition: basis_fem_vector.cc:83
rheolef::basis_fem_vector::size_type
base::size_type size_type
Definition: basis_fem_vector.h:49
rheolef::basis_rep
Definition: basis.h:209
T
Expr1::float_type T
Definition: field_expr.h:218