TaggingInterface.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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

#include "MooseTypes.h"
#include "MultiMooseEnum.h"

#include "libmesh/dense_vector.h"
#include "libmesh/dense_matrix.h"

// Forward declarations
class InputParameters;
class MooseObject;
class TaggingInterface;
class SubProblem;
class Assembly;

template <typename T>
InputParameters validParams();

template <>
InputParameters validParams<TaggingInterface>();

class TaggingInterface
{
public:
  TaggingInterface(const MooseObject * moose_object);
  virtual ~TaggingInterface();

  void useVectorTag(const TagName & tag_name);

  void useMatrixTag(const TagName & tag_name);

  void useVectorTag(TagID tag_id);

  void useMatrixTag(TagID tag_id);

  bool isVectorTagged() { return _vector_tags.size() > 0; }

  bool isMatrixTagged() { return _matrix_tags.size() > 0; }

  const std::set<TagID> & getVectorTags() const { return _vector_tags; }

  const std::set<TagID> & getMatrixTags() const { return _matrix_tags; }

  void prepareVectorTag(Assembly & assembly, unsigned int ivar);

  void prepareVectorTagNeighbor(Assembly & assembly, unsigned int ivar);

  void prepareVectorTagLower(Assembly & assembly, unsigned int ivar);

  void prepareMatrixTag(Assembly & assembly, unsigned int ivar, unsigned int jvar);

  void prepareMatrixTagNeighbor(Assembly & assembly,
                                unsigned int ivar,
                                unsigned int jvar,
                                Moose::DGJacobianType type);

  void prepareMatrixTagLower(Assembly & assembly,
                             unsigned int ivar,
                             unsigned int jvar,
                             Moose::ConstraintJacobianType type);

  void accumulateTaggedLocalResidual();

  void assignTaggedLocalResidual();

  void accumulateTaggedLocalMatrix();

  void assignTaggedLocalMatrix();

protected:
  std::set<TagID> _vector_tags;

  std::set<TagID> _matrix_tags;

  const MooseObject & _moose_object;

  const InputParameters & _tag_params;

  SubProblem & _subproblem;

  std::vector<DenseVector<Number> *> _re_blocks;

  std::vector<DenseMatrix<Number> *> _ke_blocks;

  DenseVector<Number> _local_re;

  DenseMatrix<Number> _local_ke;
};

#define usingTaggingInterfaceMembers                                                               \
  using TaggingInterface::_subproblem;                                                             \
  using TaggingInterface::accumulateTaggedLocalResidual;                                           \
  using TaggingInterface::accumulateTaggedLocalMatrix;                                             \
  using TaggingInterface::prepareVectorTag;                                                        \
  using TaggingInterface::prepareMatrixTag;                                                        \
  using TaggingInterface::prepareVectorTagNeighbor;                                                \
  using TaggingInterface::_local_re;                                                               \
  using TaggingInterface::prepareVectorTagLower;                                                   \
  using TaggingInterface::prepareMatrixTagNeighbor;                                                \
  using TaggingInterface::prepareMatrixTagLower;                                                   \
  using TaggingInterface::_local_ke