FluidPropertiesInterrogator Class Reference

User object for querying a single-phase or two-phase fluid properties object. More...

#include <FluidPropertiesInterrogator.h>

Inheritance diagram for FluidPropertiesInterrogator:

Public Member Functions
	FluidPropertiesInterrogator (const InputParameters &parameters)
virtual void	initialize () override
virtual void	execute () override
virtual void	finalize () override

Protected Member Functions
InputParameters	compute1Phase (const SinglePhaseFluidProperties *const fp_1phase, bool throw_error_if_no_match)
	Queries a 1-phase fluid properties object. More...
InputParameters	computeVaporMixture (bool throw_error_if_no_match)
	Queries a vapor mixture fluid properties object. More...
InputParameters	compute2Phase ()
	Queries a 2-phase fluid properties object. More...
std::map< std::string, bool >	getSpecifiedSetMap (const std::vector< std::vector< std::string >> &parameter_sets, const std::string &fp_type, bool throw_error_if_no_match) const
	Gets a map of a parameter set to a flag telling whether that set was provided. More...
void	buildJSON1Phase (moosecontrib::Json::Value &json, const InputParameters &params)
	Build 1-phase fluid properties in JSON format. More...
void	buildJSON2Phase (moosecontrib::Json::Value &json, const InputParameters &params)
	Build 2-phase fluid properties in JSON format. More...
void	buildJSONVaporMixture (moosecontrib::Json::Value &json, const InputParameters &params)
	Build vapor mixture fluid properties in JSON format. More...
void	outputASCII1Phase (const std::string &description, const InputParameters &params)
	Output 1-phase fluid properties in plain text format. More...
void	outputASCII2Phase (const InputParameters &params)
	Output 2-phase fluid properties in plain text format. More...
void	outputASCIIVaporMixture (const InputParameters &params)
	Output vapor mixture fluid properties in plain text format. More...
void	outputHeader (const std::string &header) const
	Outputs a header for a section of properties. More...
void	outputProperty (const std::string &name, const Real &value, const std::string &units)
	Outputs a property value. More...
void	outputStaticProperties (const InputParameters &params)
	Outputs static properties for a single-phase fluid properties object. More...
void	outputStagnationProperties (const InputParameters &params)
	Outputs stagnation properties for a single-phase fluid properties object. More...
void	outputVaporMixtureStaticProperties (const InputParameters &params)
	Outputs static properties for a vapor mixture fluid properties object. More...
void	outputVaporMixtureStagnationProperties (const InputParameters &params)
	Outputs stagnation properties for a vapor mixture fluid properties object. More...

Protected Attributes
const bool &	_json
	true if the output should use JSON format More...
const FluidProperties *const	_fp
	pointer to fluid properties object More...
const SinglePhaseFluidProperties *const	_fp_1phase
	pointer to 1-phase fluid properties object (if provided 1-phase object) More...
const TwoPhaseFluidProperties *const	_fp_2phase
	pointer to 2-phase fluid properties object (if provided 2-phase object) More...
const TwoPhaseNCGFluidProperties *const	_fp_2phase_ncg
	pointer to 2-phase NCG fluid properties object (if provided 2-phase NCG object) More...
const bool	_has_1phase
	flag that user provided 1-phase fluid properties More...
const bool	_has_vapor_mixture
	flag that user provided vapor mixture fluid properties More...
const bool	_has_2phase
	flag that user provided 2-phase fluid properties More...
const bool	_has_2phase_ncg
	flag that user provided 2-phase NCG fluid properties More...
const SinglePhaseFluidProperties *const	_fp_liquid
	pointer to liquid fluid properties object (if provided 2-phase object) More...
const SinglePhaseFluidProperties *const	_fp_vapor
	pointer to vapor fluid properties object (if provided 2-phase object) More...
const VaporMixtureFluidProperties *const	_fp_vapor_mixture
	pointer to vapor mixture fluid properties object (if provided 2-phase NCG object) More...
bool	_nan_encountered
	flag that NaN has been encountered More...
const unsigned int &	_precision
	Precision used for printing values. More...

Detailed Description

User object for querying a single-phase or two-phase fluid properties object.

Definition at line 28 of file FluidPropertiesInterrogator.h.

Constructor & Destructor Documentation

FluidPropertiesInterrogator()

FluidPropertiesInterrogator::FluidPropertiesInterrogator

(

const InputParameters &

parameters

)

