NodeFaceConstraint.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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; }

  // TODO: Make this protected or add an accessor
  // Do the same for all the other public members
  SparseMatrix<Number> * _jacobian;

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