Mesh generator for hexagonal duct. More...

#include <SCMTriDuctMeshGenerator.h>

Inheritance diagram for SCMTriDuctMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SCMTriDuctMeshGenerator (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 flat_to_flat, const Point &center) const
	Computes the x-y corner coordinates of the duct cross-section.

void	ductCrossSec (std::vector< Point > &cross_sec, const std::vector< Point > &corners, unsigned int nrings, Real pitch) const
	Generates the points along the duct cross-section sides.

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
	unheated length of the fuel Pin at the entry of the assembly

const Real	_heated_length
	heated length of the fuel Pin

const Real	_unheated_length_exit
	unheated length of the fuel Pin at the exit of the assembly

const unsigned int	_block_id
	block index

const Real	_pitch
	Distance between the neighbor fuel pins, pitch.

const unsigned int	_n_rings
	number of rings of fuel pins

const Real	_flat_to_flat
	the distance between flat surfaces of the duct facing each other

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 hexagonal duct.

Definition at line 17 of file SCMTriDuctMeshGenerator.h.

Constructor & Destructor Documentation

◆ SCMTriDuctMeshGenerator()

SCMTriDuctMeshGenerator::SCMTriDuctMeshGenerator ( const InputParameters & parameters )

Definition at line 37 of file SCMTriDuctMeshGenerator.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")),
    _n_rings(getParam<unsigned int>("nrings")),
    _flat_to_flat(getParam<Real>("flat_to_flat"))
{
  SubChannelMesh::generateZGrid(
      _unheated_length_entry, _heated_length, _unheated_length_exit, _n_cells, _z_grid);
}

Member Function Documentation

◆ buildDuct()

void SCMTriDuctMeshGenerator::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 185 of file SCMTriDuctMeshGenerator.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 SCMTriDuctMeshGenerator::ductCorners	(	std::vector< Point > &	corners,
		Real	flat_to_flat,
		const Point &	center
	)		const

protected

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

Parameters

corners	Output vector containing the duct corner points
flat_to_flat	Flat-to-flat distance of the duct
center	Center point of the duct cross-section

Definition at line 81 of file SCMTriDuctMeshGenerator.C.

{
  corners.resize(TriSubChannelMesh::N_CORNERS);
  Real r_corner = flat_to_flat / 2. / std::cos(libMesh::pi / 6.);
  for (size_t i = 0; i < TriSubChannelMesh::N_CORNERS; i++)
  {
    Real theta = i * libMesh::pi / 3.;
    Point corner = {r_corner * std::cos(theta), r_corner * std::sin(theta)};
    corners[i] = center + corner;
  }
}

Referenced by generate().

◆ ductCrossSec()

void SCMTriDuctMeshGenerator::ductCrossSec	(	std::vector< Point > &	cross_sec,
		const std::vector< Point > &	corners,
		unsigned int	nrings,
		Real	pitch
	)		const

protected

Generates the points along the duct cross-section sides.

Parameters

cross_sec	Output vector of cross-section boundary points
corners	Corner points defining the duct geometry
nrings	Number of rings of the assembly. (Rings of pins around central pin)
pitch	Spacing between adjacent pins/subchannel centroids

Definition at line 96 of file SCMTriDuctMeshGenerator.C.

{
  cross_sec.clear();
 
  if (pitch <= 0.0)
    mooseError("The 'pitch' must be > 0.");
 
  if (nrings < 2)
    mooseError("The 'nrings' must be >= 2.");
 
  // Side length of the regular hexagon (distance between adjacent corners)
  const Real side_length = (corners[0] - corners[1]).norm();
 
  // start_offset = (hexagon_side - (nrings - 2)*pitch) / 2
  const Real start_offset = 0.5 * (side_length - (nrings - 2) * pitch);
 
  // If this is negative, the requested layout cannot fit.
  if (start_offset < 0.0)
    mooseError("SCMTriDuctMeshGenerator: computed start_offset is negative (",
               start_offset,
               "). Check 'nrings', 'pitch', and duct side length.");
 
  for (size_t i = 0; i < corners.size(); i++)
  {
    const Point left = corners[i];
    const Point right = corners[(i + 1) % corners.size()];
 
    // Always include the left corner
    cross_sec.push_back(left);
 
    // Unit direction along this side
    const Point direc = (right - left).unit();
 
    // Add exactly (nrings - 1) points after the left corner
    // at start_offset + k*pitch, k = 0..(nrings-2)
    for (const auto k : make_range(nrings - 1))
    {
      const Real offset_from_corner = start_offset + k * pitch;
      cross_sec.push_back(left + direc * offset_from_corner);
    }
  }
}

Referenced by generate().

◆ ductElems()

void SCMTriDuctMeshGenerator::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 163 of file SCMTriDuctMeshGenerator.C.

