GetFEM  5.5
getfem_regular_meshes.h
Go to the documentation of this file.
1 /* -*- c++ -*- (enables emacs c++ mode) */
2 /*===========================================================================
3 
4  Copyright (C) 1999-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_regular_meshes.h
32  @author Yves Renard <Yves.Renard@insa-lyon.fr>
33  @date December 20, 1999.
34  @brief Build regular meshes.
35 */
36 #ifndef GETFEM_REGULAR_MESHES_H__
37 #define GETFEM_REGULAR_MESHES_H__
38 
39 #include "getfem_mesh.h"
40 
41 namespace getfem
42 {
43  /* ******************************************************************** */
44  /* Generation de maillages reguliers de simplexes. */
45  /* ******************************************************************** */
46 
47  /* ******************************************************************** */
48  /* ajoute au maillage "me" un maillage regulier de dimension "N" */
49  /* a partir du point "org" defini par les parallelepipedes engendres */
50  /* par la liste des vecteurs "vect". La liste iref est une liste */
51  /* d'entiers correspondant au nombre de parallelepidedes sur chaque */
52  /* dimension. Chaque parallelepidede est simplexifie. */
53  /* ******************************************************************** */
54 
55  void parallelepiped_regular_simplex_mesh_(mesh &me, dim_type N,
56  const base_node &org, const base_small_vector *ivect, const size_type *iref);
57 
58  template<class ITER1, class ITER2>
59  void parallelepiped_regular_simplex_mesh(mesh &me,
60  dim_type N,
61  const base_node &org, ITER1 ivect, ITER2 iref)
62  {
63  std::vector<base_small_vector> vect(N);
64  std::copy(ivect, ivect+N, vect.begin());
65  std::vector<size_type> ref(N);
66  std::copy(iref, iref+N, ref.begin());
67  parallelepiped_regular_simplex_mesh_(me, N, org, &(vect[0]),
68  &(ref[0]));
69  }
70 
71  void parallelepiped_regular_prism_mesh_(mesh &me, dim_type N,
72  const base_node &org, const base_small_vector *ivect, const size_type *iref);
73 
74  template<class ITER1, class ITER2>
75  void parallelepiped_regular_prism_mesh(mesh &me,
76  dim_type N,
77  const base_node &org, ITER1 ivect, ITER2 iref)
78  {
79  std::vector<base_small_vector> vect(N);
80  std::copy(ivect, ivect+N, vect.begin());
81  std::vector<size_type> ref(N);
82  std::copy(iref, iref+N, ref.begin());
83  parallelepiped_regular_prism_mesh_(me, N, org, &(vect[0]),
84  &(ref[0]));
85  }
86 
87  void parallelepiped_regular_mesh_(mesh &me, dim_type N,
88  const base_node &org, const base_small_vector *ivect, const size_type *iref, bool linear_gt);
89 
90  template<class ITER1, class ITER2>
91  void parallelepiped_regular_mesh(mesh &me,
92  dim_type N,
93  const base_node &org, ITER1 ivect, ITER2 iref, bool linear_gt=false)
94  {
95  std::vector<base_small_vector> vect(N);
96  std::copy(ivect, ivect+N, vect.begin());
97  std::vector<size_type> ref(N);
98  std::copy(iref, iref+N, ref.begin());
99  parallelepiped_regular_mesh_(me, N, org, &(vect[0]), &(ref[0]), linear_gt);
100  }
101 
102  void parallelepiped_regular_pyramid_mesh_(mesh &me, const base_node &org,
103  const base_small_vector *ivect, const size_type *iref);
104 
105  template<class ITER1, class ITER2>
106  void parallelepiped_regular_pyramid_mesh(mesh &me,
107  const base_node &org, ITER1 ivect, ITER2 iref)
108  {
109  int N=3;
110  std::vector<base_small_vector> vect(N);
111  std::copy(ivect, ivect+N, vect.begin());
112  std::vector<size_type> ref(N);
113  std::copy(iref, iref+N, ref.begin());
114  parallelepiped_regular_pyramid_mesh_(me, org, &(vect[0]), &(ref[0]));
115  }
116 
117 
118  /**
119  Build a regular mesh of the unit square/cube/, etc.
120  @param m the output mesh.
121 
122  @param pgt the geometric transformation to use. For example, use
123  @code
124  pgt = geometric_trans_descriptor("GT_PK(2,1"); // to build a mesh of triangles
125  pgt = geometric_trans_descriptor("QK(3,2)"); // to build a mesh of order 2 parallelepiped
126  @endcode
127 
128  @param nsubdiv is the number of cells in each direction.
129 
130  @param noised if set, will cause the interior nodes to be randomly "shaken".
131  */
132  void regular_unit_mesh(mesh& m, std::vector<size_type> nsubdiv,
133  bgeot::pgeometric_trans pgt, bool noised = false);
134 
135  /**
136  Build a regular mesh parametrized by the string st.
137  The format of st is the following
138  std::string st("GT='GT_PK(2,1)'; NSUBDIV=[5,5]; ORG=[0,0]; SIZES=[1,1]; NOISED=0");
139  where GT is the geometric transformation, NSUBDIV a vector of the number
140  of subdivisions in each coordinate (default value 2), ORG is the origin
141  of the mesh (default value [0,0,...]), SIZES is a vector of the sizes
142  in each direction (default value [1, 1, ...] and if NOISED=1 the nodes
143  of the interior of the mesh are randomly "shaken" (default value NOISED=0).
144  All the parameters are optional but GT.
145 
146  @param m the output mesh.
147  */
148  void regular_mesh(mesh& m, const std::string &st);
149 
150  /**
151  Build a regular mesh on a ball, parametrized by the string st.
152  The format of st is similar to getfem::regular_mesh.
153  @see getfem::import_mesh.
154  All parameters except the geometric transformation GT are optional.
155  Here, parameter NSUBDIV has to be a vector of size 2 that holds the
156  number of subdivisions in the core and the peel sub-regions of the mesh.
157  SIZES is an one element vector that provides the ball radius
158  (default radius is equal to 1).
159  If NOISED=1 the nodes in the interior of the individual sub-regions
160  of the mesh are randomly "shaken" (default value NOISED=0).
161  An additional integer paramater called SYMMETRIES receiving the
162  values 1, 2 or 3 (in three dimensions) permits to respectively request
163  one half, one quarter or one eighth of the ball to be meshed
164  (default value SYMMETRIES=0).
165 
166  @param m the output mesh.
167  */
168  void regular_ball_mesh(mesh& m, const std::string &st);
169 
170  /**
171  Build a regular mesh on a ball shell, parametrized by the string st.
172  The format of st is similar to getfem::regular_mesh.
173  @see getfem::import_mesh.
174  All parameters except the geometric transformation GT are optional.
175  Here, parameter NSUBDIV has to be a vector of size 2 that holds the
176  number of subdivisions in the circumferential and radial direction
177  of the mesh.
178  SIZES is a two element vector that provides the ball radius and shell
179  thickness (default radius is equal to 1 and default thickness is
180  ewual to 0.5).
181  If NOISED=1 the nodes in the interior of the individual sub-regions
182  of the mesh are randomly "shaken" (default value NOISED=0).
183  An additional integer paramater called SYMMETRIES receiving the
184  values 1, 2 or 3 (in three dimensions) permits to respectively request
185  one half, one quarter or one eighth of the ball to be meshed
186  (default value SYMMETRIES=0).
187 
188  @param m the output mesh.
189  */
190  void regular_ball_shell_mesh(mesh& m, const std::string &st);
191 
192 } /* end of namespace getfem. */
193 
194 
195 #endif /* GETFEM_REGULAR_MESHES_H__ */
getfem_mesh.h
Define a getfem::getfem_mesh object.
bgeot::size_type
size_t size_type
used as the common size type in the library
Definition: bgeot_poly.h:48
bgeot::pgeometric_trans
std::shared_ptr< const bgeot::geometric_trans > pgeometric_trans
pointer type for a geometric transformation
Definition: bgeot_geometric_trans.h:185
getfem
GEneric Tool for Finite Element Methods.
Definition: getfem_accumulated_distro.h:46
getfem::regular_mesh
void regular_mesh(mesh &m, const std::string &st)
Build a regular mesh parametrized by the string st.
Definition: getfem_regular_meshes.cc:288
getfem::regular_ball_mesh
void regular_ball_mesh(mesh &m, const std::string &st)
Build a regular mesh on a ball, parametrized by the string st.
Definition: getfem_regular_meshes.cc:351
getfem::regular_unit_mesh
void regular_unit_mesh(mesh &m, std::vector< size_type > nsubdiv, bgeot::pgeometric_trans pgt, bool noised=false)
Build a regular mesh of the unit square/cube/, etc.
Definition: getfem_regular_meshes.cc:237
getfem::regular_ball_shell_mesh
void regular_ball_shell_mesh(mesh &m, const std::string &st)
Build a regular mesh on a ball shell, parametrized by the string st.
Definition: getfem_regular_meshes.cc:504