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