FixedPointSolve.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "SolveObject.h"

// System includes
#include <string>

class FixedPointSolve : public SolveObject
{
public:
  FixedPointSolve(Executioner & ex);

  virtual ~FixedPointSolve() = default;

  static InputParameters fixedPointDefaultConvergenceParams();
  static InputParameters validParams();

  virtual void initialSetup() override;

  virtual bool solve() override;

  enum class MooseFixedPointConvergenceReason
  {
    UNSOLVED = 0,                  
    CONVERGED_NONLINEAR = 1,       
    CONVERGED_ABS = 2,             
    CONVERGED_RELATIVE = 3,        
    CONVERGED_PP = 4,              
    REACH_MAX_ITS = 5,             
    CONVERGED_OBJECT = 6,          
    DIVERGED_MAX_ITS = -1,         
    DIVERGED_NONLINEAR = -2,       
    DIVERGED_FAILED_MULTIAPP = -3, 
    DIVERGED_OBJECT = -4           
  };

  unsigned int numFixedPointIts() const { return _fixed_point_it + 1; }

  unsigned int numPicardIts() const
  {
    mooseDeprecated("numPicards() is deprecated. Please use numFixedPointIts() instead.");

    return _fixed_point_it + 1;
  }

  MooseFixedPointConvergenceReason checkConvergence() const { return _fixed_point_status; }

  bool XFEMRepeatStep() const { return _xfem_repeat_step; }

  void setFixedPointStatus(MooseFixedPointConvergenceReason status)
  {
    _fixed_point_status = status;
  }

  void clearFixedPointStatus() { _fixed_point_status = MooseFixedPointConvergenceReason::UNSOLVED; }

  bool hasFixedPointIteration() { return _has_fixed_point_its; }

  void setMultiAppRelaxationFactor(Real factor) { _secondary_relaxation_factor = factor; }

  void setMultiAppTransformedVariables(const std::vector<std::string> & vars)
  {
    _secondary_transformed_variables = vars;
  }

  virtual void setMultiAppTransformedPostprocessors(const std::vector<PostprocessorName> & pps)
  {
    _secondary_transformed_pps = pps;
  }

  virtual void allocateStorage(const bool primary) = 0;

  bool autoAdvance() const;

  void failStep() { _fail_step = true; }

  virtual void
  printFixedPointConvergenceHistory(Real initial_norm,
                                    const std::vector<Real> & timestep_begin_norms,
                                    const std::vector<Real> & timestep_end_norms) const = 0;

protected:
  virtual void saveVariableValues(const bool primary) = 0;

  virtual void savePostprocessorValues(const bool primary) = 0;

  virtual bool useFixedPointAlgorithmUpdateInsteadOfPicard(const bool primary) = 0;

  virtual bool solveStep(const std::set<dof_id_type> & transformed_dofs);

  virtual void saveAllValues(const bool primary);

  virtual void transformPostprocessors(const bool primary) = 0;

  virtual void transformVariables(const std::set<dof_id_type> & transformed_dofs,
                                  const bool primary) = 0;

  bool examineFixedPointConvergence(bool & converged);

  void printFixedPointConvergenceReason();

  const bool _has_fixed_point_its;

  const Real _relax_factor;
  std::vector<std::string> _transformed_vars; // TODO: make const once relaxed_variables is removed
  const std::vector<PostprocessorName> _transformed_pps;
  std::vector<std::vector<PostprocessorValue>> _transformed_pps_values;

  Real _secondary_relaxation_factor;
  std::vector<std::string> _secondary_transformed_variables;
  std::vector<PostprocessorName> _secondary_transformed_pps;
  std::vector<std::vector<PostprocessorValue>> _secondary_transformed_pps_values;

  unsigned int _fixed_point_it;
  unsigned int _main_fixed_point_it;
  MooseFixedPointConvergenceReason _fixed_point_status;
private:
  const unsigned int _max_xfem_update;
  const bool _update_xfem_at_timestep_begin;

  unsigned int _xfem_update_count;
  bool _xfem_repeat_step;

  Real _old_entering_time;

  bool _fail_step;

  const bool _auto_advance_set_by_user;

  const bool _auto_advance_user_value;
};