StaggeredCoupling.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <functional>
#include <memory>
#include <tuple>
#include <variant>
#include <vector>
 
#include "MathLib/LinAlg/GlobalMatrixVectorTypes.h"
#include "MathLib/LinAlg/LinAlg.h"
#include "NumLib/ODESolver/ConvergenceCriterion.h"
#include "NumLib/ODESolver/NonlinearSolverStatus.h"
 
namespace NumLib
{

struct CouplingNode
{
    std::string process_name;
    std::unique_ptr<NumLib::ConvergenceCriterion> convergence_criterion;
    int max_iterations;
    int process_id;
};
 
struct RootCouplingNode
{
    int max_iterations;
    using CouplingNodeVariant = std::variant<CouplingNode, RootCouplingNode>;
    std::vector<CouplingNodeVariant> sub_coupling_nodes;
};

class StaggeredCoupling
{
    template <typename ProcessData, typename Output>
    using ProcessSolver = std::function<NumLib::NonlinearSolverStatus(
        std::vector<GlobalVector*>& /*xs*/,
        std::vector<GlobalVector*> const& /*xs_prev*/,
        std::size_t const /*timestep*/, double const /*t*/,
        double const /*delta_t*/, ProcessData const& /*process_data*/,
        std::vector<Output> const& /*outputs*/)>;
 
    using CouplingNodeVariant = std::variant<CouplingNode, RootCouplingNode>;
 
public:
    StaggeredCoupling(const int global_coupling_max_iterations,
                      std::vector<CouplingNodeVariant>&& coupling_nodes)
        : global_coupling_max_iterations_(global_coupling_max_iterations),
          coupling_nodes_(std::move(coupling_nodes))
    {
    }
 
    ~StaggeredCoupling();

    int lastNumberOfCouplingIterations() const
    {
        return number_of_global_coupling_iterations_;
    }

    void initializeCoupledSolutions(
        std::vector<GlobalVector*> const& process_solutions);

    template <typename ProcessData, typename Output>
    NumLib::NonlinearSolverStatus execute(
        const double t, const double dt, const std::size_t timestep_id,
        std::vector<GlobalVector*>& process_solutions,
        std::vector<GlobalVector*> const& process_solutions_prev,
        std::vector<std::unique_ptr<ProcessData>> const& per_process_data,
        std::vector<Output> const& outputs,
        ProcessSolver<ProcessData, Output> const&
            solve_one_time_step_one_process);
 
private:
    const int global_coupling_max_iterations_;

    int number_of_global_coupling_iterations_ = 0;

    std::vector<CouplingNodeVariant> coupling_nodes_;

    template <typename ProcessData, typename Output>
    std::tuple<NumLib::NonlinearSolverStatus, bool, int> executeConcrete(
        std::vector<CouplingNodeVariant>& coupling_nodes,
        const int max_iterations, const double t, const double dt,
        const std::size_t timestep_id,
        std::vector<GlobalVector*>& process_solutions,
        std::vector<GlobalVector*> const& process_solutions_prev,
        std::vector<std::unique_ptr<ProcessData>> const& per_process_data,
        std::vector<Output> const& outputs,
        ProcessSolver<ProcessData, Output> const&
            solve_one_time_step_one_process);
 
    template <typename ProcessData, typename Output>
    std::tuple<NumLib::NonlinearSolverStatus, bool, int> executeSubCoupling(
        CouplingNodeVariant& coupling_node, const double t, const double dt,
        const std::size_t timestep_id,
        std::vector<GlobalVector*>& process_solutions,
        std::vector<GlobalVector*> const& process_solutions_prev,
        std::vector<std::unique_ptr<ProcessData>> const& per_process_data,
        std::vector<Output> const& outputs,
        ProcessSolver<ProcessData, Output> const&
            solve_one_time_step_one_process);
 
    template <typename ProcessData, typename Output>
    NumLib::NonlinearSolverStatus executeSingleIteration(
        int const global_coupling_iteration,
        CouplingNode const& regular_coupling_node, const double t,
        const double dt, const std::size_t timestep_id,
        std::vector<GlobalVector*>& process_solutions,
        std::vector<GlobalVector*> const& process_solutions_prev,
        std::vector<std::unique_ptr<ProcessData>> const& per_process_data,
        std::vector<Output> const& outputs,
        ProcessSolver<ProcessData, Output> const&
            solve_one_time_step_one_process);

    std::vector<GlobalVector*> solutions_of_last_cpl_iteration_;

    void setFirstIterationIndicator(
        std::vector<CouplingNodeVariant> const& coupling_nodes);
 
    void resetCouplingConvergenceCriteria(
        std::vector<CouplingNodeVariant> const& coupling_nodes);
 
    bool checkCouplingConvergence(const bool convergence_of_last_process,
                                  CouplingNode const& coupling_node,
                                  GlobalVector const& x) const;
 
    void updatePreviousSolution(int const process_id, GlobalVector const& x);
};
 
}  // namespace NumLib
 
#include "StaggeredCoupling-impl.h"