DiffusionLHDGAssemblyHelper.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
 
#include "Moose.h"
#include "MooseTypes.h"
#include "MooseArray.h"
#include "MooseVariableDependencyInterface.h"
#include "ADFunctorInterface.h"
 
#include "libmesh/vector_value.h"
#include <vector>
 
template <typename>
class MooseVariableFE;
class MooseVariableScalar;
template <typename>
class MooseArray;
class SystemBase;
class MooseMesh;
class MooseObject;
class MaterialPropertyInterface;
class MooseVariableDependencyInterface;
class TransientInterface;
 
class DiffusionLHDGAssemblyHelper : public ADFunctorInterface
{
public:
  static InputParameters validParams();
 
  DiffusionLHDGAssemblyHelper(const MooseObject * const moose_obj,
                              MaterialPropertyInterface * const mpi,
                              MooseVariableDependencyInterface * const mvdi,
                              const TransientInterface * const ti,
                              const FEProblemBase & fe_problem,
                              SystemBase & sys,
                              const THREAD_ID tid);
  void checkCoupling();
 
protected:
  void vectorVolumeResidual(const MooseArray<Gradient> & vector_sol,
                            const MooseArray<Number> & scalar_sol,
                            const MooseArray<Real> & JxW,
                            const libMesh::QBase & qrule,
                            DenseVector<Number> & vector_re);
 
  void vectorVolumeJacobian(const MooseArray<Real> & JxW,
                            const libMesh::QBase & qrule,
                            DenseMatrix<Number> & vector_vector_jac,
                            DenseMatrix<Number> & vector_scalar_jac);
 
  void scalarVolumeResidual(const MooseArray<Gradient> & vector_field,
                            const Moose::Functor<Real> & source,
                            const MooseArray<Real> & JxW,
                            const libMesh::QBase & qrule,
                            const Elem * const current_elem,
                            const MooseArray<Point> & q_point,
                            DenseVector<Number> & scalar_re);
 
  void scalarVolumeJacobian(const MooseArray<Real> & JxW,
                            const libMesh::QBase & qrule,
                            DenseMatrix<Number> & scalar_vector_jac);
 
  //
  // Methods which can be leveraged both on internal sides in the kernel and by boundary conditions
  //
 
  void vectorFaceResidual(const MooseArray<Number> & lm_sol,
                          const MooseArray<Real> & JxW_face,
                          const libMesh::QBase & qrule_face,
                          const MooseArray<Point> & normals,
                          DenseVector<Number> & vector_re);
 
  void vectorFaceJacobian(const MooseArray<Real> & JxW_face,
                          const libMesh::QBase & qrule_face,
                          const MooseArray<Point> & normals,
                          DenseMatrix<Number> & vector_lm_jac);
 
  void scalarFaceResidual(const MooseArray<Gradient> & vector_sol,
                          const MooseArray<Number> & scalar_sol,
                          const MooseArray<Number> & lm_sol,
                          const MooseArray<Real> & JxW_face,
                          const libMesh::QBase & qrule_face,
                          const MooseArray<Point> & normals,
                          DenseVector<Number> & scalar_re);
 
  void scalarFaceJacobian(const MooseArray<Real> & JxW_face,
                          const libMesh::QBase & qrule_face,
                          const MooseArray<Point> & normals,
                          DenseMatrix<Number> & scalar_vector_jac,
                          DenseMatrix<Number> & scalar_scalar_jac,
                          DenseMatrix<Number> & scalar_lm_jac);
 
  void lmFaceResidual(const MooseArray<Gradient> & vector_sol,
                      const MooseArray<Number> & scalar_sol,
                      const MooseArray<Number> & lm_sol,
                      const MooseArray<Real> & JxW_face,
                      const libMesh::QBase & qrule_face,
                      const MooseArray<Point> & normals,
                      DenseVector<Number> & lm_re);
 
