A base class for flow channels. More...

#include <FlowChannelBase.h>

Inheritance diagram for FlowChannelBase:

Public Types
enum	EConvHeatTransGeom { PIPE , ROD_BUNDLE , HEX_ROD_BUNDLE }
	Type of convective heat transfer geometry. More...

enum	EPipeType { STRAIGHT , CURVED , DOWNCOMER }
	Pipe type. More...

enum	EPipeLocation { INTERIOR , EDGE , CORNER }
	Pipe location. More...

enum	EComponentSetupStatus { CREATED , MESH_PREPARED , INITIALIZED_PRIMARY , INITIALIZED_SECONDARY , CHECKED }
	Component setup status type. More...

typedef DataFileName	DataFileParameterType

Public Member Functions
	FlowChannelBase (const InputParameters &params)

virtual void	addVariables () override

virtual void	addMooseObjects () override

virtual const Real &	getGravityAngle () const
	Gets the gravity angle for this component.

const UserObjectName &	getFluidPropertiesName () const
	Gets the name of the fluid properties user object for this component.

virtual const THM::FlowModelID &	getFlowModelID () const =0
	Gets the flow model ID.

virtual std::shared_ptr< const FlowModel >	getFlowModel () const

const FunctionName &	getAreaFunctionName () const
	Get the name of the function describing the flow channel area.

virtual FunctionName	createAreaFunctionAndGetName ()
	Creates the area function if needed and then stores the name.

EConvHeatTransGeom	getHeatTransferGeometry () const
	Gets heat transfer geometry.

EPipeLocation	getPipeLocation () const
	Gets the pipe location.

std::vector< std::string >	getHeatTransferNames () const
	Gets the names of all connected heat transfer components.

bool	getTemperatureMode () const
	Gets temperature mode flag.

unsigned int	getNumberOfHeatTransferConnections () const
	Gets the number of heat transfer connections.

std::vector< VariableName >	getHeatedPerimeterNames () const
	Gets heated perimeter names for connected heat transfers.

std::vector< VariableName >	getWallTemperatureNames () const
	Gets wall temperature names for connected heat transfers.

std::vector< MaterialPropertyName >	getWallTemperatureMatNames () const

std::vector< MaterialPropertyName >	getWallHeatFluxNames () const
	Gets wall heat flux names for connected heat transfers.

void	addHeatTransferName (const std::string &ht_name) const
	Adds the name of a heat transfer component to the flow channel's list.

std::string	getHeatTransferNamesSuffix (const std::string &ht_name) const
	Gets suffix to add to heat-transfer-related names in a heat transfer component.

std::vector< std::shared_ptr< ClosuresBase > >	getClosuresObjects () const
	Get the used closures object(s)

virtual void	buildMesh () override

unsigned int	getNodesetID () const
	Gets the 1D component nodeset ID.

const BoundaryName &	getNodesetName () const
	Gets the 1D component nodeset name.

virtual const std::vector< Connection > &	getConnections (Component1DConnection::EEndType end_type) const
	Gets the vector of connections of an end type for this component.

std::string	stringify (EComponentSetupStatus status) const
	Return a string for the setup status.

const std::string &	cname () const
	Get the component name.

Component *	parent ()

const THMMesh &	constMesh () const
	Const reference to mesh, which can be called at any point.

THMMesh &	mesh ()
	Non-const reference to THM mesh, which can only be called before the end of mesh setup.

THMProblem &	getTHMProblem () const
	Gets the THM problem.

template<typename T >
bool	hasParam (const std::string &name) const
	Test if a parameter exists in the object's input parameters.

const std::vector< std::string > &	getDependencies () const
	Returns a list of names of components that this component depends upon.

void	executeInit ()
	Wrapper function for `init()` that marks the function as being called.

void	executeInitSecondary ()
	Wrapper function for `initSecondary()` that marks the function as being called.

void	executeCheck () const
	Wrapper function for `check()` that marks the function as being called.

void	executeSetupMesh ()
	Wrapper function for `setupMesh()` that marks the function as being called.

virtual void	addRelationshipManagers (Moose::RelationshipManagerType)
	Adds relationship managers for the component.

virtual Convergence *	getNonlinearConvergence () const
	Gets the Component's nonlinear Convergence object if it has one.

template<typename T >
const T &	getComponent (const std::string &name) const
	Return a reference to a component via a parameter name.

template<typename T >
const T &	getComponentByName (const std::string &cname) const
	Return a reference to a component given its name.

template<typename T >
bool	hasComponent (const std::string &name) const
	Check the existence and type of a component via a parameter name.

template<typename T >
bool	hasComponentByName (const std::string &cname) const
	Check the existence and type of a component given its name.

void	connectObject (const InputParameters &obj_params, const std::string &obj_name, const std::string &param) const
	Connects a controllable parameter of the component to a controllable parameter of a constituent object.

void	connectObject (const InputParameters &obj_params, const std::string &obj_name, const std::string &comp_param, const std::string &obj_param) const
	Connects a controllable parameter of the component to a controllable parameter of a constituent object.

void	checkSetupStatus (const EComponentSetupStatus &status) const
	Throws an error if the supplied setup status of this component has not been reached.

void	checkComponentExistsByName (const std::string &comp_name) const
	Checks that a component exists.

template<typename T >
void	checkComponentOfTypeExists (const std::string &param) const
	Checks that the component of a certain type exists, where the name is given by a parameter.

template<typename T >
void	checkComponentOfTypeExistsByName (const std::string &comp_name) const
	Checks that the component of a certain type exists.

template<typename... Args>
void	logError (Args &&... args) const
	Logs an error.

template<typename... Args>
void	logWarning (Args &&... args) const
	Logs a warning.

void	addDependency (const std::string &dependency)
	Adds a component name to the list of dependencies.

template<typename T >
T	getEnumParam (const std::string &param, bool log_error=true) const
	Gets an enum parameter.

bool	problemIsTransient () const
	Whether the problem is transient.

const std::vector< dof_id_type > &	getNodeIDs () const
	Gets the node IDs corresponding to this component.

const std::vector< dof_id_type > &	getElementIDs () const
	Gets the element IDs corresponding to this component.

virtual const std::vector< SubdomainName > &	getSubdomainNames () const
	Gets the subdomain names for this component.

virtual const std::vector< Moose::CoordinateSystemType > &	getCoordSysTypes () const
	Gets the coordinate system types for this component.

template<typename T >
void	insistParameterExists (const std::string &function_name, const std::string &param_name) const
	Runtime check to make sure that a parameter of specified type exists in the component's input parameters.

template<typename T >
void	checkParameterValueLessThan (const std::string &param, const T &value_max) const
	Checks that a parameter value is less than a value.

template<typename T >
void	checkSizeLessThan (const std::string &param, const unsigned int &n_entries) const
	Checks that the size of a vector parameter is less than a value.

template<typename T >
void	checkSizeGreaterThan (const std::string &param, const unsigned int &n_entries) const
	Checks that the size of a vector parameter is greater than a value.

template<typename T1 , typename T2 >
void	checkEqualSize (const std::string &param1, const std::string &param2) const
	Checks that the size of two vector parameters are equal.

template<typename T >
void	checkSizeEqualsValue (const std::string &param, const unsigned int &n_entries) const
	Checks that the size of a vector parameter equals a value.

template<typename T >
void	checkSizeEqualsValue (const std::string &param, const unsigned int &n_entries, const std::string &description) const
	Checks that the size of a vector parameter equals a value.

template<typename T1 , typename T2 >
void	checkSizeEqualsParameterValue (const std::string &param1, const std::string &param2) const
	Checks that the size of a vector parameter equals the value of another parameter.

void	checkMutuallyExclusiveParameters (const std::vector< std::string > &params, bool need_one_specified=true) const
	Checks that exactly one parameter out of a list is provided.

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

template<typename... Args>
void	logComponentError (const std::string &component_name, Args &&... args) const
	Logs an error for a component.

template<typename... Args>
void	logComponentWarning (const std::string &component_name, Args &&... args) const
	Logs a warning for a component.

std::string	genName (const std::string &prefix, unsigned int id, const std::string &suffix="") const
	Build a name from a prefix, number and possible suffix.

std::string	genName (const std::string &prefix, unsigned int i, unsigned int j, const std::string &suffix="") const
	Build a name from a prefix, 2 numbers and possible suffix.

std::string	genName (const std::string &prefix, const std::string &name, unsigned int i) const
	Build a name from 2 strings and a number.

std::string	genName (const std::string &prefix, const std::string &middle, const std::string &suffix="") const
	Build a name from strings.

std::string	genSafeName (const std::string &prefix, const std::string &middle, const std::string &suffix="") const
	Build a name from strings that is safe to use in input files (i.e.

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

virtual Point	getPosition () const

Point	getStartPoint () const

Point	getEndPoint () const

virtual RealVectorValue	getDirection () const

virtual Real	getRotation () const

virtual Real	getNumElems () const

virtual Real	getLength () const

Real	getMinimumElemSize () const
	Gets the minimum element size.

Real	computeAxialCoordinate (const Point &p) const

Real	computeRadialCoordinate (const Point &p) const

unsigned int	getAxialSectionIndex (const Point &p) const

unsigned int	getAxialElementIndex (const Point &p_center) const

Point	computeRealPointFromReferencePoint (const Point &p) const
	Computes point in 3-D space from a point in reference space.

Point	computeReferencePointFromRealPoint (const Point &p) const
	Computes point in reference space from a point in 3-D space.

MooseEnum	getAlignmentAxis () const
	Gets an axis MooseEnum for the axis the component is aligned with.

std::vector< Real >	getElementBoundaryCoordinates () const
	Gets the element boundary coordinates for the aligned axis.

Real	getGravityMagnitude () const
	Gets gravity magnitude.

Static Public Member Functions
static MooseEnum	getConvHeatTransGeometry (const std::string &name)
	Gets a MooseEnum for convective heat transfer geometry type.

static MooseEnum	getPipeType (const std::string &name)
	Gets a MooseEnum for pipe type.

static MooseEnum	getPipeLocation (const std::string &name)
	Gets a MooseEnum for pipe location.

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)

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)

static Point	computeRealPointFromReferencePoint (const Point &p, const RealVectorValue &position, const RealTensorValue &R, const RealTensorValue &Rx)
	Computes point in 3-D space from a point in reference space.

static Point	computeReferencePointFromRealPoint (const Point &p, const RealVectorValue &position, const RealTensorValue &R_inv, const RealTensorValue &Rx_inv)
	Computes point in reference space from a point in 3-D space.

static MooseEnum	getAlignmentAxis (const RealVectorValue &dir)
	Gets an axis MooseEnum for the axis the component is aligned with.

static std::vector< Real >	getElementBoundaryCoordinates (const RealVectorValue &position, const RealVectorValue &orientation, const Real &rotation, const std::vector< Real > &lengths, const std::vector< unsigned int > &n_elems)
	Gets the element boundary coordinates for the aligned axis.

static RealTensorValue	computeDirectionTransformationTensor (const RealVectorValue &dir)
	Computes the direction transformation tensor.

static RealTensorValue	computeXRotationTransformationTensor (const Real &rotation)
	Computes the rotation transformation tensor.

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Real	_dx_min
	Minimum element size.

Static Public Attributes
static const std::map< std::string, EConvHeatTransGeom >	_heat_transfer_geom_to_enum
	Map of convective heat transfer geometry type to enum.

static const std::map< std::string, EPipeType >	_pipe_type_to_enum
	Map of pipe type to enum.

static const std::map< std::string, EPipeLocation >	_pipe_location_to_enum
	Map of pipe location to enum.

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
virtual std::shared_ptr< FlowModel >	buildFlowModel ()=0

virtual void	init () override
	Initializes the component.

virtual void	initSecondary () override
	Perform secondary initialization, which relies on init() being called for all components.

virtual void	check () const override
	Check the component integrity.

virtual void	addCommonObjects ()
	Adds objects which are common for single- and two-phase flow.

virtual void	getHeatTransferVariableNames ()
	Populates heat connection variable names lists.

virtual bool	usingSecondOrderMesh () const override
	Check if second order mesh is being used by this geometrical component.

std::string	sortBy () const

virtual void	setupMesh () override
	Performs mesh setup such as creating mesh or naming mesh sets.

Elem *	addElement (libMesh::ElemType elem_type, const std::vector< dof_id_type > &node_ids)

Elem *	addElementEdge2 (dof_id_type node0, dof_id_type node1)

Elem *	addElementEdge3 (dof_id_type node0, dof_id_type node1, dof_id_type node2)

Elem *	addElementQuad4 (dof_id_type node0, dof_id_type node1, dof_id_type node2, dof_id_type node3)

Elem *	addElementQuad9 (dof_id_type node0, dof_id_type node1, dof_id_type node2, dof_id_type node3, dof_id_type node4, dof_id_type node5, dof_id_type node6, dof_id_type node7, dof_id_type node8)

const FunctionName &	getVariableFn (const FunctionName &fn_param_name)
	Makes a constant function parameter controllable and returns its name.

void	addRelationshipManagersFromParameters (const InputParameters &moose_object_pars)
	Method to add a relationship manager for the objects being added to the system.

Node *	addNode (const Point &pt)

Elem *	addNodeElement (dof_id_type node)

virtual void	setSubdomainInfo (SubdomainID subdomain_id, const std::string &subdomain_name, const Moose::CoordinateSystemType &coord_system=Moose::COORD_XYZ)
	Sets the next subdomain ID, name, and coordinate system.

void	addNonlinearStepFunctorMaterial (const std::string &functor_name, const std::string &property, bool functor_is_ad)
	Adds a functor material to compute the absolute value of the change (step) of some functor between nonlinear iterations.

void	addMaximumFunctorPostprocessor (const std::string &functor_name, const std::string &pp_name, const Real normalization, const std::vector< SubdomainName > &subdomains)
	Adds a Postprocessor to compute the maximum of a functor over some domain.

void	addMultiPostprocessorConvergence (const std::vector< PostprocessorName > &postprocessors, const std::vector< std::string > &descriptions, const std::vector< Real > &tolerances)
	Adds a MultiPostprocessorConvergence for nonlinear convergence for the component.

std::string	nonlinearConvergenceName () const
	Nonlinear Convergence name.

template<typename T >
void	passParameter (const std::string &name, const std::string &new_name, InputParameters &params) const
	Passes a parameter from this object's input parameters to another set of input parameters.

template<typename T >
void	passParameter (const std::string &name, InputParameters &params) const
	Passes a parameter from this object's input parameters to another set of input parameters.

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

std::string	deduceFunctorName (const std::string &name) const

const Moose::Functor< T > &	getFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

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

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const

void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)

const Moose::Functor< T > &	getFunctorByName (const std::string &name)

Protected Attributes
std::shared_ptr< FlowModel >	_flow_model
	The flow model used by this flow channel.

const UserObjectName &	_fp_name
	Name of fluid properties user object.

const Real	_gravity_angle
	Angle between orientation vector and gravity vector, in degrees.

FunctionName	_area_function
	Function describing the flow channel area.

std::vector< std::shared_ptr< ClosuresBase > >	_closures_objects
	Closures object(s)

const bool &	_pipe_pars_transferred

const Real &	_roughness
	Roughness of flow channel surface, [m].

EConvHeatTransGeom	_HT_geometry
	Convective Heat transfer geometry.

EPipeLocation	_pipe_location
	Pipe location within the bundle.

const Real &	_PoD
	Pitch to diameter ratio for parallel bundle heat transfer.

bool	_has_PoD
	True if user provides PoD.

bool	_temperature_mode
	True if there is one or more sources specified by wall temperature.

std::vector< std::string >	_heat_transfer_names
	Names of the heat transfer components connected to this component.

unsigned int	_n_heat_transfer_connections
	Number of connected heat transfer components.

std::vector< MaterialPropertyName >	_Hw_1phase_names
	1-phase wall heat transfer coefficient names for connected heat transfers

std::vector< MaterialPropertyName >	_Hw_liquid_names
	liquid wall heat transfer coefficient names for connected heat transfers

std::vector< MaterialPropertyName >	_Hw_vapor_names
	vapor wall heat transfer coefficient names for connected heat transfers

std::vector< VariableName >	_P_hf_names
	heated perimeter names for connected heat transfers

std::vector< VariableName >	_T_wall_names
	wall temperature auxvariable names for connected heat transfers

std::vector< MaterialPropertyName >	_T_wall_mat_names
	wall temperature material names for connected heat transfers

std::vector< MaterialPropertyName >	_q_wall_names
	wall heat flux names for connected heat transfers