Definition at line 43 of file FluidPropertiesInterrogator.C.

  : GeneralUserObject(parameters),
    _json(getParam<bool>("json")),
    _fp(&getUserObject<FluidProperties>("fp")),
    _fp_1phase(dynamic_cast<const SinglePhaseFluidProperties * const>(_fp)),
    _fp_2phase(dynamic_cast<const TwoPhaseFluidProperties * const>(_fp)),
    _fp_2phase_ncg(dynamic_cast<const TwoPhaseNCGFluidProperties * const>(_fp)),
    _has_1phase(_fp_1phase),
    _has_vapor_mixture(dynamic_cast<const VaporMixtureFluidProperties * const>(_fp)),
    _has_2phase(_fp_2phase),
    _has_2phase_ncg(_fp_2phase_ncg),
    _fp_liquid(_has_2phase
                   ? &getUserObjectByName<SinglePhaseFluidProperties>(_fp_2phase->getLiquidName())
                   : nullptr),
    _fp_vapor(_has_2phase
                  ? &getUserObjectByName<SinglePhaseFluidProperties>(_fp_2phase->getVaporName())
                  : nullptr),
    _fp_vapor_mixture(_has_vapor_mixture
                          ? dynamic_cast<const VaporMixtureFluidProperties * const>(_fp)
                          : (_has_2phase_ncg ? &getUserObjectByName<VaporMixtureFluidProperties>(
                                                   _fp_2phase_ncg->getVaporMixtureName())
                                             : nullptr)),
    _nan_encountered(false),
    _precision(getParam<unsigned int>("precision"))
{
  if (!(_has_1phase || _has_2phase || _has_vapor_mixture))
    mooseError(
        "The type of the parameter 'fp' must be derived from type 'SinglePhaseFluidProperties', "
        "'VaporMixtureFluidProperties', or 'TwoPhaseFluidProperties'.");
}

Member Function Documentation

buildJSON1Phase()

void FluidPropertiesInterrogator::buildJSON1Phase ( moosecontrib::Json::Value &  json, const InputParameters &  params  )

protected

Build 1-phase fluid properties in JSON format.

Definition at line 484 of file FluidPropertiesInterrogator.C.

{
  for (auto p : {"rho", "e", "p", "T", "v", "h", "s", "c", "mu", "cp", "cv", "k", "beta"})
    json["static"][p] = params.get<Real>(p);
 
  if (params.have_parameter<Real>("vel"))
    for (auto p : {"vel",
                   "rho0",
                   "s0",
                   "v0",
                   "e0",
                   "h0",
                   "p0",
                   "T0",
                   "c0",
                   "mu0",
                   "cp0",
                   "cv0",
                   "k0",
                   "beta0"})
      json["stagnation"][p] = params.get<Real>(p);
}

Referenced by execute().

buildJSON2Phase()

void FluidPropertiesInterrogator::buildJSON2Phase ( moosecontrib::Json::Value &  json, const InputParameters &  params  )

protected

Build 2-phase fluid properties in JSON format.

Definition at line 509 of file FluidPropertiesInterrogator.C.

{
  json["p_critical"] = params.get<Real>("p_critical");
  for (auto p : {"T_sat", "p_sat", "h_lat", "sigma"})
    if (params.have_parameter<Real>(p))
      json[p] = params.get<Real>(p);
}

Referenced by execute().

buildJSONVaporMixture()

void FluidPropertiesInterrogator::buildJSONVaporMixture ( moosecontrib::Json::Value &  json, const InputParameters &  params  )

protected

Build vapor mixture fluid properties in JSON format.

Definition at line 519 of file FluidPropertiesInterrogator.C.

{
  for (auto p : {"p", "T", "rho", "e", "v", "h", "c", "mu", "cp", "cv", "k"})
    if (params.have_parameter<Real>(p))
      json["static"][p] = params.get<Real>(p);
 
  if (params.have_parameter<Real>("vel"))
    json["stagnation"]["h0"] = params.get<Real>("h0");
}

Referenced by execute().

compute1Phase()

InputParameters FluidPropertiesInterrogator::compute1Phase ( const SinglePhaseFluidProperties *const  fp_1phase, bool  throw_error_if_no_match  )

protected

Queries a 1-phase fluid properties object.

Returns

Input parameters holding the computed values

Parameters

[in]	fp_1phase	1-phase fluid properties
[in]	throw_error_if_no_match	Option to throw an error if no sets match the inputs

Definition at line 186 of file FluidPropertiesInterrogator.C.

