Reference documentation for deal.II version GIT 49863513f1 2023-10-02 19:40:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
grid_generator_from_name.cc
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2019 - 2023 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
17 
19 
21 
22 namespace GridGenerator
23 {
24  namespace
25  {
32  template <int dim, int spacedim, class... Arguments>
33  void
34  parse_and_create(void (*generator)(Triangulation<dim, spacedim> &,
35  Arguments...),
36  const std::string &arguments,
38  {
39  std::function<void(Arguments...)> wrapper =
40  [&tria, &generator](Arguments... args) { generator(tria, args...); };
41  auto bound_function = Utilities::mutable_bind(wrapper);
42  bound_function.parse_arguments(arguments);
43  bound_function();
44  }
45 
46 
52  template <int dim, int spacedim>
53  std::enable_if_t<dim != spacedim, bool>
54  generate_codimension_zero_grid(const std::string &,
55  const std::string &,
57  {
58  return false;
59  }
60 
66  template <int dim>
67  bool
68  generate_codimension_zero_grid(const std::string &name,
69  const std::string &arguments,
71  {
72  if (name == "simplex")
73  parse_and_create<dim, dim, const std::vector<Point<dim>> &>(simplex,
74  arguments,
75  tria);
76  else if (name == "subdivided_hyper_rectangle")
77  {
78  // subdivided_hyper_rectangle is polymorphic, and can be called with
79  // different sets of arguments. We support two of these function
80  // calls. We try the first one, and if parsing fails, we go to the
81  // second one.
82  try
83  {
84  parse_and_create<dim,
85  dim,
86  const std::vector<unsigned int> &,
87  const Point<dim> &,
88  const Point<dim> &,
90  arguments,
91  tria);
92  }
94  {
95  parse_and_create<dim,
96  dim,
97  const std::vector<std::vector<double>> &,
98  const Point<dim> &,
99  const Point<dim> &,
101  arguments,
102  tria);
103  }
104  }
105  else if (name == "plate_with_a_hole")
106  parse_and_create<dim,
107  dim,
108  double,
109  double,
110  double,
111  double,
112  double,
113  double,
114  const Point<dim> &,
117  double,
118  unsigned int,
119  bool>(plate_with_a_hole, arguments, tria);
120  else if (name == "channel_with_cylinder")
121  parse_and_create<dim, dim, double, unsigned int, double, bool>(
122  channel_with_cylinder, arguments, tria);
123 
124  else if (name == "enclosed_hyper_cube")
125  parse_and_create<dim, dim, double, double, double, bool>(
126  enclosed_hyper_cube, arguments, tria);
127 
128  else if (name == "hyper_ball")
129  parse_and_create<dim, dim, const Point<dim> &, double, bool>(hyper_ball,
130  arguments,
131  tria);
132  else if (name == "hyper_ball_balanced")
133  parse_and_create<dim, dim, const Point<dim> &, double>(
134  hyper_ball_balanced, arguments, tria);
135 
136  else if (name == "quarter_hyper_ball")
137  parse_and_create<dim, dim, const Point<dim> &, double>(
138  quarter_hyper_ball, arguments, tria);
139 
140  else if (name == "half_hyper_ball")
141  parse_and_create<dim, dim, const Point<dim> &, double>(half_hyper_ball,
142  arguments,
143  tria);
144 
145  else if (name == "cylinder")
146  parse_and_create<dim, dim, double, double>(cylinder, arguments, tria);
147 
148  else if (name == "subdivided_cylinder")
149  parse_and_create<dim, dim, unsigned int, double, double>(
150  subdivided_cylinder, arguments, tria);
151 
152  else if (name == "truncated_cone")
153  parse_and_create<dim, dim, double, double, double>(truncated_cone,
154  arguments,
155  tria);
156 
157  else if (name == "pipe_junction")
158  parse_and_create<dim,
159  dim,
160  const std::vector<std::pair<Point<dim>, double>> &,
161  const std::pair<Point<dim>, double> &,
162  double>(pipe_junction, arguments, tria);
163 
164  else if (name == "hyper_L")
165  parse_and_create<dim, dim, double, double, bool>(hyper_L,
166  arguments,
167  tria);
168 
169  else if (name == "hyper_cube_slit")
170  parse_and_create<dim, dim, double, double, bool>(hyper_cube_slit,
171  arguments,
172  tria);
173 
174  else if (name == "hyper_shell")
175  parse_and_create<dim,
176  dim,
177  const Point<dim> &,
178  double,
179  double,
180  unsigned int,
181  bool>(hyper_shell, arguments, tria);
182 
183  else if (name == "half_hyper_shell")
184  parse_and_create<dim,
185  dim,
186  const Point<dim> &,
187  double,
188  double,
189  unsigned int,
190  bool>(half_hyper_shell, arguments, tria);
191 
192  else if (name == "quarter_hyper_shell")
193  parse_and_create<dim,
194  dim,
195  const Point<dim> &,
196  double,
197  double,
198  unsigned int,
199  bool>(quarter_hyper_shell, arguments, tria);
200 
201  else if (name == "eccentric_hyper_shell")
202  parse_and_create<dim,
203  dim,
204  const Point<dim> &,
205  const Point<dim> &,
206  double,
207  double,
208  unsigned int>(eccentric_hyper_shell, arguments, tria);
209 
210  else if (name == "cylinder_shell")
211  parse_and_create<dim,
212  dim,
213  double,
214  double,
215  double,
216  unsigned int,
217  unsigned int>(cylinder_shell, arguments, tria);
218 
219  else if (name == "hyper_cube_with_cylindrical_hole")
220  parse_and_create<dim, dim, double, double, double, unsigned int, bool>(
222 
223  else if (name == "concentric_hyper_shells")
224  parse_and_create<dim,
225  dim,
226  const Point<dim> &,
227  double,
228  double,
229  unsigned int,
230  double,
231  unsigned int,
232  bool>(concentric_hyper_shells, arguments, tria);
233 
234  else if (name == "subdivided_hyper_cube_with_simplices")
235  parse_and_create<dim, dim, unsigned int, double, double, bool>(
237 
238  else if (name == "subdivided_hyper_rectangle_with_simplices")
239  parse_and_create<dim,
240  dim,
241  const std::vector<unsigned int> &,
242  const Point<dim> &,
243  const Point<dim> &,
245  arguments,
246  tria);
247 
248  else
249  return false;
250 
251  return true;
252  }
253 
254 
260  template <int dim, int spacedim>
261  std::enable_if_t<dim != spacedim - 1, bool>
262  generate_codimension_one_grid(const std::string &,
263  const std::string &,
265  {
266  return false;
267  }
268 
274  template <int dim>
275  bool
276  generate_codimension_one_grid(const std::string &name,
277  const std::string &arguments,
279  {
280  if (name == "hyper_sphere")
281  parse_and_create<dim, dim + 1, const Point<dim + 1> &, double>(
282  hyper_sphere, arguments, tria);
283  else
284  return false;
285  return true;
286  }
287 
293  template <int dim, int spacedim>
294  bool
295  generate_special(const std::string &,
296  const std::string &,
298  {
299  return false;
300  }
301 
307  bool
308  generate_special(const std::string &name,
309  const std::string &arguments,
311  {
312  if (name == "moebius")
313  parse_and_create<3, 3, unsigned int, unsigned int, double, double>(
314  moebius, arguments, tria);
315  else if (name == "torus")
316  parse_and_create<3, 3, double, double, unsigned int, double>(torus,
317  arguments,
318  tria);
319  else
320  {
321  return false;
322  }
323  return true;
324  }
325 
331  bool
332  generate_special(const std::string &name,
333  const std::string &arguments,
335  {
336  if (name == "torus")
337  parse_and_create<2, 3, double, double, unsigned int, double>(torus,
338  arguments,
339  tria);
340  else
341  {
342  return false;
343  }
344  return true;
345  }
346  } // namespace
347 
348 
349 
350  template <int dim, int spacedim>
351  void
353  const std::string &name,
354  const std::string &arguments)
355  {
356  // We begin with all function calls that are implemented for all
357  // combinations of dim and spacedim.
358  if (name == "hyper_cube")
359  parse_and_create<dim, spacedim, double, double, bool>(hyper_cube,
360  arguments,
361  tria);
362  else if (name == "subdivided_hyper_cube")
363  parse_and_create<dim, spacedim, unsigned int, double, double, bool>(
364  subdivided_hyper_cube, arguments, tria);
365  else if (name == "hyper_rectangle")
366  parse_and_create<dim,
367  spacedim,
368  const Point<dim> &,
369  const Point<dim> &,
370  bool>(hyper_rectangle, arguments, tria);
371  else if (name == "cheese")
372  parse_and_create<dim, spacedim, const std::vector<unsigned int> &>(
373  cheese, arguments, tria);
374  else if (name == "general_cell")
375  parse_and_create<dim,
376  spacedim,
377  const std::vector<Point<spacedim>> &,
378  bool>(general_cell, arguments, tria);
379  else if (name == "hyper_cross")
380  parse_and_create<dim, spacedim, const std::vector<unsigned int> &, bool>(
381  hyper_cross, arguments, tria);
382  // If none of the above worked, than we try with more specific function
383  // calls. First we try to call functions that are only implemented when
384  // dim == spacedim, then when dim == spacedim-1, and lastly, we try to see
385  // if the name, dim, and spacedim match some of the very special grid
386  // generator functions, like torus, moebius, etc.
387  //
388  // If one of the function call succeeds, we skip the rest and return.
389  else if (generate_codimension_zero_grid(name, arguments, tria))
390  {
391  }
392  else if (generate_codimension_one_grid(name, arguments, tria))
393  {
394  }
395  else if (generate_special(name, arguments, tria))
396  {
397  }
398  else
399  // If we got here, we really have no idea what grid the user wants to
400  // generate.
401  AssertThrow(false,
402  ExcMessage(name + "(" + arguments + ") not implemented"));
403  }
404 } // namespace GridGenerator
405 
406 #include "grid_generator_from_name.inst"
407 
Definition: point.h:112
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:477
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:478
static ::ExceptionBase & ExcNoMatch(std::string arg1, std::string arg2)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
Definition: exceptions.h:1705
void subdivided_hyper_cube_with_simplices(Triangulation< dim, spacedim > &tria, const unsigned int repetitions, const double p1=0.0, const double p2=1.0, const bool colorize=false)
void hyper_cross(Triangulation< dim, spacedim > &tria, const std::vector< unsigned int > &sizes, const bool colorize_cells=false)
A center cell with stacks of cell protruding from each surface.
void hyper_ball_balanced(Triangulation< dim > &tria, const Point< dim > &center=Point< dim >(), const double radius=1.)
void plate_with_a_hole(Triangulation< dim > &tria, const double inner_radius=0.4, const double outer_radius=1., const double pad_bottom=2., const double pad_top=2., const double pad_left=1., const double pad_right=1., const Point< dim > &center=Point< dim >(), const types::manifold_id polar_manifold_id=0, const types::manifold_id tfi_manifold_id=1, const double L=1., const unsigned int n_slices=2, const bool colorize=false)
Rectangular plate with an (offset) cylindrical hole.
void generate_from_name_and_arguments(Triangulation< dim, spacedim > &tria, const std::string &grid_generator_function_name, const std::string &grid_generator_function_arguments)
void general_cell(Triangulation< dim, spacedim > &tria, const std::vector< Point< spacedim >> &vertices, const bool colorize=false)
void enclosed_hyper_cube(Triangulation< dim > &tria, const double left=0., const double right=1., const double thickness=1., const bool colorize=false)
void subdivided_hyper_cube(Triangulation< dim, spacedim > &tria, const unsigned int repetitions, const double left=0., const double right=1., const bool colorize=false)
void hyper_L(Triangulation< dim > &tria, const double left=-1., const double right=1., const bool colorize=false)
void hyper_cube_slit(Triangulation< dim > &tria, const double left=0., const double right=1., const bool colorize=false)
void hyper_ball(Triangulation< dim > &tria, const Point< dim > &center=Point< dim >(), const double radius=1., const bool attach_spherical_manifold_on_boundary_cells=false)
void eccentric_hyper_shell(Triangulation< dim > &triangulation, const Point< dim > &inner_center, const Point< dim > &outer_center, const double inner_radius, const double outer_radius, const unsigned int n_cells)
void hyper_rectangle(Triangulation< dim, spacedim > &tria, const Point< dim > &p1, const Point< dim > &p2, const bool colorize=false)
void cylinder(Triangulation< dim > &tria, const double radius=1., const double half_length=1.)
void moebius(Triangulation< 3, 3 > &tria, const unsigned int n_cells, const unsigned int n_rotations, const double R, const double r)
void half_hyper_shell(Triangulation< dim > &tria, const Point< dim > &center, const double inner_radius, const double outer_radius, const unsigned int n_cells=0, const bool colorize=false)
void quarter_hyper_ball(Triangulation< dim > &tria, const Point< dim > &center=Point< dim >(), const double radius=1.)
void cylinder_shell(Triangulation< dim > &tria, const double length, const double inner_radius, const double outer_radius, const unsigned int n_radial_cells=0, const unsigned int n_axial_cells=0)
void cheese(Triangulation< dim, spacedim > &tria, const std::vector< unsigned int > &holes)
Rectangular domain with rectangular pattern of holes.
void simplex(Triangulation< dim, dim > &tria, const std::vector< Point< dim >> &vertices)
void torus(Triangulation< dim, spacedim > &tria, const double R, const double r, const unsigned int n_cells_toroidal=6, const double phi=2.0 *numbers::PI)
void subdivided_hyper_rectangle_with_simplices(Triangulation< dim, spacedim > &tria, const std::vector< unsigned int > &repetitions, const Point< dim > &p1, const Point< dim > &p2, const bool colorize=false)
void subdivided_cylinder(Triangulation< dim > &tria, const unsigned int x_subdivisions, const double radius=1., const double half_length=1.)
void channel_with_cylinder(Triangulation< dim > &tria, const double shell_region_width=0.03, const unsigned int n_shells=2, const double skewness=2.0, const bool colorize=false)
void hyper_sphere(Triangulation< spacedim - 1, spacedim > &tria, const Point< spacedim > &center=Point< spacedim >(), const double radius=1.)
void concentric_hyper_shells(Triangulation< dim > &triangulation, const Point< dim > &center, const double inner_radius=0.125, const double outer_radius=0.25, const unsigned int n_shells=1, const double skewness=0.1, const unsigned int n_cells_per_shell=0, const bool colorize=false)
void pipe_junction(Triangulation< dim, spacedim > &tria, const std::vector< std::pair< Point< spacedim >, double >> &openings, const std::pair< Point< spacedim >, double > &bifurcation, const double aspect_ratio=0.5)
void subdivided_hyper_rectangle(Triangulation< dim, spacedim > &tria, const std::vector< unsigned int > &repetitions, const Point< dim > &p1, const Point< dim > &p2, const bool colorize=false)
void quarter_hyper_shell(Triangulation< dim > &tria, const Point< dim > &center, const double inner_radius, const double outer_radius, const unsigned int n_cells=0, const bool colorize=false)
void hyper_cube(Triangulation< dim, spacedim > &tria, const double left=0., const double right=1., const bool colorize=false)
void hyper_shell(Triangulation< dim > &tria, const Point< dim > &center, const double inner_radius, const double outer_radius, const unsigned int n_cells=0, bool colorize=false)
void hyper_cube_with_cylindrical_hole(Triangulation< dim > &triangulation, const double inner_radius=.25, const double outer_radius=.5, const double L=.5, const unsigned int repetitions=1, const bool colorize=false)
void truncated_cone(Triangulation< dim > &tria, const double radius_0=1.0, const double radius_1=0.5, const double half_length=1.0)
void half_hyper_ball(Triangulation< dim > &tria, const Point< dim > &center=Point< dim >(), const double radius=1.)
MutableBind< ReturnType, FunctionArgs... > mutable_bind(ReturnType(*function)(FunctionArgs...), std_cxx20::type_identity_t< FunctionArgs > &&...arguments)
unsigned int manifold_id
Definition: types.h:153
const ::Triangulation< dim, spacedim > & tria