[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Getfemcommits] (no subject)
From: 
Yves Renard 
Subject: 
[Getfemcommits] (no subject) 
Date: 
Tue, 19 Jun 2018 04:34:27 0400 (EDT) 
branch: master
commit b98e9b54800abe92133f81d3e522d995bae3c116
Author: Yves Renard <address@hidden>
Date: Tue Jun 19 10:34:01 2018 +0200
minor modifications for 5.3 release

bin/extract_doc  4 ++
configure.ac  4 ++
doc/doxygen/Doxyfile  2 +
doc/sphinx/source/.templates/indexcontent.html  2 +
.../source/project/libdesc_high_gen_assemb.rst  6 ++
doc/sphinx/source/project/libdesc_mim.rst  2 +
doc/sphinx/source/replaces.txt  4 ++
doc/sphinx/source/tutorial/basic_usage.rst  2 +
doc/sphinx/source/tutorial/thermo_coupling.rst  6 ++
doc/sphinx/source/tutorial/wheel.rst  6 ++
doc/sphinx/source/userdoc/gasm_high.rst  28 +++++++++++
doc/sphinx/source/userdoc/interMM.rst  8 +++
doc/sphinx/source/userdoc/model_Mindlin_plate.rst  4 ++
doc/sphinx/source/userdoc/model_Nitsche.rst  16 +++++
.../model_contact_friction_large_sliding.rst  16 ++++++
doc/sphinx/source/userdoc/model_fourier_robin.rst  3 +
.../source/userdoc/model_generic_assembly.rst  4 ++
.../source/userdoc/model_generic_elliptic.rst  2 +
.../source/userdoc/model_nonlinear_elasticity.rst  2 +
.../userdoc/model_plasticity_small_strain.rst  2 +
doc/sphinx/source/userdoc/model_source_term.rst  2 +
.../source/userdoc/model_time_integration.rst  8 +++
doc/sphinx/source/userdoc/xfem.rst  2 +
doc/sphinx/source/whatsnew/4.2.rst  4 ++
doc/sphinx/source/whatsnew/4.3.rst  6 ++
doc/sphinx/source/whatsnew/5.0.rst  11 ++++
doc/sphinx/source/whatsnew/5.1.rst  6 ++
doc/sphinx/source/whatsnew/5.2.rst  2 +
doc/sphinx/source/whatsnew/5.3.rst  21 ++++++++++++++++
doc/sphinx/source/whatsnew/index.rst  1 +
extract_gmm++  2 +
interface/src/python/getfem_python.c  4 ++
interface/src/python/setup.py.in  2 +
src/bgeot_geometric_trans.cc  8 +++
src/bgeot_geotrans_inv.cc  3 ++
src/getfem_fem_level_set.cc  4 +
src/getfem_generic_assembly_compile_and_exec.cc  5 +
37 files changed, 112 insertions(+), 102 deletions()
diff git a/bin/extract_doc b/bin/extract_doc
index 12cf717..d9fc8ec 100755
 a/bin/extract_doc
+++ b/bin/extract_doc
@@ 1,7 +1,7 @@
#!/usr/bin/env python
# * python *
#
# Copyright (C) 20042017 Yves Renard, Julien Pommier.
+# Copyright (C) 20042018 Yves Renard, Julien Pommier.
#
# This file is a part of GetFEM++
#
@@ 1579,7 +1579,7 @@ elif (option == 'pythoncom' or option ==
'pythoncompar'):
#
# Python GetFEM++ interface
#
# Copyright (C) 20042016 Yves Renard, Julien Pommier.
+# Copyright (C) 20042018 Yves Renard, Julien Pommier.
#
# This file is a part of GetFEM++
#
diff git a/configure.ac b/configure.ac
index 9ab0ff0..f64a2ea 100644
 a/configure.ac
+++ b/configure.ac
@@ 27,9 +27,9 @@ dnl thus, updating cache ./config.cache avoided.
define([AC_CACHE_LOAD], )dnl
define([AC_CACHE_SAVE], )dnl
AC_INIT(getfem, 5.2)
+AC_INIT(getfem, 5.3)
MAJOR_VERSION="5"
MINOR_VERSION="2"
+MINOR_VERSION="3"
PATCH_VERSION=""
AC_CONFIG_SRCDIR([installsh])
diff git a/doc/doxygen/Doxyfile b/doc/doxygen/Doxyfile
index d461e3d..b0c4fae 100644
 a/doc/doxygen/Doxyfile
+++ b/doc/doxygen/Doxyfile
@@ 31,7 +31,7 @@ PROJECT_NAME = GetFEM++
# This could be handy for archiving the generated documentation or
# if some version control system is used.
PROJECT_NUMBER = 5.2
+PROJECT_NUMBER = 5.3
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
diff git a/doc/sphinx/source/.templates/indexcontent.html
b/doc/sphinx/source/.templates/indexcontent.html
index 305f01c..66feec2 100644
 a/doc/sphinx/source/.templates/indexcontent.html
+++ b/doc/sphinx/source/.templates/indexcontent.html
@@ 91,7 +91,7 @@
</p>
<ul>
 <li> A generic assembly language (in terms of operators) that allows to
translate quite arbitrary weak formulations. A symbolic derivation that allows
to automatically obtain the tangent system for nonlinear problems. A
compilation of assembly terms into optimized basic instructions. </li>
+ <li> A weak form language (in terms of operators) that allows to
translate quite arbitrary weak formulations. A symbolic derivation that allows
to automatically obtain the tangent system for nonlinear problems. A
compilation of assembly terms into optimized basic instructions. </li>
<li> A model description that gather the variables, data and terms of a
problem and some predefined bricks representing classical models : elasticity
in small and large deformations, Helmholtz problem, scalar elliptic problem,
Dirichlet, contact and Neumann boundary conditions, incompressibility
constraint, ... </li>
<li> A complete separation between geometric transformation, finite
element method, integration methods and partial differential term description,
which allows to easily switch from a method to another. </li>
<li> A large set of predefined methods :
isoparametric/subparametric/overparametric elements, Pk on simplices of
arbitrary degree and dimension, Qk on parallelepipeds, pyramidal elements, P1,
P2 with bubble functions, Hermite elements, Argyris element, HCT and FVS,
elements with hierarchical basis (for multigrid methods for instance),
discontinuous Pk and Qk, vector elements (RT0, Nedelec) ... </li>
diff git a/doc/sphinx/source/project/libdesc_high_gen_assemb.rst
b/doc/sphinx/source/project/libdesc_high_gen_assemb.rst
index 194ef0c..ad6a6d9 100644
 a/doc/sphinx/source/project/libdesc_high_gen_assemb.rst
+++ b/doc/sphinx/source/project/libdesc_high_gen_assemb.rst
@@ 15,7 +15,7 @@ The highlevel generic assembly module in gf
Description
^^^^^^^^^^^
The high level generic assembly language of gf is a key module which allows
to describe weak formulation of partial differential equation problems. See the
description of the language in the user documentation section
:ref:`udgasmhigh`.
+The high level generic assembly module of gf and its weak form language is a
key module which allows to describe weak formulation of partial differential
equation problems. See the description of the language in the user
documentation section :ref:`udgasmhigh`.
Files
^^^^^
@@ 26,7 +26,7 @@ Files
:file:`getfem_generic_assembly.h`, "Main header for exported definitions.
Only this header has to be included to use the generic assembly. Other headers
of the module are for internal use only."
:file:`getfem_generic_assembly_tree.h` and
:file:`getfem_generic_assembly_tree.cc`, "Definition of the tree structure and
basic operations on it, including reading an assembly string and transform it
in a syntax tree and make the invert transformation of a tree into a string."
 :file:`getfem_generic_assembly_fonction_and_operators.h` and
