BlockRestrictable.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 "ParallelUniqueId.h"
#include "MaterialData.h"
#include "MooseObject.h"

#define usingBlockRestrictableMembers using BlockRestrictable::getBlockCoordSystem

class FEProblemBase;
class MooseMesh;

#ifdef MOOSE_KOKKOS_ENABLED
namespace Moose::Kokkos
{
class Mesh;
}
#endif

class MooseVariableFieldBase;

class BlockRestrictable
{
public:
  BlockRestrictable(const MooseObject * moose_object, bool initialize = true);

  static InputParameters validParams();

  BlockRestrictable(const MooseObject * moose_object, const std::set<BoundaryID> & boundary_ids);

#ifdef MOOSE_KOKKOS_ENABLED

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

  virtual ~BlockRestrictable() {}

  const std::vector<SubdomainName> & blocks() const;

  unsigned int numBlocks() const;

  virtual const std::set<SubdomainID> & blockIDs() const;

  unsigned int blocksMaxDimension() const;

  bool hasBlocks(const SubdomainName & name) const;

  bool hasBlocks(const std::vector<SubdomainName> & names) const;

  bool hasBlocks(const std::set<SubdomainName> & names) const;

  bool hasBlocks(SubdomainID id) const;

  bool hasBlocks(const std::vector<SubdomainID> & ids) const;

  bool hasBlocks(const std::set<SubdomainID> & ids) const;

  bool isBlockSubset(const std::set<SubdomainID> & ids) const;

  bool isBlockSubset(const std::vector<SubdomainID> & ids) const;

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

  const std::set<SubdomainID> & meshBlockIDs() const;

  virtual bool blockRestricted() const;

  virtual void checkVariable(const MooseVariableFieldBase & variable) const;

protected:
  const MaterialData * _blk_material_data;

  virtual bool hasBlockMaterialPropertyHelper(const std::string & prop_name);

  void initializeBlockRestrictable(const MooseObject * moose_object);

#ifdef MOOSE_KOKKOS_ENABLED
  void initializeKokkosBlockRestrictable(const Moose::Kokkos::Mesh * mesh);
#endif

  Moose::CoordinateSystemType getBlockCoordSystem();

#ifdef MOOSE_KOKKOS_SCOPE

  KOKKOS_FUNCTION dof_id_type numKokkosBlockElements() const { return _kokkos_element_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosBlockNodes() const { return _kokkos_node_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosBlockSides() const
  {
    return _kokkos_element_side_ids.size();
  }
  KOKKOS_FUNCTION ContiguousElementID kokkosBlockElementID(ThreadID tid) const
  {
    return _kokkos_element_ids[tid];
  }
  KOKKOS_FUNCTION ContiguousElementID kokkosBlockNodeID(ThreadID tid) const
  {
    return _kokkos_node_ids[tid];
  }
  KOKKOS_FUNCTION auto kokkosBlockElementSideID(ThreadID tid) const
  {
    return _kokkos_element_side_ids[tid];
  }
#endif

private:
  std::set<SubdomainID> _blk_ids;

  std::vector<SubdomainID> _vec_ids;

  std::vector<SubdomainName> _blocks;

  const bool _blk_dual_restrictable;

  FEProblemBase * _blk_feproblem;

  const MooseMesh * _blk_mesh;

  const std::set<BoundaryID> _empty_boundary_ids;

  const std::set<BoundaryID> & _boundary_ids;

  THREAD_ID _blk_tid;

  const std::string & _blk_name;

  unsigned int _blk_dim;

  const MooseObject * _moose_object;

#ifdef MOOSE_KOKKOS_ENABLED

  Moose::Kokkos::Array<ContiguousElementID> _kokkos_element_ids;
  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
BlockRestrictable::hasBlockMaterialProperty(const std::string & prop_name)
{
  mooseAssert(_blk_material_data != NULL, "MaterialData pointer is not defined");
  return hasBlockMaterialPropertyHelper(prop_name) &&
         _blk_material_data->haveGenericProperty<T, is_ad>(prop_name);
}