UserObjectBase.h

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
 
#pragma once
 
// MOOSE includes
#include "DistributionInterface.h"
#include "FunctionInterface.h"
#include "UserObjectInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "ReporterInterface.h"
#include "MeshChangedInterface.h"
#include "MeshDisplacedInterface.h"
#include "MooseObject.h"
#include "MooseTypes.h"
#include "Restartable.h"
#include "MeshMetaDataInterface.h"
#include "ScalarCoupleable.h"
#include "SetupInterface.h"
#include "PerfGraphInterface.h"
#include "SamplerInterface.h"
 
#include "libmesh/parallel.h"
 
class FEProblemBase;
class SubProblem;
class Assembly;
class SystemBase;
 
class UserObjectBase : public MooseObject,
                       public SetupInterface,
                       protected FunctionInterface,
                       public UserObjectInterface,
                       protected PostprocessorInterface,
                       protected VectorPostprocessorInterface,
                       protected ReporterInterface,
                       protected DistributionInterface,
                       protected SamplerInterface,
                       protected Restartable,
                       protected MeshMetaDataInterface,
                       protected MeshChangedInterface,
                       protected MeshDisplacedInterface,
                       protected PerfGraphInterface,
                       public DependencyResolverInterface
{
public:
  static InputParameters validParams();
 
  UserObjectBase(const InputParameters & params);
  virtual ~UserObjectBase() = default;
 
#ifdef MOOSE_KOKKOS_ENABLED
  UserObjectBase(const UserObjectBase & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  virtual void initialize() = 0;
 
  virtual void finalize() = 0;
 
  SubProblem & getSubProblem() const { return _subproblem; }
 
  bool shouldDuplicateInitialExecution() const { return _duplicate_initial_execution; }
 
  template <typename T>
  void gatherSum(T & value)
  {
    _communicator.sum(value);
  }
 
  template <typename T>
  void gatherMax(T & value)
  {
    _communicator.max(value);
  }
 
  template <typename T>
  void gatherMin(T & value)
  {
    _communicator.min(value);
  }
 
  template <typename T1, typename T2>
  void gatherProxyValueMax(T1 & proxy, T2 & value);
 
  template <typename T1, typename T2>
  void gatherProxyValueMin(T1 & proxy, T2 & value);
 
  std::set<UserObjectName> getDependObjects() const;
 
  const std::set<std::string> & getRequestedItems() override { return _depend_uo; }
 
  const std::set<std::string> & getSuppliedItems() override { return _supplied_uo; }
 
  unsigned int systemNumber() const { return _sys.number(); }
 
  virtual bool needThreadedCopy() const { return false; }
 
protected:
  virtual void addPostprocessorDependencyHelper(const PostprocessorName & name) const override;
  virtual void
  addVectorPostprocessorDependencyHelper(const VectorPostprocessorName & name) const override;
  virtual void addUserObjectDependencyHelper(const UserObjectBase & uo) const override;
  void addReporterDependencyHelper(const ReporterName & reporter_name) override;
 
  const THREAD_ID _tid;
 
  SubProblem & _subproblem;
 
  FEProblemBase & _fe_problem;
 
  SystemBase & _sys;
 
  Assembly & _assembly;
 
  const bool _duplicate_initial_execution;
 
  mutable std::set<std::string> _depend_uo;
 
private:
  std::set<std::string> _supplied_uo;
};
 
template <typename T1, typename T2>
void
UserObjectBase::gatherProxyValueMax(T1 & proxy, T2 & value)
{
  // Get all proxy, value pairs. _communicator.maxloc would be faster but leads to
  // partitioning dependent results if the maximum proxy is not unique.
  std::vector<std::pair<T1, T2>> all(n_processors());
  const auto pair = std::make_pair(proxy, value);
  _communicator.allgather(pair, all);
 
  // find maximum, disambiguated by the value
  const auto it = std::max_element(all.begin(), all.end());
  proxy = it->first;
  value = it->second;
}
 
template <typename T1, typename T2>
void
UserObjectBase::gatherProxyValueMin(T1 & proxy, T2 & value)
{
  // get all proxy, value pairs
  std::vector<std::pair<T1, T2>> all(n_processors());
  const auto pair = std::make_pair(proxy, value);
  _communicator.allgather(pair, all);
 
  // find minimum, disambiguated by the value
  const auto it = std::min_element(all.begin(), all.end());
  proxy = it->first;
  value = it->second;
}