NewtonIterationContext.hpp

/*
  Copyright 2026 SINTEF AS.
 
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef OPM_NEWTON_ITERATION_CONTEXT_HPP
#define OPM_NEWTON_ITERATION_CONTEXT_HPP
 
#include <cassert>
 
namespace Opm {

struct NewtonIterationContext {
 
    NewtonIterationContext() = default;


    int iteration() const
    {
        return inLocalSolve_ ? localIteration_ : globalIteration_;
    }

    bool inLocalSolve() const { return inLocalSolve_; }

    bool timestepInitialized() const { return timestepInitialized_; }


    bool needsTimestepInit() const
    {
        return !timestepInitialized_ && !inLocalSolve_;
    }

    bool isFirstGlobalIteration() const
    {
        return globalIteration_ == 0 && !inLocalSolve_;
    }

    bool withinNupcol(int nupcol) const
    {
        return globalIteration_ < nupcol;
    }

    bool shouldRelax(int strictIterations) const
    {
        return iteration() >= strictIterations;
    }

    bool shouldRunInnerWellIterations(int maxIter) const
    {
        if (inLocalSolve_) return false;
        return globalIteration_ < maxIter;
    }


    void markTimestepInitialized()
    {
        timestepInitialized_ = true;
    }

    void advanceIteration()
    {
        if (inLocalSolve_) {
            localIteration_++;
        } else {
            globalIteration_++;
        }
    }

    void resetForNewTimestep()
    {
        globalIteration_ = 0;
        localIteration_ = 0;
        timestepInitialized_ = false;
        inLocalSolve_ = false;
    }

    NewtonIterationContext forLocalSolve() const
    {
        return {globalIteration_, 0, /*inLocalSolve=*/true, /*timestepInitialized=*/true};
    }
 
private:
    NewtonIterationContext(int globalIter, int localIter, bool localSolve, bool tsInit)
        : globalIteration_(globalIter), localIteration_(localIter)
        , inLocalSolve_(localSolve), timestepInitialized_(tsInit)
    {}
    int globalIteration_ = 0;
    int localIteration_ = 0;
    bool inLocalSolve_ = false;
    bool timestepInitialized_ = false;
};

template<class Problem>
class LocalContextGuard {
public:
    LocalContextGuard(Problem& problem)
        : problem_(problem)
        , saved_(problem.iterationContext())
    {
        problem_.mutableIterationContext() = saved_.forLocalSolve();
    }
 
    ~LocalContextGuard()
    {
        problem_.mutableIterationContext() = saved_;
    }
 
    LocalContextGuard(const LocalContextGuard&) = delete;
    LocalContextGuard& operator=(const LocalContextGuard&) = delete;
    LocalContextGuard(LocalContextGuard&&) = delete;
    LocalContextGuard& operator=(LocalContextGuard&&) = delete;
 
    NewtonIterationContext& context() { return problem_.mutableIterationContext(); }
    const NewtonIterationContext& context() const { return problem_.iterationContext(); }
 
private:
    Problem& problem_;
    NewtonIterationContext saved_;
};
 
} // namespace Opm
 
#endif // OPM_NEWTON_ITERATION_CONTEXT_HPP