https://mooseframework.inl.gov
MooseVariableData.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #include "MooseArray.h"
13 #include "MooseTypes.h"
14 #include "MooseVariableDataBase.h"
15 #include "Conversion.h"
16 
17 #include "libmesh/tensor_tools.h"
18 #include "libmesh/vector_value.h"
19 #include "libmesh/tensor_value.h"
20 #include "libmesh/type_n_tensor.h"
21 #include "libmesh/enum_fe_family.h"
22 #include "libmesh/fe_type.h"
23 #include "ADUtils.h"
24 
25 #include <functional>
26 #include <vector>
27 
28 namespace libMesh
29 {
30 class QBase;
31 class DofMap;
32 template <typename>
33 class DenseVector;
34 }
35 
37 using libMesh::DofMap;
38 using libMesh::QBase;
40 
41 class TimeIntegrator;
42 class Assembly;
43 class SubProblem;
44 template <typename>
45 class MooseVariableFE;
46 class SystemBase;
47 
48 template <typename OutputType>
49 class MooseVariableData : public MooseVariableDataBase<OutputType>
50 {
51 public:
52  // type for gradient, second and divergence of template class OutputType
56 
57  // shortcut for types storing values on quadrature points
63 
64  // shape function type for the template class OutputType
66 
67  // type for gradient, second and divergence of shape functions of template class OutputType
71 
72  // shortcut for types storing shape function values on quadrature points
78 
79  // shortcut for types storing test function values on quadrature points
80  // Note: here we assume the types are the same as of shape functions.
86 
87  // DoF value type for the template class OutputType
90 
92  SystemBase & sys,
93  THREAD_ID tid,
94  Moose::ElementType element_type,
95  const QBase * const & qrule_in,
96  const QBase * const & qrule_face_in,
97  const Node * const & node,
98  const Elem * const & elem);
99 
103  bool needsAD() const { return _need_ad; }
104 
109  void setGeometry(Moose::GeometryType gm_type);
110 
112 
116  void computeValues();
117 
121  void computeMonomialValues();
122 
126  void computeAD(const unsigned int num_dofs, const unsigned int nqp);
127 
131  void computeNodalValues();
132 
134 
138  const FieldVariablePhiValue & phi() const { return *_phi; }
139 
143  const FieldVariablePhiValue & phiFace() const { return *_phi_face; }
144 
148  const FieldVariablePhiGradient & gradPhi() const { return *_grad_phi; }
149 
154  {
155  mooseAssert(var().fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY, "Not an array variable");
156  return _mapped_grad_phi;
157  }
158 
163 
168  {
169  mooseAssert(var().fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY, "Not an array variable");
170  return _mapped_grad_phi_face;
171  }
172 
176  const FieldVariablePhiSecond & secondPhi() const;
177 
181  const FieldVariablePhiSecond & secondPhiFace() const;
182 
186  const FieldVariablePhiCurl & curlPhi() const;
187 
191  const FieldVariablePhiCurl & curlPhiFace() const;
192 
196  const FieldVariablePhiDivergence & divPhi() const;
197 
201  const FieldVariablePhiDivergence & divPhiFace() const;
202 
207 
212 
216  std::size_t phiSize() const { return _phi->size(); }
217 
221  std::size_t phiFaceSize() const { return _phi_face->size(); }
222 
226  bool usesSecondPhi() const
227  {
229  }
230 
234  bool computingCurl() const { return _need_curl || _need_curl_old; }
235 
239  bool computingDiv() const { return _need_div || _need_div_old; }
240 
242 
243  bool isNodal() const override { return _is_nodal; }
244  bool hasDoFsOnNodes() const override { return _continuity != libMesh::DISCONTINUOUS; }
245  libMesh::FEContinuity getContinuity() const override { return _continuity; };
246  const Node * const & node() const { return _node; }
247  const dof_id_type & nodalDofIndex() const { return _nodal_dof_index; }
248  bool isNodalDefined() const { return _has_dof_indices; }
249 
253  const Elem * const & currentElem() const { return _elem; }
254 
258  const unsigned int & currentSide() const { return _current_side; }
259 
263  void prepareIC();
264 
266 
270  const FieldVariableGradient & gradSlnDot() const;
271 
275  const FieldVariableGradient & gradSlnDotDot() const;
276 
282 
287  const FieldVariableCurl & curlSln(Moose::SolutionState state) const;
288 
294 
296  {
297  _need_ad = _need_ad_u = true;
298  return _ad_u;
299  }
300 
302  {
303  _need_ad = _need_ad_grad_u = true;
304  return _ad_grad_u;
305  }
306 
308  {
309  _need_ad = _need_ad_grad_u_dot = true;
310 
311  if (!_time_integrator)
312  // If we don't have a time integrator (this will be the case for variables that are a part of
313  // the AuxiliarySystem) then we have no way to calculate _ad_grad_u_dot and we are just going
314  // to copy the values from _grad_u_dot. Of course in order to be able to do that we need to
315  // calculate _grad_u_dot
316  _need_grad_dot = true;
317 
318  return _ad_grad_u_dot;
319  }
320 
322  {
323  _need_ad = _need_ad_second_u = true;
324  secondPhi();
325  secondPhiFace();
326  return _ad_second_u;
327  }
328 
330 
332 
333  const FieldVariableValue & uDot() const;
334 
335  const FieldVariableValue & uDotDot() const;
336 
337  const FieldVariableValue & uDotOld() const;
338 
339  const FieldVariableValue & uDotDotOld() const;
340 
341  const VariableValue & duDotDu() const
342  {
343  _need_du_dot_du = true;
344  return _du_dot_du;
345  }
346 
347  const VariableValue & duDotDotDu() const
348  {
349  _need_du_dotdot_du = true;
350  return _du_dotdot_du;
351  }
352 
354  {
355  _need_ad = _need_ad_curl_u = true;
356  curlPhi();
357  curlPhiFace();
358  return _ad_curl_u;
359  }
360 
362 
363  const OutputType & nodalValueDot() const;
364  const OutputType & nodalValueDotDot() const;
365  const OutputType & nodalValueDotOld() const;
366  const OutputType & nodalValueDotDotOld() const;
367  const OutputType & nodalValueDuDotDu() const;
368  const OutputType & nodalValueDuDotDotDu() const;
369 
370  const typename Moose::ADType<OutputType>::type & adNodalValue() const;
371 
375  void setDofValues(const DenseVector<OutputData> & values);
376 
378 
381  void setDofValue(const OutputData & value, unsigned int index);
383 
388  OutputData getNodalValue(const Node & node, Moose::SolutionState state) const;
389  OutputData
390  getElementalValue(const Elem * elem, Moose::SolutionState state, unsigned int idx = 0) const;
391 
393 
394  void getDofIndices(const Elem * elem, std::vector<dof_id_type> & dof_indices) const;
395  const std::vector<dof_id_type> & dofIndices() const { return _dof_indices; }
396  unsigned int numberOfDofs() const { return _dof_indices.size(); }
397  void clearDofIndices() { _dof_indices.clear(); }
398 
402  void prepare();
403 
407  void reinitNode();
408 
412  void reinitAux();
413 
418  void reinitNodes(const std::vector<dof_id_type> & nodes);
419 
424  const DenseVector<libMesh::Number> & v) const;
425 
427 
428  const DoFValue & dofValuesDot() const;
429  const DoFValue & dofValuesDotOld() const;
430  const DoFValue & dofValuesDotDot() const;
431  const DoFValue & dofValuesDotDotOld() const;
434 
438  const MooseArray<ADReal> & adDofValues() const;
439 
443  const MooseArray<ADReal> & adDofValuesDot() const;
444 
446 
451  const FieldVariableValue & increment() const { return _increment; }
452 
457 
462 
463 private:
469  void assignADNodalValue(const ADReal & value, const unsigned int & component);
470  void fetchADNodalValues();
471 
478  template <bool monomial>
479  void computeValuesInternal();
480 
482 
483  const unsigned int _var_num;
484 
486 
489 
491  bool _is_nodal;
492 
495 
498 
501 
504 
507 
509  mutable bool _need_ad_u_dot;
510  mutable bool _need_ad_u_dotdot;
511 
513  mutable bool _need_second;
514  mutable bool _need_second_old;
515  mutable bool _need_second_older;
517 
519  mutable bool _need_curl;
520  mutable bool _need_curl_old;
521  mutable bool _need_curl_older;
522 
524  mutable bool _need_div;
525  mutable bool _need_div_old;
526  mutable bool _need_div_older;
527 
529  mutable bool _need_ad;
530  mutable bool _need_ad_u;
531  mutable bool _need_ad_grad_u;
532  mutable bool _need_ad_grad_u_dot;
533  mutable bool _need_ad_second_u;
534  mutable bool _need_ad_curl_u;
535 
537 
541 
547 
552 
557 
569 
570  // time derivatives
571 
574 
577 
580 
583 
586 
589 
593  const QBase * const & _qrule;
594  const QBase * const & _qrule_face;
595 
596  // Shape function values, gradients, second derivatives
602 
603  // Mapped array phi
608 
609  // Values, gradients and second derivatives of shape function on faces
615 
618 
626 
627  // dual mortar
628  const bool _use_dual;
629 
636 
643 
650 
657 
661 
665 
666  std::function<const ADTemplateVariablePhiGradient<OutputShape> &(const Assembly &,
669  std::function<const ADTemplateVariablePhiGradient<OutputShape> &(const Assembly &,
672 
675 
679  const Node * const & _node;
680 
684  const Elem * const & _elem;
685 
687  const bool _displaced;
688 
690  const unsigned int & _current_side;
691 
694 
744 };
745 
747 
748 template <typename OutputType>
749 const MooseArray<ADReal> &
751 {
752  _need_ad = true;
753  return _ad_dof_values;
754 }
755 
756 template <typename OutputType>
757 const MooseArray<ADReal> &
759 {
760  _need_ad = _need_ad_u_dot = true;
761  if (!_time_integrator)
762  // See explanation in adUDot() body
763  _need_u_dot = true;
764  return _ad_dofs_dot;
765 }
766 
767 template <typename OutputType>
768 const typename Moose::ADType<OutputType>::type &
770 {
771  _need_ad = true;
772  return _ad_nodal_value;
773 }
774 
775 template <typename OutputType>
778 {
779  _need_ad = _need_ad_u_dot = true;
780 
781  if (!_time_integrator)
782  // If we don't have a time integrator (this will be the case for variables that are a part of
783  // the AuxiliarySystem) then we have no way to calculate _ad_u_dot and we are just going to
784  // copy the values from _u_dot. Of course in order to be able to do that we need to calculate
785  // _u_dot
786  _need_u_dot = true;
787 
788  return _ad_u_dot;
789 }
790 
791 template <typename OutputType>
794 {
795  _need_ad = _need_ad_u_dotdot = true;
796 
797  if (!_time_integrator)
798  // If we don't have a time integrator (this will be the case for variables that are a part
799  // of the AuxiliarySystem) then we have no way to calculate _ad_u_dotdot and we are just
800  // going to copy the values from _u_dotdot. Of course in order to be able to do that we need
801  // to calculate _u_dotdot
802  _need_u_dotdot = true;
803 
804  return _ad_u_dotdot;
805 }
806 
807 template <typename OutputType>
810 {
811  if (_element_type == Moose::ElementType::Neighbor || _element_type == Moose::ElementType::Lower)
812  mooseError("Unsupported element type: ", Moose::stringify(_element_type));
813  mooseAssert(_ad_grad_phi, "this should be non-null");
814  return *_ad_grad_phi;
815 }
816 
817 template <typename OutputType>
820 {
821  if (_element_type == Moose::ElementType::Neighbor || _element_type == Moose::ElementType::Lower)
822  mooseError("Unsupported element type: ", Moose::stringify(_element_type));
823  mooseAssert(_ad_grad_phi_face, "this should be non-null");
824  return *_ad_grad_phi_face;
825 }
const FieldVariableDivergence & divSln(Moose::SolutionState state) const
Local solution divergence getter.
typename OutputTools< typename Moose::ADType< T >::type >::VariableSecond ADTemplateVariableSecond
Definition: MooseTypes.h:609
FieldVariableCurl _curl_u_old
const Assembly & _assembly
bool _need_grad_dot
gradient dot flags
const ADTemplateVariableValue< OutputType > & adUDot() const
OutputData getNodalValue(const Node &node, Moose::SolutionState state) const
const FieldVariablePhiDivergence * _div_phi_face
typename OutputTools< typename Moose::ADType< T >::type >::VariableCurl ADTemplateVariableCurl
Definition: MooseTypes.h:611
const ADTemplateVariableSecond< OutputType > & adSecondSln() const
const FieldVariableValue & uDotDotOld() const
const OutputType & nodalValueDuDotDotDu() const
bool usesSecondPhi() const
Whether or not this variable is computing any second derivatives.
const MappedArrayVariablePhiGradient & arrayGradPhiFace() const
mapped_grad_phi_face getter
const FieldVariablePhiSecond * _second_phi
void computeAD(const unsigned int num_dofs, const unsigned int nqp)
compute AD things
typename OutputTools< typename Moose::ADType< T >::type >::VariablePhiGradient ADTemplateVariablePhiGradient
Definition: MooseTypes.h:637
const unsigned int & currentSide() const
The current side.
MooseArray< std::vector< OutputShape > > FieldVariableTestCurl
const FieldVariablePhiCurl & curlPhi() const
curl_phi getter
void reinitNodes(const std::vector< dof_id_type > &nodes)
Set _dof_indices to the degrees of freedom existing on the passed-in nodes.
Keeps track of stuff related to assembling.
Definition: Assembly.h:101
Class for stuff related to variables.
Definition: Adaptivity.h:31
void prepare()
Get the dof indices corresponding to the current element.
MooseArray< OutputDivergence > FieldVariableDivergence
MappedArrayVariablePhiGradient _mapped_grad_phi
ADTemplateVariableValue< OutputType > _ad_u
AD u.
Class for stuff related to variables.
const MappedArrayVariablePhiGradient & arrayGradPhi() const
mapped_grad_phi getter
MooseArray< OutputType > FieldVariableValue
libMesh::TensorTools::DecrementRank< OutputShape >::type OutputShapeDivergence
void setDofValue(const OutputData &value, unsigned int index)
dof value setters
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
MooseArray< OutputData > DoFValue
MooseArray< std::vector< OutputShape > > FieldVariablePhiCurl
MooseArray< std::vector< OutputShapeDivergence > > FieldVariableTestDivergence
OutputType type
Definition: MooseTypes.h:268
const ADTemplateVariableGradient< OutputType > & adGradSlnDot() const
OutputType type
Definition: MooseTypes.h:257
const Node *const & _node
The current node.
MooseArray< ADReal > _ad_dofs_dot
bool computingCurl() const
Whether or not this variable is computing the curl.
void computeValues()
compute the variable values
ADTemplateVariableSecond< OutputType > _ad_second_u
FieldVariableSecond _second_u_older
FieldVariableSecond _second_u_previous_nl
const FieldVariableValue & uDotDot() const
void getDofIndices(const Elem *elem, std::vector< dof_id_type > &dof_indices) const
std::function< const typename OutputTools< OutputShape >::VariablePhiCurl &(const Assembly &, libMesh::FEType)> _curl_phi_assembly_method
Moose::DOFType< OutputType >::type OutputData
bool _need_second
SolutionState second_u flags.
const OutputType & nodalValueDotOld() const
const FieldVariablePhiGradient * _current_grad_phi
const MooseArray< ADReal > & adDofValues() const
Return the AD dof values.
MooseArray< OutputSecond > FieldVariableSecond
const FieldVariableValue & increment() const
Increment getter.
MappedArrayVariablePhiGradient _mapped_grad_phi_face
std::function< const typename OutputTools< OutputShape >::VariablePhiCurl &(const Assembly &, libMesh::FEType)> _curl_phi_face_assembly_method
typename OutputTools< typename Moose::ADType< T >::type >::VariableValue ADTemplateVariableValue
Definition: MooseTypes.h:603
void computeIncrementAtNode(const libMesh::NumericVector< libMesh::Number > &increment_vec)
Compute and store incremental change at the current node based on increment_vec.
const FieldVariablePhiDivergence * _div_phi
ADTemplateVariableGradient< OutputType > _ad_grad_u
dof_id_type _nodal_dof_index
The dof index for the current node.
const FieldVariablePhiCurl * _current_curl_phi
const FieldVariableValue & uDot() const
OutputTools< Real >::VariablePhiValue VariablePhiValue
Definition: MooseTypes.h:319
const ADTemplateVariableValue< OutputType > & adUDotDot() const
void computeMonomialValues()
compute the values for const monomial variables
MooseArray< ADReal > _ad_dofs_dotdot
ADReal _ad_real_dummy
A dummy ADReal variable.
const FieldVariablePhiDivergence * _current_div_phi
MooseVariableData(const MooseVariableField< OutputType > &var, SystemBase &sys, THREAD_ID tid, Moose::ElementType element_type, const QBase *const &qrule_in, const QBase *const &qrule_face_in, const Node *const &node, const Elem *const &elem)
const FieldVariablePhiCurl * _curl_phi_face
void computeNodalValues()
compute nodal things
const MooseArray< libMesh::Number > & dofValuesDuDotDotDu() const
MooseArray< std::vector< OutputShapeSecond > > FieldVariablePhiSecond
const QBase * _current_qrule
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
ElementType
Definition: MooseTypes.h:763
const FieldVariablePhiCurl * _curl_phi
std::function< const ADTemplateVariablePhiGradient< OutputShape > &(const Assembly &, libMesh::FEType)> _ad_grad_phi_assembly_method
Base class for a system (of equations)
Definition: SystemBase.h:84
MooseArray< std::vector< OutputShapeSecond > > FieldVariableTestSecond
bool hasDoFsOnNodes() const override
Whether this data is associated with a variable that has DoFs on nodes.
DualNumber< Real, DNDerivativeType, true > ADReal
Definition: ADRealForward.h:46
A structure for storing the various lists that contain the names of the items to be exported...
ADTemplateVariableGradient< OutputType > _ad_grad_u_dot
FieldVariableValue _u_dot_old
u_dot_old (time derivative)
const unsigned int _var_num
libMesh::TensorTools::IncrementRank< OutputType >::type OutputGradient
void prepareIC()
prepare the initial condition
MappedArrayVariablePhiGradient _mapped_grad_phi_neighbor
OutputTools< Real >::VariablePhiSecond VariablePhiSecond
Definition: MooseTypes.h:321
void assignADNodalValue(const ADReal &value, const unsigned int &component)
Helper methods for assigning nodal values from their corresponding solution values (dof values as the...
MooseArray< std::vector< OutputShapeDivergence > > FieldVariablePhiDivergence
FieldVariableDivergence _div_u_old
const FieldVariableGradient & gradSlnDot() const
Local time derivative of solution gradient getter.
FieldVariableDivergence _div_u_older
libMesh::TensorTools::IncrementRank< OutputShapeGradient >::type OutputShapeSecond
void setDofValues(const DenseVector< OutputData > &values)
Set local DOF values and evaluate the values on quadrature points.
VariableValue _du_dot_du
derivative of u_dot wrt u
std::function< const typename OutputTools< OutputShape >::VariablePhiValue &(const Assembly &, libMesh::FEType)> _phi_face_assembly_method
OutputData getElementalValue(const Elem *elem, Moose::SolutionState state, unsigned int idx=0) const
MappedArrayVariablePhiGradient _mapped_grad_phi_face_neighbor
void insertNodalValue(libMesh::NumericVector< libMesh::Number > &residual, const OutputData &v)
Write a nodal value to the passed-in solution vector.
std::function< const typename OutputTools< OutputShape >::VariablePhiSecond &(const Assembly &, libMesh::FEType)> _second_phi_face_assembly_method
const FieldVariablePhiSecond * _second_phi_face
const DoFValue & dofValuesDotDotOld() const
const MooseArray< libMesh::Number > & dofValuesDuDotDu() const
const DoFValue & dofValuesDot() const
FieldVariableValue _u_dot
u_dot (time derivative)
unsigned int size() const
The number of elements that can currently be stored in the array.
Definition: MooseArray.h:259
const FieldVariablePhiValue & phi() const
phi getter
ADTemplateVariableValue< OutputType > _ad_u_dot
libMesh::FEContinuity getContinuity() const override
Return the variable continuity.
FieldVariableSecond _second_u
second_u
const FieldVariablePhiDivergence & divPhi() const
divergence_phi getter
const MooseArray< ADReal > & adDofValuesDot() const
Return the AD time derivative values of degrees of freedom.
void computeValuesInternal()
Internal method for computeValues() and computeMonomialValues()
const OutputType & nodalValueDot() const
unsigned int numberOfDofs() const
const Elem *const & currentElem() const
The current element.
bool _need_ad_u_dot
AD u dot flags.
const FieldVariablePhiSecond & secondPhiFace() const
second_phi_face getter
const QBase *const & _qrule_face
void computeIncrementAtQps(const libMesh::NumericVector< libMesh::Number > &increment_vec)
Compute and store incremental change in solution at QPs based on increment_vec.
const VariableValue & duDotDotDu() const
const FieldVariablePhiGradient & gradPhiFace() const
grad_phi_face getter
const FieldVariableGradient & gradSlnDotDot() const
Local second time derivative of solution gradient getter.
const ADTemplateVariableValue< OutputType > & adSln() const
bool _need_curl
curl flags
virtual const MooseVariableField< OutputType > & var() const
std::vector< std::vector< Eigen::Map< RealDIMValue > > > MappedArrayVariablePhiGradient
Definition: MooseTypes.h:355
std::function< const typename OutputTools< OutputShape >::VariablePhiDivergence &(const Assembly &, libMesh::FEType)> _div_phi_face_assembly_method
FieldVariableGradient _grad_u_dotdot
const OutputType & nodalValueDuDotDu() const
typename OutputTools< typename Moose::ADType< T >::type >::VariableGradient ADTemplateVariableGradient
Definition: MooseTypes.h:606
OutputTools< Real >::VariablePhiCurl VariablePhiCurl
Definition: MooseTypes.h:322
bool _need_div
divergence flags
void reinitNode()
Prepare degrees of freedom for the current node.
bool isNodalDefined() const
const QBase *const & _qrule
The current qrule.
std::function< const ADTemplateVariablePhiGradient< OutputShape > &(const Assembly &, libMesh::FEType)> _ad_grad_phi_face_assembly_method
const TimeIntegrator * _time_integrator
Pointer to time integrator.
libMesh::TensorTools::IncrementRank< OutputGradient >::type OutputSecond
MooseArray< OutputType > FieldVariableCurl
FieldVariableValue _increment
Increment in the variable used in dampers.
FieldVariableDivergence _div_u
divergence_u
const Elem *const & _elem
The current elem.
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
const DoFValue & dofValuesDotDot() const
const std::vector< dof_id_type > & dofIndices() const
const ADTemplateVariableCurl< OutputType > & adCurlSln() const
bool _need_ad
AD flags.
const ADTemplateVariablePhiGradient< OutputShape > & adGradPhi() const
ad_grad_phi getter
libMesh::FEContinuity _continuity
Continuity type of the variable.
OutputTools< Real >::VariablePhiDivergence VariablePhiDivergence
Definition: MooseTypes.h:323
std::size_t phiSize() const
Return phi size.
const ADTemplateVariableGradient< OutputType > & adGradSln() const
Moose::ElementType _element_type
The element type this object is storing data for. This is either Element, Neighbor, or Lower.
ADReal _ad_zero
A zero AD variable.
const Moose::ADType< OutputType >::type & adNodalValue() const
std::function< const typename OutputTools< OutputShape >::VariablePhiGradient &(const Assembly &, libMesh::FEType)> _grad_phi_assembly_method
const ADTemplateVariablePhiGradient< OutputShape > * _ad_grad_phi
Moose::ADType< OutputType >::type _ad_nodal_value
AD nodal value.
const dof_id_type & nodalDofIndex() const
const VariableValue & duDotDu() const
const OutputType & nodalValueDotDotOld() const
FieldVariableValue _u_dotdot
u_dotdot (second time derivative)
OutputTools< Real >::VariableValue VariableValue
Definition: MooseTypes.h:314
std::function< const typename OutputTools< OutputShape >::VariablePhiGradient &(const Assembly &, libMesh::FEType)> _grad_phi_face_assembly_method
const FieldVariablePhiValue * _phi_face
OutputTools< Real >::VariablePhiGradient VariablePhiGradient
Definition: MooseTypes.h:320
libMesh::TensorTools::DecrementRank< OutputType >::type OutputDivergence
FieldVariableGradient _grad_u_dot
grad_u dots
const FieldVariablePhiValue & phiFace() const
phi_face getter
std::function< const typename OutputTools< OutputShape >::VariablePhiSecond &(const Assembly &, libMesh::FEType)> _second_phi_assembly_method
const Node *const & node() const
FieldVariableValue _u_dotdot_old
u_dotdot_old (second time derivative)
Base class for time integrators.
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:78
GeometryType
Definition: MooseTypes.h:248
const FieldVariableCurl & curlSln(Moose::SolutionState state) const
Local solution curl getter.
const FieldVariableValue & uDotOld() const
SolutionState
Definition: MooseTypes.h:233
const libMesh::FEType & _fe_type
FieldVariableSecond _second_u_old
Moose::ShapeType< OutputType >::type OutputShape
const ADTemplateVariablePhiGradient< OutputShape > * _ad_grad_phi_face
const FieldVariablePhiSecond & secondPhi() const
second_phi getter
const OutputType & nodalValueDotDot() const
bool computingDiv() const
Whether or not this variable is computing the divergence.
libMesh::TensorTools::IncrementRank< OutputShape >::type OutputShapeGradient
MooseArray< std::vector< OutputShape > > FieldVariablePhiValue
const bool _displaced
Whether this variable is being calculated on a displaced system.
const FieldVariablePhiSecond * _current_second_phi
const unsigned int & _current_side
The current element side.
const FieldVariablePhiGradient * _grad_phi_face
void addSolution(libMesh::NumericVector< libMesh::Number > &sol, const DenseVector< libMesh::Number > &v) const
Add passed in local DOF values to a solution vector.
MooseArray< OutputGradient > FieldVariableGradient
const FieldVariablePhiCurl & curlPhiFace() const
curl_phi_face getter
const DoFValue & dofValuesDotOld() const
const ADTemplateVariablePhiGradient< OutputShape > & adGradPhiFace() const
ad_grad_phi_face getter
const FieldVariablePhiGradient & gradPhi() const
grad_phi getter
MooseArray< std::vector< OutputShapeGradient > > FieldVariableTestGradient
VariableValue _du_dotdot_du
derivative of u_dotdot wrt u
const FieldVariablePhiValue * _current_phi
void setGeometry(Moose::GeometryType gm_type)
Set the geometry type before calculating variables values.
void reinitAux()
Prepare dof indices and solution values for elemental auxiliary variables.
std::vector< dof_id_type > _dof_indices
The dof indices for the current element.
const ADTemplateVariablePhiGradient< OutputShape > * _current_ad_grad_phi
ADTemplateVariableValue< OutputType > _ad_u_dotdot
std::function< const typename OutputTools< OutputType >::VariablePhiValue &(const Assembly &, libMesh::FEType)> _phi_assembly_method
bool isNodal() const override
const FieldVariablePhiDivergence & divPhiFace() const
divergence_phi_face getter
const FieldVariableSecond & secondSln(Moose::SolutionState state) const
Local solution second spatial derivative getter.
FieldVariableCurl _curl_u_older
ADTemplateVariableCurl< OutputType > _ad_curl_u
std::size_t phiFaceSize() const
Return phiFace size.
MooseArray< ADReal > _ad_dof_values
bool _is_nodal
if variable is nodal
const FieldVariablePhiGradient * _grad_phi
std::function< const typename OutputTools< OutputShape >::VariablePhiDivergence &(const Assembly &, libMesh::FEType)> _div_phi_assembly_method
bool needsAD() const
Returns whether this data structure needs automatic differentiation calculations. ...
const FieldVariablePhiValue * _phi
MooseArray< std::vector< OutputShape > > FieldVariableTestValue
unsigned int THREAD_ID
Definition: MooseTypes.h:209
MooseArray< std::vector< OutputShapeGradient > > FieldVariablePhiGradient
uint8_t dof_id_type
FieldVariableCurl _curl_u
curl_u