Line data Source code
1 : // The libMesh Finite Element Library.
2 : // Copyright (C) 2002-2025 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 327780 : build_reverse_map (const MapType & forward)
61 : {
62 9240 : std::map<typename MapType::mapped_type, typename MapType::key_type> reverse;
63 :
64 5539482 : 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 5211702 : if (auto preimage = reverse.find(val);
72 146916 : preimage == reverse.end())
73 4475487 : reverse.emplace (val, key);
74 623487 : else if (preimage->second < key)
75 17094 : preimage->second = key;
76 : }
77 :
78 327780 : return reverse;
79 : }
80 :
81 : std::map<std::string, ElemType> elem_type_to_enum {
82 : {"EDGE" , EDGE2},
83 : {"EDGE2" , EDGE2},
84 : {"EDGE2" , EDGE2},
85 : {"EDGE3" , EDGE3},
86 : {"EDGE4" , EDGE4},
87 :
88 : {"TRI" , TRI3},
89 : {"TRI3" , TRI3},
90 : {"TRISHELL3" , TRISHELL3},
91 : {"TRI3SUBDIVISION", TRI3SUBDIVISION},
92 : {"TRI6" , TRI6},
93 : {"TRI7" , TRI7},
94 :
95 : {"QUAD" , QUAD4},
96 : {"QUAD4" , QUAD4},
97 : {"QUADSHELL4" , QUADSHELL4},
98 : {"QUAD8" , QUAD8},
99 : {"QUADSHELL8" , QUADSHELL8},
100 : {"QUAD9" , QUAD9},
101 : {"QUADSHELL9" , QUADSHELL9},
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 : {"HIERARCHIC" , HIERARCHIC},
228 : {"HIERARCHIC_VEC" , HIERARCHIC_VEC},
229 : {"L2_HIERARCHIC" , L2_HIERARCHIC},
230 : {"L2_HIERARCHIC_VEC" , L2_HIERARCHIC_VEC},
231 : {"SIDE_HIERARCHIC" , SIDE_HIERARCHIC},
232 : {"MONOMIAL" , MONOMIAL},
233 : {"MONOMIAL_VEC" , MONOMIAL_VEC},
234 : {"SCALAR" , SCALAR},
235 : {"XYZ" , XYZ},
236 : {"BERNSTEIN" , BERNSTEIN},
237 : {"RATIONAL_BERNSTEIN", RATIONAL_BERNSTEIN},
238 : {"SZABAB" , SZABAB},
239 : {"INFINITE_MAP" , INFINITE_MAP},
240 : {"JACOBI_20_00" , JACOBI_20_00},
241 : {"JACOBI_30_00" , JACOBI_30_00},
242 : {"LEGENDRE" , LEGENDRE},
243 : {"CLOUGH" , CLOUGH},
244 : {"HERMITE" , HERMITE},
245 : {"SUBDIVISION" , SUBDIVISION},
246 : {"NEDELEC_ONE" , NEDELEC_ONE},
247 : {"RAVIART_THOMAS" , RAVIART_THOMAS},
248 : {"L2_RAVIART_THOMAS" , L2_RAVIART_THOMAS}
249 : };
250 :
251 : std::map<FEFamily, std::string> enum_to_fefamily =
252 : build_reverse_map(fefamily_to_enum);
253 :
254 :
255 : std::map<std::string, InfMapType> inf_map_type_to_enum {
256 : {"CARTESIAN" , CARTESIAN},
257 : {"SPHERICAL" , SPHERICAL},
258 : {"ELLIPSOIDAL", ELLIPSOIDAL}
259 : };
260 :
261 : std::map<InfMapType, std::string> enum_to_inf_map_type =
262 : build_reverse_map(inf_map_type_to_enum);
263 :
264 :
265 : std::map<std::string, QuadratureType> quadrature_type_to_enum {
266 : {"QCLOUGH" , QCLOUGH},
267 : {"QCOMPOSITE" , QCOMPOSITE},
268 : {"QCONICAL" , QCONICAL},
269 : {"QGAUSS" , QGAUSS},
270 : {"QGAUSS_LOBATTO" , QGAUSS_LOBATTO},
271 : {"QGRID" , QGRID},
272 : {"QGRUNDMANN_MOLLER", QGRUNDMANN_MOLLER},
273 : {"QJACOBI_1_0" , QJACOBI_1_0},
274 : {"QJACOBI_2_0" , QJACOBI_2_0},
275 : {"QMONOMIAL" , QMONOMIAL},
276 : {"QNODAL" , QNODAL},
277 : {"QSIMPSON" , QSIMPSON},
278 : {"QTRAP" , QTRAP}
279 : };
280 :
281 : std::map<QuadratureType, std::string> enum_to_quadrature_type =
282 : build_reverse_map(quadrature_type_to_enum);
283 :
284 :
285 : std::map<std::string, PartitionerType> partitioner_type_to_enum {
286 : {"CENTROID_PARTITIONER" , CENTROID_PARTITIONER},
287 : {"LINEAR_PARTITIONER" , LINEAR_PARTITIONER},
288 : {"SFC_PARTITIONER" , SFC_PARTITIONER},
289 : {"HILBERT_SFC_PARTITIONER" , HILBERT_SFC_PARTITIONER},
290 : {"MORTON_SFC_PARTITIONER" , MORTON_SFC_PARTITIONER},
291 : {"METIS_PARTITIONER" , METIS_PARTITIONER},
292 : {"PARMETIS_PARTITIONER" , PARMETIS_PARTITIONER},
293 : {"SUBDOMAIN_PARTITIONER" , SUBDOMAIN_PARTITIONER},
294 : {"MAPPED_SUBDOMAIN_PARTITIONER", MAPPED_SUBDOMAIN_PARTITIONER},
295 :
296 : //shorter
297 : {"CENTROID" , CENTROID_PARTITIONER},
298 : {"LINEAR" , LINEAR_PARTITIONER},
299 : {"SFC" , SFC_PARTITIONER},
300 : {"HILBERT_SFC" , HILBERT_SFC_PARTITIONER},
301 : {"MORTON_SFC" , MORTON_SFC_PARTITIONER},
302 : {"METIS" , METIS_PARTITIONER},
303 : {"PARMETIS" , PARMETIS_PARTITIONER},
304 : {"SUBDOMAIN" , SUBDOMAIN_PARTITIONER},
305 : {"MAPPED_SUBDOMAIN" , MAPPED_SUBDOMAIN_PARTITIONER},
306 : };
307 :
308 : std::map<PartitionerType, std::string> enum_to_partitioner_type =
309 : build_reverse_map(partitioner_type_to_enum);
310 :
311 :
312 : std::map<std::string, PreconditionerType> preconditioner_type_to_enum {
313 : {"IDENTITY_PRECOND" , IDENTITY_PRECOND},
314 : {"JACOBI_PRECOND" , JACOBI_PRECOND},
315 : {"BLOCK_JACOBI_PRECOND" , BLOCK_JACOBI_PRECOND},
316 : {"SOR_PRECOND" , SOR_PRECOND},
317 : {"SSOR_PRECOND" , SSOR_PRECOND},
318 : {"EISENSTAT_PRECOND" , EISENSTAT_PRECOND},
319 : {"ASM_PRECOND" , ASM_PRECOND},
320 : {"CHOLESKY_PRECOND" , CHOLESKY_PRECOND},
321 : {"ICC_PRECOND" , ICC_PRECOND},
322 : {"ILU_PRECOND" , ILU_PRECOND},
323 : {"LU_PRECOND" , LU_PRECOND},
324 : {"USER_PRECOND" , USER_PRECOND},
325 : {"SHELL_PRECOND" , SHELL_PRECOND},
326 : {"AMG_PRECOND" , AMG_PRECOND},
327 : {"SVD_PRECOND" , SVD_PRECOND},
328 : {"INVALID_PRECONDITIONER", INVALID_PRECONDITIONER},
329 :
330 : //shorter
331 : {"IDENTITY" , IDENTITY_PRECOND},
332 : {"JACOBI" , JACOBI_PRECOND},
333 : {"BLOCK_JACOBI", BLOCK_JACOBI_PRECOND},
334 : {"SOR" , SOR_PRECOND},
335 : {"SSOR" , SSOR_PRECOND},
336 : {"EISENSTAT" , EISENSTAT_PRECOND},
337 : {"ASM" , ASM_PRECOND},
338 : {"CHOLESKY" , CHOLESKY_PRECOND},
339 : {"ICC" , ICC_PRECOND},
340 : {"ILU" , ILU_PRECOND},
341 : {"LU" , LU_PRECOND},
342 : {"USER" , USER_PRECOND},
343 : {"SHELL" , SHELL_PRECOND},
344 : {"AMG" , AMG_PRECOND},
345 : {"SVD" , SVD_PRECOND},
346 : {"INVALID" , INVALID_PRECONDITIONER},
347 : };
348 :
349 : std::map<PreconditionerType, std::string> enum_to_preconditioner_type =
350 : build_reverse_map(preconditioner_type_to_enum);
351 :
352 :
353 : #ifdef LIBMESH_ENABLE_AMR
354 : std::map<std::string, Elem::RefinementState> refinementstate_type_to_enum {
355 : {"COARSEN" , Elem::COARSEN},
356 : {"DO_NOTHING" , Elem::DO_NOTHING},
357 : {"REFINE" , Elem::REFINE},
358 : {"JUST_REFINED" , Elem::JUST_REFINED},
359 : {"JUST_COARSENED" , Elem::JUST_COARSENED},
360 : {"INACTIVE" , Elem::INACTIVE},
361 : {"COARSEN_INACTIVE" , Elem::COARSEN_INACTIVE},
362 : {"INVALID_REFINEMENTSTATE", Elem::INVALID_REFINEMENTSTATE},
363 : };
364 :
365 : std::map<Elem::RefinementState, std::string> enum_to_refinementstate_type =
366 : build_reverse_map(refinementstate_type_to_enum);
367 : #endif // LIBMESH_ENABLE_AMR
368 :
369 :
370 : std::map<std::string, EigenSolverType> eigensolvertype_to_enum {
371 : {"POWER" , POWER},
372 : {"LAPACK" , LAPACK},
373 : {"SUBSPACE" , SUBSPACE},
374 : {"ARNOLDI" , ARNOLDI},
375 : {"LANCZOS" , LANCZOS},
376 : {"KRYLOVSCHUR" , KRYLOVSCHUR},
377 : {"INVALID_EIGENSOLVER", INVALID_EIGENSOLVER},
378 : };
379 :
380 : std::map<EigenSolverType, std::string> enum_to_eigensolvertype =
381 : build_reverse_map(eigensolvertype_to_enum);
382 :
383 :
384 : std::map<std::string, SolverType> solvertype_to_enum {
385 : {"CG" , CG},
386 : {"CGN" , CGN},
387 : {"CGS" , CGS},
388 : {"CR" , CR},
389 : {"QMR" , QMR},
390 : {"TCQMR" , TCQMR},
391 : {"TFQMR" , TFQMR},
392 : {"BICG" , BICG},
393 : {"BICGSTAB" , BICGSTAB},
394 : {"MINRES" , MINRES},
395 : {"GMRES" , GMRES},
396 : {"LSQR" , LSQR},
397 : {"JACOBI" , JACOBI},
398 : {"SOR_FORWARD" , SOR_FORWARD},
399 : {"SOR_BACKWARD" , SOR_BACKWARD},
400 : {"SSOR" , SSOR},
401 : {"RICHARDSON" , RICHARDSON},
402 : {"CHEBYSHEV" , CHEBYSHEV},
403 : {"SPARSELU" , SPARSELU},
404 : {"INVALID_SOLVER", INVALID_SOLVER},
405 : };
406 :
407 : std::map<SolverType, std::string> enum_to_solvertype =
408 : build_reverse_map(solvertype_to_enum);
409 :
410 :
411 : std::map<std::string, ElemQuality> elemquality_to_enum {
412 : {"ASPECT_RATIO" , ASPECT_RATIO},
413 : {"SKEW" , SKEW},
414 : {"SHEAR" , SHEAR},
415 : {"SHAPE" , SHAPE},
416 : {"MAX_ANGLE" , MAX_ANGLE},
417 : {"MIN_ANGLE" , MIN_ANGLE},
418 : {"MAX_DIHEDRAL_ANGLE" , MAX_DIHEDRAL_ANGLE},
419 : {"MIN_DIHEDRAL_ANGLE" , MIN_DIHEDRAL_ANGLE},
420 : {"CONDITION" , CONDITION},
421 : {"DISTORTION" , DISTORTION},
422 : {"TAPER" , TAPER},
423 : {"WARP" , WARP},
424 : {"STRETCH" , STRETCH},
425 : {"DIAGONAL" , DIAGONAL},
426 : {"ASPECT_RATIO_BETA" , ASPECT_RATIO_BETA},
427 : {"ASPECT_RATIO_GAMMA" , ASPECT_RATIO_GAMMA},
428 : {"SIZE" , SIZE},
429 : {"JACOBIAN" , JACOBIAN},
430 : {"TWIST" , TWIST},
431 : };
432 :
433 : std::map<ElemQuality, std::string> enum_to_elemquality =
434 : build_reverse_map(elemquality_to_enum);
435 :
436 :
437 : std::map<std::string, IOPackage> iopackage_to_enum {
438 : {"TECPLOT" , TECPLOT},
439 : {"GMV" , GMV},
440 : {"GMSH" , GMSH},
441 : {"VTK" , VTK},
442 : {"DIVA" , DIVA},
443 : {"TETGEN" , TETGEN},
444 : {"UCD" , UCD},
445 : {"LIBMESH" , LIBMESH},
446 : };
447 :
448 : std::map<IOPackage, std::string> enum_to_iopackage =
449 : build_reverse_map(iopackage_to_enum);
450 :
451 :
452 : std::map<std::string, FEMNormType> norm_type_to_enum {
453 : {"L2" , L2},
454 : {"H1" , H1},
455 : {"H2" , H2},
456 : {"HCURL" , HCURL},
457 : {"HDIV" , HDIV},
458 :
459 : {"L1" , L1},
460 : {"L_INF" , L_INF},
461 :
462 : {"H1_SEMINORM" , H1_SEMINORM},
463 : {"H2_SEMINORM" , H2_SEMINORM},
464 : {"HCURL_SEMINORM" , HCURL_SEMINORM},
465 : {"HDIV_SEMINORM" , HDIV_SEMINORM},
466 :
467 : {"W1_INF_SEMINORM", W1_INF_SEMINORM},
468 : {"W2_INF_SEMINORM", W2_INF_SEMINORM},
469 :
470 : {"DISCRETE_L1" , DISCRETE_L1},
471 : {"DISCRETE_L2" , DISCRETE_L2},
472 : {"DISCRETE_L_INF" , DISCRETE_L_INF},
473 :
474 : {"H1_X_SEMINORM" , H1_X_SEMINORM},
475 : {"H1_Y_SEMINORM" , H1_Y_SEMINORM},
476 : {"H1_Z_SEMINORM" , H1_Z_SEMINORM},
477 :
478 : {"INVALID_NORM" , INVALID_NORM},
479 : };
480 :
481 : std::map<FEMNormType, std::string> enum_to_norm_type =
482 : build_reverse_map(norm_type_to_enum);
483 :
484 :
485 : std::map<std::string, ParallelType> parallel_type_to_enum {
486 : {"AUTOMATIC" , AUTOMATIC},
487 : {"SERIAL" , SERIAL},
488 : {"PARALLEL" , PARALLEL},
489 : {"GHOSTED" , GHOSTED},
490 : {"INVALID_PARALLELIZATION" , INVALID_PARALLELIZATION},
491 : };
492 :
493 : std::map<ParallelType, std::string> enum_to_parallel_type =
494 : build_reverse_map(parallel_type_to_enum);
495 :
496 :
497 : std::map<std::string, PointLocatorType> point_locator_type_to_enum {
498 : {"TREE" , TREE},
499 : {"INVALID_LOCATOR" , INVALID_LOCATOR},
500 : };
501 :
502 : std::map<PointLocatorType, std::string> enum_to_point_locator_type =
503 : build_reverse_map(point_locator_type_to_enum);
504 :
505 :
506 : std::map<std::string, SolverPackage> solverpackage_type_to_enum {
507 : {"PETSC_SOLVERS" , PETSC_SOLVERS},
508 : {"TRILINOS_SOLVERS" , TRILINOS_SOLVERS},
509 : {"LASPACK_SOLVERS" , LASPACK_SOLVERS},
510 : {"SLEPC_SOLVERS" , SLEPC_SOLVERS},
511 : {"EIGEN_SOLVERS" , EIGEN_SOLVERS},
512 : {"NLOPT_SOLVERS" , NLOPT_SOLVERS},
513 : {"INVALID_SOLVER_PACKAGE" , INVALID_SOLVER_PACKAGE},
514 : };
515 :
516 : std::map<SolverPackage, std::string> enum_to_solverpackage_type =
517 : build_reverse_map(solverpackage_type_to_enum);
518 :
519 :
520 : std::map<std::string, SubsetSolveMode> subset_solve_mode_to_enum {
521 : {"SUBSET_ZERO" , SUBSET_ZERO},
522 : {"SUBSET_COPY_RHS" , SUBSET_COPY_RHS},
523 : {"SUBSET_DONT_TOUCH" , SUBSET_DONT_TOUCH},
524 : };
525 :
526 : std::map<SubsetSolveMode, std::string> enum_to_subset_solve_mode =
527 : build_reverse_map(subset_solve_mode_to_enum);
528 :
529 :
530 : std::map<std::string, XdrMODE> xdr_mode_to_enum {
531 : {"UNKNOWN" , UNKNOWN},
532 : {"ENCODE" , ENCODE},
533 : {"DECODE" , DECODE},
534 : {"WRITE" , WRITE},
535 : {"READ" , READ},
536 : };
537 :
538 : std::map<XdrMODE, std::string> enum_to_xdr_mode =
539 : build_reverse_map(xdr_mode_to_enum);
540 :
541 :
542 : std::map<std::string, LinearConvergenceReason> linear_convergence_reason_to_enum {
543 : {"CONVERGED_RTOL_NORMAL", CONVERGED_RTOL_NORMAL},
544 : {"CONVERGED_ATOL_NORMAL", CONVERGED_ATOL_NORMAL},
545 : {"CONVERGED_RTOL", CONVERGED_RTOL},
546 : {"CONVERGED_ATOL", CONVERGED_ATOL},
547 : {"CONVERGED_ITS", CONVERGED_ITS},
548 : {"CONVERGED_CG_NEG_CURVE", CONVERGED_CG_NEG_CURVE},
549 : {"CONVERGED_CG_CONSTRAINED", CONVERGED_CG_CONSTRAINED},
550 : {"CONVERGED_STEP_LENGTH", CONVERGED_STEP_LENGTH},
551 : {"CONVERGED_HAPPY_BREAKDOWN", CONVERGED_HAPPY_BREAKDOWN},
552 : {"DIVERGED_NULL", DIVERGED_NULL},
553 : {"DIVERGED_ITS", DIVERGED_ITS},
554 : {"DIVERGED_DTOL", DIVERGED_DTOL},
555 : {"DIVERGED_BREAKDOWN", DIVERGED_BREAKDOWN},
556 : {"DIVERGED_BREAKDOWN_BICG", DIVERGED_BREAKDOWN_BICG},
557 : {"DIVERGED_NONSYMMETRIC", DIVERGED_NONSYMMETRIC},
558 : {"DIVERGED_INDEFINITE_PC", DIVERGED_INDEFINITE_PC},
559 : {"DIVERGED_NAN", DIVERGED_NAN},
560 : {"DIVERGED_INDEFINITE_MAT", DIVERGED_INDEFINITE_MAT},
561 : {"DIVERGED_PCSETUP_FAILED", DIVERGED_PCSETUP_FAILED},
562 : {"CONVERGED_ITERATING", CONVERGED_ITERATING},
563 : {"UNKNOWN_FLAG", UNKNOWN_FLAG},
564 : };
565 :
566 : std::map<LinearConvergenceReason, std::string> enum_to_linear_convergence_reason =
567 : build_reverse_map(linear_convergence_reason_to_enum);
568 :
569 : } // end anonymous namespace
570 :
571 :
572 :
573 : // ------------------------------------------------------
574 : // Utility::string_to_enum<> & Utility::enum_to_string<>
575 : // full specializations
576 : namespace Utility {
577 :
578 : #define INSTANTIATE_STRING_TO_ENUM(ENUM_NAME,VAR_NAME) \
579 : template <> \
580 : ENUM_NAME string_to_enum<ENUM_NAME> (std::string_view s) \
581 : { \
582 : std::string upper(s); \
583 : std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper); \
584 : \
585 : if (!VAR_NAME##_to_enum.count(upper)) \
586 : { \
587 : libmesh_error_msg("No " #ENUM_NAME " named " << s << " found."); \
588 : } \
589 : \
590 : return VAR_NAME##_to_enum[upper]; \
591 : } \
592 : \
593 : template <> \
594 : ENUM_NAME string_to_enum<ENUM_NAME> (const std::string & s) \
595 : { \
596 : return string_to_enum<ENUM_NAME>(std::string_view(s)); \
597 : } \
598 : \
599 : template <> \
600 : ENUM_NAME string_to_enum<ENUM_NAME> (const char * s) \
601 : { \
602 : return string_to_enum<ENUM_NAME>(std::string_view(s)); \
603 : } \
604 : \
605 : template <> \
606 : std::string enum_to_string<ENUM_NAME> (const ENUM_NAME e) \
607 : { \
608 : if (!enum_to_##VAR_NAME .count(e)) \
609 : libmesh_error_msg("No " #ENUM_NAME " with enumeration " << e << " found."); \
610 : \
611 : return enum_to_##VAR_NAME [e]; \
612 : }
613 :
614 :
615 :
616 47300 : INSTANTIATE_STRING_TO_ENUM(ElemType,elem_type)
617 0 : INSTANTIATE_STRING_TO_ENUM(ElemMappingType,elem_mapping_type)
618 49731 : INSTANTIATE_STRING_TO_ENUM(Order,order)
619 45537 : INSTANTIATE_STRING_TO_ENUM(FEFamily,fefamily)
620 2820 : INSTANTIATE_STRING_TO_ENUM(InfMapType,inf_map_type)
621 4717 : INSTANTIATE_STRING_TO_ENUM(QuadratureType,quadrature_type)
622 924496 : INSTANTIATE_STRING_TO_ENUM(PartitionerType,partitioner_type)
623 0 : INSTANTIATE_STRING_TO_ENUM(PreconditionerType,preconditioner_type)
624 :
625 : #ifdef LIBMESH_ENABLE_AMR
626 0 : INSTANTIATE_STRING_TO_ENUM(Elem::RefinementState,refinementstate_type)
627 : #endif // LIBMESH_ENABLE_AMR
628 :
629 87 : INSTANTIATE_STRING_TO_ENUM(SolverType,solvertype)
630 0 : INSTANTIATE_STRING_TO_ENUM(EigenSolverType,eigensolvertype)
631 0 : INSTANTIATE_STRING_TO_ENUM(ElemQuality,elemquality)
632 0 : INSTANTIATE_STRING_TO_ENUM(IOPackage,iopackage)
633 0 : INSTANTIATE_STRING_TO_ENUM(FEMNormType, norm_type)
634 0 : INSTANTIATE_STRING_TO_ENUM(ParallelType, parallel_type)
635 0 : INSTANTIATE_STRING_TO_ENUM(PointLocatorType, point_locator_type)
636 217 : INSTANTIATE_STRING_TO_ENUM(SolverPackage,solverpackage_type)
637 0 : INSTANTIATE_STRING_TO_ENUM(SubsetSolveMode,subset_solve_mode)
638 0 : INSTANTIATE_STRING_TO_ENUM(XdrMODE,xdr_mode)
639 0 : INSTANTIATE_STRING_TO_ENUM(LinearConvergenceReason, linear_convergence_reason)
640 :
641 : #undef INSTANTIATE_STRING_TO_ENUM
642 :
643 : } // namespace Utility
644 :
645 : } // namespace libMesh
|
