Simulation Class Reference

Main class for simulation (the driver of the simulation) More...

#include <Simulation.h>

Inheritance diagram for Simulation:

Classes
struct	ICInfo
struct	VariableInfo
	Variable information. More...

Public Member Functions
	Simulation (FEProblemBase &fe_problem, const InputParameters &params)
virtual	~Simulation ()
const libMesh::FEType &	getFlowFEType () const
	Gets the FE type for the flow in this simulation.
virtual void	setupQuadrature ()
	Sets up quadrature rules.
virtual void	initSimulation ()
	Initialize this simulation.
virtual void	initComponents ()
	Initialize this simulation's components.
void	identifyLoops ()
	Identifies the component loops.
void	printComponentLoops () const
	Prints the component loops.
virtual void	run ()
	Run the simulation.
virtual void	addComponent (const std::string &type, const std::string &name, InputParameters params)
	Add a component into this simulation.
bool	hasComponent (const std::string &name) const
	Find out if simulation has a component with the given name.
template<typename T >
bool	hasComponentOfType (const std::string &name) const
	Find out if simulation has a component with the given name and specified type.
template<typename T >
const T &	getComponentByName (const std::string &name) const
	Get component by its name.
const std::vector< std::shared_ptr< Component > > &	getComponents () const
	Return list of components available in the simulation.
virtual void	addClosures (const std::string &type, const std::string &name, InputParameters params)
	Add a closures object into this simulation.
bool	hasClosures (const std::string &name) const
	Return whether the simulation has a closures object.
std::shared_ptr< ClosuresBase >	getClosures (const std::string &name) const
	Get a pointer to a closures object.
void	addSimVariable (bool nl, const VariableName &name, libMesh::FEType fe_type, Real scaling_factor=1.0)
	Queues a variable of type MooseVariableScalar to be added to the nonlinear or aux system.
void	addSimVariable (bool nl, const VariableName &name, libMesh::FEType fe_type, const std::vector< SubdomainName > &subdomain_names, Real scaling_factor=1.0)
	Queues a variable of type MooseVariable to be added to the nonlinear or aux system.
void	addSimVariable (bool nl, const std::string &var_type, const VariableName &name, const InputParameters &params)
	Queues a generic variable to be added to the nonlinear or aux system.
void	checkVariableNameLength (const std::string &name) const
	Reports an error if the variable name is too long.
void	addConstantIC (const VariableName &var_name, Real value, const std::vector< SubdomainName > &block_names)
void	addFunctionIC (const VariableName &var_name, const std::string &func_name, const std::vector< SubdomainName > &block_names)
void	addConstantScalarIC (const VariableName &var_name, Real value)
void	addComponentScalarIC (const VariableName &var_name, const std::vector< Real > &value)
void	addSimInitialCondition (const std::string &type, const std::string &name, InputParameters params)
void	addControl (const std::string &type, const std::string &name, InputParameters params)
	Add a control.
void	addFileOutputter (const std::string &name)
void	addScreenOutputter (const std::string &name)
std::vector< OutputName >	getOutputsVector (const std::string &key) const
	Gets the vector of output names corresponding to a 1-word key string.
virtual void	buildMesh ()
	Create mesh for this simulation.
virtual void	addVariables ()
	Add variables involved in this simulation.
virtual void	addMooseObjects ()
	Add component MOOSE objects.
virtual void	setupMesh ()
	Perform mesh setup actions such as setting up the coordinate system(s) and creating ghosted elements.
ThermalHydraulicsApp &	getApp ()
	Get the ThermalHydraulicsApp.
virtual void	integrityCheck () const
	Check the integrity of the simulation.
virtual void	advanceState ()
	Advance all of the state holding vectors / datastructures so that we can move to the next timestep.
virtual void	controlDataIntegrityCheck ()
	Check the integrity of the control data.
virtual void	couplingMatrixIntegrityCheck () const
	Check integrity of coupling matrix used by the preconditioner.
template<typename T >
bool	hasControlData (const std::string &name)
	Query if control data with name 'name' exists.
template<typename T >
ControlData< T > *	getControlData (const std::string &name)
	Get control data of type T and name 'name', if it does not exist it will be created.
template<typename T >
ControlData< T > *	declareControlData (const std::string &name, THMControl *ctrl)
	Declare control data of type T and name 'name', if it does not exist it will be created.
const bool &	getImplicitTimeIntegrationFlag ()
	Gets the flag indicating whether an implicit time integration scheme is being used.
bool	hasInitialConditionsFromFile () const
	Are initial conditions specified from a file.
Logger &	log ()
void	setCheckJacobian (bool state)
	Enable Jacobian checking.
virtual void	augmentSparsity (const dof_id_type &elem_id1, const dof_id_type &elem_id2)
	Hint how to augment sparsity pattern between two elements.
bool	getVectorValuedVelocity ()
	Is velocity output as vector-valued field.
void	setVectorValuedVelocity (bool vector_velocity)
	Set if velocity is being output as a vector-valued field.
void	addRelationshipManagers ()
	Add additional relationship managers to run the simulation.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
template<typename... Args>
void	logError (Args &&... args) const
	Logs an error.
template<typename... Args>
void	logComponentError (const std::string &component_name, Args &&... args) const
	Logs an error for a component.
template<typename... Args>
void	logWarning (Args &&... args) const
	Logs a warning.
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.

Static Public Member Functions
static void	setComponentVariableOrder (const VariableName &var, int index)
	Sets a component variable order index.

Public Attributes
Real	_zero

Protected Member Functions
void	setupEquations ()
	Setup equations to be solved in this simulation.
void	setupInitialConditionsFromFile ()
	Setup reading initial conditions from a specified file, see 'initial_from_file' and 'initial_from_file_timestep' parameters.
void	setupInitialConditionObjects ()
void	setupCoordinateSystem ()
	Sets the coordinate system for each subdomain.
void	setupCriticalHeatFluxTable ()
	Setup ctirical heat flux table user object.

Protected Attributes
THMMesh &	_thm_mesh
	THM mesh.
FEProblemBase &	_fe_problem
	Pointer to FEProblem representing this simulation.
ThermalHydraulicsApp &	_thm_app
	The application this is associated with.
Factory &	_thm_factory
	The Factory associated with the MooseApp.
std::vector< std::shared_ptr< Component > >	_components
	List of components in this simulation.
std::map< std::string, std::shared_ptr< Component > >	_comp_by_name
	Map of components by their names.
std::map< std::string, std::string >	_component_name_to_loop_name
	Map of component name to component loop name.
std::map< std::string, THM::FlowModelID >	_loop_name_to_model_id
	Map of loop name to model type.
std::map< std::string, std::shared_ptr< ClosuresBase > >	_closures_by_name
	Map of closures by their names.
std::map< VariableName, VariableInfo >	_vars
	variables for this simulation (name and info about the var)
std::map< std::string, ICInfo >	_ics
const InputParameters &	_thm_pars
	"Global" of this simulation
libMesh::FEType	_flow_fe_type
	finite element type for the flow in the simulation
std::vector< OutputName >	_outputters_all
std::vector< OutputName >	_outputters_file
std::vector< OutputName >	_outputters_screen
std::map< std::string, ControlDataValue * >	_control_data
	Control data created in the control logic system.
bool	_implicit_time_integration
	true if using implicit time integration scheme
Logger	_log
bool	_check_jacobian
	True if checking jacobian.
std::map< dof_id_type, std::vector< dof_id_type > >	_sparsity_elem_augmentation
	Additional sparsity pattern that needs to be added into the Jacobian matrix.
bool	_output_vector_velocity
	Flag indicating if velocity is output as vector-valued field.
const Parallel::Communicator &	_communicator

Private Member Functions
std::vector< VariableName >	sortAddedComponentVariables () const
	Returns a sorted list of the variables added by components.

Static Private Attributes
static std::map< VariableName, int >	_component_variable_order_map
	Component variable order map; see setComponentVariableOrder for more info.

Detailed Description

Main class for simulation (the driver of the simulation)

Definition at line 29 of file Simulation.h.

Constructor & Destructor Documentation

Simulation()

Simulation::Simulation	(	FEProblemBase &	fe_problem,
		const InputParameters &	params
	)

Definition at line 45 of file Simulation.C.

  : ParallelObject(fe_problem.comm()),
    LoggingInterface(_log),
    _thm_mesh(*static_cast<THMMesh *>(pars.get<MooseMesh *>("mesh"))),
    _fe_problem(fe_problem),
    _thm_app(static_cast<ThermalHydraulicsApp &>(*pars.get<MooseApp *>(MooseBase::app_param))),
    _thm_factory(_thm_app.getFactory()),
    _thm_pars(pars),
    _flow_fe_type(FEType(CONSTANT, MONOMIAL)),
    _implicit_time_integration(true),
    _check_jacobian(false),
    _output_vector_velocity(true),
    _zero(0)
{
  bool second_order_mesh = pars.get<bool>("2nd_order_mesh");
  HeatConductionModel::_fe_type =
      second_order_mesh ? FEType(SECOND, LAGRANGE) : FEType(FIRST, LAGRANGE);
}

