Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
geo_seq_visu_gnuplot.cc
Go to the documentation of this file.
1
21//
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
34namespace rheolef {
35
36// ----------------------------------------------------------------------------
37// element puts
38// ----------------------------------------------------------------------------
39template<class T>
40static
41void
42put_vertex (std::ostream& gdat, const geo_element& P, const geo_basic<T,sequential>& omega)
43{
44 using namespace std;
45 typedef typename geo_basic<T,sequential>::size_type size_type;
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)
50template<class T>
51static
52void
53put_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;
57 typedef typename geo_basic<T,sequential>::size_type size_type;
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
71template<class T>
72static
73void
74put_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;
78 typedef typename geo_basic<T,sequential>::size_type size_type;
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
134template<class T>
135static
136void
137put_3d_face (std::ostream& gdat, const geo_element& F, const geo_basic<T,sequential>& omega)
138{
139 using namespace std;
140 typedef typename geo_basic<T,sequential>::size_type size_type;
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}
161template<class T>
162static
163void
164put_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}
173template<class T>
174static
175void
176put_volume (std::ostream& gdat, const geo_element& K, const geo_basic<T,sequential>& omega)
177{
178 using namespace std;
179 typedef typename geo_basic<T,sequential>::size_type size_type;
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}
261template<class T>
262static
263void
264put (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// ----------------------------------------------------------------------------
278template <class T>
279odiststream&
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();
306 size_type ne = omega.sizes().ownership_by_dimension[map_dim].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"+std::to_string(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:430
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
std::ostream & os()
Definition diststream.h:247
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
#define error_macro(message)
Definition dis_macros.h:49
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)")
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 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
std::string get_tmpdir()
get_tmpdir: see the rheostream page for the full documentation
Definition rheostream.cc:54
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition tiny_lu.h:155
bool file_exists(const std::string &filename)
file_exists: see the rheostream page for the full documentation
Definition scatch.icc:34
odiststream & visu_gnuplot(odiststream &, const field_basic< T, sequential > &)
STL namespace.