#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. More...

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

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

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

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

Protected Attributes

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

const bool	_has_axis

Private Attributes
const MooseObject &	_object
	The object. More...

const InputParameters &	_parameters
	Parameters supplied to the object. More...

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


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

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.

Referenced by PiecewiseTabularBase::PiecewiseTabularBase().

 {
   // 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.

Referenced by PiecewiseTabularBase::initialSetup().

 {
   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.

Referenced by PiecewiseTabularBase::PiecewiseTabularBase().

 {
   _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.

Referenced by PiecewiseTabularBase::PiecewiseTabularBase().

 {
   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.

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

28 { return _raw_data_loaded; }

PiecewiseTabularInterface::_raw_data_loaded

bool _raw_data_loaded

Boolean to keep track of whether the data has been loaded.

Definition: PiecewiseTabularInterface.h:55

◆ validParams()

InputParameters PiecewiseTabularInterface::validParams ( )

static

Definition at line 17 of file PiecewiseTabularInterface.C.

Referenced by PiecewiseTabularBase::validParams().

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