LMWeightedGapUserObject.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 "WeightedGapUserObject.h"
 
#include "libmesh/fe_base.h"
#include "libmesh/quadrature_gauss.h"
 
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
template <typename>
class MooseVariableFE;
 
class LMWeightedGapUserObject : virtual public WeightedGapUserObject
{
public:
  static InputParameters validParams();
  static InputParameters newParams();
 
  LMWeightedGapUserObject(const InputParameters & parameters);
 
  virtual const ADVariableValue & contactPressure() const override;
  virtual void reinit() override;
  virtual Real getNormalContactPressure(const Node * const /*node*/) const override;
 
  virtual void initialize() override;
  virtual void finalize() override;
 
  virtual Real nodalScale(const DofObject * const dof) const override
  {
    return findValue(_dof_to_nodal_scale, dof, Real(1));
  }
  virtual bool usesNodalScaling() const override { return _use_nodal_scaling; }
 
  virtual Real normalizeCDivisor(const DofObject * const dof,
                                 const Real covered_normalization) const override
  {
    return _use_nodal_scaling ? findValue(_dof_to_full_normalization, dof, covered_normalization)
                              : covered_normalization;
  }
 
protected:
  virtual const VariableTestValue & test() const override;
  virtual bool constrainedByOwner() const override { return true; }
  virtual void computeQpIProperties() override;
 
  void initializeNodalScaling();
  void finalizeNodalScaling();
  void computeQpINodalScaling();
 
  const std::vector<Real> & fullNodalIntegrals(const Elem * elem);
 
  void checkInput(const MooseVariable * const var, const std::string & var_name) const;
 
  void verifyLagrange(const MooseVariable & var, const std::string & var_name) const;
 
  const MooseVariableFE<Real> * const _lm_var;
 
  const bool _use_petrov_galerkin;
 
  const MooseVariable * const _aux_lm_var;
 
  ADVariableValue _scaled_contact_pressure;
 
  const bool _use_nodal_scaling;
 
  std::unordered_map<const DofObject *, Real> _dof_to_covered_fraction_sum;
 
  std::unordered_map<const DofObject *, Real> _dof_to_nodal_scale;
 
  std::unordered_map<dof_id_type, std::vector<Real>> _elem_to_full_nodal_integral;
 
  std::unordered_map<const DofObject *, Real> _dof_to_full_normalization;
 
  std::unordered_map<const DofObject *, std::unordered_set<dof_id_type>> _full_normalization_elems;
 
  std::unique_ptr<libMesh::FEBase> _nodal_scaling_fe;
  std::unique_ptr<libMesh::QGauss> _nodal_scaling_qrule;
};