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