Mesh generator for a square/rectangular duct around a square-lattice subassembly. More...

#include <SCMQuadDuctMeshGenerator.h>

Inheritance diagram for SCMQuadDuctMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMQuadDuctMeshGenerator (const InputParameters &parameters)

std::unique_ptr< MeshBase >	generate () override

std::unique_ptr< CSG::CSGBase >	generateInternalCSG ()

std::unique_ptr< MeshBase >	generateInternal ()

const std::set< MeshGeneratorName > &	getRequestedMeshGenerators () const

const std::set< MeshGeneratorName > &	getRequestedMeshGeneratorsForSub () const

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

const std::set< const MeshGenerator *, Comparator > &	getParentMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getChildMeshGenerators () const

const std::set< const MeshGenerator *, Comparator > &	getSubMeshGenerators () const

bool	isParentMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isChildMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	hasGenerateCSG () const

bool	isDataOnly () const

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

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 bool	hasGenerateData (const InputParameters &params)

static bool	hasGenerateCSG (const InputParameters &params)

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)

static void	setHasGenerateData (InputParameters &params)

static void	setHasGenerateCSG (InputParameters &params)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

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

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
size_t	ductPointIndex (unsigned int points_per_layer, unsigned int layer, unsigned int point) const
	Maps a duct cross-section point and axial layer to a linear point index.

void	ductCorners (std::vector< Point > &corners, Real half_x, Real half_y, const Point &center) const
	Computes the x-y corner coordinates of a rectangular duct cross-section.

void	ductCrossSec (std::vector< Point > &cross_sec, unsigned int nx, unsigned int ny, Real pitch, Real side_gap) const
	Generates the points along the rectangular duct cross-section boundary.

void	ductPoints (std::vector< Point > &points, const std::vector< Point > &cross_sec, const std::vector< Real > &z_layers) const
	Computes all 3D point locations used to construct the duct mesh.

void	ductElems (std::vector< std::vector< size_t > > &elem_point_indices, unsigned int n_layers, unsigned int points_per_layer) const
	Determines element connectivity for the duct mesh.

void	buildDuct (std::unique_ptr< MeshBase > &mesh, std::vector< Node * > &duct_nodes, const std::vector< Point > &points, const std::vector< std::vector< size_t > > &elem_point_indices, SubdomainID block) const
	Builds duct mesh nodes and elements and inserts them into the mesh.

virtual void	generateData ()

virtual std::unique_ptr< CSG::CSGBase >	generateCSG ()

T &	copyMeshProperty (const std::string &target_data_name, const std::string &source_data_name, const std::string &source_mesh)

T &	copyMeshProperty (const std::string &source_data_name, const std::string &source_mesh)

std::unique_ptr< MeshBase > &	getMesh (const std::string &param_name, const bool allow_invalid=false)

std::vector< std::unique_ptr< MeshBase > * >	getMeshes (const std::string &param_name)

std::unique_ptr< MeshBase > &	getMeshByName (const MeshGeneratorName &mesh_generator_name)

std::vector< std::unique_ptr< MeshBase > * >	getMeshesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

std::unique_ptr< CSG::CSGBase > &	getCSGBase (const std::string &param_name)

std::unique_ptr< CSG::CSGBase > &	getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBases (const std::string &param_name)

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBasesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

void	declareMeshesForSubByName (const std::vector< MeshGeneratorName > &mesh_generator_names)

std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< ReplicatedMesh >	buildReplicatedMesh (unsigned int dim=libMesh::invalid_uint)

std::unique_ptr< DistributedMesh >	buildDistributedMesh (unsigned int dim=libMesh::invalid_uint)

void	addMeshSubgenerator (const std::string &type, const std::string &name, Ts... extra_input_parameters)

void	addMeshSubgenerator (const std::string &type, const std::string &name, InputParameters params)

void	declareNullMeshName (const MeshGeneratorName &name)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

T &	declareMeshProperty (const std::string &data_name, Args &&... args)

T &	declareMeshProperty (const std::string &data_name, const T &data_value)

T &	declareMeshProperty (const std::string &data_name, Args &&... args)

T &	declareMeshProperty (const std::string &data_name, const T &data_value)

