17 template <
typename OutputType>
22 _subproblem(_sys.subproblem()),
24 _dof_map(_sys.dofMap()),
26 _has_dof_values(false),
33 _need_u_dotdot(false),
34 _need_u_dot_old(false),
35 _need_u_dotdot_old(false),
36 _need_du_dot_du(false),
37 _need_du_dotdot_du(false),
38 _need_grad_dot(false),
39 _need_grad_dotdot(false),
40 _need_dof_values_dot(false),
41 _need_dof_values_dotdot(false),
42 _need_dof_values_dot_old(false),
43 _need_dof_values_dotdot_old(false),
44 _need_dof_du_dot_du(false),
45 _need_dof_du_dotdot_du(false),
53 const auto max_future_num_vector_tags = num_vector_tags + 2;
83 template <
typename OutputType>
87 auto num_matrix_tags = _subproblem.numMatrixTags();
89 _matrix_tags_dof_u.resize(num_matrix_tags);
90 _need_matrix_tag_dof_u.resize(num_matrix_tags,
false);
92 _need_matrix_tag_u.resize(num_matrix_tags,
false);
93 _matrix_tag_u.resize(num_matrix_tags);
96 template <
typename OutputType>
102 if (tag >= _need_vector_tag_dof_u.size())
105 _need_vector_tag_dof_u[tag] =
true;
107 if (_sys.hasVector(tag))
108 return _vector_tags_dof_u[tag];
111 "Tag ", tag,
" is not associated with any vector for nodal variable ", _var.name());
114 mooseError(
"Nodal values can be requested only on nodal variables, variable '",
119 template <
typename OutputType>
125 if (tag >= _matrix_tags_dof_u.size())
127 _need_matrix_tag_dof_u.
resize(tag + 1,
false);
131 _need_matrix_tag_dof_u[tag] =
true;
133 if (_sys.hasMatrix(tag))
134 return _matrix_tags_dof_u[tag];
137 "Tag ", tag,
" is not associated with any matrix for nodal variable ", _var.name());
140 mooseError(
"Nodal values can be requested only on nodal variables, variable '",
145 template <
typename OutputType>
149 mooseAssert(_need_vector_tag_dof_u.size() == _need_vector_tag_u.size() &&
150 _need_vector_tag_dof_u.size() == _need_vector_tag_grad.size() &&
151 _need_vector_tag_dof_u.size() == _vector_tags_dof_u.size() &&
152 _need_vector_tag_dof_u.size() == _vector_tag_u.size() &&
153 _need_vector_tag_dof_u.size() == _vector_tag_grad.size(),
154 "These sizes should be in sync.");
156 auto check_capacity = [tag](
const auto & vector_to_check)
158 if (tag + 1 > vector_to_check.capacity())
159 mooseError(
"New size greater than tag capacity. This will cause reallocation which will " 160 "invalidate any stored references.");
162 check_capacity(_need_vector_tag_dof_u);
163 check_capacity(_need_vector_tag_u);
164 check_capacity(_need_vector_tag_grad);
165 check_capacity(_vector_tags_dof_u);
166 check_capacity(_vector_tag_u);
167 check_capacity(_vector_tag_grad);
169 _need_vector_tag_dof_u.resize(tag + 1,
false);
170 _need_vector_tag_u.resize(tag + 1,
false);
171 _need_vector_tag_grad.resize(tag + 1,
false);
172 _vector_tags_dof_u.resize(tag + 1);
173 _vector_tag_u.resize(tag + 1);
174 _vector_tag_grad.resize(tag + 1);
177 template <
typename OutputType>
181 if (tag >= _need_vector_tag_u.size())
184 _need_vector_tag_u[tag] =
true;
186 if (_sys.hasVector(tag))
187 return _vector_tag_u[tag];
189 mooseError(
"Tag ", tag,
" is not associated with any vector for variable ", _var.name());
192 template <
typename OutputType>
196 if (tag >= _need_vector_tag_dof_u.size())
199 _need_vector_tag_dof_u[tag] =
true;
201 if (_sys.hasVector(tag))
202 return _vector_tags_dof_u[tag];
204 mooseError(
"Tag ", tag,
" is not associated with any vector for variable ", _var.name());
207 template <
typename OutputType>
211 if (tag >= _need_vector_tag_grad.size())
214 _need_vector_tag_grad[tag] =
true;
216 if (_sys.hasVector(tag))
217 return _vector_tag_grad[tag];
219 mooseError(
"Tag ", tag,
" is not associated with any vector for variable ", _var.name());
222 template <
typename OutputType>
226 if (tag >= _matrix_tag_u.size())
228 _need_matrix_tag_u.
resize(tag + 1,
false);
232 _need_matrix_tag_u[tag] =
true;
234 if (_sys.hasMatrix(tag))
235 return _matrix_tag_u[tag];
237 mooseError(
"Tag ", tag,
" is not associated with any matrix for variable ", _var.name());
240 template <
typename OutputType>
247 template <
typename OutputType>
251 if (state > _max_state)
253 _sys.needSolutionState(state);
258 template <
typename OutputType>
259 template <
typename ReturnType,
typename Functor>
268 needSolutionState(cast_int<unsigned int>(state));
279 insertSolutionTag(_old_solution_tag);
280 return functor(_old_solution_tag);
286 insertSolutionTag(_older_solution_tag);
287 return functor(_older_solution_tag);
293 insertSolutionTag(_previous_nl_solution_tag);
294 return functor(_previous_nl_solution_tag);
304 template <
typename OutputType>
309 {
return vectorTagValue(tag_id); };
312 ->stateToTagHelper<FieldVariableValue>(state, functor);
315 template <
typename OutputType>
320 {
return vectorTagGradient(tag_id); };
323 ->stateToTagHelper<FieldVariableGradient>(state, functor);
326 template <
typename OutputType>
330 auto functor = [
this](
TagID tag_id) ->
const DoFValue & {
return vectorTagDofValue(tag_id); };
336 template <
typename OutputType>
343 template <
typename OutputType>
350 template <
typename OutputType>
357 template <
typename OutputType>
364 template <
typename OutputType>
368 auto & dof_values = _vector_tags_dof_u[_solution_tag];
369 mooseAssert(
idx < dof_values.size(),
"idx is out of the bounds of degree of freedom values");
371 _has_dof_values =
true;
372 _nodal_value =
value;
375 auto & u = _vector_tag_u[_solution_tag];
376 for (
unsigned int qp = 0; qp < u.size(); qp++)
385 auto & dof_values = _vector_tags_dof_u[_solution_tag];
386 for (decltype(
idx) i = 0; i < dof_values.size(); ++i, ++
idx)
389 _has_dof_values =
true;
390 _nodal_value =
value;
393 template <
typename OutputType>
399 auto & dof_values = _vector_tags_dof_u[_solution_tag];
400 mooseAssert(dof_values.size() == _dof_indices.size(),
401 "Degree of freedom values size and degree of freedom indices sizes must match.");
402 residual.
insert(&dof_values[0], _dof_indices);
412 auto & dof_values = _vector_tags_dof_u[_solution_tag];
415 for (
unsigned int i = 0; i < _dof_indices.size(); ++i)
416 for (
unsigned int j = 0; j < _count; ++j)
417 residual.
set(_dof_indices[i] + j, dof_values[i](j));
422 for (
unsigned int j = 0; j < _count; ++j)
424 for (
unsigned int i = 0; i < _dof_indices.size(); ++i)
425 residual.
set(_dof_indices[i] + n, dof_values[i](j));
426 n += _dof_indices.size();
432 template <
typename OutputType>
438 auto & dof_values = _vector_tags_dof_u[_solution_tag];
439 residual.
add_vector(&dof_values[0], _dof_indices);
449 auto & dof_values = _vector_tags_dof_u[_solution_tag];
452 for (
unsigned int i = 0; i < _dof_indices.size(); ++i)
453 for (
unsigned int j = 0; j < _count; ++j)
454 residual.
add(_dof_indices[i] + j, dof_values[i](j));
459 for (
unsigned int j = 0; j < _count; ++j)
461 for (
unsigned int i = 0; i < _dof_indices.size(); ++i)
462 residual.
add(_dof_indices[i] + n, dof_values[i](j));
463 n += _dof_indices.size();
469 template <
typename OutputType>
476 vectorTagDofValue(state);
483 return _nodal_value_old;
486 return _nodal_value_older;
489 return _nodal_value_previous_nl;
498 mooseError(
"Nodal values can be requested only on nodal variables, variable '",
503 template <
typename OutputType>
510 vectorTagDofValue(state);
514 return _nodal_value_array;
517 return _nodal_value_old_array;
520 return _nodal_value_older_array;
523 mooseError(
"No current support for PreviousNL for nodal value array");
527 mooseError(
"Nodal values can be requested only on nodal variables, variable '",
532 template <
typename OutputType>
536 bool is_transient = _subproblem.isTransient();
538 auto n = _dof_indices.size();
543 if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
546 _dof_values_dot.resize(n);
547 _sys.solutionUDot()->get(_dof_indices, &_dof_values_dot[0]);
549 if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
552 _dof_values_dotdot.resize(n);
553 _sys.solutionUDotDot()->get(_dof_indices, &_dof_values_dotdot[0]);
555 if (_need_u_dot_old || _need_dof_values_dot_old)
558 _dof_values_dot_old.resize(n);
559 _sys.solutionUDotOld()->get(_dof_indices, &_dof_values_dot_old[0]);
561 if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
564 _dof_values_dotdot_old.resize(n);
565 _sys.solutionUDotDotOld()->get(_dof_indices, &_dof_values_dotdot_old[0]);
569 for (
auto tag : _required_vector_tags)
570 if (_need_vector_tag_u[tag] || _need_vector_tag_grad[tag] || _need_vector_tag_dof_u[tag])
572 _subproblem.safeAccessTaggedVectors()) ||
578 if (_sys.hasVector(tag) )
580 auto & vec = _sys.getVector(tag);
581 _vector_tags_dof_u[tag].resize(n);
582 vec.get(_dof_indices, &_vector_tags_dof_u[tag][0]);
586 if (_subproblem.safeAccessTaggedMatrices())
588 auto & active_coupleable_matrix_tags =
589 _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);
591 for (
auto tag : active_coupleable_matrix_tags)
593 _matrix_tags_dof_u[tag].resize(n);
594 if (_need_matrix_tag_dof_u[tag] || _need_matrix_tag_u[tag])
595 if (_sys.hasMatrix(tag) && _sys.matrixTagActive(tag) && _sys.getMatrix(tag).closed())
597 auto & mat = _sys.getMatrix(tag);
598 for (
unsigned i = 0; i < n; i++)
600 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
601 _matrix_tags_dof_u[tag][i] = mat(_dof_indices[i], _dof_indices[i]);
607 if (_need_du_dot_du || _need_dof_du_dot_du)
609 _dof_du_dot_du.resize(n);
610 for (decltype(n) i = 0; i < n; ++i)
611 _dof_du_dot_du[i] = _sys.duDotDu(_var.number());
613 if (_need_du_dotdot_du || _need_dof_du_dotdot_du)
615 _dof_du_dotdot_du.resize(n);
616 for (decltype(n) i = 0; i < n; ++i)
617 _dof_du_dotdot_du[i] = _sys.duDotDotDu();
621 template <
typename OutputType>
630 for (
unsigned int i = 0; i < n; ++i)
632 dof_values[i].
resize(_count);
633 auto dof = _dof_indices[i];
634 for (
unsigned int j = 0; j < _count; ++j)
635 dof_values[i](j) = sol(dof++);
640 for (
unsigned int i = 0; i < n; ++i)
642 dof_values[i].
resize(_count);
643 auto dof = _dof_indices[i];
644 for (
unsigned int j = 0; j < _count; ++j)
646 dof_values[i](j) = sol(dof);
657 bool is_transient = _subproblem.isTransient();
659 auto n = _dof_indices.size();
664 if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
667 getArrayDoFValues(*_sys.solutionUDot(), n, _dof_values_dot);
669 if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
672 getArrayDoFValues(*_sys.solutionUDot(), n, _dof_values_dotdot);
674 if (_need_u_dot_old || _need_dof_values_dot_old)
677 getArrayDoFValues(*_sys.solutionUDotOld(), n, _dof_values_dot_old);
679 if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
682 getArrayDoFValues(*_sys.solutionUDotDotOld(), n, _dof_values_dotdot_old);
686 for (
auto tag : _required_vector_tags)
688 _subproblem.safeAccessTaggedVectors()) ||
691 if (_sys.hasVector(tag) && _sys.getVector(tag).closed())
692 getArrayDoFValues(_sys.getVector(tag), n, _vector_tags_dof_u[tag]);
694 if (_subproblem.safeAccessTaggedMatrices())
696 auto & active_coupleable_matrix_tags =
697 _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);
698 for (
auto tag : active_coupleable_matrix_tags)
700 _matrix_tags_dof_u[tag].resize(n);
701 if (_need_matrix_tag_dof_u[tag] || _need_matrix_tag_u[tag])
702 if (_sys.hasMatrix(tag) && _sys.matrixTagActive(tag) && _sys.getMatrix(tag).closed())
704 auto & mat = _sys.getMatrix(tag);
705 for (
unsigned i = 0; i < n; i++)
707 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
708 for (
unsigned j = 0; j < _count; j++)
709 _matrix_tags_dof_u[tag][i](j) = mat(_dof_indices[i] + j, _dof_indices[i] + j);
715 if (_need_du_dot_du || _need_dof_du_dot_du)
717 _dof_du_dot_du.resize(n);
718 for (decltype(n) i = 0; i < n; ++i)
719 _dof_du_dot_du[i] = _sys.duDotDu(_var.number());
721 if (_need_du_dotdot_du || _need_dof_du_dotdot_du)
723 _dof_du_dotdot_du.resize(n);
724 for (decltype(n) i = 0; i < n; ++i)
725 _dof_du_dotdot_du[i] = _sys.duDotDotDu();
729 template <
typename OutputType>
733 if (_subproblem.isTransient())
735 _dof_values_dot.resize(0);
736 _dof_values_dotdot.resize(0);
737 _dof_values_dot_old.resize(0);
738 _dof_values_dotdot_old.resize(0);
739 _dof_du_dot_du.resize(0);
740 _dof_du_dotdot_du.resize(0);
743 for (
auto & dof_values : _vector_tags_dof_u)
744 dof_values.resize(0);
746 _has_dof_values =
false;
749 template <
typename OutputType>
753 bool is_transient = _subproblem.isTransient();
757 auto & dof_values = _vector_tags_dof_u[_solution_tag];
758 _nodal_value = dof_values[0];
759 _nodal_value_array[0] = _nodal_value;
763 if (oldestSolutionStateRequested() >= 1)
765 _nodal_value_old = _vector_tags_dof_u[_old_solution_tag][0];
766 _nodal_value_old_array[0] = _nodal_value_old;
768 if (oldestSolutionStateRequested() >= 2)
770 _nodal_value_older = _vector_tags_dof_u[_older_solution_tag][0];
771 _nodal_value_older_array[0] = _nodal_value_older;
773 if (_need_dof_values_dot)
774 _nodal_value_dot = _dof_values_dot[0];
775 if (_need_dof_values_dotdot)
776 _nodal_value_dotdot = _dof_values_dotdot[0];
777 if (_need_dof_values_dot_old)
778 _nodal_value_dot_old = _dof_values_dot_old[0];
779 if (_need_dof_values_dotdot_old)
780 _nodal_value_dotdot_old = _dof_values_dotdot_old[0];
783 _nodal_value_previous_nl = _vector_tags_dof_u[_previous_nl_solution_tag][0];
790 bool is_transient = _subproblem.isTransient();
792 auto n = _dof_indices.size();
795 auto & dof_values = _vector_tags_dof_u[_solution_tag];
796 for (decltype(n) i = 0; i < n; ++i)
797 _nodal_value(i) = dof_values[i];
798 _nodal_value_array[0] = _nodal_value;
802 if (oldestSolutionStateRequested() >= 1)
804 auto & dof_values_old = _vector_tags_dof_u[_old_solution_tag];
805 for (decltype(n) i = 0; i < n; ++i)
806 _nodal_value_old(i) = dof_values_old[i];
807 _nodal_value_old_array[0] = _nodal_value_old;
809 if (oldestSolutionStateRequested() >= 2)
811 auto & dof_values_older = _vector_tags_dof_u[_older_solution_tag];
812 for (decltype(n) i = 0; i < n; ++i)
813 _nodal_value_older(i) = dof_values_older[i];
814 _nodal_value_older_array[0] = _nodal_value_older;
816 if (_need_dof_values_dot)
817 for (decltype(n) i = 0; i < n; ++i)
818 _nodal_value_dot(i) = _dof_values_dot[i];
819 if (_need_dof_values_dotdot)
820 for (decltype(n) i = 0; i < n; ++i)
821 _nodal_value_dotdot(i) = _dof_values_dotdot[i];
822 if (_need_dof_values_dot_old)
823 for (decltype(n) i = 0; i < n; ++i)
824 _nodal_value_dot_old(i) = _dof_values_dot_old[i];
825 if (_need_dof_values_dotdot_old)
826 for (decltype(n) i = 0; i < n; ++i)
827 _nodal_value_dotdot_old(i) = _dof_values_dotdot_old[i];
831 auto & dof_values_previous_nl = _vector_tags_dof_u[_previous_nl_solution_tag];
832 for (decltype(n) i = 0; i < n; ++i)
833 _nodal_value_previous_nl(i) = dof_values_previous_nl[i];
virtual TagID getVectorTagID(const TagName &tag_name) const
Get a TagID from a TagName.
virtual void insert(const Number *v, const std::vector< numeric_index_type > &dof_indices)
void resizeVectorTagData(TagID tag)
resize the vector tag need flags and data containers to accomodate this tag index ...
const FieldVariableValue & matrixTagValue(TagID tag) const
Class for stuff related to variables.
const ReturnType & stateToTagHelper(Moose::SolutionState state, Functor functor)
Helper method that converts a SolutionState argument into a corresponding tag ID, potentially request...
void sizeMatrixTagData()
size matrix tag data
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
const FieldVariableGradient & vectorTagGradient(TagID tag) const
const TagName OLDER_SOLUTION_TAG
virtual void add_vector(const Number *v, const std::vector< numeric_index_type > &dof_indices)
void fetchDoFValues()
Helper methods for assigning dof values from their corresponding solution values. ...
const MooseArray< OutputType > & nodalValueArray(Moose::SolutionState state) const
std::vector< bool > _need_vector_tag_u
void getArrayDoFValues(const libMesh::NumericVector< libMesh::Number > &sol, unsigned int n, MooseArray< RealEigenVector > &dof_values) const
const SubProblem & _subproblem
The subproblem which we can query for information related to tagged vectors and matrices.
Base class for a system (of equations)
const DoFValue & nodalVectorTagValue(TagID tag) const
std::vector< bool > _need_vector_tag_grad
std::vector< bool > _need_vector_tag_dof_u
void add(libMesh::NumericVector< libMesh::Number > &residual)
Add the current local DOF values to the input vector.
const DoFValue & dofValues() const
void setNodalValue(const OutputType &value, unsigned int idx=0)
Set nodal value.
void insert(libMesh::NumericVector< libMesh::Number > &residual)
Set the current local DOF values to the input vector.
const FieldVariableGradient & gradSln(Moose::SolutionState state) const
Local solution gradient getter.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
FunctorEnvelope< T > Functor
const TagName OLD_SOLUTION_TAG
MooseArray< OutputType > _nodal_value_array
Nodal values as MooseArrays for use with AuxKernels.
std::vector< DoFValue > _vector_tags_dof_u
const OutputType & nodalValue(Moose::SolutionState state) const
void insertSolutionTag(TagID tag_id)
insert a solution tag into our tag containers
MooseVariableDataBase(const MooseVariableField< OutputType > &var, SystemBase &sys, THREAD_ID tid)
const DoFValue & dofValuesOlder() const
MooseArray< OutputType > _nodal_value_old_array
const FieldVariableValue & vectorTagValue(TagID tag) const
const DoFValue & dofValuesPreviousNL() const
const TagID INVALID_TAG_ID
const DoFValue & nodalMatrixTagValue(TagID tag) const
std::vector< FieldVariableGradient > _vector_tag_grad
void resize(unsigned int size)
Change the number of elements the array can store.
virtual unsigned int numVectorTags(const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
The total number of tags, which can be limited to the tag type.
const FieldVariableValue & sln(Moose::SolutionState state) const
Local solution getter.
const DoFValue & dofValuesOld() const
const TagName SOLUTION_TAG
MooseArray< OutputType > _nodal_value_older_array
virtual void set(const numeric_index_type i, const Number value)=0
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
void needSolutionState(unsigned int state)
Request that we have at least state number of older solution states/vectors.
std::vector< FieldVariableValue > _vector_tag_u
virtual void add(const numeric_index_type i, const Number value)=0
const TagName PREVIOUS_NL_SOLUTION_TAG
unsigned int oldestSolutionStateRequested() const
The oldest solution state that is requested for this variable (0 = current, 1 = old, 2 = older, etc).
const DoFValue & vectorTagDofValue(TagID tag) const