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

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

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

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)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
void	addFluidPropertiesInterrogatorObject () const
	Adds the FluidPropertiesInterrogator user object.

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) 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

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, 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)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

void	mooseErrorInternal (Args &&... args) const

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

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

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

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.

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

Referenced by act().

◆ 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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions