DomainUserObject.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 "UserObject.h"
#include "BlockRestrictable.h"
#include "ThreeMaterialPropertyInterface.h"
#include "NeighborCoupleableMooseVariableDependencyIntermediateInterface.h"
#include "TransientInterface.h"
#include "RandomInterface.h"
#include "ElementIDInterface.h"
#include "MooseError.h"
 
class MooseVariableFieldBase;
 
namespace libMesh
{
class Elem;
class QBase;
}
 
class DomainUserObject : public UserObject,
                         public BlockRestrictable,
                         public ThreeMaterialPropertyInterface,
                         public NeighborCoupleableMooseVariableDependencyIntermediateInterface,
                         public TransientInterface,
                         public RandomInterface,
                         public ElementIDInterface
{
public:
  static InputParameters validParams();
 
  DomainUserObject(const InputParameters & parameters);
 
  void execute() override final;
 
  virtual void executeOnElement() {}
 
  virtual void executeOnBoundary() {}
 
  virtual void executeOnInternalSide() {}
 
  virtual void executeOnExternalSide(const Elem * /*elem*/, unsigned int /*side*/) {}
 
  virtual void executeOnInterface() {}
 
  void preExecuteOnElement();
 
  void preExecuteOnBoundary();
 
  void preExecuteOnInternalSide();
 
  void preExecuteOnInterface();
 
  bool shouldExecuteOnInterface() const;
 
  void checkVariable(const MooseVariableFieldBase & variable) const override;
 
protected:
  const MooseArray<Point> & qPoints() const { return *_current_q_point; }
  const QBase & qRule() const { return *_current_q_rule; }
  const MooseArray<Real> & JxW() const { return *_current_JxW; }
  const MooseArray<Real> & coord() const { return _coord; }
  const MooseArray<Point> & normals() const { return _normals; }
 
  const MooseVariableFieldBase *
  getInterfaceFieldVar(const std::string & var_name,
                       unsigned int comp,
                       const std::set<BoundaryID> * interfaces = nullptr);
 
  MooseMesh & _mesh;
 
  const Elem * const & _current_elem;
 
  const Real & _current_elem_volume;
 
  const unsigned int & _current_side;
 
  const Elem * const & _current_side_elem;
 
  const Real & _current_side_volume;
 
  const Elem * const & _neighbor_elem;
 
  const Real & _current_neighbor_volume;
 
  const BoundaryID & _current_boundary_id;
 
  const MooseArray<Point> & _normals;
 
  std::set<BoundaryID> _interface_bnd_ids;
 
  std::map<BoundaryID, std::set<SubdomainID>> _interface_connected_blocks;
 
private:
  void setVolumeData();
 
  void setFaceData();
 
  const MooseArray<Point> * _current_q_point;
  const QBase * _current_q_rule;
  const MooseArray<Real> * _current_JxW;
 
  const MooseArray<Point> & _q_point;
  const QBase * const & _qrule;
  const MooseArray<Real> & _JxW;
 
  const MooseArray<Point> & _q_point_face;
  const QBase * const & _qrule_face;
  const MooseArray<Real> & _JxW_face;
 
  const MooseArray<Real> & _coord;
 
  std::map<VariableName, std::set<BoundaryID>> _var_interfaces;
};
 
inline void
DomainUserObject::execute()
{
  mooseError("Users of DomainUserObjects should call "
             "executeOnElement/executeOnBoundary/executeOnInternalSide");
}
 
inline void
DomainUserObject::preExecuteOnElement()
{
  setVolumeData();
}
 
inline void
DomainUserObject::preExecuteOnBoundary()
{
  setFaceData();
}
 
inline void
DomainUserObject::preExecuteOnInternalSide()
{
  setFaceData();
}
 
inline void
DomainUserObject::preExecuteOnInterface()
{
  setFaceData();
}
 
inline void
DomainUserObject::setVolumeData()
{
  _current_q_point = &_q_point;
  _current_q_rule = _qrule;
  _current_JxW = &_JxW;
}
 
inline void
DomainUserObject::setFaceData()
{
  _current_q_point = &_q_point_face;
  _current_q_rule = _qrule_face;
  _current_JxW = &_JxW_face;
}
 
inline bool
DomainUserObject::shouldExecuteOnInterface() const
{
  return _interface_bnd_ids.count(_current_boundary_id);
}