Line data Source code
1 : // The libMesh Finite Element Library.
2 : // Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3 :
4 : // This library is free software; you can redistribute it and/or
5 : // modify it under the terms of the GNU Lesser General Public
6 : // License as published by the Free Software Foundation; either
7 : // version 2.1 of the License, or (at your option) any later version.
8 :
9 : // This library is distributed in the hope that it will be useful,
10 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 : // Lesser General Public License for more details.
13 :
14 : // You should have received a copy of the GNU Lesser General Public
15 : // License along with this library; if not, write to the Free Software
16 : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 :
18 :
19 :
20 : // C++ includes
21 : #include <algorithm>
22 : #include <map>
23 :
24 : // Local includes
25 : #include "libmesh/libmesh_common.h"
26 : #include "libmesh/string_to_enum.h"
27 : #include "libmesh/enum_to_string.h"
28 : #include "libmesh/enum_convergence_flags.h"
29 : #include "libmesh/enum_elem_quality.h"
30 : #include "libmesh/enum_elem_type.h"
31 : #include "libmesh/enum_eigen_solver_type.h"
32 : #include "libmesh/enum_fe_family.h"
33 : #include "libmesh/enum_inf_map_type.h"
34 : #include "libmesh/enum_io_package.h"
35 : #include "libmesh/enum_norm_type.h"
36 : #include "libmesh/enum_order.h"
37 : #include "libmesh/enum_parallel_type.h"
38 : #include "libmesh/enum_partitioner_type.h"
39 : #include "libmesh/enum_point_locator_type.h"
40 : #include "libmesh/enum_preconditioner_type.h"
41 : #include "libmesh/enum_quadrature_type.h"
42 : #include "libmesh/enum_solver_package.h"
43 : #include "libmesh/enum_solver_type.h"
44 : #include "libmesh/enum_subset_solve_mode.h"
45 : #include "libmesh/enum_xdr_mode.h"
46 : #include "libmesh/elem.h"
47 :
48 : namespace libMesh
49 : {
50 :
51 : // ------------------------------------------------------------
52 : // Anonymous namespace to hold local data & methods
53 : namespace {
54 :
55 :
56 : // Reverse a map
57 : template <class MapType>
58 : inline
59 : std::map<typename MapType::mapped_type, typename MapType::key_type>
60 32900 : build_reverse_map (const MapType & forward)
61 : {
62 9480 : std::map<typename MapType::mapped_type, typename MapType::key_type> reverse;
63 :
64 565880 : for (auto & [key, val] : forward)
65 : {
66 : // If the forward map is not invertible, we might already have
67 : // found a preimage of val. Choose the "largest"
68 : // preimage according to operator<; for std::string this will
69 : // give us the longest, hopefully most specific name
70 : // corresponding to an enum.
71 532980 : if (auto preimage = reverse.find(val);
72 153576 : preimage == reverse.end())
73 336077 : reverse.emplace (val, key);
74 78403 : else if (preimage->second < key)
75 17538 : preimage->second = key;
76 : }
77 :
78 32900 : return reverse;
79 : }
80 :
81 : std::map<std::string, ElemType> elem_type_to_enum {
82 : {"EDGE" , EDGE2},
83 : {"EDGE2" , EDGE2},
84 : {"EDGE3" , EDGE3},
85 : {"EDGE4" , EDGE4},
86 :
87 : {"TRI" , TRI3},
88 : {"TRI3" , TRI3},
89 : {"TRISHELL3" , TRISHELL3},
90 : {"TRI3SUBDIVISION", TRI3SUBDIVISION},
91 : {"TRI6" , TRI6},
92 : {"TRI7" , TRI7},
93 :
94 : {"QUAD" , QUAD4},
95 : {"QUAD4" , QUAD4},
96 : {"QUADSHELL4" , QUADSHELL4},
97 : {"QUAD8" , QUAD8},
98 : {"QUADSHELL8" , QUADSHELL8},
99 : {"QUAD9" , QUAD9},
100 : {"QUADSHELL9" , QUADSHELL9},
101 : {"QUAD16" , QUAD16},
102 :
103 : {"C0POLYGON" , C0POLYGON},
104 :
105 : {"C0POLYHEDRON" , C0POLYHEDRON},
106 :
107 : {"TET" , TET4},
108 : {"TET4" , TET4},
109 : {"TET10" , TET10},
110 : {"TET14" , TET14},
111 :
112 : {"HEX" , HEX8},
113 : {"HEX8" , HEX8},
114 : {"HEX20" , HEX20},
115 : {"HEX27" , HEX27},
116 :
117 : {"PRISM" , PRISM6},
118 : {"PRISM6" , PRISM6},
119 : {"PRISM15" , PRISM15},
120 : {"PRISM18" , PRISM18},
121 : {"PRISM20" , PRISM20},
122 : {"PRISM21" , PRISM21},
123 :
124 : {"PYRAMID" , PYRAMID5},
125 : {"PYRAMID5" , PYRAMID5},
126 : {"PYRAMID13" , PYRAMID13},
127 : {"PYRAMID14" , PYRAMID14},
128 : {"PYRAMID18" , PYRAMID18},
129 :
130 : {"INFEDGE" , INFEDGE2},
131 : {"INFEDGE2" , INFEDGE2},
132 :
133 : {"INFQUAD" , INFQUAD4},
134 : {"INFQUAD4" , INFQUAD4},
135 : {"INFQUAD6" , INFQUAD6},
136 :
137 : {"INFHEX" , INFHEX8},
138 : {"INFHEX8" , INFHEX8},
139 : {"INFHEX16" , INFHEX16},
140 : {"INFHEX18" , INFHEX18},
141 :
142 : {"INFPRISM" , INFPRISM6},
143 : {"INFPRISM6" , INFPRISM6},
144 : {"INFPRISM12" , INFPRISM12},
145 :
146 : {"NODE" , NODEELEM},
147 : {"NODEELEM" , NODEELEM},
148 :
149 : {"INVALID_ELEM" , INVALID_ELEM}
150 : };
151 :
152 : std::map<ElemType, std::string> enum_to_elem_type =
153 : build_reverse_map(elem_type_to_enum);
154 :
155 :
156 : std::map<std::string, ElemMappingType> elem_mapping_type_to_enum {
157 : {"LAGRANGE_MAP" , LAGRANGE_MAP},
158 : {"RATIONAL_BERNSTEIN_MAP", RATIONAL_BERNSTEIN_MAP},
159 : {"INVALID_MAP" , INVALID_MAP}
160 : };
161 :
162 : std::map<ElemMappingType, std::string> enum_to_elem_mapping_type =
163 : build_reverse_map(elem_mapping_type_to_enum);
164 :
165 :
166 : std::map<std::string, Order> order_to_enum {
167 : {"CONSTANT" , CONSTANT},
168 : {"FIRST" , FIRST},
169 : {"SECOND" , SECOND},
170 : {"THIRD" , THIRD},
171 : {"FOURTH" , FOURTH},
172 : {"FIFTH" , FIFTH},
173 : {"SIXTH" , SIXTH},
174 : {"SEVENTH" , SEVENTH},
175 : {"EIGHTH" , EIGHTH},
176 : {"NINTH" , NINTH},
177 : {"TENTH" , TENTH},
178 :
179 : {"ELEVENTH" , ELEVENTH},
180 : {"TWELFTH" , TWELFTH},
181 : {"THIRTEENTH" , THIRTEENTH},
182 : {"FOURTEENTH" , FOURTEENTH},
183 : {"FIFTEENTH" , FIFTEENTH},
184 : {"SIXTEENTH" , SIXTEENTH},
185 : {"SEVENTEENTH" , SEVENTEENTH},
186 : {"EIGHTTEENTH" , EIGHTTEENTH},
187 : {"NINETEENTH" , NINETEENTH},
188 : {"TWENTIETH" , TWENTIETH},
189 :
190 : {"TWENTYFIRST" , TWENTYFIRST},
191 : {"TWENTYSECOND" , TWENTYSECOND},
192 : {"TWENTYTHIRD" , TWENTYTHIRD},
193 : {"TWENTYFOURTH" , TWENTYFOURTH},
194 : {"TWENTYFIFTH" , TWENTYFIFTH},
195 : {"TWENTYSIXTH" , TWENTYSIXTH},
196 : {"TWENTYSEVENTH", TWENTYSEVENTH},
197 : {"TWENTYEIGHTH" , TWENTYEIGHTH},
198 : {"TWENTYNINTH" , TWENTYNINTH},
199 : {"THIRTIETH" , THIRTIETH},
200 :
201 : {"THIRTYFIRST" , THIRTYFIRST},
202 : {"THIRTYSECOND" , THIRTYSECOND},
203 : {"THIRTYTHIRD" , THIRTYTHIRD},
204 : {"THIRTYFOURTH" , THIRTYFOURTH},
205 : {"THIRTYFIFTH" , THIRTYFIFTH},
206 : {"THIRTYSIXTH" , THIRTYSIXTH},
207 : {"THIRTYSEVENTH", THIRTYSEVENTH},
208 : {"THIRTYEIGHTH" , THIRTYEIGHTH},
209 : {"THIRTYNINTH" , THIRTYNINTH},
210 : {"FORTIETH" , FORTIETH},
211 :
212 : {"FORTYFIRST" , FORTYFIRST},
213 : {"FORTYSECOND" , FORTYSECOND},
214 : {"FORTYTHIRD" , FORTYTHIRD},
215 : {"MAXIMUM" , MAXIMUM}
216 : };
217 :
218 : std::map<Order, std::string> enum_to_order =
219 : build_reverse_map(order_to_enum);
220 :
221 :
222 : std::map<std::string, FEFamily> fefamily_to_enum {
223 : {"LAGRANGE" , LAGRANGE},
224 : {"LAGRANGE_VEC" , LAGRANGE_VEC},
225 : {"L2_LAGRANGE" , L2_LAGRANGE},
226 : {"L2_LAGRANGE_VEC" , L2_LAGRANGE_VEC},
227 : {"LAGRANGE_GLL" , LAGRANGE_GLL},
228 : {"L2_LAGRANGE_GLL" , L2_LAGRANGE_GLL},
229 : {"HIERARCHIC" , HIERARCHIC},
230 : {"HIERARCHIC_VEC" , HIERARCHIC_VEC},
231 : {"L2_HIERARCHIC" , L2_HIERARCHIC},
232 : {"L2_HIERARCHIC_VEC" , L2_HIERARCHIC_VEC},
233 : {"SIDE_HIERARCHIC" , SIDE_HIERARCHIC},
234 : {"MONOMIAL" , MONOMIAL},
235 : {"MONOMIAL_VEC" , MONOMIAL_VEC},
236 : {"SCALAR" , SCALAR},
237 : {"XYZ" , XYZ},
238 : {"BERNSTEIN" , BERNSTEIN},
239 : {"RATIONAL_BERNSTEIN", RATIONAL_BERNSTEIN},
240 : {"SZABAB" , SZABAB},
241 : {"INFINITE_MAP" , INFINITE_MAP},
242 : {"JACOBI_20_00" , JACOBI_20_00},
243 : {"JACOBI_30_00" , JACOBI_30_00},
244 : {"LEGENDRE" , LEGENDRE},
245 : {"CLOUGH" , CLOUGH},
246 : {"HERMITE" , HERMITE},
247 : {"SUBDIVISION" , SUBDIVISION},
248 : {"NEDELEC_ONE" , NEDELEC_ONE},
249 : {"RAVIART_THOMAS" , RAVIART_THOMAS},
250 : {"L2_RAVIART_THOMAS" , L2_RAVIART_THOMAS}
251 : };
252 :
253 : std::map<FEFamily, std::string> enum_to_fefamily =
254 : build_reverse_map(fefamily_to_enum);
255 :
256 :
257 : std::map<std::string, InfMapType> inf_map_type_to_enum {
258 : {"CARTESIAN" , CARTESIAN},
259 : {"SPHERICAL" , SPHERICAL},
260 : {"ELLIPSOIDAL", ELLIPSOIDAL}
261 : };
262 :
263 : std::map<InfMapType, std::string> enum_to_inf_map_type =
264 : build_reverse_map(inf_map_type_to_enum);
265 :
266 :
267 : std::map<std::string, QuadratureType> quadrature_type_to_enum {
268 : {"QCLOUGH" , QCLOUGH},
269 : {"QCOMPOSITE" , QCOMPOSITE},
270 : {"QCONICAL" , QCONICAL},
271 : {"QGAUSS" , QGAUSS},
272 : {"QGAUSS_LOBATTO" , QGAUSS_LOBATTO},
273 : {"QGRID" , QGRID},
274 : {"QGRUNDMANN_MOLLER", QGRUNDMANN_MOLLER},
275 : {"QJACOBI_1_0" , QJACOBI_1_0},
276 : {"QJACOBI_2_0" , QJACOBI_2_0},
277 : {"QMONOMIAL" , QMONOMIAL},
278 : {"QNODAL" , QNODAL},
279 : {"QSIMPSON" , QSIMPSON},
280 : {"QTRAP" , QTRAP}
281 : };
282 :
283 : std::map<QuadratureType, std::string> enum_to_quadrature_type =
284 : build_reverse_map(quadrature_type_to_enum);
285 :
286 :
287 : std::map<std::string, PartitionerType> partitioner_type_to_enum {
288 : {"CENTROID_PARTITIONER" , CENTROID_PARTITIONER},
289 : {"LINEAR_PARTITIONER" , LINEAR_PARTITIONER},
290 : {"SFC_PARTITIONER" , SFC_PARTITIONER},
291 : {"HILBERT_SFC_PARTITIONER" , HILBERT_SFC_PARTITIONER},
292 : {"MORTON_SFC_PARTITIONER" , MORTON_SFC_PARTITIONER},
293 : {"METIS_PARTITIONER" , METIS_PARTITIONER},
294 : {"PARMETIS_PARTITIONER" , PARMETIS_PARTITIONER},
295 : {"SUBDOMAIN_PARTITIONER" , SUBDOMAIN_PARTITIONER},
296 : {"MAPPED_SUBDOMAIN_PARTITIONER", MAPPED_SUBDOMAIN_PARTITIONER},
297 :
298 : //shorter
299 : {"CENTROID" , CENTROID_PARTITIONER},
300 : {"LINEAR" , LINEAR_PARTITIONER},
301 : {"SFC" , SFC_PARTITIONER},
302 : {"HILBERT_SFC" , HILBERT_SFC_PARTITIONER},
303 : {"MORTON_SFC" , MORTON_SFC_PARTITIONER},
304 : {"METIS" , METIS_PARTITIONER},
305 : {"PARMETIS" , PARMETIS_PARTITIONER},
306 : {"SUBDOMAIN" , SUBDOMAIN_PARTITIONER},
307 : {"MAPPED_SUBDOMAIN" , MAPPED_SUBDOMAIN_PARTITIONER},
308 : };
309 :
310 : std::map<PartitionerType, std::string> enum_to_partitioner_type =
311 : build_reverse_map(partitioner_type_to_enum);
312 :
313 :
314 : std::map<std::string, PreconditionerType> preconditioner_type_to_enum {
315 : {"IDENTITY_PRECOND" , IDENTITY_PRECOND},
316 : {"JACOBI_PRECOND" , JACOBI_PRECOND},
317 : {"BLOCK_JACOBI_PRECOND" , BLOCK_JACOBI_PRECOND},
318 : {"SOR_PRECOND" , SOR_PRECOND},
319 : {"SSOR_PRECOND" , SSOR_PRECOND},
320 : {"EISENSTAT_PRECOND" , EISENSTAT_PRECOND},
321 : {"ASM_PRECOND" , ASM_PRECOND},
322 : {"CHOLESKY_PRECOND" , CHOLESKY_PRECOND},
323 : {"ICC_PRECOND" , ICC_PRECOND},
324 : {"ILU_PRECOND" , ILU_PRECOND},
325 : {"LU_PRECOND" , LU_PRECOND},
326 : {"USER_PRECOND" , USER_PRECOND},
327 : {"SHELL_PRECOND" , SHELL_PRECOND},
328 : {"AMG_PRECOND" , AMG_PRECOND},
329 : {"SVD_PRECOND" , SVD_PRECOND},
330 : {"INVALID_PRECONDITIONER", INVALID_PRECONDITIONER},
331 :
332 : //shorter
333 : {"IDENTITY" , IDENTITY_PRECOND},
334 : {"JACOBI" , JACOBI_PRECOND},
335 : {"BLOCK_JACOBI", BLOCK_JACOBI_PRECOND},
336 : {"SOR" , SOR_PRECOND},
337 : {"SSOR" , SSOR_PRECOND},
338 : {"EISENSTAT" , EISENSTAT_PRECOND},
339 : {"ASM" , ASM_PRECOND},
340 : {"CHOLESKY" , CHOLESKY_PRECOND},
341 : {"ICC" , ICC_PRECOND},
342 : {"ILU" , ILU_PRECOND},
343 : {"LU" , LU_PRECOND},
344 : {"USER" , USER_PRECOND},
345 : {"SHELL" , SHELL_PRECOND},
346 : {"AMG" , AMG_PRECOND},
347 : {"SVD" , SVD_PRECOND},
348 : {"INVALID" , INVALID_PRECONDITIONER},
349 : };
350 :
351 : std::map<PreconditionerType, std::string> enum_to_preconditioner_type =
352 : build_reverse_map(preconditioner_type_to_enum);
353 :
354 :
355 : #ifdef LIBMESH_ENABLE_AMR
356 : std::map<std::string, Elem::RefinementState> refinementstate_type_to_enum {
357 : {"COARSEN" , Elem::COARSEN},
358 : {"DO_NOTHING" , Elem::DO_NOTHING},
359 : {"REFINE" , Elem::REFINE},
360 : {"JUST_REFINED" , Elem::JUST_REFINED},
361 : {"JUST_COARSENED" , Elem::JUST_COARSENED},
362 : {"INACTIVE" , Elem::INACTIVE},
363 : {"COARSEN_INACTIVE" , Elem::COARSEN_INACTIVE},
364 : {"INVALID_REFINEMENTSTATE", Elem::INVALID_REFINEMENTSTATE},
365 : };
366 :
367 : std::map<Elem::RefinementState, std::string> enum_to_refinementstate_type =
368 : build_reverse_map(refinementstate_type_to_enum);
369 : #endif // LIBMESH_ENABLE_AMR
370 :
371 :
372 : std::map<std::string, EigenSolverType> eigensolvertype_to_enum {
373 : {"POWER" , POWER},
374 : {"LAPACK" , LAPACK},
375 : {"SUBSPACE" , SUBSPACE},
376 : {"ARNOLDI" , ARNOLDI},
377 : {"LANCZOS" , LANCZOS},
378 : {"KRYLOVSCHUR" , KRYLOVSCHUR},
379 : {"INVALID_EIGENSOLVER", INVALID_EIGENSOLVER},
380 : };
381 :
382 : std::map<EigenSolverType, std::string> enum_to_eigensolvertype =
383 : build_reverse_map(eigensolvertype_to_enum);
384 :
385 :
386 : std::map<std::string, SolverType> solvertype_to_enum {
387 : {"CG" , CG},
388 : {"CGN" , CGN},
389 : {"CGS" , CGS},
390 : {"CR" , CR},
391 : {"QMR" , QMR},
392 : {"TCQMR" , TCQMR},
393 : {"TFQMR" , TFQMR},
394 : {"BICG" , BICG},
395 : {"BICGSTAB" , BICGSTAB},
396 : {"MINRES" , MINRES},
397 : {"GMRES" , GMRES},
398 : {"LSQR" , LSQR},
399 : {"JACOBI" , JACOBI},
400 : {"SOR_FORWARD" , SOR_FORWARD},
401 : {"SOR_BACKWARD" , SOR_BACKWARD},
402 : {"SSOR" , SSOR},
403 : {"RICHARDSON" , RICHARDSON},
404 : {"CHEBYSHEV" , CHEBYSHEV},
405 : {"SPARSELU" , SPARSELU},
406 : {"INVALID_SOLVER", INVALID_SOLVER},
407 : };
408 :
409 : std::map<SolverType, std::string> enum_to_solvertype =
410 : build_reverse_map(solvertype_to_enum);
411 :
412 :
413 : std::map<std::string, ElemQuality> elemquality_to_enum {
414 : {"ASPECT_RATIO" , ASPECT_RATIO},
415 : {"SKEW" , SKEW},
416 : {"SKEW_ANGLE" , SKEW_ANGLE},
417 : {"SHEAR" , SHEAR},
418 : {"SHAPE" , SHAPE},
419 : {"MAX_ANGLE" , MAX_ANGLE},
420 : {"MIN_ANGLE" , MIN_ANGLE},
421 : {"MAX_DIHEDRAL_ANGLE" , MAX_DIHEDRAL_ANGLE},
422 : {"MIN_DIHEDRAL_ANGLE" , MIN_DIHEDRAL_ANGLE},
423 : {"CONDITION" , CONDITION},
424 : {"DISTORTION" , DISTORTION},
425 : {"TAPER" , TAPER},
426 : {"WARP" , WARP},
427 : {"STRETCH" , STRETCH},
428 : {"DIAGONAL" , DIAGONAL},
429 : {"ASPECT_RATIO_BETA" , ASPECT_RATIO_BETA},
430 : {"ASPECT_RATIO_GAMMA" , ASPECT_RATIO_GAMMA},
431 : {"SIZE" , SIZE},
432 : {"JACOBIAN" , JACOBIAN},
433 : {"SCALED_JACOBIAN" , SCALED_JACOBIAN},
434 : {"TWIST" , TWIST},
435 : {"EDGE_LENGTH_RATIO" , EDGE_LENGTH_RATIO},
436 : };
437 :
438 : std::map<ElemQuality, std::string> enum_to_elemquality =
439 : build_reverse_map(elemquality_to_enum);
440 :
441 :
442 : std::map<std::string, IOPackage> iopackage_to_enum {
443 : {"TECPLOT" , TECPLOT},
444 : {"GMV" , GMV},
445 : {"GMSH" , GMSH},
446 : {"VTK" , VTK},
447 : {"DIVA" , DIVA},
448 : {"TETGEN" , TETGEN},
449 : {"UCD" , UCD},
450 : {"LIBMESH" , LIBMESH},
451 : };
452 :
453 : std::map<IOPackage, std::string> enum_to_iopackage =
454 : build_reverse_map(iopackage_to_enum);
455 :
456 :
457 : std::map<std::string, FEMNormType> norm_type_to_enum {
458 : {"L2" , L2},
459 : {"H1" , H1},
460 : {"H2" , H2},
461 : {"HCURL" , HCURL},
462 : {"HDIV" , HDIV},
463 :
464 : {"L1" , L1},
465 : {"L_INF" , L_INF},
466 :
467 : {"H1_SEMINORM" , H1_SEMINORM},
468 : {"H2_SEMINORM" , H2_SEMINORM},
469 : {"HCURL_SEMINORM" , HCURL_SEMINORM},
470 : {"HDIV_SEMINORM" , HDIV_SEMINORM},
471 :
472 : {"W1_INF_SEMINORM", W1_INF_SEMINORM},
473 : {"W2_INF_SEMINORM", W2_INF_SEMINORM},
474 :
475 : {"DISCRETE_L1" , DISCRETE_L1},
476 : {"DISCRETE_L2" , DISCRETE_L2},
477 : {"DISCRETE_L_INF" , DISCRETE_L_INF},
478 :
479 : {"H1_X_SEMINORM" , H1_X_SEMINORM},
480 : {"H1_Y_SEMINORM" , H1_Y_SEMINORM},
481 : {"H1_Z_SEMINORM" , H1_Z_SEMINORM},
482 :
483 : {"INVALID_NORM" , INVALID_NORM},
484 : };
485 :
486 : std::map<FEMNormType, std::string> enum_to_norm_type =
487 : build_reverse_map(norm_type_to_enum);
488 :
489 :
490 : std::map<std::string, ParallelType> parallel_type_to_enum {
491 : {"AUTOMATIC" , AUTOMATIC},
492 : {"SERIAL" , SERIAL},
493 : {"PARALLEL" , PARALLEL},
494 : {"GHOSTED" , GHOSTED},
495 : {"INVALID_PARALLELIZATION" , INVALID_PARALLELIZATION},
496 : };
497 :
498 : std::map<ParallelType, std::string> enum_to_parallel_type =
499 : build_reverse_map(parallel_type_to_enum);
500 :
501 :
502 : std::map<std::string, PointLocatorType> point_locator_type_to_enum {
503 : {"TREE" , TREE},
504 : {"INVALID_LOCATOR" , INVALID_LOCATOR},
505 : };
506 :
507 : std::map<PointLocatorType, std::string> enum_to_point_locator_type =
508 : build_reverse_map(point_locator_type_to_enum);
509 :
510 :
511 : std::map<std::string, SolverPackage> solverpackage_type_to_enum {
512 : {"PETSC_SOLVERS" , PETSC_SOLVERS},
513 : {"TRILINOS_SOLVERS" , TRILINOS_SOLVERS},
514 : {"LASPACK_SOLVERS" , LASPACK_SOLVERS},
515 : {"SLEPC_SOLVERS" , SLEPC_SOLVERS},
516 : {"EIGEN_SOLVERS" , EIGEN_SOLVERS},
517 : {"NLOPT_SOLVERS" , NLOPT_SOLVERS},
518 : {"INVALID_SOLVER_PACKAGE" , INVALID_SOLVER_PACKAGE},
519 : };
520 :
521 : std::map<SolverPackage, std::string> enum_to_solverpackage_type =
522 : build_reverse_map(solverpackage_type_to_enum);
523 :
524 :
525 : std::map<std::string, SubsetSolveMode> subset_solve_mode_to_enum {
526 : {"SUBSET_ZERO" , SUBSET_ZERO},
527 : {"SUBSET_COPY_RHS" , SUBSET_COPY_RHS},
528 : {"SUBSET_DONT_TOUCH" , SUBSET_DONT_TOUCH},
529 : };
530 :
531 : std::map<SubsetSolveMode, std::string> enum_to_subset_solve_mode =
532 : build_reverse_map(subset_solve_mode_to_enum);
533 :
534 :
535 : std::map<std::string, XdrMODE> xdr_mode_to_enum {
536 : {"UNKNOWN" , UNKNOWN},
537 : {"ENCODE" , ENCODE},
538 : {"DECODE" , DECODE},
539 : {"WRITE" , WRITE},
540 : {"READ" , READ},
541 : };
542 :
543 : std::map<XdrMODE, std::string> enum_to_xdr_mode =
544 : build_reverse_map(xdr_mode_to_enum);
545 :
546 :
547 : std::map<std::string, LinearConvergenceReason> linear_convergence_reason_to_enum {
548 : {"CONVERGED_RTOL_NORMAL", CONVERGED_RTOL_NORMAL},
549 : {"CONVERGED_ATOL_NORMAL", CONVERGED_ATOL_NORMAL},
550 : {"CONVERGED_RTOL", CONVERGED_RTOL},
551 : {"CONVERGED_ATOL", CONVERGED_ATOL},
552 : {"CONVERGED_ITS", CONVERGED_ITS},
553 : {"CONVERGED_CG_NEG_CURVE", CONVERGED_CG_NEG_CURVE},
554 : {"CONVERGED_CG_CONSTRAINED", CONVERGED_CG_CONSTRAINED},
555 : {"CONVERGED_STEP_LENGTH", CONVERGED_STEP_LENGTH},
556 : {"CONVERGED_HAPPY_BREAKDOWN", CONVERGED_HAPPY_BREAKDOWN},
557 : {"DIVERGED_NULL", DIVERGED_NULL},
558 : {"DIVERGED_ITS", DIVERGED_ITS},
559 : {"DIVERGED_DTOL", DIVERGED_DTOL},
560 : {"DIVERGED_BREAKDOWN", DIVERGED_BREAKDOWN},
561 : {"DIVERGED_BREAKDOWN_BICG", DIVERGED_BREAKDOWN_BICG},
562 : {"DIVERGED_NONSYMMETRIC", DIVERGED_NONSYMMETRIC},
563 : {"DIVERGED_INDEFINITE_PC", DIVERGED_INDEFINITE_PC},
564 : {"DIVERGED_NAN", DIVERGED_NAN},
565 : {"DIVERGED_INDEFINITE_MAT", DIVERGED_INDEFINITE_MAT},
566 : {"DIVERGED_PCSETUP_FAILED", DIVERGED_PCSETUP_FAILED},
567 : {"CONVERGED_ITERATING", CONVERGED_ITERATING},
568 : {"UNKNOWN_FLAG", UNKNOWN_FLAG},
569 : };
570 :
571 : std::map<LinearConvergenceReason, std::string> enum_to_linear_convergence_reason =
572 : build_reverse_map(linear_convergence_reason_to_enum);
573 :
574 : } // end anonymous namespace
575 :
576 :
577 :
578 : // ------------------------------------------------------
579 : // Utility::string_to_enum<> & Utility::enum_to_string<>
580 : // full specializations
581 : namespace Utility {
582 :
583 : #define INSTANTIATE_STRING_TO_ENUM(ENUM_NAME,VAR_NAME) \
584 : template <> \
585 : ENUM_NAME string_to_enum<ENUM_NAME> (std::string_view s) \
586 : { \
587 : std::string upper(s); \
588 : std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper); \
589 : \
590 : if (!VAR_NAME##_to_enum.count(upper)) \
591 : { \
592 : libmesh_error_msg("No " #ENUM_NAME " named " << s << " found."); \
593 : } \
594 : \
595 : return VAR_NAME##_to_enum[upper]; \
596 : } \
597 : \
598 : template <> \
599 : ENUM_NAME string_to_enum<ENUM_NAME> (const std::string & s) \
600 : { \
601 : return string_to_enum<ENUM_NAME>(std::string_view(s)); \
602 : } \
603 : \
604 : template <> \
605 : ENUM_NAME string_to_enum<ENUM_NAME> (const char * s) \
606 : { \
607 : return string_to_enum<ENUM_NAME>(std::string_view(s)); \
608 : } \
609 : \
610 : template <> \
611 : std::string enum_to_string<ENUM_NAME> (const ENUM_NAME e) \
612 : { \
613 : if (!enum_to_##VAR_NAME .count(e)) \
614 : libmesh_error_msg("No " #ENUM_NAME " with enumeration " << e << " found."); \
615 : \
616 : return enum_to_##VAR_NAME [e]; \
617 : }
618 :
619 :
620 :
621 766986 : INSTANTIATE_STRING_TO_ENUM(ElemType,elem_type)
622 0 : INSTANTIATE_STRING_TO_ENUM(ElemMappingType,elem_mapping_type)
623 9499 : INSTANTIATE_STRING_TO_ENUM(Order,order)
624 8611 : INSTANTIATE_STRING_TO_ENUM(FEFamily,fefamily)
625 2849 : INSTANTIATE_STRING_TO_ENUM(InfMapType,inf_map_type)
626 685 : INSTANTIATE_STRING_TO_ENUM(QuadratureType,quadrature_type)
627 190946 : INSTANTIATE_STRING_TO_ENUM(PartitionerType,partitioner_type)
628 0 : INSTANTIATE_STRING_TO_ENUM(PreconditionerType,preconditioner_type)
629 :
630 : #ifdef LIBMESH_ENABLE_AMR
631 0 : INSTANTIATE_STRING_TO_ENUM(Elem::RefinementState,refinementstate_type)
632 : #endif // LIBMESH_ENABLE_AMR
633 :
634 23 : INSTANTIATE_STRING_TO_ENUM(SolverType,solvertype)
635 0 : INSTANTIATE_STRING_TO_ENUM(EigenSolverType,eigensolvertype)
636 642515 : INSTANTIATE_STRING_TO_ENUM(ElemQuality,elemquality)
637 0 : INSTANTIATE_STRING_TO_ENUM(IOPackage,iopackage)
638 0 : INSTANTIATE_STRING_TO_ENUM(FEMNormType, norm_type)
639 0 : INSTANTIATE_STRING_TO_ENUM(ParallelType, parallel_type)
640 0 : INSTANTIATE_STRING_TO_ENUM(PointLocatorType, point_locator_type)
641 22 : INSTANTIATE_STRING_TO_ENUM(SolverPackage,solverpackage_type)
642 0 : INSTANTIATE_STRING_TO_ENUM(SubsetSolveMode,subset_solve_mode)
643 0 : INSTANTIATE_STRING_TO_ENUM(XdrMODE,xdr_mode)
644 0 : INSTANTIATE_STRING_TO_ENUM(LinearConvergenceReason, linear_convergence_reason)
645 :
646 : #undef INSTANTIATE_STRING_TO_ENUM
647 :
648 : } // namespace Utility
649 :
650 : } // namespace libMesh
|