std::map< Component1DConnection::EEndType, std::vector< Connection > >	_connections
	Map of end type to a list of connections.

const std::vector< std::string > &	_axial_region_names
	Axial region names.

std::vector< Real >	_node_locations
	Node locations along the main axis.

Component *	_parent
	Pointer to a parent component (used in composed components)

THMProblem &	_sim
	THM problem this component is part of TODO: make _sim private (applications need to switch to getters to avoid breaking).

Factory &	_factory
	The Factory associated with the MooseApp.

const Real &	_zero

THMMesh &	_mesh
	The THM mesh TODO: make _mesh private (applications need to switch to getters to avoid breaking)

std::vector< dof_id_type >	_node_ids
	Node IDs of this component.

std::vector< dof_id_type >	_elem_ids
	Element IDs of this component.

std::vector< SubdomainID >	_subdomain_ids
	List of subdomain IDs this components owns.

std::vector< SubdomainName >	_subdomain_names
	List of subdomain names this components owns.

std::vector< Moose::CoordinateSystemType >	_coord_sys
	List of coordinate system for each subdomain.

const bool &	_enabled

MooseApp &	_app

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

Logger &	_log

const Point &	_position
	Start position of axis in 3-D space.

const RealVectorValue &	_dir_unnormalized
	Unnormalized direction of axis from start position to end position.

const RealVectorValue	_dir
	Normalized direction of axis from start position to end position.

const Real &	_rotation
	Angle of rotation about the x-axis.

std::vector< Real >	_lengths
	Length of each axial section.

Real	_length
	Total axial length.

const Point	_end_point
	End point of line segment.

std::vector< unsigned int >	_n_elems
	Number of elements in each axial section.

unsigned int	_n_elem
	Total number of axial elements.

const unsigned int	_n_sections
	Number of axial sections.

std::vector< Real >	_section_end
	Axial coordinate of the end of each axial section using the line 'position' as the origin.

std::vector< Real >	_x_centers
	Center axial coordinate of each axial element.

const RealTensorValue	_R
	Direction transformation tensor.

const RealTensorValue	_Rx
	Rotational transformation tensor about x-axis.

const RealTensorValue	_R_inv
	Inverse direction transformation tensor.

const RealTensorValue	_Rx_inv
	Inverse rotational transformation tensor about x-axis.

const std::string	_moose_object_name_dlsi
	Name of the MOOSE object.

const RealVectorValue &	_gravity_vector
	Gravitational acceleration vector.

const Real	_gravity_magnitude
	Gravitational acceleration magnitude.

const bool	_gravity_is_zero
	Gravitational acceleration magnitude is zero?

const RealVectorValue	_gravity_direction
	Gravitational acceleration unit direction.

Private Member Functions
virtual void	buildMeshNodes ()

void	generateNodeLocations ()
	Generates axial node locations and stores in `_node_locations`.

unsigned int	computeNumberOfNodes (unsigned int n_elems)
	Computes the number of axial nodes from the number of elements.

std::vector< Real >	getUniformNodeLocations (Real length, unsigned int n_nodes)
	Computes the local positions of axial nodes for an axial section.

void	placeLocalNodeLocations (Real start_length, unsigned int start_node, std::vector< Real > &local_node_locations)
	Puts local positions of axial nodes for an axial section into `_node_locations`.

