boundary_condition_manager.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2024, Lawrence Livermore National Security, LLC and
// other Serac Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <memory>
#include <set>
 
#include "serac/physics/boundary_conditions/boundary_condition.hpp"
#include "serac/physics/state/finite_element_state.hpp"
 
namespace serac {
 
template <typename Iter, typename Pred>
class FilterView {
public:
  class FilterViewIterator {
  public:
    FilterViewIterator(Iter curr, Iter end, const Pred& pred) : curr_(curr), end_(end), pred_(pred) {}
 
    FilterViewIterator& operator++()
    {
      // Move forward once to advance the element, then continue
      // advancing until a predicate-satisfying element is found
      ++curr_;
      while ((curr_ != end_) && (!pred_(*curr_))) {
        ++curr_;
      }
      return *this;
    }
 
    const auto& operator*() const { return *curr_; }
 
    auto& operator*() { return *curr_; }
 
    bool operator!=(const FilterViewIterator& other) const { return curr_ != other.curr_; }
 
  private:
    Iter curr_;
 
    Iter end_;
 
    const Pred& pred_;
  };
 
  FilterView(Iter begin, Iter end, Pred&& pred) : begin_(begin), end_(end), pred_(std::move(pred))
  {
    // Skip to the first element that meets the predicate, making sure not to deref the "end" iterator
    while ((begin_ != end_) && (!pred_(*begin_))) {
      ++begin_;
    }
  }
 
  FilterViewIterator begin() { return FilterViewIterator(begin_, end_, pred_); }
 
  const FilterViewIterator begin() const { return FilterViewIterator(begin_, end_, pred_); }
 
  FilterViewIterator end() { return FilterViewIterator(end_, end_, pred_); }
 
  const FilterViewIterator end() const { return FilterViewIterator(end_, end_, pred_); }
 
private:
  Iter begin_;
 
  Iter end_;
 
  Pred pred_;
};
 
template <class Iter, class Pred>
FilterView(Iter, Iter, Pred&&) -> FilterView<Iter, Pred>;
 
class BoundaryConditionManager {
public:
  explicit BoundaryConditionManager(const mfem::ParMesh& mesh) : num_attrs_(mesh.bdr_attributes.Max()) {}
 
  void addEssential(const std::set<int>& ess_bdr, serac::GeneralCoefficient ess_bdr_coef,
                    mfem::ParFiniteElementSpace& space, const std::optional<int> component = {});
 
  void addEssential(const mfem::Array<int>& true_dofs, std::shared_ptr<mfem::VectorCoefficient> ess_bdr_coef,
                    mfem::ParFiniteElementSpace& space);
 
  void addNatural(const std::set<int>& nat_bdr, serac::GeneralCoefficient nat_bdr_coef,
                  mfem::ParFiniteElementSpace& space, const std::optional<int> component = {});
 
  template <typename Tag>
  void addGeneric(const std::set<int>& bdr_attr, serac::GeneralCoefficient bdr_coef, const Tag tag,
                  mfem::ParFiniteElementSpace& space, const std::optional<int> component = {})
  {
    other_bdr_.emplace_back(bdr_coef, component, space, bdr_attr);
    other_bdr_.back().setTag(tag);
    all_dofs_valid_ = false;
  }
 
  const mfem::Array<int>& allEssentialTrueDofs() const
  {
    if (!all_dofs_valid_) {
      updateAllDofs();
    }
    return all_true_dofs_;
  }
 
  const mfem::Array<int>& allEssentialLocalDofs() const
  {
    if (!all_dofs_valid_) {
      updateAllDofs();
    }
    return all_local_dofs_;
  }
 
  std::unique_ptr<mfem::HypreParMatrix> eliminateAllEssentialDofsFromMatrix(mfem::HypreParMatrix& matrix) const
  {
    return std::unique_ptr<mfem::HypreParMatrix>(matrix.EliminateRowsCols(allEssentialTrueDofs()));
  }
 
  std::vector<BoundaryCondition>& essentials() { return ess_bdr_; }
  std::vector<BoundaryCondition>& naturals() { return nat_bdr_; }
  std::vector<BoundaryCondition>& generics() { return other_bdr_; }
 
  const std::vector<BoundaryCondition>& essentials() const { return ess_bdr_; }
  const std::vector<BoundaryCondition>& naturals() const { return nat_bdr_; }
  const std::vector<BoundaryCondition>& generics() const { return other_bdr_; }
 
  template <typename Tag>
  auto genericsWithTag(const Tag tag)
  {
    static_assert(std::is_enum_v<Tag>, "Only enumerations can be used to tag a boundary condition.");
    return FilterView(other_bdr_.begin(), other_bdr_.end(), [tag](const auto& bc) { return bc.tagEquals(tag); });
  }
 
private:
  void updateAllDofs() const;
 
  const int num_attrs_;
 
  std::vector<BoundaryCondition> ess_bdr_;
 
  std::vector<BoundaryCondition> nat_bdr_;
 
  std::vector<BoundaryCondition> other_bdr_;
 
  std::set<int> attrs_in_use_;
 
  mutable mfem::Array<int> all_true_dofs_;
 
  mutable mfem::Array<int> all_local_dofs_;
 
  mutable bool all_dofs_valid_ = false;
};
 
}  // namespace serac