:file:`getfem_generic_assembly_fonction_and_operators.cc`, "Definition of
redefined function and nonlinear operator of the assembly language."
+ :file:`getfem_generic_assembly_fonction_and_operators.h` and
:file:`getfem_generic_assembly_fonction_and_operators.cc`, "Definition of
redefined function and nonlinear operator of the weak form language."
:file:`getfem_generic_assembly_semantic.h` and
:file:`getfem_generic_assembly_semantic.cc`, "Semantic analysis and enrichment
of the syntax tree. Include some operations such as making the derivation of a
tree with respect to a variable or computing the tree corresponding to the
gradient of an expression."
:file:`getfem_generic_assembly_workspace.cc`, "Methodes of the workspace
object (defined in :file:`getfem_generic_assembly.h`)."
:file:`getfem_generic_assembly_compile_and_exec.h` and
:file:`getfem_generic_assembly_compile_and_exec.cc`, "Definition of the
optimized instructions, compilation into a sequel of optimize instructions and
execution of the instructions on Gauss point/interpolation points."
@@ 139,7 +139,7 @@ Optimized instructions for variable evaluation, operations,
vector and matrix as
Predefined functions
^^^^^^^^^^^^^^^^^^^^
Some predefined scalar functions are available in gf generic assembly
langage in order to describe a weak formulation (or also to make basic
algebraic computations). This is limited to scalar functions of one or two
arguments. Due to the automatic differentiation used to obtain the tangent
system of described problems, the derivative each function have to be
available. The principle retained is the following: For each predefined
function is available:
+Some predefined scalar functions are available in gf weak form langage in
order to describe a weak formulation (or also to make basic algebraic
computations). This is limited to scalar functions of one or two arguments. Due
to the automatic differentiation used to obtain the tangent system of described
problems, the derivative each function have to be available. The principle
retained is the following: For each predefined function is available:
 A C++ function which computes the value given the argument(s).
 The support of the function in the first each argument in term of a
(possibly infinite) interval (this is for simplification of expressions).
diff git a/doc/sphinx/source/project/libdesc_mim.rst
b/doc/sphinx/source/project/libdesc_mim.rst
index 30bcc9f..2b8121a 100644
 a/doc/sphinx/source/project/libdesc_mim.rst
+++ b/doc/sphinx/source/project/libdesc_mim.rst
@@ 23,7 +23,7 @@ Files
:widths: 8, 15
:file:`getfem_mesh_im.h` and :file:`getfem_mesh_im.cc`, "Object which
defines an integration method on each element of the mesh. Reacts to the main
mesh changes (add or deletion of elements)."
 :file:`getfem_im_data.h` and :file:`getfem_im_data.cc`, "Define an object
representing a scalar, a vector or a tensor on each Gauss point of a mesh_im
object. Used for instance in plasticity approximation. Interpolation of
arbitrary expressions can be made thanks to the highlevel generic assembly
language."
+ :file:`getfem_im_data.h` and :file:`getfem_im_data.cc`, "Define an object
representing a scalar, a vector or a tensor on each Gauss point of a mesh_im
object. Used for instance in plasticity approximation. Interpolation of
arbitrary expressions can be made thanks to the weak form language."
State
diff git a/doc/sphinx/source/replaces.txt b/doc/sphinx/source/replaces.txt
index 9cf67ab..2b00ef2 100644
 a/doc/sphinx/source/replaces.txt
+++ b/doc/sphinx/source/replaces.txt
@@ 17,8 +17,8 @@
.. sLU replace:: *SuperLU*
.. mumps replace:: *MUMPS*
.. sphinx replace:: *Sphinx*
.. version replace:: 5.2
.. licyears replace:: 20042017
+.. version replace:: 5.3
+.. licyears replace:: 20042018
.. gfi replace:: *getfeminterface*
.. m replace:: `mesh`
.. mls replace:: `mesh_level_set`
diff git a/doc/sphinx/source/tutorial/basic_usage.rst
b/doc/sphinx/source/tutorial/basic_usage.rst
index 643af22..dd5c2f1 100644
 a/doc/sphinx/source/tutorial/basic_usage.rst
+++ b/doc/sphinx/source/tutorial/basic_usage.rst
@@ 38,4 +38,4 @@ A program using getfem will often have the following
structure ::
Model.solve(...options)
Note that instead of defining your pde terms with the high generic assembly
language (see :ref:`udgasmhigh` for more details on the syntaxt of the
highlevel generic assembly language), you can use predefined bricks for
standard terms : generic eliptic term, linearized or finite strain elasticity,
standard boundary conditions ...
\ No newline at end of file
+Note that instead of defining your pde terms with the weak form language (see
:ref:`udgasmhigh` for more details on the syntaxt of the weak form language),
you can use predefined bricks for standard terms : generic eliptic term,
linearized or finite strain elasticity, standard boundary conditions ...
diff git a/doc/sphinx/source/tutorial/thermo_coupling.rst
b/doc/sphinx/source/tutorial/thermo_coupling.rst
index 76f14cf..49dbaf2 100644
 a/doc/sphinx/source/tutorial/thermo_coupling.rst
+++ b/doc/sphinx/source/tutorial/thermo_coupling.rst
@@ 511,7 +511,7 @@ Let us now begin by the elastic deformation problem. We
will use the predefined
\int_{\Omega} (\lambda^* \mbox{div}(u) I + 2\mu
\bar{\varepsilon}(u)):\bar{\varepsilon}(\delta_u)dx,
to the tangent linear system. In order to use this model brick, the data
corresponding to he Lame coefficient have to be added to the model first.
Here, the Lame coefficients are constant over the domain. However, it it also
possible to define some nonconstant data. Note also that instead of using this
predefined brick, one can use equivalently the generic assembly brick
`add_linear_term(md mim, "lambda*(Div_u*Div_Test_u) + mu*((Grad_u +
Grad_u'):Grad_Test_u)"`.
+to the tangent linear system. In order to use this model brick, the data
corresponding to he Lame coefficient have to be added to the model first.
Here, the Lame coefficients are constant over the domain. However, it it also
possible to define some nonconstant data. Note also that instead of using this
predefined brick, one can use equivalently the weak form language term
`add_linear_term(md mim, "lambda*(Div_u*Div_Test_u) + mu*((Grad_u +
Grad_u'):Grad_Test_u)"`.
Concerning the coupling term
@@ 519,7 +519,7 @@ Concerning the coupling term
\int_{\Omega} (\beta\theta I) :\bar{\varepsilon}(\delta_u)dx,
there is no predefined brick and we use directly a generic assembly brick
`add_linear_term(md mim, "beta*theta*Div_Test_u)"`. See :ref:`udgasmhigh` for
more details on the highlevel generic assembly language. Basically, the
principle is that the assembly string is compiled into a list of optimized
assembly instructions which are executed on each Gauss point.
+there is no predefined brick and we use directly a weak form language term
`add_linear_term(md mim, "beta*theta*Div_Test_u)"`. See :ref:`udgasmhigh` for
more details on the weak form language. Basically, the principle is that the
assembly string is compiled into a list of optimized assembly instructions
which are executed on each Gauss point.
The following program allows to take into account the whole elastic
deformation equation. Note the use of specific brick to prescribe the Dirichlet
condition on the left boundary. There is several option to prescribe a
Dirichlet condition (see :ref:`udmodelDirichlet`).
@@ 586,7 +586,7 @@ The following program allows to take into account the whole
elastic deformation
Electric potential problem
**************************
Similarly, the following program take into account the electric potential
equation. Note the definition of the electrical conductivity :math:`\sigma`
and again the use of generic assembly bricks.
+Similarly, the following program take into account the electric potential
equation. Note the definition of the electrical conductivity :math:`\sigma`
and again the use of weak form language terms.
==========
===========================================================================
**C++** .. codeblock:: c++
diff git a/doc/sphinx/source/tutorial/wheel.rst
b/doc/sphinx/source/tutorial/wheel.rst
index 71acd82..963f71f 100644
 a/doc/sphinx/source/tutorial/wheel.rst