{
  InputParameters params = emptyInputParameters();
 
  // reset NaN flag
  _nan_encountered = false;
 
  // determine how state is specified
  std::vector<std::vector<std::string>> parameter_sets = {{"p", "T"}, {"rho", "e"}, {"rho", "p"}};
  if (_has_1phase)
    parameter_sets.push_back({"rho", "rhou", "rhoE"});
  auto specified = getSpecifiedSetMap(parameter_sets, "one-phase", throw_error_if_no_match);
 
  // compute/determine rho, e, p, T, vel
 
  Real rho, e, p, T, vel = 0;
  bool specified_a_set = false;
  if (specified["rho,e"])
  {
    rho = getParam<Real>("rho");
    e = getParam<Real>("e");
    const Real v = 1.0 / rho;
    p = fp_1phase->p_from_v_e(v, e);
    T = fp_1phase->T_from_v_e(v, e);
    if (isParamValid("vel"))
      vel = getParam<Real>("vel");
 
    specified_a_set = true;
  }
  else if (specified["rho,p"])
  {
    rho = getParam<Real>("rho");
    p = getParam<Real>("p");
    const Real v = 1.0 / rho;
    e = fp_1phase->e_from_p_rho(p, rho);
    T = fp_1phase->T_from_v_e(v, e);
    if (isParamValid("vel"))
      vel = getParam<Real>("vel");
 
    specified_a_set = true;
  }
  else if (specified["p,T"])
  {
    p = getParam<Real>("p");
    T = getParam<Real>("T");
    rho = fp_1phase->rho_from_p_T(p, T);
    e = fp_1phase->e_from_p_rho(p, rho);
    if (isParamValid("vel"))
      vel = getParam<Real>("vel");
 
    specified_a_set = true;
  }
  else if (specified["rho,rhou,rhoE"])
  {
    rho = getParam<Real>("rho");
    const Real rhou = getParam<Real>("rhou");
    const Real rhoE = getParam<Real>("rhoE");
 
    vel = rhou / rho;
    const Real E = rhoE / rho;
    e = E - 0.5 * vel * vel;
 
    const Real v = 1.0 / rho;
    p = fp_1phase->p_from_v_e(v, e);
    T = fp_1phase->T_from_v_e(v, e);
 
    specified_a_set = true;
  }
 
  if (specified_a_set)
  {
    params.set<bool>("specified") = true;
 
    const Real v = 1.0 / rho;
 
    params.set<Real>("rho") = rho;
    params.set<Real>("e") = e;
    params.set<Real>("p") = p;
    params.set<Real>("T") = T;
    params.set<Real>("v") = v;
    params.set<Real>("h") = fp_1phase->h_from_p_T(p, T);
    params.set<Real>("s") = fp_1phase->s_from_v_e(v, e);
    params.set<Real>("c") = fp_1phase->c_from_v_e(v, e);
    params.set<Real>("mu") = fp_1phase->mu_from_v_e(v, e);
    params.set<Real>("cp") = fp_1phase->cp_from_v_e(v, e);
    params.set<Real>("cv") = fp_1phase->cv_from_v_e(v, e);
    params.set<Real>("k") = fp_1phase->k_from_v_e(v, e);
    params.set<Real>("beta") = fp_1phase->beta_from_p_T(p, T);
 
    if (isParamValid("vel") || specified["rho,rhou,rhoE"])
    {
      const Real s = fp_1phase->s_from_v_e(v, e);
      const Real s0 = s;
      const Real h = fp_1phase->h_from_p_T(p, T);
      const Real h0 = h + 0.5 * vel * vel;
      const Real p0 = fp_1phase->p_from_h_s(h0, s0);
      const Real rho0 = fp_1phase->rho_from_p_s(p0, s0);
      const Real e0 = fp_1phase->e_from_p_rho(p0, rho0);
      const Real v0 = 1.0 / rho0;
      const Real T0 = fp_1phase->T_from_v_e(v0, e0);
      const Real c0 = fp_1phase->c_from_v_e(v0, e0);
      const Real mu0 = fp_1phase->mu_from_v_e(v0, e0);
      const Real cp0 = fp_1phase->cp_from_v_e(v0, e0);
      const Real cv0 = fp_1phase->cv_from_v_e(v0, e0);
      const Real k0 = fp_1phase->k_from_v_e(v0, e0);
      const Real beta0 = fp_1phase->beta_from_p_T(p0, T0);
 
      params.set<Real>("vel") = vel;
      params.set<Real>("rho0") = rho0;
      params.set<Real>("s0") = s0;
      params.set<Real>("v0") = v0;
      params.set<Real>("e0") = e0;
      params.set<Real>("h0") = h0;
      params.set<Real>("p0") = p0;
      params.set<Real>("T0") = T0;
      params.set<Real>("c0") = c0;
      params.set<Real>("mu0") = mu0;
      params.set<Real>("cp0") = cp0;
      params.set<Real>("cv0") = cv0;
      params.set<Real>("k0") = k0;
      params.set<Real>("beta0") = beta0;
    }
 
    // warn if NaN encountered
    if (_nan_encountered)
      mooseWarning(
          "At least one NaN was encountered. This implies one of the following:\n",
          "  1. The specified thermodynamic state is inconsistent with the equation of state\n",
          "     (for example, the state corresponds to a different phase of the fluid).\n",
          "  2. There is a problem with the equation of state package at this state\n",
          "     (for example, the supplied state is outside of the valid state space\n",
          "     that was programmed in the package).");
  }
 
  return params;
}

Referenced by execute().

compute2Phase()

InputParameters FluidPropertiesInterrogator::compute2Phase ( )

protected

Queries a 2-phase fluid properties object.

Returns

Input parameters holding the computed values

Definition at line 325 of file FluidPropertiesInterrogator.C.