void	addRelationshipManager (const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
	Method for adding a single relationship manager.

const Moose::Functor< T > *	defaultFunctor (const std::string &name)

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctorByName (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

virtual bool	isADObject () const override

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

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

static RealVectorValue	initializeDirectionVector (const RealVectorValue &dir_unnormalized)
	Computes a normalized direction vector or reports an error if the zero vector is provided.

Private Attributes
BoundaryID	_nodeset_id
	Nodeset ID for all 1D component nodes.

BoundaryName	_nodeset_name
	Nodeset name for all 1D component nodes.

EComponentSetupStatus	_component_setup_status
	Component setup status.

std::vector< std::string >	_dependencies
	List of names of components that this component depends upon.

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors

Detailed Description

A base class for flow channels.

A flow channel is defined by its position, direction, length and area.

Definition at line 22 of file FlowChannelBase.h.

Member Enumeration Documentation

◆ EComponentSetupStatus

enum Component::EComponentSetupStatus

inherited

Component setup status type.

Enumerator
CREATED	only created
MESH_PREPARED	mesh set up
INITIALIZED_PRIMARY	mesh set up, called primary init
INITIALIZED_SECONDARY	mesh set up, called both inits
CHECKED	mesh set up, called both inits, checked

Definition at line 37 of file Component.h.

  {
    CREATED,               
    MESH_PREPARED,         
    INITIALIZED_PRIMARY,   
    INITIALIZED_SECONDARY, 
    CHECKED                
  };

◆ EConvHeatTransGeom

enum FlowChannelBase::EConvHeatTransGeom

Type of convective heat transfer geometry.

Enumerator
PIPE	pipe geometry
ROD_BUNDLE	square array rod bundle geometry
HEX_ROD_BUNDLE	hexagonal array rod bundle geometry

Definition at line 28 of file FlowChannelBase.h.

  {
    PIPE,          
    ROD_BUNDLE,    
    HEX_ROD_BUNDLE 
  };

◆ EPipeLocation

enum FlowChannelBase::EPipeLocation

Pipe location.

Enumerator
INTERIOR
EDGE
CORNER

Definition at line 42 of file FlowChannelBase.h.

  {
    INTERIOR,
    EDGE,
    CORNER
  };

◆ EPipeType

enum FlowChannelBase::EPipeType

Pipe type.

Enumerator
STRAIGHT
CURVED
DOWNCOMER

Definition at line 35 of file FlowChannelBase.h.

  {
    STRAIGHT,
    CURVED,
    DOWNCOMER
  };

Constructor & Destructor Documentation

◆ FlowChannelBase()

FlowChannelBase::FlowChannelBase ( const InputParameters & params )

Definition at line 114 of file FlowChannelBase.C.

  : Component1D(params),
    GravityInterface(params),
 
    _flow_model(nullptr),
    _fp_name(getParam<UserObjectName>("fp")),
    _gravity_angle(MooseUtils::absoluteFuzzyEqual(_gravity_magnitude, 0.0)
                       ? 0.0
                       : std::acos(_dir * _gravity_vector / (_dir.norm() * _gravity_magnitude)) *
                             180 / M_PI),
    _pipe_pars_transferred(getParam<bool>("pipe_pars_transferred")),
    _roughness(getParam<Real>("roughness")),
    _HT_geometry(getEnumParam<EConvHeatTransGeom>("heat_transfer_geom")),
    _pipe_location(getEnumParam<EPipeLocation>("pipe_location")),
    _PoD(getParam<Real>("PoD")),
    _has_PoD(isParamValid("PoD")),
    _temperature_mode(false),
    _n_heat_transfer_connections(0)
{
}

Member Function Documentation

◆ addCommonObjects()

void FlowChannelBase::addCommonObjects ( )

protectedvirtual

Adds objects which are common for single- and two-phase flow.

Definition at line 239 of file FlowChannelBase.C.

{
  ExecFlagEnum ts_execute_on(MooseUtils::getDefaultExecFlagEnum());
  ts_execute_on = {EXEC_TIMESTEP_BEGIN, EXEC_INITIAL};
 
  {
    std::string class_name = "DirectionMaterial";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
    getTHMProblem().addMaterial(class_name, genName(name(), "dir_mat"), params);
  }
 
  if (!_pipe_pars_transferred)
  {
    // Area
    {
      std::string class_name = "FunctionAux";
      InputParameters params = _factory.getValidParams(class_name);
      params.set<AuxVariableName>("variable") = FlowModel::AREA_LINEAR;
      params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
      params.set<FunctionName>("function") = _area_function;
      params.set<ExecFlagEnum>("execute_on") = ts_execute_on;
      const std::string aux_kernel_name = genName(name(), "area_linear_aux");
      getTHMProblem().addAuxKernel(class_name, aux_kernel_name, params);
    }
    {
      const std::string class_name = "ProjectionAux";
      InputParameters params = _factory.getValidParams(class_name);
      params.set<AuxVariableName>("variable") = FlowModel::AREA;
      params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
      params.set<std::vector<VariableName>>("v") = {FlowModel::AREA_LINEAR};
      params.set<ExecFlagEnum>("execute_on") = ts_execute_on;
      const std::string aux_kernel_name = genName(name(), "area_aux");
      getTHMProblem().addAuxKernel(class_name, aux_kernel_name, params);
    }
  }
}

Referenced by addMooseObjects().

◆ addDependency()

void Component::addDependency ( const std::string & dependency )

inherited

Adds a component name to the list of dependencies.

Parameters

[in] dependency name of component to add to list of dependencies

Definition at line 129 of file Component.C.

{
  _dependencies.push_back(dependency);
}

Referenced by Component1DConnection::addConnection(), HeatTransferBase::HeatTransferBase(), HeatTransferFromHeatStructure3D1Phase::HeatTransferFromHeatStructure3D1Phase(), HSCoupler2D2DRadiation::HSCoupler2D2DRadiation(), HSCoupler2D3D::HSCoupler2D3D(), and Shaft::Shaft().

◆ addElement()

Elem * GeometricalComponent::addElement	(	libMesh::ElemType	elem_type,
		const std::vector< dof_id_type > &	node_ids
	)

protectedinherited

Definition at line 27 of file GeometricalComponent.C.

{
  auto elem = mesh().addElement(elem_type, node_ids);
  _elem_ids.push_back(elem->id());
  return elem;
}

Referenced by FileMeshComponent::buildMesh().

◆ addElementEdge2()

Elem * GeometricalComponent::addElementEdge2	(	dof_id_type	node0,
		dof_id_type	node1
	)

protectedinherited

Definition at line 36 of file GeometricalComponent.C.

{
  auto elem = mesh().addElementEdge2(node0, node1);
  _elem_ids.push_back(elem->id());
  return elem;
}

Referenced by Component1D::buildMesh().

◆ addElementEdge3()

Elem * GeometricalComponent::addElementEdge3	(	dof_id_type	node0,
		dof_id_type	node1,
		dof_id_type	node2
	)

protectedinherited

Definition at line 44 of file GeometricalComponent.C.

{
  auto elem = mesh().addElementEdge3(node0, node1, node2);
  _elem_ids.push_back(elem->id());
  return elem;
}

Referenced by Component1D::buildMesh().

◆ addElementQuad4()

Elem * GeometricalComponent::addElementQuad4	(	dof_id_type	node0,
		dof_id_type	node1,
		dof_id_type	node2,
		dof_id_type	node3
	)

protectedinherited

Definition at line 52 of file GeometricalComponent.C.

{
  auto elem = mesh().addElementQuad4(node0, node1, node2, node3);
  _elem_ids.push_back(elem->id());
  return elem;
}

Referenced by Component2D::build2DMesh().

◆ addElementQuad9()

Elem * GeometricalComponent::addElementQuad9	(	dof_id_type	node0,
		dof_id_type	node1,
		dof_id_type	node2,
		dof_id_type	node3,
		dof_id_type	node4,
		dof_id_type	node5,
		dof_id_type	node6,
		dof_id_type	node7,
		dof_id_type	node8
	)

protectedinherited

Definition at line 63 of file GeometricalComponent.C.

{
  auto elem = mesh().addElementQuad9(node0, node1, node2, node3, node4, node5, node6, node7, node8);
  _elem_ids.push_back(elem->id());
  return elem;
}

Referenced by Component2D::build2DMesh2ndOrder().

◆ addHeatTransferName()

void FlowChannelBase::addHeatTransferName ( const std::string & ht_name ) const

Adds the name of a heat transfer component to the flow channel's list.

This function is called from a heat transfer component to add its name to the flow channel's list, so that the flow channel can communicate with it, such as for determining variable names used in averages of heat transfer variables.

Parameters

[in] ht_name name of the heat transfer component

Definition at line 342 of file FlowChannelBase.C.

{
  _heat_transfer_names.push_back(name);
  _n_heat_transfer_connections++;
}

Referenced by HeatTransferBase::init(), and HeatTransferFromHeatStructure3D1Phase::init().

◆ addMaximumFunctorPostprocessor()

void Component::addMaximumFunctorPostprocessor	(	const std::string &	functor_name,
		const std::string &	pp_name,
		const Real	normalization,
		const std::vector< SubdomainName > &	subdomains
	)

protectedinherited

Adds a Postprocessor to compute the maximum of a functor over some domain.

Parameters

[in]	functor_name	Functor for which to compute maximum
[in]	pp_name	Name of new Postprocessor
[in]	normalization	Factor by which to divide quantity
[in]	subdomains	Subdomains over which to compute maximum

Definition at line 252 of file Component.C.

{
  const std::string class_name = "ElementExtremeFunctorValue";
  InputParameters params = _factory.getValidParams(class_name);
  params.set<std::vector<SubdomainName>>("block") = subdomains;
  params.set<MooseEnum>("value_type") = "max";
  params.set<MooseFunctorName>("functor") = functor_name;
  params.set<Real>("scale") = 1.0 / normalization;
  params.set<ExecFlagEnum>("execute_on") = EXEC_NONLINEAR_CONVERGENCE;
  params.set<std::vector<OutputName>>("outputs") = {"none"};
  getTHMProblem().addPostprocessor(class_name, pp_name, params);
}

Referenced by FlowChannel1Phase::addMooseObjects(), and HeatStructureBase::addMooseObjects().

◆ addMooseObjects()

void FlowChannelBase::addMooseObjects ( )

overridevirtual

Reimplemented from Component.

Reimplemented in FlowChannel1Phase, and FlowChannel1PhaseBase.

Definition at line 278 of file FlowChannelBase.C.

{
  addCommonObjects();
 
  ExecFlagEnum execute_on_initial_linear(MooseUtils::getDefaultExecFlagEnum());
  execute_on_initial_linear = {EXEC_INITIAL, EXEC_LINEAR};
 
  // total heat flux perimeter aux kernel
  if (_n_heat_transfer_connections > 1)
  {
    const std::string class_name = "SumAux";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<AuxVariableName>("variable") = FlowModel::HEAT_FLUX_PERIMETER;
    params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
    params.set<std::vector<VariableName>>("values") = _P_hf_names;
    params.set<ExecFlagEnum>("execute_on") = execute_on_initial_linear;
    getTHMProblem().addAuxKernel(class_name, genName(name(), "P_hf_auxkernel"), params);
  }
 
  // weighted average wall heat flux aux kernel
  if (!_temperature_mode)
  {
    if (_n_heat_transfer_connections > 1)
    {
      const std::string class_name = "ADWeightedAverageMaterial";
      InputParameters params = _factory.getValidParams(class_name);
      params.set<MaterialPropertyName>("prop_name") = FlowModel::HEAT_FLUX_WALL;
      params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
      params.set<std::vector<MaterialPropertyName>>("values") = _q_wall_names;
      params.set<std::vector<VariableName>>("weights") = _P_hf_names;
      getTHMProblem().addMaterial(
          class_name, genName(name(), FlowModel::HEAT_FLUX_WALL, "w_avg_mat"), params);
    }
    else if (_n_heat_transfer_connections == 0)
    {
      const std::string class_name = "ADConstantMaterial";
      InputParameters params = _factory.getValidParams(class_name);
      params.set<std::string>("property_name") = FlowModel::HEAT_FLUX_WALL;
      params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
      params.set<Real>("value") = 0;
      getTHMProblem().addMaterial(
          class_name, genName(name(), FlowModel::HEAT_FLUX_WALL, "zero_mat"), params);
    }
  }
 
  const auto & vpp_vars = getParam<std::vector<VariableName>>("vpp_vars");
  if (vpp_vars.size() > 0)
  {
    const std::string class_name = "ElementValueSampler";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
    params.set<std::vector<VariableName>>("variable") = vpp_vars;
    params.set<std::string>("sort_by") = sortBy();
    params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
    getTHMProblem().addVectorPostprocessor(class_name, name() + "_vars_vpp", params);
  }
 
  _flow_model->addMooseObjects();
 
  for (const auto & closures : _closures_objects)
    closures->addMooseObjectsFlowChannel(*this);
}

Referenced by FlowChannel1PhaseBase::addMooseObjects().

◆ addMultiPostprocessorConvergence()

void Component::addMultiPostprocessorConvergence	(	const std::vector< PostprocessorName > &	postprocessors,
		const std::vector< std::string > &	descriptions,
		const std::vector< Real > &	tolerances
	)

protectedinherited

Adds a MultiPostprocessorConvergence for nonlinear convergence for the component.

Parameters

[in]	postprocessors	Postprocessors to compare
[in]	descriptions	Description of each Postprocessor
[in]	tolerances	Tolerance for each check

Definition at line 269 of file Component.C.

{
  const std::string class_name = "MultiPostprocessorConvergence";
  InputParameters params = _factory.getValidParams(class_name);
  params.set<std::vector<PostprocessorName>>("postprocessors") = postprocessors;
  params.set<std::vector<std::string>>("descriptions") = descriptions;
  params.set<std::vector<Real>>("tolerances") = tolerances;
  params.set<unsigned int>("min_iterations") = 1;
  params.set<unsigned int>("max_iterations") = std::numeric_limits<unsigned int>::max();
  getTHMProblem().addConvergence(class_name, nonlinearConvergenceName(), params);
}

Referenced by FlowChannel1Phase::addMooseObjects(), and HeatStructureBase::addMooseObjects().

◆ addNode()

Node * Component::addNode ( const Point & pt )

protectedinherited

Definition at line 203 of file Component.C.

{
  auto node = mesh().addNode(pt);
  _node_ids.push_back(node->id());
  return node;
}

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), FileMeshComponent::buildMesh(), Component1D::buildMeshNodes(), ElbowPipe1Phase::buildMeshNodes(), and VolumeJunction1Phase::setupMesh().

◆ addNodeElement()

Elem * Component::addNodeElement ( dof_id_type node )

protectedinherited

Definition at line 211 of file Component.C.

{
  auto elem = mesh().addNodeElement(node);
  _elem_ids.push_back(elem->id());
  return elem;
}

Referenced by VolumeJunction1Phase::setupMesh().

◆ addNonlinearStepFunctorMaterial()

void Component::addNonlinearStepFunctorMaterial	(	const std::string &	functor_name,
		const std::string &	property,
		bool	functor_is_ad
	)

protectedinherited

Adds a functor material to compute the absolute value of the change (step) of some functor between nonlinear iterations.

Parameters

[in]	functor_name	Functor for which to compute step
[in]	property	Name of new step functor material property
[in]	functor_is_ad	Is the functor for which to compute the step AD?

Definition at line 236 of file Component.C.

{
  const std::string class_name =
      functor_is_ad ? "ADFunctorChangeFunctorMaterial" : "FunctorChangeFunctorMaterial";
  InputParameters params = _factory.getValidParams(class_name);
  params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
  params.set<MooseFunctorName>("functor") = functor_name;
  params.set<MooseEnum>("change_over") = "nonlinear";
  params.set<std::string>("prop_name") = property;
  params.set<bool>("take_absolute_value") = true;
  getTHMProblem().addFunctorMaterial(class_name, genName(name(), property + "_fmat"), params);
}

Referenced by FlowChannel1Phase::addMooseObjects(), and HeatStructureBase::addMooseObjects().

◆ addRelationshipManager()

void Component::addRelationshipManager	(	const InputParameters &	moose_object_pars,
		std::string	rm_name,
		Moose::RelationshipManagerType	rm_type,
		Moose::RelationshipManagerInputParameterCallback	rm_input_parameter_func,
		Moose::RMSystemType	sys_type = `Moose::RMSystemType::NONE`
	)

privateinherited

Method for adding a single relationship manager.

This method was copied from Action.

Parameters

moose_object_pars	The parameters of the MooseObject that requested the RM
rm_name	The class type of the RM, e.g. ElementSideNeighborLayers
rm_type	The RelationshipManagerType, e.g. geometric, algebraic, coupling
rm_input_parameter_func	The RM callback function, typically a lambda defined in the requesting MooseObject's validParams function
sys_type	A RMSystemType that can be used to limit the systems and consequent dof_maps that the RM can be attached to

Definition at line 163 of file Component.C.

{
  // These need unique names
  static unsigned int unique_object_id = 0;
 
  auto new_name = moose_object_pars.getBase() + '_' + name() + '_' + rm_name + "_" +
                  Moose::stringify(rm_type) + " " + std::to_string(unique_object_id);
 
  auto rm_params = _factory.getValidParams(rm_name);
  rm_params.set<Moose::RelationshipManagerType>("rm_type") = rm_type;
 
  rm_params.set<std::string>("for_whom") = name();
 
  // If there is a callback for setting the RM parameters let's use it
  if (rm_input_parameter_func)
    rm_input_parameter_func(moose_object_pars, rm_params);
 
  rm_params.set<MooseMesh *>("mesh") = &_mesh;
 
  if (!rm_params.areAllRequiredParamsValid())
    mooseError("Missing required parameters for RelationshipManager " + rm_name + " for object " +
               name());
 
  auto rm_obj = _factory.create<RelationshipManager>(rm_name, new_name, rm_params);
 
  const bool added = _app.addRelationshipManager(rm_obj);
 
  // Delete the resources created on behalf of the RM if it ends up not being added to the App.
  if (!added)
    _factory.releaseSharedObjects(*rm_obj);
  else // we added it
    unique_object_id++;
}

Referenced by Component::addRelationshipManagersFromParameters().

◆ addRelationshipManagers()

virtual void Component::addRelationshipManagers ( Moose::RelationshipManagerType )

inlinevirtualinherited

Adds relationship managers for the component.

Reimplemented in FileMeshPhysicsComponent.

Definition at line 111 of file Component.h.

111{}

◆ addRelationshipManagersFromParameters()

void Component::addRelationshipManagersFromParameters ( const InputParameters & moose_object_pars )

protectedinherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

This method was copied from Action.

Parameters

moose_object_pars The MooseObject to inspect for RelationshipManagers to add

Definition at line 148 of file Component.C.

{
  const auto & buildable_types = moose_object_pars.getBuildableRelationshipManagerTypes();
 
  for (const auto & buildable_type : buildable_types)
  {
    auto & rm_name = std::get<0>(buildable_type);
    auto & rm_type = std::get<1>(buildable_type);
    auto rm_input_parameter_func = std::get<2>(buildable_type);
 
    addRelationshipManager(moose_object_pars, rm_name, rm_type, rm_input_parameter_func);
  }
}

Referenced by FileMeshPhysicsComponent::addRelationshipManagers().

◆ addVariables()

void FlowChannelBase::addVariables ( )

overridevirtual

Reimplemented from Component.

Definition at line 216 of file FlowChannelBase.C.

{
  // This should be called after initSecondary() because it relies on the names
  // generated in initSecondary() of heat transfer components
  getHeatTransferVariableNames();
 
  _flow_model->addVariables();
 
  // total heat flux perimeter
  if (_n_heat_transfer_connections > 1 && !_app.isRestarting())
  {
    const std::string class_name = "SumIC";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<VariableName>("variable") = FlowModel::HEAT_FLUX_PERIMETER;
    params.set<std::vector<SubdomainName>>("block") = getSubdomainNames();
    params.set<std::vector<VariableName>>("values") = _P_hf_names;
    getTHMProblem().addSimInitialCondition(class_name, genName(name(), "P_hf_ic"), params);
  }
 
  _flow_model->addInitialConditions();
}

◆ buildFlowModel()

virtual std::shared_ptr< FlowModel > FlowChannelBase::buildFlowModel ( )

protectedpure virtual

Implemented in FlowChannel1PhaseBase.

Referenced by init().

◆ buildMesh()

void Component1D::buildMesh ( )

overridevirtualinherited

Implements GeneratedMeshComponent.

Definition at line 34 of file Component1D.C.

{
  buildMeshNodes();
 
  MeshBase & the_mesh = mesh().getMesh();
  BoundaryInfo & boundary_info = the_mesh.get_boundary_info();
 
  // create nodeset for all nodes for this component
  _nodeset_id = mesh().getNextBoundaryId();
  _nodeset_name = name();
  boundary_info.nodeset_name(_nodeset_id) = _nodeset_name;
 
  // Check that the number of nodes is consistent with the number of nodes in case component
  // developers screw up (typically in buildMeshNodes() call)
  if (usingSecondOrderMesh())
  {
    if (_node_ids.size() != (2 * _n_elem + 1))
      mooseError(name(),
                 ": Inconsistent number of nodes and elements. You have ",
                 _n_elem,
                 " elements and ",
                 _node_ids.size(),
                 " nodes.");
  }
  else
  {
    if (_node_ids.size() != _n_elem + 1)
      mooseError(name(),
                 ": Inconsistent number of nodes and elements. You have ",
                 _n_elem,
                 " elements and ",
                 _node_ids.size(),
                 " nodes.");
  }
 
  for (auto & node_id : _node_ids)
  {
    const Node * nd = the_mesh.node_ptr(node_id);
    boundary_info.add_node(nd, _nodeset_id);
  }
 
  // elems
  BoundaryID bc_id_inlet = mesh().getNextBoundaryId();
  BoundaryID bc_id_outlet = mesh().getNextBoundaryId();
  auto & binfo = mesh().getMesh().get_boundary_info();
  for (unsigned int i = 0; i < _n_elem; i++)
  {
    Elem * elem = nullptr;
    if (usingSecondOrderMesh())
      elem = addElementEdge3(_node_ids[2 * i], _node_ids[2 * i + 2], _node_ids[2 * i + 1]);
    else
      elem = addElementEdge2(_node_ids[i], _node_ids[i + 1]);
 
    // BCs
    if (i == 0)
    {
      Point pt = _position;
      _connections[Component1DConnection::IN].push_back(Connection(pt, elem, 0, bc_id_inlet, -1));
      boundary_info.add_side(elem, 0, bc_id_inlet);
      binfo.sideset_name(bc_id_inlet) = genName(name(), "in");
    }
    if (i == (_n_elem - 1))
    {
      Point pt = _position + _length * _dir;
      _connections[Component1DConnection::OUT].push_back(Connection(pt, elem, 1, bc_id_outlet, 1));
      boundary_info.add_side(elem, 1, bc_id_outlet);
      binfo.sideset_name(bc_id_outlet) = genName(name(), "out");
    }
  }
 
  if (_axial_region_names.size() > 0)
  {
    unsigned int k = 0;
    for (unsigned int i = 0; i < _axial_region_names.size(); i++)
    {
      const std::string & region_name = _axial_region_names[i];
      SubdomainID subdomain_id = mesh().getNextSubdomainId();
      setSubdomainInfo(subdomain_id, genName(name(), region_name));
 
      for (unsigned int j = 0; j < _n_elems[i]; j++, k++)
      {
        dof_id_type elem_id = _elem_ids[k];
        mesh().elemPtr(elem_id)->subdomain_id() = subdomain_id;
      }
    }
  }
  else
  {
    SubdomainID subdomain_id = mesh().getNextSubdomainId();
    setSubdomainInfo(subdomain_id, name());
 
    for (auto && id : _elem_ids)
      mesh().elemPtr(id)->subdomain_id() = subdomain_id;
  }
 
  // Update the mesh
  mesh().update();
}

◆ buildMeshNodes()

void Component1D::buildMeshNodes ( )

privatevirtualinherited

Reimplemented in ElbowPipe1Phase.

Definition at line 23 of file Component1D.C.

{
  Point p(0, 0, 0);
  for (unsigned int i = 0; i < _node_locations.size(); i++)
  {
    p(0) = _node_locations[i];
    addNode(p);
  }
}

Referenced by Component1D::buildMesh().

◆ check()

void FlowChannelBase::check ( ) const

overrideprotectedvirtual

Check the component integrity.

Reimplemented from GeneratedMeshComponent.

Reimplemented in FlowChannel1Phase, and FlowChannel1PhaseBase.

Definition at line 196 of file FlowChannelBase.C.

{
  Component1D::check();
 
  for (const auto & closures : _closures_objects)
    closures->checkFlowChannel(*this);
 
  // check types of heat transfer for all sources; must be all of same type
  if (_temperature_mode)
    for (unsigned int i = 0; i < _heat_transfer_names.size(); i++)
    {
      const HeatTransferBase & heat_transfer =
          getComponentByName<HeatTransferBase>(_heat_transfer_names[i]);
      if (!heat_transfer.isTemperatureType())
        logError("Heat sources for a flow channel must be all of temperature type or all of heat "
                 "flux type");
    }
}

Referenced by FlowChannel1PhaseBase::check().

◆ checkComponentExistsByName()

void Component::checkComponentExistsByName ( const std::string & comp_name ) const

inherited

Checks that a component exists.

Parameters

[in] comp_name name of the component

Definition at line 141 of file Component.C.

{
  if (!_sim.hasComponent(comp_name))
    logError("The component '", comp_name, "' does not exist");
}

◆ checkComponentOfTypeExists()

template<typename T >

void Component::checkComponentOfTypeExists ( const std::string & param ) const

inherited

Checks that the component of a certain type exists, where the name is given by a parameter.

Template Parameters

T	enforced type of component

Parameters

[in] param parameter name for component name

Definition at line 636 of file Component.h.

{
  insistParameterExists<std::string>(__FUNCTION__, param);
 
  const std::string & comp_name = getParam<std::string>(param);
  checkComponentOfTypeExistsByName<T>(comp_name);
}

◆ checkComponentOfTypeExistsByName()

template<typename T >

void Component::checkComponentOfTypeExistsByName ( const std::string & comp_name ) const

inherited

Checks that the component of a certain type exists.

Template Parameters

T	enforced type of component

Parameters

[in] comp_name component name

Definition at line 646 of file Component.h.

{
  if (!_sim.hasComponentOfType<T>(comp_name))
  {
    if (_sim.hasComponent(comp_name))
      logError("The component '", comp_name, "' is not of type '", demangle(typeid(T).name()), "'");
    else
      logError("The component '", comp_name, "' does not exist");
  }
}

◆ checkEqualSize()

template<typename T1 , typename T2 >

void Component::checkEqualSize	(	const std::string &	param1,
		const std::string &	param2
	)		const

inherited

Checks that the size of two vector parameters are equal.

Template Parameters

T1	type of element in the first vector parameter
T2	type of element in the second vector parameter

Parameters

[in]	param1	first parameter name
[in]	param2	second parameter name

Definition at line 702 of file Component.h.

{
  insistParameterExists<std::vector<T1>>(__FUNCTION__, param1);
  insistParameterExists<std::vector<T2>>(__FUNCTION__, param2);
 
  const auto & value1 = getParam<std::vector<T1>>(param1);
  const auto & value2 = getParam<std::vector<T2>>(param2);
  if (value1.size() != value2.size())
    logError("The number of entries in parameter '",
             param1,
             "' (",
             value1.size(),
             ") must equal the number of entries of parameter '",
             param2,
             "' (",
             value2.size(),
             ")");
}

◆ checkMutuallyExclusiveParameters()

void Component::checkMutuallyExclusiveParameters	(	const std::vector< std::string > &	params,
		bool	need_one_specified = `true`
	)		const

inherited

Checks that exactly one parameter out of a list is provided.

Parameters

[in]	params	vector of parameter names
[in]	need_one_specified	Need one of the parameters specified?

Definition at line 284 of file Component.C.

{
  unsigned int n_provided_params = 0;
  for (const auto & param : params)
    if (isParamValid(param))
      n_provided_params++;
 
  if (n_provided_params != 1)
  {
    std::string params_list_string = "{'" + params[0] + "'";
    for (unsigned int i = 1; i < params.size(); ++i)
      params_list_string += ", '" + params[i] + "'";
    params_list_string += "}";
 
    if (n_provided_params == 0 && need_one_specified)
      logError("One of the parameters ", params_list_string, " must be provided");
 
    if (n_provided_params != 0)
      logError("Only one of the parameters ", params_list_string, " can be provided");
  }
}

◆ checkParameterValueLessThan()

template<typename T >

void Component::checkParameterValueLessThan	(	const std::string &	param,
		const T &	value_max
	)		const

inherited

Checks that a parameter value is less than a value.

Template Parameters

T	type of parameter

Parameters

[in]	param	parameter name
[in]	value_max	value which parameter value must be less than

Definition at line 659 of file Component.h.

{
  insistParameterExists<T>(__FUNCTION__, param);
 
  const auto & value = getParam<T>(param);
  if (value >= value_max)
    logError("The value of parameter '", param, "' (", value, ") must be less than ", value_max);
}

◆ checkSetupStatus()

void Component::checkSetupStatus ( const EComponentSetupStatus & status ) const

inherited

Throws an error if the supplied setup status of this component has not been reached.

This is useful for getter functions that rely on data initialized after the constructor; if an error is not thrown, then uninitialized data could be returned from these functions.

Parameters

[in] status Setup status that this component must have reached

Definition at line 117 of file Component.C.

{
  if (_component_setup_status < status)
    mooseError(name(),
               ": The component setup status (",
               stringify(_component_setup_status),
               ") is less than the required status (",
               stringify(status),
               ")");
}

Referenced by getAreaFunctionName(), Component2D::getBoundaryArea(), Component2D::getBoundaryInfo(), FileMeshComponent::getBoundaryInfo(), Component2D::getBoundaryInfo(), Component1DConnection::getBoundaryNames(), Component1D::getConnections(), Component::getCoordSysTypes(), Component::getElementIDs(), Component2D::getExternalBoundaryName(), Component2D::getExternalBoundaryType(), getFlowModel(), FlowBoundary::getFluidPropertiesName(), FlowJunction::getFluidPropertiesName(), HeatTransferBase::getFluidPropertiesName(), HeatTransferBase::getHeatedPerimeterName(), getHeatTransferNames(), getHeatTransferNamesSuffix(), Component::getNodeIDs(), Component1DConnection::getNodeIDs(), Component1D::getNodesetID(), Component1D::getNodesetName(), Component::getSubdomainNames(), HeatTransfer1PhaseBase::getWallHeatTransferCoefficient1PhaseName(), HeatTransferBase::getWallTemperatureMatName(), HeatTransferBase::getWallTemperatureName(), Component2D::hasBoundary(), FileMeshComponent::hasBoundary(), Component2D::hasExternalBoundary(), and HeatStructureFromFile3D::hasRegion().

◆ checkSizeEqualsParameterValue()

template<typename T1 , typename T2 >

void Component::checkSizeEqualsParameterValue	(	const std::string &	param1,
		const std::string &	param2
	)		const

inherited

Checks that the size of a vector parameter equals the value of another parameter.

Template Parameters

T1	type of element in the vector parameter
T2	type of the parameter whose value is compared to size

Parameters

[in]	param1	vector parameter name
[in]	param2	name of parameter whose value is compared to size

Definition at line 760 of file Component.h.

{
  insistParameterExists<std::vector<T1>>(__FUNCTION__, param1);
  insistParameterExists<T2>(__FUNCTION__, param2);
 
  const auto & value1 = getParam<std::vector<T1>>(param1);
  const auto & value2 = getParam<T2>(param2);
  if (value1.size() != value2)
    logError("The number of entries in parameter '",
             param1,
             "' (",
             value1.size(),
             ") must be equal to the value of parameter '",
             param2,
             "' (",
             value2,
             ")");
}

◆ checkSizeEqualsValue() [1/2]

template<typename T >

void Component::checkSizeEqualsValue	(	const std::string &	param,
		const unsigned int &	n_entries
	)		const

inherited

Checks that the size of a vector parameter equals a value.

This version does not supply a description to the value.

Template Parameters

T	type of element in the vector parameter

Parameters

[in]	param	parameter name
[in]	n_entries	value which parameter size must be equal to

Definition at line 723 of file Component.h.

{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);
 
  const auto & param_value = getParam<std::vector<T>>(param);
  if (param_value.size() != n_entries)
    logError("The number of entries in parameter '",
             param,
             "' (",
             param_value.size(),
             ") must be equal to ",
             n_entries);
}

