[Getfem-commits] r4629 - in /trunk/getfem/doc/sphinx/source/userdoc: interMM.rst model.rst model_nonlinear_elasticity.rst

[Yves . Renard]

Author: renard
Date: Sun Apr 27 16:34:33 2014
New Revision: 4629

URL: http://svn.gna.org/viewcvs/getfem?rev=4629&view=rev
Log:
interpolation and nonlinear elasticity

Modified:
    trunk/getfem/doc/sphinx/source/userdoc/interMM.rst
    trunk/getfem/doc/sphinx/source/userdoc/model.rst
    trunk/getfem/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst

Modified: trunk/getfem/doc/sphinx/source/userdoc/interMM.rst
URL: 
http://svn.gna.org/viewcvs/getfem/trunk/getfem/doc/sphinx/source/userdoc/interMM.rst?rev=4629&r1=4628&r2=4629&view=diff
==============================================================================
--- trunk/getfem/doc/sphinx/source/userdoc/interMM.rst  (original)
+++ trunk/getfem/doc/sphinx/source/userdoc/interMM.rst  Sun Apr 27 16:34:33 2014
@@ -56,29 +56,31 @@
 
 It is possible to extract some arbitraries expressions on possibly several 
fields thanks to the high-level generic assembly 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)``  ...
+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.
 
 The high-level generic interpolation functions are defined in the file 
:file:`getfem/getfem_generic_assembly.h`.
 
-There are different interpolation functions corresponding to the interpolation 
on a Lagrange fem on the same mesh, the interpolation on a cloud on points or 
on a ``getfem::im_data`` object. Interpolation on a Lagrange fem::
+There is different interpolation functions corresponding to the interpolation 
on a Lagrange fem on the same mesh, the interpolation on a cloud on points or 
on a ``getfem::im_data`` object.
 
-  void ga_interpolation_Lagrange_fem(workspace, mf, result);
+Interpolation on a Lagrange fem::
 
-where ``workspace`` is a ``getfem::ga_workspace`` object which aims to store 
the different variables and data (see  :ref:`ud-gasm-high`), ``mf`` is the 
``getfem::mesh_fem`` object reresenting the Lagrange fem on which the 
interpolation is to be done and ``result`` is a ``beot::base_vector`` which 
store the interpolatin. Note that the workspace should contain the epression to 
be interpolated.::
+  void getfem::ga_interpolation_Lagrange_fem(workspace, mf, result);
 
