TheWarehouse Class Reference

TheWarehouse is a container for MooseObjects that allows querying/filtering over various customizeable attributes. More...

#include <TheWarehouse.h>

Classes
class	QueryCache
	QueryCache is a convenient way to construct and pass around (possible partially constructed) warehouse queries. More...

Public Types
template<typename T >
using	KeyType = typename T::Key
template<typename T >
using	AttribType = T *
using	Query = QueryCache<>

Public Member Functions
	TheWarehouse ()
	~TheWarehouse ()
template<typename T , typename... Args>
unsigned int	registerAttribute (const std::string &name, Args... dummy_args)
	registers a new "tracked" attribute of type T for the warehouse. More...
unsigned int	attribID (const std::string &name)
	Returns a unique ID associated with the given attribute name - i.e. More...
void	add (std::shared_ptr< MooseObject > obj)
	add adds a new object to the warehouse and stores attributes/metadata about it for running queries/filtering. More...
void	update (MooseObject *obj)
	update updates the metadata/attribute-info stored for the given object obj that must already exists in the warehouse. More...
void	update (MooseObject *obj, const Attribute &extra)
	update updates the metadata/attribute-info stored for the given object obj that must already exists in the warehouse. More...
Query	query ()
	query creates and returns an initialized a query object for querying objects from the warehouse. More...
std::size_t	count (const std::vector< std::unique_ptr< Attribute >> &conds)
	count returns the number of objects that match the provided query conditions. More...
template<typename T >
std::vector< T * > &	queryInto (const std::vector< std::unique_ptr< Attribute >> &conds, std::vector< T *> &results)
	queryInto takes the given conditions (i.e. More...
std::size_t	queryID (const std::vector< std::unique_ptr< Attribute >> &conds)
template<typename T >
std::vector< T * > &	queryInto (int query_id, std::vector< T *> &results, bool show_all=false)

Private Member Functions
int	prepare (std::vector< std::unique_ptr< Attribute >> conds)
	prepares a query and returns an associated query_id (i.e. for use with the query function). More...
const std::vector< MooseObject * > &	query (int query_id)
	callers of this function must lock _obj_cache_mutex as long as a reference to the returned vector is being used. More...
void	readAttribs (const MooseObject *obj, std::vector< std::unique_ptr< Attribute >> &attribs)

Private Attributes
std::unique_ptr< WarehouseStorage >	_store
std::vector< std::shared_ptr< MooseObject > >	_objects
std::unordered_map< MooseObject *, std::size_t >	_obj_ids
std::vector< std::vector< MooseObject * > >	_obj_cache
std::unordered_map< std::vector< std::unique_ptr< Attribute > >, int >	_query_cache
std::unordered_map< std::string, unsigned int >	_attrib_ids
std::vector< std::unique_ptr< Attribute > >	_attrib_list
std::mutex	_obj_mutex
std::mutex	_query_cache_mutex
std::mutex	_obj_cache_mutex

Detailed Description

TheWarehouse is a container for MooseObjects that allows querying/filtering over various customizeable attributes.

The meta-data about the objects is read/stored when the objects are added to the warehouse - updates to objects' state will not be reflected in query results unless the object is explicitly updated through the warehouse interface. The warehouse object can safely be queried concurrently from multiple threads.

Once Query and Attribute objects have been constructed, they are tied to the specific warehouse they were created with. They must not be used for different warehouses or the attribute ID they store internally will be wrong and that is bad.

Definition at line 185 of file TheWarehouse.h.

Member Typedef Documentation

AttribType

template<typename T >

using TheWarehouse::AttribType = T *

Definition at line 191 of file TheWarehouse.h.

KeyType

template<typename T >

using TheWarehouse::KeyType = typename T::Key

Definition at line 189 of file TheWarehouse.h.

Query

using TheWarehouse::Query = QueryCache<>

Definition at line 409 of file TheWarehouse.h.

Constructor & Destructor Documentation

TheWarehouse()

TheWarehouse::TheWarehouse

(

)

Definition at line 110 of file TheWarehouse.C.

: _store(std::make_unique<VecStore>()) {}

~TheWarehouse()

TheWarehouse::~TheWarehouse

(

)

Definition at line 111 of file TheWarehouse.C.

{}

Member Function Documentation

add()

void TheWarehouse::add

(

std::shared_ptr< MooseObject >

obj

)

add adds a new object to the warehouse and stores attributes/metadata about it for running queries/filtering.

The warehouse will maintain a pointer to the object indefinitely.

Definition at line 116 of file TheWarehouse.C.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), FEProblemBase::addObject(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), and FEProblemBase::addUserObject().