~Simulation()

Simulation::~Simulation ( )

virtual

Definition at line 64 of file Simulation.C.

{
  for (auto && k : _control_data)
    delete k.second;
}

Member Function Documentation

addClosures()

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

virtual

Add a closures object into this simulation.

Parameters

[in]	type	Closures class name
[in]	name	Closures object name
[in]	params	Input parameters

Definition at line 1009 of file Simulation.C.

{
  std::shared_ptr<ClosuresBase> obj_ptr = _thm_factory.create<ClosuresBase>(type, name, params);
  if (_closures_by_name.find(name) == _closures_by_name.end())
    _closures_by_name[name] = obj_ptr;
  else
    logError("A closures object with the name '", name, "' already exists.");
}

Referenced by AddClosuresAction::act().

addComponent()

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

virtual

Add a component into this simulation.

Parameters

type	Type (the registered class name) of the component
name	Name of the component
params	Input parameters

Definition at line 991 of file Simulation.C.

{
  std::shared_ptr<Component> comp = _thm_factory.create<Component>(type, name, params);
  if (_comp_by_name.find(name) == _comp_by_name.end())
    _comp_by_name[name] = comp;
  else
    logError("Component with name '", name, "' already exists");
  _components.push_back(comp);
}

Referenced by AddComponentAction::act(), and THMActionComponent::addTHMComponent().

addComponentScalarIC()

void Simulation::addComponentScalarIC	(	const VariableName &	var_name,
		const std::vector< Real > &	value
	)

Definition at line 565 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string class_name = "ScalarComponentIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<std::vector<Real>>("values") = value;
  addSimInitialCondition(class_name, genName(var_name, "ic"), params);
}

addConstantIC()

void Simulation::addConstantIC	(	const VariableName &	var_name,
		Real	value,
		const std::vector< SubdomainName > &	block_names
	)

Definition at line 512 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string blk_str = block_names[0];
  for (unsigned int i = 1; i < block_names.size(); i++)
    blk_str += ":" + block_names[i];
 
  std::string class_name = "ConstantIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<Real>("value") = value;
  params.set<std::vector<SubdomainName>>("block") = block_names;
  addSimInitialCondition(class_name, genName(var_name, blk_str, "ic"), params);
}

Referenced by FlowModel::addCommonInitialConditions(), VolumeJunction1Phase::addJunctionIC(), and HeatTransferFromExternalAppHeatFlux1Phase::addVariables().

addConstantScalarIC()

void Simulation::addConstantScalarIC	(	const VariableName &	var_name,
		Real	value
	)

Definition at line 552 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string class_name = "ScalarConstantIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<Real>("value") = value;
  addSimInitialCondition(class_name, genName(var_name, "ic"), params);
}

Referenced by Shaft::addVariables(), and TotalPower::addVariables().

addControl()

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

Add a control.

Parameters

type	Type (registered name) of the control
name	Name of the control
params	Input parameters

Definition at line 487 of file Simulation.C.

{
  params.addPrivateParam<FEProblemBase *>("_fe_problem_base", &_fe_problem);
  std::shared_ptr<Control> control = _thm_factory.create<Control>(type, name, params);
  _fe_problem.getControlWarehouse().addObject(control);
}

addFileOutputter()

void Simulation::addFileOutputter

(

const std::string &

name

)

Definition at line 1035 of file Simulation.C.

{
  _outputters_all.push_back(name);
  _outputters_file.push_back(name);
}

Referenced by THMSetupOutputAction::act().

addFunctionIC()

void Simulation::addFunctionIC	(	const VariableName &	var_name,
		const std::string &	func_name,
		const std::vector< SubdomainName > &	block_names
	)

Definition at line 532 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string blk_str = block_names[0];
  for (unsigned int i = 1; i < block_names.size(); i++)
    blk_str += ":" + block_names[i];
 
  std::string class_name = "FunctionIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<std::vector<SubdomainName>>("block") = block_names;
  params.set<FunctionName>("function") = func_name;
  addSimInitialCondition(class_name, genName(var_name, blk_str, "ic"), params);
}

Referenced by FlowModel::addCommonInitialConditions(), HeatTransferBase::addHeatedPerimeter(), HeatConductionModel::addInitialConditions(), HeatTransferFromExternalAppTemperature1Phase::addVariables(), HeatTransferFromHeatStructure1Phase::addVariables(), HeatTransferFromHeatStructure3D1Phase::addVariables(), and HeatTransferFromSpecifiedTemperature1Phase::addVariables().

addMooseObjects()

void Simulation::addMooseObjects ( )

virtual

Add component MOOSE objects.

Definition at line 738 of file Simulation.C.

{
  for (auto && comp : _components)
    comp->addMooseObjects();
}

Referenced by AddComponentMooseObjectsAction::act().

addRelationshipManagers()

void Simulation::addRelationshipManagers

(

)

Add additional relationship managers to run the simulation.

Definition at line 745 of file Simulation.C.

{
  {
    const std::string class_name = "AugmentSparsityBetweenElements";
    auto params = _thm_factory.getValidParams(class_name);
    params.set<Moose::RelationshipManagerType>("rm_type") =
        Moose::RelationshipManagerType::COUPLING | Moose::RelationshipManagerType::ALGEBRAIC |
        Moose::RelationshipManagerType::GEOMETRIC;
    params.set<std::string>("for_whom") = _fe_problem.name();
    params.set<MooseMesh *>("mesh") = &_thm_mesh;
    params.set<std::map<dof_id_type, std::vector<dof_id_type>> *>("_elem_map") =
        &_sparsity_elem_augmentation;
    auto rm =
        _thm_factory.create<RelationshipManager>(class_name, "thm:sparsity_btw_elems", params);
    if (!_thm_app.addRelationshipManager(rm))
      _thm_factory.releaseSharedObjects(*rm);
  }
 
  for (auto && comp : _components)
    comp->addRelationshipManagers(Moose::RelationshipManagerType::COUPLING |
                                  Moose::RelationshipManagerType::ALGEBRAIC |
                                  Moose::RelationshipManagerType::GEOMETRIC);
}

Referenced by THMAddRelationshipManagersAction::act().

addScreenOutputter()

void Simulation::addScreenOutputter

(

const std::string &

name

)

Definition at line 1042 of file Simulation.C.

{
  _outputters_all.push_back(name);
  _outputters_screen.push_back(name);
}

Referenced by THMSetupOutputAction::act().

addSimInitialCondition()

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

Definition at line 495 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  if (_ics.find(name) == _ics.end())
  {
    ICInfo ic(type, params);
    _ics[name] = ic;
  }
  else
    mooseError("Initial condition with name '", name, "' already exists.");
}

Referenced by FlowModel::addCommonInitialConditions(), addComponentScalarIC(), addConstantIC(), addConstantScalarIC(), FlowModelGasMix::addDensityIC(), FlowModelSinglePhase::addDensityIC(), FlowModel1PhaseBase::addFunctionIC(), addFunctionIC(), FlowModelSinglePhase::addPassiveTransportIC(), FlowModel1PhaseBase::addRhoAIC(), FlowModelGasMix::addRhoEAIC(), FlowModelSinglePhase::addRhoEAIC(), FlowModel1PhaseBase::addRhoUAIC(), FlowModel1PhaseBase::addSpecificInternalEnergyIC(), FlowModel1PhaseBase::addSpecificTotalEnthalpyIC(), FlowModel1PhaseBase::addSpecificVolumeIC(), FlowChannelBase::addVariables(), FlowModel1PhaseBase::addVelocityIC(), VolumeJunction1Phase::addVolumeJunctionIC(), and FlowModelGasMix::addXiRhoAIC().

addSimVariable() [1/3]

void Simulation::addSimVariable	(	bool	nl,
		const std::string &	var_type,
		const VariableName &	name,
		const InputParameters &	params
	)

Queues a generic variable to be added to the nonlinear or aux system.

Parameters

[in]	nl	True if this is a nonlinear (solution) variable
[in]	var_type	Type (class) of the variable
[in]	name	Name of the variable
[in]	params	Input parameters for the variable

Definition at line 405 of file Simulation.C.

