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	haveParameter (const std::string &name) 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. More...

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

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

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

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

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

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

const unsigned int	_n_cells
	number of axial cells More...

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

const Real	_unheated_length_entry

const Real	_heated_length

const Real	_unheated_length_exit

const unsigned int	_block_id
	block index More...

const Real	_pitch
	lattice geometry More...

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

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.

Referenced by generate().

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

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

Referenced by generate().

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

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

Referenced by generate().

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

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

Referenced by ductElems(), and ductPoints().

 {
   return layer * points_per_layer + point;
 }

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

Referenced by generate().

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

◆ 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->subdomain_name(_block_id) = name();
 
   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

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