#include <PiecewiseTabularInterface.h>

Inheritance diagram for PiecewiseTabularInterface:

Public Member Functions
	PiecewiseTabularInterface (const MooseObject &object, std::vector< Real > &data_x, std::vector< Real > &data_y)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
bool	isRawDataLoaded () const
	Returns whether the raw data has been loaded already.

void	buildFromFile (const libMesh::Parallel::Communicator &comm)
	Reads data from supplied CSV file.

void	buildFromJSON (const JSONFileReader &json_uo)
	Reads data from supplied JSON reader.

void	buildFromXandY ()
	Builds data from 'x' and 'y' parameters.

void	buildFromXY ()
	Builds data from 'xy_data' parameter.

Protected Attributes

unsigned int	_axis
	if _has_axis is true point component to use as function argument, otherwise use t

const bool	_has_axis

Private Attributes
const MooseObject &	_object
	The object.

const InputParameters &	_parameters
	Parameters supplied to the object.

bool	_raw_data_loaded = false
	Boolean to keep track of whether the data has been loaded.


std::vector< Real > &	_data_x
	raw function data as read

std::vector< Real > &	_data_y

Detailed Description

Definition at line 17 of file PiecewiseTabularInterface.h.

Constructor & Destructor Documentation

◆ PiecewiseTabularInterface()

PiecewiseTabularInterface::PiecewiseTabularInterface	(	const MooseObject &	object,
		std::vector< Real > &	data_x,
		std::vector< Real > &	data_y
	)

Definition at line 62 of file PiecewiseTabularInterface.C.

  : _has_axis(object.isParamValid("axis")),
    _object(object),
    _parameters(object.parameters()),
    _data_x(data_x),
    _data_y(data_y)
{
  // determine function argument
  if (_has_axis)
    _axis = _parameters.get<MooseEnum>("axis");
 
  // Check all parameters for inconsistencies
  if (_parameters.isParamValid("data_file") + _parameters.isParamValid("json_uo") +
          (_parameters.isParamValid("x") || _parameters.isParamValid("y")) +
          _parameters.isParamValid("xy_data") >
      1)
    _object.mooseError(
        "Either 'data_file' or 'json_uo' or 'x' and 'y' or 'xy_data' must be specified "
        "exclusively.");
  if ((_parameters.isParamValid("x") + _parameters.isParamValid("y")) % 2 != 0)
    _object.mooseError(
        "Both 'x' and 'y' parameters or neither (for another input method) must be specified");
  if (!_parameters.isParamValid("data_file") &&
      (_parameters.isParamSetByUser("x_index_in_file") ||
       _parameters.isParamSetByUser("y_index_in_file") || _parameters.isParamValid("x_title") ||
       _parameters.isParamValid("y_title") || _parameters.isParamSetByUser("xy_in_file_only") ||
       _parameters.isParamSetByUser("format")))
    _object.mooseError(
        "A parameter was passed for an option using data from a CSV file but the "
        "'data_file' parameter has not been set. This is not allowed. Please check the parameter "
        "groups in the documentation for the list of parameters for each data input method.");
  if (!_parameters.isParamValid("json_uo") &&
      (_parameters.isParamValid("x_keys") || _parameters.isParamValid("y_keys")))
    _object.mooseError(
        "A parameter was passed for a JSON input option but the 'json_uo' parameter has not "
        "been set. This is not allowed. Please check the parameter groups in the "
        "documentation for the list of parameters for each data input method.");
}

Member Function Documentation

◆ buildFromFile()

void PiecewiseTabularInterface::buildFromFile ( const libMesh::Parallel::Communicator & comm )

protected

Reads data from supplied CSV file.

Definition at line 104 of file PiecewiseTabularInterface.C.

{
  // Input parameters
  const auto & data_file_name = _parameters.get<FileName>("data_file");
  const MooseEnum & format = _parameters.get<MooseEnum>("format");
 
  // xy_in_file_only does not make sense here as it restricts the file to exactly
  // two cows/columns, which is not a likely scenario when looking up data by name.
  // A wrong 'format' parameter would be caught by the failing name resolution anyways.
  bool xy_only = _parameters.get<bool>("xy_in_file_only");
  if (_parameters.isParamValid("x_title") || _parameters.isParamValid("y_title"))
  {
    if (_parameters.isParamSetByUser("xy_in_file_only") && xy_only)
      _parameters.paramError(
          "xy_in_file_only",
          "When accessing data through 'x_title' or 'y_title' this parameter should not be used");
    else
      xy_only = false;
  }
 
  // Read the data from CSV file
  MooseUtils::DelimitedFileReader reader(data_file_name, &comm);
  reader.setFormatFlag(format.getEnum<MooseUtils::DelimitedFileReader::FormatFlag>());
  reader.setComment("#");
  reader.read();
 
  const auto & columns = reader.getNames();
  const auto & data = reader.getData();
 
  if (data.size() > 2 && xy_only)
    _object.mooseError("In ",
                       _object.name(),
                       ": Read more than two ",
                       format,
                       " of data from file '",
                       data_file_name,
                       "'.  Did you mean to use \"format = ",
                       format == "columns" ? "rows" : "columns",
                       "\" or set \"xy_in_file_only\" to false?");
 
  unsigned int x_index = libMesh::invalid_uint;
  unsigned int y_index = libMesh::invalid_uint;
  const auto setIndex = [&](unsigned int & index, const std::string & prefix)
  {
    if (_parameters.isParamValid(prefix + "_title"))
    {
      const auto name = _parameters.get<std::string>(prefix + "_title");
      for (const auto i : index_range(columns))
        if (columns[i] == name)
          index = i;
 
      if (index == libMesh::invalid_uint)
        _parameters.paramError(prefix + "_title",
                               "None of the ",
                               format,
                               " in the data file has the title '",
                               name,
                               "'.");
    }
    else
      index = _parameters.get<unsigned int>(prefix + "_index_in_file");
 
    if (index >= data.size())
      _parameters.paramError(prefix + "_index_in_file",
                             "Index out-of-range of the available data in '",
                             data_file_name,
                             "', which contains ",
                             data.size(),
                             " ",
                             format,
                             " of data.");
  };
 
  setIndex(x_index, "x");
  setIndex(y_index, "y");
 
  if (x_index == y_index)
    _object.mooseError("In ",
                       _object.name(),
                       ": 'x_index_in_file' and 'y_index_in_file' are set to the same value.");
 
  // Update the input vectors to contained the desired data
  _data_x = reader.getData(x_index);
  _data_y = reader.getData(y_index);
 
  // Size mismatch error
  if (_data_x.size() != _data_y.size())
    _object.mooseError("In ", _object.name(), ": Lengths of x and y data do not match.");
 
  _raw_data_loaded = true;
}

◆ buildFromJSON()

void PiecewiseTabularInterface::buildFromJSON ( const JSONFileReader & json_uo )

protected

Reads data from supplied JSON reader.

Definition at line 197 of file PiecewiseTabularInterface.C.

{
  if (!_parameters.isParamValid("x_keys"))
    _object.mooseError("Missing 'x_keys' parameters for loading data from JSON");
  if (!_parameters.isParamValid("y_keys"))
    _object.mooseError("Missing 'y_keys' parameters for loading data from JSON");
  json_uo.getVector<Real>(_parameters.get<std::vector<std::string>>("x_keys"), _data_x);
  json_uo.getVector<Real>(_parameters.get<std::vector<std::string>>("y_keys"), _data_y);
  _raw_data_loaded = true;
 
  // Size mismatch error
  if (_data_x.size() != _data_y.size())
    _object.mooseError(
        "Lengths of x (", _data_x.size(), ") and y (", _data_y.size(), ") data do not match.");
}

◆ buildFromXandY()

void PiecewiseTabularInterface::buildFromXandY ( )

protected

Builds data from 'x' and 'y' parameters.

Definition at line 214 of file PiecewiseTabularInterface.C.

{
  _data_x = _parameters.get<std::vector<Real>>("x");
  _data_y = _parameters.get<std::vector<Real>>("y");
  _raw_data_loaded = true;
}

◆ buildFromXY()

void PiecewiseTabularInterface::buildFromXY ( )

protected

Builds data from 'xy_data' parameter.

Definition at line 222 of file PiecewiseTabularInterface.C.

{
  const auto & xy = _parameters.get<std::vector<Real>>("xy_data");
  const auto xy_size = xy.size();
  if (xy_size % 2 != 0)
    _object.mooseError(
        "In ", _object.name(), ": Length of data provided in 'xy_data' must be a multiple of 2.");
 
  const auto data_size = xy_size / 2;
  _data_x.resize(data_size);
  _data_y.resize(data_size);
  for (const auto i : make_range(data_size))
  {
    _data_x[i] = xy[2 * i];
    _data_y[i] = xy[2 * i + 1];
  }
  _raw_data_loaded = true;
}

◆ isRawDataLoaded()

bool PiecewiseTabularInterface::isRawDataLoaded ( ) const

inlineprotected

Returns whether the raw data has been loaded already.

Definition at line 28 of file PiecewiseTabularInterface.h.

28{ return _raw_data_loaded; }

Referenced by CoarsenedPiecewiseLinear::CoarsenedPiecewiseLinear(), CoarsenedPiecewiseLinear::initialSetup(), PiecewiseLinear::initialSetup(), and PiecewiseLinear::PiecewiseLinear().

◆ validParams()

InputParameters PiecewiseTabularInterface::validParams ( )

static

Definition at line 17 of file PiecewiseTabularInterface.C.

{
  InputParameters params = emptyInputParameters();
 
  // Parameters shared across all data input methods
  MooseEnum axis("x=0 y=1 z=2");
  params.addParam<MooseEnum>(
      "axis", axis, "The axis used (x, y, or z) if this is to be a function of position");
 
  // Data from input file parameters
  params.addParam<std::vector<Real>>("xy_data",
                                     "All function data, supplied in abscissa, ordinate pairs");
  params.addParam<std::vector<Real>>("x", "The abscissa values");
  params.addParam<std::vector<Real>>("y", "The ordinate values");
 
  // Data from CSV file parameters
  params.addParam<FileName>("data_file", "File holding CSV data");
  params.addParam<unsigned int>("x_index_in_file", 0, "The abscissa index in the data file");
  params.addParam<unsigned int>("y_index_in_file", 1, "The ordinate index in the data file");
  params.addParam<std::string>(
      "x_title", "The title of the column/row containing the x data in the data file");
  params.addParam<std::string>(
      "y_title", "The title of the column/row containing the y data in the data file");
  params.addParam<bool>(
      "xy_in_file_only", true, "If the data file only contains abscissa and ordinate data");
  MooseEnum format("columns=0 rows=1", "rows");
  params.addParam<MooseEnum>(
      "format", format, "Format of csv data file that is in either in columns or rows");
 
  // Data from JSON parameters
  params.addParam<UserObjectName>("json_uo", "JSONFileReader holding the data");
  params.addParam<std::vector<std::string>>(
      "x_keys", "Ordered vector of keys in the JSON tree to obtain the abscissa");
  params.addParam<std::vector<std::string>>(
      "y_keys", "Ordered vector of keys in the JSON tree to obtain the ordinate");
 
  params.addParamNamesToGroup("xy_data x y", "Data from input file");
  params.addParamNamesToGroup(
      "data_file x_index_in_file y_index_in_file x_title y_title xy_in_file_only format",
      "Data from CSV file");
  params.addParamNamesToGroup("json_uo x_keys y_keys", "Data from JSON");
 
  return params;
}