InputParameterWarehouse Class Reference

Storage container for all InputParamter objects. More...

#include <InputParameterWarehouse.h>

Classes
class	AddRemoveParamsKey
	Class that is used as a parameter to [add/remove]InputParameters() to restrict access. More...

Public Member Functions
	InputParameterWarehouse ()
	Class constructor.
virtual	~InputParameterWarehouse ()=default
	Destruction.
const std::multimap< MooseObjectName, std::shared_ptr< InputParameters > > &	getInputParameters (THREAD_ID tid=0) const
	Return const reference to the map containing the InputParameter objects.
void	addControllableParameterConnection (const MooseObjectParameterName &primary, const MooseObjectParameterName &secondary, bool error_on_empty=true)
	Method for linking control parameters of different names.
void	addControllableParameterAlias (const MooseObjectParameterName &alias, const MooseObjectParameterName &secondary)
	Method for creating alias to an existing controllable parameters.
void	addControllableObjectAlias (const MooseObjectName &alias, const MooseObjectName &secondary)
	Method for creating alias for all shared controllable parameters between the two objects.
std::string	dumpChangedControls (bool reset_changed) const
template<typename T >
std::vector< T >	getControllableParameterValues (const MooseObjectParameterName &input) const
	Returns a copy of the current values for a controllable parameter.
std::vector< MooseObjectParameterName >	getControllableParameterNames (const MooseObjectParameterName &input) const
	Return a vector of parameters names matching the supplied name.
InputParameters &	addInputParameters (const std::string &name, const InputParameters &parameters, THREAD_ID tid, const AddRemoveParamsKey)
	Method for adding a new InputParameters object.
void	removeInputParameters (const MooseObject &moose_object, THREAD_ID tid, const AddRemoveParamsKey)
	Allows for the deletion and cleanup of an object while the simulation is running.
const InputParameters &	getInputParametersObject (const std::string &name, THREAD_ID tid=0) const
	Return a const reference to the InputParameters for the named object.
const InputParameters &	getInputParametersObject (const std::string &tag, const std::string &name, THREAD_ID tid=0) const
const InputParameters &	getInputParametersObject (const MooseObjectName &object_name, THREAD_ID tid=0) const

Private Member Functions
ControllableParameter	getControllableParameter (const MooseObjectParameterName &input) const
	Returns a ControllableParameter object that contains all matches to ControllableItem objects for the provided name.
std::vector< ControllableItem * >	getControllableItems (const MooseObjectParameterName &desired, THREAD_ID tid=0) const
	Returns a ControllableItem iterator, if the name is located.
	FRIEND_TEST (InputParameterWarehouseTest, getControllableItems)
	FRIEND_TEST (InputParameterWarehouseTest, getControllableParameter)
	FRIEND_TEST (InputParameterWarehouseTest, getControllableParameterValues)
	FRIEND_TEST (InputParameterWarehouseTest, emptyControllableParameterValues)
	FRIEND_TEST (InputParameterWarehouseTest, addControllableParameterConnection)
	FRIEND_TEST (InputParameterWarehouseTest, addControllableParameterAlias)
InputParameters &	getInputParameters (const std::string &name, THREAD_ID tid=0) const
	Return a reference to the InputParameters for the named object.
InputParameters &	getInputParameters (const std::string &tag, const std::string &name, THREAD_ID tid=0) const
InputParameters &	getInputParameters (const MooseObjectName &object_name, THREAD_ID tid=0) const

Private Attributes
std::vector< std::multimap< MooseObjectName, std::shared_ptr< InputParameters > > >	_input_parameters
	Storage for the InputParameters objects TODO: Remove multimap.
std::vector< std::vector< std::shared_ptr< ControllableItem > > >	_controllable_items
	Storage for controllable parameters via ControllableItem objects, a unique_ptr is used to avoid creating multiple copies.

Friends
class	Control
	Only controls are allowed to call getControllableParameter.

Detailed Description

Storage container for all InputParamter objects.

This object is responsible for InputParameter objects, all MooseObjects should contain a reference to the parameters object stored here.

To avoid abuse, this warehouse is also designed to restrict the ability to change the parameter to Control objects only.

Definition at line 33 of file InputParameterWarehouse.h.

