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