MortarInterfaceWarehouse.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 "Mortar3DSubpatchPlane.h"
#include "MooseTypes.h"
#include "MooseHashing.h"
#include "MortarSegmentInfo.h"

#include "libmesh/parallel_object.h"

#include <memory>
#include <unordered_map>
#include <set>
#include <string>

class SubProblem;
class MortarExecutorInterface;
class AutomaticMortarGeneration;
class MooseEnum;

struct MortarInterfaceConfig
{
  std::unique_ptr<AutomaticMortarGeneration> amg;
  bool periodic;
  bool debug;
  Real minimum_projection_angle;
  Mortar3DSubpatchPlane mortar_3d_subpatch_plane;
  MortarSegmentTriangulationMode triangulation;
  bool triangulate_triangles;
  Mortar3DQuadraturePointMapping mortar_3d_qp_mapping;
};

class MortarInterfaceWarehouse : public libMesh::ParallelObject
{
public:
  MortarInterfaceWarehouse(const libMesh::ParallelObject & other);

  void createMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
                             const std::pair<SubdomainID, SubdomainID> & subdomain_key,
                             SubProblem & subproblem,
                             bool on_displaced,
                             bool periodic,
                             const bool debug,
                             const bool correct_edge_dropping,
                             const Real minimum_projection_angle,
                             const Mortar3DSubpatchPlane mortar_3d_subpatch_plane,
                             const MooseEnum & triangulation,
                             const bool triangulate_triangles,
                             const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping =
                                 Mortar3DQuadraturePointMapping::NORMAL_PROJECTION);

  const AutomaticMortarGeneration &
  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
                     const std::pair<SubdomainID, SubdomainID> & /*subdomain_key*/,
                     bool on_displaced) const;

  AutomaticMortarGeneration &
  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
                     const std::pair<SubdomainID, SubdomainID> & /*subdomain_key*/,
                     bool on_displaced);

  const std::unordered_map<std::pair<BoundaryID, BoundaryID>, MortarInterfaceConfig> &
  getMortarInterfaces(bool on_displaced) const
  {
    if (on_displaced)
      return _displaced_mortar_interfaces;
    else
      return _mortar_interfaces;
  }

  const std::set<SubdomainID> & getMortarSubdomainIDs() const { return _mortar_subdomain_coverage; }

  const std::set<BoundaryID> & getMortarBoundaryIDs() const { return _mortar_boundary_coverage; }

  void update();

  void meshChanged();

  bool hasDisplacedObjects() const { return _displaced_mortar_interfaces.size(); }

  bool hasObjects() const { return _mortar_interfaces.size(); }

  const std::set<SubdomainID> & getHigherDimSubdomainIDs(SubdomainID lower_d_subdomain_id) const;

  void notifyWhenMortarSetup(MortarExecutorInterface * mei);

  void dontNotifyWhenMortarSetup(MortarExecutorInterface * mei);

  bool initialized() const { return _mortar_initd; }

private:
  void update(AutomaticMortarGeneration & amg);

  typedef std::pair<BoundaryID, BoundaryID> MortarKey;

  std::unordered_map<MortarKey, MortarInterfaceConfig> _mortar_interfaces;

  std::unordered_map<MortarKey, MortarInterfaceConfig> _displaced_mortar_interfaces;

  std::set<SubdomainID> _mortar_subdomain_coverage;

  std::set<BoundaryID> _mortar_boundary_coverage;

  std::unordered_map<SubdomainID, std::set<SubdomainID>> _lower_d_sub_to_higher_d_subs;

  std::set<MortarExecutorInterface *> _mei_objs;

  bool _mortar_initd;
};