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 "NumericalFlux3EqnInternalValues.h"
      11             : #include "THMIndicesVACE.h"
      12             : #include "ADNumericalFlux3EqnBase.h"
      13             : 
      14             : registerMooseObject("ThermalHydraulicsApp", NumericalFlux3EqnInternalValues);
      15             : 
      16             : InputParameters
      17          95 : NumericalFlux3EqnInternalValues::validParams()
      18             : {
      19          95 :   InputParameters params = InternalSideVectorPostprocessor::validParams();
      20          95 :   params += SamplerBase::validParams();
      21         190 :   params.addRequiredCoupledVar("A_linear", "Cross-sectional area, linear");
      22         190 :   params.addRequiredParam<UserObjectName>("numerical_flux", "Name of numerical flux user object");
      23          95 :   params.addClassDescription("Computes internal fluxes for FlowChannel1Phase.");
      24          95 :   return params;
      25           0 : }
      26             : 
      27          50 : NumericalFlux3EqnInternalValues::NumericalFlux3EqnInternalValues(const InputParameters & parameters)
      28             :   : InternalSideVectorPostprocessor(parameters),
      29             :     SamplerBase(parameters, this, _communicator),
      30          50 :     _A1(adCoupledValue("A_linear")),
      31          50 :     _A2(adCoupledNeighborValue("A_linear")),
      32         100 :     _rhoA1(getADMaterialProperty<Real>("rhoA")),
      33         100 :     _rhouA1(getADMaterialProperty<Real>("rhouA")),
      34         100 :     _rhoEA1(getADMaterialProperty<Real>("rhoEA")),
      35         100 :     _rhoA2(getNeighborADMaterialProperty<Real>("rhoA")),
      36         100 :     _rhouA2(getNeighborADMaterialProperty<Real>("rhouA")),
      37         100 :     _rhoEA2(getNeighborADMaterialProperty<Real>("rhoEA")),
      38         100 :     _numerical_flux(getUserObject<ADNumericalFlux3EqnBase>("numerical_flux"))
      39             : {
      40          50 :   std::vector<std::string> var_names(THMVACE1D::N_FLUX_OUTPUTS);
      41             :   var_names[THMVACE1D::MASS] = "mass_flux";
      42             :   var_names[THMVACE1D::MOMENTUM] = "momentum_flux";
      43             :   var_names[THMVACE1D::ENERGY] = "energy_flux";
      44             : 
      45          50 :   SamplerBase::setupVariables(var_names);
      46          50 : }
      47             : 
      48             : void
      49         131 : NumericalFlux3EqnInternalValues::initialize()
      50             : {
      51         131 :   SamplerBase::initialize();
      52         131 : }
      53             : 
      54             : void
      55         128 : NumericalFlux3EqnInternalValues::execute()
      56             : {
      57             :   // Assume we are in 1D, and internal sides have only a single quadrature point
      58             :   const unsigned int _qp = 0;
      59             : 
      60         128 :   std::vector<ADReal> U1 = {_rhoA1[_qp], _rhouA1[_qp], _rhoEA1[_qp], _A1[_qp]};
      61         128 :   std::vector<ADReal> U2 = {_rhoA2[_qp], _rhouA2[_qp], _rhoEA2[_qp], _A2[_qp]};
      62             : 
      63         128 :   const Real nLR_dot_d = _current_side * 2 - 1.0;
      64             : 
      65             :   const std::vector<ADReal> & flux_elem_ad =
      66         128 :       _numerical_flux.getFlux(_current_side, _current_elem->id(), true, U1, U2, nLR_dot_d);
      67             :   const std::vector<ADReal> & flux_neig_ad =
      68         128 :       _numerical_flux.getFlux(_current_side, _current_elem->id(), false, U1, U2, nLR_dot_d);
      69             : 
      70             :   // Convert vector to non-AD
      71         128 :   std::vector<Real> flux(flux_elem_ad.size());
      72         512 :   for (const auto i : index_range(flux))
      73         768 :     flux[i] = MetaPhysicL::raw_value(0.5 * (flux_elem_ad[i] + flux_neig_ad[i]));
      74             : 
      75         128 :   SamplerBase::addSample(_q_point[_qp], _current_elem->id(), flux);
      76         384 : }
      77             : 
      78             : void
      79         117 : NumericalFlux3EqnInternalValues::finalize()
      80             : {
      81         117 :   SamplerBase::finalize();
      82         117 : }
      83             : 
      84             : void
      85          14 : NumericalFlux3EqnInternalValues::threadJoin(const UserObject & y)
      86             : {
      87             :   const auto & vpp = static_cast<const NumericalFlux3EqnInternalValues &>(y);
      88             : 
      89          14 :   SamplerBase::threadJoin(vpp);
      90          14 : }