ReferenceResidualConvergence.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 "DefaultNonlinearConvergence.h"
#include "ReferenceResidualInterface.h"
 
// PETSc includes
#include <petsc.h>
#include <petscmat.h>
 
#include "libmesh/enum_norm_type.h"
 
class ReferenceResidualConvergence : public DefaultNonlinearConvergence,
                                     public ReferenceResidualInterface
{
public:
  static InputParameters validParams();
 
  ReferenceResidualConvergence(const InputParameters & parameters);
 
  void updateReferenceResidual();
 
  virtual void initialSetup() override;
 
  class ReferenceVectorTagIDKey
  {
    friend class TaggingInterface;
    ReferenceVectorTagIDKey() {}
    ReferenceVectorTagIDKey(const ReferenceVectorTagIDKey &) {}
  };
 
  TagID referenceVectorTagID(ReferenceVectorTagIDKey) const { return _reference_vector_tag_id; }
 
protected:
  virtual NonlinearSystemBase & nonlinearSystem() override;
 
  virtual void nonlinearConvergenceSetup() override;
 
  virtual bool checkResidualConvergence(const unsigned int n_iter,
                                        const Real fnorm,
                                        const Real ref_norm,
                                        const Real rel_tol,
                                        const Real abs_tol,
                                        std::ostringstream & oss) override;
 
  bool checkConvergenceIndividVars(const Real fnorm,
                                   const Real abs_tol,
                                   const Real rel_tol,
                                   const Real initial_residual_before_preset_bcs);
 
  const MooseEnum _norm_type_enum;
 
  std::vector<NonlinearVariableName> _soln_var_names;
  std::vector<AuxVariableName> _ref_resid_var_names;
 
  std::vector<NonlinearVariableName> _group_names;
 
  std::vector<unsigned int> _soln_vars;
  std::vector<unsigned int> _ref_resid_vars;
 
  const Real _accept_mult;
  const unsigned int _accept_iters;
 
  const unsigned int _nl_sys_num;
 
  std::vector<Real> _group_ref_resid;
  std::vector<Real> _group_resid;
 
  std::vector<bool> _is_var_grouped;
 
  std::vector<unsigned int> _group_index;
 
  std::vector<Real> _scaling_factors;
 
  const NumericVector<Number> * _residual_vector;
 
  const NumericVector<Number> * _reference_vector;
 
  std::vector<bool> _converge_on_var;
  std::vector<bool> _converge_on_group;
 
  const enum class ZeroReferenceType { ZERO_TOLERANCE, RELATIVE_TOLERANCE } _zero_ref_type;
 
  const bool _unscale_the_residual;
 
  bool _local_norm;
 
  libMesh::FEMNormType _norm_type;
 
  TagID _reference_vector_tag_id;
};