field_seq_visu_gnuplot.cc
Go to the documentation of this file.
//
// gnuplot geo visualisation
//
// author: Pierre.Saramito@imag.fr
//
// date: 16 sept 2011
//
# include "rheolef/field.h"
# include "rheolef/field_indirect.h"
# include "rheolef/field_evaluate.h"
# include "rheolef/piola_util.h"
# include "rheolef/rheostream.h"
# include "field_seq_visu_gnuplot_internal.h"
# include "rheolef/rounder.h"
# include "rheolef/interpolate.h"
namespace rheolef {
template <class T>
odiststream& visu_gnuplot (odiststream& ops, const geo_basic<T,sequential>& omega);
// ----------------------------------------------------------------------------
// puts for one element
// ----------------------------------------------------------------------------
template<class T>
static
void
put_edge (
std::ostream& gdat,
const geo_basic<T,sequential>& omega,
const geo_element& K,
const field_basic<T,sequential>& uh,
const fem_on_pointset<T>& fops,
size_t my_order,
bound_type<T>& bbox)
{
using namespace std;
typedef typename geo_basic<T,sequential>::size_type size_type;
typedef point_basic<size_type> ilat;
size_type dim = omega.dimension();
const Eigen::Matrix<piola<T>,Eigen::Dynamic,1>& piola = fops.get_piola_on_pointset().get_piola (omega, K);
Eigen::Matrix<T,Eigen::Dynamic,1> value;
field_evaluate (uh, fops, omega, K, value);
for (size_type loc_idof = 0, loc_ndof = piola.size(); loc_idof < loc_ndof; loc_idof++) {
bbox.update (piola[loc_idof].F, value[loc_idof]);
}
for (size_type i = 0; i <= my_order; i++) {
size_type loc_idof = reference_element_e::ilat2loc_inod (my_order, ilat(i));
piola[loc_idof].F.put (gdat, dim); gdat << " " << value[loc_idof] << endl;
}
gdat << endl;
gdat << endl;
}
template<class T>
static
void
put_triangle (
std::ostream& gdat,
const geo_basic<T,sequential>& omega,
const geo_element& K,
const field_basic<T,sequential>& uh,
const fem_on_pointset<T>& fops,
size_t my_order,
bound_type<T>& bbox)
{
using namespace std;
typedef typename geo_basic<T,sequential>::size_type size_type;
typedef point_basic<size_type> ilat;
size_type dim = omega.dimension();
const Eigen::Matrix<piola<T>,Eigen::Dynamic,1>& piola = fops.get_piola_on_pointset().get_piola (omega, K);
Eigen::Matrix<T,Eigen::Dynamic,1> value;
field_evaluate (uh, fops, omega, K, value);
for (size_type loc_idof = 0, loc_ndof = piola.size(); loc_idof < loc_ndof; loc_idof++) {
bbox.update (piola[loc_idof].F, value[loc_idof]);
}
for (size_type j = 0; j <= my_order; j++) {
for (size_type i1 = 0; i1 <= my_order; i1++) {
size_type i = std::min(i1, my_order-j);
size_type iloc = reference_element_t::ilat2loc_inod (my_order, ilat(i, j));
piola[iloc].F.put (gdat, dim); gdat << " " << value[iloc] << endl;
}
gdat << endl;
}
gdat << endl << endl;
}
template<class T>
static
void
put_quadrangle (
std::ostream& gdat,
const geo_basic<T,sequential>& omega,
const geo_element& K,
const field_basic<T,sequential>& uh,
const fem_on_pointset<T>& fops,
size_t my_order,
bound_type<T>& bbox)
{
using namespace std;
typedef typename geo_basic<T,sequential>::size_type size_type;
typedef point_basic<size_type> ilat;
size_type dim = omega.dimension();
const Eigen::Matrix<piola<T>,Eigen::Dynamic,1>& piola = fops.get_piola_on_pointset().get_piola (omega, K);
Eigen::Matrix<T,Eigen::Dynamic,1> value;
field_evaluate (uh, fops, omega, K, value);
for (size_type loc_idof = 0, loc_ndof = piola.size(); loc_idof < loc_ndof; loc_idof++) {
bbox.update (piola[loc_idof].F, value[loc_idof]);
}
for (size_type j = 0; j < my_order+1; j++) {
for (size_type i = 0; i < my_order+1; i++) {
size_type loc_idof00 = reference_element_q::ilat2loc_inod (my_order, ilat(i, j));
piola[loc_idof00].F.put (gdat, dim); gdat << " " << value[loc_idof00] << endl;
}
gdat << endl;
}
gdat << endl << endl;
}
template<class T>
void
put (
std::ostream& gdat,
const geo_basic<T,sequential>& omega,
const geo_element& K,
const field_basic<T,sequential>& uh,
const fem_on_pointset<T>& fops,
size_t my_order,
bound_type<T>& bbox)
{
switch (K.variant()) {
case reference_element::e: put_edge (gdat, omega, K, uh, fops, my_order, bbox); break;
case reference_element::t: put_triangle (gdat, omega, K, uh, fops, my_order, bbox); break;
case reference_element::q: put_quadrangle (gdat, omega, K, uh, fops, my_order, bbox); break;
default: error_macro ("unsupported element variant `"<<K.variant()<<"'");
}
}
// ----------------------------------------------------------------------------
// scalar field puts
// ----------------------------------------------------------------------------
template <class T>
odiststream&
visu_gnuplot_scalar (odiststream& ods, const field_basic<T,sequential>& uh)
{
using namespace std;
typedef typename field_basic<T,sequential>::float_type float_type;
typedef typename geo_basic<float_type,sequential>::size_type size_type;
typedef point_basic<size_type> ilat;
ostream& os = ods.os();
bool verbose = iorheo::getverbose(os);
bool clean = iorheo::getclean(os);
bool execute = iorheo::getexecute(os);
bool fill = iorheo::getfill(os); // show grid or fill elements
bool elevation = iorheo::getelevation(os);
bool color = iorheo::getcolor(os);
bool gray = iorheo::getgray(os);
bool black_and_white = iorheo::getblack_and_white(os);
bool reader_on_stdin = iorheo::getreader_on_stdin(os);
string format = iorheo::getimage_format(os);
string basename = iorheo::getbasename(os);
size_type subdivide = iorheo::getsubdivide(os);
size_type n_isovalue = iorheo::getn_isovalue(os);
size_type n_isovalue_negative = iorheo::getn_isovalue_negative(os);
string outfile_fmt = "";
string tmp = get_tmpdir() + "/";
if (!clean) tmp = "";
const geo_basic<float_type,sequential>& omega = uh.get_geo();
size_type dim = omega.dimension();
size_type map_dim = omega.map_dimension();
size_type nv = omega.sizes().ownership_by_dimension[0].size();
size_type nedg = omega.sizes().ownership_by_dimension[1].size();
size_type nfac = omega.sizes().ownership_by_dimension[2].size();
size_type nvol = omega.sizes().ownership_by_dimension[3].size();
size_type ne = omega.sizes().ownership_by_dimension[map_dim].size();
const basis_basic<float_type>& b = uh.get_space().get_basis();
if (subdivide == 0) { // subdivide is unset: use default
subdivide = std::max(omega.order(), subdivide);
subdivide = std::max(b.degree (), subdivide);
}
basis_basic<T> subdivide_pointset ("P"+itos(subdivide));
piola_on_pointset<T> pops; pops.initialize (omega.get_piola_basis(), subdivide_pointset, integrate_option());
fem_on_pointset<T> fops; fops.initialize (b, pops);
bound_type<T> bbox;
bbox.xmin = omega.xmin();
bbox.xmax = omega.xmax();
bbox.umin = uh.min();
bbox.umax = uh.max();
std::vector<T> values;
if (n_isovalue_negative != 0) {
for (size_t i = 0; i <= n_isovalue_negative; i++) {
values.push_back (bbox.umin*(n_isovalue_negative - i)/n_isovalue_negative);
}
for (size_t i = 1; i <= n_isovalue - n_isovalue_negative; i++) {
values.push_back (bbox.umax*i/(n_isovalue - n_isovalue_negative));
}
}
string filelist;
//
// output .gdat
//
string filename = tmp+basename + ".gdat";
string gdatname = filename;
filelist = filelist + " " + filename;
ofstream gdat (filename.c_str());
if (verbose) clog << "! file \"" << filename << "\" created.\n";
gdat << setprecision(numeric_limits<float_type>::digits10);
size_type used_dim = (fill ? map_dim : 1);
for (size_type ie = 0, ne = omega.size(used_dim); ie < ne; ie++) {
const geo_element& K = omega.get_geo_element(used_dim,ie);
put (gdat, omega, K, uh, fops, subdivide, bbox);
}
gdat.close();
//
// rounding bounds
//
T eps = 1e-7;
bbox.umin = floorer(eps) (bbox.umin);
bbox.umax = ceiler(eps) (bbox.umax);
if (fabs(bbox.umax - bbox.umin) < eps) { // empty range: constant field
bbox.umax = 1.1*bbox.umax;
bbox.umin = 0.9*bbox.umin;
}
//
// output .plot
//
filename = tmp+basename + ".plot";
filelist = filelist + " " + filename;
ofstream plot (filename.c_str());
if (verbose) clog << "! file \"" << filename << "\" created.\n";
plot << "#!gnuplot" << endl
<< setprecision(numeric_limits<float_type>::digits10);
if (format != "") {
outfile_fmt = basename + "." + format;
string terminal = format;
if (terminal == "ps") {
terminal = "postscript eps";
if (color) terminal += " color";
}
if (terminal == "jpg") terminal = "jpeg";
if (terminal == "jpeg" || terminal == "png" || terminal == "gif") {
terminal += " crop";
}
plot << "set terminal " << terminal << endl
<< "set output \"" << outfile_fmt << "\"" << endl;
}
plot << "umin = " << bbox.umin << endl
<< "umax = " << bbox.umax << endl
<< "n_isovalue = " << n_isovalue << endl
<< "uincr = 1.0*(umax-umin)/n_isovalue" << endl;
if (dim == 2) {
if (bbox.xmin[0] >= bbox.xmax[0]) plot << "#";
plot << "set xrange [" << bbox.xmin[0] << ":" << bbox.xmax[0] << "]" << endl;
if (bbox.xmin[1] >= bbox.xmax[1]) plot << "#";
plot << "set yrange [" << bbox.xmin[1] << ":" << bbox.xmax[1] << "]" << endl;
if (bbox.umin >= bbox.umax) plot << "#";
plot << "set zrange [umin:umax]" << endl;
if (bbox.xmin[0] >= bbox.xmax[0] || bbox.xmin[1] >= bbox.xmax[1]) {
plot << "set size square" << endl;
} else {
plot << "set size ratio -1 # equal scales" << endl
<< "set noxtics" << endl
<< "set noytics" << endl;
}
if (elevation) {
plot << "set xyplane at umin-0.1*(umax-umin)" << endl;
} else {
plot << "set view map" << endl;
}
if (map_dim == 2) {
plot << "unset surface" << endl
<< "set contour base" << endl;
if (values.size() != 0) {
plot << "set cntrparam levels discrete ";
for (size_t i = 0, n = values.size(); i < n; i++) {
plot << values[i];
if (i+1 != n) plot << ", ";
}
plot << endl;
} else {
plot << "eps = (umax-umin)*1e-4"<< endl;
plot << "uincr_eps = 1.0*(umax-umin-2*eps)/n_isovalue"<< endl;
plot << "set cntrparam levels incremental umin+eps,uincr_eps,umax-eps"<< endl;
}
}
if (black_and_white) {
plot << "set cbtics out scale 0.5" << endl;
}
plot << "set cbtics uincr" << endl
<< "set cbrange [umin:umax]" << endl;
if (gray) {
plot << "set palette gray" << endl;
} else if (color) {
plot << "set palette rgbformulae 33,13,-4" << endl;
} else { // bw
plot << "set palette rgbformulae 0,0,0" << endl;
}
plot << "set palette maxcolors n_isovalue+1" << endl
<< "set nokey" << endl;
} else if (dim == 3 && map_dim == 2) {
// field defined on a 3D surface
point_basic<T> dx = 0.1*(omega.xmax() - omega.xmin());
T dx_max = max(dx[0],max(dx[1],dx[2]));
if (dx_max == 0) dx_max = 0.1;
dx[0] = max(dx[0],dx_max);
if (omega.dimension() >= 2) dx[1] = max(dx[1],dx_max);
if (omega.dimension() == 3) dx[2] = max(dx[2],dx_max);
point_basic<T> xmin = omega.xmin() - dx;
point_basic<T> xmax = omega.xmax() + dx;
// TODO: visu contours discrets comme en 2d classique
plot << "set xrange [" << xmin[0] << ":" << xmax[0] << "]" << endl
<< "set yrange [" << xmin[1] << ":" << xmax[1] << "]" << endl
<< "set zrange [" << xmin[2] << ":" << xmax[2] << "]" << endl
<< "set xyplane at " << xmin[2] << endl
<< "set view equal xyz # equal scales" << endl
<< "set view 70,120" << endl
<< "n_isovalue = " << n_isovalue << endl
<< "n_subdivide = 40 " << endl
<< "uincr = 1.0*(umax-umin)/n_isovalue" << endl
<< "set cbtics uincr" << endl
<< "set pm3d interpolate n_subdivide,n_subdivide corners2color mean" << endl
<< "set palette rgbformulae 33,13,-4 maxcolors n_isovalue" << endl;
if (format != "") {
plot << "set noxlabel" << endl
<< "set noylabel" << endl
<< "set nozlabel" << endl;
} else {
plot << "set xlabel \"x\"" << endl
<< "set ylabel \"y\"" << endl
<< "set zlabel \"z\"" << endl;
}
}
if (dim == 1) {
if (color) {
plot << "set colors classic" << endl;
}
plot << "plot \"" << gdatname << "\" notitle with lines lw 2";
if (gray || black_and_white) {
plot << " lc 0" << endl;
}
plot << endl;
} else {
if (!fill && dim == 2) {
plot << "plot";
} else {
plot << "splot";
}
plot << " \"" << gdatname << "\" notitle";
if (map_dim == 2) {
if (black_and_white) {
plot << " with lines palette lw 2" << endl;
} else {
plot << " with lines palette" << endl;
}
} else { // a 2d line
plot << " with lines palette lw 2" << endl;
}
}
//
// end of plot
//
if (format == "" && !reader_on_stdin) {
plot << "pause -1 \"<return>\"\n";
}
plot.close();
//
// run gnuplot
//
int status = 0;
string command;
if (execute) {
command = "gnuplot ";
if (reader_on_stdin) command += "-persist ";
command += tmp + basename + ".plot";
if (verbose) clog << "! " << command << endl;
cin.sync();
status = system (command.c_str());
if (format != "") {
check_macro (file_exists (outfile_fmt), "! file \"" << outfile_fmt << "\" creation failed");
if (verbose) clog << "! file \"" << outfile_fmt << "\" created" << endl;
}
}
//
// clear gnuplot data
//
if (clean) {
command = "/bin/rm -f " + filelist;
if (verbose) clog << "! " << command << endl;
status = system (command.c_str());
}
return ods;
}
// ----------------------------------------------------------------------------
// vector field puts
// ----------------------------------------------------------------------------
template <class T>
odiststream&
visu_gnuplot_vector (odiststream& ods, const field_basic<T,sequential>& uh)
{
typedef typename geo_basic<T,sequential>::size_type size_type;
Float vscale = iorheo::getvectorscale(ods.os());
const geo_basic<T,sequential>& omega = uh.get_geo();
// TODO: non-isoparam => interpolate
check_macro (omega.get_piola_basis().degree() == uh.get_space().get_basis().degree(),
"gnuplot vector: unsupported non-isoparametric approx " << uh.get_space().get_basis().name());
size_type n_elt = omega.size();
size_type d = omega.dimension();
T diam_omega = norm (omega.xmax() - omega.xmin()); // characteristic length in omega
T h_moy = diam_omega/pow(n_elt,1./d);
space_basic<T,sequential> Xh (uh.get_geo(), "P"+itos(uh.get_space().degree()));
field_basic<T,sequential> norm_uh = interpolate(Xh, norm(uh));
T norm_max_uh = norm_uh.max_abs(); // get max vector length
if (norm_max_uh + 1 == 1) norm_max_uh = 1;
#ifdef TODO
T scale = vscale*(h_moy/norm_max_uh);
#endif // TODO
size_type n_comp = uh.get_space().get_basis().size();
disarray<point_basic<T>, sequential> x = omega.get_nodes();
for (size_type inod = 0, nnod = x.size(); inod < nnod; inod++) {
point_basic<T> vi;
for (size_type i_comp = 0; i_comp < n_comp; i_comp++) {
size_type idof = n_comp*inod + i_comp;
vi[i_comp] = uh.dof(idof);
}
x[inod] += vscale*vi;
}
geo_basic<T,sequential> deformed_omega = omega;
deformed_omega.set_nodes(x);
space_basic<T,sequential> deformed_Vh (deformed_omega, norm_uh.get_space().get_basis().name());
field_basic<T,sequential> deformed_norm_uh (deformed_Vh);
std::copy (norm_uh.begin_dof(), norm_uh.end_dof(), deformed_norm_uh.begin_dof());
visu_gnuplot (ods, deformed_norm_uh);
return ods;
}
// ----------------------------------------------------------------------------
// switch
// ----------------------------------------------------------------------------
template <class T>
odiststream&
visu_gnuplot (odiststream& ods, const field_basic<T,sequential>& uh)
{
switch (uh.get_space().valued_tag()) {
case space_constant::scalar: visu_gnuplot_scalar (ods, uh); break;
case space_constant::vector: visu_gnuplot_vector (ods, uh); break;
default: error_macro ("do not known how to print " << uh.valued() << "-valued field");
}
return ods;
}
// ----------------------------------------------------------------------------
// instanciation in library
// ----------------------------------------------------------------------------
#define _RHEOLEF_instanciate(T) \
template odiststream& visu_gnuplot<T> (odiststream&, const field_basic<T,sequential>&);
_RHEOLEF_instanciate(Float)
#undef _RHEOLEF_instanciate
} // rheolef namespace
rheolef::reference_element::e
static const variant_type e
Definition: reference_element.h:76
rheolef::reference_element_t::ilat2loc_inod
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
Definition: reference_element.cc:413
rheolef::geo_basic
generic mesh with rerefence counting
Definition: domain_indirect.h:64
rheolef::field_basic::get_space
const space_type & get_space() const
Definition: field.h:300
rheolef::piola_on_pointset::initialize
void initialize(const basis_basic< T > &piola_basis, const quadrature< T > &quad, const integrate_option &iopt)
Definition: piola_on_pointset.h:190
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::reference_element_e::ilat2loc_inod
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
Definition: reference_element.cc:350
rheolef::put
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition: tiny_lu.h:155
rheolef::file_exists
bool file_exists(const std::string &filename)
file_exists: see the rheostream page for the full documentation
Definition: scatch.icc:42
rheolef::bound_type
Definition: field_seq_visu_gnuplot_internal.h:42
rheolef::get_tmpdir
std::string get_tmpdir()
get_tmpdir: see the rheostream page for the full documentation
Definition: rheostream.cc:50
rheolef::sequential
Definition: distributed.h:28
rheolef::value
rheolef::std value
rheolef::field_basic::float_type
typename float_traits< T >::type float_type
Definition: field.h:245
rheolef::bound_type::umin
T umin
Definition: field_seq_visu_gnuplot_internal.h:45
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::pow
space_mult_list< T, M > pow(const space_basic< T, M > &X, size_t n)
Definition: space_mult.h:120
rheolef::float_type
typename float_traits< value_type >::type float_type
Definition: field_expr_recursive.h:501
rheolef::odiststream::os
std::ostream & os()
Definition: diststream.h:236
rheolef::size_type
size_t size_type
Definition: basis_get.cc:76
rheolef::visu_gnuplot_vector
odiststream & visu_gnuplot_vector(odiststream &ods, const field_basic< T, sequential > &uh)
Definition: field_seq_visu_gnuplot.cc:419
rheolef::geo_element::variant
variant_type variant() const
Definition: geo_element.h:161
rheolef::norm
T norm(const vec< T, M > &x)
norm(x): see the expression page for the full documentation
Definition: vec.h:387
rheolef::geo_basic< T, sequential >::set_nodes
void set_nodes(const disarray< node_type, sequential > &x)
rheolef::basis_basic
Definition: basis.h:206
rheolef::field_basic::get_geo
const geo_type & get_geo() const
Definition: field.h:301
rheolef::geo_basic< T, sequential >::xmax
const node_type & xmax() const
Definition: geo.h:1158
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition: integrate_option.h:125
rheolef::space_constant::scalar
@ scalar
Definition: space_constant.h:136
rheolef::geo_basic< T, sequential >
Definition: geo.h:1108
rheolef::bound_type::umax
T umax
Definition: field_seq_visu_gnuplot_internal.h:45
rheolef::geo_basic< T, sequential >::dimension
size_type dimension() const
Definition: geo.h:1148
rheolef::field_basic::min
T min() const
Definition: field.h:683
rheolef::reference_element_q::ilat2loc_inod
static size_type ilat2loc_inod(size_type order, const point_basic< size_type > &ilat)
Definition: reference_element.cc:481
rheolef::interpolate
field_basic< T, M > interpolate(const space_basic< T, M > &V2h, const field_basic< T, M > &u1h)
see the interpolate page for the full documentation
Definition: interpolate.cc:233
mkgeo_ball.clean
clean
Definition: mkgeo_ball.sh:335
rheolef::fem_on_pointset::initialize
void initialize(const basis_basic< T > &fem_basis, const piola_on_pointset< T > &pops)
Definition: fem_on_pointset.h:130
rheolef::field_basic::max
T max() const
Definition: field.h:699
rheolef::field_basic
Definition: field_expr_utilities.h:38
rheolef::field_basic::dof
T & dof(size_type idof)
Definition: field.h:658
rheolef::field_basic::end_dof
iterator end_dof()
Definition: field.h:509
rheolef::field_basic::begin_dof
iterator begin_dof()
Definition: field.h:501
rheolef::geo_basic< T, sequential >::get_nodes
const disarray< node_type, sequential > & get_nodes() const
Definition: geo.h:1177
rheolef::piola_on_pointset
Definition: piola_on_pointset.h:142
mkgeo_couette.basename
basename
Definition: mkgeo_couette.sh:73
gray
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin gray
Definition: iorheo-members.h:62
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
error_macro
#define error_macro(message)
Definition: dis_macros.h:49
rheolef::fem_on_pointset
Definition: fem_on_pointset.h:117
rheolef::floorer
floorer_type< T > floorer(const T &prec)
Definition: rounder.h:61
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
Float
see the Float page for the full documentation
rheolef::ceiler
ceiler_type< T > ceiler(const T &prec)
Definition: rounder.h:62
rheolef::visu_gnuplot
odiststream & visu_gnuplot(odiststream &, const field_basic< T, sequential > &)
Definition: field_seq_visu_gnuplot.cc:461
rheolef::geo_basic< T, sequential >::size
size_type size(size_type dim) const
Definition: geo.h:1209
field_seq_visu_gnuplot_internal.h
rheolef::disarray
see the disarray page for the full documentation
Definition: disarray.h:459
mkgeo_ball.d
d
Definition: mkgeo_ball.sh:154
mkgeo_ball.b
b
Definition: mkgeo_ball.sh:152
mkgeo_ball.verbose
verbose
Definition: mkgeo_ball.sh:133
rheolef::field_basic::valued
const std::string & valued() const
Definition: field.h:305
rheolef::reference_element::q
static const variant_type q
Definition: reference_element.h:78
rheolef::space_numbering::nnod
size_type nnod(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
Definition: space_numbering.cc:54
rheolef::field_evaluate
void 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, Eigen::Matrix< T, Eigen::Dynamic, 1 > &value)
Definition: field_evaluate.cc:39
rheolef::space_constant::vector
@ vector
Definition: space_constant.h:137
mkgeo_ball.n
n
Definition: mkgeo_ball.sh:150
rheolef::bound_type::xmin
point_basic< T > xmin
Definition: field_seq_visu_gnuplot_internal.h:44
rheolef::reference_element::t
static const variant_type t
Definition: reference_element.h:77
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::_RHEOLEF_instanciate
_RHEOLEF_instanciate(Float, sequential) _RHEOLEF_instanciate(Float
rheolef::geo_basic< T, sequential >::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:1155
mkgeo_ball.map_dim
map_dim
Definition: mkgeo_ball.sh:337
rheolef::bound_type::xmax
point_basic< T > xmax
Definition: field_seq_visu_gnuplot_internal.h:44
rheolef::itos
std::string itos(std::string::size_type i)
itos: see the rheostream page for the full documentation
mkgeo_ball.tmp
tmp
Definition: mkgeo_ball.sh:380
rheolef::space_basic< T, sequential >
Definition: space.h:361
mkgeo_ball.dim
dim
Definition: mkgeo_ball.sh:307
rheolef::geo_basic< T, sequential >::size_type
rep::size_type size_type
Definition: geo.h:1117
rheolef::field_basic::max_abs
T max_abs() const
Definition: field.h:731
rheolef::geo_basic< T, sequential >::xmin
const node_type & xmin() const
Definition: geo.h:1157
rheolef::std
Definition: vec_expr_v2.h:391
mkgeo_contraction.status
status
Definition: mkgeo_contraction.sh:290
mkgeo_ball.command
command
Definition: mkgeo_ball.sh:136
rheolef::visu_gnuplot_scalar
odiststream & visu_gnuplot_scalar(odiststream &ods, const field_basic< T, sequential > &uh)
Definition: field_seq_visu_gnuplot.cc:160
T
Expr1::float_type T
Definition: field_expr.h:218