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

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	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	mooseWarningNonPrefixed (Args &&... args) const

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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)

Public Attributes
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

Protected Member Functions
void	setNumDivisions (const unsigned int ndivs)

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

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

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

const Real	_pin_pitch
	Pitch between fuel pins. More...

const MooseEnum	_z_axis_index
	Axial component for the Z axis. More...

const Real	_min_z
	Minimal axial coordinate. More...

const Real	_max_z
	Maximal axial coordinate. More...

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

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

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

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

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

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 Point & pt ) const

overridevirtual

Implements MeshDivision.

Definition at line 121 of file HexagonalGridDivision.C.

Referenced by divisionIndex().

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

◆ divisionIndex() [2/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());
 }

◆ initialize()

void HexagonalGridDivision::initialize ( )

overridevirtual

Reimplemented from MeshDivision.

Definition at line 80 of file HexagonalGridDivision.C.

Referenced by HexagonalGridDivision().

 {
   // 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 ");
   }
 }

◆ 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

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