Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "NodalEqualValueConstraint.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "Assembly.h"
      14             : #include "MooseVariableScalar.h"
      15             : 
      16             : registerMooseObject("MooseApp", NodalEqualValueConstraint);
      17             : 
      18             : InputParameters
      19       14301 : NodalEqualValueConstraint::validParams()
      20             : {
      21       14301 :   InputParameters params = NodalScalarKernel::validParams();
      22       14301 :   params.addClassDescription("Constrain two nodes to have identical values.");
      23       14301 :   params.addRequiredCoupledVar("var", "Variable(s) to put the constraint on");
      24       14301 :   return params;
      25           0 : }
      26             : 
      27          20 : NodalEqualValueConstraint::NodalEqualValueConstraint(const InputParameters & parameters)
      28          20 :   : NodalScalarKernel(parameters), _val_number(coupledIndices("var")), _value(coupledValues("var"))
      29             : {
      30          20 :   if (_node_ids.size() != 2)
      31           4 :     paramError("boundary", "invalid number of nodes: want 2, got ", _node_ids.size());
      32          16 : }
      33             : 
      34             : void
      35          16 : NodalEqualValueConstraint::computeResidual()
      36             : {
      37          16 :   prepareVectorTag(_assembly, _var.number());
      38             : 
      39          32 :   for (unsigned int k = 0; k < _value.size(); k++)
      40          16 :     _local_re(k) = (*_value[k])[0] - (*_value[k])[1];
      41             : 
      42          16 :   assignTaggedLocalResidual();
      43          16 : }
      44             : 
      45             : void
      46           8 : NodalEqualValueConstraint::computeJacobian()
      47             : {
      48           8 :   prepareMatrixTag(_assembly, _var.number(), _var.number());
      49             : 
      50             :   // put zeroes on the diagonal (we have to do it, otherwise PETSc will complain!)
      51          16 :   for (unsigned int i = 0; i < _local_ke.m(); i++)
      52          16 :     for (unsigned int j = 0; j < _local_ke.n(); j++)
      53           8 :       _local_ke(i, j) = 0.;
      54             : 
      55           8 :   assignTaggedLocalMatrix();
      56             : 
      57          16 :   for (unsigned int k = 0; k < _value.size(); k++)
      58             :   {
      59           8 :     prepareMatrixTag(_assembly, _var.number(), _val_number[k]);
      60             : 
      61           8 :     _local_ke(k, 0) = 1.;
      62           8 :     _local_ke(k, 1) = -1.;
      63             : 
      64           8 :     assignTaggedLocalMatrix();
      65             :   }
      66           8 : }