{
  InputParameters params = emptyInputParameters();
 
  // reset NaN flag
  _nan_encountered = false;
 
  // determine how state is specified
  std::vector<std::vector<std::string>> parameter_sets = {{"p", "T"}, {"p"}, {"T"}};
  auto specified = getSpecifiedSetMap(parameter_sets, "two-phase", true);
 
  const Real p_critical = _fp_2phase->p_critical();
  params.set<Real>("p_critical") = p_critical;
  if (specified["p"])
  {
    const Real p = getParam<Real>("p");
    const Real T_sat = _fp_2phase->T_sat(p);
    const Real h_lat = _fp_2phase->h_lat(p, T_sat);
 
    params.set<Real>("p") = p;
    params.set<Real>("T_sat") = T_sat;
    params.set<Real>("h_lat") = h_lat;
  }
  else if (specified["T"])
  {
    const Real T = getParam<Real>("T");
    const Real p_sat = _fp_2phase->p_sat(T);
    const Real h_lat = _fp_2phase->h_lat(p_sat, T);
    const Real sigma = _fp_2phase->sigma_from_T(T);
 
    params.set<Real>("T") = T;
    params.set<Real>("p_sat") = p_sat;
    params.set<Real>("h_lat") = h_lat;
    params.set<Real>("sigma") = sigma;
  }
  else if (specified["p,T"])
  {
    const Real p = getParam<Real>("p");
    const Real T = getParam<Real>("T");
    const Real h_lat = _fp_2phase->h_lat(p, T);
 
    params.set<Real>("p") = p;
    params.set<Real>("T") = T;
    params.set<Real>("h_lat") = h_lat;
  }
 
  // warn if NaN encountered
  if (_nan_encountered)
    mooseWarning("At least one NaN was encountered.");
 
  return params;
}

Referenced by execute().

computeVaporMixture()

InputParameters FluidPropertiesInterrogator::computeVaporMixture ( bool  throw_error_if_no_match )

protected

Queries a vapor mixture fluid properties object.

Returns

Input parameters holding the computed values

Parameters

[in]

throw_error_if_no_match

Option to throw an error if no sets match the inputs

Definition at line 379 of file FluidPropertiesInterrogator.C.

{
  InputParameters params = emptyInputParameters();
 
  // reset NaN flag
  _nan_encountered = false;
 
  // determine how state is specified
  std::vector<std::vector<std::string>> parameter_sets = {
      {"p", "T", "x_ncg"}, {"rho", "e", "x_ncg"}, {"rho", "rhou", "rhoE", "x_ncg"}};
  auto specified = getSpecifiedSetMap(parameter_sets, "vapor mixture", throw_error_if_no_match);
 
  const auto x_ncg = getParam<std::vector<Real>>("x_ncg");
 
  // compute/determine rho, e, p, T, vel
 
  Real rho, e, p, T, vel = 0;
  bool specified_a_set = false;
  if (specified["rho,e,x_ncg"])
  {
    rho = getParam<Real>("rho");
    e = getParam<Real>("e");
    const Real v = 1.0 / rho;
    p = _fp_vapor_mixture->p_from_v_e(v, e, x_ncg);
    T = _fp_vapor_mixture->T_from_v_e(v, e, x_ncg);
    if (isParamValid("vel"))
      vel = getParam<Real>("vel");
 
    specified_a_set = true;
  }
  else if (specified["p,T,x_ncg"])
  {
    p = getParam<Real>("p");
    T = getParam<Real>("T");
    rho = _fp_vapor_mixture->rho_from_p_T(p, T, x_ncg);
    e = _fp_vapor_mixture->e_from_p_T(p, T, x_ncg);
    if (isParamValid("vel"))
      vel = getParam<Real>("vel");
 
    specified_a_set = true;
  }
  else if (specified["rho,rhou,rhoE,x_ncg"])
  {
    rho = getParam<Real>("rho");
    const Real rhou = getParam<Real>("rhou");
    const Real rhoE = getParam<Real>("rhoE");
 
    vel = rhou / rho;
    const Real E = rhoE / rho;
    e = E - 0.5 * vel * vel;
 
    const Real v = 1.0 / rho;
    p = _fp_vapor_mixture->p_from_v_e(v, e, x_ncg);
    T = _fp_vapor_mixture->T_from_v_e(v, e, x_ncg);
 
    specified_a_set = true;
  }
 
  if (specified_a_set)
  {
    params.set<bool>("specified") = true;
 
    const Real v = 1.0 / rho;
    const Real h = e + p / rho;
    const Real c = _fp_vapor_mixture->c_from_p_T(p, T, x_ncg);
    const Real mu = _fp_vapor_mixture->mu_from_p_T(p, T, x_ncg);
    const Real cp = _fp_vapor_mixture->cp_from_p_T(p, T, x_ncg);
    const Real cv = _fp_vapor_mixture->cv_from_p_T(p, T, x_ncg);
    const Real k = _fp_vapor_mixture->k_from_p_T(p, T, x_ncg);
 
    params.set<Real>("p") = p;
    params.set<Real>("T") = T;
    params.set<Real>("rho") = rho;
    params.set<Real>("e") = e;
    params.set<Real>("v") = v;
    params.set<Real>("h") = h;
    params.set<Real>("c") = c;
    params.set<Real>("mu") = mu;
    params.set<Real>("cp") = cp;
    params.set<Real>("cv") = cv;
    params.set<Real>("k") = k;
 
    if (isParamValid("vel") || specified["rho,rhou,rhoE,x_ncg"])
    {
      const Real h = e + p / rho;
      const Real h0 = h + 0.5 * vel * vel;
 
      params.set<Real>("h0") = h0;
    }
 
    // warn if NaN encountered
    if (_nan_encountered)
      mooseWarning(
          "At least one NaN was encountered. This implies one of the following:\n",
          "  1. The specified thermodynamic state is inconsistent with the equation of state\n",
          "     (for example, the state corresponds to a different phase of the fluid).\n",
          "  2. There is a problem with the equation of state package at this state\n",
          "     (for example, the supplied state is outside of the valid state space\n",
          "     that was programmed in the package).");
  }
 
  return params;
}

