Divides the mesh based on a hexagonal grid. More...

#include <HexagonalGridDivision.h>

Inheritance diagram for HexagonalGridDivision:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	HexagonalGridDivision (const InputParameters &parameters)

virtual void	initialize () override

virtual unsigned int	divisionIndex (const Point &pt) const override

virtual unsigned int	divisionIndex (const Elem &elem) const override

unsigned int	getNumDivisions () const

bool	coversEntireMesh () const

virtual void	meshChanged () override

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

virtual void	initialSetup ()

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	subdomainSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
void	setNumDivisions (const unsigned int ndivs)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

Protected Attributes
const Point	_center
	Center of the lattice (single lattice)

const Positions *	_center_positions
	Centers of the lattices (lattices centered around positions)

const Real	_lattice_flat_to_flat
	Distance from one side to the one facing it of the lattice.

const Real	_pin_pitch
	Pitch between fuel pins.

const MooseEnum	_z_axis_index
	Axial component for the Z axis.

const Real	_min_z
	Minimal axial coordinate.

const Real	_max_z
	Maximal axial coordinate.

const unsigned int	_nr
	Number of rings in the radial direction.

const unsigned int	_nz
	Number of divisions in the Z direction.

const bool	_outside_grid_counts_as_border
	Whether to map outside the grid onto the corner.

std::unique_ptr< HexagonalLatticeUtils >	_hex_latt
	Hexagonal lattice utility object.

const FEProblemBase *const	_fe_problem

const MooseMesh &	_mesh

bool	_mesh_fully_indexed

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

FEProblemBase &	_mci_feproblem

const Parallel::Communicator &	_communicator

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
unsigned int	_num_divs

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

Detailed Description

Divides the mesh based on a hexagonal grid.

Definition at line 20 of file HexagonalGridDivision.h.

Constructor & Destructor Documentation

◆ HexagonalGridDivision()

HexagonalGridDivision::HexagonalGridDivision ( const InputParameters & parameters )

Definition at line 53 of file HexagonalGridDivision.C.

  : MeshDivision(parameters),
    _center(isParamValid("center") ? getParam<Point>("center") : Point(0, 0, 0)),
    _center_positions(
        isParamValid("center_positions")
            ? &_fe_problem->getPositionsObject(getParam<PositionsName>("center_positions"))
            : nullptr),
    _lattice_flat_to_flat(getParam<Real>("lattice_flat_to_flat")),
    _pin_pitch(getParam<Real>("pin_pitch")),
    _z_axis_index(MooseEnum("X Y Z", "Z")),
    _min_z(getParam<Real>("z_min")),
    _max_z(getParam<Real>("z_max")),
    _nr(getParam<unsigned int>("nr")),
    _nz(getParam<unsigned int>("nz")),
    _outside_grid_counts_as_border(getParam<bool>("assign_domain_outside_grid_to_border"))
{
  HexagonalGridDivision::initialize();
 
  if (!isParamValid("center") && !_center_positions)
    paramError("center", "A center must be provided, or a Positions object for the centers");
  if (_pin_pitch > _lattice_flat_to_flat)
    mooseError("lattice_flat_to_flat", "Pin pitch should be smaller than bundle pitch");
  if ((_nz > 1) && MooseUtils::absoluteFuzzyEqual(_max_z, _min_z))
    paramError("nz", "Subdivision number must be 1 if width is 0 in Z direction");
}

Member Function Documentation

◆ divisionIndex() [1/2]

unsigned int HexagonalGridDivision::divisionIndex ( const Elem & elem ) const

overridevirtual

Implements MeshDivision.

Definition at line 115 of file HexagonalGridDivision.C.

{
  return divisionIndex(elem.vertex_average());
}

◆ divisionIndex() [2/2]

unsigned int HexagonalGridDivision::divisionIndex ( const Point & pt ) const

overridevirtual

Implements MeshDivision.

Definition at line 121 of file HexagonalGridDivision.C.