T &	setMeshProperty (const std::string &data_name, Args &&... args)

T &	setMeshProperty (const std::string &data_name, const T &data_value)

T &	setMeshProperty (const std::string &data_name, Args &&... args)

T &	setMeshProperty (const std::string &data_name, const T &data_value)

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::unique_ptr< MeshBase > &	_input
	Mesh that comes from another generator.

const unsigned int	_n_cells
	number of axial cells

std::vector< Real >	_z_grid
	axial location of nodes

const Real	_unheated_length_entry

const Real	_heated_length

const Real	_unheated_length_exit

const unsigned int	_block_id
	block index

const Real	_pitch
	lattice geometry

const unsigned int	_nx

const unsigned int	_ny

const Real	_side_gap

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

Private Member Functions
virtual std::string	meshPropertyPrefix (const std::string &) const override final

void	checkGetMesh (const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const

const MeshGeneratorName *	getMeshGeneratorNameFromParam (const std::string &param_name, const bool allow_invalid) const

const std::vector< MeshGeneratorName > &	getMeshGeneratorNamesFromParam (const std::string &param_name) const

RestartableDataValue &	setMeshPropertyHelper (const std::string &data_name)

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

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

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
std::set< MeshGeneratorName >	_requested_mesh_generators

std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub

std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > >	_requested_meshes

std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > >	_requested_csg_bases

std::unique_ptr< MeshBase >	_null_mesh

std::unique_ptr< CSG::CSGBase >	_null_csg_base

std::set< const MeshGenerator *, Comparator >	_parent_mesh_generators

std::set< const MeshGenerator *, Comparator >	_child_mesh_generators

std::set< const MeshGenerator *, Comparator >	_sub_mesh_generators

std::set< std::string >	_null_mesh_names

const std::string &	_save_with_name

const bool	_data_only

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

Detailed Description

Mesh generator for a square/rectangular duct around a square-lattice subassembly.

Definition at line 17 of file SCMQuadDuctMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMQuadDuctMeshGenerator()

SCMQuadDuctMeshGenerator::SCMQuadDuctMeshGenerator ( const InputParameters & parameters )

Definition at line 46 of file SCMQuadDuctMeshGenerator.C.

  : MeshGenerator(params),
    _input(getMesh("input")),
    _n_cells(getParam<unsigned int>("n_cells")),
    _unheated_length_entry(getParam<Real>("unheated_length_entry")),
    _heated_length(getParam<Real>("heated_length")),
    _unheated_length_exit(getParam<Real>("unheated_length_exit")),
    _block_id(getParam<unsigned int>("block_id")),
    _pitch(getParam<Real>("pitch")),
    _nx(getParam<unsigned int>("nx")),
    _ny(getParam<unsigned int>("ny")),
    _side_gap(getParam<Real>("side_gap"))
{
  SubChannelMesh::generateZGrid(
      _unheated_length_entry, _heated_length, _unheated_length_exit, _n_cells, _z_grid);
}

Member Function Documentation

◆ buildDuct()

void SCMQuadDuctMeshGenerator::buildDuct	(	std::unique_ptr< MeshBase > &	mesh,
		std::vector< Node * > &	duct_nodes,
		const std::vector< Point > &	points,
		const std::vector< std::vector< size_t > > &	elem_point_indices,
		SubdomainID	block
	)		const

protected

Builds duct mesh nodes and elements and inserts them into the mesh.

Parameters

mesh	Mesh object to which duct elements and nodes are added
duct_nodes	Output vector of created duct nodes
points	Point coordinates generated by ductPoints
elem_point_indices	Element connectivity generated by ductElems
block	Subdomain ID assigned to the duct elements

Definition at line 208 of file SCMQuadDuctMeshGenerator.C.

{
  // Create mesh nodes for all duct points and keep a local index -> Node* map
  duct_nodes.clear();
  duct_nodes.reserve(points.size());
  for (const auto & p : points)
    duct_nodes.push_back(mesh->add_point(p));
 
  // Create QUAD4 surface elements using libMesh factory style
  for (const auto & elem_indices : elem_point_indices)
  {
    mooseAssert(elem_indices.size() == 4,
                "Expected 4 node indices per element when building QUAD4 elements.");
 
    auto elem = Elem::build(ElemType::QUAD4);
    elem->subdomain_id() = block;
 
    // Set the 4 nodes of the QUAD4
    for (unsigned int i = 0; i < 4; ++i)
    {
      const auto idx = elem_indices[i];
      mooseAssert(idx < duct_nodes.size(), "Element node index out of range.");
      elem->set_node(i, duct_nodes[idx]);
    }
 
    // Hand ownership to the mesh
    mesh->add_elem(elem.release());
  }
}

Referenced by generate().

◆ ductCorners()

void SCMQuadDuctMeshGenerator::ductCorners	(	std::vector< Point > &	corners,
		Real	half_x,
		Real	half_y,
		const Point &	center
	)		const

protected

Computes the x-y corner coordinates of a rectangular duct cross-section.

Parameters

corners	Output vector containing the duct corner points
half_x	Half-width of the duct in the x-direction
half_y	Half-width of the duct in the y-direction
center	Center point of the duct cross-section

Definition at line 97 of file SCMQuadDuctMeshGenerator.C.

{
  corners.resize(4);
  corners[0] = center + Point(-half_x, -half_y, 0);
  corners[1] = center + Point(half_x, -half_y, 0);
  corners[2] = center + Point(half_x, half_y, 0);
  corners[3] = center + Point(-half_x, half_y, 0);
}

◆ ductCrossSec()

void SCMQuadDuctMeshGenerator::ductCrossSec	(	std::vector< Point > &	cross_sec,
		unsigned int	nx,
		unsigned int	ny,
		Real	pitch,
		Real	side_gap
	)		const

protected

Generates the points along the rectangular duct cross-section boundary.

Parameters

cross_sec	Output vector of cross-section boundary points
nx	Number of boundary divisions in the x-direction
ny	Number of boundary divisions in the y-direction
pitch	Spacing between adjacent boundary points
side_gap	Gap between the duct wall and surrounding geometry

Definition at line 110 of file SCMQuadDuctMeshGenerator.C.

{
  cross_sec.clear();
 
  const Real half_x = 0.5 * (nx - 1) * pitch + side_gap;
  const Real half_y = 0.5 * (ny - 1) * pitch + side_gap;
 
  // Subchannel-aligned grid extents (no side_gap)
  const Real x0 = -0.5 * (nx - 1) * pitch;
  const Real y0 = -0.5 * (ny - 1) * pitch;
 
  // ---- Bottom edge (y = -half_y): nx points, left -> right ----
  for (unsigned int i = 0; i < nx; ++i)
  {
    Real x;
    if (i == 0)
      x = -half_x;
    else if (i == nx - 1)
      x = half_x;
    else
      x = x0 + i * pitch; // aligned with subchannel x grid
 
    cross_sec.emplace_back(x, -half_y, 0.0);
  }
 
  // ---- Right edge (x = +half_x): (ny-2) points, bottom -> top (exclude corners) ----
  for (unsigned int j = 1; j + 1 < ny; ++j)
  {
    const Real y = y0 + j * pitch; // aligned with subchannel y grid
    cross_sec.emplace_back(half_x, y, 0.0);
  }
 
  // ---- Top edge (y = +half_y): nx points, right -> left ----
  for (unsigned int i = 0; i < nx; ++i)
  {
    const unsigned int ii = nx - 1 - i;
 
    Real x;
    if (ii == 0)
      x = -half_x;
    else if (ii == nx - 1)
      x = half_x;
    else
      x = x0 + ii * pitch;
 
    cross_sec.emplace_back(x, half_y, 0.0);
  }
 
  // ---- Left edge (x = -half_x): (ny-2) points, top -> bottom (exclude corners) ----
  for (unsigned int j = 1; j + 1 < ny; ++j)
  {
    const unsigned int jj = ny - 1 - j;
    const Real y = y0 + jj * pitch; // aligned with subchannel y grid
    cross_sec.emplace_back(-half_x, y, 0.0);
  }
 
  // Total points: 2*nx + 2*ny - 4
}

Referenced by generate().

◆ ductElems()

void SCMQuadDuctMeshGenerator::ductElems	(	std::vector< std::vector< size_t > > &	elem_point_indices,
		unsigned int	n_layers,
		unsigned int	points_per_layer
	)		const

protected

Determines element connectivity for the duct mesh.

Parameters

elem_point_indices	Output element connectivity defined by point indices
n_layers	Number of axial layers in the duct mesh
points_per_layer	Number of points per cross-section layer

Definition at line 186 of file SCMQuadDuctMeshGenerator.C.

{
  elem_point_indices.clear();
  for (unsigned int i = 0; i < n_layers - 1; i++)
  {
    const unsigned int bottom = i;
    const unsigned int top = i + 1;
    for (unsigned int j = 0; j < points_per_layer; j++)
    {
      const unsigned int left = j;
      const unsigned int right = (j + 1) % points_per_layer;
      elem_point_indices.push_back({ductPointIndex(points_per_layer, bottom, left),
                                    ductPointIndex(points_per_layer, bottom, right),
                                    ductPointIndex(points_per_layer, top, right),
                                    ductPointIndex(points_per_layer, top, left)});
    }
  }
}

Referenced by generate().

◆ ductPointIndex()

size_t SCMQuadDuctMeshGenerator::ductPointIndex	(	unsigned int	points_per_layer,
		unsigned int	layer,
		unsigned int	point
	)		const

protected

Maps a duct cross-section point and axial layer to a linear point index.

Parameters

points_per_layer	Number of points in each duct cross-section layer
layer	Axial (z-direction) layer index
point	Index of the point within the cross-section

Returns: Index into the flattened points vector used by ductPoints

Definition at line 89 of file SCMQuadDuctMeshGenerator.C.

{
  return layer * points_per_layer + point;
}

Referenced by ductElems(), and ductPoints().

◆ ductPoints()

void SCMQuadDuctMeshGenerator::ductPoints	(	std::vector< Point > &	points,
		const std::vector< Point > &	cross_sec,
		const std::vector< Real > &	z_layers
	)		const

protected

Computes all 3D point locations used to construct the duct mesh.

Parameters

points	Output vector of 3D point locations
cross_sec	Cross-section boundary points
z_layers	Axial (z-direction) layer coordinates

Definition at line 174 of file SCMQuadDuctMeshGenerator.C.

{
  points.resize(cross_sec.size() * z_layers.size());
  for (size_t i = 0; i < z_layers.size(); i++)
    for (size_t j = 0; j < cross_sec.size(); j++)
      points[ductPointIndex(cross_sec.size(), i, j)] =
          Point(cross_sec[j](0), cross_sec[j](1), z_layers[i]);
}

Referenced by generate().

◆ generate()

std::unique_ptr< MeshBase > SCMQuadDuctMeshGenerator::generate ( )

overridevirtual

Implements MeshGenerator.

Definition at line 64 of file SCMQuadDuctMeshGenerator.C.

{
  std::unique_ptr<MeshBase> mesh_base = std::move(_input);
  mesh_base->set_mesh_dimension(3);
 
  std::vector<Point> cross_sec;
  ductCrossSec(cross_sec, _nx, _ny, _pitch, _side_gap);
  std::vector<Point> points;
  ductPoints(points, cross_sec, _z_grid);
  std::vector<std::vector<size_t>> elem_point_indices;
  ductElems(elem_point_indices, _z_grid.size(), cross_sec.size());
  std::vector<Node *> duct_nodes;
  buildDuct(mesh_base, duct_nodes, points, elem_point_indices, _block_id);
  mesh_base->set_subdomain_name(_block_id, name(), true);
 
  mesh_base->prepare_for_use();
 
  // Mirror the Tri variant: provide mapping hooks into the subchannel mesh
  auto & sch_mesh = static_cast<QuadSubChannelMesh &>(*_mesh);
  sch_mesh.setChannelToDuctMaps(duct_nodes);
 
  return mesh_base;
}

◆ validParams()

InputParameters SCMQuadDuctMeshGenerator::validParams ( )

static

Definition at line 19 of file SCMQuadDuctMeshGenerator.C.

{
  InputParameters params = MeshGenerator::validParams();
  params.addClassDescription("Creates a mesh of 2D duct cells around a square-lattice subassembly");
  params.addRequiredParam<MeshGeneratorName>("input", "The corresponding subchannel mesh");
  params.addParam<unsigned int>("block_id", 2, "Subdomain id for the duct mesh cells");
  params.addRequiredParam<unsigned int>("n_cells", "The number of cells in the axial direction");
  params.addParam<Real>("unheated_length_entry", 0.0, "Unheated length at entry [m]");
  params.addRequiredParam<Real>("heated_length", "Heated length [m]");
  params.addParam<Real>("unheated_length_exit", 0.0, "Unheated length at exit [m]");
  params.addRangeCheckedParam<Real>("pitch", "pitch > 0", "Lattice pitch (must be positive)");
  params.addRangeCheckedParam<unsigned int>(
      "nx",
      "nx > 1",
      "Number of channels in the x direction for the subchannel assembly. Must be more than 1 to "
      "built a duct[-]");
  params.addRangeCheckedParam<unsigned int>(
      "ny",
      "ny > 1",
      "Number of channels in the y direction for the subchannel assembly. Must be more than 1 to "
      "built a duct[-]");
  params.addRequiredParam<Real>("side_gap",
                                "Gap between duct wall and outer pin lattice: distance(edge pin "
                                "center, duct wall) = pitch/2 + side_gap [m]");
  return params;
}

Member Data Documentation

◆ _block_id

const unsigned int SCMQuadDuctMeshGenerator::_block_id

protected

block index

Definition at line 91 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate().

◆ _heated_length

const Real SCMQuadDuctMeshGenerator::_heated_length

protected

Definition at line 88 of file SCMQuadDuctMeshGenerator.h.

Referenced by SCMQuadDuctMeshGenerator().

◆ _input

std::unique_ptr<MeshBase>& SCMQuadDuctMeshGenerator::_input

protected

Mesh that comes from another generator.

Definition at line 82 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate().

◆ _n_cells

const unsigned int SCMQuadDuctMeshGenerator::_n_cells

protected

number of axial cells

Definition at line 84 of file SCMQuadDuctMeshGenerator.h.

Referenced by SCMQuadDuctMeshGenerator().

◆ _nx

const unsigned int SCMQuadDuctMeshGenerator::_nx

protected

Definition at line 94 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate().

◆ _ny

const unsigned int SCMQuadDuctMeshGenerator::_ny

protected

Definition at line 95 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate().

◆ _pitch

const Real SCMQuadDuctMeshGenerator::_pitch

protected

lattice geometry

Definition at line 93 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate().

◆ _side_gap

const Real SCMQuadDuctMeshGenerator::_side_gap

protected

Definition at line 96 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate().

◆ _unheated_length_entry

const Real SCMQuadDuctMeshGenerator::_unheated_length_entry

protected

Definition at line 87 of file SCMQuadDuctMeshGenerator.h.

Referenced by SCMQuadDuctMeshGenerator().

◆ _unheated_length_exit

const Real SCMQuadDuctMeshGenerator::_unheated_length_exit

protected

Definition at line 89 of file SCMQuadDuctMeshGenerator.h.

Referenced by SCMQuadDuctMeshGenerator().

◆ _z_grid

std::vector<Real> SCMQuadDuctMeshGenerator::_z_grid

protected

axial location of nodes

Definition at line 86 of file SCMQuadDuctMeshGenerator.h.

Referenced by generate(), and SCMQuadDuctMeshGenerator().

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

subchannel/include/meshgenerators/SCMQuadDuctMeshGenerator.h
subchannel/src/meshgenerators/SCMQuadDuctMeshGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SCMQuadDuctMeshGenerator()

Member Function Documentation

◆ buildDuct()

◆ ductCorners()

◆ ductCrossSec()

◆ ductElems()

◆ ductPointIndex()

◆ ductPoints()

◆ generate()

◆ validParams()

Member Data Documentation

◆ _block_id

◆ _heated_length

◆ _input

◆ _n_cells

◆ _nx

◆ _ny

◆ _pitch

◆ _side_gap

◆ _unheated_length_entry

◆ _unheated_length_exit

◆ _z_grid