Referenced by execute().

execute()

void FluidPropertiesInterrogator::execute ( )

overridevirtual

Definition at line 80 of file FluidPropertiesInterrogator.C.

{
  if (_has_2phase_ncg)
  {
    InputParameters pars_2phase = compute2Phase();
    InputParameters pars_liquid = compute1Phase(_fp_liquid, false);
    InputParameters pars_mixture = computeVaporMixture(false);
 
    if (_json)
    {
      moosecontrib::Json::Value json;
 
      auto & json_2phase = json["2-phase"];
      buildJSON2Phase(json_2phase, pars_2phase);
      auto & json_liquid = json["liquid"];
      buildJSON1Phase(json_liquid, pars_liquid);
      auto & json_mixture = json["vapor-mixture"];
      buildJSONVaporMixture(json_mixture, pars_mixture);
 
      Moose::out << "**START JSON DATA**\n";
      Moose::out << json << "\n";
      Moose::out << "**END JSON DATA**\n";
    }
    else
    {
      outputASCII2Phase(pars_2phase);
      outputASCII1Phase("LIQUID phase", pars_liquid);
      outputASCIIVaporMixture(pars_mixture);
    }
  }
  else if (_has_2phase)
  {
    InputParameters pars_2phase = compute2Phase();
    InputParameters pars_liquid = compute1Phase(_fp_liquid, false);
    InputParameters pars_vapor = compute1Phase(_fp_vapor, false);
 
    if (_json)
    {
      moosecontrib::Json::Value json;
 
      auto & json_2phase = json["2-phase"];
      buildJSON2Phase(json_2phase, pars_2phase);
      if (pars_liquid.have_parameter<bool>("specified"))
      {
        auto & json_liquid = json["liquid"];
        buildJSON1Phase(json_liquid, pars_liquid);
      }
      if (pars_vapor.have_parameter<bool>("specified"))
      {
        auto & json_vapor = json["vapor"];
        buildJSON1Phase(json_vapor, pars_vapor);
      }
 
      Moose::out << "**START JSON DATA**\n";
      Moose::out << json << "\n";
      Moose::out << "**END JSON DATA**\n";
    }
    else
    {
      outputASCII2Phase(pars_2phase);
      if (pars_liquid.have_parameter<bool>("specified"))
        outputASCII1Phase("LIQUID phase", pars_liquid);
      if (pars_vapor.have_parameter<bool>("specified"))
        outputASCII1Phase("VAPOR phase", pars_vapor);
    }
  }
  else if (_has_vapor_mixture)
  {
    InputParameters pars_mixture = computeVaporMixture(true);
    if (_json)
    {
      moosecontrib::Json::Value json;
      buildJSONVaporMixture(json, pars_mixture);
 
      Moose::out << "**START JSON DATA**\n";
      Moose::out << json << "\n";
      Moose::out << "**END JSON DATA**\n";
    }
    else
      outputASCIIVaporMixture(pars_mixture);
  }
  else
  {
    InputParameters pars_1phase = compute1Phase(_fp_1phase, true);
 
    if (_json)
    {
      moosecontrib::Json::Value json;
 
      buildJSON1Phase(json, pars_1phase);
 
      Moose::out << "**START JSON DATA**\n";
      Moose::out << json << "\n";
      Moose::out << "**END JSON DATA**\n";
    }
    else
      outputASCII1Phase("Single-phase", pars_1phase);
  }
}

finalize()

void FluidPropertiesInterrogator::finalize ( )

overridevirtual

Definition at line 181 of file FluidPropertiesInterrogator.C.

{
}

getSpecifiedSetMap()

std::map< std::string, bool > FluidPropertiesInterrogator::getSpecifiedSetMap ( const std::vector< std::vector< std::string >> &  parameter_sets, const std::string &  fp_type, bool  throw_error_if_no_match  ) const

protected

Gets a map of a parameter set to a flag telling whether that set was provided.

Parameters

[in]	parameter_sets	vector of vectors of strings of parameter names. The first dimension is the parameter set, and the second dimension is a parameter within the set. If a set is a subset of another set, the subset should be after the other.
[in]	fp_type	string used to identify the set of parameter sets
[in]	throw_error_if_no_match	Option to throw an error if no sets match the inputs

Definition at line 578 of file FluidPropertiesInterrogator.C.