  void lmFaceJacobian(const MooseArray<Real> & JxW_face,
                      const libMesh::QBase & qrule_face,
                      const MooseArray<Point> & normals,
                      DenseMatrix<Number> & lm_vec_jac,
                      DenseMatrix<Number> & lm_scalar_jac,
                      DenseMatrix<Number> & lm_lm_jac);
 
  void vectorDirichletResidual(const Moose::Functor<Real> & dirichlet_value,
                               const MooseArray<Real> & JxW_face,
                               const libMesh::QBase & qrule_face,
                               const MooseArray<Point> & normals,
                               const Elem * const current_elem,
                               const unsigned int current_side,
                               const MooseArray<Point> & q_point_face,
                               DenseVector<Number> & vector_re);
 
  void scalarDirichletResidual(const MooseArray<Gradient> & vector_sol,
                               const MooseArray<Number> & scalar_sol,
                               const Moose::Functor<Real> & dirichlet_value,
                               const MooseArray<Real> & JxW_face,
                               const libMesh::QBase & qrule_face,
                               const MooseArray<Point> & normals,
                               const Elem * const current_elem,
                               const unsigned int current_side,
                               const MooseArray<Point> & q_point_face,
                               DenseVector<Number> & scalar_re);
 
  void scalarDirichletJacobian(const MooseArray<Real> & JxW_face,
                               const libMesh::QBase & qrule_face,
                               const MooseArray<Point> & normals,
                               DenseMatrix<Number> & scalar_vector_jac,
                               DenseMatrix<Number> & scalar_scalar_jac);
 
  void createIdentityResidual(const MooseArray<Real> & JxW,
                              const libMesh::QBase & qrule,
                              const MooseArray<std::vector<Real>> & phi,
                              const MooseArray<Number> & sol,
                              DenseVector<Number> & re);
 
  void createIdentityJacobian(const MooseArray<Real> & JxW,
                              const libMesh::QBase & qrule,
                              const MooseArray<std::vector<Real>> & phi,
                              DenseMatrix<Number> & ke);
 
  const MooseVariableFE<Real> & _u_var;
  const MooseVariableFE<RealVectorValue> & _grad_u_var;
  const MooseVariableFE<Real> & _u_face_var;
 
  // Containers for dof indices
  const std::vector<dof_id_type> & _qu_dof_indices;
  const std::vector<dof_id_type> & _u_dof_indices;
  const std::vector<dof_id_type> & _lm_u_dof_indices;
 
  // local solutions at quadrature points
  const MooseArray<libMesh::Gradient> & _qu_sol;
  const MooseArray<Number> & _u_sol;
  const MooseArray<Number> & _lm_u_sol;
 
  // Element shape functions
  const MooseArray<std::vector<RealVectorValue>> & _vector_phi;
  const MooseArray<std::vector<Real>> & _scalar_phi;
  const MooseArray<std::vector<RealVectorValue>> & _grad_scalar_phi;
  const MooseArray<std::vector<Real>> & _div_vector_phi;
 
  // Face shape functions
  const MooseArray<std::vector<RealVectorValue>> & _vector_phi_face;
  const MooseArray<std::vector<Real>> & _scalar_phi_face;
  const MooseArray<std::vector<Real>> & _lm_phi_face;
 
  const MaterialProperty<Real> & _diff;
 
  const TransientInterface & _ti;
 
  const Real _tau;
 
  const Elem * _cached_elem;
 
  // Local residual vectors
  DenseVector<Number> _vector_re, _scalar_re, _lm_re;
 
  // Local Jacobian matrices
  DenseMatrix<Number> _vector_vector_jac, _vector_scalar_jac, _scalar_vector_jac,
      _scalar_scalar_jac, _scalar_lm_jac, _lm_scalar_jac, _lm_lm_jac, _vector_lm_jac,
      _lm_vector_jac;
 
private:
  const MooseObject & _moose_obj;
 
  const FEProblemBase & _dhah_fe_problem;
 
  const SystemBase & _dhah_sys;
};