AddFluidPropertiesInterrogatorAction Class Reference

Action that sets up the fluid properties interrogator. More...

#include <AddFluidPropertiesInterrogatorAction.h>

Inheritance diagram for AddFluidPropertiesInterrogatorAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	AddFluidPropertiesInterrogatorAction (const InputParameters &parameters)
virtual void	act () override
void	timedAct ()
virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)
MooseObjectName	uniqueActionName () const
const std::string &	specificTaskName () const
const std::set< std::string > &	getAllTasks () const
void	appendTask (const std::string &task)
MooseApp &	getMooseApp () const
const std::string &	type () const
virtual const std::string &	name () const
std::string	typeAndName () const
std::string	errorPrefix (const std::string &error_type) const
void	callMooseError (std::string msg, const bool with_prefix) const
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
const InputParameters &	parameters () const
MooseObjectName	uniqueName () 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 &nm) const
void	paramError (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
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
void	mooseError (Args &&... args) const
void	mooseErrorNonPrefixed (Args &&... args) const
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
void	mooseWarning (Args &&... args) const
void	mooseWarningNonPrefixed (Args &&... args) const
void	mooseDeprecated (Args &&... args) const
void	mooseInfo (Args &&... args) 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
PerfGraph &	perfGraph ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM
static constexpr auto	NAME

Protected Member Functions
void	addFluidPropertiesInterrogatorObject () const
	Adds the FluidPropertiesInterrogator user object. More...
bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
void	associateWithParameter (const std::string &param_name, InputParameters &params) const
void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
const T &	getMeshProperty (const std::string &data_name)
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name) const
bool	hasMeshProperty (const std::string &data_name) const
std::string	meshPropertyName (const std::string &data_name) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
std::string	timedSectionName (const std::string &section_name) const

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

Protected Attributes
std::string	_registered_identifier
std::string	_specific_task_name
std::set< std::string >	_all_tasks
ActionWarehouse &	_awh
const std::string &	_current_task
std::shared_ptr< MooseMesh > &	_mesh
std::shared_ptr< MooseMesh > &	_displaced_mesh
std::shared_ptr< FEProblemBase > &	_problem
PerfID	_act_timer
MooseApp &	_app
const std::string	_type
const std::string	_name
const InputParameters &	_pars
Factory &	_factory
ActionFactory &	_action_factory
MooseApp &	_pg_moose_app
const std::string	_prefix
const Parallel::Communicator &	_communicator

Detailed Description

Action that sets up the fluid properties interrogator.

Definition at line 17 of file AddFluidPropertiesInterrogatorAction.h.

Constructor & Destructor Documentation

AddFluidPropertiesInterrogatorAction()

AddFluidPropertiesInterrogatorAction::AddFluidPropertiesInterrogatorAction

(

const InputParameters &

parameters

)

Definition at line 49 of file AddFluidPropertiesInterrogatorAction.C.

  : Action(params)
{
  // Currently these parameters are required by the constructor of Console, which
  // assumes that the action satisfying task "add_output" has these parameters.
  // However, these parameters are not meant to be seen by the user, so they
  // are added here, instead of in validParams(), with the help of const_cast.
  InputParameters & pars = const_cast<InputParameters &>(parameters());
  ExecFlagEnum exec_enum = Output::getDefaultExecFlagEnum();
  exec_enum = {EXEC_INITIAL, EXEC_TIMESTEP_END};
  pars.addParam<ExecFlagEnum>("execute_on", exec_enum, "(Does not need to be set)");
  pars.addParam<bool>("print_perf_log", false, "(Does not need to be set)");
  pars.addParam<bool>("print_linear_residuals", false, "(Does not need to be set)");
}

Member Function Documentation

act()

void AddFluidPropertiesInterrogatorAction::act ( )

overridevirtual

Implements Action.

Definition at line 66 of file AddFluidPropertiesInterrogatorAction.C.

