JvarMapInterface.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 "MooseVariableFE.h"
#include "NonlinearSystemBase.h"
#include "Enumerate.h"
 
template <class T>
class JvarMapInterfaceBase;
 
template <class T>
class JvarMapKernelInterface : public JvarMapInterfaceBase<T>
{
public:
  JvarMapKernelInterface(const InputParameters & parameters);
  virtual void computeOffDiagJacobian(unsigned int jvar) override;
};
 
template <class T>
class JvarMapIntegratedBCInterface : public JvarMapInterfaceBase<T>
{
public:
  JvarMapIntegratedBCInterface(const InputParameters & parameters);
  virtual void computeOffDiagJacobian(unsigned int jvar) override;
};
 
template <class T>
class JvarMapInterfaceBase : public T
{
public:
  typedef std::vector<int> JvarMap;
 
  static InputParameters validParams();
 
  JvarMapInterfaceBase(const InputParameters & parameters);
 
  unsigned int mapJvarToCvar(unsigned int jvar);
 
  int mapJvarToCvar(unsigned int jvar, const JvarMap & jvar_map);
 
  const JvarMap & getJvarMap() { return _jvar_map; }
 
  const JvarMap & getParameterJvarMap(std::string parameter_name);
 
  bool mapJvarToCvar(unsigned int jvar, unsigned int & cvar);
 
protected:
  const unsigned int _n_args;
 
private:
  const std::size_t _jvar_max_size;
 
  JvarMap _jvar_map;
 
  std::map<std::string, JvarMap> _jvar_local_map;
 
  friend class JvarMapKernelInterface<T>;
  friend class JvarMapIntegratedBCInterface<T>;
};
 
template <class T>
InputParameters
JvarMapInterfaceBase<T>::validParams()
{
  auto params = T::validParams();
  params.addCoupledVar("coupled_variables",
                       "Vector of nonlinear variable arguments this object depends on");
 
  return params;
}
 
template <class T>
JvarMapInterfaceBase<T>::JvarMapInterfaceBase(const InputParameters & parameters)
  : T(parameters),
    _n_args(this->_coupled_standard_moose_vars.size()),
    _jvar_max_size(this->_sys.nVariables()),
    _jvar_map(_jvar_max_size, -1)
{
  // populate map
  for (auto it : Moose::enumerate(this->_coupled_moose_vars))
  {
    const auto & var = *it.value();
 
    // skip variables from other systems (AuxVariables or variables of another nonlinear system)
    // as off-diagonal jacobian entries are not calculated for them. Their numbers are local to
    // their own system, so they cannot be distinguished by comparing against nVariables()
    if (&var.sys() == &this->_sys)
      _jvar_map[var.number()] = it.index();
  }
 
  // mark the kernel variable for the check in computeOffDiagJacobian
  _jvar_map[this->_var.number()] = 0;
}
 
template <class T>
unsigned int
JvarMapInterfaceBase<T>::mapJvarToCvar(unsigned int jvar)
{
  mooseAssert(jvar < _jvar_max_size,
              "Calling mapJvarToCvar for an invalid Moose variable number. Maybe an AuxVariable?");
  int cit = _jvar_map[jvar];
 
  mooseAssert(cit >= 0, "Calling mapJvarToCvar for a variable not coupled to this kernel.");
  return cit;
}
 
template <class T>
int
JvarMapInterfaceBase<T>::mapJvarToCvar(unsigned int jvar, const JvarMap & jvar_map)
{
  mooseAssert(jvar < _jvar_max_size,
              "Calling mapJvarToCvar for an invalid Moose variable number. Maybe an AuxVariable?");
  return jvar_map[jvar];
}
 
template <class T>
const typename JvarMapInterfaceBase<T>::JvarMap &
JvarMapInterfaceBase<T>::getParameterJvarMap(std::string parameter_name)
{
  auto & jvar_map = _jvar_local_map[parameter_name];
  jvar_map.assign(_jvar_max_size, -1);
 
  // populate local map
  const auto num = this->coupledComponents(parameter_name);
  for (std::size_t i = 0; i < num; ++i)
  {
    const auto & var = *this->getVar(parameter_name, i);
 
    // skip variables from other systems, see the constructor
    if (&var.sys() == &this->_sys)
      jvar_map[var.number()] = i;
  }
 
  return jvar_map;
}
 
template <class T>
JvarMapKernelInterface<T>::JvarMapKernelInterface(const InputParameters & parameters)
  : JvarMapInterfaceBase<T>(parameters)
{
}
 
template <class T>
JvarMapIntegratedBCInterface<T>::JvarMapIntegratedBCInterface(const InputParameters & parameters)
  : JvarMapInterfaceBase<T>(parameters)
{
}
 
template <class T>
void
JvarMapKernelInterface<T>::computeOffDiagJacobian(const unsigned int jvar)
{
  // the Kernel is not coupled to the variable; no need to loop over QPs
  if (this->_jvar_map[jvar] < 0)
    return;
 
  // call the underlying class' off-diagonal Jacobian
  T::computeOffDiagJacobian(jvar);
}
 
template <class T>
void
JvarMapIntegratedBCInterface<T>::computeOffDiagJacobian(const unsigned int jvar)
{
  // the Kernel is not coupled to the variable; no need to loop over QPs
  if (this->_jvar_map[jvar] < 0)
    return;
 
  // call the underlying class' off-diagonal Jacobian
  T::computeOffDiagJacobian(jvar);
}