# Output files produced by Montjoie

In order to visualize outputs produced by Montjoie, it is possible to use Matlab, Python, Medit or Paraview. Below, we have listed for each type of output, which software can be used :

SismoGrille | Python, Matlab, Paraview |

SismoGrille3D | Python, Matlab, Paraview |

SismoPlane | Python, Matlab, Paraview |

SismoLine | Python, Matlab, Paraview |

SismoCircle | Python, Matlab, Paraview |

SismoCircleAxi | Python, Matlab, Paraview |

SismoPointsFile | Python, Matlab, Paraview |

SismoPoint | Python, Matlab |

SismoMeshSurfacic | Medit, Paraview |

SismoMeshVolumic | Medit, Paraview |

FileRcs | Python, Matlab |

## Matlab/Python

Matlab/Python scripts are placed in directory Matlab (Python functions are actually regrouped in the single file visuND.py) :

- affiche_mode.m : displays several eigenmodes
- contour2D.m : Basic detection of the boundary of the domain from a 2-D solution
- entier_to_string.m : converts an integer into a string of four characters
- erreurL2.m : computes the L2 error between two vectors/matrices
- erreurMediane.m : computes the "median" L2 error between two vectors/matrices
- film2D.m : writes 2-D snapshots produced by Montjoie into jpeg files
- film3D.m : writes 3-D snapshots produced by Montjoie into jpeg files
- find_contour.m : Basic detection of the boundary of the domain from a 3-D solution
- load1D_real.m, load1D.m, load1D_int.m : reads Seldon vectors
- loadComplexMat.m : loads a complex sparse matrix
- loadND.m, loadE.m, loadEH.m, loadH1.m : loads outputs files produced by Montjoie
- load_full.m, load_fullSym.m, load_fullReal.m, load_fullSym_real.m : loads Seldon dense matrices
- log_triangle.m, plot_triangle.m : inserts a small triangle in a graph to check the order of convergence of a curve
- plot2dinst.m : displays a 2-D solution
- plot3d_plane.m, plot3dinst.m : displays a 3-D solution
- str2num_python.m : reproduces Python behaviour when converting a float into a string
- write_full_s.m, write_full_d.m : writes a dense matrix in Seldon binary format

For example, if you want to plot a solution with Matlab, you will type :

cd MATLAB [X, Y, Z, coor, V] = loadND('../totalCarre_U0.dat'); plot2dinst(X, Y, real(V));

By using **ipython -pylab**, the commands are similar :

ipython -pylab from visuND import * [X, Y, Z, coor, V] = loadND('../totalCarre_U0.dat'); plot2dinst(X, Y, real(V));

For outputs produced by specifying SismoGrille, SismoGrille3D,
SismoPlane, SismoLine, SismoCircle, SismoCircleAxi, SismoPointsFile,
the function **loadND** has to be considered, whereas in the case
of SismoPoint (for time-domain simulations) or FileRcs, the file can
be read directly with the command **load** (**loadtxt** in
Python).

## Paraview

If you wish to visualize results with Paraview, don't forget to insert in the data file one of these lines

OutputFormat = VTK FLOAT OutputFormat = ASCII_VTK FLOAT OutputFormat = VTK DOUBLE OutputFormat = ASCII_VTK DOUBLE

Montjoie should produce Vtk files (extension .vtk), that you can read in paraview (by clicking on File, Open). For 1-D outputs (on lines, circles), you can apply the filter "Plot Data" to see the 1-D curve. If you specify VTK after OutputFormat, the datas will be written in binary, and will take less memory. By specifying float, the datas are written in single precision (less memory is used).

# Classes for outputs in Montjoie

### Public methods of GridInterpolation

GetElementNumber | returns the element where the point i is |

GetLocalCoordinate | returns the local coordinates of point i in the reference element |

GetGlobalCoordinate | returns the global coordinates of point i |

GetTheta | returns the parameter theta for the i-th point (for axisymmetric outputs) |

GetDFjm1 | returns the inverse of the jacobian matrix for the i-th point |

GetSectionNumber | returns the section number (for cyclic or periodic domains) |

GetXmin | returns the minimum of x-coordinates of the interpolation grid |

GetXmax | returns the maximum of x-coordinates of the interpolation grid |

GetYmin | returns the minimum of y-coordinates of the interpolation grid |

GetYmax | returns the maximum of y-coordinates of the interpolation grid |

GetZmin | returns the minimum of z-coordinates of the interpolation grid |