{
  unsigned int offset = 0;
 
  // Get point in the coordinates of the lattice. This can involve a projection due to
  // the axis of the lattice, or simply a translation if there are lattices distributed
  // using positions
  Point pc;
  if (_center_positions)
  {
    // If dividing using positions, find the closest position and
    // look at the relative position of the point compared to that position
    const bool initial = _fe_problem->getCurrentExecuteOnFlag() == EXEC_INITIAL;
    const auto nearest_grid_center_index = _center_positions->getNearestPositionIndex(pt, initial);
    offset = nearest_grid_center_index * _hex_latt->totalPins(_nr) * _nz;
    const auto nearest_grid_center =
        _center_positions->getPosition(nearest_grid_center_index, initial);
 
    // Project in local hexagonal grid
    pc = pt - nearest_grid_center;
  }
  else
    pc = pt - _center;
 
  // Get radial division index, using the channel as the pins are 0-radius
  // The logic in get pin index requires getting the point in the plane of the pin centers
  auto ir = _hex_latt->pinIndex(pc);
  const auto n_pins = _hex_latt->nPins();
 
  if (!_outside_grid_counts_as_border)
  {
    if (ir == n_pins)
      return MooseMeshDivision::INVALID_DIVISION_INDEX;
    if (MooseUtils::absoluteFuzzyLessThan(pc(_z_axis_index), _min_z) ||
        MooseUtils::absoluteFuzzyGreaterThan(pc(_z_axis_index), _max_z))
      return MooseMeshDivision::INVALID_DIVISION_INDEX;
  }
 
  // If too far from the grid to have a valid radial index, use the closest pin
  if (ir == n_pins)
    ir = _hex_latt->closestPinIndex(pc);
 
  // Find axial index
  const auto not_found = MooseMeshDivision::INVALID_DIVISION_INDEX;
  auto iz = not_found;
  for (const auto jz : make_range(_nz + 1))
  {
    const auto border_z = _min_z + (_max_z - _min_z) * jz / _nz;
    if (jz > 0 && jz < _nz && MooseUtils::absoluteFuzzyEqual(border_z, pc(_z_axis_index)))
      mooseWarning(
          "Querying the division index for a point of a boundary between two regions in Z: " +
              Moose::stringify(pt),
          ", in local hex grid frame: ",
          Moose::stringify(pc));
    if (border_z >= pc(_z_axis_index))
    {
      iz = (jz > 0) ? jz - 1 : 0;
      break;
    }
  }
 
  // Look on the top of the grid
  if (MooseUtils::absoluteFuzzyGreaterEqual(pc(_z_axis_index), _max_z))
    iz = _nz - 1;
 
  // Handle edge case on widths
  if (iz == not_found && MooseUtils::absoluteFuzzyEqual(_max_z - _min_z, 0))
    iz = 0;
  mooseAssert(ir != not_found, "We should have found a mesh division bin radially");
  mooseAssert(iz != not_found, "We should have found a mesh division bin in Z");
 
  const auto n_radial = _hex_latt->totalPins(_nr);
  return offset + ir + iz * n_radial;
}

Referenced by divisionIndex().

◆ initialize()

void HexagonalGridDivision::initialize ( )

overridevirtual

Reimplemented from MeshDivision.

Definition at line 80 of file HexagonalGridDivision.C.

{
  // We make very large pins so they cover the entire position
  _hex_latt = std::make_unique<HexagonalLatticeUtils>(_lattice_flat_to_flat,
                                                      _pin_pitch,
                                                      _pin_pitch,
                                                      0.,
                                                      1.,
                                                      _nr,
                                                      _z_axis_index,
                                                      getParam<Real>("rotation_around_axis"));
 
  if (!_center_positions)
    setNumDivisions(_hex_latt->totalPins(_nr) * _nz);
  else
    setNumDivisions(_center_positions->getNumPositions() * _hex_latt->totalPins(_nr) * _nz);
 
  // Check that the grid is well-defined
  if (_center_positions)
  {
    const Real min_center_dist = _center_positions->getMinDistanceBetweenPositions();
    // Note that if the positions are not aligned on a hexagonal lattice themselves,
    // this bound is not sufficiently strict. The simplest example would be non-coplanar
    // points, which can be a great distance away axially but be on the same axis
    if (MooseUtils::absoluteFuzzyGreaterThan(_lattice_flat_to_flat, min_center_dist))
      mooseWarning(
          "Hexagonal grids centered on the positions are too close to each other (min distance: ",
          min_center_dist,
          "), closer than the extent of each grid (",
          _lattice_flat_to_flat,
          "). Mesh division is ill-defined ");
  }
}

Referenced by HexagonalGridDivision().

◆ validParams()

InputParameters HexagonalGridDivision::validParams ( )

static

Definition at line 20 of file HexagonalGridDivision.C.

