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 564235 : 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 531335 : if (auto preimage = reverse.find(val);
72 153102 : preimage == reverse.end())
73 334906 : 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 :
102 : {"C0POLYGON" , C0POLYGON},
103 :
104 : {"C0POLYHEDRON" , C0POLYHEDRON},
105 :
106 : {"TET" , TET4},
107 : {"TET4" , TET4},
108 : {"TET10" , TET10},
109 : {"TET14" , TET14},
110 :
111 : {"HEX" , HEX8},
112 : {"HEX8" , HEX8},
113 : {"HEX20" , HEX20},
114 : {"HEX27" , HEX27},
115 :
116 : {"PRISM" , PRISM6},
117 : {"PRISM6" , PRISM6},
118 : {"PRISM15" , PRISM15},
119 : {"PRISM18" , PRISM18},
120 : {"PRISM20" , PRISM20},
121 : {"PRISM21" , PRISM21},
122 :
123 : {"PYRAMID" , PYRAMID5},
124 : {"PYRAMID5" , PYRAMID5},
125 : {"PYRAMID13" , PYRAMID13},
126 : {"PYRAMID14" , PYRAMID14},
127 : {"PYRAMID18" , PYRAMID18},
128 :
129 : {"INFEDGE" , INFEDGE2},
130 : {"INFEDGE2" , INFEDGE2},
131 :
132 : {"INFQUAD" , INFQUAD4},
133 : {"INFQUAD4" , INFQUAD4},
134 : {"INFQUAD6" , INFQUAD6},
135 :
136 : {"INFHEX" , INFHEX8},
137 : {"INFHEX8" , INFHEX8},
138 : {"INFHEX16" , INFHEX16},
139 : {"INFHEX18" , INFHEX18},
140 :
141 : {"INFPRISM" , INFPRISM6},
142 : {"INFPRISM6" , INFPRISM6},
143 : {"INFPRISM12" , INFPRISM12},
144 :
145 : {"NODE" , NODEELEM},
146 : {"NODEELEM" , NODEELEM},
147 :
148 : {"INVALID_ELEM" , INVALID_ELEM}
149 : };
150 :
151 : std::map<ElemType, std::string> enum_to_elem_type =
152 : build_reverse_map(elem_type_to_enum);
153 :
154 :
155 : std::map<std::string, ElemMappingType> elem_mapping_type_to_enum {
156 : {"LAGRANGE_MAP" , LAGRANGE_MAP},
157 : {"RATIONAL_BERNSTEIN_MAP", RATIONAL_BERNSTEIN_MAP},
158 : {"INVALID_MAP" , INVALID_MAP}
159 : };
160 :
161 : std::map<ElemMappingType, std::string> enum_to_elem_mapping_type =
162 : build_reverse_map(elem_mapping_type_to_enum);
163 :
164 :
165 : std::map<std::string, Order> order_to_enum {
166 : {"CONSTANT" , CONSTANT},
167 : {"FIRST" , FIRST},
168 : {"SECOND" , SECOND},
169 : {"THIRD" , THIRD},
170 : {"FOURTH" , FOURTH},
171 : {"FIFTH" , FIFTH},
172 : {"SIXTH" , SIXTH},
173 : {"SEVENTH" , SEVENTH},
174 : {"EIGHTH" , EIGHTH},
175 : {"NINTH" , NINTH},
176 : {"TENTH" , TENTH},
177 :
178 : {"ELEVENTH" , ELEVENTH},
179 : {"TWELFTH" , TWELFTH},
180 : {"THIRTEENTH" , THIRTEENTH},
181 : {"FOURTEENTH" , FOURTEENTH},
182 : {"FIFTEENTH" , FIFTEENTH},
183 : {"SIXTEENTH" , SIXTEENTH},
184 : {"SEVENTEENTH" , SEVENTEENTH},
185 : {"EIGHTTEENTH" , EIGHTTEENTH},
186 : {"NINETEENTH" , NINETEENTH},
187 : {"TWENTIETH" , TWENTIETH},
188 :
189 : {"TWENTYFIRST" , TWENTYFIRST},
190 : {"TWENTYSECOND" , TWENTYSECOND},
191 : {"TWENTYTHIRD" , TWENTYTHIRD},
192 : {"TWENTYFOURTH" , TWENTYFOURTH},
193 : {"TWENTYFIFTH" , TWENTYFIFTH},
194 : {"TWENTYSIXTH" , TWENTYSIXTH},
195 : {"TWENTYSEVENTH", TWENTYSEVENTH},
196 : {"TWENTYEIGHTH" , TWENTYEIGHTH},
197 : {"TWENTYNINTH" , TWENTYNINTH},
198 : {"THIRTIETH" , THIRTIETH},
199 :
200 : {"THIRTYFIRST" , THIRTYFIRST},
201 : {"THIRTYSECOND" , THIRTYSECOND},
202 : {"THIRTYTHIRD" , THIRTYTHIRD},
203 : {"THIRTYFOURTH" , THIRTYFOURTH},
204 : {"THIRTYFIFTH" , THIRTYFIFTH},
205 : {"THIRTYSIXTH" , THIRTYSIXTH},
206 : {"THIRTYSEVENTH", THIRTYSEVENTH},
207 : {"THIRTYEIGHTH" , THIRTYEIGHTH},
208 : {"THIRTYNINTH" , THIRTYNINTH},
209 : {"FORTIETH" , FORTIETH},
210 :
211 : {"FORTYFIRST" , FORTYFIRST},
212 : {"FORTYSECOND" , FORTYSECOND},
213 : {"FORTYTHIRD" , FORTYTHIRD},
214 : {"MAXIMUM" , MAXIMUM}
215 : };
216 :
217 : std::map<Order, std::string> enum_to_order =
218 : build_reverse_map(order_to_enum);
219 :
220 :
221 : std::map<std::string, FEFamily> fefamily_to_enum {
222 : {"LAGRANGE" , LAGRANGE},
223 : {"LAGRANGE_VEC" , LAGRANGE_VEC},
224 : {"L2_LAGRANGE" , L2_LAGRANGE},
225 : {"L2_LAGRANGE_VEC" , L2_LAGRANGE_VEC},
226 : {"LAGRANGE_GLL" , LAGRANGE_GLL},
227 : {"L2_LAGRANGE_GLL" , L2_LAGRANGE_GLL},
228 : {"HIERARCHIC" , HIERARCHIC},
229 : {"HIERARCHIC_VEC" , HIERARCHIC_VEC},
230 : {"L2_HIERARCHIC" , L2_HIERARCHIC},
231 : {"L2_HIERARCHIC_VEC" , L2_HIERARCHIC_VEC},
232 : {"SIDE_HIERARCHIC" , SIDE_HIERARCHIC},
233 : {"MONOMIAL" , MONOMIAL},
234 : {"MONOMIAL_VEC" , MONOMIAL_VEC},
235 : {"SCALAR" , SCALAR},
236 : {"XYZ" , XYZ},
237 : {"BERNSTEIN" , BERNSTEIN},
238 : {"RATIONAL_BERNSTEIN", RATIONAL_BERNSTEIN},
239 : {"SZABAB" , SZABAB},
240 : {"INFINITE_MAP" , INFINITE_MAP},
241 : {"JACOBI_20_00" , JACOBI_20_00},
242 : {"JACOBI_30_00" , JACOBI_30_00},
243 : {"LEGENDRE" , LEGENDRE},
244 : {"CLOUGH" , CLOUGH},
245 : {"HERMITE" , HERMITE},
246 : {"SUBDIVISION" , SUBDIVISION},
247 : {"NEDELEC_ONE" , NEDELEC_ONE},
248 : {"RAVIART_THOMAS" , RAVIART_THOMAS},
249 : {"L2_RAVIART_THOMAS" , L2_RAVIART_THOMAS}
250 : };
251 :
252 : std::map<FEFamily, std::string> enum_to_fefamily =
253 : build_reverse_map(fefamily_to_enum);
254 :
255 :
256 : std::map<std::string, InfMapType> inf_map_type_to_enum {
257 : {"CARTESIAN" , CARTESIAN},
258 : {"SPHERICAL" , SPHERICAL},
259 : {"ELLIPSOIDAL", ELLIPSOIDAL}
260 : };
261 :
262 : std::map<InfMapType, std::string> enum_to_inf_map_type =
263 : build_reverse_map(inf_map_type_to_enum);
264 :
265 :
266 : std::map<std::string, QuadratureType> quadrature_type_to_enum {
267 : {"QCLOUGH" , QCLOUGH},
268 : {"QCOMPOSITE" , QCOMPOSITE},
269 : {"QCONICAL" , QCONICAL},
270 : {"QGAUSS" , QGAUSS},
271 : {"QGAUSS_LOBATTO" , QGAUSS_LOBATTO},
272 : {"QGRID" , QGRID},
273 : {"QGRUNDMANN_MOLLER", QGRUNDMANN_MOLLER},
274 : {"QJACOBI_1_0" , QJACOBI_1_0},
275 : {"QJACOBI_2_0" , QJACOBI_2_0},
276 : {"QMONOMIAL" , QMONOMIAL},
277 : {"QNODAL" , QNODAL},
278 : {"QSIMPSON" , QSIMPSON},
279 : {"QTRAP" , QTRAP}
280 : };
281 :
282 : std::map<QuadratureType, std::string> enum_to_quadrature_type =
283 : build_reverse_map(quadrature_type_to_enum);
284 :
285 :
286 : std::map<std::string, PartitionerType> partitioner_type_to_enum {
287 : {"CENTROID_PARTITIONER" , CENTROID_PARTITIONER},
288 : {"LINEAR_PARTITIONER" , LINEAR_PARTITIONER},
289 : {"SFC_PARTITIONER" , SFC_PARTITIONER},
290 : {"HILBERT_SFC_PARTITIONER" , HILBERT_SFC_PARTITIONER},
291 : {"MORTON_SFC_PARTITIONER" , MORTON_SFC_PARTITIONER},
292 : {"METIS_PARTITIONER" , METIS_PARTITIONER},
293 : {"PARMETIS_PARTITIONER" , PARMETIS_PARTITIONER},
294 : {"SUBDOMAIN_PARTITIONER" , SUBDOMAIN_PARTITIONER},
295 : {"MAPPED_SUBDOMAIN_PARTITIONER", MAPPED_SUBDOMAIN_PARTITIONER},
296 :
297 : //shorter
298 : {"CENTROID" , CENTROID_PARTITIONER},
299 : {"LINEAR" , LINEAR_PARTITIONER},
300 : {"SFC" , SFC_PARTITIONER},
301 : {"HILBERT_SFC" , HILBERT_SFC_PARTITIONER},
302 : {"MORTON_SFC" , MORTON_SFC_PARTITIONER},
303 : {"METIS" , METIS_PARTITIONER},
304 : {"PARMETIS" , PARMETIS_PARTITIONER},
305 : {"SUBDOMAIN" , SUBDOMAIN_PARTITIONER},
306 : {"MAPPED_SUBDOMAIN" , MAPPED_SUBDOMAIN_PARTITIONER},
307 : };
308 :
309 : std::map<PartitionerType, std::string> enum_to_partitioner_type =
310 : build_reverse_map(partitioner_type_to_enum);
311 :
312 :
313 : std::map<std::string, PreconditionerType> preconditioner_type_to_enum {
314 : {"IDENTITY_PRECOND" , IDENTITY_PRECOND},
315 : {"JACOBI_PRECOND" , JACOBI_PRECOND},
316 : {"BLOCK_JACOBI_PRECOND" , BLOCK_JACOBI_PRECOND},
317 : {"SOR_PRECOND" , SOR_PRECOND},
318 : {"SSOR_PRECOND" , SSOR_PRECOND},
319 : {"EISENSTAT_PRECOND" , EISENSTAT_PRECOND},
320 : {"ASM_PRECOND" , ASM_PRECOND},
321 : {"CHOLESKY_PRECOND" , CHOLESKY_PRECOND},
322 : {"ICC_PRECOND" , ICC_PRECOND},
323 : {"ILU_PRECOND" , ILU_PRECOND},
324 : {"LU_PRECOND" , LU_PRECOND},
325 : {"USER_PRECOND" , USER_PRECOND},
326 : {"SHELL_PRECOND" , SHELL_PRECOND},
327 : {"AMG_PRECOND" , AMG_PRECOND},
328 : {"SVD_PRECOND" , SVD_PRECOND},
329 : {"INVALID_PRECONDITIONER", INVALID_PRECONDITIONER},
330 :
331 : //shorter
332 : {"IDENTITY" , IDENTITY_PRECOND},
333 : {"JACOBI" , JACOBI_PRECOND},
334 : {"BLOCK_JACOBI", BLOCK_JACOBI_PRECOND},
335 : {"SOR" , SOR_PRECOND},
336 : {"SSOR" , SSOR_PRECOND},
337 : {"EISENSTAT" , EISENSTAT_PRECOND},
338 : {"ASM" , ASM_PRECOND},
339 : {"CHOLESKY" , CHOLESKY_PRECOND},
340 : {"ICC" , ICC_PRECOND},
341 : {"ILU" , ILU_PRECOND},
342 : {"LU" , LU_PRECOND},
343 : {"USER" , USER_PRECOND},
344 : {"SHELL" , SHELL_PRECOND},
345 : {"AMG" , AMG_PRECOND},
346 : {"SVD" , SVD_PRECOND},
347 : {"INVALID" , INVALID_PRECONDITIONER},
348 : };
349 :
350 : std::map<PreconditionerType, std::string> enum_to_preconditioner_type =
351 : build_reverse_map(preconditioner_type_to_enum);
352 :
353 :
354 : #ifdef LIBMESH_ENABLE_AMR
355 : std::map<std::string, Elem::RefinementState> refinementstate_type_to_enum {
356 : {"COARSEN" , Elem::COARSEN},
357 : {"DO_NOTHING" , Elem::DO_NOTHING},
358 : {"REFINE" , Elem::REFINE},
359 : {"JUST_REFINED" , Elem::JUST_REFINED},
360 : {"JUST_COARSENED" , Elem::JUST_COARSENED},
361 : {"INACTIVE" , Elem::INACTIVE},
362 : {"COARSEN_INACTIVE" , Elem::COARSEN_INACTIVE},
363 : {"INVALID_REFINEMENTSTATE", Elem::INVALID_REFINEMENTSTATE},
364 : };
365 :
366 : std::map<Elem::RefinementState, std::string> enum_to_refinementstate_type =
367 : build_reverse_map(refinementstate_type_to_enum);
368 : #endif // LIBMESH_ENABLE_AMR
369 :
370 :
371 : std::map<std::string, EigenSolverType> eigensolvertype_to_enum {
372 : {"POWER" , POWER},
373 : {"LAPACK" , LAPACK},
374 : {"SUBSPACE" , SUBSPACE},
375 : {"ARNOLDI" , ARNOLDI},
376 : {"LANCZOS" , LANCZOS},
377 : {"KRYLOVSCHUR" , KRYLOVSCHUR},
378 : {"INVALID_EIGENSOLVER", INVALID_EIGENSOLVER},
379 : };
380 :
381 : std::map<EigenSolverType, std::string> enum_to_eigensolvertype =
382 : build_reverse_map(eigensolvertype_to_enum);
383 :
384 :
385 : std::map<std::string, SolverType> solvertype_to_enum {
386 : {"CG" , CG},
387 : {"CGN" , CGN},
388 : {"CGS" , CGS},
389 : {"CR" , CR},
390 : {"QMR" , QMR},
391 : {"TCQMR" , TCQMR},
392 : {"TFQMR" , TFQMR},
393 : {"BICG" , BICG},
394 : {"BICGSTAB" , BICGSTAB},
395 : {"MINRES" , MINRES},
396 : {"GMRES" , GMRES},
397 : {"LSQR" , LSQR},
398 : {"JACOBI" , JACOBI},
399 : {"SOR_FORWARD" , SOR_FORWARD},
400 : {"SOR_BACKWARD" , SOR_BACKWARD},
401 : {"SSOR" , SSOR},
402 : {"RICHARDSON" , RICHARDSON},
403 : {"CHEBYSHEV" , CHEBYSHEV},
404 : {"SPARSELU" , SPARSELU},
405 : {"INVALID_SOLVER", INVALID_SOLVER},
406 : };
407 :
408 : std::map<SolverType, std::string> enum_to_solvertype =
409 : build_reverse_map(solvertype_to_enum);
410 :
411 :
412 : std::map<std::string, ElemQuality> elemquality_to_enum {
413 : {"ASPECT_RATIO" , ASPECT_RATIO},
414 : {"SKEW" , SKEW},
415 : {"SKEW_ANGLE" , SKEW_ANGLE},
416 : {"SHEAR" , SHEAR},
417 : {"SHAPE" , SHAPE},
418 : {"MAX_ANGLE" , MAX_ANGLE},
419 : {"MIN_ANGLE" , MIN_ANGLE},
420 : {"MAX_DIHEDRAL_ANGLE" , MAX_DIHEDRAL_ANGLE},
421 : {"MIN_DIHEDRAL_ANGLE" , MIN_DIHEDRAL_ANGLE},
422 : {"CONDITION" , CONDITION},
423 : {"DISTORTION" , DISTORTION},
424 : {"TAPER" , TAPER},
425 : {"WARP" , WARP},
426 : {"STRETCH" , STRETCH},
427 : {"DIAGONAL" , DIAGONAL},
428 : {"ASPECT_RATIO_BETA" , ASPECT_RATIO_BETA},
429 : {"ASPECT_RATIO_GAMMA" , ASPECT_RATIO_GAMMA},
430 : {"SIZE" , SIZE},
431 : {"JACOBIAN" , JACOBIAN},
432 : {"SCALED_JACOBIAN" , SCALED_JACOBIAN},
433 : {"TWIST" , TWIST},
434 : {"EDGE_LENGTH_RATIO" , EDGE_LENGTH_RATIO},
435 : };
436 :
437 : std::map<ElemQuality, std::string> enum_to_elemquality =
438 : build_reverse_map(elemquality_to_enum);
439 :
440 :
441 : std::map<std::string, IOPackage> iopackage_to_enum {
442 : {"TECPLOT" , TECPLOT},
443 : {"GMV" , GMV},
444 : {"GMSH" , GMSH},
445 : {"VTK" , VTK},
446 : {"DIVA" , DIVA},
447 : {"TETGEN" , TETGEN},
448 : {"UCD" , UCD},
449 : {"LIBMESH" , LIBMESH},
450 : };
451 :
452 : std::map<IOPackage, std::string> enum_to_iopackage =
453 : build_reverse_map(iopackage_to_enum);
454 :
455 :
456 : std::map<std::string, FEMNormType> norm_type_to_enum {
457 : {"L2" , L2},
458 : {"H1" , H1},
459 : {"H2" , H2},
460 : {"HCURL" , HCURL},
461 : {"HDIV" , HDIV},
462 :
463 : {"L1" , L1},
464 : {"L_INF" , L_INF},
465 :
466 : {"H1_SEMINORM" , H1_SEMINORM},
467 : {"H2_SEMINORM" , H2_SEMINORM},
468 : {"HCURL_SEMINORM" , HCURL_SEMINORM},
469 : {"HDIV_SEMINORM" , HDIV_SEMINORM},
470 :
471 : {"W1_INF_SEMINORM", W1_INF_SEMINORM},
472 : {"W2_INF_SEMINORM", W2_INF_SEMINORM},
473 :
474 : {"DISCRETE_L1" , DISCRETE_L1},
475 : {"DISCRETE_L2" , DISCRETE_L2},
476 : {"DISCRETE_L_INF" , DISCRETE_L_INF},
477 :
478 : {"H1_X_SEMINORM" , H1_X_SEMINORM},
479 : {"H1_Y_SEMINORM" , H1_Y_SEMINORM},
480 : {"H1_Z_SEMINORM" , H1_Z_SEMINORM},
481 :
482 : {"INVALID_NORM" , INVALID_NORM},
483 : };
484 :
485 : std::map<FEMNormType, std::string> enum_to_norm_type =
486 : build_reverse_map(norm_type_to_enum);
487 :
488 :
489 : std::map<std::string, ParallelType> parallel_type_to_enum {
490 : {"AUTOMATIC" , AUTOMATIC},
491 : {"SERIAL" , SERIAL},
492 : {"PARALLEL" , PARALLEL},
493 : {"GHOSTED" , GHOSTED},
494 : {"INVALID_PARALLELIZATION" , INVALID_PARALLELIZATION},
495 : };
496 :
497 : std::map<ParallelType, std::string> enum_to_parallel_type =
498 : build_reverse_map(parallel_type_to_enum);
499 :
500 :
501 : std::map<std::string, PointLocatorType> point_locator_type_to_enum {
502 : {"TREE" , TREE},
503 : {"INVALID_LOCATOR" , INVALID_LOCATOR},
504 : };
505 :
506 : std::map<PointLocatorType, std::string> enum_to_point_locator_type =
507 : build_reverse_map(point_locator_type_to_enum);
508 :
509 :
510 : std::map<std::string, SolverPackage> solverpackage_type_to_enum {
511 : {"PETSC_SOLVERS" , PETSC_SOLVERS},
512 : {"TRILINOS_SOLVERS" , TRILINOS_SOLVERS},
513 : {"LASPACK_SOLVERS" , LASPACK_SOLVERS},
514 : {"SLEPC_SOLVERS" , SLEPC_SOLVERS},
515 : {"EIGEN_SOLVERS" , EIGEN_SOLVERS},
516 : {"NLOPT_SOLVERS" , NLOPT_SOLVERS},
517 : {"INVALID_SOLVER_PACKAGE" , INVALID_SOLVER_PACKAGE},
518 : };
519 :
520 : std::map<SolverPackage, std::string> enum_to_solverpackage_type =
521 : build_reverse_map(solverpackage_type_to_enum);
522 :
523 :
524 : std::map<std::string, SubsetSolveMode> subset_solve_mode_to_enum {
525 : {"SUBSET_ZERO" , SUBSET_ZERO},
526 : {"SUBSET_COPY_RHS" , SUBSET_COPY_RHS},
527 : {"SUBSET_DONT_TOUCH" , SUBSET_DONT_TOUCH},
528 : };
529 :
530 : std::map<SubsetSolveMode, std::string> enum_to_subset_solve_mode =
531 : build_reverse_map(subset_solve_mode_to_enum);
532 :
533 :
534 : std::map<std::string, XdrMODE> xdr_mode_to_enum {
535 : {"UNKNOWN" , UNKNOWN},
536 : {"ENCODE" , ENCODE},
537 : {"DECODE" , DECODE},
538 : {"WRITE" , WRITE},
539 : {"READ" , READ},
540 : };
541 :
542 : std::map<XdrMODE, std::string> enum_to_xdr_mode =
543 : build_reverse_map(xdr_mode_to_enum);
544 :
545 :
546 : std::map<std::string, LinearConvergenceReason> linear_convergence_reason_to_enum {
547 : {"CONVERGED_RTOL_NORMAL", CONVERGED_RTOL_NORMAL},
548 : {"CONVERGED_ATOL_NORMAL", CONVERGED_ATOL_NORMAL},
549 : {"CONVERGED_RTOL", CONVERGED_RTOL},
550 : {"CONVERGED_ATOL", CONVERGED_ATOL},
551 : {"CONVERGED_ITS", CONVERGED_ITS},
552 : {"CONVERGED_CG_NEG_CURVE", CONVERGED_CG_NEG_CURVE},
553 : {"CONVERGED_CG_CONSTRAINED", CONVERGED_CG_CONSTRAINED},
554 : {"CONVERGED_STEP_LENGTH", CONVERGED_STEP_LENGTH},
555 : {"CONVERGED_HAPPY_BREAKDOWN", CONVERGED_HAPPY_BREAKDOWN},
556 : {"DIVERGED_NULL", DIVERGED_NULL},
557 : {"DIVERGED_ITS", DIVERGED_ITS},
558 : {"DIVERGED_DTOL", DIVERGED_DTOL},
559 : {"DIVERGED_BREAKDOWN", DIVERGED_BREAKDOWN},
560 : {"DIVERGED_BREAKDOWN_BICG", DIVERGED_BREAKDOWN_BICG},
561 : {"DIVERGED_NONSYMMETRIC", DIVERGED_NONSYMMETRIC},
562 : {"DIVERGED_INDEFINITE_PC", DIVERGED_INDEFINITE_PC},
563 : {"DIVERGED_NAN", DIVERGED_NAN},
564 : {"DIVERGED_INDEFINITE_MAT", DIVERGED_INDEFINITE_MAT},
565 : {"DIVERGED_PCSETUP_FAILED", DIVERGED_PCSETUP_FAILED},
566 : {"CONVERGED_ITERATING", CONVERGED_ITERATING},
567 : {"UNKNOWN_FLAG", UNKNOWN_FLAG},
568 : };
569 :
570 : std::map<LinearConvergenceReason, std::string> enum_to_linear_convergence_reason =
571 : build_reverse_map(linear_convergence_reason_to_enum);
572 :
573 : } // end anonymous namespace
574 :
575 :
576 :
577 : // ------------------------------------------------------
578 : // Utility::string_to_enum<> & Utility::enum_to_string<>
579 : // full specializations
580 : namespace Utility {
581 :
582 : #define INSTANTIATE_STRING_TO_ENUM(ENUM_NAME,VAR_NAME) \
583 : template <> \
584 : ENUM_NAME string_to_enum<ENUM_NAME> (std::string_view s) \
585 : { \
586 : std::string upper(s); \
587 : std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper); \
588 : \
589 : if (!VAR_NAME##_to_enum.count(upper)) \
590 : { \
591 : libmesh_error_msg("No " #ENUM_NAME " named " << s << " found."); \
592 : } \
593 : \
594 : return VAR_NAME##_to_enum[upper]; \
595 : } \
596 : \
597 : template <> \
598 : ENUM_NAME string_to_enum<ENUM_NAME> (const std::string & s) \
599 : { \
600 : return string_to_enum<ENUM_NAME>(std::string_view(s)); \
601 : } \
602 : \
603 : template <> \
604 : ENUM_NAME string_to_enum<ENUM_NAME> (const char * s) \
605 : { \
606 : return string_to_enum<ENUM_NAME>(std::string_view(s)); \
607 : } \
608 : \
609 : template <> \
610 : std::string enum_to_string<ENUM_NAME> (const ENUM_NAME e) \
611 : { \
612 : if (!enum_to_##VAR_NAME .count(e)) \
613 : libmesh_error_msg("No " #ENUM_NAME " with enumeration " << e << " found."); \
614 : \
615 : return enum_to_##VAR_NAME [e]; \
616 : }
617 :
618 :
619 :
620 764643 : INSTANTIATE_STRING_TO_ENUM(ElemType,elem_type)
621 0 : INSTANTIATE_STRING_TO_ENUM(ElemMappingType,elem_mapping_type)
622 9543 : INSTANTIATE_STRING_TO_ENUM(Order,order)
623 8611 : INSTANTIATE_STRING_TO_ENUM(FEFamily,fefamily)
624 2849 : INSTANTIATE_STRING_TO_ENUM(InfMapType,inf_map_type)
625 685 : INSTANTIATE_STRING_TO_ENUM(QuadratureType,quadrature_type)
626 189996 : INSTANTIATE_STRING_TO_ENUM(PartitionerType,partitioner_type)
627 0 : INSTANTIATE_STRING_TO_ENUM(PreconditionerType,preconditioner_type)
628 :
629 : #ifdef LIBMESH_ENABLE_AMR
630 0 : INSTANTIATE_STRING_TO_ENUM(Elem::RefinementState,refinementstate_type)
631 : #endif // LIBMESH_ENABLE_AMR
632 :
633 23 : INSTANTIATE_STRING_TO_ENUM(SolverType,solvertype)
634 0 : INSTANTIATE_STRING_TO_ENUM(EigenSolverType,eigensolvertype)
635 640427 : INSTANTIATE_STRING_TO_ENUM(ElemQuality,elemquality)
636 0 : INSTANTIATE_STRING_TO_ENUM(IOPackage,iopackage)
637 0 : INSTANTIATE_STRING_TO_ENUM(FEMNormType, norm_type)
638 0 : INSTANTIATE_STRING_TO_ENUM(ParallelType, parallel_type)
639 0 : INSTANTIATE_STRING_TO_ENUM(PointLocatorType, point_locator_type)
640 22 : INSTANTIATE_STRING_TO_ENUM(SolverPackage,solverpackage_type)
641 0 : INSTANTIATE_STRING_TO_ENUM(SubsetSolveMode,subset_solve_mode)
642 0 : INSTANTIATE_STRING_TO_ENUM(XdrMODE,xdr_mode)
643 0 : INSTANTIATE_STRING_TO_ENUM(LinearConvergenceReason, linear_convergence_reason)
644 :
645 : #undef INSTANTIATE_STRING_TO_ENUM
646 :
647 : } // namespace Utility
648 :
649 : } // namespace libMesh
|