https://mooseframework.inl.gov
Functions
HexagonalLatticeTest.C File Reference

Go to the source code of this file.

Functions

 TEST_F (HexagonalLatticeTest, rings_and_pins)
 
 TEST_F (HexagonalLatticeTest, variation_with_rings)
 
 TEST_F (HexagonalLatticeTest, pin_bundle_spacing)
 
 TEST_F (HexagonalLatticeTest, hydraulic_diameters)
 
 TEST_F (HexagonalLatticeTest, pin_centers)
 
 TEST_F (HexagonalLatticeTest, channel_index_shifted)
 
 TEST_F (HexagonalLatticeTest, channel_index)
 
 TEST_F (HexagonalLatticeTest, gaps1)
 
 TEST_F (HexagonalLatticeTest, gaps2)
 
 TEST_F (HexagonalLatticeTest, gaps3)
 
 TEST_F (HexagonalLatticeTest, closest_gap)
 
 TEST_F (HexagonalLatticeTest, normals1)
 
 TEST_F (HexagonalLatticeTest, normals2)
 
 TEST_F (HexagonalLatticeTest, normals3)
 
 TEST_F (HexagonalLatticeTest, pin_corners)
 
 TEST_F (HexagonalLatticeTest, constructor)
 

Function Documentation

◆ TEST_F() [1/16]

TEST_F ( HexagonalLatticeTest  ,
rings_and_pins   
)

Definition at line 12 of file HexagonalLatticeTest.C.

