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);
}