{
  checkVariableNameLength(name);
 
  if (_vars.find(name) == _vars.end()) // variable is new
  {
    VariableInfo vi;
    vi._nl = nl;
    vi._var_type = var_type;
    vi._params = params;
 
    _vars[name] = vi;
  }
  else // variable was previously added
  {
    VariableInfo & vi = _vars[name];
    InputParameters & vi_params = vi._params;
 
    if (vi._nl != nl)
      mooseError("The variable '",
                 name,
                 "' has already been added in a different system (nonlinear or aux).");
 
    if (vi._var_type != var_type)
      mooseError("The variable '",
                 name,
                 "' has already been added with a different type than '",
                 var_type,
                 "'.");
 
    // Check that all valid parameters (other than 'block') are consistent
    for (auto it = params.begin(); it != params.end(); it++)
    {
      const std::string param_name = it->first;
      if (param_name == "block")
      {
        if (vi_params.isParamValid("block"))
        {
          auto blocks = vi_params.get<std::vector<SubdomainName>>("block");
          const auto new_blocks = params.get<std::vector<SubdomainName>>("block");
          for (const auto & subdomain_name : new_blocks)
            if (std::find(blocks.begin(), blocks.end(), subdomain_name) == blocks.end())
              blocks.push_back(subdomain_name);
          vi_params.set<std::vector<SubdomainName>>("block") = blocks;
        }
        else
          mooseError("The variable '", name, "' was added previously without block restriction.");
      }
      else if (params.isParamValid(param_name))
      {
        if (vi_params.isParamValid(param_name))
        {
          if (params.rawParamVal(param_name) != vi_params.rawParamVal(param_name))
            mooseError("The variable '",
                       name,
                       "' was added previously with a different value for the parameter '",
                       param_name,
                       "'.");
        }
        else
          mooseError("The variable '",
                     name,
                     "' was added previously without the parameter '",
                     param_name,
                     "'.");
      }
    }
  }
}

addSimVariable() [2/3]

void Simulation::addSimVariable	(	bool	nl,
		const VariableName &	name,
		libMesh::FEType	fe_type,
		const std::vector< SubdomainName > &	subdomain_names,
		Real	scaling_factor = 1.0
	)

Queues a variable of type MooseVariable to be added to the nonlinear or aux system.

Parameters

[in]	nl	True if this is a nonlinear (solution) variable
[in]	name	Name of the variable
[in]	fe_type	FEType of the variable
[in]	subdomain_names	List of subdomain names to add the variable to
[in]	scaling_factor	Scaling factor for the variable

Definition at line 314 of file Simulation.C.

{
  checkVariableNameLength(name);
 
  if (fe_type.family == SCALAR)
    mooseDeprecated(
        "The version of Simulation::addSimVariable() with subdomain names can no longer be used "
        "with scalar variables since scalar variables cannot be block-restricted. Use the version "
        "of Simulation::addSimVariable() without subdomain names instead.");
 
#ifdef DEBUG
  for (const auto & subdomain_name : subdomain_names)
    mooseAssert(subdomain_name != "ANY_BLOCK_ID",
                "'ANY_BLOCK_ID' cannot be used for adding field variables in components.");
#endif
 
  if (_vars.find(name) == _vars.end()) // variable is new
  {
    VariableInfo vi;
    InputParameters & params = vi._params;
 
    vi._nl = nl;
    vi._var_type = "MooseVariable";
    params = _thm_factory.getValidParams(vi._var_type);
    params.set<std::vector<SubdomainName>>("block") = subdomain_names;
 
    auto family = AddVariableAction::getNonlinearVariableFamilies();
    family = Utility::enum_to_string(fe_type.family);
    params.set<MooseEnum>("family") = family;
 
    auto order = AddVariableAction::getNonlinearVariableOrders();
    order = Utility::enum_to_string<Order>(fe_type.order);
    params.set<MooseEnum>("order") = order;
 
    if (nl)
      params.set<std::vector<Real>>("scaling") = {scaling_factor};
    else if (!MooseUtils::absoluteFuzzyEqual(scaling_factor, 1.0))
      mooseError("Aux variables cannot be provided a residual scaling factor.");
 
    _vars[name] = vi;
  }
  else // variable was previously added
  {
    VariableInfo & vi = _vars[name];
    InputParameters & params = vi._params;
 
    if (vi._nl != nl)
      mooseError("The variable '",
                 name,
                 "' has already been added in a different system (nonlinear or aux).");
 
    if (vi._var_type != "MooseVariable")
      mooseError("The variable '",
                 name,
                 "' has already been added with a different type than 'MooseVariable'.");
 
    auto family = AddVariableAction::getNonlinearVariableFamilies();
    family = Utility::enum_to_string(fe_type.family);
    if (!params.get<MooseEnum>("family").compareCurrent(family))
      mooseError("The variable '", name, "' has already been added with a different FE family.");
 
    auto order = AddVariableAction::getNonlinearVariableOrders();
    order = Utility::enum_to_string<Order>(fe_type.order);
    if (!params.get<MooseEnum>("order").compareCurrent(order))
      mooseError("The variable '", name, "' has already been added with a different FE order.");
 
    // If already block-restricted, extend the block restriction
    if (params.isParamValid("block"))
    {
      auto blocks = params.get<std::vector<SubdomainName>>("block");
      for (const auto & subdomain_name : subdomain_names)
        if (std::find(blocks.begin(), blocks.end(), subdomain_name) == blocks.end())
          blocks.push_back(subdomain_name);
      params.set<std::vector<SubdomainName>>("block") = blocks;
    }
    else
      params.set<std::vector<SubdomainName>>("block") = subdomain_names;
 
    if (params.isParamValid("scaling"))
      if (!MooseUtils::absoluteFuzzyEqual(params.get<std::vector<Real>>("scaling")[0],
                                          scaling_factor))
        mooseError(
            "The variable '", name, "' has already been added with a different scaling factor.");
  }
}

addSimVariable() [3/3]

void Simulation::addSimVariable	(	bool	nl,
		const VariableName &	name,
		libMesh::FEType	fe_type,
		Real	scaling_factor = 1.0
	)

Queues a variable of type MooseVariableScalar to be added to the nonlinear or aux system.

Parameters

[in]	nl	True if this is a nonlinear (solution) variable
[in]	name	Name of the variable
[in]	fe_type	FEType of the variable
[in]	scaling_factor	Scaling factor for the variable

Definition at line 271 of file Simulation.C.

{
  checkVariableNameLength(name);
 
  if (fe_type.family != SCALAR)
    mooseError("This method should only be used for scalar variables.");
 
  if (_vars.find(name) == _vars.end()) // variable is new
  {
    VariableInfo vi;
    InputParameters & params = vi._params;
 
    vi._nl = nl;
    vi._var_type = "MooseVariableScalar";
    params = _thm_factory.getValidParams(vi._var_type);
 
    auto family = AddVariableAction::getNonlinearVariableFamilies();
    family = Utility::enum_to_string(fe_type.family);
    params.set<MooseEnum>("family") = family;
 
    auto order = AddVariableAction::getNonlinearVariableOrders();
    order = Utility::enum_to_string<Order>(fe_type.order);
    params.set<MooseEnum>("order") = order;
 
    if (nl)
      params.set<std::vector<Real>>("scaling") = {scaling_factor};
    else if (!MooseUtils::absoluteFuzzyEqual(scaling_factor, 1.0))
      mooseError("Aux variables cannot be provided a residual scaling factor.");
 
    _vars[name] = vi;
  }
  else
    // One of the two cases is true:
    // - This variable was previously added as a scalar variable, and scalar
    //   variables should not be added more than once, since there is no block
    //   restriction to extend, as there is in the field variable version of this
    //   method.
    // - This variable was previously added as a field variable, and a variable
    //   may have only one type (this method is used for scalar variables only).
    mooseError("The variable '", name, "' was already added.");
}

Referenced by FlowModel::addCommonVariables(), HeatTransferBase::addHeatedPerimeter(), HeatConductionModel::addVariables(), FlowModel1PhaseBase::addVariables(), FlowModelGasMix::addVariables(), FlowModelSinglePhase::addVariables(), FormLossFromExternalApp1Phase::addVariables(), HeatTransferFromExternalAppHeatFlux1Phase::addVariables(), HeatTransferFromHeatStructure3D1Phase::addVariables(), HeatTransferFromTemperature1Phase::addVariables(), HSBoundaryExternalAppConvection::addVariables(), HSBoundaryExternalAppHeatFlux::addVariables(), HSBoundaryExternalAppTemperature::addVariables(), Shaft::addVariables(), and TotalPowerBase::addVariables().

addVariables()

void Simulation::addVariables ( )

virtual

Add variables involved in this simulation.

Definition at line 634 of file Simulation.C.

{
  TransientBase * trex = dynamic_cast<TransientBase *>(getApp().getExecutioner());
  if (trex)
  {
    Moose::TimeIntegratorType ti_type = trex->getTimeScheme();
    // This is only needed for the listed time integrators that are using the original approach to
    // explicit integration in MOOSE.  Currently, the new time integrators like
    // ActuallyExplicitEuler do not need the implicit flag to be set.
    if (ti_type == Moose::TI_EXPLICIT_TVD_RK_2 || ti_type == Moose::TI_EXPLICIT_MIDPOINT ||
        ti_type == Moose::TI_EXPLICIT_EULER)
      _implicit_time_integration = false;
  }
 
  if (_components.size() == 0)
    return;
 
  // Cache the variables that components request to add
  for (auto && comp : _components)
    comp->addVariables();
 
  // Sort the variables for a consistent ordering
  const auto var_names = sortAddedComponentVariables();
 
  // Report the ordering if the executioner is verbose
  if (_fe_problem.getParam<MooseEnum>("verbose_setup") != "false")
  {
    std::stringstream ss;
    ss << "The system ordering of variables added by Components is as follows:\n";
    for (const auto & var : var_names)
      ss << "  " << var << "\n";
    mooseInfo(ss.str());
  }
 
  // Add the variables to the problem
  for (const auto & name : var_names)
  {
    VariableInfo & vi = _vars[name];
 
    if (vi._nl)
      _fe_problem.addVariable(vi._var_type, name, vi._params);
    else
      _fe_problem.addAuxVariable(vi._var_type, name, vi._params);
  }
 
  if (hasInitialConditionsFromFile())
    setupInitialConditionsFromFile();
  else
    setupInitialConditionObjects();
}

