[Getfem-commits] [getfem-commits] branch master updated: introducing the acronym GWFL in the documentation

[Yves Renard]

This is an automated email from the git hooks/post-receive script.

renard pushed a commit to branch master
in repository getfem.

The following commit(s) were added to refs/heads/master by this push:
     new a5c4b83  introducing the acronym GWFL in the documentation
     new 958610c  Merge branch 'master' of ssh://git.sv.gnu.org:/srv/git/getfem
a5c4b83 is described below

commit a5c4b83dd48d99657ba7d942c8ce82e278592cb5
Author: Yves Renard <address@hidden>
AuthorDate: Fri Mar 27 11:39:56 2020 +0100

    introducing the acronym GWFL in the documentation
---
 .../source/project/libdesc_high_gen_assemb.rst     |  6 ++--
 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            | 36 +++++++++++-----------
 doc/sphinx/source/userdoc/hho.rst                  | 10 +++---
 doc/sphinx/source/userdoc/interMM.rst              |  6 ++--
 doc/sphinx/source/userdoc/interNMM.rst             |  7 +++--
 doc/sphinx/source/userdoc/model_Mindlin_plate.rst  |  4 +--
 doc/sphinx/source/userdoc/model_Nitsche.rst        | 12 ++++----
 .../model_contact_friction_large_sliding.rst       | 14 ++++-----
 doc/sphinx/source/userdoc/model_fourier_robin.rst  |  2 +-
 .../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 +-
 19 files changed, 67 insertions(+), 66 deletions(-)

diff --git a/doc/sphinx/source/project/libdesc_high_gen_assemb.rst 
b/doc/sphinx/source/project/libdesc_high_gen_assemb.rst
index fddcc42..4623e0a 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 high-level generic assembly module in |gf|
 Description
 ^^^^^^^^^^^
 
-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:`ud-gasm-high`.
+The high level generic assembly module of |gf| and its generic weak form 
language (GWFL) 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:`ud-gasm-high`.
 
 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_function_and_operators.h` and 
:file:`getfem_generic_assembly_function_and_operators.cc`, "Definition of 
redefined function and nonlinear operator of the weak form language."
+   :file:`getfem_generic_assembly_function_and_operators.h` and 
:file:`getfem_generic_assembly_function_and_operators.cc`, "Definition of 
redefined function and nonlinear operator of GWFL."
    :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| weak form language 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 GWFL 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/tutorial/basic_usage.rst 
b/doc/sphinx/source/tutorial/basic_usage.rst
index d199286..8fcfd10 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 weak form language (see 
:ref:`ud-gasm-high` for more details on the syntax of the weak form language), 
you can use predefined bricks for standard terms : generic elliptic term, 
linearized or finite strain elasticity, standard boundary conditions ...
+Note that instead of defining your pde terms with GWFL, the generic weak form 
language (see :ref:`ud-gasm-high` for more details on the syntax of the weak 
form language), you can use predefined bricks for standard terms : generic 
elliptic 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 4192595..cfb1434 100644
--- a/doc/sphinx/source/tutorial/thermo_coupling.rst
+++ b/doc/sphinx/source/tutorial/thermo_coupling.rst
@@ -527,7 +527,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 the |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 non-constant 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)"`.
+to the tangent linear system. In order to use this model brick, the data 
corresponding to the |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 non-constant data. Note also that instead of using this 
predefined brick, one can use equivalently GWFL, the generic 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
 
@@ -535,7 +535,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 weak form language term 
`add_linear_term(md mim, "beta*theta*Div_Test_u)"`. See :ref:`ud-gasm-high` 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.
+there is no predefined brick and we use directly a GWFL term 
`add_linear_term(md mim, "beta*theta*Div_Test_u)"`. See :ref:`ud-gasm-high` for 
more details on GWFL. 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:`ud-model-Dirichlet`).
 
