Line data    Source code

       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             : #include "MooseVariableField.h"
      11             : #include "SystemBase.h"
      12             : #include "TimeIntegrator.h"
      13             : 
      14             : #include "libmesh/fe_base.h"
      15             : 
      16             : using namespace Moose;
      17             : 
      18             : template <typename OutputType>
      19             : InputParameters
      20      197028 : MooseVariableField<OutputType>::validParams()
      21             : {
      22      197028 :   return MooseVariableFieldBase::validParams();
      23             : }
      24             : 
      25             : template <typename OutputType>
      26      172864 : MooseVariableField<OutputType>::MooseVariableField(const InputParameters & parameters)
      27             :   : MooseVariableFieldBase(parameters),
      28             :     Moose::FunctorBase<typename Moose::ADType<OutputType>::type>(name()),
      29             :     MeshChangedInterface(parameters),
      30      518592 :     _time_integrator(_sys.queryTimeIntegrator(_var_num))
      31             : {
      32      345728 : }
      33             : 
      34             : template <typename OutputType>
      35             : void
      36     7247313 : MooseVariableField<OutputType>::residualSetup()
      37             : {
      38     7247313 :   MooseVariableFieldBase::residualSetup();
      39     7247313 :   FunctorBase<typename Moose::ADType<OutputType>::type>::residualSetup();
      40     7247313 : }
      41             : 
      42             : template <typename OutputType>
      43             : void
      44     1204373 : MooseVariableField<OutputType>::jacobianSetup()
      45             : {
      46     1204373 :   MooseVariableFieldBase::jacobianSetup();
      47     1204373 :   FunctorBase<typename Moose::ADType<OutputType>::type>::jacobianSetup();
      48     1204373 : }
      49             : 
      50             : template <typename OutputType>
      51             : void
      52     1142077 : MooseVariableField<OutputType>::timestepSetup()
      53             : {
      54     1142077 :   MooseVariableFieldBase::timestepSetup();
      55     1142077 :   FunctorBase<typename Moose::ADType<OutputType>::type>::timestepSetup();
      56     1142077 : }
      57             : 
      58             : template <typename OutputType>
      59             : const NumericVector<Number> &
      60      947481 : MooseVariableField<OutputType>::getSolution(const Moose::StateArg & state) const
      61             : {
      62             :   // It's not safe to use solutionState(0) because it returns the libMesh System solution member
      63             :   // which is wrong during things like finite difference Jacobian evaluation, e.g. when PETSc
      64             :   // perturbs the solution vector we feed these perturbations into the current_local_solution
      65             :   // while the libMesh solution is frozen in the non-perturbed state
      66      947481 :   return (state.state == 0) ? *this->_sys.currentSolution()
      67      947481 :                             : this->_sys.solutionState(state.state, state.iteration_type);
      68             : }
      69             : 
      70             : template <typename OutputType>
      71             : Moose::VarFieldType
      72   138799585 : MooseVariableField<OutputType>::fieldType() const
      73             : {
      74             :   if (std::is_same<OutputType, Real>::value)
      75   130658151 :     return Moose::VarFieldType::VAR_FIELD_STANDARD;
      76             :   else if (std::is_same<OutputType, RealVectorValue>::value)
      77     5854726 :     return Moose::VarFieldType::VAR_FIELD_VECTOR;
      78             :   else if (std::is_same<OutputType, RealEigenVector>::value)
      79     2286708 :     return Moose::VarFieldType::VAR_FIELD_ARRAY;
      80             :   else
      81             :     mooseError("Unknown variable field type");
      82             : }
      83             : 
      84             : template <typename OutputType>
      85             : bool
      86     1086608 : MooseVariableField<OutputType>::isArray() const
      87             : {
      88     1086608 :   const auto is_array = MooseVariableBase::isArray();
      89     1086608 :   if (std::is_same<OutputType, RealEigenVector>::value != is_array)
      90           0 :     mooseError("A variable is marked as an array variable in a base class, but in a derived class "
      91             :                "the output type is not consistent.");
      92     1086608 :   return is_array;
      93             : }
      94             : 
      95             : template <typename OutputType>
      96             : bool
      97      372019 : MooseVariableField<OutputType>::isVector() const
      98             : {
      99      372019 :   return std::is_same<OutputType, RealVectorValue>::value;
     100             : }
     101             : 
     102             : template <>
     103             : template <>
     104             : const MooseArray<Real> &
     105         261 : MooseVariableField<Real>::genericDofValues<false>() const
     106             : {
     107         261 :   return dofValues();
     108             : }
     109             : 
     110             : template <>
     111             : template <>
     112             : const MooseArray<Real> &
     113           0 : MooseVariableField<RealVectorValue>::genericDofValues<false>() const
     114             : {
     115           0 :   return dofValues();
     116             : }
     117             : 
     118             : template <>
     119             : template <>
     120             : const MooseArray<Real> &
     121           0 : MooseVariableField<RealEigenVector>::genericDofValues<false>() const
     122             : {
     123           0 :   mooseError("genericDofValues not implemented for array variables");
     124             : }
     125             : 
     126             : template class MooseVariableField<Real>;
     127             : template class MooseVariableField<RealVectorValue>;
     128             : template class MooseVariableField<RealEigenVector>;