Referenced by THMAddVariablesAction::act().

advanceState()

void Simulation::advanceState ( )

virtual

Advance all of the state holding vectors / datastructures so that we can move to the next timestep.

Reimplemented in THMProblem.

Definition at line 1076 of file Simulation.C.

{
  for (auto && i : _control_data)
    i.second->copyValuesBack();
}

Referenced by THMProblem::advanceState(), and THMProblem::copySolutionsBackwards().

augmentSparsity()

void Simulation::augmentSparsity ( const dof_id_type &  elem_id1, const dof_id_type &  elem_id2  )

virtual

Hint how to augment sparsity pattern between two elements.

The augmentation will be symmetric

Definition at line 71 of file Simulation.C.

{
  auto it = _sparsity_elem_augmentation.find(elem_id1);
  if (it == _sparsity_elem_augmentation.end())
    it = _sparsity_elem_augmentation.insert(_sparsity_elem_augmentation.begin(),
                                            {elem_id1, std::vector<dof_id_type>()});
  it->second.push_back(elem_id2);
 
  it = _sparsity_elem_augmentation.find(elem_id2);
  if (it == _sparsity_elem_augmentation.end())
    it = _sparsity_elem_augmentation.insert(_sparsity_elem_augmentation.begin(),
                                            {elem_id2, std::vector<dof_id_type>()});
  it->second.push_back(elem_id1);
}

Referenced by GateValve1Phase::setupMesh(), HeatStructure2DCouplerBase::setupMesh(), HeatTransferFromHeatStructure1Phase::setupMesh(), HeatTransferFromHeatStructure3D1Phase::setupMesh(), HSCoupler2D2DRadiation::setupMesh(), HSCoupler2D3D::setupMesh(), JunctionOneToOne1Phase::setupMesh(), and VolumeJunction1Phase::setupMesh().

buildMesh()

void Simulation::buildMesh ( )

virtual

Create mesh for this simulation.

Definition at line 87 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  // build mesh
  for (auto && comp : _components)
    comp->executeSetupMesh();
}

Referenced by THMBuildMeshAction::act().

checkVariableNameLength()

void Simulation::checkVariableNameLength

(

const std::string &

name

)

const

Reports an error if the variable name is too long.

Definition at line 479 of file Simulation.C.

{
  if (name.size() > THM::MAX_VARIABLE_LENGTH)
    mooseError(
        "Variable name '", name, "' is too long. The limit is ", THM::MAX_VARIABLE_LENGTH, ".");
}

Referenced by addSimVariable(), addSimVariable(), and addSimVariable().

controlDataIntegrityCheck()

void Simulation::controlDataIntegrityCheck ( )

virtual

Check the integrity of the control data.

Definition at line 911 of file Simulation.C.

{
  if (_check_jacobian)
    return;
 
  // check that control data are consistent
  for (auto && i : _control_data)
  {
    if (!i.second->getDeclared())
      logError("Control data '",
               i.first,
               "' was requested, but was not declared by any active control object.");
  }
 
  _log.emitLoggedErrors();
 
  auto & ctrl_wh = _fe_problem.getControlWarehouse()[EXEC_TIMESTEP_BEGIN];
 
  // initialize THM control objects
  for (auto && i : ctrl_wh.getObjects())
  {
    THMControl * ctrl = dynamic_cast<THMControl *>(i.get());
    if (ctrl != nullptr)
      ctrl->init();
  }
 
  for (auto && i : ctrl_wh.getObjects())
  {
    THMControl * ctrl = dynamic_cast<THMControl *>(i.get());
    // if it is a THM control
    if (ctrl != nullptr)
    {
      // get its dependencies on control data
      auto & cd_deps = ctrl->getControlDataDependencies();
      for (auto && cd_name : cd_deps)
      {
        ControlDataValue * cdv = _control_data[cd_name];
        // find out which control object built the control data
        std::string dep_name = cdv->getControl()->name();
        auto & deps = ctrl->getDependencies();
        // and if it is not in its dependency list, add it
        auto it = std::find(deps.begin(), deps.end(), dep_name);
        if (it == deps.end())
          deps.push_back(dep_name);
      }
    }
  }
 
  // Find all `TerminateControl`s and all their dependencies. Then add those
  // objects into TIMESTEP_END control warehouse
  MooseObjectWarehouse<Control> & ctrl_wh_tse =
      _fe_problem.getControlWarehouse()[EXEC_TIMESTEP_END];
  for (auto && i : ctrl_wh.getObjects())
  {
    if (TerminateControl * ctrl = dynamic_cast<TerminateControl *>(i.get()))
    {
      std::list<const THMControl *> l;
      l.push_back(ctrl);
      while (l.size() > 0)
      {
        const THMControl * ctrl = l.front();
        auto & cd_deps = ctrl->getControlDataDependencies();
        for (auto && cd_name : cd_deps)
        {
          ControlDataValue * cdv = _control_data[cd_name];
          l.push_back(cdv->getControl());
        }
        ctrl_wh_tse.addObject(ctrl_wh.getObject(ctrl->name()));
        l.pop_front();
      }
    }
  }
}

Referenced by ControlDataIntegrityCheckAction::act().

couplingMatrixIntegrityCheck()

void Simulation::couplingMatrixIntegrityCheck ( ) const

virtual

Check integrity of coupling matrix used by the preconditioner.

Definition at line 807 of file Simulation.C.

{
  if (!_fe_problem.shouldSolve())
    return;
 
  const TimeIntegrator * ti = nullptr;
  const auto & time_integrators =
      _fe_problem.getNonlinearSystemBase(/*nl_sys_num=*/0).getTimeIntegrators();
  if (!time_integrators.empty())
    ti = time_integrators.front().get();
  // Yes, this is horrible. Don't ask why...
  if ((dynamic_cast<const ExplicitTimeIntegrator *>(ti) != nullptr) ||
      (dynamic_cast<const ExplicitEuler *>(ti) != nullptr) ||
      (dynamic_cast<const ExplicitRK2 *>(ti) != nullptr) ||
      (dynamic_cast<const ExplicitTVDRK2 *>(ti) != nullptr))
    return;
 
  const CouplingMatrix * cm = _fe_problem.couplingMatrix(/*nl_sys_num=*/0);
  if (cm == nullptr)
    mooseError("Coupling matrix does not exists. Something really bad happened.");
 
  bool full = true;
  for (unsigned int i = 0; i < cm->size(); i++)
    for (unsigned int j = 0; j < cm->size(); j++)
      full &= (*cm)(i, j);
 
  if (!full)
    mooseError(
        "Single matrix preconditioning with full coupling is required to run. Please, check that "
        "your input file has the following preconditioning block:\n\n"
        "[Preconditioning]\n"
        "  [pc]\n"
        "    type = SMP\n"
        "    full = true\n"
        "  []\n"
        "[].\n");
}

Referenced by THMPreconditioningIntegrityCheckAction::act().

declareControlData()

template<typename T >

ControlData< T > * Simulation::declareControlData ( const std::string &  name, THMControl *  ctrl  )

inline

Declare control data of type T and name 'name', if it does not exist it will be created.

Parameters

name	The unique name of the control data

Returns

Pointer to the control data of type T

Definition at line 311 of file Simulation.h.

  {
    ControlData<T> * data = getControlData<T>(name);
    if (!data->getDeclared())
    {
      // Mark the data for error checking
      data->setDeclared();
      data->setControl(ctrl);
    }
    else
      logError("Trying to declare '", name, "', but it was already declared.");
 
    return data;
  }

Referenced by THMControl::declareComponentControlData(), and THMControl::declareControlData().

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

