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 "ADHeatTransferFromHeatStructure3D1PhaseUserObject.h"
      11             : #include "THMIndicesVACE.h"
      12             : #include "THMUtils.h"
      13             : 
      14             : registerMooseObject("ThermalHydraulicsApp", ADHeatTransferFromHeatStructure3D1PhaseUserObject);
      15             : 
      16             : InputParameters
      17          87 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::validParams()
      18             : {
      19          87 :   InputParameters params = ElementUserObject::validParams();
      20         174 :   params.addRequiredParam<MeshAlignment1D3D *>("_mesh_alignment", "Mesh alignment object");
      21         174 :   params.addRequiredCoupledVar("P_hf", "Heat flux perimeter");
      22         174 :   params.addRequiredParam<MaterialPropertyName>("T", "Fluid temperature");
      23         174 :   params.addRequiredParam<MaterialPropertyName>("Hw", "Convective heat transfer coefficient");
      24          87 :   params.addClassDescription("Caches heat flux information (fluid temperature and heat transfer "
      25             :                              "coefficient) between flow channel and 3D heat structure.");
      26          87 :   return params;
      27           0 : }
      28             : 
      29          50 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::
      30          50 :     ADHeatTransferFromHeatStructure3D1PhaseUserObject(const InputParameters & parameters)
      31             :   : ElementUserObject(parameters),
      32          50 :     _mesh_alignment(*getParam<MeshAlignment1D3D *>("_mesh_alignment")),
      33          50 :     _P_hf(adCoupledValue("P_hf")),
      34         100 :     _Hw(getADMaterialProperty<Real>("Hw")),
      35         150 :     _T(getADMaterialProperty<Real>("T"))
      36             : {
      37          50 :   _mesh_alignment.buildCoupledElemQpIndexMap(_assembly);
      38          50 : }
      39             : 
      40             : void
      41       10295 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::initialize()
      42             : {
      43             :   _heated_perimeter.clear();
      44             :   _T_fluid.clear();
      45             :   _htc.clear();
      46       10295 : }
      47             : 
      48             : void
      49       49800 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::execute()
      50             : {
      51       49800 :   const auto & primary_elem_id = _current_elem->id();
      52             : 
      53       49800 :   const auto & secondary_elem_ids = _mesh_alignment.getCoupledSecondaryElemIDs(primary_elem_id);
      54      297300 :   for (const auto & secondary_elem_id : secondary_elem_ids)
      55             :   {
      56      247500 :     const auto secondary_n_qps = _mesh_alignment.getSecondaryNumberOfQuadraturePoints();
      57             : 
      58      247500 :     _T_fluid[secondary_elem_id].resize(secondary_n_qps);
      59      247500 :     _htc[secondary_elem_id].resize(secondary_n_qps);
      60      247500 :     _heated_perimeter[secondary_elem_id].resize(secondary_n_qps);
      61             : 
      62     1237500 :     for (unsigned int secondary_qp = 0; secondary_qp < secondary_n_qps; secondary_qp++)
      63             :     {
      64             :       const auto primary_qp =
      65      990000 :           _mesh_alignment.getCoupledPrimaryElemQpIndex(secondary_elem_id, secondary_qp);
      66             : 
      67      990000 :       _T_fluid[secondary_elem_id][secondary_qp] = _T[primary_qp];
      68      990000 :       _htc[secondary_elem_id][secondary_qp] = _Hw[primary_qp];
      69      990000 :       _heated_perimeter[secondary_elem_id][secondary_qp] = _P_hf[primary_qp];
      70             :     }
      71             :   }
      72       49800 : }
      73             : 
      74             : void
      75        7697 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::finalize()
      76             : {
      77        7697 :   THM::allGatherADVectorMap(comm(), _heated_perimeter);
      78        7697 :   THM::allGatherADVectorMap(comm(), _T_fluid);
      79        7697 :   THM::allGatherADVectorMap(comm(), _htc);
      80        7697 : }
      81             : 
      82             : void
      83        2598 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::threadJoin(const UserObject & y)
      84             : {
      85             :   const auto & uo = static_cast<const ADHeatTransferFromHeatStructure3D1PhaseUserObject &>(y);
      86        2598 :   for (auto & it : uo._heated_perimeter)
      87           0 :     _heated_perimeter[it.first] = it.second;
      88        2598 :   for (auto & it : uo._T_fluid)
      89           0 :     _T_fluid[it.first] = it.second;
      90        2598 :   for (auto & it : uo._htc)
      91           0 :     _htc[it.first] = it.second;
      92        2598 : }
      93             : 
      94             : const std::vector<ADReal> &
      95           0 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::getHeatedPerimeter(dof_id_type element_id) const
      96             : {
      97             :   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
      98             :   auto it = _heated_perimeter.find(element_id);
      99           0 :   if (it != _heated_perimeter.end())
     100           0 :     return it->second;
     101             :   else
     102           0 :     mooseError(
     103           0 :         name(), ": Requested heated perimeter for element ", element_id, " was not computed.");
     104             : }
     105             : 
     106             : const std::vector<ADReal> &
     107     7880832 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::getHeatTransferCoeff(
     108             :     dof_id_type element_id) const
     109             : {
     110             :   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     111             :   auto it = _htc.find(element_id);
     112     7880832 :   if (it != _htc.end())
     113     7880832 :     return it->second;
     114             :   else
     115           0 :     mooseError(name(),
     116             :                ": Requested heat transfer coefficient for element ",
     117             :                element_id,
     118             :                " was not computed.");
     119             : }
     120             : 
     121             : const std::vector<ADReal> &
     122     7880832 : ADHeatTransferFromHeatStructure3D1PhaseUserObject::getTfluid(dof_id_type element_id) const
     123             : {
     124             :   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     125             :   auto it = _T_fluid.find(element_id);
     126     7880832 :   if (it != _T_fluid.end())
     127     7880832 :     return it->second;
     128             :   else
     129           0 :     mooseError(
     130           0 :         name(), ": Requested fluid temperature for element ", element_id, " was not computed.");
     131             : }