Skip to content

GitLab

Commit 71d59925 authored by Rossen Apostolov's avatar Rossen Apostolov
Browse files

Comparison of the forces in the Ewald/PME reference tests is disabled by... 

Comparison of the forces in the Ewald/PME reference tests is disabled by default. If set, they are compared to the double precision output from Gromacs.
parent ffab317b
Hide whitespace changes
Inline Side-by-side
Showing with 1795 additions and 1796 deletions
platforms/reference/tests/TestReferenceEwald.cpp
View file @ 71d59925
...@@ -95,6 +95,8 @@ void testEwaldExact() { ...@@ -95,6 +95,8 @@ void testEwaldExact() {
// E is then the energy per pair of ions, so for our case // E is then the energy per pair of ions, so for our case
// E has to be divided by 2 (per ion), multiplied by N(avogadro), multiplied by number of particles, and divided by 1000 for kJ // E has to be divided by 2 (per ion), multiplied by N(avogadro), multiplied by number of particles, and divided by 1000 for kJ
double exactEnergy = - (1.7476 * 1.6022e-19 * 1.6022e-19 * 6.02214e+23 * numParticles) / (1.112e-10 * 0.282e-9 * 2 * 1000); double exactEnergy = - (1.7476 * 1.6022e-19 * 1.6022e-19 * 6.02214e+23 * numParticles) / (1.112e-10 * 0.282e-9 * 2 * 1000);
//cout << "exact\t\t: " << exactEnergy << endl;
//cout << "calc\t\t: " << state.getPotentialEnergy() << endl;
ASSERT_EQUAL_TOL(exactEnergy, state.getPotentialEnergy(), 100*TOL); ASSERT_EQUAL_TOL(exactEnergy, state.getPotentialEnergy(), 100*TOL);
} }
...@@ -140,9 +142,10 @@ void testEwaldPME() { ...@@ -140,9 +142,10 @@ void testEwaldPME() {
ASSERT_EQUAL_TOL(-3.82047e+05, state1.getPotentialEnergy(), tol); ASSERT_EQUAL_TOL(-3.82047e+05, state1.getPotentialEnergy(), tol);
// (2) CHECK WHETHER THE EWALD FORCES ARE THE SAME AS THE GROMACS OUTPUT // (2) CHECK WHETHER THE EWALD FORCES ARE THE SAME AS THE GROMACS OUTPUT
// these are forces for alpha: 2.82756, kmax(x/y/z) = 11
tol = 1e-1; tol = 1e-2;
#include "nacl_amorph_GromacsForcesEwald.dat" // #include "nacl_amorph_GromacsForcesEwald.dat"
// (3) CHECK SELF-CONSISTENCY // (3) CHECK SELF-CONSISTENCY
...@@ -183,14 +186,10 @@ void testEwaldPME() { ...@@ -183,14 +186,10 @@ void testEwaldPME() {
tol = 1e-5; tol = 1e-5;
ASSERT_EQUAL_TOL(-3.82047e+05, state3.getPotentialEnergy(), tol); ASSERT_EQUAL_TOL(-3.82047e+05, state3.getPotentialEnergy(), tol);
// Gromacs Ewald energy // (5) CHECK WHETHER PME FORCES ARE THE SAME AS THE GROMACS OUTPUT USING EWALD
tol = 1e-5;
ASSERT_EQUAL_TOL(-3.82047e+05, state3.getPotentialEnergy(), tol);
// (5) CHECK WHETHER PME FORCES ARE THE SAME AS THE GROMACS OUTPUT
tol = 1e-1; tol = 1e-1;
#include "nacl_amorph_GromacsForcesPME.dat" // #include "nacl_amorph_GromacsForcesEwald.dat"
// (6) CHECK PME FOR SELF-CONSISTENCY // (6) CHECK PME FOR SELF-CONSISTENCY
......
platforms/reference/tests/nacl_amorph_GromacsForcesEwald.dat
View file @ 71d59925
ASSERT_EQUAL_VEC(Vec3(-1.98238e+02, -2.23826e+02, -1.02560e+02), forces1[0], tol); ASSERT_EQUAL_VEC(Vec3(-1.98249623e+02, -2.23814501e+02, -1.02563796e+02), forces1[0], tol);
ASSERT_EQUAL_VEC(Vec3( 4.44029e+02, -3.90396e+02, -8.09536e+01), forces1[1], tol); ASSERT_EQUAL_VEC(Vec3( 4.44017199e+02, -3.90390764e+02, -8.09518867e+01), forces1[1], tol);
ASSERT_EQUAL_VEC(Vec3(-8.60684e+01, -1.05676e+01, -1.87791e+02), forces1[2], tol); ASSERT_EQUAL_VEC(Vec3(-8.60789585e+01, -1.05598857e+01, -1.87798624e+02), forces1[2], tol);
ASSERT_EQUAL_VEC(Vec3( 7.05369e+02, -1.69571e+02, 2.72461e+02), forces1[3], tol); ASSERT_EQUAL_VEC(Vec3( 7.05363534e+02, -1.69549058e+02, 2.72466252e+02), forces1[3], tol);
ASSERT_EQUAL_VEC(Vec3(-2.19210e+01, 5.33286e+02, -4.56232e+01), forces1[4], tol); ASSERT_EQUAL_VEC(Vec3(-2.19333527e+01, 5.33284079e+02, -4.56197740e+01), forces1[4], tol);
ASSERT_EQUAL_VEC(Vec3(-3.04283e+02, 2.02937e+02, 1.20259e+02), forces1[5], tol); ASSERT_EQUAL_VEC(Vec3(-3.04281837e+02, 2.02941152e+02, 1.20252918e+02), forces1[5], tol);
ASSERT_EQUAL_VEC(Vec3( 1.14199e+02, 1.21088e+02, 3.40918e+02), forces1[6], tol); ASSERT_EQUAL_VEC(Vec3( 1.14210928e+02, 1.21079746e+02, 3.40929279e+02), forces1[6], tol);
ASSERT_EQUAL_VEC(Vec3(-4.02327e+01, 3.78741e+02, 1.07278e+02), forces1[7], tol); ASSERT_EQUAL_VEC(Vec3(-4.02295448e+01, 3.78740176e+02, 1.07262493e+02), forces1[7], tol);
ASSERT_EQUAL_VEC(Vec3( 9.42847e+01, 1.00794e+01, 1.57727e+02), forces1[8], tol); ASSERT_EQUAL_VEC(Vec3( 9.42807014e+01, 1.00891659e+01, 1.57729175e+02), forces1[8], tol);
ASSERT_EQUAL_VEC(Vec3( 2.98429e+02, 1.18607e+02, -4.17515e+02), forces1[9], tol); ASSERT_EQUAL_VEC(Vec3( 2.98424830e+02, 1.18614285e+02, -4.17503362e+02), forces1[9], tol);
ASSERT_EQUAL_VEC(Vec3( 4.74919e+01, -5.56396e+00, -1.92327e+02), forces1[10], tol); ASSERT_EQUAL_VEC(Vec3( 4.74881296e+01, -5.56206792e+00, -1.92332367e+02), forces1[10], tol);
ASSERT_EQUAL_VEC(Vec3(-3.61199e+02, 4.00196e+02, -3.38477e+02), forces1[11], tol); ASSERT_EQUAL_VEC(Vec3(-3.61201909e+02, 4.00192313e+02, -3.38469181e+02), forces1[11], tol);
ASSERT_EQUAL_VEC(Vec3( 1.59854e+02, -2.22196e+02, -1.71809e+02), forces1[12], tol); ASSERT_EQUAL_VEC(Vec3( 1.59855287e+02, -2.22184057e+02, -1.71814608e+02), forces1[12], tol);
ASSERT_EQUAL_VEC(Vec3( 8.02062e+01, -2.46177e+02, 1.49722e+02), forces1[13], tol); ASSERT_EQUAL_VEC(Vec3( 8.02099562e+01, -2.46176977e+02, 1.49725960e+02), forces1[13], tol);
ASSERT_EQUAL_VEC(Vec3(-2.41481e+02, -8.22165e+01, -4.19806e+02), forces1[14], tol); ASSERT_EQUAL_VEC(Vec3(-2.41478578e+02, -8.22327152e+01, -4.19802587e+02), forces1[14], tol);
ASSERT_EQUAL_VEC(Vec3(-2.42755e+02, 4.98601e+00, 1.89523e+01), forces1[15], tol); ASSERT_EQUAL_VEC(Vec3(-2.42767767e+02, 4.99651070e+00, 1.89314504e+01), forces1[15], tol);
ASSERT_EQUAL_VEC(Vec3(-2.32050e+02, 2.91140e+02, -1.56123e+02), forces1[16], tol); ASSERT_EQUAL_VEC(Vec3(-2.32048202e+02, 2.91141605e+02, -1.56147406e+02), forces1[16], tol);
ASSERT_EQUAL_VEC(Vec3(-8.77575e+01, -4.75580e+02, -2.02746e+02), forces1[17], tol); ASSERT_EQUAL_VEC(Vec3(-8.77435572e+01, -4.75580602e+02, -2.02736231e+02), forces1[17], tol);
ASSERT_EQUAL_VEC(Vec3( 3.96112e+02, -6.37136e+02, 1.78643e+02), forces1[18], tol); ASSERT_EQUAL_VEC(Vec3( 3.96101687e+02, -6.37149049e+02, 1.78647561e+02), forces1[18], tol);
ASSERT_EQUAL_VEC(Vec3( 3.72233e+02, 1.17770e+02, 2.14245e+02), forces1[19], tol); ASSERT_EQUAL_VEC(Vec3( 3.72219707e+02, 1.17763530e+02, 2.14244129e+02), forces1[19], tol);
ASSERT_EQUAL_VEC(Vec3( 4.50048e+02, -1.37506e+01, 2.39947e+02), forces1[20], tol); ASSERT_EQUAL_VEC(Vec3( 4.50062822e+02, -1.37575208e+01, 2.39948230e+02), forces1[20], tol);
ASSERT_EQUAL_VEC(Vec3( 2.00019e+02, 3.29950e+01, 8.51563e+01), forces1[21], tol); ASSERT_EQUAL_VEC(Vec3( 2.00029587e+02, 3.30130171e+01, 8.51610501e+01), forces1[21], tol);
ASSERT_EQUAL_VEC(Vec3( 1.97191e+02, 7.33297e+02, 2.15350e+01), forces1[22], tol); ASSERT_EQUAL_VEC(Vec3( 1.97192878e+02, 7.33293743e+02, 2.15221280e+01), forces1[22], tol);
ASSERT_EQUAL_VEC(Vec3(-1.44369e+02, 9.15772e+01, 3.18788e+01), forces1[23], tol); ASSERT_EQUAL_VEC(Vec3(-1.44377368e+02, 9.15716307e+01, 3.18892747e+01), forces1[23], tol);
ASSERT_EQUAL_VEC(Vec3( 2.94558e+02, -3.69032e+02, 2.69457e+00), forces1[24], tol); ASSERT_EQUAL_VEC(Vec3( 2.94552317e+02, -3.69040394e+02, 2.70288945e+00), forces1[24], tol);
ASSERT_EQUAL_VEC(Vec3( 3.23113e+02, 8.86106e+02, 3.24449e+02), forces1[25], tol); ASSERT_EQUAL_VEC(Vec3( 3.23120142e+02, 8.86114454e+02, 3.24450894e+02), forces1[25], tol);
ASSERT_EQUAL_VEC(Vec3(-6.03226e+01, 1.68456e+02, 2.31883e+02), forces1[26], tol); ASSERT_EQUAL_VEC(Vec3(-6.03295072e+01, 1.68456989e+02, 2.31869997e+02), forces1[26], tol);
ASSERT_EQUAL_VEC(Vec3( 2.93016e+01, 5.76354e+01, 3.64002e+02), forces1[27], tol); ASSERT_EQUAL_VEC(Vec3( 2.93194241e+01, 5.76413549e+01, 3.64010103e+02), forces1[27], tol);
ASSERT_EQUAL_VEC(Vec3( 3.23677e-01, 1.34470e+02, -4.39858e+01), forces1[28], tol); ASSERT_EQUAL_VEC(Vec3( 3.27452172e-01, 1.34469263e+02, -4.39755475e+01), forces1[28], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38722e+02, -2.99577e+02, -2.80334e+02), forces1[29], tol); ASSERT_EQUAL_VEC(Vec3(-1.38717677e+02, -2.99570604e+02, -2.80339165e+02), forces1[29], tol);
ASSERT_EQUAL_VEC(Vec3(-8.27799e+01, 4.40599e+02, 9.65403e+01), forces1[30], tol); ASSERT_EQUAL_VEC(Vec3(-8.27937873e+01, 4.40618490e+02, 9.65587062e+01), forces1[30], tol);
ASSERT_EQUAL_VEC(Vec3( 2.03931e+01, -4.37708e+01, -5.06934e+01), forces1[31], tol); ASSERT_EQUAL_VEC(Vec3( 2.03855205e+01, -4.37745725e+01, -5.06881413e+01), forces1[31], tol);
ASSERT_EQUAL_VEC(Vec3(-2.60758e+02, 3.70683e+02, 1.28610e+02), forces1[32], tol); ASSERT_EQUAL_VEC(Vec3(-2.60745980e+02, 3.70683505e+02, 1.28613276e+02), forces1[32], tol);
ASSERT_EQUAL_VEC(Vec3( 1.97956e+02, -1.51876e+01, -2.85740e+02), forces1[33], tol); ASSERT_EQUAL_VEC(Vec3( 1.97960989e+02, -1.51970994e+01, -2.85732029e+02), forces1[33], tol);
ASSERT_EQUAL_VEC(Vec3(-2.63680e+01, -1.29278e+01, -2.36628e+02), forces1[34], tol); ASSERT_EQUAL_VEC(Vec3(-2.63675933e+01, -1.29448310e+01, -2.36632787e+02), forces1[34], tol);
ASSERT_EQUAL_VEC(Vec3( 2.13617e+02, -2.29643e+02, -7.72855e+02), forces1[35], tol); ASSERT_EQUAL_VEC(Vec3( 2.13614470e+02, -2.29632590e+02, -7.72843645e+02), forces1[35], tol);
ASSERT_EQUAL_VEC(Vec3(-4.26090e+01, 9.00661e+01, 3.48807e+02), forces1[36], tol); ASSERT_EQUAL_VEC(Vec3(-4.26287747e+01, 9.00718113e+01, 3.48807737e+02), forces1[36], tol);
ASSERT_EQUAL_VEC(Vec3(-2.27777e+02, -8.46722e+00, -3.25577e+02), forces1[37], tol); ASSERT_EQUAL_VEC(Vec3(-2.27779547e+02, -8.46450565e+00, -3.25578367e+02), forces1[37], tol);
ASSERT_EQUAL_VEC(Vec3(-8.32081e+01, -2.50973e+02, 5.80059e+01), forces1[38], tol); ASSERT_EQUAL_VEC(Vec3(-8.32052751e+01, -2.50968185e+02, 5.80103845e+01), forces1[38], tol);
ASSERT_EQUAL_VEC(Vec3(-2.32231e+02, 1.30483e+02, 6.07258e+00), forces1[39], tol); ASSERT_EQUAL_VEC(Vec3(-2.32232234e+02, 1.30470270e+02, 6.06495521e+00), forces1[39], tol);
ASSERT_EQUAL_VEC(Vec3(-1.14457e+02, -3.48574e+01, -8.76071e+01), forces1[40], tol); ASSERT_EQUAL_VEC(Vec3(-1.14455494e+02, -3.48721419e+01, -8.76129455e+01), forces1[40], tol);
ASSERT_EQUAL_VEC(Vec3(-2.55344e+02, -2.79208e+02, -1.68797e+02), forces1[41], tol); ASSERT_EQUAL_VEC(Vec3(-2.55340689e+02, -2.79204188e+02, -1.68792912e+02), forces1[41], tol);
ASSERT_EQUAL_VEC(Vec3(-2.02302e+02, 1.47893e+02, 1.75221e+02), forces1[42], tol); ASSERT_EQUAL_VEC(Vec3(-2.02307452e+02, 1.47895858e+02, 1.75220456e+02), forces1[42], tol);
ASSERT_EQUAL_VEC(Vec3( 2.63351e+01, -4.46957e+02, -2.40048e+00), forces1[43], tol); ASSERT_EQUAL_VEC(Vec3( 2.63185604e+01, -4.46985150e+02, -2.38821173e+00), forces1[43], tol);
ASSERT_EQUAL_VEC(Vec3( 2.55954e+02, -2.93459e+02, 3.28008e+02), forces1[44], tol); ASSERT_EQUAL_VEC(Vec3( 2.55944000e+02, -2.93439747e+02, 3.28025974e+02), forces1[44], tol);
ASSERT_EQUAL_VEC(Vec3( 1.14316e+02, 2.24372e+02, -8.29855e+01), forces1[45], tol); ASSERT_EQUAL_VEC(Vec3( 1.14311082e+02, 2.24380865e+02, -8.29696179e+01), forces1[45], tol);
ASSERT_EQUAL_VEC(Vec3( 1.43330e+01, 2.46503e+02, -3.75151e+02), forces1[46], tol); ASSERT_EQUAL_VEC(Vec3( 1.43326861e+01, 2.46491923e+02, -3.75165407e+02), forces1[46], tol);
ASSERT_EQUAL_VEC(Vec3(-4.34808e+02, -9.73246e+01, -1.91092e+02), forces1[47], tol); ASSERT_EQUAL_VEC(Vec3(-4.34792273e+02, -9.73250775e+01, -1.91085096e+02), forces1[47], tol);
ASSERT_EQUAL_VEC(Vec3( 5.23081e+01, 5.50972e+02, 2.90236e+02), forces1[48], tol); ASSERT_EQUAL_VEC(Vec3( 5.23123306e+01, 5.50975366e+02, 2.90221875e+02), forces1[48], tol);
ASSERT_EQUAL_VEC(Vec3(-4.83844e+01, 1.71478e+02, -3.42277e+02), forces1[49], tol); ASSERT_EQUAL_VEC(Vec3(-4.83894734e+01, 1.71476996e+02, -3.42294535e+02), forces1[49], tol);
ASSERT_EQUAL_VEC(Vec3(-2.61478e+02, 9.01841e+01, 3.64119e+02), forces1[50], tol); ASSERT_EQUAL_VEC(Vec3(-2.61463419e+02, 9.01733107e+01, 3.64114372e+02), forces1[50], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43612e+02, -5.19322e+02, -7.74784e+01), forces1[51], tol); ASSERT_EQUAL_VEC(Vec3( 4.43625180e+02, -5.19324924e+02, -7.74662441e+01), forces1[51], tol);
ASSERT_EQUAL_VEC(Vec3( 2.15593e+02, -5.54583e+02, 1.71379e+02), forces1[52], tol); ASSERT_EQUAL_VEC(Vec3( 2.15611073e+02, -5.54577351e+02, 1.71371860e+02), forces1[52], tol);
ASSERT_EQUAL_VEC(Vec3(-2.14776e+02, 3.56698e+02, -3.71992e+02), forces1[53], tol); ASSERT_EQUAL_VEC(Vec3(-2.14763168e+02, 3.56711285e+02, -3.71984643e+02), forces1[53], tol);
ASSERT_EQUAL_VEC(Vec3( 2.22133e+02, 2.73235e+02, 1.61938e+02), forces1[54], tol); ASSERT_EQUAL_VEC(Vec3( 2.22124509e+02, 2.73223318e+02, 1.61942563e+02), forces1[54], tol);
ASSERT_EQUAL_VEC(Vec3( 2.85125e+02, 3.19148e+02, -1.98760e+02), forces1[55], tol); ASSERT_EQUAL_VEC(Vec3( 2.85121911e+02, 3.19143598e+02, -1.98763562e+02), forces1[55], tol);
ASSERT_EQUAL_VEC(Vec3( 3.90028e+02, 5.91182e+02, 8.76317e+01), forces1[56], tol); ASSERT_EQUAL_VEC(Vec3( 3.90039513e+02, 5.91179187e+02, 8.76217046e+01), forces1[56], tol);
ASSERT_EQUAL_VEC(Vec3( 1.69075e+02, -9.43172e+01, 3.42177e+02), forces1[57], tol); ASSERT_EQUAL_VEC(Vec3( 1.69060954e+02, -9.43142940e+01, 3.42180838e+02), forces1[57], tol);
ASSERT_EQUAL_VEC(Vec3( 2.93043e+01, -1.03070e+02, 5.37924e+01), forces1[58], tol); ASSERT_EQUAL_VEC(Vec3( 2.93242309e+01, -1.03060738e+02, 5.38025654e+01), forces1[58], tol);
ASSERT_EQUAL_VEC(Vec3( 4.08886e+01, 1.30036e+02, -7.16372e+01), forces1[59], tol); ASSERT_EQUAL_VEC(Vec3( 4.09077298e+01, 1.30026064e+02, -7.16489622e+01), forces1[59], tol);
ASSERT_EQUAL_VEC(Vec3(-1.89922e+02, 5.51830e+00, 4.53571e+02), forces1[60], tol); ASSERT_EQUAL_VEC(Vec3(-1.89926185e+02, 5.52058739e+00, 4.53549674e+02), forces1[60], tol);
ASSERT_EQUAL_VEC(Vec3(-1.11580e+02, 1.24181e+02, 4.53024e+02), forces1[61], tol); ASSERT_EQUAL_VEC(Vec3(-1.11572641e+02, 1.24178624e+02, 4.53016222e+02), forces1[61], tol);
ASSERT_EQUAL_VEC(Vec3( 1.54592e+02, -2.70156e+02, -7.89564e+01), forces1[62], tol); ASSERT_EQUAL_VEC(Vec3( 1.54599730e+02, -2.70150115e+02, -7.89492689e+01), forces1[62], tol);
ASSERT_EQUAL_VEC(Vec3( 2.84007e+02, -8.90015e+01, 3.24519e+02), forces1[63], tol); ASSERT_EQUAL_VEC(Vec3( 2.84023026e+02, -8.89934391e+01, 3.24522873e+02), forces1[63], tol);
ASSERT_EQUAL_VEC(Vec3( 1.44368e+02, -7.96551e+01, -2.53257e+02), forces1[64], tol); ASSERT_EQUAL_VEC(Vec3( 1.44364280e+02, -7.96613821e+01, -2.53253756e+02), forces1[64], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77725e+02, 8.43053e+01, -1.41074e+02), forces1[65], tol); ASSERT_EQUAL_VEC(Vec3(-1.77719009e+02, 8.42958696e+01, -1.41078307e+02), forces1[65], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69671e+02, -5.26514e+02, -1.04062e+02), forces1[66], tol); ASSERT_EQUAL_VEC(Vec3(-2.69676443e+02, -5.26499439e+02, -1.04061540e+02), forces1[66], tol);
ASSERT_EQUAL_VEC(Vec3(-2.41580e+02, -9.41361e+01, 3.30396e+01), forces1[67], tol); ASSERT_EQUAL_VEC(Vec3(-2.41597419e+02, -9.41368613e+01, 3.30311173e+01), forces1[67], tol);
ASSERT_EQUAL_VEC(Vec3( 6.81038e+02, -5.79233e+02, -9.64813e-01), forces1[68], tol); ASSERT_EQUAL_VEC(Vec3( 6.81038324e+02, -5.79215726e+02, -9.61706079e-01), forces1[68], tol);
ASSERT_EQUAL_VEC(Vec3( 2.88753e+02, 2.41554e+02, -1.90670e+02), forces1[69], tol); ASSERT_EQUAL_VEC(Vec3( 2.88768459e+02, 2.41571264e+02, -1.90674774e+02), forces1[69], tol);
ASSERT_EQUAL_VEC(Vec3(-1.31489e+01, 1.14240e+01, 4.13780e+01), forces1[70], tol); ASSERT_EQUAL_VEC(Vec3(-1.31534697e+01, 1.14188032e+01, 4.13763857e+01), forces1[70], tol);
ASSERT_EQUAL_VEC(Vec3( 5.14235e+01, -9.72088e+01, 1.27355e+01), forces1[71], tol); ASSERT_EQUAL_VEC(Vec3( 5.14246004e+01, -9.72308438e+01, 1.27291275e+01), forces1[71], tol);
ASSERT_EQUAL_VEC(Vec3( 7.15805e+01, -1.94128e+02, -2.48983e+02), forces1[72], tol); ASSERT_EQUAL_VEC(Vec3( 7.15804377e+01, -1.94144101e+02, -2.48994830e+02), forces1[72], tol);
ASSERT_EQUAL_VEC(Vec3(-9.16927e+01, 1.23379e+02, -2.86170e+02), forces1[73], tol); ASSERT_EQUAL_VEC(Vec3(-9.16897832e+01, 1.23379998e+02, -2.86172337e+02), forces1[73], tol);
ASSERT_EQUAL_VEC(Vec3( 9.82572e+01, -7.06987e+01, -1.29193e+02), forces1[74], tol); ASSERT_EQUAL_VEC(Vec3( 9.82636682e+01, -7.07069901e+01, -1.29205135e+02), forces1[74], tol);
ASSERT_EQUAL_VEC(Vec3(-2.15563e+02, -1.43107e+02, -1.96441e+02), forces1[75], tol); ASSERT_EQUAL_VEC(Vec3(-2.15565256e+02, -1.43101075e+02, -1.96437192e+02), forces1[75], tol);
ASSERT_EQUAL_VEC(Vec3(-4.61170e+02, -4.03111e+02, -4.55975e+01), forces1[76], tol); ASSERT_EQUAL_VEC(Vec3(-4.61171340e+02, -4.03099962e+02, -4.56004212e+01), forces1[76], tol);
ASSERT_EQUAL_VEC(Vec3( 1.52891e+02, -9.37788e+02, 2.93602e+02), forces1[77], tol); ASSERT_EQUAL_VEC(Vec3( 1.52879441e+02, -9.37786956e+02, 2.93596349e+02), forces1[77], tol);
ASSERT_EQUAL_VEC(Vec3( 2.45711e+02, 1.99735e+01, 1.17932e+02), forces1[78], tol); ASSERT_EQUAL_VEC(Vec3( 2.45712108e+02, 1.99809051e+01, 1.17930077e+02), forces1[78], tol);
ASSERT_EQUAL_VEC(Vec3(-2.37051e+02, 2.49489e+02, 2.13433e+02), forces1[79], tol); ASSERT_EQUAL_VEC(Vec3(-2.37060951e+02, 2.49499642e+02, 2.13427566e+02), forces1[79], tol);
ASSERT_EQUAL_VEC(Vec3(-2.90555e+02, 1.91164e+02, -4.24253e+02), forces1[80], tol); ASSERT_EQUAL_VEC(Vec3(-2.90549561e+02, 1.91148461e+02, -4.24254939e+02), forces1[80], tol);
ASSERT_EQUAL_VEC(Vec3( 2.98827e+02, -5.77280e+00, 2.66614e+02), forces1[81], tol); ASSERT_EQUAL_VEC(Vec3( 2.98836434e+02, -5.77088507e+00, 2.66616885e+02), forces1[81], tol);
ASSERT_EQUAL_VEC(Vec3(-3.26794e+02, -2.54754e+02, -3.00071e+02), forces1[82], tol); ASSERT_EQUAL_VEC(Vec3(-3.26780820e+02, -2.54755214e+02, -3.00078477e+02), forces1[82], tol);
ASSERT_EQUAL_VEC(Vec3(-2.95126e+02, 1.21760e+02, -2.83497e+02), forces1[83], tol); ASSERT_EQUAL_VEC(Vec3(-2.95124543e+02, 1.21754917e+02, -2.83484560e+02), forces1[83], tol);
ASSERT_EQUAL_VEC(Vec3( 4.04609e+02, 1.66799e+02, -5.58326e+01), forces1[84], tol); ASSERT_EQUAL_VEC(Vec3( 4.04593126e+02, 1.66803214e+02, -5.58277653e+01), forces1[84], tol);
ASSERT_EQUAL_VEC(Vec3(-8.21643e+02, 5.19896e+02, 5.31921e+01), forces1[85], tol); ASSERT_EQUAL_VEC(Vec3(-8.21659385e+02, 5.19877016e+02, 5.32042741e+01), forces1[85], tol);
ASSERT_EQUAL_VEC(Vec3(-3.49435e+02, -1.47693e+02, -4.95517e+02), forces1[86], tol); ASSERT_EQUAL_VEC(Vec3(-3.49440439e+02, -1.47667513e+02, -4.95516065e+02), forces1[86], tol);
ASSERT_EQUAL_VEC(Vec3(-4.48875e+02, -7.41436e+01, -4.28609e+02), forces1[87], tol); ASSERT_EQUAL_VEC(Vec3(-4.48873387e+02, -7.41398759e+01, -4.28615258e+02), forces1[87], tol);
ASSERT_EQUAL_VEC(Vec3(-1.97043e+02, -3.40600e+02, 2.11406e+00), forces1[88], tol); ASSERT_EQUAL_VEC(Vec3(-1.97035390e+02, -3.40619723e+02, 2.10014966e+00), forces1[88], tol);
ASSERT_EQUAL_VEC(Vec3( 9.52512e+01, -4.20805e+02, 5.76727e+01), forces1[89], tol); ASSERT_EQUAL_VEC(Vec3( 9.52521998e+01, -4.20785075e+02, 5.76686444e+01), forces1[89], tol);
ASSERT_EQUAL_VEC(Vec3( 1.21828e+02, -1.40431e+02, -2.93296e+02), forces1[90], tol); ASSERT_EQUAL_VEC(Vec3( 1.21817965e+02, -1.40423441e+02, -2.93286277e+02), forces1[90], tol);
ASSERT_EQUAL_VEC(Vec3( 2.10621e+02, 5.87844e+01, 7.23545e+01), forces1[91], tol); ASSERT_EQUAL_VEC(Vec3( 2.10624944e+02, 5.87898789e+01, 7.23535437e+01), forces1[91], tol);
ASSERT_EQUAL_VEC(Vec3( 6.72634e+01, -1.46947e+02, -2.63726e+02), forces1[92], tol); ASSERT_EQUAL_VEC(Vec3( 6.72728656e+01, -1.46951701e+02, -2.63713434e+02), forces1[92], tol);
ASSERT_EQUAL_VEC(Vec3( 3.96775e+02, -4.38656e+02, -2.57927e+02), forces1[93], tol); ASSERT_EQUAL_VEC(Vec3( 3.96770378e+02, -4.38652663e+02, -2.57914104e+02), forces1[93], tol);
ASSERT_EQUAL_VEC(Vec3(-2.66028e+01, 1.59130e+01, 4.36642e+02), forces1[94], tol); ASSERT_EQUAL_VEC(Vec3(-2.66188937e+01, 1.59124875e+01, 4.36635801e+02), forces1[94], tol);
ASSERT_EQUAL_VEC(Vec3(-2.99995e+02, -6.20726e+01, -4.29149e+02), forces1[95], tol); ASSERT_EQUAL_VEC(Vec3(-3.00011356e+02, -6.20659688e+01, -4.29149613e+02), forces1[95], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77072e+02, 5.58920e+01, 1.05671e+02), forces1[96], tol); ASSERT_EQUAL_VEC(Vec3(-1.77048319e+02, 5.58928761e+01, 1.05662322e+02), forces1[96], tol);
ASSERT_EQUAL_VEC(Vec3(-6.92539e+01, -5.45426e+02, -2.11030e+01), forces1[97], tol); ASSERT_EQUAL_VEC(Vec3(-6.92523247e+01, -5.45436653e+02, -2.10975756e+01), forces1[97], tol);
ASSERT_EQUAL_VEC(Vec3(-3.90151e+01, -1.21139e+02, 1.68337e+01), forces1[98], tol); ASSERT_EQUAL_VEC(Vec3(-3.90136268e+01, -1.21131977e+02, 1.68383284e+01), forces1[98], tol);
ASSERT_EQUAL_VEC(Vec3(-2.19672e+01, 1.51712e+02, -3.39114e+01), forces1[99], tol); ASSERT_EQUAL_VEC(Vec3(-2.19709988e+01, 1.51713780e+02, -3.39192065e+01), forces1[99], tol);
ASSERT_EQUAL_VEC(Vec3( 9.20622e+01, -4.22576e+02, -1.80963e+01), forces1[100], tol); ASSERT_EQUAL_VEC(Vec3( 9.20577922e+01, -4.22560191e+02, -1.80919327e+01), forces1[100], tol);
ASSERT_EQUAL_VEC(Vec3( 5.80549e+01, 1.45405e+02, -4.53162e+01), forces1[101], tol); ASSERT_EQUAL_VEC(Vec3( 5.80665653e+01, 1.45405257e+02, -4.53162940e+01), forces1[101], tol);
ASSERT_EQUAL_VEC(Vec3( 6.12572e+02, -1.41193e+01, 2.13573e+02), forces1[102], tol); ASSERT_EQUAL_VEC(Vec3( 6.12566193e+02, -1.41221826e+01, 2.13579029e+02), forces1[102], tol);
ASSERT_EQUAL_VEC(Vec3(-1.02944e+02, -8.76375e+01, 2.20902e+02), forces1[103], tol); ASSERT_EQUAL_VEC(Vec3(-1.02954777e+02, -8.76455433e+01, 2.20912307e+02), forces1[103], tol);
ASSERT_EQUAL_VEC(Vec3( 1.44793e+02, -2.88985e+02, 1.68130e+02), forces1[104], tol); ASSERT_EQUAL_VEC(Vec3( 1.44791352e+02, -2.88999813e+02, 1.68134104e+02), forces1[104], tol);
ASSERT_EQUAL_VEC(Vec3( 9.68851e+01, -2.62261e+02, -3.07300e+02), forces1[105], tol); ASSERT_EQUAL_VEC(Vec3( 9.68813543e+01, -2.62260178e+02, -3.07286290e+02), forces1[105], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09042e+02, -2.43242e+02, -2.45233e+02), forces1[106], tol); ASSERT_EQUAL_VEC(Vec3(-1.09040958e+02, -2.43241310e+02, -2.45238041e+02), forces1[106], tol);
ASSERT_EQUAL_VEC(Vec3( 1.89553e+02, 1.49306e+02, -3.74276e+02), forces1[107], tol); ASSERT_EQUAL_VEC(Vec3( 1.89550491e+02, 1.49319105e+02, -3.74285248e+02), forces1[107], tol);
ASSERT_EQUAL_VEC(Vec3( 1.20766e+02, -1.66080e+02, -4.46354e+02), forces1[108], tol); ASSERT_EQUAL_VEC(Vec3( 1.20763399e+02, -1.66082622e+02, -4.46381843e+02), forces1[108], tol);
ASSERT_EQUAL_VEC(Vec3(-6.91024e+02, 6.62260e+02, 3.05871e+01), forces1[109], tol); ASSERT_EQUAL_VEC(Vec3(-6.91025497e+02, 6.62244311e+02, 3.06047534e+01), forces1[109], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61305e+02, 8.89691e+01, -3.35847e+01), forces1[110], tol); ASSERT_EQUAL_VEC(Vec3(-1.61280438e+02, 8.89755700e+01, -3.35630671e+01), forces1[110], tol);
ASSERT_EQUAL_VEC(Vec3(-4.17347e+02, 4.25988e+01, -7.77278e+01), forces1[111], tol); ASSERT_EQUAL_VEC(Vec3(-4.17338144e+02, 4.26061590e+01, -7.77158559e+01), forces1[111], tol);
ASSERT_EQUAL_VEC(Vec3(-4.01808e+01, 8.24871e+01, 4.51865e+02), forces1[112], tol); ASSERT_EQUAL_VEC(Vec3(-4.01742893e+01, 8.24881666e+01, 4.51855292e+02), forces1[112], tol);
ASSERT_EQUAL_VEC(Vec3(-1.40949e+01, -2.40650e+02, -1.27597e+02), forces1[113], tol); ASSERT_EQUAL_VEC(Vec3(-1.40970558e+01, -2.40647487e+02, -1.27598454e+02), forces1[113], tol);
ASSERT_EQUAL_VEC(Vec3( 2.83859e+02, 2.31048e+02, 1.33540e+01), forces1[114], tol); ASSERT_EQUAL_VEC(Vec3( 2.83839724e+02, 2.31041423e+02, 1.33456841e+01), forces1[114], tol);
ASSERT_EQUAL_VEC(Vec3( 5.10860e+01, -7.13351e+02, -4.07619e+02), forces1[115], tol); ASSERT_EQUAL_VEC(Vec3( 5.10867089e+01, -7.13361227e+02, -4.07617467e+02), forces1[115], tol);
ASSERT_EQUAL_VEC(Vec3(-1.56102e+02, -1.33109e+02, 2.25962e+02), forces1[116], tol); ASSERT_EQUAL_VEC(Vec3(-1.56090473e+02, -1.33121120e+02, 2.25952345e+02), forces1[116], tol);
ASSERT_EQUAL_VEC(Vec3( 3.69762e+01, -1.35113e+01, 1.10577e+02), forces1[117], tol); ASSERT_EQUAL_VEC(Vec3( 3.69607528e+01, -1.35106805e+01, 1.10579378e+02), forces1[117], tol);
ASSERT_EQUAL_VEC(Vec3( 3.37803e+02, 8.10454e+01, -5.39809e+01), forces1[118], tol); ASSERT_EQUAL_VEC(Vec3( 3.37809441e+02, 8.10519215e+01, -5.39817090e+01), forces1[118], tol);
ASSERT_EQUAL_VEC(Vec3( 5.49995e+01, 7.54922e+01, 1.80557e+02), forces1[119], tol); ASSERT_EQUAL_VEC(Vec3( 5.49975558e+01, 7.55006073e+01, 1.80545525e+02), forces1[119], tol);
ASSERT_EQUAL_VEC(Vec3( 1.10970e+02, -3.83969e+02, 2.77979e+01), forces1[120], tol); ASSERT_EQUAL_VEC(Vec3( 1.10971245e+02, -3.83971391e+02, 2.77991517e+01), forces1[120], tol);
ASSERT_EQUAL_VEC(Vec3(-2.63192e+02, -3.16281e+02, -3.95219e+02), forces1[121], tol); ASSERT_EQUAL_VEC(Vec3(-2.63190529e+02, -3.16285880e+02, -3.95218767e+02), forces1[121], tol);
ASSERT_EQUAL_VEC(Vec3( 3.42554e+02, -2.35758e+02, 4.60365e+02), forces1[122], tol); ASSERT_EQUAL_VEC(Vec3( 3.42556090e+02, -2.35748098e+02, 4.60355306e+02), forces1[122], tol);
ASSERT_EQUAL_VEC(Vec3( 2.47675e+02, 2.42868e+02, 1.52222e+02), forces1[123], tol); ASSERT_EQUAL_VEC(Vec3( 2.47668934e+02, 2.42870015e+02, 1.52218275e+02), forces1[123], tol);
ASSERT_EQUAL_VEC(Vec3(-2.70201e+02, 2.08579e+02, -1.86859e+02), forces1[124], tol); ASSERT_EQUAL_VEC(Vec3(-2.70198409e+02, 2.08574994e+02, -1.86859372e+02), forces1[124], tol);
ASSERT_EQUAL_VEC(Vec3( 3.24096e+02, 2.54997e+02, -1.10893e+02), forces1[125], tol); ASSERT_EQUAL_VEC(Vec3( 3.24104326e+02, 2.55001752e+02, -1.10880955e+02), forces1[125], tol);
ASSERT_EQUAL_VEC(Vec3( 5.16195e+02, -5.05997e+01, -2.80852e+02), forces1[126], tol); ASSERT_EQUAL_VEC(Vec3( 5.16197105e+02, -5.06150948e+01, -2.80857737e+02), forces1[126], tol);
ASSERT_EQUAL_VEC(Vec3(-3.30844e+02, -3.47297e+02, 1.45227e+02), forces1[127], tol); ASSERT_EQUAL_VEC(Vec3(-3.30849573e+02, -3.47291965e+02, 1.45237748e+02), forces1[127], tol);
ASSERT_EQUAL_VEC(Vec3(-1.28358e+02, 7.69230e+01, 2.14906e+02), forces1[128], tol); ASSERT_EQUAL_VEC(Vec3(-1.28356764e+02, 7.69134918e+01, 2.14911544e+02), forces1[128], tol);
ASSERT_EQUAL_VEC(Vec3(-1.91481e+02, -2.11471e+02, 1.35341e+02), forces1[129], tol); ASSERT_EQUAL_VEC(Vec3(-1.91469755e+02, -2.11473339e+02, 1.35333200e+02), forces1[129], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69904e+02, 1.11330e+02, -8.98595e+01), forces1[130], tol); ASSERT_EQUAL_VEC(Vec3(-2.69887152e+02, 1.11337990e+02, -8.98463460e+01), forces1[130], tol);
ASSERT_EQUAL_VEC(Vec3(-1.36375e+02, -2.14230e+02, -5.83741e+01), forces1[131], tol); ASSERT_EQUAL_VEC(Vec3(-1.36374172e+02, -2.14238377e+02, -5.83866682e+01), forces1[131], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38571e+02, 2.36125e+02, -2.08991e+01), forces1[132], tol); ASSERT_EQUAL_VEC(Vec3(-1.38562455e+02, 2.36128851e+02, -2.08960526e+01), forces1[132], tol);
ASSERT_EQUAL_VEC(Vec3(-2.47594e+02, 3.98234e+02, -1.64753e+02), forces1[133], tol); ASSERT_EQUAL_VEC(Vec3(-2.47599869e+02, 3.98208933e+02, -1.64765063e+02), forces1[133], tol);
ASSERT_EQUAL_VEC(Vec3(-8.37480e+01, 4.07966e+02, -1.24164e+02), forces1[134], tol); ASSERT_EQUAL_VEC(Vec3(-8.37476276e+01, 4.07965070e+02, -1.24163988e+02), forces1[134], tol);
ASSERT_EQUAL_VEC(Vec3(-1.60141e+02, -6.51387e+00, 3.55061e+02), forces1[135], tol); ASSERT_EQUAL_VEC(Vec3(-1.60159071e+02, -6.49998978e+00, 3.55060364e+02), forces1[135], tol);
ASSERT_EQUAL_VEC(Vec3( 3.58250e+02, -2.81404e+02, -1.28027e+02), forces1[136], tol); ASSERT_EQUAL_VEC(Vec3( 3.58249937e+02, -2.81395872e+02, -1.28020722e+02), forces1[136], tol);
ASSERT_EQUAL_VEC(Vec3( 3.33741e+02, -3.31204e+02, -2.41779e+01), forces1[137], tol); ASSERT_EQUAL_VEC(Vec3( 3.33746078e+02, -3.31207307e+02, -2.41631386e+01), forces1[137], tol);
ASSERT_EQUAL_VEC(Vec3(-3.00688e+02, -1.70101e+02, 8.30599e+01), forces1[138], tol); ASSERT_EQUAL_VEC(Vec3(-3.00676509e+02, -1.70097272e+02, 8.30597971e+01), forces1[138], tol);
ASSERT_EQUAL_VEC(Vec3(-1.94838e+01, 1.35848e+02, -3.65144e+02), forces1[139], tol); ASSERT_EQUAL_VEC(Vec3(-1.94891185e+01, 1.35846931e+02, -3.65144038e+02), forces1[139], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77176e+02, 4.44536e+01, 2.11469e+02), forces1[140], tol); ASSERT_EQUAL_VEC(Vec3(-1.77181788e+02, 4.44531481e+01, 2.11474121e+02), forces1[140], tol);
ASSERT_EQUAL_VEC(Vec3( 4.59289e+02, -3.23643e+02, 3.67796e+02), forces1[141], tol); ASSERT_EQUAL_VEC(Vec3( 4.59275521e+02, -3.23637233e+02, 3.67800802e+02), forces1[141], tol);
ASSERT_EQUAL_VEC(Vec3( 4.22135e+02, 2.22090e+02, 2.92470e+02), forces1[142], tol); ASSERT_EQUAL_VEC(Vec3( 4.22121423e+02, 2.22068413e+02, 2.92465809e+02), forces1[142], tol);
ASSERT_EQUAL_VEC(Vec3( 2.83774e+02, -2.92618e+02, 8.17996e+01), forces1[143], tol); ASSERT_EQUAL_VEC(Vec3( 2.83763316e+02, -2.92602600e+02, 8.18013996e+01), forces1[143], tol);
ASSERT_EQUAL_VEC(Vec3(-5.70716e+01, 2.40305e+02, -3.40920e+01), forces1[144], tol); ASSERT_EQUAL_VEC(Vec3(-5.70559390e+01, 2.40295170e+02, -3.40862650e+01), forces1[144], tol);
ASSERT_EQUAL_VEC(Vec3( 1.04077e+02, 1.58991e+02, 1.10154e+01), forces1[145], tol); ASSERT_EQUAL_VEC(Vec3( 1.04075222e+02, 1.58996510e+02, 1.10304777e+01), forces1[145], tol);
ASSERT_EQUAL_VEC(Vec3( 5.88495e+02, 2.07876e+02, -7.36945e+01), forces1[146], tol); ASSERT_EQUAL_VEC(Vec3( 5.88502616e+02, 2.07880339e+02, -7.36908474e+01), forces1[146], tol);
ASSERT_EQUAL_VEC(Vec3( 2.82632e+02, 2.25991e+02, 2.16752e+02), forces1[147], tol); ASSERT_EQUAL_VEC(Vec3( 2.82632623e+02, 2.25995810e+02, 2.16745828e+02), forces1[147], tol);
ASSERT_EQUAL_VEC(Vec3(-2.02433e+02, 1.65900e+02, -1.47470e+02), forces1[148], tol); ASSERT_EQUAL_VEC(Vec3(-2.02435189e+02, 1.65899995e+02, -1.47471730e+02), forces1[148], tol);
ASSERT_EQUAL_VEC(Vec3(-2.96624e+02, -4.87434e+02, 1.60854e+02), forces1[149], tol); ASSERT_EQUAL_VEC(Vec3(-2.96622169e+02, -4.87423685e+02, 1.60844164e+02), forces1[149], tol);
ASSERT_EQUAL_VEC(Vec3( 2.94719e+02, 1.30340e+02, 2.82848e+01), forces1[150], tol); ASSERT_EQUAL_VEC(Vec3( 2.94715891e+02, 1.30347848e+02, 2.82729974e+01), forces1[150], tol);
ASSERT_EQUAL_VEC(Vec3( 3.70879e+02, 3.22175e+01, 8.74554e+01), forces1[151], tol); ASSERT_EQUAL_VEC(Vec3( 3.70885287e+02, 3.22229123e+01, 8.74581871e+01), forces1[151], tol);
ASSERT_EQUAL_VEC(Vec3( 3.44000e+02, -2.07927e+02, 3.49074e+02), forces1[152], tol); ASSERT_EQUAL_VEC(Vec3( 3.43994702e+02, -2.07935556e+02, 3.49067383e+02), forces1[152], tol);
ASSERT_EQUAL_VEC(Vec3( 1.43155e+01, -2.80346e+02, 5.69770e+01), forces1[153], tol); ASSERT_EQUAL_VEC(Vec3( 1.43099882e+01, -2.80336001e+02, 5.69626314e+01), forces1[153], tol);
ASSERT_EQUAL_VEC(Vec3( 9.72120e+01, 1.42238e+01, 1.00132e+02), forces1[154], tol); ASSERT_EQUAL_VEC(Vec3( 9.71948870e+01, 1.42192042e+01, 1.00139441e+02), forces1[154], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56996e+02, -1.87968e+01, -1.07623e+02), forces1[155], tol); ASSERT_EQUAL_VEC(Vec3( 2.56990028e+02, -1.87993683e+01, -1.07611017e+02), forces1[155], tol);
ASSERT_EQUAL_VEC(Vec3( 4.20265e+02, 1.16944e+02, 4.29567e+02), forces1[156], tol); ASSERT_EQUAL_VEC(Vec3( 4.20275466e+02, 1.16943633e+02, 4.29575935e+02), forces1[156], tol);
ASSERT_EQUAL_VEC(Vec3(-2.05592e+02, -2.74938e+02, 1.32843e+02), forces1[157], tol); ASSERT_EQUAL_VEC(Vec3(-2.05593618e+02, -2.74949188e+02, 1.32851151e+02), forces1[157], tol);
ASSERT_EQUAL_VEC(Vec3( 2.88928e+01, 1.07747e+01, -2.09429e+02), forces1[158], tol); ASSERT_EQUAL_VEC(Vec3( 2.88917359e+01, 1.07824736e+01, -2.09437913e+02), forces1[158], tol);
ASSERT_EQUAL_VEC(Vec3(-4.54617e+02, -2.58121e+01, -2.66969e+02), forces1[159], tol); ASSERT_EQUAL_VEC(Vec3(-4.54601782e+02, -2.58268961e+01, -2.66964578e+02), forces1[159], tol);
ASSERT_EQUAL_VEC(Vec3( 5.91037e+02, -7.76465e+01, 9.28992e+01), forces1[160], tol); ASSERT_EQUAL_VEC(Vec3( 5.91049307e+02, -7.76470493e+01, 9.29094217e+01), forces1[160], tol);
ASSERT_EQUAL_VEC(Vec3(-8.27728e+00, 2.39607e+02, 1.04871e+02), forces1[161], tol); ASSERT_EQUAL_VEC(Vec3(-8.26256556e+00, 2.39614788e+02, 1.04874825e+02), forces1[161], tol);
ASSERT_EQUAL_VEC(Vec3( 4.79717e+01, -1.73708e+02, -5.98009e+01), forces1[162], tol); ASSERT_EQUAL_VEC(Vec3( 4.79904829e+01, -1.73703832e+02, -5.98140813e+01), forces1[162], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26002e+02, 1.64287e+02, -4.23291e+02), forces1[163], tol); ASSERT_EQUAL_VEC(Vec3(-1.26007450e+02, 1.64300309e+02, -4.23289873e+02), forces1[163], tol);
ASSERT_EQUAL_VEC(Vec3(-2.03184e+02, 1.46917e+02, 2.50695e+02), forces1[164], tol); ASSERT_EQUAL_VEC(Vec3(-2.03205374e+02, 1.46921807e+02, 2.50701909e+02), forces1[164], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38809e+02, 1.32927e+02, 2.75568e+02), forces1[165], tol); ASSERT_EQUAL_VEC(Vec3(-1.38813652e+02, 1.32930267e+02, 2.75556760e+02), forces1[165], tol);
ASSERT_EQUAL_VEC(Vec3( 9.19160e+01, -1.55651e+02, 1.24212e+02), forces1[166], tol); ASSERT_EQUAL_VEC(Vec3( 9.19035624e+01, -1.55653738e+02, 1.24210719e+02), forces1[166], tol);
ASSERT_EQUAL_VEC(Vec3( 2.09932e+02, 1.26987e+02, -3.32804e+02), forces1[167], tol); ASSERT_EQUAL_VEC(Vec3( 2.09938122e+02, 1.26973729e+02, -3.32817155e+02), forces1[167], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56222e+02, 6.09638e+00, 3.42770e+02), forces1[168], tol); ASSERT_EQUAL_VEC(Vec3( 2.56206143e+02, 6.10122855e+00, 3.42771101e+02), forces1[168], tol);
ASSERT_EQUAL_VEC(Vec3( 3.11439e+02, 9.42118e+01, -8.52237e+00), forces1[169], tol); ASSERT_EQUAL_VEC(Vec3( 3.11438984e+02, 9.42198048e+01, -8.51953228e+00), forces1[169], tol);
ASSERT_EQUAL_VEC(Vec3( 1.78687e+02, -1.37042e+01, -2.21816e+01), forces1[170], tol); ASSERT_EQUAL_VEC(Vec3( 1.78692126e+02, -1.36964221e+01, -2.21830640e+01), forces1[170], tol);
ASSERT_EQUAL_VEC(Vec3(-4.69097e+01, 5.77161e+02, 1.04253e+02), forces1[171], tol); ASSERT_EQUAL_VEC(Vec3(-4.69093086e+01, 5.77169523e+02, 1.04262190e+02), forces1[171], tol);
ASSERT_EQUAL_VEC(Vec3( 1.31260e+02, 7.57856e+01, -9.08161e+01), forces1[172], tol); ASSERT_EQUAL_VEC(Vec3( 1.31254187e+02, 7.57774979e+01, -9.08207172e+01), forces1[172], tol);
ASSERT_EQUAL_VEC(Vec3(-1.69457e+02, -3.62026e+02, 2.68891e+02), forces1[173], tol); ASSERT_EQUAL_VEC(Vec3(-1.69436483e+02, -3.62015361e+02, 2.68889227e+02), forces1[173], tol);
ASSERT_EQUAL_VEC(Vec3(-1.68465e+02, -2.62636e+02, 7.41297e+01), forces1[174], tol); ASSERT_EQUAL_VEC(Vec3(-1.68463797e+02, -2.62627703e+02, 7.41106664e+01), forces1[174], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53151e+02, 2.68930e+02, -3.92496e+02), forces1[175], tol); ASSERT_EQUAL_VEC(Vec3(-2.53154790e+02, 2.68914173e+02, -3.92489521e+02), forces1[175], tol);
ASSERT_EQUAL_VEC(Vec3( 1.95114e+02, -5.76768e+01, 3.91948e+02), forces1[176], tol); ASSERT_EQUAL_VEC(Vec3( 1.95110073e+02, -5.76611142e+01, 3.91951958e+02), forces1[176], tol);
ASSERT_EQUAL_VEC(Vec3( 2.43331e+02, -3.91494e+02, -8.64033e+01), forces1[177], tol); ASSERT_EQUAL_VEC(Vec3( 2.43338357e+02, -3.91477149e+02, -8.63953114e+01), forces1[177], tol);
ASSERT_EQUAL_VEC(Vec3(-1.34171e+02, 1.46598e+02, 1.19865e+02), forces1[178], tol); ASSERT_EQUAL_VEC(Vec3(-1.34179863e+02, 1.46591166e+02, 1.19878040e+02), forces1[178], tol);
ASSERT_EQUAL_VEC(Vec3( 1.63175e+02, -2.66968e+02, 1.65784e+02), forces1[179], tol); ASSERT_EQUAL_VEC(Vec3( 1.63174304e+02, -2.66960106e+02, 1.65770978e+02), forces1[179], tol);
ASSERT_EQUAL_VEC(Vec3( 5.46533e+01, 6.58700e+01, -4.94243e+02), forces1[180], tol); ASSERT_EQUAL_VEC(Vec3( 5.46495327e+01, 6.58671492e+01, -4.94244139e+02), forces1[180], tol);
ASSERT_EQUAL_VEC(Vec3(-1.62972e+02, 1.53807e+02, 2.72103e+01), forces1[181], tol); ASSERT_EQUAL_VEC(Vec3(-1.62957088e+02, 1.53806002e+02, 2.72147870e+01), forces1[181], tol);
ASSERT_EQUAL_VEC(Vec3(-1.97746e+02, -9.08102e+01, -5.59646e+02), forces1[182], tol); ASSERT_EQUAL_VEC(Vec3(-1.97769720e+02, -9.08099669e+01, -5.59653565e+02), forces1[182], tol);
ASSERT_EQUAL_VEC(Vec3(-9.59209e+01, -3.67220e+02, -1.37099e+02), forces1[183], tol); ASSERT_EQUAL_VEC(Vec3(-9.59272102e+01, -3.67219179e+02, -1.37098968e+02), forces1[183], tol);
ASSERT_EQUAL_VEC(Vec3(-3.13283e+02, -4.77509e+02, -2.82333e+02), forces1[184], tol); ASSERT_EQUAL_VEC(Vec3(-3.13273853e+02, -4.77528382e+02, -2.82320271e+02), forces1[184], tol);
ASSERT_EQUAL_VEC(Vec3( 3.47137e+01, -1.51847e+02, -2.71794e+02), forces1[185], tol); ASSERT_EQUAL_VEC(Vec3( 3.47090516e+01, -1.51861017e+02, -2.71782882e+02), forces1[185], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09988e+02, 7.60637e+01, -1.90767e+02), forces1[186], tol); ASSERT_EQUAL_VEC(Vec3(-1.09985174e+02, 7.60658358e+01, -1.90751868e+02), forces1[186], tol);
ASSERT_EQUAL_VEC(Vec3( 3.49596e+02, 1.52761e+02, 4.22513e+02), forces1[187], tol); ASSERT_EQUAL_VEC(Vec3( 3.49595143e+02, 1.52747707e+02, 4.22488620e+02), forces1[187], tol);
ASSERT_EQUAL_VEC(Vec3(-3.59603e+01, 3.55468e+01, -7.87468e+01), forces1[188], tol); ASSERT_EQUAL_VEC(Vec3(-3.59725754e+01, 3.55475701e+01, -7.87334885e+01), forces1[188], tol);
ASSERT_EQUAL_VEC(Vec3(-5.53794e+02, 1.58098e+02, -5.47141e+01), forces1[189], tol); ASSERT_EQUAL_VEC(Vec3(-5.53788647e+02, 1.58101235e+02, -5.47105678e+01), forces1[189], tol);
ASSERT_EQUAL_VEC(Vec3( 8.55461e+01, -2.88449e+02, 2.54414e+01), forces1[190], tol); ASSERT_EQUAL_VEC(Vec3( 8.55520733e+01, -2.88444498e+02, 2.54318577e+01), forces1[190], tol);
ASSERT_EQUAL_VEC(Vec3( 1.96804e+02, 1.69080e+02, 2.41084e+02), forces1[191], tol); ASSERT_EQUAL_VEC(Vec3( 1.96800399e+02, 1.69077439e+02, 2.41074010e+02), forces1[191], tol);
ASSERT_EQUAL_VEC(Vec3( 7.64077e+01, 3.05714e+02, 2.76160e+02), forces1[192], tol); ASSERT_EQUAL_VEC(Vec3( 7.64011738e+01, 3.05710609e+02, 2.76162549e+02), forces1[192], tol);
ASSERT_EQUAL_VEC(Vec3( 1.23268e+02, 8.57335e+01, 3.46717e+02), forces1[193], tol); ASSERT_EQUAL_VEC(Vec3( 1.23265853e+02, 8.57500919e+01, 3.46722858e+02), forces1[193], tol);
ASSERT_EQUAL_VEC(Vec3(-9.05846e+01, 5.50636e+01, -4.12452e+02), forces1[194], tol); ASSERT_EQUAL_VEC(Vec3(-9.05651135e+01, 5.50685032e+01, -4.12462772e+02), forces1[194], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69809e+00, 1.30557e+02, -1.55138e+02), forces1[195], tol); ASSERT_EQUAL_VEC(Vec3(-2.70875191e+00, 1.30545633e+02, -1.55140021e+02), forces1[195], tol);
ASSERT_EQUAL_VEC(Vec3(-1.37393e+02, -2.94301e+02, -1.24606e+02), forces1[196], tol); ASSERT_EQUAL_VEC(Vec3(-1.37389162e+02, -2.94304654e+02, -1.24611408e+02), forces1[196], tol);
ASSERT_EQUAL_VEC(Vec3(-3.56101e+02, -9.03577e+01, 3.14895e+02), forces1[197], tol); ASSERT_EQUAL_VEC(Vec3(-3.56088703e+02, -9.03800091e+01, 3.14895993e+02), forces1[197], tol);
ASSERT_EQUAL_VEC(Vec3(-7.79151e+01, 1.12191e+02, 3.86366e+02), forces1[198], tol); ASSERT_EQUAL_VEC(Vec3(-7.79280727e+01, 1.12179786e+02, 3.86364249e+02), forces1[198], tol);
ASSERT_EQUAL_VEC(Vec3( 2.43090e+02, 5.36467e+02, -9.47378e+01), forces1[199], tol); ASSERT_EQUAL_VEC(Vec3( 2.43080372e+02, 5.36466609e+02, -9.47357535e+01), forces1[199], tol);
ASSERT_EQUAL_VEC(Vec3(-7.39602e+01, -3.53177e+02, 1.42840e+01), forces1[200], tol); ASSERT_EQUAL_VEC(Vec3(-7.39441823e+01, -3.53188450e+02, 1.42886370e+01), forces1[200], tol);
ASSERT_EQUAL_VEC(Vec3( 6.56574e+02, -2.80426e+02, 2.95741e+02), forces1[201], tol); ASSERT_EQUAL_VEC(Vec3( 6.56556933e+02, -2.80423857e+02, 2.95738831e+02), forces1[201], tol);
ASSERT_EQUAL_VEC(Vec3(-2.72320e+02, -1.44067e+02, 2.55686e+02), forces1[202], tol); ASSERT_EQUAL_VEC(Vec3(-2.72306632e+02, -1.44066176e+02, 2.55684522e+02), forces1[202], tol);
ASSERT_EQUAL_VEC(Vec3(-3.75733e+01, 2.99426e+02, -4.12491e+02), forces1[203], tol); ASSERT_EQUAL_VEC(Vec3(-3.75638941e+01, 2.99415967e+02, -4.12490294e+02), forces1[203], tol);
ASSERT_EQUAL_VEC(Vec3( 3.64692e+02, 3.39122e+02, -8.08599e+01), forces1[204], tol); ASSERT_EQUAL_VEC(Vec3( 3.64685442e+02, 3.39117459e+02, -8.08643870e+01), forces1[204], tol);
ASSERT_EQUAL_VEC(Vec3( 4.32803e+02, -1.78896e+02, 3.86638e+02), forces1[205], tol); ASSERT_EQUAL_VEC(Vec3( 4.32799610e+02, -1.78895030e+02, 3.86635331e+02), forces1[205], tol);
ASSERT_EQUAL_VEC(Vec3(-9.04327e+01, 3.89963e+02, -5.47933e+02), forces1[206], tol); ASSERT_EQUAL_VEC(Vec3(-9.04462035e+01, 3.89960088e+02, -5.47950733e+02), forces1[206], tol);
ASSERT_EQUAL_VEC(Vec3(-6.35039e+02, 1.85266e+01, 3.17042e+01), forces1[207], tol); ASSERT_EQUAL_VEC(Vec3(-6.35043448e+02, 1.85486756e+01, 3.17016236e+01), forces1[207], tol);
ASSERT_EQUAL_VEC(Vec3(-5.92779e+01, -2.85278e+02, -1.42352e+02), forces1[208], tol); ASSERT_EQUAL_VEC(Vec3(-5.92896097e+01, -2.85274924e+02, -1.42348620e+02), forces1[208], tol);
ASSERT_EQUAL_VEC(Vec3(-1.35193e+02, -3.56088e+02, 1.07994e+02), forces1[209], tol); ASSERT_EQUAL_VEC(Vec3(-1.35207298e+02, -3.56081009e+02, 1.07991189e+02), forces1[209], tol);
ASSERT_EQUAL_VEC(Vec3( 3.94898e+02, 9.99407e+01, -1.57841e+02), forces1[210], tol); ASSERT_EQUAL_VEC(Vec3( 3.94900105e+02, 9.99453126e+01, -1.57827968e+02), forces1[210], tol);
ASSERT_EQUAL_VEC(Vec3(-1.56518e+02, -1.66140e+02, -4.77233e+00), forces1[211], tol); ASSERT_EQUAL_VEC(Vec3(-1.56528334e+02, -1.66144237e+02, -4.78550980e+00), forces1[211], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77289e+02, -9.52036e+01, -3.42046e+02), forces1[212], tol); ASSERT_EQUAL_VEC(Vec3(-1.77280437e+02, -9.51924294e+01, -3.42048132e+02), forces1[212], tol);
ASSERT_EQUAL_VEC(Vec3( 2.97749e+02, 7.18134e+02, -4.94760e+02), forces1[213], tol); ASSERT_EQUAL_VEC(Vec3( 2.97739381e+02, 7.18137153e+02, -4.94774385e+02), forces1[213], tol);
ASSERT_EQUAL_VEC(Vec3(-5.12806e+02, 7.63629e+02, -5.44446e+01), forces1[214], tol); ASSERT_EQUAL_VEC(Vec3(-5.12807812e+02, 7.63618980e+02, -5.44479748e+01), forces1[214], tol);
ASSERT_EQUAL_VEC(Vec3(-2.55715e+02, -4.46410e+02, -1.72492e+02), forces1[215], tol); ASSERT_EQUAL_VEC(Vec3(-2.55718099e+02, -4.46413837e+02, -1.72488334e+02), forces1[215], tol);
ASSERT_EQUAL_VEC(Vec3( 3.15188e+02, 5.62389e+02, 2.42568e+02), forces1[216], tol); ASSERT_EQUAL_VEC(Vec3( 3.15155213e+02, 5.62372598e+02, 2.42573447e+02), forces1[216], tol);
ASSERT_EQUAL_VEC(Vec3(-2.90591e+01, 3.91005e+02, 1.36606e+02), forces1[217], tol); ASSERT_EQUAL_VEC(Vec3(-2.90686044e+01, 3.91008419e+02, 1.36603112e+02), forces1[217], tol);
ASSERT_EQUAL_VEC(Vec3(-4.26370e+02, 5.13939e+02, 8.37965e+01), forces1[218], tol); ASSERT_EQUAL_VEC(Vec3(-4.26382270e+02, 5.13937396e+02, 8.38021440e+01), forces1[218], tol);
ASSERT_EQUAL_VEC(Vec3(-2.88402e+02, 6.41615e+01, 3.02407e+02), forces1[219], tol); ASSERT_EQUAL_VEC(Vec3(-2.88415254e+02, 6.41404241e+01, 3.02418529e+02), forces1[219], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13294e+01, -3.20420e+02, 1.98734e+02), forces1[220], tol); ASSERT_EQUAL_VEC(Vec3(-1.13264423e+01, -3.20432026e+02, 1.98735533e+02), forces1[220], tol);
ASSERT_EQUAL_VEC(Vec3(-1.73218e+02, 2.09792e+02, 2.60737e+02), forces1[221], tol); ASSERT_EQUAL_VEC(Vec3(-1.73201040e+02, 2.09799717e+02, 2.60748570e+02), forces1[221], tol);
ASSERT_EQUAL_VEC(Vec3( 4.34186e+02, -1.25025e+02, 2.52905e+02), forces1[222], tol); ASSERT_EQUAL_VEC(Vec3( 4.34181587e+02, -1.25026352e+02, 2.52906543e+02), forces1[222], tol);
ASSERT_EQUAL_VEC(Vec3(-3.09512e+02, 2.63403e+02, -2.33547e+02), forces1[223], tol); ASSERT_EQUAL_VEC(Vec3(-3.09528945e+02, 2.63415228e+02, -2.33523213e+02), forces1[223], tol);
ASSERT_EQUAL_VEC(Vec3( 8.65392e+01, -5.32180e+02, -2.36430e+02), forces1[224], tol); ASSERT_EQUAL_VEC(Vec3( 8.65524156e+01, -5.32178407e+02, -2.36443769e+02), forces1[224], tol);
ASSERT_EQUAL_VEC(Vec3(-1.74976e+02, -2.30192e+02, -1.33680e+02), forces1[225], tol); ASSERT_EQUAL_VEC(Vec3(-1.74965243e+02, -2.30177295e+02, -1.33679144e+02), forces1[225], tol);
ASSERT_EQUAL_VEC(Vec3( 1.53824e+02, -1.24391e+02, -3.93389e+01), forces1[226], tol); ASSERT_EQUAL_VEC(Vec3( 1.53826901e+02, -1.24391764e+02, -3.93679341e+01), forces1[226], tol);
ASSERT_EQUAL_VEC(Vec3(-4.51760e+02, -7.75119e+01, -5.36139e+02), forces1[227], tol); ASSERT_EQUAL_VEC(Vec3(-4.51778358e+02, -7.75156480e+01, -5.36133859e+02), forces1[227], tol);
ASSERT_EQUAL_VEC(Vec3( 5.99310e+01, 2.97305e+02, 5.99023e+01), forces1[228], tol); ASSERT_EQUAL_VEC(Vec3( 5.99205686e+01, 2.97292572e+02, 5.99156789e+01), forces1[228], tol);
ASSERT_EQUAL_VEC(Vec3(-3.10628e+02, 2.94271e+00, -3.63631e+01), forces1[229], tol); ASSERT_EQUAL_VEC(Vec3(-3.10624444e+02, 2.94567470e+00, -3.63693136e+01), forces1[229], tol);
ASSERT_EQUAL_VEC(Vec3( 3.85866e+02, 1.41650e+02, 2.75093e+02), forces1[230], tol); ASSERT_EQUAL_VEC(Vec3( 3.85876747e+02, 1.41639709e+02, 2.75108543e+02), forces1[230], tol);
ASSERT_EQUAL_VEC(Vec3( 5.43231e+02, -3.20271e+02, -3.02182e+01), forces1[231], tol); ASSERT_EQUAL_VEC(Vec3( 5.43221531e+02, -3.20245253e+02, -3.02057882e+01), forces1[231], tol);
ASSERT_EQUAL_VEC(Vec3( 3.85585e+02, 6.64113e+01, -3.49628e+01), forces1[232], tol); ASSERT_EQUAL_VEC(Vec3( 3.85583563e+02, 6.64091011e+01, -3.49559777e+01), forces1[232], tol);
ASSERT_EQUAL_VEC(Vec3(-4.52861e+02, -3.40718e+02, 1.28899e+02), forces1[233], tol); ASSERT_EQUAL_VEC(Vec3(-4.52863518e+02, -3.40704717e+02, 1.28905508e+02), forces1[233], tol);
ASSERT_EQUAL_VEC(Vec3( 9.34281e+02, -1.39462e+02, 3.57857e+02), forces1[234], tol); ASSERT_EQUAL_VEC(Vec3( 9.34276939e+02, -1.39482274e+02, 3.57869403e+02), forces1[234], tol);
ASSERT_EQUAL_VEC(Vec3(-2.03077e+02, 7.44480e+01, 9.27321e+01), forces1[235], tol); ASSERT_EQUAL_VEC(Vec3(-2.03067148e+02, 7.44441061e+01, 9.27320006e+01), forces1[235], tol);
ASSERT_EQUAL_VEC(Vec3(-5.97533e+02, 1.26795e+02, 2.78890e+02), forces1[236], tol); ASSERT_EQUAL_VEC(Vec3(-5.97531539e+02, 1.26804078e+02, 2.78893030e+02), forces1[236], tol);
ASSERT_EQUAL_VEC(Vec3( 5.67862e+02, -5.34683e+02, -1.84231e+02), forces1[237], tol); ASSERT_EQUAL_VEC(Vec3( 5.67860193e+02, -5.34681659e+02, -1.84230283e+02), forces1[237], tol);
ASSERT_EQUAL_VEC(Vec3( 2.13176e+02, 2.99773e+02, -2.66449e+02), forces1[238], tol); ASSERT_EQUAL_VEC(Vec3( 2.13190333e+02, 2.99783610e+02, -2.66458597e+02), forces1[238], tol);
ASSERT_EQUAL_VEC(Vec3( 3.11510e+01, 4.54676e+02, 3.81105e+01), forces1[239], tol); ASSERT_EQUAL_VEC(Vec3( 3.11473403e+01, 4.54685224e+02, 3.81034869e+01), forces1[239], tol);
ASSERT_EQUAL_VEC(Vec3( 1.57537e+02, 3.19235e+01, -1.57705e+02), forces1[240], tol); ASSERT_EQUAL_VEC(Vec3( 1.57514487e+02, 3.19318405e+01, -1.57720436e+02), forces1[240], tol);
ASSERT_EQUAL_VEC(Vec3( 4.34923e+02, -4.69309e+02, -3.96609e+01), forces1[241], tol); ASSERT_EQUAL_VEC(Vec3( 4.34917141e+02, -4.69320639e+02, -3.96620193e+01), forces1[241], tol);
ASSERT_EQUAL_VEC(Vec3(-3.54156e+01, -1.00161e+02, 7.07549e+01), forces1[242], tol); ASSERT_EQUAL_VEC(Vec3(-3.54127895e+01, -1.00145510e+02, 7.07653587e+01), forces1[242], tol);
ASSERT_EQUAL_VEC(Vec3( 3.29682e+02, 3.63915e+02, -3.89186e+02), forces1[243], tol); ASSERT_EQUAL_VEC(Vec3( 3.29669760e+02, 3.63920894e+02, -3.89179023e+02), forces1[243], tol);
ASSERT_EQUAL_VEC(Vec3( 7.63984e+02, 2.97359e+02, -5.39998e+01), forces1[244], tol); ASSERT_EQUAL_VEC(Vec3( 7.63985812e+02, 2.97343162e+02, -5.39992884e+01), forces1[244], tol);
ASSERT_EQUAL_VEC(Vec3(-2.67910e+02, 2.23581e+02, -1.67262e+02), forces1[245], tol); ASSERT_EQUAL_VEC(Vec3(-2.67917290e+02, 2.23564800e+02, -1.67266290e+02), forces1[245], tol);
ASSERT_EQUAL_VEC(Vec3(-6.45289e+02, -9.39105e+00, -5.71132e+02), forces1[246], tol); ASSERT_EQUAL_VEC(Vec3(-6.45289709e+02, -9.38444040e+00, -5.71116404e+02), forces1[246], tol);
ASSERT_EQUAL_VEC(Vec3( 1.48212e+02, -1.78741e+02, 8.43704e+01), forces1[247], tol); ASSERT_EQUAL_VEC(Vec3( 1.48220582e+02, -1.78737448e+02, 8.43814640e+01), forces1[247], tol);
ASSERT_EQUAL_VEC(Vec3( 3.26723e+02, -3.84541e+02, 2.88338e+02), forces1[248], tol); ASSERT_EQUAL_VEC(Vec3( 3.26731869e+02, -3.84524983e+02, 2.88339532e+02), forces1[248], tol);
ASSERT_EQUAL_VEC(Vec3( 2.58368e+02, 5.43895e+01, 3.38641e+02), forces1[249], tol); ASSERT_EQUAL_VEC(Vec3( 2.58365914e+02, 5.43905231e+01, 3.38641536e+02), forces1[249], tol);
ASSERT_EQUAL_VEC(Vec3(-3.51597e+02, -3.06741e+02, -2.99473e+01), forces1[250], tol); ASSERT_EQUAL_VEC(Vec3(-3.51600062e+02, -3.06740536e+02, -2.99454859e+01), forces1[250], tol);
ASSERT_EQUAL_VEC(Vec3(-2.78755e+01, 2.36163e+02, 1.06050e+01), forces1[251], tol); ASSERT_EQUAL_VEC(Vec3(-2.78580097e+01, 2.36156123e+02, 1.06081152e+01), forces1[251], tol);
ASSERT_EQUAL_VEC(Vec3(-1.75901e+02, -9.39734e+00, 1.84205e+02), forces1[252], tol); ASSERT_EQUAL_VEC(Vec3(-1.75899733e+02, -9.38608562e+00, 1.84207408e+02), forces1[252], tol);
ASSERT_EQUAL_VEC(Vec3(-5.60402e+02, 1.90143e+02, -2.90235e+02), forces1[253], tol); ASSERT_EQUAL_VEC(Vec3(-5.60399133e+02, 1.90145998e+02, -2.90215623e+02), forces1[253], tol);
ASSERT_EQUAL_VEC(Vec3(-1.69427e+02, 2.23702e+02, -3.41995e+02), forces1[254], tol); ASSERT_EQUAL_VEC(Vec3(-1.69434526e+02, 2.23702263e+02, -3.41994449e+02), forces1[254], tol);
ASSERT_EQUAL_VEC(Vec3(-6.96572e+01, 1.66426e+02, -6.78413e+00), forces1[255], tol); ASSERT_EQUAL_VEC(Vec3(-6.96578236e+01, 1.66438449e+02, -6.77499321e+00), forces1[255], tol);
ASSERT_EQUAL_VEC(Vec3( 2.73655e+02, 1.49543e+00, 7.80427e+01), forces1[256], tol); ASSERT_EQUAL_VEC(Vec3( 2.73655591e+02, 1.49071325e+00, 7.80565008e+01), forces1[256], tol);
ASSERT_EQUAL_VEC(Vec3(-2.58383e+02, 8.46420e+01, -9.41928e+01), forces1[257], tol); ASSERT_EQUAL_VEC(Vec3(-2.58366132e+02, 8.46288614e+01, -9.42098129e+01), forces1[257], tol);
ASSERT_EQUAL_VEC(Vec3(-4.25862e+02, 9.84376e+00, 6.39519e+01), forces1[258], tol); ASSERT_EQUAL_VEC(Vec3(-4.25847146e+02, 9.84292470e+00, 6.39709870e+01), forces1[258], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12089e+02, 6.10266e+01, -1.38674e+02), forces1[259], tol); ASSERT_EQUAL_VEC(Vec3( 1.12083087e+02, 6.10255158e+01, -1.38662830e+02), forces1[259], tol);
ASSERT_EQUAL_VEC(Vec3( 3.21961e+01, 3.67498e+02, 6.87052e+01), forces1[260], tol); ASSERT_EQUAL_VEC(Vec3( 3.21828259e+01, 3.67493765e+02, 6.86972453e+01), forces1[260], tol);
ASSERT_EQUAL_VEC(Vec3(-3.72208e+02, 3.36282e+02, 3.15264e+02), forces1[261], tol); ASSERT_EQUAL_VEC(Vec3(-3.72206379e+02, 3.36289489e+02, 3.15273168e+02), forces1[261], tol);
ASSERT_EQUAL_VEC(Vec3( 4.28486e+01, 5.93401e+01, 4.86911e+02), forces1[262], tol); ASSERT_EQUAL_VEC(Vec3( 4.28443395e+01, 5.93339946e+01, 4.86905134e+02), forces1[262], tol);
ASSERT_EQUAL_VEC(Vec3( 3.03350e+01, 3.70289e+02, -5.83422e+02), forces1[263], tol); ASSERT_EQUAL_VEC(Vec3( 3.03267567e+01, 3.70293845e+02, -5.83420472e+02), forces1[263], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61734e+02, 3.70569e+02, -2.03595e+01), forces1[264], tol); ASSERT_EQUAL_VEC(Vec3(-1.61738517e+02, 3.70576503e+02, -2.03659425e+01), forces1[264], tol);
ASSERT_EQUAL_VEC(Vec3(-6.67242e+02, -1.24228e+01, -9.42022e+01), forces1[265], tol); ASSERT_EQUAL_VEC(Vec3(-6.67229637e+02, -1.24339105e+01, -9.41959187e+01), forces1[265], tol);
ASSERT_EQUAL_VEC(Vec3( 4.66963e+02, 3.49516e+02, 2.04641e+02), forces1[266], tol); ASSERT_EQUAL_VEC(Vec3( 4.66955725e+02, 3.49515015e+02, 2.04652411e+02), forces1[266], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52474e+02, -1.24064e+01, 2.24733e+01), forces1[267], tol); ASSERT_EQUAL_VEC(Vec3(-3.52483062e+02, -1.24093769e+01, 2.24828418e+01), forces1[267], tol);
ASSERT_EQUAL_VEC(Vec3( 4.58821e+01, -2.20901e+02, 7.64600e+01), forces1[268], tol); ASSERT_EQUAL_VEC(Vec3( 4.58746968e+01, -2.20898924e+02, 7.64552584e+01), forces1[268], tol);
ASSERT_EQUAL_VEC(Vec3(-4.43667e+01, -1.14903e+02, -2.87903e+02), forces1[269], tol); ASSERT_EQUAL_VEC(Vec3(-4.43630058e+01, -1.14899930e+02, -2.87900025e+02), forces1[269], tol);
ASSERT_EQUAL_VEC(Vec3(-9.22336e+01, 6.40902e+02, 3.17834e+02), forces1[270], tol); ASSERT_EQUAL_VEC(Vec3(-9.22312443e+01, 6.40883419e+02, 3.17836134e+02), forces1[270], tol);
ASSERT_EQUAL_VEC(Vec3(-2.15612e+02, -2.05460e+02, 6.85482e+01), forces1[271], tol); ASSERT_EQUAL_VEC(Vec3(-2.15623653e+02, -2.05460783e+02, 6.85627383e+01), forces1[271], tol);
ASSERT_EQUAL_VEC(Vec3( 2.24220e+02, -1.43084e+02, -4.17817e+01), forces1[272], tol); ASSERT_EQUAL_VEC(Vec3( 2.24218604e+02, -1.43080040e+02, -4.17826551e+01), forces1[272], tol);
ASSERT_EQUAL_VEC(Vec3( 1.79827e+02, -3.72428e+02, 2.12169e+02), forces1[273], tol); ASSERT_EQUAL_VEC(Vec3( 1.79823435e+02, -3.72425962e+02, 2.12155872e+02), forces1[273], tol);
ASSERT_EQUAL_VEC(Vec3( 9.74659e+01, 7.66823e+01, -5.04536e+02), forces1[274], tol); ASSERT_EQUAL_VEC(Vec3( 9.74694224e+01, 7.66864835e+01, -5.04542197e+02), forces1[274], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18103e+01, -5.76168e+02, -3.23940e+02), forces1[275], tol); ASSERT_EQUAL_VEC(Vec3( 2.18132641e+01, -5.76171362e+02, -3.23926383e+02), forces1[275], tol);
ASSERT_EQUAL_VEC(Vec3(-2.97063e+02, -1.47133e+02, -1.56566e+02), forces1[276], tol); ASSERT_EQUAL_VEC(Vec3(-2.97073240e+02, -1.47150317e+02, -1.56565197e+02), forces1[276], tol);
ASSERT_EQUAL_VEC(Vec3( 4.21742e+01, -2.91448e+02, -1.50260e+02), forces1[277], tol); ASSERT_EQUAL_VEC(Vec3( 4.21710637e+01, -2.91447830e+02, -1.50257335e+02), forces1[277], tol);
ASSERT_EQUAL_VEC(Vec3( 1.75443e+02, -9.12846e+01, 6.45420e+01), forces1[278], tol); ASSERT_EQUAL_VEC(Vec3( 1.75442608e+02, -9.12859677e+01, 6.45491342e+01), forces1[278], tol);
ASSERT_EQUAL_VEC(Vec3( 1.50387e+02, -1.42448e+02, 2.67962e+02), forces1[279], tol); ASSERT_EQUAL_VEC(Vec3( 1.50392869e+02, -1.42464974e+02, 2.67956841e+02), forces1[279], tol);
ASSERT_EQUAL_VEC(Vec3(-4.86650e+02, -2.18609e+01, 1.45714e+02), forces1[280], tol); ASSERT_EQUAL_VEC(Vec3(-4.86651400e+02, -2.18667898e+01, 1.45713495e+02), forces1[280], tol);
ASSERT_EQUAL_VEC(Vec3( 9.28241e+01, -6.94970e+01, -8.88868e+00), forces1[281], tol); ASSERT_EQUAL_VEC(Vec3( 9.28412896e+01, -6.94874667e+01, -8.89080435e+00), forces1[281], tol);
ASSERT_EQUAL_VEC(Vec3(-5.85180e+01, 2.84915e+02, 4.82511e+02), forces1[282], tol); ASSERT_EQUAL_VEC(Vec3(-5.85240520e+01, 2.84901112e+02, 4.82507287e+02), forces1[282], tol);
ASSERT_EQUAL_VEC(Vec3(-2.83566e+01, -1.73726e+02, -3.77869e+02), forces1[283], tol); ASSERT_EQUAL_VEC(Vec3(-2.83558886e+01, -1.73735212e+02, -3.77887550e+02), forces1[283], tol);
ASSERT_EQUAL_VEC(Vec3(-4.34936e+02, -1.30375e+02, -3.31908e+02), forces1[284], tol); ASSERT_EQUAL_VEC(Vec3(-4.34949543e+02, -1.30350821e+02, -3.31882572e+02), forces1[284], tol);
ASSERT_EQUAL_VEC(Vec3( 3.85233e+01, -2.55003e+02, -5.18585e+02), forces1[285], tol); ASSERT_EQUAL_VEC(Vec3( 3.85307564e+01, -2.54990214e+02, -5.18576435e+02), forces1[285], tol);
ASSERT_EQUAL_VEC(Vec3(-7.79025e+01, 1.25369e+02, -3.80662e+02), forces1[286], tol); ASSERT_EQUAL_VEC(Vec3(-7.78941445e+01, 1.25379603e+02, -3.80663737e+02), forces1[286], tol);
ASSERT_EQUAL_VEC(Vec3(-1.27197e+02, 3.88666e+02, 9.40651e+01), forces1[287], tol); ASSERT_EQUAL_VEC(Vec3(-1.27210929e+02, 3.88670263e+02, 9.40643492e+01), forces1[287], tol);
ASSERT_EQUAL_VEC(Vec3( 1.39436e+02, 4.03541e+02, -4.33325e+02), forces1[288], tol); ASSERT_EQUAL_VEC(Vec3( 1.39431191e+02, 4.03532370e+02, -4.33316557e+02), forces1[288], tol);
ASSERT_EQUAL_VEC(Vec3(-2.89434e+00, -2.06299e+02, -7.48586e+02), forces1[289], tol); ASSERT_EQUAL_VEC(Vec3(-2.89025871e+00, -2.06301323e+02, -7.48588265e+02), forces1[289], tol);
ASSERT_EQUAL_VEC(Vec3( 1.07919e+01, 2.35872e+02, -1.38380e+02), forces1[290], tol); ASSERT_EQUAL_VEC(Vec3( 1.07859207e+01, 2.35870879e+02, -1.38371079e+02), forces1[290], tol);
ASSERT_EQUAL_VEC(Vec3( 8.60498e+01, 5.74957e+02, 1.95764e+02), forces1[291], tol); ASSERT_EQUAL_VEC(Vec3( 8.60427044e+01, 5.74941322e+02, 1.95760444e+02), forces1[291], tol);
ASSERT_EQUAL_VEC(Vec3(-2.45599e+02, 1.95537e+02, 1.22005e+02), forces1[292], tol); ASSERT_EQUAL_VEC(Vec3(-2.45607229e+02, 1.95528757e+02, 1.22011573e+02), forces1[292], tol);
ASSERT_EQUAL_VEC(Vec3(-3.33827e+02, -2.71377e+02, -3.43363e+02), forces1[293], tol); ASSERT_EQUAL_VEC(Vec3(-3.33845399e+02, -2.71367745e+02, -3.43358433e+02), forces1[293], tol);
ASSERT_EQUAL_VEC(Vec3(-4.28605e+02, 1.60907e+02, 2.18082e+02), forces1[294], tol); ASSERT_EQUAL_VEC(Vec3(-4.28617139e+02, 1.60904342e+02, 2.18072650e+02), forces1[294], tol);
ASSERT_EQUAL_VEC(Vec3(-5.40069e+02, -1.47447e+02, 4.35227e+02), forces1[295], tol); ASSERT_EQUAL_VEC(Vec3(-5.40064874e+02, -1.47448303e+02, 4.35229212e+02), forces1[295], tol);
ASSERT_EQUAL_VEC(Vec3( 1.48802e+02, 3.45668e+01, -1.25816e+02), forces1[296], tol); ASSERT_EQUAL_VEC(Vec3( 1.48815476e+02, 3.45639218e+01, -1.25812382e+02), forces1[296], tol);
ASSERT_EQUAL_VEC(Vec3( 3.39116e+02, 3.68460e+01, 2.99567e+01), forces1[297], tol); ASSERT_EQUAL_VEC(Vec3( 3.39107837e+02, 3.68504225e+01, 2.99572367e+01), forces1[297], tol);
ASSERT_EQUAL_VEC(Vec3(-1.67745e+02, -2.84603e+02, 3.88498e+01), forces1[298], tol); ASSERT_EQUAL_VEC(Vec3(-1.67736264e+02, -2.84608426e+02, 3.88526274e+01), forces1[298], tol);
ASSERT_EQUAL_VEC(Vec3(-3.21486e+02, -4.49320e+02, 1.41899e+02), forces1[299], tol); ASSERT_EQUAL_VEC(Vec3(-3.21480824e+02, -4.49315290e+02, 1.41881616e+02), forces1[299], tol);
ASSERT_EQUAL_VEC(Vec3( 1.16235e+02, 6.79436e+00, -1.08229e+02), forces1[300], tol); ASSERT_EQUAL_VEC(Vec3( 1.16232320e+02, 6.79621131e+00, -1.08227149e+02), forces1[300], tol);
ASSERT_EQUAL_VEC(Vec3(-1.85571e+02, -2.95256e+02, 5.01923e+02), forces1[301], tol); ASSERT_EQUAL_VEC(Vec3(-1.85570778e+02, -2.95260833e+02, 5.01922551e+02), forces1[301], tol);
ASSERT_EQUAL_VEC(Vec3( 9.27659e+01, -3.83909e+02, -2.77954e+02), forces1[302], tol); ASSERT_EQUAL_VEC(Vec3( 9.27568700e+01, -3.83929681e+02, -2.77944844e+02), forces1[302], tol);
ASSERT_EQUAL_VEC(Vec3(-3.97566e+01, 2.84546e+02, 2.33449e+02), forces1[303], tol); ASSERT_EQUAL_VEC(Vec3(-3.97618765e+01, 2.84553517e+02, 2.33447892e+02), forces1[303], tol);
ASSERT_EQUAL_VEC(Vec3( 1.40773e+00, 2.25388e+02, 9.48028e+01), forces1[304], tol); ASSERT_EQUAL_VEC(Vec3( 1.40428160e+00, 2.25397804e+02, 9.47967922e+01), forces1[304], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06089e+02, 2.06344e+02, -2.00210e+02), forces1[305], tol); ASSERT_EQUAL_VEC(Vec3( 1.06100768e+02, 2.06346469e+02, -2.00231208e+02), forces1[305], tol);
ASSERT_EQUAL_VEC(Vec3(-3.33971e+02, -3.09272e+01, -9.23914e+01), forces1[306], tol); ASSERT_EQUAL_VEC(Vec3(-3.33973365e+02, -3.09218137e+01, -9.23886091e+01), forces1[306], tol);
ASSERT_EQUAL_VEC(Vec3( 1.47226e+01, 1.47710e+02, 2.61213e+02), forces1[307], tol); ASSERT_EQUAL_VEC(Vec3( 1.47272865e+01, 1.47732830e+02, 2.61213219e+02), forces1[307], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43970e+01, 1.15103e+02, 1.21348e+02), forces1[308], tol); ASSERT_EQUAL_VEC(Vec3( 4.44151506e+01, 1.15101400e+02, 1.21319924e+02), forces1[308], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53484e+02, 2.00357e+02, 3.38843e+01), forces1[309], tol); ASSERT_EQUAL_VEC(Vec3(-2.53470761e+02, 2.00350042e+02, 3.38960006e+01), forces1[309], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06575e+02, -1.16081e+02, 5.96449e+01), forces1[310], tol); ASSERT_EQUAL_VEC(Vec3( 1.06594777e+02, -1.16077611e+02, 5.96359334e+01), forces1[310], tol);
ASSERT_EQUAL_VEC(Vec3(-2.01613e+02, 4.15966e+01, 4.19306e+02), forces1[311], tol); ASSERT_EQUAL_VEC(Vec3(-2.01610478e+02, 4.15967754e+01, 4.19293914e+02), forces1[311], tol);
ASSERT_EQUAL_VEC(Vec3( 4.40529e+02, 1.34423e+02, 7.74294e+01), forces1[312], tol); ASSERT_EQUAL_VEC(Vec3( 4.40516207e+02, 1.34417352e+02, 7.74205210e+01), forces1[312], tol);
ASSERT_EQUAL_VEC(Vec3(-3.89161e+02, -2.83338e+02, -4.23553e+02), forces1[313], tol); ASSERT_EQUAL_VEC(Vec3(-3.89160154e+02, -2.83344572e+02, -4.23546685e+02), forces1[313], tol);
ASSERT_EQUAL_VEC(Vec3( 2.42069e+02, -6.45977e+02, 3.91509e+02), forces1[314], tol); ASSERT_EQUAL_VEC(Vec3( 2.42068089e+02, -6.45978033e+02, 3.91506210e+02), forces1[314], tol);
ASSERT_EQUAL_VEC(Vec3(-3.71527e+02, -4.54069e+01, 5.02864e+02), forces1[315], tol); ASSERT_EQUAL_VEC(Vec3(-3.71531404e+02, -4.54039493e+01, 5.02846871e+02), forces1[315], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52580e+02, 8.61014e+01, 2.63795e+02), forces1[316], tol); ASSERT_EQUAL_VEC(Vec3(-3.52589600e+02, 8.61061306e+01, 2.63798519e+02), forces1[316], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18271e+01, -1.24899e+02, -2.32014e+02), forces1[317], tol); ASSERT_EQUAL_VEC(Vec3( 2.18337261e+01, -1.24898517e+02, -2.32012734e+02), forces1[317], tol);
ASSERT_EQUAL_VEC(Vec3(-4.28761e+02, 2.69300e+02, -1.63298e+02), forces1[318], tol); ASSERT_EQUAL_VEC(Vec3(-4.28763733e+02, 2.69298277e+02, -1.63307373e+02), forces1[318], tol);
ASSERT_EQUAL_VEC(Vec3( 6.90322e+01, 2.01135e+02, -1.25402e+02), forces1[319], tol); ASSERT_EQUAL_VEC(Vec3( 6.90348283e+01, 2.01119799e+02, -1.25394407e+02), forces1[319], tol);
ASSERT_EQUAL_VEC(Vec3( 4.42964e+01, -1.48490e+02, 9.26006e+01), forces1[320], tol); ASSERT_EQUAL_VEC(Vec3( 4.42904652e+01, -1.48495330e+02, 9.26084336e+01), forces1[320], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52919e+01, 1.28674e+02, -3.63355e+02), forces1[321], tol); ASSERT_EQUAL_VEC(Vec3(-3.52950825e+01, 1.28676758e+02, -3.63357597e+02), forces1[321], tol);
ASSERT_EQUAL_VEC(Vec3(-5.24120e+02, -9.42825e+01, 1.18533e+01), forces1[322], tol); ASSERT_EQUAL_VEC(Vec3(-5.24105679e+02, -9.42729828e+01, 1.18442536e+01), forces1[322], tol);
ASSERT_EQUAL_VEC(Vec3( 2.26144e+02, 3.21618e+02, -3.90520e+02), forces1[323], tol); ASSERT_EQUAL_VEC(Vec3( 2.26120919e+02, 3.21635617e+02, -3.90518982e+02), forces1[323], tol);
ASSERT_EQUAL_VEC(Vec3( 3.59335e+01, -3.07403e+02, -5.38388e+01), forces1[324], tol); ASSERT_EQUAL_VEC(Vec3( 3.59312804e+01, -3.07405817e+02, -5.38361197e+01), forces1[324], tol);
ASSERT_EQUAL_VEC(Vec3(-1.17175e+02, 2.29585e+02, 1.57262e+02), forces1[325], tol); ASSERT_EQUAL_VEC(Vec3(-1.17174424e+02, 2.29573805e+02, 1.57259382e+02), forces1[325], tol);
ASSERT_EQUAL_VEC(Vec3(-9.86435e+01, -2.13490e+02, 9.34899e+01), forces1[326], tol); ASSERT_EQUAL_VEC(Vec3(-9.86427642e+01, -2.13494062e+02, 9.34926885e+01), forces1[326], tol);
ASSERT_EQUAL_VEC(Vec3( 2.32246e+02, 6.06594e+01, -3.57480e+02), forces1[327], tol); ASSERT_EQUAL_VEC(Vec3( 2.32229566e+02, 6.06664996e+01, -3.57479293e+02), forces1[327], tol);
ASSERT_EQUAL_VEC(Vec3(-4.16049e+01, 1.12553e+02, -2.00669e+02), forces1[328], tol); ASSERT_EQUAL_VEC(Vec3(-4.16211931e+01, 1.12554898e+02, -2.00660318e+02), forces1[328], tol);
ASSERT_EQUAL_VEC(Vec3(-5.14912e+01, 2.96281e+02, 3.68499e+02), forces1[329], tol); ASSERT_EQUAL_VEC(Vec3(-5.14819799e+01, 2.96285849e+02, 3.68505357e+02), forces1[329], tol);
ASSERT_EQUAL_VEC(Vec3( 1.02085e+02, -9.70777e+01, 3.02494e+01), forces1[330], tol); ASSERT_EQUAL_VEC(Vec3( 1.02082491e+02, -9.70741301e+01, 3.02493232e+01), forces1[330], tol);
ASSERT_EQUAL_VEC(Vec3(-1.03766e+02, -1.54754e+02, 2.10255e+02), forces1[331], tol); ASSERT_EQUAL_VEC(Vec3(-1.03774260e+02, -1.54760894e+02, 2.10251674e+02), forces1[331], tol);
ASSERT_EQUAL_VEC(Vec3( 1.90537e+02, 6.04458e+01, -9.59242e+01), forces1[332], tol); ASSERT_EQUAL_VEC(Vec3( 1.90529911e+02, 6.04211367e+01, -9.59263387e+01), forces1[332], tol);
ASSERT_EQUAL_VEC(Vec3(-1.16805e+02, -5.22835e+02, 5.66580e+02), forces1[333], tol); ASSERT_EQUAL_VEC(Vec3(-1.16797386e+02, -5.22831328e+02, 5.66578589e+02), forces1[333], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18107e+02, -1.37436e+02, 1.53049e+02), forces1[334], tol); ASSERT_EQUAL_VEC(Vec3( 2.18104094e+02, -1.37421044e+02, 1.53038417e+02), forces1[334], tol);
ASSERT_EQUAL_VEC(Vec3(-9.04326e+01, -1.47594e+02, 8.89496e+01), forces1[335], tol); ASSERT_EQUAL_VEC(Vec3(-9.04351491e+01, -1.47606538e+02, 8.89490712e+01), forces1[335], tol);
ASSERT_EQUAL_VEC(Vec3( 2.09848e+01, -2.05499e+02, 1.26842e+02), forces1[336], tol); ASSERT_EQUAL_VEC(Vec3( 2.09976599e+01, -2.05500194e+02, 1.26830512e+02), forces1[336], tol);
ASSERT_EQUAL_VEC(Vec3(-1.68058e+02, -2.97755e+02, -1.20737e+02), forces1[337], tol); ASSERT_EQUAL_VEC(Vec3(-1.68042754e+02, -2.97763125e+02, -1.20743571e+02), forces1[337], tol);
ASSERT_EQUAL_VEC(Vec3( 3.99121e+02, 2.95138e+02, 3.91146e+02), forces1[338], tol); ASSERT_EQUAL_VEC(Vec3( 3.99127236e+02, 2.95151794e+02, 3.91132406e+02), forces1[338], tol);
ASSERT_EQUAL_VEC(Vec3( 6.84892e+02, -2.36113e+02, 3.42250e+02), forces1[339], tol); ASSERT_EQUAL_VEC(Vec3( 6.84892471e+02, -2.36108313e+02, 3.42251555e+02), forces1[339], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26652e+02, 1.75709e+02, 1.84797e+02), forces1[340], tol); ASSERT_EQUAL_VEC(Vec3(-1.26672745e+02, 1.75724905e+02, 1.84788262e+02), forces1[340], tol);
ASSERT_EQUAL_VEC(Vec3(-1.32499e+01, 4.13674e+01, -7.23874e+01), forces1[341], tol); ASSERT_EQUAL_VEC(Vec3(-1.32600337e+01, 4.13643381e+01, -7.23942729e+01), forces1[341], tol);
ASSERT_EQUAL_VEC(Vec3(-2.77917e+02, 3.10251e+02, 1.84661e+01), forces1[342], tol); ASSERT_EQUAL_VEC(Vec3(-2.77915476e+02, 3.10253507e+02, 1.84685854e+01), forces1[342], tol);
ASSERT_EQUAL_VEC(Vec3( 1.17776e+02, 2.88281e+02, 2.83210e+02), forces1[343], tol); ASSERT_EQUAL_VEC(Vec3( 1.17778181e+02, 2.88287609e+02, 2.83205737e+02), forces1[343], tol);
ASSERT_EQUAL_VEC(Vec3(-2.14368e+01, 5.21211e+02, 1.00235e+02), forces1[344], tol); ASSERT_EQUAL_VEC(Vec3(-2.14268136e+01, 5.21209080e+02, 1.00248187e+02), forces1[344], tol);
ASSERT_EQUAL_VEC(Vec3( 1.24335e+02, -1.12315e+02, 2.11962e+02), forces1[345], tol); ASSERT_EQUAL_VEC(Vec3( 1.24343155e+02, -1.12330818e+02, 2.11958643e+02), forces1[345], tol);
ASSERT_EQUAL_VEC(Vec3( 6.49798e+00, 2.20331e+02, -3.03861e+02), forces1[346], tol); ASSERT_EQUAL_VEC(Vec3( 6.50667567e+00, 2.20334635e+02, -3.03866910e+02), forces1[346], tol);
ASSERT_EQUAL_VEC(Vec3( 3.27044e+02, 1.14369e+02, 4.53333e+02), forces1[347], tol); ASSERT_EQUAL_VEC(Vec3( 3.27052657e+02, 1.14360733e+02, 4.53348042e+02), forces1[347], tol);
ASSERT_EQUAL_VEC(Vec3( 3.89494e+01, 3.55287e+02, 2.25431e+01), forces1[348], tol); ASSERT_EQUAL_VEC(Vec3( 3.89440847e+01, 3.55283477e+02, 2.25739503e+01), forces1[348], tol);
ASSERT_EQUAL_VEC(Vec3(-2.25243e+02, -2.30571e+02, -2.32661e+02), forces1[349], tol); ASSERT_EQUAL_VEC(Vec3(-2.25235013e+02, -2.30566443e+02, -2.32657384e+02), forces1[349], tol);
ASSERT_EQUAL_VEC(Vec3(-4.40561e+02, -4.18861e+01, -8.73158e+01), forces1[350], tol); ASSERT_EQUAL_VEC(Vec3(-4.40565237e+02, -4.18860845e+01, -8.73230334e+01), forces1[350], tol);
ASSERT_EQUAL_VEC(Vec3( 2.03284e+02, -7.41953e+01, -3.11219e+02), forces1[351], tol); ASSERT_EQUAL_VEC(Vec3( 2.03282144e+02, -7.41935514e+01, -3.11210179e+02), forces1[351], tol);
ASSERT_EQUAL_VEC(Vec3( 3.14055e+02, -4.52020e+01, 1.15697e+02), forces1[352], tol); ASSERT_EQUAL_VEC(Vec3( 3.14039162e+02, -4.52223142e+01, 1.15692941e+02), forces1[352], tol);
ASSERT_EQUAL_VEC(Vec3(-3.05768e+02, -8.44042e+01, 2.77050e+02), forces1[353], tol); ASSERT_EQUAL_VEC(Vec3(-3.05758853e+02, -8.44053388e+01, 2.77050868e+02), forces1[353], tol);
ASSERT_EQUAL_VEC(Vec3( 6.03157e+02, 7.49838e+01, 1.08085e+02), forces1[354], tol); ASSERT_EQUAL_VEC(Vec3( 6.03148128e+02, 7.49868064e+01, 1.08098034e+02), forces1[354], tol);
ASSERT_EQUAL_VEC(Vec3( 1.19381e+02, 3.22000e+02, 1.19609e+01), forces1[355], tol); ASSERT_EQUAL_VEC(Vec3( 1.19374260e+02, 3.21999447e+02, 1.19594257e+01), forces1[355], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06927e+02, 2.87605e+01, 2.37359e+02), forces1[356], tol); ASSERT_EQUAL_VEC(Vec3( 1.06938874e+02, 2.87582961e+01, 2.37371892e+02), forces1[356], tol);
ASSERT_EQUAL_VEC(Vec3( 3.21438e+02, -7.92930e+02, 4.18608e+01), forces1[357], tol); ASSERT_EQUAL_VEC(Vec3( 3.21431483e+02, -7.92928539e+02, 4.18517370e+01), forces1[357], tol);
ASSERT_EQUAL_VEC(Vec3(-1.08646e+02, 2.36723e+02, -5.75423e+02), forces1[358], tol); ASSERT_EQUAL_VEC(Vec3(-1.08651668e+02, 2.36736551e+02, -5.75424218e+02), forces1[358], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53722e+02, -4.66566e+02, 3.71594e+02), forces1[359], tol); ASSERT_EQUAL_VEC(Vec3(-1.53739502e+02, -4.66583392e+02, 3.71587906e+02), forces1[359], tol);
ASSERT_EQUAL_VEC(Vec3(-1.56276e+02, -8.97133e+01, -3.26302e+02), forces1[360], tol); ASSERT_EQUAL_VEC(Vec3(-1.56290228e+02, -8.97065131e+01, -3.26308160e+02), forces1[360], tol);
ASSERT_EQUAL_VEC(Vec3( 3.42782e+02, -3.18233e+01, -4.08916e+02), forces1[361], tol); ASSERT_EQUAL_VEC(Vec3( 3.42780206e+02, -3.18082387e+01, -4.08917799e+02), forces1[361], tol);
ASSERT_EQUAL_VEC(Vec3( 1.47594e+02, 4.76903e+02, 4.19645e+01), forces1[362], tol); ASSERT_EQUAL_VEC(Vec3( 1.47584556e+02, 4.76918724e+02, 4.19802714e+01), forces1[362], tol);
ASSERT_EQUAL_VEC(Vec3( 6.14676e-01, -4.13536e+01, 4.39900e+02), forces1[363], tol); ASSERT_EQUAL_VEC(Vec3( 6.13790369e-01, -4.13596811e+01, 4.39898790e+02), forces1[363], tol);
ASSERT_EQUAL_VEC(Vec3(-2.56826e+02, -1.83027e+02, 6.00002e+01), forces1[364], tol); ASSERT_EQUAL_VEC(Vec3(-2.56833301e+02, -1.83037454e+02, 5.99913896e+01), forces1[364], tol);
ASSERT_EQUAL_VEC(Vec3( 2.48241e+02, 5.50134e+01, -1.54900e+01), forces1[365], tol); ASSERT_EQUAL_VEC(Vec3( 2.48242646e+02, 5.50143719e+01, -1.55138787e+01), forces1[365], tol);
ASSERT_EQUAL_VEC(Vec3(-1.93623e+02, -1.86578e+01, 5.86681e-01), forces1[366], tol); ASSERT_EQUAL_VEC(Vec3(-1.93628316e+02, -1.86534319e+01, 6.08100347e-01), forces1[366], tol);
ASSERT_EQUAL_VEC(Vec3(-1.63206e+02, 1.90024e+02, -4.93445e+02), forces1[367], tol); ASSERT_EQUAL_VEC(Vec3(-1.63211080e+02, 1.90023269e+02, -4.93452441e+02), forces1[367], tol);
ASSERT_EQUAL_VEC(Vec3(-2.85344e+01, -4.66039e+02, -2.10845e+02), forces1[368], tol); ASSERT_EQUAL_VEC(Vec3(-2.85383893e+01, -4.66032637e+02, -2.10849424e+02), forces1[368], tol);
ASSERT_EQUAL_VEC(Vec3( 2.27152e+02, 1.52674e+01, -1.64065e+02), forces1[369], tol); ASSERT_EQUAL_VEC(Vec3( 2.27151522e+02, 1.52613464e+01, -1.64052797e+02), forces1[369], tol);
ASSERT_EQUAL_VEC(Vec3(-1.07162e+02, 2.01289e+01, 6.04856e+01), forces1[370], tol); ASSERT_EQUAL_VEC(Vec3(-1.07153893e+02, 2.01257828e+01, 6.04845684e+01), forces1[370], tol);
ASSERT_EQUAL_VEC(Vec3( 2.41330e+02, 4.05680e+02, -8.71450e+01), forces1[371], tol); ASSERT_EQUAL_VEC(Vec3( 2.41332167e+02, 4.05683718e+02, -8.71412268e+01), forces1[371], tol);
ASSERT_EQUAL_VEC(Vec3( 1.33802e+02, 1.72175e+02, -1.15342e+02), forces1[372], tol); ASSERT_EQUAL_VEC(Vec3( 1.33799918e+02, 1.72174836e+02, -1.15342391e+02), forces1[372], tol);
ASSERT_EQUAL_VEC(Vec3( 4.19294e+02, -4.68240e+02, -3.30499e+02), forces1[373], tol); ASSERT_EQUAL_VEC(Vec3( 4.19296496e+02, -4.68248373e+02, -3.30514440e+02), forces1[373], tol);
ASSERT_EQUAL_VEC(Vec3(-1.88016e+02, -2.43520e+02, 8.86746e+01), forces1[374], tol); ASSERT_EQUAL_VEC(Vec3(-1.88005342e+02, -2.43525310e+02, 8.87016270e+01), forces1[374], tol);
ASSERT_EQUAL_VEC(Vec3( 1.54035e+02, 2.52343e+02, 1.76398e+02), forces1[375], tol); ASSERT_EQUAL_VEC(Vec3( 1.54021861e+02, 2.52343848e+02, 1.76403306e+02), forces1[375], tol);
ASSERT_EQUAL_VEC(Vec3(-1.10653e+02, 3.33211e+01, 1.23759e+02), forces1[376], tol); ASSERT_EQUAL_VEC(Vec3(-1.10645837e+02, 3.33150389e+01, 1.23771287e+02), forces1[376], tol);
ASSERT_EQUAL_VEC(Vec3( 1.64778e+02, 8.99636e-01, 1.56211e+02), forces1[377], tol); ASSERT_EQUAL_VEC(Vec3( 1.64776571e+02, 8.96065400e-01, 1.56210970e+02), forces1[377], tol);
ASSERT_EQUAL_VEC(Vec3(-1.65392e+02, -1.50241e+02, 2.41792e+02), forces1[378], tol); ASSERT_EQUAL_VEC(Vec3(-1.65400014e+02, -1.50236349e+02, 2.41793992e+02), forces1[378], tol);
ASSERT_EQUAL_VEC(Vec3( 4.78065e+02, -2.36430e+02, 4.04926e+02), forces1[379], tol); ASSERT_EQUAL_VEC(Vec3( 4.78064936e+02, -2.36432797e+02, 4.04933329e+02), forces1[379], tol);
ASSERT_EQUAL_VEC(Vec3(-2.33371e+02, -7.47061e+02, 1.09718e+02), forces1[380], tol); ASSERT_EQUAL_VEC(Vec3(-2.33366235e+02, -7.47065850e+02, 1.09704004e+02), forces1[380], tol);
ASSERT_EQUAL_VEC(Vec3( 1.09384e+02, -3.37524e+02, 1.99857e+02), forces1[381], tol); ASSERT_EQUAL_VEC(Vec3( 1.09391089e+02, -3.37517532e+02, 1.99876556e+02), forces1[381], tol);
ASSERT_EQUAL_VEC(Vec3( 1.45362e+02, 1.34679e+02, 3.46392e+02), forces1[382], tol); ASSERT_EQUAL_VEC(Vec3( 1.45367287e+02, 1.34686504e+02, 3.46411849e+02), forces1[382], tol);
ASSERT_EQUAL_VEC(Vec3(-8.87085e+01, 1.70745e+02, 1.86643e+02), forces1[383], tol); ASSERT_EQUAL_VEC(Vec3(-8.86938780e+01, 1.70740693e+02, 1.86633045e+02), forces1[383], tol);
ASSERT_EQUAL_VEC(Vec3( 1.03273e+02, -2.54993e+02, -2.04401e+01), forces1[384], tol); ASSERT_EQUAL_VEC(Vec3( 1.03267086e+02, -2.54994757e+02, -2.04500741e+01), forces1[384], tol);
ASSERT_EQUAL_VEC(Vec3(-5.06134e+02, -3.72064e+02, 9.10803e+01), forces1[385], tol); ASSERT_EQUAL_VEC(Vec3(-5.06124981e+02, -3.72066492e+02, 9.10787327e+01), forces1[385], tol);
ASSERT_EQUAL_VEC(Vec3( 4.33832e+02, 5.30910e+02, 1.18184e+02), forces1[386], tol); ASSERT_EQUAL_VEC(Vec3( 4.33830100e+02, 5.30903070e+02, 1.18187318e+02), forces1[386], tol);
ASSERT_EQUAL_VEC(Vec3(-3.34813e+02, 2.29894e+02, 1.73573e+02), forces1[387], tol); ASSERT_EQUAL_VEC(Vec3(-3.34819970e+02, 2.29884568e+02, 1.73578789e+02), forces1[387], tol);
ASSERT_EQUAL_VEC(Vec3(-3.27928e+00, 3.50944e+02, -5.68848e+00), forces1[388], tol); ASSERT_EQUAL_VEC(Vec3(-3.26221462e+00, 3.50944116e+02, -5.69053250e+00), forces1[388], tol);
ASSERT_EQUAL_VEC(Vec3(-3.18231e+02, -4.16029e+02, 3.91338e+00), forces1[389], tol); ASSERT_EQUAL_VEC(Vec3(-3.18235913e+02, -4.16037121e+02, 3.93503581e+00), forces1[389], tol);
ASSERT_EQUAL_VEC(Vec3(-9.01667e+01, -2.83146e+02, -1.78615e+02), forces1[390], tol); ASSERT_EQUAL_VEC(Vec3(-9.01641240e+01, -2.83129838e+02, -1.78590049e+02), forces1[390], tol);
ASSERT_EQUAL_VEC(Vec3(-1.86926e+02, 2.96529e+02, -1.29636e+02), forces1[391], tol); ASSERT_EQUAL_VEC(Vec3(-1.86933795e+02, 2.96536275e+02, -1.29641779e+02), forces1[391], tol);
ASSERT_EQUAL_VEC(Vec3(-7.78106e+02, 3.37786e+02, 2.46235e+02), forces1[392], tol); ASSERT_EQUAL_VEC(Vec3(-7.78116915e+02, 3.37770325e+02, 2.46251396e+02), forces1[392], tol);
ASSERT_EQUAL_VEC(Vec3(-4.88271e+02, -3.62828e+02, 1.09219e+02), forces1[393], tol); ASSERT_EQUAL_VEC(Vec3(-4.88284661e+02, -3.62815567e+02, 1.09199755e+02), forces1[393], tol);
ASSERT_EQUAL_VEC(Vec3( 1.68826e+02, -1.54083e+02, 2.44132e+02), forces1[394], tol); ASSERT_EQUAL_VEC(Vec3( 1.68815587e+02, -1.54091010e+02, 2.44129524e+02), forces1[394], tol);
ASSERT_EQUAL_VEC(Vec3( 8.59819e+01, -4.73415e+02, 1.81320e+02), forces1[395], tol); ASSERT_EQUAL_VEC(Vec3( 8.59930047e+01, -4.73421243e+02, 1.81326697e+02), forces1[395], tol);
ASSERT_EQUAL_VEC(Vec3(-5.15308e+01, 3.80574e+01, 1.48503e+02), forces1[396], tol); ASSERT_EQUAL_VEC(Vec3(-5.15421845e+01, 3.80615163e+01, 1.48495241e+02), forces1[396], tol);
ASSERT_EQUAL_VEC(Vec3( 4.40897e+02, -9.36809e+01, 2.19941e+02), forces1[397], tol); ASSERT_EQUAL_VEC(Vec3( 4.40902491e+02, -9.36772951e+01, 2.19937945e+02), forces1[397], tol);
ASSERT_EQUAL_VEC(Vec3( 4.56047e+01, 5.74619e+02, -5.74937e+01), forces1[398], tol); ASSERT_EQUAL_VEC(Vec3( 4.55969069e+01, 5.74615780e+02, -5.74937832e+01), forces1[398], tol);
ASSERT_EQUAL_VEC(Vec3( 1.07801e+02, -3.19751e+02, 1.15905e+01), forces1[399], tol); ASSERT_EQUAL_VEC(Vec3( 1.07815006e+02, -3.19754972e+02, 1.16024132e+01), forces1[399], tol);
ASSERT_EQUAL_VEC(Vec3(-1.73808e+02, -1.72659e+02, 3.26117e+02), forces1[400], tol); ASSERT_EQUAL_VEC(Vec3(-1.73815462e+02, -1.72653517e+02, 3.26124498e+02), forces1[400], tol);
ASSERT_EQUAL_VEC(Vec3(-4.48602e+02, -4.95399e+02, -1.37766e+02), forces1[401], tol); ASSERT_EQUAL_VEC(Vec3(-4.48598839e+02, -4.95402699e+02, -1.37769354e+02), forces1[401], tol);
ASSERT_EQUAL_VEC(Vec3( 1.43495e+02, -7.71750e+01, 1.27159e+02), forces1[402], tol); ASSERT_EQUAL_VEC(Vec3( 1.43484140e+02, -7.71666828e+01, 1.27161815e+02), forces1[402], tol);
ASSERT_EQUAL_VEC(Vec3( 1.26037e+02, -3.81387e+02, -2.85769e+02), forces1[403], tol); ASSERT_EQUAL_VEC(Vec3( 1.26016451e+02, -3.81399993e+02, -2.85764454e+02), forces1[403], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53044e+02, -2.67885e+02, 1.51847e+02), forces1[404], tol); ASSERT_EQUAL_VEC(Vec3(-2.53052241e+02, -2.67885549e+02, 1.51849847e+02), forces1[404], tol);
ASSERT_EQUAL_VEC(Vec3(-1.01057e+02, -1.79837e+02, -2.05767e+02), forces1[405], tol); ASSERT_EQUAL_VEC(Vec3(-1.01063516e+02, -1.79837645e+02, -2.05759531e+02), forces1[405], tol);
ASSERT_EQUAL_VEC(Vec3( 1.32060e+02, -2.56999e+02, -4.06122e+02), forces1[406], tol); ASSERT_EQUAL_VEC(Vec3( 1.32065714e+02, -2.56988983e+02, -4.06119988e+02), forces1[406], tol);
ASSERT_EQUAL_VEC(Vec3( 5.49851e+01, 5.20976e+01, -2.41015e+01), forces1[407], tol); ASSERT_EQUAL_VEC(Vec3( 5.49845413e+01, 5.21020888e+01, -2.40829321e+01), forces1[407], tol);
ASSERT_EQUAL_VEC(Vec3(-3.04221e+01, -3.45388e+02, 3.52728e+02), forces1[408], tol); ASSERT_EQUAL_VEC(Vec3(-3.04151550e+01, -3.45385052e+02, 3.52732396e+02), forces1[408], tol);
ASSERT_EQUAL_VEC(Vec3( 5.76191e+02, 2.51418e+02, -2.05688e+02), forces1[409], tol); ASSERT_EQUAL_VEC(Vec3( 5.76196622e+02, 2.51408790e+02, -2.05694905e+02), forces1[409], tol);
ASSERT_EQUAL_VEC(Vec3(-5.46251e+02, -3.81438e+01, 1.55939e+02), forces1[410], tol); ASSERT_EQUAL_VEC(Vec3(-5.46232631e+02, -3.81426810e+01, 1.55940692e+02), forces1[410], tol);
ASSERT_EQUAL_VEC(Vec3(-1.00756e+02, 2.13316e+02, 3.33080e+02), forces1[411], tol); ASSERT_EQUAL_VEC(Vec3(-1.00759671e+02, 2.13338964e+02, 3.33068075e+02), forces1[411], tol);
ASSERT_EQUAL_VEC(Vec3( 8.00305e+01, 1.85311e+02, -4.43364e+02), forces1[412], tol); ASSERT_EQUAL_VEC(Vec3( 8.00270910e+01, 1.85305844e+02, -4.43363841e+02), forces1[412], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53972e+02, 1.76435e+01, 5.07005e+01), forces1[413], tol); ASSERT_EQUAL_VEC(Vec3(-1.53961901e+02, 1.76452569e+01, 5.07044493e+01), forces1[413], tol);
ASSERT_EQUAL_VEC(Vec3(-2.54134e+01, -1.01744e+02, -1.47135e+02), forces1[414], tol); ASSERT_EQUAL_VEC(Vec3(-2.54074128e+01, -1.01739609e+02, -1.47118371e+02), forces1[414], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53024e+02, 2.89712e+02, -1.78278e+02), forces1[415], tol); ASSERT_EQUAL_VEC(Vec3(-2.53018564e+02, 2.89709169e+02, -1.78282141e+02), forces1[415], tol);
ASSERT_EQUAL_VEC(Vec3(-1.30254e+02, -4.66605e+02, -3.53366e+02), forces1[416], tol); ASSERT_EQUAL_VEC(Vec3(-1.30257510e+02, -4.66610129e+02, -3.53374887e+02), forces1[416], tol);
ASSERT_EQUAL_VEC(Vec3( 1.82467e+02, 3.77979e+02, 1.90487e+02), forces1[417], tol); ASSERT_EQUAL_VEC(Vec3( 1.82472116e+02, 3.77974857e+02, 1.90476251e+02), forces1[417], tol);
ASSERT_EQUAL_VEC(Vec3(-2.59807e+02, 3.29707e+02, 3.93434e+02), forces1[418], tol); ASSERT_EQUAL_VEC(Vec3(-2.59801797e+02, 3.29708022e+02, 3.93439213e+02), forces1[418], tol);
ASSERT_EQUAL_VEC(Vec3(-1.08616e+01, -5.30934e+02, -1.53158e+01), forces1[419], tol); ASSERT_EQUAL_VEC(Vec3(-1.08573872e+01, -5.30931700e+02, -1.53102646e+01), forces1[419], tol);
ASSERT_EQUAL_VEC(Vec3(-3.27780e+01, -3.45924e+02, -1.45599e+02), forces1[420], tol); ASSERT_EQUAL_VEC(Vec3(-3.27827015e+01, -3.45915139e+02, -1.45604367e+02), forces1[420], tol);
ASSERT_EQUAL_VEC(Vec3(-1.92422e+02, 3.68852e+00, -1.26535e+02), forces1[421], tol); ASSERT_EQUAL_VEC(Vec3(-1.92424159e+02, 3.69087390e+00, -1.26537763e+02), forces1[421], tol);
ASSERT_EQUAL_VEC(Vec3( 2.61442e+02, -1.63245e+02, -1.22723e+02), forces1[422], tol); ASSERT_EQUAL_VEC(Vec3( 2.61430852e+02, -1.63239575e+02, -1.22742408e+02), forces1[422], tol);
ASSERT_EQUAL_VEC(Vec3(-1.42880e+02, 4.15431e+02, 5.04207e+02), forces1[423], tol); ASSERT_EQUAL_VEC(Vec3(-1.42902423e+02, 4.15429338e+02, 5.04220960e+02), forces1[423], tol);
ASSERT_EQUAL_VEC(Vec3( 3.36583e+02, -1.06056e+02, 4.54191e+02), forces1[424], tol); ASSERT_EQUAL_VEC(Vec3( 3.36581855e+02, -1.06051528e+02, 4.54169047e+02), forces1[424], tol);
ASSERT_EQUAL_VEC(Vec3(-2.32222e+02, -1.87571e+00, 4.48431e+01), forces1[425], tol); ASSERT_EQUAL_VEC(Vec3(-2.32221397e+02, -1.86391490e+00, 4.48412526e+01), forces1[425], tol);
ASSERT_EQUAL_VEC(Vec3( 4.12420e+02, -5.04674e+02, 4.00890e+02), forces1[426], tol); ASSERT_EQUAL_VEC(Vec3( 4.12435657e+02, -5.04677016e+02, 4.00894902e+02), forces1[426], tol);
ASSERT_EQUAL_VEC(Vec3(-1.54634e+02, -2.68568e+02, -1.52867e+01), forces1[427], tol); ASSERT_EQUAL_VEC(Vec3(-1.54630518e+02, -2.68571764e+02, -1.52962938e+01), forces1[427], tol);
ASSERT_EQUAL_VEC(Vec3( 2.69730e+02, 2.18572e+02, -1.75348e+02), forces1[428], tol); ASSERT_EQUAL_VEC(Vec3( 2.69725750e+02, 2.18570974e+02, -1.75370463e+02), forces1[428], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77154e+01, -4.66305e+01, 6.24252e+01), forces1[429], tol); ASSERT_EQUAL_VEC(Vec3(-1.77174496e+01, -4.66383654e+01, 6.24325771e+01), forces1[429], tol);
ASSERT_EQUAL_VEC(Vec3(-1.29897e+02, 8.07525e+01, 1.84687e+01), forces1[430], tol); ASSERT_EQUAL_VEC(Vec3(-1.29891497e+02, 8.07513513e+01, 1.84796034e+01), forces1[430], tol);
ASSERT_EQUAL_VEC(Vec3( 1.76180e+02, -3.20026e+02, -2.47786e+02), forces1[431], tol); ASSERT_EQUAL_VEC(Vec3( 1.76173623e+02, -3.20023221e+02, -2.47794470e+02), forces1[431], tol);
ASSERT_EQUAL_VEC(Vec3(-1.68161e+02, 2.05754e+02, -1.17392e+02), forces1[432], tol); ASSERT_EQUAL_VEC(Vec3(-1.68165877e+02, 2.05742253e+02, -1.17371622e+02), forces1[432], tol);
ASSERT_EQUAL_VEC(Vec3(-1.93375e+02, 7.76962e+01, -1.60933e+02), forces1[433], tol); ASSERT_EQUAL_VEC(Vec3(-1.93368937e+02, 7.77030375e+01, -1.60942447e+02), forces1[433], tol);
ASSERT_EQUAL_VEC(Vec3(-8.97755e+01, 2.56570e+02, -3.94698e+02), forces1[434], tol); ASSERT_EQUAL_VEC(Vec3(-8.97795426e+01, 2.56568674e+02, -3.94711205e+02), forces1[434], tol);
ASSERT_EQUAL_VEC(Vec3(-2.33047e+02, 9.53157e+01, 3.03009e+02), forces1[435], tol); ASSERT_EQUAL_VEC(Vec3(-2.33025806e+02, 9.53111817e+01, 3.02984350e+02), forces1[435], tol);
ASSERT_EQUAL_VEC(Vec3( 4.34541e+01, -4.44332e+02, -5.00367e+00), forces1[436], tol); ASSERT_EQUAL_VEC(Vec3( 4.34416040e+01, -4.44341362e+02, -4.99903855e+00), forces1[436], tol);
ASSERT_EQUAL_VEC(Vec3( 3.32043e+02, -4.10856e+02, -6.13640e+01), forces1[437], tol); ASSERT_EQUAL_VEC(Vec3( 3.32041110e+02, -4.10874874e+02, -6.13697373e+01), forces1[437], tol);
ASSERT_EQUAL_VEC(Vec3(-1.45963e+02, -2.28303e+02, -2.99006e+02), forces1[438], tol); ASSERT_EQUAL_VEC(Vec3(-1.45971034e+02, -2.28311940e+02, -2.99006034e+02), forces1[438], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38544e+02, -1.27387e+02, -2.93858e+02), forces1[439], tol); ASSERT_EQUAL_VEC(Vec3(-1.38544644e+02, -1.27394726e+02, -2.93844502e+02), forces1[439], tol);
ASSERT_EQUAL_VEC(Vec3( 2.97426e+02, 3.38275e+02, -2.14825e+02), forces1[440], tol); ASSERT_EQUAL_VEC(Vec3( 2.97433737e+02, 3.38274025e+02, -2.14834485e+02), forces1[440], tol);
ASSERT_EQUAL_VEC(Vec3( 2.49303e+01, 1.88458e+02, -8.02836e+01), forces1[441], tol); ASSERT_EQUAL_VEC(Vec3( 2.49325388e+01, 1.88464224e+02, -8.02957242e+01), forces1[441], tol);
ASSERT_EQUAL_VEC(Vec3(-1.32435e+02, -3.86547e+02, -6.69703e+01), forces1[442], tol); ASSERT_EQUAL_VEC(Vec3(-1.32436289e+02, -3.86539713e+02, -6.69802109e+01), forces1[442], tol);
ASSERT_EQUAL_VEC(Vec3( 1.84539e+01, 2.24797e+02, -1.36943e+02), forces1[443], tol); ASSERT_EQUAL_VEC(Vec3( 1.84591010e+01, 2.24796153e+02, -1.36943849e+02), forces1[443], tol);
ASSERT_EQUAL_VEC(Vec3( 2.15330e+02, 1.06093e+02, -1.25714e+02), forces1[444], tol); ASSERT_EQUAL_VEC(Vec3( 2.15317088e+02, 1.06092575e+02, -1.25718903e+02), forces1[444], tol);
ASSERT_EQUAL_VEC(Vec3( 3.07790e+02, 4.34360e+02, 2.17130e+01), forces1[445], tol); ASSERT_EQUAL_VEC(Vec3( 3.07793097e+02, 4.34340797e+02, 2.17184869e+01), forces1[445], tol);
ASSERT_EQUAL_VEC(Vec3( 8.07389e+00, 4.99898e+01, -3.14240e+02), forces1[446], tol); ASSERT_EQUAL_VEC(Vec3( 8.06779109e+00, 4.99925960e+01, -3.14233384e+02), forces1[446], tol);
ASSERT_EQUAL_VEC(Vec3( 1.36944e+03, 6.44803e+02, -3.85105e+02), forces1[447], tol); ASSERT_EQUAL_VEC(Vec3( 1.36943103e+03, 6.44803649e+02, -3.85109067e+02), forces1[447], tol);
ASSERT_EQUAL_VEC(Vec3( 3.32234e+02, -1.04226e+02, -4.08588e+02), forces1[448], tol); ASSERT_EQUAL_VEC(Vec3( 3.32242272e+02, -1.04208324e+02, -4.08589589e+02), forces1[448], tol);
ASSERT_EQUAL_VEC(Vec3( 3.73257e+02, 2.70945e+02, 3.80711e+02), forces1[449], tol); ASSERT_EQUAL_VEC(Vec3( 3.73255876e+02, 2.70951542e+02, 3.80697548e+02), forces1[449], tol);
ASSERT_EQUAL_VEC(Vec3(-2.09788e+02, 4.29894e+02, 8.40836e+02), forces1[450], tol); ASSERT_EQUAL_VEC(Vec3(-2.09798900e+02, 4.29900198e+02, 8.40839028e+02), forces1[450], tol);
ASSERT_EQUAL_VEC(Vec3(-3.48541e+02, -3.63126e+02, 5.10386e+02), forces1[451], tol); ASSERT_EQUAL_VEC(Vec3(-3.48538763e+02, -3.63130308e+02, 5.10379446e+02), forces1[451], tol);
ASSERT_EQUAL_VEC(Vec3(-3.28289e+00, 4.56623e-01, -6.04133e+00), forces1[452], tol); ASSERT_EQUAL_VEC(Vec3(-3.28341714e+00, 4.69698489e-01, -6.05231376e+00), forces1[452], tol);
ASSERT_EQUAL_VEC(Vec3( 3.83213e+01, 3.59835e+02, 8.67060e+02), forces1[453], tol); ASSERT_EQUAL_VEC(Vec3( 3.83253792e+01, 3.59830676e+02, 8.67060383e+02), forces1[453], tol);
ASSERT_EQUAL_VEC(Vec3(-1.57372e+02, 5.68723e+02, -1.87736e+02), forces1[454], tol); ASSERT_EQUAL_VEC(Vec3(-1.57391804e+02, 5.68715567e+02, -1.87718510e+02), forces1[454], tol);
ASSERT_EQUAL_VEC(Vec3( 4.16135e+02, 5.83005e+01, -5.75721e+02), forces1[455], tol); ASSERT_EQUAL_VEC(Vec3( 4.16155580e+02, 5.83079478e+01, -5.75730469e+02), forces1[455], tol);
ASSERT_EQUAL_VEC(Vec3( 2.58781e+02, -1.00658e+02, -4.43422e+02), forces1[456], tol); ASSERT_EQUAL_VEC(Vec3( 2.58779906e+02, -1.00655656e+02, -4.43420159e+02), forces1[456], tol);
ASSERT_EQUAL_VEC(Vec3( 1.38964e+02, 4.93481e+02, 9.06769e+02), forces1[457], tol); ASSERT_EQUAL_VEC(Vec3( 1.38953668e+02, 4.93490759e+02, 9.06786307e+02), forces1[457], tol);
ASSERT_EQUAL_VEC(Vec3(-4.81144e+01, 9.53316e+02, -1.83930e+02), forces1[458], tol); ASSERT_EQUAL_VEC(Vec3(-4.81272447e+01, 9.53310029e+02, -1.83936453e+02), forces1[458], tol);
ASSERT_EQUAL_VEC(Vec3( 6.64517e+02, -3.77342e+02, 1.93106e+02), forces1[459], tol); ASSERT_EQUAL_VEC(Vec3( 6.64523579e+02, -3.77321549e+02, 1.93098326e+02), forces1[459], tol);
ASSERT_EQUAL_VEC(Vec3( 8.34258e+01, 1.77799e+02, 4.70668e+02), forces1[460], tol); ASSERT_EQUAL_VEC(Vec3( 8.34547360e+01, 1.77795489e+02, 4.70670853e+02), forces1[460], tol);
ASSERT_EQUAL_VEC(Vec3( 9.98955e+02, -3.98573e+02, 9.83617e+02), forces1[461], tol); ASSERT_EQUAL_VEC(Vec3( 9.98948440e+02, -3.98575936e+02, 9.83617396e+02), forces1[461], tol);
ASSERT_EQUAL_VEC(Vec3(-5.06602e+02, -4.10726e+01, 4.75183e+02), forces1[462], tol); ASSERT_EQUAL_VEC(Vec3(-5.06587875e+02, -4.10766357e+01, 4.75189712e+02), forces1[462], tol);
ASSERT_EQUAL_VEC(Vec3(-7.58561e+01, 1.45224e+02, 4.53017e+01), forces1[463], tol); ASSERT_EQUAL_VEC(Vec3(-7.58615745e+01, 1.45234354e+02, 4.52909546e+01), forces1[463], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13503e+02, 5.29876e+02, -3.00948e+02), forces1[464], tol); ASSERT_EQUAL_VEC(Vec3(-1.13502225e+02, 5.29861493e+02, -3.00954235e+02), forces1[464], tol);
ASSERT_EQUAL_VEC(Vec3(-1.46460e+02, -3.86626e+02, -6.42399e+02), forces1[465], tol); ASSERT_EQUAL_VEC(Vec3(-1.46461752e+02, -3.86629519e+02, -6.42383694e+02), forces1[465], tol);
ASSERT_EQUAL_VEC(Vec3(-2.70162e+02, 3.67197e+02, -1.78819e+02), forces1[466], tol); ASSERT_EQUAL_VEC(Vec3(-2.70141632e+02, 3.67195269e+02, -1.78826923e+02), forces1[466], tol);
ASSERT_EQUAL_VEC(Vec3(-1.23812e+02, -1.77337e+02, 2.37370e+02), forces1[467], tol); ASSERT_EQUAL_VEC(Vec3(-1.23815721e+02, -1.77323218e+02, 2.37363709e+02), forces1[467], tol);
ASSERT_EQUAL_VEC(Vec3(-4.94035e+02, 1.34875e+02, 6.98777e+02), forces1[468], tol); ASSERT_EQUAL_VEC(Vec3(-4.94036325e+02, 1.34870851e+02, 6.98764302e+02), forces1[468], tol);
ASSERT_EQUAL_VEC(Vec3( 7.08737e+02, 1.85253e+02, 5.51154e+02), forces1[469], tol); ASSERT_EQUAL_VEC(Vec3( 7.08752797e+02, 1.85258249e+02, 5.51159246e+02), forces1[469], tol);
ASSERT_EQUAL_VEC(Vec3( 2.01277e+02, -5.84722e+02, 5.82922e+02), forces1[470], tol); ASSERT_EQUAL_VEC(Vec3( 2.01291495e+02, -5.84720738e+02, 5.82921267e+02), forces1[470], tol);
ASSERT_EQUAL_VEC(Vec3( 5.29650e+02, 4.06976e+01, 9.99169e+01), forces1[471], tol); ASSERT_EQUAL_VEC(Vec3( 5.29650511e+02, 4.07054187e+01, 9.99156291e+01), forces1[471], tol);
ASSERT_EQUAL_VEC(Vec3(-1.19729e+02, 4.42970e+02, -2.70454e+02), forces1[472], tol); ASSERT_EQUAL_VEC(Vec3(-1.19707215e+02, 4.42978965e+02, -2.70437350e+02), forces1[472], tol);
ASSERT_EQUAL_VEC(Vec3(-6.87757e+02, -1.32212e+02, -7.35576e+01), forces1[473], tol); ASSERT_EQUAL_VEC(Vec3(-6.87780787e+02, -1.32227443e+02, -7.35818874e+01), forces1[473], tol);
ASSERT_EQUAL_VEC(Vec3(-2.99638e+02, 8.14652e+02, 2.72171e+01), forces1[474], tol); ASSERT_EQUAL_VEC(Vec3(-2.99625888e+02, 8.14649386e+02, 2.72145234e+01), forces1[474], tol);
ASSERT_EQUAL_VEC(Vec3(-2.26054e+02, -3.49826e+02, -2.73662e+02), forces1[475], tol); ASSERT_EQUAL_VEC(Vec3(-2.26042622e+02, -3.49838280e+02, -2.73671757e+02), forces1[475], tol);
ASSERT_EQUAL_VEC(Vec3(-3.38855e+02, 8.74199e+02, 2.98582e+02), forces1[476], tol); ASSERT_EQUAL_VEC(Vec3(-3.38859328e+02, 8.74208207e+02, 2.98575880e+02), forces1[476], tol);
ASSERT_EQUAL_VEC(Vec3( 5.63049e+02, 1.51178e+02, -1.10345e+02), forces1[477], tol); ASSERT_EQUAL_VEC(Vec3( 5.63054826e+02, 1.51181551e+02, -1.10341988e+02), forces1[477], tol);
ASSERT_EQUAL_VEC(Vec3( 3.44145e+02, 2.73281e+02, 5.44571e+02), forces1[478], tol); ASSERT_EQUAL_VEC(Vec3( 3.44122544e+02, 2.73292900e+02, 5.44577027e+02), forces1[478], tol);
ASSERT_EQUAL_VEC(Vec3( 3.29090e+01, 3.66764e+02, 3.30306e+02), forces1[479], tol); ASSERT_EQUAL_VEC(Vec3( 3.29121922e+01, 3.66764263e+02, 3.30304492e+02), forces1[479], tol);
ASSERT_EQUAL_VEC(Vec3(-4.97949e+01, -3.26330e+02, -6.47510e+02), forces1[480], tol); ASSERT_EQUAL_VEC(Vec3(-4.98111364e+01, -3.26335514e+02, -6.47508532e+02), forces1[480], tol);
ASSERT_EQUAL_VEC(Vec3( 6.05943e+01, -1.41030e+02, 4.05559e+02), forces1[481], tol); ASSERT_EQUAL_VEC(Vec3( 6.05970391e+01, -1.41039500e+02, 4.05545963e+02), forces1[481], tol);
ASSERT_EQUAL_VEC(Vec3(-1.35192e+03, 5.06868e+01, -1.40069e+02), forces1[482], tol); ASSERT_EQUAL_VEC(Vec3(-1.35191146e+03, 5.06763950e+01, -1.40076012e+02), forces1[482], tol);
ASSERT_EQUAL_VEC(Vec3( 7.70418e+01, -2.68994e+02, -1.75059e+02), forces1[483], tol); ASSERT_EQUAL_VEC(Vec3( 7.70144671e+01, -2.68985491e+02, -1.75067707e+02), forces1[483], tol);
ASSERT_EQUAL_VEC(Vec3(-1.89546e+02, -2.32976e+02, -2.54881e+02), forces1[484], tol); ASSERT_EQUAL_VEC(Vec3(-1.89547256e+02, -2.32975097e+02, -2.54877338e+02), forces1[484], tol);
ASSERT_EQUAL_VEC(Vec3( 2.37143e+02, 6.49196e+02, 1.01760e+02), forces1[485], tol); ASSERT_EQUAL_VEC(Vec3( 2.37141279e+02, 6.49194662e+02, 1.01757997e+02), forces1[485], tol);
ASSERT_EQUAL_VEC(Vec3(-3.38577e+02, 1.34700e+02, 7.89794e+02), forces1[486], tol); ASSERT_EQUAL_VEC(Vec3(-3.38583468e+02, 1.34692366e+02, 7.89810999e+02), forces1[486], tol);
ASSERT_EQUAL_VEC(Vec3(-5.59979e+02, -1.46810e+02, 3.62578e+01), forces1[487], tol); ASSERT_EQUAL_VEC(Vec3(-5.59974436e+02, -1.46817839e+02, 3.62598852e+01), forces1[487], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52719e+02, 1.16582e+02, -4.55479e+02), forces1[488], tol); ASSERT_EQUAL_VEC(Vec3(-3.52715734e+02, 1.16573021e+02, -4.55490471e+02), forces1[488], tol);
ASSERT_EQUAL_VEC(Vec3( 6.56862e+01, 1.02563e+02, -9.81605e+01), forces1[489], tol); ASSERT_EQUAL_VEC(Vec3( 6.56757625e+01, 1.02550774e+02, -9.81490452e+01), forces1[489], tol);
ASSERT_EQUAL_VEC(Vec3(-4.22979e+02, 8.89173e+02, -9.19659e+01), forces1[490], tol); ASSERT_EQUAL_VEC(Vec3(-4.22997875e+02, 8.89168040e+02, -9.19714230e+01), forces1[490], tol);
ASSERT_EQUAL_VEC(Vec3( 5.13348e+02, 4.56117e+02, -6.85992e+01), forces1[491], tol); ASSERT_EQUAL_VEC(Vec3( 5.13351576e+02, 4.56111157e+02, -6.86014949e+01), forces1[491], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12138e+02, 6.84716e+02, 4.44643e+01), forces1[492], tol); ASSERT_EQUAL_VEC(Vec3( 1.12137269e+02, 6.84704993e+02, 4.44636019e+01), forces1[492], tol);
ASSERT_EQUAL_VEC(Vec3( 2.15958e+02, 3.33080e+02, -4.41262e+02), forces1[493], tol); ASSERT_EQUAL_VEC(Vec3( 2.15980740e+02, 3.33093803e+02, -4.41281918e+02), forces1[493], tol);
ASSERT_EQUAL_VEC(Vec3(-4.66030e-01, -2.16930e+02, -5.39086e+02), forces1[494], tol); ASSERT_EQUAL_VEC(Vec3(-4.77801486e-01, -2.16935238e+02, -5.39082462e+02), forces1[494], tol);
ASSERT_EQUAL_VEC(Vec3(-3.91583e+02, 2.80072e+02, 4.50310e+02), forces1[495], tol); ASSERT_EQUAL_VEC(Vec3(-3.91584043e+02, 2.80049288e+02, 4.50318805e+02), forces1[495], tol);
ASSERT_EQUAL_VEC(Vec3( 2.40456e+02, -1.24635e+02, -2.70112e+02), forces1[496], tol); ASSERT_EQUAL_VEC(Vec3( 2.40458755e+02, -1.24624268e+02, -2.70106867e+02), forces1[496], tol);
ASSERT_EQUAL_VEC(Vec3( 7.23877e+01, 1.59326e+01, -5.24030e+01), forces1[497], tol); ASSERT_EQUAL_VEC(Vec3( 7.23763468e+01, 1.59346249e+01, -5.23998896e+01), forces1[497], tol);
ASSERT_EQUAL_VEC(Vec3(-1.41173e+02, -3.23940e+02, -4.05096e+02), forces1[498], tol); ASSERT_EQUAL_VEC(Vec3(-1.41166795e+02, -3.23959396e+02, -4.05099054e+02), forces1[498], tol);
ASSERT_EQUAL_VEC(Vec3( 3.93718e+02, 3.77836e+02, -4.56289e+02), forces1[499], tol); ASSERT_EQUAL_VEC(Vec3( 3.93723518e+02, 3.77829620e+02, -4.56301133e+02), forces1[499], tol);
ASSERT_EQUAL_VEC(Vec3(-2.68000e+02, -2.12738e+02, -7.96444e+02), forces1[500], tol); ASSERT_EQUAL_VEC(Vec3(-2.68009341e+02, -2.12736933e+02, -7.96445111e+02), forces1[500], tol);
ASSERT_EQUAL_VEC(Vec3( 9.59473e+02, 1.74115e+02, 1.16027e+01), forces1[501], tol); ASSERT_EQUAL_VEC(Vec3( 9.59480600e+02, 1.74115813e+02, 1.16126031e+01), forces1[501], tol);
ASSERT_EQUAL_VEC(Vec3(-3.93566e+01, 1.28980e+01, -1.89342e+02), forces1[502], tol); ASSERT_EQUAL_VEC(Vec3(-3.93575465e+01, 1.29079012e+01, -1.89350441e+02), forces1[502], tol);
ASSERT_EQUAL_VEC(Vec3( 2.49459e+02, 7.84026e+01, -4.78251e+02), forces1[503], tol); ASSERT_EQUAL_VEC(Vec3( 2.49464458e+02, 7.84144311e+01, -4.78252942e+02), forces1[503], tol);
ASSERT_EQUAL_VEC(Vec3( 5.16051e+02, 6.52908e+02, -5.05258e+02), forces1[504], tol); ASSERT_EQUAL_VEC(Vec3( 5.16031453e+02, 6.52899912e+02, -5.05259519e+02), forces1[504], tol);
ASSERT_EQUAL_VEC(Vec3( 5.10772e+01, -5.19623e+02, 6.83232e+00), forces1[505], tol); ASSERT_EQUAL_VEC(Vec3( 5.10845388e+01, -5.19606468e+02, 6.82761515e+00), forces1[505], tol);
ASSERT_EQUAL_VEC(Vec3(-7.69005e+01, -1.13216e+03, -7.05202e+02), forces1[506], tol); ASSERT_EQUAL_VEC(Vec3(-7.68910836e+01, -1.13215494e+03, -7.05213833e+02), forces1[506], tol);
ASSERT_EQUAL_VEC(Vec3(-2.13051e+02, 1.70983e+00, 8.26360e+02), forces1[507], tol); ASSERT_EQUAL_VEC(Vec3(-2.13058157e+02, 1.70549578e+00, 8.26365735e+02), forces1[507], tol);
ASSERT_EQUAL_VEC(Vec3( 1.86646e+01, 1.91406e+02, 4.18425e+02), forces1[508], tol); ASSERT_EQUAL_VEC(Vec3( 1.86647493e+01, 1.91383875e+02, 4.18426660e+02), forces1[508], tol);
ASSERT_EQUAL_VEC(Vec3( 2.35352e+02, 3.79659e+02, -3.13837e+02), forces1[509], tol); ASSERT_EQUAL_VEC(Vec3( 2.35361629e+02, 3.79668975e+02, -3.13824585e+02), forces1[509], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26229e+02, -2.59698e+02, -6.76333e+02), forces1[510], tol); ASSERT_EQUAL_VEC(Vec3(-1.26205360e+02, -2.59705171e+02, -6.76333230e+02), forces1[510], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38231e+02, -3.38609e+02, 2.20483e+02), forces1[511], tol); ASSERT_EQUAL_VEC(Vec3(-1.38240856e+02, -3.38607085e+02, 2.20460843e+02), forces1[511], tol);
ASSERT_EQUAL_VEC(Vec3(-2.25445e+02, -7.80827e+02, -2.43657e+02), forces1[512], tol); ASSERT_EQUAL_VEC(Vec3(-2.25429800e+02, -7.80817051e+02, -2.43643666e+02), forces1[512], tol);
ASSERT_EQUAL_VEC(Vec3(-3.10576e+01, 4.16295e+01, 6.15551e+01), forces1[513], tol); ASSERT_EQUAL_VEC(Vec3(-3.10585529e+01, 4.16080403e+01, 6.15476974e+01), forces1[513], tol);
ASSERT_EQUAL_VEC(Vec3( 6.75625e+01, 9.67875e+01, 6.03427e+02), forces1[514], tol); ASSERT_EQUAL_VEC(Vec3( 6.75639613e+01, 9.67778416e+01, 6.03424295e+02), forces1[514], tol);
ASSERT_EQUAL_VEC(Vec3(-1.27083e+02, -4.75076e+01, 4.67743e+02), forces1[515], tol); ASSERT_EQUAL_VEC(Vec3(-1.27080812e+02, -4.74945218e+01, 4.67735437e+02), forces1[515], tol);
ASSERT_EQUAL_VEC(Vec3(-2.72712e+02, 3.30735e+01, -2.81982e+02), forces1[516], tol); ASSERT_EQUAL_VEC(Vec3(-2.72716149e+02, 3.30769806e+01, -2.81976538e+02), forces1[516], tol);
ASSERT_EQUAL_VEC(Vec3( 4.78713e+02, 8.27546e+01, -3.32376e+02), forces1[517], tol); ASSERT_EQUAL_VEC(Vec3( 4.78709091e+02, 8.27541480e+01, -3.32366235e+02), forces1[517], tol);
ASSERT_EQUAL_VEC(Vec3( 1.48566e+02, 1.88637e+02, -5.92121e+02), forces1[518], tol); ASSERT_EQUAL_VEC(Vec3( 1.48574421e+02, 1.88635391e+02, -5.92117141e+02), forces1[518], tol);
ASSERT_EQUAL_VEC(Vec3(-9.24850e+01, 6.86942e+01, 5.16802e+02), forces1[519], tol); ASSERT_EQUAL_VEC(Vec3(-9.24795792e+01, 6.86826191e+01, 5.16804407e+02), forces1[519], tol);
ASSERT_EQUAL_VEC(Vec3( 4.32914e+02, -4.67486e+02, 1.09364e+02), forces1[520], tol); ASSERT_EQUAL_VEC(Vec3( 4.32902806e+02, -4.67485932e+02, 1.09369501e+02), forces1[520], tol);
ASSERT_EQUAL_VEC(Vec3(-2.19089e+02, 2.10199e+00, 1.05236e+03), forces1[521], tol); ASSERT_EQUAL_VEC(Vec3(-2.19075642e+02, 2.09097287e+00, 1.05235595e+03), forces1[521], tol);
ASSERT_EQUAL_VEC(Vec3(-3.95724e+02, -3.31349e+02, 6.33917e+02), forces1[522], tol); ASSERT_EQUAL_VEC(Vec3(-3.95717922e+02, -3.31346394e+02, 6.33930848e+02), forces1[522], tol);
ASSERT_EQUAL_VEC(Vec3( 2.29088e+01, 5.34152e+02, 3.47856e+01), forces1[523], tol); ASSERT_EQUAL_VEC(Vec3( 2.29152652e+01, 5.34146722e+02, 3.47887307e+01), forces1[523], tol);
ASSERT_EQUAL_VEC(Vec3( 4.58865e+02, -2.39331e+02, 5.46717e+01), forces1[524], tol); ASSERT_EQUAL_VEC(Vec3( 4.58874513e+02, -2.39333403e+02, 5.46784973e+01), forces1[524], tol);
ASSERT_EQUAL_VEC(Vec3( 9.97437e+01, 6.32213e+02, -2.38265e+02), forces1[525], tol); ASSERT_EQUAL_VEC(Vec3( 9.97690238e+01, 6.32211339e+02, -2.38267224e+02), forces1[525], tol);
ASSERT_EQUAL_VEC(Vec3(-5.41816e+02, 2.23592e+02, 3.43977e+02), forces1[526], tol); ASSERT_EQUAL_VEC(Vec3(-5.41815785e+02, 2.23592441e+02, 3.43988502e+02), forces1[526], tol);
ASSERT_EQUAL_VEC(Vec3( 6.66010e+02, 4.01168e+02, 3.95443e+02), forces1[527], tol); ASSERT_EQUAL_VEC(Vec3( 6.66020295e+02, 4.01173887e+02, 3.95444004e+02), forces1[527], tol);
ASSERT_EQUAL_VEC(Vec3(-3.06410e+02, 9.39700e+02, -8.27854e+01), forces1[528], tol); ASSERT_EQUAL_VEC(Vec3(-3.06415141e+02, 9.39706150e+02, -8.27903644e+01), forces1[528], tol);
ASSERT_EQUAL_VEC(Vec3(-6.74070e+02, 3.08263e+02, 3.73255e+02), forces1[529], tol); ASSERT_EQUAL_VEC(Vec3(-6.74078464e+02, 3.08248161e+02, 3.73260958e+02), forces1[529], tol);
ASSERT_EQUAL_VEC(Vec3( 2.12314e+02, -1.45397e+02, 2.64286e+02), forces1[530], tol); ASSERT_EQUAL_VEC(Vec3( 2.12314396e+02, -1.45381664e+02, 2.64300301e+02), forces1[530], tol);
ASSERT_EQUAL_VEC(Vec3( 5.45332e+01, -8.21067e+01, 1.51452e+01), forces1[531], tol); ASSERT_EQUAL_VEC(Vec3( 5.45322328e+01, -8.21066892e+01, 1.51406100e+01), forces1[531], tol);
ASSERT_EQUAL_VEC(Vec3( 1.18910e+03, 9.92324e+02, 1.56933e+02), forces1[532], tol); ASSERT_EQUAL_VEC(Vec3( 1.18910001e+03, 9.92330102e+02, 1.56915624e+02), forces1[532], tol);
ASSERT_EQUAL_VEC(Vec3( 4.27114e+02, 1.57527e+02, -3.44357e+02), forces1[533], tol); ASSERT_EQUAL_VEC(Vec3( 4.27125646e+02, 1.57551086e+02, -3.44348874e+02), forces1[533], tol);
ASSERT_EQUAL_VEC(Vec3( 4.25881e+02, -8.14519e+02, -2.37516e+02), forces1[534], tol); ASSERT_EQUAL_VEC(Vec3( 4.25889733e+02, -8.14519408e+02, -2.37525602e+02), forces1[534], tol);
ASSERT_EQUAL_VEC(Vec3( 1.28751e+02, 2.55775e+02, 4.07891e+02), forces1[535], tol); ASSERT_EQUAL_VEC(Vec3( 1.28754744e+02, 2.55775344e+02, 4.07880224e+02), forces1[535], tol);
ASSERT_EQUAL_VEC(Vec3(-4.27469e+02, 1.69799e+02, 1.81379e+02), forces1[536], tol); ASSERT_EQUAL_VEC(Vec3(-4.27463797e+02, 1.69782847e+02, 1.81381656e+02), forces1[536], tol);
ASSERT_EQUAL_VEC(Vec3(-1.35756e+01, 6.03614e+01, -2.72312e+02), forces1[537], tol); ASSERT_EQUAL_VEC(Vec3(-1.35673145e+01, 6.03614577e+01, -2.72320347e+02), forces1[537], tol);
ASSERT_EQUAL_VEC(Vec3( 3.33183e+02, 2.70223e+02, -1.39427e+02), forces1[538], tol); ASSERT_EQUAL_VEC(Vec3( 3.33191831e+02, 2.70237134e+02, -1.39415972e+02), forces1[538], tol);
ASSERT_EQUAL_VEC(Vec3( 4.27481e+02, 1.39186e+02, 1.50066e+02), forces1[539], tol); ASSERT_EQUAL_VEC(Vec3( 4.27473593e+02, 1.39188845e+02, 1.50065516e+02), forces1[539], tol);
ASSERT_EQUAL_VEC(Vec3(-8.29173e+01, -1.00127e+02, -6.81951e+01), forces1[540], tol); ASSERT_EQUAL_VEC(Vec3(-8.29214695e+01, -1.00138197e+02, -6.82077450e+01), forces1[540], tol);
ASSERT_EQUAL_VEC(Vec3( 4.42468e+02, -8.63521e+02, 5.13472e+02), forces1[541], tol); ASSERT_EQUAL_VEC(Vec3( 4.42484380e+02, -8.63519014e+02, 5.13464509e+02), forces1[541], tol);
ASSERT_EQUAL_VEC(Vec3( 2.60696e+02, -6.37295e+01, 1.70988e+02), forces1[542], tol); ASSERT_EQUAL_VEC(Vec3( 2.60684466e+02, -6.37356238e+01, 1.70982604e+02), forces1[542], tol);
ASSERT_EQUAL_VEC(Vec3(-3.90393e+02, -6.79775e+01, -2.36507e+02), forces1[543], tol); ASSERT_EQUAL_VEC(Vec3(-3.90400226e+02, -6.79695956e+01, -2.36488456e+02), forces1[543], tol);
ASSERT_EQUAL_VEC(Vec3( 2.47128e+02, -6.89560e+02, 2.32359e+02), forces1[544], tol); ASSERT_EQUAL_VEC(Vec3( 2.47126838e+02, -6.89575321e+02, 2.32358423e+02), forces1[544], tol);
ASSERT_EQUAL_VEC(Vec3(-5.36760e+02, 2.88863e+02, -6.13644e+02), forces1[545], tol); ASSERT_EQUAL_VEC(Vec3(-5.36761583e+02, 2.88858194e+02, -6.13643573e+02), forces1[545], tol);
ASSERT_EQUAL_VEC(Vec3(-7.93509e+02, 1.07645e+02, 1.05024e+03), forces1[546], tol); ASSERT_EQUAL_VEC(Vec3(-7.93525749e+02, 1.07662863e+02, 1.05022658e+03), forces1[546], tol);
ASSERT_EQUAL_VEC(Vec3( 5.82901e+02, 1.51821e+02, 4.23880e+02), forces1[547], tol); ASSERT_EQUAL_VEC(Vec3( 5.82900512e+02, 1.51819356e+02, 4.23873744e+02), forces1[547], tol);
ASSERT_EQUAL_VEC(Vec3( 1.88320e+02, 3.18363e+02, 2.45839e+02), forces1[548], tol); ASSERT_EQUAL_VEC(Vec3( 1.88325572e+02, 3.18360865e+02, 2.45830156e+02), forces1[548], tol);
ASSERT_EQUAL_VEC(Vec3( 2.61705e+02, 2.14131e+02, -1.84878e+02), forces1[549], tol); ASSERT_EQUAL_VEC(Vec3( 2.61705414e+02, 2.14134022e+02, -1.84880999e+02), forces1[549], tol);
ASSERT_EQUAL_VEC(Vec3(-6.23170e+01, -3.92079e+02, 3.63673e+02), forces1[550], tol); ASSERT_EQUAL_VEC(Vec3(-6.23192888e+01, -3.92071740e+02, 3.63685367e+02), forces1[550], tol);
ASSERT_EQUAL_VEC(Vec3( 2.19330e+02, -3.09047e+02, 2.60278e+02), forces1[551], tol); ASSERT_EQUAL_VEC(Vec3( 2.19338376e+02, -3.09058211e+02, 2.60284559e+02), forces1[551], tol);
ASSERT_EQUAL_VEC(Vec3( 5.02105e+02, -5.84019e+02, -2.55791e+02), forces1[552], tol); ASSERT_EQUAL_VEC(Vec3( 5.02128707e+02, -5.84024469e+02, -2.55784996e+02), forces1[552], tol);
ASSERT_EQUAL_VEC(Vec3( 3.03887e+02, 8.14692e+01, 3.89626e+02), forces1[553], tol); ASSERT_EQUAL_VEC(Vec3( 3.03909158e+02, 8.14707135e+01, 3.89632253e+02), forces1[553], tol);
ASSERT_EQUAL_VEC(Vec3(-1.63671e+01, -1.20655e+02, -1.80826e+02), forces1[554], tol); ASSERT_EQUAL_VEC(Vec3(-1.63583654e+01, -1.20664911e+02, -1.80828909e+02), forces1[554], tol);
ASSERT_EQUAL_VEC(Vec3( 5.41991e+02, 1.88548e+02, 1.13704e+02), forces1[555], tol); ASSERT_EQUAL_VEC(Vec3( 5.41992468e+02, 1.88563930e+02, 1.13691301e+02), forces1[555], tol);
ASSERT_EQUAL_VEC(Vec3( 1.22528e+01, -7.61796e+02, -5.24477e+02), forces1[556], tol); ASSERT_EQUAL_VEC(Vec3( 1.22553432e+01, -7.61799733e+02, -5.24485038e+02), forces1[556], tol);
ASSERT_EQUAL_VEC(Vec3(-4.66757e+02, 1.60553e+02, 1.60949e+02), forces1[557], tol); ASSERT_EQUAL_VEC(Vec3(-4.66745376e+02, 1.60550422e+02, 1.60943530e+02), forces1[557], tol);
ASSERT_EQUAL_VEC(Vec3( 1.52471e+02, -2.28618e+02, -5.94633e+01), forces1[558], tol); ASSERT_EQUAL_VEC(Vec3( 1.52464706e+02, -2.28608668e+02, -5.94662997e+01), forces1[558], tol);
ASSERT_EQUAL_VEC(Vec3( 1.80857e+02, 2.02584e+02, 2.57327e+02), forces1[559], tol); ASSERT_EQUAL_VEC(Vec3( 1.80874781e+02, 2.02580348e+02, 2.57314201e+02), forces1[559], tol);
ASSERT_EQUAL_VEC(Vec3( 6.16835e+02, -3.58513e+02, -5.69813e+02), forces1[560], tol); ASSERT_EQUAL_VEC(Vec3( 6.16836590e+02, -3.58505580e+02, -5.69821380e+02), forces1[560], tol);
ASSERT_EQUAL_VEC(Vec3(-1.57108e+02, -1.13532e+02, -1.64422e+02), forces1[561], tol); ASSERT_EQUAL_VEC(Vec3(-1.57121513e+02, -1.13551528e+02, -1.64421656e+02), forces1[561], tol);
ASSERT_EQUAL_VEC(Vec3(-5.95582e+02, 1.76708e+02, -1.20425e+02), forces1[562], tol); ASSERT_EQUAL_VEC(Vec3(-5.95579860e+02, 1.76709860e+02, -1.20420471e+02), forces1[562], tol);
ASSERT_EQUAL_VEC(Vec3(-6.70974e+01, 7.56229e+02, 5.71570e+02), forces1[563], tol); ASSERT_EQUAL_VEC(Vec3(-6.71038012e+01, 7.56227414e+02, 5.71572718e+02), forces1[563], tol);
ASSERT_EQUAL_VEC(Vec3(-2.03112e+02, -5.27288e+02, -8.87798e+01), forces1[564], tol); ASSERT_EQUAL_VEC(Vec3(-2.03114489e+02, -5.27279840e+02, -8.87711978e+01), forces1[564], tol);
ASSERT_EQUAL_VEC(Vec3(-1.55603e+02, 2.45867e+02, 3.01763e+01), forces1[565], tol); ASSERT_EQUAL_VEC(Vec3(-1.55593136e+02, 2.45854044e+02, 3.01808246e+01), forces1[565], tol);
ASSERT_EQUAL_VEC(Vec3( 1.30685e+02, -2.25613e+02, -3.22220e+02), forces1[566], tol); ASSERT_EQUAL_VEC(Vec3( 1.30686350e+02, -2.25620374e+02, -3.22214134e+02), forces1[566], tol);
ASSERT_EQUAL_VEC(Vec3( 8.48237e+00, -1.67338e+02, 1.64208e+02), forces1[567], tol); ASSERT_EQUAL_VEC(Vec3( 8.49438622e+00, -1.67348790e+02, 1.64216652e+02), forces1[567], tol);
ASSERT_EQUAL_VEC(Vec3(-2.31489e+02, -5.95299e+00, -4.92422e+02), forces1[568], tol); ASSERT_EQUAL_VEC(Vec3(-2.31492960e+02, -5.94613152e+00, -4.92415232e+02), forces1[568], tol);
ASSERT_EQUAL_VEC(Vec3(-1.99394e+02, -1.40003e+02, 2.20660e+01), forces1[569], tol); ASSERT_EQUAL_VEC(Vec3(-1.99398672e+02, -1.39998676e+02, 2.20660038e+01), forces1[569], tol);
ASSERT_EQUAL_VEC(Vec3(-2.65260e+02, 6.41890e+02, 2.96511e+01), forces1[570], tol); ASSERT_EQUAL_VEC(Vec3(-2.65259682e+02, 6.41897575e+02, 2.96772423e+01), forces1[570], tol);
ASSERT_EQUAL_VEC(Vec3(-6.43670e+02, -9.18870e+01, 4.59934e+02), forces1[571], tol); ASSERT_EQUAL_VEC(Vec3(-6.43663438e+02, -9.18800569e+01, 4.59932589e+02), forces1[571], tol);
ASSERT_EQUAL_VEC(Vec3( 3.08971e+02, 8.15561e+02, 4.66099e+02), forces1[572], tol); ASSERT_EQUAL_VEC(Vec3( 3.08969568e+02, 8.15568208e+02, 4.66102799e+02), forces1[572], tol);
ASSERT_EQUAL_VEC(Vec3( 3.27966e+02, -3.65760e+02, -7.14742e+02), forces1[573], tol); ASSERT_EQUAL_VEC(Vec3( 3.27967531e+02, -3.65749496e+02, -7.14744561e+02), forces1[573], tol);
ASSERT_EQUAL_VEC(Vec3(-2.27167e+01, 1.71599e+02, 5.53844e+02), forces1[574], tol); ASSERT_EQUAL_VEC(Vec3(-2.27124135e+01, 1.71611100e+02, 5.53831720e+02), forces1[574], tol);
ASSERT_EQUAL_VEC(Vec3(-3.66166e+02, -4.26964e+02, 4.19230e+02), forces1[575], tol); ASSERT_EQUAL_VEC(Vec3(-3.66175366e+02, -4.26970546e+02, 4.19237233e+02), forces1[575], tol);
ASSERT_EQUAL_VEC(Vec3( 3.35351e+02, 4.34263e+02, 3.88537e+02), forces1[576], tol); ASSERT_EQUAL_VEC(Vec3( 3.35350939e+02, 4.34257827e+02, 3.88519433e+02), forces1[576], tol);
ASSERT_EQUAL_VEC(Vec3( 1.92384e+02, 3.19991e+01, 2.85813e+02), forces1[577], tol); ASSERT_EQUAL_VEC(Vec3( 1.92391997e+02, 3.19970198e+01, 2.85801367e+02), forces1[577], tol);
ASSERT_EQUAL_VEC(Vec3(-1.98788e+02, -5.26333e+02, 3.78354e+02), forces1[578], tol); ASSERT_EQUAL_VEC(Vec3(-1.98802026e+02, -5.26322826e+02, 3.78354799e+02), forces1[578], tol);
ASSERT_EQUAL_VEC(Vec3( 1.45699e+01, -4.73239e+02, 1.99926e+02), forces1[579], tol); ASSERT_EQUAL_VEC(Vec3( 1.45671139e+01, -4.73231557e+02, 1.99919499e+02), forces1[579], tol);
ASSERT_EQUAL_VEC(Vec3(-4.54992e+02, -4.41717e+02, -1.24512e+01), forces1[580], tol); ASSERT_EQUAL_VEC(Vec3(-4.54983469e+02, -4.41701623e+02, -1.24425267e+01), forces1[580], tol);
ASSERT_EQUAL_VEC(Vec3(-4.14910e+02, 2.39760e+02, 1.50735e+02), forces1[581], tol); ASSERT_EQUAL_VEC(Vec3(-4.14904603e+02, 2.39751623e+02, 1.50738334e+02), forces1[581], tol);
ASSERT_EQUAL_VEC(Vec3(-3.05998e+02, -5.48503e+02, 1.68219e+02), forces1[582], tol); ASSERT_EQUAL_VEC(Vec3(-3.06008464e+02, -5.48479559e+02, 1.68208702e+02), forces1[582], tol);
ASSERT_EQUAL_VEC(Vec3(-4.75155e+02, -5.13916e+02, -3.05846e+02), forces1[583], tol); ASSERT_EQUAL_VEC(Vec3(-4.75151928e+02, -5.13940177e+02, -3.05856025e+02), forces1[583], tol);
ASSERT_EQUAL_VEC(Vec3(-1.94337e+02, 1.30216e+02, -3.61863e+02), forces1[584], tol); ASSERT_EQUAL_VEC(Vec3(-1.94335510e+02, 1.30203790e+02, -3.61867940e+02), forces1[584], tol);
ASSERT_EQUAL_VEC(Vec3(-3.90906e+02, 9.91510e+01, -5.15014e+02), forces1[585], tol); ASSERT_EQUAL_VEC(Vec3(-3.90897312e+02, 9.91504462e+01, -5.15012540e+02), forces1[585], tol);
ASSERT_EQUAL_VEC(Vec3(-6.84331e+01, 4.13259e+01, -2.50197e+02), forces1[586], tol); ASSERT_EQUAL_VEC(Vec3(-6.84365306e+01, 4.13335965e+01, -2.50193483e+02), forces1[586], tol);
ASSERT_EQUAL_VEC(Vec3(-1.33536e+02, 4.37431e+02, 3.93116e+02), forces1[587], tol); ASSERT_EQUAL_VEC(Vec3(-1.33552662e+02, 4.37424563e+02, 3.93116748e+02), forces1[587], tol);
ASSERT_EQUAL_VEC(Vec3( 2.17892e+02, -3.56958e+02, -2.19153e+01), forces1[588], tol); ASSERT_EQUAL_VEC(Vec3( 2.17908981e+02, -3.56944423e+02, -2.19072785e+01), forces1[588], tol);
ASSERT_EQUAL_VEC(Vec3(-6.71290e+01, -2.85190e+01, -4.77734e+02), forces1[589], tol); ASSERT_EQUAL_VEC(Vec3(-6.71090167e+01, -2.85234245e+01, -4.77739167e+02), forces1[589], tol);
ASSERT_EQUAL_VEC(Vec3(-1.52928e+02, 1.00747e+02, 7.10752e+01), forces1[590], tol); ASSERT_EQUAL_VEC(Vec3(-1.52916503e+02, 1.00727331e+02, 7.10681385e+01), forces1[590], tol);
ASSERT_EQUAL_VEC(Vec3(-4.51736e+02, 3.40002e+02, -4.62194e+02), forces1[591], tol); ASSERT_EQUAL_VEC(Vec3(-4.51746452e+02, 3.40018663e+02, -4.62193306e+02), forces1[591], tol);
ASSERT_EQUAL_VEC(Vec3(-3.10150e+02, 9.78202e+02, 6.76386e+02), forces1[592], tol); ASSERT_EQUAL_VEC(Vec3(-3.10163906e+02, 9.78195399e+02, 6.76387827e+02), forces1[592], tol);
ASSERT_EQUAL_VEC(Vec3(-3.27573e+02, -1.79616e+02, -2.92235e+02), forces1[593], tol); ASSERT_EQUAL_VEC(Vec3(-3.27558084e+02, -1.79605758e+02, -2.92242524e+02), forces1[593], tol);
ASSERT_EQUAL_VEC(Vec3(-1.59840e+02, 2.90875e+01, -2.88804e+02), forces1[594], tol); ASSERT_EQUAL_VEC(Vec3(-1.59840534e+02, 2.90890718e+01, -2.88814524e+02), forces1[594], tol);
ASSERT_EQUAL_VEC(Vec3( 2.51649e+02, -6.16130e+02, -2.74664e+02), forces1[595], tol); ASSERT_EQUAL_VEC(Vec3( 2.51648228e+02, -6.16115272e+02, -2.74650686e+02), forces1[595], tol);
ASSERT_EQUAL_VEC(Vec3(-4.29806e+02, 2.97844e+02, 2.42787e+02), forces1[596], tol); ASSERT_EQUAL_VEC(Vec3(-4.29795517e+02, 2.97846602e+02, 2.42790721e+02), forces1[596], tol);
ASSERT_EQUAL_VEC(Vec3(-6.54170e+01, -3.72045e+00, 1.09366e+02), forces1[597], tol); ASSERT_EQUAL_VEC(Vec3(-6.54290494e+01, -3.71027774e+00, 1.09362533e+02), forces1[597], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13636e+02, 1.22420e+02, -1.64191e+02), forces1[598], tol); ASSERT_EQUAL_VEC(Vec3(-1.13635998e+02, 1.22421969e+02, -1.64181430e+02), forces1[598], tol);
ASSERT_EQUAL_VEC(Vec3(-4.58003e+02, -5.24225e+02, -4.23531e+02), forces1[599], tol); ASSERT_EQUAL_VEC(Vec3(-4.58014050e+02, -5.24237205e+02, -4.23517393e+02), forces1[599], tol);
ASSERT_EQUAL_VEC(Vec3(-4.01124e+02, -3.10918e+02, -4.86423e+02), forces1[600], tol); ASSERT_EQUAL_VEC(Vec3(-4.01134799e+02, -3.10910001e+02, -4.86430772e+02), forces1[600], tol);
ASSERT_EQUAL_VEC(Vec3( 5.98517e+02, 2.14440e+02, -3.57298e+02), forces1[601], tol); ASSERT_EQUAL_VEC(Vec3( 5.98531056e+02, 2.14442508e+02, -3.57310754e+02), forces1[601], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56641e+02, 7.11862e+01, -6.74283e+02), forces1[602], tol); ASSERT_EQUAL_VEC(Vec3( 2.56644787e+02, 7.12047294e+01, -6.74281621e+02), forces1[602], tol);
ASSERT_EQUAL_VEC(Vec3(-4.29296e+02, 3.33251e+02, -9.12898e+02), forces1[603], tol); ASSERT_EQUAL_VEC(Vec3(-4.29285173e+02, 3.33264141e+02, -9.12908079e+02), forces1[603], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69819e+01, -1.31683e+02, -3.65262e+02), forces1[604], tol); ASSERT_EQUAL_VEC(Vec3(-2.69676355e+01, -1.31676984e+02, -3.65274088e+02), forces1[604], tol);
ASSERT_EQUAL_VEC(Vec3(-9.51312e+00, 3.29551e+02, 1.84492e+01), forces1[605], tol); ASSERT_EQUAL_VEC(Vec3(-9.51192754e+00, 3.29563459e+02, 1.84451527e+01), forces1[605], tol);
ASSERT_EQUAL_VEC(Vec3( 1.01476e+03, 8.03253e+01, -6.28556e+02), forces1[606], tol); ASSERT_EQUAL_VEC(Vec3( 1.01475969e+03, 8.03401303e+01, -6.28558583e+02), forces1[606], tol);
ASSERT_EQUAL_VEC(Vec3( 2.39376e+02, -4.08084e+02, -1.62882e+02), forces1[607], tol); ASSERT_EQUAL_VEC(Vec3( 2.39384773e+02, -4.08077252e+02, -1.62875513e+02), forces1[607], tol);
ASSERT_EQUAL_VEC(Vec3(-3.93620e+02, -5.17088e+02, 5.21855e+02), forces1[608], tol); ASSERT_EQUAL_VEC(Vec3(-3.93619429e+02, -5.17089524e+02, 5.21862274e+02), forces1[608], tol);
ASSERT_EQUAL_VEC(Vec3(-1.37185e+02, -3.86140e+01, 4.26815e+02), forces1[609], tol); ASSERT_EQUAL_VEC(Vec3(-1.37188342e+02, -3.86301530e+01, 4.26852072e+02), forces1[609], tol);
ASSERT_EQUAL_VEC(Vec3( 4.56728e+02, 1.63804e+02, 1.01400e+01), forces1[610], tol); ASSERT_EQUAL_VEC(Vec3( 4.56729328e+02, 1.63797747e+02, 1.01225457e+01), forces1[610], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53125e+02, 1.02274e+02, -7.27488e+02), forces1[611], tol); ASSERT_EQUAL_VEC(Vec3(-1.53128373e+02, 1.02270086e+02, -7.27501148e+02), forces1[611], tol);
ASSERT_EQUAL_VEC(Vec3(-1.82097e+02, 7.23262e+00, -5.10656e+02), forces1[612], tol); ASSERT_EQUAL_VEC(Vec3(-1.82095738e+02, 7.23918424e+00, -5.10663887e+02), forces1[612], tol);
ASSERT_EQUAL_VEC(Vec3( 3.54495e+02, -8.64483e+01, -4.10160e+02), forces1[613], tol); ASSERT_EQUAL_VEC(Vec3( 3.54485642e+02, -8.64332815e+01, -4.10166872e+02), forces1[613], tol);
ASSERT_EQUAL_VEC(Vec3(-6.67502e+01, -7.58019e+01, 7.77335e+01), forces1[614], tol); ASSERT_EQUAL_VEC(Vec3(-6.67557801e+01, -7.57917504e+01, 7.77239103e+01), forces1[614], tol);
ASSERT_EQUAL_VEC(Vec3( 5.34013e+01, -3.49037e+02, -4.41047e+02), forces1[615], tol); ASSERT_EQUAL_VEC(Vec3( 5.34069903e+01, -3.49052174e+02, -4.41040697e+02), forces1[615], tol);
ASSERT_EQUAL_VEC(Vec3(-2.55995e+02, -1.85105e+02, -1.67759e+01), forces1[616], tol); ASSERT_EQUAL_VEC(Vec3(-2.55993121e+02, -1.85106916e+02, -1.67700877e+01), forces1[616], tol);
ASSERT_EQUAL_VEC(Vec3(-2.60212e+02, 4.50689e+02, 6.87579e+02), forces1[617], tol); ASSERT_EQUAL_VEC(Vec3(-2.60226735e+02, 4.50682021e+02, 6.87571461e+02), forces1[617], tol);
ASSERT_EQUAL_VEC(Vec3(-4.84798e+01, -1.47695e+02, 1.30447e+02), forces1[618], tol); ASSERT_EQUAL_VEC(Vec3(-4.84797099e+01, -1.47670701e+02, 1.30460152e+02), forces1[618], tol);
ASSERT_EQUAL_VEC(Vec3(-5.03877e+02, 3.00390e+02, 2.91279e+01), forces1[619], tol); ASSERT_EQUAL_VEC(Vec3(-5.03867743e+02, 3.00373068e+02, 2.90989581e+01), forces1[619], tol);
ASSERT_EQUAL_VEC(Vec3(-3.26887e+02, -2.54125e+02, -1.97280e+02), forces1[620], tol); ASSERT_EQUAL_VEC(Vec3(-3.26901569e+02, -2.54115591e+02, -1.97292733e+02), forces1[620], tol);
ASSERT_EQUAL_VEC(Vec3( 2.23123e+02, 4.31813e+02, -3.45780e+02), forces1[621], tol); ASSERT_EQUAL_VEC(Vec3( 2.23124353e+02, 4.31821924e+02, -3.45785529e+02), forces1[621], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69764e+00, -7.70571e+01, -4.27761e-01), forces1[622], tol); ASSERT_EQUAL_VEC(Vec3(-2.69721533e+00, -7.70690632e+01, -4.19805145e-01), forces1[622], tol);
ASSERT_EQUAL_VEC(Vec3( 8.20422e+02, 7.99600e+02, 4.14357e+02), forces1[623], tol); ASSERT_EQUAL_VEC(Vec3( 8.20412852e+02, 7.99595268e+02, 4.14368303e+02), forces1[623], tol);
ASSERT_EQUAL_VEC(Vec3(-6.20344e+01, -4.27141e+02, -3.70561e+02), forces1[624], tol); ASSERT_EQUAL_VEC(Vec3(-6.20301649e+01, -4.27145295e+02, -3.70568508e+02), forces1[624], tol);
ASSERT_EQUAL_VEC(Vec3(-2.49435e+01, -1.44622e+02, 7.41532e+02), forces1[625], tol); ASSERT_EQUAL_VEC(Vec3(-2.49452268e+01, -1.44630413e+02, 7.41551042e+02), forces1[625], tol);
ASSERT_EQUAL_VEC(Vec3(-6.41693e+02, 6.30167e+01, 1.57990e+02), forces1[626], tol); ASSERT_EQUAL_VEC(Vec3(-6.41685916e+02, 6.29980324e+01, 1.57997582e+02), forces1[626], tol);
ASSERT_EQUAL_VEC(Vec3(-5.89353e+02, -2.66714e+02, 7.40555e+01), forces1[627], tol); ASSERT_EQUAL_VEC(Vec3(-5.89339824e+02, -2.66715415e+02, 7.40290187e+01), forces1[627], tol);
ASSERT_EQUAL_VEC(Vec3( 5.26888e+02, -4.19413e+02, -2.37111e+02), forces1[628], tol); ASSERT_EQUAL_VEC(Vec3( 5.26893408e+02, -4.19407888e+02, -2.37125726e+02), forces1[628], tol);
ASSERT_EQUAL_VEC(Vec3( 4.42838e+02, -3.90953e+00, 5.35437e+02), forces1[629], tol); ASSERT_EQUAL_VEC(Vec3( 4.42841034e+02, -3.91060128e+00, 5.35417838e+02), forces1[629], tol);
ASSERT_EQUAL_VEC(Vec3( 2.38364e+02, -5.34605e+02, 2.63017e+02), forces1[630], tol); ASSERT_EQUAL_VEC(Vec3( 2.38357324e+02, -5.34613334e+02, 2.63026026e+02), forces1[630], tol);
ASSERT_EQUAL_VEC(Vec3(-2.48032e+02, -1.45044e+01, 7.55544e+02), forces1[631], tol); ASSERT_EQUAL_VEC(Vec3(-2.48018560e+02, -1.44967289e+01, 7.55539331e+02), forces1[631], tol);
ASSERT_EQUAL_VEC(Vec3(-8.06907e+01, -4.42703e+02, -4.11281e+02), forces1[632], tol); ASSERT_EQUAL_VEC(Vec3(-8.06994987e+01, -4.42696335e+02, -4.11279013e+02), forces1[632], tol);
ASSERT_EQUAL_VEC(Vec3( 4.64134e+02, -7.82558e+02, 7.48592e+02), forces1[633], tol); ASSERT_EQUAL_VEC(Vec3( 4.64135556e+02, -7.82576620e+02, 7.48567804e+02), forces1[633], tol);
ASSERT_EQUAL_VEC(Vec3( 3.75019e+02, 3.06945e+02, 2.76982e+02), forces1[634], tol); ASSERT_EQUAL_VEC(Vec3( 3.75022611e+02, 3.06926438e+02, 2.76985876e+02), forces1[634], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43686e+02, -1.70150e+02, -2.61366e+02), forces1[635], tol); ASSERT_EQUAL_VEC(Vec3( 4.43672142e+02, -1.70168440e+02, -2.61360725e+02), forces1[635], tol);
ASSERT_EQUAL_VEC(Vec3( 5.20777e+02, -7.65571e+00, -2.76122e+02), forces1[636], tol); ASSERT_EQUAL_VEC(Vec3( 5.20775219e+02, -7.66015101e+00, -2.76123645e+02), forces1[636], tol);
ASSERT_EQUAL_VEC(Vec3(-2.28472e+02, 5.33842e+02, -3.58141e+01), forces1[637], tol); ASSERT_EQUAL_VEC(Vec3(-2.28464032e+02, 5.33849652e+02, -3.58040265e+01), forces1[637], tol);
ASSERT_EQUAL_VEC(Vec3(-1.70106e+02, -7.30241e+01, -3.73105e+02), forces1[638], tol); ASSERT_EQUAL_VEC(Vec3(-1.70105892e+02, -7.30464804e+01, -3.73115603e+02), forces1[638], tol);
ASSERT_EQUAL_VEC(Vec3( 1.90859e+02, 1.53726e+02, -9.75013e+00), forces1[639], tol); ASSERT_EQUAL_VEC(Vec3( 1.90860772e+02, 1.53722926e+02, -9.75608771e+00), forces1[639], tol);
ASSERT_EQUAL_VEC(Vec3( 2.59603e+02, 2.75243e+01, -2.02341e+02), forces1[640], tol); ASSERT_EQUAL_VEC(Vec3( 2.59606432e+02, 2.75260084e+01, -2.02338885e+02), forces1[640], tol);
ASSERT_EQUAL_VEC(Vec3( 3.25218e+02, 2.78124e+01, 5.21693e+02), forces1[641], tol); ASSERT_EQUAL_VEC(Vec3( 3.25211743e+02, 2.78186538e+01, 5.21700978e+02), forces1[641], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12829e+02, -6.70132e+02, -7.85949e+01), forces1[642], tol); ASSERT_EQUAL_VEC(Vec3( 1.12827984e+02, -6.70115666e+02, -7.85972574e+01), forces1[642], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09778e+01, -4.90800e+01, -2.91315e+02), forces1[643], tol); ASSERT_EQUAL_VEC(Vec3(-1.09776266e+01, -4.90753809e+01, -2.91319708e+02), forces1[643], tol);
ASSERT_EQUAL_VEC(Vec3( 2.77334e+02, 2.29317e+02, 5.59774e+02), forces1[644], tol); ASSERT_EQUAL_VEC(Vec3( 2.77337771e+02, 2.29328824e+02, 5.59770839e+02), forces1[644], tol);
ASSERT_EQUAL_VEC(Vec3( 4.59577e+02, 1.21291e+02, -4.79316e+02), forces1[645], tol); ASSERT_EQUAL_VEC(Vec3( 4.59572121e+02, 1.21311799e+02, -4.79315463e+02), forces1[645], tol);
ASSERT_EQUAL_VEC(Vec3(-5.30597e+02, -3.96115e+02, -4.37675e+01), forces1[646], tol); ASSERT_EQUAL_VEC(Vec3(-5.30617073e+02, -3.96120276e+02, -4.37634971e+01), forces1[646], tol);
ASSERT_EQUAL_VEC(Vec3( 5.87271e+01, 3.74987e+02, -4.61298e+00), forces1[647], tol); ASSERT_EQUAL_VEC(Vec3( 5.87394968e+01, 3.74984490e+02, -4.60404623e+00), forces1[647], tol);
ASSERT_EQUAL_VEC(Vec3(-5.72036e+02, -3.24813e+02, -5.11098e+01), forces1[648], tol); ASSERT_EQUAL_VEC(Vec3(-5.72051098e+02, -3.24819120e+02, -5.11080203e+01), forces1[648], tol);
ASSERT_EQUAL_VEC(Vec3(-1.51869e+03, 1.63914e+02, -7.68151e+01), forces1[649], tol); ASSERT_EQUAL_VEC(Vec3(-1.51869992e+03, 1.63914081e+02, -7.68191132e+01), forces1[649], tol);
ASSERT_EQUAL_VEC(Vec3( 4.86999e+02, 5.16875e+02, -7.62745e+01), forces1[650], tol); ASSERT_EQUAL_VEC(Vec3( 4.86996174e+02, 5.16874032e+02, -7.62783455e+01), forces1[650], tol);
ASSERT_EQUAL_VEC(Vec3( 2.48285e+02, -8.90762e+02, 6.71562e+01), forces1[651], tol); ASSERT_EQUAL_VEC(Vec3( 2.48291844e+02, -8.90767951e+02, 6.71591151e+01), forces1[651], tol);
ASSERT_EQUAL_VEC(Vec3(-1.55988e+00, 1.36956e+02, -1.04194e+02), forces1[652], tol); ASSERT_EQUAL_VEC(Vec3(-1.55902671e+00, 1.36945322e+02, -1.04198745e+02), forces1[652], tol);
ASSERT_EQUAL_VEC(Vec3(-1.20201e+02, 2.89598e+02, -6.63133e+02), forces1[653], tol); ASSERT_EQUAL_VEC(Vec3(-1.20204512e+02, 2.89617545e+02, -6.63132635e+02), forces1[653], tol);
ASSERT_EQUAL_VEC(Vec3(-1.59428e+02, -4.16170e+02, 2.79417e+02), forces1[654], tol); ASSERT_EQUAL_VEC(Vec3(-1.59431738e+02, -4.16178632e+02, 2.79410323e+02), forces1[654], tol);
ASSERT_EQUAL_VEC(Vec3(-2.98748e+02, -2.96274e+02, 3.36141e+02), forces1[655], tol); ASSERT_EQUAL_VEC(Vec3(-2.98742818e+02, -2.96272331e+02, 3.36156942e+02), forces1[655], tol);
ASSERT_EQUAL_VEC(Vec3(-4.91917e+02, -4.26611e+01, 1.25384e+01), forces1[656], tol); ASSERT_EQUAL_VEC(Vec3(-4.91918911e+02, -4.26618142e+01, 1.25349379e+01), forces1[656], tol);
ASSERT_EQUAL_VEC(Vec3(-2.47968e+02, -2.67485e+02, 2.21857e+02), forces1[657], tol); ASSERT_EQUAL_VEC(Vec3(-2.47949202e+02, -2.67488422e+02, 2.21868927e+02), forces1[657], tol);
ASSERT_EQUAL_VEC(Vec3(-2.42743e+01, 2.61340e+01, -6.65098e+01), forces1[658], tol); ASSERT_EQUAL_VEC(Vec3(-2.42806912e+01, 2.61371857e+01, -6.65056079e+01), forces1[658], tol);
ASSERT_EQUAL_VEC(Vec3( 3.64163e+02, 4.13051e+02, -5.51357e+02), forces1[659], tol); ASSERT_EQUAL_VEC(Vec3( 3.64167110e+02, 4.13052005e+02, -5.51357152e+02), forces1[659], tol);
ASSERT_EQUAL_VEC(Vec3( 3.74839e+02, -6.33613e+02, 5.37605e+00), forces1[660], tol); ASSERT_EQUAL_VEC(Vec3( 3.74835025e+02, -6.33613808e+02, 5.37740565e+00), forces1[660], tol);
ASSERT_EQUAL_VEC(Vec3( 6.51954e+01, 5.97074e+02, 2.54542e+01), forces1[661], tol); ASSERT_EQUAL_VEC(Vec3( 6.51925635e+01, 5.97066743e+02, 2.54479164e+01), forces1[661], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53444e+02, -7.91779e-02, -3.64198e+02), forces1[662], tol); ASSERT_EQUAL_VEC(Vec3(-2.53444698e+02, -7.31192246e-02, -3.64183108e+02), forces1[662], tol);
ASSERT_EQUAL_VEC(Vec3(-4.19815e+01, 5.32490e+02, 5.67514e+02), forces1[663], tol); ASSERT_EQUAL_VEC(Vec3(-4.19912375e+01, 5.32489389e+02, 5.67529873e+02), forces1[663], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18304e+01, -2.88676e+02, 2.73897e+02), forces1[664], tol); ASSERT_EQUAL_VEC(Vec3( 2.18364904e+01, -2.88671495e+02, 2.73914838e+02), forces1[664], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56692e+02, 1.75280e+02, 2.67812e+02), forces1[665], tol); ASSERT_EQUAL_VEC(Vec3( 2.56684383e+02, 1.75277073e+02, 2.67819228e+02), forces1[665], tol);
ASSERT_EQUAL_VEC(Vec3(-1.42013e+02, -1.93549e+02, -4.45938e+02), forces1[666], tol); ASSERT_EQUAL_VEC(Vec3(-1.42021939e+02, -1.93549789e+02, -4.45927086e+02), forces1[666], tol);
ASSERT_EQUAL_VEC(Vec3(-5.74272e+01, -4.30855e+02, -7.59688e+02), forces1[667], tol); ASSERT_EQUAL_VEC(Vec3(-5.74451363e+01, -4.30855207e+02, -7.59667162e+02), forces1[667], tol);
ASSERT_EQUAL_VEC(Vec3(-4.90341e+02, 2.12534e+02, 1.21400e+02), forces1[668], tol); ASSERT_EQUAL_VEC(Vec3(-4.90348302e+02, 2.12533193e+02, 1.21388630e+02), forces1[668], tol);
ASSERT_EQUAL_VEC(Vec3( 1.94617e+02, 1.32076e+02, 1.71427e+02), forces1[669], tol); ASSERT_EQUAL_VEC(Vec3( 1.94617803e+02, 1.32085507e+02, 1.71425945e+02), forces1[669], tol);
ASSERT_EQUAL_VEC(Vec3(-2.73624e+02, 7.78019e+02, 2.78039e+02), forces1[670], tol); ASSERT_EQUAL_VEC(Vec3(-2.73616831e+02, 7.78021634e+02, 2.78045494e+02), forces1[670], tol);
ASSERT_EQUAL_VEC(Vec3(-2.62096e+02, 3.53991e+02, 1.59730e+02), forces1[671], tol); ASSERT_EQUAL_VEC(Vec3(-2.62086498e+02, 3.53986939e+02, 1.59714894e+02), forces1[671], tol);
ASSERT_EQUAL_VEC(Vec3( 3.74080e+01, -6.21083e+02, -1.89732e+02), forces1[672], tol); ASSERT_EQUAL_VEC(Vec3( 3.73999411e+01, -6.21073575e+02, -1.89719863e+02), forces1[672], tol);
ASSERT_EQUAL_VEC(Vec3( 2.70249e+02, -1.98701e+02, -1.68446e+02), forces1[673], tol); ASSERT_EQUAL_VEC(Vec3( 2.70260860e+02, -1.98707881e+02, -1.68446389e+02), forces1[673], tol);
ASSERT_EQUAL_VEC(Vec3(-3.72181e+02, 2.16541e+02, -7.51597e+01), forces1[674], tol); ASSERT_EQUAL_VEC(Vec3(-3.72177189e+02, 2.16561917e+02, -7.51668953e+01), forces1[674], tol);
ASSERT_EQUAL_VEC(Vec3( 4.60656e+02, -2.41013e+02, 1.87550e+02), forces1[675], tol); ASSERT_EQUAL_VEC(Vec3( 4.60661709e+02, -2.41016609e+02, 1.87547311e+02), forces1[675], tol);
ASSERT_EQUAL_VEC(Vec3(-8.65762e+00, -4.96544e+01, 4.14104e+02), forces1[676], tol); ASSERT_EQUAL_VEC(Vec3(-8.64826359e+00, -4.96643240e+01, 4.14108827e+02), forces1[676], tol);
ASSERT_EQUAL_VEC(Vec3(-5.53550e+02, 2.02033e+02, 2.48790e+02), forces1[677], tol); ASSERT_EQUAL_VEC(Vec3(-5.53564746e+02, 2.02028062e+02, 2.48782202e+02), forces1[677], tol);
ASSERT_EQUAL_VEC(Vec3( 4.12917e+02, 3.97617e+02, -7.77101e+02), forces1[678], tol); ASSERT_EQUAL_VEC(Vec3( 4.12907277e+02, 3.97611070e+02, -7.77110932e+02), forces1[678], tol);
ASSERT_EQUAL_VEC(Vec3( 4.37857e+02, 3.87769e+02, -2.57118e+02), forces1[679], tol); ASSERT_EQUAL_VEC(Vec3( 4.37842786e+02, 3.87794283e+02, -2.57117992e+02), forces1[679], tol);
ASSERT_EQUAL_VEC(Vec3(-1.99556e+02, -5.31858e+02, -7.08368e+02), forces1[680], tol); ASSERT_EQUAL_VEC(Vec3(-1.99542679e+02, -5.31843337e+02, -7.08353449e+02), forces1[680], tol);
ASSERT_EQUAL_VEC(Vec3( 7.16823e+01, 2.15342e+02, -2.17982e+02), forces1[681], tol); ASSERT_EQUAL_VEC(Vec3( 7.16866224e+01, 2.15343692e+02, -2.17970964e+02), forces1[681], tol);
ASSERT_EQUAL_VEC(Vec3(-2.27236e+02, -3.33108e+02, -8.95734e+01), forces1[682], tol); ASSERT_EQUAL_VEC(Vec3(-2.27242549e+02, -3.33098733e+02, -8.95890783e+01), forces1[682], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12353e+02, -2.81408e+02, 1.84386e+02), forces1[683], tol); ASSERT_EQUAL_VEC(Vec3( 1.12351413e+02, -2.81401181e+02, 1.84388002e+02), forces1[683], tol);
ASSERT_EQUAL_VEC(Vec3( 5.30638e+01, -1.73618e+02, 3.80451e+02), forces1[684], tol); ASSERT_EQUAL_VEC(Vec3( 5.30452008e+01, -1.73617150e+02, 3.80454625e+02), forces1[684], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53104e+02, -4.19549e+02, 3.62057e+02), forces1[685], tol); ASSERT_EQUAL_VEC(Vec3(-1.53115972e+02, -4.19542700e+02, 3.62046980e+02), forces1[685], tol);
ASSERT_EQUAL_VEC(Vec3(-8.25981e+01, 1.22031e+02, -2.05531e+01), forces1[686], tol); ASSERT_EQUAL_VEC(Vec3(-8.25931831e+01, 1.22022997e+02, -2.05397162e+01), forces1[686], tol);
ASSERT_EQUAL_VEC(Vec3(-4.09530e+02, 3.88253e+01, 7.34591e+02), forces1[687], tol); ASSERT_EQUAL_VEC(Vec3(-4.09536810e+02, 3.88110352e+01, 7.34591479e+02), forces1[687], tol);
ASSERT_EQUAL_VEC(Vec3( 2.30492e+02, 4.58875e+01, -3.44439e+02), forces1[688], tol); ASSERT_EQUAL_VEC(Vec3( 2.30482332e+02, 4.58992821e+01, -3.44448449e+02), forces1[688], tol);
ASSERT_EQUAL_VEC(Vec3(-2.99015e+02, 6.71185e+02, -1.01235e+03), forces1[689], tol); ASSERT_EQUAL_VEC(Vec3(-2.99021647e+02, 6.71173507e+02, -1.01234738e+03), forces1[689], tol);
ASSERT_EQUAL_VEC(Vec3( 2.93610e+02, -1.62682e+01, -5.52904e+02), forces1[690], tol); ASSERT_EQUAL_VEC(Vec3( 2.93609447e+02, -1.62689588e+01, -5.52892039e+02), forces1[690], tol);
ASSERT_EQUAL_VEC(Vec3(-1.41618e+02, -4.87784e+02, 2.73061e+02), forces1[691], tol); ASSERT_EQUAL_VEC(Vec3(-1.41608406e+02, -4.87778496e+02, 2.73057317e+02), forces1[691], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26624e+02, -4.36391e+02, 7.19783e+01), forces1[692], tol); ASSERT_EQUAL_VEC(Vec3(-1.26623333e+02, -4.36398742e+02, 7.19789728e+01), forces1[692], tol);
ASSERT_EQUAL_VEC(Vec3( 1.33487e+02, 2.25674e+02, 5.65773e+02), forces1[693], tol); ASSERT_EQUAL_VEC(Vec3( 1.33484619e+02, 2.25668941e+02, 5.65772889e+02), forces1[693], tol);
ASSERT_EQUAL_VEC(Vec3( 7.34313e+02, 4.69250e+02, -5.53041e+02), forces1[694], tol); ASSERT_EQUAL_VEC(Vec3( 7.34328437e+02, 4.69241195e+02, -5.53029876e+02), forces1[694], tol);
ASSERT_EQUAL_VEC(Vec3(-6.36676e+01, -2.05109e+02, -4.73031e+02), forces1[695], tol); ASSERT_EQUAL_VEC(Vec3(-6.36703964e+01, -2.05105546e+02, -4.73051447e+02), forces1[695], tol);
ASSERT_EQUAL_VEC(Vec3(-3.35911e+02, -2.75957e+02, 4.10429e+02), forces1[696], tol); ASSERT_EQUAL_VEC(Vec3(-3.35917709e+02, -2.75962396e+02, 4.10424916e+02), forces1[696], tol);
ASSERT_EQUAL_VEC(Vec3(-1.98463e+02, -2.81396e+02, -1.48448e+02), forces1[697], tol); ASSERT_EQUAL_VEC(Vec3(-1.98439482e+02, -2.81389872e+02, -1.48450243e+02), forces1[697], tol);
ASSERT_EQUAL_VEC(Vec3( 6.97000e+02, -2.08397e+02, -1.22085e+02), forces1[698], tol); ASSERT_EQUAL_VEC(Vec3( 6.96988850e+02, -2.08391821e+02, -1.22085562e+02), forces1[698], tol);
ASSERT_EQUAL_VEC(Vec3( 6.16644e+02, -2.04938e+02, -2.28460e+02), forces1[699], tol); ASSERT_EQUAL_VEC(Vec3( 6.16645748e+02, -2.04946166e+02, -2.28454418e+02), forces1[699], tol);
ASSERT_EQUAL_VEC(Vec3( 1.59002e+02, 2.68322e+02, -1.13408e+02), forces1[700], tol); ASSERT_EQUAL_VEC(Vec3( 1.59003207e+02, 2.68316786e+02, -1.13415654e+02), forces1[700], tol);
ASSERT_EQUAL_VEC(Vec3( 2.52346e+02, 3.78646e+02, -1.30510e+03), forces1[701], tol); ASSERT_EQUAL_VEC(Vec3( 2.52361394e+02, 3.78641684e+02, -1.30511196e+03), forces1[701], tol);
ASSERT_EQUAL_VEC(Vec3( 7.30832e+02, -3.70985e+02, -6.60676e+02), forces1[702], tol); ASSERT_EQUAL_VEC(Vec3( 7.30824903e+02, -3.70993861e+02, -6.60674538e+02), forces1[702], tol);
ASSERT_EQUAL_VEC(Vec3(-4.64517e+01, 1.28043e+02, 8.75715e+01), forces1[703], tol); ASSERT_EQUAL_VEC(Vec3(-4.64466620e+01, 1.28056043e+02, 8.75616746e+01), forces1[703], tol);
ASSERT_EQUAL_VEC(Vec3( 3.26210e+02, -1.75825e+02, 7.02944e+01), forces1[704], tol); ASSERT_EQUAL_VEC(Vec3( 3.26209378e+02, -1.75823502e+02, 7.02935072e+01), forces1[704], tol);
ASSERT_EQUAL_VEC(Vec3( 9.80652e+01, -2.26683e+02, -2.00001e+02), forces1[705], tol); ASSERT_EQUAL_VEC(Vec3( 9.80733438e+01, -2.26694393e+02, -2.00005470e+02), forces1[705], tol);
ASSERT_EQUAL_VEC(Vec3( 5.01837e+01, 2.67259e+02, 5.24668e+02), forces1[706], tol); ASSERT_EQUAL_VEC(Vec3( 5.01964740e+01, 2.67230250e+02, 5.24657350e+02), forces1[706], tol);
ASSERT_EQUAL_VEC(Vec3(-2.52926e+02, -8.04956e+02, 4.03052e+02), forces1[707], tol); ASSERT_EQUAL_VEC(Vec3(-2.52920558e+02, -8.04959983e+02, 4.03061082e+02), forces1[707], tol);
ASSERT_EQUAL_VEC(Vec3(-2.40219e+02, -2.54326e+02, 5.06439e+02), forces1[708], tol); ASSERT_EQUAL_VEC(Vec3(-2.40233840e+02, -2.54317274e+02, 5.06457155e+02), forces1[708], tol);
ASSERT_EQUAL_VEC(Vec3( 4.48949e+02, 3.49498e+02, 2.88397e+02), forces1[709], tol); ASSERT_EQUAL_VEC(Vec3( 4.48943662e+02, 3.49500783e+02, 2.88397394e+02), forces1[709], tol);
ASSERT_EQUAL_VEC(Vec3( 3.10165e+02, 3.91032e+02, -9.77455e+02), forces1[710], tol); ASSERT_EQUAL_VEC(Vec3( 3.10154028e+02, 3.91036441e+02, -9.77447313e+02), forces1[710], tol);
ASSERT_EQUAL_VEC(Vec3( 7.63186e+02, 2.06919e+02, 1.03489e+02), forces1[711], tol); ASSERT_EQUAL_VEC(Vec3( 7.63180049e+02, 2.06937000e+02, 1.03491184e+02), forces1[711], tol);
ASSERT_EQUAL_VEC(Vec3( 4.64448e+02, 2.52690e+02, 7.37853e+01), forces1[712], tol); ASSERT_EQUAL_VEC(Vec3( 4.64445959e+02, 2.52682144e+02, 7.37736774e+01), forces1[712], tol);
ASSERT_EQUAL_VEC(Vec3( 9.14928e+02, 3.40046e+02, -2.99022e+02), forces1[713], tol); ASSERT_EQUAL_VEC(Vec3( 9.14937811e+02, 3.40042036e+02, -2.99018712e+02), forces1[713], tol);
ASSERT_EQUAL_VEC(Vec3( 5.05301e+02, 1.59566e+02, -9.12189e+00), forces1[714], tol); ASSERT_EQUAL_VEC(Vec3( 5.05299633e+02, 1.59569259e+02, -9.12327108e+00), forces1[714], tol);
ASSERT_EQUAL_VEC(Vec3(-3.46683e+02, 1.39994e+02, 1.54719e+02), forces1[715], tol); ASSERT_EQUAL_VEC(Vec3(-3.46682702e+02, 1.40007400e+02, 1.54710821e+02), forces1[715], tol);
ASSERT_EQUAL_VEC(Vec3(-1.66404e+01, -4.02275e+01, -1.23844e+02), forces1[716], tol); ASSERT_EQUAL_VEC(Vec3(-1.66209573e+01, -4.02206977e+01, -1.23824382e+02), forces1[716], tol);
ASSERT_EQUAL_VEC(Vec3(-7.57074e+01, -4.48068e+02, -4.21112e+02), forces1[717], tol); ASSERT_EQUAL_VEC(Vec3(-7.57122358e+01, -4.48068180e+02, -4.21106487e+02), forces1[717], tol);
ASSERT_EQUAL_VEC(Vec3( 1.04056e+03, -2.36038e+02, 1.43089e+01), forces1[718], tol); ASSERT_EQUAL_VEC(Vec3( 1.04054861e+03, -2.36054466e+02, 1.43176151e+01), forces1[718], tol);
ASSERT_EQUAL_VEC(Vec3(-2.65373e+01, 6.06558e+02, 4.91366e+01), forces1[719], tol); ASSERT_EQUAL_VEC(Vec3(-2.65447945e+01, 6.06566369e+02, 4.91348853e+01), forces1[719], tol);
ASSERT_EQUAL_VEC(Vec3(-1.33811e+02, -3.09753e+02, 2.79781e+01), forces1[720], tol); ASSERT_EQUAL_VEC(Vec3(-1.33799337e+02, -3.09748236e+02, 2.79834422e+01), forces1[720], tol);
ASSERT_EQUAL_VEC(Vec3(-9.76251e+01, -1.13791e+03, 4.60478e+02), forces1[721], tol); ASSERT_EQUAL_VEC(Vec3(-9.76340308e+01, -1.13791543e+03, 4.60481356e+02), forces1[721], tol);
ASSERT_EQUAL_VEC(Vec3(-2.56809e+02, 9.31607e+01, 3.24976e+02), forces1[722], tol); ASSERT_EQUAL_VEC(Vec3(-2.56814290e+02, 9.31514446e+01, 3.24980766e+02), forces1[722], tol);
ASSERT_EQUAL_VEC(Vec3(-8.65943e+01, 5.60567e+02, 2.96444e+02), forces1[723], tol); ASSERT_EQUAL_VEC(Vec3(-8.66006627e+01, 5.60562069e+02, 2.96440803e+02), forces1[723], tol);
ASSERT_EQUAL_VEC(Vec3( 1.26239e+02, 1.40931e+02, 3.97456e+02), forces1[724], tol); ASSERT_EQUAL_VEC(Vec3( 1.26231775e+02, 1.40946887e+02, 3.97459193e+02), forces1[724], tol);
ASSERT_EQUAL_VEC(Vec3( 1.03122e+02, -1.43340e+02, 1.91595e+02), forces1[725], tol); ASSERT_EQUAL_VEC(Vec3( 1.03134630e+02, -1.43345076e+02, 1.91574929e+02), forces1[725], tol);
ASSERT_EQUAL_VEC(Vec3(-9.29679e+01, 4.44838e+01, -9.69929e+01), forces1[726], tol); ASSERT_EQUAL_VEC(Vec3(-9.29586783e+01, 4.44777503e+01, -9.69828338e+01), forces1[726], tol);
ASSERT_EQUAL_VEC(Vec3(-1.07827e+02, 4.40282e+01, 2.20884e+02), forces1[727], tol); ASSERT_EQUAL_VEC(Vec3(-1.07833245e+02, 4.40219598e+01, 2.20888632e+02), forces1[727], tol);
ASSERT_EQUAL_VEC(Vec3( 2.92921e+02, 5.54179e+02, 3.57020e+02), forces1[728], tol); ASSERT_EQUAL_VEC(Vec3( 2.92915083e+02, 5.54179388e+02, 3.57016084e+02), forces1[728], tol);
ASSERT_EQUAL_VEC(Vec3(-6.11702e+02, 1.34356e+02, 4.75012e+01), forces1[729], tol); ASSERT_EQUAL_VEC(Vec3(-6.11696651e+02, 1.34361189e+02, 4.74917740e+01), forces1[729], tol);
ASSERT_EQUAL_VEC(Vec3(-8.07621e+02, 1.63939e+01, -2.56537e+02), forces1[730], tol); ASSERT_EQUAL_VEC(Vec3(-8.07629704e+02, 1.63946818e+01, -2.56529488e+02), forces1[730], tol);
ASSERT_EQUAL_VEC(Vec3( 5.08915e+01, 1.35163e+01, 4.82195e+02), forces1[731], tol); ASSERT_EQUAL_VEC(Vec3( 5.08866790e+01, 1.35087356e+01, 4.82186568e+02), forces1[731], tol);
ASSERT_EQUAL_VEC(Vec3(-5.01054e+02, -7.35316e+02, 6.67914e+02), forces1[732], tol); ASSERT_EQUAL_VEC(Vec3(-5.01056820e+02, -7.35300196e+02, 6.67917664e+02), forces1[732], tol);
ASSERT_EQUAL_VEC(Vec3(-1.74250e+00, 6.70725e+02, -1.03874e+03), forces1[733], tol); ASSERT_EQUAL_VEC(Vec3(-1.75353826e+00, 6.70720055e+02, -1.03873923e+03), forces1[733], tol);
ASSERT_EQUAL_VEC(Vec3(-1.95458e+02, 4.63763e+02, 7.41301e+01), forces1[734], tol); ASSERT_EQUAL_VEC(Vec3(-1.95461285e+02, 4.63755838e+02, 7.41243174e+01), forces1[734], tol);
ASSERT_EQUAL_VEC(Vec3(-2.73262e+02, -4.33942e+02, -5.86873e+02), forces1[735], tol); ASSERT_EQUAL_VEC(Vec3(-2.73265807e+02, -4.33952751e+02, -5.86859952e+02), forces1[735], tol);
ASSERT_EQUAL_VEC(Vec3( 3.87503e+02, -3.57434e+02, -1.22669e+02), forces1[736], tol); ASSERT_EQUAL_VEC(Vec3( 3.87492595e+02, -3.57416581e+02, -1.22674219e+02), forces1[736], tol);
ASSERT_EQUAL_VEC(Vec3( 2.10280e+02, -8.24100e+01, -3.92473e+02), forces1[737], tol); ASSERT_EQUAL_VEC(Vec3( 2.10277679e+02, -8.24319147e+01, -3.92467268e+02), forces1[737], tol);
ASSERT_EQUAL_VEC(Vec3( 8.30185e+02, -6.58247e+02, -4.70878e+02), forces1[738], tol); ASSERT_EQUAL_VEC(Vec3( 8.30183105e+02, -6.58248549e+02, -4.70873747e+02), forces1[738], tol);
ASSERT_EQUAL_VEC(Vec3( 1.32204e+02, 1.07239e+02, -2.42575e+02), forces1[739], tol); ASSERT_EQUAL_VEC(Vec3( 1.32224273e+02, 1.07242154e+02, -2.42599632e+02), forces1[739], tol);
ASSERT_EQUAL_VEC(Vec3(-4.36743e+02, 2.00428e+01, -3.45985e+02), forces1[740], tol); ASSERT_EQUAL_VEC(Vec3(-4.36748065e+02, 2.00463318e+01, -3.45993944e+02), forces1[740], tol);
ASSERT_EQUAL_VEC(Vec3(-5.77269e+02, 1.27434e+02, -4.58817e+02), forces1[741], tol); ASSERT_EQUAL_VEC(Vec3(-5.77263697e+02, 1.27439720e+02, -4.58810491e+02), forces1[741], tol);
ASSERT_EQUAL_VEC(Vec3( 1.97483e+02, -2.58384e+02, 1.34671e+02), forces1[742], tol); ASSERT_EQUAL_VEC(Vec3( 1.97481946e+02, -2.58388548e+02, 1.34658918e+02), forces1[742], tol);
ASSERT_EQUAL_VEC(Vec3( 3.87576e+01, -8.11452e+02, -2.37628e+02), forces1[743], tol); ASSERT_EQUAL_VEC(Vec3( 3.87665419e+01, -8.11439393e+02, -2.37617083e+02), forces1[743], tol);
ASSERT_EQUAL_VEC(Vec3(-5.43735e+02, 7.08865e+01, -1.18495e+02), forces1[744], tol); ASSERT_EQUAL_VEC(Vec3(-5.43756717e+02, 7.08678099e+01, -1.18510886e+02), forces1[744], tol);
ASSERT_EQUAL_VEC(Vec3(-4.18090e+02, 9.12482e+01, -3.26409e+02), forces1[745], tol); ASSERT_EQUAL_VEC(Vec3(-4.18101023e+02, 9.12399127e+01, -3.26402702e+02), forces1[745], tol);
ASSERT_EQUAL_VEC(Vec3(-1.04727e+02, 4.73090e+02, -5.52392e+02), forces1[746], tol); ASSERT_EQUAL_VEC(Vec3(-1.04715128e+02, 4.73092172e+02, -5.52394413e+02), forces1[746], tol);
ASSERT_EQUAL_VEC(Vec3( 1.50384e+02, 6.74559e+02, -8.65298e+01), forces1[747], tol); ASSERT_EQUAL_VEC(Vec3( 1.50377202e+02, 6.74569790e+02, -8.65206460e+01), forces1[747], tol);
ASSERT_EQUAL_VEC(Vec3(-4.91773e+01, 9.70105e+01, 4.14941e+01), forces1[748], tol); ASSERT_EQUAL_VEC(Vec3(-4.91854971e+01, 9.70238350e+01, 4.14795171e+01), forces1[748], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53139e+02, -3.14684e+02, 1.64528e+02), forces1[749], tol); ASSERT_EQUAL_VEC(Vec3(-1.53136450e+02, -3.14704270e+02, 1.64509568e+02), forces1[749], tol);
ASSERT_EQUAL_VEC(Vec3( 5.38743e-01, -2.20855e+02, 2.62849e+02), forces1[750], tol); ASSERT_EQUAL_VEC(Vec3( 5.38381589e-01, -2.20857586e+02, 2.62858346e+02), forces1[750], tol);
ASSERT_EQUAL_VEC(Vec3(-6.92127e+02, 2.00418e+02, -2.65833e+02), forces1[751], tol); ASSERT_EQUAL_VEC(Vec3(-6.92118459e+02, 2.00416528e+02, -2.65829388e+02), forces1[751], tol);
ASSERT_EQUAL_VEC(Vec3( 3.79022e+01, -1.05191e+02, -3.82768e+01), forces1[752], tol); ASSERT_EQUAL_VEC(Vec3( 3.79128765e+01, -1.05184233e+02, -3.82602540e+01), forces1[752], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53016e+02, 2.11989e+02, -3.81674e+02), forces1[753], tol); ASSERT_EQUAL_VEC(Vec3(-2.53012338e+02, 2.11976275e+02, -3.81671037e+02), forces1[753], tol);
ASSERT_EQUAL_VEC(Vec3(-2.51268e+02, -3.93332e+02, -1.33248e+01), forces1[754], tol); ASSERT_EQUAL_VEC(Vec3(-2.51271776e+02, -3.93332088e+02, -1.33288963e+01), forces1[754], tol);
ASSERT_EQUAL_VEC(Vec3(-3.01384e+01, 1.45597e+02, -6.30474e+01), forces1[755], tol); ASSERT_EQUAL_VEC(Vec3(-3.01457396e+01, 1.45589903e+02, -6.30529431e+01), forces1[755], tol);
ASSERT_EQUAL_VEC(Vec3(-2.76307e+02, -4.61697e+02, -2.69335e+02), forces1[756], tol); ASSERT_EQUAL_VEC(Vec3(-2.76296961e+02, -4.61689259e+02, -2.69337581e+02), forces1[756], tol);
ASSERT_EQUAL_VEC(Vec3( 6.48662e+01, 3.68740e+02, 2.32254e+02), forces1[757], tol); ASSERT_EQUAL_VEC(Vec3( 6.48638526e+01, 3.68743791e+02, 2.32261042e+02), forces1[757], tol);
ASSERT_EQUAL_VEC(Vec3(-4.48058e+02, 4.24011e+02, 2.00618e+02), forces1[758], tol); ASSERT_EQUAL_VEC(Vec3(-4.48058548e+02, 4.24011162e+02, 2.00613297e+02), forces1[758], tol);
ASSERT_EQUAL_VEC(Vec3( 1.50185e+01, -7.33767e+01, 4.00845e+02), forces1[759], tol); ASSERT_EQUAL_VEC(Vec3( 1.50464122e+01, -7.33758427e+01, 4.00841100e+02), forces1[759], tol);
ASSERT_EQUAL_VEC(Vec3( 4.06786e+02, 1.22308e+02, -3.26330e+02), forces1[760], tol); ASSERT_EQUAL_VEC(Vec3( 4.06782738e+02, 1.22303609e+02, -3.26339153e+02), forces1[760], tol);
ASSERT_EQUAL_VEC(Vec3(-3.55717e+02, -4.23654e+02, 1.92964e+02), forces1[761], tol); ASSERT_EQUAL_VEC(Vec3(-3.55711012e+02, -4.23650736e+02, 1.92960061e+02), forces1[761], tol);
ASSERT_EQUAL_VEC(Vec3(-4.78897e+01, 1.13392e+02, -4.55729e+02), forces1[762], tol); ASSERT_EQUAL_VEC(Vec3(-4.78915336e+01, 1.13386663e+02, -4.55722593e+02), forces1[762], tol);
ASSERT_EQUAL_VEC(Vec3( 5.50236e+02, 3.20978e+02, -2.04100e+02), forces1[763], tol); ASSERT_EQUAL_VEC(Vec3( 5.50242083e+02, 3.20971060e+02, -2.04129569e+02), forces1[763], tol);
ASSERT_EQUAL_VEC(Vec3(-3.98386e+01, 6.42990e+01, 2.62923e+02), forces1[764], tol); ASSERT_EQUAL_VEC(Vec3(-3.98415518e+01, 6.43149241e+01, 2.62918629e+02), forces1[764], tol);
ASSERT_EQUAL_VEC(Vec3(-7.85233e+01, -7.50433e+01, -7.62979e+02), forces1[765], tol); ASSERT_EQUAL_VEC(Vec3(-7.85279974e+01, -7.50534137e+01, -7.62991530e+02), forces1[765], tol);
ASSERT_EQUAL_VEC(Vec3( 9.56804e+00, -3.95490e+02, -8.95634e+01), forces1[766], tol); ASSERT_EQUAL_VEC(Vec3( 9.55632719e+00, -3.95488033e+02, -8.95724718e+01), forces1[766], tol);
ASSERT_EQUAL_VEC(Vec3( 4.83249e+02, -7.40419e+02, -5.32392e+02), forces1[767], tol); ASSERT_EQUAL_VEC(Vec3( 4.83248484e+02, -7.40432533e+02, -5.32388436e+02), forces1[767], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61826e+02, 8.15275e+01, 4.71858e+02), forces1[768], tol); ASSERT_EQUAL_VEC(Vec3(-1.61825590e+02, 8.15278549e+01, 4.71854738e+02), forces1[768], tol);
ASSERT_EQUAL_VEC(Vec3(-3.30810e+02, -4.22051e+01, -1.05048e+03), forces1[769], tol); ASSERT_EQUAL_VEC(Vec3(-3.30808156e+02, -4.21996977e+01, -1.05047553e+03), forces1[769], tol);
ASSERT_EQUAL_VEC(Vec3( 3.34228e+02, -1.34572e+02, 3.33960e+02), forces1[770], tol); ASSERT_EQUAL_VEC(Vec3( 3.34236506e+02, -1.34581292e+02, 3.33945615e+02), forces1[770], tol);
ASSERT_EQUAL_VEC(Vec3( 2.25465e+01, 6.94634e+02, 3.48167e+01), forces1[771], tol); ASSERT_EQUAL_VEC(Vec3( 2.25548584e+01, 6.94629483e+02, 3.48264737e+01), forces1[771], tol);
ASSERT_EQUAL_VEC(Vec3( 4.92306e+02, -3.56650e+02, 7.11572e+01), forces1[772], tol); ASSERT_EQUAL_VEC(Vec3( 4.92311713e+02, -3.56653650e+02, 7.11601228e+01), forces1[772], tol);
ASSERT_EQUAL_VEC(Vec3( 2.17173e+02, 4.04900e+01, 3.47154e+02), forces1[773], tol); ASSERT_EQUAL_VEC(Vec3( 2.17161427e+02, 4.05017188e+01, 3.47168571e+02), forces1[773], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61153e+01, 1.47266e+03, 5.49813e+02), forces1[774], tol); ASSERT_EQUAL_VEC(Vec3(-1.61160760e+01, 1.47265327e+03, 5.49839208e+02), forces1[774], tol);
ASSERT_EQUAL_VEC(Vec3( 8.39593e+01, -4.18460e+02, 2.34855e+02), forces1[775], tol); ASSERT_EQUAL_VEC(Vec3( 8.39508346e+01, -4.18462111e+02, 2.34856125e+02), forces1[775], tol);
ASSERT_EQUAL_VEC(Vec3(-2.31366e+02, 2.37284e+02, 6.61407e+01), forces1[776], tol); ASSERT_EQUAL_VEC(Vec3(-2.31363191e+02, 2.37282362e+02, 6.61594930e+01), forces1[776], tol);
ASSERT_EQUAL_VEC(Vec3(-6.24147e+01, -7.00154e+02, 4.91306e+02), forces1[777], tol); ASSERT_EQUAL_VEC(Vec3(-6.23920550e+01, -7.00163723e+02, 4.91292544e+02), forces1[777], tol);
ASSERT_EQUAL_VEC(Vec3( 2.68269e+01, 2.46999e+02, 6.64376e-01), forces1[778], tol); ASSERT_EQUAL_VEC(Vec3( 2.68222410e+01, 2.46989964e+02, 6.49012925e-01), forces1[778], tol);
ASSERT_EQUAL_VEC(Vec3( 5.26245e+02, 1.10208e+02, 3.46428e+02), forces1[779], tol); ASSERT_EQUAL_VEC(Vec3( 5.26234504e+02, 1.10220781e+02, 3.46422754e+02), forces1[779], tol);
ASSERT_EQUAL_VEC(Vec3(-3.29274e+02, -3.87179e+02, 8.51878e+01), forces1[780], tol); ASSERT_EQUAL_VEC(Vec3(-3.29262429e+02, -3.87187275e+02, 8.51736504e+01), forces1[780], tol);
ASSERT_EQUAL_VEC(Vec3( 6.42869e+02, 2.34873e+02, 3.71364e+02), forces1[781], tol); ASSERT_EQUAL_VEC(Vec3( 6.42859552e+02, 2.34857815e+02, 3.71368125e+02), forces1[781], tol);
ASSERT_EQUAL_VEC(Vec3(-3.24678e+02, 5.64049e+02, -4.46061e+01), forces1[782], tol); ASSERT_EQUAL_VEC(Vec3(-3.24691537e+02, 5.64035803e+02, -4.45828642e+01), forces1[782], tol);
ASSERT_EQUAL_VEC(Vec3( 5.74450e+01, 1.20266e+02, -5.84619e+01), forces1[783], tol); ASSERT_EQUAL_VEC(Vec3( 5.74664181e+01, 1.20257138e+02, -5.84616728e+01), forces1[783], tol);
ASSERT_EQUAL_VEC(Vec3(-2.83822e+02, -2.10802e+02, 1.66003e+02), forces1[784], tol); ASSERT_EQUAL_VEC(Vec3(-2.83822896e+02, -2.10782913e+02, 1.66012284e+02), forces1[784], tol);
ASSERT_EQUAL_VEC(Vec3( 4.01597e+02, -2.85123e+02, 2.49476e+02), forces1[785], tol); ASSERT_EQUAL_VEC(Vec3( 4.01591578e+02, -2.85111660e+02, 2.49467396e+02), forces1[785], tol);
ASSERT_EQUAL_VEC(Vec3( 3.05508e+02, 7.04817e+02, -5.94580e+01), forces1[786], tol); ASSERT_EQUAL_VEC(Vec3( 3.05502334e+02, 7.04806702e+02, -5.94571548e+01), forces1[786], tol);
ASSERT_EQUAL_VEC(Vec3(-5.06839e+02, 3.13597e+02, -7.30055e+02), forces1[787], tol); ASSERT_EQUAL_VEC(Vec3(-5.06843754e+02, 3.13614505e+02, -7.30043017e+02), forces1[787], tol);
ASSERT_EQUAL_VEC(Vec3(-1.65618e+02, -1.02571e+02, -4.10514e+02), forces1[788], tol); ASSERT_EQUAL_VEC(Vec3(-1.65622368e+02, -1.02579327e+02, -4.10521389e+02), forces1[788], tol);
ASSERT_EQUAL_VEC(Vec3( 2.50024e+02, 9.82342e+02, 3.08275e+02), forces1[789], tol); ASSERT_EQUAL_VEC(Vec3( 2.50016463e+02, 9.82377276e+02, 3.08289476e+02), forces1[789], tol);
ASSERT_EQUAL_VEC(Vec3( 3.60201e+02, 3.06215e+02, 4.01452e+02), forces1[790], tol); ASSERT_EQUAL_VEC(Vec3( 3.60198825e+02, 3.06200915e+02, 4.01455745e+02), forces1[790], tol);
ASSERT_EQUAL_VEC(Vec3(-5.15579e+02, -3.80891e+02, -2.65984e+02), forces1[791], tol); ASSERT_EQUAL_VEC(Vec3(-5.15582709e+02, -3.80887100e+02, -2.65984423e+02), forces1[791], tol);
ASSERT_EQUAL_VEC(Vec3( 9.16931e+02, -2.71011e+02, 2.88899e+02), forces1[792], tol); ASSERT_EQUAL_VEC(Vec3( 9.16914445e+02, -2.70992304e+02, 2.88892766e+02), forces1[792], tol);
ASSERT_EQUAL_VEC(Vec3( 5.58182e+01, 1.28559e+02, 4.36840e+02), forces1[793], tol); ASSERT_EQUAL_VEC(Vec3( 5.58063411e+01, 1.28556880e+02, 4.36834411e+02), forces1[793], tol);
ASSERT_EQUAL_VEC(Vec3( 3.48852e+02, 3.63954e+02, 3.78553e+02), forces1[794], tol); ASSERT_EQUAL_VEC(Vec3( 3.48855713e+02, 3.63953389e+02, 3.78554885e+02), forces1[794], tol);
ASSERT_EQUAL_VEC(Vec3( 6.36614e+02, -1.91574e+02, 4.14276e+02), forces1[795], tol); ASSERT_EQUAL_VEC(Vec3( 6.36625415e+02, -1.91568531e+02, 4.14269326e+02), forces1[795], tol);
ASSERT_EQUAL_VEC(Vec3(-3.31371e+01, -1.47710e+02, 3.03803e+02), forces1[796], tol); ASSERT_EQUAL_VEC(Vec3(-3.31399256e+01, -1.47717726e+02, 3.03791102e+02), forces1[796], tol);
ASSERT_EQUAL_VEC(Vec3(-8.19780e+01, -5.66605e+02, -7.77526e+01), forces1[797], tol); ASSERT_EQUAL_VEC(Vec3(-8.19625890e+01, -5.66609696e+02, -7.77438618e+01), forces1[797], tol);
ASSERT_EQUAL_VEC(Vec3( 1.20336e+02, 3.66637e+02, -2.38045e+02), forces1[798], tol); ASSERT_EQUAL_VEC(Vec3( 1.20348179e+02, 3.66643084e+02, -2.38052731e+02), forces1[798], tol);
ASSERT_EQUAL_VEC(Vec3( 3.60717e+02, 4.45420e+02, -6.03548e+02), forces1[799], tol); ASSERT_EQUAL_VEC(Vec3( 3.60705602e+02, 4.45404187e+02, -6.03564902e+02), forces1[799], tol);
ASSERT_EQUAL_VEC(Vec3(-8.71339e+01, 1.63926e+02, -1.43931e+02), forces1[800], tol); ASSERT_EQUAL_VEC(Vec3(-8.71394660e+01, 1.63937553e+02, -1.43929941e+02), forces1[800], tol);
ASSERT_EQUAL_VEC(Vec3(-9.98807e+01, 1.96104e+01, -5.85565e+01), forces1[801], tol); ASSERT_EQUAL_VEC(Vec3(-9.99012969e+01, 1.96050644e+01, -5.85512840e+01), forces1[801], tol);
ASSERT_EQUAL_VEC(Vec3( 4.81448e+02, -7.04110e+01, -2.08012e+02), forces1[802], tol); ASSERT_EQUAL_VEC(Vec3( 4.81464959e+02, -7.04133234e+01, -2.08003335e+02), forces1[802], tol);
ASSERT_EQUAL_VEC(Vec3(-7.69380e+02, 5.40415e+01, 5.38434e+02), forces1[803], tol); ASSERT_EQUAL_VEC(Vec3(-7.69383659e+02, 5.40518266e+01, 5.38423746e+02), forces1[803], tol);
ASSERT_EQUAL_VEC(Vec3(-6.60832e+02, -1.87951e+02, 4.11977e+02), forces1[804], tol); ASSERT_EQUAL_VEC(Vec3(-6.60834570e+02, -1.87942951e+02, 4.11979846e+02), forces1[804], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06274e+02, 3.55329e+02, -2.27802e+02), forces1[805], tol); ASSERT_EQUAL_VEC(Vec3( 1.06277928e+02, 3.55317856e+02, -2.27807465e+02), forces1[805], tol);
ASSERT_EQUAL_VEC(Vec3(-2.66108e+02, 2.41366e+02, -4.99243e+02), forces1[806], tol); ASSERT_EQUAL_VEC(Vec3(-2.66112993e+02, 2.41378629e+02, -4.99239330e+02), forces1[806], tol);
ASSERT_EQUAL_VEC(Vec3(-5.23138e+01, 9.33681e+01, 7.23821e+02), forces1[807], tol); ASSERT_EQUAL_VEC(Vec3(-5.23091617e+01, 9.33588668e+01, 7.23830549e+02), forces1[807], tol);
ASSERT_EQUAL_VEC(Vec3( 2.79874e+00, 6.04333e+01, 1.65510e+02), forces1[808], tol); ASSERT_EQUAL_VEC(Vec3( 2.82159908e+00, 6.04185043e+01, 1.65510623e+02), forces1[808], tol);
ASSERT_EQUAL_VEC(Vec3(-2.97263e+02, -5.53742e+01, 3.87130e+02), forces1[809], tol); ASSERT_EQUAL_VEC(Vec3(-2.97249356e+02, -5.53850820e+01, 3.87132557e+02), forces1[809], tol);
ASSERT_EQUAL_VEC(Vec3(-8.18642e+02, -2.66096e+02, 1.07283e+03), forces1[810], tol); ASSERT_EQUAL_VEC(Vec3(-8.18654835e+02, -2.66089588e+02, 1.07282779e+03), forces1[810], tol);
ASSERT_EQUAL_VEC(Vec3(-2.43716e+02, -2.51623e+02, 3.46345e+02), forces1[811], tol); ASSERT_EQUAL_VEC(Vec3(-2.43727371e+02, -2.51641252e+02, 3.46339026e+02), forces1[811], tol);
ASSERT_EQUAL_VEC(Vec3( 4.04766e+02, 1.12586e+02, -6.66763e+02), forces1[812], tol); ASSERT_EQUAL_VEC(Vec3( 4.04775249e+02, 1.12602806e+02, -6.66755260e+02), forces1[812], tol);
ASSERT_EQUAL_VEC(Vec3(-8.31008e+01, -9.75678e+01, -5.15306e+02), forces1[813], tol); ASSERT_EQUAL_VEC(Vec3(-8.30889004e+01, -9.75627382e+01, -5.15294649e+02), forces1[813], tol);
ASSERT_EQUAL_VEC(Vec3(-8.88915e+01, -2.43586e+02, -4.28258e+02), forces1[814], tol); ASSERT_EQUAL_VEC(Vec3(-8.88900158e+01, -2.43585030e+02, -4.28254176e+02), forces1[814], tol);
ASSERT_EQUAL_VEC(Vec3(-9.15351e+01, 4.50360e+02, -2.64172e+02), forces1[815], tol); ASSERT_EQUAL_VEC(Vec3(-9.15239756e+01, 4.50356816e+02, -2.64185924e+02), forces1[815], tol);
ASSERT_EQUAL_VEC(Vec3(-9.11782e+01, 4.24895e+02, -1.85104e+02), forces1[816], tol); ASSERT_EQUAL_VEC(Vec3(-9.11727906e+01, 4.24890801e+02, -1.85085639e+02), forces1[816], tol);
ASSERT_EQUAL_VEC(Vec3(-3.91198e+02, -6.86407e+02, 1.52751e+02), forces1[817], tol); ASSERT_EQUAL_VEC(Vec3(-3.91190277e+02, -6.86391314e+02, 1.52743025e+02), forces1[817], tol);
ASSERT_EQUAL_VEC(Vec3(-8.21125e+01, -2.49524e+02, 5.27519e+02), forces1[818], tol); ASSERT_EQUAL_VEC(Vec3(-8.21031361e+01, -2.49525239e+02, 5.27536153e+02), forces1[818], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09416e+02, -6.29105e+02, 3.34948e+02), forces1[819], tol); ASSERT_EQUAL_VEC(Vec3(-1.09414974e+02, -6.29098191e+02, 3.34955724e+02), forces1[819], tol);
ASSERT_EQUAL_VEC(Vec3(-4.17383e+02, -9.10802e+01, -3.54785e+01), forces1[820], tol); ASSERT_EQUAL_VEC(Vec3(-4.17387560e+02, -9.10777301e+01, -3.54885448e+01), forces1[820], tol);
ASSERT_EQUAL_VEC(Vec3( 2.79537e+02, -5.39045e+02, 5.07376e+02), forces1[821], tol); ASSERT_EQUAL_VEC(Vec3( 2.79543439e+02, -5.39041840e+02, 5.07374351e+02), forces1[821], tol);
ASSERT_EQUAL_VEC(Vec3( 2.14819e+02, 1.92076e+01, -3.14831e+02), forces1[822], tol); ASSERT_EQUAL_VEC(Vec3( 2.14822336e+02, 1.92270744e+01, -3.14848497e+02), forces1[822], tol);
ASSERT_EQUAL_VEC(Vec3(-1.92610e+02, -4.26140e+02, -6.22529e+00), forces1[823], tol); ASSERT_EQUAL_VEC(Vec3(-1.92605165e+02, -4.26132560e+02, -6.22677382e+00), forces1[823], tol);
ASSERT_EQUAL_VEC(Vec3(-6.55145e+02, -4.86066e+02, -3.89400e+02), forces1[824], tol); ASSERT_EQUAL_VEC(Vec3(-6.55145464e+02, -4.86073333e+02, -3.89399825e+02), forces1[824], tol);
ASSERT_EQUAL_VEC(Vec3(-1.89869e+02, -3.77326e+02, -1.36204e+02), forces1[825], tol); ASSERT_EQUAL_VEC(Vec3(-1.89867341e+02, -3.77315894e+02, -1.36214663e+02), forces1[825], tol);
ASSERT_EQUAL_VEC(Vec3( 4.60002e+02, 1.99080e+02, 2.82584e+02), forces1[826], tol); ASSERT_EQUAL_VEC(Vec3( 4.60001225e+02, 1.99094537e+02, 2.82584474e+02), forces1[826], tol);
ASSERT_EQUAL_VEC(Vec3( 1.21553e+02, -1.21196e+02, 7.24061e+02), forces1[827], tol); ASSERT_EQUAL_VEC(Vec3( 1.21553284e+02, -1.21203683e+02, 7.24058067e+02), forces1[827], tol);
ASSERT_EQUAL_VEC(Vec3(-9.16947e+01, 7.09282e+01, 7.89316e+01), forces1[828], tol); ASSERT_EQUAL_VEC(Vec3(-9.16986437e+01, 7.09307382e+01, 7.89267421e+01), forces1[828], tol);
ASSERT_EQUAL_VEC(Vec3(-3.83823e+02, 8.44731e+01, 1.09605e+03), forces1[829], tol); ASSERT_EQUAL_VEC(Vec3(-3.83808972e+02, 8.44796287e+01, 1.09604935e+03), forces1[829], tol);
ASSERT_EQUAL_VEC(Vec3(-3.65402e+02, -1.88795e+02, 4.62345e+02), forces1[830], tol); ASSERT_EQUAL_VEC(Vec3(-3.65392705e+02, -1.88802374e+02, 4.62347013e+02), forces1[830], tol);
ASSERT_EQUAL_VEC(Vec3( 5.76342e+02, -9.42175e+01, -1.98147e+02), forces1[831], tol); ASSERT_EQUAL_VEC(Vec3( 5.76337730e+02, -9.41995570e+01, -1.98141882e+02), forces1[831], tol);
ASSERT_EQUAL_VEC(Vec3(-4.21544e+02, -5.96887e+01, -8.33519e+02), forces1[832], tol); ASSERT_EQUAL_VEC(Vec3(-4.21540736e+02, -5.96961388e+01, -8.33517850e+02), forces1[832], tol);
ASSERT_EQUAL_VEC(Vec3( 1.20308e+03, 4.53520e+02, 2.29392e+02), forces1[833], tol); ASSERT_EQUAL_VEC(Vec3( 1.20307619e+03, 4.53518250e+02, 2.29372510e+02), forces1[833], tol);
ASSERT_EQUAL_VEC(Vec3( 2.92096e+02, 4.13378e+01, -3.61116e+02), forces1[834], tol); ASSERT_EQUAL_VEC(Vec3( 2.92097304e+02, 4.13164379e+01, -3.61110495e+02), forces1[834], tol);
ASSERT_EQUAL_VEC(Vec3( 2.49882e+02, -1.26746e+02, 2.01737e+02), forces1[835], tol); ASSERT_EQUAL_VEC(Vec3( 2.49877930e+02, -1.26742169e+02, 2.01739900e+02), forces1[835], tol);
ASSERT_EQUAL_VEC(Vec3( 4.82077e+02, -4.36732e+02, 2.10931e+02), forces1[836], tol); ASSERT_EQUAL_VEC(Vec3( 4.82075008e+02, -4.36717554e+02, 2.10931182e+02), forces1[836], tol);
ASSERT_EQUAL_VEC(Vec3( 7.38933e+00, -3.07859e+02, -2.19284e+02), forces1[837], tol); ASSERT_EQUAL_VEC(Vec3( 7.40048230e+00, -3.07870679e+02, -2.19267744e+02), forces1[837], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77938e+02, -1.78450e+02, 3.27367e+02), forces1[838], tol); ASSERT_EQUAL_VEC(Vec3(-1.77929397e+02, -1.78455309e+02, 3.27383377e+02), forces1[838], tol);
ASSERT_EQUAL_VEC(Vec3(-1.43512e+02, 2.36682e+02, 1.76256e+02), forces1[839], tol); ASSERT_EQUAL_VEC(Vec3(-1.43502125e+02, 2.36677035e+02, 1.76250580e+02), forces1[839], tol);
ASSERT_EQUAL_VEC(Vec3(-3.11012e+02, 3.30169e+01, 2.29428e+02), forces1[840], tol); ASSERT_EQUAL_VEC(Vec3(-3.11015280e+02, 3.30102369e+01, 2.29419157e+02), forces1[840], tol);
ASSERT_EQUAL_VEC(Vec3( 7.16714e+01, -1.44526e+00, -8.22935e+02), forces1[841], tol); ASSERT_EQUAL_VEC(Vec3( 7.16636078e+01, -1.43182827e+00, -8.22939586e+02), forces1[841], tol);
ASSERT_EQUAL_VEC(Vec3(-2.21652e+02, -4.50322e+01, -4.49961e+02), forces1[842], tol); ASSERT_EQUAL_VEC(Vec3(-2.21647238e+02, -4.50480586e+01, -4.49964194e+02), forces1[842], tol);
ASSERT_EQUAL_VEC(Vec3(-4.26331e+02, -2.93331e+02, 2.05048e+02), forces1[843], tol); ASSERT_EQUAL_VEC(Vec3(-4.26322975e+02, -2.93336811e+02, 2.05038938e+02), forces1[843], tol);
ASSERT_EQUAL_VEC(Vec3( 8.06853e+01, 3.83782e+02, 4.54351e+02), forces1[844], tol); ASSERT_EQUAL_VEC(Vec3( 8.06775958e+01, 3.83777410e+02, 4.54379037e+02), forces1[844], tol);
ASSERT_EQUAL_VEC(Vec3( 1.36446e+01, -1.12114e+02, -2.08562e+02), forces1[845], tol); ASSERT_EQUAL_VEC(Vec3( 1.36404637e+01, -1.12124193e+02, -2.08562538e+02), forces1[845], tol);
ASSERT_EQUAL_VEC(Vec3(-4.31289e+01, 1.28742e+02, 2.41015e+02), forces1[846], tol); ASSERT_EQUAL_VEC(Vec3(-4.31330496e+01, 1.28721913e+02, 2.41017400e+02), forces1[846], tol);
ASSERT_EQUAL_VEC(Vec3( 3.71915e+02, 3.66514e+02, -1.02558e+02), forces1[847], tol); ASSERT_EQUAL_VEC(Vec3( 3.71916499e+02, 3.66494598e+02, -1.02567885e+02), forces1[847], tol);
ASSERT_EQUAL_VEC(Vec3(-2.30303e+02, 7.54911e+02, 1.07596e+02), forces1[848], tol); ASSERT_EQUAL_VEC(Vec3(-2.30281354e+02, 7.54907643e+02, 1.07586282e+02), forces1[848], tol);
ASSERT_EQUAL_VEC(Vec3( 2.67841e+02, -1.51918e+01, -1.70089e+02), forces1[849], tol); ASSERT_EQUAL_VEC(Vec3( 2.67865075e+02, -1.51751902e+01, -1.70086059e+02), forces1[849], tol);
ASSERT_EQUAL_VEC(Vec3(-9.39296e+02, 5.63969e+01, -2.22408e+02), forces1[850], tol); ASSERT_EQUAL_VEC(Vec3(-9.39303971e+02, 5.64031361e+01, -2.22408474e+02), forces1[850], tol);
ASSERT_EQUAL_VEC(Vec3(-1.01325e+02, 3.31072e+02, 7.07372e+02), forces1[851], tol); ASSERT_EQUAL_VEC(Vec3(-1.01324797e+02, 3.31075650e+02, 7.07373134e+02), forces1[851], tol);
ASSERT_EQUAL_VEC(Vec3( 1.78202e+02, 8.50260e+01, -6.39938e+02), forces1[852], tol); ASSERT_EQUAL_VEC(Vec3( 1.78185244e+02, 8.50185531e+01, -6.39941165e+02), forces1[852], tol);
ASSERT_EQUAL_VEC(Vec3( 3.33078e+02, 9.10321e+01, 1.20467e+02), forces1[853], tol); ASSERT_EQUAL_VEC(Vec3( 3.33075565e+02, 9.10263334e+01, 1.20466005e+02), forces1[853], tol);
ASSERT_EQUAL_VEC(Vec3( 4.22497e+01, -7.37212e+02, 6.08446e+02), forces1[854], tol); ASSERT_EQUAL_VEC(Vec3( 4.22270537e+01, -7.37202915e+02, 6.08451352e+02), forces1[854], tol);
ASSERT_EQUAL_VEC(Vec3(-4.16910e+02, -4.82517e+02, 3.91824e+01), forces1[855], tol); ASSERT_EQUAL_VEC(Vec3(-4.16913834e+02, -4.82510498e+02, 3.91902755e+01), forces1[855], tol);
ASSERT_EQUAL_VEC(Vec3(-4.09096e+02, -1.95377e+02, -1.49036e+02), forces1[856], tol); ASSERT_EQUAL_VEC(Vec3(-4.09087109e+02, -1.95401814e+02, -1.49030786e+02), forces1[856], tol);
ASSERT_EQUAL_VEC(Vec3(-2.89150e+01, 3.78194e+02, 2.19686e+02), forces1[857], tol); ASSERT_EQUAL_VEC(Vec3(-2.89287185e+01, 3.78198264e+02, 2.19689536e+02), forces1[857], tol);
ASSERT_EQUAL_VEC(Vec3(-2.77571e+02, 7.90454e+01, 3.49469e+02), forces1[858], tol); ASSERT_EQUAL_VEC(Vec3(-2.77576965e+02, 7.90464050e+01, 3.49478331e+02), forces1[858], tol);
ASSERT_EQUAL_VEC(Vec3( 4.71065e+02, -1.88933e+02, -2.48139e+02), forces1[859], tol); ASSERT_EQUAL_VEC(Vec3( 4.71047132e+02, -1.88937165e+02, -2.48124657e+02), forces1[859], tol);
ASSERT_EQUAL_VEC(Vec3(-1.51518e+02, 4.96207e+01, -2.65458e+02), forces1[860], tol); ASSERT_EQUAL_VEC(Vec3(-1.51518383e+02, 4.96193568e+01, -2.65467571e+02), forces1[860], tol);
ASSERT_EQUAL_VEC(Vec3(-7.66433e+02, 8.46593e+01, -3.64801e+02), forces1[861], tol); ASSERT_EQUAL_VEC(Vec3(-7.66418994e+02, 8.46521518e+01, -3.64791094e+02), forces1[861], tol);
ASSERT_EQUAL_VEC(Vec3(-5.09762e+02, 2.10681e+01, 3.01829e+02), forces1[862], tol); ASSERT_EQUAL_VEC(Vec3(-5.09774310e+02, 2.10742961e+01, 3.01814635e+02), forces1[862], tol);
ASSERT_EQUAL_VEC(Vec3(-9.75617e+00, 7.12489e+01, 9.37948e+01), forces1[863], tol); ASSERT_EQUAL_VEC(Vec3(-9.75620816e+00, 7.12587243e+01, 9.37836693e+01), forces1[863], tol);
ASSERT_EQUAL_VEC(Vec3( 9.17135e+01, -4.41196e+02, -1.00411e+02), forces1[864], tol); ASSERT_EQUAL_VEC(Vec3( 9.17385110e+01, -4.41182772e+02, -1.00398188e+02), forces1[864], tol);
ASSERT_EQUAL_VEC(Vec3(-2.52908e+01, -1.90233e+02, 4.81483e+01), forces1[865], tol); ASSERT_EQUAL_VEC(Vec3(-2.52943928e+01, -1.90239695e+02, 4.81670302e+01), forces1[865], tol);
ASSERT_EQUAL_VEC(Vec3(-5.44288e+02, 2.54813e+02, -1.75169e+02), forces1[866], tol); ASSERT_EQUAL_VEC(Vec3(-5.44266700e+02, 2.54811263e+02, -1.75181268e+02), forces1[866], tol);
ASSERT_EQUAL_VEC(Vec3( 4.08130e+02, -1.23549e+02, -2.06938e+02), forces1[867], tol); ASSERT_EQUAL_VEC(Vec3( 4.08120113e+02, -1.23559887e+02, -2.06942160e+02), forces1[867], tol);
ASSERT_EQUAL_VEC(Vec3( 4.38397e+02, -1.73668e+02, 4.68129e+02), forces1[868], tol); ASSERT_EQUAL_VEC(Vec3( 4.38405816e+02, -1.73677702e+02, 4.68119374e+02), forces1[868], tol);
ASSERT_EQUAL_VEC(Vec3(-3.66087e+02, 3.32522e+02, 2.43489e+02), forces1[869], tol); ASSERT_EQUAL_VEC(Vec3(-3.66077262e+02, 3.32534980e+02, 2.43501977e+02), forces1[869], tol);
ASSERT_EQUAL_VEC(Vec3( 2.09689e+02, 2.98078e+02, -4.55251e+02), forces1[870], tol); ASSERT_EQUAL_VEC(Vec3( 2.09710096e+02, 2.98077408e+02, -4.55256035e+02), forces1[870], tol);
ASSERT_EQUAL_VEC(Vec3( 4.70687e+01, -8.03989e+01, 1.44534e+02), forces1[871], tol); ASSERT_EQUAL_VEC(Vec3( 4.70548055e+01, -8.03931446e+01, 1.44535738e+02), forces1[871], tol);
ASSERT_EQUAL_VEC(Vec3( 4.51445e+01, -3.68247e+02, 2.65387e+02), forces1[872], tol); ASSERT_EQUAL_VEC(Vec3( 4.51389996e+01, -3.68239965e+02, 2.65390908e+02), forces1[872], tol);
ASSERT_EQUAL_VEC(Vec3(-2.22417e+02, 4.99753e+02, 1.50958e+02), forces1[873], tol); ASSERT_EQUAL_VEC(Vec3(-2.22430692e+02, 4.99756041e+02, 1.50958469e+02), forces1[873], tol);
ASSERT_EQUAL_VEC(Vec3(-3.32900e+02, 7.08245e+02, -2.53299e+02), forces1[874], tol); ASSERT_EQUAL_VEC(Vec3(-3.32911574e+02, 7.08248783e+02, -2.53293033e+02), forces1[874], tol);
ASSERT_EQUAL_VEC(Vec3(-2.24308e+02, 3.61207e+02, 3.14062e+02), forces1[875], tol); ASSERT_EQUAL_VEC(Vec3(-2.24293564e+02, 3.61202816e+02, 3.14067039e+02), forces1[875], tol);
ASSERT_EQUAL_VEC(Vec3( 2.85982e+01, 3.62426e+02, -2.25881e+01), forces1[876], tol); ASSERT_EQUAL_VEC(Vec3( 2.85994423e+01, 3.62421372e+02, -2.25792435e+01), forces1[876], tol);
ASSERT_EQUAL_VEC(Vec3( 3.25330e+02, -8.59875e+01, 6.05370e+02), forces1[877], tol); ASSERT_EQUAL_VEC(Vec3( 3.25319985e+02, -8.59870785e+01, 6.05364581e+02), forces1[877], tol);
ASSERT_EQUAL_VEC(Vec3( 3.08146e+02, 2.08412e+02, -3.04902e+02), forces1[878], tol); ASSERT_EQUAL_VEC(Vec3( 3.08171871e+02, 2.08420326e+02, -3.04923980e+02), forces1[878], tol);
ASSERT_EQUAL_VEC(Vec3( 3.65574e+02, 1.38323e+02, 2.10360e+02), forces1[879], tol); ASSERT_EQUAL_VEC(Vec3( 3.65570529e+02, 1.38310252e+02, 2.10363363e+02), forces1[879], tol);
ASSERT_EQUAL_VEC(Vec3( 6.56709e+01, 4.57995e+02, -1.05222e+02), forces1[880], tol); ASSERT_EQUAL_VEC(Vec3( 6.56661313e+01, 4.58001752e+02, -1.05217312e+02), forces1[880], tol);
ASSERT_EQUAL_VEC(Vec3(-7.04592e+02, 1.95849e+02, 6.29329e+01), forces1[881], tol); ASSERT_EQUAL_VEC(Vec3(-7.04591192e+02, 1.95857268e+02, 6.29174462e+01), forces1[881], tol);
ASSERT_EQUAL_VEC(Vec3(-5.03151e+02, -4.91097e+02, 2.39521e+00), forces1[882], tol); ASSERT_EQUAL_VEC(Vec3(-5.03143865e+02, -4.91096731e+02, 2.40904263e+00), forces1[882], tol);
ASSERT_EQUAL_VEC(Vec3(-6.84460e+01, 8.09473e+01, 2.50180e+02), forces1[883], tol); ASSERT_EQUAL_VEC(Vec3(-6.84583679e+01, 8.09254534e+01, 2.50188730e+02), forces1[883], tol);
ASSERT_EQUAL_VEC(Vec3(-5.35050e+01, 1.91736e+02, -1.93699e+02), forces1[884], tol); ASSERT_EQUAL_VEC(Vec3(-5.35217316e+01, 1.91746428e+02, -1.93678243e+02), forces1[884], tol);
ASSERT_EQUAL_VEC(Vec3( 5.56351e+02, -6.69133e+02, -2.99832e+02), forces1[885], tol); ASSERT_EQUAL_VEC(Vec3( 5.56342532e+02, -6.69136606e+02, -2.99835083e+02), forces1[885], tol);
ASSERT_EQUAL_VEC(Vec3(-3.35813e+02, 5.18617e+01, -2.16392e+02), forces1[886], tol); ASSERT_EQUAL_VEC(Vec3(-3.35801693e+02, 5.18603710e+01, -2.16409061e+02), forces1[886], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13161e+02, 6.23008e+02, -1.73739e+01), forces1[887], tol); ASSERT_EQUAL_VEC(Vec3(-1.13151480e+02, 6.23015348e+02, -1.73858304e+01), forces1[887], tol);
ASSERT_EQUAL_VEC(Vec3(-4.64248e+02, -2.03169e+02, 4.33728e+02), forces1[888], tol); ASSERT_EQUAL_VEC(Vec3(-4.64256120e+02, -2.03157899e+02, 4.33730698e+02), forces1[888], tol);
ASSERT_EQUAL_VEC(Vec3( 5.74899e+01, -4.61837e+02, -4.22536e+02), forces1[889], tol); ASSERT_EQUAL_VEC(Vec3( 5.74737750e+01, -4.61823893e+02, -4.22521242e+02), forces1[889], tol);
ASSERT_EQUAL_VEC(Vec3(-3.53693e+02, 1.04002e+02, 1.47429e+02), forces1[890], tol); ASSERT_EQUAL_VEC(Vec3(-3.53693728e+02, 1.03991649e+02, 1.47435093e+02), forces1[890], tol);
ASSERT_EQUAL_VEC(Vec3( 9.55615e+01, 4.15267e+02, 1.37725e+02), forces1[891], tol); ASSERT_EQUAL_VEC(Vec3( 9.55664834e+01, 4.15286634e+02, 1.37712413e+02), forces1[891], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43131e+02, -3.69951e+01, -4.01954e+02), forces1[892], tol); ASSERT_EQUAL_VEC(Vec3( 4.43136857e+02, -3.70066034e+01, -4.01965849e+02), forces1[892], tol);
ASSERT_EQUAL_VEC(Vec3( 1.26680e+02, -2.55278e+02, 1.49220e+02), forces1[893], tol); ASSERT_EQUAL_VEC(Vec3( 1.26699422e+02, -2.55274151e+02, 1.49229513e+02), forces1[893], tol);
platforms/reference/tests/nacl_amorph_GromacsForcesPME.dat
View file @ 71d59925
ASSERT_EQUAL_VEC(Vec3(-1.98226e+02, -2.23829e+02, -1.02563e+02), forces1[0], tol); ASSERT_EQUAL_VEC(Vec3(-1.98238e+02, -2.23819e+02, -1.02566e+02), forces1[0], tol);
ASSERT_EQUAL_VEC(Vec3( 4.44041e+02, -3.90401e+02, -8.09578e+01), forces1[1], tol); ASSERT_EQUAL_VEC(Vec3( 4.44029e+02, -3.90395e+02, -8.09590e+01), forces1[1], tol);
ASSERT_EQUAL_VEC(Vec3(-8.60774e+01, -1.05674e+01, -1.87768e+02), forces1[2], tol); ASSERT_EQUAL_VEC(Vec3(-8.60870e+01, -1.05622e+01, -1.87777e+02), forces1[2], tol);
ASSERT_EQUAL_VEC(Vec3( 7.05379e+02, -1.69604e+02, 2.72470e+02), forces1[3], tol); ASSERT_EQUAL_VEC(Vec3( 7.05375e+02, -1.69584e+02, 2.72477e+02), forces1[3], tol);
ASSERT_EQUAL_VEC(Vec3(-2.19233e+01, 5.33298e+02, -4.56220e+01), forces1[4], tol); ASSERT_EQUAL_VEC(Vec3(-2.19351e+01, 5.33294e+02, -4.56194e+01), forces1[4], tol);
ASSERT_EQUAL_VEC(Vec3(-3.04280e+02, 2.02917e+02, 1.20251e+02), forces1[5], tol); ASSERT_EQUAL_VEC(Vec3(-3.04277e+02, 2.02922e+02, 1.20245e+02), forces1[5], tol);
ASSERT_EQUAL_VEC(Vec3( 1.14202e+02, 1.21110e+02, 3.40932e+02), forces1[6], tol); ASSERT_EQUAL_VEC(Vec3( 1.14214e+02, 1.21102e+02, 3.40941e+02), forces1[6], tol);
ASSERT_EQUAL_VEC(Vec3(-4.02368e+01, 3.78738e+02, 1.07263e+02), forces1[7], tol); ASSERT_EQUAL_VEC(Vec3(-4.02332e+01, 3.78737e+02, 1.07247e+02), forces1[7], tol);
ASSERT_EQUAL_VEC(Vec3( 9.43005e+01, 1.00765e+01, 1.57704e+02), forces1[8], tol); ASSERT_EQUAL_VEC(Vec3( 9.42963e+01, 1.00871e+01, 1.57706e+02), forces1[8], tol);
ASSERT_EQUAL_VEC(Vec3( 2.98437e+02, 1.18606e+02, -4.17527e+02), forces1[9], tol); ASSERT_EQUAL_VEC(Vec3( 2.98432e+02, 1.18617e+02, -4.17515e+02), forces1[9], tol);
ASSERT_EQUAL_VEC(Vec3( 4.75079e+01, -5.56320e+00, -1.92337e+02), forces1[10], tol); ASSERT_EQUAL_VEC(Vec3( 4.75037e+01, -5.56223e+00, -1.92343e+02), forces1[10], tol);
ASSERT_EQUAL_VEC(Vec3(-3.61207e+02, 4.00201e+02, -3.38487e+02), forces1[11], tol); ASSERT_EQUAL_VEC(Vec3(-3.61212e+02, 4.00194e+02, -3.38480e+02), forces1[11], tol);
ASSERT_EQUAL_VEC(Vec3( 1.59869e+02, -2.22200e+02, -1.71803e+02), forces1[12], tol); ASSERT_EQUAL_VEC(Vec3( 1.59872e+02, -2.22188e+02, -1.71809e+02), forces1[12], tol);
ASSERT_EQUAL_VEC(Vec3( 8.02055e+01, -2.46192e+02, 1.49727e+02), forces1[13], tol); ASSERT_EQUAL_VEC(Vec3( 8.02097e+01, -2.46192e+02, 1.49732e+02), forces1[13], tol);
ASSERT_EQUAL_VEC(Vec3(-2.41490e+02, -8.22211e+01, -4.19820e+02), forces1[14], tol); ASSERT_EQUAL_VEC(Vec3(-2.41490e+02, -8.22349e+01, -4.19816e+02), forces1[14], tol);
ASSERT_EQUAL_VEC(Vec3(-2.42750e+02, 4.98498e+00, 1.89460e+01), forces1[15], tol); ASSERT_EQUAL_VEC(Vec3(-2.42760e+02, 4.99404e+00, 1.89251e+01), forces1[15], tol);
ASSERT_EQUAL_VEC(Vec3(-2.32034e+02, 2.91120e+02, -1.56124e+02), forces1[16], tol); ASSERT_EQUAL_VEC(Vec3(-2.32033e+02, 2.91123e+02, -1.56148e+02), forces1[16], tol);
ASSERT_EQUAL_VEC(Vec3(-8.77409e+01, -4.75577e+02, -2.02749e+02), forces1[17], tol); ASSERT_EQUAL_VEC(Vec3(-8.77282e+01, -4.75575e+02, -2.02740e+02), forces1[17], tol);
ASSERT_EQUAL_VEC(Vec3( 3.96099e+02, -6.37122e+02, 1.78659e+02), forces1[18], tol); ASSERT_EQUAL_VEC(Vec3( 3.96090e+02, -6.37135e+02, 1.78663e+02), forces1[18], tol);
ASSERT_EQUAL_VEC(Vec3( 3.72243e+02, 1.17763e+02, 2.14246e+02), forces1[19], tol); ASSERT_EQUAL_VEC(Vec3( 3.72230e+02, 1.17758e+02, 2.14245e+02), forces1[19], tol);
ASSERT_EQUAL_VEC(Vec3( 4.50054e+02, -1.37597e+01, 2.39931e+02), forces1[20], tol); ASSERT_EQUAL_VEC(Vec3( 4.50070e+02, -1.37646e+01, 2.39932e+02), forces1[20], tol);
ASSERT_EQUAL_VEC(Vec3( 2.00005e+02, 3.30049e+01, 8.51782e+01), forces1[21], tol); ASSERT_EQUAL_VEC(Vec3( 2.00016e+02, 3.30198e+01, 8.51831e+01), forces1[21], tol);
ASSERT_EQUAL_VEC(Vec3( 1.97196e+02, 7.33306e+02, 2.15329e+01), forces1[22], tol); ASSERT_EQUAL_VEC(Vec3( 1.97199e+02, 7.33301e+02, 2.15197e+01), forces1[22], tol);
ASSERT_EQUAL_VEC(Vec3(-1.44362e+02, 9.15817e+01, 3.18871e+01), forces1[23], tol); ASSERT_EQUAL_VEC(Vec3(-1.44369e+02, 9.15743e+01, 3.18981e+01), forces1[23], tol);
ASSERT_EQUAL_VEC(Vec3( 2.94565e+02, -3.69022e+02, 2.69541e+00), forces1[24], tol); ASSERT_EQUAL_VEC(Vec3( 2.94560e+02, -3.69029e+02, 2.70469e+00), forces1[24], tol);
ASSERT_EQUAL_VEC(Vec3( 3.23100e+02, 8.86114e+02, 3.24424e+02), forces1[25], tol); ASSERT_EQUAL_VEC(Vec3( 3.23107e+02, 8.86120e+02, 3.24425e+02), forces1[25], tol);
ASSERT_EQUAL_VEC(Vec3(-6.03077e+01, 1.68440e+02, 2.31904e+02), forces1[26], tol); ASSERT_EQUAL_VEC(Vec3(-6.03139e+01, 1.68441e+02, 2.31890e+02), forces1[26], tol);
ASSERT_EQUAL_VEC(Vec3( 2.93185e+01, 5.76391e+01, 3.63986e+02), forces1[27], tol); ASSERT_EQUAL_VEC(Vec3( 2.93353e+01, 5.76451e+01, 3.63994e+02), forces1[27], tol);
ASSERT_EQUAL_VEC(Vec3( 3.13374e-01, 1.34475e+02, -4.39935e+01), forces1[28], tol); ASSERT_EQUAL_VEC(Vec3( 3.18489e-01, 1.34475e+02, -4.39831e+01), forces1[28], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38714e+02, -2.99577e+02, -2.80321e+02), forces1[29], tol); ASSERT_EQUAL_VEC(Vec3(-1.38709e+02, -2.99570e+02, -2.80326e+02), forces1[29], tol);
ASSERT_EQUAL_VEC(Vec3(-8.28003e+01, 4.40605e+02, 9.65346e+01), forces1[30], tol); ASSERT_EQUAL_VEC(Vec3(-8.28155e+01, 4.40624e+02, 9.65531e+01), forces1[30], tol);
ASSERT_EQUAL_VEC(Vec3( 2.03847e+01, -4.37659e+01, -5.06781e+01), forces1[31], tol); ASSERT_EQUAL_VEC(Vec3( 2.03774e+01, -4.37685e+01, -5.06727e+01), forces1[31], tol);
ASSERT_EQUAL_VEC(Vec3(-2.60770e+02, 3.70681e+02, 1.28618e+02), forces1[32], tol); ASSERT_EQUAL_VEC(Vec3(-2.60759e+02, 3.70684e+02, 1.28621e+02), forces1[32], tol);
ASSERT_EQUAL_VEC(Vec3( 1.97959e+02, -1.52049e+01, -2.85737e+02), forces1[33], tol); ASSERT_EQUAL_VEC(Vec3( 1.97964e+02, -1.52120e+01, -2.85728e+02), forces1[33], tol);
ASSERT_EQUAL_VEC(Vec3(-2.63688e+01, -1.29230e+01, -2.36627e+02), forces1[34], tol); ASSERT_EQUAL_VEC(Vec3(-2.63683e+01, -1.29412e+01, -2.36630e+02), forces1[34], tol);
ASSERT_EQUAL_VEC(Vec3( 2.13610e+02, -2.29660e+02, -7.72858e+02), forces1[35], tol); ASSERT_EQUAL_VEC(Vec3( 2.13607e+02, -2.29651e+02, -7.72846e+02), forces1[35], tol);
ASSERT_EQUAL_VEC(Vec3(-4.26128e+01, 9.00648e+01, 3.48805e+02), forces1[36], tol); ASSERT_EQUAL_VEC(Vec3(-4.26326e+01, 9.00722e+01, 3.48806e+02), forces1[36], tol);
ASSERT_EQUAL_VEC(Vec3(-2.27757e+02, -8.49940e+00, -3.25566e+02), forces1[37], tol); ASSERT_EQUAL_VEC(Vec3(-2.27760e+02, -8.49427e+00, -3.25568e+02), forces1[37], tol);
ASSERT_EQUAL_VEC(Vec3(-8.32059e+01, -2.50954e+02, 5.80140e+01), forces1[38], tol); ASSERT_EQUAL_VEC(Vec3(-8.32014e+01, -2.50950e+02, 5.80192e+01), forces1[38], tol);
ASSERT_EQUAL_VEC(Vec3(-2.32230e+02, 1.30469e+02, 6.05883e+00), forces1[39], tol); ASSERT_EQUAL_VEC(Vec3(-2.32232e+02, 1.30458e+02, 6.05363e+00), forces1[39], tol);
ASSERT_EQUAL_VEC(Vec3(-1.14433e+02, -3.48607e+01, -8.76082e+01), forces1[40], tol); ASSERT_EQUAL_VEC(Vec3(-1.14431e+02, -3.48761e+01, -8.76148e+01), forces1[40], tol);
ASSERT_EQUAL_VEC(Vec3(-2.55345e+02, -2.79190e+02, -1.68751e+02), forces1[41], tol); ASSERT_EQUAL_VEC(Vec3(-2.55342e+02, -2.79189e+02, -1.68749e+02), forces1[41], tol);
ASSERT_EQUAL_VEC(Vec3(-2.02316e+02, 1.47907e+02, 1.75227e+02), forces1[42], tol); ASSERT_EQUAL_VEC(Vec3(-2.02321e+02, 1.47907e+02, 1.75227e+02), forces1[42], tol);
ASSERT_EQUAL_VEC(Vec3( 2.63431e+01, -4.46968e+02, -2.38851e+00), forces1[43], tol); ASSERT_EQUAL_VEC(Vec3( 2.63248e+01, -4.46996e+02, -2.37737e+00), forces1[43], tol);
ASSERT_EQUAL_VEC(Vec3( 2.55974e+02, -2.93458e+02, 3.28004e+02), forces1[44], tol); ASSERT_EQUAL_VEC(Vec3( 2.55965e+02, -2.93440e+02, 3.28023e+02), forces1[44], tol);
ASSERT_EQUAL_VEC(Vec3( 1.14329e+02, 2.24363e+02, -8.29873e+01), forces1[45], tol); ASSERT_EQUAL_VEC(Vec3( 1.14323e+02, 2.24373e+02, -8.29717e+01), forces1[45], tol);
ASSERT_EQUAL_VEC(Vec3( 1.43353e+01, 2.46494e+02, -3.75132e+02), forces1[46], tol); ASSERT_EQUAL_VEC(Vec3( 1.43347e+01, 2.46486e+02, -3.75145e+02), forces1[46], tol);
ASSERT_EQUAL_VEC(Vec3(-4.34821e+02, -9.73197e+01, -1.91084e+02), forces1[47], tol); ASSERT_EQUAL_VEC(Vec3(-4.34804e+02, -9.73177e+01, -1.91079e+02), forces1[47], tol);
ASSERT_EQUAL_VEC(Vec3( 5.22895e+01, 5.50942e+02, 2.90253e+02), forces1[48], tol); ASSERT_EQUAL_VEC(Vec3( 5.22940e+01, 5.50944e+02, 2.90237e+02), forces1[48], tol);
ASSERT_EQUAL_VEC(Vec3(-4.83886e+01, 1.71482e+02, -3.42284e+02), forces1[49], tol); ASSERT_EQUAL_VEC(Vec3(-4.83950e+01, 1.71484e+02, -3.42302e+02), forces1[49], tol);
ASSERT_EQUAL_VEC(Vec3(-2.61468e+02, 9.01808e+01, 3.64106e+02), forces1[50], tol); ASSERT_EQUAL_VEC(Vec3(-2.61453e+02, 9.01727e+01, 3.64102e+02), forces1[50], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43614e+02, -5.19309e+02, -7.74918e+01), forces1[51], tol); ASSERT_EQUAL_VEC(Vec3( 4.43627e+02, -5.19312e+02, -7.74800e+01), forces1[51], tol);
ASSERT_EQUAL_VEC(Vec3( 2.15578e+02, -5.54591e+02, 1.71373e+02), forces1[52], tol); ASSERT_EQUAL_VEC(Vec3( 2.15597e+02, -5.54586e+02, 1.71365e+02), forces1[52], tol);
ASSERT_EQUAL_VEC(Vec3(-2.14789e+02, 3.56710e+02, -3.72004e+02), forces1[53], tol); ASSERT_EQUAL_VEC(Vec3(-2.14777e+02, 3.56724e+02, -3.71997e+02), forces1[53], tol);
ASSERT_EQUAL_VEC(Vec3( 2.22126e+02, 2.73209e+02, 1.61947e+02), forces1[54], tol); ASSERT_EQUAL_VEC(Vec3( 2.22118e+02, 2.73200e+02, 1.61950e+02), forces1[54], tol);
ASSERT_EQUAL_VEC(Vec3( 2.85124e+02, 3.19149e+02, -1.98759e+02), forces1[55], tol); ASSERT_EQUAL_VEC(Vec3( 2.85119e+02, 3.19144e+02, -1.98761e+02), forces1[55], tol);
ASSERT_EQUAL_VEC(Vec3( 3.90036e+02, 5.91189e+02, 8.76156e+01), forces1[56], tol); ASSERT_EQUAL_VEC(Vec3( 3.90047e+02, 5.91187e+02, 8.76052e+01), forces1[56], tol);
ASSERT_EQUAL_VEC(Vec3( 1.69082e+02, -9.43267e+01, 3.42173e+02), forces1[57], tol); ASSERT_EQUAL_VEC(Vec3( 1.69067e+02, -9.43258e+01, 3.42177e+02), forces1[57], tol);
ASSERT_EQUAL_VEC(Vec3( 2.92829e+01, -1.03076e+02, 5.37809e+01), forces1[58], tol); ASSERT_EQUAL_VEC(Vec3( 2.93040e+01, -1.03068e+02, 5.37913e+01), forces1[58], tol);
ASSERT_EQUAL_VEC(Vec3( 4.08819e+01, 1.30033e+02, -7.16512e+01), forces1[59], tol); ASSERT_EQUAL_VEC(Vec3( 4.08998e+01, 1.30025e+02, -7.16616e+01), forces1[59], tol);
ASSERT_EQUAL_VEC(Vec3(-1.89920e+02, 5.51773e+00, 4.53570e+02), forces1[60], tol); ASSERT_EQUAL_VEC(Vec3(-1.89925e+02, 5.51894e+00, 4.53550e+02), forces1[60], tol);
ASSERT_EQUAL_VEC(Vec3(-1.11562e+02, 1.24171e+02, 4.53019e+02), forces1[61], tol); ASSERT_EQUAL_VEC(Vec3(-1.11554e+02, 1.24171e+02, 4.53012e+02), forces1[61], tol);
ASSERT_EQUAL_VEC(Vec3( 1.54592e+02, -2.70151e+02, -7.89592e+01), forces1[62], tol); ASSERT_EQUAL_VEC(Vec3( 1.54597e+02, -2.70144e+02, -7.89501e+01), forces1[62], tol);
ASSERT_EQUAL_VEC(Vec3( 2.84014e+02, -8.89969e+01, 3.24508e+02), forces1[63], tol); ASSERT_EQUAL_VEC(Vec3( 2.84029e+02, -8.89897e+01, 3.24511e+02), forces1[63], tol);
ASSERT_EQUAL_VEC(Vec3( 1.44364e+02, -7.96538e+01, -2.53249e+02), forces1[64], tol); ASSERT_EQUAL_VEC(Vec3( 1.44360e+02, -7.96586e+01, -2.53245e+02), forces1[64], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77740e+02, 8.43040e+01, -1.41068e+02), forces1[65], tol); ASSERT_EQUAL_VEC(Vec3(-1.77734e+02, 8.42945e+01, -1.41070e+02), forces1[65], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69646e+02, -5.26530e+02, -1.04064e+02), forces1[66], tol); ASSERT_EQUAL_VEC(Vec3(-2.69652e+02, -5.26516e+02, -1.04064e+02), forces1[66], tol);
ASSERT_EQUAL_VEC(Vec3(-2.41584e+02, -9.41451e+01, 3.30232e+01), forces1[67], tol); ASSERT_EQUAL_VEC(Vec3(-2.41602e+02, -9.41429e+01, 3.30147e+01), forces1[67], tol);
ASSERT_EQUAL_VEC(Vec3( 6.81067e+02, -5.79259e+02, -9.75586e-01), forces1[68], tol); ASSERT_EQUAL_VEC(Vec3( 6.81069e+02, -5.79240e+02, -9.71642e-01), forces1[68], tol);
ASSERT_EQUAL_VEC(Vec3( 2.88754e+02, 2.41565e+02, -1.90680e+02), forces1[69], tol); ASSERT_EQUAL_VEC(Vec3( 2.88769e+02, 2.41582e+02, -1.90685e+02), forces1[69], tol);
ASSERT_EQUAL_VEC(Vec3(-1.31552e+01, 1.14326e+01, 4.13781e+01), forces1[70], tol); ASSERT_EQUAL_VEC(Vec3(-1.31603e+01, 1.14262e+01, 4.13776e+01), forces1[70], tol);
ASSERT_EQUAL_VEC(Vec3( 5.14402e+01, -9.72074e+01, 1.27327e+01), forces1[71], tol); ASSERT_EQUAL_VEC(Vec3( 5.14411e+01, -9.72283e+01, 1.27245e+01), forces1[71], tol);
ASSERT_EQUAL_VEC(Vec3( 7.15713e+01, -1.94118e+02, -2.48968e+02), forces1[72], tol); ASSERT_EQUAL_VEC(Vec3( 7.15737e+01, -1.94134e+02, -2.48980e+02), forces1[72], tol);
ASSERT_EQUAL_VEC(Vec3(-9.16967e+01, 1.23394e+02, -2.86177e+02), forces1[73], tol); ASSERT_EQUAL_VEC(Vec3(-9.16921e+01, 1.23396e+02, -2.86180e+02), forces1[73], tol);
ASSERT_EQUAL_VEC(Vec3( 9.82429e+01, -7.07044e+01, -1.29180e+02), forces1[74], tol); ASSERT_EQUAL_VEC(Vec3( 9.82499e+01, -7.07136e+01, -1.29192e+02), forces1[74], tol);
ASSERT_EQUAL_VEC(Vec3(-2.15573e+02, -1.43107e+02, -1.96439e+02), forces1[75], tol); ASSERT_EQUAL_VEC(Vec3(-2.15576e+02, -1.43100e+02, -1.96438e+02), forces1[75], tol);
ASSERT_EQUAL_VEC(Vec3(-4.61159e+02, -4.03107e+02, -4.56034e+01), forces1[76], tol); ASSERT_EQUAL_VEC(Vec3(-4.61162e+02, -4.03097e+02, -4.56028e+01), forces1[76], tol);
ASSERT_EQUAL_VEC(Vec3( 1.52896e+02, -9.37802e+02, 2.93606e+02), forces1[77], tol); ASSERT_EQUAL_VEC(Vec3( 1.52885e+02, -9.37800e+02, 2.93600e+02), forces1[77], tol);
ASSERT_EQUAL_VEC(Vec3( 2.45709e+02, 1.99795e+01, 1.17919e+02), forces1[78], tol); ASSERT_EQUAL_VEC(Vec3( 2.45711e+02, 1.99845e+01, 1.17917e+02), forces1[78], tol);
ASSERT_EQUAL_VEC(Vec3(-2.37040e+02, 2.49514e+02, 2.13431e+02), forces1[79], tol); ASSERT_EQUAL_VEC(Vec3(-2.37050e+02, 2.49524e+02, 2.13426e+02), forces1[79], tol);
ASSERT_EQUAL_VEC(Vec3(-2.90559e+02, 1.91146e+02, -4.24250e+02), forces1[80], tol); ASSERT_EQUAL_VEC(Vec3(-2.90554e+02, 1.91128e+02, -4.24254e+02), forces1[80], tol);
ASSERT_EQUAL_VEC(Vec3( 2.98831e+02, -5.76048e+00, 2.66630e+02), forces1[81], tol); ASSERT_EQUAL_VEC(Vec3( 2.98841e+02, -5.76039e+00, 2.66632e+02), forces1[81], tol);
ASSERT_EQUAL_VEC(Vec3(-3.26795e+02, -2.54767e+02, -3.00070e+02), forces1[82], tol); ASSERT_EQUAL_VEC(Vec3(-3.26781e+02, -2.54764e+02, -3.00077e+02), forces1[82], tol);
ASSERT_EQUAL_VEC(Vec3(-2.95145e+02, 1.21767e+02, -2.83486e+02), forces1[83], tol); ASSERT_EQUAL_VEC(Vec3(-2.95144e+02, 1.21764e+02, -2.83475e+02), forces1[83], tol);
ASSERT_EQUAL_VEC(Vec3( 4.04614e+02, 1.66815e+02, -5.58168e+01), forces1[84], tol); ASSERT_EQUAL_VEC(Vec3( 4.04598e+02, 1.66819e+02, -5.58132e+01), forces1[84], tol);
ASSERT_EQUAL_VEC(Vec3(-8.21647e+02, 5.19863e+02, 5.31907e+01), forces1[85], tol); ASSERT_EQUAL_VEC(Vec3(-8.21664e+02, 5.19844e+02, 5.32043e+01), forces1[85], tol);
ASSERT_EQUAL_VEC(Vec3(-3.49439e+02, -1.47708e+02, -4.95512e+02), forces1[86], tol); ASSERT_EQUAL_VEC(Vec3(-3.49444e+02, -1.47683e+02, -4.95512e+02), forces1[86], tol);
ASSERT_EQUAL_VEC(Vec3(-4.48881e+02, -7.41561e+01, -4.28590e+02), forces1[87], tol); ASSERT_EQUAL_VEC(Vec3(-4.48878e+02, -7.41503e+01, -4.28596e+02), forces1[87], tol);
ASSERT_EQUAL_VEC(Vec3(-1.97051e+02, -3.40580e+02, 2.11774e+00), forces1[88], tol); ASSERT_EQUAL_VEC(Vec3(-1.97044e+02, -3.40603e+02, 2.10204e+00), forces1[88], tol);
ASSERT_EQUAL_VEC(Vec3( 9.52478e+01, -4.20801e+02, 5.76782e+01), forces1[89], tol); ASSERT_EQUAL_VEC(Vec3( 9.52481e+01, -4.20783e+02, 5.76746e+01), forces1[89], tol);
ASSERT_EQUAL_VEC(Vec3( 1.21816e+02, -1.40409e+02, -2.93294e+02), forces1[90], tol); ASSERT_EQUAL_VEC(Vec3( 1.21807e+02, -1.40400e+02, -2.93285e+02), forces1[90], tol);
ASSERT_EQUAL_VEC(Vec3( 2.10625e+02, 5.87995e+01, 7.23679e+01), forces1[91], tol); ASSERT_EQUAL_VEC(Vec3( 2.10629e+02, 5.88038e+01, 7.23663e+01), forces1[91], tol);
ASSERT_EQUAL_VEC(Vec3( 6.72826e+01, -1.46943e+02, -2.63722e+02), forces1[92], tol); ASSERT_EQUAL_VEC(Vec3( 6.72915e+01, -1.46949e+02, -2.63710e+02), forces1[92], tol);
ASSERT_EQUAL_VEC(Vec3( 3.96782e+02, -4.38669e+02, -2.57930e+02), forces1[93], tol); ASSERT_EQUAL_VEC(Vec3( 3.96779e+02, -4.38664e+02, -2.57916e+02), forces1[93], tol);
ASSERT_EQUAL_VEC(Vec3(-2.66028e+01, 1.59123e+01, 4.36643e+02), forces1[94], tol); ASSERT_EQUAL_VEC(Vec3(-2.66189e+01, 1.59116e+01, 4.36637e+02), forces1[94], tol);
ASSERT_EQUAL_VEC(Vec3(-3.00000e+02, -6.20609e+01, -4.29145e+02), forces1[95], tol); ASSERT_EQUAL_VEC(Vec3(-3.00015e+02, -6.20522e+01, -4.29146e+02), forces1[95], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77072e+02, 5.58861e+01, 1.05683e+02), forces1[96], tol); ASSERT_EQUAL_VEC(Vec3(-1.77047e+02, 5.58882e+01, 1.05674e+02), forces1[96], tol);
ASSERT_EQUAL_VEC(Vec3(-6.92763e+01, -5.45421e+02, -2.10922e+01), forces1[97], tol); ASSERT_EQUAL_VEC(Vec3(-6.92728e+01, -5.45431e+02, -2.10884e+01), forces1[97], tol);
ASSERT_EQUAL_VEC(Vec3(-3.90095e+01, -1.21134e+02, 1.68273e+01), forces1[98], tol); ASSERT_EQUAL_VEC(Vec3(-3.90061e+01, -1.21126e+02, 1.68310e+01), forces1[98], tol);
ASSERT_EQUAL_VEC(Vec3(-2.19546e+01, 1.51710e+02, -3.39233e+01), forces1[99], tol); ASSERT_EQUAL_VEC(Vec3(-2.19576e+01, 1.51712e+02, -3.39292e+01), forces1[99], tol);
ASSERT_EQUAL_VEC(Vec3( 9.20515e+01, -4.22564e+02, -1.81118e+01), forces1[100], tol); ASSERT_EQUAL_VEC(Vec3( 9.20478e+01, -4.22547e+02, -1.81073e+01), forces1[100], tol);
ASSERT_EQUAL_VEC(Vec3( 5.80426e+01, 1.45410e+02, -4.53188e+01), forces1[101], tol); ASSERT_EQUAL_VEC(Vec3( 5.80549e+01, 1.45413e+02, -4.53187e+01), forces1[101], tol);
ASSERT_EQUAL_VEC(Vec3( 6.12584e+02, -1.41296e+01, 2.13574e+02), forces1[102], tol); ASSERT_EQUAL_VEC(Vec3( 6.12578e+02, -1.41330e+01, 2.13583e+02), forces1[102], tol);
ASSERT_EQUAL_VEC(Vec3(-1.02936e+02, -8.76371e+01, 2.20897e+02), forces1[103], tol); ASSERT_EQUAL_VEC(Vec3(-1.02947e+02, -8.76472e+01, 2.20906e+02), forces1[103], tol);
ASSERT_EQUAL_VEC(Vec3( 1.44802e+02, -2.89000e+02, 1.68136e+02), forces1[104], tol); ASSERT_EQUAL_VEC(Vec3( 1.44800e+02, -2.89016e+02, 1.68141e+02), forces1[104], tol);
ASSERT_EQUAL_VEC(Vec3( 9.68833e+01, -2.62264e+02, -3.07305e+02), forces1[105], tol); ASSERT_EQUAL_VEC(Vec3( 9.68802e+01, -2.62265e+02, -3.07293e+02), forces1[105], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09044e+02, -2.43251e+02, -2.45227e+02), forces1[106], tol); ASSERT_EQUAL_VEC(Vec3(-1.09044e+02, -2.43250e+02, -2.45232e+02), forces1[106], tol);
ASSERT_EQUAL_VEC(Vec3( 1.89555e+02, 1.49320e+02, -3.74279e+02), forces1[107], tol); ASSERT_EQUAL_VEC(Vec3( 1.89553e+02, 1.49335e+02, -3.74288e+02), forces1[107], tol);
ASSERT_EQUAL_VEC(Vec3( 1.20775e+02, -1.66090e+02, -4.46361e+02), forces1[108], tol); ASSERT_EQUAL_VEC(Vec3( 1.20770e+02, -1.66095e+02, -4.46390e+02), forces1[108], tol);
ASSERT_EQUAL_VEC(Vec3(-6.91042e+02, 6.62272e+02, 3.05919e+01), forces1[109], tol); ASSERT_EQUAL_VEC(Vec3(-6.91040e+02, 6.62259e+02, 3.06075e+01), forces1[109], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61311e+02, 8.89617e+01, -3.35717e+01), forces1[110], tol); ASSERT_EQUAL_VEC(Vec3(-1.61286e+02, 8.89662e+01, -3.35508e+01), forces1[110], tol);
ASSERT_EQUAL_VEC(Vec3(-4.17346e+02, 4.26208e+01, -7.77344e+01), forces1[111], tol); ASSERT_EQUAL_VEC(Vec3(-4.17337e+02, 4.26282e+01, -7.77221e+01), forces1[111], tol);
ASSERT_EQUAL_VEC(Vec3(-4.01828e+01, 8.24721e+01, 4.51861e+02), forces1[112], tol); ASSERT_EQUAL_VEC(Vec3(-4.01777e+01, 8.24730e+01, 4.51851e+02), forces1[112], tol);
ASSERT_EQUAL_VEC(Vec3(-1.40932e+01, -2.40651e+02, -1.27609e+02), forces1[113], tol); ASSERT_EQUAL_VEC(Vec3(-1.40974e+01, -2.40650e+02, -1.27611e+02), forces1[113], tol);
ASSERT_EQUAL_VEC(Vec3( 2.83859e+02, 2.31060e+02, 1.33519e+01), forces1[114], tol); ASSERT_EQUAL_VEC(Vec3( 2.83838e+02, 2.31052e+02, 1.33440e+01), forces1[114], tol);
ASSERT_EQUAL_VEC(Vec3( 5.10744e+01, -7.13342e+02, -4.07610e+02), forces1[115], tol); ASSERT_EQUAL_VEC(Vec3( 5.10743e+01, -7.13353e+02, -4.07609e+02), forces1[115], tol);
ASSERT_EQUAL_VEC(Vec3(-1.56093e+02, -1.33112e+02, 2.25962e+02), forces1[116], tol); ASSERT_EQUAL_VEC(Vec3(-1.56084e+02, -1.33127e+02, 2.25953e+02), forces1[116], tol);
ASSERT_EQUAL_VEC(Vec3( 3.69899e+01, -1.35064e+01, 1.10568e+02), forces1[117], tol); ASSERT_EQUAL_VEC(Vec3( 3.69751e+01, -1.35050e+01, 1.10570e+02), forces1[117], tol);
ASSERT_EQUAL_VEC(Vec3( 3.37815e+02, 8.10375e+01, -5.39667e+01), forces1[118], tol); ASSERT_EQUAL_VEC(Vec3( 3.37822e+02, 8.10444e+01, -5.39664e+01), forces1[118], tol);
ASSERT_EQUAL_VEC(Vec3( 5.49950e+01, 7.54980e+01, 1.80546e+02), forces1[119], tol); ASSERT_EQUAL_VEC(Vec3( 5.49925e+01, 7.55077e+01, 1.80537e+02), forces1[119], tol);
ASSERT_EQUAL_VEC(Vec3( 1.10958e+02, -3.83960e+02, 2.78083e+01), forces1[120], tol); ASSERT_EQUAL_VEC(Vec3( 1.10959e+02, -3.83960e+02, 2.78081e+01), forces1[120], tol);
ASSERT_EQUAL_VEC(Vec3(-2.63194e+02, -3.16256e+02, -3.95226e+02), forces1[121], tol); ASSERT_EQUAL_VEC(Vec3(-2.63191e+02, -3.16263e+02, -3.95227e+02), forces1[121], tol);
ASSERT_EQUAL_VEC(Vec3( 3.42549e+02, -2.35762e+02, 4.60358e+02), forces1[122], tol); ASSERT_EQUAL_VEC(Vec3( 3.42551e+02, -2.35755e+02, 4.60349e+02), forces1[122], tol);
ASSERT_EQUAL_VEC(Vec3( 2.47667e+02, 2.42868e+02, 1.52223e+02), forces1[123], tol); ASSERT_EQUAL_VEC(Vec3( 2.47660e+02, 2.42873e+02, 1.52219e+02), forces1[123], tol);
ASSERT_EQUAL_VEC(Vec3(-2.70209e+02, 2.08579e+02, -1.86855e+02), forces1[124], tol); ASSERT_EQUAL_VEC(Vec3(-2.70208e+02, 2.08577e+02, -1.86857e+02), forces1[124], tol);
ASSERT_EQUAL_VEC(Vec3( 3.24083e+02, 2.54999e+02, -1.10885e+02), forces1[125], tol); ASSERT_EQUAL_VEC(Vec3( 3.24091e+02, 2.55006e+02, -1.10874e+02), forces1[125], tol);
ASSERT_EQUAL_VEC(Vec3( 5.16195e+02, -5.06054e+01, -2.80855e+02), forces1[126], tol); ASSERT_EQUAL_VEC(Vec3( 5.16198e+02, -5.06223e+01, -2.80862e+02), forces1[126], tol);
ASSERT_EQUAL_VEC(Vec3(-3.30845e+02, -3.47292e+02, 1.45234e+02), forces1[127], tol); ASSERT_EQUAL_VEC(Vec3(-3.30850e+02, -3.47287e+02, 1.45245e+02), forces1[127], tol);
ASSERT_EQUAL_VEC(Vec3(-1.28352e+02, 7.69159e+01, 2.14896e+02), forces1[128], tol); ASSERT_EQUAL_VEC(Vec3(-1.28351e+02, 7.69111e+01, 2.14899e+02), forces1[128], tol);
ASSERT_EQUAL_VEC(Vec3(-1.91485e+02, -2.11486e+02, 1.35337e+02), forces1[129], tol); ASSERT_EQUAL_VEC(Vec3(-1.91475e+02, -2.11487e+02, 1.35327e+02), forces1[129], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69903e+02, 1.11309e+02, -8.98598e+01), forces1[130], tol); ASSERT_EQUAL_VEC(Vec3(-2.69888e+02, 1.11316e+02, -8.98475e+01), forces1[130], tol);
ASSERT_EQUAL_VEC(Vec3(-1.36359e+02, -2.14222e+02, -5.83815e+01), forces1[131], tol); ASSERT_EQUAL_VEC(Vec3(-1.36356e+02, -2.14227e+02, -5.83946e+01), forces1[131], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38565e+02, 2.36116e+02, -2.08893e+01), forces1[132], tol); ASSERT_EQUAL_VEC(Vec3(-1.38558e+02, 2.36118e+02, -2.08878e+01), forces1[132], tol);
ASSERT_EQUAL_VEC(Vec3(-2.47596e+02, 3.98219e+02, -1.64761e+02), forces1[133], tol); ASSERT_EQUAL_VEC(Vec3(-2.47603e+02, 3.98194e+02, -1.64773e+02), forces1[133], tol);
ASSERT_EQUAL_VEC(Vec3(-8.37458e+01, 4.07951e+02, -1.24165e+02), forces1[134], tol); ASSERT_EQUAL_VEC(Vec3(-8.37474e+01, 4.07950e+02, -1.24164e+02), forces1[134], tol);
ASSERT_EQUAL_VEC(Vec3(-1.60132e+02, -6.51558e+00, 3.55060e+02), forces1[135], tol); ASSERT_EQUAL_VEC(Vec3(-1.60152e+02, -6.50199e+00, 3.55060e+02), forces1[135], tol);
ASSERT_EQUAL_VEC(Vec3( 3.58254e+02, -2.81415e+02, -1.28036e+02), forces1[136], tol); ASSERT_EQUAL_VEC(Vec3( 3.58257e+02, -2.81406e+02, -1.28029e+02), forces1[136], tol);
ASSERT_EQUAL_VEC(Vec3( 3.33743e+02, -3.31202e+02, -2.41715e+01), forces1[137], tol); ASSERT_EQUAL_VEC(Vec3( 3.33746e+02, -3.31207e+02, -2.41567e+01), forces1[137], tol);
ASSERT_EQUAL_VEC(Vec3(-3.00689e+02, -1.70096e+02, 8.30787e+01), forces1[138], tol); ASSERT_EQUAL_VEC(Vec3(-3.00677e+02, -1.70094e+02, 8.30774e+01), forces1[138], tol);
ASSERT_EQUAL_VEC(Vec3(-1.94790e+01, 1.35845e+02, -3.65167e+02), forces1[139], tol); ASSERT_EQUAL_VEC(Vec3(-1.94848e+01, 1.35839e+02, -3.65168e+02), forces1[139], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77170e+02, 4.44429e+01, 2.11468e+02), forces1[140], tol); ASSERT_EQUAL_VEC(Vec3(-1.77179e+02, 4.44424e+01, 2.11476e+02), forces1[140], tol);
ASSERT_EQUAL_VEC(Vec3( 4.59301e+02, -3.23654e+02, 3.67796e+02), forces1[141], tol); ASSERT_EQUAL_VEC(Vec3( 4.59288e+02, -3.23648e+02, 3.67802e+02), forces1[141], tol);
ASSERT_EQUAL_VEC(Vec3( 4.22149e+02, 2.22106e+02, 2.92484e+02), forces1[142], tol); ASSERT_EQUAL_VEC(Vec3( 4.22135e+02, 2.22083e+02, 2.92481e+02), forces1[142], tol);
ASSERT_EQUAL_VEC(Vec3( 2.83745e+02, -2.92608e+02, 8.17895e+01), forces1[143], tol); ASSERT_EQUAL_VEC(Vec3( 2.83734e+02, -2.92595e+02, 8.17914e+01), forces1[143], tol);
ASSERT_EQUAL_VEC(Vec3(-5.70614e+01, 2.40297e+02, -3.40934e+01), forces1[144], tol); ASSERT_EQUAL_VEC(Vec3(-5.70476e+01, 2.40284e+02, -3.40876e+01), forces1[144], tol);
ASSERT_EQUAL_VEC(Vec3( 1.04089e+02, 1.58971e+02, 1.10021e+01), forces1[145], tol); ASSERT_EQUAL_VEC(Vec3( 1.04088e+02, 1.58977e+02, 1.10182e+01), forces1[145], tol);
ASSERT_EQUAL_VEC(Vec3( 5.88495e+02, 2.07868e+02, -7.36894e+01), forces1[146], tol); ASSERT_EQUAL_VEC(Vec3( 5.88504e+02, 2.07873e+02, -7.36857e+01), forces1[146], tol);
ASSERT_EQUAL_VEC(Vec3( 2.82644e+02, 2.25980e+02, 2.16747e+02), forces1[147], tol); ASSERT_EQUAL_VEC(Vec3( 2.82644e+02, 2.25984e+02, 2.16741e+02), forces1[147], tol);
ASSERT_EQUAL_VEC(Vec3(-2.02424e+02, 1.65903e+02, -1.47470e+02), forces1[148], tol); ASSERT_EQUAL_VEC(Vec3(-2.02425e+02, 1.65903e+02, -1.47473e+02), forces1[148], tol);
ASSERT_EQUAL_VEC(Vec3(-2.96637e+02, -4.87430e+02, 1.60846e+02), forces1[149], tol); ASSERT_EQUAL_VEC(Vec3(-2.96634e+02, -4.87422e+02, 1.60837e+02), forces1[149], tol);
ASSERT_EQUAL_VEC(Vec3( 2.94717e+02, 1.30341e+02, 2.82895e+01), forces1[150], tol); ASSERT_EQUAL_VEC(Vec3( 2.94716e+02, 1.30350e+02, 2.82786e+01), forces1[150], tol);
ASSERT_EQUAL_VEC(Vec3( 3.70878e+02, 3.22131e+01, 8.74428e+01), forces1[151], tol); ASSERT_EQUAL_VEC(Vec3( 3.70883e+02, 3.22177e+01, 8.74457e+01), forces1[151], tol);
ASSERT_EQUAL_VEC(Vec3( 3.44005e+02, -2.07916e+02, 3.49066e+02), forces1[152], tol); ASSERT_EQUAL_VEC(Vec3( 3.44000e+02, -2.07929e+02, 3.49059e+02), forces1[152], tol);
ASSERT_EQUAL_VEC(Vec3( 1.43078e+01, -2.80359e+02, 5.69790e+01), forces1[153], tol); ASSERT_EQUAL_VEC(Vec3( 1.43030e+01, -2.80350e+02, 5.69624e+01), forces1[153], tol);
ASSERT_EQUAL_VEC(Vec3( 9.72090e+01, 1.42442e+01, 1.00131e+02), forces1[154], tol); ASSERT_EQUAL_VEC(Vec3( 9.71900e+01, 1.42411e+01, 1.00140e+02), forces1[154], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56968e+02, -1.88055e+01, -1.07634e+02), forces1[155], tol); ASSERT_EQUAL_VEC(Vec3( 2.56963e+02, -1.88089e+01, -1.07623e+02), forces1[155], tol);
ASSERT_EQUAL_VEC(Vec3( 4.20285e+02, 1.16953e+02, 4.29561e+02), forces1[156], tol); ASSERT_EQUAL_VEC(Vec3( 4.20295e+02, 1.16954e+02, 4.29566e+02), forces1[156], tol);
ASSERT_EQUAL_VEC(Vec3(-2.05588e+02, -2.74949e+02, 1.32847e+02), forces1[157], tol); ASSERT_EQUAL_VEC(Vec3(-2.05593e+02, -2.74959e+02, 1.32855e+02), forces1[157], tol);
ASSERT_EQUAL_VEC(Vec3( 2.89202e+01, 1.07690e+01, -2.09455e+02), forces1[158], tol); ASSERT_EQUAL_VEC(Vec3( 2.89209e+01, 1.07778e+01, -2.09463e+02), forces1[158], tol);
ASSERT_EQUAL_VEC(Vec3(-4.54606e+02, -2.58096e+01, -2.66967e+02), forces1[159], tol); ASSERT_EQUAL_VEC(Vec3(-4.54593e+02, -2.58228e+01, -2.66965e+02), forces1[159], tol);
ASSERT_EQUAL_VEC(Vec3( 5.91038e+02, -7.76649e+01, 9.29046e+01), forces1[160], tol); ASSERT_EQUAL_VEC(Vec3( 5.91052e+02, -7.76642e+01, 9.29134e+01), forces1[160], tol);
ASSERT_EQUAL_VEC(Vec3(-8.27947e+00, 2.39607e+02, 1.04872e+02), forces1[161], tol); ASSERT_EQUAL_VEC(Vec3(-8.26339e+00, 2.39612e+02, 1.04877e+02), forces1[161], tol);
ASSERT_EQUAL_VEC(Vec3( 4.79749e+01, -1.73701e+02, -5.97911e+01), forces1[162], tol); ASSERT_EQUAL_VEC(Vec3( 4.79939e+01, -1.73697e+02, -5.98017e+01), forces1[162], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26004e+02, 1.64310e+02, -4.23294e+02), forces1[163], tol); ASSERT_EQUAL_VEC(Vec3(-1.26010e+02, 1.64321e+02, -4.23292e+02), forces1[163], tol);
ASSERT_EQUAL_VEC(Vec3(-2.03173e+02, 1.46918e+02, 2.50708e+02), forces1[164], tol); ASSERT_EQUAL_VEC(Vec3(-2.03195e+02, 1.46922e+02, 2.50713e+02), forces1[164], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38806e+02, 1.32927e+02, 2.75576e+02), forces1[165], tol); ASSERT_EQUAL_VEC(Vec3(-1.38811e+02, 1.32928e+02, 2.75566e+02), forces1[165], tol);
ASSERT_EQUAL_VEC(Vec3( 9.19209e+01, -1.55643e+02, 1.24226e+02), forces1[166], tol); ASSERT_EQUAL_VEC(Vec3( 9.19090e+01, -1.55644e+02, 1.24224e+02), forces1[166], tol);
ASSERT_EQUAL_VEC(Vec3( 2.09929e+02, 1.26986e+02, -3.32804e+02), forces1[167], tol); ASSERT_EQUAL_VEC(Vec3( 2.09934e+02, 1.26972e+02, -3.32816e+02), forces1[167], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56206e+02, 6.10336e+00, 3.42780e+02), forces1[168], tol); ASSERT_EQUAL_VEC(Vec3( 2.56192e+02, 6.10657e+00, 3.42782e+02), forces1[168], tol);
ASSERT_EQUAL_VEC(Vec3( 3.11424e+02, 9.42220e+01, -8.53155e+00), forces1[169], tol); ASSERT_EQUAL_VEC(Vec3( 3.11423e+02, 9.42269e+01, -8.52675e+00), forces1[169], tol);
ASSERT_EQUAL_VEC(Vec3( 1.78679e+02, -1.37371e+01, -2.21884e+01), forces1[170], tol); ASSERT_EQUAL_VEC(Vec3( 1.78684e+02, -1.37283e+01, -2.21919e+01), forces1[170], tol);
ASSERT_EQUAL_VEC(Vec3(-4.69163e+01, 5.77166e+02, 1.04220e+02), forces1[171], tol); ASSERT_EQUAL_VEC(Vec3(-4.69160e+01, 5.77174e+02, 1.04228e+02), forces1[171], tol);
ASSERT_EQUAL_VEC(Vec3( 1.31265e+02, 7.58001e+01, -9.08243e+01), forces1[172], tol); ASSERT_EQUAL_VEC(Vec3( 1.31260e+02, 7.57898e+01, -9.08328e+01), forces1[172], tol);
ASSERT_EQUAL_VEC(Vec3(-1.69452e+02, -3.62017e+02, 2.68885e+02), forces1[173], tol); ASSERT_EQUAL_VEC(Vec3(-1.69432e+02, -3.62007e+02, 2.68885e+02), forces1[173], tol);
ASSERT_EQUAL_VEC(Vec3(-1.68473e+02, -2.62630e+02, 7.41196e+01), forces1[174], tol); ASSERT_EQUAL_VEC(Vec3(-1.68470e+02, -2.62621e+02, 7.40996e+01), forces1[174], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53152e+02, 2.68918e+02, -3.92495e+02), forces1[175], tol); ASSERT_EQUAL_VEC(Vec3(-2.53156e+02, 2.68902e+02, -3.92489e+02), forces1[175], tol);
ASSERT_EQUAL_VEC(Vec3( 1.95130e+02, -5.76716e+01, 3.91953e+02), forces1[176], tol); ASSERT_EQUAL_VEC(Vec3( 1.95127e+02, -5.76545e+01, 3.91956e+02), forces1[176], tol);
ASSERT_EQUAL_VEC(Vec3( 2.43334e+02, -3.91489e+02, -8.64027e+01), forces1[177], tol); ASSERT_EQUAL_VEC(Vec3( 2.43341e+02, -3.91473e+02, -8.63941e+01), forces1[177], tol);
ASSERT_EQUAL_VEC(Vec3(-1.34173e+02, 1.46590e+02, 1.19857e+02), forces1[178], tol); ASSERT_EQUAL_VEC(Vec3(-1.34182e+02, 1.46584e+02, 1.19870e+02), forces1[178], tol);
ASSERT_EQUAL_VEC(Vec3( 1.63166e+02, -2.66975e+02, 1.65803e+02), forces1[179], tol); ASSERT_EQUAL_VEC(Vec3( 1.63164e+02, -2.66967e+02, 1.65791e+02), forces1[179], tol);
ASSERT_EQUAL_VEC(Vec3( 5.46618e+01, 6.58768e+01, -4.94239e+02), forces1[180], tol); ASSERT_EQUAL_VEC(Vec3( 5.46590e+01, 6.58743e+01, -4.94241e+02), forces1[180], tol);
ASSERT_EQUAL_VEC(Vec3(-1.62982e+02, 1.53813e+02, 2.72197e+01), forces1[181], tol); ASSERT_EQUAL_VEC(Vec3(-1.62967e+02, 1.53812e+02, 2.72243e+01), forces1[181], tol);
ASSERT_EQUAL_VEC(Vec3(-1.97729e+02, -9.07914e+01, -5.59631e+02), forces1[182], tol); ASSERT_EQUAL_VEC(Vec3(-1.97753e+02, -9.07862e+01, -5.59637e+02), forces1[182], tol);
ASSERT_EQUAL_VEC(Vec3(-9.59262e+01, -3.67224e+02, -1.37095e+02), forces1[183], tol); ASSERT_EQUAL_VEC(Vec3(-9.59328e+01, -3.67223e+02, -1.37096e+02), forces1[183], tol);
ASSERT_EQUAL_VEC(Vec3(-3.13280e+02, -4.77507e+02, -2.82333e+02), forces1[184], tol); ASSERT_EQUAL_VEC(Vec3(-3.13273e+02, -4.77523e+02, -2.82321e+02), forces1[184], tol);
ASSERT_EQUAL_VEC(Vec3( 3.47155e+01, -1.51842e+02, -2.71796e+02), forces1[185], tol); ASSERT_EQUAL_VEC(Vec3( 3.47114e+01, -1.51858e+02, -2.71784e+02), forces1[185], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09990e+02, 7.60819e+01, -1.90760e+02), forces1[186], tol); ASSERT_EQUAL_VEC(Vec3(-1.09989e+02, 7.60839e+01, -1.90745e+02), forces1[186], tol);
ASSERT_EQUAL_VEC(Vec3( 3.49592e+02, 1.52760e+02, 4.22501e+02), forces1[187], tol); ASSERT_EQUAL_VEC(Vec3( 3.49591e+02, 1.52748e+02, 4.22478e+02), forces1[187], tol);
ASSERT_EQUAL_VEC(Vec3(-3.59682e+01, 3.55490e+01, -7.87259e+01), forces1[188], tol); ASSERT_EQUAL_VEC(Vec3(-3.59778e+01, 3.55514e+01, -7.87122e+01), forces1[188], tol);
ASSERT_EQUAL_VEC(Vec3(-5.53792e+02, 1.58095e+02, -5.47454e+01), forces1[189], tol); ASSERT_EQUAL_VEC(Vec3(-5.53788e+02, 1.58097e+02, -5.47413e+01), forces1[189], tol);
ASSERT_EQUAL_VEC(Vec3( 8.55309e+01, -2.88451e+02, 2.54433e+01), forces1[190], tol); ASSERT_EQUAL_VEC(Vec3( 8.55383e+01, -2.88446e+02, 2.54335e+01), forces1[190], tol);
ASSERT_EQUAL_VEC(Vec3( 1.96778e+02, 1.69086e+02, 2.41090e+02), forces1[191], tol); ASSERT_EQUAL_VEC(Vec3( 1.96776e+02, 1.69083e+02, 2.41079e+02), forces1[191], tol);
ASSERT_EQUAL_VEC(Vec3( 7.64032e+01, 3.05705e+02, 2.76174e+02), forces1[192], tol); ASSERT_EQUAL_VEC(Vec3( 7.63954e+01, 3.05700e+02, 2.76177e+02), forces1[192], tol);
ASSERT_EQUAL_VEC(Vec3( 1.23271e+02, 8.57374e+01, 3.46727e+02), forces1[193], tol); ASSERT_EQUAL_VEC(Vec3( 1.23270e+02, 8.57544e+01, 3.46732e+02), forces1[193], tol);
ASSERT_EQUAL_VEC(Vec3(-9.05699e+01, 5.50749e+01, -4.12465e+02), forces1[194], tol); ASSERT_EQUAL_VEC(Vec3(-9.05524e+01, 5.50783e+01, -4.12477e+02), forces1[194], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69299e+00, 1.30555e+02, -1.55113e+02), forces1[195], tol); ASSERT_EQUAL_VEC(Vec3(-2.70275e+00, 1.30545e+02, -1.55114e+02), forces1[195], tol);
ASSERT_EQUAL_VEC(Vec3(-1.37396e+02, -2.94311e+02, -1.24613e+02), forces1[196], tol); ASSERT_EQUAL_VEC(Vec3(-1.37391e+02, -2.94314e+02, -1.24617e+02), forces1[196], tol);
ASSERT_EQUAL_VEC(Vec3(-3.56092e+02, -9.03511e+01, 3.14901e+02), forces1[197], tol); ASSERT_EQUAL_VEC(Vec3(-3.56081e+02, -9.03717e+01, 3.14903e+02), forces1[197], tol);
ASSERT_EQUAL_VEC(Vec3(-7.79080e+01, 1.12179e+02, 3.86362e+02), forces1[198], tol); ASSERT_EQUAL_VEC(Vec3(-7.79201e+01, 1.12169e+02, 3.86360e+02), forces1[198], tol);
ASSERT_EQUAL_VEC(Vec3( 2.43094e+02, 5.36465e+02, -9.47494e+01), forces1[199], tol); ASSERT_EQUAL_VEC(Vec3( 2.43084e+02, 5.36465e+02, -9.47472e+01), forces1[199], tol);
ASSERT_EQUAL_VEC(Vec3(-7.39663e+01, -3.53189e+02, 1.42838e+01), forces1[200], tol); ASSERT_EQUAL_VEC(Vec3(-7.39515e+01, -3.53203e+02, 1.42906e+01), forces1[200], tol);
ASSERT_EQUAL_VEC(Vec3( 6.56541e+02, -2.80418e+02, 2.95738e+02), forces1[201], tol); ASSERT_EQUAL_VEC(Vec3( 6.56525e+02, -2.80413e+02, 2.95738e+02), forces1[201], tol);
ASSERT_EQUAL_VEC(Vec3(-2.72307e+02, -1.44070e+02, 2.55682e+02), forces1[202], tol); ASSERT_EQUAL_VEC(Vec3(-2.72295e+02, -1.44068e+02, 2.55682e+02), forces1[202], tol);
ASSERT_EQUAL_VEC(Vec3(-3.75660e+01, 2.99418e+02, -4.12454e+02), forces1[203], tol); ASSERT_EQUAL_VEC(Vec3(-3.75581e+01, 2.99407e+02, -4.12452e+02), forces1[203], tol);
ASSERT_EQUAL_VEC(Vec3( 3.64691e+02, 3.39106e+02, -8.08600e+01), forces1[204], tol); ASSERT_EQUAL_VEC(Vec3( 3.64683e+02, 3.39099e+02, -8.08627e+01), forces1[204], tol);
ASSERT_EQUAL_VEC(Vec3( 4.32797e+02, -1.78901e+02, 3.86638e+02), forces1[205], tol); ASSERT_EQUAL_VEC(Vec3( 4.32794e+02, -1.78902e+02, 3.86635e+02), forces1[205], tol);
ASSERT_EQUAL_VEC(Vec3(-9.04289e+01, 3.89966e+02, -5.47927e+02), forces1[206], tol); ASSERT_EQUAL_VEC(Vec3(-9.04431e+01, 3.89962e+02, -5.47942e+02), forces1[206], tol);
ASSERT_EQUAL_VEC(Vec3(-6.35043e+02, 1.85143e+01, 3.17121e+01), forces1[207], tol); ASSERT_EQUAL_VEC(Vec3(-6.35047e+02, 1.85340e+01, 3.17100e+01), forces1[207], tol);
ASSERT_EQUAL_VEC(Vec3(-5.92798e+01, -2.85284e+02, -1.42340e+02), forces1[208], tol); ASSERT_EQUAL_VEC(Vec3(-5.92927e+01, -2.85278e+02, -1.42336e+02), forces1[208], tol);
ASSERT_EQUAL_VEC(Vec3(-1.35184e+02, -3.56067e+02, 1.07961e+02), forces1[209], tol); ASSERT_EQUAL_VEC(Vec3(-1.35200e+02, -3.56060e+02, 1.07958e+02), forces1[209], tol);
ASSERT_EQUAL_VEC(Vec3( 3.94878e+02, 9.99496e+01, -1.57865e+02), forces1[210], tol); ASSERT_EQUAL_VEC(Vec3( 3.94881e+02, 9.99543e+01, -1.57851e+02), forces1[210], tol);
ASSERT_EQUAL_VEC(Vec3(-1.56539e+02, -1.66153e+02, -4.75316e+00), forces1[211], tol); ASSERT_EQUAL_VEC(Vec3(-1.56550e+02, -1.66155e+02, -4.76763e+00), forces1[211], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77279e+02, -9.52088e+01, -3.42045e+02), forces1[212], tol); ASSERT_EQUAL_VEC(Vec3(-1.77273e+02, -9.51984e+01, -3.42047e+02), forces1[212], tol);
ASSERT_EQUAL_VEC(Vec3( 2.97737e+02, 7.18133e+02, -4.94792e+02), forces1[213], tol); ASSERT_EQUAL_VEC(Vec3( 2.97728e+02, 7.18136e+02, -4.94807e+02), forces1[213], tol);
ASSERT_EQUAL_VEC(Vec3(-5.12782e+02, 7.63632e+02, -5.44345e+01), forces1[214], tol); ASSERT_EQUAL_VEC(Vec3(-5.12783e+02, 7.63620e+02, -5.44394e+01), forces1[214], tol);
ASSERT_EQUAL_VEC(Vec3(-2.55725e+02, -4.46412e+02, -1.72492e+02), forces1[215], tol); ASSERT_EQUAL_VEC(Vec3(-2.55726e+02, -4.46420e+02, -1.72489e+02), forces1[215], tol);
ASSERT_EQUAL_VEC(Vec3( 3.15204e+02, 5.62404e+02, 2.42570e+02), forces1[216], tol); ASSERT_EQUAL_VEC(Vec3( 3.15171e+02, 5.62389e+02, 2.42576e+02), forces1[216], tol);
ASSERT_EQUAL_VEC(Vec3(-2.90625e+01, 3.91010e+02, 1.36611e+02), forces1[217], tol); ASSERT_EQUAL_VEC(Vec3(-2.90712e+01, 3.91014e+02, 1.36611e+02), forces1[217], tol);
ASSERT_EQUAL_VEC(Vec3(-4.26366e+02, 5.13936e+02, 8.37893e+01), forces1[218], tol); ASSERT_EQUAL_VEC(Vec3(-4.26378e+02, 5.13932e+02, 8.37934e+01), forces1[218], tol);
ASSERT_EQUAL_VEC(Vec3(-2.88389e+02, 6.41439e+01, 3.02418e+02), forces1[219], tol); ASSERT_EQUAL_VEC(Vec3(-2.88401e+02, 6.41261e+01, 3.02429e+02), forces1[219], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13227e+01, -3.20426e+02, 1.98721e+02), forces1[220], tol); ASSERT_EQUAL_VEC(Vec3(-1.13219e+01, -3.20436e+02, 1.98720e+02), forces1[220], tol);
ASSERT_EQUAL_VEC(Vec3(-1.73211e+02, 2.09799e+02, 2.60737e+02), forces1[221], tol); ASSERT_EQUAL_VEC(Vec3(-1.73195e+02, 2.09809e+02, 2.60748e+02), forces1[221], tol);
ASSERT_EQUAL_VEC(Vec3( 4.34176e+02, -1.25032e+02, 2.52922e+02), forces1[222], tol); ASSERT_EQUAL_VEC(Vec3( 4.34172e+02, -1.25036e+02, 2.52922e+02), forces1[222], tol);
ASSERT_EQUAL_VEC(Vec3(-3.09514e+02, 2.63401e+02, -2.33532e+02), forces1[223], tol); ASSERT_EQUAL_VEC(Vec3(-3.09527e+02, 2.63414e+02, -2.33511e+02), forces1[223], tol);
ASSERT_EQUAL_VEC(Vec3( 8.65295e+01, -5.32177e+02, -2.36433e+02), forces1[224], tol); ASSERT_EQUAL_VEC(Vec3( 8.65417e+01, -5.32174e+02, -2.36445e+02), forces1[224], tol);
ASSERT_EQUAL_VEC(Vec3(-1.74967e+02, -2.30203e+02, -1.33697e+02), forces1[225], tol); ASSERT_EQUAL_VEC(Vec3(-1.74956e+02, -2.30188e+02, -1.33696e+02), forces1[225], tol);
ASSERT_EQUAL_VEC(Vec3( 1.53824e+02, -1.24371e+02, -3.93440e+01), forces1[226], tol); ASSERT_EQUAL_VEC(Vec3( 1.53827e+02, -1.24376e+02, -3.93704e+01), forces1[226], tol);
ASSERT_EQUAL_VEC(Vec3(-4.51752e+02, -7.75083e+01, -5.36166e+02), forces1[227], tol); ASSERT_EQUAL_VEC(Vec3(-4.51770e+02, -7.75099e+01, -5.36164e+02), forces1[227], tol);
ASSERT_EQUAL_VEC(Vec3( 5.99295e+01, 2.97295e+02, 5.98938e+01), forces1[228], tol); ASSERT_EQUAL_VEC(Vec3( 5.99182e+01, 2.97286e+02, 5.99064e+01), forces1[228], tol);
ASSERT_EQUAL_VEC(Vec3(-3.10615e+02, 2.95703e+00, -3.63614e+01), forces1[229], tol); ASSERT_EQUAL_VEC(Vec3(-3.10611e+02, 2.95975e+00, -3.63666e+01), forces1[229], tol);
ASSERT_EQUAL_VEC(Vec3( 3.85857e+02, 1.41638e+02, 2.75093e+02), forces1[230], tol); ASSERT_EQUAL_VEC(Vec3( 3.85866e+02, 1.41628e+02, 2.75110e+02), forces1[230], tol);
ASSERT_EQUAL_VEC(Vec3( 5.43219e+02, -3.20261e+02, -3.02153e+01), forces1[231], tol); ASSERT_EQUAL_VEC(Vec3( 5.43212e+02, -3.20236e+02, -3.02040e+01), forces1[231], tol);
ASSERT_EQUAL_VEC(Vec3( 3.85595e+02, 6.64255e+01, -3.49506e+01), forces1[232], tol); ASSERT_EQUAL_VEC(Vec3( 3.85594e+02, 6.64254e+01, -3.49438e+01), forces1[232], tol);
ASSERT_EQUAL_VEC(Vec3(-4.52864e+02, -3.40712e+02, 1.28889e+02), forces1[233], tol); ASSERT_EQUAL_VEC(Vec3(-4.52870e+02, -3.40699e+02, 1.28895e+02), forces1[233], tol);
ASSERT_EQUAL_VEC(Vec3( 9.34278e+02, -1.39480e+02, 3.57848e+02), forces1[234], tol); ASSERT_EQUAL_VEC(Vec3( 9.34274e+02, -1.39499e+02, 3.57860e+02), forces1[234], tol);
ASSERT_EQUAL_VEC(Vec3(-2.03070e+02, 7.44620e+01, 9.27246e+01), forces1[235], tol); ASSERT_EQUAL_VEC(Vec3(-2.03059e+02, 7.44587e+01, 9.27241e+01), forces1[235], tol);
ASSERT_EQUAL_VEC(Vec3(-5.97531e+02, 1.26797e+02, 2.78888e+02), forces1[236], tol); ASSERT_EQUAL_VEC(Vec3(-5.97529e+02, 1.26808e+02, 2.78892e+02), forces1[236], tol);
ASSERT_EQUAL_VEC(Vec3( 5.67860e+02, -5.34679e+02, -1.84220e+02), forces1[237], tol); ASSERT_EQUAL_VEC(Vec3( 5.67859e+02, -5.34679e+02, -1.84220e+02), forces1[237], tol);
ASSERT_EQUAL_VEC(Vec3( 2.13188e+02, 2.99774e+02, -2.66439e+02), forces1[238], tol); ASSERT_EQUAL_VEC(Vec3( 2.13200e+02, 2.99785e+02, -2.66449e+02), forces1[238], tol);
ASSERT_EQUAL_VEC(Vec3( 3.11339e+01, 4.54661e+02, 3.81038e+01), forces1[239], tol); ASSERT_EQUAL_VEC(Vec3( 3.11287e+01, 4.54671e+02, 3.80933e+01), forces1[239], tol);
ASSERT_EQUAL_VEC(Vec3( 1.57529e+02, 3.19130e+01, -1.57712e+02), forces1[240], tol); ASSERT_EQUAL_VEC(Vec3( 1.57505e+02, 3.19189e+01, -1.57725e+02), forces1[240], tol);
ASSERT_EQUAL_VEC(Vec3( 4.34923e+02, -4.69293e+02, -3.96785e+01), forces1[241], tol); ASSERT_EQUAL_VEC(Vec3( 4.34917e+02, -4.69304e+02, -3.96804e+01), forces1[241], tol);
ASSERT_EQUAL_VEC(Vec3(-3.54055e+01, -1.00167e+02, 7.07492e+01), forces1[242], tol); ASSERT_EQUAL_VEC(Vec3(-3.54012e+01, -1.00149e+02, 7.07594e+01), forces1[242], tol);
ASSERT_EQUAL_VEC(Vec3( 3.29675e+02, 3.63909e+02, -3.89193e+02), forces1[243], tol); ASSERT_EQUAL_VEC(Vec3( 3.29664e+02, 3.63915e+02, -3.89187e+02), forces1[243], tol);
ASSERT_EQUAL_VEC(Vec3( 7.63973e+02, 2.97350e+02, -5.40150e+01), forces1[244], tol); ASSERT_EQUAL_VEC(Vec3( 7.63973e+02, 2.97338e+02, -5.40126e+01), forces1[244], tol);
ASSERT_EQUAL_VEC(Vec3(-2.67914e+02, 2.23586e+02, -1.67256e+02), forces1[245], tol); ASSERT_EQUAL_VEC(Vec3(-2.67921e+02, 2.23572e+02, -1.67260e+02), forces1[245], tol);
ASSERT_EQUAL_VEC(Vec3(-6.45303e+02, -9.39869e+00, -5.71100e+02), forces1[246], tol); ASSERT_EQUAL_VEC(Vec3(-6.45303e+02, -9.38934e+00, -5.71083e+02), forces1[246], tol);
ASSERT_EQUAL_VEC(Vec3( 1.48200e+02, -1.78762e+02, 8.43530e+01), forces1[247], tol); ASSERT_EQUAL_VEC(Vec3( 1.48206e+02, -1.78758e+02, 8.43606e+01), forces1[247], tol);
ASSERT_EQUAL_VEC(Vec3( 3.26724e+02, -3.84560e+02, 2.88340e+02), forces1[248], tol); ASSERT_EQUAL_VEC(Vec3( 3.26733e+02, -3.84541e+02, 2.88339e+02), forces1[248], tol);
ASSERT_EQUAL_VEC(Vec3( 2.58355e+02, 5.43901e+01, 3.38659e+02), forces1[249], tol); ASSERT_EQUAL_VEC(Vec3( 2.58355e+02, 5.43926e+01, 3.38657e+02), forces1[249], tol);
ASSERT_EQUAL_VEC(Vec3(-3.51581e+02, -3.06747e+02, -2.99604e+01), forces1[250], tol); ASSERT_EQUAL_VEC(Vec3(-3.51580e+02, -3.06746e+02, -2.99583e+01), forces1[250], tol);
ASSERT_EQUAL_VEC(Vec3(-2.78730e+01, 2.36176e+02, 1.05994e+01), forces1[251], tol); ASSERT_EQUAL_VEC(Vec3(-2.78564e+01, 2.36171e+02, 1.06051e+01), forces1[251], tol);
ASSERT_EQUAL_VEC(Vec3(-1.75885e+02, -9.37533e+00, 1.84212e+02), forces1[252], tol); ASSERT_EQUAL_VEC(Vec3(-1.75884e+02, -9.36825e+00, 1.84217e+02), forces1[252], tol);
ASSERT_EQUAL_VEC(Vec3(-5.60414e+02, 1.90156e+02, -2.90261e+02), forces1[253], tol); ASSERT_EQUAL_VEC(Vec3(-5.60414e+02, 1.90158e+02, -2.90241e+02), forces1[253], tol);
ASSERT_EQUAL_VEC(Vec3(-1.69412e+02, 2.23707e+02, -3.41995e+02), forces1[254], tol); ASSERT_EQUAL_VEC(Vec3(-1.69419e+02, 2.23708e+02, -3.41993e+02), forces1[254], tol);
ASSERT_EQUAL_VEC(Vec3(-6.96461e+01, 1.66431e+02, -6.77217e+00), forces1[255], tol); ASSERT_EQUAL_VEC(Vec3(-6.96442e+01, 1.66443e+02, -6.76290e+00), forces1[255], tol);
ASSERT_EQUAL_VEC(Vec3( 2.73632e+02, 1.48499e+00, 7.80562e+01), forces1[256], tol); ASSERT_EQUAL_VEC(Vec3( 2.73634e+02, 1.47945e+00, 7.80674e+01), forces1[256], tol);
ASSERT_EQUAL_VEC(Vec3(-2.58379e+02, 8.46671e+01, -9.41773e+01), forces1[257], tol); ASSERT_EQUAL_VEC(Vec3(-2.58360e+02, 8.46506e+01, -9.41941e+01), forces1[257], tol);
ASSERT_EQUAL_VEC(Vec3(-4.25872e+02, 9.84419e+00, 6.39485e+01), forces1[258], tol); ASSERT_EQUAL_VEC(Vec3(-4.25856e+02, 9.84269e+00, 6.39688e+01), forces1[258], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12081e+02, 6.10186e+01, -1.38681e+02), forces1[259], tol); ASSERT_EQUAL_VEC(Vec3( 1.12074e+02, 6.10175e+01, -1.38671e+02), forces1[259], tol);
ASSERT_EQUAL_VEC(Vec3( 3.21882e+01, 3.67507e+02, 6.86913e+01), forces1[260], tol); ASSERT_EQUAL_VEC(Vec3( 3.21742e+01, 3.67503e+02, 6.86820e+01), forces1[260], tol);
ASSERT_EQUAL_VEC(Vec3(-3.72200e+02, 3.36289e+02, 3.15260e+02), forces1[261], tol); ASSERT_EQUAL_VEC(Vec3(-3.72197e+02, 3.36299e+02, 3.15267e+02), forces1[261], tol);
ASSERT_EQUAL_VEC(Vec3( 4.28586e+01, 5.93504e+01, 4.86909e+02), forces1[262], tol); ASSERT_EQUAL_VEC(Vec3( 4.28544e+01, 5.93439e+01, 4.86904e+02), forces1[262], tol);
ASSERT_EQUAL_VEC(Vec3( 3.03289e+01, 3.70285e+02, -5.83428e+02), forces1[263], tol); ASSERT_EQUAL_VEC(Vec3( 3.03218e+01, 3.70289e+02, -5.83427e+02), forces1[263], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61741e+02, 3.70546e+02, -2.03512e+01), forces1[264], tol); ASSERT_EQUAL_VEC(Vec3(-1.61746e+02, 3.70556e+02, -2.03554e+01), forces1[264], tol);
ASSERT_EQUAL_VEC(Vec3(-6.67240e+02, -1.24276e+01, -9.41912e+01), forces1[265], tol); ASSERT_EQUAL_VEC(Vec3(-6.67228e+02, -1.24405e+01, -9.41848e+01), forces1[265], tol);
ASSERT_EQUAL_VEC(Vec3( 4.66969e+02, 3.49515e+02, 2.04641e+02), forces1[266], tol); ASSERT_EQUAL_VEC(Vec3( 4.66963e+02, 3.49517e+02, 2.04653e+02), forces1[266], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52481e+02, -1.24048e+01, 2.24580e+01), forces1[267], tol); ASSERT_EQUAL_VEC(Vec3(-3.52489e+02, -1.24054e+01, 2.24698e+01), forces1[267], tol);
ASSERT_EQUAL_VEC(Vec3( 4.58754e+01, -2.20883e+02, 7.64580e+01), forces1[268], tol); ASSERT_EQUAL_VEC(Vec3( 4.58673e+01, -2.20882e+02, 7.64532e+01), forces1[268], tol);
ASSERT_EQUAL_VEC(Vec3(-4.43794e+01, -1.14905e+02, -2.87915e+02), forces1[269], tol); ASSERT_EQUAL_VEC(Vec3(-4.43759e+01, -1.14901e+02, -2.87908e+02), forces1[269], tol);
ASSERT_EQUAL_VEC(Vec3(-9.22309e+01, 6.40918e+02, 3.17836e+02), forces1[270], tol); ASSERT_EQUAL_VEC(Vec3(-9.22294e+01, 6.40897e+02, 3.17837e+02), forces1[270], tol);
ASSERT_EQUAL_VEC(Vec3(-2.15607e+02, -2.05475e+02, 6.85600e+01), forces1[271], tol); ASSERT_EQUAL_VEC(Vec3(-2.15619e+02, -2.05476e+02, 6.85753e+01), forces1[271], tol);
ASSERT_EQUAL_VEC(Vec3( 2.24212e+02, -1.43089e+02, -4.17830e+01), forces1[272], tol); ASSERT_EQUAL_VEC(Vec3( 2.24210e+02, -1.43086e+02, -4.17853e+01), forces1[272], tol);
ASSERT_EQUAL_VEC(Vec3( 1.79807e+02, -3.72431e+02, 2.12166e+02), forces1[273], tol); ASSERT_EQUAL_VEC(Vec3( 1.79801e+02, -3.72431e+02, 2.12152e+02), forces1[273], tol);
ASSERT_EQUAL_VEC(Vec3( 9.74669e+01, 7.66818e+01, -5.04526e+02), forces1[274], tol); ASSERT_EQUAL_VEC(Vec3( 9.74712e+01, 7.66879e+01, -5.04532e+02), forces1[274], tol);
ASSERT_EQUAL_VEC(Vec3( 2.17830e+01, -5.76189e+02, -3.23940e+02), forces1[275], tol); ASSERT_EQUAL_VEC(Vec3( 2.17851e+01, -5.76193e+02, -3.23925e+02), forces1[275], tol);
ASSERT_EQUAL_VEC(Vec3(-2.97060e+02, -1.47125e+02, -1.56574e+02), forces1[276], tol); ASSERT_EQUAL_VEC(Vec3(-2.97069e+02, -1.47147e+02, -1.56571e+02), forces1[276], tol);
ASSERT_EQUAL_VEC(Vec3( 4.21743e+01, -2.91448e+02, -1.50267e+02), forces1[277], tol); ASSERT_EQUAL_VEC(Vec3( 4.21716e+01, -2.91447e+02, -1.50265e+02), forces1[277], tol);
ASSERT_EQUAL_VEC(Vec3( 1.75433e+02, -9.12778e+01, 6.45412e+01), forces1[278], tol); ASSERT_EQUAL_VEC(Vec3( 1.75434e+02, -9.12760e+01, 6.45501e+01), forces1[278], tol);
ASSERT_EQUAL_VEC(Vec3( 1.50370e+02, -1.42435e+02, 2.67956e+02), forces1[279], tol); ASSERT_EQUAL_VEC(Vec3( 1.50375e+02, -1.42450e+02, 2.67953e+02), forces1[279], tol);
ASSERT_EQUAL_VEC(Vec3(-4.86649e+02, -2.18700e+01, 1.45716e+02), forces1[280], tol); ASSERT_EQUAL_VEC(Vec3(-4.86647e+02, -2.18743e+01, 1.45714e+02), forces1[280], tol);
ASSERT_EQUAL_VEC(Vec3( 9.28241e+01, -6.95094e+01, -8.90426e+00), forces1[281], tol); ASSERT_EQUAL_VEC(Vec3( 9.28419e+01, -6.94980e+01, -8.90565e+00), forces1[281], tol);
ASSERT_EQUAL_VEC(Vec3(-5.85150e+01, 2.84909e+02, 4.82515e+02), forces1[282], tol); ASSERT_EQUAL_VEC(Vec3(-5.85243e+01, 2.84897e+02, 4.82514e+02), forces1[282], tol);
ASSERT_EQUAL_VEC(Vec3(-2.83565e+01, -1.73726e+02, -3.77869e+02), forces1[283], tol); ASSERT_EQUAL_VEC(Vec3(-2.83552e+01, -1.73734e+02, -3.77885e+02), forces1[283], tol);
ASSERT_EQUAL_VEC(Vec3(-4.34926e+02, -1.30369e+02, -3.31912e+02), forces1[284], tol); ASSERT_EQUAL_VEC(Vec3(-4.34939e+02, -1.30344e+02, -3.31885e+02), forces1[284], tol);
ASSERT_EQUAL_VEC(Vec3( 3.85231e+01, -2.55005e+02, -5.18587e+02), forces1[285], tol); ASSERT_EQUAL_VEC(Vec3( 3.85318e+01, -2.54993e+02, -5.18580e+02), forces1[285], tol);
ASSERT_EQUAL_VEC(Vec3(-7.78979e+01, 1.25366e+02, -3.80650e+02), forces1[286], tol); ASSERT_EQUAL_VEC(Vec3(-7.78898e+01, 1.25376e+02, -3.80651e+02), forces1[286], tol);
ASSERT_EQUAL_VEC(Vec3(-1.27205e+02, 3.88673e+02, 9.40595e+01), forces1[287], tol); ASSERT_EQUAL_VEC(Vec3(-1.27219e+02, 3.88677e+02, 9.40603e+01), forces1[287], tol);
ASSERT_EQUAL_VEC(Vec3( 1.39444e+02, 4.03535e+02, -4.33301e+02), forces1[288], tol); ASSERT_EQUAL_VEC(Vec3( 1.39438e+02, 4.03527e+02, -4.33294e+02), forces1[288], tol);
ASSERT_EQUAL_VEC(Vec3(-2.89031e+00, -2.06316e+02, -7.48586e+02), forces1[289], tol); ASSERT_EQUAL_VEC(Vec3(-2.88829e+00, -2.06320e+02, -7.48585e+02), forces1[289], tol);
ASSERT_EQUAL_VEC(Vec3( 1.08033e+01, 2.35864e+02, -1.38369e+02), forces1[290], tol); ASSERT_EQUAL_VEC(Vec3( 1.07981e+01, 2.35861e+02, -1.38359e+02), forces1[290], tol);
ASSERT_EQUAL_VEC(Vec3( 8.60346e+01, 5.74958e+02, 1.95765e+02), forces1[291], tol); ASSERT_EQUAL_VEC(Vec3( 8.60284e+01, 5.74943e+02, 1.95762e+02), forces1[291], tol);
ASSERT_EQUAL_VEC(Vec3(-2.45595e+02, 1.95536e+02, 1.22023e+02), forces1[292], tol); ASSERT_EQUAL_VEC(Vec3(-2.45605e+02, 1.95528e+02, 1.22031e+02), forces1[292], tol);
ASSERT_EQUAL_VEC(Vec3(-3.33826e+02, -2.71372e+02, -3.43376e+02), forces1[293], tol); ASSERT_EQUAL_VEC(Vec3(-3.33844e+02, -2.71363e+02, -3.43370e+02), forces1[293], tol);
ASSERT_EQUAL_VEC(Vec3(-4.28626e+02, 1.60893e+02, 2.18059e+02), forces1[294], tol); ASSERT_EQUAL_VEC(Vec3(-4.28638e+02, 1.60891e+02, 2.18049e+02), forces1[294], tol);
ASSERT_EQUAL_VEC(Vec3(-5.40061e+02, -1.47441e+02, 4.35216e+02), forces1[295], tol); ASSERT_EQUAL_VEC(Vec3(-5.40059e+02, -1.47441e+02, 4.35219e+02), forces1[295], tol);
ASSERT_EQUAL_VEC(Vec3( 1.48820e+02, 3.45750e+01, -1.25816e+02), forces1[296], tol); ASSERT_EQUAL_VEC(Vec3( 1.48834e+02, 3.45734e+01, -1.25812e+02), forces1[296], tol);
ASSERT_EQUAL_VEC(Vec3( 3.39101e+02, 3.68717e+01, 2.99725e+01), forces1[297], tol); ASSERT_EQUAL_VEC(Vec3( 3.39094e+02, 3.68778e+01, 2.99734e+01), forces1[297], tol);
ASSERT_EQUAL_VEC(Vec3(-1.67743e+02, -2.84602e+02, 3.88525e+01), forces1[298], tol); ASSERT_EQUAL_VEC(Vec3(-1.67733e+02, -2.84609e+02, 3.88550e+01), forces1[298], tol);
ASSERT_EQUAL_VEC(Vec3(-3.21481e+02, -4.49310e+02, 1.41904e+02), forces1[299], tol); ASSERT_EQUAL_VEC(Vec3(-3.21477e+02, -4.49303e+02, 1.41885e+02), forces1[299], tol);
ASSERT_EQUAL_VEC(Vec3( 1.16247e+02, 6.78061e+00, -1.08228e+02), forces1[300], tol); ASSERT_EQUAL_VEC(Vec3( 1.16243e+02, 6.78513e+00, -1.08225e+02), forces1[300], tol);
ASSERT_EQUAL_VEC(Vec3(-1.85555e+02, -2.95250e+02, 5.01918e+02), forces1[301], tol); ASSERT_EQUAL_VEC(Vec3(-1.85556e+02, -2.95254e+02, 5.01916e+02), forces1[301], tol);
ASSERT_EQUAL_VEC(Vec3( 9.27550e+01, -3.83919e+02, -2.77965e+02), forces1[302], tol); ASSERT_EQUAL_VEC(Vec3( 9.27468e+01, -3.83936e+02, -2.77959e+02), forces1[302], tol);
ASSERT_EQUAL_VEC(Vec3(-3.97598e+01, 2.84534e+02, 2.33444e+02), forces1[303], tol); ASSERT_EQUAL_VEC(Vec3(-3.97651e+01, 2.84541e+02, 2.33443e+02), forces1[303], tol);
ASSERT_EQUAL_VEC(Vec3( 1.40322e+00, 2.25391e+02, 9.48146e+01), forces1[304], tol); ASSERT_EQUAL_VEC(Vec3( 1.40072e+00, 2.25399e+02, 9.48102e+01), forces1[304], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06082e+02, 2.06346e+02, -2.00197e+02), forces1[305], tol); ASSERT_EQUAL_VEC(Vec3( 1.06096e+02, 2.06345e+02, -2.00217e+02), forces1[305], tol);
ASSERT_EQUAL_VEC(Vec3(-3.33981e+02, -3.09196e+01, -9.24078e+01), forces1[306], tol); ASSERT_EQUAL_VEC(Vec3(-3.33985e+02, -3.09147e+01, -9.24046e+01), forces1[306], tol);
ASSERT_EQUAL_VEC(Vec3( 1.47295e+01, 1.47696e+02, 2.61218e+02), forces1[307], tol); ASSERT_EQUAL_VEC(Vec3( 1.47346e+01, 1.47720e+02, 2.61218e+02), forces1[307], tol);
ASSERT_EQUAL_VEC(Vec3( 4.44039e+01, 1.15108e+02, 1.21361e+02), forces1[308], tol); ASSERT_EQUAL_VEC(Vec3( 4.44221e+01, 1.15106e+02, 1.21336e+02), forces1[308], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53480e+02, 2.00351e+02, 3.39065e+01), forces1[309], tol); ASSERT_EQUAL_VEC(Vec3(-2.53468e+02, 2.00343e+02, 3.39205e+01), forces1[309], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06586e+02, -1.16087e+02, 5.96537e+01), forces1[310], tol); ASSERT_EQUAL_VEC(Vec3( 1.06608e+02, -1.16082e+02, 5.96468e+01), forces1[310], tol);
ASSERT_EQUAL_VEC(Vec3(-2.01603e+02, 4.15920e+01, 4.19320e+02), forces1[311], tol); ASSERT_EQUAL_VEC(Vec3(-2.01600e+02, 4.15917e+01, 4.19308e+02), forces1[311], tol);
ASSERT_EQUAL_VEC(Vec3( 4.40519e+02, 1.34432e+02, 7.74382e+01), forces1[312], tol); ASSERT_EQUAL_VEC(Vec3( 4.40503e+02, 1.34424e+02, 7.74282e+01), forces1[312], tol);
ASSERT_EQUAL_VEC(Vec3(-3.89155e+02, -2.83343e+02, -4.23565e+02), forces1[313], tol); ASSERT_EQUAL_VEC(Vec3(-3.89154e+02, -2.83347e+02, -4.23560e+02), forces1[313], tol);
ASSERT_EQUAL_VEC(Vec3( 2.42087e+02, -6.45962e+02, 3.91502e+02), forces1[314], tol); ASSERT_EQUAL_VEC(Vec3( 2.42086e+02, -6.45962e+02, 3.91500e+02), forces1[314], tol);
ASSERT_EQUAL_VEC(Vec3(-3.71535e+02, -4.54035e+01, 5.02855e+02), forces1[315], tol); ASSERT_EQUAL_VEC(Vec3(-3.71539e+02, -4.53999e+01, 5.02838e+02), forces1[315], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52582e+02, 8.61156e+01, 2.63790e+02), forces1[316], tol); ASSERT_EQUAL_VEC(Vec3(-3.52594e+02, 8.61216e+01, 2.63794e+02), forces1[316], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18315e+01, -1.24905e+02, -2.32017e+02), forces1[317], tol); ASSERT_EQUAL_VEC(Vec3( 2.18403e+01, -1.24903e+02, -2.32014e+02), forces1[317], tol);
ASSERT_EQUAL_VEC(Vec3(-4.28773e+02, 2.69289e+02, -1.63284e+02), forces1[318], tol); ASSERT_EQUAL_VEC(Vec3(-4.28776e+02, 2.69290e+02, -1.63292e+02), forces1[318], tol);
ASSERT_EQUAL_VEC(Vec3( 6.90347e+01, 2.01140e+02, -1.25402e+02), forces1[319], tol); ASSERT_EQUAL_VEC(Vec3( 6.90376e+01, 2.01126e+02, -1.25394e+02), forces1[319], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43131e+01, -1.48475e+02, 9.25874e+01), forces1[320], tol); ASSERT_EQUAL_VEC(Vec3( 4.43084e+01, -1.48482e+02, 9.25935e+01), forces1[320], tol);
ASSERT_EQUAL_VEC(Vec3(-3.53033e+01, 1.28681e+02, -3.63350e+02), forces1[321], tol); ASSERT_EQUAL_VEC(Vec3(-3.53044e+01, 1.28686e+02, -3.63353e+02), forces1[321], tol);
ASSERT_EQUAL_VEC(Vec3(-5.24116e+02, -9.42920e+01, 1.18433e+01), forces1[322], tol); ASSERT_EQUAL_VEC(Vec3(-5.24106e+02, -9.42773e+01, 1.18349e+01), forces1[322], tol);
ASSERT_EQUAL_VEC(Vec3( 2.26138e+02, 3.21631e+02, -3.90518e+02), forces1[323], tol); ASSERT_EQUAL_VEC(Vec3( 2.26116e+02, 3.21645e+02, -3.90520e+02), forces1[323], tol);
ASSERT_EQUAL_VEC(Vec3( 3.59466e+01, -3.07420e+02, -5.38383e+01), forces1[324], tol); ASSERT_EQUAL_VEC(Vec3( 3.59470e+01, -3.07422e+02, -5.38345e+01), forces1[324], tol);
ASSERT_EQUAL_VEC(Vec3(-1.17161e+02, 2.29592e+02, 1.57262e+02), forces1[325], tol); ASSERT_EQUAL_VEC(Vec3(-1.17162e+02, 2.29578e+02, 1.57257e+02), forces1[325], tol);
ASSERT_EQUAL_VEC(Vec3(-9.86435e+01, -2.13508e+02, 9.34894e+01), forces1[326], tol); ASSERT_EQUAL_VEC(Vec3(-9.86447e+01, -2.13510e+02, 9.34945e+01), forces1[326], tol);
ASSERT_EQUAL_VEC(Vec3( 2.32254e+02, 6.06751e+01, -3.57489e+02), forces1[327], tol); ASSERT_EQUAL_VEC(Vec3( 2.32239e+02, 6.06792e+01, -3.57488e+02), forces1[327], tol);
ASSERT_EQUAL_VEC(Vec3(-4.16067e+01, 1.12535e+02, -2.00681e+02), forces1[328], tol); ASSERT_EQUAL_VEC(Vec3(-4.16208e+01, 1.12534e+02, -2.00673e+02), forces1[328], tol);
ASSERT_EQUAL_VEC(Vec3(-5.14875e+01, 2.96274e+02, 3.68482e+02), forces1[329], tol); ASSERT_EQUAL_VEC(Vec3(-5.14797e+01, 2.96279e+02, 3.68486e+02), forces1[329], tol);
ASSERT_EQUAL_VEC(Vec3( 1.02090e+02, -9.70814e+01, 3.02440e+01), forces1[330], tol); ASSERT_EQUAL_VEC(Vec3( 1.02087e+02, -9.70760e+01, 3.02447e+01), forces1[330], tol);
ASSERT_EQUAL_VEC(Vec3(-1.03764e+02, -1.54759e+02, 2.10253e+02), forces1[331], tol); ASSERT_EQUAL_VEC(Vec3(-1.03773e+02, -1.54768e+02, 2.10252e+02), forces1[331], tol);
ASSERT_EQUAL_VEC(Vec3( 1.90535e+02, 6.04433e+01, -9.59246e+01), forces1[332], tol); ASSERT_EQUAL_VEC(Vec3( 1.90526e+02, 6.04195e+01, -9.59270e+01), forces1[332], tol);
ASSERT_EQUAL_VEC(Vec3(-1.16817e+02, -5.22825e+02, 5.66573e+02), forces1[333], tol); ASSERT_EQUAL_VEC(Vec3(-1.16808e+02, -5.22817e+02, 5.66574e+02), forces1[333], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18110e+02, -1.37430e+02, 1.53034e+02), forces1[334], tol); ASSERT_EQUAL_VEC(Vec3( 2.18109e+02, -1.37414e+02, 1.53024e+02), forces1[334], tol);
ASSERT_EQUAL_VEC(Vec3(-9.04337e+01, -1.47612e+02, 8.89517e+01), forces1[335], tol); ASSERT_EQUAL_VEC(Vec3(-9.04344e+01, -1.47623e+02, 8.89515e+01), forces1[335], tol);
ASSERT_EQUAL_VEC(Vec3( 2.10079e+01, -2.05506e+02, 1.26845e+02), forces1[336], tol); ASSERT_EQUAL_VEC(Vec3( 2.10214e+01, -2.05509e+02, 1.26834e+02), forces1[336], tol);
ASSERT_EQUAL_VEC(Vec3(-1.68064e+02, -2.97762e+02, -1.20742e+02), forces1[337], tol); ASSERT_EQUAL_VEC(Vec3(-1.68046e+02, -2.97773e+02, -1.20748e+02), forces1[337], tol);
ASSERT_EQUAL_VEC(Vec3( 3.99127e+02, 2.95149e+02, 3.91149e+02), forces1[338], tol); ASSERT_EQUAL_VEC(Vec3( 3.99130e+02, 2.95164e+02, 3.91133e+02), forces1[338], tol);
ASSERT_EQUAL_VEC(Vec3( 6.84896e+02, -2.36112e+02, 3.42242e+02), forces1[339], tol); ASSERT_EQUAL_VEC(Vec3( 6.84897e+02, -2.36112e+02, 3.42241e+02), forces1[339], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26656e+02, 1.75725e+02, 1.84794e+02), forces1[340], tol); ASSERT_EQUAL_VEC(Vec3(-1.26674e+02, 1.75741e+02, 1.84784e+02), forces1[340], tol);
ASSERT_EQUAL_VEC(Vec3(-1.32461e+01, 4.13666e+01, -7.24151e+01), forces1[341], tol); ASSERT_EQUAL_VEC(Vec3(-1.32552e+01, 4.13616e+01, -7.24209e+01), forces1[341], tol);
ASSERT_EQUAL_VEC(Vec3(-2.77912e+02, 3.10248e+02, 1.84737e+01), forces1[342], tol); ASSERT_EQUAL_VEC(Vec3(-2.77910e+02, 3.10252e+02, 1.84772e+01), forces1[342], tol);
ASSERT_EQUAL_VEC(Vec3( 1.17751e+02, 2.88275e+02, 2.83199e+02), forces1[343], tol); ASSERT_EQUAL_VEC(Vec3( 1.17751e+02, 2.88285e+02, 2.83196e+02), forces1[343], tol);
ASSERT_EQUAL_VEC(Vec3(-2.14449e+01, 5.21208e+02, 1.00228e+02), forces1[344], tol); ASSERT_EQUAL_VEC(Vec3(-2.14324e+01, 5.21203e+02, 1.00240e+02), forces1[344], tol);
ASSERT_EQUAL_VEC(Vec3( 1.24347e+02, -1.12342e+02, 2.11954e+02), forces1[345], tol); ASSERT_EQUAL_VEC(Vec3( 1.24356e+02, -1.12357e+02, 2.11950e+02), forces1[345], tol);
ASSERT_EQUAL_VEC(Vec3( 6.48042e+00, 2.20312e+02, -3.03858e+02), forces1[346], tol); ASSERT_EQUAL_VEC(Vec3( 6.49096e+00, 2.20316e+02, -3.03863e+02), forces1[346], tol);
ASSERT_EQUAL_VEC(Vec3( 3.27047e+02, 1.14355e+02, 4.53331e+02), forces1[347], tol); ASSERT_EQUAL_VEC(Vec3( 3.27054e+02, 1.14349e+02, 4.53346e+02), forces1[347], tol);
ASSERT_EQUAL_VEC(Vec3( 3.89316e+01, 3.55285e+02, 2.25454e+01), forces1[348], tol); ASSERT_EQUAL_VEC(Vec3( 3.89302e+01, 3.55284e+02, 2.25739e+01), forces1[348], tol);
ASSERT_EQUAL_VEC(Vec3(-2.25224e+02, -2.30563e+02, -2.32667e+02), forces1[349], tol); ASSERT_EQUAL_VEC(Vec3(-2.25217e+02, -2.30560e+02, -2.32663e+02), forces1[349], tol);
ASSERT_EQUAL_VEC(Vec3(-4.40568e+02, -4.18883e+01, -8.73114e+01), forces1[350], tol); ASSERT_EQUAL_VEC(Vec3(-4.40572e+02, -4.18868e+01, -8.73193e+01), forces1[350], tol);
ASSERT_EQUAL_VEC(Vec3( 2.03286e+02, -7.41888e+01, -3.11223e+02), forces1[351], tol); ASSERT_EQUAL_VEC(Vec3( 2.03285e+02, -7.41876e+01, -3.11213e+02), forces1[351], tol);
ASSERT_EQUAL_VEC(Vec3( 3.14064e+02, -4.51997e+01, 1.15688e+02), forces1[352], tol); ASSERT_EQUAL_VEC(Vec3( 3.14048e+02, -4.52169e+01, 1.15684e+02), forces1[352], tol);
ASSERT_EQUAL_VEC(Vec3(-3.05774e+02, -8.44103e+01, 2.77051e+02), forces1[353], tol); ASSERT_EQUAL_VEC(Vec3(-3.05766e+02, -8.44138e+01, 2.77051e+02), forces1[353], tol);
ASSERT_EQUAL_VEC(Vec3( 6.03151e+02, 7.49829e+01, 1.08091e+02), forces1[354], tol); ASSERT_EQUAL_VEC(Vec3( 6.03142e+02, 7.49854e+01, 1.08102e+02), forces1[354], tol);
ASSERT_EQUAL_VEC(Vec3( 1.19384e+02, 3.21994e+02, 1.19529e+01), forces1[355], tol); ASSERT_EQUAL_VEC(Vec3( 1.19382e+02, 3.21995e+02, 1.19502e+01), forces1[355], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06913e+02, 2.87632e+01, 2.37369e+02), forces1[356], tol); ASSERT_EQUAL_VEC(Vec3( 1.06924e+02, 2.87624e+01, 2.37383e+02), forces1[356], tol);
ASSERT_EQUAL_VEC(Vec3( 3.21446e+02, -7.92931e+02, 4.18567e+01), forces1[357], tol); ASSERT_EQUAL_VEC(Vec3( 3.21440e+02, -7.92932e+02, 4.18479e+01), forces1[357], tol);
ASSERT_EQUAL_VEC(Vec3(-1.08671e+02, 2.36705e+02, -5.75404e+02), forces1[358], tol); ASSERT_EQUAL_VEC(Vec3(-1.08675e+02, 2.36719e+02, -5.75404e+02), forces1[358], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53714e+02, -4.66572e+02, 3.71583e+02), forces1[359], tol); ASSERT_EQUAL_VEC(Vec3(-1.53731e+02, -4.66587e+02, 3.71577e+02), forces1[359], tol);
ASSERT_EQUAL_VEC(Vec3(-1.56284e+02, -8.97083e+01, -3.26306e+02), forces1[360], tol); ASSERT_EQUAL_VEC(Vec3(-1.56295e+02, -8.97020e+01, -3.26310e+02), forces1[360], tol);
ASSERT_EQUAL_VEC(Vec3( 3.42778e+02, -3.18189e+01, -4.08903e+02), forces1[361], tol); ASSERT_EQUAL_VEC(Vec3( 3.42777e+02, -3.18031e+01, -4.08905e+02), forces1[361], tol);
ASSERT_EQUAL_VEC(Vec3( 1.47612e+02, 4.76904e+02, 4.19492e+01), forces1[362], tol); ASSERT_EQUAL_VEC(Vec3( 1.47602e+02, 4.76918e+02, 4.19650e+01), forces1[362], tol);
ASSERT_EQUAL_VEC(Vec3( 6.22986e-01, -4.13612e+01, 4.39907e+02), forces1[363], tol); ASSERT_EQUAL_VEC(Vec3( 6.19970e-01, -4.13644e+01, 4.39906e+02), forces1[363], tol);
ASSERT_EQUAL_VEC(Vec3(-2.56829e+02, -1.83018e+02, 5.99959e+01), forces1[364], tol); ASSERT_EQUAL_VEC(Vec3(-2.56834e+02, -1.83029e+02, 5.99876e+01), forces1[364], tol);
ASSERT_EQUAL_VEC(Vec3( 2.48249e+02, 5.50097e+01, -1.54845e+01), forces1[365], tol); ASSERT_EQUAL_VEC(Vec3( 2.48250e+02, 5.50128e+01, -1.55098e+01), forces1[365], tol);
ASSERT_EQUAL_VEC(Vec3(-1.93624e+02, -1.86418e+01, 5.84869e-01), forces1[366], tol); ASSERT_EQUAL_VEC(Vec3(-1.93630e+02, -1.86414e+01, 6.10783e-01), forces1[366], tol);
ASSERT_EQUAL_VEC(Vec3(-1.63219e+02, 1.90015e+02, -4.93440e+02), forces1[367], tol); ASSERT_EQUAL_VEC(Vec3(-1.63225e+02, 1.90017e+02, -4.93447e+02), forces1[367], tol);
ASSERT_EQUAL_VEC(Vec3(-2.85270e+01, -4.66023e+02, -2.10837e+02), forces1[368], tol); ASSERT_EQUAL_VEC(Vec3(-2.85285e+01, -4.66015e+02, -2.10844e+02), forces1[368], tol);
ASSERT_EQUAL_VEC(Vec3( 2.27175e+02, 1.52564e+01, -1.64048e+02), forces1[369], tol); ASSERT_EQUAL_VEC(Vec3( 2.27175e+02, 1.52519e+01, -1.64037e+02), forces1[369], tol);
ASSERT_EQUAL_VEC(Vec3(-1.07167e+02, 2.01385e+01, 6.04964e+01), forces1[370], tol); ASSERT_EQUAL_VEC(Vec3(-1.07158e+02, 2.01372e+01, 6.04946e+01), forces1[370], tol);
ASSERT_EQUAL_VEC(Vec3( 2.41287e+02, 4.05686e+02, -8.71432e+01), forces1[371], tol); ASSERT_EQUAL_VEC(Vec3( 2.41288e+02, 4.05688e+02, -8.71414e+01), forces1[371], tol);
ASSERT_EQUAL_VEC(Vec3( 1.33812e+02, 1.72167e+02, -1.15344e+02), forces1[372], tol); ASSERT_EQUAL_VEC(Vec3( 1.33810e+02, 1.72165e+02, -1.15347e+02), forces1[372], tol);
ASSERT_EQUAL_VEC(Vec3( 4.19302e+02, -4.68238e+02, -3.30508e+02), forces1[373], tol); ASSERT_EQUAL_VEC(Vec3( 4.19305e+02, -4.68244e+02, -3.30524e+02), forces1[373], tol);
ASSERT_EQUAL_VEC(Vec3(-1.88009e+02, -2.43509e+02, 8.86871e+01), forces1[374], tol); ASSERT_EQUAL_VEC(Vec3(-1.88000e+02, -2.43516e+02, 8.87125e+01), forces1[374], tol);
ASSERT_EQUAL_VEC(Vec3( 1.54022e+02, 2.52336e+02, 1.76379e+02), forces1[375], tol); ASSERT_EQUAL_VEC(Vec3( 1.54008e+02, 2.52337e+02, 1.76385e+02), forces1[375], tol);
ASSERT_EQUAL_VEC(Vec3(-1.10640e+02, 3.33202e+01, 1.23748e+02), forces1[376], tol); ASSERT_EQUAL_VEC(Vec3(-1.10634e+02, 3.33134e+01, 1.23764e+02), forces1[376], tol);
ASSERT_EQUAL_VEC(Vec3( 1.64797e+02, 8.94314e-01, 1.56186e+02), forces1[377], tol); ASSERT_EQUAL_VEC(Vec3( 1.64797e+02, 8.89785e-01, 1.56187e+02), forces1[377], tol);
ASSERT_EQUAL_VEC(Vec3(-1.65388e+02, -1.50250e+02, 2.41783e+02), forces1[378], tol); ASSERT_EQUAL_VEC(Vec3(-1.65397e+02, -1.50246e+02, 2.41784e+02), forces1[378], tol);
ASSERT_EQUAL_VEC(Vec3( 4.78079e+02, -2.36414e+02, 4.04911e+02), forces1[379], tol); ASSERT_EQUAL_VEC(Vec3( 4.78079e+02, -2.36417e+02, 4.04919e+02), forces1[379], tol);
ASSERT_EQUAL_VEC(Vec3(-2.33378e+02, -7.47049e+02, 1.09739e+02), forces1[380], tol); ASSERT_EQUAL_VEC(Vec3(-2.33373e+02, -7.47052e+02, 1.09725e+02), forces1[380], tol);
ASSERT_EQUAL_VEC(Vec3( 1.09366e+02, -3.37530e+02, 1.99870e+02), forces1[381], tol); ASSERT_EQUAL_VEC(Vec3( 1.09374e+02, -3.37524e+02, 1.99891e+02), forces1[381], tol);
ASSERT_EQUAL_VEC(Vec3( 1.45361e+02, 1.34680e+02, 3.46388e+02), forces1[382], tol); ASSERT_EQUAL_VEC(Vec3( 1.45367e+02, 1.34685e+02, 3.46407e+02), forces1[382], tol);
ASSERT_EQUAL_VEC(Vec3(-8.86934e+01, 1.70747e+02, 1.86646e+02), forces1[383], tol); ASSERT_EQUAL_VEC(Vec3(-8.86795e+01, 1.70743e+02, 1.86635e+02), forces1[383], tol);
ASSERT_EQUAL_VEC(Vec3( 1.03277e+02, -2.54979e+02, -2.04453e+01), forces1[384], tol); ASSERT_EQUAL_VEC(Vec3( 1.03271e+02, -2.54982e+02, -2.04505e+01), forces1[384], tol);
ASSERT_EQUAL_VEC(Vec3(-5.06129e+02, -3.72064e+02, 9.10688e+01), forces1[385], tol); ASSERT_EQUAL_VEC(Vec3(-5.06120e+02, -3.72063e+02, 9.10667e+01), forces1[385], tol);
ASSERT_EQUAL_VEC(Vec3( 4.33826e+02, 5.30918e+02, 1.18193e+02), forces1[386], tol); ASSERT_EQUAL_VEC(Vec3( 4.33821e+02, 5.30907e+02, 1.18197e+02), forces1[386], tol);
ASSERT_EQUAL_VEC(Vec3(-3.34800e+02, 2.29896e+02, 1.73583e+02), forces1[387], tol); ASSERT_EQUAL_VEC(Vec3(-3.34808e+02, 2.29883e+02, 1.73589e+02), forces1[387], tol);
ASSERT_EQUAL_VEC(Vec3(-3.28841e+00, 3.50940e+02, -5.66607e+00), forces1[388], tol); ASSERT_EQUAL_VEC(Vec3(-3.27223e+00, 3.50940e+02, -5.66750e+00), forces1[388], tol);
ASSERT_EQUAL_VEC(Vec3(-3.18245e+02, -4.16006e+02, 3.91666e+00), forces1[389], tol); ASSERT_EQUAL_VEC(Vec3(-3.18249e+02, -4.16016e+02, 3.93821e+00), forces1[389], tol);
ASSERT_EQUAL_VEC(Vec3(-9.01756e+01, -2.83155e+02, -1.78630e+02), forces1[390], tol); ASSERT_EQUAL_VEC(Vec3(-9.01726e+01, -2.83141e+02, -1.78609e+02), forces1[390], tol);
ASSERT_EQUAL_VEC(Vec3(-1.86953e+02, 2.96524e+02, -1.29660e+02), forces1[391], tol); ASSERT_EQUAL_VEC(Vec3(-1.86960e+02, 2.96534e+02, -1.29666e+02), forces1[391], tol);
ASSERT_EQUAL_VEC(Vec3(-7.78130e+02, 3.37762e+02, 2.46216e+02), forces1[392], tol); ASSERT_EQUAL_VEC(Vec3(-7.78140e+02, 3.37747e+02, 2.46235e+02), forces1[392], tol);
ASSERT_EQUAL_VEC(Vec3(-4.88282e+02, -3.62820e+02, 1.09216e+02), forces1[393], tol); ASSERT_EQUAL_VEC(Vec3(-4.88292e+02, -3.62809e+02, 1.09196e+02), forces1[393], tol);
ASSERT_EQUAL_VEC(Vec3( 1.68825e+02, -1.54064e+02, 2.44125e+02), forces1[394], tol); ASSERT_EQUAL_VEC(Vec3( 1.68815e+02, -1.54070e+02, 2.44122e+02), forces1[394], tol);
ASSERT_EQUAL_VEC(Vec3( 8.59758e+01, -4.73413e+02, 1.81312e+02), forces1[395], tol); ASSERT_EQUAL_VEC(Vec3( 8.59883e+01, -4.73417e+02, 1.81318e+02), forces1[395], tol);
ASSERT_EQUAL_VEC(Vec3(-5.15344e+01, 3.80584e+01, 1.48509e+02), forces1[396], tol); ASSERT_EQUAL_VEC(Vec3(-5.15453e+01, 3.80575e+01, 1.48501e+02), forces1[396], tol);
ASSERT_EQUAL_VEC(Vec3( 4.40884e+02, -9.36690e+01, 2.19945e+02), forces1[397], tol); ASSERT_EQUAL_VEC(Vec3( 4.40890e+02, -9.36667e+01, 2.19946e+02), forces1[397], tol);
ASSERT_EQUAL_VEC(Vec3( 4.56084e+01, 5.74617e+02, -5.74982e+01), forces1[398], tol); ASSERT_EQUAL_VEC(Vec3( 4.55989e+01, 5.74616e+02, -5.74981e+01), forces1[398], tol);
ASSERT_EQUAL_VEC(Vec3( 1.07778e+02, -3.19747e+02, 1.16089e+01), forces1[399], tol); ASSERT_EQUAL_VEC(Vec3( 1.07793e+02, -3.19752e+02, 1.16186e+01), forces1[399], tol);
ASSERT_EQUAL_VEC(Vec3(-1.73808e+02, -1.72675e+02, 3.26154e+02), forces1[400], tol); ASSERT_EQUAL_VEC(Vec3(-1.73817e+02, -1.72672e+02, 3.26164e+02), forces1[400], tol);
ASSERT_EQUAL_VEC(Vec3(-4.48596e+02, -4.95423e+02, -1.37764e+02), forces1[401], tol); ASSERT_EQUAL_VEC(Vec3(-4.48594e+02, -4.95425e+02, -1.37767e+02), forces1[401], tol);
ASSERT_EQUAL_VEC(Vec3( 1.43492e+02, -7.71805e+01, 1.27158e+02), forces1[402], tol); ASSERT_EQUAL_VEC(Vec3( 1.43480e+02, -7.71741e+01, 1.27160e+02), forces1[402], tol);
ASSERT_EQUAL_VEC(Vec3( 1.26035e+02, -3.81387e+02, -2.85763e+02), forces1[403], tol); ASSERT_EQUAL_VEC(Vec3( 1.26017e+02, -3.81397e+02, -2.85760e+02), forces1[403], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53029e+02, -2.67890e+02, 1.51837e+02), forces1[404], tol); ASSERT_EQUAL_VEC(Vec3(-2.53035e+02, -2.67890e+02, 1.51840e+02), forces1[404], tol);
ASSERT_EQUAL_VEC(Vec3(-1.01054e+02, -1.79826e+02, -2.05761e+02), forces1[405], tol); ASSERT_EQUAL_VEC(Vec3(-1.01060e+02, -1.79828e+02, -2.05754e+02), forces1[405], tol);
ASSERT_EQUAL_VEC(Vec3( 1.32069e+02, -2.57007e+02, -4.06096e+02), forces1[406], tol); ASSERT_EQUAL_VEC(Vec3( 1.32075e+02, -2.56994e+02, -4.06095e+02), forces1[406], tol);
ASSERT_EQUAL_VEC(Vec3( 5.49930e+01, 5.20979e+01, -2.40870e+01), forces1[407], tol); ASSERT_EQUAL_VEC(Vec3( 5.49913e+01, 5.21043e+01, -2.40692e+01), forces1[407], tol);
ASSERT_EQUAL_VEC(Vec3(-3.04259e+01, -3.45368e+02, 3.52722e+02), forces1[408], tol); ASSERT_EQUAL_VEC(Vec3(-3.04198e+01, -3.45366e+02, 3.52724e+02), forces1[408], tol);
ASSERT_EQUAL_VEC(Vec3( 5.76195e+02, 2.51431e+02, -2.05663e+02), forces1[409], tol); ASSERT_EQUAL_VEC(Vec3( 5.76204e+02, 2.51419e+02, -2.05669e+02), forces1[409], tol);
ASSERT_EQUAL_VEC(Vec3(-5.46267e+02, -3.81551e+01, 1.55945e+02), forces1[410], tol); ASSERT_EQUAL_VEC(Vec3(-5.46249e+02, -3.81508e+01, 1.55947e+02), forces1[410], tol);
ASSERT_EQUAL_VEC(Vec3(-1.00736e+02, 2.13300e+02, 3.33091e+02), forces1[411], tol); ASSERT_EQUAL_VEC(Vec3(-1.00739e+02, 2.13319e+02, 3.33076e+02), forces1[411], tol);
ASSERT_EQUAL_VEC(Vec3( 8.00417e+01, 1.85324e+02, -4.43382e+02), forces1[412], tol); ASSERT_EQUAL_VEC(Vec3( 8.00363e+01, 1.85321e+02, -4.43381e+02), forces1[412], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53976e+02, 1.76327e+01, 5.07014e+01), forces1[413], tol); ASSERT_EQUAL_VEC(Vec3(-1.53965e+02, 1.76341e+01, 5.07046e+01), forces1[413], tol);
ASSERT_EQUAL_VEC(Vec3(-2.54163e+01, -1.01739e+02, -1.47121e+02), forces1[414], tol); ASSERT_EQUAL_VEC(Vec3(-2.54115e+01, -1.01737e+02, -1.47105e+02), forces1[414], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53036e+02, 2.89732e+02, -1.78279e+02), forces1[415], tol); ASSERT_EQUAL_VEC(Vec3(-2.53030e+02, 2.89729e+02, -1.78282e+02), forces1[415], tol);
ASSERT_EQUAL_VEC(Vec3(-1.30259e+02, -4.66595e+02, -3.53360e+02), forces1[416], tol); ASSERT_EQUAL_VEC(Vec3(-1.30262e+02, -4.66600e+02, -3.53368e+02), forces1[416], tol);
ASSERT_EQUAL_VEC(Vec3( 1.82471e+02, 3.77991e+02, 1.90490e+02), forces1[417], tol); ASSERT_EQUAL_VEC(Vec3( 1.82473e+02, 3.77989e+02, 1.90480e+02), forces1[417], tol);
ASSERT_EQUAL_VEC(Vec3(-2.59804e+02, 3.29719e+02, 3.93440e+02), forces1[418], tol); ASSERT_EQUAL_VEC(Vec3(-2.59797e+02, 3.29719e+02, 3.93445e+02), forces1[418], tol);
ASSERT_EQUAL_VEC(Vec3(-1.08487e+01, -5.30930e+02, -1.53260e+01), forces1[419], tol); ASSERT_EQUAL_VEC(Vec3(-1.08424e+01, -5.30928e+02, -1.53190e+01), forces1[419], tol);
ASSERT_EQUAL_VEC(Vec3(-3.27721e+01, -3.45915e+02, -1.45599e+02), forces1[420], tol); ASSERT_EQUAL_VEC(Vec3(-3.27758e+01, -3.45905e+02, -1.45609e+02), forces1[420], tol);
ASSERT_EQUAL_VEC(Vec3(-1.92426e+02, 3.69961e+00, -1.26534e+02), forces1[421], tol); ASSERT_EQUAL_VEC(Vec3(-1.92427e+02, 3.70108e+00, -1.26539e+02), forces1[421], tol);
ASSERT_EQUAL_VEC(Vec3( 2.61443e+02, -1.63240e+02, -1.22703e+02), forces1[422], tol); ASSERT_EQUAL_VEC(Vec3( 2.61433e+02, -1.63237e+02, -1.22721e+02), forces1[422], tol);
ASSERT_EQUAL_VEC(Vec3(-1.42886e+02, 4.15427e+02, 5.04215e+02), forces1[423], tol); ASSERT_EQUAL_VEC(Vec3(-1.42907e+02, 4.15425e+02, 5.04223e+02), forces1[423], tol);
ASSERT_EQUAL_VEC(Vec3( 3.36581e+02, -1.06050e+02, 4.54204e+02), forces1[424], tol); ASSERT_EQUAL_VEC(Vec3( 3.36579e+02, -1.06048e+02, 4.54179e+02), forces1[424], tol);
ASSERT_EQUAL_VEC(Vec3(-2.32220e+02, -1.85597e+00, 4.48454e+01), forces1[425], tol); ASSERT_EQUAL_VEC(Vec3(-2.32219e+02, -1.84431e+00, 4.48455e+01), forces1[425], tol);
ASSERT_EQUAL_VEC(Vec3( 4.12395e+02, -5.04694e+02, 4.00891e+02), forces1[426], tol); ASSERT_EQUAL_VEC(Vec3( 4.12408e+02, -5.04695e+02, 4.00897e+02), forces1[426], tol);
ASSERT_EQUAL_VEC(Vec3(-1.54645e+02, -2.68561e+02, -1.52928e+01), forces1[427], tol); ASSERT_EQUAL_VEC(Vec3(-1.54644e+02, -2.68563e+02, -1.53010e+01), forces1[427], tol);
ASSERT_EQUAL_VEC(Vec3( 2.69730e+02, 2.18576e+02, -1.75360e+02), forces1[428], tol); ASSERT_EQUAL_VEC(Vec3( 2.69725e+02, 2.18578e+02, -1.75382e+02), forces1[428], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77263e+01, -4.66471e+01, 6.24232e+01), forces1[429], tol); ASSERT_EQUAL_VEC(Vec3(-1.77257e+01, -4.66563e+01, 6.24304e+01), forces1[429], tol);
ASSERT_EQUAL_VEC(Vec3(-1.29891e+02, 8.07579e+01, 1.84769e+01), forces1[430], tol); ASSERT_EQUAL_VEC(Vec3(-1.29886e+02, 8.07543e+01, 1.84899e+01), forces1[430], tol);
ASSERT_EQUAL_VEC(Vec3( 1.76186e+02, -3.20026e+02, -2.47771e+02), forces1[431], tol); ASSERT_EQUAL_VEC(Vec3( 1.76179e+02, -3.20023e+02, -2.47777e+02), forces1[431], tol);
ASSERT_EQUAL_VEC(Vec3(-1.68167e+02, 2.05774e+02, -1.17403e+02), forces1[432], tol); ASSERT_EQUAL_VEC(Vec3(-1.68173e+02, 2.05763e+02, -1.17388e+02), forces1[432], tol);
ASSERT_EQUAL_VEC(Vec3(-1.93375e+02, 7.76848e+01, -1.60929e+02), forces1[433], tol); ASSERT_EQUAL_VEC(Vec3(-1.93371e+02, 7.76884e+01, -1.60936e+02), forces1[433], tol);
ASSERT_EQUAL_VEC(Vec3(-8.97858e+01, 2.56575e+02, -3.94696e+02), forces1[434], tol); ASSERT_EQUAL_VEC(Vec3(-8.97869e+01, 2.56574e+02, -3.94708e+02), forces1[434], tol);
ASSERT_EQUAL_VEC(Vec3(-2.33044e+02, 9.53268e+01, 3.03013e+02), forces1[435], tol); ASSERT_EQUAL_VEC(Vec3(-2.33025e+02, 9.53235e+01, 3.02990e+02), forces1[435], tol);
ASSERT_EQUAL_VEC(Vec3( 4.34435e+01, -4.44338e+02, -5.01049e+00), forces1[436], tol); ASSERT_EQUAL_VEC(Vec3( 4.34327e+01, -4.44348e+02, -5.00356e+00), forces1[436], tol);
ASSERT_EQUAL_VEC(Vec3( 3.32046e+02, -4.10867e+02, -6.13749e+01), forces1[437], tol); ASSERT_EQUAL_VEC(Vec3( 3.32045e+02, -4.10887e+02, -6.13802e+01), forces1[437], tol);
ASSERT_EQUAL_VEC(Vec3(-1.45940e+02, -2.28294e+02, -2.99014e+02), forces1[438], tol); ASSERT_EQUAL_VEC(Vec3(-1.45947e+02, -2.28307e+02, -2.99015e+02), forces1[438], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38552e+02, -1.27390e+02, -2.93871e+02), forces1[439], tol); ASSERT_EQUAL_VEC(Vec3(-1.38554e+02, -1.27402e+02, -2.93859e+02), forces1[439], tol);
ASSERT_EQUAL_VEC(Vec3( 2.97411e+02, 3.38268e+02, -2.14820e+02), forces1[440], tol); ASSERT_EQUAL_VEC(Vec3( 2.97418e+02, 3.38266e+02, -2.14828e+02), forces1[440], tol);
ASSERT_EQUAL_VEC(Vec3( 2.49387e+01, 1.88456e+02, -8.02910e+01), forces1[441], tol); ASSERT_EQUAL_VEC(Vec3( 2.49417e+01, 1.88462e+02, -8.02993e+01), forces1[441], tol);
ASSERT_EQUAL_VEC(Vec3(-1.32439e+02, -3.86546e+02, -6.69915e+01), forces1[442], tol); ASSERT_EQUAL_VEC(Vec3(-1.32440e+02, -3.86535e+02, -6.70018e+01), forces1[442], tol);
ASSERT_EQUAL_VEC(Vec3( 1.84528e+01, 2.24810e+02, -1.36948e+02), forces1[443], tol); ASSERT_EQUAL_VEC(Vec3( 1.84581e+01, 2.24810e+02, -1.36951e+02), forces1[443], tol);
ASSERT_EQUAL_VEC(Vec3( 2.15322e+02, 1.06098e+02, -1.25724e+02), forces1[444], tol); ASSERT_EQUAL_VEC(Vec3( 2.15314e+02, 1.06097e+02, -1.25729e+02), forces1[444], tol);
ASSERT_EQUAL_VEC(Vec3( 3.07801e+02, 4.34360e+02, 2.17212e+01), forces1[445], tol); ASSERT_EQUAL_VEC(Vec3( 3.07808e+02, 4.34344e+02, 2.17287e+01), forces1[445], tol);
ASSERT_EQUAL_VEC(Vec3( 8.09101e+00, 4.99796e+01, -3.14223e+02), forces1[446], tol); ASSERT_EQUAL_VEC(Vec3( 8.08473e+00, 4.99811e+01, -3.14217e+02), forces1[446], tol);
ASSERT_EQUAL_VEC(Vec3( 1.36945e+03, 6.44819e+02, -3.85093e+02), forces1[447], tol); ASSERT_EQUAL_VEC(Vec3( 1.36944e+03, 6.44821e+02, -3.85099e+02), forces1[447], tol);
ASSERT_EQUAL_VEC(Vec3( 3.32213e+02, -1.04224e+02, -4.08593e+02), forces1[448], tol); ASSERT_EQUAL_VEC(Vec3( 3.32220e+02, -1.04207e+02, -4.08594e+02), forces1[448], tol);
ASSERT_EQUAL_VEC(Vec3( 3.73255e+02, 2.70956e+02, 3.80718e+02), forces1[449], tol); ASSERT_EQUAL_VEC(Vec3( 3.73256e+02, 2.70963e+02, 3.80703e+02), forces1[449], tol);
ASSERT_EQUAL_VEC(Vec3(-2.09791e+02, 4.29903e+02, 8.40856e+02), forces1[450], tol); ASSERT_EQUAL_VEC(Vec3(-2.09802e+02, 4.29907e+02, 8.40858e+02), forces1[450], tol);
ASSERT_EQUAL_VEC(Vec3(-3.48553e+02, -3.63118e+02, 5.10375e+02), forces1[451], tol); ASSERT_EQUAL_VEC(Vec3(-3.48550e+02, -3.63122e+02, 5.10367e+02), forces1[451], tol);
ASSERT_EQUAL_VEC(Vec3(-3.29125e+00, 4.48284e-01, -6.03690e+00), forces1[452], tol); ASSERT_EQUAL_VEC(Vec3(-3.29139e+00, 4.63314e-01, -6.04797e+00), forces1[452], tol);
ASSERT_EQUAL_VEC(Vec3( 3.83263e+01, 3.59809e+02, 8.67058e+02), forces1[453], tol); ASSERT_EQUAL_VEC(Vec3( 3.83320e+01, 3.59803e+02, 8.67059e+02), forces1[453], tol);
ASSERT_EQUAL_VEC(Vec3(-1.57381e+02, 5.68728e+02, -1.87739e+02), forces1[454], tol); ASSERT_EQUAL_VEC(Vec3(-1.57402e+02, 5.68721e+02, -1.87722e+02), forces1[454], tol);
ASSERT_EQUAL_VEC(Vec3( 4.16138e+02, 5.82985e+01, -5.75704e+02), forces1[455], tol); ASSERT_EQUAL_VEC(Vec3( 4.16157e+02, 5.83052e+01, -5.75714e+02), forces1[455], tol);
ASSERT_EQUAL_VEC(Vec3( 2.58778e+02, -1.00684e+02, -4.43416e+02), forces1[456], tol); ASSERT_EQUAL_VEC(Vec3( 2.58777e+02, -1.00684e+02, -4.43414e+02), forces1[456], tol);
ASSERT_EQUAL_VEC(Vec3( 1.38957e+02, 4.93475e+02, 9.06770e+02), forces1[457], tol); ASSERT_EQUAL_VEC(Vec3( 1.38944e+02, 4.93487e+02, 9.06788e+02), forces1[457], tol);
ASSERT_EQUAL_VEC(Vec3(-4.81083e+01, 9.53319e+02, -1.83917e+02), forces1[458], tol); ASSERT_EQUAL_VEC(Vec3(-4.81206e+01, 9.53313e+02, -1.83923e+02), forces1[458], tol);
ASSERT_EQUAL_VEC(Vec3( 6.64518e+02, -3.77338e+02, 1.93101e+02), forces1[459], tol); ASSERT_EQUAL_VEC(Vec3( 6.64525e+02, -3.77318e+02, 1.93095e+02), forces1[459], tol);
ASSERT_EQUAL_VEC(Vec3( 8.34297e+01, 1.77792e+02, 4.70680e+02), forces1[460], tol); ASSERT_EQUAL_VEC(Vec3( 8.34571e+01, 1.77786e+02, 4.70682e+02), forces1[460], tol);
ASSERT_EQUAL_VEC(Vec3( 9.98941e+02, -3.98571e+02, 9.83607e+02), forces1[461], tol); ASSERT_EQUAL_VEC(Vec3( 9.98937e+02, -3.98574e+02, 9.83608e+02), forces1[461], tol);
ASSERT_EQUAL_VEC(Vec3(-5.06606e+02, -4.10873e+01, 4.75187e+02), forces1[462], tol); ASSERT_EQUAL_VEC(Vec3(-5.06594e+02, -4.10896e+01, 4.75194e+02), forces1[462], tol);
ASSERT_EQUAL_VEC(Vec3(-7.58415e+01, 1.45218e+02, 4.53046e+01), forces1[463], tol); ASSERT_EQUAL_VEC(Vec3(-7.58517e+01, 1.45227e+02, 4.52920e+01), forces1[463], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13510e+02, 5.29904e+02, -3.00926e+02), forces1[464], tol); ASSERT_EQUAL_VEC(Vec3(-1.13510e+02, 5.29893e+02, -3.00930e+02), forces1[464], tol);
ASSERT_EQUAL_VEC(Vec3(-1.46459e+02, -3.86621e+02, -6.42408e+02), forces1[465], tol); ASSERT_EQUAL_VEC(Vec3(-1.46460e+02, -3.86625e+02, -6.42393e+02), forces1[465], tol);
ASSERT_EQUAL_VEC(Vec3(-2.70162e+02, 3.67185e+02, -1.78818e+02), forces1[466], tol); ASSERT_EQUAL_VEC(Vec3(-2.70142e+02, 3.67184e+02, -1.78825e+02), forces1[466], tol);
ASSERT_EQUAL_VEC(Vec3(-1.23814e+02, -1.77343e+02, 2.37355e+02), forces1[467], tol); ASSERT_EQUAL_VEC(Vec3(-1.23818e+02, -1.77327e+02, 2.37348e+02), forces1[467], tol);
ASSERT_EQUAL_VEC(Vec3(-4.94037e+02, 1.34885e+02, 6.98783e+02), forces1[468], tol); ASSERT_EQUAL_VEC(Vec3(-4.94038e+02, 1.34882e+02, 6.98769e+02), forces1[468], tol);
ASSERT_EQUAL_VEC(Vec3( 7.08739e+02, 1.85249e+02, 5.51147e+02), forces1[469], tol); ASSERT_EQUAL_VEC(Vec3( 7.08753e+02, 1.85253e+02, 5.51151e+02), forces1[469], tol);
ASSERT_EQUAL_VEC(Vec3( 2.01265e+02, -5.84706e+02, 5.82922e+02), forces1[470], tol); ASSERT_EQUAL_VEC(Vec3( 2.01280e+02, -5.84706e+02, 5.82923e+02), forces1[470], tol);
ASSERT_EQUAL_VEC(Vec3( 5.29638e+02, 4.06832e+01, 9.99134e+01), forces1[471], tol); ASSERT_EQUAL_VEC(Vec3( 5.29637e+02, 4.06934e+01, 9.99138e+01), forces1[471], tol);
ASSERT_EQUAL_VEC(Vec3(-1.19723e+02, 4.42970e+02, -2.70470e+02), forces1[472], tol); ASSERT_EQUAL_VEC(Vec3(-1.19702e+02, 4.42978e+02, -2.70454e+02), forces1[472], tol);
ASSERT_EQUAL_VEC(Vec3(-6.87768e+02, -1.32228e+02, -7.35550e+01), forces1[473], tol); ASSERT_EQUAL_VEC(Vec3(-6.87792e+02, -1.32245e+02, -7.35776e+01), forces1[473], tol);
ASSERT_EQUAL_VEC(Vec3(-2.99633e+02, 8.14628e+02, 2.72140e+01), forces1[474], tol); ASSERT_EQUAL_VEC(Vec3(-2.99619e+02, 8.14627e+02, 2.72106e+01), forces1[474], tol);
ASSERT_EQUAL_VEC(Vec3(-2.26052e+02, -3.49830e+02, -2.73654e+02), forces1[475], tol); ASSERT_EQUAL_VEC(Vec3(-2.26041e+02, -3.49841e+02, -2.73664e+02), forces1[475], tol);
ASSERT_EQUAL_VEC(Vec3(-3.38849e+02, 8.74208e+02, 2.98578e+02), forces1[476], tol); ASSERT_EQUAL_VEC(Vec3(-3.38853e+02, 8.74214e+02, 2.98569e+02), forces1[476], tol);
ASSERT_EQUAL_VEC(Vec3( 5.63034e+02, 1.51171e+02, -1.10343e+02), forces1[477], tol); ASSERT_EQUAL_VEC(Vec3( 5.63040e+02, 1.51174e+02, -1.10341e+02), forces1[477], tol);
ASSERT_EQUAL_VEC(Vec3( 3.44151e+02, 2.73271e+02, 5.44557e+02), forces1[478], tol); ASSERT_EQUAL_VEC(Vec3( 3.44129e+02, 2.73283e+02, 5.44564e+02), forces1[478], tol);
ASSERT_EQUAL_VEC(Vec3( 3.29030e+01, 3.66771e+02, 3.30307e+02), forces1[479], tol); ASSERT_EQUAL_VEC(Vec3( 3.29047e+01, 3.66771e+02, 3.30305e+02), forces1[479], tol);
ASSERT_EQUAL_VEC(Vec3(-4.97818e+01, -3.26338e+02, -6.47518e+02), forces1[480], tol); ASSERT_EQUAL_VEC(Vec3(-4.97987e+01, -3.26340e+02, -6.47519e+02), forces1[480], tol);
ASSERT_EQUAL_VEC(Vec3( 6.05951e+01, -1.41011e+02, 4.05562e+02), forces1[481], tol); ASSERT_EQUAL_VEC(Vec3( 6.05980e+01, -1.41021e+02, 4.05550e+02), forces1[481], tol);
ASSERT_EQUAL_VEC(Vec3(-1.35194e+03, 5.06588e+01, -1.40082e+02), forces1[482], tol); ASSERT_EQUAL_VEC(Vec3(-1.35193e+03, 5.06460e+01, -1.40089e+02), forces1[482], tol);
ASSERT_EQUAL_VEC(Vec3( 7.70231e+01, -2.68990e+02, -1.75045e+02), forces1[483], tol); ASSERT_EQUAL_VEC(Vec3( 7.69975e+01, -2.68983e+02, -1.75054e+02), forces1[483], tol);
ASSERT_EQUAL_VEC(Vec3(-1.89530e+02, -2.32958e+02, -2.54877e+02), forces1[484], tol); ASSERT_EQUAL_VEC(Vec3(-1.89530e+02, -2.32958e+02, -2.54876e+02), forces1[484], tol);
ASSERT_EQUAL_VEC(Vec3( 2.37143e+02, 6.49185e+02, 1.01762e+02), forces1[485], tol); ASSERT_EQUAL_VEC(Vec3( 2.37140e+02, 6.49184e+02, 1.01759e+02), forces1[485], tol);
ASSERT_EQUAL_VEC(Vec3(-3.38575e+02, 1.34691e+02, 7.89809e+02), forces1[486], tol); ASSERT_EQUAL_VEC(Vec3(-3.38582e+02, 1.34683e+02, 7.89826e+02), forces1[486], tol);
ASSERT_EQUAL_VEC(Vec3(-5.59993e+02, -1.46815e+02, 3.62410e+01), forces1[487], tol); ASSERT_EQUAL_VEC(Vec3(-5.59991e+02, -1.46821e+02, 3.62431e+01), forces1[487], tol);
ASSERT_EQUAL_VEC(Vec3(-3.52723e+02, 1.16585e+02, -4.55478e+02), forces1[488], tol); ASSERT_EQUAL_VEC(Vec3(-3.52720e+02, 1.16574e+02, -4.55489e+02), forces1[488], tol);
ASSERT_EQUAL_VEC(Vec3( 6.56860e+01, 1.02562e+02, -9.81555e+01), forces1[489], tol); ASSERT_EQUAL_VEC(Vec3( 6.56764e+01, 1.02552e+02, -9.81453e+01), forces1[489], tol);
ASSERT_EQUAL_VEC(Vec3(-4.22981e+02, 8.89179e+02, -9.19646e+01), forces1[490], tol); ASSERT_EQUAL_VEC(Vec3(-4.22999e+02, 8.89176e+02, -9.19669e+01), forces1[490], tol);
ASSERT_EQUAL_VEC(Vec3( 5.13332e+02, 4.56111e+02, -6.86062e+01), forces1[491], tol); ASSERT_EQUAL_VEC(Vec3( 5.13334e+02, 4.56108e+02, -6.86079e+01), forces1[491], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12137e+02, 6.84714e+02, 4.44625e+01), forces1[492], tol); ASSERT_EQUAL_VEC(Vec3( 1.12135e+02, 6.84704e+02, 4.44625e+01), forces1[492], tol);
ASSERT_EQUAL_VEC(Vec3( 2.15948e+02, 3.33087e+02, -4.41254e+02), forces1[493], tol); ASSERT_EQUAL_VEC(Vec3( 2.15971e+02, 3.33099e+02, -4.41275e+02), forces1[493], tol);
ASSERT_EQUAL_VEC(Vec3(-4.77612e-01, -2.16938e+02, -5.39080e+02), forces1[494], tol); ASSERT_EQUAL_VEC(Vec3(-4.87370e-01, -2.16943e+02, -5.39078e+02), forces1[494], tol);
ASSERT_EQUAL_VEC(Vec3(-3.91574e+02, 2.80079e+02, 4.50308e+02), forces1[495], tol); ASSERT_EQUAL_VEC(Vec3(-3.91577e+02, 2.80055e+02, 4.50317e+02), forces1[495], tol);
ASSERT_EQUAL_VEC(Vec3( 2.40448e+02, -1.24646e+02, -2.70118e+02), forces1[496], tol); ASSERT_EQUAL_VEC(Vec3( 2.40450e+02, -1.24633e+02, -2.70115e+02), forces1[496], tol);
ASSERT_EQUAL_VEC(Vec3( 7.23837e+01, 1.59363e+01, -5.24007e+01), forces1[497], tol); ASSERT_EQUAL_VEC(Vec3( 7.23732e+01, 1.59397e+01, -5.23970e+01), forces1[497], tol);
ASSERT_EQUAL_VEC(Vec3(-1.41179e+02, -3.23952e+02, -4.05103e+02), forces1[498], tol); ASSERT_EQUAL_VEC(Vec3(-1.41172e+02, -3.23970e+02, -4.05105e+02), forces1[498], tol);
ASSERT_EQUAL_VEC(Vec3( 3.93741e+02, 3.77850e+02, -4.56267e+02), forces1[499], tol); ASSERT_EQUAL_VEC(Vec3( 3.93746e+02, 3.77842e+02, -4.56281e+02), forces1[499], tol);
ASSERT_EQUAL_VEC(Vec3(-2.67988e+02, -2.12761e+02, -7.96439e+02), forces1[500], tol); ASSERT_EQUAL_VEC(Vec3(-2.67998e+02, -2.12761e+02, -7.96439e+02), forces1[500], tol);
ASSERT_EQUAL_VEC(Vec3( 9.59486e+02, 1.74116e+02, 1.16095e+01), forces1[501], tol); ASSERT_EQUAL_VEC(Vec3( 9.59492e+02, 1.74115e+02, 1.16152e+01), forces1[501], tol);
ASSERT_EQUAL_VEC(Vec3(-3.93480e+01, 1.29031e+01, -1.89340e+02), forces1[502], tol); ASSERT_EQUAL_VEC(Vec3(-3.93501e+01, 1.29106e+01, -1.89347e+02), forces1[502], tol);
ASSERT_EQUAL_VEC(Vec3( 2.49451e+02, 7.83846e+01, -4.78247e+02), forces1[503], tol); ASSERT_EQUAL_VEC(Vec3( 2.49458e+02, 7.83930e+01, -4.78250e+02), forces1[503], tol);
ASSERT_EQUAL_VEC(Vec3( 5.16063e+02, 6.52910e+02, -5.05255e+02), forces1[504], tol); ASSERT_EQUAL_VEC(Vec3( 5.16044e+02, 6.52904e+02, -5.05255e+02), forces1[504], tol);
ASSERT_EQUAL_VEC(Vec3( 5.10700e+01, -5.19617e+02, 6.83449e+00), forces1[505], tol); ASSERT_EQUAL_VEC(Vec3( 5.10790e+01, -5.19600e+02, 6.82941e+00), forces1[505], tol);
ASSERT_EQUAL_VEC(Vec3(-7.69090e+01, -1.13216e+03, -7.05200e+02), forces1[506], tol); ASSERT_EQUAL_VEC(Vec3(-7.68988e+01, -1.13215e+03, -7.05215e+02), forces1[506], tol);
ASSERT_EQUAL_VEC(Vec3(-2.13076e+02, 1.69436e+00, 8.26370e+02), forces1[507], tol); ASSERT_EQUAL_VEC(Vec3(-2.13083e+02, 1.68863e+00, 8.26377e+02), forces1[507], tol);
ASSERT_EQUAL_VEC(Vec3( 1.86590e+01, 1.91426e+02, 4.18422e+02), forces1[508], tol); ASSERT_EQUAL_VEC(Vec3( 1.86606e+01, 1.91403e+02, 4.18423e+02), forces1[508], tol);
ASSERT_EQUAL_VEC(Vec3( 2.35348e+02, 3.79656e+02, -3.13838e+02), forces1[509], tol); ASSERT_EQUAL_VEC(Vec3( 2.35358e+02, 3.79667e+02, -3.13829e+02), forces1[509], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26223e+02, -2.59713e+02, -6.76312e+02), forces1[510], tol); ASSERT_EQUAL_VEC(Vec3(-1.26198e+02, -2.59719e+02, -6.76311e+02), forces1[510], tol);
ASSERT_EQUAL_VEC(Vec3(-1.38250e+02, -3.38622e+02, 2.20473e+02), forces1[511], tol); ASSERT_EQUAL_VEC(Vec3(-1.38258e+02, -3.38620e+02, 2.20451e+02), forces1[511], tol);
ASSERT_EQUAL_VEC(Vec3(-2.25477e+02, -7.80823e+02, -2.43664e+02), forces1[512], tol); ASSERT_EQUAL_VEC(Vec3(-2.25461e+02, -7.80816e+02, -2.43646e+02), forces1[512], tol);
ASSERT_EQUAL_VEC(Vec3(-3.10596e+01, 4.16269e+01, 6.15706e+01), forces1[513], tol); ASSERT_EQUAL_VEC(Vec3(-3.10604e+01, 4.16051e+01, 6.15644e+01), forces1[513], tol);
ASSERT_EQUAL_VEC(Vec3( 6.75611e+01, 9.67865e+01, 6.03427e+02), forces1[514], tol); ASSERT_EQUAL_VEC(Vec3( 6.75638e+01, 9.67799e+01, 6.03426e+02), forces1[514], tol);
ASSERT_EQUAL_VEC(Vec3(-1.27093e+02, -4.74920e+01, 4.67739e+02), forces1[515], tol); ASSERT_EQUAL_VEC(Vec3(-1.27092e+02, -4.74786e+01, 4.67732e+02), forces1[515], tol);
ASSERT_EQUAL_VEC(Vec3(-2.72714e+02, 3.30888e+01, -2.81975e+02), forces1[516], tol); ASSERT_EQUAL_VEC(Vec3(-2.72718e+02, 3.30904e+01, -2.81969e+02), forces1[516], tol);
ASSERT_EQUAL_VEC(Vec3( 4.78711e+02, 8.27637e+01, -3.32375e+02), forces1[517], tol); ASSERT_EQUAL_VEC(Vec3( 4.78708e+02, 8.27630e+01, -3.32365e+02), forces1[517], tol);
ASSERT_EQUAL_VEC(Vec3( 1.48575e+02, 1.88623e+02, -5.92113e+02), forces1[518], tol); ASSERT_EQUAL_VEC(Vec3( 1.48583e+02, 1.88623e+02, -5.92109e+02), forces1[518], tol);
ASSERT_EQUAL_VEC(Vec3(-9.24743e+01, 6.87075e+01, 5.16805e+02), forces1[519], tol); ASSERT_EQUAL_VEC(Vec3(-9.24687e+01, 6.86960e+01, 5.16806e+02), forces1[519], tol);
ASSERT_EQUAL_VEC(Vec3( 4.32894e+02, -4.67487e+02, 1.09384e+02), forces1[520], tol); ASSERT_EQUAL_VEC(Vec3( 4.32885e+02, -4.67487e+02, 1.09388e+02), forces1[520], tol);
ASSERT_EQUAL_VEC(Vec3(-2.19089e+02, 2.09544e+00, 1.05235e+03), forces1[521], tol); ASSERT_EQUAL_VEC(Vec3(-2.19076e+02, 2.08356e+00, 1.05234e+03), forces1[521], tol);
ASSERT_EQUAL_VEC(Vec3(-3.95718e+02, -3.31337e+02, 6.33902e+02), forces1[522], tol); ASSERT_EQUAL_VEC(Vec3(-3.95711e+02, -3.31334e+02, 6.33917e+02), forces1[522], tol);
ASSERT_EQUAL_VEC(Vec3( 2.29069e+01, 5.34148e+02, 3.48004e+01), forces1[523], tol); ASSERT_EQUAL_VEC(Vec3( 2.29127e+01, 5.34140e+02, 3.48041e+01), forces1[523], tol);
ASSERT_EQUAL_VEC(Vec3( 4.58852e+02, -2.39328e+02, 5.46896e+01), forces1[524], tol); ASSERT_EQUAL_VEC(Vec3( 4.58862e+02, -2.39332e+02, 5.46969e+01), forces1[524], tol);
ASSERT_EQUAL_VEC(Vec3( 9.97428e+01, 6.32201e+02, -2.38254e+02), forces1[525], tol); ASSERT_EQUAL_VEC(Vec3( 9.97684e+01, 6.32200e+02, -2.38256e+02), forces1[525], tol);
ASSERT_EQUAL_VEC(Vec3(-5.41815e+02, 2.23588e+02, 3.43976e+02), forces1[526], tol); ASSERT_EQUAL_VEC(Vec3(-5.41816e+02, 2.23588e+02, 3.43986e+02), forces1[526], tol);
ASSERT_EQUAL_VEC(Vec3( 6.66026e+02, 4.01161e+02, 3.95434e+02), forces1[527], tol); ASSERT_EQUAL_VEC(Vec3( 6.66038e+02, 4.01166e+02, 3.95435e+02), forces1[527], tol);
ASSERT_EQUAL_VEC(Vec3(-3.06408e+02, 9.39710e+02, -8.27900e+01), forces1[528], tol); ASSERT_EQUAL_VEC(Vec3(-3.06412e+02, 9.39713e+02, -8.27951e+01), forces1[528], tol);
ASSERT_EQUAL_VEC(Vec3(-6.74076e+02, 3.08248e+02, 3.73247e+02), forces1[529], tol); ASSERT_EQUAL_VEC(Vec3(-6.74084e+02, 3.08236e+02, 3.73252e+02), forces1[529], tol);
ASSERT_EQUAL_VEC(Vec3( 2.12294e+02, -1.45374e+02, 2.64291e+02), forces1[530], tol); ASSERT_EQUAL_VEC(Vec3( 2.12296e+02, -1.45360e+02, 2.64306e+02), forces1[530], tol);
ASSERT_EQUAL_VEC(Vec3( 5.45263e+01, -8.21086e+01, 1.51324e+01), forces1[531], tol); ASSERT_EQUAL_VEC(Vec3( 5.45245e+01, -8.21096e+01, 1.51265e+01), forces1[531], tol);
ASSERT_EQUAL_VEC(Vec3( 1.18909e+03, 9.92308e+02, 1.56930e+02), forces1[532], tol); ASSERT_EQUAL_VEC(Vec3( 1.18910e+03, 9.92315e+02, 1.56912e+02), forces1[532], tol);
ASSERT_EQUAL_VEC(Vec3( 4.27118e+02, 1.57533e+02, -3.44352e+02), forces1[533], tol); ASSERT_EQUAL_VEC(Vec3( 4.27129e+02, 1.57559e+02, -3.44345e+02), forces1[533], tol);
ASSERT_EQUAL_VEC(Vec3( 4.25871e+02, -8.14511e+02, -2.37529e+02), forces1[534], tol); ASSERT_EQUAL_VEC(Vec3( 4.25879e+02, -8.14513e+02, -2.37537e+02), forces1[534], tol);
ASSERT_EQUAL_VEC(Vec3( 1.28751e+02, 2.55760e+02, 4.07900e+02), forces1[535], tol); ASSERT_EQUAL_VEC(Vec3( 1.28753e+02, 2.55759e+02, 4.07890e+02), forces1[535], tol);
ASSERT_EQUAL_VEC(Vec3(-4.27478e+02, 1.69797e+02, 1.81398e+02), forces1[536], tol); ASSERT_EQUAL_VEC(Vec3(-4.27472e+02, 1.69782e+02, 1.81400e+02), forces1[536], tol);
ASSERT_EQUAL_VEC(Vec3(-1.35883e+01, 6.03699e+01, -2.72308e+02), forces1[537], tol); ASSERT_EQUAL_VEC(Vec3(-1.35803e+01, 6.03708e+01, -2.72317e+02), forces1[537], tol);
ASSERT_EQUAL_VEC(Vec3( 3.33164e+02, 2.70211e+02, -1.39411e+02), forces1[538], tol); ASSERT_EQUAL_VEC(Vec3( 3.33174e+02, 2.70226e+02, -1.39400e+02), forces1[538], tol);
ASSERT_EQUAL_VEC(Vec3( 4.27470e+02, 1.39180e+02, 1.50050e+02), forces1[539], tol); ASSERT_EQUAL_VEC(Vec3( 4.27463e+02, 1.39185e+02, 1.50051e+02), forces1[539], tol);
ASSERT_EQUAL_VEC(Vec3(-8.29087e+01, -1.00144e+02, -6.81966e+01), forces1[540], tol); ASSERT_EQUAL_VEC(Vec3(-8.29129e+01, -1.00155e+02, -6.82106e+01), forces1[540], tol);
ASSERT_EQUAL_VEC(Vec3( 4.42441e+02, -8.63493e+02, 5.13466e+02), forces1[541], tol); ASSERT_EQUAL_VEC(Vec3( 4.42454e+02, -8.63490e+02, 5.13458e+02), forces1[541], tol);
ASSERT_EQUAL_VEC(Vec3( 2.60692e+02, -6.37478e+01, 1.70976e+02), forces1[542], tol); ASSERT_EQUAL_VEC(Vec3( 2.60683e+02, -6.37510e+01, 1.70972e+02), forces1[542], tol);
ASSERT_EQUAL_VEC(Vec3(-3.90397e+02, -6.79745e+01, -2.36508e+02), forces1[543], tol); ASSERT_EQUAL_VEC(Vec3(-3.90402e+02, -6.79668e+01, -2.36492e+02), forces1[543], tol);
ASSERT_EQUAL_VEC(Vec3( 2.47136e+02, -6.89577e+02, 2.32358e+02), forces1[544], tol); ASSERT_EQUAL_VEC(Vec3( 2.47134e+02, -6.89590e+02, 2.32358e+02), forces1[544], tol);
ASSERT_EQUAL_VEC(Vec3(-5.36758e+02, 2.88867e+02, -6.13642e+02), forces1[545], tol); ASSERT_EQUAL_VEC(Vec3(-5.36759e+02, 2.88860e+02, -6.13641e+02), forces1[545], tol);
ASSERT_EQUAL_VEC(Vec3(-7.93507e+02, 1.07635e+02, 1.05022e+03), forces1[546], tol); ASSERT_EQUAL_VEC(Vec3(-7.93522e+02, 1.07651e+02, 1.05021e+03), forces1[546], tol);
ASSERT_EQUAL_VEC(Vec3( 5.82887e+02, 1.51818e+02, 4.23898e+02), forces1[547], tol); ASSERT_EQUAL_VEC(Vec3( 5.82887e+02, 1.51816e+02, 4.23889e+02), forces1[547], tol);
ASSERT_EQUAL_VEC(Vec3( 1.88318e+02, 3.18350e+02, 2.45839e+02), forces1[548], tol); ASSERT_EQUAL_VEC(Vec3( 1.88325e+02, 3.18348e+02, 2.45829e+02), forces1[548], tol);
ASSERT_EQUAL_VEC(Vec3( 2.61705e+02, 2.14111e+02, -1.84881e+02), forces1[549], tol); ASSERT_EQUAL_VEC(Vec3( 2.61706e+02, 2.14114e+02, -1.84884e+02), forces1[549], tol);
ASSERT_EQUAL_VEC(Vec3(-6.23111e+01, -3.92087e+02, 3.63669e+02), forces1[550], tol); ASSERT_EQUAL_VEC(Vec3(-6.23135e+01, -3.92081e+02, 3.63681e+02), forces1[550], tol);
ASSERT_EQUAL_VEC(Vec3( 2.19334e+02, -3.09061e+02, 2.60290e+02), forces1[551], tol); ASSERT_EQUAL_VEC(Vec3( 2.19342e+02, -3.09069e+02, 2.60297e+02), forces1[551], tol);
ASSERT_EQUAL_VEC(Vec3( 5.02098e+02, -5.84009e+02, -2.55787e+02), forces1[552], tol); ASSERT_EQUAL_VEC(Vec3( 5.02121e+02, -5.84013e+02, -2.55782e+02), forces1[552], tol);
ASSERT_EQUAL_VEC(Vec3( 3.03876e+02, 8.14771e+01, 3.89603e+02), forces1[553], tol); ASSERT_EQUAL_VEC(Vec3( 3.03896e+02, 8.14784e+01, 3.89611e+02), forces1[553], tol);
ASSERT_EQUAL_VEC(Vec3(-1.63631e+01, -1.20656e+02, -1.80833e+02), forces1[554], tol); ASSERT_EQUAL_VEC(Vec3(-1.63570e+01, -1.20665e+02, -1.80834e+02), forces1[554], tol);
ASSERT_EQUAL_VEC(Vec3( 5.41976e+02, 1.88550e+02, 1.13701e+02), forces1[555], tol); ASSERT_EQUAL_VEC(Vec3( 5.41978e+02, 1.88566e+02, 1.13688e+02), forces1[555], tol);
ASSERT_EQUAL_VEC(Vec3( 1.22396e+01, -7.61806e+02, -5.24491e+02), forces1[556], tol); ASSERT_EQUAL_VEC(Vec3( 1.22433e+01, -7.61806e+02, -5.24497e+02), forces1[556], tol);
ASSERT_EQUAL_VEC(Vec3(-4.66752e+02, 1.60559e+02, 1.60945e+02), forces1[557], tol); ASSERT_EQUAL_VEC(Vec3(-4.66740e+02, 1.60557e+02, 1.60939e+02), forces1[557], tol);
ASSERT_EQUAL_VEC(Vec3( 1.52462e+02, -2.28614e+02, -5.94669e+01), forces1[558], tol); ASSERT_EQUAL_VEC(Vec3( 1.52457e+02, -2.28607e+02, -5.94690e+01), forces1[558], tol);
ASSERT_EQUAL_VEC(Vec3( 1.80868e+02, 2.02589e+02, 2.57330e+02), forces1[559], tol); ASSERT_EQUAL_VEC(Vec3( 1.80888e+02, 2.02585e+02, 2.57319e+02), forces1[559], tol);
ASSERT_EQUAL_VEC(Vec3( 6.16842e+02, -3.58505e+02, -5.69813e+02), forces1[560], tol); ASSERT_EQUAL_VEC(Vec3( 6.16843e+02, -3.58498e+02, -5.69821e+02), forces1[560], tol);
ASSERT_EQUAL_VEC(Vec3(-1.57099e+02, -1.13548e+02, -1.64406e+02), forces1[561], tol); ASSERT_EQUAL_VEC(Vec3(-1.57111e+02, -1.13569e+02, -1.64406e+02), forces1[561], tol);
ASSERT_EQUAL_VEC(Vec3(-5.95577e+02, 1.76704e+02, -1.20422e+02), forces1[562], tol); ASSERT_EQUAL_VEC(Vec3(-5.95573e+02, 1.76708e+02, -1.20416e+02), forces1[562], tol);
ASSERT_EQUAL_VEC(Vec3(-6.70970e+01, 7.56219e+02, 5.71556e+02), forces1[563], tol); ASSERT_EQUAL_VEC(Vec3(-6.71022e+01, 7.56220e+02, 5.71559e+02), forces1[563], tol);
ASSERT_EQUAL_VEC(Vec3(-2.03115e+02, -5.27290e+02, -8.87861e+01), forces1[564], tol); ASSERT_EQUAL_VEC(Vec3(-2.03120e+02, -5.27280e+02, -8.87774e+01), forces1[564], tol);
ASSERT_EQUAL_VEC(Vec3(-1.55608e+02, 2.45866e+02, 3.01805e+01), forces1[565], tol); ASSERT_EQUAL_VEC(Vec3(-1.55600e+02, 2.45850e+02, 3.01861e+01), forces1[565], tol);
ASSERT_EQUAL_VEC(Vec3( 1.30691e+02, -2.25609e+02, -3.22207e+02), forces1[566], tol); ASSERT_EQUAL_VEC(Vec3( 1.30693e+02, -2.25616e+02, -3.22200e+02), forces1[566], tol);
ASSERT_EQUAL_VEC(Vec3( 8.49051e+00, -1.67318e+02, 1.64197e+02), forces1[567], tol); ASSERT_EQUAL_VEC(Vec3( 8.50163e+00, -1.67330e+02, 1.64207e+02), forces1[567], tol);
ASSERT_EQUAL_VEC(Vec3(-2.31489e+02, -5.93950e+00, -4.92432e+02), forces1[568], tol); ASSERT_EQUAL_VEC(Vec3(-2.31496e+02, -5.93524e+00, -4.92426e+02), forces1[568], tol);
ASSERT_EQUAL_VEC(Vec3(-1.99372e+02, -1.40006e+02, 2.20588e+01), forces1[569], tol); ASSERT_EQUAL_VEC(Vec3(-1.99378e+02, -1.40003e+02, 2.20600e+01), forces1[569], tol);
ASSERT_EQUAL_VEC(Vec3(-2.65254e+02, 6.41902e+02, 2.96574e+01), forces1[570], tol); ASSERT_EQUAL_VEC(Vec3(-2.65254e+02, 6.41911e+02, 2.96826e+01), forces1[570], tol);
ASSERT_EQUAL_VEC(Vec3(-6.43650e+02, -9.18767e+01, 4.59943e+02), forces1[571], tol); ASSERT_EQUAL_VEC(Vec3(-6.43644e+02, -9.18721e+01, 4.59939e+02), forces1[571], tol);
ASSERT_EQUAL_VEC(Vec3( 3.08963e+02, 8.15556e+02, 4.66114e+02), forces1[572], tol); ASSERT_EQUAL_VEC(Vec3( 3.08964e+02, 8.15563e+02, 4.66117e+02), forces1[572], tol);
ASSERT_EQUAL_VEC(Vec3( 3.27956e+02, -3.65742e+02, -7.14731e+02), forces1[573], tol); ASSERT_EQUAL_VEC(Vec3( 3.27958e+02, -3.65732e+02, -7.14736e+02), forces1[573], tol);
ASSERT_EQUAL_VEC(Vec3(-2.27211e+01, 1.71608e+02, 5.53850e+02), forces1[574], tol); ASSERT_EQUAL_VEC(Vec3(-2.27143e+01, 1.71616e+02, 5.53835e+02), forces1[574], tol);
ASSERT_EQUAL_VEC(Vec3(-3.66146e+02, -4.26967e+02, 4.19217e+02), forces1[575], tol); ASSERT_EQUAL_VEC(Vec3(-3.66153e+02, -4.26970e+02, 4.19225e+02), forces1[575], tol);
ASSERT_EQUAL_VEC(Vec3( 3.35354e+02, 4.34256e+02, 3.88531e+02), forces1[576], tol); ASSERT_EQUAL_VEC(Vec3( 3.35352e+02, 4.34253e+02, 3.88513e+02), forces1[576], tol);
ASSERT_EQUAL_VEC(Vec3( 1.92404e+02, 3.20051e+01, 2.85816e+02), forces1[577], tol); ASSERT_EQUAL_VEC(Vec3( 1.92411e+02, 3.20021e+01, 2.85805e+02), forces1[577], tol);
ASSERT_EQUAL_VEC(Vec3(-1.98785e+02, -5.26329e+02, 3.78343e+02), forces1[578], tol); ASSERT_EQUAL_VEC(Vec3(-1.98797e+02, -5.26323e+02, 3.78346e+02), forces1[578], tol);
ASSERT_EQUAL_VEC(Vec3( 1.45508e+01, -4.73237e+02, 1.99931e+02), forces1[579], tol); ASSERT_EQUAL_VEC(Vec3( 1.45478e+01, -4.73229e+02, 1.99924e+02), forces1[579], tol);
ASSERT_EQUAL_VEC(Vec3(-4.54993e+02, -4.41705e+02, -1.24656e+01), forces1[580], tol); ASSERT_EQUAL_VEC(Vec3(-4.54986e+02, -4.41692e+02, -1.24580e+01), forces1[580], tol);
ASSERT_EQUAL_VEC(Vec3(-4.14892e+02, 2.39747e+02, 1.50735e+02), forces1[581], tol); ASSERT_EQUAL_VEC(Vec3(-4.14887e+02, 2.39737e+02, 1.50739e+02), forces1[581], tol);
ASSERT_EQUAL_VEC(Vec3(-3.05975e+02, -5.48498e+02, 1.68235e+02), forces1[582], tol); ASSERT_EQUAL_VEC(Vec3(-3.05987e+02, -5.48474e+02, 1.68225e+02), forces1[582], tol);
ASSERT_EQUAL_VEC(Vec3(-4.75147e+02, -5.13921e+02, -3.05843e+02), forces1[583], tol); ASSERT_EQUAL_VEC(Vec3(-4.75144e+02, -5.13947e+02, -3.05852e+02), forces1[583], tol);
ASSERT_EQUAL_VEC(Vec3(-1.94336e+02, 1.30207e+02, -3.61873e+02), forces1[584], tol); ASSERT_EQUAL_VEC(Vec3(-1.94336e+02, 1.30198e+02, -3.61876e+02), forces1[584], tol);
ASSERT_EQUAL_VEC(Vec3(-3.90904e+02, 9.91501e+01, -5.15023e+02), forces1[585], tol); ASSERT_EQUAL_VEC(Vec3(-3.90896e+02, 9.91483e+01, -5.15021e+02), forces1[585], tol);
ASSERT_EQUAL_VEC(Vec3(-6.84425e+01, 4.13100e+01, -2.50210e+02), forces1[586], tol); ASSERT_EQUAL_VEC(Vec3(-6.84463e+01, 4.13153e+01, -2.50205e+02), forces1[586], tol);
ASSERT_EQUAL_VEC(Vec3(-1.33530e+02, 4.37443e+02, 3.93114e+02), forces1[587], tol); ASSERT_EQUAL_VEC(Vec3(-1.33546e+02, 4.37436e+02, 3.93115e+02), forces1[587], tol);
ASSERT_EQUAL_VEC(Vec3( 2.17867e+02, -3.56959e+02, -2.19083e+01), forces1[588], tol); ASSERT_EQUAL_VEC(Vec3( 2.17884e+02, -3.56946e+02, -2.18969e+01), forces1[588], tol);
ASSERT_EQUAL_VEC(Vec3(-6.71307e+01, -2.85153e+01, -4.77732e+02), forces1[589], tol); ASSERT_EQUAL_VEC(Vec3(-6.71098e+01, -2.85177e+01, -4.77738e+02), forces1[589], tol);
ASSERT_EQUAL_VEC(Vec3(-1.52922e+02, 1.00756e+02, 7.10581e+01), forces1[590], tol); ASSERT_EQUAL_VEC(Vec3(-1.52910e+02, 1.00734e+02, 7.10518e+01), forces1[590], tol);
ASSERT_EQUAL_VEC(Vec3(-4.51735e+02, 3.39995e+02, -4.62180e+02), forces1[591], tol); ASSERT_EQUAL_VEC(Vec3(-4.51744e+02, 3.40012e+02, -4.62177e+02), forces1[591], tol);
ASSERT_EQUAL_VEC(Vec3(-3.10146e+02, 9.78211e+02, 6.76385e+02), forces1[592], tol); ASSERT_EQUAL_VEC(Vec3(-3.10160e+02, 9.78204e+02, 6.76386e+02), forces1[592], tol);
ASSERT_EQUAL_VEC(Vec3(-3.27581e+02, -1.79625e+02, -2.92222e+02), forces1[593], tol); ASSERT_EQUAL_VEC(Vec3(-3.27570e+02, -1.79611e+02, -2.92229e+02), forces1[593], tol);
ASSERT_EQUAL_VEC(Vec3(-1.59843e+02, 2.90886e+01, -2.88799e+02), forces1[594], tol); ASSERT_EQUAL_VEC(Vec3(-1.59844e+02, 2.90908e+01, -2.88809e+02), forces1[594], tol);
ASSERT_EQUAL_VEC(Vec3( 2.51645e+02, -6.16102e+02, -2.74663e+02), forces1[595], tol); ASSERT_EQUAL_VEC(Vec3( 2.51646e+02, -6.16089e+02, -2.74649e+02), forces1[595], tol);
ASSERT_EQUAL_VEC(Vec3(-4.29780e+02, 2.97840e+02, 2.42774e+02), forces1[596], tol); ASSERT_EQUAL_VEC(Vec3(-4.29770e+02, 2.97845e+02, 2.42778e+02), forces1[596], tol);
ASSERT_EQUAL_VEC(Vec3(-6.54148e+01, -3.71008e+00, 1.09373e+02), forces1[597], tol); ASSERT_EQUAL_VEC(Vec3(-6.54276e+01, -3.70145e+00, 1.09371e+02), forces1[597], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13649e+02, 1.22412e+02, -1.64184e+02), forces1[598], tol); ASSERT_EQUAL_VEC(Vec3(-1.13649e+02, 1.22416e+02, -1.64174e+02), forces1[598], tol);
ASSERT_EQUAL_VEC(Vec3(-4.57983e+02, -5.24204e+02, -4.23547e+02), forces1[599], tol); ASSERT_EQUAL_VEC(Vec3(-4.57994e+02, -5.24219e+02, -4.23537e+02), forces1[599], tol);
ASSERT_EQUAL_VEC(Vec3(-4.01113e+02, -3.10918e+02, -4.86425e+02), forces1[600], tol); ASSERT_EQUAL_VEC(Vec3(-4.01122e+02, -3.10908e+02, -4.86433e+02), forces1[600], tol);
ASSERT_EQUAL_VEC(Vec3( 5.98509e+02, 2.14432e+02, -3.57296e+02), forces1[601], tol); ASSERT_EQUAL_VEC(Vec3( 5.98525e+02, 2.14431e+02, -3.57310e+02), forces1[601], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56634e+02, 7.11836e+01, -6.74287e+02), forces1[602], tol); ASSERT_EQUAL_VEC(Vec3( 2.56640e+02, 7.11992e+01, -6.74285e+02), forces1[602], tol);
ASSERT_EQUAL_VEC(Vec3(-4.29307e+02, 3.33252e+02, -9.12887e+02), forces1[603], tol); ASSERT_EQUAL_VEC(Vec3(-4.29293e+02, 3.33266e+02, -9.12898e+02), forces1[603], tol);
ASSERT_EQUAL_VEC(Vec3(-2.69763e+01, -1.31700e+02, -3.65251e+02), forces1[604], tol); ASSERT_EQUAL_VEC(Vec3(-2.69637e+01, -1.31695e+02, -3.65262e+02), forces1[604], tol);
ASSERT_EQUAL_VEC(Vec3(-9.50858e+00, 3.29539e+02, 1.84487e+01), forces1[605], tol); ASSERT_EQUAL_VEC(Vec3(-9.50771e+00, 3.29551e+02, 1.84445e+01), forces1[605], tol);
ASSERT_EQUAL_VEC(Vec3( 1.01475e+03, 8.03321e+01, -6.28559e+02), forces1[606], tol); ASSERT_EQUAL_VEC(Vec3( 1.01475e+03, 8.03474e+01, -6.28561e+02), forces1[606], tol);
ASSERT_EQUAL_VEC(Vec3( 2.39367e+02, -4.08078e+02, -1.62864e+02), forces1[607], tol); ASSERT_EQUAL_VEC(Vec3( 2.39376e+02, -4.08073e+02, -1.62858e+02), forces1[607], tol);
ASSERT_EQUAL_VEC(Vec3(-3.93619e+02, -5.17096e+02, 5.21846e+02), forces1[608], tol); ASSERT_EQUAL_VEC(Vec3(-3.93618e+02, -5.17098e+02, 5.21853e+02), forces1[608], tol);
ASSERT_EQUAL_VEC(Vec3(-1.37168e+02, -3.86209e+01, 4.26796e+02), forces1[609], tol); ASSERT_EQUAL_VEC(Vec3(-1.37173e+02, -3.86360e+01, 4.26832e+02), forces1[609], tol);
ASSERT_EQUAL_VEC(Vec3( 4.56732e+02, 1.63816e+02, 1.01562e+01), forces1[610], tol); ASSERT_EQUAL_VEC(Vec3( 4.56735e+02, 1.63812e+02, 1.01401e+01), forces1[610], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53133e+02, 1.02277e+02, -7.27475e+02), forces1[611], tol); ASSERT_EQUAL_VEC(Vec3(-1.53136e+02, 1.02274e+02, -7.27489e+02), forces1[611], tol);
ASSERT_EQUAL_VEC(Vec3(-1.82096e+02, 7.24199e+00, -5.10677e+02), forces1[612], tol); ASSERT_EQUAL_VEC(Vec3(-1.82093e+02, 7.24771e+00, -5.10685e+02), forces1[612], tol);
ASSERT_EQUAL_VEC(Vec3( 3.54496e+02, -8.64334e+01, -4.10166e+02), forces1[613], tol); ASSERT_EQUAL_VEC(Vec3( 3.54488e+02, -8.64195e+01, -4.10175e+02), forces1[613], tol);
ASSERT_EQUAL_VEC(Vec3(-6.67588e+01, -7.58054e+01, 7.77398e+01), forces1[614], tol); ASSERT_EQUAL_VEC(Vec3(-6.67624e+01, -7.57961e+01, 7.77301e+01), forces1[614], tol);
ASSERT_EQUAL_VEC(Vec3( 5.34134e+01, -3.49043e+02, -4.41048e+02), forces1[615], tol); ASSERT_EQUAL_VEC(Vec3( 5.34204e+01, -3.49058e+02, -4.41041e+02), forces1[615], tol);
ASSERT_EQUAL_VEC(Vec3(-2.55982e+02, -1.85091e+02, -1.67810e+01), forces1[616], tol); ASSERT_EQUAL_VEC(Vec3(-2.55977e+02, -1.85092e+02, -1.67787e+01), forces1[616], tol);
ASSERT_EQUAL_VEC(Vec3(-2.60202e+02, 4.50671e+02, 6.87577e+02), forces1[617], tol); ASSERT_EQUAL_VEC(Vec3(-2.60220e+02, 4.50663e+02, 6.87571e+02), forces1[617], tol);
ASSERT_EQUAL_VEC(Vec3(-4.84838e+01, -1.47686e+02, 1.30444e+02), forces1[618], tol); ASSERT_EQUAL_VEC(Vec3(-4.84849e+01, -1.47661e+02, 1.30457e+02), forces1[618], tol);
ASSERT_EQUAL_VEC(Vec3(-5.03880e+02, 3.00398e+02, 2.91453e+01), forces1[619], tol); ASSERT_EQUAL_VEC(Vec3(-5.03870e+02, 3.00380e+02, 2.91153e+01), forces1[619], tol);
ASSERT_EQUAL_VEC(Vec3(-3.26870e+02, -2.54132e+02, -1.97277e+02), forces1[620], tol); ASSERT_EQUAL_VEC(Vec3(-3.26882e+02, -2.54121e+02, -1.97289e+02), forces1[620], tol);
ASSERT_EQUAL_VEC(Vec3( 2.23127e+02, 4.31844e+02, -3.45776e+02), forces1[621], tol); ASSERT_EQUAL_VEC(Vec3( 2.23127e+02, 4.31849e+02, -3.45782e+02), forces1[621], tol);
ASSERT_EQUAL_VEC(Vec3(-2.68979e+00, -7.70417e+01, -4.29380e-01), forces1[622], tol); ASSERT_EQUAL_VEC(Vec3(-2.69077e+00, -7.70485e+01, -4.23857e-01), forces1[622], tol);
ASSERT_EQUAL_VEC(Vec3( 8.20406e+02, 7.99599e+02, 4.14359e+02), forces1[623], tol); ASSERT_EQUAL_VEC(Vec3( 8.20397e+02, 7.99593e+02, 4.14368e+02), forces1[623], tol);
ASSERT_EQUAL_VEC(Vec3(-6.20320e+01, -4.27149e+02, -3.70567e+02), forces1[624], tol); ASSERT_EQUAL_VEC(Vec3(-6.20274e+01, -4.27151e+02, -3.70575e+02), forces1[624], tol);
ASSERT_EQUAL_VEC(Vec3(-2.49512e+01, -1.44615e+02, 7.41532e+02), forces1[625], tol); ASSERT_EQUAL_VEC(Vec3(-2.49506e+01, -1.44622e+02, 7.41551e+02), forces1[625], tol);
ASSERT_EQUAL_VEC(Vec3(-6.41678e+02, 6.30077e+01, 1.57994e+02), forces1[626], tol); ASSERT_EQUAL_VEC(Vec3(-6.41672e+02, 6.29867e+01, 1.58002e+02), forces1[626], tol);
ASSERT_EQUAL_VEC(Vec3(-5.89367e+02, -2.66713e+02, 7.40713e+01), forces1[627], tol); ASSERT_EQUAL_VEC(Vec3(-5.89354e+02, -2.66715e+02, 7.40461e+01), forces1[627], tol);
ASSERT_EQUAL_VEC(Vec3( 5.26891e+02, -4.19408e+02, -2.37113e+02), forces1[628], tol); ASSERT_EQUAL_VEC(Vec3( 5.26897e+02, -4.19406e+02, -2.37126e+02), forces1[628], tol);
ASSERT_EQUAL_VEC(Vec3( 4.42820e+02, -3.89867e+00, 5.35413e+02), forces1[629], tol); ASSERT_EQUAL_VEC(Vec3( 4.42823e+02, -3.89602e+00, 5.35394e+02), forces1[629], tol);
ASSERT_EQUAL_VEC(Vec3( 2.38358e+02, -5.34620e+02, 2.63018e+02), forces1[630], tol); ASSERT_EQUAL_VEC(Vec3( 2.38351e+02, -5.34626e+02, 2.63027e+02), forces1[630], tol);
ASSERT_EQUAL_VEC(Vec3(-2.48053e+02, -1.44814e+01, 7.55538e+02), forces1[631], tol); ASSERT_EQUAL_VEC(Vec3(-2.48039e+02, -1.44724e+01, 7.55533e+02), forces1[631], tol);
ASSERT_EQUAL_VEC(Vec3(-8.06900e+01, -4.42711e+02, -4.11283e+02), forces1[632], tol); ASSERT_EQUAL_VEC(Vec3(-8.06993e+01, -4.42707e+02, -4.11282e+02), forces1[632], tol);
ASSERT_EQUAL_VEC(Vec3( 4.64133e+02, -7.82558e+02, 7.48574e+02), forces1[633], tol); ASSERT_EQUAL_VEC(Vec3( 4.64135e+02, -7.82572e+02, 7.48550e+02), forces1[633], tol);
ASSERT_EQUAL_VEC(Vec3( 3.75020e+02, 3.06939e+02, 2.76971e+02), forces1[634], tol); ASSERT_EQUAL_VEC(Vec3( 3.75024e+02, 3.06926e+02, 2.76975e+02), forces1[634], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43681e+02, -1.70144e+02, -2.61363e+02), forces1[635], tol); ASSERT_EQUAL_VEC(Vec3( 4.43670e+02, -1.70164e+02, -2.61356e+02), forces1[635], tol);
ASSERT_EQUAL_VEC(Vec3( 5.20768e+02, -7.65445e+00, -2.76123e+02), forces1[636], tol); ASSERT_EQUAL_VEC(Vec3( 5.20769e+02, -7.66032e+00, -2.76126e+02), forces1[636], tol);
ASSERT_EQUAL_VEC(Vec3(-2.28468e+02, 5.33827e+02, -3.58150e+01), forces1[637], tol); ASSERT_EQUAL_VEC(Vec3(-2.28461e+02, 5.33833e+02, -3.58038e+01), forces1[637], tol);
ASSERT_EQUAL_VEC(Vec3(-1.70108e+02, -7.30232e+01, -3.73092e+02), forces1[638], tol); ASSERT_EQUAL_VEC(Vec3(-1.70108e+02, -7.30449e+01, -3.73102e+02), forces1[638], tol);
ASSERT_EQUAL_VEC(Vec3( 1.90862e+02, 1.53720e+02, -9.75162e+00), forces1[639], tol); ASSERT_EQUAL_VEC(Vec3( 1.90864e+02, 1.53717e+02, -9.75681e+00), forces1[639], tol);
ASSERT_EQUAL_VEC(Vec3( 2.59593e+02, 2.75154e+01, -2.02349e+02), forces1[640], tol); ASSERT_EQUAL_VEC(Vec3( 2.59596e+02, 2.75192e+01, -2.02348e+02), forces1[640], tol);
ASSERT_EQUAL_VEC(Vec3( 3.25234e+02, 2.78155e+01, 5.21690e+02), forces1[641], tol); ASSERT_EQUAL_VEC(Vec3( 3.25228e+02, 2.78224e+01, 5.21697e+02), forces1[641], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12827e+02, -6.70122e+02, -7.86072e+01), forces1[642], tol); ASSERT_EQUAL_VEC(Vec3( 1.12825e+02, -6.70108e+02, -7.86084e+01), forces1[642], tol);
ASSERT_EQUAL_VEC(Vec3(-1.10057e+01, -4.90717e+01, -2.91296e+02), forces1[643], tol); ASSERT_EQUAL_VEC(Vec3(-1.10050e+01, -4.90683e+01, -2.91299e+02), forces1[643], tol);
ASSERT_EQUAL_VEC(Vec3( 2.77323e+02, 2.29314e+02, 5.59761e+02), forces1[644], tol); ASSERT_EQUAL_VEC(Vec3( 2.77327e+02, 2.29323e+02, 5.59760e+02), forces1[644], tol);
ASSERT_EQUAL_VEC(Vec3( 4.59578e+02, 1.21280e+02, -4.79317e+02), forces1[645], tol); ASSERT_EQUAL_VEC(Vec3( 4.59573e+02, 1.21299e+02, -4.79315e+02), forces1[645], tol);
ASSERT_EQUAL_VEC(Vec3(-5.30603e+02, -3.96111e+02, -4.37774e+01), forces1[646], tol); ASSERT_EQUAL_VEC(Vec3(-5.30622e+02, -3.96117e+02, -4.37730e+01), forces1[646], tol);
ASSERT_EQUAL_VEC(Vec3( 5.87297e+01, 3.74984e+02, -4.60365e+00), forces1[647], tol); ASSERT_EQUAL_VEC(Vec3( 5.87415e+01, 3.74983e+02, -4.59323e+00), forces1[647], tol);
ASSERT_EQUAL_VEC(Vec3(-5.72032e+02, -3.24795e+02, -5.11143e+01), forces1[648], tol); ASSERT_EQUAL_VEC(Vec3(-5.72048e+02, -3.24796e+02, -5.11139e+01), forces1[648], tol);
ASSERT_EQUAL_VEC(Vec3(-1.51869e+03, 1.63888e+02, -7.67896e+01), forces1[649], tol); ASSERT_EQUAL_VEC(Vec3(-1.51870e+03, 1.63888e+02, -7.67908e+01), forces1[649], tol);
ASSERT_EQUAL_VEC(Vec3( 4.86984e+02, 5.16873e+02, -7.62715e+01), forces1[650], tol); ASSERT_EQUAL_VEC(Vec3( 4.86979e+02, 5.16872e+02, -7.62781e+01), forces1[650], tol);
ASSERT_EQUAL_VEC(Vec3( 2.48278e+02, -8.90768e+02, 6.71637e+01), forces1[651], tol); ASSERT_EQUAL_VEC(Vec3( 2.48285e+02, -8.90776e+02, 6.71667e+01), forces1[651], tol);
ASSERT_EQUAL_VEC(Vec3(-1.54444e+00, 1.36950e+02, -1.04186e+02), forces1[652], tol); ASSERT_EQUAL_VEC(Vec3(-1.54175e+00, 1.36939e+02, -1.04189e+02), forces1[652], tol);
ASSERT_EQUAL_VEC(Vec3(-1.20205e+02, 2.89614e+02, -6.63136e+02), forces1[653], tol); ASSERT_EQUAL_VEC(Vec3(-1.20205e+02, 2.89638e+02, -6.63136e+02), forces1[653], tol);
ASSERT_EQUAL_VEC(Vec3(-1.59423e+02, -4.16170e+02, 2.79425e+02), forces1[654], tol); ASSERT_EQUAL_VEC(Vec3(-1.59426e+02, -4.16181e+02, 2.79418e+02), forces1[654], tol);
ASSERT_EQUAL_VEC(Vec3(-2.98738e+02, -2.96279e+02, 3.36128e+02), forces1[655], tol); ASSERT_EQUAL_VEC(Vec3(-2.98735e+02, -2.96276e+02, 3.36143e+02), forces1[655], tol);
ASSERT_EQUAL_VEC(Vec3(-4.91903e+02, -4.26711e+01, 1.25410e+01), forces1[656], tol); ASSERT_EQUAL_VEC(Vec3(-4.91907e+02, -4.26747e+01, 1.25389e+01), forces1[656], tol);
ASSERT_EQUAL_VEC(Vec3(-2.47961e+02, -2.67470e+02, 2.21833e+02), forces1[657], tol); ASSERT_EQUAL_VEC(Vec3(-2.47943e+02, -2.67473e+02, 2.21842e+02), forces1[657], tol);
ASSERT_EQUAL_VEC(Vec3(-2.42779e+01, 2.61466e+01, -6.65092e+01), forces1[658], tol); ASSERT_EQUAL_VEC(Vec3(-2.42851e+01, 2.61470e+01, -6.65055e+01), forces1[658], tol);
ASSERT_EQUAL_VEC(Vec3( 3.64170e+02, 4.13061e+02, -5.51339e+02), forces1[659], tol); ASSERT_EQUAL_VEC(Vec3( 3.64175e+02, 4.13063e+02, -5.51340e+02), forces1[659], tol);
ASSERT_EQUAL_VEC(Vec3( 3.74850e+02, -6.33619e+02, 5.37517e+00), forces1[660], tol); ASSERT_EQUAL_VEC(Vec3( 3.74845e+02, -6.33619e+02, 5.37646e+00), forces1[660], tol);
ASSERT_EQUAL_VEC(Vec3( 6.51867e+01, 5.97080e+02, 2.54555e+01), forces1[661], tol); ASSERT_EQUAL_VEC(Vec3( 6.51845e+01, 5.97073e+02, 2.54487e+01), forces1[661], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53436e+02, -8.04195e-02, -3.64192e+02), forces1[662], tol); ASSERT_EQUAL_VEC(Vec3(-2.53437e+02, -7.70454e-02, -3.64178e+02), forces1[662], tol);
ASSERT_EQUAL_VEC(Vec3(-4.19689e+01, 5.32474e+02, 5.67508e+02), forces1[663], tol); ASSERT_EQUAL_VEC(Vec3(-4.19786e+01, 5.32473e+02, 5.67523e+02), forces1[663], tol);
ASSERT_EQUAL_VEC(Vec3( 2.18324e+01, -2.88672e+02, 2.73899e+02), forces1[664], tol); ASSERT_EQUAL_VEC(Vec3( 2.18380e+01, -2.88670e+02, 2.73917e+02), forces1[664], tol);
ASSERT_EQUAL_VEC(Vec3( 2.56672e+02, 1.75289e+02, 2.67800e+02), forces1[665], tol); ASSERT_EQUAL_VEC(Vec3( 2.56668e+02, 1.75282e+02, 2.67811e+02), forces1[665], tol);
ASSERT_EQUAL_VEC(Vec3(-1.41995e+02, -1.93560e+02, -4.45945e+02), forces1[666], tol); ASSERT_EQUAL_VEC(Vec3(-1.42006e+02, -1.93562e+02, -4.45933e+02), forces1[666], tol);
ASSERT_EQUAL_VEC(Vec3(-5.74310e+01, -4.30856e+02, -7.59702e+02), forces1[667], tol); ASSERT_EQUAL_VEC(Vec3(-5.74483e+01, -4.30855e+02, -7.59684e+02), forces1[667], tol);
ASSERT_EQUAL_VEC(Vec3(-4.90362e+02, 2.12537e+02, 1.21413e+02), forces1[668], tol); ASSERT_EQUAL_VEC(Vec3(-4.90370e+02, 2.12536e+02, 1.21399e+02), forces1[668], tol);
ASSERT_EQUAL_VEC(Vec3( 1.94636e+02, 1.32076e+02, 1.71428e+02), forces1[669], tol); ASSERT_EQUAL_VEC(Vec3( 1.94634e+02, 1.32086e+02, 1.71425e+02), forces1[669], tol);
ASSERT_EQUAL_VEC(Vec3(-2.73631e+02, 7.78023e+02, 2.78016e+02), forces1[670], tol); ASSERT_EQUAL_VEC(Vec3(-2.73623e+02, 7.78030e+02, 2.78021e+02), forces1[670], tol);
ASSERT_EQUAL_VEC(Vec3(-2.62083e+02, 3.54003e+02, 1.59726e+02), forces1[671], tol); ASSERT_EQUAL_VEC(Vec3(-2.62074e+02, 3.53998e+02, 1.59712e+02), forces1[671], tol);
ASSERT_EQUAL_VEC(Vec3( 3.74240e+01, -6.21080e+02, -1.89723e+02), forces1[672], tol); ASSERT_EQUAL_VEC(Vec3( 3.74175e+01, -6.21070e+02, -1.89712e+02), forces1[672], tol);
ASSERT_EQUAL_VEC(Vec3( 2.70244e+02, -1.98707e+02, -1.68454e+02), forces1[673], tol); ASSERT_EQUAL_VEC(Vec3( 2.70256e+02, -1.98712e+02, -1.68453e+02), forces1[673], tol);
ASSERT_EQUAL_VEC(Vec3(-3.72183e+02, 2.16536e+02, -7.51567e+01), forces1[674], tol); ASSERT_EQUAL_VEC(Vec3(-3.72180e+02, 2.16555e+02, -7.51654e+01), forces1[674], tol);
ASSERT_EQUAL_VEC(Vec3( 4.60639e+02, -2.41016e+02, 1.87543e+02), forces1[675], tol); ASSERT_EQUAL_VEC(Vec3( 4.60646e+02, -2.41020e+02, 1.87544e+02), forces1[675], tol);
ASSERT_EQUAL_VEC(Vec3(-8.65481e+00, -4.96504e+01, 4.14101e+02), forces1[676], tol); ASSERT_EQUAL_VEC(Vec3(-8.64562e+00, -4.96607e+01, 4.14111e+02), forces1[676], tol);
ASSERT_EQUAL_VEC(Vec3(-5.53536e+02, 2.02025e+02, 2.48787e+02), forces1[677], tol); ASSERT_EQUAL_VEC(Vec3(-5.53550e+02, 2.02023e+02, 2.48778e+02), forces1[677], tol);
ASSERT_EQUAL_VEC(Vec3( 4.12909e+02, 3.97620e+02, -7.77095e+02), forces1[678], tol); ASSERT_EQUAL_VEC(Vec3( 4.12902e+02, 3.97615e+02, -7.77105e+02), forces1[678], tol);
ASSERT_EQUAL_VEC(Vec3( 4.37880e+02, 3.87772e+02, -2.57117e+02), forces1[679], tol); ASSERT_EQUAL_VEC(Vec3( 4.37864e+02, 3.87796e+02, -2.57117e+02), forces1[679], tol);
ASSERT_EQUAL_VEC(Vec3(-1.99559e+02, -5.31850e+02, -7.08371e+02), forces1[680], tol); ASSERT_EQUAL_VEC(Vec3(-1.99545e+02, -5.31838e+02, -7.08357e+02), forces1[680], tol);
ASSERT_EQUAL_VEC(Vec3( 7.16802e+01, 2.15324e+02, -2.17996e+02), forces1[681], tol); ASSERT_EQUAL_VEC(Vec3( 7.16820e+01, 2.15323e+02, -2.17986e+02), forces1[681], tol);
ASSERT_EQUAL_VEC(Vec3(-2.27234e+02, -3.33110e+02, -8.95659e+01), forces1[682], tol); ASSERT_EQUAL_VEC(Vec3(-2.27238e+02, -3.33101e+02, -8.95801e+01), forces1[682], tol);
ASSERT_EQUAL_VEC(Vec3( 1.12343e+02, -2.81426e+02, 1.84403e+02), forces1[683], tol); ASSERT_EQUAL_VEC(Vec3( 1.12342e+02, -2.81421e+02, 1.84405e+02), forces1[683], tol);
ASSERT_EQUAL_VEC(Vec3( 5.30599e+01, -1.73621e+02, 3.80444e+02), forces1[684], tol); ASSERT_EQUAL_VEC(Vec3( 5.30416e+01, -1.73619e+02, 3.80448e+02), forces1[684], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53120e+02, -4.19552e+02, 3.62058e+02), forces1[685], tol); ASSERT_EQUAL_VEC(Vec3(-1.53132e+02, -4.19546e+02, 3.62048e+02), forces1[685], tol);
ASSERT_EQUAL_VEC(Vec3(-8.26114e+01, 1.22027e+02, -2.05582e+01), forces1[686], tol); ASSERT_EQUAL_VEC(Vec3(-8.26083e+01, 1.22020e+02, -2.05481e+01), forces1[686], tol);
ASSERT_EQUAL_VEC(Vec3(-4.09514e+02, 3.88217e+01, 7.34580e+02), forces1[687], tol); ASSERT_EQUAL_VEC(Vec3(-4.09521e+02, 3.88078e+01, 7.34580e+02), forces1[687], tol);
ASSERT_EQUAL_VEC(Vec3( 2.30489e+02, 4.59033e+01, -3.44433e+02), forces1[688], tol); ASSERT_EQUAL_VEC(Vec3( 2.30481e+02, 4.59140e+01, -3.44443e+02), forces1[688], tol);
ASSERT_EQUAL_VEC(Vec3(-2.99014e+02, 6.71198e+02, -1.01233e+03), forces1[689], tol); ASSERT_EQUAL_VEC(Vec3(-2.99023e+02, 6.71185e+02, -1.01234e+03), forces1[689], tol);
ASSERT_EQUAL_VEC(Vec3( 2.93613e+02, -1.62647e+01, -5.52897e+02), forces1[690], tol); ASSERT_EQUAL_VEC(Vec3( 2.93615e+02, -1.62637e+01, -5.52882e+02), forces1[690], tol);
ASSERT_EQUAL_VEC(Vec3(-1.41613e+02, -4.87783e+02, 2.73048e+02), forces1[691], tol); ASSERT_EQUAL_VEC(Vec3(-1.41601e+02, -4.87777e+02, 2.73045e+02), forces1[691], tol);
ASSERT_EQUAL_VEC(Vec3(-1.26641e+02, -4.36390e+02, 7.19775e+01), forces1[692], tol); ASSERT_EQUAL_VEC(Vec3(-1.26640e+02, -4.36399e+02, 7.19796e+01), forces1[692], tol);
ASSERT_EQUAL_VEC(Vec3( 1.33474e+02, 2.25651e+02, 5.65785e+02), forces1[693], tol); ASSERT_EQUAL_VEC(Vec3( 1.33472e+02, 2.25647e+02, 5.65785e+02), forces1[693], tol);
ASSERT_EQUAL_VEC(Vec3( 7.34320e+02, 4.69231e+02, -5.53033e+02), forces1[694], tol); ASSERT_EQUAL_VEC(Vec3( 7.34336e+02, 4.69224e+02, -5.53023e+02), forces1[694], tol);
ASSERT_EQUAL_VEC(Vec3(-6.36568e+01, -2.05112e+02, -4.73040e+02), forces1[695], tol); ASSERT_EQUAL_VEC(Vec3(-6.36602e+01, -2.05110e+02, -4.73058e+02), forces1[695], tol);
ASSERT_EQUAL_VEC(Vec3(-3.35924e+02, -2.75958e+02, 4.10412e+02), forces1[696], tol); ASSERT_EQUAL_VEC(Vec3(-3.35930e+02, -2.75966e+02, 4.10409e+02), forces1[696], tol);
ASSERT_EQUAL_VEC(Vec3(-1.98458e+02, -2.81403e+02, -1.48442e+02), forces1[697], tol); ASSERT_EQUAL_VEC(Vec3(-1.98434e+02, -2.81395e+02, -1.48447e+02), forces1[697], tol);
ASSERT_EQUAL_VEC(Vec3( 6.97011e+02, -2.08389e+02, -1.22103e+02), forces1[698], tol); ASSERT_EQUAL_VEC(Vec3( 6.97000e+02, -2.08385e+02, -1.22103e+02), forces1[698], tol);
ASSERT_EQUAL_VEC(Vec3( 6.16654e+02, -2.04954e+02, -2.28467e+02), forces1[699], tol); ASSERT_EQUAL_VEC(Vec3( 6.16657e+02, -2.04959e+02, -2.28466e+02), forces1[699], tol);
ASSERT_EQUAL_VEC(Vec3( 1.59030e+02, 2.68344e+02, -1.13404e+02), forces1[700], tol); ASSERT_EQUAL_VEC(Vec3( 1.59028e+02, 2.68339e+02, -1.13410e+02), forces1[700], tol);
ASSERT_EQUAL_VEC(Vec3( 2.52329e+02, 3.78677e+02, -1.30508e+03), forces1[701], tol); ASSERT_EQUAL_VEC(Vec3( 2.52343e+02, 3.78670e+02, -1.30509e+03), forces1[701], tol);
ASSERT_EQUAL_VEC(Vec3( 7.30835e+02, -3.70980e+02, -6.60680e+02), forces1[702], tol); ASSERT_EQUAL_VEC(Vec3( 7.30827e+02, -3.70990e+02, -6.60678e+02), forces1[702], tol);
ASSERT_EQUAL_VEC(Vec3(-4.64457e+01, 1.28054e+02, 8.75776e+01), forces1[703], tol); ASSERT_EQUAL_VEC(Vec3(-4.64409e+01, 1.28066e+02, 8.75692e+01), forces1[703], tol);
ASSERT_EQUAL_VEC(Vec3( 3.26219e+02, -1.75859e+02, 7.03159e+01), forces1[704], tol); ASSERT_EQUAL_VEC(Vec3( 3.26215e+02, -1.75860e+02, 7.03132e+01), forces1[704], tol);
ASSERT_EQUAL_VEC(Vec3( 9.80699e+01, -2.26678e+02, -2.00000e+02), forces1[705], tol); ASSERT_EQUAL_VEC(Vec3( 9.80781e+01, -2.26689e+02, -2.00001e+02), forces1[705], tol);
ASSERT_EQUAL_VEC(Vec3( 5.01828e+01, 2.67263e+02, 5.24673e+02), forces1[706], tol); ASSERT_EQUAL_VEC(Vec3( 5.01952e+01, 2.67236e+02, 5.24662e+02), forces1[706], tol);
ASSERT_EQUAL_VEC(Vec3(-2.52908e+02, -8.04957e+02, 4.03059e+02), forces1[707], tol); ASSERT_EQUAL_VEC(Vec3(-2.52900e+02, -8.04961e+02, 4.03069e+02), forces1[707], tol);
ASSERT_EQUAL_VEC(Vec3(-2.40199e+02, -2.54325e+02, 5.06447e+02), forces1[708], tol); ASSERT_EQUAL_VEC(Vec3(-2.40213e+02, -2.54318e+02, 5.06462e+02), forces1[708], tol);
ASSERT_EQUAL_VEC(Vec3( 4.48951e+02, 3.49503e+02, 2.88405e+02), forces1[709], tol); ASSERT_EQUAL_VEC(Vec3( 4.48948e+02, 3.49506e+02, 2.88403e+02), forces1[709], tol);
ASSERT_EQUAL_VEC(Vec3( 3.10156e+02, 3.91028e+02, -9.77458e+02), forces1[710], tol); ASSERT_EQUAL_VEC(Vec3( 3.10145e+02, 3.91032e+02, -9.77450e+02), forces1[710], tol);
ASSERT_EQUAL_VEC(Vec3( 7.63182e+02, 2.06915e+02, 1.03494e+02), forces1[711], tol); ASSERT_EQUAL_VEC(Vec3( 7.63176e+02, 2.06934e+02, 1.03498e+02), forces1[711], tol);
ASSERT_EQUAL_VEC(Vec3( 4.64450e+02, 2.52688e+02, 7.37838e+01), forces1[712], tol); ASSERT_EQUAL_VEC(Vec3( 4.64450e+02, 2.52676e+02, 7.37725e+01), forces1[712], tol);
ASSERT_EQUAL_VEC(Vec3( 9.14938e+02, 3.40046e+02, -2.99026e+02), forces1[713], tol); ASSERT_EQUAL_VEC(Vec3( 9.14947e+02, 3.40040e+02, -2.99021e+02), forces1[713], tol);
ASSERT_EQUAL_VEC(Vec3( 5.05313e+02, 1.59559e+02, -9.12061e+00), forces1[714], tol); ASSERT_EQUAL_VEC(Vec3( 5.05311e+02, 1.59558e+02, -9.12417e+00), forces1[714], tol);
ASSERT_EQUAL_VEC(Vec3(-3.46704e+02, 1.40007e+02, 1.54726e+02), forces1[715], tol); ASSERT_EQUAL_VEC(Vec3(-3.46704e+02, 1.40018e+02, 1.54716e+02), forces1[715], tol);
ASSERT_EQUAL_VEC(Vec3(-1.66363e+01, -4.02136e+01, -1.23837e+02), forces1[716], tol); ASSERT_EQUAL_VEC(Vec3(-1.66193e+01, -4.02081e+01, -1.23816e+02), forces1[716], tol);
ASSERT_EQUAL_VEC(Vec3(-7.57127e+01, -4.48051e+02, -4.21102e+02), forces1[717], tol); ASSERT_EQUAL_VEC(Vec3(-7.57179e+01, -4.48049e+02, -4.21095e+02), forces1[717], tol);
ASSERT_EQUAL_VEC(Vec3( 1.04055e+03, -2.36045e+02, 1.43043e+01), forces1[718], tol); ASSERT_EQUAL_VEC(Vec3( 1.04055e+03, -2.36062e+02, 1.43125e+01), forces1[718], tol);
ASSERT_EQUAL_VEC(Vec3(-2.65353e+01, 6.06563e+02, 4.91442e+01), forces1[719], tol); ASSERT_EQUAL_VEC(Vec3(-2.65437e+01, 6.06573e+02, 4.91404e+01), forces1[719], tol);
ASSERT_EQUAL_VEC(Vec3(-1.33813e+02, -3.09746e+02, 2.79805e+01), forces1[720], tol); ASSERT_EQUAL_VEC(Vec3(-1.33799e+02, -3.09741e+02, 2.79872e+01), forces1[720], tol);
ASSERT_EQUAL_VEC(Vec3(-9.76473e+01, -1.13792e+03, 4.60485e+02), forces1[721], tol); ASSERT_EQUAL_VEC(Vec3(-9.76583e+01, -1.13792e+03, 4.60486e+02), forces1[721], tol);
ASSERT_EQUAL_VEC(Vec3(-2.56791e+02, 9.31735e+01, 3.24967e+02), forces1[722], tol); ASSERT_EQUAL_VEC(Vec3(-2.56797e+02, 9.31614e+01, 3.24973e+02), forces1[722], tol);
ASSERT_EQUAL_VEC(Vec3(-8.66036e+01, 5.60538e+02, 2.96447e+02), forces1[723], tol); ASSERT_EQUAL_VEC(Vec3(-8.66116e+01, 5.60535e+02, 2.96444e+02), forces1[723], tol);
ASSERT_EQUAL_VEC(Vec3( 1.26235e+02, 1.40932e+02, 3.97443e+02), forces1[724], tol); ASSERT_EQUAL_VEC(Vec3( 1.26228e+02, 1.40946e+02, 3.97444e+02), forces1[724], tol);
ASSERT_EQUAL_VEC(Vec3( 1.03110e+02, -1.43338e+02, 1.91594e+02), forces1[725], tol); ASSERT_EQUAL_VEC(Vec3( 1.03121e+02, -1.43347e+02, 1.91577e+02), forces1[725], tol);
ASSERT_EQUAL_VEC(Vec3(-9.29561e+01, 4.44629e+01, -9.69884e+01), forces1[726], tol); ASSERT_EQUAL_VEC(Vec3(-9.29460e+01, 4.44591e+01, -9.69787e+01), forces1[726], tol);
ASSERT_EQUAL_VEC(Vec3(-1.07834e+02, 4.40197e+01, 2.20881e+02), forces1[727], tol); ASSERT_EQUAL_VEC(Vec3(-1.07841e+02, 4.40146e+01, 2.20888e+02), forces1[727], tol);
ASSERT_EQUAL_VEC(Vec3( 2.92931e+02, 5.54166e+02, 3.56997e+02), forces1[728], tol); ASSERT_EQUAL_VEC(Vec3( 2.92927e+02, 5.54167e+02, 3.56991e+02), forces1[728], tol);
ASSERT_EQUAL_VEC(Vec3(-6.11693e+02, 1.34358e+02, 4.75132e+01), forces1[729], tol); ASSERT_EQUAL_VEC(Vec3(-6.11691e+02, 1.34361e+02, 4.75043e+01), forces1[729], tol);
ASSERT_EQUAL_VEC(Vec3(-8.07627e+02, 1.63828e+01, -2.56534e+02), forces1[730], tol); ASSERT_EQUAL_VEC(Vec3(-8.07637e+02, 1.63874e+01, -2.56526e+02), forces1[730], tol);
ASSERT_EQUAL_VEC(Vec3( 5.08763e+01, 1.35244e+01, 4.82195e+02), forces1[731], tol); ASSERT_EQUAL_VEC(Vec3( 5.08711e+01, 1.35146e+01, 4.82187e+02), forces1[731], tol);
ASSERT_EQUAL_VEC(Vec3(-5.01037e+02, -7.35306e+02, 6.67899e+02), forces1[732], tol); ASSERT_EQUAL_VEC(Vec3(-5.01040e+02, -7.35292e+02, 6.67901e+02), forces1[732], tol);
ASSERT_EQUAL_VEC(Vec3(-1.73456e+00, 6.70716e+02, -1.03875e+03), forces1[733], tol); ASSERT_EQUAL_VEC(Vec3(-1.74444e+00, 6.70711e+02, -1.03875e+03), forces1[733], tol);
ASSERT_EQUAL_VEC(Vec3(-1.95454e+02, 4.63760e+02, 7.41423e+01), forces1[734], tol); ASSERT_EQUAL_VEC(Vec3(-1.95458e+02, 4.63751e+02, 7.41370e+01), forces1[734], tol);
ASSERT_EQUAL_VEC(Vec3(-2.73267e+02, -4.33960e+02, -5.86874e+02), forces1[735], tol); ASSERT_EQUAL_VEC(Vec3(-2.73273e+02, -4.33968e+02, -5.86860e+02), forces1[735], tol);
ASSERT_EQUAL_VEC(Vec3( 3.87504e+02, -3.57428e+02, -1.22666e+02), forces1[736], tol); ASSERT_EQUAL_VEC(Vec3( 3.87495e+02, -3.57412e+02, -1.22672e+02), forces1[736], tol);
ASSERT_EQUAL_VEC(Vec3( 2.10274e+02, -8.24148e+01, -3.92490e+02), forces1[737], tol); ASSERT_EQUAL_VEC(Vec3( 2.10269e+02, -8.24362e+01, -3.92484e+02), forces1[737], tol);
ASSERT_EQUAL_VEC(Vec3( 8.30179e+02, -6.58234e+02, -4.70881e+02), forces1[738], tol); ASSERT_EQUAL_VEC(Vec3( 8.30177e+02, -6.58237e+02, -4.70878e+02), forces1[738], tol);
ASSERT_EQUAL_VEC(Vec3( 1.32194e+02, 1.07235e+02, -2.42581e+02), forces1[739], tol); ASSERT_EQUAL_VEC(Vec3( 1.32212e+02, 1.07237e+02, -2.42604e+02), forces1[739], tol);
ASSERT_EQUAL_VEC(Vec3(-4.36748e+02, 2.00485e+01, -3.45985e+02), forces1[740], tol); ASSERT_EQUAL_VEC(Vec3(-4.36754e+02, 2.00495e+01, -3.45995e+02), forces1[740], tol);
ASSERT_EQUAL_VEC(Vec3(-5.77247e+02, 1.27450e+02, -4.58818e+02), forces1[741], tol); ASSERT_EQUAL_VEC(Vec3(-5.77243e+02, 1.27456e+02, -4.58812e+02), forces1[741], tol);
ASSERT_EQUAL_VEC(Vec3( 1.97468e+02, -2.58379e+02, 1.34671e+02), forces1[742], tol); ASSERT_EQUAL_VEC(Vec3( 1.97467e+02, -2.58380e+02, 1.34659e+02), forces1[742], tol);
ASSERT_EQUAL_VEC(Vec3( 3.87543e+01, -8.11451e+02, -2.37616e+02), forces1[743], tol); ASSERT_EQUAL_VEC(Vec3( 3.87615e+01, -8.11440e+02, -2.37606e+02), forces1[743], tol);
ASSERT_EQUAL_VEC(Vec3(-5.43727e+02, 7.09024e+01, -1.18501e+02), forces1[744], tol); ASSERT_EQUAL_VEC(Vec3(-5.43753e+02, 7.08855e+01, -1.18515e+02), forces1[744], tol);
ASSERT_EQUAL_VEC(Vec3(-4.18089e+02, 9.12592e+01, -3.26399e+02), forces1[745], tol); ASSERT_EQUAL_VEC(Vec3(-4.18102e+02, 9.12534e+01, -3.26390e+02), forces1[745], tol);
ASSERT_EQUAL_VEC(Vec3(-1.04721e+02, 4.73096e+02, -5.52374e+02), forces1[746], tol); ASSERT_EQUAL_VEC(Vec3(-1.04709e+02, 4.73095e+02, -5.52378e+02), forces1[746], tol);
ASSERT_EQUAL_VEC(Vec3( 1.50367e+02, 6.74554e+02, -8.65248e+01), forces1[747], tol); ASSERT_EQUAL_VEC(Vec3( 1.50360e+02, 6.74565e+02, -8.65160e+01), forces1[747], tol);
ASSERT_EQUAL_VEC(Vec3(-4.91639e+01, 9.70025e+01, 4.14824e+01), forces1[748], tol); ASSERT_EQUAL_VEC(Vec3(-4.91737e+01, 9.70173e+01, 4.14679e+01), forces1[748], tol);
ASSERT_EQUAL_VEC(Vec3(-1.53124e+02, -3.14687e+02, 1.64528e+02), forces1[749], tol); ASSERT_EQUAL_VEC(Vec3(-1.53125e+02, -3.14702e+02, 1.64510e+02), forces1[749], tol);
ASSERT_EQUAL_VEC(Vec3( 5.30483e-01, -2.20850e+02, 2.62847e+02), forces1[750], tol); ASSERT_EQUAL_VEC(Vec3( 5.30495e-01, -2.20851e+02, 2.62854e+02), forces1[750], tol);
ASSERT_EQUAL_VEC(Vec3(-6.92142e+02, 2.00413e+02, -2.65840e+02), forces1[751], tol); ASSERT_EQUAL_VEC(Vec3(-6.92133e+02, 2.00411e+02, -2.65836e+02), forces1[751], tol);
ASSERT_EQUAL_VEC(Vec3( 3.79074e+01, -1.05193e+02, -3.82741e+01), forces1[752], tol); ASSERT_EQUAL_VEC(Vec3( 3.79173e+01, -1.05185e+02, -3.82562e+01), forces1[752], tol);
ASSERT_EQUAL_VEC(Vec3(-2.53021e+02, 2.11979e+02, -3.81686e+02), forces1[753], tol); ASSERT_EQUAL_VEC(Vec3(-2.53019e+02, 2.11965e+02, -3.81685e+02), forces1[753], tol);
ASSERT_EQUAL_VEC(Vec3(-2.51269e+02, -3.93319e+02, -1.33267e+01), forces1[754], tol); ASSERT_EQUAL_VEC(Vec3(-2.51275e+02, -3.93318e+02, -1.33319e+01), forces1[754], tol);
ASSERT_EQUAL_VEC(Vec3(-3.01456e+01, 1.45601e+02, -6.30440e+01), forces1[755], tol); ASSERT_EQUAL_VEC(Vec3(-3.01504e+01, 1.45593e+02, -6.30497e+01), forces1[755], tol);
ASSERT_EQUAL_VEC(Vec3(-2.76302e+02, -4.61707e+02, -2.69326e+02), forces1[756], tol); ASSERT_EQUAL_VEC(Vec3(-2.76292e+02, -4.61698e+02, -2.69332e+02), forces1[756], tol);
ASSERT_EQUAL_VEC(Vec3( 6.48643e+01, 3.68732e+02, 2.32241e+02), forces1[757], tol); ASSERT_EQUAL_VEC(Vec3( 6.48621e+01, 3.68736e+02, 2.32248e+02), forces1[757], tol);
ASSERT_EQUAL_VEC(Vec3(-4.48066e+02, 4.24010e+02, 2.00615e+02), forces1[758], tol); ASSERT_EQUAL_VEC(Vec3(-4.48067e+02, 4.24009e+02, 2.00610e+02), forces1[758], tol);
ASSERT_EQUAL_VEC(Vec3( 1.50167e+01, -7.33710e+01, 4.00845e+02), forces1[759], tol); ASSERT_EQUAL_VEC(Vec3( 1.50429e+01, -7.33695e+01, 4.00840e+02), forces1[759], tol);
ASSERT_EQUAL_VEC(Vec3( 4.06789e+02, 1.22310e+02, -3.26354e+02), forces1[760], tol); ASSERT_EQUAL_VEC(Vec3( 4.06786e+02, 1.22307e+02, -3.26363e+02), forces1[760], tol);
ASSERT_EQUAL_VEC(Vec3(-3.55725e+02, -4.23670e+02, 1.92964e+02), forces1[761], tol); ASSERT_EQUAL_VEC(Vec3(-3.55719e+02, -4.23669e+02, 1.92960e+02), forces1[761], tol);
ASSERT_EQUAL_VEC(Vec3(-4.78699e+01, 1.13409e+02, -4.55747e+02), forces1[762], tol); ASSERT_EQUAL_VEC(Vec3(-4.78729e+01, 1.13402e+02, -4.55740e+02), forces1[762], tol);
ASSERT_EQUAL_VEC(Vec3( 5.50239e+02, 3.20976e+02, -2.04107e+02), forces1[763], tol); ASSERT_EQUAL_VEC(Vec3( 5.50243e+02, 3.20969e+02, -2.04136e+02), forces1[763], tol);
ASSERT_EQUAL_VEC(Vec3(-3.98694e+01, 6.42940e+01, 2.62910e+02), forces1[764], tol); ASSERT_EQUAL_VEC(Vec3(-3.98710e+01, 6.43079e+01, 2.62905e+02), forces1[764], tol);
ASSERT_EQUAL_VEC(Vec3(-7.85277e+01, -7.50535e+01, -7.62971e+02), forces1[765], tol); ASSERT_EQUAL_VEC(Vec3(-7.85308e+01, -7.50634e+01, -7.62985e+02), forces1[765], tol);
ASSERT_EQUAL_VEC(Vec3( 9.58233e+00, -3.95506e+02, -8.95660e+01), forces1[766], tol); ASSERT_EQUAL_VEC(Vec3( 9.57106e+00, -3.95503e+02, -8.95762e+01), forces1[766], tol);
ASSERT_EQUAL_VEC(Vec3( 4.83241e+02, -7.40416e+02, -5.32398e+02), forces1[767], tol); ASSERT_EQUAL_VEC(Vec3( 4.83241e+02, -7.40429e+02, -5.32394e+02), forces1[767], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61813e+02, 8.15332e+01, 4.71842e+02), forces1[768], tol); ASSERT_EQUAL_VEC(Vec3(-1.61812e+02, 8.15330e+01, 4.71839e+02), forces1[768], tol);
ASSERT_EQUAL_VEC(Vec3(-3.30808e+02, -4.22092e+01, -1.05047e+03), forces1[769], tol); ASSERT_EQUAL_VEC(Vec3(-3.30804e+02, -4.22034e+01, -1.05047e+03), forces1[769], tol);
ASSERT_EQUAL_VEC(Vec3( 3.34227e+02, -1.34565e+02, 3.33962e+02), forces1[770], tol); ASSERT_EQUAL_VEC(Vec3( 3.34235e+02, -1.34572e+02, 3.33949e+02), forces1[770], tol);
ASSERT_EQUAL_VEC(Vec3( 2.25370e+01, 6.94648e+02, 3.48155e+01), forces1[771], tol); ASSERT_EQUAL_VEC(Vec3( 2.25419e+01, 6.94642e+02, 3.48219e+01), forces1[771], tol);
ASSERT_EQUAL_VEC(Vec3( 4.92298e+02, -3.56650e+02, 7.11590e+01), forces1[772], tol); ASSERT_EQUAL_VEC(Vec3( 4.92303e+02, -3.56656e+02, 7.11609e+01), forces1[772], tol);
ASSERT_EQUAL_VEC(Vec3( 2.17162e+02, 4.04913e+01, 3.47154e+02), forces1[773], tol); ASSERT_EQUAL_VEC(Vec3( 2.17147e+02, 4.05015e+01, 3.47170e+02), forces1[773], tol);
ASSERT_EQUAL_VEC(Vec3(-1.61139e+01, 1.47264e+03, 5.49805e+02), forces1[774], tol); ASSERT_EQUAL_VEC(Vec3(-1.61124e+01, 1.47264e+03, 5.49828e+02), forces1[774], tol);
ASSERT_EQUAL_VEC(Vec3( 8.39560e+01, -4.18454e+02, 2.34854e+02), forces1[775], tol); ASSERT_EQUAL_VEC(Vec3( 8.39474e+01, -4.18457e+02, 2.34855e+02), forces1[775], tol);
ASSERT_EQUAL_VEC(Vec3(-2.31372e+02, 2.37300e+02, 6.61509e+01), forces1[776], tol); ASSERT_EQUAL_VEC(Vec3(-2.31366e+02, 2.37297e+02, 6.61710e+01), forces1[776], tol);
ASSERT_EQUAL_VEC(Vec3(-6.24112e+01, -7.00150e+02, 4.91312e+02), forces1[777], tol); ASSERT_EQUAL_VEC(Vec3(-6.23896e+01, -7.00160e+02, 4.91298e+02), forces1[777], tol);
ASSERT_EQUAL_VEC(Vec3( 2.68236e+01, 2.47004e+02, 6.68818e-01), forces1[778], tol); ASSERT_EQUAL_VEC(Vec3( 2.68205e+01, 2.46992e+02, 6.51925e-01), forces1[778], tol);
ASSERT_EQUAL_VEC(Vec3( 5.26238e+02, 1.10200e+02, 3.46429e+02), forces1[779], tol); ASSERT_EQUAL_VEC(Vec3( 5.26229e+02, 1.10211e+02, 3.46425e+02), forces1[779], tol);
ASSERT_EQUAL_VEC(Vec3(-3.29270e+02, -3.87180e+02, 8.51858e+01), forces1[780], tol); ASSERT_EQUAL_VEC(Vec3(-3.29259e+02, -3.87187e+02, 8.51738e+01), forces1[780], tol);
ASSERT_EQUAL_VEC(Vec3( 6.42848e+02, 2.34891e+02, 3.71362e+02), forces1[781], tol); ASSERT_EQUAL_VEC(Vec3( 6.42840e+02, 2.34874e+02, 3.71367e+02), forces1[781], tol);
ASSERT_EQUAL_VEC(Vec3(-3.24657e+02, 5.64075e+02, -4.46171e+01), forces1[782], tol); ASSERT_EQUAL_VEC(Vec3(-3.24670e+02, 5.64060e+02, -4.45941e+01), forces1[782], tol);
ASSERT_EQUAL_VEC(Vec3( 5.74437e+01, 1.20266e+02, -5.84568e+01), forces1[783], tol); ASSERT_EQUAL_VEC(Vec3( 5.74639e+01, 1.20255e+02, -5.84555e+01), forces1[783], tol);
ASSERT_EQUAL_VEC(Vec3(-2.83819e+02, -2.10806e+02, 1.66008e+02), forces1[784], tol); ASSERT_EQUAL_VEC(Vec3(-2.83818e+02, -2.10789e+02, 1.66016e+02), forces1[784], tol);
ASSERT_EQUAL_VEC(Vec3( 4.01593e+02, -2.85126e+02, 2.49472e+02), forces1[785], tol); ASSERT_EQUAL_VEC(Vec3( 4.01586e+02, -2.85114e+02, 2.49462e+02), forces1[785], tol);
ASSERT_EQUAL_VEC(Vec3( 3.05495e+02, 7.04823e+02, -5.94583e+01), forces1[786], tol); ASSERT_EQUAL_VEC(Vec3( 3.05493e+02, 7.04816e+02, -5.94585e+01), forces1[786], tol);
ASSERT_EQUAL_VEC(Vec3(-5.06826e+02, 3.13595e+02, -7.30035e+02), forces1[787], tol); ASSERT_EQUAL_VEC(Vec3(-5.06832e+02, 3.13613e+02, -7.30025e+02), forces1[787], tol);
ASSERT_EQUAL_VEC(Vec3(-1.65626e+02, -1.02560e+02, -4.10505e+02), forces1[788], tol); ASSERT_EQUAL_VEC(Vec3(-1.65633e+02, -1.02565e+02, -4.10514e+02), forces1[788], tol);
ASSERT_EQUAL_VEC(Vec3( 2.50020e+02, 9.82334e+02, 3.08268e+02), forces1[789], tol); ASSERT_EQUAL_VEC(Vec3( 2.50011e+02, 9.82368e+02, 3.08282e+02), forces1[789], tol);
ASSERT_EQUAL_VEC(Vec3( 3.60207e+02, 3.06228e+02, 4.01442e+02), forces1[790], tol); ASSERT_EQUAL_VEC(Vec3( 3.60209e+02, 3.06214e+02, 4.01448e+02), forces1[790], tol);
ASSERT_EQUAL_VEC(Vec3(-5.15561e+02, -3.80896e+02, -2.65985e+02), forces1[791], tol); ASSERT_EQUAL_VEC(Vec3(-5.15566e+02, -3.80892e+02, -2.65987e+02), forces1[791], tol);
ASSERT_EQUAL_VEC(Vec3( 9.16925e+02, -2.71004e+02, 2.88903e+02), forces1[792], tol); ASSERT_EQUAL_VEC(Vec3( 9.16906e+02, -2.70982e+02, 2.88897e+02), forces1[792], tol);
ASSERT_EQUAL_VEC(Vec3( 5.58090e+01, 1.28558e+02, 4.36840e+02), forces1[793], tol); ASSERT_EQUAL_VEC(Vec3( 5.57959e+01, 1.28554e+02, 4.36834e+02), forces1[793], tol);
ASSERT_EQUAL_VEC(Vec3( 3.48845e+02, 3.63957e+02, 3.78554e+02), forces1[794], tol); ASSERT_EQUAL_VEC(Vec3( 3.48851e+02, 3.63953e+02, 3.78555e+02), forces1[794], tol);
ASSERT_EQUAL_VEC(Vec3( 6.36611e+02, -1.91579e+02, 4.14276e+02), forces1[795], tol); ASSERT_EQUAL_VEC(Vec3( 6.36621e+02, -1.91572e+02, 4.14270e+02), forces1[795], tol);
ASSERT_EQUAL_VEC(Vec3(-3.31210e+01, -1.47707e+02, 3.03799e+02), forces1[796], tol); ASSERT_EQUAL_VEC(Vec3(-3.31253e+01, -1.47718e+02, 3.03786e+02), forces1[796], tol);
ASSERT_EQUAL_VEC(Vec3(-8.19834e+01, -5.66602e+02, -7.77485e+01), forces1[797], tol); ASSERT_EQUAL_VEC(Vec3(-8.19713e+01, -5.66604e+02, -7.77410e+01), forces1[797], tol);
ASSERT_EQUAL_VEC(Vec3( 1.20345e+02, 3.66643e+02, -2.38047e+02), forces1[798], tol); ASSERT_EQUAL_VEC(Vec3( 1.20358e+02, 3.66650e+02, -2.38055e+02), forces1[798], tol);
ASSERT_EQUAL_VEC(Vec3( 3.60718e+02, 4.45416e+02, -6.03539e+02), forces1[799], tol); ASSERT_EQUAL_VEC(Vec3( 3.60706e+02, 4.45401e+02, -6.03554e+02), forces1[799], tol);
ASSERT_EQUAL_VEC(Vec3(-8.71267e+01, 1.63938e+02, -1.43935e+02), forces1[800], tol); ASSERT_EQUAL_VEC(Vec3(-8.71329e+01, 1.63947e+02, -1.43935e+02), forces1[800], tol);
ASSERT_EQUAL_VEC(Vec3(-9.98796e+01, 1.95932e+01, -5.85422e+01), forces1[801], tol); ASSERT_EQUAL_VEC(Vec3(-9.99017e+01, 1.95915e+01, -5.85374e+01), forces1[801], tol);
ASSERT_EQUAL_VEC(Vec3( 4.81452e+02, -7.03954e+01, -2.08017e+02), forces1[802], tol); ASSERT_EQUAL_VEC(Vec3( 4.81470e+02, -7.03993e+01, -2.08008e+02), forces1[802], tol);
ASSERT_EQUAL_VEC(Vec3(-7.69391e+02, 5.40321e+01, 5.38443e+02), forces1[803], tol); ASSERT_EQUAL_VEC(Vec3(-7.69394e+02, 5.40411e+01, 5.38431e+02), forces1[803], tol);
ASSERT_EQUAL_VEC(Vec3(-6.60815e+02, -1.87935e+02, 4.11986e+02), forces1[804], tol); ASSERT_EQUAL_VEC(Vec3(-6.60820e+02, -1.87929e+02, 4.11990e+02), forces1[804], tol);
ASSERT_EQUAL_VEC(Vec3( 1.06275e+02, 3.55338e+02, -2.27791e+02), forces1[805], tol); ASSERT_EQUAL_VEC(Vec3( 1.06278e+02, 3.55326e+02, -2.27795e+02), forces1[805], tol);
ASSERT_EQUAL_VEC(Vec3(-2.66099e+02, 2.41357e+02, -4.99254e+02), forces1[806], tol); ASSERT_EQUAL_VEC(Vec3(-2.66101e+02, 2.41367e+02, -4.99250e+02), forces1[806], tol);
ASSERT_EQUAL_VEC(Vec3(-5.22996e+01, 9.33706e+01, 7.23835e+02), forces1[807], tol); ASSERT_EQUAL_VEC(Vec3(-5.22955e+01, 9.33616e+01, 7.23845e+02), forces1[807], tol);
ASSERT_EQUAL_VEC(Vec3( 2.80524e+00, 6.04329e+01, 1.65509e+02), forces1[808], tol); ASSERT_EQUAL_VEC(Vec3( 2.82637e+00, 6.04183e+01, 1.65509e+02), forces1[808], tol);
ASSERT_EQUAL_VEC(Vec3(-2.97260e+02, -5.53590e+01, 3.87133e+02), forces1[809], tol); ASSERT_EQUAL_VEC(Vec3(-2.97247e+02, -5.53685e+01, 3.87138e+02), forces1[809], tol);
ASSERT_EQUAL_VEC(Vec3(-8.18636e+02, -2.66089e+02, 1.07281e+03), forces1[810], tol); ASSERT_EQUAL_VEC(Vec3(-8.18648e+02, -2.66083e+02, 1.07281e+03), forces1[810], tol);
ASSERT_EQUAL_VEC(Vec3(-2.43721e+02, -2.51626e+02, 3.46341e+02), forces1[811], tol); ASSERT_EQUAL_VEC(Vec3(-2.43734e+02, -2.51644e+02, 3.46336e+02), forces1[811], tol);
ASSERT_EQUAL_VEC(Vec3( 4.04761e+02, 1.12599e+02, -6.66763e+02), forces1[812], tol); ASSERT_EQUAL_VEC(Vec3( 4.04771e+02, 1.12611e+02, -6.66755e+02), forces1[812], tol);
ASSERT_EQUAL_VEC(Vec3(-8.30900e+01, -9.75688e+01, -5.15294e+02), forces1[813], tol); ASSERT_EQUAL_VEC(Vec3(-8.30809e+01, -9.75613e+01, -5.15283e+02), forces1[813], tol);
ASSERT_EQUAL_VEC(Vec3(-8.88964e+01, -2.43588e+02, -4.28240e+02), forces1[814], tol); ASSERT_EQUAL_VEC(Vec3(-8.88969e+01, -2.43585e+02, -4.28237e+02), forces1[814], tol);
ASSERT_EQUAL_VEC(Vec3(-9.15440e+01, 4.50373e+02, -2.64172e+02), forces1[815], tol); ASSERT_EQUAL_VEC(Vec3(-9.15331e+01, 4.50369e+02, -2.64187e+02), forces1[815], tol);
ASSERT_EQUAL_VEC(Vec3(-9.11725e+01, 4.24902e+02, -1.85119e+02), forces1[816], tol); ASSERT_EQUAL_VEC(Vec3(-9.11685e+01, 4.24897e+02, -1.85102e+02), forces1[816], tol);
ASSERT_EQUAL_VEC(Vec3(-3.91187e+02, -6.86420e+02, 1.52738e+02), forces1[817], tol); ASSERT_EQUAL_VEC(Vec3(-3.91181e+02, -6.86407e+02, 1.52727e+02), forces1[817], tol);
ASSERT_EQUAL_VEC(Vec3(-8.21209e+01, -2.49526e+02, 5.27507e+02), forces1[818], tol); ASSERT_EQUAL_VEC(Vec3(-8.21105e+01, -2.49526e+02, 5.27526e+02), forces1[818], tol);
ASSERT_EQUAL_VEC(Vec3(-1.09398e+02, -6.29107e+02, 3.34941e+02), forces1[819], tol); ASSERT_EQUAL_VEC(Vec3(-1.09397e+02, -6.29100e+02, 3.34949e+02), forces1[819], tol);
ASSERT_EQUAL_VEC(Vec3(-4.17360e+02, -9.10791e+01, -3.54803e+01), forces1[820], tol); ASSERT_EQUAL_VEC(Vec3(-4.17364e+02, -9.10769e+01, -3.54884e+01), forces1[820], tol);
ASSERT_EQUAL_VEC(Vec3( 2.79511e+02, -5.39058e+02, 5.07386e+02), forces1[821], tol); ASSERT_EQUAL_VEC(Vec3( 2.79520e+02, -5.39057e+02, 5.07383e+02), forces1[821], tol);
ASSERT_EQUAL_VEC(Vec3( 2.14807e+02, 1.92028e+01, -3.14827e+02), forces1[822], tol); ASSERT_EQUAL_VEC(Vec3( 2.14808e+02, 1.92238e+01, -3.14844e+02), forces1[822], tol);
ASSERT_EQUAL_VEC(Vec3(-1.92615e+02, -4.26147e+02, -6.21474e+00), forces1[823], tol); ASSERT_EQUAL_VEC(Vec3(-1.92606e+02, -4.26137e+02, -6.21690e+00), forces1[823], tol);
ASSERT_EQUAL_VEC(Vec3(-6.55141e+02, -4.86081e+02, -3.89405e+02), forces1[824], tol); ASSERT_EQUAL_VEC(Vec3(-6.55144e+02, -4.86084e+02, -3.89405e+02), forces1[824], tol);
ASSERT_EQUAL_VEC(Vec3(-1.89859e+02, -3.77323e+02, -1.36212e+02), forces1[825], tol); ASSERT_EQUAL_VEC(Vec3(-1.89858e+02, -3.77314e+02, -1.36225e+02), forces1[825], tol);
ASSERT_EQUAL_VEC(Vec3( 4.60005e+02, 1.99075e+02, 2.82594e+02), forces1[826], tol); ASSERT_EQUAL_VEC(Vec3( 4.60006e+02, 1.99089e+02, 2.82592e+02), forces1[826], tol);
ASSERT_EQUAL_VEC(Vec3( 1.21552e+02, -1.21212e+02, 7.24048e+02), forces1[827], tol); ASSERT_EQUAL_VEC(Vec3( 1.21553e+02, -1.21221e+02, 7.24045e+02), forces1[827], tol);
ASSERT_EQUAL_VEC(Vec3(-9.16915e+01, 7.09379e+01, 7.89108e+01), forces1[828], tol); ASSERT_EQUAL_VEC(Vec3(-9.16961e+01, 7.09417e+01, 7.89088e+01), forces1[828], tol);
ASSERT_EQUAL_VEC(Vec3(-3.83832e+02, 8.44797e+01, 1.09603e+03), forces1[829], tol); ASSERT_EQUAL_VEC(Vec3(-3.83816e+02, 8.44889e+01, 1.09603e+03), forces1[829], tol);
ASSERT_EQUAL_VEC(Vec3(-3.65385e+02, -1.88801e+02, 4.62336e+02), forces1[830], tol); ASSERT_EQUAL_VEC(Vec3(-3.65376e+02, -1.88809e+02, 4.62338e+02), forces1[830], tol);
ASSERT_EQUAL_VEC(Vec3( 5.76333e+02, -9.42224e+01, -1.98149e+02), forces1[831], tol); ASSERT_EQUAL_VEC(Vec3( 5.76327e+02, -9.42016e+01, -1.98144e+02), forces1[831], tol);
ASSERT_EQUAL_VEC(Vec3(-4.21546e+02, -5.96852e+01, -8.33519e+02), forces1[832], tol); ASSERT_EQUAL_VEC(Vec3(-4.21543e+02, -5.96901e+01, -8.33520e+02), forces1[832], tol);
ASSERT_EQUAL_VEC(Vec3( 1.20308e+03, 4.53520e+02, 2.29402e+02), forces1[833], tol); ASSERT_EQUAL_VEC(Vec3( 1.20308e+03, 4.53517e+02, 2.29384e+02), forces1[833], tol);
ASSERT_EQUAL_VEC(Vec3( 2.92104e+02, 4.13344e+01, -3.61129e+02), forces1[834], tol); ASSERT_EQUAL_VEC(Vec3( 2.92105e+02, 4.13134e+01, -3.61124e+02), forces1[834], tol);
ASSERT_EQUAL_VEC(Vec3( 2.49884e+02, -1.26755e+02, 2.01745e+02), forces1[835], tol); ASSERT_EQUAL_VEC(Vec3( 2.49880e+02, -1.26751e+02, 2.01746e+02), forces1[835], tol);
ASSERT_EQUAL_VEC(Vec3( 4.82080e+02, -4.36696e+02, 2.10915e+02), forces1[836], tol); ASSERT_EQUAL_VEC(Vec3( 4.82079e+02, -4.36678e+02, 2.10916e+02), forces1[836], tol);
ASSERT_EQUAL_VEC(Vec3( 7.39224e+00, -3.07856e+02, -2.19285e+02), forces1[837], tol); ASSERT_EQUAL_VEC(Vec3( 7.40340e+00, -3.07867e+02, -2.19268e+02), forces1[837], tol);
ASSERT_EQUAL_VEC(Vec3(-1.77938e+02, -1.78459e+02, 3.27353e+02), forces1[838], tol); ASSERT_EQUAL_VEC(Vec3(-1.77931e+02, -1.78462e+02, 3.27369e+02), forces1[838], tol);
ASSERT_EQUAL_VEC(Vec3(-1.43503e+02, 2.36671e+02, 1.76247e+02), forces1[839], tol); ASSERT_EQUAL_VEC(Vec3(-1.43493e+02, 2.36669e+02, 1.76242e+02), forces1[839], tol);
ASSERT_EQUAL_VEC(Vec3(-3.11000e+02, 3.30156e+01, 2.29463e+02), forces1[840], tol); ASSERT_EQUAL_VEC(Vec3(-3.11001e+02, 3.30086e+01, 2.29454e+02), forces1[840], tol);
ASSERT_EQUAL_VEC(Vec3( 7.16508e+01, -1.44157e+00, -8.22927e+02), forces1[841], tol); ASSERT_EQUAL_VEC(Vec3( 7.16440e+01, -1.42656e+00, -8.22932e+02), forces1[841], tol);
ASSERT_EQUAL_VEC(Vec3(-2.21654e+02, -4.50385e+01, -4.49965e+02), forces1[842], tol); ASSERT_EQUAL_VEC(Vec3(-2.21653e+02, -4.50533e+01, -4.49967e+02), forces1[842], tol);
ASSERT_EQUAL_VEC(Vec3(-4.26333e+02, -2.93350e+02, 2.05061e+02), forces1[843], tol); ASSERT_EQUAL_VEC(Vec3(-4.26325e+02, -2.93355e+02, 2.05051e+02), forces1[843], tol);
ASSERT_EQUAL_VEC(Vec3( 8.06761e+01, 3.83779e+02, 4.54340e+02), forces1[844], tol); ASSERT_EQUAL_VEC(Vec3( 8.06715e+01, 3.83773e+02, 4.54367e+02), forces1[844], tol);
ASSERT_EQUAL_VEC(Vec3( 1.36431e+01, -1.12109e+02, -2.08560e+02), forces1[845], tol); ASSERT_EQUAL_VEC(Vec3( 1.36370e+01, -1.12119e+02, -2.08559e+02), forces1[845], tol);
ASSERT_EQUAL_VEC(Vec3(-4.31330e+01, 1.28726e+02, 2.40989e+02), forces1[846], tol); ASSERT_EQUAL_VEC(Vec3(-4.31375e+01, 1.28705e+02, 2.40993e+02), forces1[846], tol);
ASSERT_EQUAL_VEC(Vec3( 3.71926e+02, 3.66500e+02, -1.02564e+02), forces1[847], tol); ASSERT_EQUAL_VEC(Vec3( 3.71930e+02, 3.66483e+02, -1.02572e+02), forces1[847], tol);
ASSERT_EQUAL_VEC(Vec3(-2.30317e+02, 7.54917e+02, 1.07603e+02), forces1[848], tol); ASSERT_EQUAL_VEC(Vec3(-2.30298e+02, 7.54918e+02, 1.07591e+02), forces1[848], tol);
ASSERT_EQUAL_VEC(Vec3( 2.67842e+02, -1.52213e+01, -1.70088e+02), forces1[849], tol); ASSERT_EQUAL_VEC(Vec3( 2.67868e+02, -1.52050e+01, -1.70085e+02), forces1[849], tol);
ASSERT_EQUAL_VEC(Vec3(-9.39289e+02, 5.64142e+01, -2.22390e+02), forces1[850], tol); ASSERT_EQUAL_VEC(Vec3(-9.39293e+02, 5.64192e+01, -2.22390e+02), forces1[850], tol);
ASSERT_EQUAL_VEC(Vec3(-1.01321e+02, 3.31056e+02, 7.07374e+02), forces1[851], tol); ASSERT_EQUAL_VEC(Vec3(-1.01320e+02, 3.31059e+02, 7.07374e+02), forces1[851], tol);
ASSERT_EQUAL_VEC(Vec3( 1.78190e+02, 8.50377e+01, -6.39941e+02), forces1[852], tol); ASSERT_EQUAL_VEC(Vec3( 1.78173e+02, 8.50286e+01, -6.39943e+02), forces1[852], tol);
ASSERT_EQUAL_VEC(Vec3( 3.33076e+02, 9.10257e+01, 1.20449e+02), forces1[853], tol); ASSERT_EQUAL_VEC(Vec3( 3.33072e+02, 9.10202e+01, 1.20449e+02), forces1[853], tol);
ASSERT_EQUAL_VEC(Vec3( 4.22506e+01, -7.37193e+02, 6.08437e+02), forces1[854], tol); ASSERT_EQUAL_VEC(Vec3( 4.22307e+01, -7.37185e+02, 6.08442e+02), forces1[854], tol);
ASSERT_EQUAL_VEC(Vec3(-4.16911e+02, -4.82542e+02, 3.91831e+01), forces1[855], tol); ASSERT_EQUAL_VEC(Vec3(-4.16912e+02, -4.82533e+02, 3.91904e+01), forces1[855], tol);
ASSERT_EQUAL_VEC(Vec3(-4.09101e+02, -1.95374e+02, -1.49056e+02), forces1[856], tol); ASSERT_EQUAL_VEC(Vec3(-4.09092e+02, -1.95397e+02, -1.49049e+02), forces1[856], tol);
ASSERT_EQUAL_VEC(Vec3(-2.89280e+01, 3.78185e+02, 2.19681e+02), forces1[857], tol); ASSERT_EQUAL_VEC(Vec3(-2.89402e+01, 3.78193e+02, 2.19684e+02), forces1[857], tol);
ASSERT_EQUAL_VEC(Vec3(-2.77573e+02, 7.90343e+01, 3.49454e+02), forces1[858], tol); ASSERT_EQUAL_VEC(Vec3(-2.77581e+02, 7.90343e+01, 3.49462e+02), forces1[858], tol);
ASSERT_EQUAL_VEC(Vec3( 4.71076e+02, -1.88924e+02, -2.48137e+02), forces1[859], tol); ASSERT_EQUAL_VEC(Vec3( 4.71062e+02, -1.88929e+02, -2.48123e+02), forces1[859], tol);
ASSERT_EQUAL_VEC(Vec3(-1.51512e+02, 4.96286e+01, -2.65468e+02), forces1[860], tol); ASSERT_EQUAL_VEC(Vec3(-1.51510e+02, 4.96268e+01, -2.65476e+02), forces1[860], tol);
ASSERT_EQUAL_VEC(Vec3(-7.66399e+02, 8.46707e+01, -3.64826e+02), forces1[861], tol); ASSERT_EQUAL_VEC(Vec3(-7.66386e+02, 8.46641e+01, -3.64816e+02), forces1[861], tol);
ASSERT_EQUAL_VEC(Vec3(-5.09768e+02, 2.10708e+01, 3.01831e+02), forces1[862], tol); ASSERT_EQUAL_VEC(Vec3(-5.09778e+02, 2.10810e+01, 3.01816e+02), forces1[862], tol);
ASSERT_EQUAL_VEC(Vec3(-9.74773e+00, 7.12284e+01, 9.37965e+01), forces1[863], tol); ASSERT_EQUAL_VEC(Vec3(-9.74895e+00, 7.12371e+01, 9.37892e+01), forces1[863], tol);
ASSERT_EQUAL_VEC(Vec3( 9.17045e+01, -4.41200e+02, -1.00403e+02), forces1[864], tol); ASSERT_EQUAL_VEC(Vec3( 9.17307e+01, -4.41188e+02, -1.00390e+02), forces1[864], tol);
ASSERT_EQUAL_VEC(Vec3(-2.52886e+01, -1.90235e+02, 4.81425e+01), forces1[865], tol); ASSERT_EQUAL_VEC(Vec3(-2.52934e+01, -1.90242e+02, 4.81585e+01), forces1[865], tol);
ASSERT_EQUAL_VEC(Vec3(-5.44286e+02, 2.54802e+02, -1.75174e+02), forces1[866], tol); ASSERT_EQUAL_VEC(Vec3(-5.44265e+02, 2.54798e+02, -1.75185e+02), forces1[866], tol);
ASSERT_EQUAL_VEC(Vec3( 4.08140e+02, -1.23552e+02, -2.06950e+02), forces1[867], tol); ASSERT_EQUAL_VEC(Vec3( 4.08129e+02, -1.23564e+02, -2.06955e+02), forces1[867], tol);
ASSERT_EQUAL_VEC(Vec3( 4.38394e+02, -1.73655e+02, 4.68132e+02), forces1[868], tol); ASSERT_EQUAL_VEC(Vec3( 4.38403e+02, -1.73663e+02, 4.68123e+02), forces1[868], tol);
ASSERT_EQUAL_VEC(Vec3(-3.66083e+02, 3.32516e+02, 2.43512e+02), forces1[869], tol); ASSERT_EQUAL_VEC(Vec3(-3.66073e+02, 3.32526e+02, 2.43522e+02), forces1[869], tol);
ASSERT_EQUAL_VEC(Vec3( 2.09675e+02, 2.98066e+02, -4.55259e+02), forces1[870], tol); ASSERT_EQUAL_VEC(Vec3( 2.09695e+02, 2.98063e+02, -4.55262e+02), forces1[870], tol);
ASSERT_EQUAL_VEC(Vec3( 4.70593e+01, -8.03949e+01, 1.44531e+02), forces1[871], tol); ASSERT_EQUAL_VEC(Vec3( 4.70466e+01, -8.03891e+01, 1.44535e+02), forces1[871], tol);
ASSERT_EQUAL_VEC(Vec3( 4.51460e+01, -3.68233e+02, 2.65394e+02), forces1[872], tol); ASSERT_EQUAL_VEC(Vec3( 4.51402e+01, -3.68229e+02, 2.65397e+02), forces1[872], tol);
ASSERT_EQUAL_VEC(Vec3(-2.22413e+02, 4.99716e+02, 1.50950e+02), forces1[873], tol); ASSERT_EQUAL_VEC(Vec3(-2.22430e+02, 4.99723e+02, 1.50953e+02), forces1[873], tol);
ASSERT_EQUAL_VEC(Vec3(-3.32900e+02, 7.08247e+02, -2.53300e+02), forces1[874], tol); ASSERT_EQUAL_VEC(Vec3(-3.32916e+02, 7.08253e+02, -2.53294e+02), forces1[874], tol);
ASSERT_EQUAL_VEC(Vec3(-2.24307e+02, 3.61215e+02, 3.14051e+02), forces1[875], tol); ASSERT_EQUAL_VEC(Vec3(-2.24293e+02, 3.61211e+02, 3.14058e+02), forces1[875], tol);
ASSERT_EQUAL_VEC(Vec3( 2.86053e+01, 3.62423e+02, -2.26045e+01), forces1[876], tol); ASSERT_EQUAL_VEC(Vec3( 2.86069e+01, 3.62417e+02, -2.25939e+01), forces1[876], tol);
ASSERT_EQUAL_VEC(Vec3( 3.25317e+02, -8.59836e+01, 6.05375e+02), forces1[877], tol); ASSERT_EQUAL_VEC(Vec3( 3.25305e+02, -8.59847e+01, 6.05371e+02), forces1[877], tol);
ASSERT_EQUAL_VEC(Vec3( 3.08148e+02, 2.08400e+02, -3.04899e+02), forces1[878], tol); ASSERT_EQUAL_VEC(Vec3( 3.08168e+02, 2.08408e+02, -3.04918e+02), forces1[878], tol);
ASSERT_EQUAL_VEC(Vec3( 3.65572e+02, 1.38329e+02, 2.10352e+02), forces1[879], tol); ASSERT_EQUAL_VEC(Vec3( 3.65569e+02, 1.38315e+02, 2.10354e+02), forces1[879], tol);
ASSERT_EQUAL_VEC(Vec3( 6.56819e+01, 4.57985e+02, -1.05224e+02), forces1[880], tol); ASSERT_EQUAL_VEC(Vec3( 6.56765e+01, 4.57994e+02, -1.05220e+02), forces1[880], tol);
ASSERT_EQUAL_VEC(Vec3(-7.04585e+02, 1.95853e+02, 6.29407e+01), forces1[881], tol); ASSERT_EQUAL_VEC(Vec3(-7.04583e+02, 1.95861e+02, 6.29259e+01), forces1[881], tol);
ASSERT_EQUAL_VEC(Vec3(-5.03174e+02, -4.91099e+02, 2.39631e+00), forces1[882], tol); ASSERT_EQUAL_VEC(Vec3(-5.03165e+02, -4.91098e+02, 2.40840e+00), forces1[882], tol);
ASSERT_EQUAL_VEC(Vec3(-6.84532e+01, 8.09437e+01, 2.50201e+02), forces1[883], tol); ASSERT_EQUAL_VEC(Vec3(-6.84653e+01, 8.09254e+01, 2.50208e+02), forces1[883], tol);
ASSERT_EQUAL_VEC(Vec3(-5.34894e+01, 1.91739e+02, -1.93680e+02), forces1[884], tol); ASSERT_EQUAL_VEC(Vec3(-5.35069e+01, 1.91749e+02, -1.93660e+02), forces1[884], tol);
ASSERT_EQUAL_VEC(Vec3( 5.56353e+02, -6.69139e+02, -2.99818e+02), forces1[885], tol); ASSERT_EQUAL_VEC(Vec3( 5.56345e+02, -6.69144e+02, -2.99821e+02), forces1[885], tol);
ASSERT_EQUAL_VEC(Vec3(-3.35822e+02, 5.18658e+01, -2.16393e+02), forces1[886], tol); ASSERT_EQUAL_VEC(Vec3(-3.35809e+02, 5.18670e+01, -2.16408e+02), forces1[886], tol);
ASSERT_EQUAL_VEC(Vec3(-1.13163e+02, 6.22995e+02, -1.73825e+01), forces1[887], tol); ASSERT_EQUAL_VEC(Vec3(-1.13154e+02, 6.23001e+02, -1.73934e+01), forces1[887], tol);
ASSERT_EQUAL_VEC(Vec3(-4.64226e+02, -2.03176e+02, 4.33716e+02), forces1[888], tol); ASSERT_EQUAL_VEC(Vec3(-4.64234e+02, -2.03165e+02, 4.33719e+02), forces1[888], tol);
ASSERT_EQUAL_VEC(Vec3( 5.74856e+01, -4.61834e+02, -4.22531e+02), forces1[889], tol); ASSERT_EQUAL_VEC(Vec3( 5.74659e+01, -4.61823e+02, -4.22519e+02), forces1[889], tol);
ASSERT_EQUAL_VEC(Vec3(-3.53688e+02, 1.04004e+02, 1.47412e+02), forces1[890], tol); ASSERT_EQUAL_VEC(Vec3(-3.53687e+02, 1.03995e+02, 1.47418e+02), forces1[890], tol);
ASSERT_EQUAL_VEC(Vec3( 9.55563e+01, 4.15265e+02, 1.37732e+02), forces1[891], tol); ASSERT_EQUAL_VEC(Vec3( 9.55591e+01, 4.15281e+02, 1.37721e+02), forces1[891], tol);
ASSERT_EQUAL_VEC(Vec3( 4.43125e+02, -3.69927e+01, -4.01932e+02), forces1[892], tol); ASSERT_EQUAL_VEC(Vec3( 4.43132e+02, -3.70019e+01, -4.01946e+02), forces1[892], tol);
ASSERT_EQUAL_VEC(Vec3( 1.26678e+02, -2.55277e+02, 1.49226e+02), forces1[893], tol); ASSERT_EQUAL_VEC(Vec3( 1.26695e+02, -2.55273e+02, 1.49235e+02), forces1[893], tol);
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment