ResidualObject.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 "MooseObject.h"
#include "SetupInterface.h"
#include "FunctionInterface.h"
#include "UserObjectInterface.h"
#include "TransientInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "RandomInterface.h"
#include "Restartable.h"
#include "MeshChangedInterface.h"
#include "TaggingInterface.h"
 
class FEProblemBase;
class MooseMesh;
class SubProblem;
class Assembly;
class MooseVariableBase;
class MooseVariableFieldBase;
class InputParameters;
class SystemBase;
 
class ResidualObject : public MooseObject,
                       public SetupInterface,
                       public FunctionInterface,
                       public UserObjectInterface,
                       public TransientInterface,
                       public PostprocessorInterface,
                       public VectorPostprocessorInterface,
                       public RandomInterface,
                       public Restartable,
                       public MeshChangedInterface,
                       public TaggingInterface
{
public:
  static InputParameters validParams();
 
  ResidualObject(const InputParameters & parameters, bool nodal = false);
 
#ifdef MOOSE_KOKKOS_ENABLED
  ResidualObject(const ResidualObject & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  virtual void computeResidual() = 0;
 
  virtual void computeJacobian() = 0;
 
  virtual void computeResidualAndJacobian();
 
  virtual void computeOffDiagJacobian(unsigned int /*jvar*/) {}
 
  virtual void computeOffDiagJacobianScalar(unsigned int /*jvar*/) {}
 
  virtual void computeNonlocalJacobian() {}
 
  virtual void computeNonlocalOffDiagJacobian(unsigned int /* jvar */) {}
 
  virtual const MooseVariableBase & variable() const = 0;
 
  const SubProblem & subProblem() const { return _subproblem; }
 
  virtual void prepareShapes(unsigned int var_num);
 
  virtual std::set<std::string> additionalROVariables() { return {}; }
 
protected:
  virtual void precalculateResidual() {}
  virtual void precalculateJacobian() {}
  virtual void precalculateOffDiagJacobian(unsigned int /* jvar */) {}
 
  const MooseVariableFieldBase & getVariable(unsigned int jvar_num) const
  {
    return _sys.getVariable(_tid, jvar_num);
  }
 
protected:
  SubProblem & _subproblem;
 
  FEProblemBase & _fe_problem;
 
  SystemBase & _sys;
 
  THREAD_ID _tid;
 
  Assembly & _assembly;
 
  MooseMesh & _mesh;
};