GetFEM  5.4.2
getfem_linearized_plates.cc
1 /*===========================================================================
2 
3  Copyright (C) 2004-2020 Yves Renard, Jeremie Lasry, Mathieu Fabre
4 
5  This file is a part of GetFEM
6 
7  GetFEM is free software; you can redistribute it and/or modify it
8  under the terms of the GNU Lesser General Public License as published
9  by the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version along with the GCC Runtime Library
11  Exception either version 3.1 or (at your option) any later version.
12  This program is distributed in the hope that it will be useful, but
13  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
15  License and GCC Runtime Library Exception for more details.
16  You should have received a copy of the GNU Lesser General Public License
17  along with this program; if not, write to the Free Software Foundation,
18  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 
20 ===========================================================================*/
21 
22 
23 #include "getfem/getfem_linearized_plates.h"
24 
25 
26 namespace getfem {
27 
28  size_type add_Mindlin_Reissner_plate_brick(model &md,
29  const mesh_im & mim,
30  const mesh_im & mim_red,
31  const std::string &U,
32  const std::string &Theta,
33  const std::string &param_E,
34  const std::string &param_nu,
35  const std::string &param_epsilon,
36  const std::string &param_kappa,
37  size_type variant,
38  size_type region) {
39 
40 
41  std::string test_U = "Test_" + sup_previous_and_dot_to_varname(U);
42  std::string test_Theta = "Test_" + sup_previous_and_dot_to_varname(Theta);
43  std::string proj_Theta = (variant == 2) ?
44  ("Elementary_transformation("+Theta+",_2D_rotated_RT0_projection__434)")
45  : Theta;
46  std::string proj_test_Theta = (variant == 2) ?
47  ("Elementary_transformation("+test_Theta
48  +",_2D_rotated_RT0_projection__434)") : test_Theta;
49 
50  std::string D = "(("+param_E+")*pow("+param_epsilon+
51  ",3))/(12*(1-sqr("+param_nu+")))";
52  std::string G = "(("+param_E+")*("+param_epsilon+"))*("+param_kappa+
53  ")/(2*(1+("+param_nu+")))";
54  std::string E_theta = "(Grad_" + Theta + "+(Grad_" + Theta + ")')/2";
55  std::string E_test_Theta="(Grad_"+test_Theta+"+(Grad_"+test_Theta+")')/2";
56 
57  std::string expr_left =
58  D+"*(( 1-("+param_nu+"))*("+E_theta+"):("+E_test_Theta+")+("+param_nu+
59  ")*Trace("+E_theta+")*Trace("+E_test_Theta+"))";
60 
61  std::string expr_right =
62  "("+G+")*(Grad_"+U+"-"+proj_Theta+").Grad_"+test_U+
63  "-("+G+")*(Grad_"+U+"-"+proj_Theta+")."+proj_test_Theta;
64 
65  switch(variant) {
66  case 0: // Without reduction
67  return add_linear_generic_assembly_brick
68  (md, mim, expr_left+"+"+expr_right, region, false, false,
69  "Reissner-Mindlin plate model brick");
70  case 1: // With reduced integration
71  add_linear_generic_assembly_brick
72  (md, mim, expr_left, region, false, false,
73  "Reissner-Mindlin plate model brick, rotation term");
74  return add_linear_generic_assembly_brick
75  (md, mim_red, expr_right, region, false, false,
76  "Reissner-Mindlin plate model brick, transverse shear term");
77  case 2: // Variant with projection on rotated RT0
78  add_2D_rotated_RT0_projection(md, "_2D_rotated_RT0_projection__434");
79  return add_linear_generic_assembly_brick
80  (md, mim, expr_left+"+"+expr_right, region, false, false,
81  "Reissner-Mindlin plate model brick");
82  break;
83  default: GMM_ASSERT1(false, "Invalid variant for Reissner-Mindlin brick.");
84  }
85  return size_type(-1);
86  }
87 
88 
89  size_type add_enriched_Mindlin_Reissner_plate_brick(model &md,
90  const mesh_im & mim,
91  const mesh_im & mim_red1,
92  const mesh_im & mim_red2,
93  const std::string &Ua,
94  const std::string &Theta,
95  const std::string &U3,
96  const std::string &Theta3,
97  const std::string &param_E,
98  const std::string &param_nu,
99  const std::string &param_epsilon,
100  size_type variant,
101  size_type region) {
102 
103  std::string test_Ua = "Test_" + sup_previous_and_dot_to_varname(Ua);
104  std::string test_U3 = "Test_" + sup_previous_and_dot_to_varname(U3);
105  std::string test_Theta = "Test_" + sup_previous_and_dot_to_varname(Theta);
106  std::string proj_Theta = (variant >= 2) ?
107  ("Elementary_transformation("+Theta+",_2D_rotated_RT0_projection__434)")
108  : Theta;
109  std::string proj_test_Theta = (variant >= 2) ?
110  ("Elementary_transformation("+test_Theta+",_2D_rotated_RT0_projection__434)")
111  : test_Theta;
112  std::string test_Theta3 = "Test_" + sup_previous_and_dot_to_varname(Theta3);
113  std::string proj_Theta3 = (variant == 3) ?
114  ("Elementary_transformation("+Theta3+",_P0_projection__434)")
115  : Theta3;
116  std::string proj_test_Theta3 = (variant == 3) ?
117  ("Elementary_transformation("+test_Theta3+",_P0_projection__434)")
118  : test_Theta3;
119  std::string D1 = "(("+param_E+")*pow("+param_epsilon+",3))/(12*(1+("+param_nu+")))";
120  std::string D2 = D1+"*("+param_nu+")/(1-2*("+param_nu+"))";
121  std::string D3 = D1+"/2";
122  std::string G1 = "(("+param_E+")*("+param_epsilon+"))/(1+("+param_nu+"))";
123  std::string G2 = G1+"*("+param_nu+")/(1-2*("+param_nu+"))";
124  std::string G3 = G1+"/2";
125 
126  std::string E_Ua = "(Grad_" + Ua + "+(Grad_" + Ua + ")')/2";
127  std::string E_test_Ua = "(Grad_" + test_Ua + "+(Grad_" + test_Ua + ")')/2";
128  std::string E_Theta = "(Grad_" + Theta + "+(Grad_" + Theta + ")')/2";
129  std::string E_test_Theta="(Grad_"+test_Theta+"+(Grad_"+test_Theta+")')/2";
130 
131  std::string expr_no_coupled_1 = G1+"*("+E_Ua+"):("+E_test_Ua+") + "+G1+"*("+Theta3+")*("+test_Theta3+")";
132  std::string expr_no_coupled_2 = D1+"*("+E_Theta+"):("+E_test_Theta+") + "+D2+"*Trace(Grad_"+Theta+")*Trace(Grad_"+test_Theta+") + "+D3+"*(Grad_"+Theta3+").(Grad_"+test_Theta3+")";
133 
134  std::string expr_coupled_1 = G3+"*(Grad_"+U3+" + "+proj_Theta+").(Grad_"+test_U3+" + "+proj_test_Theta+")";
135  std::string expr_coupled_2 = G2+"*(Trace("+E_Ua+") + "+proj_Theta3+")*(Trace("+E_test_Ua+") + "+proj_test_Theta3+")";
136 
137  switch(variant) {
138  case 0: // Without reduction
139  add_nonlinear_generic_assembly_brick
140  (md, mim, expr_no_coupled_1+"+"+expr_no_coupled_2, region, false, false,
141  "enriched Reissner-Mindlin plate model brick, no coupled");
142  return add_nonlinear_generic_assembly_brick
143  (md, mim, expr_coupled_1+"+"+expr_coupled_2, region, false, false,
144  "enriched Reissner-Mindlin plate model brick, coupled");
145  case 1: // With reduced integration
146  add_nonlinear_generic_assembly_brick
147  (md, mim, expr_no_coupled_1+"+"+expr_no_coupled_2, region, false, false,
148  "enriched Reissner-Mindlin plate model brick, no coupled");
149  add_nonlinear_generic_assembly_brick
150  (md, mim_red1, expr_coupled_1, region, false, false,
151  "enriched Reissner-Mindlin plate model brick, coupled MR");
152  return add_nonlinear_generic_assembly_brick
153  (md, mim_red2, expr_coupled_2, region, false, false,
154  "enriched Reissner-Mindlin plate model brick, coupled eMR");
155  case 2: // Variant with projection on rotated RT0 and reduction
156  add_2D_rotated_RT0_projection(md, "_2D_rotated_RT0_projection__434");
157  add_nonlinear_generic_assembly_brick
158  (md, mim, expr_no_coupled_1+"+"+expr_no_coupled_2, region, false, false,
159  "enriched Reissner-Mindlin plate model brick, no coupled");
160  add_nonlinear_generic_assembly_brick
161  (md, mim, expr_coupled_1, region, false, false,
162  "enriched Reissner-Mindlin plate model brick, coupled MR");
163  return add_nonlinear_generic_assembly_brick
164  (md, mim_red2, expr_coupled_2, region, false, false,
165  "enriched Reissner-Mindlin plate model brick, coupled eMR");
166  case 3: // Variant with projection on rotated RT0 and projection P0
167  add_2D_rotated_RT0_projection(md, "_2D_rotated_RT0_projection__434");
168  add_P0_projection(md, "_P0_projection__434");
169  add_nonlinear_generic_assembly_brick
170  (md, mim, expr_no_coupled_1+"+"+expr_no_coupled_2, region, false, false,
171  "enriched Reissner-Mindlin plate model brick, no coupled");
172  add_nonlinear_generic_assembly_brick
173  (md, mim, expr_coupled_1, region, false, false,
174  "enriched Reissner-Mindlin plate model brick, coupled MR");
175  return add_nonlinear_generic_assembly_brick
176  (md, mim, expr_coupled_2, region, false, false,
177  "enriched Reissner-Mindlin plate model brick, coupled eMR");
178  break;
179  default: GMM_ASSERT1(false, " testInvalid variant for enriched Reissner-Mindlin brick.");
180  }
181  return size_type(-1);
182  }
183 
184 
185 
186 
187 
188 
189 
190 
191  // For the moment, only projection onto rotated RT0 element in dimension 2
192 
193  class _2D_Rotated_RT0_projection_transformation
194  : public virtual_elementary_transformation {
195 
196  public:
197 
198  virtual void give_transformation(const mesh_fem &mf, const mesh_fem &mf2,
199  size_type cv, base_matrix &M) const{
200 
201  THREAD_SAFE_STATIC base_matrix M_old;
202  THREAD_SAFE_STATIC pfem pf_old = nullptr;
203 
204  GMM_ASSERT1(&mf == &mf2,
205  "This transformation works on identical fems only");
206 
207  // Obtaining the fem descriptors
208  pfem pf1 = mf.fem_of_element(cv);
209  size_type N = 2;
210  GMM_ASSERT1(pf1->dim() == 2, "This projection is only defined "
211  "for two-dimensional elements");
212  size_type qmult = N / pf1->target_dim();
213 
214  bool simplex = false;
215  if (pf1->ref_convex(cv) == bgeot::simplex_of_reference(dim_type(N))) {
216  simplex = true;
217  } else if (pf1->ref_convex(cv)
218  == bgeot::parallelepiped_of_reference(dim_type(N))) {
219  simplex = false;
220  } else {
221  GMM_ASSERT1(false, "Cannot adapt the method for such an element.");
222  }
223 
224  if (pf1 == pf_old && pf1->is_equivalent() && M.size() == M_old.size()) {
225  gmm::copy(M_old, M);
226  return;
227  }
228 
229  std::stringstream fem_desc;
230  fem_desc << "FEM_RT0" << (simplex ? "":"Q") << "(" << N << ")";
231  pfem pf2 = fem_descriptor(fem_desc.str());
232 
233  // Obtaining a convenient integration method
234  size_type degree = pf1->estimated_degree() + pf2->estimated_degree();
235  bgeot::pgeometric_trans pgt = mf.linked_mesh().trans_of_convex(cv);
236  papprox_integration pim
237  = classical_approx_im(pgt, dim_type(degree))->approx_method();
238 
239  // Computation of mass matrices
240  size_type ndof1 = pf1->nb_dof(cv) * qmult;
241  size_type ndof2 = pf2->nb_dof(0);
242  base_matrix M1(ndof1, ndof1), M2(ndof2, ndof2), B(ndof1, ndof2);
243  base_matrix aux0(ndof1, ndof1), aux1(ndof1, ndof2), aux2(ndof1, ndof2);
244  base_matrix aux3(ndof2, ndof2);
245 
246 
247  base_matrix G;
248  bgeot::vectors_to_base_matrix(G, mf.linked_mesh().points_of_convex(cv));
249  fem_interpolation_context ctx1(pgt, pf1, base_node(N), G, cv);
250  fem_interpolation_context ctx2(pgt, pf2, base_node(N), G, cv);
251 
252  base_tensor t1, t2;
253  base_matrix tv1, tv2;
254 
255  for (size_type i = 0; i < pim->nb_points_on_convex(); ++i) {
256 
257  scalar_type coeff = pim->coeff(i); // Mult by ctx.J() not useful here
258  ctx1.set_xref(pim->point(i));
259  ctx2.set_xref(pim->point(i));
260  pf1->real_base_value(ctx1, t1);
261  vectorize_base_tensor(t1, tv1, ndof1, pf1->target_dim(), N);
262  pf2->real_base_value(ctx2, t2);
263  vectorize_base_tensor(t2, tv2, ndof2, pf2->target_dim(), N);
264  for (size_type j = 0; j < ndof2; ++j) std::swap(tv2(j,0), tv2(j,1));
265 
266  gmm::mult(tv1, gmm::transposed(tv1), aux0);
267  gmm::add(gmm::scaled(aux0, coeff), M1);
268  gmm::mult(tv2, gmm::transposed(tv2), aux3);
269  gmm::add(gmm::scaled(aux3, coeff), M2);
270  gmm::mult(tv1, gmm::transposed(tv2), aux1);
271  gmm::add(gmm::scaled(aux1, coeff), B);
272  }
273 
274 
275  // Computation of M
276  gmm::lu_inverse(M1);
277  gmm::lu_inverse(M2);
278  gmm::mult(M1, B, aux1);
279  gmm::mult(aux1, M2, aux2);
280  GMM_ASSERT1(gmm::mat_nrows(M) == ndof1,
281  "Element not convenient for projection");
282  gmm::mult(aux2, gmm::transposed(B), M);
283  gmm::clean(M, 1E-15);
284  M_old = M; pf_old = pf1;
285  }
286  };
287 
288  void add_2D_rotated_RT0_projection(model &md, std::string name) {
289  pelementary_transformation
290  p = std::make_shared<_2D_Rotated_RT0_projection_transformation>();
291  md.add_elementary_transformation(name, p);
292  }
293 
294 
295 
296  // Can be simplified ...
297  class _P0_projection_transformation
298  : public virtual_elementary_transformation {
299 
300  public:
301 
302  virtual void give_transformation(const mesh_fem &mf, const mesh_fem &mf2,
303  size_type cv, base_matrix &M) const{
304 
305  THREAD_SAFE_STATIC base_matrix M_old;
306  THREAD_SAFE_STATIC pfem pf_old = nullptr;
307 
308  GMM_ASSERT1(&mf == &mf2,
309  "This transformation works on identical fems only");
310 
311  // Obtaining the fem descriptors
312  pfem pf1 = mf.fem_of_element(cv);
313  size_type N = mf.get_qdim(), d = pf1->dim();
314  // GMM_ASSERT1(pf1->dim() == 2, "This projection is only defined "
315  // "for two-dimensional elements");
316  size_type qmult = N / pf1->target_dim();
317 
318  bool simplex = false;
319  if (pf1->ref_convex(cv) == bgeot::simplex_of_reference(dim_type(d))) {
320  simplex = true;
321  } else if (pf1->ref_convex(cv)
322  == bgeot::parallelepiped_of_reference(dim_type(d))) {
323  simplex = false;
324  } else {
325  GMM_ASSERT1(false, "Cannot adapt the method for such an element.");
326  }
327 
328  if (pf1 == pf_old && pf1->is_equivalent() && M.size() == M_old.size()) {
329  gmm::copy(M_old, M);
330  return;
331  }
332 
333  std::stringstream fem_desc;
334  fem_desc << "FEM_" << (simplex ? "PK":"QK") << "(" << d << "," << 0 << ")";
335  pfem pf2 = fem_descriptor(fem_desc.str());
336 
337  // Obtaining a convenient integration method
338  size_type degree = pf1->estimated_degree() + pf2->estimated_degree();
339  bgeot::pgeometric_trans pgt = mf.linked_mesh().trans_of_convex(cv);
340  papprox_integration pim
341  = classical_approx_im(pgt, dim_type(degree))->approx_method();
342 
343  // Computation of mass matrices
344  size_type ndof1 = pf1->nb_dof(cv) * qmult;
345  size_type ndof2 = pf2->nb_dof(0) * qmult;
346  base_matrix M1(ndof1, ndof1), M2(ndof2, ndof2), B(ndof1, ndof2);
347  base_matrix aux0(ndof1, ndof1), aux1(ndof1, ndof2), aux2(ndof1, ndof2);
348  base_matrix aux3(ndof2, ndof2);
349 
350 
351  base_matrix G;
352  bgeot::vectors_to_base_matrix(G, mf.linked_mesh().points_of_convex(cv));
353  fem_interpolation_context ctx1(pgt, pf1, base_node(d), G, cv);
354  fem_interpolation_context ctx2(pgt, pf2, base_node(d), G, cv);
355 
356  base_tensor t1, t2;
357  base_matrix tv1, tv2;
358 
359  for (size_type i = 0; i < pim->nb_points_on_convex(); ++i) {
360 
361  scalar_type coeff = pim->coeff(i); // Mult by ctx.J() not useful here
362  ctx1.set_xref(pim->point(i));
363  ctx2.set_xref(pim->point(i));
364  pf1->real_base_value(ctx1, t1);
365  vectorize_base_tensor(t1, tv1, ndof1, pf1->target_dim(), N);
366  pf2->real_base_value(ctx2, t2);
367  vectorize_base_tensor(t2, tv2, ndof2, pf2->target_dim(), N);
368  // for (size_type j = 0; j < ndof2; ++j) std::swap(tv2(j,0), tv2(j,1));
369 
370  gmm::mult(tv1, gmm::transposed(tv1), aux0);
371  gmm::add(gmm::scaled(aux0, coeff), M1);
372  gmm::mult(tv2, gmm::transposed(tv2), aux3);
373  gmm::add(gmm::scaled(aux3, coeff), M2);
374  gmm::mult(tv1, gmm::transposed(tv2), aux1);
375  gmm::add(gmm::scaled(aux1, coeff), B);
376  }
377 
378 
379  // Computation of M
380  gmm::lu_inverse(M1);
381  gmm::lu_inverse(M2);
382  gmm::mult(M1, B, aux1);
383  gmm::mult(aux1, M2, aux2);
384  GMM_ASSERT1(gmm::mat_nrows(M) == ndof1,
385  "Element not convenient for projection");
386  gmm::mult(aux2, gmm::transposed(B), M);
387  gmm::clean(M, 1E-15);
388  M_old = M; pf_old = pf1;
389  }
390  };
391 
392 
393 
394 
395  void add_P0_projection(model &md, std::string name) {
396  pelementary_transformation
397  p = std::make_shared<_P0_projection_transformation>();
398  md.add_elementary_transformation(name, p);
399  }
400 
401 
402 
403 
404  // RT0 projection in any dimension. Unused for the moment.
405 
406 
407 // class RT0_projection_transformation
408 // : public virtual_elementary_transformation {
409 
410 // public:
411 
412 // virtual void give_transformation(const mesh_fem &mf, size_type cv,
413 // base_matrix &M) const{
414 
415 
416 
417 // // Obtaining the fem descriptors
418 // pfem pf1 = mf.fem_of_element(cv);
419 // size_type N = pf1->dim();
420 // size_type qmult = N / pf1->target_dim();
421 
422 // bool simplex = false;
423 // if (pf1->ref_convex(cv) == bgeot::simplex_of_reference(dim_type(N))) {
424 // simplex = true;
425 // } else if (pf1->ref_convex(cv)
426 // == bgeot::parallelepiped_of_reference(dim_type(N))) {
427 // simplex = false;
428 // } else {
429 // GMM_ASSERT1(false, "Cannot adapt the method for such an element.");
430 // }
431 
432 // GMM_ASSERT1(pf1->is_equivalent(), "For tau-equivalent fem only."); // Indeed no, for the moment ...
433 
434 // std::stringstream fem_desc;
435 // fem_desc << "FEM_RT0" << (simplex ? "":"Q") << "(" << N << ")";
436 // pfem pf2 = fem_descriptor(fem_desc.str());
437 
438 // // Obtaining a convenient integration method
439 // size_type degree = pf1->estimated_degree() + pf2->estimated_degree();
440 // bgeot::pgeometric_trans pgt = mf.linked_mesh().trans_of_convex(cv);
441 // papprox_integration pim
442 // = classical_approx_im(pgt, dim_type(degree))->approx_method();
443 
444 // // Computation of mass matrices
445 // size_type ndof1 = pf1->nb_dof(cv) * qmult;
446 // size_type ndof2 = pf2->nb_dof(0);
447 // base_matrix M1(ndof1, ndof1), M2(ndof2, ndof2), B(ndof1, ndof2);
448 // base_matrix aux0(ndof1, ndof1), aux1(ndof1, ndof2), aux2(ndof1, ndof2);
449 // base_matrix aux3(ndof2, ndof2);
450 
451 
452 // base_matrix G;
453 // bgeot::vectors_to_base_matrix(G, mf.linked_mesh().points_of_convex(cv));
454 // fem_interpolation_context ctx1(pgt, pf1, base_node(N), G, cv);
455 // fem_interpolation_context ctx2(pgt, pf2, base_node(N), G, cv);
456 
457 // base_tensor t1, t2;
458 // base_matrix tv1, tv2;
459 
460 // for (size_type i = 0; i < pim->nb_points_on_convex(); ++i) {
461 
462 // scalar_type coeff = pim->coeff(i); // Mult by ctx.J() not useful here
463 // ctx1.set_xref(pim->point(i));
464 // ctx2.set_xref(pim->point(i));
465 // pf1->real_base_value(ctx1, t1);
466 // vectorize_base_tensor(t1, tv1, ndof1, pf1->target_dim(), N);
467 // pf2->real_base_value(ctx2, t2);
468 // vectorize_base_tensor(t2, tv2, ndof2, pf2->target_dim(), N);
469 
470 
471 // // for (size_type j = 0; j < 4; ++j)
472 // // std::swap(tv2(j,0), tv2(j,1));
473 
474 
475 // gmm::mult(tv1, gmm::transposed(tv1), aux0);
476 // gmm::add(gmm::scaled(aux0, coeff), M1);
477 // gmm::mult(tv2, gmm::transposed(tv2), aux3);
478 // gmm::add(gmm::scaled(aux3, coeff), M2);
479 // gmm::mult(tv1, gmm::transposed(tv2), aux1);
480 // gmm::add(gmm::scaled(aux1, coeff), B);
481 // }
482 
483 
484 // // Computation of M
485 // gmm::lu_inverse(M1);
486 // gmm::lu_inverse(M2);
487 // gmm::mult(M1, B, aux1);
488 // gmm::mult(aux1, M2, aux2);
489 // GMM_ASSERT1(gmm::mat_nrows(M) == ndof1,
490 // "Element not convenient for projection");
491 // gmm::mult(aux2, gmm::transposed(B), M);
492 // gmm::clean(M, 1E-15);
493 // // cout << "M = " << M << endl;
494 // }
495 // };
496 
497 
498 
499 
500 
501 
502 
503 
504 } /* end of namespace getfem. */
505 
getfem::model::add_elementary_transformation
void add_elementary_transformation(const std::string &name, pelementary_transformation ptrans)
Add an elementary transformation to the model to be used with the generic assembly.
Definition: getfem_models.h:1135
getfem::add_Mindlin_Reissner_plate_brick
size_type add_Mindlin_Reissner_plate_brick(model &md, const mesh_im &mim, const mesh_im &mim_reduced, const std::string &u3, const std::string &Theta, const std::string &param_E, const std::string &param_nu, const std::string &param_epsilon, const std::string &param_kappa, size_type variant=size_type(2), size_type region=size_type(-1))
Add a term corresponding to the classical Reissner-Mindlin plate model for which u3 is the transverse...
Definition: getfem_linearized_plates.cc:28
getfem::add_enriched_Mindlin_Reissner_plate_brick
size_type add_enriched_Mindlin_Reissner_plate_brick(model &md, const mesh_im &mim, const mesh_im &mim_reduced1, const mesh_im &mim_reduced2, const std::string &ua, const std::string &Theta, const std::string &u3, const std::string &Theta3, const std::string &param_E, const std::string &param_nu, const std::string &param_epsilon, size_type variant=size_type(3), size_type region=size_type(-1))
Add a term corresponding to the enriched Reissner-Mindlin plate model for which varname_ua is the mem...
Definition: getfem_linearized_plates.cc:89
bgeot::size_type
size_t size_type
used as the common size type in the library
Definition: bgeot_poly.h:49
getfem::mesh_im
Describe an integration method linked to a mesh.
Definition: getfem_mesh_im.h:47
getfem::add_P0_projection
void add_P0_projection(model &md, std::string name)
Add the elementary transformation corresponding to the projection on P0 element.
Definition: getfem_linearized_plates.cc:395
getfem::model
`‘Model’' variables store the variables, the data and the description of a model.
Definition: getfem_models.h:114
getfem
GEneric Tool for Finite Element Methods.
Definition: getfem_accumulated_distro.h:46
getfem_linearized_plates.h
Reissner-Mindlin plate model brick.
getfem::pfem
std::shared_ptr< const getfem::virtual_fem > pfem
type of pointer on a fem description
Definition: getfem_fem.h:244
getfem::add_2D_rotated_RT0_projection
void add_2D_rotated_RT0_projection(model &md, std::string name)
Add the elementary transformation corresponding to the projection on rotated RT0 element for two-dime...
Definition: getfem_linearized_plates.cc:288
bgeot::parallelepiped_of_reference
pconvex_ref parallelepiped_of_reference(dim_type nc, dim_type k)
parallelepiped of reference of dimension nc (and degree 1)
Definition: bgeot_convex_ref.cc:747
getfem::classical_approx_im
pintegration_method classical_approx_im(bgeot::pgeometric_trans pgt, dim_type degree)
try to find an approximate integration method for the geometric transformation pgt which is able to i...
Definition: getfem_integration.cc:1280
bgeot::pgeometric_trans
std::shared_ptr< const bgeot::geometric_trans > pgeometric_trans
pointer type for a geometric transformation
Definition: bgeot_geometric_trans.h:186
bgeot::simplex_of_reference
pconvex_ref simplex_of_reference(dim_type nc, short_type K)
returns a simplex of reference of dimension nc and degree k
Definition: bgeot_convex_ref.cc:340
getfem::fem_descriptor
pfem fem_descriptor(const std::string &name)
get a fem descriptor from its string name.
Definition: getfem_fem.cc:4232

Rabisu Mirror Service We provide mirrors to support Open source communities. Our mirror server is located in Istanbul/Turkey region.

Please do not hesitate to contact mirror@rabisu.com for new open source mirror submissions.