@@ -611,7 +611,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 weak form language terms.
+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 GWFL terms.
 
 .. tabularcolumns:: |p{0.080\linewidth}|p{0.900\linewidth}|
 
diff --git a/doc/sphinx/source/tutorial/wheel.rst 
b/doc/sphinx/source/tutorial/wheel.rst
index 09d5a72..92c740d 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 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:`ud-gasm-hi [...]
+As a consequence, it will be possible to use this transformation, from the 
mesh of the wheel to the mesh of the foundation, into GWFL 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:`ud-gasm-high-transf` for [...]
 
 Using the defined transformation, we can write an integral contact condition 
using an augmented Lagrangian formulation (see :ref:`ud-model-contact-friction` 
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 weak form language, the contact condition can be added by:
+Using GWFL, the contact condition can be added by:
 
 .. code-block:: 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 weak form language:
+This could be added to the model with GWFL:
 
 .. code-block:: python
 
diff --git a/doc/sphinx/source/userdoc/gasm_high.rst 
b/doc/sphinx/source/userdoc/gasm_high.rst
index 6200a04..a0eeca4 100644
--- a/doc/sphinx/source/userdoc/gasm_high.rst
+++ b/doc/sphinx/source/userdoc/gasm_high.rst
@@ -8,10 +8,10 @@
 
 .. _ud-gasm-high:
 
-Compute arbitrary terms - high-level generic assembly procedures - Weak-form 
language
-=====================================================================================
+Compute arbitrary terms - high-level generic assembly procedures - Generic 
Weak-Form Language (GWFL)
+====================================================================================================
 
-This section presents what is now the main generic assembly of |gf|. It is a 
high-level 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 low-level generic assembly (see  
:ref:`ud-gasm-low`) for which nonlinear terms were quite difficult to describe. 
Conversely, a symbolic differentiation algorith [...]
+This section presents what is now the main generic assembly of |gf|. It is a 
high-level generic assembly in the sense that it is based on Generic Weak Form 
Language (GWFL) 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 low-level generic assembly (see  
:ref:`ud-gasm-low`) for which nonlinear terms were quite difficult to describe. 
Conversely, a symbolic differentia [...]
 
 The header file to be included to use the high-level generic assembly 
procedures in C++ is :file:`getfem/generic\_assembly.h`.
 
@@ -21,8 +21,8 @@ For basic linear assembly terms, the high level generic 
assembly is most of the
 
 
 
-Overview of the weak form language syntax
------------------------------------------
+Overview of GWFL
+----------------
 
 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:
 
@@ -368,7 +368,7 @@ For the use with Python, Scilab or Matlab interfaces, see 
the respective documen
 The tensors
 -----------
 
-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 [...]
+Basically, what is manipulated in GWFL 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 computations. When a [...]
 
 Order four tensors are necessary for instance to express elasticity tensors or 
in general to obtain the tangent term for vector valued unknowns.
 
@@ -439,7 +439,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 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 [...]
+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 
GWFL 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 
derivatives with respect to ``t [...]
 
 
 Additionally,::
@@ -511,7 +511,7 @@ Parentheses can be used in a standard way to change the 
operation order. If no p
 Explicit vectors
 ----------------
 
-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 [...]
+GWFL 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 respect to the test  [...]
 
 
 Explicit matrices
@@ -586,7 +586,7 @@ The four operators can be applied on test functions. Which 
means that for instan
 Nonlinear operators
 -------------------
 
-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.
+GWFL provides 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.
 
@@ -617,7 +617,7 @@ The weak form language provide some predefined nonlinear 
operator. Each nonlinea
 Macro definition
 ----------------
 
-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::
+GWFL 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)
 
@@ -629,7 +629,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 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::
+where ``name`` is he macro name which then can be used in GWFL and contains 
also the macro parameters, ``expr`` is a valid expression of GWFL (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)]");
 
@@ -730,7 +730,7 @@ or::
   add_interpolate_transformation_from_expression
     (model, transname, source_mesh, target_mesh, expr);
 
-where ``workspace`` is a workspace object, ``model`` 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 
high-level generic weak form language which may contains reference to the 
variables of the workspace/model.
+where ``workspace`` is a workspace object, ``model`` 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 GWFL which 
may contains reference to the variables of the workspace/model.
 
 For instance, an expression::
 
@@ -770,7 +770,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:`ud-model-contact-friction_raytrace_inter_trans` for the differentiation 
between rigid bodies and deformable ones in the 
Raytracing_interpolate_transformation) the transformation returns an integer 
identifier to the weak form language. A value 0 of this identifier 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:`ud-model-contact-friction_raytrace_inter_trans` for the differentiation 
between rigid bodies and deformable ones in the 
Raytracing_interpolate_transformation) the transformation returns an integer 
identifier to the weak form language. A value 0 of this identifier means t [...]
 
   Interpolate_filter(transname, expr, i)
 
@@ -860,7 +860,7 @@ where :math:`k(x,y)` is a given kernel, :math:`u` a 
quantity defined on :math:`\
 CAUTION: Of course, this kind of term have to be used with great care, since 