{
  isValid(obj.get());

  std::size_t obj_id = 0;
  {
    std::lock_guard<std::mutex> lock(_obj_mutex);

    mooseAssert(!_obj_ids.count(obj.get()), obj->typeAndName() + " has already been added");

    _objects.push_back(obj);
    obj_id = _objects.size() - 1;
    _obj_ids[obj.get()] = obj_id;

    // reset/invalidate the query cache since query results may have been affected by this warehouse
    // insertion.
    _obj_cache.clear();
    _query_cache.clear();
  }

  std::vector<std::unique_ptr<Attribute>> attribs;
  readAttribs(obj.get(), attribs);
  _store->add(obj_id, std::move(attribs));
}

attribID()

unsigned int TheWarehouse::attribID ( const std::string &  name )

inline

Returns a unique ID associated with the given attribute name - i.e.

an attribute and name that were previously registered via calls to registerAttribute. Users should generally not need to use this function.

Definition at line 443 of file TheWarehouse.h.

  {
    auto it = _attrib_ids.find(name);
    if (it != _attrib_ids.end())
      return it->second;
    mooseError("no ID exists for unregistered attribute '", name, "'");
  }

count()

std::size_t TheWarehouse::count

(

const std::vector< std::unique_ptr< Attribute >> &

conds

)

count returns the number of objects that match the provided query conditions.

This requires executing a full query operation (i.e. as if calling queryInto). A Query object should generally be used via the query() member function instead.

Definition at line 263 of file TheWarehouse.C.

Referenced by TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces >::count().

{
  auto query_id = queryID(conds);
  std::lock_guard<std::mutex> lock(_obj_cache_mutex);
  auto & objs = query(query_id);
  std::size_t count = 0;
  for (auto obj : objs)
    if (obj->enabled())
      count++;
  return count;
}

prepare()

int TheWarehouse::prepare ( std::vector< std::unique_ptr< Attribute >>  conds )

private

prepares a query and returns an associated query_id (i.e. for use with the query function).

Definition at line 166 of file TheWarehouse.C.

Referenced by queryID().

{
  bool sort = false;
  std::unique_ptr<Attribute> sorted_attrib;
  if (!conds.empty() && dynamic_cast<AttribSorted *>(conds.back().get()))
  {
    sorted_attrib = std::move(conds.back());
    static const AttribSorted sorted_attrib_true(*this, true);
    sort = sorted_attrib->isMatch(sorted_attrib_true);
    // Remove the sorted condition temporarily
    conds.pop_back();
  }

#ifdef DEBUG
  for (auto & cond : conds)
    mooseAssert(!dynamic_cast<AttribSorted *>(cond.get()),
                "There should be no sorted attributes in this container.");
#endif

  auto obj_ids = _store->query(conds);
  if (sorted_attrib)
    conds.push_back(std::move(sorted_attrib));

  std::lock_guard<std::mutex> lock(_obj_cache_mutex);
  auto & vec = _obj_cache.emplace_back(obj_ids.size());
  const auto query_id = _obj_cache.size() - 1;
  {
    std::lock_guard<std::mutex> lock(_query_cache_mutex);
    _query_cache[std::move(conds)] = query_id;
  }

  std::lock_guard<std::mutex> o_lock(_obj_mutex);
  for (const auto i : index_range(obj_ids))
  {
    auto obj = _objects[obj_ids[i]].get();
    mooseAssert(std::find(vec.begin(), vec.end(), obj) == vec.end(), "Duplicate object");
    vec[i] = obj;
  }

  if (sort && !vec.empty() && dynamic_cast<DependencyResolverInterface *>(vec[0]))
  {
    std::vector<DependencyResolverInterface *> dependers;
    for (auto obj : vec)
    {
      auto d = dynamic_cast<DependencyResolverInterface *>(obj);
      if (!d)
      {
        dependers.clear();
        break;
      }
      dependers.push_back(d);
    }

    try
    {
      DependencyResolverInterface::sort(dependers);
    }
    catch (CyclicDependencyException<DependencyResolverInterface *> & e)
    {
      DependencyResolverInterface::cyclicDependencyError<UserObject *>(
          e, "Cyclic dependency detected in object ordering");
    }

    mooseAssert(dependers.size() == vec.size(), "Dependency resolution size mismatch");
    for (unsigned int i = 0; i < dependers.size(); i++)
      vec[i] = dynamic_cast<MooseObject *>(dependers[i]);
  }

  return query_id;
}

query() [1/2]

Query TheWarehouse::query ( )

inline

query creates and returns an initialized a query object for querying objects from the warehouse.

Definition at line 466 of file TheWarehouse.h.

