boundary_conditions.hpp

Go to the documentation of this file.

#pragma once
#include <deal.II/base/exceptions.h>
#include <deal.II/base/function.h>
#include <deal.II/base/types.h>
 
#include <meltpooldg/core/exceptions.hpp>
 
#include <map>
#include <memory>
#include <ranges>
#include <string>
 
namespace MeltPoolDG
{
  template <int dim, typename number>
  class BoundaryConditionManager
  {
  private:
    std::map<std::string,
             std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>>
      bc;
 
  public:
    void
    attach_boundary_condition(
      std::pair<const dealii::types::boundary_id, const std::shared_ptr<dealii::Function<dim>>>
                         id_and_function,
      const std::string &type)
    {
      AssertThrow(!bc[type].contains(id_and_function.first), ExcBCAlreadyAssigned(type));
 
      bc[type][id_and_function.first] = id_and_function.second;
    }
 
    void
    set_time(const number time)
    {
      for (const auto &[type, outer_map] : bc)
        for (const auto &[id_, function_ptr] : outer_map)
          if (function_ptr)
            function_ptr->set_time(time);
    }
 
    std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>
    get_bc_of_type(const std::string type, const bool is_optional = true) const
    {
      AssertThrow(is_optional || bc.contains(type), dealii::ExcMessage("Type not found: " + type));
 
      if (!bc.contains(type))
        return std::map<dealii::types::boundary_id, std::shared_ptr<dealii::Function<dim>>>();
      else
        return bc.at(type);
    }
 
    std::vector<dealii::types::boundary_id>
    get_indices_of_type(const std::string type, const bool is_optional = true) const
    {
      auto bc_of_type = get_bc_of_type(type, is_optional);
      auto kv         = std::views::keys(bc_of_type);
      return {kv.begin(), kv.end()};
    }
 
    std::string
    get_type(dealii::types::boundary_id id, const bool is_optional = true) const
    {
      for (const auto &[type_, inner_map] : bc)
        if (inner_map.contains(id))
          return type_; // Found boundary ID, return type
 
      // If not found, check the is_optional flag
      AssertThrow(is_optional, dealii::ExcMessage("Boundary ID not found in boundary conditions."));
 
      // If optional, return an empty string as a fallback
      return "";
    }
  };
} // namespace MeltPoolDG