GetZmax | returns the maximum of z-coordinates of the interpolation grid |

SetNbSubdivisions | sets the number of points used for the intermediate regular grid |

SetSubdivisionStep | sets the spacings for the intermediate regular grid |

SetNbCyclicSections | sets the number of sections for a cyclic domain |

SetNbCartesianSections | sets the number of sections for a periodic domain |

Append | adds points that will be localized |

InitInterpolationGrid | initialisation of the intermediate regular grid for localization of points of a mesh |

PreLocalizePoints | first localization of points on the intermediate regular grid |

LocalizePoints | localization of points on the mesh |

### Public methods of GridInterpolationFull

GetOutputType | returns the type of interpolation grid |

SetOutputType | sets the type of interpolation grid |

GetNbPointsX | returns the number of points along x |

GetNbPointsY | returns the number of points along y |

GetNbPointsZ | returns the number of points along z |

SetNbPointsX | sets the number of points along x |

SetNbPointsY | sets the number of points along y |

SetNbPointsZ | sets the number of points along z |

GetCenter | returns the intersection of the three planes |

GetXmin | returns the minimum of x-coordinates of the interpolation grid |

GetXmax | returns the maximum of x-coordinates of the interpolation grid |

GetYmin | returns the minimum of y-coordinates of the interpolation grid |

GetYmax | returns the maximum of y-coordinates of the interpolation grid |

GetZmin | returns the minimum of z-coordinates of the interpolation grid |

GetZmax | returns the maximum of z-coordinates of the interpolation grid |

SetXmin | sets the minimum of x-coordinates of the interpolation grid |

SetXmax | sets the maximum of x-coordinates of the interpolation grid |

SetYmin | sets the minimum of y-coordinates of the interpolation grid |

SetYmax | sets the maximum of y-coordinates of the interpolation grid |

SetZmin | sets the minimum of z-coordinates of the interpolation grid |

SetZmax | sets the maximum of z-coordinates of the interpolation grid |

GetType | returns the type of interpolation grid from a string |

GetDimension | returns the dimension of the output interpolation grid |

GenerateGridPoints | generates the points of the interpolation grid |

InitGrid | appends points to an object GridInterpolation in order to localize those points |

Write | writes header of the interpolation grid in binary format |

WriteText | writes header of the interpolation grid in text format |

WriteVtk | writes header of the interpolation grid in vtk format |

Read | reads header of the interpolation grid in binary format |

ReadText | reads header of the interpolation grid in text format |

ReadVtk | reads header of the interpolation grid in vtk format |

### Specific methods of GridInterpolationFull<Dimension2>

SetPlaneOutput | regular points in 2-D |

SetPlaneAxiOutput | regular points in a 3-D plane |

SetLineOutput | regular points on a 2-D line |

SetLineAxiOutput | regular points on a 3-D line |

SetPointOutput | a single 2-D point |

SetPointAxiOutput | a single 3-D point |

SetCircleOutput | regular points on a 2-D circle |

SetCircleAxiOutput | regular points on a 3-D circle |

SetPointsFileOutput | 2-D points contained in a file |

SetPointsFileAxiOutput | 3-D points contained in a file |

SetThreePlanesAxiOutput | regular points on three cartesian planes in 3-D |

SetVolumeAxiOutput | regular points in 3-D |

### Specific methods of GridInterpolationFull<Dimension3>

SetPlaneOutput | regular points in a 3-D plane |

SetLineOutput | regular points on a 3-D line |

SetPointOutput | a single 3-D point |

SetCircleOutput | regular points on a 3-D circle |

SetPointsFileOutput | 3-D points contained in a file |

SetThreePlanesOutput | regular points on three cartesian planes in 3-D |

SetVolumeOutput | regular points in 3-D |

### Methods of MeshInterpolation

GetNbSubdivisions | returns the number of sub-intervals |

SetRegularSubdivisions | each edge of the mesh will be split into r regular subintervals |

SetLobattoSubdivisions | each edge of the mesh will be split into r subintervals, intermediate points are Gauss-Lobatto points |

GetSubdivisionStep | returns the intermediate points used for each edge |

SetRegularPoints | each edge of the mesh will be split into r regular subintervals |

SetGaussQuadrature | preparation of the computation of values of the solution on Gauss quadrature points |

PointsReferenceVolume | intermediate points on the unit tetrahedron/pyramid/prism and cube |

PointsReferenceSurface | intermediate points on the unit triangle/square |

