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

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