BoundaryRestrictable.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

#ifdef MOOSE_KOKKOS_ENABLED
#include "KokkosTypes.h"
#endif

// MOOSE includes
#include "InputParameters.h"
#include "MaterialData.h"

class MooseMesh;

class BoundaryRestrictable
{
public:
  enum TEST_TYPE
  {
    ALL,
    ANY
  };

  BoundaryRestrictable(const MooseObject * moose_object, bool nodal);

  static InputParameters validParams();

  BoundaryRestrictable(const MooseObject * moose_object,
                       const std::set<SubdomainID> & block_ids,
                       bool nodal);

#ifdef MOOSE_KOKKOS_ENABLED

  BoundaryRestrictable(const BoundaryRestrictable & object, const Moose::Kokkos::FunctorCopy & key);
#endif

  static bool restricted(const std::set<BoundaryID> & ids);

  virtual ~BoundaryRestrictable();

  const virtual std::set<BoundaryID> & boundaryIDs() const;

  const std::vector<BoundaryName> & boundaryNames() const;

  unsigned int numBoundaryIDs() const;

  bool hasBoundary(const BoundaryName & name) const;

  bool hasBoundary(const std::vector<BoundaryName> & names) const;

  bool hasBoundary(const BoundaryID & id) const;

  bool hasBoundary(const std::vector<BoundaryID> & ids, TEST_TYPE type = ALL) const;

  bool hasBoundary(const std::set<BoundaryID> & ids, TEST_TYPE type = ALL) const;

  bool isBoundarySubset(const std::set<BoundaryID> & ids) const;

  /*
   * Test if the class boundary ids are a subset of the supplied objects
   * @param ids A std::set of Boundary IDs to check
   * @return True if all of the boundary ids for this class are found within the given ids (opposite
   * of hasBoundary)
   * \see hasBoundary
   */
  bool isBoundarySubset(const std::vector<BoundaryID> & ids) const;

  template <typename T, bool is_ad = false>
  bool hasBoundaryMaterialProperty(const std::string & prop_name) const;

  virtual bool boundaryRestricted() const;

  const std::set<BoundaryID> & meshBoundaryIDs() const;

  virtual bool checkVariableBoundaryIntegrity() const { return true; }

private:
  FEProblemBase * _bnd_feproblem;

  MooseMesh * _bnd_mesh;

  std::set<BoundaryID> _bnd_ids;

  std::vector<BoundaryID> _vec_ids;

  std::vector<BoundaryName> _boundary_names;

  const bool _bnd_dual_restrictable;

  const std::set<SubdomainID> _empty_block_ids;

  const std::set<SubdomainID> & _block_ids;

  THREAD_ID _bnd_tid;

  const MaterialData & _bnd_material_data;

  bool _bnd_nodal;

  const MooseObject & _moose_object;

  void initializeBoundaryRestrictable();

#ifdef MOOSE_KOKKOS_ENABLED
  void initializeKokkosBoundaryRestrictable(MooseMesh * mesh);
#endif

protected:
  bool hasBoundaryMaterialPropertyHelper(const std::string & prop_name) const;

#ifdef MOOSE_KOKKOS_SCOPE

  KOKKOS_FUNCTION dof_id_type numKokkosBoundaryNodes() const { return _kokkos_node_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosBoundarySides() const
  {
    return _kokkos_element_side_ids.size();
  }
  KOKKOS_FUNCTION ContiguousNodeID kokkosBoundaryNodeID(ThreadID tid) const
  {
    return _kokkos_node_ids[tid];
  }
  KOKKOS_FUNCTION auto kokkosBoundaryElementSideID(ThreadID tid) const
  {
    return _kokkos_element_side_ids[tid];
  }
#endif

#ifdef MOOSE_KOKKOS_ENABLED
private:
  Moose::Kokkos::Array<ContiguousNodeID> _kokkos_node_ids;
  Moose::Kokkos::Array<Moose::Kokkos::Pair<ContiguousElementID, unsigned int>>
      _kokkos_element_side_ids;
#endif
};

template <typename T, bool is_ad>
bool
BoundaryRestrictable::hasBoundaryMaterialProperty(const std::string & prop_name) const
{
  // If you get here the supplied property is defined on all boundaries, but is still subject
  // existence in the MateialData class
  return hasBoundaryMaterialPropertyHelper(prop_name) &&
         _bnd_material_data.haveGenericProperty<T, is_ad>(prop_name);
}