Rheolef  7.1
an efficient C++ finite element environment
geo_seq_visu_gnuplot.cc
Go to the documentation of this file.
1 //
22 // gnuplot geo visualisation
23 //
24 // author: Pierre.Saramito@imag.fr
25 //
26 // date: 16 sept 2011
27 //
28 #include "rheolef/geo.h"
29 #include "rheolef/rheostream.h"
30 #include "rheolef/iorheo.h"
31 #include "rheolef/reference_element.h"
32 #include "rheolef/piola_util.h"
33 
34 namespace rheolef {
35 
36 // ----------------------------------------------------------------------------
37 // element puts
38 // ----------------------------------------------------------------------------
39 template<class T>
40 static
41 void
42 put_vertex (std::ostream& gdat, const geo_element& P, const geo_basic<T,sequential>& omega)
43 {
44  using namespace std;
46  size_type dim = max (omega.dimension(), size_type(2));
47  omega.node (P[0]).put (gdat, dim); gdat << endl;
48 }
49 // simple edge, could be curved (order > 1 => n_node = order+1 > 2)
50 template<class T>
51 static
52 void
53 put_edge (std::ostream& gdat, const geo_element& E, const geo_basic<T,sequential>& omega,
54  const basis_on_pointset<T>& pointset, size_t subdivide)
55 {
56  using namespace std;
58  typedef point_basic<size_type> ilat;
59  size_type dim = max (omega.dimension(), size_type(2));
60  std::vector<size_type> dis_inod;
61  omega.dis_inod (E, dis_inod);
62  Eigen::Matrix<point_basic<T>,Eigen::Dynamic,1> x;
63  piola_transformation (omega, pointset, E.variant(), dis_inod, x);
64  for (size_type i = 0; i <= subdivide; i++) {
65  size_type loc_inod = reference_element_e::ilat2loc_inod (subdivide, ilat(i));
66  x[loc_inod].put (gdat, dim); gdat << endl;
67  }
68  gdat << endl << endl;
69 }
70 // 2d triangle or quadrangle
71 template<class T>
72 static
73 void
74 put_2d_face (std::ostream& gdat, const geo_element& F, const geo_basic<T,sequential>& omega,
75  const basis_on_pointset<T>& pointset, size_t subdivide)
76 {
77  using namespace std;
79  typedef point_basic<size_type> ilat;
80  size_type dim = max (omega.dimension(), size_type(2));
81  std::vector<size_type> dis_inod;
82  omega.dis_inod (F, dis_inod);
83  Eigen::Matrix<point_basic<T>,Eigen::Dynamic,1> x;
84  piola_transformation (omega, pointset, F.variant(), dis_inod, x);
85  if (F.variant() == reference_element::q) {
86  // 2d quadrangle: draw lines of the lattice
87  // ICI
88  for (size_type j = 0; j < subdivide; j++) {
89  for (size_type i = 0; i < subdivide; i++) {
90  size_type loc_inod00 = reference_element_q::ilat2loc_inod (subdivide, ilat(i, j));
91  size_type loc_inod10 = reference_element_q::ilat2loc_inod (subdivide, ilat(i+1, j));
92  size_type loc_inod01 = reference_element_q::ilat2loc_inod (subdivide, ilat(i, j+1));
93  size_type loc_inod11 = reference_element_q::ilat2loc_inod (subdivide, ilat(i+1, j+1));
94  const point_basic<T>& x00 = x[loc_inod00];
95  const point_basic<T>& x10 = x[loc_inod10];
96  const point_basic<T>& x01 = x[loc_inod01];
97  const point_basic<T>& x11 = x[loc_inod11];
98  if (i+1 == subdivide) {
99  x11.put (gdat, dim); gdat << endl;
100  }
101  x10.put (gdat, dim); gdat << endl;
102  x00.put (gdat, dim); gdat << endl;
103  x01.put (gdat, dim); gdat << endl;
104  if (j+1 == subdivide) {
105  x11.put (gdat, dim); gdat << endl;
106  }
107  gdat << endl;
108  }
109  }
110  gdat << endl;
111  } else {
112  // 2d triangle: draw lines of the lattice
113  for (size_type i = 0; i < subdivide; i++) {
114  for (size_type j = 0; j < subdivide - i; j++) {
115  size_type loc_inod00 = reference_element_t::ilat2loc_inod (subdivide, ilat(i, j));
116  size_type loc_inod10 = reference_element_t::ilat2loc_inod (subdivide, ilat(i+1, j));
117  size_type loc_inod01 = reference_element_t::ilat2loc_inod (subdivide, ilat(i, j+1));
118  const point_basic<T>& x00 = x[loc_inod00];
119  const point_basic<T>& x10 = x[loc_inod10];
120  const point_basic<T>& x01 = x[loc_inod01];
121  x10.put (gdat, dim); gdat << endl;
122  x00.put (gdat, dim); gdat << endl;
123  x01.put (gdat, dim); gdat << endl;
124  if (i+j+1 == subdivide) {
125  x10.put (gdat, dim); gdat << endl;
126  }
127  gdat << endl;
128  }
129  }
130  gdat << endl;
131  }
132 }
133 // 3d triangle or quadrangle: splot lattice data, for hidden faces removal
134 template<class T>
135 static
136 void
137 put_3d_face (std::ostream& gdat, const geo_element& F, const geo_basic<T,sequential>& omega)
138 {
139  using namespace std;
141  typedef point_basic<size_type> ilat;
142  size_type dim = max (omega.dimension(), size_type(2));
143  size_type order = omega.order();
144  std::vector<size_type> inod;
145  omega.dis_inod (F, inod);
146  gdat << "# F"<<F.dis_ie()<<endl;
147  for (size_type j = 0; j <= order; j++) {
148  for (size_type i = 0; i <= order; i++) {
149  size_type loc_inod;
150  if (F.variant() == reference_element::q) { // TODO: virtual in geo_elment_v2::loc_ilat2loc_inod
151  loc_inod = reference_element_q::ilat2loc_inod (order, ilat(i, j));
152  } else {
153  loc_inod = reference_element_t::ilat2loc_inod (order, ilat(min(i,order-j), j));
154  }
155  omega.node (inod[loc_inod]).put (gdat, dim); gdat << endl;
156  }
157  gdat << endl;
158  }
159  gdat << endl;
160 }
161 template<class T>
162 static
163 void
164 put_face (std::ostream& gdat, const geo_element& F, const geo_basic<T,sequential>& omega,
165  const basis_on_pointset<T>& pointset, size_t subdivide)
166 {
167  switch (omega.dimension()) {
168  case 2: put_2d_face (gdat, F, omega, pointset, subdivide); break;
169  case 3: put_3d_face (gdat, F, omega); break;
170  default: break;
171  }
172 }
173 template<class T>
174 static
175 void
176 put_volume (std::ostream& gdat, const geo_element& K, const geo_basic<T,sequential>& omega)
177 {
178  using namespace std;
180  typedef point_basic<size_type> ilat;
181  size_type dim = max (omega.dimension(), size_type(2));
182  size_type order = omega.order();
183  std::vector<size_type> inod;
184  omega.dis_inod (K, inod);
185  gdat << "# K"<<K.dis_ie()<<endl;
186  if (K.variant() == reference_element::T) {
187  // 3d tetra: draw lattice
188  for (size_type i = 0; i < order; i++) {
189  for (size_type j = 0; j < order - i; j++) {
190  for (size_type k = 0; k < order - i - j; k++) {
191  size_type loc_inod000 = reference_element_T::ilat2loc_inod (order, ilat(i, j, k));
192  size_type loc_inod100 = reference_element_T::ilat2loc_inod (order, ilat(i+1, j, k));
193  size_type loc_inod010 = reference_element_T::ilat2loc_inod (order, ilat(i, j+1, k));
194  size_type loc_inod001 = reference_element_T::ilat2loc_inod (order, ilat(i, j, k+1));
195  gdat << omega.node (inod[loc_inod100]) << endl
196  << omega.node (inod[loc_inod000]) << endl
197  << omega.node (inod[loc_inod010]) << endl << endl
198  << omega.node (inod[loc_inod000]) << endl
199  << omega.node (inod[loc_inod001]) << endl << endl;
200  if (i+j+k+1 == order) {
201  gdat << omega.node (inod[loc_inod100]) << endl
202  << omega.node (inod[loc_inod010]) << endl
203  << omega.node (inod[loc_inod001]) << endl
204  << omega.node (inod[loc_inod100]) << endl << endl;
205  }
206  }
207  }
208  }
209  } else if (K.variant() == reference_element::H) {
210  // 3d hexa: draw lattice
211  for (size_type k = 0; k < order; k++) {
212  for (size_type j = 0; j < order; j++) {
213  for (size_type i = 0; i < order; i++) {
214  size_type loc_inod000 = reference_element_H::ilat2loc_inod (order, ilat(i, j, k));
215  size_type loc_inod100 = reference_element_H::ilat2loc_inod (order, ilat(i+1, j, k));
216  size_type loc_inod110 = reference_element_H::ilat2loc_inod (order, ilat(i+1, j+1, k));
217  size_type loc_inod010 = reference_element_H::ilat2loc_inod (order, ilat(i, j+1, k));
218  size_type loc_inod001 = reference_element_H::ilat2loc_inod (order, ilat(i, j, k+1));
219  size_type loc_inod101 = reference_element_H::ilat2loc_inod (order, ilat(i+1, j, k+1));
220  size_type loc_inod111 = reference_element_H::ilat2loc_inod (order, ilat(i+1, j+1, k+1));
221  size_type loc_inod011 = reference_element_H::ilat2loc_inod (order, ilat(i, j+1, k+1));
222  gdat << omega.node (inod[loc_inod100]) << endl
223  << omega.node (inod[loc_inod000]) << endl
224  << omega.node (inod[loc_inod010]) << endl << endl
225  << omega.node (inod[loc_inod000]) << endl
226  << omega.node (inod[loc_inod001]) << endl << endl;
227  if (i+1 == order) {
228  gdat << omega.node (inod[loc_inod101]) << endl
229  << omega.node (inod[loc_inod100]) << endl
230  << omega.node (inod[loc_inod110]) << endl << endl;
231  }
232  if (j+1 == order) {
233  gdat << omega.node (inod[loc_inod011]) << endl
234  << omega.node (inod[loc_inod010]) << endl
235  << omega.node (inod[loc_inod110]) << endl << endl;
236  }
237  if (k+1 == order) {
238  gdat << omega.node (inod[loc_inod101]) << endl
239  << omega.node (inod[loc_inod001]) << endl
240  << omega.node (inod[loc_inod011]) << endl << endl;
241  }
242  if (i+1 == order && j+1 == order) {
243  gdat << omega.node (inod[loc_inod110]) << endl
244  << omega.node (inod[loc_inod111]) << endl << endl;
245  }
246  if (i+1 == order && k+1 == order) {
247  gdat << omega.node (inod[loc_inod101]) << endl
248  << omega.node (inod[loc_inod111]) << endl << endl;
249  }
250  if (j+1 == order && k+1 == order) {
251  gdat << omega.node (inod[loc_inod011]) << endl
252  << omega.node (inod[loc_inod111]) << endl << endl;
253  }
254  }
255  }
256  }
257  } else { // prism:
258  error_macro ("gnuplot volume '" << K.name() << "': not yet!");
259  }
260 }
261 template<class T>
262 static
263 void
264 put (std::ostream& gdat, const geo_element& K, const geo_basic<T,sequential>& omega,
265  const basis_on_pointset<T>& pointset, size_t subdivide)
266 {
267  switch (K.dimension()) {
268  case 0: put_vertex (gdat, K, omega); break;
269  case 1: put_edge (gdat, K, omega, pointset, subdivide); break;
270  case 2: put_face (gdat, K, omega, pointset, subdivide); break;
271  case 3: put_volume (gdat, K, omega); break;
272  default: break;
273  }
274 }
275 // ----------------------------------------------------------------------------
276 // mesh puts
277 // ----------------------------------------------------------------------------
278 template <class T>
279 odiststream&
281 {
282  using namespace std;
284  typedef point_basic<size_type> ilat;
285  ostream& os = ops.os();
286  bool verbose = iorheo::getverbose(os);
287  bool clean = iorheo::getclean(os);
288  bool execute = iorheo::getexecute(os);
289  string basename = iorheo::getbasename(os);
290  bool full = iorheo::getfull(os); // all edges & !faces in 3d
291  bool lattice = iorheo::getlattice(os); // face & volume lattices
292  bool reader_on_stdin = iorheo::getreader_on_stdin(os);
293  bool color = iorheo::getcolor(os);
294  string format = iorheo::getimage_format(os);
295  size_type subdivide = iorheo::getsubdivide(os);
296  if (basename.length() == 0) basename = "output";
297  string filelist;
298 
299  size_type dim = max (omega.dimension(), size_type(2));
300  size_type map_dim = omega.map_dimension();
301  size_type order = omega.order();
302  size_type nv = omega.sizes().ownership_by_dimension[0].size();
303  size_type nedg = omega.sizes().ownership_by_dimension[1].size();
304  size_type nfac = omega.sizes().ownership_by_dimension[2].size();
305  size_type nvol = omega.sizes().ownership_by_dimension[3].size();
307 
308  if (order == 1) lattice = false;
309  bool show_volumes = (lattice && full && map_dim == 3);
310  bool show_faces = ((!full || lattice) && map_dim == 3) || (lattice && map_dim < 3);
311  bool show_edges = ((full && map_dim == 3) || (map_dim < 3)) || (order > 1);
312  bool show_vertices = (map_dim <= 1);
313  bool show_domains = true;
314  subdivide = std::max(omega.order(), subdivide);
315 
316  string outfile_fmt = "";
317  string tmp = get_tmpdir() + "/";
318  if (!clean) tmp = "";
319  string filename = tmp+basename + ".plot";
320  filelist = filelist + " " + filename;
321  ofstream plot (filename.c_str());
322  ofstream gdat;
323  if (verbose) clog << "! file \"" << filename << "\" created." << endl;
324 
325  basis_basic<T> subdivide_pointset ("P"+itos(subdivide));
326  basis_on_pointset<T> pointset (subdivide_pointset, omega.get_piola_basis());
327 
328  plot << "#!gnuplot" << endl
329  << setprecision(numeric_limits<T>::digits10);
330  if (format != "") {
331  outfile_fmt = basename + "." + format;
332  string terminal = format;
333  if (terminal == "ps") {
334  terminal = "postscript eps";
335  if (color) terminal += " color";
336  }
337  if (terminal == "jpg") terminal = "jpeg";
338  if (terminal == "jpeg" || terminal == "png" || terminal == "gif") {
339  terminal += " crop";
340  }
341  plot << "set terminal " << terminal << endl
342  << "set output \"" << outfile_fmt << "\"" << endl;
343  }
344  if (format == "") {
345  plot << "set title \"" << basename << ": " << ne << " elements, " << nv << " vertices\"" << endl;
346  }
347  check_macro (omega.dimension() > 0, "unsupported 0d geo gnuplot output");
348  point_basic<T> dx = 0.1*(omega.xmax() - omega.xmin());
349  T dx_max = max(dx[0],max(dx[1],dx[2]));
350  if (dx_max == 0) dx_max = 0.1;
351  dx[0] = max(dx[0],dx_max);
352  if (omega.dimension() >= 2) dx[1] = max(dx[1],dx_max);
353  if (omega.dimension() == 3) dx[2] = max(dx[2],dx_max);
354  point_basic<T> xmin = omega.xmin() - dx;
355  point_basic<T> xmax = omega.xmax() + dx;
356  plot << "set xrange [" << xmin[0] << ":" << xmax[0] << "]" << endl;
357  if (omega.dimension() == 1) {
358  plot << "set yrange [-1:1]" << endl;
359  }
360  if (omega.dimension() >= 2) {
361  plot << "set yrange [" << xmin[1] << ":" << xmax[1] << "]" << endl;
362  }
363  if (omega.dimension() == 2) {
364  plot << "set size ratio -1 # equal scales" << endl
365  << "#set key left Right at graph 1,1" << endl;
366  }
367  if (omega.dimension() == 3) {
368  plot << "set zrange [" << xmin[2] << ":" << xmax[2] << "]" << endl
369  << "set xyplane at " << xmin[2] << endl
370  << "set view equal xyz # equal scales" << endl
371  << "set view 70,120" << endl;
372  if (format != "") {
373  plot << "set noxlabel" << endl
374  << "set noylabel" << endl
375  << "set nozlabel" << endl;
376  } else {
377  plot << "set xlabel \"x\"" << endl
378  << "set ylabel \"y\"" << endl
379  << "set zlabel \"z\"" << endl;
380  }
381  if (!full) {
382  plot << "set hidden3d nooffset" << endl;
383  }
384  }
385  if (format != "") {
386  plot << "set nokey" << endl
387  << "set noborder" << endl
388  << "set notics" << endl;
389  }
390  if (omega.dimension() <= 2) {
391  plot << "plot \\" << endl;
392  } else {
393  plot << "splot \\" << endl;
394  }
395  bool first_plot_line = true;
396  //
397  // plot internal volume, as lattice, for high order elements
398  //
399  if (show_volumes) {
400  filename = tmp+basename + "-vol.gdat";
401  if (!first_plot_line) plot << ",\\" << endl;
402  first_plot_line = false;
403  plot << " \"" << filename << "\" u 1:2:3:(0.0) title \"volumes\" with l lc 3 lw 1";
404 
405  filelist = filelist + " " + filename;
406  gdat.open (filename.c_str());
407  if (verbose) clog << "! file \"" << filename << "\" created." << endl;
408  gdat << setprecision(numeric_limits<T>::digits10);
409  for (size_type ivol = 0; ivol < nvol; ivol++) {
410  const geo_element& K = omega.get_geo_element(3,ivol);
411  put_volume (gdat, K, omega);
412  }
413  gdat.close();
414  }
415  //
416  // plot faces
417  //
418  if (show_faces) {
419  filename = tmp+basename + "-fac.gdat";
420  if (!first_plot_line) plot << ",\\" << endl;
421  first_plot_line = false;
422  plot << " \"" << filename << "\" title \"faces\" with l lc 3 lw 1";
423 
424  filelist = filelist + " " + filename;
425  gdat.open (filename.c_str());
426  if (verbose) clog << "! file \"" << filename << "\" created." << endl;
427  gdat << setprecision(numeric_limits<T>::digits10);
428  for (size_type ifac = 0; ifac < nfac; ifac++) {
429  const geo_element& F = omega.get_geo_element(2,ifac);
430  put_face (gdat, F, omega, pointset, subdivide);
431  }
432  gdat.close();
433  }
434  //
435  // plot edges
436  //
437  if (show_edges) {
438  filename = tmp+basename + "-edg.gdat";
439  if (!first_plot_line) plot << ",\\" << endl;
440  first_plot_line = false;
441  plot << " \"" << filename << "\" title \"edges\" with l lc 1 lw 1.5";
442 
443  filelist = filelist + " " + filename;
444  gdat.open (filename.c_str());
445  if (verbose) clog << "! file \"" << filename << "\" created." << endl;
446  gdat << setprecision(numeric_limits<T>::digits10);
447  for (size_type iedg = 0; iedg < nedg; iedg++) {
448  const geo_element& E = omega.get_geo_element(1,iedg);
449  put_edge (gdat, E, omega, pointset, subdivide);
450  }
451  gdat.close();
452  }
453  //
454  // plot vertices
455  //
456  if (show_vertices) {
457  if (!first_plot_line) plot << ",\\" << endl;
458  first_plot_line = false;
459  plot << " \"" << tmp+basename << "-ver.gdat\" title \"vertices\" with p lc 0";
460 
461  filename = tmp+basename + "-ver.gdat";
462  filelist = filelist + " " + filename;
463  gdat.open (filename.c_str());
464  if (verbose) clog << "! file \"" << filename << "\" created." << endl;
465  gdat << setprecision(numeric_limits<T>::digits10);
466  for (size_type iv = 0; iv < nv; iv++) {
467  const geo_element& P = omega.get_geo_element(0,iv);
468  put_vertex (gdat, P, omega);
469  }
470  gdat.close();
471  }
472  //
473  // plot domains, by decreasing dimension order
474  // 3d: faces opaques si (!full) ou edges sinon : couleur = code du domaine
475  // 2d: edges
476  // 1d: vertex
477  if (show_domains) {
478  size_type line_color = 3;
479  for (size_type dim = omega.map_dimension(); dim+1 >= 1; dim--) {
480  for (size_type idom = 0; idom < omega.n_domain_indirect(); idom++) {
481  const domain_indirect_basic<sequential>& dom = omega.get_domain_indirect (idom);
482  if (dom.map_dimension() != dim) continue;
483  if (dom.size() == 0) continue;
484  if (dim == 3) continue; // TODO: only d=0,1,2 domains yet
485 
486  filename = tmp+basename + "-dom-" + dom.name() + ".gdat";
487  if (!first_plot_line) plot << ",\\" << endl;
488  first_plot_line = false;
489  plot << " \"" << filename + "\" title \"" << dom.name() << "\"";
490  if (dom.map_dimension() == 0) {
491  plot << " with p";
492  } else if (dom.map_dimension() == 1 && omega.dimension() == 1) {
493  plot << " with lp";
494  } else {
495  plot << " with l";
496  }
497  plot << " lc " << line_color << " lw 2";
498  line_color++;
499 
500  filelist = filelist + " " + filename;
501  gdat.open (filename.c_str());
502  if (verbose) clog << "! file \"" << filename << "\" created." << endl;
503  gdat << setprecision(numeric_limits<T>::digits10);
504  for (size_type ioige = 0; ioige < dom.size(); ioige++) {
505  size_type ige = dom.oige(ioige).index();
506  const geo_element& S = omega.get_geo_element (dim, ige);
507  put (gdat, S, omega, pointset, subdivide);
508  }
509  gdat.close();
510  }
511  }
512  }
513  //
514  // end of plot
515  //
516  plot << endl;
517  if (format == "" && !reader_on_stdin) {
518  plot << "pause -1 \"<return>\"" << endl;
519  }
520  plot.close();
521  //
522  // run gnuplot
523  //
524  int status = 0;
525  string command;
526  if (execute) {
527  command = "gnuplot ";
528  if (reader_on_stdin) command += "-persist ";
529  command += tmp + basename + ".plot";
530  if (verbose) clog << "! " << command << endl;
531  cin.sync();
532  status = system (command.c_str());
533  if (format != "") {
534  check_macro (file_exists (outfile_fmt), "! file \"" << outfile_fmt << "\" creation failed");
535  if (verbose) clog << "! file \"" << outfile_fmt << "\" created" << endl;
536  }
537  }
538  //
539  // clear gnuplot data
540  //
541  if (clean) {
542  command = "/bin/rm -f " + filelist;
543  if (verbose) clog << "! " << command << endl;
544  status = system (command.c_str());
545  }
546  return ops;
547 }
548 // ----------------------------------------------------------------------------
549 // instanciation in library
550 // ----------------------------------------------------------------------------
552 
553 } // rheolef namespace
field::size_type size_type
Definition: branch.cc:425
size_type size(size_type iproc) const
Definition: distributor.h:163
const geo_element_indirect & oige(size_type ioige) const
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:1155
const node_type & xmin() const
Definition: geo.h:1157
size_type map_dimension() const
Definition: geo.h:1149
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const
Definition: geo.h:1182
size_type dimension() const
Definition: geo.h:1148
size_type n_domain_indirect() const
Definition: geo.h:1180
const node_type & xmax() const
Definition: geo.h:1158
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:1164
size_type order() const
Definition: geo.h:1156
const geo_size & sizes() const
Definition: geo.h:1162
generic mesh with rerefence counting
Definition: geo.h:1089
see the geo_element page for the full documentation
Definition: geo_element.h:102
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
std::ostream & os()
Definition: diststream.h:236
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
static const variant_type H
static const variant_type q
static const variant_type T
size_t size_type
Definition: basis_get.cc:76
point_basic< T >
Definition: piola_fem.h:135
Expr1::float_type T
Definition: field_expr.h:261
string command
Definition: mkgeo_ball.sh:136
void dis_inod(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_inod_tab)
This file is part of Rheolef.
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition: tiny_lu.h:155
std::string itos(std::string::size_type i)
itos: see the rheostream page for the full documentation
odiststream & visu_gnuplot(odiststream &, const field_basic< T, sequential > &)
std::string get_tmpdir()
get_tmpdir: see the rheostream page for the full documentation
Definition: rheostream.cc:50
bool file_exists(const std::string &filename)
file_exists: see the rheostream page for the full documentation
Definition: scatch.icc:42
void piola_transformation(const geo_basic< T, M > &omega, const basis_on_pointset< T > &piola_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_inod, Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 > &x)
Definition: piola_util.cc:43
distributor ownership_by_dimension[4]
Definition: geo_size.h:63