HexagonalLatticeUtils.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 "Moose.h"
#include "MooseTypes.h"
 
#ifndef CARDINAL_ENUM_H
namespace channel_type
{
enum ChannelTypeEnum
{
  interior,
  edge,
  corner
};
} // namespace channel_type
#endif
 
class HexagonalLatticeUtils
{
public:
  HexagonalLatticeUtils(const Real bundle_inner_flat_to_flat,
                        const Real pin_pitch,
                        const Real pin_diameter,
                        const Real wire_diameter,
                        const Real wire_pitch,
                        const unsigned int n_rings,
                        const unsigned int axis,
                        const Real rotation_around_axis = 0);
 
  Real distanceFromGap(const Point & pt, const unsigned int gap_index) const;
 
  unsigned int gapIndex(const Point & point) const;
 
  void gapIndexAndDistance(const Point & point, unsigned int & index, Real & distance) const;
 
  Real sideTranslationX(const unsigned int side) const { return _unit_translation_x[side]; }
 
  Real sideTranslationY(const unsigned int side) const { return _unit_translation_y[side]; }
 
  unsigned int firstPinInRing(const unsigned int ring) const;
 
  unsigned int lastPinInRing(const unsigned int ring) const;
 
  bool lastGapInRing(const unsigned int gap_index) const;
 
  unsigned int ringIndex(const unsigned int pin) const;
 
  const std::vector<Point> & gapUnitNormals() const { return _gap_unit_normals; }
 
  unsigned int pins(const unsigned int n) const;
 
  unsigned int totalPins(const unsigned int n) const;
 
  unsigned int rings(const unsigned int n) const;
 
  unsigned int interiorChannels(const unsigned int ring);
 
  unsigned int nInteriorGaps() const { return _n_interior_gaps; }
 
  const std::vector<Point> & gapCenters() const { return _gap_centers; }
 
  unsigned int nGaps() const { return _n_gaps; }
 
  Real pitchToDiameter() const { return _P_over_D; }
 
  Real heightToDiameter() const { return _L_over_D; }
 
  unsigned int axis() const { return _axis; }
 
  Real pinDiameter() const { return _pin_diameter; }
 
  Real wirePitch() const { return _wire_pitch; }
 
  Real wireDiameter() const { return _wire_diameter; }
 
  Real pinPitch() const { return _pin_pitch; }
 
  Real bundlePitch() const { return _bundle_pitch; }
 
  Real pinVolumePerPitch() const { return _pin_volume_per_pitch; }
 
  Real wireVolumePerPitch() const { return _wire_volume_per_pitch; }
 
  unsigned int nInteriorPins() const { return _n_interior_pins; }
 
  unsigned int nEdgePins() const { return _n_edge_pins; }
 
  unsigned int nCornerPins() const { return _n_corner_pins; }
 
  unsigned int nPins() const { return _n_pins; }
 
  Real interiorHydraulicDiameter() const { return _interior_Dh; }
 
  Real edgeHydraulicDiameter() const { return _edge_Dh; }
 
  Real cornerHydraulicDiameter() const { return _corner_Dh; }
 
  Real hydraulicDiameter() const { return _Dh; }
 
  Real interiorWettedArea() const { return _interior_wetted_area; }
 
  Real edgeWettedArea() const { return _edge_wetted_area; }
 
  Real cornerWettedArea() const { return _corner_wetted_area; }
 
  Real wettedArea() const { return _wetted_area; }
 
  Real interiorFlowVolume() const { return _interior_flow_volume; }
 
  Real edgeFlowVolume() const { return _edge_flow_volume; }
 
  Real cornerFlowVolume() const { return _corner_flow_volume; }
 
  Real interiorVolume() const { return _interior_volume; }
 
  Real edgeVolume() const { return _edge_volume; }
 
  Real cornerVolume() const { return _corner_volume; }
 
  Real flowVolume() const { return _flow_volume; }
 
  unsigned int nInteriorChannels() const { return _n_interior_channels; }
 
  unsigned int nEdgeChannels() const { return _n_edge_channels; }
 
  unsigned int nCornerChannels() const { return _n_corner_channels; }
 
  unsigned int nChannels() const { return _n_channels; }
 
  Real pinBundleSpacing() const { return _pin_bundle_spacing; }
 
  const std::vector<Point> & pinCenters() const { return _pin_centers; }
 
  const std::vector<std::vector<Point>> & pinCenteredCornerCoordinates() const
  {
    return _pin_centered_corner_coordinates;
  }
 
  Real pinSurfaceAreaPerPitch() const { return _pin_surface_area_per_pitch; }
 
  Real cornerEdgeLength() const { return _corner_edge_length; }
 
  Real minDuctWallDistance(const Point & p) const;
 
  Real minDuctCornerDistance(const Point & p) const;
 
  channel_type::ChannelTypeEnum channelType(const Point & p) const;
 
  Real channelSpecificSurfaceArea(const channel_type::ChannelTypeEnum & channel) const;
 
  Real channelHydraulicDiameter(const channel_type::ChannelTypeEnum & channel) const;
 
  Real pinRadius() const;
 
  Real hexagonArea(const Real pitch) const;
 
  Real hexagonSide(const Real pitch) const;
 
