input.hpp

Go to the documentation of this file.

// Copyright (c) Lawrence Livermore National Security, LLC and
// other Smith Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <string>
#include <variant>
#include <optional>
#include <functional>
#include <memory>
#include <set>
#include <unordered_map>
 
#include "mfem.hpp"
#include "axom/inlet.hpp"
#include "axom/sidre.hpp"
 
namespace smith::input {
 
enum class Language
{
  Lua,
  JSON,
  YAML
};
 
axom::inlet::Inlet initialize(axom::sidre::DataStore& datastore, const std::string& input_file_path,
                              const Language language = Language::Lua, const std::string& sidre_path = "input_file");
 
std::string findMeshFilePath(const std::string& mesh_path, const std::string& input_file_path);
 
std::string fullDirectoryFromPath(const std::string& file_path);
 
std::string getInputFileName(const std::string& file_path);
 
void defineVectorInputFileSchema(axom::inlet::Container& container);
 
struct CoefficientInputOptions {
  using VecFunc = std::function<void(const mfem::Vector&, double, mfem::Vector&)>;
 
  using ScalarFunc = std::function<double(const mfem::Vector&, double)>;
  ScalarFunc scalar_function;
 
  VecFunc vector_function;
 
  std::optional<double> scalar_constant;
 
  std::optional<mfem::Vector> vector_constant;
 
  std::unordered_map<int, double> scalar_pw_const;
 
  std::unordered_map<int, mfem::Vector> vector_pw_const;
 
  std::optional<int> component;
  bool isVector() const;
  std::unique_ptr<mfem::VectorCoefficient> constructVector(const int dim = 3) const;
  std::unique_ptr<mfem::Coefficient> constructScalar() const;
  static void defineInputFileSchema(axom::inlet::Container& container);
};
 
struct BoundaryConditionInputOptions {
  std::set<int> attrs{};
  CoefficientInputOptions coef_opts;
  static void defineInputFileSchema(axom::inlet::Container& container);
};
 
}  // namespace smith::input
 
template <>
struct FromInlet<mfem::Vector> {
  mfem::Vector operator()(const axom::inlet::Container& base);
};
 
template <>
struct FromInlet<smith::input::CoefficientInputOptions> {
  smith::input::CoefficientInputOptions operator()(const axom::inlet::Container& base);
};
 
template <>
struct FromInlet<smith::input::BoundaryConditionInputOptions> {
  smith::input::BoundaryConditionInputOptions operator()(const axom::inlet::Container& base);
};