{
  elem_point_indices.clear();
  for (unsigned int i = 0; i < n_layers - 1; i++)
  {
    unsigned int bottom = i;
    unsigned int top = i + 1;
    for (unsigned int j = 0; j < points_per_layer; j++)
    {
      unsigned int left = j;
      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 SCMTriDuctMeshGenerator::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 143 of file SCMTriDuctMeshGenerator.C.

{
  return layer * points_per_layer + point;
}

Referenced by ductElems(), and ductPoints().

◆ ductPoints()

void SCMTriDuctMeshGenerator::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 151 of file SCMTriDuctMeshGenerator.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 > SCMTriDuctMeshGenerator::generate ( )

overridevirtual

Implements MeshGenerator.

Definition at line 54 of file SCMTriDuctMeshGenerator.C.

{
  std::unique_ptr<MeshBase> mesh_base = std::move(_input);
  mesh_base->set_mesh_dimension(3);
 
  std::vector<Point> corners;
  ductCorners(corners, _flat_to_flat, Point(0, 0, 0));
  std::vector<Point> cross_sec;
  ductCrossSec(cross_sec, corners, _n_rings, _pitch);
  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();
 
  auto & sch_mesh = static_cast<TriSubChannelMesh &>(*_mesh);
  sch_mesh.setChannelToDuctMaps(duct_nodes);
  sch_mesh._duct_mesh_exist = true;
 
  return mesh_base;
}

◆ validParams()

InputParameters SCMTriDuctMeshGenerator::validParams ( )

static

Definition at line 19 of file SCMTriDuctMeshGenerator.C.

{
  InputParameters params = MeshGenerator::validParams();
  params.addClassDescription(
      "Creates a mesh of 2D duct cells around a triangular lattice subassembly");
  params.addRequiredParam<MeshGeneratorName>("input", "The corresponding subchannel mesh");
  params.addParam<unsigned int>("block_id", 2, "Domain Index");
  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.addRequiredParam<Real>("pitch", "Pitch is the distance between adjacent pins [m]");
  params.addRequiredParam<unsigned int>("nrings", "Number of fuel Pin rings in the assembly [-]");
  params.addRequiredParam<Real>("flat_to_flat",
                                "Flat to flat distance for the hexagonal assembly [m]");
  return params;
}

Member Data Documentation

◆ _block_id

const unsigned int SCMTriDuctMeshGenerator::_block_id

protected

block index

Definition at line 90 of file SCMTriDuctMeshGenerator.h.

Referenced by generate().

◆ _flat_to_flat

const Real SCMTriDuctMeshGenerator::_flat_to_flat

protected

the distance between flat surfaces of the duct facing each other

Definition at line 96 of file SCMTriDuctMeshGenerator.h.

Referenced by generate().

◆ _heated_length

const Real SCMTriDuctMeshGenerator::_heated_length

protected

heated length of the fuel Pin

Definition at line 86 of file SCMTriDuctMeshGenerator.h.

Referenced by SCMTriDuctMeshGenerator().

◆ _input

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

protected

Mesh that comes from another generator.

Definition at line 78 of file SCMTriDuctMeshGenerator.h.

Referenced by generate().

◆ _n_cells

const unsigned int SCMTriDuctMeshGenerator::_n_cells

protected

number of axial cells

Definition at line 80 of file SCMTriDuctMeshGenerator.h.

Referenced by SCMTriDuctMeshGenerator().

◆ _n_rings

const unsigned int SCMTriDuctMeshGenerator::_n_rings

protected

number of rings of fuel pins

Definition at line 94 of file SCMTriDuctMeshGenerator.h.

Referenced by generate().

◆ _pitch

const Real SCMTriDuctMeshGenerator::_pitch

protected

Distance between the neighbor fuel pins, pitch.

Definition at line 92 of file SCMTriDuctMeshGenerator.h.

Referenced by generate().

◆ _unheated_length_entry

const Real SCMTriDuctMeshGenerator::_unheated_length_entry

protected

unheated length of the fuel Pin at the entry of the assembly

Definition at line 84 of file SCMTriDuctMeshGenerator.h.

Referenced by SCMTriDuctMeshGenerator().

◆ _unheated_length_exit

const Real SCMTriDuctMeshGenerator::_unheated_length_exit

protected

unheated length of the fuel Pin at the exit of the assembly

Definition at line 88 of file SCMTriDuctMeshGenerator.h.

Referenced by SCMTriDuctMeshGenerator().

◆ _z_grid

std::vector<Real> SCMTriDuctMeshGenerator::_z_grid

protected

axial location of nodes

Definition at line 82 of file SCMTriDuctMeshGenerator.h.

Referenced by generate(), and SCMTriDuctMeshGenerator().

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

subchannel/include/meshgenerators/SCMTriDuctMeshGenerator.h
subchannel/src/meshgenerators/SCMTriDuctMeshGenerator.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

◆ SCMTriDuctMeshGenerator()

Member Function Documentation

◆ buildDuct()

◆ ductCorners()

◆ ductCrossSec()

◆ ductElems()

◆ ductPointIndex()

◆ ductPoints()

◆ generate()

◆ validParams()

Member Data Documentation

◆ _block_id

◆ _flat_to_flat

◆ _heated_length

◆ _input

◆ _n_cells

◆ _n_rings

◆ _pitch

◆ _unheated_length_entry

◆ _unheated_length_exit

◆ _z_grid