Referenced by Closures1PhaseBase::addAverageWallTemperatureMaterial(), FlowModel::addCommonInitialConditions(), FlowModel::addCommonMooseObjects(), FlowChannelBase::addCommonObjects(), addComponentScalarIC(), HeatStructureBase::addConstantDensitySolidPropertiesMaterial(), addConstantIC(), addConstantScalarIC(), FlowModel1PhaseBase::addDensityAux(), FlowModelGasMix::addDensityIC(), FlowModelSinglePhase::addDensityIC(), FlowModel1PhaseBase::addEnergyGravityKernel(), FlowChannel1Phase::addFlowChannel1PhaseFunctorMaterial(), FlowModelGasMix::addFluidPropertiesMaterials(), FlowModelSinglePhase::addFluidPropertiesMaterials(), VolumeJunctionCoupledFlux1Phase::addFluxTransfer(), FlowModel1PhaseBase::addFunctionIC(), addFunctionIC(), FlowModel1PhaseBase::addHeatConductionDGKernel(), HeatTransferBase::addHeatedPerimeter(), HeatConductionModel::addHeatEquationRZ(), HeatConductionModel::addHeatEquationXYZ(), HeatTransferFromTemperature1Phase::addHeatTransferKernels(), FlowChannel1PhaseBase::addHydraulicDiameterMaterial(), FlowModelGasMix::addMassDiffusionEnergyDGKernel(), FlowModelGasMix::addMassDiffusionSpeciesDGKernel(), FlowModelGasMix::addMassFractionAux(), FlowModel1PhaseBase::addMomentumAreaGradientKernel(), FlowModel1PhaseBase::addMomentumFrictionKernel(), FlowModel1PhaseBase::addMomentumGravityKernel(), FlowChannel1Phase::addMooseObjects(), FlowChannelBase::addMooseObjects(), FormLoss1PhaseBase::addMooseObjects(), FormLossFromExternalApp1Phase::addMooseObjects(), FormLossFromFunction1Phase::addMooseObjects(), GateValve1Phase::addMooseObjects(), HeatSourceFromPowerDensity::addMooseObjects(), HeatSourceFromTotalPower::addMooseObjects(), HeatSourceVolumetric1Phase::addMooseObjects(), HeatStructure2DCoupler::addMooseObjects(), HeatStructure2DRadiationCouplerRZ::addMooseObjects(), HeatTransferBase::addMooseObjects(), HeatTransferFromExternalAppHeatFlux1Phase::addMooseObjects(), HeatTransferFromHeatFlux1Phase::addMooseObjects(), HeatTransferFromHeatStructure1Phase::addMooseObjects(), HeatTransferFromHeatStructure3D1Phase::addMooseObjects(), HeatTransferFromSpecifiedTemperature1Phase::addMooseObjects(), HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryExternalAppHeatFlux::addMooseObjects(), HSBoundaryExternalAppTemperature::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), HSBoundaryRadiation::addMooseObjects(), HSBoundarySpecifiedTemperature::addMooseObjects(), HSCoupler2D2DRadiation::addMooseObjects(), HSCoupler2D3D::addMooseObjects(), InletVelocityTemperature1Phase::addMooseObjects(), JunctionOneToOne1Phase::addMooseObjects(), Shaft::addMooseObjects(), ShaftConnectedCompressor1Phase::addMooseObjects(), ShaftConnectedPump1Phase::addMooseObjects(), ShaftConnectedTurbine1Phase::addMooseObjects(), SimpleTurbine1Phase::addMooseObjects(), TotalPower::addMooseObjects(), VolumeJunction1Phase::addMooseObjects(), FunctorClosures::addMooseObjectsFlowChannel(), Closures1PhaseSimple::addMooseObjectsHeatTransfer(), Component::addNonlinearStepFunctorMaterial(), FlowChannel1Phase::addNormalized1PhaseResidualNorm(), FlowModelSinglePhase::addPassiveTransportIC(), FlowModelGasMix::addPressureAux(), FlowModelSinglePhase::addPressureAux(), VolumeJunctionCoupledFlux1Phase::addPropertyTransfer(), FlowModelGasMix::addRDGAdvectionDGKernels(), FlowModelSinglePhase::addRDGAdvectionDGKernels(), FlowModel1PhaseBase::addRhoAIC(), FlowModelGasMix::addRhoEAIC(), FlowModelSinglePhase::addRhoEAIC(), FlowModel1PhaseBase::addRhoUAIC(), FlowModelGasMix::addSlopeReconstructionMaterial(), FlowModelSinglePhase::addSlopeReconstructionMaterial(), FlowModel1PhaseBase::addSpecificInternalEnergyAux(), FlowModel1PhaseBase::addSpecificInternalEnergyIC(), FlowModel1PhaseBase::addSpecificTotalEnthalpyAux(), FlowModel1PhaseBase::addSpecificTotalEnthalpyIC(), FlowModel1PhaseBase::addSpecificVolumeAux(), FlowModel1PhaseBase::addSpecificVolumeIC(), FlowModelGasMix::addTemperatureAux(), FlowModelSinglePhase::addTemperatureAux(), FlowModel1PhaseBase::addTimeDerivativeKernelIfTransient(), FlowChannelBase::addVariables(), FlowModel1PhaseBase::addVelocityAux(), FlowModel1PhaseBase::addVelocityIC(), VolumeJunction1Phase::addVolumeJunctionIC(), VolumeJunctionCoupledFlux1Phase::addVolumeJunctionKernel(), Closures1PhaseTHM::addWallFFMaterial(), Closures1PhaseBase::addWallFrictionFunctionMaterial(), Closures1PhaseTHM::addWallHTCMaterial(), ClosuresBase::addWallTemperatureFromAuxMaterial(), Closures1PhaseSimple::addWallTemperatureFromHeatFluxMaterial(), FlowBoundary1Phase::addWeakBCs(), FlowBoundaryGasMix::addWeakBCs(), ClosuresBase::addWeightedAverageMaterial(), FlowModelGasMix::addXiRhoAIC(), ClosuresBase::addZeroMaterial(), FileMeshComponent::buildMesh(), Component1D::buildMesh(), Component2D::buildMesh(), HeatSourceBase::HeatSourceBase(), Component::nonlinearConvergenceName(), and setupInitialConditionsFromFile().

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().

getApp()

ThermalHydraulicsApp & Simulation::getApp ( )

inline

Get the ThermalHydraulicsApp.

Definition at line 245 of file Simulation.h.

{ return _thm_app; }

Referenced by addVariables().

getClosures()

std::shared_ptr< ClosuresBase > Simulation::getClosures

(

const std::string &

name

)

const

Get a pointer to a closures object.

Parameters

[in]

name

Closures object name

Definition at line 1025 of file Simulation.C.

{
  auto it = _closures_by_name.find(name);
  if (it != _closures_by_name.end())
    return it->second;
  else
    mooseError("The requested closures object '", name, "' does not exist.");
}

Referenced by FlowChannelBase::init().

getComponentByName()

template<typename T >

const T & Simulation::getComponentByName

(

const std::string &

name

)

const

Get component by its name.

Template Parameters

T	the type of the component we are requesting

Parameters

name	The name of the component

Returns

Pointer to the component if found, otherwise throws and error

Definition at line 504 of file Simulation.h.

{
  auto it = _comp_by_name.find(name);
  if (it != _comp_by_name.end())
    return *dynamic_cast<T *>((it->second).get());
  else
    mooseError("Component '",
               name,
               "' does not exist in the simulation. Use hasComponent or "
               "checkComponnetByName before calling getComponent.");
}

Referenced by VolumeJunctionCoupledFlux1Phase::addFluxPostprocessor(), VolumeJunctionCoupledFlux1Phase::addVolumeJunctionKernel(), Component::getComponentByName(), Component1DConnection::init(), FlowBoundary::init(), FlowBoundary1PhaseBase::init(), FlowJunction::init(), and FlowJunction1Phase::init().

getComponents()

const std::vector< std::shared_ptr< Component > > & Simulation::getComponents ( ) const

inline

Return list of components available in the simulation.

Definition at line 117 of file Simulation.h.

{ return _components; }

Referenced by ComponentsConvergence::initialSetup(), and ParaviewComponentAnnotationMap::output().

getControlData()

template<typename T >

ControlData< T > * Simulation::getControlData ( const std::string &  name )

inline

Get control data of type T and name 'name', if it does not exist it will be created.

Parameters

name	The unique name of the control data

Returns

Pointer to the control data of type T

Definition at line 290 of file Simulation.h.

  {
    ControlData<T> * data = nullptr;
    if (_control_data.find(name) == _control_data.end())
    {
      data = new ControlData<T>(_thm_app, name);
      _control_data[name] = data;
    }
    else
      data = dynamic_cast<ControlData<T> *>(_control_data[name]);
 
    return data;
  }

Referenced by BoolControlDataValuePostprocessor::BoolControlDataValuePostprocessor(), THMControl::getControlDataByName(), THMControl::getControlDataOldByName(), THMParsedFunctionWrapper::initialize(), and RealControlDataValuePostprocessor::RealControlDataValuePostprocessor().

getFlowFEType()

const libMesh::FEType & Simulation::getFlowFEType ( ) const

inline

Gets the FE type for the flow in this simulation.

Definition at line 48 of file Simulation.h.

{ return _flow_fe_type; }

Referenced by setupQuadrature().

getImplicitTimeIntegrationFlag()

const bool & Simulation::getImplicitTimeIntegrationFlag ( )

inline

