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

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