{
  // get union of parameters from all sets
  std::vector<std::string> parameter_union;
  for (auto & parameter_set : parameter_sets)
    parameter_union.insert(parameter_union.end(), parameter_set.begin(), parameter_set.end());
  std::sort(parameter_union.begin(), parameter_union.end());
  parameter_union.erase(std::unique(parameter_union.begin(), parameter_union.end()),
                        parameter_union.end());
 
  std::vector<std::string> parameter_set_names;
  std::map<std::string, bool> specified;
  bool specified_a_set = false;
  for (const auto & parameter_set : parameter_sets)
  {
    // create unique string to identify parameter set
    std::stringstream ss;
    for (unsigned int i = 0; i < parameter_set.size(); i++)
      if (i == 0)
        ss << parameter_set[i];
      else
        ss << "," << parameter_set[i];
    const std::string parameter_set_name = ss.str();
    parameter_set_names.push_back(parameter_set_name);
 
    // check if the set parameters were provided
    bool all_parameters_provided = true;
    for (const auto & parameter : parameter_set)
      if (!isParamValid(parameter))
        all_parameters_provided = false;
 
    if (all_parameters_provided)
    {
      // exclude set if a superset (assumed to be ordered before this set) was specified
      if (!specified_a_set)
      {
        specified[parameter_set_name] = true;
 
        // check that there are no extraneous parameters
        std::vector<std::string> parameter_set_sorted(parameter_set);
        std::sort(parameter_set_sorted.begin(), parameter_set_sorted.end());
        std::vector<std::string> extraneous_parameters;
        std::set_difference(parameter_union.begin(),
                            parameter_union.end(),
                            parameter_set_sorted.begin(),
                            parameter_set_sorted.end(),
                            std::inserter(extraneous_parameters, extraneous_parameters.end()));
        for (const auto & parameter : extraneous_parameters)
          if (isParamValid(parameter))
            mooseError(name(),
                       ": (",
                       parameter_set_name,
                       ") has been specified; ",
                       parameter,
                       " cannot be specified.");
      }
 
      specified_a_set = true;
    }
    else
      specified[parameter_set_name] = false;
  }
 
  if (!specified_a_set && throw_error_if_no_match)
  {
    std::stringstream ss;
    ss << name() << ": For " << fp_type
       << " fluid properties, you must provide one of the following\n"
          "combinations of thermodynamic properties:\n";
    for (const auto & parameter_set_name : parameter_set_names)
      ss << "  * (" << parameter_set_name << ")\n";
    mooseError(ss.str());
  }
 
  return specified;
}

Referenced by compute1Phase(), compute2Phase(), and computeVaporMixture().

initialize()

void FluidPropertiesInterrogator::initialize ( )

overridevirtual

Definition at line 75 of file FluidPropertiesInterrogator.C.

{
}

outputASCII1Phase()

void FluidPropertiesInterrogator::outputASCII1Phase ( const std::string &  description, const InputParameters &  params  )

protected

Output 1-phase fluid properties in plain text format.

Parameters

[in]	description	String describing the 1-phase fluid properties
[in]	params	Input parameters with values to print

Definition at line 531 of file FluidPropertiesInterrogator.C.

{
  // output static property values
  outputHeader(description + " STATIC properties");
  outputStaticProperties(params);
 
  // output stagnation property values
  if (params.have_parameter<Real>("vel"))
  {
    outputHeader(description + " STAGNATION properties");
    outputStagnationProperties(params);
  }
}

Referenced by execute().

outputASCII2Phase()

void FluidPropertiesInterrogator::outputASCII2Phase ( const InputParameters &  params )

protected

Output 2-phase fluid properties in plain text format.

Parameters

[in]

params

Input parameters with values to print

Definition at line 547 of file FluidPropertiesInterrogator.C.

{
  outputHeader("TWO-PHASE properties");
  outputProperty("Critical pressure", params.get<Real>("p_critical"), "Pa");
  if (params.have_parameter<Real>("T_sat"))
    outputProperty("Saturation temperature", params.get<Real>("T_sat"), "K");
  if (params.have_parameter<Real>("p_sat"))
    outputProperty("Saturation pressure", params.get<Real>("p_sat"), "Pa");
  if (params.have_parameter<Real>("h_lat"))
    outputProperty("Latent heat of vaporization", params.get<Real>("h_lat"), "J/kg");
  if (params.have_parameter<Real>("sigma"))
    outputProperty("Surface tension", params.get<Real>("sigma"), "N/m");
  _console << std::endl;
}

Referenced by execute().

outputASCIIVaporMixture()

void FluidPropertiesInterrogator::outputASCIIVaporMixture ( const InputParameters &  params )

protected

Output vapor mixture fluid properties in plain text format.

Parameters

[in]

params

Input parameters with values to print

Definition at line 563 of file FluidPropertiesInterrogator.C.

{
  // output static property values
  outputHeader("Vapor mixture STATIC properties");
  outputVaporMixtureStaticProperties(params);
 
  // output stagnation property values
  if (params.have_parameter<Real>("vel"))
  {
    outputHeader("Vapor mixture STAGNATION properties");
    outputVaporMixtureStagnationProperties(params);
  }
}

Referenced by execute().

outputHeader()

void FluidPropertiesInterrogator::outputHeader ( const std::string &  header ) const

protected

Outputs a header for a section of properties.

Definition at line 659 of file FluidPropertiesInterrogator.C.

{
  _console << std::endl
           << std::endl
           << header << ":" << std::endl
           << std::setfill('-') << std::setw(80) << "-" << std::setfill(' ') << std::endl;
}