13 {
14  Real bp = 10.0, pp = 0.1, pd = 0.04, wd = 0.01, wp = 50.0;
15  unsigned int nr = 1, a = 2;
16  HexagonalLatticeUtils hl1(bp, pp, pd, wd, wp, nr, a);
17 
18  // Test number of rings given number of pins
19  EXPECT_EQ(hl1.rings(1), (unsigned int)1);
20  EXPECT_EQ(hl1.rings(7), (unsigned int)2);
21  EXPECT_EQ(hl1.rings(19), (unsigned int)3);
22  EXPECT_EQ(hl1.rings(37), (unsigned int)4);
23 
24  try
25  {
26  hl1.rings(100);
27  FAIL() << "missing expected error";
28  }
29  catch (const std::exception & e)
30  {
31  std::string msg(e.what());
32  ASSERT_NE(msg.find("Number of pins 100 not evenly divisible in a hexagonal lattice!"),
33  std::string::npos)
34  << "failed with unexpected error: " << msg;
35  }
36 
37  // Test number of pins in given ring
38  EXPECT_EQ(hl1.pins(1), (unsigned int)1);
39  EXPECT_EQ(hl1.pins(2), (unsigned int)6);
40  EXPECT_EQ(hl1.pins(3), (unsigned int)12);
41 
42  // Test first and last pins in given ring
43  EXPECT_EQ(hl1.firstPinInRing(1), (unsigned int)0);
44  EXPECT_EQ(hl1.lastPinInRing(1), (unsigned int)0);
45 
46  EXPECT_EQ(hl1.firstPinInRing(2), (unsigned int)1);
47  EXPECT_EQ(hl1.lastPinInRing(2), (unsigned int)6);
48 
49  EXPECT_EQ(hl1.firstPinInRing(3), (unsigned int)7);
50  EXPECT_EQ(hl1.lastPinInRing(3), (unsigned int)18);
51 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [2/16]

TEST_F ( HexagonalLatticeTest  ,
variation_with_rings   
)

Definition at line 53 of file HexagonalLatticeTest.C.

54 {
55  Real bp = 10.0, pp = 0.1, pd = 0.04, wd = 0.01, wp = 50.0;
56  unsigned int nr = 1, a = 2;
57  HexagonalLatticeUtils hl1(bp, pp, pd, wd, wp, nr, a);
58 
59  nr = 2;
60  HexagonalLatticeUtils hl2(bp, pp, pd, wd, wp, nr, a);
61 
62  nr = 3;
63  HexagonalLatticeUtils hl3(bp, pp, pd, wd, wp, nr, a);
64 
65  nr = 4;
66  HexagonalLatticeUtils hl4(bp, pp, pd, wd, wp, nr, a);
67 
68  EXPECT_EQ(hl1.nPins(), (unsigned int)1);
69  EXPECT_EQ(hl1.nInteriorPins(), (unsigned int)1);
70  EXPECT_EQ(hl1.nEdgePins(), (unsigned int)0);
71  EXPECT_EQ(hl1.nCornerPins(), (unsigned int)0);
72  EXPECT_EQ(hl1.nChannels(), (unsigned int)6);
73  EXPECT_EQ(hl1.nInteriorChannels(), (unsigned int)0);
74  EXPECT_EQ(hl1.nEdgeChannels(), (unsigned int)0);
75  EXPECT_EQ(hl1.nCornerChannels(), (unsigned int)6);
76 
77  EXPECT_EQ(hl2.nPins(), (unsigned int)7);
78  EXPECT_EQ(hl2.nInteriorPins(), (unsigned int)1);
79  EXPECT_EQ(hl2.nEdgePins(), (unsigned int)0);
80  EXPECT_EQ(hl2.nCornerPins(), (unsigned int)6);
81  EXPECT_EQ(hl2.nChannels(), (unsigned int)18);
82  EXPECT_EQ(hl2.nInteriorChannels(), (unsigned int)6);
83  EXPECT_EQ(hl2.nEdgeChannels(), (unsigned int)6);
84  EXPECT_EQ(hl2.nCornerChannels(), (unsigned int)6);
85 
86  EXPECT_EQ(hl3.nPins(), (unsigned int)19);
87  EXPECT_EQ(hl3.nInteriorPins(), (unsigned int)7);
88  EXPECT_EQ(hl3.nEdgePins(), (unsigned int)6);
89  EXPECT_EQ(hl3.nCornerPins(), (unsigned int)6);
90  EXPECT_EQ(hl3.nChannels(), (unsigned int)42);
91  EXPECT_EQ(hl3.nInteriorChannels(), (unsigned int)24);
92  EXPECT_EQ(hl3.nEdgeChannels(), (unsigned int)12);
93  EXPECT_EQ(hl3.nCornerChannels(), (unsigned int)6);
94 
95  EXPECT_EQ(hl4.nPins(), (unsigned int)37);
96  EXPECT_EQ(hl4.nInteriorPins(), (unsigned int)19);
97  EXPECT_EQ(hl4.nEdgePins(), (unsigned int)12);
98  EXPECT_EQ(hl4.nCornerPins(), (unsigned int)6);
99  EXPECT_EQ(hl4.nChannels(), (unsigned int)78);
100  EXPECT_EQ(hl4.nInteriorChannels(), (unsigned int)54);
101  EXPECT_EQ(hl4.nEdgeChannels(), (unsigned int)18);
102  EXPECT_EQ(hl4.nCornerChannels(), (unsigned int)6);
103 
104  auto interior_pins2 = hl2.interiorChannelPinIndices();
105  EXPECT_EQ(interior_pins2[0][0], (unsigned int)0);
106  EXPECT_EQ(interior_pins2[0][1], (unsigned int)1);
107  EXPECT_EQ(interior_pins2[0][2], (unsigned int)2);
108  EXPECT_EQ(interior_pins2[1][0], (unsigned int)0);
109  EXPECT_EQ(interior_pins2[1][1], (unsigned int)2);
110  EXPECT_EQ(interior_pins2[1][2], (unsigned int)3);
111  EXPECT_EQ(interior_pins2[2][0], (unsigned int)0);
112  EXPECT_EQ(interior_pins2[2][1], (unsigned int)3);
113  EXPECT_EQ(interior_pins2[2][2], (unsigned int)4);
114  EXPECT_EQ(interior_pins2[3][0], (unsigned int)0);
115  EXPECT_EQ(interior_pins2[3][1], (unsigned int)4);
116  EXPECT_EQ(interior_pins2[3][2], (unsigned int)5);
117  EXPECT_EQ(interior_pins2[4][0], (unsigned int)0);
118  EXPECT_EQ(interior_pins2[4][1], (unsigned int)5);
119  EXPECT_EQ(interior_pins2[4][2], (unsigned int)6);
120  EXPECT_EQ(interior_pins2[5][0], (unsigned int)0);
121  EXPECT_EQ(interior_pins2[5][1], (unsigned int)6);
122  EXPECT_EQ(interior_pins2[5][2], (unsigned int)1);
123 
124  auto edge_pins2 = hl2.edgeChannelPinIndices();
125  EXPECT_EQ(edge_pins2[0][0], (unsigned int)1);
126  EXPECT_EQ(edge_pins2[0][1], (unsigned int)2);
127  EXPECT_EQ(edge_pins2[1][0], (unsigned int)2);
128  EXPECT_EQ(edge_pins2[1][1], (unsigned int)3);
129  EXPECT_EQ(edge_pins2[2][0], (unsigned int)3);
130  EXPECT_EQ(edge_pins2[2][1], (unsigned int)4);
131  EXPECT_EQ(edge_pins2[3][0], (unsigned int)4);
132  EXPECT_EQ(edge_pins2[3][1], (unsigned int)5);
133  EXPECT_EQ(edge_pins2[4][0], (unsigned int)5);
134  EXPECT_EQ(edge_pins2[4][1], (unsigned int)6);
135  EXPECT_EQ(edge_pins2[5][0], (unsigned int)6);
136  EXPECT_EQ(edge_pins2[5][1], (unsigned int)1);
137 
138  auto corner_pins2 = hl2.cornerChannelPinIndices();
139  EXPECT_EQ(corner_pins2[0][0], (unsigned int)1);
140  EXPECT_EQ(corner_pins2[1][0], (unsigned int)2);
141  EXPECT_EQ(corner_pins2[2][0], (unsigned int)3);
142  EXPECT_EQ(corner_pins2[3][0], (unsigned int)4);
143  EXPECT_EQ(corner_pins2[4][0], (unsigned int)5);
144  EXPECT_EQ(corner_pins2[5][0], (unsigned int)6);
145 
146  auto interior_pins3 = hl3.interiorChannelPinIndices();
147  EXPECT_EQ(interior_pins3[0][0], (unsigned int)0);
148  EXPECT_EQ(interior_pins3[0][1], (unsigned int)1);
149  EXPECT_EQ(interior_pins3[0][2], (unsigned int)2);
150  EXPECT_EQ(interior_pins3[1][0], (unsigned int)0);
151  EXPECT_EQ(interior_pins3[1][1], (unsigned int)2);
152  EXPECT_EQ(interior_pins3[1][2], (unsigned int)3);
153  EXPECT_EQ(interior_pins3[2][0], (unsigned int)0);
154  EXPECT_EQ(interior_pins3[2][1], (unsigned int)3);
155  EXPECT_EQ(interior_pins3[2][2], (unsigned int)4);
156  EXPECT_EQ(interior_pins3[3][0], (unsigned int)0);
157  EXPECT_EQ(interior_pins3[3][1], (unsigned int)4);
158  EXPECT_EQ(interior_pins3[3][2], (unsigned int)5);
159  EXPECT_EQ(interior_pins3[4][0], (unsigned int)0);
160  EXPECT_EQ(interior_pins3[4][1], (unsigned int)5);
161  EXPECT_EQ(interior_pins3[4][2], (unsigned int)6);
162  EXPECT_EQ(interior_pins3[5][0], (unsigned int)0);
163  EXPECT_EQ(interior_pins3[5][1], (unsigned int)6);
164  EXPECT_EQ(interior_pins3[5][2], (unsigned int)1);
165  EXPECT_EQ(interior_pins3[6][0], (unsigned int)1);
166  EXPECT_EQ(interior_pins3[6][1], (unsigned int)7);
167  EXPECT_EQ(interior_pins3[6][2], (unsigned int)8);
168  EXPECT_EQ(interior_pins3[7][0], (unsigned int)8);
169  EXPECT_EQ(interior_pins3[7][1], (unsigned int)2);
170  EXPECT_EQ(interior_pins3[7][2], (unsigned int)1);
171  EXPECT_EQ(interior_pins3[8][0], (unsigned int)2);
172  EXPECT_EQ(interior_pins3[8][1], (unsigned int)8);
173  EXPECT_EQ(interior_pins3[8][2], (unsigned int)9);
174  EXPECT_EQ(interior_pins3[9][0], (unsigned int)2);
175  EXPECT_EQ(interior_pins3[9][1], (unsigned int)9);
176  EXPECT_EQ(interior_pins3[9][2], (unsigned int)10);
177  EXPECT_EQ(interior_pins3[10][0], (unsigned int)10);
178  EXPECT_EQ(interior_pins3[10][1], (unsigned int)3);
179  EXPECT_EQ(interior_pins3[10][2], (unsigned int)2);
180  EXPECT_EQ(interior_pins3[11][0], (unsigned int)3);
181  EXPECT_EQ(interior_pins3[11][1], (unsigned int)10);
182  EXPECT_EQ(interior_pins3[11][2], (unsigned int)11);
183  EXPECT_EQ(interior_pins3[12][0], (unsigned int)3);
184  EXPECT_EQ(interior_pins3[12][1], (unsigned int)11);
185  EXPECT_EQ(interior_pins3[12][2], (unsigned int)12);
186  EXPECT_EQ(interior_pins3[13][0], (unsigned int)12);
187  EXPECT_EQ(interior_pins3[13][1], (unsigned int)4);
188  EXPECT_EQ(interior_pins3[13][2], (unsigned int)3);
189  EXPECT_EQ(interior_pins3[14][0], (unsigned int)4);
190  EXPECT_EQ(interior_pins3[14][1], (unsigned int)12);
191  EXPECT_EQ(interior_pins3[14][2], (unsigned int)13);
192  EXPECT_EQ(interior_pins3[15][0], (unsigned int)4);
193  EXPECT_EQ(interior_pins3[15][1], (unsigned int)13);
194  EXPECT_EQ(interior_pins3[15][2], (unsigned int)14);
195  EXPECT_EQ(interior_pins3[16][0], (unsigned int)14);
196  EXPECT_EQ(interior_pins3[16][1], (unsigned int)5);
197  EXPECT_EQ(interior_pins3[16][2], (unsigned int)4);
198  EXPECT_EQ(interior_pins3[17][0], (unsigned int)5);
199  EXPECT_EQ(interior_pins3[17][1], (unsigned int)14);
200  EXPECT_EQ(interior_pins3[17][2], (unsigned int)15);
201  EXPECT_EQ(interior_pins3[18][0], (unsigned int)5);
202  EXPECT_EQ(interior_pins3[18][1], (unsigned int)15);
203  EXPECT_EQ(interior_pins3[18][2], (unsigned int)16);
204  EXPECT_EQ(interior_pins3[19][0], (unsigned int)16);
205  EXPECT_EQ(interior_pins3[19][1], (unsigned int)6);
206  EXPECT_EQ(interior_pins3[19][2], (unsigned int)5);
207  EXPECT_EQ(interior_pins3[20][0], (unsigned int)6);
208  EXPECT_EQ(interior_pins3[20][1], (unsigned int)16);
209  EXPECT_EQ(interior_pins3[20][2], (unsigned int)17);
210  EXPECT_EQ(interior_pins3[21][0], (unsigned int)6);
211  EXPECT_EQ(interior_pins3[21][1], (unsigned int)17);
212  EXPECT_EQ(interior_pins3[21][2], (unsigned int)18);
213  EXPECT_EQ(interior_pins3[22][0], (unsigned int)18);
214  EXPECT_EQ(interior_pins3[22][1], (unsigned int)1);
215  EXPECT_EQ(interior_pins3[22][2], (unsigned int)6);
216  EXPECT_EQ(interior_pins3[23][0], (unsigned int)1);
217  EXPECT_EQ(interior_pins3[23][1], (unsigned int)18);
218  EXPECT_EQ(interior_pins3[23][2], (unsigned int)7);
219 
220  auto edge_pins3 = hl3.edgeChannelPinIndices();
221  EXPECT_EQ(edge_pins3[0][0], (unsigned int)7);
222  EXPECT_EQ(edge_pins3[0][1], (unsigned int)8);
223  EXPECT_EQ(edge_pins3[1][0], (unsigned int)8);
224  EXPECT_EQ(edge_pins3[1][1], (unsigned int)9);
225  EXPECT_EQ(edge_pins3[2][0], (unsigned int)9);
226  EXPECT_EQ(edge_pins3[2][1], (unsigned int)10);
227  EXPECT_EQ(edge_pins3[3][0], (unsigned int)10);
228  EXPECT_EQ(edge_pins3[3][1], (unsigned int)11);
229  EXPECT_EQ(edge_pins3[4][0], (unsigned int)11);
230  EXPECT_EQ(edge_pins3[4][1], (unsigned int)12);
231  EXPECT_EQ(edge_pins3[5][0], (unsigned int)12);
232  EXPECT_EQ(edge_pins3[5][1], (unsigned int)13);
233  EXPECT_EQ(edge_pins3[6][0], (unsigned int)13);
234  EXPECT_EQ(edge_pins3[6][1], (unsigned int)14);
235  EXPECT_EQ(edge_pins3[7][0], (unsigned int)14);
236  EXPECT_EQ(edge_pins3[7][1], (unsigned int)15);
237  EXPECT_EQ(edge_pins3[8][0], (unsigned int)15);
238  EXPECT_EQ(edge_pins3[8][1], (unsigned int)16);
239  EXPECT_EQ(edge_pins3[9][0], (unsigned int)16);
240  EXPECT_EQ(edge_pins3[9][1], (unsigned int)17);
241  EXPECT_EQ(edge_pins3[10][0], (unsigned int)17);
242  EXPECT_EQ(edge_pins3[10][1], (unsigned int)18);
243  EXPECT_EQ(edge_pins3[11][0], (unsigned int)18);
244  EXPECT_EQ(edge_pins3[11][1], (unsigned int)7);
245 
246  auto corner_pins3 = hl3.cornerChannelPinIndices();
247  EXPECT_EQ(corner_pins3[0][0], (unsigned int)7);
248  EXPECT_EQ(corner_pins3[1][0], (unsigned int)9);
249  EXPECT_EQ(corner_pins3[2][0], (unsigned int)11);
250  EXPECT_EQ(corner_pins3[3][0], (unsigned int)13);
251  EXPECT_EQ(corner_pins3[4][0], (unsigned int)15);
252  EXPECT_EQ(corner_pins3[5][0], (unsigned int)17);
253 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [3/16]

TEST_F ( HexagonalLatticeTest  ,
pin_bundle_spacing   
)

Definition at line 255 of file HexagonalLatticeTest.C.

256 {
257  Real bp = 5.0, pp = 1.0, pd = 0.8, wd = 0.05, wp = 50.0;
258  unsigned int nr = 1, a = 2;
259  HexagonalLatticeUtils hl5(bp, pp, pd, wd, wp, nr, a);
260 
261  nr = 2;
262  HexagonalLatticeUtils hl6(bp, pp, pd, wd, wp, nr, a);
263 
264  wd = 0.0;
265  nr = 1;
266  HexagonalLatticeUtils hl7(bp, pp, pd, wd, wp, nr, a);
267 
268  nr = 2;
269  HexagonalLatticeUtils hl8(bp, pp, pd, wd, wp, nr, a);
270 
271  // wire-wrapped bundles
272  EXPECT_DOUBLE_EQ(hl5.pinBundleSpacing(), 2.1);
273  EXPECT_DOUBLE_EQ(hl6.pinBundleSpacing(), (5.0 - (std::sqrt(3.0) + 0.8)) / 2.);
274 
275  // bare bundles
276  EXPECT_DOUBLE_EQ(hl7.pinBundleSpacing(), 2.1);
277  EXPECT_DOUBLE_EQ(hl8.pinBundleSpacing(), (5.0 - (std::sqrt(3.0) + 0.8)) / 2.);
278 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST_F() [4/16]

TEST_F ( HexagonalLatticeTest  ,
hydraulic_diameters   
)

Definition at line 280 of file HexagonalLatticeTest.C.

281 {
282  int n_interior, n_edge, n_corner;
283  Real flow_interior, flow_edge, flow_corner;
284  Real area_interior, area_edge, area_corner;
285 
286  Real bp = 5.0, pp = 1.0, pd = 0.8, wd = 0.1, wp = 50.0;
287  unsigned int nr = 1, a = 2;
288  HexagonalLatticeUtils hl9(bp, pp, pd, wd, wp, nr, a);
289 
290  nr = 2;
291  HexagonalLatticeUtils hl10(bp, pp, pd, wd, wp, nr, a);
292 
293  pp = 0.99;
294  nr = 3;
295  HexagonalLatticeUtils hl11(bp, pp, pd, wd, wp, nr, a);
296 
297  pp = 1.0;
298  wd = 0.0;
299  nr = 1;
300  HexagonalLatticeUtils hl12(bp, pp, pd, wd, wp, nr, a);
301 
302  nr = 2;
303  HexagonalLatticeUtils hl13(bp, pp, pd, wd, wp, nr, a);
304 
305  pp = 0.99;
306  nr = 3;
307  HexagonalLatticeUtils hl14(bp, pp, pd, wd, wp, nr, a);
308 
309  // values are obtained from a completely separately-developed Python script for
310  // verifying the bundle-wide hydraulic diameter. We verify the diameters for each
311  // individual channel by requiring that the n-channel-weighted sum equals the
312  // bundle-wide values for volume and areas, since we can verify that easily.
313  EXPECT_DOUBLE_EQ(hl9.hydraulicDiameter(), 4.196872851813099);
314  n_interior = hl9.nInteriorChannels();
315  n_edge = hl9.nEdgeChannels();
316  n_corner = hl9.nCornerChannels();
317  flow_interior = hl9.interiorFlowVolume();
318  flow_edge = hl9.edgeFlowVolume();
319  flow_corner = hl9.cornerFlowVolume();
320  area_interior = hl9.interiorWettedArea();
321  area_edge = hl9.edgeWettedArea();
322  area_corner = hl9.cornerWettedArea();
323  EXPECT_DOUBLE_EQ(hl9.flowVolume(),
324  n_interior * flow_interior + n_edge * flow_edge + n_corner * flow_corner);
325  EXPECT_DOUBLE_EQ(hl9.wettedArea(),
326  n_interior * area_interior + n_edge * area_edge + n_corner * area_corner);
327 
328  EXPECT_DOUBLE_EQ(hl10.hydraulicDiameter(), 1.948158075579034);
329  n_interior = hl10.nInteriorChannels();
330  n_edge = hl10.nEdgeChannels();
331  n_corner = hl10.nCornerChannels();
332  flow_interior = hl10.interiorFlowVolume();
333  flow_edge = hl10.edgeFlowVolume();
334  flow_corner = hl10.cornerFlowVolume();
335  area_interior = hl10.interiorWettedArea();
336  area_edge = hl10.edgeWettedArea();
337  area_corner = hl10.cornerWettedArea();
338  EXPECT_DOUBLE_EQ(hl10.flowVolume(),
339  n_interior * flow_interior + n_edge * flow_edge + n_corner * flow_corner);
340  EXPECT_DOUBLE_EQ(hl10.wettedArea(),
341  n_interior * area_interior + n_edge * area_edge + n_corner * area_corner);
342 
343  EXPECT_DOUBLE_EQ(hl11.hydraulicDiameter(), 0.6727946134052672);
344  n_interior = hl11.nInteriorChannels();
345  n_edge = hl11.nEdgeChannels();
346  n_corner = hl11.nCornerChannels();
347  flow_interior = hl11.interiorFlowVolume();
348  flow_edge = hl11.edgeFlowVolume();
349  flow_corner = hl11.cornerFlowVolume();
350  area_interior = hl11.interiorWettedArea();
351  area_edge = hl11.edgeWettedArea();
352  area_corner = hl11.cornerWettedArea();
353  EXPECT_DOUBLE_EQ(hl11.flowVolume(),
354  n_interior * flow_interior + n_edge * flow_edge + n_corner * flow_corner);
355  EXPECT_DOUBLE_EQ(hl11.wettedArea(),
356  n_interior * area_interior + n_edge * area_edge + n_corner * area_corner);
357 
358  // bare bundles
359  EXPECT_DOUBLE_EQ(hl12.hydraulicDiameter(), 4.2650423521483205);
360  n_interior = hl12.nInteriorChannels();
361  n_edge = hl12.nEdgeChannels();
362  n_corner = hl12.nCornerChannels();
363  flow_interior = hl12.interiorFlowVolume();
364  flow_edge = hl12.edgeFlowVolume();
365  flow_corner = hl12.cornerFlowVolume();
366  area_interior = hl12.interiorWettedArea();
367  area_edge = hl12.edgeWettedArea();
368  area_corner = hl12.cornerWettedArea();
369  EXPECT_DOUBLE_EQ(hl12.flowVolume(),
370  n_interior * flow_interior + n_edge * flow_edge + n_corner * flow_corner);
371  EXPECT_DOUBLE_EQ(hl12.wettedArea(),
372  n_interior * area_interior + n_edge * area_edge + n_corner * area_corner);
373 
374  EXPECT_DOUBLE_EQ(hl13.hydraulicDiameter(), 2.077372852104904);
375  n_interior = hl13.nInteriorChannels();
376  n_edge = hl13.nEdgeChannels();
377  n_corner = hl13.nCornerChannels();
378  flow_interior = hl13.interiorFlowVolume();
379  flow_edge = hl13.edgeFlowVolume();
380  flow_corner = hl13.cornerFlowVolume();
381  area_interior = hl13.interiorWettedArea();
382  area_edge = hl13.edgeWettedArea();
383  area_corner = hl13.cornerWettedArea();
384  EXPECT_DOUBLE_EQ(hl13.flowVolume(),
385  n_interior * flow_interior + n_edge * flow_edge + n_corner * flow_corner);
386  EXPECT_DOUBLE_EQ(hl13.wettedArea(),
387  n_interior * area_interior + n_edge * area_edge + n_corner * area_corner);
388 
389  EXPECT_DOUBLE_EQ(hl14.hydraulicDiameter(), 0.7437951937590452);
390  n_interior = hl14.nInteriorChannels();
391  n_edge = hl14.nEdgeChannels();
392  n_corner = hl14.nCornerChannels();
393  flow_interior = hl14.interiorFlowVolume();
394  flow_edge = hl14.edgeFlowVolume();
395  flow_corner = hl14.cornerFlowVolume();
396  area_interior = hl14.interiorWettedArea();
397  area_edge = hl14.edgeWettedArea();
398  area_corner = hl14.cornerWettedArea();
399  EXPECT_DOUBLE_EQ(hl14.flowVolume(),
400  n_interior * flow_interior + n_edge * flow_edge + n_corner * flow_corner);
401  EXPECT_DOUBLE_EQ(hl14.wettedArea(),
402  n_interior * area_interior + n_edge * area_edge + n_corner * area_corner);
403 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST_F() [5/16]

TEST_F ( HexagonalLatticeTest  ,
pin_centers   
)

Definition at line 405 of file HexagonalLatticeTest.C.

406 {
407  Real bp = 5.0, pp = 0.99, pd = 0.8, wd = 0.0, wp = 50.0;
408  unsigned int nr = 3, a = 2;
409  HexagonalLatticeUtils hl14(bp, pp, pd, wd, wp, nr, a);
410 
411  nr = 1;
412  HexagonalLatticeUtils hl15(bp, pp, pd, wd, wp, nr, a);
413 
414  nr = 2;
415  HexagonalLatticeUtils hl16(bp, pp, pd, wd, wp, nr, a);
416 
417  bp = 10.0;
418  nr = 4;
419  HexagonalLatticeUtils hl17(bp, pp, pd, wd, wp, nr, a);
420 
421  Real cos60 = 0.5;
422  Real sin60 = std::sqrt(3.0) / 2.0;
423 
424  auto & centers = hl15.pinCenters();
425  EXPECT_EQ(centers.size(), hl15.nPins());
426  EXPECT_DOUBLE_EQ(centers[0](0), 0.0);
427  EXPECT_DOUBLE_EQ(centers[0](1), 0.0);
428  EXPECT_DOUBLE_EQ(centers[0](2), 0.0);
429 
430  Real p = 0.99;
431  auto & centers2 = hl16.pinCenters();
432  EXPECT_EQ(centers2.size(), hl16.nPins());
433  EXPECT_DOUBLE_EQ(centers2[0](0), 0.0);
434  EXPECT_DOUBLE_EQ(centers2[0](1), 0.0);
435  EXPECT_DOUBLE_EQ(centers2[1](0), cos60 * p);
436  EXPECT_DOUBLE_EQ(centers2[1](1), sin60 * p);
437  EXPECT_DOUBLE_EQ(centers2[2](0), -cos60 * p);
438  EXPECT_DOUBLE_EQ(centers2[2](1), sin60 * p);
439  EXPECT_DOUBLE_EQ(centers2[3](0), -p);
440  EXPECT_DOUBLE_EQ(centers2[3](1), 0.0);
441  EXPECT_DOUBLE_EQ(centers2[4](0), -cos60 * p);
442  EXPECT_DOUBLE_EQ(centers2[4](1), -sin60 * p);
443  EXPECT_DOUBLE_EQ(centers2[5](0), cos60 * p);
444  EXPECT_DOUBLE_EQ(centers2[5](1), -sin60 * p);
445  EXPECT_DOUBLE_EQ(centers2[6](0), p);
446  EXPECT_DOUBLE_EQ(centers2[6](1), (unsigned int)0);
447 
448  for (const auto i : make_range(hl16.nPins()))
449  EXPECT_DOUBLE_EQ(centers2[i](2), 0.0);
450 
451  auto & centers3 = hl14.pinCenters();
452  EXPECT_EQ(centers3.size(), hl14.nPins());
453  EXPECT_DOUBLE_EQ(centers3[0](0), 0.0);
454  EXPECT_DOUBLE_EQ(centers3[0](1), 0.0);
455  EXPECT_DOUBLE_EQ(centers3[1](0), cos60 * p);
456  EXPECT_DOUBLE_EQ(centers3[1](1), sin60 * p);
457  EXPECT_DOUBLE_EQ(centers3[2](0), -cos60 * p);
458  EXPECT_DOUBLE_EQ(centers3[2](1), sin60 * p);
459  EXPECT_DOUBLE_EQ(centers3[3](0), -p);
460  EXPECT_DOUBLE_EQ(centers3[3](1), 0.0);
461  EXPECT_DOUBLE_EQ(centers3[4](0), -cos60 * p);
462  EXPECT_DOUBLE_EQ(centers3[4](1), -sin60 * p);
463  EXPECT_DOUBLE_EQ(centers3[5](0), cos60 * p);
464  EXPECT_DOUBLE_EQ(centers3[5](1), -sin60 * p);
465  EXPECT_DOUBLE_EQ(centers3[6](0), p);
466  EXPECT_DOUBLE_EQ(centers3[6](1), (unsigned int)0);
467 
468  EXPECT_DOUBLE_EQ(centers3[7](0), p);
469  EXPECT_DOUBLE_EQ(centers3[7](1), 2 * p * sin60);
470  EXPECT_DOUBLE_EQ(centers3[8](0), (unsigned int)0);
471  EXPECT_DOUBLE_EQ(centers3[8](1), 2 * p * sin60);
472  EXPECT_DOUBLE_EQ(centers3[9](0), -p);
473  EXPECT_DOUBLE_EQ(centers3[9](1), 2 * p * sin60);
474  EXPECT_DOUBLE_EQ(centers3[10](0), -p - p * cos60);
475  EXPECT_DOUBLE_EQ(centers3[10](1), p * sin60);
476  EXPECT_DOUBLE_EQ(centers3[11](0), -2 * p);
477  EXPECT_DOUBLE_EQ(centers3[11](1), (unsigned int)0);
478  EXPECT_DOUBLE_EQ(centers3[12](0), -p - p * cos60);
479  EXPECT_DOUBLE_EQ(centers3[12](1), -p * sin60);
480  EXPECT_DOUBLE_EQ(centers3[13](0), -p);
481  EXPECT_DOUBLE_EQ(centers3[13](1), -2 * p * sin60);
482  EXPECT_DOUBLE_EQ(centers3[14](0), (unsigned int)0);
483  EXPECT_DOUBLE_EQ(centers3[14](1), -2 * p * sin60);
484  EXPECT_DOUBLE_EQ(centers3[15](0), p);
485  EXPECT_DOUBLE_EQ(centers3[15](1), -2 * p * sin60);
486  EXPECT_DOUBLE_EQ(centers3[16](0), p + p * cos60);
487  EXPECT_DOUBLE_EQ(centers3[16](1), -p * sin60);
488  EXPECT_DOUBLE_EQ(centers3[17](0), 2 * p);
489  EXPECT_DOUBLE_EQ(centers3[17](1), 0.0);
490  EXPECT_DOUBLE_EQ(centers3[18](0), p + p * cos60);
491  EXPECT_DOUBLE_EQ(centers3[18](1), p * sin60);
492 
493  for (const auto i : make_range(hl14.nPins()))
494  EXPECT_DOUBLE_EQ(centers3[i](2), 0.0);
495 
496  auto & centers4 = hl17.pinCenters();
497  EXPECT_EQ(centers4.size(), hl17.nPins());
498  EXPECT_DOUBLE_EQ(centers4[0](0), 0.0);
499  EXPECT_DOUBLE_EQ(centers4[0](1), 0.0);
500  EXPECT_DOUBLE_EQ(centers4[1](0), cos60 * p);
501  EXPECT_DOUBLE_EQ(centers4[1](1), sin60 * p);
502  EXPECT_DOUBLE_EQ(centers4[2](0), -cos60 * p);
503  EXPECT_DOUBLE_EQ(centers4[2](1), sin60 * p);
504  EXPECT_DOUBLE_EQ(centers4[3](0), -p);
505  EXPECT_DOUBLE_EQ(centers4[3](1), 0.0);
506  EXPECT_DOUBLE_EQ(centers4[4](0), -cos60 * p);
507  EXPECT_DOUBLE_EQ(centers4[4](1), -sin60 * p);
508  EXPECT_DOUBLE_EQ(centers4[5](0), cos60 * p);
509  EXPECT_DOUBLE_EQ(centers4[5](1), -sin60 * p);
510  EXPECT_DOUBLE_EQ(centers4[6](0), p);
511  EXPECT_DOUBLE_EQ(centers4[6](1), (unsigned int)0);
512 
513  EXPECT_DOUBLE_EQ(centers4[7](0), p);
514  EXPECT_DOUBLE_EQ(centers4[7](1), 2 * p * sin60);
515  EXPECT_DOUBLE_EQ(centers4[8](0), (unsigned int)0);
516  EXPECT_DOUBLE_EQ(centers4[8](1), 2 * p * sin60);
517  EXPECT_DOUBLE_EQ(centers4[9](0), -p);
518  EXPECT_DOUBLE_EQ(centers4[9](1), 2 * p * sin60);
519  EXPECT_DOUBLE_EQ(centers4[10](0), -p - p * cos60);
520  EXPECT_DOUBLE_EQ(centers4[10](1), p * sin60);
521  EXPECT_DOUBLE_EQ(centers4[11](0), -2 * p);
522  EXPECT_DOUBLE_EQ(centers4[11](1), (unsigned int)0);
523  EXPECT_DOUBLE_EQ(centers4[12](0), -p - p * cos60);
524  EXPECT_DOUBLE_EQ(centers4[12](1), -p * sin60);
525  EXPECT_DOUBLE_EQ(centers4[13](0), -p);
526  EXPECT_DOUBLE_EQ(centers4[13](1), -2 * p * sin60);
527  EXPECT_DOUBLE_EQ(centers4[14](0), (unsigned int)0);
528  EXPECT_DOUBLE_EQ(centers4[14](1), -2 * p * sin60);
529  EXPECT_DOUBLE_EQ(centers4[15](0), p);
530  EXPECT_DOUBLE_EQ(centers4[15](1), -2 * p * sin60);
531  EXPECT_DOUBLE_EQ(centers4[16](0), p + p * cos60);
532  EXPECT_DOUBLE_EQ(centers4[16](1), -p * sin60);
533  EXPECT_DOUBLE_EQ(centers4[17](0), 2 * p);
534  EXPECT_DOUBLE_EQ(centers4[17](1), 0.0);
535  EXPECT_DOUBLE_EQ(centers4[18](0), p + p * cos60);
536  EXPECT_DOUBLE_EQ(centers4[18](1), p * sin60);
537 
538  EXPECT_DOUBLE_EQ(centers4[19](0), p + p * cos60);
539  EXPECT_DOUBLE_EQ(centers4[19](1), 3 * p * sin60);
540  EXPECT_DOUBLE_EQ(centers4[20](0), p * cos60);
541  EXPECT_DOUBLE_EQ(centers4[20](1), 3 * p * sin60);
542  EXPECT_DOUBLE_EQ(centers4[21](0), -p * cos60);
543  EXPECT_DOUBLE_EQ(centers4[21](1), 3 * p * sin60);
544  EXPECT_DOUBLE_EQ(centers4[22](0), -p - p * cos60);
545  EXPECT_DOUBLE_EQ(centers4[22](1), 3 * p * sin60);
546  EXPECT_DOUBLE_EQ(centers4[23](0), -2 * p);
547  EXPECT_DOUBLE_EQ(centers4[23](1), 2 * p * sin60);
548  EXPECT_DOUBLE_EQ(centers4[24](0), -2 * p - p * cos60);
549  EXPECT_DOUBLE_EQ(centers4[24](1), p * sin60);
550  EXPECT_DOUBLE_EQ(centers4[25](0), -3 * p);
551  EXPECT_DOUBLE_EQ(centers4[25](1), (unsigned int)0);
552  EXPECT_DOUBLE_EQ(centers4[26](0), -2 * p - p * cos60);
553  EXPECT_DOUBLE_EQ(centers4[26](1), -p * sin60);
554  EXPECT_DOUBLE_EQ(centers4[27](0), -2 * p);
555  EXPECT_DOUBLE_EQ(centers4[27](1), -2 * p * sin60);
556  EXPECT_DOUBLE_EQ(centers4[28](0), -p - p * cos60);
557  EXPECT_DOUBLE_EQ(centers4[28](1), -3 * p * sin60);
558  EXPECT_DOUBLE_EQ(centers4[29](0), -p * cos60);
559  EXPECT_DOUBLE_EQ(centers4[29](1), -3 * p * sin60);
560  EXPECT_DOUBLE_EQ(centers4[30](0), p * cos60);
561  EXPECT_DOUBLE_EQ(centers4[30](1), -3 * p * sin60);
562  EXPECT_DOUBLE_EQ(centers4[31](0), p + p * cos60);
563  EXPECT_DOUBLE_EQ(centers4[31](1), -3 * p * sin60);
564  EXPECT_DOUBLE_EQ(centers4[32](0), 2 * p);
565  EXPECT_DOUBLE_EQ(centers4[32](1), -2 * p * sin60);
566  EXPECT_DOUBLE_EQ(centers4[33](0), 2 * p + p * cos60);
567  EXPECT_DOUBLE_EQ(centers4[33](1), -p * sin60);
568  EXPECT_DOUBLE_EQ(centers4[34](0), 3 * p);
569  EXPECT_DOUBLE_EQ(centers4[34](1), (unsigned int)0);
570  EXPECT_DOUBLE_EQ(centers4[35](0), 2 * p + p * cos60);
571  EXPECT_DOUBLE_EQ(centers4[35](1), p * sin60);
572  EXPECT_DOUBLE_EQ(centers4[36](0), 2 * p);
573  EXPECT_DOUBLE_EQ(centers4[36](1), 2 * p * sin60);
574 
575  for (const auto i : make_range(hl17.nPins()))
576  EXPECT_DOUBLE_EQ(centers4[i](2), 0.0);
577 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
make_range
IntRange< T > make_range(T beg, T end)

◆ TEST_F() [6/16]

TEST_F ( HexagonalLatticeTest  ,
channel_index_shifted   
)

Definition at line 579 of file HexagonalLatticeTest.C.

580 {
581  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
582  unsigned int nr = 3, a = 2;
583  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
584 
585  // check that the z-coordinate doesn't affect the channel index identification
586  Point pt0(0.06, 0.35, 3.5);
587  Point pt1(-0.47, 0.28, 3.5);
588  Point pt2(-0.26, -0.21, 3.5);
589  Point pt3(-0.12, -0.349, 3.5);
590  Point pt4(0.46, -0.27, 3.5);
591  Point pt5(0.37, 0.6, 3.5);
592 
593  EXPECT_EQ(hl.channelIndex(pt0), (unsigned int)0);
594  EXPECT_EQ(hl.channelIndex(pt1), (unsigned int)1);
595  EXPECT_EQ(hl.channelIndex(pt2), (unsigned int)2);
596  EXPECT_EQ(hl.channelIndex(pt3), (unsigned int)3);
597  EXPECT_EQ(hl.channelIndex(pt4), (unsigned int)4);
598  EXPECT_EQ(hl.channelIndex(pt5), (unsigned int)5);
599 
600  Point pt6(0.36, 1.06, -7.0);
601  Point pt7(0.11, 0.98, -7.0);
602  Point pt8(-0.43, 1.27, -7.0);
603  Point pt9(-0.81, 0.93, -7.0);
604  Point pt10(-0.75, 0.47, -7.0);
605  Point pt11(-1.06, 0.28, -7.0);
606  Point pt12(-1.16, -0.13, -7.0);
607  Point pt13(-0.73, -0.41, -7.0);
608  Point pt14(-0.73, -0.81, -7.0);
609  Point pt15(-0.46, -1.18, -7.0);
610  Point pt16(0.05, -0.98, -7.0);
611  Point pt17(0.27, -1.00, -7.0);
612  Point pt18(0.72, -0.98, -7.0);
613  Point pt19(0.75, -0.58, -7.0);
614  Point pt20(1.23, -0.23, -7.0);
615  Point pt21(1.17, 0.09, -7.0);
616  Point pt22(0.78, 0.38, -7.0);
617  Point pt23(0.74, 0.84, -7.0);
618 
619  EXPECT_EQ(hl.channelIndex(pt6), (unsigned int)6);
620  EXPECT_EQ(hl.channelIndex(pt7), (unsigned int)7);
621  EXPECT_EQ(hl.channelIndex(pt8), (unsigned int)8);
622  EXPECT_EQ(hl.channelIndex(pt9), (unsigned int)9);
623  EXPECT_EQ(hl.channelIndex(pt10), (unsigned int)10);
624  EXPECT_EQ(hl.channelIndex(pt11), (unsigned int)11);
625  EXPECT_EQ(hl.channelIndex(pt12), (unsigned int)12);
626  EXPECT_EQ(hl.channelIndex(pt13), (unsigned int)13);
627  EXPECT_EQ(hl.channelIndex(pt14), (unsigned int)14);
628  EXPECT_EQ(hl.channelIndex(pt15), (unsigned int)15);
629  EXPECT_EQ(hl.channelIndex(pt16), (unsigned int)16);
630  EXPECT_EQ(hl.channelIndex(pt17), (unsigned int)17);
631  EXPECT_EQ(hl.channelIndex(pt18), (unsigned int)18);
632  EXPECT_EQ(hl.channelIndex(pt19), (unsigned int)19);
633  EXPECT_EQ(hl.channelIndex(pt20), (unsigned int)20);
634  EXPECT_EQ(hl.channelIndex(pt21), (unsigned int)21);
635  EXPECT_EQ(hl.channelIndex(pt22), (unsigned int)22);
636  EXPECT_EQ(hl.channelIndex(pt23), (unsigned int)23);
637 
638  Point pt24(0.31, 1.44, -0.1);
639  Point pt25(-0.38, 1.61, -0.1);
640  Point pt26(-1.17, 1.52, -0.1);
641  Point pt27(-1.78, 0.38, -0.1);
642  Point pt28(-1.91, -0.42, -0.1);
643  Point pt29(-1.39, -1.24, -0.1);
644  Point pt30(-0.46, -1.74, -0.1);
645  Point pt31(0.18, -1.79, -0.1);
646  Point pt32(1.24, -1.17, -0.1);
647  Point pt33(1.75, -0.57, -0.1);
648  Point pt34(1.51, 0.37, -0.1);
649  Point pt35(1.16, 1.42, -0.1);
650 
651  EXPECT_EQ(hl.channelIndex(pt24), (unsigned int)24);
652  EXPECT_EQ(hl.channelIndex(pt25), (unsigned int)25);
653  // EXPECT_EQ(hl.channelIndex(pt26), (unsigned int)26);
654  EXPECT_EQ(hl.channelIndex(pt27), (unsigned int)27);
655  EXPECT_EQ(hl.channelIndex(pt28), (unsigned int)28);
656  EXPECT_EQ(hl.channelIndex(pt29), (unsigned int)29);
657  EXPECT_EQ(hl.channelIndex(pt30), (unsigned int)30);
658  EXPECT_EQ(hl.channelIndex(pt31), (unsigned int)31);
659  EXPECT_EQ(hl.channelIndex(pt32), (unsigned int)32);
660  EXPECT_EQ(hl.channelIndex(pt33), (unsigned int)33);
661  EXPECT_EQ(hl.channelIndex(pt34), (unsigned int)34);
662  EXPECT_EQ(hl.channelIndex(pt35), (unsigned int)35);
663 
664  Point pt36(1.05, 1.75, 1.2);
665  Point pt37(-1.02, 1.72, 1.2);
666  Point pt38(-2.03, -0.05, 1.2);
667  Point pt39(-1.01, -1.59, 1.2);
668  Point pt40(0.89, -1.79, 1.2);
669  Point pt41(1.98, 0.12, 1.2);
670 
671  EXPECT_EQ(hl.channelIndex(pt36), (unsigned int)36);
672  EXPECT_EQ(hl.channelIndex(pt37), (unsigned int)37);
673  EXPECT_EQ(hl.channelIndex(pt38), (unsigned int)38);
674  EXPECT_EQ(hl.channelIndex(pt39), (unsigned int)39);
675  EXPECT_EQ(hl.channelIndex(pt40), (unsigned int)40);
676  EXPECT_EQ(hl.channelIndex(pt41), (unsigned int)41);
677 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [7/16]

TEST_F ( HexagonalLatticeTest  ,
channel_index   
)

Definition at line 679 of file HexagonalLatticeTest.C.

680 {
681  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
682  unsigned int nr = 3, a = 2;
683  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
684 
685  Point pt0(0.06, 0.35, 0.0);
686  Point pt1(-0.47, 0.28, 0.0);
687  Point pt2(-0.26, -0.21, 0.0);
688  Point pt3(-0.12, -0.349, 0.0);
689  Point pt4(0.46, -0.27, 0.0);
690  Point pt5(0.37, 0.6, 0.0);
691  EXPECT_EQ(hl.channelType(pt0), channel_type::interior);
692  EXPECT_EQ(hl.channelType(pt1), channel_type::interior);
693  EXPECT_EQ(hl.channelType(pt2), channel_type::interior);
694  EXPECT_EQ(hl.channelType(pt3), channel_type::interior);
695  EXPECT_EQ(hl.channelType(pt4), channel_type::interior);
696  EXPECT_EQ(hl.channelType(pt5), channel_type::interior);
697  EXPECT_EQ(hl.channelIndex(pt0), (unsigned int)0);
698  EXPECT_EQ(hl.channelIndex(pt1), (unsigned int)1);
699  EXPECT_EQ(hl.channelIndex(pt2), (unsigned int)2);
700  EXPECT_EQ(hl.channelIndex(pt3), (unsigned int)3);
701  EXPECT_EQ(hl.channelIndex(pt4), (unsigned int)4);
702  EXPECT_EQ(hl.channelIndex(pt5), (unsigned int)5);
703 
704  // check that a point exactly on the edge falls into one channel
705  pt0 = {0.5 * 0.8 * 0.5, 0.5 * 0.8 * std::sqrt(3.0) / 2.0, 0.0};
706  EXPECT_EQ(hl.channelIndex(pt0), (unsigned int)0);
707 
708  Point pt6(0.36, 1.06, 0.0);
709  Point pt7(0.11, 0.98, 0.0);
710  Point pt8(-0.43, 1.27, 0.0);
711  Point pt9(-0.81, 0.93, 0.0);
712  Point pt10(-0.75, 0.47, 0.0);
713  Point pt11(-1.06, 0.28, 0.0);
714  Point pt12(-1.16, -0.13, 0.0);
715  Point pt13(-0.73, -0.41, 0.0);
716  Point pt14(-0.73, -0.81, 0.0);
717  Point pt15(-0.46, -1.18, 0.0);
718  Point pt16(0.05, -0.98, 0.0);
719  Point pt17(0.27, -1.00, 0.0);
720  Point pt18(0.72, -0.98, 0.0);
721  Point pt19(0.75, -0.58, 0.0);
722  Point pt20(1.23, -0.23, 0.0);
723  Point pt21(1.17, 0.09, 0.0);
724  Point pt22(0.78, 0.38, 0.0);
725  Point pt23(0.74, 0.84, 0.0);
726 
727  EXPECT_EQ(hl.channelType(pt6), channel_type::interior);
728  EXPECT_EQ(hl.channelType(pt7), channel_type::interior);
729  EXPECT_EQ(hl.channelType(pt8), channel_type::interior);
730  EXPECT_EQ(hl.channelType(pt9), channel_type::interior);
731  EXPECT_EQ(hl.channelType(pt10), channel_type::interior);
732  EXPECT_EQ(hl.channelType(pt11), channel_type::interior);
733  EXPECT_EQ(hl.channelType(pt12), channel_type::interior);
734  EXPECT_EQ(hl.channelType(pt13), channel_type::interior);
735  EXPECT_EQ(hl.channelType(pt14), channel_type::interior);
736  EXPECT_EQ(hl.channelType(pt15), channel_type::interior);
737  EXPECT_EQ(hl.channelType(pt16), channel_type::interior);
738  EXPECT_EQ(hl.channelType(pt17), channel_type::interior);
739  EXPECT_EQ(hl.channelType(pt18), channel_type::interior);
740  EXPECT_EQ(hl.channelType(pt19), channel_type::interior);
741  EXPECT_EQ(hl.channelType(pt20), channel_type::interior);
742  EXPECT_EQ(hl.channelType(pt21), channel_type::interior);
743  EXPECT_EQ(hl.channelType(pt22), channel_type::interior);
744  EXPECT_EQ(hl.channelType(pt23), channel_type::interior);
745  EXPECT_EQ(hl.channelIndex(pt6), (unsigned int)6);
746  EXPECT_EQ(hl.channelIndex(pt7), (unsigned int)7);
747  EXPECT_EQ(hl.channelIndex(pt8), (unsigned int)8);
748  EXPECT_EQ(hl.channelIndex(pt9), (unsigned int)9);
749  EXPECT_EQ(hl.channelIndex(pt10), (unsigned int)10);
750  EXPECT_EQ(hl.channelIndex(pt11), (unsigned int)11);
751  EXPECT_EQ(hl.channelIndex(pt12), (unsigned int)12);
752  EXPECT_EQ(hl.channelIndex(pt13), (unsigned int)13);
753  EXPECT_EQ(hl.channelIndex(pt14), (unsigned int)14);
754  EXPECT_EQ(hl.channelIndex(pt15), (unsigned int)15);
755  EXPECT_EQ(hl.channelIndex(pt16), (unsigned int)16);
756  EXPECT_EQ(hl.channelIndex(pt17), (unsigned int)17);
757  EXPECT_EQ(hl.channelIndex(pt18), (unsigned int)18);
758  EXPECT_EQ(hl.channelIndex(pt19), (unsigned int)19);
759  EXPECT_EQ(hl.channelIndex(pt20), (unsigned int)20);
760  EXPECT_EQ(hl.channelIndex(pt21), (unsigned int)21);
761  EXPECT_EQ(hl.channelIndex(pt22), (unsigned int)22);
762  EXPECT_EQ(hl.channelIndex(pt23), (unsigned int)23);
763 
764  Point pt24(0.31, 1.44, 0.0);
765  Point pt25(-0.38, 1.61, 0.0);
766  Point pt26(-1.17, 1.52, 0.0);
767  Point pt27(-1.78, 0.38, 0.0);
768  Point pt28(-1.91, -0.42, 0.0);
769  Point pt29(-1.39, -1.24, 0.0);
770  Point pt30(-0.46, -1.74, 0.0);
771  Point pt31(0.18, -1.79, 0.0);
772  Point pt32(1.24, -1.17, 0.0);
773  Point pt33(1.75, -0.57, 0.0);
774  Point pt34(1.51, 0.37, 0.0);
775  Point pt35(1.16, 1.42, 0.0);
776 
777  EXPECT_EQ(hl.channelType(pt24), channel_type::edge);
778  EXPECT_EQ(hl.channelType(pt25), channel_type::edge);
779  EXPECT_EQ(hl.channelType(pt26), channel_type::edge);
780  EXPECT_EQ(hl.channelType(pt27), channel_type::edge);
781  EXPECT_EQ(hl.channelType(pt28), channel_type::edge);
782  EXPECT_EQ(hl.channelType(pt29), channel_type::edge);
783  EXPECT_EQ(hl.channelType(pt30), channel_type::edge);
784  EXPECT_EQ(hl.channelType(pt31), channel_type::edge);
785  EXPECT_EQ(hl.channelType(pt32), channel_type::edge);
786  EXPECT_EQ(hl.channelType(pt33), channel_type::edge);
787  EXPECT_EQ(hl.channelType(pt34), channel_type::edge);
788  EXPECT_EQ(hl.channelType(pt35), channel_type::edge);
789  EXPECT_EQ(hl.channelIndex(pt24), (unsigned int)24);
790  EXPECT_EQ(hl.channelIndex(pt25), (unsigned int)25);
791  // EXPECT_EQ(hl.channelIndex(pt26), (unsigned int)26);
792  EXPECT_EQ(hl.channelIndex(pt27), (unsigned int)27);
793  EXPECT_EQ(hl.channelIndex(pt28), (unsigned int)28);
794  EXPECT_EQ(hl.channelIndex(pt29), (unsigned int)29);
795  EXPECT_EQ(hl.channelIndex(pt30), (unsigned int)30);
796  EXPECT_EQ(hl.channelIndex(pt31), (unsigned int)31);
797  EXPECT_EQ(hl.channelIndex(pt32), (unsigned int)32);
798  EXPECT_EQ(hl.channelIndex(pt33), (unsigned int)33);
799  EXPECT_EQ(hl.channelIndex(pt34), (unsigned int)34);
800  EXPECT_EQ(hl.channelIndex(pt35), (unsigned int)35);
801 
802  Point pt36(1.05, 1.75, 0.0);
803  Point pt37(-1.02, 1.72, 0.0);
804  Point pt38(-2.03, -0.05, 0.0);
805  Point pt39(-1.01, -1.59, 0.0);
806  Point pt40(0.89, -1.79, 0.0);
807  Point pt41(1.98, 0.12, 0.0);
808 
809  EXPECT_EQ(hl.channelType(pt36), channel_type::corner);
810  EXPECT_EQ(hl.channelType(pt37), channel_type::corner);
811  EXPECT_EQ(hl.channelType(pt38), channel_type::corner);
812  EXPECT_EQ(hl.channelType(pt39), channel_type::corner);
813  EXPECT_EQ(hl.channelType(pt40), channel_type::corner);
814  EXPECT_EQ(hl.channelType(pt41), channel_type::corner);
815  EXPECT_EQ(hl.channelIndex(pt36), (unsigned int)36);
816  EXPECT_EQ(hl.channelIndex(pt37), (unsigned int)37);
817  EXPECT_EQ(hl.channelIndex(pt38), (unsigned int)38);
818  EXPECT_EQ(hl.channelIndex(pt39), (unsigned int)39);
819  EXPECT_EQ(hl.channelIndex(pt40), (unsigned int)40);
820  EXPECT_EQ(hl.channelIndex(pt41), (unsigned int)41);
821 }
channel_type::interior
Definition: HexagonalLatticeUtils.h:21
channel_type::corner
Definition: HexagonalLatticeUtils.h:23
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
channel_type::edge
Definition: HexagonalLatticeUtils.h:22
int
void ErrorVector unsigned int

◆ TEST_F() [8/16]

TEST_F ( HexagonalLatticeTest  ,
gaps1   
)

Definition at line 823 of file HexagonalLatticeTest.C.

824 {
825  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
826  unsigned int nr = 1, a = 2;
827  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
828  const auto & gi = hl.gapIndices();
829  const auto & lg = hl.localToGlobalGaps();
830 
831  EXPECT_EQ(hl.nInteriorGaps(), (unsigned int)0);
832 
833  int i = 0;
834  EXPECT_EQ(gi[i].first, 0);
835  EXPECT_EQ(gi[i++].second, -1);
836 
837  EXPECT_EQ(gi[i].first, 0);
838  EXPECT_EQ(gi[i++].second, -2);
839 
840  EXPECT_EQ(gi[i].first, 0);
841  EXPECT_EQ(gi[i++].second, -3);
842 
843  EXPECT_EQ(gi[i].first, 0);
844  EXPECT_EQ(gi[i++].second, -4);
845 
846  EXPECT_EQ(gi[i].first, 0);
847  EXPECT_EQ(gi[i++].second, -5);
848 
849  EXPECT_EQ(gi[i].first, 0);
850  EXPECT_EQ(gi[i++].second, -6);
851 
852  for (unsigned int i = 0; i < hl.nGaps(); ++i)
853  EXPECT_FALSE(hl.lastGapInRing(i));
854 
855  i = 0;
856  EXPECT_EQ(lg[i][0], 5);
857  EXPECT_EQ(lg[i++][1], 0);
858 
859  EXPECT_EQ(lg[i][0], 0);
860  EXPECT_EQ(lg[i++][1], 1);
861 
862  EXPECT_EQ(lg[i][0], 1);
863  EXPECT_EQ(lg[i++][1], 2);
864 
865  EXPECT_EQ(lg[i][0], 2);
866  EXPECT_EQ(lg[i++][1], 3);
867 
868  EXPECT_EQ(lg[i][0], 3);
869  EXPECT_EQ(lg[i++][1], 4);
870 
871  EXPECT_EQ(lg[i][0], 4);
872  EXPECT_EQ(lg[i++][1], 5);
873 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [9/16]

TEST_F ( HexagonalLatticeTest  ,
gaps2   
)

Definition at line 875 of file HexagonalLatticeTest.C.

876 {
877  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
878  unsigned int nr = 2, a = 2;
879  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
880  const auto & gi = hl.gapIndices();
881  const auto & lg = hl.localToGlobalGaps();
882 
883  EXPECT_EQ(hl.nInteriorGaps(), (unsigned int)12);
884 
885  int i = 0;
886  EXPECT_EQ(gi[i].first, 0);
887  EXPECT_EQ(gi[i++].second, 1);
888 
889  EXPECT_EQ(gi[i].first, 0);
890  EXPECT_EQ(gi[i++].second, 2);
891 
892  EXPECT_EQ(gi[i].first, 0);
893  EXPECT_EQ(gi[i++].second, 3);
894 
895  EXPECT_EQ(gi[i].first, 0);
896  EXPECT_EQ(gi[i++].second, 4);
897 
898  EXPECT_EQ(gi[i].first, 0);
899  EXPECT_EQ(gi[i++].second, 5);
900 
901  EXPECT_EQ(gi[i].first, 0);
902  EXPECT_EQ(gi[i++].second, 6);
903 
904  EXPECT_EQ(gi[i].first, 1);
905  EXPECT_EQ(gi[i++].second, 2);
906 
907  EXPECT_EQ(gi[i].first, 1);
908  EXPECT_EQ(gi[i++].second, 6);
909 
910  EXPECT_EQ(gi[i].first, 2);
911  EXPECT_EQ(gi[i++].second, 3);
912 
913  EXPECT_EQ(gi[i].first, 3);
914  EXPECT_EQ(gi[i++].second, 4);
915 
916  EXPECT_EQ(gi[i].first, 4);
917  EXPECT_EQ(gi[i++].second, 5);
918 
919  EXPECT_EQ(gi[i].first, 5);
920  EXPECT_EQ(gi[i++].second, 6);
921 
922  EXPECT_EQ(gi[i].first, 1);
923  EXPECT_EQ(gi[i++].second, -1);
924 
925  EXPECT_EQ(gi[i].first, 2);
926  EXPECT_EQ(gi[i++].second, -1);
927 
928  EXPECT_EQ(gi[i].first, 2);
929  EXPECT_EQ(gi[i++].second, -2);
930 
931  EXPECT_EQ(gi[i].first, 3);
932  EXPECT_EQ(gi[i++].second, -2);
933 
934  EXPECT_EQ(gi[i].first, 3);
935  EXPECT_EQ(gi[i++].second, -3);
936 
937  EXPECT_EQ(gi[i].first, 4);
938  EXPECT_EQ(gi[i++].second, -3);
939 
940  EXPECT_EQ(gi[i].first, 4);
941  EXPECT_EQ(gi[i++].second, -4);
942 
943  EXPECT_EQ(gi[i].first, 5);
944  EXPECT_EQ(gi[i++].second, -4);
945 
946  EXPECT_EQ(gi[i].first, 5);
947  EXPECT_EQ(gi[i++].second, -5);
948 
949  EXPECT_EQ(gi[i].first, 6);
950  EXPECT_EQ(gi[i++].second, -5);
951 
952  EXPECT_EQ(gi[i].first, 6);
953  EXPECT_EQ(gi[i++].second, -6);
954 
955  EXPECT_EQ(gi[i].first, 1);
956  EXPECT_EQ(gi[i++].second, -6);
957 
958  for (unsigned int i = 0; i < hl.nGaps(); ++i)
959  {
960  if (i == 7)
961  EXPECT_TRUE(hl.lastGapInRing(i));
962  else
963  EXPECT_FALSE(hl.lastGapInRing(i));
964  }
965 
966  i = 0;
967  EXPECT_EQ(lg[i][0], 0);
968  EXPECT_EQ(lg[i][1], 6);
969  EXPECT_EQ(lg[i++][2], 1);
970 
971  EXPECT_EQ(lg[i][0], 1);
972  EXPECT_EQ(lg[i][1], 8);
973  EXPECT_EQ(lg[i++][2], 2);
974 
975  EXPECT_EQ(lg[i][0], 2);
976  EXPECT_EQ(lg[i][1], 9);
977  EXPECT_EQ(lg[i++][2], 3);
978 
979  EXPECT_EQ(lg[i][0], 3);
980  EXPECT_EQ(lg[i][1], 10);
981  EXPECT_EQ(lg[i++][2], 4);
982 
983  EXPECT_EQ(lg[i][0], 4);
984  EXPECT_EQ(lg[i][1], 11);
985  EXPECT_EQ(lg[i++][2], 5);
986 
987  EXPECT_EQ(lg[i][0], 5);
988  EXPECT_EQ(lg[i][1], 7);
989  EXPECT_EQ(lg[i++][2], 0);
990 
991  EXPECT_EQ(lg[i][0], 6);
992  EXPECT_EQ(lg[i][1], 13);
993  EXPECT_EQ(lg[i++][2], 12);
994 
995  EXPECT_EQ(lg[i][0], 8);
996  EXPECT_EQ(lg[i][1], 15);
997  EXPECT_EQ(lg[i++][2], 14);
998 
999  EXPECT_EQ(lg[i][0], 9);
1000  EXPECT_EQ(lg[i][1], 17);
1001  EXPECT_EQ(lg[i++][2], 16);
1002 
1003  EXPECT_EQ(lg[i][0], 10);
1004  EXPECT_EQ(lg[i][1], 19);
1005  EXPECT_EQ(lg[i++][2], 18);
1006 
1007  EXPECT_EQ(lg[i][0], 11);
1008  EXPECT_EQ(lg[i][1], 21);
1009  EXPECT_EQ(lg[i++][2], 20);
1010 
1011  EXPECT_EQ(lg[i][0], 7);
1012  EXPECT_EQ(lg[i][1], 23);
1013  EXPECT_EQ(lg[i++][2], 22);
1014 
1015  EXPECT_EQ(lg[i][0], 23);
1016  EXPECT_EQ(lg[i++][1], 12);
1017 
1018  EXPECT_EQ(lg[i][0], 13);
1019  EXPECT_EQ(lg[i++][1], 14);
1020 
1021  EXPECT_EQ(lg[i][0], 15);
1022  EXPECT_EQ(lg[i++][1], 16);
1023 
1024  EXPECT_EQ(lg[i][0], 17);
1025  EXPECT_EQ(lg[i++][1], 18);
1026 
1027  EXPECT_EQ(lg[i][0], 19);
1028  EXPECT_EQ(lg[i++][1], 20);
1029 
1030  EXPECT_EQ(lg[i][0], 21);
1031  EXPECT_EQ(lg[i++][1], 22);
1032 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [10/16]

TEST_F ( HexagonalLatticeTest  ,
gaps3   
)

Definition at line 1034 of file HexagonalLatticeTest.C.

1035 {
1036  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1037  unsigned int nr = 3, a = 2;
1038  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1039  const auto & gi = hl.gapIndices();
1040  const auto & lg = hl.localToGlobalGaps();
1041 
1042  EXPECT_EQ(hl.nInteriorGaps(), (unsigned int)42);
1043 
1044  int i = 0;
1045  EXPECT_EQ(gi[i].first, 0);
1046  EXPECT_EQ(gi[i++].second, 1);
1047 
1048  EXPECT_EQ(gi[i].first, 0);
1049  EXPECT_EQ(gi[i++].second, 2);
1050 
1051  EXPECT_EQ(gi[i].first, 0);
1052  EXPECT_EQ(gi[i++].second, 3);
1053 
1054  EXPECT_EQ(gi[i].first, 0);
1055  EXPECT_EQ(gi[i++].second, 4);
1056 
1057  EXPECT_EQ(gi[i].first, 0);
1058  EXPECT_EQ(gi[i++].second, 5);
1059 
1060  EXPECT_EQ(gi[i].first, 0);
1061  EXPECT_EQ(gi[i++].second, 6);
1062 
1063  EXPECT_EQ(gi[i].first, 1);
1064  EXPECT_EQ(gi[i++].second, 2);
1065 
1066  EXPECT_EQ(gi[i].first, 1);
1067  EXPECT_EQ(gi[i++].second, 6);
1068 
1069  EXPECT_EQ(gi[i].first, 1);
1070  EXPECT_EQ(gi[i++].second, 7);
1071 
1072  EXPECT_EQ(gi[i].first, 1);
1073  EXPECT_EQ(gi[i++].second, 8);
1074 
1075  EXPECT_EQ(gi[i].first, 1);
1076  EXPECT_EQ(gi[i++].second, 18);
1077 
1078  EXPECT_EQ(gi[i].first, 2);
1079  EXPECT_EQ(gi[i++].second, 3);
1080 
1081  EXPECT_EQ(gi[i].first, 2);
1082  EXPECT_EQ(gi[i++].second, 8);
1083 
1084  EXPECT_EQ(gi[i].first, 2);
1085  EXPECT_EQ(gi[i++].second, 9);
1086 
1087  EXPECT_EQ(gi[i].first, 2);
1088  EXPECT_EQ(gi[i++].second, 10);
1089 
1090  EXPECT_EQ(gi[i].first, 3);
1091  EXPECT_EQ(gi[i++].second, 4);
1092 
1093  EXPECT_EQ(gi[i].first, 3);
1094  EXPECT_EQ(gi[i++].second, 10);
1095 
1096  EXPECT_EQ(gi[i].first, 3);
1097  EXPECT_EQ(gi[i++].second, 11);
1098 
1099  EXPECT_EQ(gi[i].first, 3);
1100  EXPECT_EQ(gi[i++].second, 12);
1101 
1102  EXPECT_EQ(gi[i].first, 4);
1103  EXPECT_EQ(gi[i++].second, 5);
1104 
1105  EXPECT_EQ(gi[i].first, 4);
1106  EXPECT_EQ(gi[i++].second, 12);
1107 
1108  EXPECT_EQ(gi[i].first, 4);
1109  EXPECT_EQ(gi[i++].second, 13);
1110 
1111  EXPECT_EQ(gi[i].first, 4);
1112  EXPECT_EQ(gi[i++].second, 14);
1113 
1114  EXPECT_EQ(gi[i].first, 5);
1115  EXPECT_EQ(gi[i++].second, 6);
1116 
1117  EXPECT_EQ(gi[i].first, 5);
1118  EXPECT_EQ(gi[i++].second, 14);
1119 
1120  EXPECT_EQ(gi[i].first, 5);
1121  EXPECT_EQ(gi[i++].second, 15);
1122 
1123  EXPECT_EQ(gi[i].first, 5);
1124  EXPECT_EQ(gi[i++].second, 16);
1125 
1126  EXPECT_EQ(gi[i].first, 6);
1127  EXPECT_EQ(gi[i++].second, 16);
1128 
1129  EXPECT_EQ(gi[i].first, 6);
1130  EXPECT_EQ(gi[i++].second, 17);
1131 
1132  EXPECT_EQ(gi[i].first, 6);
1133  EXPECT_EQ(gi[i++].second, 18);
1134 
1135  EXPECT_EQ(gi[i].first, 7);
1136  EXPECT_EQ(gi[i++].second, 8);
1137 
1138  EXPECT_EQ(gi[i].first, 7);
1139  EXPECT_EQ(gi[i++].second, 18);
1140 
1141  EXPECT_EQ(gi[i].first, 8);
1142  EXPECT_EQ(gi[i++].second, 9);
1143 
1144  EXPECT_EQ(gi[i].first, 9);
1145  EXPECT_EQ(gi[i++].second, 10);
1146 
1147  EXPECT_EQ(gi[i].first, 10);
1148  EXPECT_EQ(gi[i++].second, 11);
1149 
1150  EXPECT_EQ(gi[i].first, 11);
1151  EXPECT_EQ(gi[i++].second, 12);
1152 
1153  EXPECT_EQ(gi[i].first, 12);
1154  EXPECT_EQ(gi[i++].second, 13);
1155 
1156  EXPECT_EQ(gi[i].first, 13);
1157  EXPECT_EQ(gi[i++].second, 14);
1158 
1159  EXPECT_EQ(gi[i].first, 14);
1160  EXPECT_EQ(gi[i++].second, 15);
1161 
1162  EXPECT_EQ(gi[i].first, 15);
1163  EXPECT_EQ(gi[i++].second, 16);
1164 
1165  EXPECT_EQ(gi[i].first, 16);
1166  EXPECT_EQ(gi[i++].second, 17);
1167 
1168  EXPECT_EQ(gi[i].first, 17);
1169  EXPECT_EQ(gi[i++].second, 18);
1170 
1171  EXPECT_EQ(gi[i].first, 7);
1172  EXPECT_EQ(gi[i++].second, -1);
1173 
1174  EXPECT_EQ(gi[i].first, 8);
1175  EXPECT_EQ(gi[i++].second, -1);
1176 
1177  EXPECT_EQ(gi[i].first, 9);
1178  EXPECT_EQ(gi[i++].second, -1);
1179 
1180  EXPECT_EQ(gi[i].first, 9);
1181  EXPECT_EQ(gi[i++].second, -2);
1182 
1183  EXPECT_EQ(gi[i].first, 10);
1184  EXPECT_EQ(gi[i++].second, -2);
1185 
1186  EXPECT_EQ(gi[i].first, 11);
1187  EXPECT_EQ(gi[i++].second, -2);
1188 
1189  EXPECT_EQ(gi[i].first, 11);
1190  EXPECT_EQ(gi[i++].second, -3);
1191 
1192  EXPECT_EQ(gi[i].first, 12);
1193  EXPECT_EQ(gi[i++].second, -3);
1194 
1195  EXPECT_EQ(gi[i].first, 13);
1196  EXPECT_EQ(gi[i++].second, -3);
1197 
1198  EXPECT_EQ(gi[i].first, 13);
1199  EXPECT_EQ(gi[i++].second, -4);
1200 
1201  EXPECT_EQ(gi[i].first, 14);
1202  EXPECT_EQ(gi[i++].second, -4);
1203 
1204  EXPECT_EQ(gi[i].first, 15);
1205  EXPECT_EQ(gi[i++].second, -4);
1206 
1207  EXPECT_EQ(gi[i].first, 15);
1208  EXPECT_EQ(gi[i++].second, -5);
1209 
1210  EXPECT_EQ(gi[i].first, 16);
1211  EXPECT_EQ(gi[i++].second, -5);
1212 
1213  EXPECT_EQ(gi[i].first, 17);
1214  EXPECT_EQ(gi[i++].second, -5);
1215 
1216  EXPECT_EQ(gi[i].first, 17);
1217  EXPECT_EQ(gi[i++].second, -6);
1218 
1219  EXPECT_EQ(gi[i].first, 18);
1220  EXPECT_EQ(gi[i++].second, -6);
1221 
1222  EXPECT_EQ(gi[i].first, 7);
1223  EXPECT_EQ(gi[i++].second, -6);
1224 
1225  for (unsigned int i = 0; i < hl.nGaps(); ++i)
1226  {
1227  if (i == 7 || i == 31)
1228  EXPECT_TRUE(hl.lastGapInRing(i));
1229  else
1230  EXPECT_FALSE(hl.lastGapInRing(i));
1231  }
1232 
1233  i = 0;
1234  EXPECT_EQ(lg[i][0], 0);
1235  EXPECT_EQ(lg[i][1], 6);
1236  EXPECT_EQ(lg[i++][2], 1);
1237 
1238  EXPECT_EQ(lg[i][0], 1);
1239  EXPECT_EQ(lg[i][1], 11);
1240  EXPECT_EQ(lg[i++][2], 2);
1241 
1242  EXPECT_EQ(lg[i][0], 2);
1243  EXPECT_EQ(lg[i][1], 15);
1244  EXPECT_EQ(lg[i++][2], 3);
1245 
1246  EXPECT_EQ(lg[i][0], 3);
1247  EXPECT_EQ(lg[i][1], 19);
1248  EXPECT_EQ(lg[i++][2], 4);
1249 
1250  EXPECT_EQ(lg[i][0], 4);
1251  EXPECT_EQ(lg[i][1], 23);
1252  EXPECT_EQ(lg[i++][2], 5);
1253 
1254  EXPECT_EQ(lg[i][0], 5);
1255  EXPECT_EQ(lg[i][1], 7);
1256  EXPECT_EQ(lg[i++][2], 0);
1257 
1258  EXPECT_EQ(lg[i][0], 8);
1259  EXPECT_EQ(lg[i][1], 30);
1260  EXPECT_EQ(lg[i++][2], 9);
1261 
1262  EXPECT_EQ(lg[i][0], 12);
1263  EXPECT_EQ(lg[i][1], 6);
1264  EXPECT_EQ(lg[i++][2], 9);
1265 
1266  EXPECT_EQ(lg[i][0], 12);
1267  EXPECT_EQ(lg[i][1], 32);
1268  EXPECT_EQ(lg[i++][2], 13);
1269 
1270  EXPECT_EQ(lg[i][0], 13);
1271  EXPECT_EQ(lg[i][1], 33);
1272  EXPECT_EQ(lg[i++][2], 14);
1273 
1274  EXPECT_EQ(lg[i][0], 16);
1275  EXPECT_EQ(lg[i][1], 11);
1276  EXPECT_EQ(lg[i++][2], 14);
1277 
1278  EXPECT_EQ(lg[i][0], 16);
1279  EXPECT_EQ(lg[i][1], 34);
1280  EXPECT_EQ(lg[i++][2], 17);
1281 
1282  EXPECT_EQ(lg[i][0], 17);
1283  EXPECT_EQ(lg[i][1], 35);
1284  EXPECT_EQ(lg[i++][2], 18);
1285 
1286  EXPECT_EQ(lg[i][0], 20);
1287  EXPECT_EQ(lg[i][1], 15);
1288  EXPECT_EQ(lg[i++][2], 18);
1289 
1290  EXPECT_EQ(lg[i][0], 20);
1291  EXPECT_EQ(lg[i][1], 36);
1292  EXPECT_EQ(lg[i++][2], 21);
1293 
1294  EXPECT_EQ(lg[i][0], 21);
1295  EXPECT_EQ(lg[i][1], 37);
1296  EXPECT_EQ(lg[i++][2], 22);
1297 
1298  EXPECT_EQ(lg[i][0], 24);
1299  EXPECT_EQ(lg[i][1], 19);
1300  EXPECT_EQ(lg[i++][2], 22);
1301 
1302  EXPECT_EQ(lg[i][0], 24);
1303  EXPECT_EQ(lg[i][1], 38);
1304  EXPECT_EQ(lg[i++][2], 25);
1305 
1306  EXPECT_EQ(lg[i][0], 25);
1307  EXPECT_EQ(lg[i][1], 39);
1308  EXPECT_EQ(lg[i++][2], 26);
1309 
1310  EXPECT_EQ(lg[i][0], 27);
1311  EXPECT_EQ(lg[i][1], 23);
1312  EXPECT_EQ(lg[i++][2], 26);
1313 
1314  EXPECT_EQ(lg[i][0], 27);
1315  EXPECT_EQ(lg[i][1], 40);
1316  EXPECT_EQ(lg[i++][2], 28);
1317 
1318  EXPECT_EQ(lg[i][0], 28);
1319  EXPECT_EQ(lg[i][1], 41);
1320  EXPECT_EQ(lg[i++][2], 29);
1321 
1322  EXPECT_EQ(lg[i][0], 10);
1323  EXPECT_EQ(lg[i][1], 7);
1324  EXPECT_EQ(lg[i++][2], 29);
1325 
1326  EXPECT_EQ(lg[i][0], 10);
1327  EXPECT_EQ(lg[i][1], 31);
1328  EXPECT_EQ(lg[i++][2], 8);
1329 
1330  // edge channels
1331  EXPECT_EQ(lg[i][0], 30);
1332  EXPECT_EQ(lg[i][1], 43);
1333  EXPECT_EQ(lg[i++][2], 42);
1334 
1335  EXPECT_EQ(lg[i][0], 32);
1336  EXPECT_EQ(lg[i][1], 44);
1337  EXPECT_EQ(lg[i++][2], 43);
1338 
1339  EXPECT_EQ(lg[i][0], 33);
1340  EXPECT_EQ(lg[i][1], 46);
1341  EXPECT_EQ(lg[i++][2], 45);
1342 
1343  EXPECT_EQ(lg[i][0], 34);
1344  EXPECT_EQ(lg[i][1], 47);
1345  EXPECT_EQ(lg[i++][2], 46);
1346 
1347  EXPECT_EQ(lg[i][0], 35);
1348  EXPECT_EQ(lg[i][1], 49);
1349  EXPECT_EQ(lg[i++][2], 48);
1350 
1351  EXPECT_EQ(lg[i][0], 36);
1352  EXPECT_EQ(lg[i][1], 50);
1353  EXPECT_EQ(lg[i++][2], 49);
1354 
1355  EXPECT_EQ(lg[i][0], 37);
1356  EXPECT_EQ(lg[i][1], 52);
1357  EXPECT_EQ(lg[i++][2], 51);
1358 
1359  EXPECT_EQ(lg[i][0], 38);
1360  EXPECT_EQ(lg[i][1], 53);
1361  EXPECT_EQ(lg[i++][2], 52);
1362 
1363  EXPECT_EQ(lg[i][0], 39);
1364  EXPECT_EQ(lg[i][1], 55);
1365  EXPECT_EQ(lg[i++][2], 54);
1366 
1367  EXPECT_EQ(lg[i][0], 40);
1368  EXPECT_EQ(lg[i][1], 56);
1369  EXPECT_EQ(lg[i++][2], 55);
1370 
1371  EXPECT_EQ(lg[i][0], 41);
1372  EXPECT_EQ(lg[i][1], 58);
1373  EXPECT_EQ(lg[i++][2], 57);
1374 
1375  EXPECT_EQ(lg[i][0], 31);
1376  EXPECT_EQ(lg[i][1], 59);
1377  EXPECT_EQ(lg[i++][2], 58);
1378 
1379  // corner channels
1380  EXPECT_EQ(lg[i][0], 59);
1381  EXPECT_EQ(lg[i++][1], 42);
1382 
1383  EXPECT_EQ(lg[i][0], 44);
1384  EXPECT_EQ(lg[i++][1], 45);
1385 
1386  EXPECT_EQ(lg[i][0], 47);
1387  EXPECT_EQ(lg[i++][1], 48);
1388 
1389  EXPECT_EQ(lg[i][0], 50);
1390  EXPECT_EQ(lg[i++][1], 51);
1391 
1392  EXPECT_EQ(lg[i][0], 53);
1393  EXPECT_EQ(lg[i++][1], 54);
1394 
1395  EXPECT_EQ(lg[i][0], 56);
1396  EXPECT_EQ(lg[i++][1], 57);
1397 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [11/16]

TEST_F ( HexagonalLatticeTest  ,
closest_gap   
)

Definition at line 1399 of file HexagonalLatticeTest.C.

1400 {
1401  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1402  unsigned int nr = 3, a = 2;
1403  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1404 
1405  Point pt1(0.23, 0.27, 0.0);
1406  EXPECT_EQ(hl.gapIndex(pt1), (unsigned int)0);
1407 
1408  Point pt2(-0.5, 0.29, 0.0);
1409  EXPECT_EQ(hl.gapIndex(pt2), (unsigned int)11);
1410 
1411  Point pt3(1.14, 0.275, 0.0);
1412  EXPECT_EQ(hl.gapIndex(pt3), (unsigned int)29);
1413 
1414  Point pt4(-0.77, 1.015, 0.0);
1415  EXPECT_EQ(hl.gapIndex(pt4), (unsigned int)13);
1416 
1417  Point pt5(-0.84, 0.445, 0.0);
1418  EXPECT_EQ(hl.gapIndex(pt5), (unsigned int)16);
1419 
1420  Point pt6(-0.47, 1.55, 0.0);
1421  EXPECT_EQ(hl.gapIndex(pt6), (unsigned int)32);
1422 
1423  Point pt7(-0.069, 1.94, 0.0);
1424  EXPECT_EQ(hl.gapIndex(pt7), (unsigned int)43);
1425 
1426  Point pt8(-1.22, 1.79, 0.0);
1427  EXPECT_EQ(hl.gapIndex(pt8), (unsigned int)45);
1428 
1429  Point pt10(-0.26, -1.61, 0.0);
1430  EXPECT_EQ(hl.gapIndex(pt10), (unsigned int)37);
1431 
1432  Point pt11(2.23, 0.03, 0.0);
1433  EXPECT_EQ(hl.gapIndex(pt11), (unsigned int)57);
1434 
1435  Point pt12(-1.77, -0.70, 0.0);
1436  EXPECT_EQ(hl.gapIndex(pt12), (unsigned int)49);
1437 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [12/16]

TEST_F ( HexagonalLatticeTest  ,
normals1   
)

Definition at line 1439 of file HexagonalLatticeTest.C.

1440 {
1441  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1442  unsigned int nr = 1, a = 2;
1443  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1444  const auto & normals = hl.gapUnitNormals();
1445  Real sin60 = std::sqrt(3.0) / 2.0;
1446 
1447  for (const auto & n : normals)
1448  EXPECT_DOUBLE_EQ(n(2), 0.0);
1449 
1450  EXPECT_DOUBLE_EQ(normals[0](0), -1.0);
1451  EXPECT_DOUBLE_EQ(normals[0](1), 0.0);
1452 
1453  EXPECT_DOUBLE_EQ(normals[1](0), -0.5);
1454  EXPECT_DOUBLE_EQ(normals[1](1), -sin60);
1455 
1456  EXPECT_DOUBLE_EQ(normals[2](0), 0.5);
1457  EXPECT_DOUBLE_EQ(normals[2](1), -sin60);
1458 
1459  EXPECT_DOUBLE_EQ(normals[3](0), 1.0);
1460  EXPECT_DOUBLE_EQ(normals[3](1), 0.0);
1461 
1462  EXPECT_DOUBLE_EQ(normals[4](0), 0.5);
1463  EXPECT_DOUBLE_EQ(normals[4](1), sin60);
1464 
1465  EXPECT_DOUBLE_EQ(normals[5](0), -0.5);
1466  EXPECT_DOUBLE_EQ(normals[5](1), sin60);
1467 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST_F() [13/16]

TEST_F ( HexagonalLatticeTest  ,
normals2   
)

Definition at line 1469 of file HexagonalLatticeTest.C.

1470 {
1471  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1472  unsigned int nr = 2, a = 2;
1473  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1474  const auto & normals = hl.gapUnitNormals();
1475  Real sin60 = std::sqrt(3.0) / 2.0;
1476 
1477  for (const auto & n : normals)
1478  EXPECT_DOUBLE_EQ(n(2), 0.0);
1479 
1480  EXPECT_DOUBLE_EQ(normals[0](0), -sin60);
1481  EXPECT_DOUBLE_EQ(normals[0](1), 0.5);
1482 
1483  EXPECT_DOUBLE_EQ(normals[1](0), -sin60);
1484  EXPECT_DOUBLE_EQ(normals[1](1), -0.5);
1485 
1486  EXPECT_DOUBLE_EQ(normals[2](0), 0.0);
1487  EXPECT_DOUBLE_EQ(normals[2](1), -1.0);
1488 
1489  EXPECT_DOUBLE_EQ(normals[3](0), sin60);
1490  EXPECT_DOUBLE_EQ(normals[3](1), -0.5);
1491 
1492  EXPECT_DOUBLE_EQ(normals[4](0), sin60);
1493  EXPECT_DOUBLE_EQ(normals[4](1), 0.5);
1494 
1495  EXPECT_DOUBLE_EQ(normals[5](0), 0.0);
1496  EXPECT_DOUBLE_EQ(normals[5](1), 1.0);
1497 
1498  EXPECT_DOUBLE_EQ(normals[6](0), 0.0);
1499  EXPECT_DOUBLE_EQ(normals[6](1), -1.0);
1500 
1501  EXPECT_DOUBLE_EQ(normals[7](0), -sin60);
1502  EXPECT_DOUBLE_EQ(normals[7](1), -0.5);
1503 
1504  EXPECT_DOUBLE_EQ(normals[8](0), sin60);
1505  EXPECT_DOUBLE_EQ(normals[8](1), -0.5);
1506 
1507  EXPECT_DOUBLE_EQ(normals[9](0), sin60);
1508  EXPECT_DOUBLE_EQ(normals[9](1), 0.5);
1509 
1510  EXPECT_DOUBLE_EQ(normals[10](0), 0.0);
1511  EXPECT_DOUBLE_EQ(normals[10](1), 1.0);
1512 
1513  EXPECT_DOUBLE_EQ(normals[11](0), -sin60);
1514  EXPECT_DOUBLE_EQ(normals[11](1), 0.5);
1515 
1516  EXPECT_DOUBLE_EQ(normals[12](0), -1.0);
1517  EXPECT_DOUBLE_EQ(normals[12](1), 0.0);
1518 
1519  EXPECT_DOUBLE_EQ(normals[13](0), -1.0);
1520  EXPECT_DOUBLE_EQ(normals[13](1), 0.0);
1521 
1522  EXPECT_DOUBLE_EQ(normals[14](0), -0.5);
1523  EXPECT_DOUBLE_EQ(normals[14](1), -sin60);
1524 
1525  EXPECT_DOUBLE_EQ(normals[15](0), -0.5);
1526  EXPECT_DOUBLE_EQ(normals[15](1), -sin60);
1527 
1528  EXPECT_DOUBLE_EQ(normals[16](0), 0.5);
1529  EXPECT_DOUBLE_EQ(normals[16](1), -sin60);
1530 
1531  EXPECT_DOUBLE_EQ(normals[17](0), 0.5);
1532  EXPECT_DOUBLE_EQ(normals[17](1), -sin60);
1533 
1534  EXPECT_DOUBLE_EQ(normals[18](0), 1.0);
1535  EXPECT_DOUBLE_EQ(normals[18](1), 0.0);
1536 
1537  EXPECT_DOUBLE_EQ(normals[19](0), 1.0);
1538  EXPECT_DOUBLE_EQ(normals[19](1), 0.0);
1539 
1540  EXPECT_DOUBLE_EQ(normals[20](0), 0.5);
1541  EXPECT_DOUBLE_EQ(normals[20](1), sin60);
1542 
1543  EXPECT_DOUBLE_EQ(normals[21](0), 0.5);
1544  EXPECT_DOUBLE_EQ(normals[21](1), sin60);
1545 
1546  EXPECT_DOUBLE_EQ(normals[22](0), -0.5);
1547  EXPECT_DOUBLE_EQ(normals[22](1), sin60);
1548 
1549  EXPECT_DOUBLE_EQ(normals[23](0), -0.5);
1550  EXPECT_DOUBLE_EQ(normals[23](1), sin60);
1551 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST_F() [14/16]

TEST_F ( HexagonalLatticeTest  ,
normals3   
)

Definition at line 1553 of file HexagonalLatticeTest.C.

1554 {
1555  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1556  unsigned int nr = 3, a = 2;
1557  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1558  const auto & normals = hl.gapUnitNormals();
1559  Real sin60 = std::sqrt(3.0) / 2.0;
1560 
1561  for (const auto & n : normals)
1562  EXPECT_DOUBLE_EQ(n(2), 0.0);
1563 
1564  EXPECT_DOUBLE_EQ(normals[0](0), -sin60);
1565  EXPECT_DOUBLE_EQ(normals[0](1), 0.5);
1566 
1567  EXPECT_DOUBLE_EQ(normals[1](0), -sin60);
1568  EXPECT_DOUBLE_EQ(normals[1](1), -0.5);
1569 
1570  EXPECT_DOUBLE_EQ(normals[2](0), 0.0);
1571  EXPECT_DOUBLE_EQ(normals[2](1), -1.0);
1572 
1573  EXPECT_DOUBLE_EQ(normals[3](0), sin60);
1574  EXPECT_DOUBLE_EQ(normals[3](1), -0.5);
1575 
1576  EXPECT_DOUBLE_EQ(normals[4](0), sin60);
1577  EXPECT_DOUBLE_EQ(normals[4](1), 0.5);
1578 
1579  EXPECT_DOUBLE_EQ(normals[5](0), 0.0);
1580  EXPECT_DOUBLE_EQ(normals[5](1), 1.0);
1581 
1582  EXPECT_DOUBLE_EQ(normals[6](0), 0.0);
1583  EXPECT_DOUBLE_EQ(normals[6](1), -1.0);
1584 
1585  EXPECT_DOUBLE_EQ(normals[7](0), -sin60);
1586  EXPECT_DOUBLE_EQ(normals[7](1), -0.5);
1587 
1588  EXPECT_DOUBLE_EQ(normals[8](0), -sin60);
1589  EXPECT_DOUBLE_EQ(normals[8](1), 0.5);
1590 
1591  EXPECT_DOUBLE_EQ(normals[9](0), -sin60);
1592  EXPECT_DOUBLE_EQ(normals[9](1), -0.5);
1593 
1594  EXPECT_DOUBLE_EQ(normals[10](0), 0.0);
1595  EXPECT_DOUBLE_EQ(normals[10](1), 1.0);
1596 
1597  EXPECT_DOUBLE_EQ(normals[11](0), sin60);
1598  EXPECT_DOUBLE_EQ(normals[11](1), -0.5);
1599 
1600  EXPECT_DOUBLE_EQ(normals[12](0), -sin60);
1601  EXPECT_DOUBLE_EQ(normals[12](1), 0.5);
1602 
1603  EXPECT_DOUBLE_EQ(normals[13](0), -sin60);
1604  EXPECT_DOUBLE_EQ(normals[13](1), -0.5);
1605 
1606  EXPECT_DOUBLE_EQ(normals[14](0), 0.0);
1607  EXPECT_DOUBLE_EQ(normals[14](1), -1.0);
1608 
1609  EXPECT_DOUBLE_EQ(normals[15](0), sin60);
1610  EXPECT_DOUBLE_EQ(normals[15](1), 0.5);
1611 
1612  EXPECT_DOUBLE_EQ(normals[16](0), -sin60);
1613  EXPECT_DOUBLE_EQ(normals[16](1), -0.5);
1614 
1615  EXPECT_DOUBLE_EQ(normals[17](0), 0.0);
1616  EXPECT_DOUBLE_EQ(normals[17](1), -1.0);
1617 
1618  EXPECT_DOUBLE_EQ(normals[18](0), sin60);
1619  EXPECT_DOUBLE_EQ(normals[18](1), -0.5);
1620 
1621  EXPECT_DOUBLE_EQ(normals[19](0), 0.0);
1622  EXPECT_DOUBLE_EQ(normals[19](1), 1.0);
1623 
1624  EXPECT_DOUBLE_EQ(normals[20](0), 0.0);
1625  EXPECT_DOUBLE_EQ(normals[20](1), -1.0);
1626 
1627  EXPECT_DOUBLE_EQ(normals[21](0), sin60);
1628  EXPECT_DOUBLE_EQ(normals[21](1), -0.5);
1629 
1630  EXPECT_DOUBLE_EQ(normals[22](0), sin60);
1631  EXPECT_DOUBLE_EQ(normals[22](1), 0.5);
1632 
1633  EXPECT_DOUBLE_EQ(normals[23](0), -sin60);
1634  EXPECT_DOUBLE_EQ(normals[23](1), 0.5);
1635 
1636  EXPECT_DOUBLE_EQ(normals[24](0), sin60);
1637  EXPECT_DOUBLE_EQ(normals[24](1), -0.5);
1638 
1639  EXPECT_DOUBLE_EQ(normals[25](0), sin60);
1640  EXPECT_DOUBLE_EQ(normals[25](1), 0.5);
1641 
1642  EXPECT_DOUBLE_EQ(normals[26](0), 0.0);
1643  EXPECT_DOUBLE_EQ(normals[26](1), 1.0);
1644 
1645  EXPECT_DOUBLE_EQ(normals[27](0), sin60);
1646  EXPECT_DOUBLE_EQ(normals[27](1), 0.5);
1647 
1648  EXPECT_DOUBLE_EQ(normals[28](0), 0.0);
1649  EXPECT_DOUBLE_EQ(normals[28](1), 1.0);
1650 
1651  EXPECT_DOUBLE_EQ(normals[29](0), -sin60);
1652  EXPECT_DOUBLE_EQ(normals[29](1), 0.5);
1653 
1654  EXPECT_DOUBLE_EQ(normals[30](0), 0.0);
1655  EXPECT_DOUBLE_EQ(normals[30](1), -1.0);
1656 
1657  EXPECT_DOUBLE_EQ(normals[31](0), -sin60);
1658  EXPECT_DOUBLE_EQ(normals[31](1), -0.5);
1659 
1660  EXPECT_DOUBLE_EQ(normals[32](0), 0.0);
1661  EXPECT_DOUBLE_EQ(normals[32](1), -1.0);
1662 
1663  EXPECT_DOUBLE_EQ(normals[33](0), sin60);
1664  EXPECT_DOUBLE_EQ(normals[33](1), -0.5);
1665 
1666  EXPECT_DOUBLE_EQ(normals[34](0), sin60);
1667  EXPECT_DOUBLE_EQ(normals[34](1), -0.5);
1668 
1669  EXPECT_DOUBLE_EQ(normals[35](0), sin60);
1670  EXPECT_DOUBLE_EQ(normals[35](1), 0.5);
1671 
1672  EXPECT_DOUBLE_EQ(normals[36](0), sin60);
1673  EXPECT_DOUBLE_EQ(normals[36](1), 0.5);
1674 
1675  EXPECT_DOUBLE_EQ(normals[37](0), 0.0);
1676  EXPECT_DOUBLE_EQ(normals[37](1), 1.0);
1677 
1678  EXPECT_DOUBLE_EQ(normals[38](0), 0.0);
1679  EXPECT_DOUBLE_EQ(normals[38](1), 1.0);
1680 
1681  EXPECT_DOUBLE_EQ(normals[39](0), -sin60);
1682  EXPECT_DOUBLE_EQ(normals[39](1), 0.5);
1683 
1684  EXPECT_DOUBLE_EQ(normals[40](0), -sin60);
1685  EXPECT_DOUBLE_EQ(normals[40](1), 0.5);
1686 
1687  EXPECT_DOUBLE_EQ(normals[41](0), -sin60);
1688  EXPECT_DOUBLE_EQ(normals[41](1), -0.5);
1689 
1690  EXPECT_DOUBLE_EQ(normals[42](0), -1.0);
1691  EXPECT_DOUBLE_EQ(normals[42](1), 0.0);
1692 
1693  EXPECT_DOUBLE_EQ(normals[43](0), -1.0);
1694  EXPECT_DOUBLE_EQ(normals[43](1), 0.0);
1695 
1696  EXPECT_DOUBLE_EQ(normals[44](0), -1.0);
1697  EXPECT_DOUBLE_EQ(normals[44](1), 0.0);
1698 
1699  EXPECT_DOUBLE_EQ(normals[45](0), -0.5);
1700  EXPECT_DOUBLE_EQ(normals[45](1), -sin60);
1701 
1702  EXPECT_DOUBLE_EQ(normals[46](0), -0.5);
1703  EXPECT_DOUBLE_EQ(normals[46](1), -sin60);
1704 
1705  EXPECT_DOUBLE_EQ(normals[47](0), -0.5);
1706  EXPECT_DOUBLE_EQ(normals[47](1), -sin60);
1707 
1708  EXPECT_DOUBLE_EQ(normals[48](0), 0.5);
1709  EXPECT_DOUBLE_EQ(normals[48](1), -sin60);
1710 
1711  EXPECT_DOUBLE_EQ(normals[49](0), 0.5);
1712  EXPECT_DOUBLE_EQ(normals[49](1), -sin60);
1713 
1714  EXPECT_DOUBLE_EQ(normals[50](0), 0.5);
1715  EXPECT_DOUBLE_EQ(normals[50](1), -sin60);
1716 
1717  EXPECT_DOUBLE_EQ(normals[51](0), 1.0);
1718  EXPECT_DOUBLE_EQ(normals[51](1), 0.0);
1719 
1720  EXPECT_DOUBLE_EQ(normals[52](0), 1.0);
1721  EXPECT_DOUBLE_EQ(normals[52](1), 0.0);
1722 
1723  EXPECT_DOUBLE_EQ(normals[53](0), 1.0);
1724  EXPECT_DOUBLE_EQ(normals[53](1), 0.0);
1725 
1726  EXPECT_DOUBLE_EQ(normals[54](0), 0.5);
1727  EXPECT_DOUBLE_EQ(normals[54](1), sin60);
1728 
1729  EXPECT_DOUBLE_EQ(normals[55](0), 0.5);
1730  EXPECT_DOUBLE_EQ(normals[55](1), sin60);
1731 
1732  EXPECT_DOUBLE_EQ(normals[56](0), 0.5);
1733  EXPECT_DOUBLE_EQ(normals[56](1), sin60);
1734 
1735  EXPECT_DOUBLE_EQ(normals[57](0), -0.5);
1736  EXPECT_DOUBLE_EQ(normals[57](1), sin60);
1737 
1738  EXPECT_DOUBLE_EQ(normals[58](0), -0.5);
1739  EXPECT_DOUBLE_EQ(normals[58](1), sin60);
1740 
1741  EXPECT_DOUBLE_EQ(normals[59](0), -0.5);
1742  EXPECT_DOUBLE_EQ(normals[59](1), sin60);
1743 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ TEST_F() [15/16]

TEST_F ( HexagonalLatticeTest  ,
pin_corners   
)

Definition at line 1745 of file HexagonalLatticeTest.C.

1746 {
1747  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1748  unsigned int nr = 2, a = 2;
1749  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1750  const auto & pin_corners = hl.pinCenteredCornerCoordinates();
1751  Real sin60 = std::sqrt(3.0) / 2.0;
1752  Real cos60 = 0.5;
1753 
1754  // center pin
1755  double side = 0.46188021535170065;
1756  const auto & pin0 = pin_corners[0];
1757  EXPECT_DOUBLE_EQ(pin0[0](0), 0.0);
1758  EXPECT_DOUBLE_EQ(pin0[0](1), side);
1759 
1760  EXPECT_DOUBLE_EQ(pin0[1](0), -side * sin60);
1761  EXPECT_DOUBLE_EQ(pin0[1](1), side * cos60);
1762 
1763  EXPECT_DOUBLE_EQ(pin0[2](0), -side * sin60);
1764  EXPECT_DOUBLE_EQ(pin0[2](1), -side * cos60);
1765 
1766  EXPECT_DOUBLE_EQ(pin0[3](0), (unsigned int)0);
1767  EXPECT_DOUBLE_EQ(pin0[3](1), -side);
1768 
1769  EXPECT_DOUBLE_EQ(pin0[4](0), side * sin60);
1770  EXPECT_DOUBLE_EQ(pin0[4](1), -side * cos60);
1771 
1772  EXPECT_DOUBLE_EQ(pin0[5](0), side * sin60);
1773  EXPECT_DOUBLE_EQ(pin0[5](1), side * cos60);
1774 
1775  // second pin
1776  const auto & pin_centers = hl.pinCenters();
1777  const auto & pin1 = pin_corners[1];
1778  double x = pin_centers[1](0);
1779  double y = pin_centers[1](1);
1780 
1781  EXPECT_DOUBLE_EQ(pin1[0](0), x + 0.0);
1782  EXPECT_DOUBLE_EQ(pin1[0](1), y + side);
1783 
1784  EXPECT_DOUBLE_EQ(pin1[1](0), x + -side * sin60);
1785  EXPECT_DOUBLE_EQ(pin1[1](1), y + side * cos60);
1786 
1787  EXPECT_DOUBLE_EQ(pin1[2](0), x + -side * sin60);
1788  EXPECT_DOUBLE_EQ(pin1[2](1), y + -side * cos60);
1789 
1790  EXPECT_DOUBLE_EQ(pin1[3](0), x + 0);
1791  EXPECT_DOUBLE_EQ(pin1[3](1), y + -side);
1792 
1793  EXPECT_DOUBLE_EQ(pin1[4](0), x + side * sin60);
1794  EXPECT_DOUBLE_EQ(pin1[4](1), y + -side * cos60);
1795 
1796  EXPECT_DOUBLE_EQ(pin1[5](0), x + side * sin60);
1797  EXPECT_DOUBLE_EQ(pin1[5](1), y + side * cos60);
1798 
1799  // check for bin indexing
1800  Point p(0.07, 0.195, 0.0);
1801  EXPECT_EQ(hl.pinIndex(p), (unsigned int)0);
1802 
1803  p = {0.02, 0.42, 0.0};
1804  EXPECT_EQ(hl.pinIndex(p), (unsigned int)0);
1805 
1806  p = {0.74, 0.46, 0.0};
1807  EXPECT_EQ(hl.pinIndex(p), (unsigned int)1);
1808 
1809  p = {-0.206, 0.668, 0.0};
1810  EXPECT_EQ(hl.pinIndex(p), (unsigned int)2);
1811 
1812  p = {-0.99, 0.313, 0.0};
1813  EXPECT_EQ(hl.pinIndex(p), (unsigned int)3);
1814 
1815  p = {-0.257, -0.67, 0.0};
1816  EXPECT_EQ(hl.pinIndex(p), (unsigned int)4);
1817 
1818  p = {0.67, -0.79, 0.0};
1819  EXPECT_EQ(hl.pinIndex(p), (unsigned int)5);
1820 
1821  p = {0.43, 0.0206, 0.0};
1822  EXPECT_EQ(hl.pinIndex(p), (unsigned int)6);
1823 
1824  p = {0.85, 0.51, 0.0};
1825  EXPECT_EQ(hl.pinIndex(p), (unsigned int)7);
1826 }
y
const std::vector< double > y
Definition: EquilibriumConstantFitTest.C:18
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
x
const std::vector< double > x
Definition: EquilibriumConstantFitTest.C:17
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
int
void ErrorVector unsigned int

◆ TEST_F() [16/16]

TEST_F ( HexagonalLatticeTest  ,
constructor   
)

Definition at line 1828 of file HexagonalLatticeTest.C.

1829 {
1830  Real bp = 4.0, pp = 0.8, pd = 0.6, wd = 0.05, wp = 50.0;
1831  unsigned int nr = 3, a = 2;
1832  HexagonalLatticeUtils hl(bp, pp, pd, wd, wp, nr, a);
1833  EXPECT_DOUBLE_EQ(hl.bundlePitch(), 4.0);
1834  EXPECT_DOUBLE_EQ(hl.pinPitch(), 0.8);
1835  EXPECT_DOUBLE_EQ(hl.pinDiameter(), 0.6);
1836  EXPECT_DOUBLE_EQ(hl.pinRadius(), 0.3);
1837  EXPECT_DOUBLE_EQ(hl.wireDiameter(), 0.05);
1838  EXPECT_DOUBLE_EQ(hl.wirePitch(), 50.0);
1839 }
HexagonalLatticeUtils
Class providing various utility functions related to triangular lattices of pins enclosed in a hexago...
Definition: HexagonalLatticeUtils.h:38
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Generated on Fri Jul 18 2025 13:44:09 for https://mooseframework.inl.gov by   doxygen 1.8.14