dirichlet_boundary_conditions.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 <optional>
 
#include "smith/physics/boundary_conditions/boundary_condition_manager.hpp"
 
namespace smith {
 
class Mesh;
 
class DirichletBoundaryConditions {
 public:
  DirichletBoundaryConditions(const mfem::ParMesh& mfem_mesh, mfem::ParFiniteElementSpace& space);
 
  DirichletBoundaryConditions(const Mesh& mesh, mfem::ParFiniteElementSpace& space);
 
  template <int spatial_dim, typename AppliedDisplacementFunction>
  void setVectorBCs(const Domain& domain, std::vector<int> components, AppliedDisplacementFunction applied_displacement)
  {
    int field_dim = space_.GetVDim();
    for (auto component : components) {
      SLIC_ERROR_IF(component >= field_dim || component < 0,
                    std::format("Trying to set boundary conditions on a field with dim {}, using component {}",
                                field_dim, component));
      auto mfem_coefficient_function = [applied_displacement, component](const mfem::Vector& X_mfem, double t) {
        auto X = make_tensor<spatial_dim>([&X_mfem](int k) { return X_mfem[k]; });
        return applied_displacement(t, X)[component];
      };
 
      auto dof_list = domain.dof_list(&space_);
      // scalar ldofs -> vector ldofs
      space_.DofsToVDofs(static_cast<int>(component), dof_list);
 
      auto component_disp_bdr_coef_ = std::make_shared<mfem::FunctionCoefficient>(mfem_coefficient_function);
      bcs_.addEssential(dof_list, component_disp_bdr_coef_, space_, static_cast<int>(component));
    }
  }
 
  template <int spatial_dim, typename AppliedDisplacementFunction>
  void setVectorBCs(const Domain& domain, AppliedDisplacementFunction applied_displacement)
  {
    const int field_dim = space_.GetVDim();
    std::vector<int> components(static_cast<size_t>(field_dim));
    for (int component = 0; component < field_dim; ++component) {
      components[static_cast<size_t>(component)] = component;
    }
    setVectorBCs<spatial_dim>(domain, components, applied_displacement);
  }
 
  template <int spatial_dim, typename AppliedDisplacementFunction>
  void setScalarBCs(const Domain& domain, AppliedDisplacementFunction applied_displacement)
  {
    auto mfem_coefficient_function = [applied_displacement](const mfem::Vector& X_mfem, double t) {
      auto X = make_tensor<spatial_dim>([&X_mfem](int k) { return X_mfem[k]; });
      return applied_displacement(t, X);
    };
 
    auto dof_list = domain.dof_list(&space_);
    space_.DofsToVDofs(static_cast<int>(0), dof_list);
 
    auto component_disp_bdr_coef_ = std::make_shared<mfem::FunctionCoefficient>(mfem_coefficient_function);
    bcs_.addEssential(dof_list, component_disp_bdr_coef_, space_, 0);
  }
 
  template <int spatial_dim, typename AppliedDisplacementFunction>
  void setScalarBCsOnLocalDofs(const mfem::Array<int>& local_dofs, AppliedDisplacementFunction applied_displacement)
  {
    auto mfem_coefficient_function = [applied_displacement](const mfem::Vector& X_mfem, double t) {
      auto X = make_tensor<spatial_dim>([&X_mfem](int k) { return X_mfem[k]; });
      return applied_displacement(t, X);
    };
 
    auto component_disp_bdr_coef_ = std::make_shared<mfem::FunctionCoefficient>(mfem_coefficient_function);
    bcs_.addEssential(local_dofs, component_disp_bdr_coef_, space_, 0);
  }
 
  template <int spatial_dim>
  void setFixedScalarBCs(const Domain& domain)
  {
    setScalarBCs<spatial_dim>(domain, [](auto, auto) { return 0.0; });
  }
 
  template <int spatial_dim>
  void setFixedScalarBCsOnLocalDofs(const mfem::Array<int>& local_dofs)
  {
    setScalarBCsOnLocalDofs<spatial_dim>(local_dofs, [](auto, auto) { return 0.0; });
  }
 
  template <int spatial_dim, int field_dim>
  void setFixedVectorBCs(const Domain& domain, std::vector<int> components)
  {
    setVectorBCs<spatial_dim>(domain, components, [](auto, auto) { return smith::tensor<double, field_dim>{}; });
  }
 
  template <int spatial_dim>
  void setFixedVectorBCs(const Domain& domain, std::vector<int> components)
  {
    setFixedVectorBCs<spatial_dim, spatial_dim>(domain, components);
  }
 
  template <int spatial_dim, int field_dim>
  void setFixedVectorBCs(const Domain& domain, int component)
  {
    std::vector<int> components{component};
    setFixedVectorBCs<spatial_dim, field_dim>(domain, components);
  }
 
  template <int spatial_dim>
  void setFixedVectorBCs(const Domain& domain, int component)
  {
    setFixedVectorBCs<spatial_dim, spatial_dim>(domain, component);
  }
 
  template <int spatial_dim, int field_dim = spatial_dim>
  void setFixedVectorBCs(const Domain& domain)
  {
    SLIC_ERROR_IF(field_dim != space_.GetVDim(), "Vector boundary condition field_dim does not match the fields vdim");
    std::vector<int> components(static_cast<size_t>(field_dim));
    for (int component = 0; component < field_dim; ++component) {
      components[static_cast<size_t>(component)] = component;
    }
    setFixedVectorBCs<spatial_dim, field_dim>(domain, components);
  }
 
  const smith::BoundaryConditionManager& getBoundaryConditionManager() const { return bcs_; }
 
  const smith::BoundaryConditionManager& getSecondDerivativeManager() const;
 
 private:
  void rebuildSecondDerivativeManager(BoundaryConditionManager& target) const;
 
  const mfem::ParMesh& mfem_mesh_;       
  smith::BoundaryConditionManager bcs_;  
  mfem::ParFiniteElementSpace& space_;   
 
  mutable std::optional<BoundaryConditionManager> second_derivative_manager_;
};
 
}  // namespace smith