Referenced by CheckFVBCAction::act(), NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkUserObjectJacobianRequirement(), FEProblemBase::checkUserObjects(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), LinearSystem::containsTimeKernel(), count(), NonlinearSystemBase::customSetup(), FEProblemBase::customSetup(), ComputeResidualThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), FEProblemBase::executeSamplers(), ComputeLinearFVElementalThread::fetchBlockSystemContributionObjects(), ComputeLinearFVFaceThread::fetchBlockSystemContributionObjects(), FEProblemBase::getDistribution(), FEProblemBase::getMortarUserObjects(), FEProblemBase::getPositionsObject(), FEProblemBase::getSampler(), CompositionDT::getTimeSteppers(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), FEProblemBase::hasUserObject(), SideFVFluxBCIntegral::initialSetup(), ExplicitTimeIntegrator::initialSetup(), LinearSystem::initialSetup(), NonlinearSystemBase::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needSubdomainMaterialOnSide(), JSONOutput::outputReporters(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), queryInto(), ComputeLinearFVElementalThread::setupSystemContributionObjects(), ComputeLinearFVFaceThread::setupSystemContributionObjects(), NonlinearThread::subdomainChanged(), NonlinearSystemBase::timestepSetup(), and FEProblemBase::timestepSetup().

{ return Query(*this); }

query() [2/2]

const std::vector< MooseObject * > & TheWarehouse::query ( int  query_id )

private

callers of this function must lock _obj_cache_mutex as long as a reference to the returned vector is being used.

Definition at line 238 of file TheWarehouse.C.

{
  if (static_cast<std::size_t>(query_id) >= _obj_cache.size())
    throw std::runtime_error("unknown query id");
  return _obj_cache[query_id];
}

queryID()

std::size_t TheWarehouse::queryID

(

const std::vector< std::unique_ptr< Attribute >> &

conds

)

Definition at line 246 of file TheWarehouse.C.

Referenced by count(), JSONOutput::outputReporters(), queryInto(), and TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces >::queryIntoHelper().

{
  {
    std::lock_guard<std::mutex> lock(_query_cache_mutex);
    auto it = _query_cache.find(conds);
    if (it != _query_cache.end())
      return it->second;
  }

  std::vector<std::unique_ptr<Attribute>> conds_clone;
  conds_clone.resize(conds.size());
  for (std::size_t i = 0; i < conds.size(); i++)
    conds_clone[i] = conds[i]->clone();
  return prepare(std::move(conds_clone));
}

queryInto() [1/2]

template<typename T >

std::vector<T *>& TheWarehouse::queryInto ( const std::vector< std::unique_ptr< Attribute >> &  conds, std::vector< T *> &  results  )

inline

queryInto takes the given conditions (i.e.

Attributes holding the values to filter/match over) and filters all objects in the warehouse that match all conditions (i.e. "and"ing the conditions together) and stores them in the results vector. All result objects must be castable to the templated type T. This function filters out disabled objects on the fly - only returning enabled ones.

Definition at line 477 of file TheWarehouse.h.

Referenced by JSONOutput::outputReporters(), and TheWarehouse::QueryCache< AttribThread, AttribBoundaries, AttribInterfaces >::queryIntoHelper().

  {
    return queryInto(queryID(conds), results);
  }

queryInto() [2/2]

template<typename T >

std::vector<T *>& TheWarehouse::queryInto ( int  query_id, std::vector< T *> &  results, bool  show_all = false  )

inline

Definition at line 486 of file TheWarehouse.h.

  {
    std::lock_guard<std::mutex> lock(_obj_cache_mutex);
    auto & objs = query(query_id);
    results.clear();
    results.reserve(objs.size());
    for (auto & obj : objs)
    {
      mooseAssert(obj, "Null object");
      auto cast_obj = dynamic_cast<T *>(obj);
      if (obj)
        mooseAssert(cast_obj,
                    "Queried object " + obj->typeAndName() + " has incompatible c++ type with " +
                        MooseUtils::prettyCppType<T>());
      mooseAssert(std::find(results.begin(), results.end(), cast_obj) == results.end(),
                  "Duplicate object");
      if (show_all || obj->enabled())
        results.push_back(cast_obj);
    }
    return results;
  }

readAttribs()

void TheWarehouse::readAttribs ( const MooseObject *  obj, std::vector< std::unique_ptr< Attribute >> &  attribs  )

private

Definition at line 276 of file TheWarehouse.C.

Referenced by add(), and update().

{
  for (auto & ref : _attrib_list)
  {
    attribs.emplace_back(ref->clone());
    attribs.back()->initFrom(obj);
  }
}

registerAttribute()

template<typename T , typename... Args>

unsigned int TheWarehouse::registerAttribute ( const std::string &  name, Args...  dummy_args  )

inline