+++ b/doc/sphinx/source/tutorial/wheel.rst
@@ 157,7 +157,7 @@ where :math:`X` is the vector of coordinates of the point.
We add this transform
md.add_interpolate_transformation_from_expression('Proj1', mesh1, mesh2,
'[X(1);0]')
As a consequence, it will be possible to use this transformation, from the
mesh of the wheel to the mesh of the foundation, into generic assembly
expressions. Notes that this is here a very simple constant expression. More
complex expressions depending on the data or even the variables of the model
can be used. If the expression of a transformation depends on the variable of
the model, the tangent linear system will automatically takes into account this
dependence (see :ref:`udgasmhigh [...]
+As a consequence, it will be possible to use this transformation, from the
mesh of the wheel to the mesh of the foundation, into weak form language
expressions. Notes that this is here a very simple constant expression. More
complex expressions depending on the data or even the variables of the model
can be used. If the expression of a transformation depends on the variable of
the model, the tangent linear system will automatically takes into account this
dependence (see :ref:`udgasmhi [...]
Using the defined transformation, we can write an integral contact condition
using an augmented Lagrangian formulation (see :ref:`udmodelcontactfriction`
for more details). The corresponding term (to be added to the rest of the weak
formulation) reads:
@@ 168,7 +168,7 @@ Using the defined transformation, we can write an integral
contact condition usi
where :math:`\Gamma_c` is the slave contact boundary, :math:`\lambda_N` is the
contact multiplier (contact pressure), :math:`h_T` is the radius of the
element, :math:`\Pi` is the transformation, `n` is the outward normal vector to
the master contact boundary (here :math:`n = (0,1)`), :math:`\gamma_0` is an
augmentation parameter, :math:`(\cdot)_:I\hspace{0.2em}R\rightarrow
I\hspace{0.2em}R_+` is the negative part and :math:`\delta_{\lambda_N},
\delta_{u^1}, \delta_{u^2}` are the test [...]
Using the highlevel generic assembly bricks, the contact condition can be
added by:
+Using the weak form language, the contact condition can be added by:
.. codeblock:: python
@@ 203,7 +203,7 @@ This multiplier represents the boundary stress that is
necessary to prescribe th
where :math:`\Gamma_D` is the rim boundary, :math:`F` is the applied density
of force.
This could be added to the model with the generic assembly brick:
+This could be added to the model with the weak form language:
.. codeblock:: python
diff git a/doc/sphinx/source/userdoc/gasm_high.rst
b/doc/sphinx/source/userdoc/gasm_high.rst
index 717d993..e3ef022 100644
 a/doc/sphinx/source/userdoc/gasm_high.rst
+++ b/doc/sphinx/source/userdoc/gasm_high.rst
@@ 11,7 +11,7 @@
Compute arbitrary terms  highlevel generic assembly procedures
================================================================
This section presents what is now the main generic assembly of gf. It is a
highlevel generic assembly in the sense that the language used to describe the
assembly is quite close to the weak formulation of boundary value problems of
partial differential equations. It mainly has been developed to circumvent the
difficulties with the previous lowlevel generic assembly (see
:ref:`udgasmlow`) for which nonlinear terms were quite difficult to describe.
Conversely, a symbolic differentia [...]
+This section presents what is now the main generic assembly of gf. It is a
highlevel generic assembly in the sense that it is based on a weak form
language to describe the weak formulation of boundary value problems of partial
differential equations. It mainly has been developed to circumvent the
difficulties with the previous lowlevel generic assembly (see
:ref:`udgasmlow`) for which nonlinear terms were quite difficult to describe.
Conversely, a symbolic differentiation algorith [...]
The header file to be included to use the highlevel generic assembly
procedures in C++ is :file:`getfem/generic\_assembly.h`.
@@ 21,10 +21,10 @@ For basic linear assembly terms, the high level generic
assembly is most of the
Overview of the assembly language syntax

+Overview of the weak form language syntax
+
A specific language has been developed to describe the weak formulation of
boundary value problems. It is intended to be close to the structure of a
standard weak formulation and it incorporates the following components:
+A specific weak form language has been developed to describe the weak
formulation of boundary value problems. It is intended to be close to the
structure of a standard weak formulation and it incorporates the following
components:
 Variable names: A list of variables should be given. The variables are
described on a finite element method or can be a simple vector of unknowns. For
instance ``u``, ``v``, ``p``, ``pressure``, ``electric_field`` are valid
variable names.
@@ 361,7 +361,7 @@ with ``D`` the flexion modulus and ``nu`` the Poisson ratio.
The tensors

Basically, what is manipulated in the generic assembly language are tensors.
This can be order 0 tensors in scalar expressions (for instance in
``3+sin(pi/2)``), order 1 tensors in vector expressions (such as ``X.X`` or
``Grad_u`` if u is a scalar variable), order 2 tensors for matrix expressions
and so on. For efficiency reasons, the language manipulates tensors up to order
six. The language could be easily extended to support tensors of order greater
than six but it may lead to ineffic [...]
+Basically, what is manipulated in the weak form language are tensors. This can
be order 0 tensors in scalar expressions (for instance in ``3+sin(pi/2)``),
order 1 tensors in vector expressions (such as ``X.X`` or ``Grad_u`` if u is a
scalar variable), order 2 tensors for matrix expressions and so on. For
efficiency reasons, the language manipulates tensors up to order six. The
language could be easily extended to support tensors of order greater than six
but it may lead to inefficient co [...]
Order four tensors are necessary for instance to express elasticity tensors or
in general to obtain the tangent term for vector valued unknowns.
@@ 432,7 +432,7 @@ It is possible to add a scalar function to the already
predefined ones. Note tha
ga_define_function(name, getfem::pscalar_func_twoargs f2, der1="", der2="");
where ``name`` is the name of the function to be defined, ``nb_args`` is equal
to 1 or 2. In the first call, ``expr`` is a string describing the function in
the generic assembly language and using ``t`` as the first variable and ``u``
as the second one (if ``nb_args`` is equal to 2). For instance,
``sin(2*t)+sqr(t)`` is a valid expression. Note that it is not possible to
refer to constant or data defined in a ``ga_workspace`` object. ``der1`` and
``der2`` are the expression of the deriva [...]
+where ``name`` is the name of the function to be defined, ``nb_args`` is equal
to 1 or 2. In the first call, ``expr`` is a string describing the function in
the generic weak form language and using ``t`` as the first variable and ``u``
as the second one (if ``nb_args`` is equal to 2). For instance,
``sin(2*t)+sqr(t)`` is a valid expression. Note that it is not possible to
refer to constant or data defined in a ``ga_workspace`` object. ``der1`` and
``der2`` are the expression of the deriv [...]
Additionally,::
@@ 504,7 +504,7 @@ Parentheses can be used in a standard way to change the
operation order. If no p
Explicit vectors

The assembly language allows to define explicit vectors (i.e. order 1 tensors)
with the notation ``[a,b,c,d,e]``, i.e. an arbitrary number of components
separated by a comma (note the separation with a semicolon ``[a;b;c;d;e]`` is
also permitted), the whole vector beginning with a right bracket and ended by a
left bracket. The components can be some numeric constants, some valid
expressions and may also contain test functions. In the latter case, the vector
has to be homogeneous with res [...]
+The weak form language allows to define explicit vectors (i.e. order 1
tensors) with the notation ``[a,b,c,d,e]``, i.e. an arbitrary number of
components separated by a comma (note the separation with a semicolon
``[a;b;c;d;e]`` is also permitted), the whole vector beginning with a right
bracket and ended by a left bracket. The components can be some numeric
constants, some valid expressions and may also contain test functions. In the
latter case, the vector has to be homogeneous with re [...]
Explicit matrices
@@ 579,7 +579,7 @@ The four operators can be applied on test functions. Which
means that for instan
Nonlinear operators

The assembly language provide some predefined nonlinear operator. Each
nonlinear operator is available together with its first and second derivatives.
Nonlinear operator can be applied to an expression as long as this expression
do not contain some test functions.
+The weak form language provide some predefined nonlinear operator. Each
nonlinear operator is available together with its first and second derivatives.
Nonlinear operator can be applied to an expression as long as this expression
do not contain some test functions.
 ``Norm(v)`` for ``v`` a vector or a matrix gives the euclidean norm of a
vector or a Frobenius norm of a matrix.
@@ 610,7 +610,7 @@ The assembly language provide some predefined nonlinear
operator. Each nonlinear
Macro definition

The assembly language allows the use of macros that are either predefined in
the model or ga_workspace object or directly defined at the begining of an
assembly string. The definition into a ga_workspace or model object is done as
follows::
+The weak form language allows the use of macros that are either predefined in
the model or ga_workspace object or directly defined at the begining of an
assembly string. The definition into a ga_workspace or model object is done as
follows::
workspace.add_macro(name, expr)
@@ 622,7 +622,7 @@ The definition of a macro into an assembly string is
inserted before any regular
"Def name:=expr; regular_expression"
where ``name`` is he macro name which then can be used in the assembly
language and contains also the macro parameters, ``expr`` is a valid expression
of the assembly language (which may itself contain some macro definitions). For
instance, a valid macro with no parameter is::
+where ``name`` is he macro name which then can be used in the weak form
language and contains also the macro parameters, ``expr`` is a valid expression
of the weak form language (which may itself contain some macro definitions).
For instance, a valid macro with no parameter is::
model.add_macro("my_transformation", "[cos(alpha)*X(1);sin(alpha)*X(2)]");
@@ 723,7 +723,7 @@ or::
add_interpolate_transformation_from_expression
(md, transname, source_mesh, target_mesh, expr);
where ``workspace`` is a workspace object, ``md`` a model object,
``transname`` is the name given to the transformation, ``source_mesh`` the mesh
on which the integration occurs, ``target_mesh`` the mesh on which the
interpolation is performed and ``expr`` is a regular expression of the
highlevel generic assembly language which may contains reference to the
variables of the workspace/model.
+where ``workspace`` is a workspace object, ``md`` a model object,
``transname`` is the name given to the transformation, ``source_mesh`` the mesh
on which the integration occurs, ``target_mesh`` the mesh on which the
interpolation is performed and ``expr`` is a regular expression of the
highlevel generic weak form language which may contains reference to the
variables of the workspace/model.
For instance, an expression::
@@ 763,7 +763,7 @@ For instance, the assembly expression to prescribe the
equality of a variable ``
(see :file:`demo\_periodic\_laplacian.m` in :file:`interface/tests/matlab`
directory).
In some situations, the interpolation of a point may fail if the transformed
point is outside the target mesh. Both in order to treat this case and to allow
the transformation to differentiate some other cases (see
:ref:`udmodelcontactfriction_raytrace_inter_trans` for the differentiation
between rigid bodies and deformable ones in the
Raytracing_interpolate_transformation) the tranformation returns an integer
identifiant to the assembly language. A value 0 of this identifiant means t
[...]
+In some situations, the interpolation of a point may fail if the transformed
point is outside the target mesh. Both in order to treat this case and to allow
the transformation to differentiate some other cases (see
:ref:`udmodelcontactfriction_raytrace_inter_trans` for the differentiation
between rigid bodies and deformable ones in the
Raytracing_interpolate_transformation) the tranformation returns an integer
identifiant to the weak form language. A value 0 of this identifiant means
[...]
Interpolate_filter(transname, expr, i)
@@ 855,7 +855,7 @@ the method::
model.add_elementary_transformation(transname, pelementary_transformation)
where ``pelementary_transformation`` is a pointer to an object deriving from
``virtual_elementary_transformation``. Once it is added to the model/workspace,
it is possible to use the following expressions in the assembly language::
+where ``pelementary_transformation`` is a pointer to an object deriving from
``virtual_elementary_transformation``. Once it is added to the model/workspace,
it is possible to use the following expressions in the weak form language::
Elementary_transformation(u, transname)
Elementary_transformation(Grad_u, transname)
@@ 875,7 +875,7 @@ where ``u`` is one of the FEM variables of the
model/workspace. For the moment,
Xfem discontinuity evaluation (with mesh_fem_level_set)

For gf 5.1. When using a fem cut by a levelset (using fem_level_set or
mesh_fem_level_set objects), it is often interesting to integrate the
discontinuity jump of a variable, or the jump in gradient or the average value.
For this purpose, the generic assembly language furnishes the following
expressions for ``u`` a FEM variable::
+For gf 5.1. When using a fem cut by a levelset (using fem_level_set or
mesh_fem_level_set objects), it is often interesting to integrate the
discontinuity jump of a variable, or the jump in gradient or the average value.
For this purpose, the weak form language furnishes the following expressions
for ``u`` a FEM variable::
Xfem_plus(u)
Xfem_plus(Grad_u)
diff git a/doc/sphinx/source/userdoc/interMM.rst
b/doc/sphinx/source/userdoc/interMM.rst
index b16779c..aa21f76 100644
 a/doc/sphinx/source/userdoc/interMM.rst
+++ b/doc/sphinx/source/userdoc/interMM.rst
@@ 51,10 +51,10 @@ the interpolation is done with a simple matrix
multiplication::
gmm::mult(M, U, V);
Interpolation based on the highlevel generic assembly langage
**************************************************************
+Interpolation based on the highlevel weak form langage
+*******************************************************
It is possible to extract some arbitraries expressions on possibly several
fields thanks to the highlevel generic assembly langage and the interpolation
functions.
+It is possible to extract some arbitraries expressions on possibly several
fields thanks to the weak form langage and the interpolation functions.
This is specially dedicated to the model object (but it can also be used with
a ga_workspace object). For instance if ``md`` is a valid object containing
some defined variables ``u`` (vectorial) and ``p`` (scalar), one can
interpolate on a Lagrange finite element method an expression such as
``p*Trace(Grad_u)``. The resulting expression can be scalar, vectorial or
tensorial. The size of the resulting vector is automatically adapted.
@@ 83,4 +83,4 @@ Interpolation on an im_data object (on the Gauss points of an
integration method
void getfem::ga_interpolation_im_data(md, expr, im_data &imd,
base_vector &result, const mesh_region &rg=mesh_region::all_convexes());
where ``md`` is a ``getfem::model`` object (containing the variables and
data), ``expr`` (std::string object) is the expression to be interpolated,
``imd`` is a ``getfem::im_data`` object which refers to a integration method
(see :file:`getfem/getfem_im_data.h`), ``result`` is the vector in which the
interpolation is stored and ``rg`` is the optional mesh region.
\ No newline at end of file
+where ``md`` is a ``getfem::model`` object (containing the variables and
data), ``expr`` (std::string object) is the expression to be interpolated,
``imd`` is a ``getfem::im_data`` object which refers to a integration method
(see :file:`getfem/getfem_im_data.h`), ``result`` is the vector in which the
interpolation is stored and ``rg`` is the optional mesh region.
diff git a/doc/sphinx/source/userdoc/model_Mindlin_plate.rst
b/doc/sphinx/source/userdoc/model_Mindlin_plate.rst
index 0781f45..eaa5b80 100644
 a/doc/sphinx/source/userdoc/model_Mindlin_plate.rst
+++ b/doc/sphinx/source/userdoc/model_Mindlin_plate.rst
@@ 75,7 +75,7 @@ where :math:`P^h(T)` is the elementwize
:math:`L^2`projection onto the rotated
\int_{\Omega}G\epsilon (\nabla u_3  P^h(\theta))\cdot(\nabla v_3 
P^h(\psi))dx
The principle of the definition of an elementary projection is explained if
the description of the highlevel generic assembly language (see
:ref:`udgasmhighelemtrans`) and an example can be found in the file
:file:`src/getfem_linearized_plates.cc`.
+The principle of the definition of an elementary projection is explained if
the description of the weak form language (see :ref:`udgasmhighelemtrans`)
and an example can be found in the file :file:`src/getfem_linearized_plates.cc`.
@@ 89,7 +89,7 @@ The following function defined in
:file:`src/getfem/getfem_linearized_plates.h`
param_nu, param_epsilon, param_kappa, variant = 2, region)
where `name_u3` is name of the variable which represents the transverse
displacmenent, `name_theta` the variable which represents the rotation,
'param_E' the Young Modulus, `param_nu` the poisson ratio, `param_epsilon` the
plate thickness, `param_kappa` the shear correction factor. Note that since
this brick
uses the high level generic assembly language, the parameter can be regular
expression of this language.
+uses the weak form language, the parameter can be regular expression of this
language.
There are three variants.
`variant = 0` corresponds to the an
unreduced formulation and in that case only the integration
diff git a/doc/sphinx/source/userdoc/model_Nitsche.rst
b/doc/sphinx/source/userdoc/model_Nitsche.rst
index 39357d6..3054f52 100644
 a/doc/sphinx/source/userdoc/model_Nitsche.rst
+++ b/doc/sphinx/source/userdoc/model_Nitsche.rst
@@ 32,7 +32,7 @@ Of course, in that case :math:`G` also depends on some
material parameters.
If additionally a mixed incompressibility brick is added with a variable
:math:`p` denoting the pressure, the Neumann term on :math:`u` will depend on
:math:`p` in the following way:
:math:`G = \sigma(u)n  pn`
In order to allow a generic implementation in which the brick imposing
Nitsche's method will work for every partial differential term applied to the
concerned variables, each brick adding a partial differential term to a model
is required to give its expression via an assembly string (high generic
assembly language).
+In order to allow a generic implementation in which the brick imposing
Nitsche's method will work for every partial differential term applied to the
concerned variables, each brick adding a partial differential term to a model
is required to give its expression via an assembly string (weak form language).
These expressions are utilized in a special method of the model object::
@@ 80,8 +80,7 @@ The bricks adding a Dirichlet condition with Nitsche's method
to a model are the
This function adds a Dirichlet condition on the variable `varname` and the mesh
region `region`. This region should be a boundary. `Neumannterm`
is the expression of the Neumann term (obtained by the Green formula)
described as an expression of the highlevel
generic assembly language. This term can be obtained with
+described as an expression of the xeak form language. This term can be
obtained with
md.Neumann_term(varname, region) once all volumic bricks have
been added to the model. The Dirichlet
condition is prescribed with Nitsche's method. `dataname` is the optional
@@ 110,8 +109,7 @@ This function adds a Dirichlet condition to the normal
component of the vector
(or tensor) valued variable `varname` and the mesh region `region`.
This region should be a boundary. `Neumannterm`
is the expression of the Neumann term (obtained by the Green formula)
described as an expression of the highlevel
generic assembly language. This term can be obtained with
+described as an expression of the weak form language. This term can be
obtained with
md.Neumann_term(varname, region) once all volumic bricks have
been added to the model. The Dirichlet
condition is prescribed with Nitsche's method. `dataname` is the optional
@@ 141,8 +139,7 @@ This version is for vector field. It prescribes a condition
:math:`Hu = r` where :math:`H` is a matrix field. The region should be a
boundary. This region should be a boundary. `Neumannterm`
is the expression of the Neumann term (obtained by the Green formula)
described as an expression of the highlevel
generic assembly language. This term can be obtained with
+described as an expression of the weak form language. This term can be
obtained with
md.Neumann_term(varname, region) once all volumic bricks have
been added to the model. The Dirichlet
condition is prescribed with Nitsche's method.
@@ 195,8 +192,7 @@ The following function adds a contact condition with or
without Coulomb
friction on the variable
`varname_u` and the mesh boundary `region`. `Neumannterm`
is the expression of the Neumann term (obtained by the Green formula)
described as an expression of the highlevel
generic assembly language. This term can be obtained with
+described as an expression of the weak form language. This term can be
obtained with
md.Neumann_term(varname, region) once all volumic bricks have
been added to the model. The contact condition
is prescribed with Nitsche's method. The rigid obstacle should
@@ 210,7 +206,7 @@ method which is conditionnaly coercive for `gamma0` small.
inconditionnaly coercive. `theta = 0` is the simplest method
for which the second derivative of the Neumann term is not necessary.
The optional parameter `dataexpr_friction_coeff` is the friction
coefficient which could be any expression of the assembly language.
+coefficient which could be any expression of the weak form language.
Returns the brick index in the model.::
diff git a/doc/sphinx/source/userdoc/model_contact_friction_large_sliding.rst
b/doc/sphinx/source/userdoc/model_contact_friction_large_sliding.rst
index 305b3f6..80fa8f4 100644
 a/doc/sphinx/source/userdoc/model_contact_friction_large_sliding.rst
+++ b/doc/sphinx/source/userdoc/model_contact_friction_large_sliding.rst
@@ 11,7 +11,7 @@
Large sliding/large deformation contact with friction bricks

The basic tools to deal with large sliding/large deformation contact of
deformable structures are accessible in the highlevel generic assembly
language. Some interpolate transformations (see :ref:`udgasmhightransf`) are
defined to perform the contact detection and allow to integrate from a contacct
bondary to the opposite contact boundary. Some other useful tools such as the
unit normal vector in the real configuration and projections to take into
account contact with Coulomb frictio [...]
+The basic tools to deal with large sliding/large deformation contact of
deformable structures are accessible in the weak form language. Some
interpolate transformations (see :ref:`udgasmhightransf`) are defined to
perform the contact detection and allow to integrate from a contacct bondary to
the opposite contact boundary. Some other useful tools such as the unit normal
vector in the real configuration and projections to take into account contact
with Coulomb friction are also defined [...]
Of course, the computational cost of large sliding/large deformation contact
algorithms is greatly higher than small slidingsmall deformation ones.
@@ 38,7 +38,7 @@ The addition of a raytracing transformation to a model::
void add_raytracing_transformation(model &md, const std::string &transname,
scalar_type d)
where ``transname`` is a name given to the transformation which allows to
refer to it in the highlevel generic assembly language and ``d`` is the
release distance (see above).
+where ``transname`` is a name given to the transformation which allows to
refer to it in the weak form language and ``d`` is the release distance (see
above).
The raytracing transformation is added without any slave or master contact
boundary. The following functions allows to add some boundaries to the
transformation::
@@ 59,9 +59,9 @@ It is also possible to add a rigid obstacle (considered as a
master surface) tha
const std::string &transname,
const std::string &expr, size_type N)
where ``expr`` is the expression of a signed distance to the obstacle using
the syntax of the highlevel generic assembly language (``X`` being the current
position, ``X(0)``, ``X(1)`` ... the corresponding components). For instance an
expression ``X(0) + 5`` will correspond to a flat obstacle lying on the right
of the position ``5`` of the first coordinate. Be aware that the expression
have to be close to a signed distance, which in particular means that the
gradient norm have to be cl [...]
+where ``expr`` is the expression of a signed distance to the obstacle using
the syntax of the weak form language (``X`` being the current position,
``X(0)``, ``X(1)`` ... the corresponding components). For instance an
expression ``X(0) + 5`` will correspond to a flat obstacle lying on the right
of the position ``5`` of the first coordinate. Be aware that the expression
have to be close to a signed distance, which in particular means that the
gradient norm have to be close to 1.
In order to distinguish between noncontact situations and the occurence of a
contact with another deformable body or with a rigid obstacle, the
transformation returns an integer identifiant which can be used by the
`Interpolate_filter` command of the highlevel generic assembly language (see
:ref:`udgasmhightransf`). The different values:
+In order to distinguish between noncontact situations and the occurence of a
contact with another deformable body or with a rigid obstacle, the
transformation returns an integer identifiant which can be used by the
`Interpolate_filter` command of the weak form language (see
:ref:`udgasmhightransf`). The different values:
* 0 : no contact found on this Gauss point
@@ 75,7 +75,7 @@ such that it is possible to differentiate the treatment of
these three cases usi
Interpolate_filter(transname, expr2, 1)
Interpolate_filter(transname, expr3, 2)
in the assembly language, where ``expr1``, ``expr2`` and ``expr3`` correspond
to the different terms to be computed. The matlab interface demo program
:file:`/interface/tests/matlab/demo_large_sliding_contact.m` presents an
example of use.
+in the weak form language, where ``expr1``, ``expr2`` and ``expr3`` correspond
to the different terms to be computed. The matlab interface demo program
:file:`/interface/tests/matlab/demo_large_sliding_contact.m` presents an
example of use.
Note that the transformation could also be directly used with a `ga_workspace`
object if model object are not used. See
:file:`getfem/getfem_contact_and_friction_common.h` for more details. Note also
that in the framework of the model object, a interfaced use of this
transformation is allowed by the model bricks described below.
@@ 231,7 +231,7 @@ Sorry, for the moment the brick is not working.
Tools of the highlevel generic assembly for contact with friction
******************************************************************
The following nonlinear operators are defined in the highlevel generic
assembly langage (see :ref:`udgasmhigh`):
+The following nonlinear operators are defined in the weak form language (see
:ref:`udgasmhigh`):
 ``Transformed_unit_vector(Grad_u, n)`` where ``Grad_u`` is the gradient of
