system_solver.hpp

// 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 <vector>
#include <memory>
#include <mpi.h>
#include "smith/differentiable_numerics/field_state.hpp"
#include "smith/numerics/solver_config.hpp"
#include "smith/physics/common.hpp"
 
namespace smith {
 
class WeakForm;
class NonlinearBlockSolverBase;
class BoundaryConditionManager;
 
class SystemSolver {
 public:
  struct Stage {
    std::vector<size_t> block_indices;                 
    std::shared_ptr<NonlinearBlockSolverBase> solver;  
    double relaxation_factor = 1.0;                    
  };
 
  SystemSolver(std::shared_ptr<NonlinearBlockSolverBase> single_solver);
 
  SystemSolver(int max_staggered_iterations, bool exact_staggered_steps = false);
 
  void addSubsystemSolver(const std::vector<size_t>& block_indices, std::shared_ptr<NonlinearBlockSolverBase> solver,
                          double relaxation_factor = 1.0);
 
  void appendStagesWithBlockMapping(const SystemSolver& subsystem_solver,
                                    const std::vector<size_t>& global_block_indices);
 
  std::vector<FieldState> solve(const std::vector<WeakForm*>& residual_evals,
                                const std::vector<std::vector<size_t>>& block_indices, const FieldState& shape_disp,
                                const std::vector<std::vector<FieldState>>& states,
                                const std::vector<std::vector<FieldState>>& params, const TimeInfo& time_info,
                                const std::vector<const BoundaryConditionManager*>& bc_managers) const;
 
  std::shared_ptr<SystemSolver> singleBlockSolver(size_t block_index) const;
 
  int maxStaggeredIterations() const { return max_staggered_iterations_; }
 
  bool exactStaggeredSteps() const { return exact_staggered_steps_; }
 
 private:
  int max_staggered_iterations_;  
  bool exact_staggered_steps_;    
  std::vector<Stage> stages_;     
};
 
}  // namespace smith