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