heat_transfer_weak_form.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 "smith/physics/functional_weak_form.hpp"
 
namespace smith {
 
template <int order, int dim, typename InputSpaces = Parameters<>>
class HeatTransferWeakForm;
 
template <int order, int dim, typename... InputSpaces>
class HeatTransferWeakForm<order, dim, Parameters<InputSpaces...>>
    : public FunctionalWeakForm<dim, H1<order>, Parameters<H1<order>, H1<order>, InputSpaces...>> {
 public:
  using BaseWeakFormT = FunctionalWeakForm<dim, H1<order>, Parameters<H1<order>, H1<order>, InputSpaces...>>;
 
  // /// @brief a container holding quadrature point data of the specified type
  // /// @tparam T the type of data to store at each quadrature point
  // template <typename T>
  // using qdata_type = std::shared_ptr<QuadratureData<T>>;
 
  static constexpr int NUM_STATE_VARS = 2;
 
  enum STATE
  {
    TEMPERATURE,
    TEMPERATURE_RATE,
    NUM_STATES
  };
 
  HeatTransferWeakForm(std::string physics_name, std::shared_ptr<Mesh> mesh,
                       const mfem::ParFiniteElementSpace& test_space,
                       std::vector<const mfem::ParFiniteElementSpace*> parameter_fe_spaces = {})
      : BaseWeakFormT(physics_name, mesh, test_space, constructAllSpaces(test_space, parameter_fe_spaces))
  {
  }
 
  template <int... active_parameters, typename MaterialType>
  void setMaterial(DependsOn<active_parameters...>, std::string body_name, const MaterialType& material)
  {
    ThermalMaterialFunctor<MaterialType> material_functor(material);
    BaseWeakFormT::weak_form_->AddDomainIntegral(Dimension<dim>{},
                                                 DependsOn<0, 1, active_parameters + NUM_STATE_VARS...>{},
                                                 std::move(material_functor), BaseWeakFormT::mesh_->domain(body_name));
    BaseWeakFormT::v_dot_weak_form_residual_->AddDomainIntegral(
        Dimension<dim>{}, DependsOn<0, 1, 2, active_parameters + 1 + NUM_STATE_VARS...>{},
        [material_functor](double t, auto X, auto V, auto... params) {
          auto flux = material_functor(t, X, params...);
          return smith::inner(get<VALUE>(V), get<VALUE>(flux)) +
                 smith::inner(get<DERIVATIVE>(V), get<DERIVATIVE>(flux));
        },
        BaseWeakFormT::mesh_->domain(body_name));
  }
 
  template <typename MaterialType>
  void setMaterial(std::string body_name, const MaterialType& material)
  {
    setMaterial(DependsOn<>{}, body_name, material);
  }
 
 protected:
  std::vector<const mfem::ParFiniteElementSpace*> constructAllSpaces(
      const mfem::ParFiniteElementSpace& state_space, const std::vector<const mfem::ParFiniteElementSpace*>& spaces)
  {
    std::vector<const mfem::ParFiniteElementSpace*> all_spaces{&state_space, &state_space};
    for (auto& s : spaces) {
      all_spaces.push_back(s);
    }
    return all_spaces;
  }
 
  template <typename MaterialType>
  struct ThermalMaterialFunctor {
    ThermalMaterialFunctor(MaterialType material) : material_(material) {}
 
    MaterialType material_;
 
    template <typename X, typename Temperature, typename dT_dt, typename... Params>
    auto operator()(double /*time*/, X x, Temperature temperature, dT_dt dtemp_dt, Params... params) const
    {
      // Get the value and the gradient from the input tuple
      auto [u, du_dX] = temperature;
      auto du_dt = get<VALUE>(dtemp_dt);
      auto [heat_capacity, heat_flux] = material_(x, u, du_dX, params...);
      return smith::tuple{heat_capacity * du_dt, -heat_flux};
    }
  };
};
 
}  // namespace smith