registers a new "tracked" attribute of type T for the warehouse.

args are all arguments necessary to create an instance of the T class excluding the warehouse reference/pointer which is assumed to be first and automatically inserted. An instance of every registered attribute will be created for and initialized to each object added to the warehouse allowing queries to be executed over specific values the attribute may take on. Attributes must be registered before objects are added to the warehouse. A unique ID associated with the registered attribute is returned - which is generally not needed used by users.

As an example, to register a class with the constructor "YourAttribute(TheWarehouse& w, int foo)", you would call "registerAttribute<YourAttribute>("your_attrib_name", constructor_arg1, ...)". Custom attribute classes are required to pass an attribute name (i.e. "your_attrib_name") to the Attribute base class. The dummy args are forwarded to the attrib class' constructor. The name passed here into registerAttribute must be the same string as the name passed to the Attribute base class's constructor.

Definition at line 429 of file TheWarehouse.h.

  {
    auto it = _attrib_ids.find(name);
    if (it != _attrib_ids.end())
      return it->second;

    _attrib_ids[name] = _attrib_list.size();
    _attrib_list.push_back(std::unique_ptr<Attribute>(new T(*this, dummy_args...)));
    return _attrib_list.size() - 1;
  }

update() [1/2]

void TheWarehouse::update

(

MooseObject *

obj

)

update updates the metadata/attribute-info stored for the given object obj that must already exists in the warehouse.

Call this if an object's state has changed in such a way that its warehouse attributes have become stale/incorrect.

Definition at line 154 of file TheWarehouse.C.

Referenced by groupUserObjects().

{
  std::vector<std::unique_ptr<Attribute>> attribs;
  readAttribs(obj, attribs);
  _store->set(_obj_ids[obj], std::move(attribs));
  // reset/invalidate the query cache since query results may have been affected by this object
  // attribute modification.
  _obj_cache.clear();
  _query_cache.clear();
}

update() [2/2]

void TheWarehouse::update	(	MooseObject *	obj,
		const Attribute &	extra
	)

update updates the metadata/attribute-info stored for the given object obj that must already exists in the warehouse.

Call this if an object's state has changed in such a way that its warehouse attributes have become stale/incorrect. Any attribute specified in extra overwrites/trumps one read from the object's current state.

Definition at line 142 of file TheWarehouse.C.

{
  std::vector<std::unique_ptr<Attribute>> attribs;
  attribs.push_back(extra.clone());
  _store->set(_obj_ids[obj], std::move(attribs));
  // reset/invalidate the query cache since query results may have been affected by this object
  // attribute modification.
  _obj_cache.clear();
  _query_cache.clear();
}

Member Data Documentation

_attrib_ids

std::unordered_map<std::string, unsigned int> TheWarehouse::_attrib_ids

private

Definition at line 530 of file TheWarehouse.h.

Referenced by attribID(), and registerAttribute().

_attrib_list

std::vector<std::unique_ptr<Attribute> > TheWarehouse::_attrib_list

private

Definition at line 531 of file TheWarehouse.h.

Referenced by readAttribs(), and registerAttribute().

_obj_cache

std::vector<std::vector<MooseObject *> > TheWarehouse::_obj_cache

private

Definition at line 524 of file TheWarehouse.h.

Referenced by add(), prepare(), query(), and update().

_obj_cache_mutex

std::mutex TheWarehouse::_obj_cache_mutex

private

Definition at line 535 of file TheWarehouse.h.

Referenced by count(), prepare(), and queryInto().

_obj_ids

std::unordered_map<MooseObject *, std::size_t> TheWarehouse::_obj_ids

private

Definition at line 520 of file TheWarehouse.h.

Referenced by add(), and update().

_obj_mutex

std::mutex TheWarehouse::_obj_mutex

private

Definition at line 533 of file TheWarehouse.h.

Referenced by add(), and prepare().

_objects

std::vector<std::shared_ptr<MooseObject> > TheWarehouse::_objects

private

Definition at line 519 of file TheWarehouse.h.

Referenced by add(), and prepare().

_query_cache

std::unordered_map<std::vector<std::unique_ptr<Attribute> >, int> TheWarehouse::_query_cache

private

Definition at line 528 of file TheWarehouse.h.

Referenced by add(), prepare(), queryID(), and update().

_query_cache_mutex

std::mutex TheWarehouse::_query_cache_mutex

private

Definition at line 534 of file TheWarehouse.h.

Referenced by prepare(), and queryID().

_store

std::unique_ptr<WarehouseStorage> TheWarehouse::_store

private

Definition at line 518 of file TheWarehouse.h.

Referenced by add(), prepare(), and update().

---

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

• include/base/TheWarehouse.h
• src/base/TheWarehouse.C