it naturally leads to fully populated stiffness or tangent matrices.
 
 
-The weak form language of |gf| furnishes a mechanism to compute such a term. 
First, the secondary domain has to be declared in the workspace/model with its 
integration methods. The addition of a standard secondary domain can be done 
with one of the two following functions::
+GWFL furnishes a mechanism to compute such a term. First, the secondary domain 
has to be declared in the workspace/model with its integration methods. The 
addition of a standard secondary domain can be done with one of the two 
following functions::
 
   add_standard_secondary_domain(model, domain_name, mim, region);
 
@@ -868,7 +868,7 @@ The weak form language of |gf| furnishes a mechanism to 
compute such a term. Fir
 
 where ``model`` or ``workspace`` is the model or workspace where the secondary 
domain has to be declared, ``domain_name`` is a string for the identification 
of this domain together with the mesh region and integration method, ``mim`` 
the integration method and ``region`` a mesh region. Note that with these 
standard secondary domains, the integration is done on the whole region for 
each element of the primary domain. It can be interesting to implement specific 
secondary domains restrictin [...]
 
-Once a secondary domain has been declared, it can be specified that a weak 
form language expression has to be assembled on the direct product of a current 
domain and a secondary domain, adding the name of the secondary domain to the 
``add_expression`` method of the workspace object or using 
``add_linear_twodomain_term``, ``add_nonlinear_twodomain_term`` or 
``add_twodomain_source_term`` functions::
+Once a secondary domain has been declared, it can be specified that a GWFL 
expression has to be assembled on the direct product of a current domain and a 
secondary domain, adding the name of the secondary domain to the 
``add_expression`` method of the workspace object or using 
``add_linear_twodomain_term``, ``add_nonlinear_twodomain_term`` or 
``add_twodomain_source_term`` functions::
 
   workspace.add_expression(expr, mim, region, derivative_order, 
secondary_domain)
   add_twodomain_source_term(model, mim, expr, region, secondary_domain)
@@ -878,7 +878,7 @@ Once a secondary domain has been declared, it can be 
specified that a weak form
 For the utilisation with the Python/Scilab/Matlab interface, see the 
documentation on ``gf_asm`` command and the ``model`` object.
 
 
-Inside an expression of the weak form language, one can refer to the unit 
normal vector to a boundary, to the current position or to the value of a 
variable thanks to the expressions::
+Inside an expression of GWFL, one can refer to the unit normal vector to a 
boundary, to the current position or to the value of a variable thanks to the 
expressions::
 
   Secondary_domain(Normal)
   Secondary_domain(X)
@@ -920,7 +920,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 weak form 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 GWFL::
 
   Elementary_transformation(u, transname[, dest])
   Elementary_transformation(Grad_u, transname[, dest])
