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;
 
  void copyPreviousFixedPointSolutionForSystem(SystemBase * sys)
  {
    _systems_to_copy_previous_solutions_for.insert(sys);
  }
 
protected:
  bool performingRelaxation(const bool primary) const;
 
  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();
 
  void findTransformedSystem(const bool primary);
 
  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;
  SystemBase * _transformed_sys;
  std::set<SystemBase *> _systems_to_copy_previous_solutions_for;
 
  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;
};