ThermalSolidProperties.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 "SolidProperties.h"
 
#define propfuncNonADValueOnly(want)                                                               \
  virtual Real want##_from_T(const Real &) const                                                   \
  {                                                                                                \
    mooseError(__PRETTY_FUNCTION__, " not implemented.");                                          \
  }
 
#define propfuncNonADDerivatives(want)                                                             \
  virtual void want##_from_T(const Real & T, Real & val, Real & d##want##dT) const                 \
  {                                                                                                \
    solidPropError(__PRETTY_FUNCTION__, " derivatives not implemented.");                          \
    d##want##dT = 0;                                                                               \
    val = want##_from_T(T);                                                                        \
  }
 
#define propfuncAD(want)                                                                           \
  virtual ADReal want##_from_T(const ADReal & T) const                                             \
  {                                                                                                \
    Real x = 0;                                                                                    \
    Real raw = T.value();                                                                          \
    Real dxdT = 0;                                                                                 \
    want##_from_T(raw, x, dxdT);                                                                   \
                                                                                                   \
    ADReal result = x;                                                                             \
    result.derivatives() = T.derivatives() * dxdT;                                                 \
    return result;                                                                                 \
  }
 
#define propfunc(want) propfuncNonADValueOnly(want) propfuncNonADDerivatives(want) propfuncAD(want)
 
class ThermalSolidProperties : public SolidProperties
{
public:
  static InputParameters validParams();
 
  ThermalSolidProperties(const InputParameters & parameters);
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
  // clang-format off
 
  propfunc(k)
  propfunc(cp)
  propfunc(rho)
 
  
  virtual Real cp_integral(const Real & /*T*/) const
  {
    mooseError(__PRETTY_FUNCTION__, " not implemented.");
  }
 
  // Specific internal energy methods; these designed to not be virtual; only
  // cp_integral(T) needs to be implemented.
  Real e_from_T(const Real & T) const;
  void e_from_T(const Real & T, Real & val, Real & dedT) const;
  propfuncAD(e)
 
  // clang-format on
 
#undef propfunc
#undef propfuncAD
 
    protected :
  template <typename... Args>
  void solidPropError(Args... args) const
  {
    if (_allow_imperfect_jacobians)
      mooseDoOnce(mooseWarning(std::forward<Args>(args)...));
    else
      mooseError(std::forward<Args>(args)...);
  }
 
protected:
  const Real _T_zero_e;
};
 
#pragma GCC diagnostic pop