system_base.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 <string>
#include <vector>
#include <memory>
#include <utility>
#include "field_state.hpp"
#include "field_store.hpp"
#include "system_solver.hpp"
#include "state_advancer.hpp"
#include "smith/physics/common.hpp"
#include "mfem.hpp"
 
namespace smith {
 
template <typename... Args>
struct Parameters;
 
namespace detail {
 
template <std::size_t, typename T>
using always_t = T;
 
template <typename Space, typename... Tail, std::size_t... Is>
auto time_rule_params_impl(std::index_sequence<Is...>) -> Parameters<always_t<Is, Space>..., Tail...>;
 
}  // namespace detail
 
template <typename Rule, typename Space, typename... Tail>
using TimeRuleParams =
    decltype(detail::time_rule_params_impl<Space, Tail...>(std::make_index_sequence<Rule::num_states>{}));
 
struct SystemBase {
  // --- equations ---
  std::vector<std::shared_ptr<WeakForm>> weak_forms;  
 
  // --- infrastructure ---
  std::shared_ptr<FieldStore> field_store;  
  std::shared_ptr<SystemSolver> solver;     
  std::vector<std::shared_ptr<SystemBase>>
      cycle_zero_systems;  
  std::vector<std::shared_ptr<SystemBase>> post_solve_systems;  
  std::vector<std::string>
      solve_result_field_names;  
  std::vector<std::vector<std::string>>
      solve_input_field_names;  
 
  SystemBase() = default;
  explicit SystemBase(std::shared_ptr<FieldStore> fs, std::shared_ptr<SystemSolver> sol = nullptr,
                      std::vector<std::shared_ptr<WeakForm>> wfs = {})
      : weak_forms(std::move(wfs)), field_store(std::move(fs)), solver(std::move(sol))
  {
  }
  virtual ~SystemBase() = default;
 
  virtual std::vector<FieldState> solve(const TimeInfo& time_info) const;
 
  virtual std::vector<ReactionState> computeReactions(const TimeInfo& time_info,
                                                      const std::vector<FieldState>& states_for_reactions) const;
};
 
inline std::shared_ptr<SystemBase> makeSystem(std::shared_ptr<FieldStore> field_store,
                                              std::shared_ptr<SystemSolver> solver,
                                              std::vector<std::shared_ptr<WeakForm>> weak_forms)
{
  return std::make_shared<SystemBase>(std::move(field_store), std::move(solver), std::move(weak_forms));
}
 
}  // namespace smith
 
namespace smith {
namespace detail {
 
template <typename WeakFormT, typename FieldStorePtr, typename... Args, std::size_t... Is>
auto buildWeakFormWithCouplingImpl(const FieldStorePtr& field_store, const std::string& weak_form_name,
                                   const std::string& unknown_field_name, const std::tuple<Args...>& args_tuple,
                                   std::index_sequence<Is...>)
{
  auto coupling_fields_tuple = std::get<sizeof...(Args) - 1>(args_tuple);
  return std::apply(
      [&](const auto&... coupling_fields) {
        return std::make_shared<WeakFormT>(weak_form_name, field_store->getMesh(),
                                           field_store->getField(unknown_field_name).get()->space(),
                                           field_store->createSpaces(weak_form_name, unknown_field_name,
                                                                     std::get<Is>(args_tuple)..., coupling_fields...));
      },
      coupling_fields_tuple);
}
 
template <typename WeakFormT, typename FieldStorePtr, typename... Args>
auto buildWeakFormWithCoupling(const FieldStorePtr& field_store, const std::string& weak_form_name,
                               const std::string& unknown_field_name, const Args&... args)
{
  return buildWeakFormWithCouplingImpl<WeakFormT>(field_store, weak_form_name, unknown_field_name, std::tie(args...),
                                                  std::make_index_sequence<sizeof...(Args) - 1>{});
}
 
}  // namespace detail
}  // namespace smith