UserObject.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 UserObject : 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();

  UserObject(const InputParameters & params);
  virtual ~UserObject() = default;

  virtual void execute() = 0;

  virtual void initialize() = 0;

  virtual void finalize() = 0;

  SubProblem & getSubProblem() const { return _subproblem; }

  bool shouldDuplicateInitialExecution() const { return _duplicate_initial_execution; }

  virtual Real spatialValue(const Point & /*p*/) const
  {
    mooseError(name(), " does not satisfy the Spatial UserObject interface!");
  }

  virtual const std::vector<Point> spatialPoints() const
  {
    mooseError("Spatial UserObject interface is not satisfied; spatialPoints() must be overridden");
  }

  virtual void threadJoin(const UserObject & uo) = 0;

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

  void setPrimaryThreadCopy(UserObject * primary);

  UserObject * primaryThreadCopy() { return _primary_thread_copy; }

  std::set<UserObjectName> getDependObjects() const;

  virtual bool needThreadedCopy() const { return false; }

  const std::set<std::string> & getRequestedItems() override { return _depend_uo; }

  const std::set<std::string> & getSuppliedItems() override { return _supplied_uo; }

  unsigned int systemNumber() const;

protected:
  virtual void addPostprocessorDependencyHelper(const PostprocessorName & name) const override;
  virtual void
  addVectorPostprocessorDependencyHelper(const VectorPostprocessorName & name) const override;
  virtual void addUserObjectDependencyHelper(const UserObject & uo) const override;
  void addReporterDependencyHelper(const ReporterName & reporter_name) override;

  SubProblem & _subproblem;

  FEProblemBase & _fe_problem;

  SystemBase & _sys;

  const THREAD_ID _tid;
  Assembly & _assembly;

  const Moose::CoordinateSystemType & _coord_sys;

  const bool _duplicate_initial_execution;

  mutable std::set<std::string> _depend_uo;

private:
  UserObject * _primary_thread_copy = nullptr;

  std::set<std::string> _supplied_uo;
};

template <typename T1, typename T2>
void
UserObject::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
UserObject::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;
}