Gets the flag indicating whether an implicit time integration scheme is being used.

Definition at line 329 of file Simulation.h.

{ return _implicit_time_integration; }

Referenced by FlowModelGasMix::addMassDiffusionEnergyDGKernel(), FlowModelGasMix::addMassDiffusionSpeciesDGKernel(), GateValve1Phase::addMooseObjects(), JunctionOneToOne1Phase::addMooseObjects(), VolumeJunction1Phase::addMooseObjects(), FlowModelGasMix::addRDGAdvectionDGKernels(), FlowModelSinglePhase::addRDGAdvectionDGKernels(), FlowModelGasMix::addSlopeReconstructionMaterial(), FlowModelSinglePhase::addSlopeReconstructionMaterial(), FlowBoundary1Phase::addWeakBCs(), and FlowBoundaryGasMix::addWeakBCs().

getOutputsVector()

std::vector< OutputName > Simulation::getOutputsVector

(

const std::string &

key

)

const

Gets the vector of output names corresponding to a 1-word key string.

Parameters

[in]

key

string key that corresponds to an output names vector

Returns

output names vector corresponding to key

Definition at line 1049 of file Simulation.C.

{
  std::string key_lowercase = key;
  std::transform(key_lowercase.begin(), key_lowercase.end(), key_lowercase.begin(), ::tolower);
 
  std::vector<OutputName> outputs;
  if (key_lowercase == "none")
    outputs.push_back("none"); // provide non-existent name, so it does not get printed out
  else if (key_lowercase == "screen")
    outputs = _outputters_screen;
  else if (key_lowercase == "file")
    outputs = _outputters_file;
  else if (key_lowercase == "both")
    outputs = _outputters_all;
  else
    mooseError("The outputs vector key '" + key_lowercase + "' is invalid");
 
  return outputs;
}

getVectorValuedVelocity()

bool Simulation::getVectorValuedVelocity ( )

inline

Is velocity output as vector-valued field.

Returns

true for vector-valued field, false for scalar

Definition at line 359 of file Simulation.h.

{ return _output_vector_velocity; }

Referenced by FlowChannel1PhaseBase::buildFlowModel().

hasClosures()

bool Simulation::hasClosures

(

const std::string &

name

)

const

Return whether the simulation has a closures object.

Parameters

[in]

name

Closures object name

Definition at line 1019 of file Simulation.C.

{
  return _closures_by_name.find(name) != _closures_by_name.end();
}

hasComponent()

bool Simulation::hasComponent

(

const std::string &

name

)

const

Find out if simulation has a component with the given name.

Parameters

name	The name of the component

Returns

true if the components exists, otherwise false

Definition at line 1002 of file Simulation.C.

{
  auto it = _comp_by_name.find(name);
  return (it != _comp_by_name.end());
}

Referenced by Component::checkComponentExistsByName(), Component::checkComponentOfTypeExistsByName(), and initSimulation().

hasComponentOfType()

template<typename T >

bool Simulation::hasComponentOfType

(

const std::string &

name

)

const

Find out if simulation has a component with the given name and specified type.

Template Parameters

T	the type of the component we are requesting

Parameters

name	The name of the component

Returns

true if the component exists and has specified type, otherwise false

Definition at line 493 of file Simulation.h.

{
  auto it = _comp_by_name.find(name);
  if (it != _comp_by_name.end())
    return dynamic_cast<T *>((it->second).get()) != nullptr;
  else
    return false;
}

Referenced by Component::checkComponentOfTypeExistsByName(), and Component::hasComponentByName().

hasControlData()

template<typename T >

bool Simulation::hasControlData ( const std::string &  name )

inline

Query if control data with name 'name' exists.

Parameters

name	The unique name of the control data

Returns

true if control data 'name' exists, false otherwise

Definition at line 275 of file Simulation.h.

  {
    if (_control_data.find(name) == _control_data.end())
      return false;
    else
      return dynamic_cast<ControlData<T> *>(_control_data[name]) != NULL;
  }

Referenced by THMParsedFunctionWrapper::initialize().

hasInitialConditionsFromFile()

bool Simulation::hasInitialConditionsFromFile

(

)

const

Are initial conditions specified from a file.

Returns

true if initial conditions are specified from a file

Definition at line 1070 of file Simulation.C.

{
  return _thm_pars.isParamValid("initial_from_file");
}

Referenced by addComponentScalarIC(), addConstantIC(), addConstantScalarIC(), addFunctionIC(), addSimInitialCondition(), addVariables(), HeatStructureInterface::check(), FlowChannel1PhaseBase::check(), Shaft::check(), and VolumeJunction1Phase::check().

identifyLoops()

void Simulation::identifyLoops

(

)

Identifies the component loops.

Definition at line 164 of file Simulation.C.

{
  // loop over junctions and boundaries (non-geometrical components)
  for (const auto & component : _components)
  {
    const auto flow_connection =
        MooseSharedNamespace::dynamic_pointer_cast<Component1DConnection>(component);
    if (flow_connection)
    {
      // create vector of names of this component and its connected flow channels, and then sort
      // them
      std::vector<std::string> names = flow_connection->getConnectedComponentNames();
      names.push_back(component->name());
      std::sort(names.begin(), names.end());
 
      // pick first name alphabetically to be the proposed loop name
      std::string proposed_loop_name = names[0];
 
      for (const std::string & name : names)
      {
        // if the name is not yet in the map
        if (_component_name_to_loop_name.find(name) == _component_name_to_loop_name.end())
          // just add the new map key; nothing else needs updating
          _component_name_to_loop_name[name] = proposed_loop_name;
        else
        {
          // compare to the existing loop name for this component to make sure the
          // proposed loop name is first alphabetically
          const std::string current_loop_name = _component_name_to_loop_name[name];
          // if proposed loop name comes later, change map values of the current
          // loop name to be the proposed name, and then update the proposed name
          // to be the current name
          if (proposed_loop_name > current_loop_name)
          {
            for (auto && entry : _component_name_to_loop_name)
              if (entry.second == proposed_loop_name)
                entry.second = current_loop_name;
            proposed_loop_name = current_loop_name;
          }
          // if proposed loop name comes earlier, change map values of the current
          // loop name to be the proposed name
          else if (proposed_loop_name < current_loop_name)
          {
            for (auto && entry : _component_name_to_loop_name)
              if (entry.second == current_loop_name)
                entry.second = proposed_loop_name;
          }
        }
      }
    }
  }
 
  // get the list of loops
  std::vector<std::string> loops;
  for (const auto & entry : _component_name_to_loop_name)
    if (std::find(loops.begin(), loops.end(), entry.second) == loops.end())
      loops.push_back(entry.second);
 
  // fill the map of loop name to model ID
  for (const auto & loop : loops)
  {
    // find a flow channel in this loop and get its model ID
    THM::FlowModelID model_id;
    bool found_model_id = false;
    for (const auto & component : _components)
    {
      const auto flow_chan_base_component =
          MooseSharedNamespace::dynamic_pointer_cast<FlowChannelBase>(component);
      if (flow_chan_base_component && (_component_name_to_loop_name[component->name()] == loop))
      {
        model_id = flow_chan_base_component->getFlowModelID();
        found_model_id = true;
        break;
      }
    }
    // set the value in the map or throw an error
    if (found_model_id)
      _loop_name_to_model_id[loop] = model_id;
    else
      logError("No FlowChannelBase-derived components were found in loop '", loop, "'");
  }
}

Referenced by IdentifyLoopsAction::act().

initComponents()

void Simulation::initComponents ( )

virtual

Initialize this simulation's components.

Definition at line 151 of file Simulation.C.

{
  // initialize components
  for (auto && comp : _components)
    comp->executeInit();
 
  // perform secondary initialization, which relies on init() being called
  // already for all components
  for (auto && comp : _components)
    comp->executeInitSecondary();
}

Referenced by THMInitComponentsAction::act().

initSimulation()

void Simulation::initSimulation ( )

virtual

Initialize this simulation.

Definition at line 135 of file Simulation.C.

{
  // sort the components using dependency resolver
  DependencyResolver<std::shared_ptr<Component>> dependency_resolver;
  for (const auto & comp : _components)
  {
    dependency_resolver.addNode(comp);
    for (const auto & dep : comp->getDependencies())
      if (hasComponent(dep))
        dependency_resolver.addEdge(_comp_by_name[dep], comp);
  }
 
  _components = dependency_resolver.dfs();
}

Referenced by THMInitSimulationAction::act().

integrityCheck()

void Simulation::integrityCheck ( ) const

virtual

Check the integrity of the simulation.

