aselimov/cudaCAC
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Change default precision to float and use float4 for force and potential calculations

Browse source
This commit is contained in:
Alex Selimov 2025-09-12 21:44:41 -04:00
parent dd83fc6330
commit 130b613a7c
Signed by: aselimov
GPG key ID: 3DDB9C3E023F1F31
9 changed files with 151 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

89
tests/cuda_unit_tests/test_forces.cu
View file

@ -55,33 +55,30 @@ protected:
}
// Helper function to run the force calculation kernel
std::pair<std::vector<real>, std::vector<real>>
run_force_calculation(int n_particles, const std::vector<real> &positions,
std::vector<float4>
run_force_calculation(int n_particles, const std::vector<float4> &positions,
const std::vector<real> &box_dimensions) {
std::vector<real> forces(3 * n_particles, 0.0);
std::vector<real> energies(n_particles, 0.0);
std::vector<float4> force_energies(n_particles,
make_float4(0.0, 0.0, 0.0, 0.0));
real *d_positions = allocateAndCopyToGPU(positions);
real *d_forces = allocateAndCopyToGPU(forces);
real *d_energies = allocateAndCopyToGPU(energies);
float4 *d_positions = allocateAndCopyToGPU(positions);
float4 *d_force_energies = allocateAndCopyToGPU(force_energies);
real *d_box_len = allocateAndCopyToGPU(box_dimensions);
std::vector<PairPotentials> potentials = {LennardJones(1.0, 1.0, 3.0)};
CAC::launch_force_kernels(d_positions, d_forces, d_energies, n_particles,
CAC::launch_force_kernels(d_positions, d_force_energies, n_particles,
d_box_len, potentials, GRID_SIZE, BLOCK_SIZE);
checkCudaError(cudaGetLastError(), "kernel launch");
checkCudaError(cudaDeviceSynchronize(), "kernel execution");
std::vector<real> result_forces =
copyFromGPUAndFree(d_forces, 3 * n_particles);
std::vector<real> result_energies =
copyFromGPUAndFree(d_energies, n_particles);
std::vector<float4> result_force_energies =
copyFromGPUAndFree(d_force_energies, n_particles);
checkCudaError(cudaFree(d_positions), "cudaFree positions");
checkCudaError(cudaFree(d_box_len), "cudaFree box_len");
return {result_forces, result_energies};
return result_force_energies;
}
};
@ -90,14 +87,14 @@ TEST_F(CudaForceKernelTest, BasicFunctionalityTest) {
const real tolerance = 1e-5;
// Set up test data - simple 2x2 grid of particles
std::vector<real> positions = {
0.0, 0.0, 0.0, // particle 0
0.5, 0.0, 0.0, // particle 1
std::vector<float4> positions = {
make_float4(0.0, 0.0, 0.0, 0.0), // particle 0
make_float4(0.5, 0.0, 0.0, 0.0), // particle 1
};
std::vector<real> box_dimensions = {10.0, 10.0, 10.0};
auto [result_forces, result_energies] =
auto result_force_energies =
run_force_calculation(n_particles, positions, box_dimensions);
// Verify results - forces should be non-zero and energies should be
@ -105,17 +102,14 @@ TEST_F(CudaForceKernelTest, BasicFunctionalityTest) {
bool has_nonzero_force = false;
bool has_nonzero_energy = false;
for (int i = 0; i < 3 * n_particles; i++) {
if (std::abs(result_forces[i]) > tolerance) {
has_nonzero_force = true;
break;
}
}
for (int i = 0; i < n_particles; i++) {
if (std::abs(result_energies[i]) > tolerance) {
if (std::abs(result_force_energies[i].x) > tolerance ||
std::abs(result_force_energies[i].y) > tolerance ||
std::abs(result_force_energies[i].z) > tolerance) {
has_nonzero_force = true;
}
if (std::abs(result_force_energies[i].w) > tolerance) {
has_nonzero_energy = true;
break;
}
}
@ -130,60 +124,61 @@ TEST_F(CudaForceKernelTest, PeriodicBoundaryConditionsTest) {
const real tolerance = 1e-5;
// Place particles near opposite edges of a small box
std::vector<real> positions = {
0.1, 0.0, 0.0, // particle 0 near left edge
4.9, 0.0, 0.0 // particle 1 near right edge
std::vector<float4> positions = {
make_float4(0.1, 0.0, 0.0, 0.0), // particle 0 near left edge
make_float4(4.9, 0.0, 0.0, 0.0) // particle 1 near right edge
};
std::vector<real> box_dimensions = {5.0, 5.0, 5.0}; // Small box to test PBC
auto [result_forces, result_energies] =
auto result_force_energies =
run_force_calculation(n_particles, positions, box_dimensions);
// With PBC, particles should interact as if they're close (distance ~0.2)
// rather than far apart (distance ~4.8)
EXPECT_GT(std::abs(result_forces[0]), tolerance)
EXPECT_GT(std::abs(result_force_energies[0].x), tolerance)
<< "Expected significant force due to PBC";
EXPECT_GT(std::abs(result_energies[0]), tolerance)
<< "Expected significant energy due to PBC";
}
TEST_F(CudaForceKernelTest, SingleParticleTest) {
const int n_particles = 1;
std::vector<real> positions = {0.0, 0.0, 0.0};
std::vector<float4> positions = {make_float4(0.0, 0.0, 0.0, 0.0)};
std::vector<real> box_dimensions = {10.0, 10.0, 10.0};
auto [result_forces, result_energies] =
auto result_force_energies =
run_force_calculation(n_particles, positions, box_dimensions);
// Single particle should have zero force and energy
EXPECT_NEAR(result_forces[0], 0.0, 1e-10);
EXPECT_NEAR(result_forces[1], 0.0, 1e-10);
EXPECT_NEAR(result_forces[2], 0.0, 1e-10);
EXPECT_NEAR(result_energies[0], 0.0, 1e-10);
EXPECT_NEAR(result_force_energies[0].x, 0.0, 1e-10);
EXPECT_NEAR(result_force_energies[0].y, 0.0, 1e-10);
EXPECT_NEAR(result_force_energies[0].z, 0.0, 1e-10);
EXPECT_NEAR(result_force_energies[0].w, 0.0, 1e-10);
}
TEST_F(CudaForceKernelTest, ForceSymmetryTest) {
const int n_particles = 2;
const real tolerance = 1e-5;
std::vector<real> positions = {
0.0, 0.0, 0.0, // particle 0
1.5, 0.0, 0.0 // particle 1
std::vector<float4> positions = {
make_float4(0.0, 0.0, 0.0, 0.0), // particle 0
make_float4(1.5, 0.0, 0.0, 0.0) // particle 1
};
std::vector<real> box_dimensions = {10.0, 10.0, 10.0};
auto [result_forces, result_energies] =
auto result_force_energies =
run_force_calculation(n_particles, positions, box_dimensions);
// Newton's third law: forces should be equal and opposite
EXPECT_NEAR(result_forces[0], -result_forces[3], tolerance)
EXPECT_NEAR(result_force_energies[0].x, -result_force_energies[1].x,
tolerance)
<< "Force x-components should be opposite";
EXPECT_NEAR(result_forces[1], -result_forces[4], tolerance)
EXPECT_NEAR(result_force_energies[0].y, -result_force_energies[1].y,
tolerance)
<< "Force y-components should be opposite";
EXPECT_NEAR(result_forces[2], -result_forces[5], tolerance)
EXPECT_NEAR(result_force_energies[0].z, -result_force_energies[1].z,
tolerance)
<< "Force z-components should be opposite";
// Energies should be equal for symmetric particles
EXPECT_NEAR(result_energies[0], result_energies[1], tolerance)
EXPECT_NEAR(result_force_energies[0].w, result_force_energies[1].w, tolerance)
<< "Energies should be equal";
}

147
tests/cuda_unit_tests/test_potential.cu
View file

@ -2,6 +2,7 @@
#include "precision.hpp"
#include "gtest/gtest.h"
#include <cmath>
#include <cstdio>
#include <cuda_runtime.h>
// Structure to hold test results from device
@ -18,8 +19,7 @@ struct TestResults {
bool near_cutoff_pass;
// Additional result data for exact checks
real energy_values[10];
Vec3<real> force_values[10];
float4 force_energy_values[10];
};
// Check if two Vec3 values are close within tolerance
@ -35,7 +35,7 @@ __global__ void lennard_jones_test_kernel(TestResults *results) {
real sigma = 1.0;
real epsilon = 1.0;
real r_cutoff = 2.5;
real tolerance = 1e-10;
real tolerance = 1e-5;
// Create LennardJones object on device
LennardJones lj(sigma, epsilon, r_cutoff);
@ -43,87 +43,78 @@ __global__ void lennard_jones_test_kernel(TestResults *results) {
// Zero Distance Test
{
Vec3<real> r = {0.0, 0.0, 0.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[0] = result.energy;
results->force_values[0] = result.force;
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[0] = result;
results->zero_distance_pass =
(result.energy == 0.0) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0}, result.force, tolerance);
(result.w == 0.0) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0},
Vec3<real>{result.x, result.y, result.z}, tolerance);
}
// Beyond Cutoff Test
{
Vec3<real> r = {3.0, 0.0, 0.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[1] = result.energy;
results->force_values[1] = result.force;
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[1] = result;
results->beyond_cutoff_pass =
(result.energy == 0.0) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0}, result.force, tolerance);
(result.w == 0.0) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0},
Vec3<real>{result.x, result.y, result.z}, tolerance);
}
// At Minimum Test
{
real min_dist = pow(2.0, 1.0 / 6.0) * sigma;
Vec3<real> r = {min_dist, 0.0, 0.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[2] = result.energy;
results->force_values[2] = result.force;
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[2] = result;
results->at_minimum_pass =
(fabs(result.energy + epsilon) < tolerance) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0}, result.force, tolerance);
(fabs(result.w + epsilon) < tolerance) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0},
Vec3<real>{result.x, result.y, result.z}, tolerance);
}
// At Equilibrium Test
{
Vec3<real> r = {sigma, 0.0, 0.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[3] = result.energy;
results->force_values[3] = result.force;
results->at_equilibrium_pass = (fabs(result.energy) < tolerance) &&
(result.force.x > 0.0) &&
(fabs(result.force.y) < tolerance) &&
(fabs(result.force.z) < tolerance);
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[3] = result;
results->at_equilibrium_pass =
(fabs(result.w) < tolerance) && (result.x > 0.0) &&
(fabs(result.y) < tolerance) && (fabs(result.z) < tolerance);
}
// Repulsive Region Test
{
Vec3<real> r = {0.8 * sigma, 0.0, 0.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[4] = result.energy;
results->force_values[4] = result.force;
results->repulsive_region_pass =
(result.energy > 0.0) && (result.force.x > 0.0);
Vec3<real> r = {0.8f * sigma, 0.0, 0.0};
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[4] = result;
results->repulsive_region_pass = (result.w > 0.0) && (result.x > 0.0);
}
// Attractive Region Test
{
Vec3<real> r = {1.5 * sigma, 0.0, 0.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[5] = result.energy;
results->force_values[5] = result.force;
results->attractive_region_pass =
(result.energy < 0.0) && (result.force.x < 0.0);
Vec3<real> r = {1.5f * sigma, 0.0, 0.0};
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[5] = result;
results->attractive_region_pass = (result.w < 0.0) && (result.x < 0.0);
}
// Arbitrary Direction Test
{
Vec3<real> r = {1.0, 1.0, 1.0};
auto result = lj.calc_force_and_energy(r);
results->energy_values[6] = result.energy;
results->force_values[6] = result.force;
float4 result = lj.calc_force_and_energy(r);
results->force_energy_values[6] = result;
real r_mag = sqrt(r.squared_norm2());
Vec3<real> normalized_r = r.scale(1.0 / r_mag);
real force_dot_r = result.force.x * normalized_r.x +
result.force.y * normalized_r.y +
result.force.z * normalized_r.z;
real force_dot_r = result.x * normalized_r.x + result.y * normalized_r.y +
result.z * normalized_r.z;
results->arbitrary_direction_pass =
(force_dot_r < 0.0) &&
(fabs(result.force.x - result.force.y) < tolerance) &&
(fabs(result.force.y - result.force.z) < tolerance);
(force_dot_r < 0.0) && (fabs(result.x - result.y) < tolerance) &&
(fabs(result.y - result.z) < tolerance);
}
// Parameter Variation Test
@ -135,34 +126,31 @@ __global__ void lennard_jones_test_kernel(TestResults *results) {
LennardJones lj2(new_sigma, new_epsilon, new_r_cutoff);
Vec3<real> r = {2.0, 0.0, 0.0};
auto result1 = lj.calc_force_and_energy(r);
auto result2 = lj2.calc_force_and_energy(r);
float4 result1 = lj.calc_force_and_energy(r);
float4 result2 = lj2.calc_force_and_energy(r);
results->energy_values[7] = result2.energy;
results->force_values[7] = result2.force;
results->force_energy_values[7] = result2;
results->parameter_variation_pass = (result1.energy != result2.energy) &&
(result1.force.x != result2.force.x);
results->parameter_variation_pass =
(result1.w != result2.w) && (result1.x != result2.x);
}
// Exact Value Check Test
{
LennardJones lj_exact(1.0, 1.0, 3.0);
Vec3<real> r = {1.5, 0.0, 0.0};
auto result = lj_exact.calc_force_and_energy(r);
float4 result = lj_exact.calc_force_and_energy(r);
results->energy_values[8] = result.energy;
results->force_values[8] = result.force;
results->force_energy_values[8] = result;
real expected_energy = 4.0 * (pow(1.0 / 1.5, 12) - pow(1.0 / 1.5, 6));
real expected_force =
24.0 * (pow(1.0 / 1.5, 6) - 2.0 * pow(1.0 / 1.5, 12)) / 1.5;
results->exact_value_check_pass =
(fabs(result.energy - expected_energy) < tolerance) &&
(fabs(result.force.x + expected_force) < tolerance) &&
(fabs(result.force.y) < tolerance) &&
(fabs(result.force.z) < tolerance);
(fabs(result.w - expected_energy) < tolerance) &&
(fabs(result.x + expected_force) < tolerance) &&
(fabs(result.y) < tolerance) && (fabs(result.z) < tolerance);
}
// Near Cutoff Test
@ -173,16 +161,18 @@ __global__ void lennard_jones_test_kernel(TestResults *results) {
Vec3<real> r_inside = {inside_cutoff, 0.0, 0.0};
Vec3<real> r_outside = {outside_cutoff, 0.0, 0.0};
auto result_inside = lj.calc_force_and_energy(r_inside);
auto result_outside = lj.calc_force_and_energy(r_outside);
float4 result_inside = lj.calc_force_and_energy(r_inside);
float4 result_outside = lj.calc_force_and_energy(r_outside);
results->energy_values[9] = result_inside.energy;
results->force_values[9] = result_inside.force;
results->force_energy_values[9] = result_inside;
results->near_cutoff_pass =
(result_inside.energy != 0.0) && (result_inside.force.x != 0.0) &&
(result_outside.energy == 0.0) &&
vec3_near(Vec3<real>{0.0, 0.0, 0.0}, result_outside.force, tolerance);
(result_inside.w != 0.0) && (result_inside.x != 0.0) &&
(result_outside.w == 0.0) &&
vec3_near(
Vec3<real>{0.0, 0.0, 0.0},
Vec3<real>{result_outside.x, result_outside.y, result_outside.z},
tolerance);
}
}
@ -250,44 +240,48 @@ TEST_F(LennardJonesCudaTest, DeviceZeroDistance) {
auto results = runDeviceTests();
EXPECT_TRUE(results.zero_distance_pass)
<< "Zero distance test failed on device. Energy: "
<< results.energy_values[0] << ", Force: (" << results.force_values[0].x
<< ", " << results.force_values[0].y << ", " << results.force_values[0].z
<< ")";
<< results.force_energy_values[0].w << ", Force: ("
<< results.force_energy_values[0].x << ", "
<< results.force_energy_values[0].y << ", "
<< results.force_energy_values[0].z << ")";
}
TEST_F(LennardJonesCudaTest, DeviceBeyondCutoff) {
auto results = runDeviceTests();
EXPECT_TRUE(results.beyond_cutoff_pass)
<< "Beyond cutoff test failed on device. Energy: "
<< results.energy_values[1];
<< results.force_energy_values[1].w;
}
TEST_F(LennardJonesCudaTest, DeviceAtMinimum) {
auto results = runDeviceTests();
EXPECT_TRUE(results.at_minimum_pass)
<< "At minimum test failed on device. Energy: "
<< results.energy_values[2];
<< results.force_energy_values[2].w;
}
TEST_F(LennardJonesCudaTest, DeviceAtEquilibrium) {
auto results = runDeviceTests();
EXPECT_TRUE(results.at_equilibrium_pass)
<< "At equilibrium test failed on device. Energy: "
<< results.energy_values[3] << ", Force x: " << results.force_values[3].x;
<< results.force_energy_values[3].w
<< ", Force x: " << results.force_energy_values[3].x;
}
TEST_F(LennardJonesCudaTest, DeviceRepulsiveRegion) {
auto results = runDeviceTests();
EXPECT_TRUE(results.repulsive_region_pass)
<< "Repulsive region test failed on device. Energy: "
<< results.energy_values[4] << ", Force x: " << results.force_values[4].x;
<< results.force_energy_values[4].w
<< ", Force x: " << results.force_energy_values[4].x;
}
TEST_F(LennardJonesCudaTest, DeviceAttractiveRegion) {
auto results = runDeviceTests();
EXPECT_TRUE(results.attractive_region_pass)
<< "Attractive region test failed on device. Energy: "
<< results.energy_values[5] << ", Force x: " << results.force_values[5].x;
<< results.force_energy_values[5].w
<< ", Force x: " << results.force_energy_values[5].x;
}
TEST_F(LennardJonesCudaTest, DeviceArbitraryDirection) {
@ -306,12 +300,13 @@ TEST_F(LennardJonesCudaTest, DeviceExactValueCheck) {
auto results = runDeviceTests();
EXPECT_TRUE(results.exact_value_check_pass)
<< "Exact value check test failed on device. Energy: "
<< results.energy_values[8] << ", Force x: " << results.force_values[8].x;
<< results.force_energy_values[8].w
<< ", Force x: " << results.force_energy_values[8].x;
}
TEST_F(LennardJonesCudaTest, DeviceNearCutoff) {
auto results = runDeviceTests();
EXPECT_TRUE(results.near_cutoff_pass)
<< "Near cutoff test failed on device. Inside energy: "
<< results.energy_values[9];
<< results.force_energy_values[9].w;
}