◆ checkSizeEqualsValue() [2/2]

template<typename T >

void Component::checkSizeEqualsValue	(	const std::string &	param,
		const unsigned int &	n_entries,
		const std::string &	description
	)		const

inherited

Checks that the size of a vector parameter equals a value.

This version supplies a description to the value.

Template Parameters

T	type of element in the vector parameter

Parameters

[in]	param	parameter name
[in]	n_entries	value which parameter size must be equal to
[in]	description	description of the value that size must be equal to

Definition at line 739 of file Component.h.

{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);
 
  const auto & param_value = getParam<std::vector<T>>(param);
  if (param_value.size() != n_entries)
    logError("The number of entries in parameter '",
             param,
             "' (",
             param_value.size(),
             ") must be equal to ",
             description,
             " (",
             n_entries,
             ")");
}

◆ checkSizeGreaterThan()

template<typename T >

void Component::checkSizeGreaterThan	(	const std::string &	param,
		const unsigned int &	n_entries
	)		const

inherited

Checks that the size of a vector parameter is greater than a value.

Template Parameters

T	type of element in the vector parameter

Parameters

[in]	param	parameter name
[in]	n_entries	value which parameter size must be greater than

Definition at line 686 of file Component.h.

{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);
 
  const auto & value = getParam<std::vector<T>>(param);
  if (value.size() <= n_entries)
    logError("The number of entries in the parameter '",
             param,
             "' (",
             value.size(),
             ") must be greater than ",
             n_entries);
}

◆ checkSizeLessThan()

template<typename T >

void Component::checkSizeLessThan	(	const std::string &	param,
		const unsigned int &	n_entries
	)		const

inherited

Checks that the size of a vector parameter is less than a value.

Template Parameters

T	type of element in the vector parameter

Parameters

[in]	param	parameter name
[in]	n_entries	value which parameter size must be less than

Definition at line 670 of file Component.h.

{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);
 
  const auto & value = getParam<std::vector<T>>(param);
  if (value.size() >= n_entries)
    logError("The number of entries in the parameter '",
             param,
             "' (",
             value.size(),
             ") must be less than ",
             n_entries);
}

◆ cname()

const std::string & Component::cname ( ) const

inherited

Get the component name.

Returns: The name of the component. For composite component, return its parent name

Definition at line 51 of file Component.C.

{
  if (_parent)
    return _parent->cname();
  else
    return name();
}

Referenced by ShaftConnectedCompressor1Phase::buildVolumeJunctionUserObject(), ShaftConnectedPump1Phase::buildVolumeJunctionUserObject(), ShaftConnectedTurbine1Phase::buildVolumeJunctionUserObject(), Closures1PhaseSimple::checkFlowChannel(), Closures1PhaseSimple::checkHeatTransfer(), Component::cname(), Component::logError(), and Component::logWarning().

◆ computeAxialCoordinate()

Real DiscreteLineSegmentInterface::computeAxialCoordinate ( const Point & p ) const

inherited

Definition at line 110 of file DiscreteLineSegmentInterface.C.

{
  const Real ax_coord = _dir * (p - _position);
  if (MooseUtils::absoluteFuzzyLessThan(ax_coord, 0.0) ||
      MooseUtils::absoluteFuzzyGreaterThan(ax_coord, _length))
    mooseError(_moose_object_name_dlsi,
               ": The point ",
               p,
               " has an invalid axial coordinate (",
               ax_coord,
               "). Valid axial coordinates are in the range (0,",
               _length,
               ").");
  else
    return ax_coord;
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue(), DiscreteLineSegmentInterface::getAxialElementIndex(), and DiscreteLineSegmentInterface::getAxialSectionIndex().

◆ computeDirectionTransformationTensor()

RealTensorValue DiscreteLineSegmentInterface::computeDirectionTransformationTensor ( const RealVectorValue & dir )

staticinherited

Computes the direction transformation tensor.

Parameters

[in] dir Direction vector

Definition at line 85 of file DiscreteLineSegmentInterface.C.

{
  if (MooseUtils::absoluteFuzzyEqual(dir.norm(), 0.0))
    mooseError("The direction vector must not be the zero vector.");
 
  const auto dir_normalized = dir / dir.norm();
  const Real theta = acos(dir_normalized(2));
  const Real aphi = atan2(dir_normalized(1), dir_normalized(0));
  return RealTensorValue(
      RealVectorValue(cos(aphi) * sin(theta), -sin(aphi), -cos(aphi) * cos(theta)),
      RealVectorValue(sin(aphi) * sin(theta), cos(aphi), -sin(aphi) * cos(theta)),
      RealVectorValue(cos(theta), 0.0, sin(theta)));
}

Referenced by DiscreteLineSegmentInterface::getElementBoundaryCoordinates().

◆ computeNumberOfNodes()

unsigned int GeneratedMeshComponent::computeNumberOfNodes ( unsigned int n_elems )

privateinherited

Computes the number of axial nodes from the number of elements.

Parameters

[in] n_elems The number of axial elements

Definition at line 71 of file GeneratedMeshComponent.C.

{
  return usingSecondOrderMesh() ? (2 * n_elems) + 1 : n_elems + 1;
}

Referenced by GeneratedMeshComponent::generateNodeLocations().

◆ computeRadialCoordinate()

Real DiscreteLineSegmentInterface::computeRadialCoordinate ( const Point & p ) const

inherited

Definition at line 128 of file DiscreteLineSegmentInterface.C.

{
  const RealVectorValue v = (p - _position);
  return v.cross(_dir).norm();
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

◆ computeRealPointFromReferencePoint() [1/2]

Point DiscreteLineSegmentInterface::computeRealPointFromReferencePoint ( const Point & p ) const

inherited

Computes point in 3-D space from a point in reference space.

Parameters

[in] p Point in reference space

Definition at line 166 of file DiscreteLineSegmentInterface.C.

{
  return computeRealPointFromReferencePoint(p, _position, _R, _Rx);
}

Referenced by DiscreteLineSegmentInterface::computeRealPointFromReferencePoint(), DiscreteLineSegmentInterface::getElementBoundaryCoordinates(), and GeneratedMeshComponent::setupMesh().

◆ computeRealPointFromReferencePoint() [2/2]

Point DiscreteLineSegmentInterface::computeRealPointFromReferencePoint	(	const Point &	p,
		const RealVectorValue &	position,
		const RealTensorValue &	R,
		const RealTensorValue &	Rx
	)

staticinherited

Computes point in 3-D space from a point in reference space.

Parameters

[in] p Point in reference space

Definition at line 157 of file DiscreteLineSegmentInterface.C.

{
  return R * (Rx * p) + position;
}

◆ computeReferencePointFromRealPoint() [1/2]

Point DiscreteLineSegmentInterface::computeReferencePointFromRealPoint ( const Point & p ) const

inherited

Computes point in reference space from a point in 3-D space.

Parameters

[in] p Point in 3-D space

Definition at line 181 of file DiscreteLineSegmentInterface.C.

{
  return computeReferencePointFromRealPoint(p, _position, _R_inv, _Rx_inv);
}

Referenced by DiscreteLineSegmentInterface::computeReferencePointFromRealPoint().

◆ computeReferencePointFromRealPoint() [2/2]

Point DiscreteLineSegmentInterface::computeReferencePointFromRealPoint	(	const Point &	p,
		const RealVectorValue &	position,
		const RealTensorValue &	R_inv,
		const RealTensorValue &	Rx_inv
	)

staticinherited

Computes point in reference space from a point in 3-D space.

Parameters

[in] p Point in 3-D space

Definition at line 172 of file DiscreteLineSegmentInterface.C.

{
  return Rx_inv * R_inv * (p - position);
}

◆ computeXRotationTransformationTensor()

RealTensorValue DiscreteLineSegmentInterface::computeXRotationTransformationTensor ( const Real & rotation )

staticinherited

Computes the rotation transformation tensor.

Parameters

[in] rotation Rotation about the x-axis, in degrees

Definition at line 100 of file DiscreteLineSegmentInterface.C.

{
  const Real rotation_rad = M_PI * rotation / 180.;
  const RealVectorValue Rx_x(1., 0., 0.);
  const RealVectorValue Rx_y(0., cos(rotation_rad), -sin(rotation_rad));
  const RealVectorValue Rx_z(0., sin(rotation_rad), cos(rotation_rad));
  return RealTensorValue(Rx_x, Rx_y, Rx_z);
}

Referenced by DiscreteLineSegmentInterface::getElementBoundaryCoordinates().

◆ connectObject() [1/2]

void Component::connectObject	(	const InputParameters &	obj_params,
		const std::string &	obj_name,
		const std::string &	comp_param,
		const std::string &	obj_param
	)		const

inherited

Connects a controllable parameter of the component to a controllable parameter of a constituent object.

This is achieved by creating a "controllable parameter alias".

Parameters

[in]	obj_params	Constituent object input parameters object
[in]	obj_name	Constituent object name
[in]	comp_param	Controllable component parameter
[in]	obj_param	Constituent object parameter

Definition at line 106 of file Component.C.

{
  MooseObjectParameterName alias("component", this->name(), comp_param, "::");
  MooseObjectParameterName obj_controlled_param(obj_params.getBase(), obj_name, obj_param);
  _app.getInputParameterWarehouse().addControllableParameterAlias(alias, obj_controlled_param);
}

◆ connectObject() [2/2]

void Component::connectObject	(	const InputParameters &	obj_params,
		const std::string &	obj_name,
		const std::string &	param
	)		const

inherited

Connects a controllable parameter of the component to a controllable parameter of a constituent object.

This version assumes that the component and object have the same control parameter name.

Parameters

[in]	obj_params	Constituent object input parameters object
[in]	obj_name	Constituent object name
[in]	param	Controllable parameter name (same in both component and constituent object)

Definition at line 98 of file Component.C.

{
  connectObject(obj_params, obj_name, param, param);
}

Referenced by GateValve1Phase::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), InletDensityVelocity1Phase::addMooseObjects(), InletMassFlowRateTemperature1Phase::addMooseObjects(), InletStagnationPressureTemperature1Phase::addMooseObjects(), InletVelocityTemperature1Phase::addMooseObjects(), Outlet1Phase::addMooseObjects(), SimpleTurbine1Phase::addMooseObjects(), TotalPower::addMooseObjects(), Closures1PhaseTHM::addWallFFMaterial(), VolumeJunction1Phase::buildVolumeJunctionUserObject(), JunctionParallelChannels1Phase::buildVolumeJunctionUserObject(), Pump1Phase::buildVolumeJunctionUserObject(), ShaftConnectedCompressor1Phase::buildVolumeJunctionUserObject(), ShaftConnectedPump1Phase::buildVolumeJunctionUserObject(), ShaftConnectedTurbine1Phase::buildVolumeJunctionUserObject(), SimpleTurbine1Phase::buildVolumeJunctionUserObject(), Component::connectObject(), FlowModel::getVariableFn(), and GeometricalComponent::getVariableFn().

◆ constMesh()

const THMMesh & Component::constMesh ( ) const

inlineinherited

Const reference to mesh, which can be called at any point.

Note that overloading mesh() was not possible due to the need to call this const version, even when the component is not const.

Definition at line 63 of file Component.h.

63{ return _mesh; }

Referenced by FileMeshPhysicsComponent::getMesh(), and Component1DJunction::initSecondary().

◆ createAreaFunctionAndGetName()

FunctionName FlowChannelBase::createAreaFunctionAndGetName ( )

virtual

Creates the area function if needed and then stores the name.

Definition at line 152 of file FlowChannelBase.C.

{
  // Area function has already been created; just need to return its name
  return getParam<FunctionName>("A");
}

Referenced by init().

◆ executeCheck()

void Component::executeCheck ( ) const

inherited

Wrapper function for check() that marks the function as being called.

Definition at line 84 of file Component.C.

{
  check();
  _component_setup_status = CHECKED;
}

Referenced by Simulation::integrityCheck().

◆ executeInit()

void Component::executeInit ( )

inherited

Wrapper function for init() that marks the function as being called.

Definition at line 70 of file Component.C.

{
  init();
  _component_setup_status = INITIALIZED_PRIMARY;
}

◆ executeInitSecondary()

void Component::executeInitSecondary ( )

inherited

Wrapper function for initSecondary() that marks the function as being called.

Definition at line 77 of file Component.C.

{
  initSecondary();
  _component_setup_status = INITIALIZED_SECONDARY;
}

◆ executeSetupMesh()

void Component::executeSetupMesh ( )

inherited

Wrapper function for setupMesh() that marks the function as being called.

Definition at line 91 of file Component.C.

{
  setupMesh();
  _component_setup_status = MESH_PREPARED;
}

◆ generateNodeLocations()

void GeneratedMeshComponent::generateNodeLocations ( )

privateinherited

Generates axial node locations and stores in _node_locations.

Definition at line 77 of file GeneratedMeshComponent.C.

{
  unsigned int n_nodes = computeNumberOfNodes(_n_elem);
  unsigned int start_node = 0;
  Real start_length = 0.0;
  _node_locations = std::vector<Real>(n_nodes);
  _node_locations[0] = start_length;
 
  for (unsigned int i = 0; i < _n_sections; ++i)
  {
    Real section_length = _lengths[i];
    Real section_n_elems = _n_elems[i];
    Real section_n_nodes = computeNumberOfNodes(section_n_elems);
 
    std::vector<Real> section_node_array = getUniformNodeLocations(section_length, section_n_nodes);
    placeLocalNodeLocations(start_length, start_node, section_node_array);
 
    start_length += section_length;
    start_node += (section_n_nodes - 1);
  }
}

Referenced by GeneratedMeshComponent::setupMesh().

◆ genName() [1/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		const std::string &	middle,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from strings.

Definition at line 66 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << middle;
    if (!suffix.empty())
      ss << ":" << suffix;
    return ss.str();
  }

◆ genName() [2/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		const std::string &	name,
		unsigned int	i
	)		const

inlineinherited

Build a name from 2 strings and a number.

Definition at line 56 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << name << ":" << i;
    return ss.str();
  }