-  void ga_interpolation_Lagrange_fem(md, expr, mf, result, 
rg=mesh_region::all_convexes());
+where ``workspace`` is a ``getfem::ga_workspace`` object which aims to store 
the different variables and data (see  :ref:`ud-gasm-high`), ``mf`` is the 
``getfem::mesh_fem`` object reresenting the Lagrange fem on which the 
interpolation is to be done and ``result`` is a ``beot::base_vector`` which 
store the interpolatin. Note that the workspace should contain the epression to 
be interpolated. ::
+
+  void getfem::ga_interpolation_Lagrange_fem(md, expr, mf, result, 
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, 
``mf`` is the ``getfem::mesh_fem`` object reresenting the Lagrange fem on which 
the interpolation is to be done, ``result`` is the vector in which the 
interpolation is stored and ``rg`` is the optional mesh region.
 
 Interpolation on a cloud of points::
 
-  void ga_interpolation_mti(md, expr, mti, result, extrapolation = 0, 
rg=mesh_region::all_convexes(), nbpoints = size_type(-1));
+  void getfem::ga_interpolation_mti(md, expr, mti, result, extrapolation = 0, 
rg=mesh_region::all_convexes(), nbpoints = size_type(-1));
 
 where ``md`` is a ``getfem::model`` object (containing the variables and 
data), ``expr`` (std::string object) is the expression to be interpolated, 
``mti`` is a ``getfem::mesh_trans_inv`` object which stores the cloud of points 
(see :file:`getfem/getfem_interpolation.h`), ``result`` is the vector in which 
the interpolation is stored, ``extrapolation`` is an option for extrapolating 
the field outside the mesh for outside points, ``rg`` is the optional mesh 
region and ``nbpoints`` is the optional maximal number of points.
 
 Interpolation on an im_data object (on the Gauss points of an integration 
method)::
 
-  void ga_interpolation_im_data(md, expr, im_data &imd,
+  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.

Modified: trunk/getfem/doc/sphinx/source/userdoc/model.rst
URL: 
http://svn.gna.org/viewcvs/getfem/trunk/getfem/doc/sphinx/source/userdoc/model.rst?rev=4629&r1=4628&r2=4629&view=diff
==============================================================================
--- trunk/getfem/doc/sphinx/source/userdoc/model.rst    (original)
+++ trunk/getfem/doc/sphinx/source/userdoc/model.rst    Sun Apr 27 16:34:33 2014
@@ -54,9 +54,9 @@
    model_mass.rst
    model_time_dispatch.rst
    model_basic_nonlinear.rst
+   model_nonlinear_elasticity.rst
    model_contact_friction.rst
    model_contact_friction_large_sliding.rst
    model_elastoplasticity.rst
-   model_nonlinear_elasticity.rst
    model_bilaplacian.rst
    model_continuation.rst

Modified: trunk/getfem/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst
URL: 
http://svn.gna.org/viewcvs/getfem/trunk/getfem/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst?rev=4629&r1=4628&r2=4629&view=diff
==============================================================================
--- trunk/getfem/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst       
(original)
+++ trunk/getfem/doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst       
Sun Apr 27 16:34:33 2014
@@ -345,9 +345,82 @@
 High-level generic assembly versions
 ++++++++++++++++++++++++++++++++++++
 
-For incompressibility ::
-
- ind = add_finite_strain_incompressibility_brick
-    (md, mim, varname, multname, region = -1);
-
-In fact this brick just add the term ``p*(1-Det(Id(meshdim)+Grad_u))`` if 
``p`` is the multiplier and ``u`` the variable which represent the displacement.
+The high-level generic assembly langage give access to the potential and 
constitutive laws of the hyperelastic constitutive laws implemented in |gf|. 
This allows to directly use them into 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 Langage nonlinear operator which could be usefull for 
nonlinear elasticity::
+
+  Det(M)                                % determinant of the matrix M
+  Trace(M)                              % trace of the matrix M
+  Matrix_i2(M)                          % second invariant of M (in 3D): 
(sqr(Trace(m)) - Trace(m*m))/2
+  Matrix_j1(M)                          % modified first invariant of M: 
Trace(m)pow(Det(m),-1/3).
+  Matrix_j2(M)                          % modified second invariant of M: 
Matrix_I2(m)*pow(Det(m),-2/3).
+  Right_Cauchy_Green(F)                 % F' * F
+  Left_Cauchy_Green(F)                  % F * F'
+  Green_Lagrangian(F)                   % (F'F - Id(meshdim))/2
+  Cauchy_stress_from_PK2(sigma, Grad_u) % 
(Id+Grad_u)*sigma*(I+Grad_u')/det(I+Grad_u)
+
+The potentials::
+
+  Saint_Venant_Kirchhoff_potential(Grad_u, [lambda; mu])
+  Plane_Strain_Saint_Venant_Kirchhoff_potential(Grad_u, [lambda; mu])
+  Generalized_Blatz_Ko_potential(Grad_u, [a;b;c;d;n])
+  Plane_Strain_Generalized_Blatz_Ko_potential(Grad_u, [a;b;c;d;n])
+  Ciarlet_Geymonat_potential(Grad_u, [lambda;mu;a])
+  Plane_Strain_Ciarlet_Geymonat_potential(Grad_u, [lambda;mu;a])
+  Incompressible_Mooney_Rivlin_potential(Grad_u, [c1;c2])
+  Plane_Strain_Incompressible_Mooney_Rivlin_potential(Grad_u, [c1;c2])
+  Compressible_Mooney_Rivlin_potential(Grad_u, [c1;c2;d1])
+  Plane_Strain_Compressible_Mooney_Rivlin_potential(Grad_u, [c1;c2;d1])
+  Incompressible_Neo_Hookean_potential(Grad_u, [c1])
+  Plane_Strain_Incompressible_Neo_Hookean_potential(Grad_u,  [c1])
+  Compressible_Neo_Hookean_potential(Grad_u,  [lambda;mu])
+  Plane_Strain_Compressible_Neo_Hookean_potential(Grad_u,  [lambda;mu])
+
+
+The second Piola-Kirchoff stress tensors::
+
+  Saint_Venant_Kirchhoff_sigma(Grad_u, [lambda; mu])
+  Plane_Strain_Saint_Venant_Kirchhoff_sigma(Grad_u, [lambda; mu])
+  Generalized_Blatz_Ko_sigma(Grad_u, [a;b;c;d;n])
+  Plane_Strain_Generalized_Blatz_Ko_sigma(Grad_u, [a;b;c;d;n])
+  Ciarlet_Geymonat_sigma(Grad_u, [lambda;mu;a])
+  Plane_Strain_Ciarlet_Geymonat_sigma(Grad_u, [lambda;mu;a])
+  Incompressible_Mooney_Rivlin_sigma(Grad_u, [c1;c2])
+  Plane_Strain_Incompressible_Mooney_Rivlin_sigma(Grad_u, [c1;c2])
+  Compressible_Mooney_Rivlin_sigma(Grad_u, [c1;c2;d1])
+  Plane_Strain_Compressible_Mooney_Rivlin_sigma(Grad_u, [c1;c2;d1])
+  Incompressible_Neo_Hookean_sigma(Grad_u, [c1])
+  Plane_Strain_Incompressible_Neo_Hookean_sigma(Grad_u, [c1])
+  Compressible_Neo_Hookean_sigma(Grad_u,  [lambda;mu])
+  Plane_Strain_Compressible_Neo_Hookean_sigma(Grad_u,  [lambda;mu])
+
+
+Note that for the derivative with respect to the parameters has not been 
implemented apart for the Saint Venant Kirchhoff hyperelastic law. So that it 
is not possible to make the parameter depend on other variables of a model 
(derivatives are not necessary complicated to implement but for the moment, 
only a wrapper with old implementations has been written).
+
+Note that the coupling of models it to be done at the weak formulation level. 
In a general way, it is recommended not to use the potential to define a 
problem. Two reasons are first that the second order derivative of the 
potential  (necessary to obtain the tangent system) can be very complicated and 
non-optimized and main couplings cannot be obtained at the potential level. 
Thus the use of potential should be restricted to the actual computation of the 
potential.
+
+An example of use to add a  Saint Venant-Kirchhoff hyperelastic term to a 
variable ``u`` in a model or a ga_workspace is given by the addition of the 
following assembly string::
+
+  
"((Id(meshdim)+Grad_u)*(Saint_Venant_Kirchhoff_sigma(Grad_u,[lambda;mu]))):Grad_Test_u"
+
+Note that in that case, ``lambda`` and ``mu`` have to be declared data of the 
model/ga_workspace. It is of course possible to replace them by explicit 
constants or expressions depending on several data.
+
+Concerning the incompressible Mooney-Rivlin law, it has to be completed by a 
incompressibility term. For instance by adding the following incompressibility 
brick::
+
+ ind = add_finite_strain_incompressibility_brick(md, mim, varname, multname, 
region = -1);
+
+This brick just add the term ``p*(1-Det(Id(meshdim)+Grad_u))`` if ``p`` is the 
multiplier and ``u`` the variable which represent the displacement.
+
+The addition to an hyperelastic term to a model can also be done thanks to the 
following function::
+
+  ind = add_finite_strain_elasticity_brick(md, mim, varname, lawname, params,
+                                           region = size_type(-1));
+
+where ``md`` is the model, ``mim`` the integration method, ``varname`` the 
variable of the model representing the large strain displacement, ``lawname`` 
is the constitutive law name which could be ``Saint_Venant_Kirchhoff``, 
``Generalized_Blatz_Ko``, ``Ciarlet_Geymonat``, 
``Incompressible_Mooney_Rivlin``, ``Compressible_Mooney_Rivlin``, 
``Incompressible_Neo_Hookean_sigma`` or ``Compressible_Neo_Hookean_sigma``, 
``params`` is a string representing the parameters of the law. It should 
represent a small vector or vetor field.
+
+The Von Mises stress can be interpolated with the following function::
+
+  void finite_strain_elasticity_Von_Mises(md, varname, lawname, params, mf_vm, 
VM,
+                                          rg=mesh_region::all_convexes());
+
+where ``md`` is the model, ``varname`` the variable of the model representing 
the large strain displacement, ``lawname`` is the constitutive law name (see 
previou brick), ``params`` is a string representing the parameters of the law, 
``mf_vm`` a (preferably discontinuous) Lagrange  finite element method on which 
the interpolation will be done and ``VM`` a vector of type 
``model_real_plain_vector`` in which the interpolation will be stored.