a
displacement field and ``n`` a unit vector in the reference configuration.
@@ 358,6 +358,4 @@ A rigid obstacle can be added to the brick with::
add_rigid_obstacle_to_large_sliding_contact_brick(model &md,
size_type indbrick, std::string expr, size_type N)
where `expr` is an expression using the highlevel
generic assembly language (with `X` is the current position) which should
be a signed distance to the obstacle. `N` is the mesh dimension.
+where `expr` is an expression using the weak form language (with `X` is the
current position) which should be a signed distance to the obstacle. `N` is the
mesh dimension.
diff git a/doc/sphinx/source/userdoc/model_fourier_robin.rst
b/doc/sphinx/source/userdoc/model_fourier_robin.rst
index 3ba88e4..8bd1ddf 100644
 a/doc/sphinx/source/userdoc/model_fourier_robin.rst
+++ b/doc/sphinx/source/userdoc/model_fourier_robin.rst
@@ 35,8 +35,7 @@ The function adding this brick to a model is::
add_Fourier_Robin_brick(md, mim, varname, dataexpr, region);
where ``dataexpr`` is the data of the model which represents the coefficient
:math:`Q`. It can be an arbitrary valid expression of the highlevel generic
assembly language (except for the complex version for which it should be a
data of the model)
+:math:`Q`. It can be an arbitrary valid expression of the weak form language
(except for the complex version for which it should be a data of the model)
Note that an additional right hand side can be added with a source term brick.
diff git a/doc/sphinx/source/userdoc/model_generic_assembly.rst
b/doc/sphinx/source/userdoc/model_generic_assembly.rst
index eb355a1..17e22c4 100644
 a/doc/sphinx/source/userdoc/model_generic_assembly.rst