{
  // Set up an arbitrary mesh
  if (_current_task == "setup_mesh")
  {
    const std::string class_name = "GeneratedMesh";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<MooseEnum>("dim") = "1";
    _mesh = _factory.create<MooseMesh>(class_name, "mesh", params);
  }
  // Initialize the arbitrary mesh
  else if (_current_task == "init_mesh")
  {
    _mesh->init();
  }
  // Create a "solve=false" FEProblem
  else if (_current_task == "create_problem")
  {
    const std::string class_name = "FEProblem";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<MooseMesh *>("mesh") = _mesh.get();
    params.set<bool>("use_nonlinear") = true;
    params.set<bool>("solve") = false;
    _problem = _factory.create<FEProblemBase>(class_name, "Problem", params);
    _problem->setKernelCoverageCheck(FEProblemBase::CoverageCheckMode::FALSE);
  }
  // Add the fluid properties interrogator user object
  else if (_current_task == "add_user_object")
  {
    addFluidPropertiesInterrogatorObject();
  }
  // Set up an arbitrary steady executioner
  else if (_current_task == "setup_executioner")
  {
    const std::string class_name = "Steady";
    InputParameters params = _factory.getValidParams(class_name);
    params.set<FEProblemBase *>("_fe_problem_base") = _problem.get();
    params.set<FEProblem *>("_fe_problem") = (std::dynamic_pointer_cast<FEProblem>(_problem)).get();
    std::shared_ptr<Executioner> executioner =
        _factory.create<Executioner>(class_name, "Executioner", params);
    _app.setExecutioner(std::move(executioner));
  }
  // Create a console that executes only on FINAL and does not print system info
  else if (_current_task == "add_fp_output")
  {
    OutputWarehouse & output_warehouse = _app.getOutputWarehouse();
    if (!output_warehouse.hasOutput("console"))
    {
      const std::string class_name = "Console";
      InputParameters params = _factory.getValidParams(class_name);
      params.addPrivateParam<FEProblemBase *>("_fe_problem_base", _problem.get());
      params.set<std::string>("file_base") = _app.getOutputFileBase();
      params.set<ExecFlagEnum>("execute_on") = EXEC_FINAL;
      params.set<MultiMooseEnum>("system_info") = "";
      std::shared_ptr<Output> output = _factory.create<Output>(class_name, "Console", params);
      output_warehouse.addOutput(output);
    }
  }
  else if (_current_task == "common_output")
  {
    // This action must satisfy this task to prevent CommonOutputAction from
    // acting, which performs a static cast that assumes that the action
    // satisfying the task "add_output" is derived from MooseObjectAction,
    // which is now false.
  }
  else if (_current_task == "add_output_aux_variables")
  {
    // This action must satisfy this task to prevent MaterialOutputAction from
    // acting, which assumes that the action satisfying "add_output" can be
    // dynamic_cast-ed to type "AddOutputAction", which is now false.
  }
}

addFluidPropertiesInterrogatorObject()

void AddFluidPropertiesInterrogatorAction::addFluidPropertiesInterrogatorObject ( ) const

protected

Adds the FluidPropertiesInterrogator user object.

Definition at line 140 of file AddFluidPropertiesInterrogatorAction.C.

Referenced by act().

{
  const std::string class_name = "FluidPropertiesInterrogator";
  InputParameters params = _factory.getValidParams(class_name);
  params.set<UserObjectName>("fp") = getParam<UserObjectName>("fp");
  // Only pass parameters that were supplied to this action
  if (isParamValid("rho"))
    params.set<Real>("rho") = getParam<Real>("rho");
  if (isParamValid("rhou"))
    params.set<Real>("rhou") = getParam<Real>("rhou");
  if (isParamValid("rhoE"))
    params.set<Real>("rhoE") = getParam<Real>("rhoE");
  if (isParamValid("e"))
    params.set<Real>("e") = getParam<Real>("e");
  if (isParamValid("p"))
    params.set<Real>("p") = getParam<Real>("p");
  if (isParamValid("T"))
    params.set<Real>("T") = getParam<Real>("T");
  if (isParamValid("vel"))
    params.set<Real>("vel") = getParam<Real>("vel");
  if (isParamValid("x_ncg"))
    params.set<std::vector<Real>>("x_ncg") = getParam<std::vector<Real>>("x_ncg");
  params.set<unsigned int>("precision") = getParam<unsigned int>("precision");
  params.set<bool>("json") = getParam<bool>("json");
  _problem->addUserObject(class_name, "fp_interrogator", params);
}

validParams()

InputParameters AddFluidPropertiesInterrogatorAction::validParams ( )

static

Definition at line 28 of file AddFluidPropertiesInterrogatorAction.C.

{
  InputParameters params = Action::validParams();
  params.addRequiredParam<UserObjectName>("fp",
                                          "The name of the fluid properties object to query.");
  params.addParam<Real>("rho", "Density");
  params.addParam<Real>("rhou", "Momentum density; rho * u");
  params.addParam<Real>("rhoE", "Total energy density: rho * E");
  params.addParam<Real>("e", "Specific internal energy");
  params.addParam<Real>("p", "Pressure");
  params.addParam<Real>("T", "Temperature");
  params.addParam<Real>("vel", "Velocity");
  params.addParam<std::vector<Real>>("x_ncg", "Mass fractions of NCGs");
  params.addParam<unsigned int>("precision", 10, "Precision for printing values");
  params.addParam<bool>("json", false, "Output in JSON format");

  params.addClassDescription("Action that sets up the fluid properties interrogator");

  return params;
}

---

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

• fluid_properties/include/actions/AddFluidPropertiesInterrogatorAction.h
• fluid_properties/src/actions/AddFluidPropertiesInterrogatorAction.C