GetFileName | returns the name of the file where the subdivided mesh will be stored |

SetFileName | sets the name of the file where the subdivided mesh will be stored |

SetType | sets the type of required output |

GetType | returns the type of required output |

SetSurfaceReference | sets the references of the surface for which solution will be interpolated |

GetSurfaceReference | returns the references of the surface for which solution will be interpolated |

NumberingArray | numbers for each element |

InitProjectionVolume | computes interpolation projector for volumetric interpolation |

InitProjectionSurface | computes interpolation projector for surfacic interpolation |

ProjectVolume | computes interpolation of the solution in an element |

ProjectSurface | computes interpolation of the solution on a surface of an element |

IsVolumetric | returns true if the object performs volumetric interpolations |

IsSurfacic | returns true if the object performs surfacic interpolations |

ComputeSurfaceMesh | extracts surface mesh and computes interpolation points |

StoreGeometricDataSurface | computes and stores interpolation points, normales, jacobian matrices, etc |

GetElementNumberOfSurface | returns element number of the element adjacent to the face |

GetLocalPositionOfSurface | returns local number of the face in the element |

GetNbBoundary | returns the number of faces on which interpolation will be computed |

GetNbPointsQuadrature | returns the number of quadrature points on all the surface mesh |

PointsQuadrature | returns the quadrature points of face i |

Dfjm1Quadrature | returns the jacobian matrices of face i |

NormaleQuadrature | returns the normales of face i |

WeightsQuadrature | returns the quadrature weights of face i |

DsQuadrature | returns the surface elements of integration of face i |

GetNbAllQuadraturePoints | returns the total number of quadrature points (on all the processors) |

GetQuadraturePoint | returns the global quadrature point (among all the processors) |

GetQuadratureNormale | returns the global normale (among all the processors) |

GetQuadratureWeight | returns the global quadrature weight (among all the processors) |