+++ b/doc/sphinx/source/userdoc/model_generic_assembly.rst
@@ 13,7 +13,7 @@ Generic assembly bricks

A mean to add a term either on one variable or on several ones is to directly
use the highlevel generic assembly langage describe in Section
:ref:`udgasmhigh`. The more general way is to use::
+A mean to add a term either on one variable or on several ones is to directly
use the weak form langage described in Section :ref:`udgasmhigh`. The more
general way is to use::
size_type getfem::add_nonlinear_term(md, mim, expr,
region = 1, is_sym = false, is_coercive = false);
@@ 46,4 +46,4 @@ where ``F`` is a predefined constant of the model
representing the right hand s
Note that for the moment, the use of the highlevel generic assembly is not
possible for complex valued problems.
+Note that for the moment, the use of the weak form language is not possible
for complex valued problems.
diff git a/doc/sphinx/source/userdoc/model_generic_elliptic.rst
b/doc/sphinx/source/userdoc/model_generic_elliptic.rst
index 60a4bfc..625ae2c 100644
 a/doc/sphinx/source/userdoc/model_generic_elliptic.rst
+++ b/doc/sphinx/source/userdoc/model_generic_elliptic.rst
@@ 49,7 +49,7 @@ The second function is::
size_type getfem::add_generic_elliptic_brick(md, mim, varname, dataexpr,
region = 1);
It adds a term with an arbitrary coefficient given by the expression
``dataexpr`` which has to be a regular expression of the highlevel generic
assembly language (like "1", "sin(X[0])" or "Norm(u)" for instance) even
depending on model variables (except for the complex version where it has to be
a declared data of the model)
+It adds a term with an arbitrary coefficient given by the expression
``dataexpr`` which has to be a regular expression of the weak form language
(like "1", "sin(X[0])" or "Norm(u)" for instance) even depending on model
variables (except for the complex version where it has to be a declared data of
the model)
Note that very general equations can be obtained with this brick. For instance,
linear anisotropic elasticity can be obtained with a tensor data. When an order
diff git a/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst
b/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst
index 5329bbf..8c125bc 100644
 a/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst
+++ b/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst
@@ 345,7 +345,7 @@ where ``md`` is the model, ``mim`` the integration method,
``varname`` the varia
Highlevel generic assembly versions
++++++++++++++++++++++++++++++++++++
The highlevel generic assembly language gives access to the hyperelastic
potential and constitutive laws implemented in gf. This allows to directly
use them in the language, for instance using a generic assembly brick in a
model or for interpolation of certain quantities (the stress for instance).
+The weak form language gives access to the hyperelastic potential and
constitutive laws implemented in gf. This allows to directly use them in the
language, for instance using a generic assembly brick in a model or for
interpolation of certain quantities (the stress for instance).
Here is the list of nonlinear operators in the language which can be useful
for nonlinear elasticity::
diff git a/doc/sphinx/source/userdoc/model_plasticity_small_strain.rst
b/doc/sphinx/source/userdoc/model_plasticity_small_strain.rst
index b872c59..beffece 100644
 a/doc/sphinx/source/userdoc/model_plasticity_small_strain.rst
+++ b/doc/sphinx/source/userdoc/model_plasticity_small_strain.rst
@@ 502,7 +502,7 @@ displacement, the plastic multiplier and the plastic
strain).
`params` is a list of expressions for the parameters (at least elastic
coefficients and the yield stress). These expressions can be some data
names (or even variable names) of the model but can also be any scalar
valid expression of the high level assembly language (such as "1/2",
+valid expression of the weak form language (such as "1/2",
"2+sin(X[0])", "1+Norm(v)" ...). The last two parameters optionally
provided in `params` are the `theta` parameter of the `theta`scheme
(generalized trapezoidal rule) used for the plastic strain integration
diff git a/doc/sphinx/source/userdoc/model_source_term.rst
b/doc/sphinx/source/userdoc/model_source_term.rst
index fe1a054..0dc0653 100644
 a/doc/sphinx/source/userdoc/model_source_term.rst
+++ b/doc/sphinx/source/userdoc/model_source_term.rst
@@ 33,7 +33,7 @@ The function to add a source term to a model is::
directdataname = std::string());
where ``md``is the model object, ``mim`` is the integration method,
``varname`` is
the variable of the model for which the source term is added, ``dataexpr`` has
to be a regular expression of the highlevel generic assembly language (except
for the complex version where it has to be a declared data of the model). It
has to be
+the variable of the model for which the source term is added, ``dataexpr`` has
to be a regular expression of the weak form language (except for the complex
version where it has to be a declared data of the model). It has to be
scalar or vector valued depending on the fact that the variable is scalar or
vector valued itself. ``region`` is a mesh region on which the term is added.
If
the region corresponds to a boundary, the source term will represent a Neumann
diff git a/doc/sphinx/source/userdoc/model_time_integration.rst
b/doc/sphinx/source/userdoc/model_time_integration.rst
index 82c27fb..218e42f 100644
 a/doc/sphinx/source/userdoc/model_time_integration.rst