◆ genName() [3/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		unsigned int	i,
		unsigned int	j,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from a prefix, 2 numbers and possible suffix.

Definition at line 41 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << i << ":" << j;
    if (!suffix.empty())
      ss << ":" << suffix;
    return ss.str();
  }

◆ genName() [4/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		unsigned int	id,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from a prefix, number and possible suffix.

Definition at line 29 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << id;
    if (!suffix.empty())
      ss << ":" << suffix;
    return ss.str();
  }

◆ genSafeName()

std::string NamingInterface::genSafeName	(	const std::string &	prefix,
		const std::string &	middle,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from strings that is safe to use in input files (i.e.

can be exposed to users)

Definition at line 80 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << "_" << middle;
    if (!suffix.empty())
      ss << "_" << suffix;
    return ss.str();
  }

Referenced by HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryExternalAppHeatFlux::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), and HSBoundaryRadiation::addMooseObjects().

◆ getAlignmentAxis() [1/2]

MooseEnum DiscreteLineSegmentInterface::getAlignmentAxis ( ) const

inherited

Gets an axis MooseEnum for the axis the component is aligned with.

If the axis does not align with the x, y, or z axis, then an invalid MooseEnum is returned.

Definition at line 201 of file DiscreteLineSegmentInterface.C.

{
  return getAlignmentAxis(_dir);
}

Referenced by CoupledHeatTransferAction::addUserObjects(), CoupledHeatTransferAction::CoupledHeatTransferAction(), DiscreteLineSegmentInterface::getAlignmentAxis(), and DiscreteLineSegmentInterface::getElementBoundaryCoordinates().

◆ getAlignmentAxis() [2/2]

MooseEnum DiscreteLineSegmentInterface::getAlignmentAxis ( const RealVectorValue & dir )

staticinherited

Gets an axis MooseEnum for the axis the component is aligned with.

If the axis does not align with the x, y, or z axis, then an invalid MooseEnum is returned.

Definition at line 187 of file DiscreteLineSegmentInterface.C.

{
  MooseEnum axis("x y z");
  if (THM::areParallelVectors(dir, RealVectorValue(1, 0, 0)))
    axis = "x";
  else if (THM::areParallelVectors(dir, RealVectorValue(0, 1, 0)))
    axis = "y";
  else if (THM::areParallelVectors(dir, RealVectorValue(0, 0, 1)))
    axis = "z";
 
  return axis;
}

◆ getAreaFunctionName()

const FunctionName & FlowChannelBase::getAreaFunctionName ( ) const

Get the name of the function describing the flow channel area.

Returns: The name of the function describing the flow channel area

Definition at line 144 of file FlowChannelBase.C.

{
  checkSetupStatus(INITIALIZED_PRIMARY);
 
  return _area_function;
}

Referenced by FlowModel::addCommonInitialConditions(), and HeatTransferBase::init().

◆ getAxialElementIndex()

unsigned int DiscreteLineSegmentInterface::getAxialElementIndex ( const Point & p_center ) const

inherited

Definition at line 146 of file DiscreteLineSegmentInterface.C.

{
  const Real axial_coordinate = computeAxialCoordinate(p_center);
  for (unsigned int i = 0; i < _n_elem; ++i)
    if (MooseUtils::absoluteFuzzyEqual(axial_coordinate, _x_centers[i]))
      return i;
 
  mooseError("No axial element index was found.");
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

◆ getAxialSectionIndex()

unsigned int DiscreteLineSegmentInterface::getAxialSectionIndex ( const Point & p ) const

inherited

Definition at line 135 of file DiscreteLineSegmentInterface.C.

{
  const Real axial_coordinate = computeAxialCoordinate(p);
  for (unsigned int i = 0; i < _n_sections; ++i)
    if (MooseUtils::absoluteFuzzyLessEqual(axial_coordinate, _section_end[i]))
      return i;
 
  mooseError("No axial section index was found.");
}

Referenced by DiscreteLineSegmentInterfaceTestAux::computeValue().

◆ getClosuresObjects()

std::vector< std::shared_ptr< ClosuresBase > > FlowChannelBase::getClosuresObjects ( ) const

inline

Get the used closures object(s)

Returns: The closures object(s)

Definition at line 185 of file FlowChannelBase.h.

  {
    return _closures_objects;
  }

Referenced by HeatTransferBase::init(), and HeatTransferFromHeatStructure3D1Phase::init().

◆ getComponent()

template<typename T >

const T & Component::getComponent ( const std::string & name ) const

inherited

Return a reference to a component via a parameter name.

Template Parameters

T	the type of the component we are requesting

Parameters

name	The parameter name that has the component name

Definition at line 557 of file Component.h.

{
  const std::string & comp_name = getParam<std::string>(pname);
  return getComponentByName<T>(comp_name);
}

◆ getComponentByName()

template<typename T >

const T & Component::getComponentByName ( const std::string & cname ) const

inherited

Return a reference to a component given its name.

Template Parameters

T	the type of the component we are requesting

Parameters

cname The name of the component

Definition at line 565 of file Component.h.

{
  return _sim.getComponentByName<T>(comp_name);
}

◆ getConnections()

const std::vector< Component1D::Connection > & Component1D::getConnections ( Component1DConnection::EEndType end_type ) const

virtualinherited

Gets the vector of connections of an end type for this component.

Parameters

[in] end_type end type for the connections to get

Definition at line 156 of file Component1D.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  std::map<Component1DConnection::EEndType, std::vector<Connection>>::const_iterator it =
      _connections.find(end_type);
  if (it != _connections.end())
    return it->second;
  else
    mooseError(name(), ": Invalid end type (", end_type, ").");
}

Referenced by Component1DConnection::setupMesh(), and Component1DJunction::setupMesh().

◆ getConvHeatTransGeometry()

MooseEnum FlowChannelBase::getConvHeatTransGeometry ( const std::string & name )

static

Gets a MooseEnum for convective heat transfer geometry type.

Parameters

[in] name default value

Returns: MooseEnum for convective heat transfer geometry type

Definition at line 30 of file FlowChannelBase.C.

{
  return THM::getMooseEnum<EConvHeatTransGeom>(name, _heat_transfer_geom_to_enum);
}

Referenced by validParams().

◆ getCoordSysTypes()

const std::vector< Moose::CoordinateSystemType > & Component::getCoordSysTypes ( ) const

virtualinherited

Gets the coordinate system types for this component.

Returns: vector of coordinate system types for this component

Definition at line 353 of file Component.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  return _coord_sys;
}

◆ getDependencies()

const std::vector< std::string > & Component::getDependencies ( ) const

inlineinherited

Returns a list of names of components that this component depends upon.

Definition at line 86 of file Component.h.

86{ return _dependencies; }

◆ getDirection()

virtual RealVectorValue DiscreteLineSegmentInterface::getDirection ( ) const

inlinevirtualinherited

Definition at line 30 of file DiscreteLineSegmentInterface.h.

30{ return _dir; }

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatSourceFromPowerDensity::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), HeatStructure2DCoupler::addMooseObjects(), HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), HSBoundaryRadiation::addMooseObjects(), HeatTransferFromHeatStructure3D1Phase::getFlowChannelAxisAlignment(), and Component1DConnection::setupMesh().

◆ getElementBoundaryCoordinates() [1/2]

std::vector< Real > DiscreteLineSegmentInterface::getElementBoundaryCoordinates ( ) const

inherited

Gets the element boundary coordinates for the aligned axis.

Definition at line 257 of file DiscreteLineSegmentInterface.C.

{
  return getElementBoundaryCoordinates(_position, _dir, _rotation, _lengths, _n_elems);
}

Referenced by CoupledHeatTransferAction::addUserObjects(), and DiscreteLineSegmentInterface::getElementBoundaryCoordinates().

◆ getElementBoundaryCoordinates() [2/2]

std::vector< Real > DiscreteLineSegmentInterface::getElementBoundaryCoordinates	(	const RealVectorValue &	position,
		const RealVectorValue &	orientation,
		const Real &	rotation,
		const std::vector< Real > &	lengths,
		const std::vector< unsigned int > &	n_elems
	)

staticinherited

Gets the element boundary coordinates for the aligned axis.

Parameters

[in]	position	Start position of axis in 3-D space
[in]	orientation	Direction of axis from start position to end position
[in]	rotation	Angle of rotation about the x-axis, in degrees
[in]	lengths	Length of each axial section
[in]	n_elems	Number of elements in each axial section

Definition at line 207 of file DiscreteLineSegmentInterface.C.

{
  const auto axis = getAlignmentAxis(orientation);
 
  unsigned int d;
  if (axis == "x")
    d = 0;
  else if (axis == "y")
    d = 1;
  else if (axis == "z")
    d = 2;
  else
    mooseError("Invalid axis.");
 
  const auto R = computeDirectionTransformationTensor(orientation);
  const auto Rx = computeXRotationTransformationTensor(rotation);
 
  const unsigned int n_elems_total = std::accumulate(n_elems.begin(), n_elems.end(), 0);
  const unsigned int n_sections = lengths.size();
 
  unsigned int i_section_start = 0;
  Real section_start_ref_position = 0.0;
  std::vector<Real> element_boundary_coordinates(n_elems_total + 1);
  element_boundary_coordinates[0] =
      computeRealPointFromReferencePoint(Point(0, 0, 0), position, R, Rx)(d);
  for (unsigned int j = 0; j < n_sections; ++j)
  {
    const Real section_dx = lengths[j] / n_elems[j];
    for (unsigned int k = 0; k < n_elems[j]; ++k)
    {
      const unsigned int i = i_section_start + k + 1;
      const Real ref_position = section_start_ref_position + section_dx * k;
      const Point ref_point = Point(ref_position, 0, 0);
      element_boundary_coordinates[i] =
          computeRealPointFromReferencePoint(ref_point, position, R, Rx)(d);
    }
 
    section_start_ref_position += lengths[j];
    i_section_start += n_elems[j];
  }
 
  return element_boundary_coordinates;
}

◆ getElementIDs()

const std::vector< dof_id_type > & Component::getElementIDs ( ) const

inherited

Gets the element IDs corresponding to this component.

Definition at line 337 of file Component.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  return _elem_ids;
}

Referenced by HeatTransferFromHeatStructure1Phase::setupMesh(), and HeatTransferFromHeatStructure3D1Phase::setupMesh().

◆ getEndPoint()

Point DiscreteLineSegmentInterface::getEndPoint ( ) const

inlineinherited

Definition at line 29 of file DiscreteLineSegmentInterface.h.

29{ return _end_point; }

DiscreteLineSegmentInterface::_end_point

const Point _end_point

End point of line segment.

Definition DiscreteLineSegmentInterface.h:110

Referenced by FlowChannel1Phase::addNormalized1PhaseResidualNorm().

◆ getEnumParam()

template<typename T >

T Component::getEnumParam	(	const std::string &	param,
		bool	log_error = `true`
	)		const

inherited

Gets an enum parameter.

This function takes the name of a MooseEnum parameter that is tied to an enum defined in THM. If the value is invalid, an error will be logged, and a negative integer will be cast into the enum type.

Template Parameters

T enum type

Parameters

[in]	param	name of the MooseEnum parameter
[in]	log_error	If true, log an error if the valid is invalid

Definition at line 590 of file Component.h.

{
  const MooseEnum & moose_enum = getParam<MooseEnum>(param);
  const T value = THM::stringToEnum<T>(moose_enum);
  if (log_error && static_cast<int>(value) < 0) // cast necessary for scoped enums
  {
    // Get the keys from the MooseEnum. Unfortunately, this returns a list of
    // *all* keys, including the invalid key that was supplied. Thus, that key
    // needs to be manually excluded below.
    const std::vector<std::string> & keys = moose_enum.getNames();
 
    // Create the string of keys to go in the error message. The last element of
    // keys is skipped because the invalid key should always be last.
    std::string keys_string = "{";
    for (unsigned int i = 0; i < keys.size() - 1; ++i)
    {
      if (i != 0)
        keys_string += ",";
      keys_string += "'" + keys[i] + "'";
    }
    keys_string += "}";
 
    logError("The parameter '" + param + "' was given an invalid value ('" +
             std::string(moose_enum) + "'). Valid values (case-insensitive) are " + keys_string);
  }
 
  return value;
}

◆ getFlowModel()

std::shared_ptr< const FlowModel > FlowChannelBase::getFlowModel ( ) const

virtual

Definition at line 136 of file FlowChannelBase.C.

{
  checkSetupStatus(INITIALIZED_PRIMARY);
 
  return _flow_model;
}

Referenced by FlowBoundary::init(), FlowJunction::init(), and TestSetupStatusComponent::init().

◆ getFlowModelID()

virtual const THM::FlowModelID & FlowChannelBase::getFlowModelID ( ) const

pure virtual

Gets the flow model ID.

Implemented in FlowChannel1Phase, and FlowChannelGasMix.

Referenced by FlowBoundary::init(), FlowJunction::init(), and HeatTransferBase::init().

◆ getFluidPropertiesName()

const UserObjectName & FlowChannelBase::getFluidPropertiesName ( ) const

inline

Gets the name of the fluid properties user object for this component.

Definition at line 68 of file FlowChannelBase.h.

68{ return _fp_name; }

Referenced by FlowBoundary::init(), FlowJunction::init(), and HeatTransferBase::init().

◆ getGravityAngle()

virtual const Real & FlowChannelBase::getGravityAngle ( ) const

inlinevirtual

Gets the gravity angle for this component.

Returns: gravity angle for this component

Definition at line 63 of file FlowChannelBase.h.

63{ return _gravity_angle; }

◆ getGravityMagnitude()

Real GravityInterface::getGravityMagnitude ( ) const

inlineinherited

Gets gravity magnitude.

Definition at line 26 of file GravityInterface.h.

26{ return _gravity_magnitude; }

◆ getHeatedPerimeterNames()

std::vector< VariableName > FlowChannelBase::getHeatedPerimeterNames ( ) const

inline

Gets heated perimeter names for connected heat transfers.

Definition at line 142 of file FlowChannelBase.h.

142{ return _P_hf_names; }

Referenced by Closures1PhaseBase::addAverageWallTemperatureMaterial(), and Closures1PhaseSimple::addMooseObjectsFlowChannel().

◆ getHeatTransferGeometry()

EConvHeatTransGeom FlowChannelBase::getHeatTransferGeometry ( ) const

inline

Gets heat transfer geometry.

Definition at line 117 of file FlowChannelBase.h.

117{ return _HT_geometry; }

Referenced by Closures1PhaseTHM::addWallFFMaterial(), and Closures1PhaseTHM::addWallHTCMaterial().

◆ getHeatTransferNames()

std::vector< std::string > FlowChannelBase::getHeatTransferNames ( ) const

Gets the names of all connected heat transfer components.

Definition at line 395 of file FlowChannelBase.C.

{
  checkSetupStatus(INITIALIZED_PRIMARY);
 
  return _heat_transfer_names;
}

◆ getHeatTransferNamesSuffix()

std::string FlowChannelBase::getHeatTransferNamesSuffix ( const std::string & ht_name ) const

Gets suffix to add to heat-transfer-related names in a heat transfer component.

This function is called from a heat transfer component to determine how to name its variables. If the flow channel has only one heat transfer coefficient, for example, then no suffix is returned. This function must be called after all of the heat transfer component names have been added to the flow channel's list (via addHeatTransferName()).

Parameters

[in] ht_name name of the heat transfer component

Returns: suffix to add to heat transfer variable names

Definition at line 364 of file FlowChannelBase.C.

{
  checkSetupStatus(INITIALIZED_PRIMARY);
 
  // if there is more than one connected heat transfer component, then number them
  if (_n_heat_transfer_connections > 1)
  {
    // determine index of heat transfer name based on when it was added
    auto it = std::find(_heat_transfer_names.begin(), _heat_transfer_names.end(), ht_name);
    if (it != _heat_transfer_names.end())
    {
      const unsigned int index = std::distance(_heat_transfer_names.begin(), it);
 
      std::string suffix = ":";
      if (getParam<bool>("name_multiple_ht_by_index"))
        suffix += std::to_string(index + 1);
      else
        suffix += _heat_transfer_names[index];
 
      return suffix;
    }
    else
      mooseError(
          "Heat transfer component '", ht_name, "' was not added to flow channel '", name(), "'");
  }
  // else, don't add a suffix; there is no need
  else
    return "";
}