Constructor & Destructor Documentation

InputParameterWarehouse()

InputParameterWarehouse::InputParameterWarehouse

(

)

Class constructor.

Definition at line 14 of file InputParameterWarehouse.C.

  : _input_parameters(libMesh::n_threads()), _controllable_items(libMesh::n_threads())
{
}

~InputParameterWarehouse()

virtual InputParameterWarehouse::~InputParameterWarehouse ( )

virtualdefault

Destruction.

Member Function Documentation

addControllableObjectAlias()

void InputParameterWarehouse::addControllableObjectAlias	(	const MooseObjectName &	alias,
		const MooseObjectName &	secondary
	)

Method for creating alias for all shared controllable parameters between the two objects.

Definition at line 207 of file InputParameterWarehouse.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    std::vector<ControllableItem *> secondaries =
        getControllableItems(MooseObjectParameterName(secondary, "*"), tid);
    for (auto secondary_ptr : secondaries)
    {
      MooseObjectParameterName alias_param(alias, secondary_ptr->name().parameter());
      MooseObjectParameterName secondary_param(secondary, secondary_ptr->name().parameter());
      addControllableParameterAlias(alias_param, secondary_param);
    }
  }
}

addControllableParameterAlias()

void InputParameterWarehouse::addControllableParameterAlias	(	const MooseObjectParameterName &	alias,
		const MooseObjectParameterName &	secondary
	)

Method for creating alias to an existing controllable parameters.

Parameters

alias	The new name to serve as an alias.
secondary	The name of the secondary parameter to be aliased.

Definition at line 224 of file InputParameterWarehouse.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    std::vector<ControllableItem *> secondaries = getControllableItems(secondary, tid);
    if (secondaries.empty() && tid == 0) // some objects only exist on tid 0
      mooseError("Unable to locate secondary parameter with name ", secondary);
 
    for (auto secondary_ptr : secondaries)
      _controllable_items[tid].emplace_back(
          std::make_unique<ControllableAlias>(alias, secondary_ptr));
  }
}

Referenced by addControllableObjectAlias().

addControllableParameterConnection()

void InputParameterWarehouse::addControllableParameterConnection	(	const MooseObjectParameterName &	primary,
		const MooseObjectParameterName &	secondary,
		bool	error_on_empty = true
	)

Method for linking control parameters of different names.

Definition at line 174 of file InputParameterWarehouse.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    std::vector<ControllableItem *> primaries = getControllableItems(primary, tid);
    if (primaries.empty() && error_on_empty && tid == 0) // some objects only exist on tid 0
      mooseError("Unable to locate primary parameter with name ", primary);
    else if (primaries.empty())
    {
      if (tid == 0)
        return;
      else
        // try to connect non-threaded primary control to secondary controls of all threads
        primaries = getControllableItems(primary, 0);
    }
 
    std::vector<ControllableItem *> secondaries = getControllableItems(secondary, tid);
    if (secondaries.empty() && error_on_empty && tid == 0) // some objects only exist on tid 0
      mooseError("Unable to locate secondary parameter with name ", secondary);
    else if (secondaries.empty())
      return;
 
    for (auto primary_ptr : primaries)
      for (auto secondary_ptr : secondaries)
        if (primary_ptr != secondary_ptr)
          primary_ptr->connect(secondary_ptr);
  }
}

Referenced by FEProblemBase::addMaterialHelper().

addInputParameters()

InputParameters & InputParameterWarehouse::addInputParameters	(	const std::string &	name,
		const InputParameters &	parameters,
		THREAD_ID	tid,
		const AddRemoveParamsKey
	)

Method for adding a new InputParameters object.

Parameters

parameters

The InputParameters object to copy and store in the warehouse

Returns

A reference to the warehouse copy of the InputParameters, this is what should be passed into the MooseObjects constructors.

A new object is created from the old object because InputParameters objects are generic until Factory::create() is called and the actual MooseObject is created.

This method is protected by the AddRemoveParamsKey, because only the factories that are creating objects should be able to call this method.

Definition at line 20 of file InputParameterWarehouse.C.

