rheolef  7.0
field_evaluate.cc
Go to the documentation of this file.
1 #include "rheolef/field_evaluate.h"
2 namespace rheolef {
3 
4 template<class T, class M>
5 T
7  const field_basic<T,M>& uh,
8  const basis_on_pointset<T>& bops,
9  reference_element hat_K,
10  const std::vector<size_t>& dis_idof,
11  size_t q)
12 {
13  typedef typename field_basic<T,M>::size_type size_type;
14  T value = 0;
15  size_type loc_idof = 0;
16  bops.evaluate (hat_K, q);
17  for (size_type loc_idof = 0, loc_ndof = dis_idof.size(); loc_idof < loc_ndof; ++loc_idof) {
18  const T& cdof = bops.value (loc_idof);
19  const T& udof = uh.dis_dof (dis_idof[loc_idof]);
20  value += cdof*udof;
21  }
22  return value;
23 }
24 template<class T, class M>
27  const field_basic<T,M>& uh,
28  const basis_on_pointset<T>& bops,
29  reference_element hat_K,
30  const std::vector<size_t>& dis_idof_tab,
31  size_t q)
32 {
33  typedef typename field_basic<T,M>::size_type size_type;
34  size_type dis_ndof = uh.dis_ndof();
35  size_type loc_ndof = dis_idof_tab.size();
36  bops.evaluate (hat_K, q);
37  size_type loc_comp_ndof = std::distance (bops.begin(), bops.end());
38  size_type loc_comp_idof = 0;
39  size_type n_comp = uh.get_geo().dimension();
40  point_basic<T> value (0,0,0);
41  for (typename basis_on_pointset<T>::const_iterator iter = bops.begin(), last = bops.end();
42  iter != last;
43  iter++, loc_comp_idof++) {
44  const T& cdof = *iter;
45  for (size_type i_comp = 0; i_comp < n_comp; i_comp++) {
46  size_type loc_idof = loc_comp_idof + i_comp*loc_comp_ndof;
47  assert_macro (loc_idof < loc_ndof, "invalid local index "<<loc_idof<<" out of range [0:"<<loc_ndof<<"[");
48  size_type dis_idof = dis_idof_tab[loc_idof];
49  assert_macro (dis_idof < dis_ndof, "invalid distr index");
50  const T& udof = uh.dis_dof (dis_idof);
51  value[i_comp] += cdof*udof;
52  }
53  }
54  return value;
55 }
56 template<class T, class M>
59  const field_basic<T,M>& uh,
60  const basis_on_pointset<T>& bops,
61  reference_element hat_K,
62  const std::vector<size_t>& dis_idof_tab,
63  size_t q)
64 {
65  typedef typename field_basic<T,M>::size_type size_type;
66  size_type dis_ndof = uh.dis_ndof();
67  size_type loc_ndof = dis_idof_tab.size();
68  bops.evaluate (hat_K, q);
69  size_type loc_comp_ndof = std::distance (bops.begin(), bops.end());
70  size_type loc_comp_idof = 0;
71  size_type d = uh.get_geo().dimension();
72  space_constant::coordinate_type sys_coord = uh.get_geo().coordinate_system();
73  size_type n_comp = space_constant::n_component (space_constant::tensor, d, sys_coord);
74  tensor_basic<T> value; // initiated to zero
75  for (typename basis_on_pointset<T>::const_iterator iter = bops.begin(), last = bops.end();
76  iter != last;
77  iter++, loc_comp_idof++) {
78  const T& cdof = *iter;
79  for (size_type ij_comp = 0; ij_comp < n_comp; ij_comp++) {
80  size_type loc_idof = loc_comp_idof + ij_comp*loc_comp_ndof;
81  assert_macro (loc_idof < loc_ndof, "invalid local index "<<loc_idof<<" out of range [0:"<<loc_ndof<<"[");
82  size_type dis_idof = dis_idof_tab[loc_idof];
83  assert_macro (dis_idof < dis_ndof, "invalid distr index");
84  const T& udof = uh.dis_dof (dis_idof);
85  T tmp = cdof*udof;
86  std::pair<size_type,size_type> ij
88  size_type i = ij.first;
89  size_type j = ij.second;
90  value(i,j) += tmp;
91  if (i != j) value(j,i) += tmp;
92  }
93  }
94  return value;
95 }
96 template<class T, class M>
97 T
99  const field_basic<T,M>& uh,
100  const basis_on_pointset<T>& bops,
101  reference_element hat_K,
102  const std::vector<size_t>& dis_idof_tab,
103  size_t q,
104  size_t i_comp)
105 {
106  typedef typename field_basic<T,M>::size_type size_type;
107  bops.evaluate (hat_K, q);
108  size_type dis_ndof = uh.dis_ndof();
109  size_type loc_ndof = dis_idof_tab.size();
110  size_type loc_comp_ndof = std::distance (bops.begin(), bops.end());
111  size_type loc_comp_idof = 0;
112  size_type n_comp = uh.get_geo().dimension();
113  T value = 0;
114  for (typename basis_on_pointset<T>::const_iterator iter = bops.begin(), last = bops.end();
115  iter != last;
116  iter++, loc_comp_idof++) {
117  const T& cdof = *iter;
118  size_type loc_idof = loc_comp_idof + i_comp*loc_comp_ndof;
119  assert_macro (loc_idof < loc_ndof, "invalid local index "<<loc_idof<<" out of range [0:"<<loc_ndof<<"[");
120  size_type dis_idof = dis_idof_tab[loc_idof];
121  assert_macro (dis_idof < dis_ndof, "invalid distr index");
122  const T& udof = uh.dis_dof (dis_idof);
123  value += cdof*udof;
124  }
125  return value;
126 }
127 #define _RHEOLEF_instanciation(T,M) \
128 template \
129 T \
130 field_evaluate<T,M>( \
131  const field_basic<T,M>& uh, \
132  const basis_on_pointset<T>& bops, \
133  reference_element hat_K, \
134  const std::vector<size_t>& dis_idof, \
135  size_t q); \
136 template \
137 point_basic<T> \
138 vector_field_evaluate<T,M> ( \
139  const field_basic<T,M>& uh, \
140  const basis_on_pointset<T>& bops, \
141  reference_element hat_K, \
142  const std::vector<size_t>& dis_idof_tab, \
143  size_t q); \
144 template \
145 tensor_basic<T> \
146 tensor_field_evaluate<T,M> ( \
147  const field_basic<T,M>& uh, \
148  const basis_on_pointset<T>& bops, \
149  reference_element hat_K, \
150  const std::vector<size_t>& dis_idof_tab, \
151  size_t q); \
152 template \
153 T \
154 field_component_evaluate<T,M> ( \
155  const field_basic<T,M>& uh, \
156  const basis_on_pointset<T>& bops, \
157  reference_element hat_K, \
158  const std::vector<size_t>& dis_idof_tab, \
159  size_t q, \
160  size_t i_comp);
161 
162 _RHEOLEF_instanciation(Float,sequential)
163 #ifdef _RHEOLEF_HAVE_MPI
164 _RHEOLEF_instanciation(Float,distributed)
165 #endif // _RHEOLEF_HAVE_MPI
166 
167 } // namespace rheolef
const T & dis_dof(size_type dis_idof) const
Definition: field.cc:270
std::size_t size_type
Definition: field.h:234
field - piecewise polynomial finite element field
reference_element - reference element
point - vertex of a mesh
Definition: point.h:22
irheostream, orheostream - large data streams
Definition: compiler.h:7
#define assert_macro(ok_condition, message)
Definition: compiler.h:121
const geo_type & get_geo() const
Definition: field.h:284
double Float
Definition: compiler.h:160
size_t d
rheolef::std value
T field_component_evaluate(const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q, size_t i_comp)
size_type dis_ndof() const
Definition: field.h:319
point_basic< T > vector_field_evaluate(const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q)
std::pair< size_type, size_type > tensor_subscript(valued_type valued_tag, coordinate_type sys_coord, size_type i_comp)
size_type n_component(valued_type valued_tag, size_type d, coordinate_type sys_coord)
#define _RHEOLEF_instanciation(T, M)
T field_evaluate(const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q)
tensor_basic< T > tensor_field_evaluate(const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q)