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 validParams();

  virtual bool solve() override;

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

  unsigned int minFixedPointIts() const { return _min_fixed_point_its; }

  unsigned int maxFixedPointIts() const { return _max_fixed_point_its; }

  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 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; }

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(Real & begin_norm, Real & end_norm, 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;

  virtual void printFixedPointConvergenceHistory() = 0;

  void computeCustomConvergencePostprocessor();

  bool examineFixedPointConvergence(bool & converged);

  void printFixedPointConvergenceReason();

  unsigned int _min_fixed_point_its;
  unsigned int _max_fixed_point_its;
  bool _has_fixed_point_its; // TODO: make const once picard parameters are removed
  bool _accept_max_it; // TODO: make const once picard parameters are removed
  bool _has_fixed_point_norm; // TODO: make const once picard parameters are removed
  Real _fixed_point_rel_tol; // TODO: make const once picard parameters are removed
  Real _fixed_point_abs_tol; // TODO: make const once picard parameters are removed
  bool _fixed_point_force_norms; // TODO: make const once picard parameters are removed

  const PostprocessorValue *
      _fixed_point_custom_pp; // FIXME Make const and private once picard_custom_pp is gone

  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;
  Real _fixed_point_initial_norm;
  std::vector<Real> _fixed_point_timestep_begin_norm;
  std::vector<Real> _fixed_point_timestep_end_norm;
  MooseFixedPointConvergenceReason _fixed_point_status;
private:
  const Real _custom_rel_tol;
  const Real _custom_abs_tol;
  Real _pp_old;
  Real _pp_new;
  Real _pp_scaling;
  std::ostringstream _pp_history;

  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;
};