{
  // Error if the name contains "::"
  if (name.find("::") != std::string::npos)
    mooseError("The object name may not contain '::' in the name: ", name);
 
  // Create the actual InputParameters object that will be reference by the objects
  std::shared_ptr<InputParameters> ptr = std::make_shared<InputParameters>(parameters);
 
  const auto & base = ptr->getBase();
 
  // The object name defined by the base class name, this method of storing is used for
  // determining the uniqueness of the name
  MooseObjectName unique_name(base, name, "::");
 
  // Check that the Parameters do not already exist. We allow duplicate unique_names for
  // MooseVariableBase objects because we require duplication of the variable for reference and
  // displaced problems. We must also have std::pair(reference_var, reference_params) AND
  // std::pair(displaced_var, displaced_params) elements because the two vars will have different
  // values for _sys. It's a good thing we are using a multi-map as our underlying storage.
  // We also allow duplicate unique_names for Action objects because it is allowed to have
  // multiple [Materials] input blocks each of which can add an action but all of these actions
  // will have the same unique name.
  if (_input_parameters[tid].find(unique_name) != _input_parameters[tid].end() &&
      base != "MooseVariableBase" && base != "Action")
    mooseError("A '",
               unique_name.tag(),
               "' object already exists with the name '",
               unique_name.name(),
               "'.\n");
 
  // Store the parameters according to the base name
  _input_parameters[tid].insert(
      std::pair<MooseObjectName, std::shared_ptr<InputParameters>>(unique_name, ptr));
 
  // Build a list of object names
  std::vector<MooseObjectName> object_names;
  object_names.push_back(unique_name);
 
  // Store the object according to the control tags
  if (ptr->isParamValid("control_tags"))
  {
    const std::vector<std::string> & tags = ptr->get<std::vector<std::string>>("control_tags");
    for (const auto & tag : tags)
    {
      if (!tag.empty())
      {
        auto short_name = MooseUtils::shortName(name);
        _input_parameters[tid].insert(std::pair<MooseObjectName, std::shared_ptr<InputParameters>>(
            MooseObjectName(tag, short_name), ptr));
        object_names.emplace_back(tag, short_name);
      }
    }
  }
 
  // Store controllable parameters using all possible names
  for (libMesh::Parameters::iterator map_iter = ptr->begin(); map_iter != ptr->end(); ++map_iter)
  {
    const std::string & pname = map_iter->first;
    libMesh::Parameters::Value * value = MooseUtils::get(map_iter->second);
 
    if (ptr->isControllable(pname))
      for (const auto & object_name : object_names)
      {
        MooseObjectParameterName param_name(object_name, pname);
        _controllable_items[tid].emplace_back(std::make_shared<ControllableItem>(
            param_name, value, ptr->getControllableExecuteOnTypes(pname)));
      }
  }
 
  // Set the name and tid parameters, and unique_name
  std::stringstream oss;
  oss << unique_name;
 
  ptr->addPrivateParam<std::string>(MooseBase::unique_name_param, oss.str());
  ptr->addPrivateParam<std::string>(MooseBase::name_param, name);
  ptr->addPrivateParam<THREAD_ID>("_tid", tid);
 
  // no more copies allowed
  ptr->allowCopy(false);
 
  // Return a reference to the InputParameters object
  return *ptr;
}

Referenced by ActionFactory::create(), and Factory::initialize().

dumpChangedControls()

std::string InputParameterWarehouse::dumpChangedControls

(

bool

reset_changed

)

const

Definition at line 262 of file InputParameterWarehouse.C.

{
  std::stringstream oss;
  oss << std::left;
 
  for (const auto & item : _controllable_items[0])
    if (item->isChanged())
    {
      oss << item->dump(4);
      if (reset_changed)
        item->resetChanged();
    }
  return oss.str();
}

Referenced by ControlOutput::outputChangedControls().

FRIEND_TEST() [1/6]

InputParameterWarehouse::FRIEND_TEST ( InputParameterWarehouseTest  , addControllableParameterAlias    )

private

FRIEND_TEST() [2/6]

InputParameterWarehouse::FRIEND_TEST ( InputParameterWarehouseTest  , addControllableParameterConnection    )

private

FRIEND_TEST() [3/6]

InputParameterWarehouse::FRIEND_TEST ( InputParameterWarehouseTest  , emptyControllableParameterValues    )