Referenced by outputASCII1Phase(), outputASCII2Phase(), and outputASCIIVaporMixture().

outputProperty()

void FluidPropertiesInterrogator::outputProperty ( const std::string &  name, const Real &  value, const std::string &  units  )

protected

Outputs a property value.

Definition at line 668 of file FluidPropertiesInterrogator.C.

{
  const bool use_scientific_notation = ((value < 0.001) || (value >= 10000.0));
 
  // check for NaN value
  const bool is_nan = value != value;
  if (is_nan)
    _nan_encountered = true;
 
  const std::string units_printed = is_nan ? "" : units;
 
  // The console output is not used directly because there is no way to reset
  // format flags. For example, if scientific format is used, there is no way
  // to restore the general format (not fixed format); for cout, there are
  // methods to save and restore format flags, but Console does not provide these.
  std::stringstream ss;
 
  if (use_scientific_notation)
    ss << std::setw(35) << std::left << name + ":" << std::setw(_precision + 10) << std::right
       << std::setprecision(_precision) << std::scientific << value << "  " << units_printed
       << std::endl;
  else
    ss << std::setw(35) << std::left << name + ":" << std::setw(_precision + 10) << std::right
       << std::setprecision(_precision) << value << "  " << units_printed << std::endl;
 
  _console << ss.str();
}

Referenced by outputASCII2Phase(), outputStagnationProperties(), outputStaticProperties(), outputVaporMixtureStagnationProperties(), and outputVaporMixtureStaticProperties().

outputStagnationProperties()

void FluidPropertiesInterrogator::outputStagnationProperties ( const InputParameters &  params )

protected

Outputs stagnation properties for a single-phase fluid properties object.

Parameters

[in]

params

Input parameters with values to print

Definition at line 719 of file FluidPropertiesInterrogator.C.

{
  outputProperty("Pressure", params.get<Real>("p0"), "Pa");
  outputProperty("Temperature", params.get<Real>("T0"), "K");
  outputProperty("Density", params.get<Real>("rho0"), "kg/m^3");
  outputProperty("Specific volume", params.get<Real>("v0"), "m^3/kg");
  outputProperty("Specific internal energy", params.get<Real>("e0"), "J/kg");
  outputProperty("Specific enthalpy", params.get<Real>("h0"), "J/kg");
  outputProperty("Specific entropy", params.get<Real>("s0"), "J/kg");
  _console << std::endl;
  outputProperty("Sound speed", params.get<Real>("c0"), "m/s");
  outputProperty("Dynamic viscosity", params.get<Real>("mu0"), "Pa-s");
  outputProperty("Specific heat at constant pressure", params.get<Real>("cp0"), "J/(kg-K)");
  outputProperty("Specific heat at constant volume", params.get<Real>("cv0"), "J/(kg-K)");
  outputProperty("Thermal conductivity", params.get<Real>("k0"), "W/(m-K)");
  outputProperty("Volumetric expansion coefficient", params.get<Real>("beta0"), "1/K");
  _console << std::endl;
}

Referenced by outputASCII1Phase().

outputStaticProperties()

void FluidPropertiesInterrogator::outputStaticProperties ( const InputParameters &  params )

protected

Outputs static properties for a single-phase fluid properties object.

Parameters

[in]

params

Input parameters with values to print

Definition at line 699 of file FluidPropertiesInterrogator.C.

{
  outputProperty("Pressure", params.get<Real>("p"), "Pa");
  outputProperty("Temperature", params.get<Real>("T"), "K");
  outputProperty("Density", params.get<Real>("rho"), "kg/m^3");
  outputProperty("Specific volume", params.get<Real>("v"), "m^3/kg");
  outputProperty("Specific internal energy", params.get<Real>("e"), "J/kg");
  outputProperty("Specific enthalpy", params.get<Real>("h"), "J/kg");
  outputProperty("Specific entropy", params.get<Real>("s"), "J/kg");
  _console << std::endl;
  outputProperty("Sound speed", params.get<Real>("c"), "m/s");
  outputProperty("Dynamic viscosity", params.get<Real>("mu"), "Pa-s");
  outputProperty("Specific heat at constant pressure", params.get<Real>("cp"), "J/(kg-K)");
  outputProperty("Specific heat at constant volume", params.get<Real>("cv"), "J/(kg-K)");
  outputProperty("Thermal conductivity", params.get<Real>("k"), "W/(m-K)");
  outputProperty("Volumetric expansion coefficient", params.get<Real>("beta"), "1/K");
  _console << std::endl;
}

Referenced by outputASCII1Phase().

outputVaporMixtureStagnationProperties()

void FluidPropertiesInterrogator::outputVaporMixtureStagnationProperties ( const InputParameters &  params )

protected

Outputs stagnation properties for a vapor mixture fluid properties object.

Parameters

[in]

params

Input parameters with values to print

Definition at line 757 of file FluidPropertiesInterrogator.C.

{
  outputProperty("Specific enthalpy", params.get<Real>("h0"), "J/kg");
  _console << std::endl;
}

Referenced by outputASCIIVaporMixture().

outputVaporMixtureStaticProperties()

