InitialConditionTempl.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 "InitialConditionBase.h"
 
// libMesh
#include "libmesh/point.h"
#include "libmesh/vector_value.h"
#include "libmesh/elem.h"
 
// forward declarations
template <typename>
class InitialConditionTempl;
class FEProblemBase;
class Assembly;
 
template <>
InputParameters validParams<InitialConditionTempl<Real>>();
template <>
InputParameters validParams<InitialConditionTempl<RealVectorValue>>();
template <>
InputParameters validParams<InitialConditionTempl<RealEigenVector>>();
 
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 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 RealGradient & op1, const RealGradient & op2) { return op1 * op2; }
  Real dotHelper(const RealTensor & op1, const RealTensor & op2) { return op1.contract(op2); }
  RealEigenVector dotHelper(const RealVectorArrayValue & op1, const RealGradient & op2)
  {
    RealEigenVector v = op1.col(0) * op2(0);
    for (unsigned int i = 1; i < LIBMESH_DIM; ++i)
      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;
 
  Assembly & _assembly;
 
  Real & _t;
 
  const Moose::CoordinateSystemType & _coord_sys;
 
  MooseVariableFE<T> & _var;
 
  const Elem * const & _current_elem;
 
  const Node * _current_node;
 
  unsigned int _qp;
 
  DenseMatrix<Real> _Ke;
  DenseVector<DataType> _Fe;
  DenseVector<DataType> _Ue;
 
  const FEType & _fe_type;
  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;
};
 
typedef InitialConditionTempl<Real> InitialCondition;
typedef InitialConditionTempl<RealVectorValue> VectorInitialCondition;
typedef InitialConditionTempl<RealEigenVector> ArrayInitialCondition;