@@ -954,7 +954,7 @@ Some other transformations are available for the use into 
Hybrid High-Order meth
 Xfem discontinuity evaluation (with mesh_fem_level_set)
 -------------------------------------------------------
 
-When using a fem cut by a level-set (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::
+When using a fem cut by a level-set (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, GWFL 
furnishes the following expressions for ``u`` a FEM variable::
 
   Xfem_plus(u)
   Xfem_plus(Grad_u)
diff --git a/doc/sphinx/source/userdoc/hho.rst 
b/doc/sphinx/source/userdoc/hho.rst
index b7296ce..de3a735 100644
--- a/doc/sphinx/source/userdoc/hho.rst
+++ b/doc/sphinx/source/userdoc/hho.rst
@@ -50,7 +50,7 @@ In order to be used, the elementary transformation 
corresponding to this operato
 
   add_HHO_reconstructed_gradient(model, transname);
 
-where ``transname`` is an arbitrary name which will designate the 
transformation in the weak form language. Then, it will be possible to refer to 
the reconstructed gradient of a variable ``u`` into the weak form language as 
``Elementary_transformation(u, HHO_grad, Gu)``, if ``transname="HHO_grad"``. 
The third parameter of the transformation ``Gu`` should be a fem variable or a 
data of the model. This variable will not be used on itself but will determine 
the finite element space of the r [...]
+where ``transname`` is an arbitrary name which will designate the 
transformation in GWFL (the generic weak form language). Then, it will be 
possible to refer to the reconstructed gradient of a variable ``u`` into GWFL 
as ``Elementary_transformation(u, HHO_grad, Gu)``, if ``transname="HHO_grad"``. 
The third parameter of the transformation ``Gu`` should be a fem variable or a 
data of the model. This variable will not be used on itself but will determine 
the finite element space of the reco [...]
 
 This is an example of use with the Python interface for a two-dimensional 
triangule mesh ``m`` ::
 
@@ -87,7 +87,7 @@ The elementary transformation corresponding to this operator 
can be added to the
 
   add_HHO_reconstructed_symmetrized_gradient(model, transname);
 
-and then be used into the weak form language as ``Elementary_transformation(u, 
HHO_sym_grad, Gu)``, if ``transname="HHO_sym_grad"``, with ``Gu`` still 
determining the reconstruction space.
+and then be used into GWFL as ``Elementary_transformation(u, HHO_sym_grad, 
Gu)``, if ``transname="HHO_sym_grad"``, with ``Gu`` still determining the 
reconstruction space.
 
 Reconstructed variable
 ++++++++++++++++++++++
@@ -107,7 +107,7 @@ The corresponding elementary transformation can be added to 
the model by the com
 
   add_HHO_reconstructed_value(model, transname);
 
-and used into the weak form language as ``Elementary_transformation(u, 
HHO_val, ud)``, if ``transname="HHO_val"``, with ``ud`` determining the 
reconstruction space.
+and used into GWFL as ``Elementary_transformation(u, HHO_val, ud)``, if 
``transname="HHO_val"``, with ``ud`` determining the reconstruction space.
 
 Reconstructed variable with symmetrized gradient
 ++++++++++++++++++++++++++++++++++++++++++++++++
@@ -131,7 +131,7 @@ The corresponding elementary transformation can be added to 
the model by the com
 
   add_HHO_reconstructed_value(model, transname);
 
-and used into the weak form language as ``Elementary_transformation(u, 
HHO_val, ud)``, if ``transname="HHO_val"``, with ``ud`` determining the 
reconstruction space.
+and used into GWFL as ``Elementary_transformation(u, HHO_val, ud)``, if 
``transname="HHO_val"``, with ``ud`` determining the reconstruction space.
 
 
 Stabilization operators
@@ -154,4 +154,4 @@ The corresponding elementary transformations can be added 
to the model by the tw
   add_HHO_stabilization(model, transname);
   add_HHO_symmetrized_stabilization(model, transname);
 
-and used into the weak form language as ``Elementary_transformation(u, 
HHO_stab)``, if ``transname="HHO_stab"``. A third argument is optional to 
specify the target (HHO) space (the default is one of the variable itself). An 
example of use is also given in the test programs 
:file:`interface/tests/demo_laplacian_HHO.py` and 
:file:`interface/tests/demo_elasticity_HHO.py`.
+and used into GWFL as ``Elementary_transformation(u, HHO_stab)``, if 
``transname="HHO_stab"``. A third argument is optional to specify the target 
(HHO) space (the default is one of the variable itself). An example of use is 
also given in the test programs :file:`interface/tests/demo_laplacian_HHO.py` 
and :file:`interface/tests/demo_elasticity_HHO.py`.
diff --git a/doc/sphinx/source/userdoc/interMM.rst 
b/doc/sphinx/source/userdoc/interMM.rst
index 895d807..2523719 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 high-level weak form language
-********************************************************
+Interpolation based on the generic weak form language (GWFL)
+************************************************************
 
-It is possible to extract some arbitrary expressions on possibly several 
fields thanks to the weak form language and the interpolation functions.
+It is possible to extract some arbitrary expressions on possibly several 
fields thanks to GWFL 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.
 
diff --git a/doc/sphinx/source/userdoc/interNMM.rst 
b/doc/sphinx/source/userdoc/interNMM.rst
index d4ad5ee..9ca561f 100644
--- a/doc/sphinx/source/userdoc/interNMM.rst
+++ b/doc/sphinx/source/userdoc/interNMM.rst
@@ -53,8 +53,9 @@ mixed methods with different meshes
 -----------------------------------
 Instead of using the previous tools (interpolated and projected fems), it is
 possible to use a finite element variable defined on an another mesh than the 
one
-on which an assembly is computed using the "interpolate transformation" tool of
-the weak form language (see :ref:`ud-gasm-high-transf` ), the finite element
+on which an assembly is computed using the "interpolate transformation" tool
+of GWFL (the generic weak form language, see :ref:`ud-gasm-high-transf` ),
+the finite element
 variables will be interpolated on each Gauss point. There is no restriction
 on the dimensions of the mesh used, which means in particular that a
 two-dimensional fem variable can be interpolated on a one-dimensional mesh
@@ -67,4 +68,4 @@ mortar methods
 --------------
 Mortar methods are supported by |gf|. The coupling term between non matching
 meshes can in particular be computed using the interpolate transformations of
-the weak form language (see :ref:`ud-gasm-high-transf`).
+GWFL (see :ref:`ud-gasm-high-transf`).
diff --git a/doc/sphinx/source/userdoc/model_Mindlin_plate.rst 
b/doc/sphinx/source/userdoc/model_Mindlin_plate.rst
index 35aac80..b638177 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 weak form language (see :ref:`ud-gasm-high-elem-trans`) 
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 GWFL, the generic weak form language (see 
:ref:`ud-gasm-high-elem-trans`) 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 weak form language, the parameter can be regular expression of this 
language.
+uses GWFL, 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 b0bee0e..afdbc3d 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 (weak form 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 a GWFL (generic weak form language) 
expression.
 
 These expressions are utilized in a special method of the model object::
 
@@ -80,7 +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 weak form language. This term can be 
obtained with
+described as an expression of GWFL. 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
@@ -109,7 +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 weak form language. This term can be 
obtained with
+described as an expression of GWFL. 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
@@ -139,7 +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 weak form language. This term can be 
obtained with
+described as an expression of GWFL. 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.
@@ -192,7 +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 weak form language. This term can be 
obtained with
+described as an expression of GWFL. 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
@@ -206,7 +206,7 @@ method which is conditionally coercive for  `gamma0` small.
 inconditionally 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 weak form language.
+coefficient which could be any expression of GWFL.
 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 ff67172..8a05d5f 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 weak form language. Some 
interpolate transformations (see :ref:`ud-gasm-high-transf`) 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 [...]
+The basic tools to deal with large sliding/large deformation contact of 
deformable structures are accessible in GWFL (the generic weak form language). 
Some interpolate transformations (see :ref:`ud-gasm-high-transf`) 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 a [...]
 
 Of course, the computational cost of large sliding/large deformation contact 
algorithms is greatly higher than small sliding-small 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 weak form 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 GWFL 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 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.
+where ``expr`` is the expression of a signed distance to the obstacle using 
the syntax of GWFL (``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 non-contact situations and the occurence of a 
contact with another deformable body or with a rigid obstacle, the 
transformation returns an integer identifier which can be used by the 
`Interpolate_filter` command of the weak form language (see 
:ref:`ud-gasm-high-transf`). The different values:
+In order to distinguish between non-contact situations and the occurence of a 
contact with another deformable body or with a rigid obstacle, the 
transformation returns an integer identifier which can be used by the 
`Interpolate_filter` command of GWFL (see :ref:`ud-gasm-high-transf`). 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 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.
+in GWFL, 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 high-level generic assembly for contact with friction
 ******************************************************************
 
-The following nonlinear operators are defined in the weak form language (see 
:ref:`ud-gasm-high`):
+The following nonlinear operators are defined in GWFL (see 
:ref:`ud-gasm-high`):
 
   - ``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,4 +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 weak form 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 GWFL (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 8bd1ddf..71e90eb 100644
--- a/doc/sphinx/source/userdoc/model_fourier_robin.rst
+++ b/doc/sphinx/source/userdoc/model_fourier_robin.rst
@@ -35,7 +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 weak form 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 GWFL, the generic 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 eed8097..8737faf 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 weak form language described in Section :ref:`ud-gasm-high`. 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 GWFL, the generic weak form language described in Section 
:ref:`ud-gasm-high`. 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 pre-defined constant of the model 
representing the right hand s
 
 
 
-Note that for the moment, the use of the weak form language is not possible 
for complex valued problems.
+Note that for the moment, the use of GWFL 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 625ae2c..f7ff106 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 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)
+It adds a term with an arbitrary coefficient given by the expression 
``dataexpr`` which has to be a regular expression of GWFL, the generic 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 1771bc0..de20651 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
 High-level generic assembly versions
 ++++++++++++++++++++++++++++++++++++
 
-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).
+The generic weak form language (GWFL) 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 e5308df..c9de38e 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 weak form language (such as "1/2",
+valid expression of GWFL, the generic 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 0dc0653..14f8e6b 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 weak form 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 GWFL, the generic 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 20963a8..7157fc7 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 one-step schemes (for the moment, only 
one-step schemes are provided), only the previous time step is stored. For 
instance if `u` is a variable (thus represented at step n), `Previous_u`, 
`Previous2_u`, `Previous3_u` will be the data representing the state of the 
variable at the previous time step (step n-1, n-2 and n-3).
 
-* 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 [...]
+* 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 GWFL, the generic 
weak form language. However, these are not considered to be independent 
variables, they will be linked to t [...]
 
 * 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 
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 data `t` represent the time parameter and can be used (either in GWFL 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 weak form 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 GWFL of the problem
 
   .. math::
 
@@ -263,7 +263,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 weak form 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 GWFL, the term:
 
 .. math::
 
diff --git a/doc/sphinx/source/userdoc/xfem.rst 
b/doc/sphinx/source/userdoc/xfem.rst
index 1224a04..906c65f 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 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 level-set (see :ref:`ud-gasm-high_xfem`). This 
a priori allows to write any interface law easily.
+Additionally, GWFL, the generic 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 level-set (see 
:ref:`ud-gasm-high_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).