Component2D.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 "GeneratedMeshComponent.h"
 
class Component2D : public GeneratedMeshComponent
{
public:
  enum class ExternalBoundaryType
  {
    INNER = 0,
    OUTER = 1,
    START = 2,
    END = 3
  };
 
  Component2D(const InputParameters & params);
 
  virtual void buildMesh() override;
 
  const Real & getTotalWidth() const { return _total_width; }
 
  unsigned int getNumRegions() const { return _n_regions; }
 
  bool hasBlock(const std::string & name) const;
 
  const std::vector<std::string> & getNames() const { return _names; }
 
  const std::vector<Real> & getVolumes() const { return _volume; }
 
  bool isBoundaryInVector(const BoundaryName & boundary_name,
                          const std::vector<BoundaryName> & boundary_name_vector) const;
 
  bool hasBoundary(const BoundaryName & boundary_name) const;
 
  bool hasExternalBoundary(const BoundaryName & boundary_name) const;
 
  const std::vector<std::tuple<dof_id_type, unsigned short int>> &
  getBoundaryInfo(const BoundaryName & boundary_name) const;
 
  const std::vector<std::tuple<dof_id_type, unsigned short int>> &
  getBoundaryInfo(const ExternalBoundaryType & boundary_type) const;
 
  ExternalBoundaryType getExternalBoundaryType(const BoundaryName & boundary_name) const;
 
  Real getAxialOffset() const { return _axial_offset; }
 
  const BoundaryName & getExternalBoundaryName(const ExternalBoundaryType & boundary_type) const;
 
  const Real & getBoundaryArea(const BoundaryName & boundary_name) const;
 
  virtual Real computeRadialBoundaryArea(const Real & length, const Real & y) const = 0;
 
  virtual Real computeAxialBoundaryArea(const Real & y_min, const Real & y_max) const = 0;
 
protected:
  virtual void check() const override;
 
  void build2DMesh();
 
  void build2DMesh2ndOrder();
 
  unsigned int _n_regions;
  std::vector<std::string> _names;
  std::vector<Real> _width;
  Real _total_width;
  std::vector<Real> _volume;
  std::vector<unsigned int> _n_part_elems;
  unsigned int _total_elem_number;
 
  unsigned int _outer_bc_id;
  unsigned int _inner_bc_id;
  unsigned int _start_bc_id;
  unsigned int _end_bc_id;
  std::vector<unsigned int> _interior_axial_per_radial_section_bc_id;
  std::vector<unsigned int> _axial_outer_bc_id;
  std::vector<unsigned int> _axial_inner_bc_id;
  std::vector<unsigned int> _radial_start_bc_id;
  std::vector<unsigned int> _radial_end_bc_id;
  std::vector<unsigned int> _inner_radial_bc_id;
 
  BoundaryName _boundary_name_outer;
  BoundaryName _boundary_name_inner;
  BoundaryName _boundary_name_start;
  BoundaryName _boundary_name_end;
  std::vector<BoundaryName> _boundary_names_interior_axial_per_radial_section;
  std::vector<BoundaryName> _boundary_names_axial_outer;
  std::vector<BoundaryName> _boundary_names_axial_inner;
  std::vector<BoundaryName> _boundary_names_radial_start;
  std::vector<BoundaryName> _boundary_names_radial_end;
  std::vector<BoundaryName> _boundary_names_inner_radial;
 
  std::map<BoundaryName, Real> _boundary_name_to_area;
 
  std::map<BoundaryName, std::vector<std::tuple<dof_id_type, unsigned short int>>> _boundary_info;
 
  mutable Real _axial_offset;
 
private:
public:
  static InputParameters validParams();
 
  static MooseEnum getExternalBoundaryTypeMooseEnum(const std::string & default_value = "");
 
  static const std::map<std::string, ExternalBoundaryType> _external_boundary_type_to_enum;
};
 
namespace THM
{
template <>
Component2D::ExternalBoundaryType stringToEnum(const std::string & s);
}