  Real hexagonVolume(const Real side) const;
 
  Real hexagonPitch(const Real volume) const;
 
  Real triangleArea(const Real side) const;
 
  Real triangleHeight(const Real side) const;
 
  Real triangleSide(const Real height) const;
 
  Real triangleVolume(const Real side) const;
 
  const std::vector<std::vector<unsigned int>> & interiorChannelPinIndices() const
  {
    return _interior_channel_pin_indices;
  }
 
  const std::vector<std::vector<unsigned int>> & edgeChannelPinIndices() const
  {
    return _edge_channel_pin_indices;
  }
 
  const std::vector<std::vector<unsigned int>> & cornerChannelPinIndices() const
  {
    return _corner_channel_pin_indices;
  }
 
  const std::vector<std::pair<int, int>> & gapIndices() const { return _gap_indices; }
 
  const std::vector<std::vector<int>> & localToGlobalGaps() const { return _local_to_global_gaps; }
 
  const std::vector<Point>
  interiorChannelCornerCoordinates(const unsigned int interior_channel_id) const;
 
  const std::vector<Point> edgeChannelCornerCoordinates(const unsigned int edge_channel_id) const;
 
  const std::vector<Point>
  cornerChannelCornerCoordinates(const unsigned int corner_channel_id) const;
 
  Point channelCentroid(const std::vector<Point> & corners) const;
 
  unsigned int pinIndex(const Point & point) const;
 
  unsigned int closestPinIndex(const Point & point) const;
 
  unsigned int channelIndex(const Point & point) const;
 
  bool insideLattice(const Point & point) const;
 
  void get2DInputPatternIndex(const unsigned int pin_index,
                              unsigned int & row_index,
                              unsigned int & within_row_index) const;
 
protected:
  unsigned int globalGapIndex(const std::pair<int, int> & local_gap) const;
 
  const Real _bundle_pitch;
 
  const Real _pin_pitch;
 
  const Real _pin_diameter;
 
  const Real _wire_diameter;
 
  const Real _wire_pitch;
 
  const unsigned int _n_rings;
 
  const unsigned int _axis;
 
  const Real _rotation_around_axis;
 
  const RealTensorValue _rotation_matrix;
 
  const Real _bundle_side_length;
 
  const Real _pin_area;
 
  const Real _pin_circumference;
 
  const Real _wire_area;
 
  const Real _wire_circumference;
 
  const Real _pin_surface_area_per_pitch;
 
  const Real _pin_volume_per_pitch;
 
  const Real _P_over_D;
 
  const Real _L_over_D;
 
  Real _wire_surface_area_per_pitch;
 
  Real _pin_bundle_spacing;
 
  Real _wire_volume_per_pitch;
 
  unsigned int _n_pins;
 
  unsigned int _n_interior_pins;
 
  unsigned int _n_edge_pins;
 
  unsigned int _n_corner_pins;
 
  unsigned int _n_channels;
 
  unsigned int _n_interior_channels;
 
  unsigned int _n_edge_channels;
 
  unsigned int _n_corner_channels;
 
  Real _corner_edge_length;
 
  Real _interior_Dh;
 
  Real _edge_Dh;
 
  Real _corner_Dh;
 
  Real _Dh;
 
  Real _interior_flow_volume;
 
  Real _edge_flow_volume;
 
  Real _corner_flow_volume;
 
  Real _interior_volume;
 
  Real _edge_volume;
 
  Real _corner_volume;
 
  Real _flow_volume;
 
  Real _interior_wetted_area;
 
  Real _edge_wetted_area;
 
  Real _corner_wetted_area;
 
  Real _wetted_area;
 
  std::vector<Point> _pin_centers;
 
  std::vector<std::vector<Point>> _pin_centered_corner_coordinates;
 
  std::vector<Point> _duct_corners;
 
  std::vector<std::vector<Real>> _duct_coeffs;
 
  std::vector<std::vector<unsigned int>> _interior_channel_pin_indices;
 
  std::vector<std::vector<unsigned int>> _edge_channel_pin_indices;
 
  std::vector<std::vector<unsigned int>> _corner_channel_pin_indices;
 
  std::vector<std::pair<int, int>> _gap_indices;
 
  std::vector<std::vector<int>> _local_to_global_gaps;
 
  std::vector<std::vector<Point>> _gap_points;
 
  std::vector<Point> _gap_unit_normals;
 
  unsigned int _n_interior_gaps;
 
  unsigned int _n_gaps;
 
  static const Real SIN60;
 
  static const Real COS60;
 
  static const unsigned int NUM_SIDES;
 
  std::vector<Real> _unit_translation_x;
 
  std::vector<Real> _unit_translation_y;
 
  std::vector<Point> _gap_centers;
 
  unsigned int _ix;
 
  unsigned int _iy;
 
private:
  void computeGapIndices();
 
  void computePinAndChannelTypes();
 
  void computePinBundleSpacing();
 
  void computeWireVolumeAndAreaPerPitch();
 
  void computeFlowVolumes();
 
  void computeWettedAreas();
 
  void computeHydraulicDiameters();
 
  void computePinAndDuctCoordinates();
 
  void computeChannelPinIndices();
};