GetFEM  5.5
getfem_fourth_order.h
Go to the documentation of this file.
1 /* -*- c++ -*- (enables emacs c++ mode) */
2 /*===========================================================================
3 
4  Copyright (C) 2006-2026 Yves Renard
5 
6  This file is a part of GetFEM
7 
8  GetFEM is free software; you can redistribute it and/or modify it
9  under the terms of the GNU Lesser General Public License as published
10  by the Free Software Foundation; either version 3 of the License, or
11  (at your option) any later version along with the GCC Runtime Library
12  Exception either version 3.1 or (at your option) any later version.
13  This program is distributed in the hope that it will be useful, but
14  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16  License and GCC Runtime Library Exception for more details.
17  You should have received a copy of the GNU Lesser General Public License
18  along with this program. If not, see https://www.gnu.org/licenses/.
19 
20  As a special exception, you may use this file as it is a part of a free
21  software library without restriction. Specifically, if other files
22  instantiate templates or use macros or inline functions from this file,
23  or you compile this file and link it with other files to produce an
24  executable, this file does not by itself cause the resulting executable
25  to be covered by the GNU Lesser General Public License. This exception
26  does not however invalidate any other reasons why the executable file
27  might be covered by the GNU Lesser General Public License.
28 
29 ===========================================================================*/
30 
31 /**@file getfem_fourth_order.h
32  @author Yves Renard <Yves.Renard@insa-lyon.fr>,
33  Julien Pommier <Julien.Pommier@insa-toulouse.fr>
34  @date January 6, 2006.
35  @brief assembly procedures and bricks for fourth order pdes.
36 */
37 #ifndef GETFEM_FOURTH_ORDER_H__
38 #define GETFEM_FOURTH_ORDER_H__
39 
40 #include "getfem_models.h"
41 #include "getfem_assembling.h"
42 
43 namespace getfem {
44 
45  /* ******************************************************************** */
46  /* Bilaplacian assembly routines. */
47  /* ******************************************************************** */
48 
49  /**
50  assembly of @f$\int_\Omega \Delta u \Delta v@f$.
51  @ingroup asm
52  */
53  template<typename MAT, typename VECT>
54  void asm_stiffness_matrix_for_bilaplacian
55  (const MAT &M, const mesh_im &mim, const mesh_fem &mf,
56  const mesh_fem &mf_data, const VECT &A,
57  const mesh_region &rg = mesh_region::all_convexes()) {
58  generic_assembly assem
59  ("a=data$1(#2);"
60  "M(#1,#1)+=sym(comp(Hess(#1).Hess(#1).Base(#2))(:,i,i,:,j,j,k).a(k))");
61  assem.push_mi(mim);
62  assem.push_mf(mf);
63  assem.push_mf(mf_data);
64  assem.push_data(A);
65  assem.push_mat(const_cast<MAT &>(M));
66  assem.assembly(rg);
67  }
68 
69  template<typename MAT, typename VECT>
70  void asm_stiffness_matrix_for_homogeneous_bilaplacian
71  (const MAT &M, const mesh_im &mim, const mesh_fem &mf,
72  const VECT &A, const mesh_region &rg = mesh_region::all_convexes()) {
73  generic_assembly assem
74  ("a=data$1(1);"
75  "M(#1,#1)+=sym(comp(Hess(#1).Hess(#1))(:,i,i,:,j,j).a(1))");
76  assem.push_mi(mim);
77  assem.push_mf(mf);
78  assem.push_data(A);
79  assem.push_mat(const_cast<MAT &>(M));
80  assem.assembly(rg);
81  }
82 
83 
84  template<typename MAT, typename VECT>
85  void asm_stiffness_matrix_for_bilaplacian_KL
86  (const MAT &M, const mesh_im &mim, const mesh_fem &mf,
87  const mesh_fem &mf_data, const VECT &D_, const VECT &nu_,
88  const mesh_region &rg = mesh_region::all_convexes()) {
89  generic_assembly assem
90  ("d=data$1(#2); n=data$2(#2);"
91  "t=comp(Hess(#1).Hess(#1).Base(#2).Base(#2));"
92  "M(#1,#1)+=sym(t(:,i,j,:,i,j,k,l).d(k)-t(:,i,j,:,i,j,k,l).d(k).n(l)"
93  "+t(:,i,i,:,j,j,k,l).d(k).n(l))");
94  assem.push_mi(mim);
95  assem.push_mf(mf);
96  assem.push_mf(mf_data);
97  assem.push_data(D_);
98  assem.push_data(nu_);
99  assem.push_mat(const_cast<MAT &>(M));
100  assem.assembly(rg);
101  }
102 
103  template<typename MAT, typename VECT>
104  void asm_stiffness_matrix_for_homogeneous_bilaplacian_KL
105  (const MAT &M, const mesh_im &mim, const mesh_fem &mf,
106  const VECT &D_, const VECT &nu_,
107  const mesh_region &rg = mesh_region::all_convexes()) {
108  generic_assembly assem
109  ("d=data$1(1); n=data$2(1);"
110  "t=comp(Hess(#1).Hess(#1));"
111  "M(#1,#1)+=sym(t(:,i,j,:,i,j).d(1)-t(:,i,j,:,i,j).d(1).n(1)"
112  "+t(:,i,i,:,j,j).d(1).n(1))");
113  assem.push_mi(mim);
114  assem.push_mf(mf);
115  assem.push_data(D_);
116  assem.push_data(nu_);
117  assem.push_mat(const_cast<MAT &>(M));
118  assem.assembly(rg);
119  }
120 
121  /* ******************************************************************** */
122  /* Bilaplacian bricks. */
123  /* ******************************************************************** */
124 
125 
126  /** Adds a bilaplacian brick on the variable
127  `varname` and on the mesh region `region`.
128  This represent a term :math:`\Delta(D \Delta u)`.
129  where :math:`D(x)` is a coefficient determined by `dataname` which
130  could be constant or described on a f.e.m. The corresponding weak form
131  is :math:`\int D(x)\Delta u(x) \Delta v(x) dx`.
132  */
133  size_type add_bilaplacian_brick
134  (model &md, const mesh_im &mim, const std::string &varname,
135  const std::string &dataname, size_type region = size_type(-1));
136 
137  /** Adds a bilaplacian brick on the variable
138  `varname` and on the mesh region `region`.
139  This represent a term :math:`\Delta(D \Delta u)` where :math:`D(x)`
140  is a the flexion modulus determined by `dataname1`. The term is
141  integrated by part following a Kirchhoff-Love plate model
142  with `dataname2` the poisson ratio.
143  */
144  size_type add_bilaplacian_brick_KL
145  (model &md, const mesh_im &mim, const std::string &varname,
146  const std::string &dataname1, const std::string &dataname2,
147  size_type region = size_type(-1));
148 
149 
150  /* ******************************************************************** */
151  /* Normale derivative source term assembly routines. */
152  /* ******************************************************************** */
153 
154  /**
155  assembly of @f$\int_\Gamma{\partial_n u f}@f$.
156  @ingroup asm
157  */
158  template<typename VECT1, typename VECT2>
159  void asm_normal_derivative_source_term
160  (VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data,
161  const VECT2 &F, const mesh_region &rg) {
162  GMM_ASSERT1(mf_data.get_qdim() == 1,
163  "invalid data mesh fem (Qdim=1 required)");
164 
165  size_type Q = gmm::vect_size(F) / mf_data.nb_dof();
166 
167  // const char *s;
168  // if (mf.get_qdim() == 1 && Q == 1)
169  // s = "F=data(#2);"
170  // "V(#1)+=comp(Grad(#1).Normal().Base(#2))(:,i,i,j).F(j);";
171  // else if (mf.get_qdim() == 1 && Q == gmm::sqr(mf.linked_mesh().dim()))
172  // s = "F=data(mdim(#1),mdim(#1),#2);"
173  // "V(#1)+=comp(Grad(#1).Normal().Normal().Normal().Base(#2))"
174  // "(:,i,i,k,l,j).F(k,l,j);";
175  // else if (mf.get_qdim() > size_type(1) && Q == mf.get_qdim())
176  // s = "F=data(qdim(#1),#2);"
177  // "V(#1)+=comp(vGrad(#1).Normal().Base(#2))(:,i,k,k,j).F(i,j);";
178  // else if (mf.get_qdim() > size_type(1) &&
179  // Q == size_type(mf.get_qdim()*gmm::sqr(mf.linked_mesh().dim())))
180  // s = "F=data(qdim(#1),mdim(#1),mdim(#1),#2);"
181  // "V(#1)+=comp(vGrad(#1).Normal().Normal().Normal().Base(#2))"
182  // "(:,i,k,k,l,m,j).F(i,l,m,j);";
183  // else
184  // GMM_ASSERT1(false, "invalid rhs vector");
185  // asm_real_or_complex_1_param(B, mim, mf, mf_data, F, rg, s);
186 
187  const char *s;
188  if (mf.get_qdim() == 1 && Q == 1)
189  s = "Grad_Test_u.(A*Normal)";
190  else if (mf.get_qdim() == 1 && Q == gmm::sqr(mf.linked_mesh().dim()))
191  s = "Grad_Test_u.(((Reshape(A,meshdim,meshdim)*Normal).Normal)*Normal)";
192  else if (mf.get_qdim() > size_type(1) && Q == mf.get_qdim())
193  s = "((Grad_Test_u')*A).Normal";
194  else if (mf.get_qdim() > size_type(1) &&
195  Q == size_type(mf.get_qdim()*gmm::sqr(mf.linked_mesh().dim())))
196  s = "((((Grad_Test_u').Reshape(A,qdim(u),meshdim,meshdim)).Normal).Normal).Normal";
197  else
198  GMM_ASSERT1(false, "invalid rhs vector");
199  asm_real_or_complex_1_param_vec(B, mim, mf, &mf_data, F, rg, s);
200  }
201 
202  template<typename VECT1, typename VECT2>
203  void asm_homogeneous_normal_derivative_source_term
204  (VECT1 &B, const mesh_im &mim, const mesh_fem &mf,
205  const VECT2 &F, const mesh_region &rg) {
206 
207  size_type Q = gmm::vect_size(F);
208 
209  // const char *s;
210  // if (mf.get_qdim() == 1 && Q == 1)
211  // s = "F=data(1);"
212  // "V(#1)+=comp(Grad(#1).Normal())(:,i,i).F(1);";
213  // else if (mf.get_qdim() == 1 && Q == gmm::sqr(mf.linked_mesh().dim()))
214  // s = "F=data(mdim(#1),mdim(#1));"
215  // "V(#1)+=comp(Grad(#1).Normal().Normal().Normal())"
216  // "(:,i,i,l,j).F(l,j);";
217  // else if (mf.get_qdim() > size_type(1) && Q == mf.get_qdim())
218  // s = "F=data(qdim(#1));"
219  // "V(#1)+=comp(vGrad(#1).Normal())(:,i,k,k).F(i);";
220  // else if (mf.get_qdim() > size_type(1) &&
221  // Q == size_type(mf.get_qdim()*gmm::sqr(mf.linked_mesh().dim())))
222  // s = "F=data(qdim(#1),mdim(#1),mdim(#1));"
223  // "V(#1)+=comp(vGrad(#1).Normal().Normal().Normal())"
224  // "(:,i,k,k,l,m).F(i,l,m);";
225  // else
226  // GMM_ASSERT1(false, "invalid rhs vector");
227  // asm_real_or_complex_1_param(B, mim, mf, mf, F, rg, s);
228 
229  const char *s;
230  if (mf.get_qdim() == 1 && Q == 1)
231  s = "Test_Grad_u.(A*Normal)";
232  else if (mf.get_qdim() == 1 && Q == gmm::sqr(mf.linked_mesh().dim()))
233  s = "Test_Grad_u.(((Reshape(A,meshdim,meshdim)*Normal).Normal)*Normal)";
234  else if (mf.get_qdim() > size_type(1) && Q == mf.get_qdim())
235  s = "((Test_Grad_u')*A).Normal";
236  else if (mf.get_qdim() > size_type(1) &&
237  Q == size_type(mf.get_qdim()*gmm::sqr(mf.linked_mesh().dim())))
238  s = "((((Test_Grad_u').Reshape(A,qdim(u),meshdim,meshdim)).Normal).Normal).Normal";
239  else
240  GMM_ASSERT1(false, "invalid rhs vector");
241  asm_real_or_complex_1_param_vec(B, mim, mf, 0, F, rg, s);
242  }
243 
244 
245  /* ******************************************************************** */
246  /* Normale derivative source term brick. */
247  /* ******************************************************************** */
248 
249 
250  /** Adds a normal derivative source term brick
251  :math:`F = \int b.\partial_n v` on the variable `varname` and the
252  mesh region `region`.
253 
254  Update the right hand side of the linear system.
255  `dataname` represents `b` and `varname` represents `v`.
256  */
257  size_type add_normal_derivative_source_term_brick
258  (model &md, const mesh_im &mim, const std::string &varname,
259  const std::string &dataname, size_type region);
260 
261 
262  /* ******************************************************************** */
263  /* Special boundary condition for Kirchhoff-Love model. */
264  /* ******************************************************************** */
265 
266  /*
267  assembly of the special boundary condition for Kirchhoff-Love model.
268  @ingroup asm
269  */
270  template<typename VECT1, typename VECT2>
271  void asm_neumann_KL_term
272  (VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data,
273  const VECT2 &M, const VECT2 &divM, const mesh_region &rg) {
274  GMM_ASSERT1(mf_data.get_qdim() == 1,
275  "invalid data mesh fem (Qdim=1 required)");
276 
277  generic_assembly assem
278  ("MM=data$1(mdim(#1),mdim(#1),#2);"
279  "divM=data$2(mdim(#1),#2);"
280  "V(#1)+=comp(Base(#1).Normal().Base(#2))(:,i,j).divM(i,j);"
281  "V(#1)+=comp(Grad(#1).Normal().Base(#2))(:,i,j,k).MM(i,j,k)*(-1);"
282  "V(#1)+=comp(Grad(#1).Normal().Normal().Normal().Base(#2))(:,i,i,j,k,l).MM(j,k,l);");
283 
284  assem.push_mi(mim);
285  assem.push_mf(mf);
286  assem.push_mf(mf_data);
287  assem.push_data(M);
288  assem.push_data(divM);
289  assem.push_vec(B);
290  assem.assembly(rg);
291  }
292 
293  template<typename VECT1, typename VECT2>
294  void asm_neumann_KL_homogeneous_term
295  (VECT1 &B, const mesh_im &mim, const mesh_fem &mf,
296  const VECT2 &M, const VECT2 &divM, const mesh_region &rg) {
297 
298  generic_assembly assem
299  ("MM=data$1(mdim(#1),mdim(#1));"
300  "divM=data$2(mdim(#1));"
301  "V(#1)+=comp(Base(#1).Normal())(:,i).divM(i);"
302  "V(#1)+=comp(Grad(#1).Normal())(:,i,j).MM(i,j)*(-1);"
303  "V(#1)+=comp(Grad(#1).Normal().Normal().Normal())(:,i,i,j,k).MM(j,k);");
304 
305  assem.push_mi(mim);
306  assem.push_mf(mf);
307  assem.push_data(M);
308  assem.push_data(divM);
309  assem.push_vec(B);
310  assem.assembly(rg);
311  }
312 
313  /* ******************************************************************** */
314  /* Kirchhoff Love Neumann term brick. */
315  /* ******************************************************************** */
316 
317 
318  /** Adds a Neumann term brick for Kirchhoff-Love model
319  on the variable `varname` and the mesh region `region`.
320  `dataname1` represents the bending moment tensor and `dataname2`
321  its divergence.
322  */
323  size_type add_Kirchhoff_Love_Neumann_term_brick
324  (model &md, const mesh_im &mim, const std::string &varname,
325  const std::string &dataname1, const std::string &dataname2,
326  size_type region);
327 
328 
329  /* ******************************************************************** */
330  /* Normal derivative Dirichlet assembly routines. */
331  /* ******************************************************************** */
332 
333  /**
334  Assembly of normal derivative Dirichlet constraints
335  @f$ \partial_n u(x) = r(x) @f$ in a weak form
336  @f[ \int_{\Gamma} \partial_n u(x)v(x)=\int_{\Gamma} r(x)v(x) \forall v@f],
337  where @f$ v @f$ is in
338  the space of multipliers corresponding to mf_mult.
339 
340  size(r_data) = Q * nb_dof(mf_rh);
341 
342  version = |ASMDIR_BUILDH : build H
343  |ASMDIR_BUILDR : build R
344  |ASMDIR_BUILDALL : do everything.
345 
346  @ingroup asm
347  */
348 
349  template<typename MAT, typename VECT1, typename VECT2>
350  void asm_normal_derivative_dirichlet_constraints
351  (MAT &H, VECT1 &R, const mesh_im &mim, const mesh_fem &mf_u,
352  const mesh_fem &mf_mult, const mesh_fem &mf_r,
353  const VECT2 &r_data, const mesh_region &rg, bool R_must_be_derivated,
354  int version) {
355  typedef typename gmm::linalg_traits<VECT1>::value_type value_type;
356  typedef typename gmm::number_traits<value_type>::magnitude_type magn_type;
357 
358  rg.from_mesh(mim.linked_mesh()).error_if_not_faces();
359 
360  if (version & ASMDIR_BUILDH) {
361  const char *s;
362  if (mf_u.get_qdim() == 1 && mf_mult.get_qdim() == 1)
363  s = "M(#1,#2)+=comp(Base(#1).Grad(#2).Normal())(:,:,i,i)";
364  else
365  s = "M(#1,#2)+=comp(vBase(#1).vGrad(#2).Normal())(:,i,:,i,j,j);";
366 
367  generic_assembly assem(s);
368  assem.push_mi(mim);
369  assem.push_mf(mf_mult);
370  assem.push_mf(mf_u);
371  assem.push_mat(H);
372  assem.assembly(rg);
373  gmm::clean(H, gmm::default_tol(magn_type())
374  * gmm::mat_maxnorm(H) * magn_type(1000));
375  }
376  if (version & ASMDIR_BUILDR) {
377  GMM_ASSERT1(mf_r.get_qdim() == 1,
378  "invalid data mesh fem (Qdim=1 required)");
379  if (!R_must_be_derivated) {
380  asm_normal_source_term(R, mim, mf_mult, mf_r, r_data, rg);
381  } else {
382  asm_real_or_complex_1_param_vec(R, mim, mf_mult, &mf_r, r_data, rg,
383  "(Grad_A.Normal)*Test_u");
384  // asm_real_or_complex_1_param
385  // (R, mim, mf_mult, mf_r, r_data, rg,
386  // "R=data(#2); V(#1)+=comp(Base(#1).Grad(#2).Normal())(:,i,j,j).R(i)");
387  }
388  }
389  }
390 
391  /* ******************************************************************** */
392  /* Normal derivative Dirichlet condition bricks. */
393  /* ******************************************************************** */
394 
395  /** Adds a Dirichlet condition on the normal derivative of the variable
396  `varname` and on the mesh region `region` (which should be a boundary).
397  The general form is
398  :math:`\int \partial_n u(x)v(x) = \int r(x)v(x) \forall v`
399  where :math:`r(x)` is
400  the right hand side for the Dirichlet condition (0 for
401  homogeneous conditions) and :math:`v` is in a space of multipliers
402  defined by the variable `multname` on the part of boundary determined
403  by `region`. `dataname` is an optional parameter which represents
404  the right hand side of the Dirichlet condition.
405  If `R_must_be_derivated` is set to `true` then the normal
406  derivative of `dataname` is considered.
407  */
408  size_type add_normal_derivative_Dirichlet_condition_with_multipliers
409  (model &md, const mesh_im &mim, const std::string &varname,
410  const std::string &multname, size_type region,
411  const std::string &dataname = std::string(),
412  bool R_must_be_derivated = false);
413 
414 
415  /** Adds a Dirichlet condition on the normal derivative of the variable
416  `varname` and on the mesh region `region` (which should be a boundary).
417  The general form is
418  :math:`\int \partial_n u(x)v(x) = \int r(x)v(x) \forall v`
419  where :math:`r(x)` is
420  the right hand side for the Dirichlet condition (0 for
421  homogeneous conditions) and :math:`v` is in a space of multipliers
422  defined by the trace of mf_mult on the part of boundary determined
423  by `region`. `dataname` is an optional parameter which represents
424  the right hand side of the Dirichlet condition.
425  If `R_must_be_derivated` is set to `true` then the normal
426  derivative of `dataname` is considered.
427  */
428  size_type add_normal_derivative_Dirichlet_condition_with_multipliers
429  (model &md, const mesh_im &mim, const std::string &varname,
430  const mesh_fem &mf_mult, size_type region,
431  const std::string &dataname = std::string(),
432  bool R_must_be_derivated = false);
433 
434  /** Adds a Dirichlet condition on the normal derivative of the variable
435  `varname` and on the mesh region `region` (which should be a boundary).
436  The general form is
437  :math:`\int \partial_n u(x)v(x) = \int r(x)v(x) \forall v`
438  where :math:`r(x)` is
439  the right hand side for the Dirichlet condition (0 for
440  homogeneous conditions) and :math:`v` is in a space of multipliers
441  defined by the trace of a Lagranfe finite element method of degree
442  `degree` and on the boundary determined
443  by `region`. `dataname` is an optional parameter which represents
444  the right hand side of the Dirichlet condition.
445  If `R_must_be_derivated` is set to `true` then the normal
446  derivative of `dataname` is considered.
447  */
448  size_type add_normal_derivative_Dirichlet_condition_with_multipliers
449  (model &md, const mesh_im &mim, const std::string &varname,
450  dim_type degree, size_type region,
451  const std::string &dataname = std::string(),
452  bool R_must_be_derivated = false);
453 
454  /** Adds a Dirichlet condition on the normal derivative of the variable
455  `varname` and on the mesh region `region` (which should be a boundary).
456  The general form is
457  :math:`\int \partial_n u(x)v(x) = \int r(x)v(x) \forall v`
458  where :math:`r(x)` is
459  the right hand side for the Dirichlet condition (0 for
460  homogeneous conditions). For this brick the condition is enforced with
461  a penalisation with a penanalization parameter `penalization_coeff` on
462  the boundary determined by `region`.
463  `dataname` is an optional parameter which represents
464  the right hand side of the Dirichlet condition.
465  If `R_must_be_derivated` is set to `true` then the normal
466  derivative of `dataname` is considered.
467  Note that is is possible to change the penalization coefficient
468  using the function `getfem::change_penalization_coeff` of the standard
469  Dirichlet condition.
470  */
471  size_type add_normal_derivative_Dirichlet_condition_with_penalization
472  (model &md, const mesh_im &mim, const std::string &varname,
473  scalar_type penalisation_coeff, size_type region,
474  const std::string &dataname = std::string(),
475  bool R_must_be_derivated = false);
476 
477 
478 
479 
480 
481 
482 } /* end of namespace getfem. */
483 
484 
485 #endif /* GETFEM_FOURTH_ORDER_H__ */
getfem::generic_assembly
Generic assembly of vectors, matrices.
Definition: getfem_assembling_tensors.h:606
getfem::generic_assembly::push_data
void push_data(const VEC &d)
Add a new data (dense array)
Definition: getfem_assembling_tensors.h:658
getfem::generic_assembly::push_mat
void push_mat(const MAT &m)
Add a new output matrix (fake const version..)
Definition: getfem_assembling_tensors.h:670
getfem::generic_assembly::assembly
void assembly(const mesh_region &region=mesh_region::all_convexes())
do the assembly on the specified region (boundary or set of convexes)
Definition: getfem_assembling_tensors.cc:1820
getfem::generic_assembly::push_mi
void push_mi(const mesh_im &im_)
Add a new mesh_im.
Definition: getfem_assembling_tensors.h:651
getfem::generic_assembly::push_mf
void push_mf(const mesh_fem &mf_)
Add a new mesh_fem.
Definition: getfem_assembling_tensors.h:649
getfem::mesh_fem
Describe a finite element method linked to a mesh.
Definition: getfem_mesh_fem.h:151
getfem::mesh_fem::get_qdim
virtual dim_type get_qdim() const
Return the Q dimension.
Definition: getfem_mesh_fem.h:315
getfem::mesh_fem::nb_dof
virtual size_type nb_dof() const
Return the total number of degrees of freedom.
Definition: getfem_mesh_fem.h:565
getfem::mesh_fem::linked_mesh
const mesh & linked_mesh() const
Return a reference to the underlying mesh.
Definition: getfem_mesh_fem.h:282
getfem::mesh_im
Describe an integration method linked to a mesh.
Definition: getfem_mesh_im.h:46
getfem::mesh_im::linked_mesh
const mesh & linked_mesh() const
Give a reference to the linked mesh of type mesh.
Definition: getfem_mesh_im.h:78
getfem::mesh_region
structure used to hold a set of convexes and/or convex faces.
Definition: getfem_mesh_region.h:54
getfem::mesh_region::from_mesh
const mesh_region & from_mesh(const mesh &m) const
For regions which have been built with just a number 'id', from_mesh(m) sets the current region to 'm...
Definition: getfem_mesh_region.cc:71
getfem::mesh_region::all_convexes
static mesh_region all_convexes()
provide a default value for the mesh_region parameters of assembly procedures etc.
Definition: getfem_mesh_region.h:141
getfem_assembling.h
Miscelleanous assembly routines for common terms. Use the low-level generic assembly....
getfem_models.h
Model representation in Getfem.
getfem::asm_stiffness_matrix_for_bilaplacian
void asm_stiffness_matrix_for_bilaplacian(const MAT &M, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT &A, const mesh_region &rg=mesh_region::all_convexes())
assembly of .
Definition: getfem_fourth_order.h:55
getfem::asm_normal_derivative_dirichlet_constraints
void asm_normal_derivative_dirichlet_constraints(MAT &H, VECT1 &R, const mesh_im &mim, const mesh_fem &mf_u, const mesh_fem &mf_mult, const mesh_fem &mf_r, const VECT2 &r_data, const mesh_region &rg, bool R_must_be_derivated, int version)
Assembly of normal derivative Dirichlet constraints in a weak form.
Definition: getfem_fourth_order.h:351
getfem::asm_normal_derivative_source_term
void asm_normal_derivative_source_term(VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT2 &F, const mesh_region &rg)
assembly of .
Definition: getfem_fourth_order.h:160
getfem::asm_normal_source_term
void asm_normal_source_term(VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT2 &F, const mesh_region &rg)
Normal source term (for boundary (Neumann) condition).
Definition: getfem_assembling.h:904
bgeot::size_type
size_t size_type
used as the common size type in the library
Definition: bgeot_poly.h:48
getfem
GEneric Tool for Finite Element Methods.
Definition: getfem_accumulated_distro.h:46
getfem::add_bilaplacian_brick
size_type add_bilaplacian_brick(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname, size_type region=size_type(-1))
Adds a bilaplacian brick on the variable varname and on the mesh region region.
Definition: getfem_fourth_order.cc:119
getfem::add_bilaplacian_brick_KL
size_type add_bilaplacian_brick_KL(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname1, const std::string &dataname2, size_type region=size_type(-1))
Adds a bilaplacian brick on the variable varname and on the mesh region region.
Definition: getfem_fourth_order.cc:131
getfem::add_normal_derivative_Dirichlet_condition_with_multipliers
size_type add_normal_derivative_Dirichlet_condition_with_multipliers(model &md, const mesh_im &mim, const std::string &varname, const std::string &multname, size_type region, const std::string &dataname=std::string(), bool R_must_be_derivated=false)
Adds a Dirichlet condition on the normal derivative of the variable varname and on the mesh region re...
Definition: getfem_fourth_order.cc:619
getfem::add_normal_derivative_source_term_brick
size_type add_normal_derivative_source_term_brick(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname, size_type region)
Adds a normal derivative source term brick :math:F = \int b.
Definition: getfem_fourth_order.cc:249
getfem::add_Kirchhoff_Love_Neumann_term_brick
size_type add_Kirchhoff_Love_Neumann_term_brick(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname1, const std::string &dataname2, size_type region)
Adds a Neumann term brick for Kirchhoff-Love model on the variable varname and the mesh region region...
Definition: getfem_fourth_order.cc:332
getfem::add_normal_derivative_Dirichlet_condition_with_penalization
size_type add_normal_derivative_Dirichlet_condition_with_penalization(model &md, const mesh_im &mim, const std::string &varname, scalar_type penalisation_coeff, size_type region, const std::string &dataname=std::string(), bool R_must_be_derivated=false)
Adds a Dirichlet condition on the normal derivative of the variable varname and on the mesh region re...
Definition: getfem_fourth_order.cc:655