private

FRIEND_TEST() [4/6]

InputParameterWarehouse::FRIEND_TEST ( InputParameterWarehouseTest  , getControllableItems    )

private

FRIEND_TEST() [5/6]

InputParameterWarehouse::FRIEND_TEST ( InputParameterWarehouseTest  , getControllableParameter    )

private

FRIEND_TEST() [6/6]

InputParameterWarehouse::FRIEND_TEST ( InputParameterWarehouseTest  , getControllableParameterValues    )

private

getControllableItems()

std::vector< ControllableItem * > InputParameterWarehouse::getControllableItems ( const MooseObjectParameterName &  desired, THREAD_ID  tid = 0  ) const

private

Returns a ControllableItem iterator, if the name is located.

See also

Control

Definition at line 240 of file InputParameterWarehouse.C.

{
  std::vector<ControllableItem *> output;
  for (auto & ptr : _controllable_items[tid])
    if (ptr->name() == input)
      output.push_back(ptr.get());
  return output;
}

Referenced by addControllableObjectAlias(), addControllableParameterAlias(), and addControllableParameterConnection().

getControllableParameter()

ControllableParameter InputParameterWarehouse::getControllableParameter ( const MooseObjectParameterName &  input ) const

private

Returns a ControllableParameter object that contains all matches to ControllableItem objects for the provided name.

This is private because it should only be accessed via a Control object.

Definition at line 251 of file InputParameterWarehouse.C.

{
  ControllableParameter cparam;
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    for (auto it = _controllable_items[tid].begin(); it != _controllable_items[tid].end(); ++it)
      if ((*it)->name() == input)
        cparam.add(it->get());
  return cparam;
}

Referenced by Control::getControllableParameterByName(), getControllableParameterValues(), and Control::hasControllableParameterByName().

getControllableParameterNames()

std::vector< MooseObjectParameterName > InputParameterWarehouse::getControllableParameterNames

(

const MooseObjectParameterName &

input

)

const

Return a vector of parameters names matching the supplied name.

Definition at line 278 of file InputParameterWarehouse.C.

{
  std::vector<MooseObjectParameterName> names;
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    for (auto it = _controllable_items[tid].begin(); it != _controllable_items[tid].end(); ++it)
      if ((*it)->name() == input)
        names.push_back((*it)->name());
  return names;
}

Referenced by FEProblemBase::addMaterialHelper().

getControllableParameterValues()

template<typename T >

std::vector< T > InputParameterWarehouse::getControllableParameterValues

(

const MooseObjectParameterName &

input

)

const

Returns a copy of the current values for a controllable parameter.

This method is designed to provide access to objects for monitoring the state of a controllable parameter.

Definition at line 214 of file InputParameterWarehouse.h.

{
  ControllableParameter param = getControllableParameter(input);
  return param.get<T>();
}

getInputParameters() [1/4]

InputParameters & InputParameterWarehouse::getInputParameters ( const MooseObjectName &  object_name, THREAD_ID  tid = 0  ) const

private

Definition at line 155 of file InputParameterWarehouse.C.

{
  // Locate the InputParameters object and error if it was not located
  const auto iter = _input_parameters[tid].find(object_name);
  if (iter == _input_parameters[tid].end())
    mooseError("Unknown InputParameters object ", object_name);
 
  // Return a reference to the parameter
  return *(iter->second.get());
}

getInputParameters() [2/4]

InputParameters & InputParameterWarehouse::getInputParameters ( const std::string &  name, THREAD_ID  tid = 0  ) const

private

Return a reference to the InputParameters for the named object.

Parameters

tag	The tag of the object (e.g., 'Kernel')
name	The name of the parameters object, including the tag (name only input) or MooseObjectName object
tid	The thread id

Returns

A reference to the warehouse copy of the InputParameters

If you are using this method to access a writable reference to input parameters, this will break the ability to control the parameters with the MOOSE control logic system. Only change parameters if you know what you are doing. Hence, this is private for a reason.

Definition at line 141 of file InputParameterWarehouse.C.

{
  return getInputParameters(MooseObjectName(name), tid);
}

getInputParameters() [3/4]

InputParameters & InputParameterWarehouse::getInputParameters ( const std::string &  tag, const std::string &  name, THREAD_ID  tid = 0  ) const

