MortarConsumerInterface.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 "MooseTypes.h"
 
#include <set>
 
class InputParameters;
class MooseObject;
class MooseMesh;
class MortarInterfaceWarehouse;
class AutomaticMortarGeneration;
class MooseVariableFieldBase;
class SubProblem;
class Assembly;
 
namespace libMesh
{
class QBase;
}
 
class MortarConsumerInterface
{
public:
  MortarConsumerInterface(const MooseObject * moose_object);
 
  static InputParameters validParams();
 
  static InputParameters triangulationParams();
 
  SubdomainID primarySubdomain() const { return _primary_subdomain_id; }
 
  SubdomainID secondarySubdomain() const { return _secondary_subdomain_id; }
 
  bool onInterface(BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id) const;
 
protected:
  const std::set<SubdomainID> & getHigherDimSubdomainIDs() const
  {
    return _higher_dim_subdomain_ids;
  }
  const std::set<BoundaryID> & getBoundaryIDs() const { return _boundary_ids; }
 
  const AutomaticMortarGeneration & amg() const;
 
  bool interpolateNormals() const { return _interpolate_normals; }
 
  void checkPetrovGalerkinQuadraticFaces(const MooseObject & moose_object,
                                         const MooseVariableFieldBase & lm_var) const;
 
  static void trimDerivative(dof_id_type remove_derivative_index, ADReal & dual_number);
 
  template <typename Variables, typename DualNumbers>
  static void
  trimInteriorNodeDerivatives(const std::map<unsigned int, unsigned int> & primary_ip_lowerd_map,
                              const Variables & moose_var,
                              DualNumbers & ad_vars,
                              const bool is_secondary);
 
  FEProblemBase & _mci_fe_problem;
  SubProblem & _mci_subproblem;
  const THREAD_ID _mci_tid;
 
  MooseMesh & _mci_mesh;
 
  Assembly & _mci_assembly;
 
  const MortarInterfaceWarehouse & _mortar_data;
 
  const BoundaryID _secondary_id;
 
  const BoundaryID _primary_id;
 
  const SubdomainID _secondary_subdomain_id;
 
  const SubdomainID _primary_subdomain_id;
 
  std::set<BoundaryID> _secondary_set;
 
  std::set<BoundaryID> _boundary_ids;
 
  std::set<SubdomainID> _higher_dim_subdomain_ids;
 
  const bool _interpolate_normals;
 
  const MooseArray<Point> & _phys_points_secondary;
 
  const MooseArray<Point> & _phys_points_primary;
 
  const libMesh::QBase * const & _qrule_msm;
 
  const libMesh::QBase * const & _qrule_face;
 
  Elem const * const & _lower_secondary_elem;
 
  Elem const * const & _lower_primary_elem;
 
  const std::vector<Real> & _JxW_msm;
 
  const Elem * const & _msm_elem;
 
  std::vector<Point> _normals;
 
private:
  void setNormals();
 
  // Pointer to automatic mortar generation object to give constraints access to mortar geometry
  const AutomaticMortarGeneration * _amg;
 
  friend class ComputeMortarFunctor;
  friend class FEProblemBase;
 
  template <typename>
  friend class MortarNodalAuxKernelTempl;
  friend class MortarUserObjectThread;
 
  friend void reinitMortarUserObjects(BoundaryID, BoundaryID, bool);
};
 
inline const AutomaticMortarGeneration &
MortarConsumerInterface::amg() const
{
  mooseAssert(_amg, "this should have been set in the constructor");
  return *_amg;
}
 
template <typename Variables, typename DualNumbers>
void
MortarConsumerInterface::trimInteriorNodeDerivatives(
    const std::map<unsigned int, unsigned int> & domain_ip_lowerd_map,
    const Variables & moose_vars,
    DualNumbers & dual_numbers,
    const bool is_secondary)
{
  //
  // Remove interior node variable's derivatives from AD objects.
  //
 
  mooseAssert(moose_vars.size(), "Should have passed at least one variable");
  const auto num_indices = is_secondary ? moose_vars[0]->dofIndices().size()
                                        : moose_vars[0]->dofIndicesNeighbor().size();
#ifdef DEBUG
  for (const auto i : make_range(std::size_t(1), moose_vars.size()))
    if (auto * moose_var = moose_vars[i])
      mooseAssert(is_secondary ? moose_var->dofIndices().size()
                               : moose_var->dofIndicesNeighbor().size() == num_indices,
                  "These must be the same for all passed in variables");
#endif
 
  for (const auto dof_index : make_range(num_indices))
    if (!domain_ip_lowerd_map.count(dof_index))
    {
      for (const auto * const moose_var : moose_vars)
      {
        // It's valid for a user to pass a container that represents a LIBMESH_DIM vector of
        // component variables for which one or two of the variables may be null depending on the
        // mesh dimension in the simulation
        if (!moose_var)
          continue;
 
        mooseAssert(moose_var->isNodal(),
                    "Trimming of interior node's derivatives is only supported for Lagrange "
                    "elements in mortar objects");
 
        const auto remove_derivative_index = is_secondary
                                                 ? moose_var->dofIndices()[dof_index]
                                                 : moose_var->dofIndicesNeighbor()[dof_index];
        for (auto & dual_number : dual_numbers)
          trimDerivative(remove_derivative_index, dual_number);
      }
    }
}
 
inline bool
MortarConsumerInterface::onInterface(const BoundaryID primary_boundary_id,
                                     const BoundaryID secondary_boundary_id) const
{
  return (primary_boundary_id == _primary_id) && (secondary_boundary_id == _secondary_id);
}