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;
 
  const 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>;