constraint_parameters.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 <deal.II/base/point.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/types.h>
#include <deal.II/base/utilities.h>
 
#include <boost/algorithm/string/predicate.hpp>
 
#include <prismspf/core/conditional_ostreams.h>
#include <prismspf/core/exceptions.h>
#include <prismspf/core/field_attributes.h>
#include <prismspf/core/type_enums.h>
#include <prismspf/core/types.h>
 
#include <prismspf/config.h>
 
#include <algorithm>
#include <map>
#include <string>
#include <unordered_set>
 
PRISMS_PF_BEGIN_NAMESPACE
 
enum Condition : std::uint8_t
{
  Natural,
  Dirichlet,
  Neumann,
  TimeDependentDirichlet,
  TimeDependentNeumann,
  UniformDirichlet,
  UniformNeumann,
  Periodic,
};
 
[[nodiscard]] inline std::string
to_string(Condition boundary_type)
{
  switch (boundary_type)
    {
      case Condition::Natural:
        return "Natural";
      case Condition::Dirichlet:
        return "Dirichlet";
      case Condition::Neumann:
        return "Neumann";
      case Condition::TimeDependentDirichlet:
        return "TimeDependentDirichlet";
      case Condition::TimeDependentNeumann:
        return "TimeDependentNeumann";
      case Condition::UniformDirichlet:
        return "UniformDirichlet";
      case Condition::UniformNeumann:
        return "UniformNeumann";
      case Condition::Periodic:
        return "Periodic";
      default:
        return "UNKNOWN";
    }
}
 
[[nodiscard]] inline Condition
condition_from_string(const std::string &boundary_string)
{
  if (boundary_string == "Natural")
    {
      return Condition::Natural;
    }
  if (boundary_string == "Dirichlet")
    {
      return Condition::Dirichlet;
    }
  if (boundary_string == "Neumann")
    {
      return Condition::Neumann;
    }
  if (boundary_string == "TimeDependentDirichlet")
    {
      return Condition::TimeDependentDirichlet;
    }
  if (boundary_string == "TimeDependentNeumann")
    {
      return Condition::TimeDependentNeumann;
    }
  if (boundary_string == "UniformDirichlet")
    {
      return Condition::UniformDirichlet;
    }
  if (boundary_string == "UniformNeumann")
    {
      return Condition::UniformNeumann;
    }
  if (boundary_string == "Periodic")
    {
      return Condition::Periodic;
    }
  AssertThrow(false, dealii::ExcMessage("Invalid boundary condition " + boundary_string));
  return Condition::Natural;
}
 
struct ComponentConditions
{
  // Map of boundary conditions and domain boundary for which they correspond to. For a
  // simple geometry like a square the boundary ids are marked, in order, by x=0, x=max,
  // y=0, y=max. More complex geometries can have somewhat arbitrary ordering, but will
  // render some of our assertions moot.
  std::map<unsigned int, Condition> conditions;
 
  [[nodiscard]] bool
  has_time_dependent_bcs() const
  {
    return std::any_of(conditions.begin(),
                       conditions.end(),
                       [](const auto &dir_cond)
                       {
                         return dir_cond.second == Condition::TimeDependentDirichlet ||
                                dir_cond.second == Condition::TimeDependentNeumann;
                       });
  }
};
 
template <unsigned int dim>
struct FieldConstraints
{
  std::array<ComponentConditions, dim> component_constraints;
 
  // std::unordered_set<std::pair<dealii::Point<dim>, dealii::Tensor<1, dim>>>
  // pinned_points;
 
  [[nodiscard]] bool
  has_time_dependent_bcs() const
  {
    return std::any_of(component_constraints.begin(),
                       component_constraints.end(),
                       [](const ComponentConditions &comp)
                       {
                         return comp.has_time_dependent_bcs();
                       });
  }
};
 
template <unsigned int dim>
struct BoundaryParameters
{
public:
  void
  validate();
 
  void
  print_parameter_summary() const;
 
  [[nodiscard]] bool
  has_time_dependent_bcs() const
  { // todo
  }
 
  // Map of boundary conditions. The first key is the field index.
  std::unordered_map<std::string, FieldConstraints<dim>> boundary_condition_list;
};
 
template <unsigned int dim>
inline void
BoundaryParameters<dim>::validate()
{ // todo
}
 
template <unsigned int dim>
inline void
BoundaryParameters<dim>::print_parameter_summary() const
{
  ConditionalOStreams::pout_summary()
    << "================================================\n"
    << "  Boundary Parameters\n"
    << "================================================\n";
 
  for (const auto &[index, component_map] : boundary_condition_list)
    {
      // Todo
    }
  // TODO print pinned points
 
  ConditionalOStreams::pout_summary() << "\n" << std::flush;
}
 
PRISMS_PF_END_NAMESPACE