boundary_condition.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 <memory>
#include <optional>
#include <set>
#include <type_traits>
#include <utility>
#include <cstddef>
 
#include "smith/infrastructure/logger.hpp"
#include "smith/physics/state/finite_element_state.hpp"
#include "smith/physics/state/finite_element_vector.hpp"
 
namespace smith {
 
class BoundaryCondition {
 public:
  BoundaryCondition(GeneralCoefficient coef, const std::optional<int> component,
                    const mfem::ParFiniteElementSpace& space, const std::set<int>& attrs);
 
  BoundaryCondition(GeneralCoefficient coef, const std::optional<int> component,
                    const mfem::ParFiniteElementSpace& space, const mfem::Array<int>& true_dofs);
 
  template <typename Tag>
  bool tagEquals(const Tag tag) const
  {
    static_assert(std::is_enum_v<Tag>, "Only enumerations can be used to tag a boundary condition.");
    SLIC_ERROR_ROOT_IF(!tag_, "No tag has been configured for this boundary condition");
    bool tags_same_type = typeid(tag).hash_code() == tag_->second;
    SLIC_WARNING_ROOT_IF(!tags_same_type, "Attempting to compare tags of two different enum types (always false)");
    return (static_cast<int>(tag) == tag_->first) && tags_same_type;
  }
 
  template <typename Tag>
  void setTag(const Tag tag)
  {
    static_assert(std::is_enum_v<Tag>, "Only enumerations can be used to tag a boundary condition.");
    tag_ = {static_cast<int>(tag), typeid(tag).hash_code()};
  }
 
  const mfem::Array<int>& markers() const { return attr_markers_; }
 
  mfem::Array<int>& markers() { return attr_markers_; }
 
  const mfem::Array<int>& getTrueDofList() const { return true_dofs_; }
 
  const mfem::Array<int>& getLocalDofList() const { return local_dofs_; }
 
  const GeneralCoefficient& coefficient() const { return coef_; }
 
  const std::optional<int>& component() const { return component_; }
 
  void setDofs(mfem::Vector& state, const double time = 0.0) const;
 
  void apply(mfem::HypreParMatrix& k_mat, mfem::Vector& rhs, mfem::Vector& state) const;
 
 private:
  void setDofListsFromAttributeMarkers();
 
  void setTrueDofList(const mfem::Array<int>& true_dofs);
 
  GeneralCoefficient coef_;
  std::optional<int> component_;
  mfem::Array<int> attr_markers_;
  mfem::Array<int> true_dofs_;
  mfem::Array<int> local_dofs_;
  const mfem::ParFiniteElementSpace& space_;
 
  std::optional<std::pair<int, std::size_t>> tag_;
};
 
}  // namespace smith