type_enums.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2025 PRISMS Center at the University of Michigan
// SPDX-License-Identifier: GNU Lesser General Public Version 2.1
 
#pragma once
 
#include <prismspf/config.h>
 
#include <cstdint>
#include <string>
 
PRISMS_PF_BEGIN_NAMESPACE

enum SolveType : std::uint8_t
{
  Constant,
  Explicit,
  Linear,
  Newton
};

enum TensorRank : unsigned int
{
  Undefined = static_cast<unsigned int>(-1),
  Scalar    = 0,
  Vector    = 1
};

enum ElasticityModel : std::uint8_t
{
  Isotropic,
  Transverse,
  Orthotropic,
  Anisotropic
};

enum StressState : std::uint8_t
{
  ThreeDimension,
  PlaneStrain,
  PlaneStress,
};

enum DependencyType : int
{
  DST      = -2,
  SRC      = -1,
  LHS      = SRC,
  Solution = SRC,
  Trial    = SRC,
  Change   = SRC,
  Current  = 0,
  OldOne,
  OldTwo,
  OldThree,
  OldFour
};

enum SolverToleranceType : std::uint8_t
{
  AbsoluteResidual,
  // TODO: these names and descriptions are not great. The point is to determine whether
  // to average over the domain and whether to average over components.
  // TODO: this could also be bitwise
  // TODO: consider returning relative residual change
  RMSEPerField,
  IntegratedPerField,
  RMSETotal,
  IntegratedTotal
};

enum PreconditionerType : std::uint8_t
{
  None,
  Chebyshev,
  GMG
};

enum DataFormatType : std::uint8_t
{
  VTKUnstructuredGrid,
  FlatBinary,
  LastEntry
};

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(StressState type)
{
  switch (type)
    {
      case StressState::ThreeDimension:
        return "ThreeDimension";
      case StressState::PlaneStrain:
        return "PlaneStrain";
      case StressState::PlaneStress:
        return "PlaneStress";
      default:
        return "UNKNOWN";
    }
}

inline std::string
to_string(DependencyType type)
{
  switch (type)
    {
      case DependencyType::Current:
        return "Current";
      case DependencyType::Change:
        return "Change";
      case DependencyType::OldOne:
        return "OldOne";
      case DependencyType::OldTwo:
        return "OldTwo";
      case DependencyType::OldThree:
        return "OldThree";
      case DependencyType::OldFour:
        return "OldFour";
      default:
        return "UNKNOWN";
    }
}

inline std::string
to_string(SolverToleranceType type)
{
  switch (type)
    {
      case SolverToleranceType::AbsoluteResidual:
        return "AbsoluteResidual";
      case SolverToleranceType::RMSEPerField:
        return "RMSEPerField";
      case SolverToleranceType::RMSETotal:
        return "RMSETotal";
      case SolverToleranceType::IntegratedPerField:
        return "IntegratedPerField";
      case SolverToleranceType::IntegratedTotal:
        return "IntegratedTotal";
      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";
    }
}

inline std::string
to_string(DataFormatType type)
{
  switch (type)
    {
      case DataFormatType::VTKUnstructuredGrid:
        return "vtk_unstructured_grid";
      case DataFormatType::FlatBinary:
        return "flat_binary";
      default:
        return "unknown";
    }
}
 
PRISMS_PF_END_NAMESPACE