Definition at line 846 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  if (_check_jacobian)
    return;
 
  // go over components and put flow channels into one "bucket"
  std::vector<Component *> flow_channels;
  for (auto && comp : _components)
  {
    auto flow_channel = dynamic_cast<FlowChannelBase *>(comp.get());
    if (flow_channel != nullptr)
      flow_channels.push_back(flow_channel);
  }
 
  // initialize number of connected flow channel inlets and outlets to zero
  std::map<std::string, unsigned int> flow_channel_inlets;
  std::map<std::string, unsigned int> flow_channel_outlets;
  for (auto && comp : flow_channels)
  {
    flow_channel_inlets[comp->name()] = 0;
    flow_channel_outlets[comp->name()] = 0;
  }
 
  // mark connections of any Component1DConnection components
  for (const auto & comp : _components)
  {
    auto pc_comp = dynamic_cast<Component1DConnection *>(comp.get());
    if (pc_comp != nullptr)
    {
      for (const auto & connection : pc_comp->getConnections())
      {
        if (connection._end_type == Component1DConnection::IN)
          flow_channel_inlets[connection._component_name]++;
        else if (connection._end_type == Component1DConnection::OUT)
          flow_channel_outlets[connection._component_name]++;
      }
    }
  }
 
  // finally, check that each flow channel has exactly one input and one output
  for (auto && comp : flow_channels)
  {
    if (flow_channel_inlets[comp->name()] == 0)
      logError("Component '", comp->name(), "' does not have connected inlet.");
    else if (flow_channel_inlets[comp->name()] > 1)
      logError("Multiple inlets specified for component '", comp->name(), "'.");
 
    if (flow_channel_outlets[comp->name()] == 0)
      logError("Component '", comp->name(), "' does not have connected outlet.");
    else if (flow_channel_outlets[comp->name()] > 1)
      logError("Multiple outlets specified for component '", comp->name(), "'.");
  }
 
  // let components check themselves
  for (auto && comp : _components)
    comp->executeCheck();
 
  _log.emitLoggedWarnings();
  _log.emitLoggedErrors();
}

Referenced by IntegrityCheckAction::act().

log()

Logger & Simulation::log ( )

inline

Definition at line 338 of file Simulation.h.

{ return _log; }

Referenced by AddClosuresAction::act().

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 LoggingInterface::logError ( Args &&...  args ) const

inlineinherited

Logs an error.

Definition at line 36 of file LoggingInterface.h.

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

Referenced by addClosures(), addComponent(), controlDataIntegrityCheck(), declareControlData(), identifyLoops(), and integrityCheck().

logWarning()

template<typename... Args>

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

inlineinherited

Logs a warning.

Definition at line 56 of file LoggingInterface.h.

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

printComponentLoops()

void Simulation::printComponentLoops

(

)

const

Prints the component loops.

Definition at line 248 of file Simulation.C.

{
  // get the list of loops
  std::vector<std::string> loops;
  for (auto && entry : _component_name_to_loop_name)
    if (std::find(loops.begin(), loops.end(), entry.second) == loops.end())
      loops.push_back(entry.second);
 
  // for each loop
  Moose::out << "\nListing of component loops:" << std::endl;
  for (unsigned int i = 0; i < loops.size(); i++)
  {
    Moose::out << "\n  Loop " << i + 1 << ":" << std::endl;
 
    // print out each component in the loop
    for (auto && entry : _component_name_to_loop_name)
      if (entry.second == loops[i])
        Moose::out << "    " << entry.first << std::endl;
  }
  Moose::out << std::endl;
}

Referenced by THMPrintComponentLoopsAction::act().

run()

void Simulation::run ( )

virtual

Run the simulation.

Definition at line 986 of file Simulation.C.

{
}

setCheckJacobian()

void Simulation::setCheckJacobian ( bool  state )

inline

Enable Jacobian checking.

Parameters

state

True for Jacobian checking, otherwise false

Definition at line 345 of file Simulation.h.

{ _check_jacobian = state; }

Referenced by THMDebugAction::act().

setComponentVariableOrder()

void Simulation::setComponentVariableOrder ( const VariableName &  var, int  index  )

static

Sets a component variable order index.

See Component system documentation for more information.

Parameters

[in]	var	Variable to order
[in]	index	Order index

Definition at line 40 of file Simulation.C.

{
  _component_variable_order_map[var] = index;
}

Referenced by ThermalHydraulicsApp::registerAll().

setupCoordinateSystem()

void Simulation::setupCoordinateSystem ( )

protected

Sets the coordinate system for each subdomain.

Definition at line 770 of file Simulation.C.

{
  MultiMooseEnum coord_types("XYZ RZ RSPHERICAL");
  std::vector<SubdomainName> blocks;
 
  for (auto && comp : _components)
  {
    if (comp->parent() == nullptr)
    {
      const auto & subdomains = comp->getSubdomainNames();
      const auto & coord_sys = comp->getCoordSysTypes();
 
      for (unsigned int i = 0; i < subdomains.size(); i++)
      {
        blocks.push_back(subdomains[i]);
        // coord_types.push_back("XYZ");
        coord_types.setAdditionalValue(coord_sys[i] == Moose::COORD_RZ ? "RZ" : "XYZ");
      }
    }
  }
  _fe_problem.setCoordSystem(blocks, coord_types);
 
  // RZ geometries are always aligned with x-axis
  MooseEnum rz_coord_axis("X=0 Y=1", "X");
  _fe_problem.setAxisymmetricCoordAxis(rz_coord_axis);
}

Referenced by setupMesh().

setupCriticalHeatFluxTable()

void Simulation::setupCriticalHeatFluxTable ( )

protected

Setup ctirical heat flux table user object.

setupEquations()

void Simulation::setupEquations ( )

protected

Setup equations to be solved in this simulation.

setupInitialConditionObjects()

void Simulation::setupInitialConditionObjects ( )

protected

Definition at line 727 of file Simulation.C.

{
  for (auto && i : _ics)
  {
    const std::string & name = i.first;
    ICInfo & ic = i.second;
    _fe_problem.addInitialCondition(ic._type, name, ic._params);
  }
}

Referenced by addVariables().

setupInitialConditionsFromFile()

void Simulation::setupInitialConditionsFromFile ( )

protected

Setup reading initial conditions from a specified file, see 'initial_from_file' and 'initial_from_file_timestep' parameters.

Definition at line 686 of file Simulation.C.

{
  const UserObjectName suo_name = genName("thm", "suo");
  {
    const std::string class_name = "SolutionUserObject";
    InputParameters params = _thm_factory.getValidParams(class_name);
    params.set<MeshFileName>("mesh") = _thm_pars.get<FileName>("initial_from_file");
    params.set<std::string>("timestep") = _thm_pars.get<std::string>("initial_from_file_timestep");
    _fe_problem.addUserObject(class_name, suo_name, params);
  }
 
  for (auto && v : _vars)
  {
    const VariableName & var_name = v.first;
    const VariableInfo & vi = v.second;
 
    if (vi._var_type == "MooseVariableScalar")
    {
      std::string class_name = "ScalarSolutionIC";
      InputParameters params = _thm_factory.getValidParams(class_name);
      params.set<VariableName>("variable") = var_name;
      params.set<VariableName>("from_variable") = var_name;
      params.set<UserObjectName>("solution_uo") = suo_name;
      _fe_problem.addInitialCondition(class_name, genName(var_name, "ic"), params);
    }
    else
    {
      std::string class_name = "SolutionIC";
      InputParameters params = _thm_factory.getValidParams(class_name);
      params.set<VariableName>("variable") = var_name;
      params.set<VariableName>("from_variable") = var_name;
      params.set<UserObjectName>("solution_uo") = suo_name;
      if (vi._params.isParamValid("block"))
        params.set<std::vector<SubdomainName>>("block") =
            vi._params.get<std::vector<SubdomainName>>("block");
      _fe_problem.addInitialCondition(class_name, genName(var_name, "ic"), params);
    }
  }
}

Referenced by addVariables().

setupMesh()

void Simulation::setupMesh ( )

virtual

Perform mesh setup actions such as setting up the coordinate system(s) and creating ghosted elements.

Definition at line 798 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  setupCoordinateSystem();
}

Referenced by THMSetupMeshAction::act().

setupQuadrature()

void Simulation::setupQuadrature ( )

virtual

Sets up quadrature rules.

Definition at line 98 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  Order order = CONSTANT;
  unsigned int n_flow_channels = 0;
  unsigned int n_heat_structures = 0;
 
  for (auto && comp : _components)
  {
    auto flow_channel = dynamic_cast<FlowChannelBase *>(comp.get());
    if (flow_channel != nullptr)
      n_flow_channels++;
 
    auto hs_interface = dynamic_cast<HeatStructureInterface *>(comp.get());
    if (hs_interface)
      n_heat_structures++;
  }
 
  if (n_flow_channels > 0)
  {
    const FEType & fe_type = getFlowFEType();
    if (fe_type.default_quadrature_order() > order)
      order = fe_type.default_quadrature_order();
  }
  if (n_heat_structures > 0)
  {
    const FEType & fe_type = HeatConductionModel::feType();
    if (fe_type.default_quadrature_order() > order)
      order = fe_type.default_quadrature_order();
  }
 
  _fe_problem.createQRules(QGAUSS, order, order, order);
}