void FluidPropertiesInterrogator::outputVaporMixtureStaticProperties ( const InputParameters &  params )

protected

Outputs static properties for a vapor mixture fluid properties object.

Parameters

[in]

params

Input parameters with values to print

Definition at line 739 of file FluidPropertiesInterrogator.C.

{
  outputProperty("Pressure", params.get<Real>("p"), "Pa");
  outputProperty("Temperature", params.get<Real>("T"), "K");
  outputProperty("Density", params.get<Real>("rho"), "kg/m^3");
  outputProperty("Specific volume", params.get<Real>("v"), "m^3/kg");
  outputProperty("Specific internal energy", params.get<Real>("e"), "J/kg");
  outputProperty("Specific enthalpy", params.get<Real>("h"), "J/kg");
  _console << std::endl;
  outputProperty("Sound speed", params.get<Real>("c"), "m/s");
  outputProperty("Dynamic viscosity", params.get<Real>("mu"), "Pa-s");
  outputProperty("Specific heat at constant pressure", params.get<Real>("cp"), "J/(kg-K)");
  outputProperty("Specific heat at constant volume", params.get<Real>("cv"), "J/(kg-K)");
  outputProperty("Thermal conductivity", params.get<Real>("k"), "W/(m-K)");
  _console << std::endl;
}

Referenced by outputASCIIVaporMixture().

Member Data Documentation

_fp

const FluidProperties* const FluidPropertiesInterrogator::_fp

protected

pointer to fluid properties object

Definition at line 159 of file FluidPropertiesInterrogator.h.

_fp_1phase

const SinglePhaseFluidProperties* const FluidPropertiesInterrogator::_fp_1phase

protected

pointer to 1-phase fluid properties object (if provided 1-phase object)

Definition at line 161 of file FluidPropertiesInterrogator.h.

Referenced by execute().

_fp_2phase

const TwoPhaseFluidProperties* const FluidPropertiesInterrogator::_fp_2phase

protected

pointer to 2-phase fluid properties object (if provided 2-phase object)

Definition at line 163 of file FluidPropertiesInterrogator.h.

Referenced by compute2Phase().

_fp_2phase_ncg

const TwoPhaseNCGFluidProperties* const FluidPropertiesInterrogator::_fp_2phase_ncg

protected

pointer to 2-phase NCG fluid properties object (if provided 2-phase NCG object)

Definition at line 165 of file FluidPropertiesInterrogator.h.

_fp_liquid

const SinglePhaseFluidProperties* const FluidPropertiesInterrogator::_fp_liquid

protected

pointer to liquid fluid properties object (if provided 2-phase object)

Definition at line 177 of file FluidPropertiesInterrogator.h.

Referenced by execute().

_fp_vapor

const SinglePhaseFluidProperties* const FluidPropertiesInterrogator::_fp_vapor

protected

pointer to vapor fluid properties object (if provided 2-phase object)

Definition at line 179 of file FluidPropertiesInterrogator.h.

Referenced by execute().

_fp_vapor_mixture

const VaporMixtureFluidProperties* const FluidPropertiesInterrogator::_fp_vapor_mixture

protected

pointer to vapor mixture fluid properties object (if provided 2-phase NCG object)

Definition at line 181 of file FluidPropertiesInterrogator.h.

Referenced by computeVaporMixture().

_has_1phase

const bool FluidPropertiesInterrogator::_has_1phase

protected

flag that user provided 1-phase fluid properties

Definition at line 168 of file FluidPropertiesInterrogator.h.

Referenced by compute1Phase(), and FluidPropertiesInterrogator().

_has_2phase

const bool FluidPropertiesInterrogator::_has_2phase

protected

flag that user provided 2-phase fluid properties

Definition at line 172 of file FluidPropertiesInterrogator.h.

Referenced by execute(), and FluidPropertiesInterrogator().

_has_2phase_ncg

const bool FluidPropertiesInterrogator::_has_2phase_ncg

protected

flag that user provided 2-phase NCG fluid properties

Definition at line 174 of file FluidPropertiesInterrogator.h.

Referenced by execute().

_has_vapor_mixture

const bool FluidPropertiesInterrogator::_has_vapor_mixture

protected

flag that user provided vapor mixture fluid properties

Definition at line 170 of file FluidPropertiesInterrogator.h.

Referenced by execute(), and FluidPropertiesInterrogator().

_json

const bool& FluidPropertiesInterrogator::_json

protected

true if the output should use JSON format

Definition at line 157 of file FluidPropertiesInterrogator.h.

Referenced by execute().

_nan_encountered

bool FluidPropertiesInterrogator::_nan_encountered

protected

flag that NaN has been encountered

Definition at line 184 of file FluidPropertiesInterrogator.h.

Referenced by compute1Phase(), compute2Phase(), computeVaporMixture(), and outputProperty().

_precision

const unsigned int& FluidPropertiesInterrogator::_precision

protected

Precision used for printing values.

Definition at line 187 of file FluidPropertiesInterrogator.h.

Referenced by outputProperty().

---

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

• fluid_properties/include/userobjects/FluidPropertiesInterrogator.h
• fluid_properties/src/userobjects/FluidPropertiesInterrogator.C