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             : // Navier-Stokes includes
      11             : #include "NSEnergyInviscidBC.h"
      12             : #include "NS.h"
      13             : 
      14             : // FluidProperties includes
      15             : #include "IdealGasFluidProperties.h"
      16             : 
      17             : InputParameters
      18          41 : NSEnergyInviscidBC::validParams()
      19             : {
      20          41 :   InputParameters params = NSIntegratedBC::validParams();
      21          41 :   params.addClassDescription("This class corresponds to the inviscid part of the 'natural' "
      22             :                              "boundary condition for the energy equation.");
      23          41 :   params.addRequiredCoupledVar(NS::temperature, "temperature");
      24          41 :   return params;
      25           0 : }
      26             : 
      27          22 : NSEnergyInviscidBC::NSEnergyInviscidBC(const InputParameters & parameters)
      28             :   : NSIntegratedBC(parameters),
      29          22 :     _temperature(coupledValue(NS::temperature)),
      30             :     // Object for computing deriviatives of pressure
      31          22 :     _pressure_derivs(*this)
      32             : {
      33          22 : }
      34             : 
      35             : Real
      36      114240 : NSEnergyInviscidBC::qpResidualHelper(Real pressure, Real un)
      37             : {
      38      114240 :   return (_rho_et[_qp] + pressure) * un * _test[_i][_qp];
      39             : }
      40             : 
      41             : Real
      42           0 : NSEnergyInviscidBC::qpResidualHelper(Real rho, RealVectorValue u, Real /*pressure*/)
      43             : {
      44             :   // return (rho*(cv*_temperature[_qp] + 0.5*u.norm_sq()) + pressure) * (u*_normals[_qp]) *
      45             :   // _test[_i][_qp];
      46             :   // We can also expand pressure in terms of rho... does this make a difference?
      47             :   // Then we don't use the input pressure value.
      48           0 :   return rho * (_fp.gamma() * _fp.cv() * _temperature[_qp] + 0.5 * u.norm_sq()) *
      49           0 :          (u * _normals[_qp]) * _test[_i][_qp];
      50             : }
      51             : 
      52             : // (U4+p) * d(u.n)/dX
      53             : Real
      54      279552 : NSEnergyInviscidBC::qpJacobianTermA(unsigned var_number, Real pressure)
      55             : {
      56             :   Real result = 0.0;
      57             : 
      58      279552 :   switch (var_number)
      59             :   {
      60       69888 :     case 0: // density
      61             :     {
      62             :       // Velocity vector object
      63       69888 :       RealVectorValue vel(_u_vel[_qp], _v_vel[_qp], _w_vel[_qp]);
      64             : 
      65       69888 :       result = -(vel * _normals[_qp]);
      66             :       break;
      67             :     }
      68             : 
      69      139776 :     case 1:
      70             :     case 2:
      71             :     case 3: // momentums
      72      139776 :       result = _normals[_qp](var_number - 1);
      73      139776 :       break;
      74             : 
      75             :     case 4: // energy
      76             :       result = 0.;
      77             :       break;
      78             : 
      79           0 :     default:
      80           0 :       mooseError("Shouldn't get here!");
      81             :       break;
      82             :   }
      83             : 
      84             :   // Notice the division by _rho[_qp] here.  This comes from taking the
      85             :   // derivative wrt to either density or momentum.
      86      279552 :   return (_rho_et[_qp] + pressure) / _rho[_qp] * result * _phi[_j][_qp] * _test[_i][_qp];
      87             : }
      88             : 
      89             : // d(U4)/dX * (u.n)
      90             : Real
      91      279552 : NSEnergyInviscidBC::qpJacobianTermB(unsigned var_number, Real un)
      92             : {
      93             :   Real result = 0.0;
      94      279552 :   switch (var_number)
      95             :   {
      96             :     case 0: // density
      97             :     case 1:
      98             :     case 2:
      99             :     case 3: // momentums
     100             :     {
     101             :       result = 0.;
     102             :       break;
     103             :     }
     104             : 
     105       69888 :     case 4: // energy
     106             :     {
     107       69888 :       result = _phi[_j][_qp] * un * _test[_i][_qp];
     108       69888 :       break;
     109             :     }
     110             : 
     111           0 :     default:
     112           0 :       mooseError("Shouldn't get here!");
     113             :       break;
     114             :   }
     115             : 
     116      279552 :   return result;
     117             : }
     118             : 
     119             : // d(p)/dX * (u.n)
     120             : Real
     121           0 : NSEnergyInviscidBC::qpJacobianTermC(unsigned var_number, Real un)
     122             : {
     123           0 :   return _pressure_derivs.get_grad(var_number) * _phi[_j][_qp] * un * _test[_i][_qp];
     124             : }