private

Definition at line 147 of file InputParameterWarehouse.C.

{
  return getInputParameters(MooseObjectName(tag, name), tid);
}

getInputParameters() [4/4]

const std::multimap< MooseObjectName, std::shared_ptr< InputParameters > > & InputParameterWarehouse::getInputParameters

(

THREAD_ID

tid = 0

)

const

Return const reference to the map containing the InputParameter objects.

Definition at line 168 of file InputParameterWarehouse.C.

{
  return _input_parameters[tid];
}

Referenced by getInputParameters(), getInputParameters(), getInputParametersObject(), getInputParametersObject(), getInputParametersObject(), NEML2Action::NEML2Action(), ControlOutput::outputActiveObjects(), ControlOutput::outputControls(), ConsoleUtils::outputDataFileParams(), and ActionWarehouse::printInputFile().

getInputParametersObject() [1/3]

const InputParameters & InputParameterWarehouse::getInputParametersObject	(	const MooseObjectName &	object_name,
		THREAD_ID	tid = 0
	)		const

Definition at line 134 of file InputParameterWarehouse.C.

{
  return getInputParameters(object_name, tid);
}

getInputParametersObject() [2/3]

const InputParameters & InputParameterWarehouse::getInputParametersObject	(	const std::string &	name,
		THREAD_ID	tid = 0
	)		const

Return a const reference to the InputParameters for the named object.

Parameters

tag	The tag of the object (e.g., 'Kernel')
name	The name of the parameters object, including the tag (name only input) or MooseObjectName object
tid	The thread id

Returns

A const reference to the warehouse copy of the InputParameters

Definition at line 120 of file InputParameterWarehouse.C.

{
  return getInputParameters(MooseObjectName(name), tid);
}

getInputParametersObject() [3/3]

const InputParameters & InputParameterWarehouse::getInputParametersObject	(	const std::string &	tag,
		const std::string &	name,
		THREAD_ID	tid = 0
	)		const

Definition at line 126 of file InputParameterWarehouse.C.

{
  return getInputParameters(MooseObjectName(tag, name), tid);
}

removeInputParameters()

void InputParameterWarehouse::removeInputParameters	(	const MooseObject &	moose_object,
		THREAD_ID	tid,
		const AddRemoveParamsKey
	)

Allows for the deletion and cleanup of an object while the simulation is running.

Definition at line 109 of file InputParameterWarehouse.C.

{
  auto moose_object_name_string =
      moose_object.parameters().get<std::string>(MooseBase::unique_name_param);
  MooseObjectName moose_object_name(moose_object_name_string);
  _input_parameters[tid].erase(moose_object_name);
}

Referenced by Factory::releaseSharedObjects().

Friends And Related Symbol Documentation

Control

friend class Control

friend

Only controls are allowed to call getControllableParameter.

The Control::getControllableParameter is the only method that calls getControllableParameter. However, this method cannot be made a friend explicitly because the method would need to be public. If the method is public then it is possible to call the method by getting access to the Control object.

Definition at line 201 of file InputParameterWarehouse.h.

Member Data Documentation

_controllable_items

std::vector<std::vector<std::shared_ptr<ControllableItem> > > InputParameterWarehouse::_controllable_items

private

Storage for controllable parameters via ControllableItem objects, a unique_ptr is used to avoid creating multiple copies.

All access to the objects are done via pointers. The ControllableItem objects are not designed and will not be used directly in user code. All user level access goes through the ControllableParameter object.

Definition at line 159 of file InputParameterWarehouse.h.

Referenced by addControllableParameterAlias(), addInputParameters(), dumpChangedControls(), getControllableItems(), getControllableParameter(), and getControllableParameterNames().

_input_parameters

std::vector<std::multimap<MooseObjectName, std::shared_ptr<InputParameters> > > InputParameterWarehouse::_input_parameters

private

Storage for the InputParameters objects TODO: Remove multimap.

Definition at line 153 of file InputParameterWarehouse.h.

Referenced by addInputParameters(), getInputParameters(), getInputParameters(), and removeInputParameters().

---

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

• include/utils/InputParameterWarehouse.h
• src/utils/InputParameterWarehouse.C