MaterialWarehouse.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
// MOOSE includes
#include "MaterialWarehouse.h"
#include "MaterialBase.h"
 
// Defined out-of-line so the MooseObjectWarehouse<MaterialBase> base is instantiated here, where
// MaterialBase is complete (it is only forward-declared in the header).
MaterialWarehouse::MaterialWarehouse(THREAD_ID num_threads)
  : MooseObjectWarehouse<MaterialBase>(num_threads)
{
}
 
void
MaterialWarehouse::addObjects(std::shared_ptr<MaterialBase> block,
                              std::shared_ptr<MaterialBase> neighbor,
                              std::shared_ptr<MaterialBase> face,
                              THREAD_ID tid /*=0*/)
{
  MooseObjectWarehouse<MaterialBase>::addObject(block, tid);
  _neighbor_materials.addObject(neighbor, tid);
  _face_materials.addObject(face, tid);
}
 
const MooseObjectWarehouse<MaterialBase> &
MaterialWarehouse::operator[](Moose::MaterialDataType data_type) const
{
  switch (data_type)
  {
    case Moose::NEIGHBOR_MATERIAL_DATA:
      return _neighbor_materials;
 
    case Moose::FACE_MATERIAL_DATA:
      return _face_materials;
 
    default:
      return *this;
  }
}
 
void
MaterialWarehouse::initialSetup(THREAD_ID tid /*=0*/) const
{
  MooseObjectWarehouse<MaterialBase>::initialSetup(tid);
  _neighbor_materials.initialSetup(tid);
  _face_materials.initialSetup(tid);
}
 
void
MaterialWarehouse::timestepSetup(THREAD_ID tid /*=0*/) const
{
  MooseObjectWarehouse<MaterialBase>::timestepSetup(tid);
  _neighbor_materials.timestepSetup(tid);
  _face_materials.timestepSetup(tid);
}
 
void
MaterialWarehouse::subdomainSetup(THREAD_ID tid /*=0*/) const
{
  MooseObjectWarehouse<MaterialBase>::subdomainSetup(tid);
  _face_materials.subdomainSetup(tid);
}
 
void
MaterialWarehouse::neighborSubdomainSetup(THREAD_ID tid /*=0*/) const
{
  _neighbor_materials.subdomainSetup(tid);
}
 
void
MaterialWarehouse::subdomainSetup(SubdomainID id, THREAD_ID tid /*=0*/) const
{
  MooseObjectWarehouse<MaterialBase>::subdomainSetup(id, tid);
  _face_materials.subdomainSetup(id, tid);
}
 
void
MaterialWarehouse::neighborSubdomainSetup(SubdomainID id, THREAD_ID tid /*=0*/) const
{
  _neighbor_materials.subdomainSetup(id, tid);
}
 
void
MaterialWarehouse::residualSetup(THREAD_ID tid /*=0*/) const
{
  MooseObjectWarehouse<MaterialBase>::residualSetup(tid);
  _neighbor_materials.residualSetup(tid);
  _face_materials.residualSetup(tid);
}
 
void
MaterialWarehouse::jacobianSetup(THREAD_ID tid /*=0*/) const
{
  MooseObjectWarehouse<MaterialBase>::jacobianSetup(tid);
  _neighbor_materials.jacobianSetup(tid);
  _face_materials.jacobianSetup(tid);
}
 
void
MaterialWarehouse::updateActive(THREAD_ID tid /*=0*/)
{
  MooseObjectWarehouse<MaterialBase>::updateActive(tid);
  _neighbor_materials.updateActive(tid);
  _face_materials.updateActive(tid);
}
 
void
MaterialWarehouse::sort(THREAD_ID tid /*=0*/, bool sort_all_objects /*=false*/)
{
  checkThreadID(tid);
 
  for (auto & object_pair : _all_block_objects[tid])
    sortHelper(object_pair.second);
  for (auto & object_pair : _all_boundary_objects[tid])
    sortHelper(object_pair.second);
 
  for (auto & object_pair : _neighbor_materials._all_block_objects[tid])
    sortHelper(object_pair.second);
  for (auto & object_pair : _neighbor_materials._all_boundary_objects[tid])
    sortHelper(object_pair.second);
 
  for (auto & object_pair : _face_materials._all_block_objects[tid])
    sortHelper(object_pair.second);
  for (auto & object_pair : _face_materials._all_boundary_objects[tid])
    sortHelper(object_pair.second);
 
  if (sort_all_objects)
  {
    sortHelper(_all_objects[tid]);
    sortHelper(_neighbor_materials._all_objects[tid]);
    sortHelper(_face_materials._all_objects[tid]);
  }
 
  updateActive(tid);
}
 
void
MaterialWarehouse::updateMatPropDependencyHelper(
    std::unordered_set<unsigned int> & needed_mat_props,
    const std::vector<std::shared_ptr<MaterialBase>> & materials,
    const bool producer_only) const
{
  if (producer_only)
  {
    std::unordered_set<unsigned int> consumer_needed_mat_props;
 
    do
    {
      consumer_needed_mat_props = needed_mat_props;
 
      for (auto & material : materials)
        for (const auto prop : consumer_needed_mat_props)
          if (material->getSuppliedPropIDs().count(prop))
          {
            auto & mp_deps = material->getMatPropDependencies();
            needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
          }
 
    } while (consumer_needed_mat_props.size() != needed_mat_props.size());
  }
  else
    MooseObjectWarehouseBase<MaterialBase>::updateMatPropDependencyHelper(
        needed_mat_props, materials, producer_only);
}