NodeFaceConstraint.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
 
// MOOSE includes
#include "Constraint.h"
#include "NeighborCoupleableMooseVariableDependencyIntermediateInterface.h"
 
// libMesh forward declarations
namespace libMesh
{
template <typename T>
class SparseMatrix;
}
 
class NodeFaceConstraint : public Constraint,
                           public NeighborCoupleableMooseVariableDependencyIntermediateInterface,
                           public NeighborMooseVariableInterface<Real>
{
public:
  static InputParameters validParams();
 
  NodeFaceConstraint(const InputParameters & parameters);
  virtual ~NodeFaceConstraint();
 
  virtual void computeSecondaryValue(NumericVector<Number> & current_solution);
 
  virtual void computeResidual() override;
 
  virtual void computeJacobian() override;
 
  virtual void computeOffDiagJacobian(unsigned int jvar) override;
 
  virtual void getConnectedDofIndices(unsigned int var_num);
 
  virtual bool shouldApply() { return true; }
 
  virtual bool overwriteSecondaryResidual();
 
  virtual bool overwriteSecondaryJacobian() { return overwriteSecondaryResidual(); };
 
  virtual MooseVariable & primaryVariable() { return _primary_var; }
 
  BoundaryID primaryBoundary() const { return _primary; }
 
  BoundaryID secondaryBoundary() const { return _secondary; }
 
  const MooseVariable & variable() const override { return _var; }
 
  Real secondaryResidual() const;
 
  void residualSetup() override;
 
  virtual const std::unordered_set<unsigned int> & getMatPropDependencies() const;
 
  virtual bool isExplicitConstraint() const { return false; }
 
  virtual void overwriteBoundaryVariables(NumericVector<Number> & /*soln*/,
                                          const Node & /*secondary_node*/) const
  {
  }
 
  std::set<SubdomainID> getSecondaryConnectedBlocks() const;
 
protected:
  // TODO: Make this protected or add an accessor
  // Do the same for all the other public members
  const SparseMatrix<Number> * _jacobian;
 
  virtual Real computeQpSecondaryValue() = 0;
 
  virtual Real computeQpResidual(Moose::ConstraintType type) = 0;
 
  virtual Real computeQpJacobian(Moose::ConstraintJacobianType type) = 0;
 
  virtual Real computeQpOffDiagJacobian(Moose::ConstraintJacobianType /*type*/,
                                        unsigned int /*jvar*/)
  {
    return 0;
  }
 
  virtual const VariableValue & coupledSecondaryValue(const std::string & var_name,
                                                      unsigned int comp = 0)
  {
    return coupledValue(var_name, comp);
  }
  virtual const VariableValue & coupledSecondaryValueOld(const std::string & var_name,
                                                         unsigned int comp = 0)
  {
    return coupledValueOld(var_name, comp);
  }
  virtual const VariableValue & coupledSecondaryValueOlder(const std::string & var_name,
                                                           unsigned int comp = 0)
  {
    return coupledValueOlder(var_name, comp);
  }
 
  virtual const VariableGradient & coupledSecondaryGradient(const std::string & var_name,
                                                            unsigned int comp = 0)
  {
    return coupledGradient(var_name, comp);
  }
  virtual const VariableGradient & coupledSecondaryGradientOld(const std::string & var_name,
                                                               unsigned int comp = 0)
  {
    return coupledGradientOld(var_name, comp);
  }
  virtual const VariableGradient & coupledSecondaryGradientOlder(const std::string & var_name,
                                                                 unsigned int comp = 0)
  {
    return coupledGradientOlder(var_name, comp);
  }
 
  virtual const VariableSecond & coupledSecondarySecond(const std::string & var_name,
                                                        unsigned int comp = 0)
  {
    return coupledSecond(var_name, comp);
  }
 
  virtual const VariableValue & coupledPrimaryValue(const std::string & var_name,
                                                    unsigned int comp = 0)
  {
    return coupledNeighborValue(var_name, comp);
  }
  virtual const VariableValue & coupledPrimaryValueOld(const std::string & var_name,
                                                       unsigned int comp = 0)
  {
    return coupledNeighborValueOld(var_name, comp);
  }
  virtual const VariableValue & coupledPrimaryValueOlder(const std::string & var_name,
                                                         unsigned int comp = 0)
  {
    return coupledNeighborValueOlder(var_name, comp);
  }
 
  virtual const VariableGradient & coupledPrimaryGradient(const std::string & var_name,
                                                          unsigned int comp = 0)
  {
    return coupledNeighborGradient(var_name, comp);
  }
  virtual const VariableGradient & coupledPrimaryGradientOld(const std::string & var_name,
                                                             unsigned int comp = 0)
  {
    return coupledNeighborGradientOld(var_name, comp);
  }
  virtual const VariableGradient & coupledPrimaryGradientOlder(const std::string & var_name,
                                                               unsigned int comp = 0)
  {
    return coupledNeighborGradientOlder(var_name, comp);
  }
 
  virtual const VariableSecond & coupledPrimarySecond(const std::string & var_name,
                                                      unsigned int comp = 0)
  {
    return coupledNeighborSecond(var_name, comp);
  }
 
  const std::set<BoundaryID> & buildBoundaryIDs();
 
  BoundaryID _secondary;
  BoundaryID _primary;
 
  MooseVariable & _var;
 
  const MooseArray<Point> & _primary_q_point;
  const QBase * const & _primary_qrule;
 
  std::set<BoundaryID> _boundary_ids;
 
  PenetrationLocator & _penetration_locator;
 
  const Node * const & _current_node;
  const Elem * const & _current_primary;
 
  const VariableValue & _u_secondary;
  VariablePhiValue _phi_secondary;
  VariableTestValue _test_secondary;
 
  MooseVariable & _primary_var;
 
  unsigned int _primary_var_num;
 
  const VariablePhiValue & _phi_primary;
  const VariablePhiGradient & _grad_phi_primary;
 
  const VariableTestValue & _test_primary;
  const VariableTestGradient & _grad_test_primary;
 
  const VariableValue & _u_primary;
  const VariableGradient & _grad_u_primary;
 
  const DofMap & _dof_map;
 
  const std::unordered_map<dof_id_type, std::vector<dof_id_type>> & _node_to_elem_map;
 
  bool _overwrite_secondary_residual;
 
  const MooseArray<Real> & _primary_JxW;
 
  bool _secondary_residual_computed;
 
  Real _secondary_residual;
 
  const std::unordered_set<unsigned int> _empty_mat_prop_deps;
 
  std::vector<dof_id_type> _connected_dof_indices;
 
  DenseMatrix<Number> _Kne;
 
  DenseMatrix<Number> _Kee;
 
  DenseMatrix<Number> _Ken;
 
  friend class NonlinearSystemBase;
};
 
inline const std::unordered_set<unsigned int> &
NodeFaceConstraint::getMatPropDependencies() const
{
  return _empty_mat_prop_deps;
}