Referenced by THMSetupQuadratureAction::act().

setVectorValuedVelocity()

void Simulation::setVectorValuedVelocity ( bool  vector_velocity )

inline

Set if velocity is being output as a vector-valued field.

Definition at line 364 of file Simulation.h.

{ _output_vector_velocity = vector_velocity; }

Referenced by THMOutputVectorVelocityAction::act().

sortAddedComponentVariables()

std::vector< VariableName > Simulation::sortAddedComponentVariables ( ) const

private

Returns a sorted list of the variables added by components.

See Component system documentation for more information.

Definition at line 578 of file Simulation.C.

{
  // Check that no index in order map is used more than once.
  // Also, convert the map to a vector of pairs to be sorted.
  std::set<int> indices;
  std::vector<std::pair<VariableName, int>> registered_var_index_pairs;
  for (const auto & var_and_index : _component_variable_order_map)
  {
    registered_var_index_pairs.push_back(var_and_index);
 
    const auto ind = var_and_index.second;
    auto insert_return = indices.insert(ind);
    if (!insert_return.second)
      mooseError("The index ", ind, " was used for multiple component variables.");
  }
 
  // Collect all of the added variable names into an unsorted vector.
  std::vector<VariableName> vars_unsorted;
  for (const auto & var_and_data : _vars)
    vars_unsorted.push_back(var_and_data.first);
 
  // The sorting works as follows. For those variables that are listed in
  // _component_variable_order_map, these are ordered before those that are not,
  // in the order of their indices in the map. Those not in the map are sorted
  // alphabetically.
 
  // Sort registered_var_index_pairs by value (index)
  std::sort(registered_var_index_pairs.begin(),
            registered_var_index_pairs.end(),
            [](const std::pair<VariableName, int> & a, const std::pair<VariableName, int> & b)
            { return a.second < b.second; });
 
  // Loop over the ordered, registered variable names and add a variable to the
  // sorted list if in vars_unsorted. When this happens, delete the element from
  // vars_unsorted, leaving only unregistered variable names after the loop.
  std::vector<VariableName> vars_sorted;
  for (const auto & var_index_pair : registered_var_index_pairs)
  {
    const auto & var = var_index_pair.first;
    if (std::find(vars_unsorted.begin(), vars_unsorted.end(), var) != vars_unsorted.end())
    {
      vars_sorted.push_back(var);
      vars_unsorted.erase(std::remove(vars_unsorted.begin(), vars_unsorted.end(), var),
                          vars_unsorted.end());
    }
  }
 
  // Sort the remaining (unregistered) variables alphabetically and then add
  // them to the end of the full list.
  std::sort(vars_unsorted.begin(), vars_unsorted.end());
  vars_sorted.insert(vars_sorted.end(), vars_unsorted.begin(), vars_unsorted.end());
 
  return vars_sorted;
}

Referenced by addVariables().

Member Data Documentation

_check_jacobian

bool Simulation::_check_jacobian

protected

True if checking jacobian.

Definition at line 468 of file Simulation.h.

Referenced by controlDataIntegrityCheck(), integrityCheck(), and setCheckJacobian().

_closures_by_name

std::map<std::string, std::shared_ptr<ClosuresBase> > Simulation::_closures_by_name

protected

Map of closures by their names.

Definition at line 409 of file Simulation.h.

Referenced by addClosures(), getClosures(), and hasClosures().

_comp_by_name

std::map<std::string, std::shared_ptr<Component> > Simulation::_comp_by_name

protected

Map of components by their names.

Definition at line 402 of file Simulation.h.

Referenced by addComponent(), getComponentByName(), hasComponent(), hasComponentOfType(), and initSimulation().

_component_name_to_loop_name

std::map<std::string, std::string> Simulation::_component_name_to_loop_name

protected

Map of component name to component loop name.

Definition at line 404 of file Simulation.h.

Referenced by identifyLoops(), and printComponentLoops().

_component_variable_order_map

std::map< VariableName, int > Simulation::_component_variable_order_map

staticprivate

Component variable order map; see setComponentVariableOrder for more info.

Definition at line 488 of file Simulation.h.

Referenced by setComponentVariableOrder(), and sortAddedComponentVariables().

_components

std::vector<std::shared_ptr<Component> > Simulation::_components

protected

List of components in this simulation.

Definition at line 400 of file Simulation.h.

Referenced by addComponent(), addMooseObjects(), addRelationshipManagers(), addVariables(), buildMesh(), getComponents(), identifyLoops(), initComponents(), initSimulation(), integrityCheck(), setupCoordinateSystem(), setupMesh(), and setupQuadrature().

_control_data

std::map<std::string, ControlDataValue *> Simulation::_control_data

protected

Control data created in the control logic system.

Definition at line 460 of file Simulation.h.

Referenced by advanceState(), controlDataIntegrityCheck(), getControlData(), hasControlData(), and ~Simulation().

_fe_problem

FEProblemBase& Simulation::_fe_problem

protected

Pointer to FEProblem representing this simulation.

Definition at line 391 of file Simulation.h.

Referenced by addControl(), addRelationshipManagers(), addVariables(), controlDataIntegrityCheck(), couplingMatrixIntegrityCheck(), setupCoordinateSystem(), setupInitialConditionObjects(), setupInitialConditionsFromFile(), and setupQuadrature().

_flow_fe_type

libMesh::FEType Simulation::_flow_fe_type

protected

finite element type for the flow in the simulation

Definition at line 430 of file Simulation.h.

Referenced by getFlowFEType().

_ics

std::map<std::string, ICInfo> Simulation::_ics

protected

Definition at line 424 of file Simulation.h.

Referenced by addSimInitialCondition(), and setupInitialConditionObjects().

_implicit_time_integration

bool Simulation::_implicit_time_integration

protected

true if using implicit time integration scheme

Definition at line 463 of file Simulation.h.

Referenced by addVariables(), and getImplicitTimeIntegrationFlag().

_log

Logger Simulation::_log

protected

Definition at line 465 of file Simulation.h.

Referenced by controlDataIntegrityCheck(), integrityCheck(), and log().

_loop_name_to_model_id

std::map<std::string, THM::FlowModelID> Simulation::_loop_name_to_model_id

protected

Map of loop name to model type.

Definition at line 406 of file Simulation.h.

Referenced by identifyLoops().

_output_vector_velocity

bool Simulation::_output_vector_velocity

protected

Flag indicating if velocity is output as vector-valued field.

Definition at line 474 of file Simulation.h.

Referenced by getVectorValuedVelocity(), and setVectorValuedVelocity().

_outputters_all

std::vector<OutputName> Simulation::_outputters_all

protected

Definition at line 455 of file Simulation.h.

Referenced by addFileOutputter(), addScreenOutputter(), and getOutputsVector().

_outputters_file

std::vector<OutputName> Simulation::_outputters_file

protected

Definition at line 456 of file Simulation.h.

Referenced by addFileOutputter(), and getOutputsVector().

_outputters_screen

std::vector<OutputName> Simulation::_outputters_screen

protected

Definition at line 457 of file Simulation.h.

Referenced by addScreenOutputter(), and getOutputsVector().

_sparsity_elem_augmentation

std::map<dof_id_type, std::vector<dof_id_type> > Simulation::_sparsity_elem_augmentation

protected

Additional sparsity pattern that needs to be added into the Jacobian matrix.

Definition at line 471 of file Simulation.h.

Referenced by addRelationshipManagers(), and augmentSparsity().

_thm_app

ThermalHydraulicsApp& Simulation::_thm_app

protected

The application this is associated with.

Definition at line 394 of file Simulation.h.

Referenced by addRelationshipManagers(), getApp(), and getControlData().

_thm_factory

Factory& Simulation::_thm_factory

protected

The Factory associated with the MooseApp.

Definition at line 397 of file Simulation.h.

Referenced by addClosures(), addComponent(), addComponentScalarIC(), addConstantIC(), addConstantScalarIC(), addControl(), addFunctionIC(), addRelationshipManagers(), addSimVariable(), addSimVariable(), and setupInitialConditionsFromFile().

_thm_mesh

THMMesh& Simulation::_thm_mesh

protected

THM mesh.

Definition at line 388 of file Simulation.h.

Referenced by addRelationshipManagers().

_thm_pars

const InputParameters& Simulation::_thm_pars

protected

"Global" of this simulation

Definition at line 427 of file Simulation.h.

Referenced by hasInitialConditionsFromFile(), and setupInitialConditionsFromFile().

_vars

std::map<VariableName, VariableInfo> Simulation::_vars

protected

variables for this simulation (name and info about the var)

Definition at line 412 of file Simulation.h.

Referenced by addSimVariable(), addSimVariable(), addSimVariable(), addVariables(), setupInitialConditionsFromFile(), and sortAddedComponentVariables().

_zero

Real Simulation::_zero

Definition at line 477 of file Simulation.h.

---

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

• thermal_hydraulics/include/base/Simulation.h
• thermal_hydraulics/src/base/Simulation.C