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