ComputeEnHnOnBoundary | computes u and du/dn (E x n and H x n for Maxwell's equastions) on quadratures points of the faces |

### Public attributes of VarOutputProblem

output_grid_param | output parameters for interpolation on predefined grids |

output_mesh_param | output parameters for interpolation on subdivided meshes |

all_points_display | object for the localization of points of interpolation grids in the current mesh |

var_grid | object for interpolation on points of predefined grids |

var_mesh_interp | object for interpolation on subdivided mesh |

grid_to_be_computed | if true the points of interpolation grid need to be localized on the mesh |

### Public methods of VarOutputProblem

InitVarGrid | initialisation of interpolation grids and outputs on subdivided meshes |

ComputeVarGrid | localization of points of predefined grids on the mesh |

SetNbCyclicModes | initialisation of the number of sections for output grids |

InitOutput | initialisation of outputs (before time iterations) |

WriteSnapshot | writes snapshots at a given time |

ChangeTimeSnapshot | changes the times associated for each output |

InitVarMeshVolumetric | computation of the subdivided mesh |

InitVarMeshSurfacic | computation of the subdivided mesh on a surface of the mesh |

GetIndexOutputFiles | returns the index in array output_grid_param for a type of predefined grid |

WriteDatas | writes outputs on predefined grids and subdivided meshes |

GetEnHn | forms u and du/dn (or E x n and H x n) from u and gradient of u |

GetEnHnQuadrature | forms u and du/dn (or E x n and H x n) from u and gradient of u |

InitFftComputation | initialisation of fft computations |

GetModalOutput | computes true value of the solution from its modal decomposition |

ModifyOutputUnknown | modification of the output vector u before writing it on the file |

ModifyOutputGradient | modification of the gradient vector du before writing it on the file |

ComputeInterpolationU | interpolation of u on points of predefined grids |

ComputeInterpolationGradU | interpolation of gradient of u on points of predefined grids |

ComputeNodalUgradU | interpolation of u and gradient of u on nodal points of the mesh |

ProjectQuadratureToDof | computation of u on degrees of freedom from values on quadrature points |

WriteOutputFile | writes the solution u on output files |

### Public methods of ParamOutputClass

GetComponent | returns component of the solution to write |

GetNature | returns the type of interpolation grid associated with the output |

SetNature | sets the type of interpolation grid associated with the output |

SetComponent | sets component of the solution to write |

IncrementSnapshot | skips to next snapshot to write |

GetSnapshotNumber | returns the current snapshot number |

GetTotalFieldFile | returns the name of the file where the total field will be written |

GetDiffractedFieldFile | returns the name of the file where the diffracted field will be written |

SetTotalFieldFile | sets the name of the file where the total field will be written |

SetDiffractedFieldFile | sets the name of the file where the diffracted field will be written |

GetTotalFieldFile | returns the name of the file where the total field will be written |

GetFileName | returns the name of the i-th file |

SetFileName | sets the name of the i-th file |

GetNbFile | returns the name of extra-files handled by this object |

InitTime | initialisation of the snapshot number |

SnapshotToStore | returns true if a snapshot has to be written for this time |

ChangeTime | changes the current time |

InitResult | initialisation of output vectors |

UpdateResult | updating output vectors |

WriteSnapshot | writes snapshots on the disk |

WriteNewSnapshot | writes snapshots on the disk |

### affiche_mode

#### Syntax :

affiche_mode(root, extension, n1, n2)

This function displays all the eigenmodes whose number is comprised between n1 and n2. The extension .dat is automatically added, so extension may be empty.

affiche_mode('../totalSquareMode', '_U0', 0, 10); affiche_mode('../totalSquareMode', '', 0, 10);

### loadND, loadE, loadEH, loadH1

#### Syntax :

[X, Y, Z, coor, V] = loadND(fichier) [X, Y, Z, coor, V] = loadND(fichier, num_inst, raff) [X, Y, Z, coor, Ex, Ey, Ez] = loadE(base) [X, Y, Z, coor, Ex, Ey, Ez, Hx, Hy, Hz] = loadEH(base) [X, Y, Z, coor, U, dUx, dUy, dUz] = loadH1(base)

This function loads an output file of Montjoie. It only works if binary format (double or single precision) has been specified in Montjoie (this is actually the default format). num_inst is the snapshot number (equal to one if not specified), it is useful if you have specified outputs on differents planes for example (with two SismoPlane in the data file). raff is the level refinement (equal to one), it can be useful, if you wish to obtain a prettier solution (for example put 4 if you want to obtain a 400x400 solution from an output file containing 100x100 solution).

// loading a single field [X, Y, Z, coor, V] = loadND('../totalCube_dU0.dat'); // if you want both u and its gradient (for a scalar field) [X, Y, Z, coor, U, dUx, dUy, dUz] = loadE('../totalCube'); // if you are solving a vector field equation // you can load simultaneously U0, U1 and U2 [X, Y, Z, coor, Ex, Ey, Ez] = loadE('../totalCube'); // for Maxwell's equation, it may be convenient // to read both electric field E and magnetic field H [X, Y, Z, coor, Ex, Ey, Ez, Hx, Hy, Hz] = loadEH('../totalCube'); // you can select another snapshot [X, Y, Z, coor, V] = loadND('../totalCube_dU0.dat', 2); // or refine the solution on more points [X, Y, Z, coor, V] = loadND('../totalCube_dU0.dat', 1, 2);

### contour2D

#### Syntax :

[non_loc, num_interface] = contour2D(X, Y, V);

This function returns the indexes for which the solution is null (it corresponds to points outside the domain), and the indexes at the boundary of the domain.

[X, Y, Z, coor, V] = loadND('../totalCarre_U0.dat'); [non_loc, num_inter ] = contour2D(X, Y, V); // then you put nan on boundary, if you want to see the contour in white V(num_inter) = nan; plot2dinst(X, Y, real(V), -0.1, 0.1);

### find_contour

#### Syntax :

[non_loc, num_interface] = find_contour(X, Y, Z, V);

This function returns the indexes for which the solution is null (it corresponds to points outside the domain), and the indexes placed on the boundary of the domain.

[X, Y, Z, coor, V] = loadND('../totalCube_U0.dat'); [non_loc, num_inter ] = find_contour(X, Y, V); // then you put nan on boundary, if you want to see the contour in white V(num_inter) = nan; plot3d_planec(X, Y, Z, real(V), coor, -0.1, 0.1);

### entier_to_string

#### Syntax :

s = entier_to_string(i)

This function converts an integer into a string such that it contains always four characters. If the integer is equal to 23, the corresponding string will be '0023'

s = entier_to_string(n); [X, Y, Z, coor, V] = loadND(['../totalCarre', s, '_U0.dat']);

### erreurL2

#### Syntax :

err = erreurL2(V, Vref);

This function returns the relative L^{2} error between two
solutions. The two solutions are compared only on the points where
they are both non-null (to avoid problems with the computation of
interpolation grid).

[X, Y, Z, coor, V] = loadND('../totalCarreH02_U0.dat'); [X, Y, Z, coor, Vref] = loadND('../totalCarreH01_U0.dat'); err = erreurL2(V, Vref); // you can compare as many components as you want [X, Y, Z, coor, Ex, Ey, Ez] = loadE('../totalCarreH02'); [X, Y, Z, coor, ExRef, EyRef, EzRef] = loadE('../totalCarreH01'); err = erreurL2(Ex, ExRef, Ey, EyRef, Ez, EzRef);

### erreurMediane

#### Syntax :

err = erreurMediane(V, Vref);

This function returns the relative "median" L^{2} error between two
solutions. The two solutions are compared only on the points where
they are both non-null (to avoid problems with the computation of
interpolation grid). To avoid extrema values which are often due to
problems of localization of the points in the mesh, this function
actually computes the L^{2} by selecting the value for
which 90% of points produce an error inferior to the error obtained
with this value.

[X, Y, Z, coor, V] = loadND('../totalCarreH02_U0.dat'); [X, Y, Z, coor, Vref] = loadND('../totalCarreH01_U0.dat'); erreurMediane(V, Vref); // you can compare as many components as you want [X, Y, Z, coor, Ex, Ey, Ez] = loadE('../totalCarreH02'); [X, Y, Z, coor, ExRef, EyRef, EzRef] = loadE('../totalCarreH01'); erreurMediane(Ex, ExRef, Ey, EyRef, Ez, EzRef);

### film2D

#### Syntax :

film2D(base, ext, debut, fin, cmin, cmax, draw_contour, num_inst, raff); film2D(base, ext, debut, fin, cmin, cmax);

This function produces a picture .jpeg for each snapshot whose number is comprised between 'debut' and 'fin'. (cmin, cmax) defines the color scale. The optional argument draw_contour is equal to by default. If you put 1, the function contour2D will be used to display the boundary of the computational domain. The optional argument num_inst is equal to 1 by default. If you put another integer, it will read the corresponding snapshot contained in the file (it occurs if you have asked several SismoPlane).

// basic command // it will read files '../TimeCarre0000_U1.dat', '../TimeCarre0001_U1.dat', etc // and produces .jpeg for each snapshot // jpeg files have the same root as output files, with .jpeg extension film2D('../TimeCarre', '_U1', 0, 500, -0.001, 0.001); // if you want to see the boundary film2D('../TimeCarre', '_U1', 0, 500, -0.001, 0.001, 1);

### film3D

#### Syntax :

film3D(base, ext, debut, fin, cmin, cmax, draw_contour, num_inst, raff); film3D(base, ext, debut, fin, cmin, cmax);

This function produces a picture .jpeg for each snapshot whose number is comprised between 'debut' and 'fin'. (cmin, cmax) defines the color scale. The optional argument draw_contour is equal to by default. If you put 1, the function find_contour will be used to display the boundary of the computational domain. The optional argument num_inst is equal to 1 by default. If you put another integer, it will read the corresponding snapshot contained in the file (it occurs if you have asked several SismoPlane).

// basic command // it will read files '../TimeCube0000_U1.dat', '../TimeCube0001_U1.dat', etc // and produces .jpeg for each snapshot // jpeg files have the same root as output files, with .jpeg extension film3D('../TimeCube', '_U1', 0, 500, -0.001, 0.001); // if you want to see the boundary film3D('../TimeCube', '_U1', 0, 500, -0.001, 0.001, 1);

### load1D, load1D_real, load1D_int

#### Syntax :

V = load1D(file_name) V = load1D_real(file_name) V = load1D_int(file_name)

These functions load a vector which has been previously written in a C++ code. For example, if you have written in C++, the following code :

Vector<double> V(10); V.FillRand(); V.Write("sol_real.dat"); Vector<complex<double> > W(10); W.FillRand(); W.Write("sol_complex.dat"); Vector<int> N(10); N.FillRand(); N.Write("num.dat");

The following Python/Matlab code can be used :

V = load1D_real('sol_real.dat'); W = load1D('sol_complex.dat'); N = load1D_int('num.dat');

### loadComplexMat

#### Syntax :

A = loadComplexMat(file_name)

This function loads a sparse complex matrix from a file. For example, if you have written in C++, the following code :

Matrix<complex<double>, General, ArrayRowSparse> A(10, 10); A.FillRand(); A.Write("mat.dat");

The created file mat.dat will look like :

1 3 (0.5432143,-2.34433) 2 4 (2.90843,0.0) 3 2 (-1.232409,-0.090982)

The following Matlab code can be used to read the matrix :

A = loadComplexMat('mat.dat');

### load_full, load_fullSym, load_fullReal, load_fullSym_real

#### Syntax :

A = load_full(file_name) A = load_fullSym(file_name) A = load_fullReal(file_name) A = load_fullSym_real(file_name)

These functions load a dense matrix which has been previously written in a C++ code. For example, if you have written in C++, the following code :

Matrix<double> A(10, 10); A.FillRand(); A.Write("Areal.dat"); Matrix<complex<double> > B(10, 10); B.FillRand(); B.Write("Bcomplex.dat"); Matrix<double, Symmetric, RowSymPacked> C(10, 10); C.FillRand(); C.Write("Csym.dat"); Matrix<complex<double>, Symmetric, RowSymPacked> D(10, 10); D.FillRand(); D.Write("Dsym_complex.dat");

The following Python/Matlab code can be used to read those matrices :

A = load_fullReal('Areal.dat'); B = load_full('Bcomplex.dat'); C = load_fullSym_real('Csym.dat'); D = load_fullSym('Dsym_complex.dat');

### plot_triangle, log_triangle

#### Syntax :

plot_triangle(position, order, taille, couleur) log_triangle(position, order, taille, couleur)

These functions adds to the current figure a small triangle to check the order of convergence of a curve of the figure. You specify the position where the triangle will be placed, the expected order of convergence, the size of the triangle, and the color. log_triangle should be considered if you are using logarithmic scales (e.g. by using loglog command in Matlab).

// adding a magenta triangle at position [-1.2, -2.5] with a slope of 2 plot_triangle([-1.2, -2.5], 2, 0.2, 'm'); // for logarithmtic scales : log_triangle([0.001, 1e-4], 2, 0.1, 'm');

### plot2dinst

#### Syntax :

plot2dinst(X, Y, V); plot2dinst(X, Y, V, cmin, cmax);

This function displays a 2-D solution. If the color extrema cmin, cmax are not specified, they are set to the minimum and maximum of the solution. With this function, you cannot plot a complex solution, you have to choose to display either its real part, imaginary or modulus.

// displaying imaginary part of a 2-D solution [X, Y, Z, coor, V] = loadND('../totalCarre.dat'); plot2dinst(X, Y, imag(V));

### plot3d_plane

#### Syntax :

plot3d_plane(X, Y, Z, V, coor); plot3d_plane(X, Y, Z, V, coor, cmin, cmax); plot3d_planec(X, Y, Z, V, coor, cmin, cmax);

This function displays a 3-D solution (on the three planes, whose intersection is coor). If the color extrema cmin, cmax are not specified, they are set to the minimum and maximum of the solution. With this function, you cannot plot a complex solution, you have to choose to display either its real part, imaginary or modulus. Use plot3d_planec to have the solution simultaneously on the three planes (in the top left corner).

// displaying modulus of a 3-D solution [X, Y, Z, coor, V] = loadND('../totalCube.dat'); plot3d_planec(X, Y, Z, abs(V), coor);

### str2num_python

#### Syntax :

str2num_python(epsilon)

This function converts a double into a string as it is performed by Python function str.

eps = 1.0; s = str2num_python(eps); [X, Y, Z, coor, V] = loadND(['total',s,'.dat']);

### write_full_s, write_full_d

#### Syntax :

write_full_s(file_name) write_full_d(file_name)

This function writes a dense matrix in binary format (it is equivalent to method Write for Seldon dense matrices). It is useful if you want to specify a variable index in Montjoie, you can create the index in Matlab, and use that function to write the data in a file, that Montjoie is able to read. For the name of the function, s means single precision, whereas d means double precision.

// creating a field X = linspace(-5, 5, 200); Y = linspace(-5, 5, 200); [XI, YI] = meshgrid(X, Y); V = exp(-(X.*X + Y.*Y)) // then writing V on the disk write_full_d('rho.dat');

# Medit

If in the data file, you have specified outputs on meshes
(keywords **SimoMeshSurfacic** and **SismoMeshVolumic**), you
can read the produced outputs with Medit. To display the solution,
you have to type medit followed by the output file (extension.mesh) generated :

medit totalCarre_U0_real.mesh

Then type **l** (like Leopold) and **m** (like Mary) to see
the solution. Look at the documentation of medit (you can
type **h** to have the list of keyboard shortcuts displayed) for
more details.