type_enums.h

// SPDX-FileCopyrightText: © 2025 PRISMS Center at the University of Michigan
// SPDX-License-Identifier: GNU Lesser General Public Version 2.1
 
#ifndef type_enums_h
#define type_enums_h
 
#include <prismspf/config.h>
 
#include <cstdint>
#include <string>
 
PRISMS_PF_BEGIN_NAMESPACE
 
enum fieldType : std::uint8_t
{
  UNDEFINED_FIELD,
  SCALAR,
  VECTOR
};
 
enum PDEType : std::uint8_t
{
  UNDEFINED_PDE,
  EXPLICIT_TIME_DEPENDENT,
  IMPLICIT_TIME_DEPENDENT,
  TIME_INDEPENDENT,
  AUXILIARY,
  CONSTANT
};
 
enum solveType : std::uint8_t
{
  EXPLICIT_RHS,
  NONEXPLICIT_RHS,
  NONEXPLICIT_LHS,
  POSTPROCESS
};
 
enum elasticityModel : std::uint8_t
{
  ISOTROPIC,
  TRANSVERSE,
  ORTHOTROPIC,
  ANISOTROPIC
};
 
enum fieldSolveType : std::uint8_t
{
  UNDEFINED_SOLVE,
  EXPLICIT_CONSTANT,
  EXPLICIT,
  NONEXPLICIT_LINEAR,
  NONEXPLICIT_SELF_NONLINEAR,
  NONEXPLICIT_AUXILIARY,
  NONEXPLICIT_CO_NONLINEAR,
  EXPLICIT_POSTPROCESS,
};
 
enum dependencyType : std::uint8_t
{
  NORMAL,
  CHANGE,
  OLD_1,
  OLD_2,
  OLD_3,
  OLD_4
};
 
enum solverToleranceType : std::uint8_t
{
  ABSOLUTE_RESIDUAL,
  RELATIVE_RESIDUAL_CHANGE
};
 
enum preconditionerType : std::uint8_t
{
  NONE,
  GMG
};
 
inline std::string
to_string(fieldType type)
 
{
  switch (type)
    {
      case fieldType::UNDEFINED_FIELD:
        return "UNDEFINED_FIELD";
      case fieldType::SCALAR:
        return "SCALAR_FIELD";
      case fieldType::VECTOR:
        return "VECTOR_FIELD";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(PDEType type)
{
  switch (type)
    {
      case PDEType::UNDEFINED_PDE:
        return "UNDEFINED_PDE";
      case PDEType::EXPLICIT_TIME_DEPENDENT:
        return "EXPLICIT_TIME_DEPENDENT";
      case PDEType::IMPLICIT_TIME_DEPENDENT:
        return "IMPLICIT_TIME_DEPENDENT";
      case PDEType::TIME_INDEPENDENT:
        return "TIME_INDEPENDENT";
      case PDEType::AUXILIARY:
        return "AUXILIARY";
      case PDEType::CONSTANT:
        return "CONSTANT";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(solveType type)
{
  switch (type)
    {
      case solveType::EXPLICIT_RHS:
        return "EXPLICIT_RHS";
      case solveType::NONEXPLICIT_RHS:
        return "NONEXPLICIT_RHS";
      case solveType::NONEXPLICIT_LHS:
        return "NONEXPLICIT_LHS";
      case solveType::POSTPROCESS:
        return "POSTPROCESS";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(elasticityModel type)
{
  switch (type)
    {
      case elasticityModel::ISOTROPIC:
        return "ISOTROPIC";
      case elasticityModel::TRANSVERSE:
        return "TRANSVERSE";
      case elasticityModel::ORTHOTROPIC:
        return "ORTHOTROPIC";
      case elasticityModel::ANISOTROPIC:
        return "ANISOTROPIC";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(fieldSolveType type)
{
  switch (type)
    {
      case fieldSolveType::UNDEFINED_SOLVE:
        return "UNDEFINED_SOLVE";
      case fieldSolveType::EXPLICIT:
        return "EXPLICIT";
      case fieldSolveType::NONEXPLICIT_LINEAR:
        return "NONEXPLICIT_LINEAR";
      case fieldSolveType::NONEXPLICIT_SELF_NONLINEAR:
        return "NONEXPLICIT_SELF_NONLINEAR";
      case fieldSolveType::NONEXPLICIT_AUXILIARY:
        return "NONEXPLICIT_AUXILIARY";
      case fieldSolveType::NONEXPLICIT_CO_NONLINEAR:
        return "NONEXPLICIT_CO_NONLINEAR";
      case fieldSolveType::EXPLICIT_POSTPROCESS:
        return "EXPLICIT_POSTPROCESS";
      case fieldSolveType::EXPLICIT_CONSTANT:
        return "EXPLICIT_CONSTANT";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(dependencyType type)
{
  switch (type)
    {
      case dependencyType::NORMAL:
        return "NORMAL";
      case dependencyType::CHANGE:
        return "CHANGE";
      case dependencyType::OLD_1:
        return "OLD_1";
      case dependencyType::OLD_2:
        return "OLD_2";
      case dependencyType::OLD_3:
        return "OLD_3";
      case dependencyType::OLD_4:
        return "OLD_4";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(solverToleranceType type)
{
  switch (type)
    {
      case solverToleranceType::ABSOLUTE_RESIDUAL:
        return "ABSOLUTE_RESIDUAL";
      case solverToleranceType::RELATIVE_RESIDUAL_CHANGE:
        return "RELATIVE_RESIDUAL_CHANGE";
      default:
        return "UNKNOWN";
    }
}
 
inline std::string
to_string(preconditionerType type)
{
  switch (type)
    {
      case preconditionerType::NONE:
        return "NONE";
      case preconditionerType::GMG:
        return "GMG";
      default:
        return "UNKNOWN";
    }
}
 
PRISMS_PF_END_NAMESPACE
 
#endif