InitialConditionTempl.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 "InitialConditionBase.h"

// libMesh
#include "libmesh/point.h"
#include "libmesh/vector_value.h"
#include "libmesh/elem.h"

// forward declarations
class FEProblemBase;
class Assembly;

template <typename T>
class InitialConditionTempl : public InitialConditionBase
{
public:
  typedef typename OutputTools<T>::OutputShape ValueType;
  typedef typename OutputTools<T>::OutputGradient GradientType;
  typedef typename OutputTools<T>::OutputShapeGradient GradientShapeType;
  typedef typename OutputTools<T>::OutputData DataType;
  typedef libMesh::FEGenericBase<ValueType> FEBaseType;

  InitialConditionTempl(const InputParameters & parameters);

  virtual ~InitialConditionTempl();

  static InputParameters validParams();

  virtual MooseVariableFEBase & variable() override { return _var; }

  virtual void compute() override;

  virtual void computeNodal(const Point & p) override;

  virtual T value(const Point & p) = 0;

  virtual GradientType gradient(const Point & /*p*/) { return GradientType(); };

  T gradientComponent(GradientType grad, unsigned int i);

  void setCZeroVertices();
  void setHermiteVertices();
  void setOtherCOneVertices();

  Real dotHelper(const libMesh::RealGradient & op1, const libMesh::RealGradient & op2)
  {
    return op1 * op2;
  }
  Real dotHelper(const RealTensor & op1, const RealTensor & op2) { return op1.contract(op2); }
  RealEigenVector dotHelper(const RealVectorArrayValue & op1, const libMesh::RealGradient & op2)
  {
    RealEigenVector v = op1.col(0) * op2(0);
    for (const auto i : make_range(Moose::dim))
      v += op1.col(i) * op2(i);
    return v;
  }

  void choleskySolve(bool is_volume);

  void choleskyAssembly(bool is_volume);

protected:
  FEProblemBase & _fe_problem;
  THREAD_ID _tid;

  Real & _t;

  MooseVariableField<T> & _var;
  MooseVariableFE<T> * _fe_var;

  Assembly & _assembly;

  const Moose::CoordinateSystemType & _coord_sys;

  const Elem * const & _current_elem;

  const Real & _current_elem_volume;

  const Node * _current_node;

  unsigned int _qp;

  DenseMatrix<Real> _Ke;
  DenseVector<DataType> _Fe;
  DenseVector<DataType> _Ue;

  const libMesh::FEType & _fe_type;
  libMesh::FEContinuity _cont;

  std::vector<dof_id_type> _dof_indices;
  std::vector<unsigned int> _side_dofs;

  unsigned int _n_qp;
  unsigned int _n_nodes;

  std::vector<char> _dof_is_fixed;
  std::vector<int> _free_dof;

  dof_id_type _free_dofs;
  dof_id_type _current_dof;
  dof_id_type _nc;

  const std::vector<std::vector<ValueType>> * _phi;
  const std::vector<std::vector<GradientShapeType>> * _dphi;
  const std::vector<Real> * _JxW;
  const std::vector<Point> * _xyz_values;

  unsigned int _n;
  unsigned int _dim;
};

template <typename T>
InputParameters
InitialConditionTempl<T>::validParams()
{
  return InitialConditionBase::validParams();
}

typedef InitialConditionTempl<Real> InitialCondition;
typedef InitialConditionTempl<RealVectorValue> VectorInitialCondition;
typedef InitialConditionTempl<RealEigenVector> ArrayInitialCondition;

// Declare all the specializations, as the template specialization declaration below must know
template <>
void InitialConditionTempl<RealVectorValue>::setCZeroVertices();
template <>
RealVectorValue InitialConditionTempl<RealVectorValue>::gradientComponent(GradientType grad,
                                                                          unsigned int i);
template <>
RealEigenVector InitialConditionTempl<RealEigenVector>::gradientComponent(GradientType grad,
                                                                          unsigned int i);
template <>
void InitialConditionTempl<RealVectorValue>::setHermiteVertices();
template <>
void InitialConditionTempl<RealVectorValue>::setOtherCOneVertices();
template <>
void InitialConditionTempl<RealEigenVector>::choleskySolve(bool is_volume);

// Prevent implicit instantiation in other translation units where these classes are used
extern template class InitialConditionTempl<Real>;
extern template class InitialConditionTempl<RealVectorValue>;
extern template class InitialConditionTempl<RealEigenVector>;