Referenced by HeatTransfer1PhaseBase::initSecondary(), HeatTransferBase::initSecondary(), and HeatTransferFromHeatStructure3D1Phase::initSecondary().

◆ getHeatTransferVariableNames()

void FlowChannelBase::getHeatTransferVariableNames ( )

protectedvirtual

Populates heat connection variable names lists.

Reimplemented in FlowChannel1PhaseBase.

Definition at line 349 of file FlowChannelBase.C.

{
  for (unsigned int i = 0; i < _n_heat_transfer_connections; i++)
  {
    const HeatTransferBase & heat_transfer =
        getComponentByName<HeatTransferBase>(_heat_transfer_names[i]);
 
    _P_hf_names.push_back(heat_transfer.getHeatedPerimeterName());
    _T_wall_names.push_back(heat_transfer.getWallTemperatureName());
    _T_wall_mat_names.push_back(heat_transfer.getWallTemperatureMatName());
    _q_wall_names.push_back(heat_transfer.getWallHeatFluxName());
  }
}

Referenced by addVariables(), and FlowChannel1PhaseBase::getHeatTransferVariableNames().

◆ getLength()

virtual Real DiscreteLineSegmentInterface::getLength ( ) const

inlinevirtualinherited

Definition at line 34 of file DiscreteLineSegmentInterface.h.

34{ return _length; }

Referenced by HeatSourceFromTotalPower::addMooseObjects(), and HeatTransferFromHeatStructure3D1Phase::init().

◆ getMinimumElemSize()

Real DiscreteLineSegmentInterface::getMinimumElemSize ( ) const

inlineinherited

Gets the minimum element size.

Definition at line 37 of file DiscreteLineSegmentInterface.h.

37{ return _dx_min; }

DiscreteLineSegmentInterface::_dx_min

Real _dx_min

Minimum element size.

Definition DiscreteLineSegmentInterface.h:207

Referenced by FlowChannel1Phase::addNormalized1PhaseResidualNorm().

◆ getNodeIDs()

const std::vector< dof_id_type > & Component::getNodeIDs ( ) const

inherited

Gets the node IDs corresponding to this component.

Definition at line 329 of file Component.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  return _node_ids;
}

◆ getNodesetID()

unsigned int Component1D::getNodesetID ( ) const

inherited

Gets the 1D component nodeset ID.

Definition at line 140 of file Component1D.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  return _nodeset_id;
}

◆ getNodesetName()

const BoundaryName & Component1D::getNodesetName ( ) const

inherited

Gets the 1D component nodeset name.

Definition at line 148 of file Component1D.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  return _nodeset_name;
}

Referenced by HeatTransferFromHeatStructure1Phase::getChannelSideName().

◆ getNonlinearConvergence()

Convergence * Component::getNonlinearConvergence ( ) const

virtualinherited

Gets the Component's nonlinear Convergence object if it has one.

Reimplemented in BoundaryBase, Component1DBoundary, FlowChannel1Phase, HeatSourceBase, HeatStructureBase, HeatTransferBase, JunctionOneToOne1Phase, and TotalPower.

Definition at line 361 of file Component.C.

{
  mooseError("getNonlinearConvergence() not implemented.");
}

◆ getNumberOfHeatTransferConnections()

unsigned int FlowChannelBase::getNumberOfHeatTransferConnections ( ) const

inline

Gets the number of heat transfer connections.

Definition at line 137 of file FlowChannelBase.h.

137{ return _n_heat_transfer_connections; }

Referenced by Closures1PhaseSimple::addMooseObjectsFlowChannel(), Closures1PhaseTHM::addMooseObjectsFlowChannel(), and WallTemperature1PhaseClosures::addMooseObjectsFlowChannel().

◆ getNumElems()

virtual Real DiscreteLineSegmentInterface::getNumElems ( ) const

inlinevirtualinherited

Definition at line 33 of file DiscreteLineSegmentInterface.h.

33{ return _n_elem; }

Referenced by HeatTransferFromHeatStructure3D1Phase::init().

◆ getPipeLocation() [1/2]

EPipeLocation FlowChannelBase::getPipeLocation ( ) const

inline

Gets the pipe location.

Definition at line 122 of file FlowChannelBase.h.

122{ return _pipe_location; }

Referenced by validParams().

◆ getPipeLocation() [2/2]

MooseEnum FlowChannelBase::getPipeLocation ( const std::string & name )

static

Gets a MooseEnum for pipe location.

Parameters

[in] name default value

Returns: MooseEnum for pipe location

Definition at line 42 of file FlowChannelBase.C.

{
  return THM::getMooseEnum<EPipeLocation>(name, _pipe_location_to_enum);
}

Referenced by Closures1PhaseTHM::addWallFFMaterial().

◆ getPipeType()

MooseEnum FlowChannelBase::getPipeType ( const std::string & name )

static

Gets a MooseEnum for pipe type.

Parameters

[in] name default value

Returns: MooseEnum for pipe type

Definition at line 36 of file FlowChannelBase.C.

{
  return THM::getMooseEnum<EPipeType>(name, _pipe_type_to_enum);
}

◆ getPosition()

virtual Point DiscreteLineSegmentInterface::getPosition ( ) const

inlinevirtualinherited

Definition at line 27 of file DiscreteLineSegmentInterface.h.

27{ return getStartPoint(); }

DiscreteLineSegmentInterface::getStartPoint

Point getStartPoint() const

Definition DiscreteLineSegmentInterface.h:28

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatSourceFromPowerDensity::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), HeatStructure2DCoupler::addMooseObjects(), HeatTransferFromHeatStructure3D1Phase::addMooseObjects(), HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), and HSBoundaryRadiation::addMooseObjects().

◆ getRotation()

virtual Real DiscreteLineSegmentInterface::getRotation ( ) const

inlinevirtualinherited

Definition at line 31 of file DiscreteLineSegmentInterface.h.

31{ return _rotation; }

◆ getStartPoint()

Point DiscreteLineSegmentInterface::getStartPoint ( ) const

inlineinherited

Definition at line 28 of file DiscreteLineSegmentInterface.h.

28{ return _position; }

Referenced by FlowChannel1Phase::addNormalized1PhaseResidualNorm(), and DiscreteLineSegmentInterface::getPosition().

◆ getSubdomainNames()

const std::vector< SubdomainName > & Component::getSubdomainNames ( ) const

virtualinherited

Gets the subdomain names for this component.

Returns: vector of subdomain names for this component

Definition at line 345 of file Component.C.

{
  checkSetupStatus(MESH_PREPARED);
 
  return _subdomain_names;
}

◆ getTemperatureMode()

bool FlowChannelBase::getTemperatureMode ( ) const

inline

Gets temperature mode flag.

Definition at line 132 of file FlowChannelBase.h.

132{ return _temperature_mode; }

Referenced by Closures1PhaseSimple::addMooseObjectsFlowChannel(), Closures1PhaseTHM::addMooseObjectsFlowChannel(), and WallTemperature1PhaseClosures::addMooseObjectsFlowChannel().

◆ getTHMProblem()

THMProblem & Component::getTHMProblem ( ) const

inherited

Gets the THM problem.

Definition at line 135 of file Component.C.

{
  return _sim;
}

◆ getUniformNodeLocations()

std::vector< Real > GeneratedMeshComponent::getUniformNodeLocations	(	Real	length,
		unsigned int	n_nodes
	)

privateinherited

Computes the local positions of axial nodes for an axial section.

Parameters

[in]	length	Length of the axial section
[in]	n_nodes	Number of axial nodes in the axial section

Definition at line 100 of file GeneratedMeshComponent.C.

{
  std::vector<Real> node_locations(n_nodes);
  Real dx = length / (n_nodes - 1);
 
  node_locations[0] = 0.0;
 
  for (unsigned int i = 1; i < (n_nodes - 1); ++i)
    node_locations[i] = node_locations[i - 1] + dx;
 
  node_locations[n_nodes - 1] = length;
  return node_locations;
}

Referenced by GeneratedMeshComponent::generateNodeLocations().

◆ getVariableFn()

const FunctionName & GeometricalComponent::getVariableFn ( const FunctionName & fn_param_name )

protectedinherited

Makes a constant function parameter controllable and returns its name.

Parameters

[in] fn_param_name FunctionName parameter

Definition at line 79 of file GeometricalComponent.C.

{
  const FunctionName & fn_name = getParam<FunctionName>(fn_param_name);
  const Function & fn = getTHMProblem().getFunction(fn_name);
 
  if (dynamic_cast<const ConstantFunction *>(&fn) != nullptr)
  {
    connectObject(fn.parameters(), fn_name, fn_param_name, "value");
  }
 
  return fn_name;
}

◆ getWallHeatFluxNames()

std::vector< MaterialPropertyName > FlowChannelBase::getWallHeatFluxNames ( ) const

inline

Gets wall heat flux names for connected heat transfers.

Definition at line 153 of file FlowChannelBase.h.

153{ return _q_wall_names; }

◆ getWallTemperatureMatNames()

std::vector< MaterialPropertyName > FlowChannelBase::getWallTemperatureMatNames ( ) const

inline

Definition at line 148 of file FlowChannelBase.h.

148{ return _T_wall_mat_names; }

◆ getWallTemperatureNames()

std::vector< VariableName > FlowChannelBase::getWallTemperatureNames ( ) const

inline

Gets wall temperature names for connected heat transfers.

Definition at line 147 of file FlowChannelBase.h.

147{ return _T_wall_names; }

Referenced by Closures1PhaseBase::addAverageWallTemperatureMaterial(), Closures1PhaseTHM::addWallHTCMaterial(), and ClosuresBase::addWallTemperatureFromAuxMaterial().

◆ hasComponent()

template<typename T >

bool Component::hasComponent ( const std::string & name ) const

inherited

Check the existence and type of a component via a parameter name.

Template Parameters

T	the type of the component we are requesting

Parameters

name	The parameter name that has the component name

Returns: true if the component with given name and type exists, otherwise false

Definition at line 572 of file Component.h.

{
  const std::string & comp_name = getParam<std::string>(pname);
  return hasComponentByName<T>(comp_name);
}

◆ hasComponentByName()

template<typename T >

bool Component::hasComponentByName ( const std::string & cname ) const

inherited

Check the existence and type of a component given its name.

Template Parameters

T	the type of the component we are requesting

Parameters

cname The name of the component

Returns: true if the component with given name and type exists, otherwise false

Definition at line 580 of file Component.h.

{
  if (_sim.hasComponentOfType<T>(comp_name))
    return true;
  else
    return false;
}

◆ hasParam()

template<typename T >

bool Component::hasParam ( const std::string & name ) const

inherited

Test if a parameter exists in the object's input parameters.

Parameters

name	The name of the parameter

Returns: true if the parameter exists, false otherwise

Definition at line 550 of file Component.h.

{
  return parameters().have_parameter<T>(name);
}

◆ init()

void FlowChannelBase::init ( )

overrideprotectedvirtual

Initializes the component.

The reason this function exists (as opposed to just having everything in the constructor) is because some initialization depends on all components existing, since many components couple to other components. Therefore, when deciding whether code should go into the constructor or this function, one should use the following reasoning: if an operation does not require the existence of other components, then put that operation in the constructor; otherwise, put it in this function.

Reimplemented from Component.

Reimplemented in FlowChannel1PhaseBase.

Definition at line 159 of file FlowChannelBase.C.

{
  Component1D::init();
 
  _area_function = createAreaFunctionAndGetName();
 
  _flow_model = buildFlowModel();
  if (_flow_model)
  {
    _flow_model->init();
 
    const auto & closures_names = getParam<std::vector<std::string>>("closures");
    for (const auto & closures_name : closures_names)
      _closures_objects.push_back(getTHMProblem().getClosures(closures_name));
  }
}

Referenced by FlowChannel1PhaseBase::init().

◆ initializeDirectionVector()

RealVectorValue DiscreteLineSegmentInterface::initializeDirectionVector ( const RealVectorValue & dir_unnormalized )

staticprivateinherited

Computes a normalized direction vector or reports an error if the zero vector is provided.

Parameters

[in] dir_unnormalized Unnormalized direction vector

Definition at line 76 of file DiscreteLineSegmentInterface.C.

{
  if (!MooseUtils::absoluteFuzzyEqual(dir_unnormalized.norm(), 0.0))
    return dir_unnormalized / dir_unnormalized.norm();
  else
    mooseError("The parameter 'orientation' must not be the zero vector.");
}

◆ initSecondary()

void FlowChannelBase::initSecondary ( )

overrideprotectedvirtual

Perform secondary initialization, which relies on init() being called for all components.

Reimplemented from Component.

Definition at line 177 of file FlowChannelBase.C.

{
  Component1D::initSecondary();
 
  // Determine heat transfer mode based on connected heat transfer components;
  // if at least one heat transfer component of temperature component is
  // connected, then it's temperature mode. Otherwise, it's heat flux mode, even
  // if no heat transfer components at all were provided - in that case, a zero
  // heat flux is added.
  for (unsigned int i = 0; i < _heat_transfer_names.size(); i++)
  {
    const HeatTransferBase & heat_transfer =
        getComponentByName<HeatTransferBase>(_heat_transfer_names[i]);
    if (heat_transfer.isTemperatureType())
      _temperature_mode = true;
  }
}

◆ insistParameterExists()

template<typename T >

void Component::insistParameterExists	(	const std::string &	function_name,
		const std::string &	param_name
	)		const

inherited

Runtime check to make sure that a parameter of specified type exists in the component's input parameters.

This is intended to help developers write code. The idea is to provide a useful message when developers make typos, etc. If this check fails, the code execution will be stopped.

Template Parameters

T	The type of the parameter to be checked

Parameters

function_name	The name of the function calling this method
param_name	The name of the parameter to be checked

Definition at line 621 of file Component.h.

{
  if (!hasParam<T>(param_name))
    mooseError(name(),
               ": Calling ",
               function_name,
               " failed, parameter '",
               param_name,
               "' does not exist or does not have the type you requested. Double check your "
               "spelling and/or type of the parameter.");
}

◆ logComponentError()

template<typename... Args>

void LoggingInterface::logComponentError	(	const std::string &	component_name,
		Args &&...	args
	)		const

inlineinherited

Logs an error for a component.

Parameters

[in] component_name Name of the component

Definition at line 47 of file LoggingInterface.h.

  {
    _log.add(Logger::ERROR, component_name, ": ", std::forward<Args>(args)...);
  }

Referenced by Closures1PhaseSimple::checkFlowChannel(), Closures1PhaseSimple::checkHeatTransfer(), and Component::logError().

◆ logComponentWarning()

template<typename... Args>

void LoggingInterface::logComponentWarning	(	const std::string &	component_name,
		Args &&...	args
	)		const

inlineinherited

Logs a warning for a component.

Parameters

[in] component_name Name of the component

Definition at line 67 of file LoggingInterface.h.

  {
    _log.add(Logger::WARNING, component_name, ": ", std::forward<Args>(args)...);
  }

Referenced by Component::logWarning().

◆ logError()

template<typename... Args>

void Component::logError ( Args &&... args ) const

inlineinherited

Logs an error.

Definition at line 226 of file Component.h.

  {
    logComponentError(cname(), std::forward<Args>(args)...);
  }

