[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Getfem-commits] (no subject)
|
From: |
khalil MANSOURI |
|
Subject: |
[Getfem-commits] (no subject) |
|
Date: |
Fri, 19 Jul 2019 14:01:09 -0400 (EDT) |
branch: origin/devel-khalil-enit
commit a31ead1b2dbfd262d8c958542288b8a7d8a265f5
Author: Khalil MANSOURI <address@hidden>
Date: Fri Jul 19 18:43:37 2019 +0100
Work in Progress 3D Crack
---
contrib/3D_Crack/Makefile.am | 37 +
contrib/3D_Crack/crack_3D | Bin 0 -> 10116264 bytes
contrib/3D_Crack/crack_3D.cc | 1087 ++++++++++++++++
contrib/3D_Crack/crack_3D.param | 133 ++
contrib/3D_Crack/crack_3D.pl | 16 +
contrib/3D_Crack/crack_3D_exact_solution.cc | 306 +++++
contrib/3D_Crack/crack_3D_exact_solution.h | 94 ++
contrib/3D_Crack/getfem_Xfem.cc | 196 +++
contrib/3D_Crack/getfem_Xfem.h | 127 ++
contrib/3D_Crack/getfem_spider_fem.h | 255 ++++
contrib/3D_Crack/untitled.geo | 9 +
getfem.config | 2 +
getfem.creator | 1 +
getfem.files | 1877 +++++++++++++++++++++++++++
getfem.includes | 20 +
15 files changed, 4160 insertions(+)
diff --git a/contrib/3D_Crack/Makefile.am b/contrib/3D_Crack/Makefile.am
new file mode 100644
index 0000000..2079a80
--- /dev/null
+++ b/contrib/3D_Crack/Makefile.am
@@ -0,0 +1,37 @@
+# Copyright (C) 1999-2017 Yves Renard
+#
+# This file is a part of GetFEM++
+#
+# GetFEM++ is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version along with the GCC Runtime Library
+# Exception either version 3.1 or (at your option) any later version.
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+# License and GCC Runtime Library Exception for more details.
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+# SUBDIRS =
+
+check_PROGRAMS = \
+ crack_3D
+CLEANFILES =
+
+crack_3D_SOURCES = crack_3D.cc crack_3D_exact_solution.cc
crack_3D_exact_solution.h getfem_Xfem.cc getfem_spider_fem.h getfem_Xfem.h
+
+
+AM_CPPFLAGS = -I$(top_srcdir)/src -I../../src
+LDADD = ../../src/libgetfem.la -lm @SUPLDFLAGS@
+
+TESTS = \
+ crack_3D.pl
+
+EXTRA_DIST = \
+ crack_3D.param
+
+
+LOG_COMPILER = perl
diff --git a/contrib/3D_Crack/crack_3D b/contrib/3D_Crack/crack_3D
new file mode 100755
index 0000000..9fc7420
Binary files /dev/null and b/contrib/3D_Crack/crack_3D differ
diff --git a/contrib/3D_Crack/crack_3D.cc b/contrib/3D_Crack/crack_3D.cc
new file mode 100644
index 0000000..ef82eb8
--- /dev/null
+++ b/contrib/3D_Crack/crack_3D.cc
@@ -0,0 +1,1087 @@
+/*===========================================================================
+
+ Copyright (C) 2002-2017 Yves Renard, Julien Pommier.
+
+ This file is a part of GetFEM++
+
+ GetFEM++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version along with the GCC Runtime Library
+ Exception either version 3.1 or (at your option) any later version.
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License and GCC Runtime Library Exception for more details.
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+===========================================================================*/
+
+/**
+ * Linear Elastostatic problem with a crack.
+ *
+ * This program is used to check that getfem++ is working. This is also
+ * a good example of use of GetFEM++.
+ */
+
+#include "getfem/getfem_assembling.h" /* import assembly methods (and norms
comp.) */
+#include "getfem/getfem_export.h" /* export functions (save solution in a
file) */
+#include "getfem/getfem_derivatives.h"
+#include "getfem/getfem_regular_meshes.h"
+#include "getfem/getfem_model_solvers.h"
+#include "getfem/getfem_mesh_im_level_set.h"
+#include "getfem/getfem_mesh_fem_level_set.h"
+#include "getfem/getfem_mesh_fem_product.h"
+#include "getfem/getfem_mesh_fem_global_function.h"
+#include "getfem_spider_fem.h"
+#include "getfem/getfem_mesh_fem_sum.h"
+#include "gmm/gmm.h"
+#include "gmm/gmm_inoutput.h"
+
+#include "crack_3D_exact_solution.h"
+
+using std::endl; using std::cout; using std::cerr;
+using std::ends; using std::cin;
+
+/* definition of some matrix/vector types. These ones are built
+ * using the predefined types in Gmm++
+ */
+typedef getfem::modeling_standard_sparse_vector sparse_vector;
+typedef getfem::modeling_standard_sparse_matrix sparse_matrix;
+typedef getfem::modeling_standard_plain_vector plain_vector;
+
+/**************************************************************************/
+/* Structure for the crack problem. */
+/**************************************************************************/
+
+struct crack_problem {
+
+ enum { DIRICHLET_BOUNDARY_NUM = 0, NEUMANN_BOUNDARY_NUM = 1,
NEUMANN_BOUNDARY_NUM1=2, NEUMANN_HOMOGENE_BOUNDARY_NUM=3,
MORTAR_BOUNDARY_IN=42, MORTAR_BOUNDARY_OUT=43};
+ getfem::mesh mesh; /* the mesh */
+ getfem::mesh_level_set mls; /* the integration methods. */
+ getfem::mesh_im_level_set mim; /* the integration methods. */
+ getfem::mesh_fem mf_pre_u, mf_pre_mortar;
+ getfem::mesh_fem mf_mult;
+ getfem::mesh_fem_level_set mfls_u, mfls_mortar;
+ getfem::mesh_fem_global_function mf_sing_u;
+ getfem::mesh_fem mf_partition_of_unity;
+ getfem::mesh_fem_product mf_product;
+ getfem::mesh_fem_sum mf_u_sum;
+
+ getfem::mesh interpolated_m;
+ getfem::mesh_fem interpolated_mf;
+
+ base_small_vector translation;
+
+ struct spider_param {
+ std::unique_ptr<getfem::spider_fem> fem;
+ scalar_type theta0;
+ scalar_type radius;
+ unsigned Nr;
+ unsigned Ntheta;
+ int K;
+ int bimat_enrichment;
+ scalar_type epsilon;
+ };
+
+ spider_param spider;
+
+ getfem::mesh_fem mf_us;
+
+ getfem::mesh_fem& mf_u() { return mf_u_sum; }
+ // getfem::mesh_fem& mf_u() { return mf_us; }
+
+ scalar_type lambda, mu; /* Lame coefficients. */
+ getfem::mesh_fem mf_rhs; /* mesh_fem for the right hand side (f(x),..) */
+ getfem::mesh_fem mf_p; /* mesh_fem for the pressure for mixed form */
+#ifdef VALIDATE_XFEM
+ crack_exact_solution exact_sol;
+#endif
+
+
+ int bimaterial; /* For bimaterial interface fracture */
+ double lambda_up, lambda_down, mu_up, mu_down; /*Lame coeff for bimaterial
case*/
+ getfem::level_set ls; /* The two level sets defining the crack. */
+ getfem::level_set ls2, ls3; /* The two level-sets defining the add. cracks.*/
+
+ scalar_type residual; /* max residual for the iterative solvers */
+ bool mixed_pressure, add_crack;
+ unsigned dir_with_mult;
+ scalar_type cutoff_radius, cutoff_radius1, cutoff_radius0, enr_area_radius;
+
+ size_type cutoff_func;
+
+ typedef enum { NO_ENRICHMENT=0,
+ FIXED_ZONE=1,
+ GLOBAL_WITH_MORTAR=2,
+ GLOBAL_WITH_CUTOFF=3,
+ SPIDER_FEM_ALONE=4,
+ SPIDER_FEM_ENRICHMENT=5 } enrichment_option_enum;
+ enrichment_option_enum enrichment_option;
+
+ std::string datafilename;
+
+ int reference_test;
+ std::string GLOBAL_FUNCTION_MF, GLOBAL_FUNCTION_U;
+
+ bgeot::md_param PARAM;
+
+ bool solve(plain_vector &U);
+ void init(void);
+ crack_problem(void) : mls(mesh), mim(mls),
+ mf_pre_u(mesh), mf_pre_mortar(mesh), mf_mult(mesh),
+ mfls_u(mls, mf_pre_u), mfls_mortar(mls, mf_pre_mortar),
+ mf_sing_u(mesh),
+ mf_partition_of_unity(mesh),
+ mf_product(mf_partition_of_unity, mf_sing_u),
+ mf_u_sum(mesh), interpolated_mf(interpolated_m),
+ mf_us(mesh), mf_rhs(mesh), mf_p(mesh),
+#ifdef VALIDATE_XFEM
+ exact_sol(mesh),
+#endif
+ ls(mesh, 1, true), ls2(mesh, 1, true),
+ ls3(mesh, 1, true) {}
+
+};
+
+std::string name_of_dof(getfem::pdof_description dof) {
+ char s[200];
+ sprintf(s, "UnknownDof[%p]", (void*)dof);
+ for (dim_type d = 0; d < 4; ++d) {
+ if (dof == getfem::lagrange_dof(d)) {
+ sprintf(s, "Lagrange[%d]", d); goto found;
+ }
+ if (dof == getfem::normal_derivative_dof(d)) {
+ sprintf(s, "D_n[%d]", d); goto found;
+ }
+ if (dof == getfem::global_dof(d)) {
+ sprintf(s, "GlobalDof[%d]", d);
+ }
+ if (dof == getfem::mean_value_dof(d)) {
+ sprintf(s, "MeanValue[%d]", d);
+ }
+ if (getfem::dof_xfem_index(dof) != 0) {
+ sprintf(s, "Xfem[idx:%d]", int(dof_xfem_index(dof)));
+ }
+
+ for (dim_type r = 0; r < d; ++r) {
+ if (dof == getfem::derivative_dof(d, r)) {
+ sprintf(s, "D_%c[%d]", "xyzuvw"[r], d); goto found;
+ }
+ for (dim_type t = 0; t < d; ++t) {
+ if (dof == getfem::second_derivative_dof(d, r, t)) {
+ sprintf(s, "D2%c%c[%d]", "xyzuvw"[r], "xyzuvw"[t], d);
+ goto found;
+ }
+ }
+ }
+ }
+ found:
+ return s;
+}
+
+
+/* Read parameters from the .param file, build the mesh, set finite element
+ * and integration methods and selects the boundaries.
+ */
+void crack_problem::init(void) {
+ std::string MESH_TYPE = PARAM.string_value("MESH_TYPE","Mesh type ");
+ std::string FEM_TYPE = PARAM.string_value("FEM_TYPE","FEM name");
+ std::string INTEGRATION = PARAM.string_value("INTEGRATION",
+ "Name of integration method");
+ std::string SIMPLEX_INTEGRATION = PARAM.string_value("SIMPLEX_INTEGRATION",
+ "Name of simplex integration method");
+ std::string SINGULAR_INTEGRATION =
PARAM.string_value("SINGULAR_INTEGRATION");
+
+ add_crack = (PARAM.int_value("ADDITIONAL_CRACK", "An additional crack ?") !=
0);
+ enrichment_option =
enrichment_option_enum(PARAM.int_value("ENRICHMENT_OPTION",
+ "Enrichment
option"));
+ cout << "MESH_TYPE=" << MESH_TYPE << "\n";
+ cout << "FEM_TYPE=" << FEM_TYPE << "\n";
+ cout << "INTEGRATION=" << INTEGRATION << "\n";
+
+ bimaterial = int(PARAM.int_value("BIMATERIAL", "bimaterial interface
crack"));
+
+ if (bimaterial == 1){
+ mu = PARAM.real_value("MU", "Lame coefficient mu");
+ mu_up = PARAM.real_value("MU_UP", "Lame coefficient mu");
+ mu_down = PARAM.real_value("MU_DOWN", "Lame coefficient mu");
+ lambda_up = PARAM.real_value("LAMBDA_UP", "Lame Coef");
+ lambda_down = PARAM.real_value("LAMBDA_DOWN", "Lame Coef");
+ lambda = PARAM.real_value("LAMBDA", "Lame coefficient lambda");
+ }
+ else{
+
+ mu = PARAM.real_value("MU", "Lame coefficient mu");
+ lambda = PARAM.real_value("LAMBDA", "Lame coefficient lambda");
+ }
+
+
+ spider.radius = PARAM.real_value("SPIDER_RADIUS","spider_radius");
+ spider.Nr = unsigned(PARAM.int_value("SPIDER_NR","Spider_Nr "));
+ spider.Ntheta = unsigned(PARAM.int_value("SPIDER_NTHETA","Ntheta "));
+ spider.K = int(PARAM.int_value("SPIDER_K","K "));
+ spider.theta0 = 0;
+ spider.bimat_enrichment =
int(PARAM.int_value("SPIDER_BIMAT_ENRICHMENT","spider_bimat_enrichment"));
+
+ /* The following constants are taken from the Chang and Xu paper of 2007
+ titled The singular stress field and stress intensity factors of a crack
+ terminating at a bimaterial interface published in IJMECSCI. epsilon
+ being the constant present in the asymptotic displacement analytic
solution:
+ r^{1/2} * cos (\epsilon Ln(r)) * f(\theta) and r^{1/2} * sin (\epsilon
Ln(r)) * f(\theta).
+ */
+
+ if (spider.bimat_enrichment == 1){
+ scalar_type nu1 = (lambda_up) / (2.*lambda_up + mu_up);
+ scalar_type nu2 = (lambda_down) / (2.*lambda_down + mu_down);
+ scalar_type kappa1 = 3. - 4. * nu1;
+ scalar_type kappa2 = 3. - 4. * nu2;
+ if (lambda_up == lambda_down && mu_up == mu_down)
+ cout << "ERROR... Connot use the spider bimaterial enrichment with an
isotropic homogenuous material (beta = 0/0!!!)... You should either use a
bimaterial or disable the spider bimaterial enrichment" << endl;
+
+ scalar_type beta = (mu_up*(kappa2-1.) - mu_down*(kappa1-1.)) /
(mu_up*(kappa2+1.) - mu_down*(kappa1+1.));
+ spider.epsilon = 1./(2.*M_PI) * log( (1.-beta) / (1.+beta) );
+
+
+ //spider.epsilon =
PARAM.real_value("SPIDER_BIMAT_ENRICHMENT","spider_bimat_enrichment");
+ }
+
+ translation.resize(2);
+ translation[0] =0.5;
+ translation[1] =0.;
+
+ /* First step : build the mesh */
+ bgeot::pgeometric_trans pgt =
+ bgeot::geometric_trans_descriptor(MESH_TYPE);
+ size_type N = pgt->dim();
+ std::vector<size_type> nsubdiv(N);
+ std::fill(nsubdiv.begin(),nsubdiv.end(),
+ PARAM.int_value("NX", "Nomber of space steps "));
+ getfem::regular_unit_mesh(mesh, nsubdiv, pgt,
+ PARAM.int_value("MESH_NOISED") != 0);
+ base_small_vector tt(N); tt[1] = -0.5;
+ mesh.translation(tt);
+
+
+ scalar_type refinement_radius;
+ refinement_radius = PARAM.real_value("REFINEMENT_RADIUS","Refinement
Radius");
+ size_type refinement_process;
+ refinement_process = PARAM.int_value("REFINEMENT_PROCESS","Refinement
process");
+ dal::bit_vector conv_to_refine;
+ size_type ref = 1;
+ if (refinement_radius > 0){
+ while(ref <= refinement_process){
+ conv_to_refine.clear();
+ for(dal::bv_visitor i(mesh.convex_index()); !i.finished(); ++i){
+ for(size_type j=0; j < 3; ++j)
+
if(fabs(mesh.points()[mesh.ind_points_of_convex(i)[j]][0])<refinement_radius
+ &&
fabs(mesh.points()[mesh.ind_points_of_convex(i)[j]][1])<refinement_radius){
+ conv_to_refine.add(i);
+ }
+ }
+ mesh.Bank_refine(conv_to_refine);
+
+ ref = ref + 1;
+ refinement_radius = refinement_radius/3.;
+ if(refinement_radius > 1e-16 )
+ cout<<"refining process step " << ref << "... refining "<<
conv_to_refine.size() <<" convexes..." << endl ;
+
+ }
+ cout<<"refining process complete." << endl ;
+ }
+
+
+
+ datafilename = PARAM.string_value("ROOTFILENAME","Base name of data files.");
+ residual = PARAM.real_value("RESIDUAL");
+ if (residual == 0.) residual = 1e-10;
+ enr_area_radius = PARAM.real_value("RADIUS_ENR_AREA",
+ "radius of the enrichment area");
+
+ GLOBAL_FUNCTION_MF = PARAM.string_value("GLOBAL_FUNCTION_MF");
+ GLOBAL_FUNCTION_U = PARAM.string_value("GLOBAL_FUNCTION_U");
+
+ reference_test = int(PARAM.int_value("REFERENCE_TEST", "Reference test"));
+
+ unsigned EXACT_SOL_NUM = unsigned(PARAM.int_value("EXACT_SOL_NUM", "Exact
solution function number"));
+
+
+ cutoff_func = PARAM.int_value("CUTOFF_FUNC", "cutoff function");
+
+ cutoff_radius = PARAM.real_value("CUTOFF", "Cutoff");
+ cutoff_radius1 = PARAM.real_value("CUTOFF1", "Cutoff1");
+ cutoff_radius0 = PARAM.real_value("CUTOFF0", "Cutoff0");
+ mf_u().set_qdim(dim_type(N));
+
+ /* set the finite element on the mf_u */
+ getfem::pfem pf_u =
+ getfem::fem_descriptor(FEM_TYPE);
+ getfem::pintegration_method ppi =
+ getfem::int_method_descriptor(INTEGRATION);
+ getfem::pintegration_method simp_ppi =
+ getfem::int_method_descriptor(SIMPLEX_INTEGRATION);
+ getfem::pintegration_method sing_ppi = (SINGULAR_INTEGRATION.size() ?
+ getfem::int_method_descriptor(SINGULAR_INTEGRATION) : 0);
+
+ mim.set_integration_method(mesh.convex_index(), ppi);
+ mls.add_level_set(ls);
+ if (add_crack) { mls.add_level_set(ls2); mls.add_level_set(ls3); }
+
+ mim.set_simplex_im(simp_ppi, sing_ppi);
+ mf_pre_u.set_finite_element(mesh.convex_index(), pf_u);
+ mf_pre_mortar.set_finite_element(mesh.convex_index(),
+
getfem::fem_descriptor(PARAM.string_value("MORTAR_FEM_TYPE")));
+ mf_mult.set_finite_element(mesh.convex_index(), pf_u);
+ mf_mult.set_qdim(dim_type(N));
+ mf_partition_of_unity.set_classical_finite_element(1);
+
+ mixed_pressure =
+ (PARAM.int_value("MIXED_PRESSURE","Mixed version or not.") != 0);
+ dir_with_mult = unsigned(PARAM.int_value("DIRICHLET_VERSINO"));
+ if (mixed_pressure) {
+ std::string FEM_TYPE_P = PARAM.string_value("FEM_TYPE_P","FEM name P");
+ mf_p.set_finite_element(mesh.convex_index(),
+ getfem::fem_descriptor(FEM_TYPE_P));
+ }
+
+ /* set the finite element on mf_rhs (same as mf_u is DATA_FEM_TYPE is
+ not used in the .param file */
+ std::string data_fem_name = PARAM.string_value("DATA_FEM_TYPE");
+ if (data_fem_name.size() == 0) {
+ GMM_ASSERT1(pf_u->is_lagrange(), "You are using a non-lagrange FEM. "
+ << "In that case you need to set "
+ << "DATA_FEM_TYPE in the .param file");
+ mf_rhs.set_finite_element(mesh.convex_index(), pf_u);
+ } else {
+ mf_rhs.set_finite_element(mesh.convex_index(),
+ getfem::fem_descriptor(data_fem_name));
+ }
+
+ /* set boundary conditions
+ * (Neuman on the upper face, Dirichlet elsewhere) */
+ cout << "Selecting Neumann and Dirichlet boundaries\n";
+ getfem::mesh_region border_faces;
+ getfem::outer_faces_of_mesh(mesh, border_faces);
+ for (getfem::mr_visitor i(border_faces); !i.finished(); ++i) {
+
+ base_node un = mesh.normal_of_face_of_convex(i.cv(), i.f());
+ un /= gmm::vect_norm2(un);
+ if(bimaterial == 1) {
+
+ if (un[0] > 1.0E-7 ) { // new Neumann face
+ mesh.region(DIRICHLET_BOUNDARY_NUM).add(i.cv(), i.f());
+ } else {
+ if (un[1] > 1.0E-7 ) {
+ cout << "normal = " << un << endl;
+ mesh.region(NEUMANN_BOUNDARY_NUM1).add(i.cv(), i.f());
+ }
+ else {
+ if (un[1] < -1.0E-7 ) {
+ cout << "normal = " << un << endl;
+ mesh.region(NEUMANN_BOUNDARY_NUM).add(i.cv(), i.f());
+ }
+ else {
+ if (un[0] < -1.0E-7 ) {
+ cout << "normal = " << un << endl;
+ mesh.region(NEUMANN_HOMOGENE_BOUNDARY_NUM).add(i.cv(), i.f());
+ }
+ }
+ }
+ }
+ }
+ else {
+
+#ifdef VALIDATE_XFEM
+ mesh.region(DIRICHLET_BOUNDARY_NUM).add(i.cv(), i.f());
+#else
+ base_node un = mesh.normal_of_face_of_convex(i.cv(), i.f());
+ un /= gmm::vect_norm2(un);
+ if (un[0] - 1.0 < -1.0E-7) { // new Neumann face
+ mesh.region(NEUMANN_BOUNDARY_NUM).add(i.cv(), i.f());
+ } else {
+ cout << "normal = " << un << endl;
+ mesh.region(DIRICHLET_BOUNDARY_NUM).add(i.cv(), i.f());
+ }
+#endif
+ }
+ }
+
+
+
+#ifdef VALIDATE_XFEM
+ exact_sol.init(EXACT_SOL_NUM, lambda, mu, ls);
+#endif
+}
+
+
+base_small_vector ls_function(const base_node P, int num = 0) {
+ scalar_type x = P[0], y = P[1];
+ base_small_vector res(2);
+ switch (num) {
+ case 0: {
+ res[0] = y;
+ res[1] = -.5 + x;
+ } break;
+ case 1: {
+ res[0] = gmm::vect_dist2(P, base_node(0.5, 0.)) - .25;
+ res[1] = gmm::vect_dist2(P, base_node(0.25, 0.0)) - 0.27;
+ } break;
+ case 2: {
+ res[0] = x - 0.25;
+ res[1] = gmm::vect_dist2(P, base_node(0.25, 0.0)) - 0.35;
+ } break;
+ default: assert(0);
+ }
+ return res;
+}
+
+bool crack_problem::solve(plain_vector &U) {
+ size_type nb_dof_rhs = mf_rhs.nb_dof();
+ size_type N = mesh.dim();
+ ls.reinit();
+ cout << "ls.get_mesh_fem().nb_dof() = " << ls.get_mesh_fem().nb_dof() <<
"\n";
+ for (size_type d = 0; d < ls.get_mesh_fem().nb_dof(); ++d) {
+ ls.values(0)[d] = ls_function(ls.get_mesh_fem().point_of_basic_dof(d),
0)[0];
+ ls.values(1)[d] = ls_function(ls.get_mesh_fem().point_of_basic_dof(d),
0)[1];
+ }
+ ls.touch();
+
+ if (add_crack) {
+ ls2.reinit();
+ for (size_type d = 0; d < ls2.get_mesh_fem().nb_dof(); ++d) {
+ ls2.values(0)[d] = ls_function(ls2.get_mesh_fem().point_of_basic_dof(d),
1)[0];
+ ls2.values(1)[d] = ls_function(ls2.get_mesh_fem().point_of_basic_dof(d),
1)[1];
+ }
+ ls2.touch();
+
+ ls3.reinit();
+ for (size_type d = 0; d < ls3.get_mesh_fem().nb_dof(); ++d) {
+ ls3.values(0)[d] = ls_function(ls2.get_mesh_fem().point_of_basic_dof(d),
2)[0];
+ ls3.values(1)[d] = ls_function(ls2.get_mesh_fem().point_of_basic_dof(d),
2)[1];
+ }
+ ls3.touch();
+ }
+
+ mls.adapt();
+ mim.adapt();
+ mfls_u.adapt();
+ mfls_mortar.adapt(); mfls_mortar.set_qdim(2);
+
+ bool load_global_fun = GLOBAL_FUNCTION_MF.size() != 0;
+
+ cout << "Setting up the singular functions for the enrichment\n";
+
+ std::vector<getfem::pglobal_function> vfunc(4);
+ if (!load_global_fun) {
+ cout << "Using default singular functions\n";
+ for (unsigned i = 0; i < vfunc.size(); ++i){
+ /* use the singularity */
+ getfem::pxy_function
+ s = std::make_shared<getfem::crack_singular_xy_function>(i);
+ if (enrichment_option != FIXED_ZONE &&
+ enrichment_option != GLOBAL_WITH_MORTAR) {
+ /* use the product of the singularity function
+ with a cutoff */
+ getfem::pxy_function c = std::make_shared<getfem::cutoff_xy_function>
+ (int(cutoff_func), cutoff_radius, cutoff_radius1,cutoff_radius0);
+ s = std::make_shared<getfem::product_of_xy_functions>(s, c);
+ }
+ vfunc[i] = getfem::global_function_on_level_set(ls, s);
+ }
+ } else {
+ cout << "Load singular functions from " << GLOBAL_FUNCTION_MF << " and "
<< GLOBAL_FUNCTION_U << "\n";
+ interpolated_m.clear();
+ interpolated_m.read_from_file(GLOBAL_FUNCTION_MF);
+ interpolated_mf.read_from_file(GLOBAL_FUNCTION_MF);
+ std::fstream f(GLOBAL_FUNCTION_U.c_str(), std::ios::in);
+ plain_vector W(interpolated_mf.nb_dof());
+
+
+
+ for (unsigned i=0; i < interpolated_mf.nb_dof(); ++i) {
+ f >> W[i];
+ GMM_ASSERT1(f.good(), "problem while reading " << GLOBAL_FUNCTION_U);
+ }
+ unsigned nb_func = interpolated_mf.get_qdim();
+ cout << "read " << nb_func << " global functions OK.\n";
+ vfunc.resize(nb_func);
+ auto global_interp
+ = std::make_shared<getfem::interpolator_on_mesh_fem>(interpolated_mf, W);
+ for (size_type i=0; i < nb_func; ++i) {
+ /* use the precalculated function for the enrichment*/
+ getfem::pxy_function
+ s =
std::make_shared<getfem::interpolated_xy_function>(global_interp,i);
+ if (enrichment_option != FIXED_ZONE &&
+ enrichment_option != GLOBAL_WITH_MORTAR) {
+
+ /* use the product of the enrichment function
+ with a cutoff */
+ getfem::pxy_function c = std::make_shared<getfem::cutoff_xy_function>
+ (int(cutoff_func), cutoff_radius, cutoff_radius1,cutoff_radius0);
+ s = std::make_shared<getfem::product_of_xy_functions>(s, c);
+ }
+ vfunc[i] = getfem::global_function_on_level_set(ls, s);
+ }
+ }
+
+
+ mf_sing_u.set_functions(vfunc);
+
+
+ if (enrichment_option == SPIDER_FEM_ALONE ||
+ enrichment_option == SPIDER_FEM_ENRICHMENT) {
+ spider.fem = std::make_unique<getfem::spider_fem>
+ (spider.radius, mim, spider.Nr, spider.Ntheta, spider.K, translation,
+ spider.theta0, spider.bimat_enrichment, spider.epsilon);
+ mf_us.set_finite_element(mesh.convex_index(),spider.fem->get_pfem());
+ for (dal::bv_visitor_c i(mf_us.convex_index()); !i.finished(); ++i) {
+ if (mf_us.fem_of_element(i)->nb_dof(i) == 0) {
+ mf_us.set_finite_element(i,0);
+ }
+ }
+ spider.fem->check();
+ }
+
+ switch (enrichment_option) {
+
+ case FIXED_ZONE :
+ {
+ dal::bit_vector enriched_dofs;
+ plain_vector X(mf_partition_of_unity.nb_dof());
+ plain_vector Y(mf_partition_of_unity.nb_dof());
+ getfem::interpolation(ls.get_mesh_fem(), mf_partition_of_unity,
+ ls.values(1), X);
+ getfem::interpolation(ls.get_mesh_fem(), mf_partition_of_unity,
+ ls.values(0), Y);
+ for (size_type j = 0; j < mf_partition_of_unity.nb_dof(); ++j) {
+ if (gmm::sqr(X[j]) + gmm::sqr(Y[j]) <= gmm::sqr(enr_area_radius))
+ enriched_dofs.add(j);
+ }
+ if (enriched_dofs.card() < 3)
+ GMM_WARNING0("There is " << enriched_dofs.card() <<
+ " enriched dofs for the crack tip");
+ mf_product.set_enrichment(enriched_dofs);
+ mf_u_sum.set_mesh_fems(mf_product, mfls_u);
+ }
+ break;
+
+
+ case GLOBAL_WITH_MORTAR: {
+ // Selecting the element in the enriched domain
+
+ dal::bit_vector cvlist_in_area;
+ dal::bit_vector cvlist_out_area;
+ for (dal::bv_visitor cv(mesh.convex_index());
+ !cv.finished(); ++cv) {
+ bool in_area = true;
+ /* For each element, we test all of its nodes.
+ If all the nodes are inside the enrichment area,
+ then the element is completly inside the area too */
+ for (unsigned j=0; j < mesh.nb_points_of_convex(cv); ++j) {
+ if (gmm::sqr(mesh.points_of_convex(cv)[j][0] - translation[0]) +
+ gmm::sqr(mesh.points_of_convex(cv)[j][1] - translation[1]) >
+ gmm::sqr(enr_area_radius)) {
+ in_area = false; break;
+ }
+ }
+
+ /* "remove" the global function on convexes outside the enrichment
+ area */
+ if (!in_area) {
+ cvlist_out_area.add(cv);
+ mf_sing_u.set_finite_element(cv, 0);
+ mf_u().set_dof_partition(cv, 1);
+ } else cvlist_in_area.add(cv);
+ }
+
+ /* extract the boundary of the enrichment area, from the
+ "inside" point-of-view, and from the "outside"
+ point-of-view */
+ getfem::mesh_region r_border, r_enr_out;
+ getfem::outer_faces_of_mesh(mesh, r_border);
+
+ getfem::outer_faces_of_mesh(mesh, cvlist_in_area,
+ mesh.region(MORTAR_BOUNDARY_IN));
+ getfem::outer_faces_of_mesh(mesh, cvlist_out_area,
+ mesh.region(MORTAR_BOUNDARY_OUT));
+ for (getfem::mr_visitor v(r_border); !v.finished(); ++v) {
+ mesh.region(MORTAR_BOUNDARY_OUT).sup(v.cv(), v.f());
+ }
+ mf_u_sum.set_mesh_fems(mf_sing_u, mfls_u);
+ } break;
+
+ case GLOBAL_WITH_CUTOFF :{
+ if(cutoff_func == 0)
+ cout<<"Using exponential Cutoff..."<<endl;
+ else
+ cout<<"Using Polynomial Cutoff..."<<endl;
+ mf_u_sum.set_mesh_fems(mf_sing_u, mfls_u);
+ } break;
+
+ case SPIDER_FEM_ALONE : {
+ mf_u_sum.set_mesh_fems(mf_us);
+ } break;
+
+ case SPIDER_FEM_ENRICHMENT : {
+ mf_u_sum.set_mesh_fems(mf_us, mfls_u);
+ } break;
+
+ case NO_ENRICHMENT: {
+ mf_u_sum.set_mesh_fems(mfls_u);
+ } break;
+
+ }
+
+
+ U.resize(mf_u().nb_dof());
+
+
+ if (mixed_pressure) cout << "Number of dof for P: " << mf_p.nb_dof() << endl;
+ cout << "Number of dof for u: " << mf_u().nb_dof() << endl;
+
+ getfem::model model;
+
+ // Linearized elasticity brick.
+ model.add_fem_variable("u", mf_u());
+ if (mixed_pressure) model.add_fem_variable("p", mf_p);
+ plain_vector lambda_(mf_rhs.nb_dof(), mixed_pressure ? 0. : lambda);
+ model.add_initialized_fem_data("lambda", mf_rhs, lambda_);
+ plain_vector mu_(mf_rhs.nb_dof(), mu);
+ model.add_initialized_fem_data("mu", mf_rhs, mu_);
+ getfem::add_isotropic_linearized_elasticity_brick
+ (model, mim, "u", "lambda", "mu");
+
+
+ if(bimaterial == 1){
+ GMM_ASSERT1(!mf_rhs.is_reduced(), "To be adapted");
+
cout<<"______________________________________________________________________________"<<endl;
+ cout<<"CASE OF BIMATERIAL CRACK with lambda_up = "<<lambda_up<<" and
lambda_down = "<<lambda_down<<endl;
+
cout<<"______________________________________________________________________________"<<endl;
+ plain_vector bi_lambda(mf_rhs.nb_dof());
+ plain_vector bi_mu(mf_rhs.nb_dof());
+
+ for (size_type ite = 0; ite < mf_rhs.nb_dof(); ite++) {
+ if (mf_rhs.point_of_basic_dof(ite)[1] > 0){
+ bi_lambda[ite] = lambda_up;
+ bi_mu[ite] = mu_up;
+ }
+ else{
+ bi_lambda[ite] = lambda_down;
+ bi_mu[ite] = mu_down;
+ }
+ }
+
+ gmm::copy(bi_lambda, model.set_real_variable("lambda"));
+ gmm::copy(bi_mu, model.set_real_variable("mu"));
+ }
+
+ if (mixed_pressure)
+ getfem::add_linear_incompressibility(model, mim, "u", "p");
+
+
+ // Defining the volumic source term.
+ plain_vector F(nb_dof_rhs * N);
+ getfem::interpolation_function(mf_rhs, F, sol_f);
+ model.add_initialized_fem_data("VolumicData", mf_rhs, F);
+ getfem::add_source_term_brick(model, mim, "u", "VolumicData");
+
+ // Defining the Neumann condition right hand side.
+ gmm::clear(F);
+
+ // Neumann condition brick.
+ if (bimaterial == 1) {
+
+ gmm::clear(F);
+ for(size_type i = 1; i<F.size(); i=i+2) F[i] = 0.4;
+ for(size_type i = 0; i<F.size(); i=i+2) F[i] = 0.;
+ model.add_initialized_fem_data("NeumannData_up", mf_rhs, F);
+ getfem::add_source_term_brick
+ (model, mim, "u", "NeumannData_up", NEUMANN_BOUNDARY_NUM1);
+ }
+
+ // Dirichlet condition brick.
+ if (bimaterial == 1) {
+ getfem::add_Dirichlet_condition_with_multipliers
+ (model, mim, "u", mf_mult, DIRICHLET_BOUNDARY_NUM);
+ } else {
+#ifdef VALIDATE_XFEM
+ model.add_initialized_fem_data("DirichletData", exact_sol.mf,
+ exact_sol.U);
+ getfem::add_Dirichlet_condition_with_multipliers
+ (model, mim, "u", mf_mult, DIRICHLET_BOUNDARY_NUM, "DirichletData");
+#else
+ getfem::add_Dirichlet_condition_with_multipliers
+ (model, mim, "u", mf_mult, DIRICHLET_BOUNDARY_NUM);
+#endif
+ }
+
+ if (enrichment_option == GLOBAL_WITH_MORTAR) {
+ /* add a constraint brick for the mortar junction between
+ the enriched area and the rest of the mesh */
+ /* we use mfls_u as the space of lagrange multipliers */
+ getfem::mesh_fem &mf_mortar = mfls_mortar;
+ /* adjust its qdim.. this is just evil and dangerous
+ since mf_u() is built upon mfls_u.. it would be better
+ to use a copy. */
+ mf_mortar.set_qdim(2);
+
+ cout << "Handling mortar junction\n";
+
+ /* list of dof of mf_mortar for the mortar condition */
+ std::vector<size_type> ind_mortar;
+ /* unfortunately , dof_on_region sometimes returns too much dof
+ when mf_mortar is an enriched one so we have to filter them */
+ GMM_ASSERT1(!mf_mortar.is_reduced(), "To be adapted");
+ sparse_matrix M(mf_mortar.nb_dof(), mf_mortar.nb_dof());
+ getfem::asm_mass_matrix(M, mim, mf_mortar, MORTAR_BOUNDARY_OUT);
+ for (dal::bv_visitor_c
d(mf_mortar.basic_dof_on_region(MORTAR_BOUNDARY_OUT));
+ !d.finished(); ++d) {
+ if (M(d,d) > 1e-8) ind_mortar.push_back(d);
+ else cout << " removing non mortar dof" << d << "\n";
+ }
+
+ cout << ind_mortar.size() << " dof for the lagrange multiplier)\n";
+
+ sparse_matrix H0(mf_mortar.nb_dof(), mf_u().nb_dof()),
+ H(ind_mortar.size(), mf_u().nb_dof());
+
+
+ gmm::sub_index sub_i(ind_mortar);
+ gmm::sub_interval sub_j(0, mf_u().nb_dof());
+
+ /* build the mortar constraint matrix -- note that the integration
+ method is conformal to the crack
+ */
+ getfem::asm_mass_matrix(H0, mim, mf_mortar, mf_u(),
+ MORTAR_BOUNDARY_OUT);
+ gmm::copy(gmm::sub_matrix(H0, sub_i, sub_j), H);
+
+ gmm::clear(H0);
+ getfem::asm_mass_matrix(H0, mim, mf_mortar, mf_u(),
+ MORTAR_BOUNDARY_IN);
+ gmm::add(gmm::scaled(gmm::sub_matrix(H0, sub_i, sub_j), -1), H);
+
+
+ /* because of the discontinuous partition of mf_u(), some levelset
+ enriched functions do not contribute any more to the
+ mass-matrix (the ones which are null on one side of the
+ levelset, when split in two by the mortar partition, may create
+ a "null" dof whose base function is all zero..
+ */
+ sparse_matrix M2(mf_u().nb_dof(), mf_u().nb_dof());
+ getfem::asm_mass_matrix(M2, mim, mf_u(), mf_u());
+
+ for (size_type d = 0; d < mf_u().nb_dof(); ++d) {
+ if (M2(d,d) < 1e-10) {
+ cout << " removing null mf_u() dof " << d << "\n";
+ size_type n = gmm::mat_nrows(H);
+ gmm::resize(H, n+1, gmm::mat_ncols(H));
+ H(n, d) = 1;
+ }
+ }
+
+ getfem::base_vector R(gmm::mat_nrows(H));
+ model.add_fixed_size_variable("mult_mo", gmm::mat_nrows(H));
+ getfem::add_constraint_with_multipliers(model, "u", "mult_mo", H, R);
+ }
+
+ // Generic solve.
+ cout << "Total number of variables : " << model.nb_dof() << endl;
+ gmm::iteration iter(residual, 1, 40000);
+ getfem::standard_solve(model, iter);
+ cout << "Solving... done" << endl;
+ // Solution extraction
+ gmm::copy(model.real_variable("u"), U);
+
+ if(reference_test)
+ {
+ cout << "Exporting reference solution...";
+ GMM_ASSERT1(!mf_u().is_reduced(), "To be adapted");
+ dal::bit_vector blocked_dof = mf_u().basic_dof_on_region(5);
+ getfem::mesh_fem mf_refined(mesh, dim_type(N));
+ std::string FEM_DISC = PARAM.string_value("FEM_DISC","fem disc ");
+ mf_refined.set_finite_element(mesh.convex_index(),
+ getfem::fem_descriptor(FEM_DISC));
+
+ plain_vector W(mf_refined.nb_dof());
+ getfem::interpolation(mf_u(), mf_refined, U, W);
+
+
+ mf_refined.write_to_file(datafilename + "_refined_test.meshfem", true);
+ gmm::vecsave(datafilename + "_refined_test.U", W);
+ cout << "done" << endl;
+ }
+
+
+ return (iter.converged());
+}
+
+void export_interpolated_on_line(const getfem::mesh_fem &mf,
+ const getfem::base_vector &U,
+ const base_node &x0,
+ const base_small_vector &dir,
+ const int nb_points,
+ const std::string &filename) {
+ getfem::mesh_trans_inv mti(mf.linked_mesh());
+ scalar_type h = 1.0/(2*nb_points);
+ for (int i=-nb_points; i <= nb_points; ++i) {
+ mti.add_point(x0 + 2*(i*h)*dir);
+ }
+
+ getfem::base_vector V(mti.nb_points() * mf.get_qdim());
+ getfem::base_matrix M;
+ getfem::interpolation(mf, mti, U, V, M, 0, false);
+
+ std::ofstream f(filename.c_str()); f.precision(16);
+
+ for (size_type i=0; i < mti.nb_points(); ++i) {
+ for (unsigned q=0; q < mf.get_qdim(); ++q) {
+ f << V[i*mf.get_qdim()+q] << " ";
+ }
+ f << "\n";
+ }
+}
+
+
+/**************************************************************************/
+/* main program. */
+/**************************************************************************/
+
+int main(int argc, char *argv[]) {
+
+ GMM_SET_EXCEPTION_DEBUG; // Exceptions make a memory fault, to debug.
+ FE_ENABLE_EXCEPT; // Enable floating point exception for Nan.
+
+ //getfem::getfem_mesh_level_set_noisy();
+
+
+ try {
+ crack_problem p;
+ p.PARAM.read_command_line(argc, argv);
+ p.init();
+ p.mesh.write_to_file(p.datafilename + ".mesh");
+
+ plain_vector U(p.mf_u().nb_dof());
+ if (!p.solve(U)) GMM_ASSERT1(false,"Solve has failed");
+
+ // for (size_type i = 4; i < U.size(); ++i)
+ //U[i] = 0;
+ //cout << "The solution" << U ;
+ gmm::vecsave("crack.U", U);
+ cout << "vecsave done"<<endl;
+ {
+ getfem::mesh mcut;
+ p.mls.global_cut_mesh(mcut);
+ unsigned Q = p.mf_u().get_qdim();
+ getfem::mesh_fem mf(mcut, dim_type(Q));
+ mf.set_classical_discontinuous_finite_element(2, 0.001);
+ // mf.set_finite_element
+ // (getfem::fem_descriptor("FEM_PK_DISCONTINUOUS(2, 2, 0.0001)"));
+ plain_vector V(mf.nb_dof());
+
+ getfem::interpolation(p.mf_u(), mf, U, V);
+
+ getfem::stored_mesh_slice sl;
+ getfem::mesh mcut_refined;
+
+ unsigned NX = unsigned(p.PARAM.int_value("NX")), nn;
+// unsigned NX = (unsigned)sqrt(p.mesh.convex_index().card());
+// unsigned nn;
+ if (NX < 6) nn = 24;
+ else if (NX < 12) nn = 6;
+ else if (NX < 30) nn = 3;
+ else nn = 3;
+
+ /* choose an adequate slice refinement based on the distance to the
crack tip */
+ std::vector<bgeot::short_type>
nrefine(mcut.convex_index().last_true()+1);
+ for (dal::bv_visitor cv(mcut.convex_index()); !cv.finished(); ++cv) {
+ scalar_type dmin=0, d;
+ base_node Pmin,P;
+ for (unsigned i=0; i < mcut.nb_points_of_convex(cv); ++i) {
+ P = mcut.points_of_convex(cv)[i];
+ d = gmm::vect_norm2(ls_function(P));
+ if (d < dmin || i == 0) { dmin = d; Pmin = P; }
+ }
+
+ if (dmin < 1e-5)
+ nrefine[cv] = short_type(nn*8);
+ else if (dmin < .1)
+ nrefine[cv] = short_type(nn*2);
+ else nrefine[cv] = short_type(nn);
+ if (dmin < .01)
+ cout << "cv: "<< cv << ", dmin = " << dmin << "Pmin=" << Pmin << " "
<< nrefine[cv] << "\n";
+ }
+
+ {
+ getfem::mesh_slicer slicer(mcut);
+ getfem::slicer_build_mesh bmesh(mcut_refined);
+ slicer.push_back_action(bmesh);
+ slicer.exec(nrefine, getfem::mesh_region::all_convexes());
+ }
+ /*
+ sl.build(mcut,
+ getfem::slicer_build_mesh(mcut_refined), nrefine);*/
+
+ getfem::mesh_im mim_refined(mcut_refined);
+ mim_refined.set_integration_method(getfem::int_method_descriptor
+ ("IM_TRIANGLE(6)"));
+
+ getfem::mesh_fem mf_refined(mcut_refined, dim_type(Q));
+ mf_refined.set_classical_discontinuous_finite_element(2, 0.001);
+ plain_vector W(mf_refined.nb_dof());
+
+ getfem::interpolation(p.mf_u(), mf_refined, U, W);
+
+
+#ifdef VALIDATE_XFEM
+ p.exact_sol.mf.set_qdim(dim_type(Q));
+ assert(p.exact_sol.mf.nb_dof() == p.exact_sol.U.size());
+ plain_vector EXACT(mf_refined.nb_dof());
+ getfem::interpolation(p.exact_sol.mf, mf_refined,
+ p.exact_sol.U, EXACT);
+
+ plain_vector DIFF(EXACT); gmm::add(gmm::scaled(W,-1),DIFF);
+#endif
+
+ if (p.PARAM.int_value("VTK_EXPORT")) {
+ getfem::mesh_fem mf_refined_vm(mcut_refined, 1);
+ mf_refined_vm.set_classical_discontinuous_finite_element(1, 0.001);
+ cerr << "mf_refined_vm.nb_dof=" << mf_refined_vm.nb_dof() << "\n";
+ plain_vector VM(mf_refined_vm.nb_dof());
+
+ cout << "computing von mises\n";
+ getfem::interpolation_von_mises(mf_refined, mf_refined_vm, W, VM);
+
+ plain_vector D(mf_refined_vm.nb_dof() * Q),
+ DN(mf_refined_vm.nb_dof());
+
+#ifdef VALIDATE_XFEM
+ getfem::interpolation(mf_refined, mf_refined_vm, DIFF, D);
+ for (unsigned i=0; i < DN.size(); ++i) {
+ DN[i] = gmm::vect_norm2(gmm::sub_vector(D, gmm::sub_interval(i*Q,
Q)));
+ }
+#endif
+
+ cout << "export to " << p.datafilename + ".vtk" << "..\n";
+ getfem::vtk_export exp(p.datafilename + ".vtk",
+ p.PARAM.int_value("VTK_EXPORT")==1);
+
+ exp.exporting(mf_refined);
+ //exp.write_point_data(mf_refined_vm, DN, "error");
+ exp.write_point_data(mf_refined_vm, VM, "von mises stress");
+
+ exp.write_point_data(mf_refined, W, "elastostatic_displacement");
+
+ base_node line_x0(0.70001,0);
+ base_small_vector line_dir(0, 0.5001);
+ unsigned line_nb_points = 1000;
+ export_interpolated_on_line(mf_refined_vm, VM,
+ line_x0, line_dir, line_nb_points,
+ "von_mises_on_line.data");
+
+#ifdef VALIDATE_XFEM
+
+ plain_vector VM_EXACT(mf_refined_vm.nb_dof());
+
+
+ /* getfem::mesh_fem_global_function mf(mcut_refined,Q);
+ std::vector<getfem::pglobal_function> cfun(4);
+ for (unsigned j=0; j < 4; ++j)
+ cfun[j] = getfem::isotropic_crack_singular_2D(j, p.ls);
+ mf.set_functions(cfun);
+ getfem::interpolation_von_mises(mf, mf_refined_vm, p.exact_sol.U,
+ VM_EXACT);
+ */
+
+
+ getfem::interpolation_von_mises(mf_refined, mf_refined_vm, EXACT,
VM_EXACT);
+ getfem::vtk_export exp2("crack_exact.vtk");
+ exp2.exporting(mf_refined);
+ exp2.write_point_data(mf_refined_vm, VM_EXACT, "exact von mises
stress");
+ exp2.write_point_data(mf_refined, EXACT, "reference solution");
+
+ export_interpolated_on_line(mf_refined_vm, VM_EXACT,
+ line_x0, line_dir, line_nb_points,
+ "von_mises_on_line_exact.data");
+#endif
+
+ cout << "export done, you can view the data file with (for example)\n"
+ "mayavi -d " << p.datafilename << ".vtk -f "
+ "WarpVector -m BandedSurfaceMap -m Outline\n";
+ }
+
+ //bool error_to_ref_sol = 0;
+
+ if(p.PARAM.int_value("ERROR_TO_REF_SOL") == 1){
+ cout << "Coputing error with respect to a reference solution..." <<
endl;
+ std::string REFERENCE_MF = "crack_refined_test.meshfem";
+ std::string REFERENCE_U = "crack_refined_test.U";
+
+ cout << "Load reference meshfem and solution from " << REFERENCE_MF <<
" and " << REFERENCE_U << "\n";
+ getfem::mesh ref_m;
+ ref_m.read_from_file(REFERENCE_MF);
+ getfem::mesh_fem ref_mf(ref_m);
+ ref_mf.read_from_file(REFERENCE_MF);
+ std::fstream f(REFERENCE_U.c_str(), std::ios::in);
+ plain_vector ref_U(ref_mf.nb_dof());
+
+ for (unsigned i=0; i < ref_mf.nb_dof(); ++i) {
+ f >> ref_U[i]; if (!f.good()) GMM_ASSERT1(f.good(), "problem while
reading " << REFERENCE_U);
+ }
+
+ getfem::mesh_im ref_mim(ref_m);
+ getfem::pintegration_method ppi =
+ getfem::int_method_descriptor("IM_TRIANGLE(6)");
+ ref_mim.set_integration_method(ref_m.convex_index(), ppi);
+ plain_vector interp_U(ref_mf.nb_dof());
+ getfem::interpolation(p.mf_u(), ref_mf, U, interp_U);
+
+ //gmm::add(gmm::scaled(interp_U, -1), ref_U);
+
+
+ cout << "To ref L2 ERROR:" << getfem::asm_L2_dist(ref_mim, ref_mf,
interp_U,
+ ref_mf, ref_U) <<
endl;
+
+ cout << "To ref H1 ERROR:" << getfem::asm_H1_dist(ref_mim, ref_mf,
interp_U,
+ ref_mf, ref_U) <<
endl;
+
+ //cout << "L2 ERROR:"<< getfem::asm_L2_norm(ref_mim, ref_mf, ref_U)
+ // << endl << "H1 ERROR:"
+ // << getfem::asm_H1_norm(ref_mim, ref_mf, ref_U) << "\n";
+
+ }
+
+#ifdef VALIDATE_XFEM
+
+ else {
+ cout << "L2 ERROR:"<< getfem::asm_L2_dist(p.mim, p.mf_u(), U,
+ p.exact_sol.mf,
p.exact_sol.U)
+ << endl << "H1 ERROR:"
+ << getfem::asm_H1_dist(p.mim, p.mf_u(), U,
+ p.exact_sol.mf, p.exact_sol.U) << "\n";
+
+ }
+
+ cout << "L2 norm of the solution:" <<
getfem::asm_L2_norm(p.mim,p.mf_u(),U)<<endl;
+ cout << "H1 norm of the solution:" <<
getfem::asm_H1_norm(p.mim,p.mf_u(),U)<<endl;
+
+
+
+ /* cout << "OLD ERROR L2:"
+ << getfem::asm_L2_norm(mim_refined,mf_refined,DIFF)
+ << " H1:" << getfem::asm_H1_dist(mim_refined,mf_refined,
+ EXACT,mf_refined,W) << "\n";
+
+ cout << "ex = " << p.exact_sol.U << "\n";
+ cout << "U = " << gmm::sub_vector(U, gmm::sub_interval(0,8)) << "\n";
+ */
+#endif
+ }
+
+ }
+ GMM_STANDARD_CATCH_ERROR;
+
+ return 0;
+}
diff --git a/contrib/3D_Crack/crack_3D.param b/contrib/3D_Crack/crack_3D.param
new file mode 100644
index 0000000..9c97a2c
--- /dev/null
+++ b/contrib/3D_Crack/crack_3D.param
@@ -0,0 +1,133 @@
+% Copyright (C) 2017-2017 Yves Renard.
+%
+% This file is a part of GetFEM++
+%
+% GetFEM++ is free software; you can redistribute it and/or modify it
+% under the terms of the GNU Lesser General Public License as published
+% by the Free Software Foundation; either version 3 of the License, or
+% (at your option) any later version along with the GCC Runtime Library
+% Exception either version 3.1 or (at your option) any later version.
+% This program is distributed in the hope that it will be useful, but
+% WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+% or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+% License and GCC Runtime Library Exception for more details.
+% You should have received a copy of the GNU Lesser General Public License
+% along with this program; if not, write to the Free Software Foundation,
+% Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+% -*- mat-lab -*- (enables emacs matlab mode)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% parameters for program crack %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%% pde parameters : %%%%%
+% MU = 77.0; % Lam� coefficient.
+% LAMBDA = 107.0; % Lam� coefficient.
+
+MU = 1.0; % Lam� coefficient.
+LAMBDA = 1.0; % Lam� coefficient.
+
+
+QUAD = 0;
+
+
+BIMATERIAL = 1; % 1 : To enable the bimaterial case
+
+if BIMATERIAL
+ LAMBDA_UP = 10.0;
+ LAMBDA_DOWN = 1.0;
+ MU_UP = 10.0;
+ MU_DOWN = 1.0;
+end
+
+REFINEMENT_RADIUS = 0.; %REF: 0.3; % 0 for no refinement
+REFINEMENT_PROCESS = 3; % nb of desired refinement steps
+
+REFERENCE_TEST = 0; % 1 to compute a reference solution to be exported into
files
+ERROR_TO_REF_SOL = 1; % 1 to compute errors with respect to the reference
solution
+
+%%%%% discretisation parameters : %%%%%
+
+if (~QUAD)
+ MESH_TYPE = 'GT_PK(2,1)'; % linear triangles
+else
+ % MESH_TYPE = 'GT_LINEAR_QK(2)';
+ MESH_TYPE = 'GT_QK(2, 1)';
+end;
+
+NX = 10; % space step.
+
+
+
+MESH_NOISED = 0; % Set to one if you want to "shake" the mesh
+
+
+
+if (~QUAD)
+ %FEM_TYPE = 'FEM_PK_WITH_CUBIC_BUBBLE(2, 2)';
+ FEM_TYPE = 'FEM_PK(2, 1)'; % PK element %REF: P3
+ DATA_FEM_TYPE = 'FEM_PK(2,1)';
+ INTEGRATION = 'IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(6), 5)';
+ FEM_TYPE_P = 'FEM_PK(2,1)';
+ MORTAR_FEM_TYPE = FEM_TYPE;
+else
+ FEM_TYPE = 'FEM_QK(2,1)'; % Q1 fem for quadrangles
+ DATA_FEM_TYPE = 'FEM_QK(2,1)';
+ INTEGRATION = 'IM_STRUCTURED_COMPOSITE(IM_GAUSS_PARALLELEPIPED(2, 1), 5)';
+ FEM_TYPE_P = 'FEM_QK(2,1)';
+ MORTAR_FEM_TYPE = FEM_TYPE;
+end;
+
+FEM_DISC = 'FEM_PK_DISCONTINUOUS(2,3,0.0001)'; % Discontinuous P1 for
triangles
+
+MIXED_PRESSURE=0; % Mixed version or not.
+DIRICHLET_VERSION = 2;
+
+% integration meth. for sub-simplexe of elements crossed by the level-set
+SIMPLEX_INTEGRATION = 'IM_STRUCTURED_COMPOSITE(IM_TRIANGLE(6),3)';
+
+% integration meth. for quasi-polar integration of sub-simplexes adjascent to
the level-set
+% (comment it to disable quasipolar integration). Should be a
+% method defined on a square for 2D, or defined on a prism for 3D.
+% SINGULAR_INTEGRATION = 'IM_GAUSS_PARALLELEPIPED(2, 10)';
+SINGULAR_INTEGRATION = 'IM_STRUCTURED_COMPOSITE(IM_GAUSS_PARALLELEPIPED(2, 6),
9)';
+
+ADDITIONAL_CRACK = 0;
+
+%Enable the following two lines to use the precalculated solution as
enrichement
+%GLOBAL_FUNCTION_MF = "bimaterial_crack12.meshfem"
+%GLOBAL_FUNCTION_U = "bimaterial_crack12.U"
+
+
+ENRICHMENT_OPTION = 5; % 0 = Pas d'enrichissement
+ % 1 = standard XFEM on a fixed zone
+ % 2 = global functions with mortar junction
+ % 3 = global functions with cutoff
+ % 4 = spider fem alone
+ % 5 = spider fem enrichment
+
+
+RADIUS_ENR_AREA = 0.2; % For XFEM and the mortar junction
+
+CUTOFF_FUNC = 2; % 0 for the exponential cutoff.
+ % 1 for a 3rd degree polynomial cutoff
+ % 2 for a 5th degree polynomial cutoff
+CUTOFF = 0.2;
+CUTOFF1 = 0.01;
+CUTOFF0 = 0.49;
+
+SPIDER_RADIUS = 0.4;
+SPIDER_NR = 10; % size of the cartesian mesh in r for spider fem
+SPIDER_NTHETA = 10; % size of the cartesian mesh in theta for spider
fem
+SPIDER_K=1; % order of the spider fem
+SPIDER_BIMAT_ENRICHMENT = 1; % 0 for a sqrt spider enrichment
+ % 1 for sqrt(r)cos(ln(r)) and sqrt(r)sin(ln(r))
spider enrichment
+
+
+RESIDUAL = 1E-9; % residual for iterative methods if any.
+
+%%%%% saving parameters %%%%%
+ROOTFILENAME = 'crack'; % Root of data files.
+VTK_EXPORT = 2 % export solution to a .vtk file ?
+
+EXACT_SOL_NUM=1 % 1 for mode I, 2 for mode II, 6 for a combination
+ % of modes
\ No newline at end of file
diff --git a/contrib/3D_Crack/crack_3D.pl b/contrib/3D_Crack/crack_3D.pl
new file mode 100644
index 0000000..602a8bb
--- /dev/null
+++ b/contrib/3D_Crack/crack_3D.pl
@@ -0,0 +1,16 @@
+# Copyright (C) 2001-2017 Yves Renard
+#
+# This file is a part of GetFEM++
+#
+# GetFEM++ is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version along with the GCC Runtime Library
+# Exception either version 3.1 or (at your option) any later version.
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+# License and GCC Runtime Library Exception for more details.
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/contrib/3D_Crack/crack_3D_exact_solution.cc
b/contrib/3D_Crack/crack_3D_exact_solution.cc
new file mode 100644
index 0000000..dc71623
--- /dev/null
+++ b/contrib/3D_Crack/crack_3D_exact_solution.cc
@@ -0,0 +1,306 @@
+/*===========================================================================
+
+ Copyright (C) 2007-2017 Yves Renard, Julien Pommier.
+
+ This file is a part of GetFEM++
+
+ GetFEM++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version along with the GCC Runtime Library
+ Exception either version 3.1 or (at your option) any later version.
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License and GCC Runtime Library Exception for more details.
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+===========================================================================*/
+
+#include "crack_3D_exact_solution.h"
+
+using std::endl; using std::cout; using std::cerr;
+using std::ends; using std::cin;
+
+/* returns sin(theta/2) where theta is the angle
+ of 0-(x,y) with the axis Ox */
+/* static scalar_type sint2(scalar_type x, scalar_type y) { */
+/* scalar_type r = sqrt(x*x+y*y); */
+/* if (r == 0) return 0; */
+/* else return (y<0 ? -1:1) * sqrt(gmm::abs(r-x)/(2*r)); */
+/* // sometimes (gcc3.3.2 -O3), r-x < 0 .... */
+/* } */
+/* static scalar_type cost2(scalar_type x, scalar_type y) { */
+/* scalar_type r = sqrt(x*x+y*y); */
+/* if (r == 0) return 0; */
+/* else return sqrt(gmm::abs(r+x)/(2*r)); */
+/* } */
+/* analytical solution for a semi-infinite crack [-inf,a] in an
+ infinite plane submitted to +sigma above the crack
+ and -sigma under the crack. (The crack is directed along the x axis).
+
+ nu and E are the poisson ratio and young modulus
+
+ solution taken from "an extended finite elt method with high order
+ elts for curved cracks", Stazi, Budyn,Chessa, Belytschko
+*/
+
+/*static void elasticite2lame(const scalar_type young_modulus,
+ const scalar_type poisson_ratio,
+ scalar_type& lambda, scalar_type& mu) {
+ mu = young_modulus/(2*(1+poisson_ratio));
+ lambda = 2*mu*poisson_ratio/(1-poisson_ratio);
+}
+*/
+
+/* solution reguliere pour une fracture en y=0 */
+static base_small_vector solution_P2(double lambda, double mu, const
base_node& pos, base_matrix* pgrad = 0) {
+ double x=pos[0], y = pos[1];
+ base_small_vector v(2);
+ double c[6] = {0, 0, 0., 0., 0., 0.01};
+ double d[6] = {0, .2, .1, 0.05, -.03, 0.06};
+ v[0] =
c[0]-1/lambda*(lambda+2.0*mu)*d[2]*x-d[1]*y-1/lambda*(lambda+2.0*mu)*d[4]*x*x/2.0-2.0*(lambda+2.0*mu)*d[5]/lambda*x*y+(3.0*lambda+4.0*mu)*d[4]/lambda*y*y/2.0;
+ v[1]= d[0]+d[1]*x+d[2]*y+1/lambda*(lambda+2.0*mu)*d[5]*x*x+d[4]*x*y+d[5]*y*y;
+ if (pgrad) {
+ (*pgrad).resize(2,2);
+ (*pgrad)(0,0) =
-1/lambda*(lambda+2.0*mu)*d[2]-1/lambda*(lambda+2.0*mu)*d[4]*x-2.0*(lambda+2.0*mu)*d[5]/lambda*y;
+ (*pgrad)(1,0) =
-d[1]-2.0*(lambda+2.0*mu)*d[5]/lambda*x+(3.0*lambda+4.0*mu)*d[4]/lambda*y;
+ (*pgrad)(0,1) = d[1]+d[4]*y+2/lambda*(lambda+2.0*mu)*d[5]*x;
+ (*pgrad)(1,1) = d[2]+d[4]*x+2*d[5]*y;
+ }
+ return v;
+}
+
+static void sol_ref_infinite_plane(scalar_type lambda, scalar_type mu,
+ scalar_type x, scalar_type y,
+ base_small_vector& U, int mode,
+ base_matrix *pgrad) {
+ //scalar_type KI = sigma*sqrt(M_PI*a);
+ scalar_type r = std::max(sqrt(x*x+y*y),1e-16);
+ scalar_type sqrtr = sqrt(r), sqrtr3 = sqrtr*sqrtr*sqrtr;
+ scalar_type cost = x/r, sint = y/r;
+ scalar_type theta = atan2(y,x);
+ scalar_type s2 = sin(theta/2); //sint2(x,y);
+ scalar_type c2 = cos(theta/2); //cost2(x,y);
+ // scalar_type c3 = cos(3*theta/2); //4*c2*c2*c2-3*c2; /* cos(3*theta/2) */
+ // scalar_type s3 = sin(3*theta/2); //4*s2*c2*c2-s2; /* sin(3*theta/2) */
+
+ U.resize(2);
+ if (pgrad) (*pgrad).resize(2,2);
+ scalar_type C=1; //1./E * (mode == 1 ? 1. : (1+nu));
+ if (mode == 1) {
+ scalar_type A=2+2*mu/(lambda+2*mu);
+ scalar_type B=-2*(lambda+mu)/(lambda+2*mu);
+ U[0] = sqrtr/sqrt(2*M_PI) * C * c2 * (A + B*cost);
+ U[1] = sqrtr/sqrt(2*M_PI) * C * s2 * (A + B*cost);
+ if (pgrad) {
+ (*pgrad)(0,0) = C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (cost*c2*A-cost*cost*c2*B+sint*s2*A+sint*s2*B*cost+2*c2*B);
+ (*pgrad)(1,0) = -C/(2*sqrt(2*M_PI)*sqrtr)
+ * (-sint*c2*A+sint*c2*B*cost+cost*s2*A+cost*cost*s2*B);
+ (*pgrad)(0,1) = C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (cost*s2*A-cost*cost*s2*B-sint*c2*A-sint*c2*B*cost+2*s2*B);
+ (*pgrad)(1,1) = C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (sint*s2*A-sint*s2*B*cost+cost*c2*A+cost*cost*c2*B);
+ }
+ } else if (mode == 2) {
+ scalar_type C1 = (lambda+3*mu)/(lambda+mu);
+ U[0] = sqrtr/sqrt(2*M_PI) * C * s2 * (C1 + 2 + cost);
+ U[1] = sqrtr/sqrt(2*M_PI) * C * c2 * (C1 - 2 + cost) * (-1.);
+ if (pgrad) {
+ (*pgrad)(0,0) = C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (cost*s2*C1+2*cost*s2-cost*cost*s2-sint*c2*C1
+ -2*sint*c2-sint*cost*c2+2*s2);
+ (*pgrad)(1,0) = C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (sint*s2*C1+2*sint*s2-sint*s2*cost+cost*c2*C1
+ +2*cost*c2+cost*cost*c2);
+ (*pgrad)(0,1) = -C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (cost*c2*C1-2*cost*c2-cost*cost*c2+sint*s2*C1
+ -2*sint*s2+sint*s2*cost+2*c2);
+ (*pgrad)(1,1) = C/(2.*sqrt(2*M_PI)*sqrtr)
+ * (-sint*c2*C1+2*sint*c2+sint*cost*c2+cost*s2*C1
+ -2*cost*s2+cost*cost*s2);
+ }
+ } else if (mode == 100) {
+ U[0] = - sqrtr3 * (c2 + 4./3 *(7*mu+3*lambda)/(lambda+mu)*c2*s2*s2
+ -1./3*(7*mu+3*lambda)/(lambda+mu)*c2);
+ U[1] = - sqrtr3 * (s2+4./3*(lambda+5*mu)/(lambda+mu)*s2*s2*s2
+ -(lambda+5*mu)/(lambda+mu)*s2);
+ if (pgrad) {
+ (*pgrad)(0,0) = 2*sqrtr*(-6*cost*c2*mu+7*cost*c2*c2*c2*mu
+ -3*cost*c2*lambda+3*cost*c2*c2*c2*lambda
+ -2*sint*s2*mu
+ +7*sint*s2*c2*c2*mu-sint*s2*lambda
+ +3*sint*s2*c2*c2*lambda)/(lambda+mu);
+ (*pgrad)(1,0) = -2*sqrtr*(6*sint*c2*mu-7*sint*c2*c2*c2*mu
+ +3*sint*c2*lambda-3*sint*c2*c2*c2*lambda
+ -2*cost*s2*mu
+ +7*cost*s2*c2*c2*mu-cost*s2*lambda
+ +3*cost*s2*c2*c2*lambda)/(lambda+mu);
+ (*pgrad)(0,1) = 2*sqrtr*(-2*cost*s2*mu-cost*s2*lambda
+ +cost*s2*c2*c2*lambda+5*cost*s2*c2*c2*mu
+ +4*sint*c2*mu
+ +sint*c2*lambda-sint*c2*c2*c2*lambda
+ -5*sint*c2*c2*c2*mu)/(lambda+mu);
+ (*pgrad)(1,1) = 2*sqrtr*(-2*sint*s2*mu-sint*s2*lambda
+ +sint*s2*c2*c2*lambda+5*sint*s2*c2*c2*mu
+ -4*cost*c2*mu
+ -cost*c2*lambda+cost*c2*c2*c2*lambda
+ +5*cost*c2*c2*c2*mu)/(lambda+mu);
+ }
+ } else if (mode == 101) {
+ U[0] = -4*sqrtr3*s2*(-lambda-2*mu+7*lambda*c2*c2
+ +11*mu*c2*c2)/(3*lambda-mu);
+ U[1] = -4*sqrtr3*c2*(-3*lambda+3*lambda*c2*c2-mu*c2*c2)/(3*lambda-mu);
+ if (pgrad) {
+ (*pgrad)(0,0) = -6*sqrtr*(-cost*s2*lambda-2*cost*s2*mu
+ +7*cost*s2*lambda*c2*c2
+ +11*cost*s2*mu*c2*c2+5*sint*c2*lambda
+ +8*sint*c2*mu-7*sint*c2*c2*c2*lambda
+ -11*sint*c2*c2*c2*mu)/(3*lambda-mu);
+ (*pgrad)(1,0) = -6*sqrtr*(-sint*s2*lambda-2*sint*s2*mu
+ +7*sint*s2*lambda*c2*c2
+ +11*sint*s2*mu*c2*c2-5*cost*c2*lambda
+ -8*cost*c2*mu+7*cost*c2*c2*c2*lambda
+ +11*cost*c2*c2*c2*mu)/(3*lambda-mu);
+ (*pgrad)(0,1) = -6*sqrtr*(-3*cost*c2*lambda+3*cost*c2*c2*c2*lambda
+ -cost*c2*c2*c2*mu-sint*s2*lambda
+ +3*sint*s2*lambda*c2*c2
+ -sint*s2*mu*c2*c2)/(3*lambda-mu);
+ (*pgrad)(1,1) = 6*sqrtr*(3*sint*c2*lambda
+ -3*sint*c2*c2*c2*lambda+sint*c2*c2*c2*mu
+ -cost*s2*lambda+3*cost*s2*lambda*c2*c2
+ -cost*s2*mu*c2*c2)/(3*lambda-mu);
+ }
+
+ } else if (mode == 10166666) {
+
+ U[0] = 4*sqrtr3*s2*(-lambda+lambda*c2*c2-3*mu*c2*c2)/(lambda-3*mu);
+ U[1] =
4*sqrtr3*c2*(-3*lambda-6*mu+5*lambda*c2*c2+9*mu*c2*c2)/(lambda-3*mu);
+ if (pgrad) {
+ (*pgrad)(0,0) = 6*sqrtr*(-cost*s2*lambda+cost*s2*lambda*c2*c2-
+ 3*cost*s2*mu*c2*c2-2*sint*c2*mu+sint*c2*lambda-
+ sint*c2*c2*c2*lambda
+ +3*sint*c2*c2*c2*mu)/(lambda-3*mu);
+ (*pgrad)(1,0) = 6*sqrtr*(-sint*s2*lambda+sint*s2*lambda*c2*c2-
+ 3*sint*s2*mu*c2*c2+2*cost*c2*mu-cost*c2*lambda+
+ cost*c2*c2*c2*lambda
+ -3*cost*c2*c2*c2*mu)/(lambda-3*mu);
+ (*pgrad)(0,1) = 6*sqrtr*(-3*cost*c2*lambda-6*cost*c2*mu
+ +5*cost*c2*c2*c2*lambda+
+ 9*cost*c2*c2*c2*mu-sint*s2*lambda-2*sint*s2*mu+
+ 5*sint*s2*lambda*c2*c2
+ +9*sint*s2*mu*c2*c2)/(lambda-3*mu);
+ (*pgrad)(1,1) = -6*sqrtr*(3*sint*c2*lambda+6*sint*c2*mu
+ -5*sint*c2*c2*c2*lambda-
+ 9*sint*c2*c2*c2*mu-cost*s2*lambda-2*cost*s2*mu+
+ 5*cost*s2*lambda*c2*c2
+ +9*cost*s2*mu*c2*c2)/(lambda-3*mu);
+ }
+ } else assert(0);
+ if (std::isnan(U[0]))
+ cerr << "raaah not a number ...\n";
+ assert(!std::isnan(U[0]));
+ assert(!std::isnan(U[1]));
+}
+
+
+base_small_vector crack_exact_solution_function::eval(const base_node &x,
base_matrix *pgrad) const {
+ int N = x.size(); base_small_vector res(N); res.fill(0.);
+ gmm::clear(res); if (pgrad) gmm::clear(*pgrad);
+ if (function_num == 1) {
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], res, 1, pgrad);
+ } else if (function_num == 2) {
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], res, 2, pgrad);
+ } else if (function_num == 3) {
+ //res[0] = (x[1]+2.5)/10;
+ res[1] = x[1]/4;
+ } else if (function_num == 4) {
+ base_small_vector modeI(2), modeII(2);
+ base_matrix gradI, gradII;
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeI, 1, (pgrad) ? &gradI
: 0);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeII, 2, (pgrad) ?
&gradII : 0);
+ res = solution_P2(lambda, mu, x, pgrad);
+ res += modeI*4. - modeII*3.;
+ if (pgrad) {
+ gmm::add(gmm::scaled(gradI,4.),*pgrad);
+ gmm::add(gmm::scaled(gradII,-3.),*pgrad);
+ }
+ } else if (function_num == 5) {
+ base_small_vector modeI(2), modeII(2), modeZ(2);
+ base_matrix gradI, gradII, gradZ;
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeI, 1, (pgrad) ? &gradI
: 0);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeII, 2, (pgrad) ?
&gradII : 0);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeZ, 100, (pgrad) ?
&gradZ : 0);
+ res = solution_P2(lambda, mu, x, pgrad);
+ res = -1. * res; if (pgrad) { for (size_type k=0; k < (*pgrad).size();
++k) (*pgrad)[k] = -(*pgrad)[k]; }
+ res += modeI*(1.) - modeII*3. - modeZ*.5;
+ if (pgrad) {
+ gmm::add(gmm::scaled(gradI,(1.)),*pgrad);
+ gmm::add(gmm::scaled(gradII,-3.),*pgrad);
+ gmm::add(gmm::scaled(gradZ,-.5),*pgrad);
+ }
+ } else if (function_num == 6) {
+ base_small_vector modeI(2), modeII(2), modeZI(2), modeZII(2);
+ base_matrix gradI, gradII, gradZI, gradZII;
+ scalar_type coef[5] = {0.5,1,1.5,1,0};
+ res = solution_P2(lambda, mu, x, pgrad);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeI, 1, (pgrad) ? &gradI
: 0);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeII, 2, (pgrad) ?
&gradII : 0);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeZI, 100, (pgrad) ?
&gradZI : 0);
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], modeZII, 101, (pgrad) ?
&gradZII : 0);
+ //res = -1. * res; if (pgrad) { for (size_type k=0; k < (*pgrad).size();
++k) (*pgrad)[k] = -(*pgrad)[k]; }
+ res = res*coef[0] + modeI*coef[1] + modeII*coef[2] + modeZI*coef[3] +
modeZII*coef[4];
+
+ if (pgrad) {
+ if (pgrad) { for (size_type k=0; k < (*pgrad).size(); ++k) (*pgrad)[k]
*= coef[0]; }
+ gmm::add(gmm::scaled(gradI,coef[1]),*pgrad);
+ gmm::add(gmm::scaled(gradII,coef[2]),*pgrad);
+ gmm::add(gmm::scaled(gradZI,coef[3]),*pgrad);
+ gmm::add(gmm::scaled(gradZII,coef[4]),*pgrad);
+ }
+ } else if (function_num == 7) {
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], res, 100, pgrad);
+ res /= -40; if (pgrad) gmm::scale(*pgrad, -1./40);
+ } else if (function_num == 8) {
+ sol_ref_infinite_plane(lambda, mu, x[0], x[1], res, 101, pgrad);
+ res /= 200; if (pgrad) gmm::scale(*pgrad, 1./200);
+ }
+ return res;
+}
+
+scalar_type crack_exact_solution_function::val(scalar_type x, scalar_type y)
const {
+ return eval(base_node(x,y), 0)[component_num];
+}
+
+base_small_vector crack_exact_solution_function::grad(scalar_type x,
scalar_type y) const {
+ base_matrix gr(2,2);
+ eval(base_node(x,y), &gr);
+ base_small_vector v(2);
+ for (unsigned i=0; i < 2; ++i) v[i] = gr(i,component_num);
+ return v;
+}
+
+
+
+void crack_exact_solution::init(int function_num, scalar_type lambda,
scalar_type mu,
+ getfem::level_set &ls) {
+ std::vector<getfem::pglobal_function> cfun(2);
+ for (unsigned i = 0; i < 2; ++i) {
+ /* use the singularity */
+ getfem::pxy_function
+ s = std::make_shared<crack_exact_solution_function>
+ (function_num, i, lambda, mu);
+ cfun[i] = getfem::global_function_on_level_set(ls, s);
+ }
+
+ mf.set_functions(cfun);
+
+ mf.set_qdim(1);
+
+ U.resize(4); assert(mf.nb_dof() == 2);
+ U[0] = 1; U[1] = 0;
+ U[2] = 0; U[3] = 1;
+}
diff --git a/contrib/3D_Crack/crack_3D_exact_solution.h
b/contrib/3D_Crack/crack_3D_exact_solution.h
new file mode 100644
index 0000000..1ce5132
--- /dev/null
+++ b/contrib/3D_Crack/crack_3D_exact_solution.h
@@ -0,0 +1,94 @@
+/* -*- c++ -*- (enables emacs c++ mode) */
+/*===========================================================================
+
+ Copyright (C) 2007-2017 Yves Renard, Julien Pommier.
+
+ This file is a part of GetFEM++
+
+ GetFEM++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version along with the GCC Runtime Library
+ Exception either version 3.1 or (at your option) any later version.
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License and GCC Runtime Library Exception for more details.
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ As a special exception, you may use this file as it is a part of a free
+ software library without restriction. Specifically, if other files
+ instantiate templates or use macros or inline functions from this file,
+ or you compile this file and link it with other files to produce an
+ executable, this file does not by itself cause the resulting executable
+ to be covered by the GNU Lesser General Public License. This exception
+ does not however invalidate any other reasons why the executable file
+ might be covered by the GNU Lesser General Public License.
+
+===========================================================================*/
+
+#include "getfem/getfem_mesh_fem_global_function.h"
+
+using std::endl; using std::cout; using std::cerr;
+using std::ends; using std::cin;
+
+
+/* some GetFEM++ types that we will be using */
+using bgeot::base_small_vector; /* special class for small (dim<16) vectors */
+using bgeot::base_node; /* geometrical nodes(derived from base_small_vector)*/
+using bgeot::scalar_type; /* = double */
+using bgeot::size_type; /* = unsigned long */
+using bgeot::dim_type;
+using bgeot::short_type;
+using bgeot::base_matrix; /* small dense matrix. */
+
+#define VALIDATE_XFEM
+
+#ifdef VALIDATE_XFEM
+
+struct crack_exact_solution_function : public getfem::abstract_xy_function {
+ unsigned function_num;
+ unsigned component_num; /* 0 -> x component, 1 -> y component */
+ scalar_type lambda, mu;
+ virtual scalar_type val(scalar_type x, scalar_type y) const;
+ virtual base_small_vector grad(scalar_type x, scalar_type y) const;
+ virtual base_matrix hess(scalar_type, scalar_type) const
+ { GMM_ASSERT1(false, "Sorry, to be done ..."); }
+ crack_exact_solution_function(unsigned fnum,
+ unsigned cnum,
+ scalar_type l, scalar_type m) {
+ function_num = fnum;
+ component_num = cnum;
+ lambda = l; mu = m;
+ }
+ base_small_vector eval(const base_node &x, base_matrix *pgrad) const;
+};
+
+
+struct crack_exact_solution {
+ getfem::mesh_fem_global_function mf;
+ getfem::base_vector U;
+
+ crack_exact_solution(getfem::mesh &me) : mf(me) {}
+
+ void init(int function_num, scalar_type lambda, scalar_type mu,
+ getfem::level_set &ls);
+};
+
+inline base_small_vector sol_f(const base_node &x) {
+ int N = x.size();
+ base_small_vector res(N);
+ return res;
+}
+
+#else
+
+inline base_small_vector sol_f(const base_node &x) {
+ int N = x.size();
+ base_small_vector res(N); res[N-1] = x[N-1];
+ return res;
+}
+
+#endif
diff --git a/contrib/3D_Crack/getfem_Xfem.cc b/contrib/3D_Crack/getfem_Xfem.cc
new file mode 100644
index 0000000..639477c
--- /dev/null
+++ b/contrib/3D_Crack/getfem_Xfem.cc
@@ -0,0 +1,196 @@
+/*===========================================================================
+
+ Copyright (C) 2003-2017 Yves Renard
+
+ This file is a part of GetFEM++
+
+ GetFEM++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version along with the GCC Runtime Library
+ Exception either version 3.1 or (at your option) any later version.
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License and GCC Runtime Library Exception for more details.
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+===========================================================================*/
+
+#include "getfem_Xfem.h"
+
+namespace getfem
+{
+ void Xfem::valid(void) {
+ init_cvs_node();
+ /* setup nodes of the base fem */
+ if (pfb)
+ for (size_type k = 0; k < pfb->nb_base(0); ++k)
+ add_node(pfb->dof_types()[k], pfb->node_of_dof(0,k));
+
+ /* setup nodes of the enriched fems */
+ for (size_type k = 0; k < nb_func; ++k) {
+ for (size_type j = 0; j < pfe(k)->nb_base(0); ++j) {
+ add_node(xfem_dof(pfe(k)->dof_types()[j], func_indices[k]),
+ pfe(k)->node_of_dof(0,j));
+ }
+ }
+ is_valid = true;
+ }
+
+ size_type Xfem::nb_dof(size_type) const {
+ GMM_ASSERT1(is_valid, "Valid the Xfem element before using it");
+ return dof_types_.size();
+ }
+
+ void Xfem::add_func(pfem pf, pXfem_func pXf, size_type ind) {
+ if (!pfb) init(pf);
+ nb_func ++;
+ if (ind == size_type(-1)) ind = nb_func;
+ funcs.resize(nb_func);
+ func_indices.resize(nb_func);
+ funcs[nb_func-1] = pXf;
+ if (cvr != pf->ref_convex(0) || (pfb && pfb->target_dim() !=
pf->target_dim()))
+ GMM_ASSERT1(false, "Incompatible Xfem fems");
+
+ /* insert the new fem in the list */
+ std::vector<pfem>::const_iterator it;
+ if ((it=std::find(uniq_pfe.begin(), uniq_pfe.end(), pf)) ==
uniq_pfe.end()) {
+ uniq_pfe.push_back(pf); func_pf.push_back(uniq_pfe.size()-1);
+ } else {
+ func_pf.push_back(it - uniq_pfe.begin());
+ }
+
+ func_indices[nb_func-1] = ind;
+ is_valid = false;
+ }
+
+ /* create an interpolation_context array based on
+ c0, for each fem of the Xfem. */
+ void Xfem::get_fem_interpolation_context_tab(const
fem_interpolation_context& c0,
+
std::vector<fem_interpolation_context>& vc) const {
+ vc.resize(uniq_pfe.size());
+ for (size_type k=0; k < uniq_pfe.size(); ++k) {
+ vc[k] = c0;
+ if (c0.have_pfp()) {
+ vc[k].set_pfp(fem_precomp(uniq_pfe[k], c0.pfp()->get_ppoint_tab(),
+ c0.pfp()));
+ } else { vc[k].set_pf(uniq_pfe[k]); }
+ }
+ }
+
+ void Xfem::base_value(const base_node &, base_tensor &) const
+ { GMM_ASSERT1(false, "No base values, real only element."); }
+ void Xfem::grad_base_value(const base_node &, base_tensor &) const
+ { GMM_ASSERT1(false, "No base values, real only element."); }
+ void Xfem::hess_base_value(const base_node &, base_tensor &) const
+ { GMM_ASSERT1(false, "No base values, real only element."); }
+
+ void Xfem::real_base_value(const fem_interpolation_context &c,
+ base_tensor &t, bool) const {
+ bgeot::multi_index mi(2);
+ mi[1] = target_dim(); mi[0] = short_type(nb_base(0));
+ t.adjust_sizes(mi);
+ scalar_type a;
+ Xfem_func_context ctx(c);
+ base_tensor::iterator it = t.begin();
+ fem_interpolation_context c0 = c;
+ base_tensor tt;
+ if (pfb) {
+ if (c0.have_pfp())
+ c0.set_pfp(fem_precomp(pfb, c0.pfp()->get_ppoint_tab(), c0.pfp()));
+ else c0.set_pf(pfb);
+ c0.base_value(tt);
+ }
+ base_tensor::const_iterator itf = tt.begin();
+ std::vector<fem_interpolation_context> vc;
get_fem_interpolation_context_tab(c, vc);
+ for (dim_type q = 0; q < target_dim(); ++q) {
+ for (size_type i = 0; i < (pfb ? pfb->nb_base(0) : 0); ++i, ++itf, ++it)
+ *it = *itf;
+ for (size_type k = 0; k < nb_func; ++k) {
+ base_tensor val_e; vc[func_pf[k]].base_value(val_e);
+ ctx.pf = pfe(k);
+ for (size_type i = 0; i < pfe(k)->nb_base(0); ++i, ++it) {
+ ctx.base_num = i; a = funcs[k]->val(ctx);
+ *it = val_e[i + q*pfe(k)->nb_base(0)] * a;
+ }
+ }
+ }
+ }
+
+ void Xfem::real_grad_base_value(const fem_interpolation_context &c,
+ base_tensor &t, bool) const {
+ bgeot::multi_index mi(3);
+ mi[2] = short_type(c.N()); mi[1] = target_dim();
+ mi[0] = short_type(nb_base(0));
+ t.adjust_sizes(mi);
+
+ Xfem_func_context ctx(c);
+ fem_interpolation_context c0 = c;
+ base_tensor tt;
+ if (pfb) {
+ if (c0.have_pfp())
+ c0.set_pfp(fem_precomp(pfb, c0.pfp()->get_ppoint_tab(), c0.pfp()));
+ else c0.set_pf(pfb);
+ c0.grad_base_value(tt);
+ }
+
+ base_tensor::iterator it = t.begin();
+ base_tensor::const_iterator itvf = tt.begin();
+ std::vector<fem_interpolation_context> vc;
get_fem_interpolation_context_tab(c, vc);
+ std::vector<base_tensor> val_e(nb_func);
+ std::vector<base_tensor> grad_e(nb_func);
+ for (size_type i=0; i < uniq_pfe.size(); ++i) {
+ vc[i].base_value(val_e[i]); vc[i].grad_base_value(grad_e[i]);
+ }
+ std::vector<std::vector<scalar_type> > vf(nb_func);
+ std::vector<std::vector<base_small_vector> > gvf(nb_func);
+ for (size_type f = 0; f < nb_func; ++f) {
+ vf[f].resize(pfe(f)->nb_base(0));
+ gvf[f].resize(pfe(f)->nb_base(0));
+ ctx.pf = pfe(f);
+ for (ctx.base_num=0; ctx.base_num < pfe(f)->nb_base(0); ++ctx.base_num) {
+ vf[f][ctx.base_num] = funcs[f]->val(ctx);
+ gvf[f][ctx.base_num] = funcs[f]->grad(ctx);
+ }
+ }
+
+ // cerr << "pfp->val(ii)={";
+ // for (size_type i=0; i < pfp->val(ii).size(); ++i) cerr <<
pfp->val(ii)[i] << " "; cerr << "}\n";
+
+ for (dim_type k = 0; k < c.N() ; ++k) {
+ for (dim_type q = 0; q < target_dim(); ++q) {
+ for (size_type i = 0; i < (pfb ? pfb->nb_base(0) : 0); ++i, ++it)
+ *it = *itvf++;
+ for (size_type f = 0; f < nb_func; ++f) {
+ size_type posg = pfe(f)->nb_base(0)*(q + k*target_dim());
+ size_type posv = pfe(f)->nb_base(0)*q;
+ for (size_type i = 0; i < pfe(f)->nb_base(0); ++i, ++it) {
+ *it = grad_e[func_pf[f]][i + posg] * vf[f][i];
+ *it += gvf[f][i][k] * (val_e[func_pf[f]])[i + posv];
+ }
+ }
+ }
+ }
+ }
+
+ void Xfem::real_hess_base_value(const fem_interpolation_context &,
+ base_tensor &, bool) const
+ { GMM_ASSERT1(false, "Sorry order 2 derivatives for Xfem to be done."); }
+
+ void Xfem::init(pfem pf) {
+ cvr = pf->ref_convex(0);
+ dim_ = cvr->structure()->dim();
+ is_equiv = real_element_defined = true;
+ is_polycomp = is_pol = is_lag = false;
+ es_degree = 5; /* humm ... */
+ ntarget_dim = pf->target_dim();
+ }
+
+ Xfem::Xfem(pfem pf) : pfb(pf), is_valid(false), nb_func(0) {
+ if (pf) init(pfb);
+ }
+
+} /* end of namespace getfem. */
diff --git a/contrib/3D_Crack/getfem_Xfem.h b/contrib/3D_Crack/getfem_Xfem.h
new file mode 100644
index 0000000..da17ec3
--- /dev/null
+++ b/contrib/3D_Crack/getfem_Xfem.h
@@ -0,0 +1,127 @@
+/* -*- c++ -*- (enables emacs c++ mode) */
+/*===========================================================================
+
+ Copyright (C) 2003-2017 Yves Renard
+
+ This file is a part of GetFEM++
+
+ GetFEM++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version along with the GCC Runtime Library
+ Exception either version 3.1 or (at your option) any later version.
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License and GCC Runtime Library Exception for more details.
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ As a special exception, you may use this file as it is a part of a free
+ software library without restriction. Specifically, if other files
+ instantiate templates or use macros or inline functions from this file,
+ or you compile this file and link it with other files to produce an
+ executable, this file does not by itself cause the resulting executable
+ to be covered by the GNU Lesser General Public License. This exception
+ does not however invalidate any other reasons why the executable file
+ might be covered by the GNU Lesser General Public License.
+
+===========================================================================*/
+
+/**@file getfem_Xfem.h
+ @author Yves Renard <address@hidden>
+ @date April 8, 2003.
+ @brief eXtended Finite Element Method.
+
+ what is an Xfem ?
+
+ It is a "base" fem (for example PK(2,2)), with additional base
+ functions.
+ These additionnal base functions are the product of:
+ - a global function (the virtual_Xfem_func)
+ - base functions of another fem (for example PK(2,1))
+
+ The Xfem is built using the add_func member function, which takes
+ as parameters, a global function and a fem.
+
+ example of use: enrichment of the finite elements space with
+ particular functions, which may represent discontinuities of the
+ field in some elements, or singularities in the field (crack tip
+ functions..)
+*/
+
+#include "getfem/getfem_fem.h"
+#include "getfem/getfem_mesh_fem.h"
+/* Works only for tau-equivalent elements */
+
+namespace getfem
+{
+ struct Xfem_func_context {
+ base_node xreal, xref;
+ pfem pf;
+ bgeot::pgeometric_trans pgt;
+ size_type base_num; /* number of the current base function of pf */
+ const base_matrix& G;
+ Xfem_func_context(const fem_interpolation_context &c) :
+ xreal(c.xreal()), xref(c.xref()), pgt(c.pgt()), G(c.G()) {}
+ };
+
+ // Object representing global functions. To be derived.
+
+ struct virtual_Xfem_func {
+ /*
+ */
+ virtual scalar_type val(const Xfem_func_context&)
+ { GMM_ASSERT1(false, "this Xfem_func has no value"); }
+ virtual base_small_vector grad(const Xfem_func_context&)
+ { GMM_ASSERT1(false, "this Xfem_func has no gradient"); }
+ virtual base_matrix hess(const Xfem_func_context&)
+ { GMM_ASSERT1(false, "this Xfem_func has no hessian"); }
+ virtual ~virtual_Xfem_func() {}
+ };
+ typedef virtual_Xfem_func *pXfem_func;
+
+ // Xfem definition
+
+ class Xfem : public virtual_fem {
+
+ protected:
+ pfem pfb; // base fem
+ std::vector<pfem> uniq_pfe;
+ std::vector<size_type> func_pf; // nb_func fems which are enriched
(indexes in the array uniq_pfe)
+ bool is_valid;
+ size_type nb_func;
+ std::vector<pXfem_func> funcs; // List of functions to be added
+ std::vector<size_type> func_indices;
+
+ void get_fem_interpolation_context_tab(
+ const fem_interpolation_context& c0,
+ std::vector<fem_interpolation_context>& vc) const;
+ pfem pfe(size_type k) const { return uniq_pfe[func_pf[k]]; }
+ public:
+
+ void valid(void);
+
+ virtual size_type nb_dof(size_type) const;
+
+ /* ind should be > 0 */
+ void add_func(pfem pf, pXfem_func pXf,
+ size_type ind = size_type(-1));
+
+ void base_value(const base_node &x, base_tensor &t) const;
+ void grad_base_value(const base_node &x, base_tensor &t) const;
+ void hess_base_value(const base_node &x, base_tensor &t) const;
+
+ void real_base_value(const fem_interpolation_context& c,
+ base_tensor &t, bool = true) const;
+ void real_grad_base_value(const fem_interpolation_context& c,
+ base_tensor &t, bool = true) const;
+ void real_hess_base_value(const fem_interpolation_context& c,
+ base_tensor &t, bool = true) const;
+ void init(pfem pf);
+ Xfem(pfem pf);
+ };
+
+
+} /* end of namespace getfem. */
diff --git a/contrib/3D_Crack/getfem_spider_fem.h
b/contrib/3D_Crack/getfem_spider_fem.h
new file mode 100644
index 0000000..797c839
--- /dev/null
+++ b/contrib/3D_Crack/getfem_spider_fem.h
@@ -0,0 +1,255 @@
+/* -*- c++ -*- (enables emacs c++ mode) */
+/*===========================================================================
+
+ Copyright (C) 2004-2017 Yves Renard
+
+ This file is a part of GetFEM++
+
+ GetFEM++ is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version along with the GCC Runtime Library
+ Exception either version 3.1 or (at your option) any later version.
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License and GCC Runtime Library Exception for more details.
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ As a special exception, you may use this file as it is a part of a free
+ software library without restriction. Specifically, if other files
+ instantiate templates or use macros or inline functions from this file,
+ or you compile this file and link it with other files to produce an
+ executable, this file does not by itself cause the resulting executable
+ to be covered by the GNU Lesser General Public License. This exception
+ does not however invalidate any other reasons why the executable file
+ might be covered by the GNU Lesser General Public License.
+
+===========================================================================*/
+
+/**@file getfem_spider_fem.h
+ @author Yves Renard <address@hidden>
+ @date October 29, 2004.
+ @brief work in progress...
+*/
+
+#ifndef GETFEM_SPIDER_FEM_H__
+#define GETFEM_SPIDER_FEM_H__
+
+#include "getfem/getfem_interpolated_fem.h"
+#include "getfem_Xfem.h"
+#include "getfem/getfem_regular_meshes.h"
+
+namespace getfem {
+
+
+ struct Xfem_sqrtr : public virtual_Xfem_func {
+
+
+ virtual scalar_type val(const Xfem_func_context &c)
+ { return ::sqrt(c.xreal[0]); }
+ // { return ::sqrt(c.xreal[0])*cos(log(c.xreal[0])); }
+ virtual base_small_vector grad(const Xfem_func_context &c)
+ { base_small_vector V(2);
+ V[0] = 1. / (2.* ::sqrt(c.xreal[0])); return V; }
+ // V[0] = (1./::sqrt(c.xreal[0]))( (cos(log(::sqrt(c.xreal[0])^2)))/2. -
sin(log(::sqrt(c.xreal[0])^2)) ); return V; }
+ virtual base_matrix hess(const Xfem_func_context &c) {
+ base_matrix m(2,2);
+ m(0,0) = 1. / (4.* ::sqrt(c.xreal[0])*c.xreal[0]);
+ //m(0,0) = ((1./::sqrt(c.xreal[0]))^(3))( (3. *
cos(log(::sqrt(c.xreal[0])^2)))/4. - sin(log(::sqrt(c.xreal[0])^2)));
+ return m;
+ }
+ };
+
+
+ struct Xfem_sqrtrcos : public virtual_Xfem_func {
+
+ scalar_type eps;
+ virtual scalar_type val(const Xfem_func_context &c) {
+ return ::sqrt(c.xreal[0]) * cos( eps*log(c.xreal[0]) );
+ }
+
+ virtual base_small_vector grad(const Xfem_func_context &c) {
+ base_small_vector V(2);
+ V[0] = ( 1./::sqrt( c.xreal[0]) ) * ( cos( eps*log(c.xreal[0]) )/2. -
eps*sin( eps*log(c.xreal[0]) ) );
+ return V;
+ }
+
+ virtual base_matrix hess(const Xfem_func_context &c) {
+ base_matrix m(2,2);
+ m(0,0) = (1./::pow(sqrt(c.xreal[0]),3.)) * ( ((-1./4.) - ::pow(eps,2.))
* cos( eps*log(c.xreal[0]) ) );
+ return m;
+ }
+ };
+
+
+ struct Xfem_sqrtrsin : public virtual_Xfem_func {
+
+ scalar_type eps;
+ virtual scalar_type val(const Xfem_func_context &c) {
+ return ::sqrt(c.xreal[0]) * sin( eps*log(c.xreal[0]) );
+ }
+
+ virtual base_small_vector grad(const Xfem_func_context &c) {
+ base_small_vector V(2);
+ V[0] = ( 1./::sqrt(c.xreal[0]) ) * ( sin( eps*log(c.xreal[0]) )/2. +
eps*cos( eps*log(c.xreal[0]) ) );
+ return V;
+ }
+
+ virtual base_matrix hess(const Xfem_func_context &c) {
+ base_matrix m(2,2);
+ m(0,0) = (1./::pow(sqrt(c.xreal[0]),3.)) * ( ((-1./4.) - ::pow(eps,2.))
* sin( eps*log(c.xreal[0]) ) );
+ return m;
+ }
+ };
+
+
+
+ /*
+ struct Xfem_sqrtr : public virtual_Xfem_func {
+ virtual scalar_type val(const Xfem_func_context &c)
+ { return 1; }
+ virtual base_small_vector grad(const Xfem_func_context &c)
+ { base_small_vector V(2); return V; }
+ virtual base_matrix hess(const Xfem_func_context &c) {
+ base_matrix m(2,2); return m;
+ }
+ };
+ */
+
+ struct interpolated_transformation : public virtual_interpolated_func{
+ /* Polar transformation and its gradient. */
+ base_small_vector trans;
+ scalar_type theta0;
+
+ virtual void val(const base_node &xreal, base_node &v) const {
+ base_node w = xreal - trans;
+ v[0] = gmm::vect_norm2(w);
+ v[1] = atan2(w[1], w[0]) - theta0;
+ }
+ virtual void grad(const base_small_vector &xreal, base_matrix &m) const {
+ base_node w = xreal - trans;
+ scalar_type r = gmm::vect_norm2(w); assert(gmm::abs(r)>1e-30);
+ m(0,0) = w[0] / r; m(0,1) = w[1] / r;
+ m(1,0) = -w[1] / gmm::sqr(r); m(1,1) = w[0] / gmm::sqr(r);
+ }
+ virtual void hess(const base_node &, base_matrix &) const
+ { GMM_ASSERT1(false, "this interpolated_func has no hessian"); }
+
+
+ virtual ~interpolated_transformation() {}
+ };
+
+ DAL_SIMPLE_KEY(special_cartesianfem_key, pfem);
+
+ class spider_fem {
+
+ protected :
+
+ mesh cartesian;
+ mesh_fem cartesian_fem;
+ pfem Qk;
+ std::shared_ptr<Xfem> penriched_Qk;
+ scalar_type R;
+ unsigned Nr, Ntheta, K;
+ Xfem_sqrtr Sqrtr;
+ Xfem_sqrtrcos Sqrtrcos;
+ Xfem_sqrtrsin Sqrtrsin;
+ int bimat_enrichment;
+ scalar_type epsilon;
+ pfem final_fem;
+ interpolated_transformation itt;
+
+ public :
+
+ pfem get_pfem(void) { return final_fem; }
+
+ ~spider_fem () {
+ pfem pf(penriched_Qk);
+ dal::del_stored_object(pf);
+ if (final_fem) del_interpolated_fem(final_fem);
+ }
+ spider_fem(scalar_type R_, mesh_im &mim, unsigned Nr_, unsigned Ntheta_,
+ unsigned K_, base_small_vector translation, scalar_type theta0,
+ int bimat_enrichment_ = 0, scalar_type epsilon_ = scalar_type(0))
+ : cartesian_fem(cartesian), R(R_), Nr(Nr_),
+ Ntheta(Ntheta_), K(K_), bimat_enrichment(bimat_enrichment_),
epsilon(epsilon_), final_fem(0) {
+
+ itt.trans = translation;
+ itt.theta0 = theta0;
+
+ /* make the cartesian mesh */
+ bgeot::pgeometric_trans pgt =
+ bgeot::geometric_trans_descriptor("GT_LINEAR_QK(2)");
+ std::vector<size_type> nsubdiv(2);
+ nsubdiv[0] = Nr; nsubdiv[1] = Ntheta;
+ getfem::regular_unit_mesh(cartesian, nsubdiv, pgt, false);
+ bgeot::base_matrix M(2,2);
+ M(0,0) = R;
+ M(1,1) = 2. * M_PI;
+ cartesian.transformation(M);
+ bgeot::base_small_vector V(2);
+ V[1] = -M_PI;
+ cartesian.translation(V);
+
+ getfem::mesh_region border_faces;
+ getfem::outer_faces_of_mesh(cartesian, border_faces);
+ for (getfem::mr_visitor it(border_faces); !it.finished(); ++it) {
+ base_node un = cartesian.normal_of_face_of_convex(it.cv(), it.f());
+ un /= gmm::vect_norm2(un);
+ if (un[0] >= 0.8) cartesian.region(0).add(it.cv(), it.f());
+ }
+
+ std::stringstream Qkname;
+ Qkname << "FEM_QK(2," << K << ")";
+ Qk = fem_descriptor(Qkname.str());
+ penriched_Qk = std::make_shared<Xfem>(pfem());
+ if(bimat_enrichment == 0){
+ cout << "Using SpiderFem homogenuous isotropic enrichment
[sqrt(r)]..." << endl;
+ penriched_Qk->add_func(Qk, &Sqrtr);
+ }
+ else {
+ cout << "Using SpiderFem bimaterial enrichement..." << endl;
+ Sqrtrcos.eps = epsilon;
+ Sqrtrsin.eps = epsilon;
+ //cout << "epsilon = " << epsilon << endl;
+ penriched_Qk->add_func(Qk, &Sqrtrcos);
+ penriched_Qk->add_func(Qk, &Sqrtrsin);
+ }
+ penriched_Qk->valid();
+ pfem pf(penriched_Qk);
+ dal::pstatic_stored_object_key
+ pk = std::make_shared<special_cartesianfem_key>(pf);
+ dal::add_stored_object(pk, pf, pf->ref_convex(0), pf->node_tab(0));
+
+ cartesian_fem.set_finite_element(cartesian.convex_index(), pf);
+ GMM_ASSERT1(!cartesian_fem.is_reduced(), "To be adapted");
+ dal::bit_vector blocked_dof = cartesian_fem.basic_dof_on_region(0);
+ // cout << "blocked dofs = " << blocked_dof << endl;
+
+ final_fem = new_interpolated_fem(cartesian_fem, mim,&itt,blocked_dof,
false);
+ }
+ void check() {
+ const interpolated_fem &ife = dynamic_cast<const
interpolated_fem&>(*final_fem);
+ dal::bit_vector bv = ife.interpolated_convexes();
+ cerr << "interpolated_convexes: nb=" << bv.card() << "; " << bv << "\n";
+ unsigned ming, maxg;
+ scalar_type meang;
+ ife.gauss_pts_stats(ming,maxg,meang);
+ cerr << " gauss pts in interpolated mesh_fem convexes: min=" << ming <<
", max=" << maxg << ", meang=" << meang << "\n";
+ if (bv.card() != cartesian.convex_index().card()) {
+ cerr << cartesian.convex_index().card() - bv.card() <<
+ "convexes missed by interpolated_fem, increase the "
+ "number of integration points";
+ GMM_ASSERT3(false, "");
+ }
+ }
+ };
+
+
+
+} /* end of namespace getfem. */
+
+#endif
diff --git a/contrib/3D_Crack/untitled.geo b/contrib/3D_Crack/untitled.geo
new file mode 100644
index 0000000..a3a6f26
--- /dev/null
+++ b/contrib/3D_Crack/untitled.geo
@@ -0,0 +1,9 @@
+//+
+SetFactory("OpenCASCADE");
+Box(1) = {-0.5, -0.5, 0, 1, 1, 1};
+//+
+Box(2) = {-0.5, -0.5, 0, 1, 1, 1};
+//+
+Box(3) = {0.6, -0.5, 0, 1, 1, 1};
+//+
+Compound Volume(4) = {3};
diff --git a/getfem.config b/getfem.config
new file mode 100644
index 0000000..e0284f4
--- /dev/null
+++ b/getfem.config
@@ -0,0 +1,2 @@
+// Add predefined macros for your project here. For example:
+// #define THE_ANSWER 42
diff --git a/getfem.creator b/getfem.creator
new file mode 100644
index 0000000..e94cbbd
--- /dev/null
+++ b/getfem.creator
@@ -0,0 +1 @@
+[General]
diff --git a/getfem.files b/getfem.files
new file mode 100644
index 0000000..95b9db9
--- /dev/null
+++ b/getfem.files
@@ -0,0 +1,1877 @@
+AUTHORS
+COPYING
+ChangeLog
+GNU_FDL_V3
+GNU_GCC_RUNTIME_EXCEPTION
+GNU_GPL_V3
+GNU_LGPL_V3
+INSTALL
+NEWS
+README
+autogen.sh
+bin/ansys2getfem_mesh
+bin/createmp
+bin/dr2dgnuplot
+bin/extract_doc
+bin/fig2eps
+bin/file_dependencies
+bin/makeheadfile
+bin/mesh_matlab_to_getfem
+bin/rst_to_xml.py
+bin/sc2dgnuplot
+bin/split_cmdref
+bin/test_dist
+bin/upload_documentation
+bin/upload_html
+bin/upload_misc
+bin/upload_version
+bin/word_count
+configure.ac
+contrib/aposteriori/aposteriori.cc
+contrib/aposteriori/aposteriori.m
+contrib/aposteriori/aposteriori.param
+contrib/aposteriori/aposteriori.pl
+contrib/aposteriori/aposteriori_laplacian.cc
+contrib/aposteriori/aposteriori_laplacian.param
+contrib/aposteriori/aposteriori_laplacian.pl
+contrib/aposteriori/bimaterial_crack_test.param
+contrib/bimaterial_crack_test/bimaterial_crack_test.cc
+contrib/bimaterial_crack_test/bimaterial_crack_test.param
+contrib/bimaterial_crack_test/bimaterial_crack_test.pl
+contrib/bimaterial_crack_test/crack.cc
+contrib/bimaterial_crack_test/crack.param
+contrib/bimaterial_crack_test/crack.pl
+contrib/bimaterial_crack_test/crack_exact_solution.cc
+contrib/bimaterial_crack_test/crack_exact_solution.h
+contrib/bimaterial_crack_test/getfem_Xfem.cc
+contrib/bimaterial_crack_test/getfem_Xfem.h
+contrib/bimaterial_crack_test/getfem_spider_fem.h
+contrib/crack_plate/crack_bilaplacian.cc
+contrib/crack_plate/crack_bilaplacian.h
+contrib/crack_plate/crack_bilaplacian.param
+contrib/crack_plate/crack_bilaplacian_mixed.param
+contrib/crack_plate/crack_bilaplacian_moment.cc
+contrib/crack_plate/crack_bilaplacian_problem.cc
+contrib/crack_plate/crack_bilaplacian_sif.cc
+contrib/crack_plate/crack_bilaplacian_singularities.cc
+contrib/crack_plate/crack_bilaplacian_tools.cc
+contrib/crack_plate/crack_mindlin.cc
+contrib/crack_plate/crack_mindlin.param
+contrib/crack_plate/crack_mindlin.pl
+contrib/crack_plate/crack_panel.cc
+contrib/crack_plate/crack_panel.param
+contrib/crack_plate/demi_plaque.mesh
+contrib/crack_plate/serie.pl
+contrib/delaminated_crack/delaminated_crack.cc
+contrib/delaminated_crack/delaminated_crack.param
+contrib/delaminated_crack/delaminated_crack.pl
+contrib/icare/icare.cc
+contrib/icare/icare.h
+contrib/icare/icare.param
+contrib/icare/icare.pl
+contrib/icare/icareplot.m
+contrib/icare/navier_stokes.net
+contrib/icare/navier_stokes_cylinder1.mesh
+contrib/icare/navier_stokes_cylinder2.mesh
+contrib/icare/tralala_3D.geo
+contrib/icare/tralala_3D.msh
+contrib/icare/triangular.msh
+contrib/level_set_contact/contact_2D.param
+contrib/level_set_contact/contact_3D.param
+contrib/level_set_contact/contact_problem.cpp
+contrib/level_set_contact/contact_problem.h
+contrib/level_set_contact/contact_problem.pl
+contrib/level_set_contact/test_contact.cpp
+contrib/mixed_elastostatic/mixed_elastostatic.cc
+contrib/mixed_elastostatic/mixed_elastostatic.param
+contrib/mixed_elastostatic/mixed_elastostatic.pl
+contrib/opt_assembly/opt_assembly.cc
+contrib/opt_assembly/opt_assembly.pl
+contrib/static_contact_gears/gear1.msh
+contrib/static_contact_gears/gear1_2D.msh
+contrib/static_contact_gears/gear1_2teeth.msh
+contrib/static_contact_gears/gear2.msh
+contrib/static_contact_gears/gear2_2D.msh
+contrib/static_contact_gears/gear2_2teeth.msh
+contrib/static_contact_gears/static_contact_gears.cc
+contrib/static_contact_gears/static_contact_gears.param
+contrib/static_contact_gears/static_contact_gears.pl
+contrib/static_contact_gears/static_contact_gears_2D.param
+contrib/static_contact_gears/static_contact_gears_2teeth.param
+contrib/static_contact_gears/static_contact_gears_u1_u2.cc
+contrib/static_contact_gears/static_contact_planetary.py
+contrib/static_contact_gears/static_contact_planetary_1.msh
+contrib/static_contact_gears/static_contact_planetary_2.msh
+contrib/static_contact_gears/static_contact_planetary_3.msh
+contrib/static_contact_gears/static_contact_planetary_4.msh
+contrib/static_contact_gears/static_contact_planetary_5.msh
+contrib/test_plasticity/conv_test_small_strain_plasticity.py
+contrib/test_plasticity/test_plasticity.py
+contrib/test_plasticity/test_small_strain_plasticity.m
+contrib/test_plasticity/test_small_strain_plasticity.py
+contrib/tests_newton/punch2D_h1.mesh
+contrib/tests_newton/punch2D_h4.mesh
+contrib/tests_newton/static_contact_1.m
+contrib/tests_newton/static_contact_2.m
+contrib/tests_newton/static_contact_3.m
+contrib/xfem_contact/plot_xfem_dirichlet.m
+contrib/xfem_contact/xfem_contact.cc
+contrib/xfem_contact/xfem_contact.param
+contrib/xfem_contact/xfem_contact.pl
+contrib/xfem_contact/xfem_dirichlet.cc
+contrib/xfem_contact/xfem_dirichlet.param
+contrib/xfem_contact/xfem_stokes.cc
+contrib/xfem_contact/xfem_stokes.param
+contrib/xfem_stab_unilat_contact/deformer.m
+contrib/xfem_stab_unilat_contact/xfem_stab_unilat_contact.cc
+contrib/xfem_stab_unilat_contact/xfem_stab_unilat_contact.m
+contrib/xfem_stab_unilat_contact/xfem_stab_unilat_contact.param
+contrib/xfem_stab_unilat_contact/xfem_stab_unilat_contact.pl
+cubature/CUBE4D_5.IM
+cubature/CUBE4D_9.IM
+cubature/GAUSSLOBATTO1D1.IM
+cubature/GAUSSLOBATTO1D11.IM
+cubature/GAUSSLOBATTO1D13.IM
+cubature/GAUSSLOBATTO1D15.IM
+cubature/GAUSSLOBATTO1D17.IM
+cubature/GAUSSLOBATTO1D19.IM
+cubature/GAUSSLOBATTO1D21.IM
+cubature/GAUSSLOBATTO1D23.IM
+cubature/GAUSSLOBATTO1D25.IM
+cubature/GAUSSLOBATTO1D27.IM
+cubature/GAUSSLOBATTO1D29.IM
+cubature/GAUSSLOBATTO1D3.IM
+cubature/GAUSSLOBATTO1D31.IM
+cubature/GAUSSLOBATTO1D33.IM
+cubature/GAUSSLOBATTO1D35.IM
+cubature/GAUSSLOBATTO1D37.IM
+cubature/GAUSSLOBATTO1D39.IM
+cubature/GAUSSLOBATTO1D41.IM
+cubature/GAUSSLOBATTO1D43.IM
+cubature/GAUSSLOBATTO1D45.IM
+cubature/GAUSSLOBATTO1D47.IM
+cubature/GAUSSLOBATTO1D49.IM
+cubature/GAUSSLOBATTO1D5.IM
+cubature/GAUSSLOBATTO1D51.IM
+cubature/GAUSSLOBATTO1D53.IM
+cubature/GAUSSLOBATTO1D55.IM
+cubature/GAUSSLOBATTO1D57.IM
+cubature/GAUSSLOBATTO1D59.IM
+cubature/GAUSSLOBATTO1D61.IM
+cubature/GAUSSLOBATTO1D63.IM
+cubature/GAUSSLOBATTO1D65.IM
+cubature/GAUSSLOBATTO1D67.IM
+cubature/GAUSSLOBATTO1D69.IM
+cubature/GAUSSLOBATTO1D7.IM
+cubature/GAUSSLOBATTO1D71.IM
+cubature/GAUSSLOBATTO1D73.IM
+cubature/GAUSSLOBATTO1D75.IM
+cubature/GAUSSLOBATTO1D77.IM
+cubature/GAUSSLOBATTO1D79.IM
+cubature/GAUSSLOBATTO1D81.IM
+cubature/GAUSSLOBATTO1D83.IM
+cubature/GAUSSLOBATTO1D85.IM
+cubature/GAUSSLOBATTO1D87.IM
+cubature/GAUSSLOBATTO1D89.IM
+cubature/GAUSSLOBATTO1D9.IM
+cubature/GAUSSLOBATTO1D91.IM
+cubature/GAUSSLOBATTO1D93.IM
+cubature/GAUSSLOBATTO1D95.IM
+cubature/GAUSSLOBATTO1D97.IM
+cubature/GAUSSLOBATTO1D99.IM
+cubature/Gauss1D1.IM
+cubature/Gauss1D11.IM
+cubature/Gauss1D13.IM
+cubature/Gauss1D15.IM
+cubature/Gauss1D17.IM
+cubature/Gauss1D19.IM
+cubature/Gauss1D21.IM
+cubature/Gauss1D23.IM
+cubature/Gauss1D25.IM
+cubature/Gauss1D27.IM
+cubature/Gauss1D29.IM
+cubature/Gauss1D3.IM
+cubature/Gauss1D31.IM
+cubature/Gauss1D33.IM
+cubature/Gauss1D35.IM
+cubature/Gauss1D37.IM
+cubature/Gauss1D39.IM
+cubature/Gauss1D41.IM
+cubature/Gauss1D43.IM
+cubature/Gauss1D45.IM
+cubature/Gauss1D47.IM
+cubature/Gauss1D49.IM
+cubature/Gauss1D5.IM
+cubature/Gauss1D51.IM
+cubature/Gauss1D53.IM
+cubature/Gauss1D55.IM
+cubature/Gauss1D57.IM
+cubature/Gauss1D59.IM
+cubature/Gauss1D61.IM
+cubature/Gauss1D63.IM
+cubature/Gauss1D65.IM
+cubature/Gauss1D67.IM
+cubature/Gauss1D69.IM
+cubature/Gauss1D7.IM
+cubature/Gauss1D71.IM
+cubature/Gauss1D73.IM
+cubature/Gauss1D75.IM
+cubature/Gauss1D77.IM
+cubature/Gauss1D79.IM
+cubature/Gauss1D81.IM
+cubature/Gauss1D83.IM
+cubature/Gauss1D85.IM
+cubature/Gauss1D87.IM
+cubature/Gauss1D89.IM
+cubature/Gauss1D9.IM
+cubature/Gauss1D91.IM
+cubature/Gauss1D93.IM
+cubature/Gauss1D95.IM
+cubature/Gauss1D97.IM
+cubature/Gauss1D99.IM
+cubature/HEXAHEDRON_11.IM
+cubature/HEXAHEDRON_5.IM
+cubature/HEXAHEDRON_9.IM
+cubature/NC_0_0.IM
+cubature/QUAD_17.IM
+cubature/QUAD_2.IM
+cubature/QUAD_3.IM
+cubature/QUAD_5.IM
+cubature/QUAD_7.IM
+cubature/QUAD_9.IM
+cubature/SIMPLEX4D_3.IM
+cubature/TETRA_1.IM
+cubature/TETRA_2.IM
+cubature/TETRA_3.IM
+cubature/TETRA_5.IM
+cubature/TETRA_6.IM
+cubature/TETRA_8.IM
+cubature/TRIANGLE_1.IM
+cubature/TRIANGLE_10.IM
+cubature/TRIANGLE_13.IM
+cubature/TRIANGLE_17.IM
+cubature/TRIANGLE_19.IM
+cubature/TRIANGLE_2.IM
+cubature/TRIANGLE_3.IM
+cubature/TRIANGLE_4.IM
+cubature/TRIANGLE_5.IM
+cubature/TRIANGLE_6.IM
+cubature/TRIANGLE_7.IM
+cubature/TRIANGLE_8.IM
+cubature/TRIANGLE_9.IM
+cubature/getFemIntGLetGLL.mws
+cubature/make_getfem_im_list
+doc/doxygen/Doxyfile
+doc/license.tex
+doc/sphinx/patch_tools.diff
+doc/sphinx/source/ACKS.txt
+doc/sphinx/source/about.rst
+doc/sphinx/source/biblio.bib
+doc/sphinx/source/biblio.rst
+doc/sphinx/source/bugs.rst
+doc/sphinx/source/conf.py
+doc/sphinx/source/contents.rst
+doc/sphinx/source/copyright.rst
+doc/sphinx/source/documenting/fromlatex.rst
+doc/sphinx/source/documenting/index.rst
+doc/sphinx/source/documenting/markup.rst
+doc/sphinx/source/documenting/rest.rst
+doc/sphinx/source/documenting/style.rst
+doc/sphinx/source/glossary.rst
+doc/sphinx/source/gmm/blas.rst
+doc/sphinx/source/gmm/blas_interface.rst
+doc/sphinx/source/gmm/catch.rst
+doc/sphinx/source/gmm/denselu.rst
+doc/sphinx/source/gmm/denseqr.rst
+doc/sphinx/source/gmm/export.rst
+doc/sphinx/source/gmm/first-step.rst
+doc/sphinx/source/gmm/images/gmmlogo.png
+doc/sphinx/source/gmm/index.rst
+doc/sphinx/source/gmm/inside.rst
+doc/sphinx/source/gmm/install.rst
+doc/sphinx/source/gmm/intro.rst
+doc/sphinx/source/gmm/iter.rst
+doc/sphinx/source/gmm/matrix.rst
+doc/sphinx/source/gmm/misc.rst
+doc/sphinx/source/gmm/noverif.rst
+doc/sphinx/source/gmm/qd.rst
+doc/sphinx/source/gmm/sub-matrix.rst
+doc/sphinx/source/gmm/superlu.rst
+doc/sphinx/source/gmm/triangular.rst
+doc/sphinx/source/install/install_linux.rst
+doc/sphinx/source/install/install_mac.rst
+doc/sphinx/source/install/install_windows.rst
+doc/sphinx/source/license.rst
+doc/sphinx/source/license.txt
+doc/sphinx/source/links.rst
+doc/sphinx/source/lists.rst
+doc/sphinx/source/matlab/code_samples/demo_laplacian.m
+doc/sphinx/source/matlab/code_samples/demo_step_by_step.m
+doc/sphinx/source/matlab/code_samples/demo_tripod.m
+doc/sphinx/source/matlab/examples.rst
+doc/sphinx/source/matlab/images/hierarchy.fig
+doc/sphinx/source/matlab/images/tripodvonmiseswithmesh.png
+doc/sphinx/source/matlab/index.rst
+doc/sphinx/source/matlab/install.rst
+doc/sphinx/source/matlab/intro.rst
+doc/sphinx/source/matlab/mlabgf.rst
+doc/sphinx/source/matlab/oocmd.rst
+doc/sphinx/source/matlab/plotcmdref.rst
+doc/sphinx/source/matlab/pre.rst
+doc/sphinx/source/project/appendixA.rst
+doc/sphinx/source/project/contribute.rst
+doc/sphinx/source/project/femdesc.rst
+doc/sphinx/source/project/images/diagram.fig
+doc/sphinx/source/project/images/getfem_structure.png
+doc/sphinx/source/project/images/getfem_structure.svg
+doc/sphinx/source/project/images/getfemelemelem.fig
+doc/sphinx/source/project/images/getfemtransgeo.fig
+doc/sphinx/source/project/images/tree_simple_laplace_tan.fig
+doc/sphinx/source/project/index.rst
+doc/sphinx/source/project/intro.rst
+doc/sphinx/source/project/libdesc.rst
+doc/sphinx/source/project/libdesc_cont.rst
+doc/sphinx/source/project/libdesc_dal.rst
+doc/sphinx/source/project/libdesc_event.rst
+doc/sphinx/source/project/libdesc_fem.rst
+doc/sphinx/source/project/libdesc_gmm.rst
+doc/sphinx/source/project/libdesc_high_gen_assemb.rst
+doc/sphinx/source/project/libdesc_im.rst
+doc/sphinx/source/project/libdesc_interface.rst
+doc/sphinx/source/project/libdesc_levelset.rst
+doc/sphinx/source/project/libdesc_low_gen_assemb.rst
+doc/sphinx/source/project/libdesc_mesh.rst
+doc/sphinx/source/project/libdesc_meshfem.rst
+doc/sphinx/source/project/libdesc_mim.rst
+doc/sphinx/source/project/libdesc_misc.rst
+doc/sphinx/source/project/libdesc_model.rst
+doc/sphinx/source/python/code_samples/demo_crack.py
+doc/sphinx/source/python/code_samples/demo_fictitious_domains.py
+doc/sphinx/source/python/code_samples/demo_laplacian.py
+doc/sphinx/source/python/code_samples/demo_step_by_step.py
+doc/sphinx/source/python/code_samples/demo_tripod.py
+doc/sphinx/source/python/code_samples/demo_tripod_alt.py
+doc/sphinx/source/python/code_samples/quad.geo
+doc/sphinx/source/python/code_samples/quad.msh
+doc/sphinx/source/python/code_samples/tripod.GiD.msh
+doc/sphinx/source/python/examples.rst
+doc/sphinx/source/python/howtos.rst
+doc/sphinx/source/python/images/hierarchy.fig
+doc/sphinx/source/python/images/laplacian.png
+doc/sphinx/source/python/images/step_by_step.png
+doc/sphinx/source/python/images/tripod.png
+doc/sphinx/source/python/index.rst
+doc/sphinx/source/python/install.rst
+doc/sphinx/source/python/intro.rst
+doc/sphinx/source/python/license.txt
+doc/sphinx/source/python/pre.rst
+doc/sphinx/source/python/pygf.rst
+doc/sphinx/source/replaces.txt
+doc/sphinx/source/scilab/images/hierarchy.fig
+doc/sphinx/source/scilab/index.rst
+doc/sphinx/source/scilab/install.rst
+doc/sphinx/source/scilab/intro.rst
+doc/sphinx/source/scilab/plotcmdref.rst
+doc/sphinx/source/scilab/scilabgf.rst
+doc/sphinx/source/screenshots/code_samples/demo_stokes_2D_tube.m
+doc/sphinx/source/screenshots/code_samples/demo_tripod.m
+doc/sphinx/source/screenshots/code_samples/demo_wave2D.m
+doc/sphinx/source/screenshots/helmholtz_source.rst
+doc/sphinx/source/screenshots/images/cuve_3D_streamlines_small.png
+doc/sphinx/source/screenshots/images/fissure_3d_de_traviole.png
+doc/sphinx/source/screenshots/images/gear.png
+doc/sphinx/source/screenshots/images/helm_k7_P10_gt6.png
+doc/sphinx/source/screenshots/images/helm_mesh_k7_P10_gt6.png
+doc/sphinx/source/screenshots/images/modestructure_paolo_small.png
+doc/sphinx/source/screenshots/images/pneu_Q2_vonmises_small.png
+doc/sphinx/source/screenshots/images/shape1.png
+doc/sphinx/source/screenshots/images/shape2.png
+doc/sphinx/source/screenshots/images/shape3.png
+doc/sphinx/source/screenshots/images/shape4.png
+doc/sphinx/source/screenshots/images/strangemesh_small.png
+doc/sphinx/source/screenshots/images/strangernd_small.png
+doc/sphinx/source/screenshots/images/torsion034.png
+doc/sphinx/source/screenshots/images/tripodvonmiseswithmesh_small.png
+doc/sphinx/source/screenshots/images/tube_small.png
+doc/sphinx/source/screenshots/images/xfembeam.png
+doc/sphinx/source/screenshots/images/xfembeammesh.png
+doc/sphinx/source/screenshots/shots.rst
+doc/sphinx/source/screenshots/stokes-source.rst
+doc/sphinx/source/screenshots/strange.mesh_fem
+doc/sphinx/source/screenshots/tripod_source.rst
+doc/sphinx/source/tutorial/basic_usage.rst
+doc/sphinx/source/tutorial/images/getfem_structure.png
+doc/sphinx/source/tutorial/images/mesh_thermo.png
+doc/sphinx/source/tutorial/images/solution_thermo.png
+doc/sphinx/source/tutorial/images/wheel.png
+doc/sphinx/source/tutorial/images/wheel_mesh.png
+doc/sphinx/source/tutorial/index.rst
+doc/sphinx/source/tutorial/install.rst
+doc/sphinx/source/tutorial/intro.rst
+doc/sphinx/source/tutorial/thermo_coupling.rst
+doc/sphinx/source/tutorial/wheel.rst
+doc/sphinx/source/userdoc/appendixA.rst
+doc/sphinx/source/userdoc/appendixB.rst
+doc/sphinx/source/userdoc/asm.rst
+doc/sphinx/source/userdoc/bfem.rst
+doc/sphinx/source/userdoc/binteg.rst
+doc/sphinx/source/userdoc/bmesh.rst
+doc/sphinx/source/userdoc/catch.rst
+doc/sphinx/source/userdoc/computeD.rst
+doc/sphinx/source/userdoc/computeL2H1.rst
+doc/sphinx/source/userdoc/convect.rst
+doc/sphinx/source/userdoc/export.rst
+doc/sphinx/source/userdoc/gasm_high.rst
+doc/sphinx/source/userdoc/gasm_low.rst
+doc/sphinx/source/userdoc/ifem.rst
+doc/sphinx/source/userdoc/iinteg.rst
+doc/sphinx/source/userdoc/images/ALE_rotating_body.fig
+doc/sphinx/source/userdoc/images/ALE_rotating_conf.fig
+doc/sphinx/source/userdoc/images/ALE_translation_body.fig
+doc/sphinx/source/userdoc/images/getfemlistHCT.fig
+doc/sphinx/source/userdoc/images/getfemlistRT0.fig
+doc/sphinx/source/userdoc/images/getfemlistargyris.fig
+doc/sphinx/source/userdoc/images/getfemlistcubeQ1.fig
+doc/sphinx/source/userdoc/images/getfemlistcubeQ3.fig
+doc/sphinx/source/userdoc/images/getfemlistincomplete.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodquad2.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodquad3.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodquad5.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtetrahedron1.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtetrahedron2.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtetrahedron3.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtetrahedron5.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle1.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle2.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle2comp.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle3.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle4.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle5.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle6.fig
+doc/sphinx/source/userdoc/images/getfemlistintmethodtriangle7.fig
+doc/sphinx/source/userdoc/images/getfemlistmorley.fig
+doc/sphinx/source/userdoc/images/getfemlistnedelec.fig
+doc/sphinx/source/userdoc/images/getfemlistprismP1.fig
+doc/sphinx/source/userdoc/images/getfemlistprismP2P1.fig
+doc/sphinx/source/userdoc/images/getfemlistprismP3.fig
+doc/sphinx/source/userdoc/images/getfemlistpyramidP0.fig
+doc/sphinx/source/userdoc/images/getfemlistpyramidP1.fig
+doc/sphinx/source/userdoc/images/getfemlistpyramidP2.fig
+doc/sphinx/source/userdoc/images/getfemlistquadQ1.fig
+doc/sphinx/source/userdoc/images/getfemlistquadQ3.fig
+doc/sphinx/source/userdoc/images/getfemlistquadc1composite.fig
+doc/sphinx/source/userdoc/images/getfemlistreducedHCT.fig
+doc/sphinx/source/userdoc/images/getfemlistreducedquadc1composite.fig
+doc/sphinx/source/userdoc/images/getfemlistsegmentPk.fig
+doc/sphinx/source/userdoc/images/getfemlistsegmentbubble.fig
+doc/sphinx/source/userdoc/images/getfemlistsegmenthermite.fig
+doc/sphinx/source/userdoc/images/getfemlistsegmenthier.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols00.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols01.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols02.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols03.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols04.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols05.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols06.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols07.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols08.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols09.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols10.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols11.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols12.fig
+doc/sphinx/source/userdoc/images/getfemlistsymbols13.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP1.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP1bubble.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP1bubbleface.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP2.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP2bubble.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP3bubble.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronP4.fig
+doc/sphinx/source/userdoc/images/getfemlisttetrahedronhermite.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1bubble.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1bubbleface.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1comp.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1comphier.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1linbubble.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1nonconforming.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP1withP2face.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP2.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP2bubble.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP3.fig
+doc/sphinx/source/userdoc/images/getfemlisttriangleP6.fig
+doc/sphinx/source/userdoc/images/getfemlisttrianglehermite.fig
+doc/sphinx/source/userdoc/images/getfemusercorrection.png
+doc/sphinx/source/userdoc/images/getfemuserelem.fig
+doc/sphinx/source/userdoc/images/getfemuserelemf.fig
+doc/sphinx/source/userdoc/images/getfemuserfrictionlaw.png
+doc/sphinx/source/userdoc/images/getfemuserfrictionlaw.svg
+doc/sphinx/source/userdoc/images/getfemuserlimitpoint.png
+doc/sphinx/source/userdoc/images/getfemuserlinearsys.fig
+doc/sphinx/source/userdoc/images/getfemuserlinsysDir.fig
+doc/sphinx/source/userdoc/images/getfemusermodeldetectcontact.fig
+doc/sphinx/source/userdoc/images/getfemusermodelfalsecontact1.fig
+doc/sphinx/source/userdoc/images/getfemusermodelfalsecontact2.fig
+doc/sphinx/source/userdoc/images/getfemusermodelmasterslave.fig
+doc/sphinx/source/userdoc/images/getfemuserrefine.fig
+doc/sphinx/source/userdoc/images/getfemusertransition.png
+doc/sphinx/source/userdoc/index.rst
+doc/sphinx/source/userdoc/install.rst
+doc/sphinx/source/userdoc/interMM.rst
+doc/sphinx/source/userdoc/interNMM.rst
+doc/sphinx/source/userdoc/intro.rst
+doc/sphinx/source/userdoc/linalg.rst
+doc/sphinx/source/userdoc/model.rst
+doc/sphinx/source/userdoc/model_ALE_rotating.rst
+doc/sphinx/source/userdoc/model_Mindlin_plate.rst
+doc/sphinx/source/userdoc/model_Nitsche.rst
+doc/sphinx/source/userdoc/model_bilaplacian.rst
+doc/sphinx/source/userdoc/model_constraint.rst
+doc/sphinx/source/userdoc/model_contact_friction.rst
+doc/sphinx/source/userdoc/model_contact_friction_large_sliding.rst
+doc/sphinx/source/userdoc/model_continuation.rst
+doc/sphinx/source/userdoc/model_dirichlet.rst
+doc/sphinx/source/userdoc/model_explicit.rst
+doc/sphinx/source/userdoc/model_fourier_robin.rst
+doc/sphinx/source/userdoc/model_generic_assembly.rst
+doc/sphinx/source/userdoc/model_generic_elliptic.rst
+doc/sphinx/source/userdoc/model_helmholtz.rst
+doc/sphinx/source/userdoc/model_linear_elasticity.rst
+doc/sphinx/source/userdoc/model_mass.rst
+doc/sphinx/source/userdoc/model_nonlinear_elasticity.rst
+doc/sphinx/source/userdoc/model_object.rst
+doc/sphinx/source/userdoc/model_plasticity_small_strain.rst
+doc/sphinx/source/userdoc/model_poisson.rst
+doc/sphinx/source/userdoc/model_solvers.rst
+doc/sphinx/source/userdoc/model_source_term.rst
+doc/sphinx/source/userdoc/model_time_integration.rst
+doc/sphinx/source/userdoc/parallel.rst
+doc/sphinx/source/userdoc/rmesh.rst
+doc/sphinx/source/userdoc/xfem.rst
+doc/sphinx/source/whatsnew/1.0.rst
+doc/sphinx/source/whatsnew/1.1.rst
+doc/sphinx/source/whatsnew/1.2.rst
+doc/sphinx/source/whatsnew/1.3.rst
+doc/sphinx/source/whatsnew/1.4.rst
+doc/sphinx/source/whatsnew/1.5.rst
+doc/sphinx/source/whatsnew/1.6.rst
+doc/sphinx/source/whatsnew/1.7.rst
+doc/sphinx/source/whatsnew/2.0.1.rst
+doc/sphinx/source/whatsnew/2.0.2.rst
+doc/sphinx/source/whatsnew/2.0.rst
+doc/sphinx/source/whatsnew/3.0.1.rst
+doc/sphinx/source/whatsnew/3.0.rst
+doc/sphinx/source/whatsnew/3.1.rst
+doc/sphinx/source/whatsnew/4.0.rst
+doc/sphinx/source/whatsnew/4.1.1.rst
+doc/sphinx/source/whatsnew/4.1.rst
+doc/sphinx/source/whatsnew/4.2.rst
+doc/sphinx/source/whatsnew/4.3.rst
+doc/sphinx/source/whatsnew/5.0.rst
+doc/sphinx/source/whatsnew/5.1.rst
+doc/sphinx/source/whatsnew/5.2.rst
+doc/sphinx/source/whatsnew/5.3.rst
+doc/sphinx/source/whatsnew/index.rst
+doc/web/doc.php
+doc/web/download.php
+doc/web/footer.inc
+doc/web/getfem_faq.php
+doc/web/getfem_intro.php
+doc/web/getfempython.php
+doc/web/gmm_faq.php
+doc/web/gmm_intro.php
+doc/web/header.inc
+doc/web/index.php
+doc/web/links.php
+doc/web/news.php
+doc/web/roadmap.php
+doc/web/shots.php
+doc/web/support.php
+doc/web/update_website.sh
+extract_gmm++
+getfem-config-notinstalled.in
+getfem-config.in
+gmm-config.in
+interface/README.txt
+interface/gnumex
+interface/src/getfem_interface.cc
+interface/src/getfem_interface.h
+interface/src/getfemint.cc
+interface/src/getfemint.h
+interface/src/getfemint_gsparse.cc
+interface/src/getfemint_gsparse.h
+interface/src/getfemint_levelset.cc
+interface/src/getfemint_levelset.h
+interface/src/getfemint_misc.cc
+interface/src/getfemint_misc.h
+interface/src/getfemint_precond.h
+interface/src/getfemint_std.h
+interface/src/getfemint_workspace.cc
+interface/src/getfemint_workspace.h
+interface/src/gf_asm.cc
+interface/src/gf_compute.cc
+interface/src/gf_cont_struct.cc
+interface/src/gf_cont_struct_get.cc
+interface/src/gf_cvstruct_get.cc
+interface/src/gf_delete.cc
+interface/src/gf_eltm.cc
+interface/src/gf_fem.cc
+interface/src/gf_fem_get.cc
+interface/src/gf_geotrans.cc
+interface/src/gf_geotrans_get.cc
+interface/src/gf_global_function.cc
+interface/src/gf_global_function_get.cc
+interface/src/gf_integ.cc
+interface/src/gf_integ_get.cc
+interface/src/gf_levelset.cc
+interface/src/gf_levelset_get.cc
+interface/src/gf_levelset_set.cc
+interface/src/gf_linsolve.cc
+interface/src/gf_mesh.cc
+interface/src/gf_mesh_fem.cc
+interface/src/gf_mesh_fem_get.cc
+interface/src/gf_mesh_fem_set.cc
+interface/src/gf_mesh_get.cc
+interface/src/gf_mesh_im.cc
+interface/src/gf_mesh_im_data.cc
+interface/src/gf_mesh_im_data_get.cc
+interface/src/gf_mesh_im_data_set.cc
+interface/src/gf_mesh_im_get.cc
+interface/src/gf_mesh_im_set.cc
+interface/src/gf_mesh_levelset.cc
+interface/src/gf_mesh_levelset_get.cc
+interface/src/gf_mesh_levelset_set.cc
+interface/src/gf_mesh_set.cc
+interface/src/gf_mesher_object.cc
+interface/src/gf_mesher_object_get.cc
+interface/src/gf_model.cc
+interface/src/gf_model_get.cc
+interface/src/gf_model_set.cc
+interface/src/gf_poly.cc
+interface/src/gf_precond.cc
+interface/src/gf_precond_get.cc
+interface/src/gf_slice.cc
+interface/src/gf_slice_get.cc
+interface/src/gf_slice_set.cc
+interface/src/gf_spmat.cc
+interface/src/gf_spmat_get.cc
+interface/src/gf_spmat_set.cc
+interface/src/gf_util.cc
+interface/src/gf_workspace.cc
+interface/src/gfi_array.c
+interface/src/gfi_array.h
+interface/src/gfi_rpc.h
+interface/src/gfi_rpc_clnt.c
+interface/src/gfi_rpc_server.c
+interface/src/gfi_rpc_svc.c
+interface/src/gfi_rpc_xdr.c
+interface/src/matlab/gfObject.m
+interface/src/matlab/gf_asm_pdetoolbc.m
+interface/src/matlab/gf_colormap.m
+interface/src/matlab/gf_compute_Q1grid_interp.m
+interface/src/matlab/gf_interpolate_on_grid.m
+interface/src/matlab/gf_mesh_fem_get_eval.m
+interface/src/matlab/gf_plot.m
+interface/src/matlab/gf_plot_1D.m
+interface/src/matlab/gf_plot_mesh.m
+interface/src/matlab/gf_plot_slice.m
+interface/src/matlab/gfm_common.c
+interface/src/matlab/gfm_common.h
+interface/src/matlab/gfm_mex.c
+interface/src/matlab/gfm_rpc.x
+interface/src/matlab/gfm_rpc_mexint.c
+interface/src/matlab/private/getopt.m
+interface/src/python/__init__.py
+interface/src/python/getfem_python.c
+interface/src/python/setup.py.in
+interface/src/scilab/builddoc.sce
+interface/src/scilab/builder.sce
+interface/src/scilab/changelog.txt
+interface/src/scilab/demos/axrot_matrix.sci
+interface/src/scilab/demos/data/disc_2D_degree3.mesh
+interface/src/scilab/demos/data/disc_P2_h0.5.mesh
+interface/src/scilab/demos/data/disc_P2_h0_3.mesh
+interface/src/scilab/demos/data/disc_P2_h0_5.mesh
+interface/src/scilab/demos/data/disc_P2_h1.mesh
+interface/src/scilab/demos/data/disc_P2_h10.mesh
+interface/src/scilab/demos/data/disc_P2_h2.mesh
+interface/src/scilab/demos/data/disc_P2_h4.mesh
+interface/src/scilab/demos/data/disc_P2_h6.mesh
+interface/src/scilab/demos/data/disc_P2_h8.mesh
+interface/src/scilab/demos/data/donut_regulier.mesh
+interface/src/scilab/demos/data/donut_regulier_32_elements.mesh
+interface/src/scilab/demos/data/donut_regulier_512_elements.mesh
+interface/src/scilab/demos/data/donut_regulier_72_elements.mesh
+interface/src/scilab/demos/data/donut_regulier_8_elements_288ddl.mesh
+interface/src/scilab/demos/data/donut_with_quadratic_tetra_1100_elements.msh
+interface/src/scilab/demos/data/holed_disc_with_quadratic_2D_triangles.msh
+interface/src/scilab/demos/data/quad.geo
+interface/src/scilab/demos/data/quad.msh
+interface/src/scilab/demos/data/sphere_with_quadratic_tetra_16000_elts.mesh
+interface/src/scilab/demos/data/sphere_with_quadratic_tetra_2000_elts.mesh
+interface/src/scilab/demos/data/sphere_with_quadratic_tetra_400_elts.mesh
+interface/src/scilab/demos/data/sphere_with_quadratic_tetra_80_elts.mesh
+interface/src/scilab/demos/data/sphere_with_quadratic_tetra_8_elts.mesh
+interface/src/scilab/demos/data/tank_quadratic_2500.GiD.msh
+interface/src/scilab/demos/data/tripod.GiD.msh
+interface/src/scilab/demos/data/tripod.mesh
+interface/src/scilab/demos/data/tube_2D_spline.GiD.msh
+interface/src/scilab/demos/data/vee_h_0.03.mesh
+interface/src/scilab/demos/demo_Navier_Stokes.sce
+interface/src/scilab/demos/demo_bilaplacian.sce
+interface/src/scilab/demos/demo_continuation.sce
+interface/src/scilab/demos/demo_continuation_block.sce
+interface/src/scilab/demos/demo_continuation_vee.sce
+interface/src/scilab/demos/demo_convection_rotating_cavity.sce
+interface/src/scilab/demos/demo_crack.sce
+interface/src/scilab/demos/demo_fictitious_domains.sce
+interface/src/scilab/demos/demo_fictitious_domains_laplacian.sce
+interface/src/scilab/demos/demo_laplacian.sce
+interface/src/scilab/demos/demo_mesh_generation.sce
+interface/src/scilab/demos/demo_mortar.sce
+interface/src/scilab/demos/demo_nonlinear_elasticity.sce
+interface/src/scilab/demos/demo_nonlinear_elasticity_anim.sce
+interface/src/scilab/demos/demo_plasticity.sce
+interface/src/scilab/demos/demo_plate.sce
+interface/src/scilab/demos/demo_refine.sce
+interface/src/scilab/demos/demo_static_contact.sce
+interface/src/scilab/demos/demo_step_by_step.sce
+interface/src/scilab/demos/demo_stokes_3D_tank.sce
+interface/src/scilab/demos/demo_stokes_3D_tank_draw.sce
+interface/src/scilab/demos/demo_structural_optimization.sce
+interface/src/scilab/demos/demo_thermo_elasticity_electrical_coupling.sce
+interface/src/scilab/demos/demo_topological_optimization.sce
+interface/src/scilab/demos/demo_tripod.sce
+interface/src/scilab/demos/demo_tripod_alt.sce
+interface/src/scilab/demos/demo_tripod_anim.sce
+interface/src/scilab/demos/demo_tripod_slice_anim.sce
+interface/src/scilab/demos/demo_wave2D.sce
+interface/src/scilab/demos/demo_wave2D_alt.sce
+interface/src/scilab/demos/demo_wave2D_animate.sce
+interface/src/scilab/demos/demo_wave_equation.sce
+interface/src/scilab/demos/sci_getfem.dem.gateway.sce
+interface/src/scilab/demos/tutorial1.sce
+interface/src/scilab/etc/sci_getfem.quit
+interface/src/scilab/etc/sci_getfem.start
+interface/src/scilab/help/builder_help.sce
+interface/src/scilab/help/en_US/build_help.sce
+interface/src/scilab/help/en_US/examples/CHAPTER
+interface/src/scilab/help/en_US/examples/another_laplacian.xml
+interface/src/scilab/help/en_US/examples/avoiding_bricks.xml
+interface/src/scilab/help/en_US/examples/linear_nonlinear_elast.xml
+interface/src/scilab/help/en_US/examples/step_by_step_example.xml
+interface/src/scilab/help/en_US/getfem_types.xml
+interface/src/scilab/help/en_US/gf_asm.xml
+interface/src/scilab/help/en_US/gf_asm_pdetoolbc.xml
+interface/src/scilab/help/en_US/gf_colormap.xml
+interface/src/scilab/help/en_US/gf_compute.xml
+interface/src/scilab/help/en_US/gf_compute_Q1grid_interp.xml
+interface/src/scilab/help/en_US/gf_cont_struct.xml
+interface/src/scilab/help/en_US/gf_cont_struct_get.xml
+interface/src/scilab/help/en_US/gf_cvstruct_get.xml
+interface/src/scilab/help/en_US/gf_delete.xml
+interface/src/scilab/help/en_US/gf_eltm.xml
+interface/src/scilab/help/en_US/gf_fem.xml
+interface/src/scilab/help/en_US/gf_fem_get.xml
+interface/src/scilab/help/en_US/gf_geotrans.xml
+interface/src/scilab/help/en_US/gf_geotrans_get.xml
+interface/src/scilab/help/en_US/gf_global_function.xml
+interface/src/scilab/help/en_US/gf_global_function_get.xml
+interface/src/scilab/help/en_US/gf_integ.xml
+interface/src/scilab/help/en_US/gf_integ_get.xml
+interface/src/scilab/help/en_US/gf_interpolate_on_grid.xml
+interface/src/scilab/help/en_US/gf_levelset.xml
+interface/src/scilab/help/en_US/gf_levelset_get.xml
+interface/src/scilab/help/en_US/gf_levelset_set.xml
+interface/src/scilab/help/en_US/gf_linsolve.xml
+interface/src/scilab/help/en_US/gf_mesh.xml
+interface/src/scilab/help/en_US/gf_mesh_fem.xml
+interface/src/scilab/help/en_US/gf_mesh_fem_get.xml
+interface/src/scilab/help/en_US/gf_mesh_fem_get_eval.xml
+interface/src/scilab/help/en_US/gf_mesh_fem_set.xml
+interface/src/scilab/help/en_US/gf_mesh_get.xml
+interface/src/scilab/help/en_US/gf_mesh_im.xml
+interface/src/scilab/help/en_US/gf_mesh_im_data.xml
+interface/src/scilab/help/en_US/gf_mesh_im_data_get.xml
+interface/src/scilab/help/en_US/gf_mesh_im_data_set.xml
+interface/src/scilab/help/en_US/gf_mesh_im_get.xml
+interface/src/scilab/help/en_US/gf_mesh_im_set.xml
+interface/src/scilab/help/en_US/gf_mesh_levelset.xml
+interface/src/scilab/help/en_US/gf_mesh_levelset_get.xml
+interface/src/scilab/help/en_US/gf_mesh_levelset_set.xml
+interface/src/scilab/help/en_US/gf_mesh_set.xml
+interface/src/scilab/help/en_US/gf_mesher_object.xml
+interface/src/scilab/help/en_US/gf_mesher_object_get.xml
+interface/src/scilab/help/en_US/gf_model.xml
+interface/src/scilab/help/en_US/gf_model_get.xml
+interface/src/scilab/help/en_US/gf_model_set.xml
+interface/src/scilab/help/en_US/gf_multi_contact_frame.xml
+interface/src/scilab/help/en_US/gf_multi_contact_frame_get.xml
+interface/src/scilab/help/en_US/gf_multi_contact_frame_set.xml
+interface/src/scilab/help/en_US/gf_plot.xml
+interface/src/scilab/help/en_US/gf_plot_1D.xml
+interface/src/scilab/help/en_US/gf_plot_mesh.xml
+interface/src/scilab/help/en_US/gf_plot_slice.xml
+interface/src/scilab/help/en_US/gf_poly.xml
+interface/src/scilab/help/en_US/gf_precond.xml
+interface/src/scilab/help/en_US/gf_precond_get.xml
+interface/src/scilab/help/en_US/gf_slice.xml
+interface/src/scilab/help/en_US/gf_slice_get.xml
+interface/src/scilab/help/en_US/gf_slice_set.xml
+interface/src/scilab/help/en_US/gf_solve.xml
+interface/src/scilab/help/en_US/gf_spmat.xml
+interface/src/scilab/help/en_US/gf_spmat_get.xml
+interface/src/scilab/help/en_US/gf_spmat_set.xml
+interface/src/scilab/help/en_US/gf_typeof.xml
+interface/src/scilab/help/en_US/gf_undelete.xml
+interface/src/scilab/help/en_US/gf_util.xml
+interface/src/scilab/help/en_US/gf_workspace.xml
+interface/src/scilab/help/en_US/objects.xml
+interface/src/scilab/help/en_US/preliminary.xml
+interface/src/scilab/help/en_US/sparses/CHAPTER
+interface/src/scilab/help/en_US/sparses/sp_cgne.xml
+interface/src/scilab/help/en_US/sparses/sp_cgs.xml
+interface/src/scilab/help/en_US/sparses/sp_chol.xml
+interface/src/scilab/help/en_US/sparses/sp_cholinc.xml
+interface/src/scilab/help/en_US/sparses/sp_chsolve.xml
+interface/src/scilab/help/en_US/sparses/sp_gmres.xml
+interface/src/scilab/help/en_US/sparses/sp_lu.xml
+interface/src/scilab/help/en_US/sparses/sp_luinc.xml
+interface/src/scilab/help/en_US/sparses/sp_lusolve.xml
+interface/src/scilab/help/en_US/sparses/sp_mgcr.xml
+interface/src/scilab/help/fig/gf_fem_get_fig_1.png
+interface/src/scilab/help/fig/gf_plot_mesh_fig_1.png
+interface/src/scilab/help/fig/hierarchy.png
+interface/src/scilab/help/fig/tripodvonmiseswithmesh_small.png
+interface/src/scilab/help/fr_FR/build_help.sce
+interface/src/scilab/help/latex/cuve3Dstreamlines.png
+interface/src/scilab/help/latex/cuve3Dstreamlinessmall.png
+interface/src/scilab/help/latex/docstyle.css
+interface/src/scilab/help/latex/donut.png
+interface/src/scilab/help/latex/donut_small.png
+interface/src/scilab/help/latex/fempk51.eps
+interface/src/scilab/help/latex/getfemmatlab.lyx
+interface/src/scilab/help/latex/getfemmatlab.tex
+interface/src/scilab/help/latex/hierarchy.eps
+interface/src/scilab/help/latex/hierarchy.fig
+interface/src/scilab/help/latex/license.lyx
+interface/src/scilab/help/latex/license.tex
+interface/src/scilab/help/latex/logo_getfem_small.png
+interface/src/scilab/help/latex/logogetfem.png
+interface/src/scilab/help/latex/logogetfemwhitebg.png
+interface/src/scilab/help/latex/next.gif
+interface/src/scilab/help/latex/previous.gif
+interface/src/scilab/help/latex/tripodvonmises.png
+interface/src/scilab/help/latex/tripodvonmiseswithmesh.png
+interface/src/scilab/help/latex/tripodvonmiseswithmesh_small.png
+interface/src/scilab/help/latex/underscore.sty
+interface/src/scilab/help/latex/up.gif
+interface/src/scilab/help/mml/avoiding_eq1.mml
+interface/src/scilab/help/mml/gf_asm_eq1.mml
+interface/src/scilab/help/mml/gf_asm_eq2.mml
+interface/src/scilab/help/mml/gf_asm_eq3.mml
+interface/src/scilab/help/mml/gf_asm_eq4.mml
+interface/src/scilab/help/mml/gf_asm_eq5.mml
+interface/src/scilab/help/mml/gf_asm_eq6.mml
+interface/src/scilab/help/mml/gf_model_set_eq1.mml
+interface/src/scilab/help/mml/gf_model_set_eq2.mml
+interface/src/scilab/help/mml/gf_model_set_eq3.mml
+interface/src/scilab/help/mml/gf_model_set_eq4.mml
+interface/src/scilab/help/mml/preliminary_eq1.mml
+interface/src/scilab/help/mml/step_by_step_eq1.mml
+interface/src/scilab/help/mml/step_by_step_eq2.mml
+interface/src/scilab/help/mml/step_by_step_eq3.mml
+interface/src/scilab/help/mml/step_by_step_eq4.mml
+interface/src/scilab/help/mml/step_by_step_eq5.mml
+interface/src/scilab/license.txt
+interface/src/scilab/macros/_setdiff.sci
+interface/src/scilab/macros/add_empty_bound.sci
+interface/src/scilab/macros/assert.sci
+interface/src/scilab/macros/assert_field.sci
+interface/src/scilab/macros/asserterr.sci
+interface/src/scilab/macros/build_options_list.sci
+interface/src/scilab/macros/buildmacros.sce
+interface/src/scilab/macros/cart2pol.sci
+interface/src/scilab/macros/champ3.sci
+interface/src/scilab/macros/cross.sci
+interface/src/scilab/macros/dot.sci
+interface/src/scilab/macros/gf_asm_pdetoolbc.sci
+interface/src/scilab/macros/gf_colormap.sci
+interface/src/scilab/macros/gf_compute_Q1grid_interp.sci
+interface/src/scilab/macros/gf_interpolate_on_grid.sci
+interface/src/scilab/macros/gf_mesh_fem_get_eval.sci
+interface/src/scilab/macros/gf_plot.sci
+interface/src/scilab/macros/gf_plot_1D.sci
+interface/src/scilab/macros/gf_plot_mesh.sci
+interface/src/scilab/macros/gf_plot_slice.sci
+interface/src/scilab/macros/gf_solve.sci
+interface/src/scilab/macros/gfassert.sci
+interface/src/scilab/macros/has_field.sci
+interface/src/scilab/macros/init_pde.sci
+interface/src/scilab/macros/isauto.sci
+interface/src/scilab/macros/isnumeric.sci
+interface/src/scilab/macros/ison.sci
+interface/src/scilab/macros/isscalar.sci
+interface/src/scilab/macros/null_space.sci
+interface/src/scilab/macros/overload/%objid_e.sci
+interface/src/scilab/macros/overload/%objid_get.sci
+interface/src/scilab/macros/overload/%objid_set.sci
+interface/src/scilab/macros/overload/gf_typeof.sci
+interface/src/scilab/macros/overload/init_gf_types.sce
+interface/src/scilab/macros/repmat.sci
+interface/src/scilab/macros/spdiags.sci
+interface/src/scilab/macros/surfnorm.sci
+interface/src/scilab/macros/test_champ3.sce
+interface/src/scilab/macros/test_spdiags.sce
+interface/src/scilab/readme.txt
+interface/src/scilab/sci_gateway/builder_gateway.sce
+interface/src/scilab/sci_gateway/c/builder_gateway_c.sce.in
+interface/src/scilab/sci_gateway/c/gfm_common.c
+interface/src/scilab/sci_gateway/c/gfm_common.h
+interface/src/scilab/sci_gateway/c/gfm_scilab.cpp
+interface/src/scilab/sci_gateway/c/rebuild_lib_windows.sci
+interface/src/scilab/sci_gateway/c/sci_cgne.c
+interface/src/scilab/sci_gateway/c/sci_cgs.c
+interface/src/scilab/sci_gateway/c/sci_gmres.c
+interface/src/scilab/sci_gateway/c/sci_mgcr.c
+interface/src/scilab/sci_gateway/c/sci_spchol.c
+interface/src/scilab/sci_gateway/c/sci_spcholinc.c
+interface/src/scilab/sci_gateway/c/sci_spchsolve.c
+interface/src/scilab/sci_gateway/c/sci_splu.c
+interface/src/scilab/sci_gateway/c/sci_spluinc.c
+interface/src/scilab/sci_gateway/c/sci_splusolve.c
+interface/src/scilab/sci_gateway/c/stream_redirect.h
+interface/src/scilab/sci_getfem.iss
+interface/src/scilab/src/builder_src.sce
+interface/src/scilab/src/c/DOC/fnindex.txt
+interface/src/scilab/src/c/DOC/tutorial.txt
+interface/src/scilab/src/c/FILELIST
+interface/src/scilab/src/c/MACHINES/Cray/machine.h
+interface/src/scilab/src/c/MACHINES/Cray/patch.1
+interface/src/scilab/src/c/MACHINES/Cray/patch.2
+interface/src/scilab/src/c/MACHINES/Cray/patch.3
+interface/src/scilab/src/c/MACHINES/GCC/machine.h
+interface/src/scilab/src/c/MACHINES/Linux/machine.h
+interface/src/scilab/src/c/MACHINES/RS6000/machine.c
+interface/src/scilab/src/c/MACHINES/RS6000/machine.h
+interface/src/scilab/src/c/MACHINES/SGI/machine.h
+interface/src/scilab/src/c/MACHINES/SPARC/machine.h
+interface/src/scilab/src/c/README
+interface/src/scilab/src/c/bdfactor.c
+interface/src/scilab/src/c/bkpfacto.c
+interface/src/scilab/src/c/builder_c.sce
+interface/src/scilab/src/c/chfactor.c
+interface/src/scilab/src/c/configure
+interface/src/scilab/src/c/configure.in
+interface/src/scilab/src/c/copy.c
+interface/src/scilab/src/c/copyright
+interface/src/scilab/src/c/err.c
+interface/src/scilab/src/c/err.h
+interface/src/scilab/src/c/extras.c
+interface/src/scilab/src/c/fft.c
+interface/src/scilab/src/c/givens.c
+interface/src/scilab/src/c/hessen.c
+interface/src/scilab/src/c/hsehldr.c
+interface/src/scilab/src/c/init.c
+interface/src/scilab/src/c/iter.h
+interface/src/scilab/src/c/iter0.c
+interface/src/scilab/src/c/iternsym.c
+interface/src/scilab/src/c/itersym.c
+interface/src/scilab/src/c/ivecop.c
+interface/src/scilab/src/c/ls.dat
+interface/src/scilab/src/c/lufactor.c
+interface/src/scilab/src/c/machine.c
+interface/src/scilab/src/c/machine.h
+interface/src/scilab/src/c/machine.h.in
+interface/src/scilab/src/c/matlab.c
+interface/src/scilab/src/c/matlab.h
+interface/src/scilab/src/c/matop.c
+interface/src/scilab/src/c/matrix.h
+interface/src/scilab/src/c/matrix2.h
+interface/src/scilab/src/c/matrixio.c
+interface/src/scilab/src/c/meminfo.c
+interface/src/scilab/src/c/meminfo.h
+interface/src/scilab/src/c/memory.c
+interface/src/scilab/src/c/memstat.c
+interface/src/scilab/src/c/mfunc.c
+interface/src/scilab/src/c/norm.c
+interface/src/scilab/src/c/oldnames.h
+interface/src/scilab/src/c/otherio.c
+interface/src/scilab/src/c/pxop.c
+interface/src/scilab/src/c/qrfactor.c
+interface/src/scilab/src/c/rk4.dat
+interface/src/scilab/src/c/schur.c
+interface/src/scilab/src/c/solve.c
+interface/src/scilab/src/c/sparse.c
+interface/src/scilab/src/c/sparse.h
+interface/src/scilab/src/c/sparse2.h
+interface/src/scilab/src/c/sparseio.c
+interface/src/scilab/src/c/spbkp.c
+interface/src/scilab/src/c/spchfctr.c
+interface/src/scilab/src/c/splufctr.c
+interface/src/scilab/src/c/sprow.c
+interface/src/scilab/src/c/spswap.c
+interface/src/scilab/src/c/submat.c
+interface/src/scilab/src/c/svd.c
+interface/src/scilab/src/c/symmeig.c
+interface/src/scilab/src/c/update.c
+interface/src/scilab/src/c/vecop.c
+interface/src/scilab/src/c/version.c
+interface/src/scilab/src/c/zcopy.c
+interface/src/scilab/src/c/zfunc.c
+interface/src/scilab/src/c/zgivens.c
+interface/src/scilab/src/c/zhessen.c
+interface/src/scilab/src/c/zhsehldr.c
+interface/src/scilab/src/c/zlufctr.c
+interface/src/scilab/src/c/zmachine.c
+interface/src/scilab/src/c/zmatio.c
+interface/src/scilab/src/c/zmatlab.c
+interface/src/scilab/src/c/zmatop.c
+interface/src/scilab/src/c/zmatrix.h
+interface/src/scilab/src/c/zmatrix2.h
+interface/src/scilab/src/c/zmemory.c
+interface/src/scilab/src/c/znorm.c
+interface/src/scilab/src/c/zqrfctr.c
+interface/src/scilab/src/c/zschur.c
+interface/src/scilab/src/c/zsolve.c
+interface/src/scilab/src/c/zvecop.c
+interface/src/scilab/tests/unit_tests/check_all.sce
+interface/src/scilab/tests/unit_tests/check_asm.sce
+interface/src/scilab/tests/unit_tests/check_fem.sce
+interface/src/scilab/tests/unit_tests/check_geotrans.sce
+interface/src/scilab/tests/unit_tests/check_integ.sce
+interface/src/scilab/tests/unit_tests/check_interpolated_fem.sce
+interface/src/scilab/tests/unit_tests/check_levelset.sce
+interface/src/scilab/tests/unit_tests/check_mesh_fem.sce
+interface/src/scilab/tests/unit_tests/check_oo.sce
+interface/src/scilab/tests/unit_tests/check_plot.sce
+interface/src/scilab/tests/unit_tests/check_slices.sce
+interface/src/scilab/tests/unit_tests/check_spmat.sce
+interface/src/scilab/tests/unit_tests/check_workspace.sce
+interface/src/scilab/tests/unit_tests/test_argyris.sce
+interface/src/scilab/tests/unit_tests/test_plasticity_new_brick.sce
+interface/tests/matlab/axrot_matrix.m
+interface/tests/matlab/check_all.m
+interface/tests/matlab/check_all.sh
+interface/tests/matlab/check_asm.m
+interface/tests/matlab/check_fem.m
+interface/tests/matlab/check_geotrans.m
+interface/tests/matlab/check_integ.m
+interface/tests/matlab/check_interpolated_fem.m
+interface/tests/matlab/check_levelset.m
+interface/tests/matlab/check_mesh_fem.m
+interface/tests/matlab/check_oo.m
+interface/tests/matlab/check_plasticity.m
+interface/tests/matlab/check_plot.m
+interface/tests/matlab/check_slices.m
+interface/tests/matlab/check_spmat.m
+interface/tests/matlab/check_workspace.m
+interface/tests/matlab/demo_Mindlin_Reissner_plate.m
+interface/tests/matlab/demo_Navier_Stokes.m
+interface/tests/matlab/demo_Nitsche_contact_by_hand.m
+interface/tests/matlab/demo_bilaplacian.m
+interface/tests/matlab/demo_contact_fictitious_domain_nitsche.m
+interface/tests/matlab/demo_continuation.m
+interface/tests/matlab/demo_convection_rotating_cavity.m
+interface/tests/matlab/demo_crack.m
+interface/tests/matlab/demo_dynamic_contact.m
+interface/tests/matlab/demo_dynamic_plasticity.m
+interface/tests/matlab/demo_dynamic_plasticity_with_contact.m
+interface/tests/matlab/demo_elasticity.m
+interface/tests/matlab/demo_fictitious_domains.m
+interface/tests/matlab/demo_fictitious_domains_laplacian.m
+interface/tests/matlab/demo_laplacian.m
+interface/tests/matlab/demo_laplacian_DG.m
+interface/tests/matlab/demo_laplacian_pyramid.m
+interface/tests/matlab/demo_large_sliding_contact.m
+interface/tests/matlab/demo_mesh_generation.m
+interface/tests/matlab/demo_mortar.m
+interface/tests/matlab/demo_nonlinear_elasticity.m
+interface/tests/matlab/demo_nonlinear_elasticity_anim.m
+interface/tests/matlab/demo_periodic_laplacian.m
+interface/tests/matlab/demo_plasticity.m
+interface/tests/matlab/demo_refine.m
+interface/tests/matlab/demo_static_contact.m
+interface/tests/matlab/demo_step_by_step.m
+interface/tests/matlab/demo_stokes_3D_tank.m
+interface/tests/matlab/demo_stokes_3D_tank_draw.m
+interface/tests/matlab/demo_structural_optimization.m
+interface/tests/matlab/demo_thermo_elasticity_electrical_coupling.m
+interface/tests/matlab/demo_topological_optimization.m
+interface/tests/matlab/demo_tripod.m
+interface/tests/matlab/demo_tripod_alt.m
+interface/tests/matlab/demo_tripod_slice_anim.m
+interface/tests/matlab/demo_wave2D.m
+interface/tests/matlab/demo_wave2D_alt.m
+interface/tests/matlab/demo_wave2D_animate.m
+interface/tests/matlab/demo_wave_equation.m
+interface/tests/matlab/demo_wheel_contact.m
+interface/tests/matlab/plate_Impact.m
+interface/tests/matlab/private/asserterr.m
+interface/tests/matlab/private/gfassert.m
+interface/tests/matlab/test1_nitsche_large_sliding.m
+interface/tests/matlab/test2_nitsche_large_sliding.m
+interface/tests/matlab/test_argyris.m
+interface/tests/matlab/tripod_anim.m
+interface/tests/matlab/tutorial1.m
+interface/tests/matlab/uAnalytic.m
+interface/tests/meshes/cuve_linear_2400.GiD.msh
+interface/tests/meshes/cuve_quadratic_2400.GiD.msh
+interface/tests/meshes/cuve_quadratic_2500.GiD.msh
+interface/tests/meshes/donut_regulier.mesh
+interface/tests/meshes/donut_with_quadratic_tetra_1100_elements.msh
+interface/tests/meshes/holed_bar.mesh
+interface/tests/meshes/holed_disc_with_quadratic_2D_triangles.msh
+interface/tests/meshes/ladder.mesh
+interface/tests/meshes/ladder_1500.mesh
+interface/tests/meshes/ladder_370.mesh
+interface/tests/meshes/mixed_mesh.gmf
+interface/tests/meshes/sphere_with_quadratic_tetra.msh
+interface/tests/meshes/tank_quadratic_2500.GiD.msh
+interface/tests/meshes/tripod.GiD.msh
+interface/tests/meshes/tripod.mesh
+interface/tests/meshes/tube_2D_spline.GiD.msh
+interface/tests/python/check_asm.py
+interface/tests/python/check_export.py
+interface/tests/python/check_global_functions.py
+interface/tests/python/check_levelset.py
+interface/tests/python/check_mixed_mesh.py
+interface/tests/python/check_secondary_domain.py
+interface/tests/python/demo_Mindlin_Reissner_plate.py
+interface/tests/python/demo_crack.py
+interface/tests/python/demo_cracked_thermo_elastic_body.py
+interface/tests/python/demo_dynamic_contact_1D.py
+interface/tests/python/demo_elastic_ring_contact.py
+interface/tests/python/demo_fictitious_domains.py
+interface/tests/python/demo_finite_strain_plasticity.py
+interface/tests/python/demo_finite_strain_plasticity_3D.py
+interface/tests/python/demo_laplacian.py
+interface/tests/python/demo_laplacian_DG.py
+interface/tests/python/demo_laplacian_aposteriori.py
+interface/tests/python/demo_laplacian_pyramid.py
+interface/tests/python/demo_large_sliding_contact.py
+interface/tests/python/demo_mortar.py
+interface/tests/python/demo_navier_stokes.py
+interface/tests/python/demo_nonlinear_elasticity.py
+interface/tests/python/demo_parallel_laplacian.py
+interface/tests/python/demo_phase_field.py
+interface/tests/python/demo_plasticity.py
+interface/tests/python/demo_plate.py
+interface/tests/python/demo_static_contact.py
+interface/tests/python/demo_step_by_step.py
+interface/tests/python/demo_stokes_3D_tank.py
+interface/tests/python/demo_stokes_3D_tank_draw.py
+interface/tests/python/demo_thermo_elasticity_electrical_coupling.py
+interface/tests/python/demo_tresca.py
+interface/tests/python/demo_tripod.py
+interface/tests/python/demo_tripod_alt.py
+interface/tests/python/demo_unit_disk.py
+interface/tests/python/demo_wave.py
+interface/tests/python/demo_wave_equation.py
+interface/tests/python/demo_wheel_contact.py
+interface/tests/python/getfem_tvtk.py
+interface/tests/python/quad.geo
+interface/tests/python/tutorial1.py
+internal_tools/HCT_reduced_triangle_base.cc
+internal_tools/HCT_triangle_base.cc
+internal_tools/argyris_base.cc
+internal_tools/c1_piecep3_quad.cc
+internal_tools/getfem-matlab-interface-script.iss
+internal_tools/getfem-python-interface-script.iss
+internal_tools/hermite_tetrahedron_base.cc
+internal_tools/make_donut.C
+internal_tools/morley_base.cc
+internal_tools/simplexification_refelt.cc
+m4/ac_python_devel.m4
+m4/acx_blas.m4
+m4/acx_getfem.m4
+m4/ax_boost_base.m4
+m4/ax_boost_system.m4
+m4/ax_boost_thread.m4
+m4/ax_check_cxx_flag.m4
+m4/ax_prefix_config_h.m4
+m4/ax_prog_cc_mpi.m4
+m4/ax_prog_cxx_mpi.m4
+m4/ax_prog_fc_mpi.m4
+m4/matlab.m4
+m4/matlabver.m4
+m4/scilab.m4
+mkinstalldirs
+msvc/BUILDING_GETFEM.txt
+msvc/bilaplacian/bilaplacian.vcxproj
+msvc/common_debug_settings.props
+msvc/common_release_settings.props
+msvc/elastostatic/elastostatic.vcxproj
+msvc/getfem.sln
+msvc/getfem.suo
+msvc/getfem/getfem_arch_config.h
+msvc/gmm/gmm_arch_config.h
+msvc/libgetfem/libgetfem.vcxproj
+msvc/libgetfemint/libgetfemint.vcxproj
+msvc/makebindist.sh
+msvc/matlab_interface/matlab_interface.vcxproj
+msvc/poly/poly.vcxproj
+msvc/superlu/superlu.vcxproj
+msvc/test_assembly/test_assembly.vcxproj
+msvc/test_contact/contact_problem.cpp
+msvc/test_contact/contact_problem.h
+msvc/test_contact/run/2Dresults/Final_step.png
+msvc/test_contact/run/2Dresults/LS_contact.wmv
+msvc/test_contact/run/2Dresults/contact.param
+msvc/test_contact/run/3Dresults/Final_step3D.png
+msvc/test_contact/run/3Dresults/LS_contact_3D.wmv
+msvc/test_contact/run/3Dresults/contact.param
+msvc/test_contact/test_contact.cpp
+msvc/test_kdtree/test_kdtree.vcxproj
+msvc/test_laplacian_with_bricks/test_laplacian_with_bricks.vcxproj
+msvc/test_laplacian_with_bricks/test_laplacian_with_bricks.vcxproj.filters
+msvc/test_level_set_contact/test_level_set_contact.vcxproj
+msvc/test_level_set_contact/test_level_set_contact.vcxproj.filters
+src/bgeot_convex_ref.cc
+src/bgeot_convex_ref_simplexified.cc
+src/bgeot_convex_structure.cc
+src/bgeot_ftool.cc
+src/bgeot_geometric_trans.cc
+src/bgeot_geotrans_inv.cc
+src/bgeot_kdtree.cc
+src/bgeot_mesh_structure.cc
+src/bgeot_node_tab.cc
+src/bgeot_poly.cc
+src/bgeot_poly_composite.cc
+src/bgeot_rtree.cc
+src/bgeot_small_vector.cc
+src/bgeot_sparse_tensors.cc
+src/bgeot_torus.cc
+src/dal_backtrace.cc
+src/dal_bit_vector.cc
+src/dal_singleton.cc
+src/dal_static_stored_objects.cc
+src/getfem/bgeot_comma_init.h
+src/getfem/bgeot_config.h
+src/getfem/bgeot_convex.h
+src/getfem/bgeot_convex_ref.h
+src/getfem/bgeot_convex_structure.h
+src/getfem/bgeot_ftool.h
+src/getfem/bgeot_geometric_trans.h
+src/getfem/bgeot_geotrans_inv.h
+src/getfem/bgeot_kdtree.h
+src/getfem/bgeot_mesh.h
+src/getfem/bgeot_mesh_structure.h
+src/getfem/bgeot_node_tab.h
+src/getfem/bgeot_permutations.h
+src/getfem/bgeot_poly.h
+src/getfem/bgeot_poly_composite.h
+src/getfem/bgeot_rtree.h
+src/getfem/bgeot_small_vector.h
+src/getfem/bgeot_sparse_tensors.h
+src/getfem/bgeot_tensor.h
+src/getfem/bgeot_torus.h
+src/getfem/dal_backtrace.h
+src/getfem/dal_basic.h
+src/getfem/dal_bit_vector.h
+src/getfem/dal_config.h
+src/getfem/dal_naming_system.h
+src/getfem/dal_singleton.h
+src/getfem/dal_static_stored_objects.h
+src/getfem/dal_tas.h
+src/getfem/dal_tree_sorted.h
+src/getfem/getfem_Navier_Stokes.h
+src/getfem/getfem_accumulated_distro.h
+src/getfem/getfem_assembling.h
+src/getfem/getfem_assembling_tensors.h
+src/getfem/getfem_config.h
+src/getfem/getfem_contact_and_friction_common.h
+src/getfem/getfem_contact_and_friction_integral.h
+src/getfem/getfem_contact_and_friction_large_sliding.h
+src/getfem/getfem_contact_and_friction_nodal.h
+src/getfem/getfem_context.h
+src/getfem/getfem_continuation.h
+src/getfem/getfem_convect.h
+src/getfem/getfem_copyable_ptr.h
+src/getfem/getfem_crack_sif.h
+src/getfem/getfem_deformable_mesh.h
+src/getfem/getfem_derivatives.h
+src/getfem/getfem_error_estimate.h
+src/getfem/getfem_export.h
+src/getfem/getfem_fem.h
+src/getfem/getfem_fem_global_function.h
+src/getfem/getfem_fem_level_set.h
+src/getfem/getfem_fourth_order.h
+src/getfem/getfem_generic_assembly.h
+src/getfem/getfem_generic_assembly_compile_and_exec.h
+src/getfem/getfem_generic_assembly_functions_and_operators.h
+src/getfem/getfem_generic_assembly_semantic.h
+src/getfem/getfem_generic_assembly_tree.h
+src/getfem/getfem_global_function.h
+src/getfem/getfem_im_data.h
+src/getfem/getfem_im_list.h
+src/getfem/getfem_import.h
+src/getfem/getfem_integration.h
+src/getfem/getfem_interpolated_fem.h
+src/getfem/getfem_interpolation.h
+src/getfem/getfem_level_set.h
+src/getfem/getfem_level_set_contact.h
+src/getfem/getfem_linearized_plates.h
+src/getfem/getfem_locale.h
+src/getfem/getfem_mat_elem.h
+src/getfem/getfem_mat_elem_type.h
+src/getfem/getfem_mesh.h
+src/getfem/getfem_mesh_fem.h
+src/getfem/getfem_mesh_fem_global_function.h
+src/getfem/getfem_mesh_fem_level_set.h
+src/getfem/getfem_mesh_fem_product.h
+src/getfem/getfem_mesh_fem_sum.h
+src/getfem/getfem_mesh_im.h
+src/getfem/getfem_mesh_im_level_set.h
+src/getfem/getfem_mesh_level_set.h
+src/getfem/getfem_mesh_region.h
+src/getfem/getfem_mesh_slice.h
+src/getfem/getfem_mesh_slicers.h
+src/getfem/getfem_mesher.h
+src/getfem/getfem_model_solvers.h
+src/getfem/getfem_models.h
+src/getfem/getfem_nonlinear_elasticity.h
+src/getfem/getfem_omp.h
+src/getfem/getfem_partial_mesh_fem.h
+src/getfem/getfem_plasticity.h
+src/getfem/getfem_projected_fem.h
+src/getfem/getfem_regular_meshes.h
+src/getfem/getfem_superlu.h
+src/getfem/getfem_torus.h
+src/getfem_assembling_tensors.cc
+src/getfem_contact_and_friction_common.cc
+src/getfem_contact_and_friction_integral.cc
+src/getfem_contact_and_friction_large_sliding.cc
+src/getfem_contact_and_friction_nodal.cc
+src/getfem_context.cc
+src/getfem_continuation.cc
+src/getfem_enumeration_dof_para.cc
+src/getfem_error_estimate.cc
+src/getfem_export.cc
+src/getfem_fem.cc
+src/getfem_fem_composite.cc
+src/getfem_fem_global_function.cc
+src/getfem_fem_level_set.cc
+src/getfem_fourth_order.cc
+src/getfem_generic_assembly_compile_and_exec.cc
+src/getfem_generic_assembly_functions_and_operators.cc
+src/getfem_generic_assembly_interpolation.cc
+src/getfem_generic_assembly_semantic.cc
+src/getfem_generic_assembly_tree.cc
+src/getfem_generic_assembly_workspace.cc
+src/getfem_global_function.cc
+src/getfem_im_data.cc
+src/getfem_import.cc
+src/getfem_integration.cc
+src/getfem_integration_composite.cc
+src/getfem_interpolated_fem.cc
+src/getfem_interpolation.cc
+src/getfem_interpolation_on_deformed_domains.cc
+src/getfem_level_set.cc
+src/getfem_level_set_contact.cc
+src/getfem_linearized_plates.cc
+src/getfem_locale.cc
+src/getfem_mat_elem.cc
+src/getfem_mat_elem_type.cc
+src/getfem_mesh.cc
+src/getfem_mesh_fem.cc
+src/getfem_mesh_fem_global_function.cc
+src/getfem_mesh_fem_level_set.cc
+src/getfem_mesh_fem_product.cc
+src/getfem_mesh_fem_sum.cc
+src/getfem_mesh_im.cc
+src/getfem_mesh_im_level_set.cc
+src/getfem_mesh_level_set.cc
+src/getfem_mesh_region.cc
+src/getfem_mesh_slice.cc
+src/getfem_mesh_slicers.cc
+src/getfem_mesher.cc
+src/getfem_model_solvers.cc
+src/getfem_models.cc
+src/getfem_nonlinear_elasticity.cc
+src/getfem_omp.cc
+src/getfem_partial_mesh_fem.cc
+src/getfem_plasticity.cc
+src/getfem_projected_fem.cc
+src/getfem_regular_meshes.cc
+src/getfem_superlu.cc
+src/getfem_torus.cc
+src/gmm/gmm.h
+src/gmm/gmm_MUMPS_interface.h
+src/gmm/gmm_algobase.h
+src/gmm/gmm_blas.h
+src/gmm/gmm_blas_interface.h
+src/gmm/gmm_condition_number.h
+src/gmm/gmm_conjugated.h
+src/gmm/gmm_def.h
+src/gmm/gmm_dense_Householder.h
+src/gmm/gmm_dense_lu.h
+src/gmm/gmm_dense_matrix_functions.h
+src/gmm/gmm_dense_qr.h
+src/gmm/gmm_dense_sylvester.h
+src/gmm/gmm_domain_decomp.h
+src/gmm/gmm_except.h
+src/gmm/gmm_feedback_management.h
+src/gmm/gmm_inoutput.h
+src/gmm/gmm_interface.h
+src/gmm/gmm_interface_bgeot.h
+src/gmm/gmm_iter.h
+src/gmm/gmm_iter_solvers.h
+src/gmm/gmm_kernel.h
+src/gmm/gmm_lapack_interface.h
+src/gmm/gmm_least_squares_cg.h
+src/gmm/gmm_matrix.h
+src/gmm/gmm_modified_gram_schmidt.h
+src/gmm/gmm_opt.h
+src/gmm/gmm_precond.h
+src/gmm/gmm_precond_diagonal.h
+src/gmm/gmm_precond_ildlt.h
+src/gmm/gmm_precond_ildltt.h
+src/gmm/gmm_precond_ilu.h
+src/gmm/gmm_precond_ilut.h
+src/gmm/gmm_precond_ilutp.h
+src/gmm/gmm_precond_mr_approx_inverse.h
+src/gmm/gmm_range_basis.h
+src/gmm/gmm_real_part.h
+src/gmm/gmm_ref.h
+src/gmm/gmm_scaled.h
+src/gmm/gmm_solver_Schwarz_additive.h
+src/gmm/gmm_solver_bfgs.h
+src/gmm/gmm_solver_bicgstab.h
+src/gmm/gmm_solver_cg.h
+src/gmm/gmm_solver_constrained_cg.h
+src/gmm/gmm_solver_gmres.h
+src/gmm/gmm_solver_idgmres.h
+src/gmm/gmm_solver_qmr.h
+src/gmm/gmm_std.h
+src/gmm/gmm_sub_index.h
+src/gmm/gmm_sub_matrix.h
+src/gmm/gmm_sub_vector.h
+src/gmm/gmm_superlu_interface.h
+src/gmm/gmm_transposed.h
+src/gmm/gmm_tri_solve.h
+src/gmm/gmm_vector.h
+src/gmm/gmm_vector_to_matrix.h
+superlu/BLAS.c
+superlu/BLAS/License.txt
+superlu/BLAS/caxpy.f
+superlu/BLAS/ccopy.f
+superlu/BLAS/cdotc.f
+superlu/BLAS/cdotu.f
+superlu/BLAS/cgbmv.f
+superlu/BLAS/cgemm.f
+superlu/BLAS/cgemv.f
+superlu/BLAS/cgerc.f
+superlu/BLAS/cgeru.f
+superlu/BLAS/chbmv.f
+superlu/BLAS/chemm.f
+superlu/BLAS/chemv.f
+superlu/BLAS/cher.f
+superlu/BLAS/cher2.f
+superlu/BLAS/cher2k.f
+superlu/BLAS/cherk.f
+superlu/BLAS/chpmv.f
+superlu/BLAS/chpr.f
+superlu/BLAS/chpr2.f
+superlu/BLAS/crotg.f
+superlu/BLAS/cscal.f
+superlu/BLAS/csrot.f
+superlu/BLAS/csscal.f
+superlu/BLAS/cswap.f
+superlu/BLAS/csymm.f
+superlu/BLAS/csyr2k.f
+superlu/BLAS/csyrk.f
+superlu/BLAS/ctbmv.f
+superlu/BLAS/ctbsv.f
+superlu/BLAS/ctpmv.f
+superlu/BLAS/ctpsv.f
+superlu/BLAS/ctrmm.f
+superlu/BLAS/ctrmv.f
+superlu/BLAS/ctrsm.f
+superlu/BLAS/ctrsv.f
+superlu/BLAS/dasum.f
+superlu/BLAS/daxpy.f
+superlu/BLAS/dcabs1.f
+superlu/BLAS/dcopy.f
+superlu/BLAS/ddot.f
+superlu/BLAS/dgbmv.f
+superlu/BLAS/dgemm.f
+superlu/BLAS/dgemv.f
+superlu/BLAS/dger.f
+superlu/BLAS/dnrm2.f
+superlu/BLAS/drot.f
+superlu/BLAS/drotg.f
+superlu/BLAS/drotm.f
+superlu/BLAS/drotmg.f
+superlu/BLAS/dsbmv.f
+superlu/BLAS/dscal.f
+superlu/BLAS/dsdot.f
+superlu/BLAS/dspmv.f
+superlu/BLAS/dspr.f
+superlu/BLAS/dspr2.f
+superlu/BLAS/dswap.f
+superlu/BLAS/dsymm.f
+superlu/BLAS/dsymv.f
+superlu/BLAS/dsyr.f
+superlu/BLAS/dsyr2.f
+superlu/BLAS/dsyr2k.f
+superlu/BLAS/dsyrk.f
+superlu/BLAS/dtbmv.f
+superlu/BLAS/dtbsv.f
+superlu/BLAS/dtpmv.f
+superlu/BLAS/dtpsv.f
+superlu/BLAS/dtrmm.f
+superlu/BLAS/dtrmv.f
+superlu/BLAS/dtrsm.f
+superlu/BLAS/dtrsv.f
+superlu/BLAS/dzasum.f
+superlu/BLAS/dznrm2.f
+superlu/BLAS/icamax.f
+superlu/BLAS/idamax.f
+superlu/BLAS/isamax.f
+superlu/BLAS/izamax.f
+superlu/BLAS/lsame.f
+superlu/BLAS/sasum.f
+superlu/BLAS/saxpy.f
+superlu/BLAS/scabs1.f
+superlu/BLAS/scasum.f
+superlu/BLAS/scnrm2.f
+superlu/BLAS/scopy.f
+superlu/BLAS/sdot.f
+superlu/BLAS/sdsdot.f
+superlu/BLAS/sgbmv.f
+superlu/BLAS/sgemm.f
+superlu/BLAS/sgemv.f
+superlu/BLAS/sger.f
+superlu/BLAS/snrm2.f
+superlu/BLAS/srot.f
+superlu/BLAS/srotg.f
+superlu/BLAS/srotm.f
+superlu/BLAS/srotmg.f
+superlu/BLAS/ssbmv.f
+superlu/BLAS/sscal.f
+superlu/BLAS/sspmv.f
+superlu/BLAS/sspr.f
+superlu/BLAS/sspr2.f
+superlu/BLAS/sswap.f
+superlu/BLAS/ssymm.f
+superlu/BLAS/ssymv.f
+superlu/BLAS/ssyr.f
+superlu/BLAS/ssyr2.f
+superlu/BLAS/ssyr2k.f
+superlu/BLAS/ssyrk.f
+superlu/BLAS/stbmv.f
+superlu/BLAS/stbsv.f
+superlu/BLAS/stpmv.f
+superlu/BLAS/stpsv.f
+superlu/BLAS/strmm.f
+superlu/BLAS/strmv.f
+superlu/BLAS/strsm.f
+superlu/BLAS/strsv.f
+superlu/BLAS/xerbla.f
+superlu/BLAS/xerbla_array.f
+superlu/BLAS/zaxpy.f
+superlu/BLAS/zcopy.f
+superlu/BLAS/zdotc.f
+superlu/BLAS/zdotu.f
+superlu/BLAS/zdrot.f
+superlu/BLAS/zdscal.f
+superlu/BLAS/zgbmv.f
+superlu/BLAS/zgemm.f
+superlu/BLAS/zgemv.f
+superlu/BLAS/zgerc.f
+superlu/BLAS/zgeru.f
+superlu/BLAS/zhbmv.f
+superlu/BLAS/zhemm.f
+superlu/BLAS/zhemv.f
+superlu/BLAS/zher.f
+superlu/BLAS/zher2.f
+superlu/BLAS/zher2k.f
+superlu/BLAS/zherk.f
+superlu/BLAS/zhpmv.f
+superlu/BLAS/zhpr.f
+superlu/BLAS/zhpr2.f
+superlu/BLAS/zrotg.f
+superlu/BLAS/zscal.f
+superlu/BLAS/zswap.f
+superlu/BLAS/zsymm.f
+superlu/BLAS/zsyr2k.f
+superlu/BLAS/zsyrk.f
+superlu/BLAS/ztbmv.f
+superlu/BLAS/ztbsv.f
+superlu/BLAS/ztpmv.f
+superlu/BLAS/ztpsv.f
+superlu/BLAS/ztrmm.f
+superlu/BLAS/ztrmv.f
+superlu/BLAS/ztrsm.f
+superlu/BLAS/ztrsv.f
+superlu/BLAS_f2c.h
+superlu/License.txt
+superlu/ccolumn_bmod.c
+superlu/ccolumn_dfs.c
+superlu/ccopy_to_ucol.c
+superlu/cgscon.c
+superlu/cgsequ.c
+superlu/cgsrfs.c
+superlu/cgssv.c
+superlu/cgssvx.c
+superlu/cgstrf.c
+superlu/cgstrs.c
+superlu/clacon.c
+superlu/clangs.c
+superlu/claqgs.c
+superlu/cmemory.c
+superlu/cmyblas2.c
+superlu/colamd.c
+superlu/colamd.h
+superlu/cpanel_bmod.c
+superlu/cpanel_dfs.c
+superlu/cpivotL.c
+superlu/cpivotgrowth.c
+superlu/cpruneL.c
+superlu/creadhb.c
+superlu/csnode_bmod.c
+superlu/csnode_dfs.c
+superlu/csp_blas2.c
+superlu/csp_blas3.c
+superlu/cutil.c
+superlu/dcolumn_bmod.c
+superlu/dcolumn_dfs.c
+superlu/dcomplex.c
+superlu/dcopy_to_ucol.c
+superlu/dgscon.c
+superlu/dgsequ.c
+superlu/dgsrfs.c
+superlu/dgssv.c
+superlu/dgssvx.c
+superlu/dgstrf.c
+superlu/dgstrs.c
+superlu/dgstrsL.c
+superlu/dlacon.c
+superlu/dlamch.c
+superlu/dlangs.c
+superlu/dlaqgs.c
+superlu/dmemory.c
+superlu/dmyblas2.c
+superlu/dpanel_bmod.c
+superlu/dpanel_dfs.c
+superlu/dpivotL.c
+superlu/dpivotgrowth.c
+superlu/dpruneL.c
+superlu/dreadhb.c
+superlu/dsnode_bmod.c
+superlu/dsnode_dfs.c
+superlu/dsp_blas2.c
+superlu/dsp_blas3.c
+superlu/dutil.c
+superlu/dzsum1.c
+superlu/f2c_lite.c
+superlu/get_perm_c.c
+superlu/heap_relax_snode.c
+superlu/icmax1.c
+superlu/izmax1.c
+superlu/lsame.c
+superlu/memory.c
+superlu/mmd.c
+superlu/relax_snode.c
+superlu/scolumn_bmod.c
+superlu/scolumn_dfs.c
+superlu/scomplex.c
+superlu/scopy_to_ucol.c
+superlu/scsum1.c
+superlu/sgscon.c
+superlu/sgsequ.c
+superlu/sgsrfs.c
+superlu/sgssv.c
+superlu/sgssvx.c
+superlu/sgstrf.c
+superlu/sgstrs.c
+superlu/slacon.c
+superlu/slamch.c
+superlu/slangs.c
+superlu/slaqgs.c
+superlu/slu_Cnames.h
+superlu/slu_cdefs.h
+superlu/slu_dcomplex.h
+superlu/slu_ddefs.h
+superlu/slu_scomplex.h
+superlu/slu_sdefs.h
+superlu/slu_util.h
+superlu/slu_zdefs.h
+superlu/smemory.c
+superlu/smyblas2.c
+superlu/sp_coletree.c
+superlu/sp_ienv.c
+superlu/sp_preorder.c
+superlu/spanel_bmod.c
+superlu/spanel_dfs.c
+superlu/spivotL.c
+superlu/spivotgrowth.c
+superlu/spruneL.c
+superlu/sreadhb.c
+superlu/ssnode_bmod.c
+superlu/ssnode_dfs.c
+superlu/ssp_blas2.c
+superlu/ssp_blas3.c
+superlu/superlu_timer.c
+superlu/supermatrix.h
+superlu/sutil.c
+superlu/util.c
+superlu/xerbla.c
+superlu/zcolumn_bmod.c
+superlu/zcolumn_dfs.c
+superlu/zcopy_to_ucol.c
+superlu/zgscon.c
+superlu/zgsequ.c
+superlu/zgsrfs.c
+superlu/zgssv.c
+superlu/zgssvx.c
+superlu/zgstrf.c
+superlu/zgstrs.c
+superlu/zlacon.c
+superlu/zlangs.c
+superlu/zlaqgs.c
+superlu/zmemory.c
+superlu/zmyblas2.c
+superlu/zpanel_bmod.c
+superlu/zpanel_dfs.c
+superlu/zpivotL.c
+superlu/zpivotgrowth.c
+superlu/zpruneL.c
+superlu/zreadhb.c
+superlu/zsnode_bmod.c
+superlu/zsnode_dfs.c
+superlu/zsp_blas2.c
+superlu/zsp_blas3.c
+superlu/zutil.c
+tests/bilaplacian.cc
+tests/bilaplacian.param
+tests/bilaplacian.pl
+tests/crack.cc
+tests/crack.param
+tests/crack.pl
+tests/cyl_slicer.cc
+tests/cyl_slicer.pl
+tests/dynamic_array.cc
+tests/dynamic_array.pl
+tests/dynamic_friction.net
+tests/dynamic_friction_anim.net
+tests/dynamic_tas.cc
+tests/dynamic_tas.pl
+tests/elastostatic.cc
+tests/elastostatic.param
+tests/elastostatic.pl
+tests/geo_trans_inv.cc
+tests/geo_trans_inv.param
+tests/geo_trans_inv.pl
+tests/gmm_torture01_lusolve.cc
+tests/gmm_torture02_baseop.cc
+tests/gmm_torture05_mult.cc
+tests/gmm_torture06_mat_mult.cc
+tests/gmm_torture10_qr.cc
+tests/gmm_torture15_sub.cc
+tests/gmm_torture20_iterative_solvers.cc
+tests/heat_equation.cc
+tests/heat_equation.param
+tests/heat_equation.pl
+tests/helmholtz.cc
+tests/helmholtz.param
+tests/helmholtz.pl
+tests/integration.cc
+tests/integration.pl
+tests/laplacian.cc
+tests/laplacian.param
+tests/laplacian.pl
+tests/laplacian_conv_pk.pl
+tests/laplacian_with_bricks.cc
+tests/laplacian_with_bricks.param
+tests/laplacian_with_bricks.pl
+tests/make_gmm_test.pl
+tests/meshes/disc_2D_degree3.mesh
+tests/meshes/disc_P2_h0_3.mesh
+tests/meshes/disc_P2_h0_5.mesh
+tests/meshes/disc_P2_h1.mesh
+tests/meshes/disc_P2_h10.mesh
+tests/meshes/disc_P2_h2.mesh
+tests/meshes/disc_P2_h4.mesh
+tests/meshes/disc_P2_h6.mesh
+tests/meshes/disc_P2_h8.mesh
+tests/meshes/disc_with_a_hole.mesh
+tests/meshes/donut_regulier_32_elements.mesh
+tests/meshes/donut_regulier_512_elements.mesh
+tests/meshes/donut_regulier_72_elements.mesh
+tests/meshes/donut_regulier_8_elements_288ddl.mesh
+tests/meshes/multi_body.mesh
+tests/meshes/punch2D_1.mesh
+tests/meshes/punch2D_2.mesh
+tests/meshes/sphere_with_quadratic_tetra_16000_elts.mesh
+tests/meshes/sphere_with_quadratic_tetra_2000_elts.mesh
+tests/meshes/sphere_with_quadratic_tetra_400_elts.mesh
+tests/meshes/sphere_with_quadratic_tetra_80_elts.mesh
+tests/meshes/sphere_with_quadratic_tetra_8_elts.mesh
+tests/nonlinear_elastostatic.cc
+tests/nonlinear_elastostatic.param
+tests/nonlinear_elastostatic.pl
+tests/nonlinear_membrane.cc
+tests/nonlinear_membrane.param
+tests/nonlinear_membrane.pl
+tests/plasticity.cc
+tests/plasticity.param
+tests/plasticity.pl
+tests/plate.cc
+tests/plate.param
+tests/plate.pl
+tests/poly.cc
+tests/poly.pl
+tests/schwarz_additive.cc
+tests/schwarz_additive.param
+tests/schwarz_additive.pl
+tests/stokes.cc
+tests/stokes.param
+tests/stokes.pl
+tests/test_assembly.cc
+tests/test_assembly.pl
+tests/test_assembly_assignment.cc
+tests/test_assembly_assignment.pl
+tests/test_continuation.cc
+tests/test_continuation.param
+tests/test_continuation.pl
+tests/test_gmm_matrix_functions.cc
+tests/test_gmm_matrix_functions.pl
+tests/test_int_set.cc
+tests/test_int_set.pl
+tests/test_internal_variables.cc
+tests/test_internal_variables.pl
+tests/test_interpolated_fem.cc
+tests/test_interpolated_fem.param
+tests/test_interpolated_fem.pl
+tests/test_interpolation.cc
+tests/test_interpolation.pl
+tests/test_kdtree.cc
+tests/test_kdtree.pl
+tests/test_mat_elem.cc
+tests/test_mat_elem.param
+tests/test_mat_elem.pl
+tests/test_mesh.cc
+tests/test_mesh.pl
+tests/test_mesh_generation.cc
+tests/test_mesh_generation.pl
+tests/test_mesh_im_level_set.cc
+tests/test_mesh_im_level_set.pl
+tests/test_range_basis.cc
+tests/test_range_basis.param
+tests/test_range_basis.pl
+tests/test_rtree.cc
+tests/test_rtree.pl
+tests/test_slice.cc
+tests/test_slice.pl
+tests/test_small_vector.cc
+tests/test_small_vector.pl
+tests/test_tree_sorted.cc
+tests/test_tree_sorted.pl
+tests/thermo_elasticity_electrical_coupling.cc
+tests/thermo_elasticity_electrical_coupling.param
+tests/thermo_elasticity_electrical_coupling.pl
+tests/wave_equation.cc
+tests/wave_equation.param
+tests/wave_equation.pl
diff --git a/getfem.includes b/getfem.includes
new file mode 100644
index 0000000..d18b78a
--- /dev/null
+++ b/getfem.includes
@@ -0,0 +1,20 @@
+contrib/bimaterial_crack_test
+contrib/crack_plate
+contrib/icare
+contrib/level_set_contact
+interface/src
+interface/src/matlab
+interface/src/scilab/sci_gateway/c
+interface/src/scilab/src/c
+interface/src/scilab/src/c/MACHINES/Cray
+interface/src/scilab/src/c/MACHINES/GCC
+interface/src/scilab/src/c/MACHINES/Linux
+interface/src/scilab/src/c/MACHINES/RS6000
+interface/src/scilab/src/c/MACHINES/SGI
+interface/src/scilab/src/c/MACHINES/SPARC
+msvc/getfem
+msvc/gmm
+msvc/test_contact
+src/getfem
+src/gmm
+superlu