+++ b/doc/sphinx/source/userdoc/model_time_integration.rst
@@ 19,13 +19,13 @@ Although time integration scheme can be written directly
using the model object
* Some data are added to the model to represent the state of the system at
previous time steps. For classical onestep schemes (for the moment, only
onestep schemes are provided), only the previous time step is stored. For
instance if `u` is a variable (thus represented at step n), `Previous_u` will
be the data representing the state of the variable at the previous time step
(step n1). Eventually, for future extension to multistep methods,
`Previous2_u` may represent the variable at t [...]
* Some intermediate variables are added to the model to represent the time
derivative (and the second order time derivative for second order problem). For
instance, if `u` is a variable, `Dot_u` will represent the first order time
derivative of `u` and `Dot2_u` the second order one. One can refer to these
variables in the model to add a brick on it or to use it in the generic
assembly language. However, these are not considered to be independent
variables, they will be linked to their co [...]
+* Some intermediate variables are added to the model to represent the time
derivative (and the second order time derivative for second order problem). For
instance, if `u` is a variable, `Dot_u` will represent the first order time
derivative of `u` and `Dot2_u` the second order one. One can refer to these
variables in the model to add a brick on it or to use it in the weak form
language. However, these are not considered to be independent variables, they
will be linked to their correspon [...]
* A different time integration scheme can be applied on each variable of the
model. Note that most of the time, multiplier variable and more generally
variables for which no time derivative is used do not need a time integration
scheme.
* The data `t` represent the time parameter and can be used (either in the
generic assembly or as parameter of some bricks). Before the assembly of the
system, the data `t` is automatically updated to the time step `n`.
+* The data `t` represent the time parameter and can be used (either in the
weak form language or as parameter of some bricks). Before the assembly of the
system, the data `t` is automatically updated to the time step `n`.
* The problem to be solved at each iteration correspond to the formulation of
the transient problem in its natural (weak) formulation in which the velocity
and the acceleration are expressed by the intermediate variables introduced.
For instance, the translation into the high level generic assembly language of
the problem
+* The problem to be solved at each iteration correspond to the formulation of
the transient problem in its natural (weak) formulation in which the velocity
and the acceleration are expressed by the intermediate variables introduced.
For instance, the translation into the weak form language of the problem
.. math::
@@ 229,7 +229,7 @@ Transient terms
As it has been explained in previous sections, some intermediate variables are
added to the model in order to represent the time derivative of the variables
on which the scheme is applied. Once again, if "u" is such a variable, "Dot_u"
will represent the time derivative of "u" approximated by the used scheme.
This also mean that "Dot_u" (and "Dot2_u" in order two in time problems) can
be used to express the transient terms. In the high level generic assembly
language, the term:
+This also mean that "Dot_u" (and "Dot2_u" in order two in time problems) can
be used to express the transient terms. In the weak form language, the term:
.. math::
diff git a/doc/sphinx/source/userdoc/xfem.rst
b/doc/sphinx/source/userdoc/xfem.rst
index 398e539..88b077c 100644
 a/doc/sphinx/source/userdoc/xfem.rst
+++ b/doc/sphinx/source/userdoc/xfem.rst
@@ 217,7 +217,7 @@ Once the asymptotic enrichment is defined, the object
``getfem::mesh_fem_sum`` a
See :file:`interface/tests/matlab/demo_crack.m`,
:file:`interface/tests/python/demo_crack.py` or :file:`tests/crack.cc` for some
examples of use of these tools.
Additionally, the generic assembly language defines the two commands
``Xfem_plus`` and ``Xfem_minus`` allowing to take into account the jump of any
field or derivative of any field across a levelset (see
:ref:`udgasmhigh_xfem`). This a priori allows to write any interface law
easily.
+Additionally, the weak form language defines the two commands ``Xfem_plus``
and ``Xfem_minus`` allowing to take into account the jump of any field or
derivative of any field across a levelset (see :ref:`udgasmhigh_xfem`). This
a priori allows to write any interface law easily.
Note also that some procedures are available in the file
:file:`src/getfem/getfem_crack_sif.h` to compute the stress intensity factors
in 2D (restricted to homogeneous isotropic linearized elasticity).
diff git a/doc/sphinx/source/whatsnew/4.2.rst
b/doc/sphinx/source/whatsnew/4.2.rst
index b3c96c7..5b2d9bc 100644
 a/doc/sphinx/source/whatsnew/4.2.rst
+++ b/doc/sphinx/source/whatsnew/4.2.rst
@@ 1,8 +1,8 @@
.. include:: ../replaces.txt
****************************
+************************
What's New in gf 4.2
****************************
+************************
The New brick system is now mature and several coupling bricks has been
developped.
diff git a/doc/sphinx/source/whatsnew/4.3.rst
b/doc/sphinx/source/whatsnew/4.3.rst
index 29d1bd2..f0dabf0 100644
 a/doc/sphinx/source/whatsnew/4.3.rst
+++ b/doc/sphinx/source/whatsnew/4.3.rst
@@ 4,7 +4,7 @@
What's New in gf 4.3
****************************
This release is a transitional one until next version 5.0. The new highlevel
generic assembly is working and usable. However, the basic model bricks still
use the old generic assembly and the new assembly is for the moment
incompatible with a few things (Nitsche bricks and time dispatcher bricks).
+This release is a transitional one until next version 5.0. The new highlevel
generic assembly based on a weak form language is working and usable. However,
the basic model bricks still use the old generic assembly and the new assembly
is for the moment incompatible with a few things (Nitsche bricks and time
dispatcher bricks).
Released version, 2014/07/14.
@@ 14,8 +14,8 @@ The main changes are:
corresponding model bricks and the associated symbolic differentiation
which allows to describe nonlinear coupled problems in a very easy way.
 * The introduction of interpolate transformations in the new generic
 assembly to deal with the assembly of terms on different meshes
+ * The introduction of interpolate transformations in the weak form language
+ to deal with the assembly of terms on different meshes
or part of meshes.
Example of applications : mortar methods, periodic boundary conditions,
large sliding contact conditions
diff git a/doc/sphinx/source/whatsnew/5.0.rst
b/doc/sphinx/source/whatsnew/5.0.rst
index 30ade56..31059f7 100644
 a/doc/sphinx/source/whatsnew/5.0.rst
+++ b/doc/sphinx/source/whatsnew/5.0.rst
@@ 30,19 +30,18 @@ The main changes are:
* MPI and OpenMP parallelization of the highlevel generic assembly.
 * The use of mu_parser have been replaced by the use of the highlevel
 generic assembly language. mu_parser in no longer a dependence of gf.
+ * The use of mu_parser have been replaced by the use of the weak
+ form language. mu_parser in no longer a dependence of gf.
 * Add of "elementary transformations" in the highlevel generic assembly
+ * Add of "elementary transformations" in the weak form language
to allow for instance a local projection of a finite element on a lower
level element to perform a reduction such as the one used in MITC element.
 * Macro definition in the highlevel generic assembly language.
+ * Macro definition in the weak form language.
* Numerical continuation/bifurcation detection/branching improved.
 * Matrix exponential and logarithm operators added to the highlevel
 generic assembly.
+ * Matrix exponential and logarithm operators added to the weak form
language.
* Allowing the use of C++11 feature.
diff git a/doc/sphinx/source/whatsnew/5.1.rst
b/doc/sphinx/source/whatsnew/5.1.rst
index 836a52f..172768e 100644
 a/doc/sphinx/source/whatsnew/5.1.rst
+++ b/doc/sphinx/source/whatsnew/5.1.rst
@@ 4,7 +4,7 @@
What's New in gf 5.1
************************
This release consists mainly in continuing to improve the highlevel generic
assembly language and continuing the brick adaptation and development. Some
small incompatibilities are due to the replacement of simple pointers by smart
ones.
+This release consists mainly in continuing to improve the weak form language
and continuing the brick adaptation and development. Some small
incompatibilities are due to the replacement of simple pointers by smart ones.
Released version, 2016/08/18.
@@ 23,9 +23,9 @@ The main changes are:
* Addition of a local projection generic function on discontinuous fems.
 * Addition of a specific transformation allowing interelement computation
in the highlevel generic assembly language (in order to compute interelement
jump of any quantity, average value, error estimator, ...)
+ * Addition of a specific transformation allowing interelement computation
in the weak form language (in order to compute interelement jump of any
quantity, average value, error estimator, ...)
 * Addition of a specific tool (Xfem_plus, Xfem_minus) in the highlevel
generic assembly language in order to have access to the jump across an
interface when using fictitious domain tools.
+ * Addition of a specific tool (Xfem_plus, Xfem_minus) in the weak form
language in order to have access to the jump across an interface when using
fictitious domain tools.
* Extension and partial rewriting of the support for global functions as
fem basis functions. Now, storing precomputation of values, gradients and
hessians is possible also for global basis functions.
diff git a/doc/sphinx/source/whatsnew/5.2.rst
b/doc/sphinx/source/whatsnew/5.2.rst
index 7122a35..f99b860 100644
 a/doc/sphinx/source/whatsnew/5.2.rst
+++ b/doc/sphinx/source/whatsnew/5.2.rst
@@ 24,7 +24,7 @@ The main changes are:
* Import of Ansys meshes.
 * A new transformation has been added to the high level generic assembly