Referenced by Component1DConnection::addConnection(), HeatStructureInterface::check(), Component1DJunction::check(), Component2D::check(), FlowBoundary1Phase::check(), FlowChannel1PhaseBase::check(), check(), FlowJunction1Phase::check(), GeneratedMeshComponent::check(), HeatSourceBase::check(), HeatStructure2DCoupler::check(), HeatStructure2DCouplerBase::check(), HeatStructure2DRadiationCouplerRZ::check(), HeatTransferFromExternalAppTemperature1Phase::check(), HeatTransferFromHeatStructure3D1Phase::check(), HSBoundary::check(), HSBoundaryExternalAppHeatFlux::check(), HSCoupler2D2DRadiation::check(), HSCoupler2D3D::check(), InletDensityVelocity1Phase::check(), InletMassFlowRateTemperature1Phase::check(), InletStagnationEnthalpyMomentum1Phase::check(), InletStagnationPressureTemperature1Phase::check(), InletVelocityTemperature1Phase::check(), Outlet1Phase::check(), Shaft::check(), VolumeJunction1Phase::check(), HSBoundary::checkAllComponent2DBoundariesAreExternal(), Component1DConnection::checkAllConnectionsHaveSame(), Component::checkComponentExistsByName(), Component::checkComponentOfTypeExistsByName(), Component::checkEqualSize(), FlowChannel1Phase::checkFluidProperties(), FlowChannelGasMix::checkFluidProperties(), Component::checkMutuallyExclusiveParameters(), Component1DConnection::checkNumberOfConnections(), Component::checkParameterValueLessThan(), Component1DConnection::checkSizeEqualsNumberOfConnections(), Component::checkSizeEqualsParameterValue(), Component::checkSizeEqualsValue(), Component::checkSizeEqualsValue(), Component::checkSizeGreaterThan(), Component::checkSizeLessThan(), ElbowPipe1Phase::ElbowPipe1Phase(), Component::getEnumParam(), HeatTransferFromHeatStructure3D1Phase::getFlowChannelAxisAlignment(), HeatStructureFromFile3D::HeatStructureFromFile3D(), Component1DConnection::init(), FlowJunction1Phase::init(), HeatTransferFromHeatStructure3D1Phase::init(), HeatTransfer1PhaseBase::initSecondary(), LoggerTestComponent::LoggerTestComponent(), Component1DConnection::setupMesh(), and HeatTransferFromHeatStructure1Phase::setupMesh().

◆ logWarning()

template<typename... Args>

void Component::logWarning ( Args &&... args ) const

inlineinherited

Logs a warning.

Definition at line 235 of file Component.h.

  {
    logComponentWarning(cname(), std::forward<Args>(args)...);
  }

Referenced by GateValve1Phase::check(), LoggerTestComponent::LoggerTestComponent(), and VolumeJunction1Phase::VolumeJunction1Phase().

◆ mesh()

THMMesh & Component::mesh ( )

inherited

Non-const reference to THM mesh, which can only be called before the end of mesh setup.

Definition at line 60 of file Component.C.

{
  if (_component_setup_status >= MESH_PREPARED)
    mooseError(
        "A non-const reference to the THM mesh cannot be obtained after mesh setup is complete.");
  else
    return _mesh;
}

Referenced by GeometricalComponent::addElement(), GeometricalComponent::addElementEdge2(), GeometricalComponent::addElementEdge3(), GeometricalComponent::addElementQuad4(), GeometricalComponent::addElementQuad9(), Component::addNode(), Component::addNodeElement(), Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), FileMeshComponent::buildMesh(), Component1D::buildMesh(), Component2D::buildMesh(), Component::setSubdomainInfo(), Component1DBoundary::setupMesh(), Component1DJunction::setupMesh(), FileMeshComponent::setupMesh(), GeneratedMeshComponent::setupMesh(), and VolumeJunction1Phase::setupMesh().

◆ nonlinearConvergenceName()

std::string Component::nonlinearConvergenceName ( ) const

inlineprotectedinherited

Nonlinear Convergence name.

Definition at line 486 of file Component.h.

486{ return genName(name(), "nlconv"); }

Referenced by Component::addMultiPostprocessorConvergence(), FlowChannel1Phase::getNonlinearConvergence(), and HeatStructureBase::getNonlinearConvergence().

◆ parent()

Component * Component::parent ( )

inlineinherited

Definition at line 55 of file Component.h.

55{ return _parent; }

◆ passParameter() [1/2]

template<typename T >

void THMObject::passParameter	(	const std::string &	name,
		const std::string &	new_name,
		InputParameters &	params
	)		const

protectedinherited

Passes a parameter from this object's input parameters to another set of input parameters.

Template Parameters

T	the type of the parameter to be passed

Parameters

name[in]	name the name of this object's parameter
new_name[in]	new_name the name of the corresponding parameters in `params`
params[in,out]	params the parameters to which the parameter will be passed

Definition at line 54 of file THMObject.h.

{
  if (isParamValid(name))
    params.set<T>(new_name) = _pars.get<T>(name);
}

◆ passParameter() [2/2]

template<typename T >

void THMObject::passParameter	(	const std::string &	name,
		InputParameters &	params
	)		const

protectedinherited

Passes a parameter from this object's input parameters to another set of input parameters.

This version overloads the other by assuming that the parameter has the same name.

Template Parameters

T	the type of the parameter to be passed

Parameters

name[in]	name the name of the parameter
params[in,out]	params the parameters to which the parameter will be passed

Definition at line 64 of file THMObject.h.

{
  passParameter<T>(name, name, params);
}

◆ placeLocalNodeLocations()

void GeneratedMeshComponent::placeLocalNodeLocations	(	Real	start_length,
		unsigned int	start_node,
		std::vector< Real > &	local_node_locations
	)

privateinherited

Puts local positions of axial nodes for an axial section into _node_locations.

Parameters

[in]	start_length	Start position for the axial section
[in]	start_node	Start node index for the axial section
[in]	local_node_locations	Local positions of axial nodes for the axial section

Definition at line 115 of file GeneratedMeshComponent.C.

{
  unsigned int n_nodes = local_node_locations.size();
  for (unsigned int i = 1; i < n_nodes; ++i)
  {
    unsigned int global_i = i + start_node;
    Real local_node_location = local_node_locations[i];
    _node_locations[global_i] = start_length + local_node_location;
  }
}

Referenced by GeneratedMeshComponent::generateNodeLocations().

◆ problemIsTransient()

bool Component::problemIsTransient ( ) const

inlineinherited

Whether the problem is transient.

Definition at line 264 of file Component.h.

264{ return getTHMProblem().isTransient(); }

FEProblem::isTransient

virtual bool isTransient() const override

Referenced by HeatConductionModel::addHeatEquationRZ(), HeatConductionModel::addHeatEquationXYZ(), and FlowModel1PhaseBase::addTimeDerivativeKernelIfTransient().

◆ setSubdomainInfo()

void Component::setSubdomainInfo	(	SubdomainID	subdomain_id,
		const std::string &	subdomain_name,
		const Moose::CoordinateSystemType &	coord_system = `Moose::COORD_XYZ`
	)

protectedvirtualinherited

Sets the next subdomain ID, name, and coordinate system.

Parameters

[in]	subdomain_id	subdomain index
[in]	subdomain_name	name of the new subdomain
[in]	coord_system	type of coordinate system

Definition at line 219 of file Component.C.

{
  _subdomain_ids.push_back(subdomain_id);
  _subdomain_names.push_back(subdomain_name);
  _coord_sys.push_back(coord_system);
  if (_parent)
  {
    _parent->_subdomain_ids.push_back(subdomain_id);
    _parent->_subdomain_names.push_back(subdomain_name);
    _parent->_coord_sys.push_back(coord_system);
  }
  mesh().setSubdomainName(subdomain_id, subdomain_name);
}

Referenced by FileMeshComponent::buildMesh(), Component1D::buildMesh(), Component2D::buildMesh(), and VolumeJunction1Phase::setupMesh().

◆ setupMesh()

void GeneratedMeshComponent::setupMesh ( )

overrideprotectedvirtualinherited

Performs mesh setup such as creating mesh or naming mesh sets.

Reimplemented from Component.

Reimplemented in HeatStructureCylindricalBase.

Definition at line 38 of file GeneratedMeshComponent.C.

{
  generateNodeLocations();
 
  buildMesh();
 
  // displace nodes
  for (auto && node_id : _node_ids)
  {
    Node & curr_node = mesh().nodeRef(node_id);
    RealVectorValue p(curr_node(0), curr_node(1), curr_node(2));
    curr_node = computeRealPointFromReferencePoint(p);
  }
}

◆ sortBy()

std::string Component1D::sortBy ( ) const

protectedinherited

Definition at line 169 of file Component1D.C.

{
  // choose the dominant direction
  std::string dominant_direction = "x";
  const Real x_abs = std::abs(_dir(0));
  const Real y_abs = std::abs(_dir(1));
  const Real z_abs = std::abs(_dir(2));
  Real max_value = x_abs;
  if (y_abs > max_value)
  {
    dominant_direction = "y";
    max_value = y_abs;
  }
  if (z_abs > max_value)
  {
    dominant_direction = "z";
    max_value = z_abs;
  }
  return dominant_direction;
}

Referenced by addMooseObjects(), and FlowChannel1Phase::addNumericalFluxVectorPostprocessor().

◆ stringify()

std::string Component::stringify ( EComponentSetupStatus status ) const

inherited

Return a string for the setup status.

Definition at line 309 of file Component.C.

{
  switch (status)
  {
    case CREATED:
      return "component created";
    case MESH_PREPARED:
      return "component mesh set up";
    case INITIALIZED_PRIMARY:
      return "primary initialization completed";
    case INITIALIZED_SECONDARY:
      return "secondary initialization completed";
    case CHECKED:
      return "component fully set up and checked";
    default:
      mooseError("Should not reach here");
  }
}

Referenced by Component::checkSetupStatus().

◆ usingSecondOrderMesh()

bool Component1D::usingSecondOrderMesh ( ) const

overrideprotectedvirtualinherited

Check if second order mesh is being used by this geometrical component.

Returns: true if second order mesh is being used, otherwise false

Implements GeneratedMeshComponent.

Definition at line 134 of file Component1D.C.

{
  return false;
}

Referenced by Component1D::buildMesh().

◆ validParams()

InputParameters FlowChannelBase::validParams ( )

static

Definition at line 70 of file FlowChannelBase.C.

{
  InputParameters params = Component1D::validParams();
  params += GravityInterface::validParams();
 
  params.addRequiredParam<UserObjectName>("fp", "Fluid properties user object");
  params.addRequiredParam<FunctionName>(
      "A", "Area of the flow channel, can be a constant or a function");
  params.addParam<Real>("roughness", 0.0, "Roughness [m]");
  params.addParam<FunctionName>("f", "Wall friction factor [-]");
  params.addParam<MooseEnum>("heat_transfer_geom",
                             FlowChannelBase::getConvHeatTransGeometry("PIPE"),
                             "Convective heat transfer geometry");
  params.addParam<MooseEnum>("pipe_location",
                             FlowChannelBase::getPipeLocation("INTERIOR"),
                             "Pipe location within the bundle");
  params.addParam<Real>("PoD", 1, "Pitch-to-diameter ratio for parallel bundle heat transfer [-]");
  params.addParam<bool>(
      "pipe_pars_transferred",
      false,
      "Set to true if Dh, P_hf and A are going to be transferred in from an external source");
  params.addParam<std::vector<std::string>>(
      "closures",
      {},
      "Closures object(s). This is optional since closure relations can be supplied directly by "
      "Materials as well.");
  params.addParam<bool>("name_multiple_ht_by_index",
                        true,
                        "If true, when there are multiple heat transfer components connected to "
                        "this flow channel, use their index for naming related quantities; "
                        "otherwise, use the name of the heat transfer component.");
  params.addParam<std::vector<VariableName>>(
      "vpp_vars", {}, "Variables to add in an ElementValueSampler");
 
  params.setDocString(
      "orientation",
      "Direction of flow channel from start position to end position (no need to normalize). For "
      "curved flow channels, it is the (tangent) direction at the start position.");
 
  params.addPrivateParam<std::string>("component_type", "pipe");
 
  return params;
}

Referenced by FlowChannel1PhaseBase::validParams().

Member Data Documentation

◆ _area_function

FunctionName FlowChannelBase::_area_function

protected

Function describing the flow channel area.

Definition at line 216 of file FlowChannelBase.h.

Referenced by addCommonObjects(), getAreaFunctionName(), and init().

◆ _axial_region_names

const std::vector<std::string>& GeneratedMeshComponent::_axial_region_names

protectedinherited

Axial region names.

Definition at line 39 of file GeneratedMeshComponent.h.

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), Component1D::buildMesh(), Component2D::buildMesh(), and GeneratedMeshComponent::GeneratedMeshComponent().

◆ _closures_objects

std::vector<std::shared_ptr<ClosuresBase> > FlowChannelBase::_closures_objects

protected

Closures object(s)

Definition at line 219 of file FlowChannelBase.h.

Referenced by addMooseObjects(), check(), getClosuresObjects(), and init().

◆ _component_setup_status

EComponentSetupStatus Component::_component_setup_status

mutableprivateinherited

Component setup status.

Definition at line 539 of file Component.h.

Referenced by Component::checkSetupStatus(), Component::executeCheck(), Component::executeInit(), Component::executeInitSecondary(), Component::executeSetupMesh(), and Component::mesh().

◆ _connections

std::map<Component1DConnection::EEndType, std::vector<Connection> > Component1D::_connections

protectedinherited

Map of end type to a list of connections.

Definition at line 79 of file Component1D.h.

Referenced by Component1D::buildMesh(), and Component1D::getConnections().

◆ _coord_sys

std::vector<Moose::CoordinateSystemType> Component::_coord_sys

protectedinherited

List of coordinate system for each subdomain.

Definition at line 515 of file Component.h.

Referenced by Component::getCoordSysTypes(), and Component::setSubdomainInfo().

◆ _dependencies

std::vector<std::string> Component::_dependencies

privateinherited

List of names of components that this component depends upon.

Definition at line 542 of file Component.h.

Referenced by Component::addDependency(), and Component::getDependencies().

◆ _dir

const RealVectorValue DiscreteLineSegmentInterface::_dir

protectedinherited

Normalized direction of axis from start position to end position.

Definition at line 100 of file DiscreteLineSegmentInterface.h.

Referenced by Component1D::buildMesh(), DiscreteLineSegmentInterface::computeAxialCoordinate(), DiscreteLineSegmentInterface::computeRadialCoordinate(), DiscreteLineSegmentInterface::getAlignmentAxis(), DiscreteLineSegmentInterface::getDirection(), DiscreteLineSegmentInterface::getElementBoundaryCoordinates(), and Component1D::sortBy().

◆ _dir_unnormalized

const RealVectorValue& DiscreteLineSegmentInterface::_dir_unnormalized

protectedinherited

Unnormalized direction of axis from start position to end position.

Definition at line 98 of file DiscreteLineSegmentInterface.h.

◆ _dx_min

Real DiscreteLineSegmentInterface::_dx_min

inherited

Minimum element size.

Definition at line 207 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::DiscreteLineSegmentInterface(), and DiscreteLineSegmentInterface::getMinimumElemSize().

◆ _elem_ids

std::vector<dof_id_type> Component::_elem_ids

protectedinherited

Element IDs of this component.

Definition at line 508 of file Component.h.

Referenced by GeometricalComponent::addElement(), GeometricalComponent::addElementEdge2(), GeometricalComponent::addElementEdge3(), GeometricalComponent::addElementQuad4(), GeometricalComponent::addElementQuad9(), Component::addNodeElement(), Component1D::buildMesh(), and Component::getElementIDs().

◆ _end_point

const Point DiscreteLineSegmentInterface::_end_point

protectedinherited

End point of line segment.

Definition at line 110 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::getEndPoint().

◆ _factory

Factory& Component::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 497 of file Component.h.

◆ _flow_model

std::shared_ptr<FlowModel> FlowChannelBase::_flow_model

protected

The flow model used by this flow channel.

Definition at line 207 of file FlowChannelBase.h.

Referenced by addMooseObjects(), addVariables(), getFlowModel(), and init().

◆ _fp_name

const UserObjectName& FlowChannelBase::_fp_name

protected

Name of fluid properties user object.

Definition at line 210 of file FlowChannelBase.h.

Referenced by FlowChannel1Phase::addFlowChannel1PhaseFunctorMaterial(), FlowChannel1Phase::addNormalized1PhaseResidualNorm(), FlowChannel1Phase::checkFluidProperties(), FlowChannelGasMix::checkFluidProperties(), and getFluidPropertiesName().

◆ _gravity_angle

const Real FlowChannelBase::_gravity_angle

protected

Angle between orientation vector and gravity vector, in degrees.

Definition at line 213 of file FlowChannelBase.h.

Referenced by getGravityAngle().

◆ _gravity_direction

const RealVectorValue GravityInterface::_gravity_direction

protectedinherited

Gravitational acceleration unit direction.

Definition at line 36 of file GravityInterface.h.

◆ _gravity_is_zero

const bool GravityInterface::_gravity_is_zero

protectedinherited

Gravitational acceleration magnitude is zero?

Definition at line 34 of file GravityInterface.h.

◆ _gravity_magnitude

const Real GravityInterface::_gravity_magnitude

protectedinherited

Gravitational acceleration magnitude.

Definition at line 32 of file GravityInterface.h.