{
  InputParameters params = MeshDivision::validParams();
  params.addClassDescription(
      "Divide the mesh along a hexagonal grid. Numbering of pin divisions increases first "
      "counterclockwise, then expanding outwards from the inner ring, then axially. "
      "Inner-numbering is within a radial ring, outer-numbering is axial divisions");
 
  params.addParam<Point>("center", "Center of the hexagonal grid");
  params.addParam<PositionsName>("center_positions", "Centers of the hexagonal grids");
 
  params.addRequiredRangeCheckedParam<Real>(
      "lattice_flat_to_flat",
      "lattice_flat_to_flat>0",
      "Distance between two (inner) opposite sides of a lattice. Also known as bundle pitch or "
      "inner flat-to-flat distance");
  params.addRequiredRangeCheckedParam<Real>("pin_pitch", "pin_pitch>0", "Distance between pins");
 
  params.addRequiredParam<Real>("z_min", "Minimal axial extent of the lattice");
  params.addRequiredParam<Real>("z_max", "Maximum axial extent of the lattice");
  params.addRequiredRangeCheckedParam<unsigned int>("nr", "nr>0", "Number of hexagonal rings");
  params.addRequiredRangeCheckedParam<unsigned int>("nz", "nz>0", "Number of divisions in Z");
  params.addParam<bool>(
      "assign_domain_outside_grid_to_border",
      false,
      "Whether to map the domain outside the grid back to the border of the grid");
  params.addParam<Real>("rotation_around_axis",
                        0.,
                        "Rotation angle to apply to the underlying hexagonal lattice (in degrees)");
 
  return params;
}

Member Data Documentation

◆ _center

const Point HexagonalGridDivision::_center

protected

Center of the lattice (single lattice)

Definition at line 33 of file HexagonalGridDivision.h.

Referenced by divisionIndex().

◆ _center_positions

const Positions* HexagonalGridDivision::_center_positions

protected

Centers of the lattices (lattices centered around positions)

Definition at line 35 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), HexagonalGridDivision(), and initialize().

◆ _hex_latt

std::unique_ptr<HexagonalLatticeUtils> HexagonalGridDivision::_hex_latt

protected

Hexagonal lattice utility object.

Definition at line 59 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), and initialize().

◆ _lattice_flat_to_flat

const Real HexagonalGridDivision::_lattice_flat_to_flat

protected

Distance from one side to the one facing it of the lattice.

Definition at line 39 of file HexagonalGridDivision.h.

Referenced by HexagonalGridDivision(), and initialize().

◆ _max_z

const Real HexagonalGridDivision::_max_z

protected

Maximal axial coordinate.

Definition at line 49 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), and HexagonalGridDivision().

◆ _min_z

const Real HexagonalGridDivision::_min_z

protected

Minimal axial coordinate.

Definition at line 47 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), and HexagonalGridDivision().

◆ _nr

const unsigned int HexagonalGridDivision::_nr

protected

Number of rings in the radial direction.

Definition at line 52 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), and initialize().

◆ _nz

const unsigned int HexagonalGridDivision::_nz

protected

Number of divisions in the Z direction.

Definition at line 54 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), HexagonalGridDivision(), and initialize().

◆ _outside_grid_counts_as_border

const bool HexagonalGridDivision::_outside_grid_counts_as_border

protected

Whether to map outside the grid onto the corner.

Definition at line 56 of file HexagonalGridDivision.h.

Referenced by divisionIndex().

◆ _pin_pitch

const Real HexagonalGridDivision::_pin_pitch

protected

Pitch between fuel pins.

Definition at line 41 of file HexagonalGridDivision.h.

Referenced by HexagonalGridDivision(), and initialize().

◆ _z_axis_index

const MooseEnum HexagonalGridDivision::_z_axis_index

protected

Axial component for the Z axis.

Definition at line 44 of file HexagonalGridDivision.h.

Referenced by divisionIndex(), and initialize().

The documentation for this class was generated from the following files:

reactor/include/meshdivisions/HexagonalGridDivision.h
reactor/src/meshdivisions/HexagonalGridDivision.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HexagonalGridDivision()

Member Function Documentation

◆ divisionIndex() [1/2]

◆ divisionIndex() [2/2]

◆ initialize()

◆ validParams()

Member Data Documentation

◆ _center

◆ _center_positions

◆ _hex_latt

◆ _lattice_flat_to_flat

◆ _max_z

◆ _min_z

◆ _nr

◆ _nz

◆ _outside_grid_counts_as_border

◆ _pin_pitch

◆ _z_axis_index