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

#include "libmesh/parallel_object.h"

#include <unordered_map>
#include <set>

class SubProblem;
class MortarExecutorInterface;
class AutomaticMortarGeneration;

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 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>,
                           std::unique_ptr<AutomaticMortarGeneration>> &
  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();

  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, std::unique_ptr<AutomaticMortarGeneration>> _mortar_interfaces;

  std::unordered_map<MortarKey, std::unique_ptr<AutomaticMortarGeneration>>
      _displaced_mortar_interfaces;

  std::set<SubdomainID> _mortar_subdomain_coverage;

  std::set<BoundaryID> _mortar_boundary_coverage;

  std::unordered_map<MortarKey, bool> _periodic_map;

  std::unordered_map<MortarKey, bool> _displaced_periodic_map;

  std::unordered_map<MortarKey, bool> _debug_flag_map;

  std::unordered_map<MortarKey, bool> _displaced_debug_flag_map;

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

  std::set<MortarExecutorInterface *> _mei_objs;

  bool _mortar_initd;
};