FlowChannelBase.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 "Component1D.h"
#include "GravityInterface.h"
 
class ClosuresBase;
 
class FlowChannelBase : public Component1D, public GravityInterface
{
public:
  FlowChannelBase(const InputParameters & params);
 
  enum EConvHeatTransGeom
  {
    PIPE,          
    ROD_BUNDLE,    
    HEX_ROD_BUNDLE 
  };
  enum EPipeType
  {
    STRAIGHT,
    CURVED,
    DOWNCOMER
  };
  enum EPipeLocation
  {
    INTERIOR,
    EDGE,
    CORNER
  };
  static const std::map<std::string, EConvHeatTransGeom> _heat_transfer_geom_to_enum;
  static const std::map<std::string, EPipeType> _pipe_type_to_enum;
  static const std::map<std::string, EPipeLocation> _pipe_location_to_enum;
 
  virtual void addVariables() override;
  virtual void addMooseObjects() override;
 
  virtual const Real & getGravityAngle() const { return _gravity_angle; }
 
  const UserObjectName & getFluidPropertiesName() const { return _fp_name; }
 
  virtual const THM::FlowModelID & getFlowModelID() const = 0;
 
  static MooseEnum getConvHeatTransGeometry(const std::string & name);
 
  static MooseEnum getPipeType(const std::string & name);
 
  static MooseEnum getPipeLocation(const std::string & name);
 
  // Flow channel specific interface ----
  virtual std::shared_ptr<const FlowModel> getFlowModel() const;
 
  const FunctionName & getAreaFunctionName() const;
 
  virtual FunctionName createAreaFunctionAndGetName();
 
  EConvHeatTransGeom getHeatTransferGeometry() const { return _HT_geometry; }
 
  EPipeLocation getPipeLocation() const { return _pipe_location; }
 
  std::vector<std::string> getHeatTransferNames() const;
 
  bool getTemperatureMode() const { return _temperature_mode; }
 
  unsigned int getNumberOfHeatTransferConnections() const { return _n_heat_transfer_connections; }
 
  std::vector<VariableName> getHeatedPerimeterNames() const { return _P_hf_names; }
 
  std::vector<VariableName> getWallTemperatureNames() const { return _T_wall_names; }
  std::vector<MaterialPropertyName> getWallTemperatureMatNames() const { return _T_wall_mat_names; }
 
  std::vector<MaterialPropertyName> getWallHeatFluxNames() const { return _q_wall_names; }
 
  void addHeatTransferName(const std::string & ht_name) const;
 
  std::string getHeatTransferNamesSuffix(const std::string & ht_name) const;
 
  std::vector<std::shared_ptr<ClosuresBase>> getClosuresObjects() const
  {
    return _closures_objects;
  }
 
protected:
  virtual std::shared_ptr<FlowModel> buildFlowModel() = 0;
  virtual void init() override;
  virtual void initSecondary() override;
  virtual void check() const override;
 
  virtual void addCommonObjects();
 
  virtual void getHeatTransferVariableNames();
 
  std::shared_ptr<FlowModel> _flow_model;
 
  const UserObjectName & _fp_name;
 
  const Real _gravity_angle;
 
  FunctionName _area_function;
 
  std::vector<std::shared_ptr<ClosuresBase>> _closures_objects;
 
  const bool & _pipe_pars_transferred;
 
  const Real & _roughness;
 
  EConvHeatTransGeom _HT_geometry;
  EPipeLocation _pipe_location;
  const Real & _PoD;
  bool _has_PoD;
 
  bool _temperature_mode;
  mutable std::vector<std::string> _heat_transfer_names;
  mutable unsigned int _n_heat_transfer_connections;
 
  std::vector<MaterialPropertyName> _Hw_1phase_names;
  std::vector<MaterialPropertyName> _Hw_liquid_names;
  std::vector<MaterialPropertyName> _Hw_vapor_names;
  std::vector<VariableName> _P_hf_names;
  std::vector<VariableName> _T_wall_names;
  std::vector<MaterialPropertyName> _T_wall_mat_names;
  std::vector<MaterialPropertyName> _q_wall_names;
 
public:
  static InputParameters validParams();
};
 
namespace THM
{
template <>
FlowChannelBase::EConvHeatTransGeom stringToEnum(const std::string & s);
 
template <>
FlowChannelBase::EPipeType stringToEnum(const std::string & s);
 
template <>
FlowChannelBase::EPipeLocation stringToEnum(const std::string & s);
}