Referenced by GravityInterface::getGravityMagnitude().

◆ _gravity_vector

const RealVectorValue& GravityInterface::_gravity_vector

protectedinherited

Gravitational acceleration vector.

Definition at line 30 of file GravityInterface.h.

◆ _has_PoD

bool FlowChannelBase::_has_PoD

protected

True if user provides PoD.

Definition at line 233 of file FlowChannelBase.h.

◆ _heat_transfer_geom_to_enum

const std::map< std::string, FlowChannelBase::EConvHeatTransGeom > FlowChannelBase::_heat_transfer_geom_to_enum

static

Initial value:

{

{"PIPE", PIPE}, {"ROD_BUNDLE", ROD_BUNDLE}, {"HEX_ROD_BUNDLE", HEX_ROD_BUNDLE}}

Map of convective heat transfer geometry type to enum.

Definition at line 20 of file FlowChannelBase.h.

Referenced by getConvHeatTransGeometry().

◆ _heat_transfer_names

std::vector<std::string> FlowChannelBase::_heat_transfer_names

mutableprotected

Names of the heat transfer components connected to this component.

Definition at line 238 of file FlowChannelBase.h.

Referenced by addHeatTransferName(), FlowChannel1PhaseBase::check(), check(), getHeatTransferNames(), getHeatTransferNamesSuffix(), getHeatTransferVariableNames(), FlowChannel1PhaseBase::getHeatTransferVariableNames(), and initSecondary().

◆ _HT_geometry

EConvHeatTransGeom FlowChannelBase::_HT_geometry

protected

Convective Heat transfer geometry.

Definition at line 227 of file FlowChannelBase.h.

Referenced by getHeatTransferGeometry().

◆ _Hw_1phase_names

std::vector<MaterialPropertyName> FlowChannelBase::_Hw_1phase_names

protected

1-phase wall heat transfer coefficient names for connected heat transfers

Definition at line 243 of file FlowChannelBase.h.

◆ _Hw_liquid_names

std::vector<MaterialPropertyName> FlowChannelBase::_Hw_liquid_names

protected

liquid wall heat transfer coefficient names for connected heat transfers

Definition at line 245 of file FlowChannelBase.h.

◆ _Hw_vapor_names

std::vector<MaterialPropertyName> FlowChannelBase::_Hw_vapor_names

protected

vapor wall heat transfer coefficient names for connected heat transfers

Definition at line 247 of file FlowChannelBase.h.

◆ _length

Real DiscreteLineSegmentInterface::_length

protectedinherited

Total axial length.

Definition at line 107 of file DiscreteLineSegmentInterface.h.

Referenced by Component1D::buildMesh(), Component2D::buildMesh(), DiscreteLineSegmentInterface::computeAxialCoordinate(), ElbowPipe1Phase::ElbowPipe1Phase(), DiscreteLineSegmentInterface::getLength(), HeatStructureCylindrical::HeatStructureCylindrical(), and HeatStructurePlate::HeatStructurePlate().

◆ _lengths

std::vector<Real> DiscreteLineSegmentInterface::_lengths

protectedinherited

Length of each axial section.

Definition at line 105 of file DiscreteLineSegmentInterface.h.

Referenced by Component2D::buildMesh(), DiscreteLineSegmentInterface::DiscreteLineSegmentInterface(), ElbowPipe1Phase::ElbowPipe1Phase(), GeneratedMeshComponent::generateNodeLocations(), and DiscreteLineSegmentInterface::getElementBoundaryCoordinates().

◆ _log

Logger& LoggingInterface::_log

protectedinherited

Definition at line 73 of file LoggingInterface.h.

Referenced by LoggingInterface::logComponentError(), LoggingInterface::logComponentWarning(), LoggingInterface::logError(), and LoggingInterface::logWarning().

◆ _mesh

THMMesh& Component::_mesh

protectedinherited

The THM mesh TODO: make _mesh private (applications need to switch to getters to avoid breaking)

Definition at line 503 of file Component.h.

Referenced by Component::addRelationshipManager(), Component::constMesh(), and Component::mesh().

◆ _moose_object_name_dlsi

const std::string DiscreteLineSegmentInterface::_moose_object_name_dlsi

protectedinherited

Name of the MOOSE object.

Definition at line 136 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::computeAxialCoordinate().

◆ _n_elem

unsigned int DiscreteLineSegmentInterface::_n_elem

protectedinherited

Total number of axial elements.

Definition at line 115 of file DiscreteLineSegmentInterface.h.

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), Component1D::buildMesh(), GeneratedMeshComponent::generateNodeLocations(), DiscreteLineSegmentInterface::getAxialElementIndex(), and DiscreteLineSegmentInterface::getNumElems().

◆ _n_elems

std::vector<unsigned int> DiscreteLineSegmentInterface::_n_elems

protectedinherited

Number of elements in each axial section.

Definition at line 113 of file DiscreteLineSegmentInterface.h.

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), Component1D::buildMesh(), DiscreteLineSegmentInterface::DiscreteLineSegmentInterface(), GeneratedMeshComponent::generateNodeLocations(), and DiscreteLineSegmentInterface::getElementBoundaryCoordinates().

◆ _n_heat_transfer_connections

unsigned int FlowChannelBase::_n_heat_transfer_connections

mutableprotected

Number of connected heat transfer components.

Definition at line 240 of file FlowChannelBase.h.

Referenced by addHeatTransferName(), addMooseObjects(), addVariables(), getHeatTransferNamesSuffix(), getHeatTransferVariableNames(), FlowChannel1PhaseBase::getHeatTransferVariableNames(), and getNumberOfHeatTransferConnections().

◆ _n_sections

const unsigned int DiscreteLineSegmentInterface::_n_sections

protectedinherited

Number of axial sections.

Definition at line 118 of file DiscreteLineSegmentInterface.h.

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), Component2D::buildMesh(), Component2D::check(), DiscreteLineSegmentInterface::DiscreteLineSegmentInterface(), GeneratedMeshComponent::generateNodeLocations(), and DiscreteLineSegmentInterface::getAxialSectionIndex().

◆ _node_ids

std::vector<dof_id_type> Component::_node_ids

protectedinherited

Node IDs of this component.

Definition at line 506 of file Component.h.

Referenced by Component::addNode(), Component1D::buildMesh(), Component::getNodeIDs(), FileMeshComponent::setupMesh(), and GeneratedMeshComponent::setupMesh().

◆ _node_locations

std::vector<Real> GeneratedMeshComponent::_node_locations

protectedinherited

Node locations along the main axis.

Definition at line 42 of file GeneratedMeshComponent.h.

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), Component1D::buildMeshNodes(), ElbowPipe1Phase::buildMeshNodes(), GeneratedMeshComponent::generateNodeLocations(), and GeneratedMeshComponent::placeLocalNodeLocations().

◆ _nodeset_id

BoundaryID Component1D::_nodeset_id

privateinherited

Nodeset ID for all 1D component nodes.

Definition at line 85 of file Component1D.h.

Referenced by Component1D::buildMesh(), and Component1D::getNodesetID().

◆ _nodeset_name

BoundaryName Component1D::_nodeset_name

privateinherited

Nodeset name for all 1D component nodes.

Definition at line 87 of file Component1D.h.

Referenced by Component1D::buildMesh(), and Component1D::getNodesetName().

◆ _P_hf_names

std::vector<VariableName> FlowChannelBase::_P_hf_names

protected

heated perimeter names for connected heat transfers

Definition at line 249 of file FlowChannelBase.h.

Referenced by addMooseObjects(), addVariables(), getHeatedPerimeterNames(), and getHeatTransferVariableNames().

◆ _parent

Component* Component::_parent

protectedinherited

Pointer to a parent component (used in composed components)

Definition at line 489 of file Component.h.

Referenced by Component::cname(), Component::parent(), and Component::setSubdomainInfo().

◆ _pipe_location

EPipeLocation FlowChannelBase::_pipe_location

protected

Pipe location within the bundle.

Definition at line 229 of file FlowChannelBase.h.

Referenced by getPipeLocation().

◆ _pipe_location_to_enum

const std::map< std::string, FlowChannelBase::EPipeLocation > FlowChannelBase::_pipe_location_to_enum

static

Initial value:

{

{"INTERIOR", INTERIOR}, {"EDGE", EDGE}, {"CORNER", CORNER}}

Map of pipe location to enum.

Definition at line 26 of file FlowChannelBase.h.

Referenced by getPipeLocation().

◆ _pipe_pars_transferred

const bool& FlowChannelBase::_pipe_pars_transferred

protected

Definition at line 221 of file FlowChannelBase.h.

Referenced by addCommonObjects(), and FlowChannel1PhaseBase::addMooseObjects().

◆ _pipe_type_to_enum

const std::map< std::string, FlowChannelBase::EPipeType > FlowChannelBase::_pipe_type_to_enum

static

Initial value:

{

{"STRAIGHT", STRAIGHT}, {"CURVED", CURVED}, {"DOWNCOMER", DOWNCOMER}}

Map of pipe type to enum.

Definition at line 23 of file FlowChannelBase.h.

23{

24public:

Referenced by getPipeType().

◆ _PoD

const Real& FlowChannelBase::_PoD

protected

Pitch to diameter ratio for parallel bundle heat transfer.

Definition at line 231 of file FlowChannelBase.h.

◆ _position

const Point& DiscreteLineSegmentInterface::_position

protectedinherited

Start position of axis in 3-D space.

Definition at line 96 of file DiscreteLineSegmentInterface.h.

Referenced by Component1D::buildMesh(), DiscreteLineSegmentInterface::computeAxialCoordinate(), DiscreteLineSegmentInterface::computeRadialCoordinate(), DiscreteLineSegmentInterface::computeRealPointFromReferencePoint(), DiscreteLineSegmentInterface::computeReferencePointFromRealPoint(), DiscreteLineSegmentInterface::getElementBoundaryCoordinates(), and DiscreteLineSegmentInterface::getStartPoint().

◆ _q_wall_names

std::vector<MaterialPropertyName> FlowChannelBase::_q_wall_names

protected

wall heat flux names for connected heat transfers

Definition at line 255 of file FlowChannelBase.h.

Referenced by addMooseObjects(), getHeatTransferVariableNames(), and getWallHeatFluxNames().

◆ _R

const RealTensorValue DiscreteLineSegmentInterface::_R

protectedinherited

Direction transformation tensor.

Definition at line 126 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::computeRealPointFromReferencePoint().

◆ _R_inv

const RealTensorValue DiscreteLineSegmentInterface::_R_inv

protectedinherited

Inverse direction transformation tensor.

Definition at line 131 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::computeReferencePointFromRealPoint().

◆ _rotation

const Real& DiscreteLineSegmentInterface::_rotation

protectedinherited

Angle of rotation about the x-axis.

Definition at line 102 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::getElementBoundaryCoordinates(), and DiscreteLineSegmentInterface::getRotation().

◆ _roughness

const Real& FlowChannelBase::_roughness

protected

Roughness of flow channel surface, [m].

Definition at line 224 of file FlowChannelBase.h.

◆ _Rx

const RealTensorValue DiscreteLineSegmentInterface::_Rx

protectedinherited

Rotational transformation tensor about x-axis.

Definition at line 128 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::computeRealPointFromReferencePoint().

◆ _Rx_inv

const RealTensorValue DiscreteLineSegmentInterface::_Rx_inv

protectedinherited

Inverse rotational transformation tensor about x-axis.

Definition at line 133 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::computeReferencePointFromRealPoint().

◆ _section_end

std::vector<Real> DiscreteLineSegmentInterface::_section_end

protectedinherited

Axial coordinate of the end of each axial section using the line 'position' as the origin.

Definition at line 120 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::DiscreteLineSegmentInterface(), and DiscreteLineSegmentInterface::getAxialSectionIndex().

◆ _sim

THMProblem& Component::_sim

protectedinherited

THM problem this component is part of TODO: make _sim private (applications need to switch to getters to avoid breaking).

Also, rename to "_thm_problem" at that point.

Definition at line 494 of file Component.h.

Referenced by Component::checkComponentExistsByName(), Component::checkComponentOfTypeExistsByName(), Component::getComponentByName(), Component::getTHMProblem(), and Component::hasComponentByName().

◆ _subdomain_ids

std::vector<SubdomainID> Component::_subdomain_ids

protectedinherited

List of subdomain IDs this components owns.

Definition at line 511 of file Component.h.

Referenced by Component2D::build2DMesh(), Component2D::build2DMesh2ndOrder(), and Component::setSubdomainInfo().

◆ _subdomain_names

std::vector<SubdomainName> Component::_subdomain_names

protectedinherited

List of subdomain names this components owns.

Definition at line 513 of file Component.h.

Referenced by Component::getSubdomainNames(), and Component::setSubdomainInfo().

◆ _T_wall_mat_names

std::vector<MaterialPropertyName> FlowChannelBase::_T_wall_mat_names

protected

wall temperature material names for connected heat transfers

Definition at line 253 of file FlowChannelBase.h.

Referenced by getHeatTransferVariableNames(), and getWallTemperatureMatNames().

◆ _T_wall_names

std::vector<VariableName> FlowChannelBase::_T_wall_names

protected

wall temperature auxvariable names for connected heat transfers

Definition at line 251 of file FlowChannelBase.h.

Referenced by getHeatTransferVariableNames(), and getWallTemperatureNames().

◆ _temperature_mode

bool FlowChannelBase::_temperature_mode

protected

True if there is one or more sources specified by wall temperature.

Definition at line 236 of file FlowChannelBase.h.

Referenced by addMooseObjects(), check(), getTemperatureMode(), and initSecondary().

◆ _x_centers

std::vector<Real> DiscreteLineSegmentInterface::_x_centers

protectedinherited

Center axial coordinate of each axial element.

Definition at line 123 of file DiscreteLineSegmentInterface.h.

Referenced by DiscreteLineSegmentInterface::DiscreteLineSegmentInterface(), and DiscreteLineSegmentInterface::getAxialElementIndex().

◆ _zero

const Real& Component::_zero

protectedinherited

Definition at line 499 of file Component.h.

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

thermal_hydraulics/include/components/FlowChannelBase.h
thermal_hydraulics/src/components/FlowChannelBase.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ EComponentSetupStatus

◆ EConvHeatTransGeom

◆ EPipeLocation

◆ EPipeType

Constructor & Destructor Documentation

◆ FlowChannelBase()

Member Function Documentation

◆ addCommonObjects()

◆ addDependency()

◆ addElement()

◆ addElementEdge2()

◆ addElementEdge3()

◆ addElementQuad4()

◆ addElementQuad9()

◆ addHeatTransferName()

◆ addMaximumFunctorPostprocessor()

◆ addMooseObjects()

◆ addMultiPostprocessorConvergence()

◆ addNode()

◆ addNodeElement()

◆ addNonlinearStepFunctorMaterial()

◆ addRelationshipManager()

◆ addRelationshipManagers()

◆ addRelationshipManagersFromParameters()

◆ addVariables()

◆ buildFlowModel()

◆ buildMesh()

◆ buildMeshNodes()

◆ check()

◆ checkComponentExistsByName()

◆ checkComponentOfTypeExists()

◆ checkComponentOfTypeExistsByName()

◆ checkEqualSize()

◆ checkMutuallyExclusiveParameters()

◆ checkParameterValueLessThan()

◆ checkSetupStatus()

◆ checkSizeEqualsParameterValue()

◆ checkSizeEqualsValue() [1/2]

◆ checkSizeEqualsValue() [2/2]

◆ checkSizeGreaterThan()

◆ checkSizeLessThan()

◆ cname()

◆ computeAxialCoordinate()

◆ computeDirectionTransformationTensor()

◆ computeNumberOfNodes()

◆ computeRadialCoordinate()

◆ computeRealPointFromReferencePoint() [1/2]

◆ computeRealPointFromReferencePoint() [2/2]

◆ computeReferencePointFromRealPoint() [1/2]

◆ computeReferencePointFromRealPoint() [2/2]

◆ computeXRotationTransformationTensor()

◆ connectObject() [1/2]

◆ connectObject() [2/2]

◆ constMesh()

◆ createAreaFunctionAndGetName()

◆ executeCheck()

◆ executeInit()

◆ executeInitSecondary()

◆ executeSetupMesh()

◆ generateNodeLocations()

◆ genName() [1/4]

◆ genName() [2/4]

◆ genName() [3/4]

◆ genName() [4/4]

◆ genSafeName()

◆ getAlignmentAxis() [1/2]

◆ getAlignmentAxis() [2/2]

◆ getAreaFunctionName()