Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
field.cc
Go to the documentation of this file.
1
21#include "rheolef/field_wdof_sliced.h" // TODO: should be cleaned after rdof
22#include "rheolef/field.h"
23#include "rheolef/rheostream.h"
24#include "rheolef/iorheo.h"
25#include "rheolef/piola_util.h"
26#include "rheolef/field_expr.h"
27
28namespace rheolef {
29
30// ---------------------------------------------------------------------------
31// allocators
32// ---------------------------------------------------------------------------
33// TODO: DVT_EXPR_CTE_VEC : init_value as point or tensor
34template <class T, class M>
36 const space_type& V,
37 const T& init_value)
38 : _V (V),
39 _u (),
40 _b (),
41 _dis_dof_indexes_requires_update(true),
42 _dis_dof_assembly_requires_update(true)
43{
44 _u.resize (_V.iu_ownership(), init_value);
45 _b.resize (_V.ib_ownership(), init_value);
46}
47template <class T, class M>
48void
50 const space_type& V,
51 const T& init_value)
52{
53 if (_V == V) return;
54 _V = V;
55 _u.resize (_V.iu_ownership(), init_value);
56 _b.resize (_V.ib_ownership(), init_value);
57 dis_dof_indexes_requires_update();
58 dis_dof_assembly_requires_update();
59}
60// ---------------------------------------------------------------------------
61// input
62// ---------------------------------------------------------------------------
63template <class T, class M>
64static
65void
66get_field_recursive (
67 idiststream& ids,
68 vec<T,M>& u_io,
69 const space_constitution<T,M>& constit,
70 distributor::size_type& comp_start_dis_idof,
71 distributor::size_type& comp_start_ios_idof,
72 bool read_header = false)
73{
74 using namespace std;
76 if (! constit.is_hierarchical()) {
77 // non-hierarchical case:
78 const space_constitution_terminal<T,M>& terminal_constit = constit.get_terminal();
79 size_type comp_dis_ndof = constit.dis_ndof();
80#ifdef TODO
81 // conserve a copy of V[i_comp].ios_ownership()
82 const distributor& comp_ios_ownership = terminal_constit.ios_ownership();
83 size_type comp_ios_ndof = comp_ios_ownership.size();
84#else // TODO
85 // recompute V[i_comp].ios_ownership() with comms and risks of errors
86 size_type comp_ios_ndof = constit.ios_ndof();
87 distributor comp_ios_ownership (comp_dis_ndof, ids.comm(), comp_ios_ndof);
88#endif // TODO
89 if (read_header) {
90 check_macro (dis_scatch(ids, comp_ios_ownership.comm(), "\nfield"), "read field failed");
91 size_type version, dis_size1;
92 std::string geo_name, approx;
93 ids >> version >> dis_size1 >> geo_name >> approx;
94 // TODO: some checks here: geo.name, size, approx
95 }
96 vec<T,M> u_comp_io (comp_ios_ownership, std::numeric_limits<T>::max());
97 u_comp_io.get_values (ids);
98 size_type ios_ndof = u_io.size();
99 for (size_type comp_ios_idof = 0; comp_ios_idof < comp_ios_ndof; comp_ios_idof++) {
100 size_type ios_idof = comp_start_ios_idof + comp_ios_idof;
101 assert_macro (ios_idof < ios_ndof, "ios_idof="<<ios_idof<<" out of range [0:"<<ios_ndof<<"[");
102 u_io [ios_idof] = u_comp_io [comp_ios_idof];
103 }
104 comp_start_dis_idof += comp_dis_ndof;
105 comp_start_ios_idof += comp_ios_ndof;
106 return;
107 }
108 // hierarchical case:
109 typedef typename space_constitution<T,M>::hierarchy_type hier_t;
110 const hier_t& hier_constit = constit.get_hierarchy();
111 for (typename hier_t::const_iterator iter = hier_constit.begin(), last = hier_constit.end(); iter != last; ++iter) {
112 const space_constitution<T,M>& curr_constit = *iter;
113 get_field_recursive (ids, u_io, curr_constit, comp_start_dis_idof, comp_start_ios_idof, true);
114 }
115}
116// extern: defined in space_constitution_old_get.cc
117template<class T, class M>
118void space_constitution_old_get (idiststream& ids, space_constitution<T,M>& constit);
119
120template <class T, class M>
121idiststream&
123{
124 using namespace std;
125 dis_dof_indexes_requires_update();
126 communicator comm = ids.comm();
127 if ( ! dis_scatch (ids, comm, "\nfield")) {
128 error_macro ("read field failed");
129 return ids;
130 }
131 size_type version;
132 ids >> version;
133 check_macro (version <= 3, "unexpected field version " << version);
135 std::string constit_name_input;
136 if (version == 1) {
137 // scalar case
138 size_type dis_size1;
139 std::string geo_name, approx;
140 ids >> dis_size1
141 >> geo_name
142 >> approx;
143 geo_type omega;
144 if (_V.get_geo().name() == geo_name) {
145 omega = _V.get_geo(); // reuse the previous mesh
146 } else {
147 omega = geo_type (geo_name); // load a new mesh
148 }
149 // TODO: get directly "P1" as a space_constitution by: "ids >> constit"; as for the version 2 format
150 constit = space_constitution<T,M>(omega, approx);
151 } else {
152 // version=2,3: multi-field header
153 // version == 2 : old format, hierarchical for vector & tensor valued fields
154 // version == 3 : new format, hierarchical for only heterogeneous fields based on spaces product
155 bool have_constit = false;
156 std::string label;
157 ids >> label;
158 check_macro (label == "header", "field file format version "<< version << ": \"header\" keyword not found");
159 while (ids.good()) {
160 ids >> label;
161 if (label == "end") {
162 break;
163 } else if (label == "size") {
164 size_type dummy_sz;
165 ids >> dummy_sz;
166 } else if (label == "constitution") {
167 ids >> constit_name_input;
168 std::istringstream istrstr (constit_name_input);
169 idiststream idiststrstr (istrstr);
170 if (version == 3) {
171 idiststrstr >> constit;
172 } else {
173 space_constitution_old_get (idiststrstr, constit);
174 }
175 have_constit = true;
176 } else {
177 error_macro ("unexpected field header member: \""<<label<<"\"");
178 }
179 }
180 ids >> label;
181 check_macro (label == "header", "field file format version "<< version << ": \"end header\" keyword not found");
182 check_macro (have_constit, "field file format version "<< version << ": \"constitution\" keyword not found");
183 }
184 // TODO: do not load mesh when we re-use _V: read only string constit and compare to _V.name()
185 if (!(_V.get_constitution() == constit)) {
186 // here cannot re-use _V: build a new space and resize the field
187 resize (space_type(constit));
188 }
189 size_type dis_ndof = _V.ownership().dis_size();
190 size_type my_proc = comm.rank();
191 size_type io_proc = ids.io_proc();
192 vec<T,M> u_io (_V.ios_ownership(), std::numeric_limits<T>::max());
193 vec<T,M> u_dof (_V.ownership(), std::numeric_limits<T>::max());
194 size_type comp_start_ios_idof = 0;
195 size_type comp_start_dis_idof = 0;
196 u_io.get_values (ids);
197 for (size_type ios_idof = 0, ios_ndof = _V.ios_ownership().size(); ios_idof < ios_ndof; ios_idof++) {
198 const T& value = u_io [ios_idof];
199 size_type dis_idof = _V.ios_idof2dis_idof (ios_idof);
200 u_dof.dis_entry (dis_idof) = value;
201 }
202 // here dispatch: communications:
203 u_dof.dis_entry_assembly();
204 // then copy vector into field (unknown, blocked) without comms
205 bool need_old2new_convert
206 = (version == 2
207 && constit.valued_tag() != space_constant::scalar
208 && constit.valued_tag() != space_constant::mixed);
209 if (!need_old2new_convert) {
210 for (size_type idof = 0, ndof = _V.ownership().size(); idof < ndof; idof++) {
211 dof(idof) = u_dof [idof];
212 }
213 return ids;
214 }
215 // automatically convert vector/tensor to version 3 by grouping components
216 std::string valued = constit.valued();
217 std::string approx = constit[0].get_basis().name();
218 std::string geo_name = constit.get_geo().name();
219 size_type n_comp = constit.size();
220 std::string new_constit_name_input = valued + "(" + approx + "){" + geo_name + "}";
221 std::istringstream new_istrstr (new_constit_name_input);
222 idiststream new_idiststrstr (new_istrstr);
223 space_constitution<T,M> new_constit;
224 new_idiststrstr >> new_constit;
225 resize (space_type(new_constit));
226 size_type ndof = u_dof.size();
227 size_type comp_ndof = ndof/n_comp;
228 // convert: new vector/tensor dof numbering have grouped components
229 for (size_type i_comp = 0; i_comp < n_comp; i_comp++) {
230 for (size_type comp_idof = 0; comp_idof < comp_ndof; comp_idof++) {
231 size_type new_idof = comp_idof*n_comp + i_comp;
232 size_type old_idof = i_comp*comp_ndof + comp_idof;
233 dof(new_idof) = u_dof [old_idof];
234 }
235 }
236 return ids;
237}
238// ---------------------------------------------------------------------------
239// output
240// ---------------------------------------------------------------------------
241template <class T, class M>
242static
243void
244put_field_recursive (
245 odiststream& ods,
247 const space_constitution<T,M>& constit,
248 distributor::size_type& comp_start_idof,
249 distributor::size_type& comp_start_dis_idof,
250 bool write_header = false)
251{
252 using namespace std;
254 if (! constit.is_hierarchical()) {
255 // non-hierarchical case:
256 // 1) merge distributed blocked and non-blocked and apply iso_dof permutation:
257 size_type comp_ndof = constit.ndof();
258 size_type comp_dis_ndof = constit.dis_ndof();
259 communicator comm = constit.comm();
260 const space_constitution_terminal<T,M>& terminal_constit = constit.get_terminal();
262 size_type my_proc = comm.rank();
263 distributor comp_ios_ownership (comp_dis_ndof, comm, (my_proc == io_proc ? comp_dis_ndof : 0));
264 vec<T,M> comp_u_io (comp_ios_ownership, std::numeric_limits<T>::max());
265 for (size_type comp_idof = 0; comp_idof < comp_ndof; comp_idof++) {
266 size_type idof = comp_start_idof + comp_idof;
267 T value = uh.dof (idof);
268 size_type ios_dis_idof = uh.get_space().idof2ios_dis_idof (idof);
269 assert_macro (ios_dis_idof >= comp_start_dis_idof, "invalid comp ios index");
270 size_type comp_ios_dis_idof = ios_dis_idof - comp_start_dis_idof;
271 comp_u_io.dis_entry (comp_ios_dis_idof) = value;
272 }
273 comp_u_io.dis_entry_assembly();
274 // 2) then output the current field component
275 size_type old_prec = ods.os().precision();
276 ods << setprecision(std::numeric_limits<Float>::digits10);
277 if (write_header) {
278 ods << "field" << endl
279 << "1 " << comp_dis_ndof << endl
280 << terminal_constit.get_geo().name() << endl
281 << terminal_constit.get_basis().name() << endl
282 << endl;
283 }
284 ods << comp_u_io
285 << setprecision(old_prec);
286 comp_start_idof += comp_ndof;
287 comp_start_dis_idof += comp_dis_ndof;
288 if (comp_start_dis_idof != uh.dis_ndof()) {
289 ods << endl;
290 }
291 return;
292 }
293 // hierarchical case:
294 typedef typename space_constitution<T,M>::hierarchy_type hier_t;
295 const hier_t& hier_constit = constit.get_hierarchy();
296 for (typename hier_t::const_iterator iter = hier_constit.begin(), last = hier_constit.end(); iter != last; ++iter) {
297 const space_constitution<T,M>& curr_constit = *iter;
298 put_field_recursive (ods, uh, curr_constit, comp_start_idof, comp_start_dis_idof, false);
299 }
300}
301template <class T, class M>
305 using namespace std;
306 bool need_header = (get_space().get_constitution().is_hierarchical());
307 if (need_header) {
308 // multi-field header or non-equispaced node set
309 ods << "field" << endl
310 << "3" << endl
311 << "header" << endl
312 << " constitution " << get_space().get_constitution().name() << endl
313 << " size " << get_space().get_constitution().dis_ndof() << endl
314 << "end header" << endl
315 << endl;
316 } else {
317 // scalar-field header and equispaced node set
318 const space_constitution_terminal<T,M>& terminal_constit = get_space().get_constitution().get_terminal();
319 ods << "field" << endl
320 << "1 " << dis_ndof() << endl
321 << terminal_constit.get_geo().name() << endl
322 << terminal_constit.get_basis().name() << endl
323 << endl;
324 }
325 size_type comp_start_idof = 0;
326 size_type comp_start_dis_idof = 0;
327 put_field_recursive (ods, *this, get_space().get_constitution(), comp_start_idof, comp_start_dis_idof);
328 return ods;
329}
330// ----------------------------------------------------------------------------
331// graphic output switch
332// ----------------------------------------------------------------------------
333// class-member template partial specialization 'field<T, M>::put(ods)' is not allowed
334// here, we want to specialize for M=seq & M=dist since only seq graphic is vailable yet:
336template <class T> odiststream& visu_gmsh (odiststream&, const field_basic<T,sequential>&);
338template <class T> odiststream& field_put_gmsh (odiststream&, const field_basic<T,sequential>&, std::string);
341
342// => use an intermediate class-function with full class specialization
343template <class T, class M>
344struct field_put {
345 odiststream& operator() (odiststream& ods, const field_basic<T, M>& uh) const {
346 return uh.put_field (ods);
347 }
348};
349// now, we can specialize the full class when M=seq:
350template <class T>
351struct field_put<T,sequential> {
352 odiststream& operator() (odiststream& ods, const field_basic<T,sequential>& uh) const
353 {
354 iorheo::flag_type format = iorheo::flags(ods.os()) & iorheo::format_field;
355 if (format [iorheo::gnuplot]) { return visu_gnuplot (ods,uh); }
356 if (format [iorheo::paraview]){ return visu_vtk_paraview (ods,uh); }
357 if (format [iorheo::gmsh]) { return visu_gmsh (ods,uh); }
358 // if (format [iorheo::gmsh]) { return field_put_gmsh (ods,uh,""); }
359 if (format [iorheo::gmsh_pos]){ return field_put_gmsh_pos(ods,uh); }
360 if (format [iorheo::bamg]) { return field_put_bamg_bb (ods,uh); }
361 return uh.put_field (ods);
362 }
363};
364// finally, the field::put member function uses the class-function
365template <class T, class M>
366odiststream&
368{
369 field_put<T,M> put_fct;
370 return put_fct (ods, *this);
371}
372// ----------------------------------------------------------------------------
373// access to non-local dofs
374// ----------------------------------------------------------------------------
375template <class T, class M>
376const T&
378{
380 if (_dis_dof_indexes_requires_update || _dis_dof_assembly_requires_update) {
381 size_type nproc = comm().size();
382 check_macro (nproc == 1, "field::dis_dof_update() need to be called before field::dis_dof(dis_idof)");
383 }
384 }
385 if (ownership().is_owned (dis_idof)) {
386 size_type first_idof = ownership().first_index ();
387 size_type idof = dis_idof - first_idof;
388 return dof (idof);
389 }
390 // here dis_idof is owned by another proc
391 space_pair_type blk_dis_iub = _V.data()._idof2blk_dis_iub.dis_at (dis_idof); // TODO: write a better access !
392 size_type dis_iub = blk_dis_iub.dis_iub();
393 const T& value = (! blk_dis_iub.is_blocked()) ? _u.dis_at (dis_iub) : _b.dis_at (dis_iub);
394 return value;
395}
396template <class T, class M>
399{
400 dis_dof_assembly_requires_update();
401 const space_pair_type& blk_dis_iub = _V.data()._idof2blk_dis_iub.dis_at (dis_idof); // TODO: write a better access !
402 size_type dis_iub = blk_dis_iub.dis_iub();
403 if (! blk_dis_iub.is_blocked()) {
404 return _u.dis_entry (dis_iub);
405 } else {
406 return _b.dis_entry (dis_iub);
407 }
408}
409// ----------------------------------------------------------------------------
410// evaluation
411// ----------------------------------------------------------------------------
412template <class T, class M>
413T
415{
416 const basis_basic<T>& b = _V.get_basis();
417 size_type loc_ndof = b.ndof (K.variant()) ;
418 std::vector<size_type> dis_idof1 (loc_ndof);
419 _V.dis_idof (K, dis_idof1);
420
421 std::vector<T> dof (loc_ndof);
422 for (size_type loc_idof = 0; loc_idof < loc_ndof; loc_idof++) {
423 dof [loc_idof] = dis_dof (dis_idof1 [loc_idof]);
424 }
425 // WARNING: not efficient since it evaluate the hat_basis at each hat_x
426 // when hat_x is on a repetitive pattern, such as quadrature nodes or Lagrange basis nodes
427 // TODO: evaluate basis one time for all on hat_K
428 Eigen::Matrix<T,Eigen::Dynamic,1> b_value (loc_ndof);
429 b.evaluate (K, hat_x, b_value);
430
431 T value = 0;
432 for (size_type loc_idof = 0; loc_idof < loc_ndof; loc_idof++) {
433 value += dof [loc_idof] * b_value[loc_idof]; // sum_i w_coef(i)*hat_phi(hat_x)
434 }
435 return value;
436}
437template <class T, class M>
438T
440{
441 dis_dof_update();
442 const geo_basic<T,M>& omega = _V.get_geo();
443 size_type dis_ie = omega.dis_locate (x);
444 check_macro (dis_ie != std::numeric_limits<size_type>::max(), "x="<<x<<" is outside the domain");
445 // only the proc owner of dis_ie compute the value; other procs are waiting for the value
446 T value = std::numeric_limits<T>::max();
447 size_type map_dim = omega.map_dimension();
448 const distributor& ownership = omega.geo_element_ownership(map_dim);
449 size_type ie_proc = ownership.find_owner(dis_ie);
450 size_type my_proc = ownership.comm().rank();
451 std::vector<size_type> dis_inod;
452 if (my_proc == ie_proc) {
453 size_type first_dis_ie = ownership.first_index();
454 size_type ie = dis_ie - first_dis_ie;
455 const geo_element& K = omega[ie];
456 omega.dis_inod (K, dis_inod);
457 point_basic<T> hat_x = inverse_piola_transformation (_V.get_geo(), K, dis_inod, x);
458 value = evaluate (K, hat_x, i_comp);
459 }
460#ifdef _RHEOLEF_HAVE_MPI
462 mpi::broadcast (mpi::communicator(), value, ie_proc);
463 }
464#endif // _RHEOLEF_HAVE_MPI
465 return value;
466}
467template <class T, class M>
470{
471 fatal_macro ("dis_vector_evaluate: not yet");
472 return point_basic<T>();
473}
474// ----------------------------------------------------------------------------
475// tensor component access: sigma_h(i,j)
476// ----------------------------------------------------------------------------
477#ifdef TO_CLEAN
478template <class T, class M>
481{
482 space_constant::coordinate_type sys_coord = get_geo().coordinate_system();
483 size_type ij_comp = space_constant::tensor_index (valued_tag(), sys_coord, i_comp, j_comp);
485}
486template <class T, class M>
487details::field_wdof_sliced<field_basic<T,M>>
489{
490 space_constant::coordinate_type sys_coord = get_geo().coordinate_system();
491 size_type ij_comp = space_constant::tensor_index (valued_tag(), sys_coord, i_comp, j_comp);
492 return details::field_wdof_sliced<field_basic<T,M>> (*this, ij_comp);
493}
494#endif // TO_CLEAN
495// ----------------------------------------------------------------------------
496// instanciation in library
497// ----------------------------------------------------------------------------
498#define _RHEOLEF_instanciation_base(T,M) \
499template class field_basic<T,M>; \
500template odiststream& operator<< (odiststream&, const field_basic<T,M>&);
501
502#ifdef TODO
503#define _RHEOLEF_instanciation(T,M) \
504_RHEOLEF_instanciation_base(T,M) \
505_RHEOLEF_instanciation_base(std::complex<T>,M)
506#else // TODO
507#define _RHEOLEF_instanciation(T,M) \
508_RHEOLEF_instanciation_base(T,M)
509#endif // TODO
510
512#ifdef _RHEOLEF_HAVE_MPI
513_RHEOLEF_instanciation(Float,distributed)
514#endif // _RHEOLEF_HAVE_MPI
515
516} // namespace rheolef
#define _RHEOLEF_instanciation(T, M, A)
Definition asr.cc:223
field::size_type size_type
Definition branch.cc:430
see the Float page for the full documentation
see the communicator page for the full documentation
see the distributor page for the full documentation
Definition distributor.h:69
size_type find_owner(size_type dis_i) const
find iproc associated to a global index dis_i: CPU=log(nproc)
size_type size(size_type iproc) const
size_type first_index(size_type iproc) const
global index range and local size owned by ip-th process
std::allocator< int >::size_type size_type
Definition distributor.h:74
const communicator_type & comm() const
const T & dis_dof(size_type dis_idof) const
Definition field.cc:377
vec< T, M > _u
Definition field.h:477
vec< T, M > _b
Definition field.h:478
size_type dis_ndof() const
Definition field.h:299
space_type _V
Definition field.h:476
idiststream & get(idiststream &ips)
Definition field.cc:122
point_basic< T > dis_vector_evaluate(const point_basic< T > &x) const
Definition field.cc:469
T & dof(size_type idof)
Definition field.h:738
odiststream & put(odiststream &ops) const
Definition field.cc:367
dis_reference dis_dof_entry(size_type dis_idof)
Definition field.cc:398
odiststream & put_field(odiststream &ops) const
Definition field.cc:303
typename vec< scalar_type, memory_type >::dis_reference dis_reference
Definition field.h:231
T operator()(const point_basic< T > &x) const
Definition field.h:320
const space_type & get_space() const
Definition field.h:270
T evaluate(const geo_element &K, const point_basic< T > &hat_xq, size_type i_comp=0) const
Definition field.cc:414
void resize(const space_type &V, const T &init_value=std::numeric_limits< T >::max())
Definition field.cc:49
std::size_t size_type
Definition field.h:225
T dis_evaluate(const point_basic< T > &x, size_type i_comp=0) const
Definition field.cc:439
see the geo_element page for the full documentation
variant_type variant() const
idiststream: see the diststream page for the full documentation
Definition diststream.h:336
static size_type io_proc()
This routine returns the rank of a process that can perform i/o.
Definition diststream.cc:64
const communicator & comm() const
Definition diststream.h:356
std::bitset< last > flag_type
Definition iorheo.h:440
static flag_type format_field
Definition iorheo.h:445
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
std::ostream & os()
Definition diststream.h:247
static size_type io_proc()
Definition diststream.cc:79
const basis_basic< T > & get_basis() const
const geo_basic< T, M > & get_geo() const
const basis_basic< T > & get_basis() const
const valued_type & valued_tag() const
rep::hierarchy_type hierarchy_type
const space_constitution_terminal< T, M > & get_terminal() const
const hierarchy_type & get_hierarchy() const
const std::string & valued() const
const geo_basic< T, M > & get_geo() const
see the vec page for the full documentation
Definition vec.h:79
void resize(const distributor &ownership, const T &init_val=std::numeric_limits< T >::max())
Definition vec.h:199
#define assert_macro(ok_condition, message)
Definition dis_macros.h:113
#define error_macro(message)
Definition dis_macros.h:49
#define fatal_macro(message)
Definition dis_macros.h:33
void get_geo(istream &in, my_geo &omega)
Expr1::float_type T
Definition field_expr.h:230
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
size_type tensor_index(valued_type valued_tag, coordinate_type sys_coord, size_type i, size_type j)
This file is part of Rheolef.
void space_constitution_old_get(idiststream &ids, space_constitution< T, M > &constit)
odiststream & visu_vtk_paraview(odiststream &, const field_basic< T, sequential > &)
odiststream & field_put_gmsh_pos(odiststream &, const field_basic< T, sequential > &)
odiststream & visu_gmsh(odiststream &, const field_basic< T, sequential > &)
bool dis_scatch(idiststream &ips, const communicator &comm, std::string ch)
distributed version of scatch(istream&,string)
Definition diststream.cc:44
void evaluate(const geo_basic< float_type, M > &omega_K, const geo_element &K, Eigen::Matrix< Result, Eigen::Dynamic, 1 > &value) const
point_basic< T > inverse_piola_transformation(const geo_basic< T, M > &omega, const reference_element &hat_K, const std::vector< size_t > &dis_inod, const point_basic< T > &x)
odiststream & field_put_bamg_bb(odiststream &, const field_basic< T, sequential > &)
odiststream & visu_gnuplot(odiststream &, const field_basic< T, sequential > &)
odiststream & field_put_gmsh(odiststream &, const field_basic< T, sequential > &, std::string)
space_constant::valued_type valued_tag() const
STL namespace.
size_type dis_iub() const
Definition space.h:126
bool is_blocked() const
Definition space.h:125