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