JvarMapInterface.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 "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(MooseVariableFEBase & jvar) override;
  using T::computeOffDiagJacobian;
};
 
template <class T>
class JvarMapIntegratedBCInterface : public JvarMapInterfaceBase<T>
{
public:
  JvarMapIntegratedBCInterface(const InputParameters & parameters);
  virtual void computeJacobianBlock(MooseVariableFEBase & jvar) override;
  using T::computeJacobianBlock;
};
 
template <class T>
class JvarMapInterfaceBase : public T
{
public:
  typedef std::vector<int> JvarMap;
 
  JvarMapInterfaceBase(const InputParameters & parameters);
 
  unsigned int mapJvarToCvar(unsigned int jvar);
 
  int mapJvarToCvar(unsigned int jvar, const JvarMap & jvar_map);
 
  const JvarMap & getParameterJvarMap(std::string parameter_name);
 
  bool mapJvarToCvar(unsigned int jvar, unsigned int & cvar);
 
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>
JvarMapInterfaceBase<T>::JvarMapInterfaceBase(const InputParameters & parameters)
  : T(parameters),
    _jvar_max_size(this->_fe_problem.getNonlinearSystemBase().nVariables()),
    _jvar_map(_jvar_max_size, -1)
{
  // populate map
  for (auto it : Moose::enumerate(this->_coupled_moose_vars))
  {
    auto number = it.value()->number();
 
    // skip AuxVars as off-diagonal jacobian entries are not calculated for them
    if (number < _jvar_max_size)
      _jvar_map[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 number = this->getVar(parameter_name, i)->number();
 
    // skip AuxVars as off-diagonal jacobian entries are not calculated for them
    if (number < _jvar_max_size)
      jvar_map[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(MooseVariableFEBase & jvar)
{
  // the Kernel is not coupled to the variable; no need to loop over QPs
  if (this->_jvar_map[jvar.number()] < 0)
    return;
 
  // call the underlying class' off-diagonal Jacobian
  T::computeOffDiagJacobian(jvar);
}
 
template <class T>
void
JvarMapIntegratedBCInterface<T>::computeJacobianBlock(MooseVariableFEBase & jvar)
{
  // the Kernel is not coupled to the variable; no need to loop over QPs
  if (this->_jvar_map[jvar.number()] < 0)
    return;
 
  // call the underlying class' off-diagonal Jacobian
  T::computeJacobianBlock(jvar);
}