+ * A new transformation has been added to the weak form
language for the extrapolation on a neighbour element.
* Compatibility for Windows and Mac installation has been checked.
diff git a/doc/sphinx/source/whatsnew/5.3.rst
b/doc/sphinx/source/whatsnew/5.3.rst
new file mode 100644
index 0000000..ebc7dc1
 /dev/null
+++ b/doc/sphinx/source/whatsnew/5.3.rst
@@ 0,0 +1,21 @@
+.. include:: ../replaces.txt
+
+************************
+ What's New in gf 5.3
+************************
+
+The main contribution of this version is the extension of the language
allowing macro definition and explicit differentiation.
+
+Released version, 2018/06/19.
+
+The main changes are:
+
+ * The weak form language now supports macro with parameters
+
+ * The weak form language has been extended with Grad(expression),
+ the spatial gradient and Diff(expression, variable, direction)
+ which performs a directional derivative. A few more tensor contraction
+ operations has been added on this occasion.
+
+ * The support for pyramidal has been extended and stabilized.
+
diff git a/doc/sphinx/source/whatsnew/index.rst
b/doc/sphinx/source/whatsnew/index.rst
index 5517823..1432e66 100644
 a/doc/sphinx/source/whatsnew/index.rst
+++ b/doc/sphinx/source/whatsnew/index.rst
@@ 11,6 +11,7 @@ for anyone wishing to stay uptodate after a new release.
.. toctree::
:maxdepth: 2
+ 5.3.rst
5.2.rst
5.1.rst
5.0.rst
diff git a/extract_gmm++ b/extract_gmm++
index 88f6429..bebaa00 100755
 a/extract_gmm++
+++ b/extract_gmm++
@@ 21,7 +21,7 @@ eval 'exec perl S $0 "$@"'
$getfem_root = ".";
$MAJOR_VERSION = "5";
$MINOR_VERSION = "2";
+$MINOR_VERSION = "3";
# $DATE_VERSION = `date +%Y%m%d`;
# $DATE_VERSION = ".0";
diff git a/interface/src/python/getfem_python.c
b/interface/src/python/getfem_python.c
index e01c70e..0d77ad8 100644
 a/interface/src/python/getfem_python.c
+++ b/interface/src/python/getfem_python.c
@@ 1,6 +1,6 @@
/*===========================================================================
 Copyright (C) 20042017 Julien Pommier.
+ Copyright (C) 20042018 Julien Pommier.
This file is a part of GetFEM++
@@ 778,7 +778,7 @@ getfem_env(PyObject *self, PyObject *args) {
word_out = PyString_FromString("GetFEM++");
} else if (strcmp(word_in,"copyright") == 0) {
word_out = PyString_FromString
 ("20042017 GetFEM++ project");
+ ("20042018 GetFEM++ project");
} else if (strcmp(word_in,"authors") == 0) {
word_out = PyString_FromString
("Yves Renard, Julien Pommier");
diff git a/interface/src/python/setup.py.in b/interface/src/python/setup.py.in
index 7e79e13..d2a9016 100644
 a/interface/src/python/setup.py.in
+++ b/interface/src/python/setup.py.in
@@ 68,7 +68,7 @@ getfemmod = Extension('_getfem',
setup (name = 'getfeminterface',
license='LGPL',
 version = '5.2',
+ version = '5.3',
maintainer="Yves Renard",
maintainer_email="address@hidden",
description = "This is the getfempythoninterface module",
diff git a/src/bgeot_geometric_trans.cc b/src/bgeot_geometric_trans.cc
index 9efe400..43d1c7d 100644
 a/src/bgeot_geometric_trans.cc
+++ b/src/bgeot_geometric_trans.cc
@@ 242,7 +242,7 @@ namespace bgeot {
scalar_type a0 = A[4]*A[8]  A[5]*A[7], a1 = A[5]*A[6]  A[3]*A[8];
scalar_type a2 = A[3]*A[7]  A[4]*A[6];
scalar_type det = A[0] * a0 + A[1] * a1 + A[2] * a2;
 GMM_ASSERT1(det != scalar_type(0), "Non invertible matrix");
+ GMM_ASSERT1(det != scalar_type(0), "Non invertible matrix");
scalar_type a3 = (A[2]*A[7]  A[1]*A[8]), a6 = (A[1]*A[5]  A[2]*A[4]);
scalar_type a4 = (A[0]*A[8]  A[2]*A[6]), a7 = (A[2]*A[3]  A[0]*A[5]);
scalar_type a5 = (A[1]*A[6]  A[0]*A[7]), a8 = (A[0]*A[4]  A[1]*A[3]);
@@ 343,9 +343,9 @@ namespace bgeot {
J__ = it[0] * a0 + it[1] * a1 + it[2] * a2;
} break;
default:
 B_factors.base_resize(P, P); // store factorization for B
computation
 gmm::copy(gmm::transposed(KK), B_factors);
 ipvt.resize(P);
+ B_factors.base_resize(P, P); // store factorization for B computation
+ gmm::copy(gmm::transposed(KK), B_factors);
+ ipvt.resize(P);
bgeot::lu_factor(&(*(B_factors.begin())), ipvt, P);
J__ = bgeot::lu_det(&(*(B_factors.begin())), ipvt, P);
break;
diff git a/src/bgeot_geotrans_inv.cc b/src/bgeot_geotrans_inv.cc
index f3fb9d0..bce5378 100644
 a/src/bgeot_geotrans_inv.cc
+++ b/src/bgeot_geotrans_inv.cc
@@ 227,7 +227,8 @@ namespace bgeot
}
if (res < res0) copy(storage.x_ref, x);
 x *= 0.999888783; // For pyramid element to avoid the singularity
+ if (res < IN_EPS)
+ x *= 0.999888783; // For pyramid element to avoid the singularity
}
diff git a/src/getfem_fem_level_set.cc b/src/getfem_fem_level_set.cc
index f04a315..2b02a0f 100644
 a/src/getfem_fem_level_set.cc
+++ b/src/getfem_fem_level_set.cc
@@ 97,8 +97,7 @@ namespace getfem {
size_type s = 0, cv = c.convex_num();
for (size_type i = 0; i < dofzones.size(); ++i)
if (dofzones[i]) s += dofzones[i]>size();
 ids.resize(0); ids.resize(dofzones.size()+1, false);
 // cout << "dofzones.size() = " << dofzones.size() << endl;
+ ids.resize(0); ids.resize(s, false);
std::string z(common_ls_zones);
base_vector coeff(32);
@@ 112,7 +111,6 @@ namespace getfem {
eval.set_shift(ls>get_shift()); // Deprecated
// mesher_level_set eval = mls.get_level_set(i)>mls_of_convex(cv);

scalar_type v = eval(c.xref());
if (side != 0) {
diff git a/src/getfem_generic_assembly_compile_and_exec.cc
b/src/getfem_generic_assembly_compile_and_exec.cc
index 5a77635..7438c79 100644
 a/src/getfem_generic_assembly_compile_and_exec.cc
+++ b/src/getfem_generic_assembly_compile_and_exec.cc
@@ 4856,8 +4856,6 @@ namespace getfem {
pgai = std::make_shared<ga_instruction_transpose_test>
(pnode>tensor(), (*it)>tensor());
rmi.instructions.push_back(std::move(pgai));
 GMM_ASSERT1(false,
 "No use of X is allowed in scalar functions");
} else {
pnode>t.set_to_copy((*it)>t);
}
@@ 4867,7 +4865,7 @@ namespace getfem {
ss << "Detected wrong equivalent nodes: ";
ga_print_node(pnode, ss);
ss << " and "; ga_print_node(*it, ss);
 ss << " (no problem, but hash code would be adapted) " << endl;
+ ss << " (no problem, but hash values could be adapted) " << endl;
GMM_TRACE2(ss.str());
}
}
@@ 6836,7 +6834,6 @@ namespace getfem {
first_ind = pai>ind_first_point_on_face(v.f());
}
for (gis.ipt = 0; gis.ipt < gis.nbpt; ++(gis.ipt)) {
 // cout << "Gauss pt " << gis.ipt << endl;
if (pgp) gis.ctx.set_ii(first_ind+gis.ipt);
else gis.ctx.set_xref((*pspt)[first_ind+gis.ipt]);
if (gis.ipt == 0  !(pgt>is_linear())) {