.gitignore

@@ -1,7 +1,5 @@
 # Builds
 build/
-Debug/
-Testing/
 
 # Google Tests
 tests/lib/
@@ -9,6 +7,3 @@ tests/lib/
 # Jet Brains
 .idea/
 cmake-build-debug/
-
-# Cache dir
-.cache

CMakeLists.txt

@@ -1,47 +1,32 @@
 cmake_minimum_required(VERSION 3.9)
-set(NAME "cudaCAC")
-project(${NAME} LANGUAGES CUDA CXX)
+project(MyProject LANGUAGES CUDA CXX)
 
-enable_testing()
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-# Default settings 
 add_compile_options(-Wall -Wextra -Wpedantic)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CUDA_ARCHITECTURES 61)
 set(CUDA_SEPARABLE_COMPILATION ON)
 
-# Add Vec3  as a dependency
-include(FetchContent)
-FetchContent_Declare(Vec3
-    GIT_REPOSITORY https://www.alexselimov.com/git/aselimov/Vec3.git
-)
 
-FetchContent_GetProperties(Vec3)
-if(NOT Vec3_POPULATED)
-    FetchContent_MakeAvailable(Vec3)
-    include_directories(${Vec3_SOURCE_DIR})
-endif()
 
 include_directories(src)
 include_directories(kernels)
 include_directories(/usr/local/cuda-12.8/include)
 
+
 add_subdirectory(src)
 add_subdirectory(kernels)
 add_subdirectory(tests)
 
-add_executable(${NAME} main.cpp)
-install(DIRECTORY src/ DESTINATION src/)
+add_executable(${CMAKE_PROJECT_NAME}_run main.cpp)
+
 
 
 target_link_libraries(
-    ${NAME} 
+    ${CMAKE_PROJECT_NAME}_run 
     PRIVATE
-    ${NAME}_lib 
-    ${NAME}_cuda_lib 
-    
+    ${CMAKE_PROJECT_NAME}_lib 
+    ${CMAKE_PROJECT_NAME}_cuda_lib 
     ${CUDA_LIBRARIES}
 )
 

kernels/CMakeLists.txt

@@ -1,4 +1,4 @@
-project(${NAME}_cuda_lib CUDA CXX)
+project(${CMAKE_PROJECT_NAME}_cuda_lib CUDA CXX)
 
 set(HEADER_FILES
     hello_world.h
@@ -8,9 +8,11 @@ set(SOURCE_FILES
 )
 
 # The library contains header and source files.
-add_library(${NAME}_cuda_lib STATIC
+add_library(${CMAKE_PROJECT_NAME}_cuda_lib STATIC
     ${SOURCE_FILES}
     ${HEADER_FILES}
 )
 
-target_compile_options(${CMAKE_PROJECT_NAME}_cuda_lib PRIVATE -Wno-gnu-line-marker -Wno-pedantic)
+if(CMAKE_COMPILER_IS_GNUCXX)
+  target_compile_options(${CMAKE_PROJECT_NAME}_cuda_lib PRIVATE -Wno-gnu-line-marker)
+endif()

main.cpp

@@ -1,10 +1,10 @@
-#include "particle.hpp"
-#include "vec3.h"
+#include "hello_world.h"
 #include <iostream>
 
 int main() {
-  Particle<float> test = {
-      {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, 10};
-  std::cout << test.pos.x << " " << test.pos.y << " " << test.pos.z;
+  std::cout << "Starting CUDA example..." << std::endl; // Using endl to flush
+  check_cuda();
+  launch_hello_cuda();
+  std::cout << "Ending CUDA example" << std::endl; // Using endl to flush
   return 0;
 }

src/CMakeLists.txt

@@ -1,17 +1,16 @@
-project(${NAME}_lib CUDA CXX)
+project(${CMAKE_PROJECT_NAME}_lib CUDA CXX)
 
 set(HEADER_FILES
-    particle.hpp
-    simulation.hpp
-    box.hpp
-    pair_potentials.hpp
+    ./test.h
 )
 set(SOURCE_FILES
-    pair_potentials.cpp
+    ./test.cpp
 )
 
 # The library contains header and source files.
-add_library(${NAME}_lib 
-    ${HEADER_FILES} 
+add_library(${CMAKE_PROJECT_NAME}_lib
     ${SOURCE_FILES}
+    ${HEADER_FILES}
 )
+
+target_include_directories(${CMAKE_PROJECT_NAME}_lib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

src/box.hpp

@@ -1,22 +0,0 @@
-#ifndef BOX_H
-#define BOX_H
-
-/**
- * Struct representing the simulation box.
- * Currently the simulation box is always assumed to be perfectly rectangular.
- * This code does not support shearing the box. This functionality may be added
- * in later.
- */
-template <typename T> struct Box {
-  T xlo;
-  T xhi;
-  T ylo;
-  T yhi;
-  T zlo;
-  T zhi;
-  bool x_is_periodic;
-  bool y_is_periodic;
-  bool z_is_periodic;
-};
-
-#endif

src/pair_potentials.cpp

@@ -1,33 +0,0 @@
-#include "pair_potentials.hpp"
-#include <cmath>
-
-PairPotential::~PairPotential() {};
-/**
- * Calculate the Lennard-Jones energy and force for the current particle pair
- * described by displacement vector r
- */
-ForceAndEnergy LennardJones::calc_force_and_energy(Vec3<real> r) {
-  real rmagsq = r.squared_norm2();
-  if (rmagsq < this->m_rcutoffsq && rmagsq > 0.0) {
-    real inv_rmag = 1 / std::sqrt(rmagsq);
-
-    // Pre-Compute the terms (doing this saves on multiple devisions/pow
-    // function call)
-    real sigma_r = m_sigma * inv_rmag;
-    real sigma_r6 = sigma_r * sigma_r * sigma_r * sigma_r * sigma_r * sigma_r;
-    real sigma_r12 = sigma_r6 * sigma_r6;
-
-    // Get the energy
-    real energy = 4.0 * m_epsilon * (sigma_r12 - sigma_r6);
-
-    // Get the force vector
-    real force_mag = 4.0 * m_epsilon *
-                     (12.0 * sigma_r12 * inv_rmag - 6.0 * sigma_r6 * inv_rmag);
-    Vec3<real> force = r.scale(force_mag * inv_rmag);
-
-    return {energy, force};
-
-  } else {
-    return ForceAndEnergy::zero();
-  }
-};

src/pair_potentials.hpp

@@ -1,49 +0,0 @@
-#ifndef POTENTIALS_H
-#define POTENTIALS_H
-
-#include "precision.hpp"
-#include "vec3.h"
-
-/**
- * Result struct for the Pair Potential
- */
-struct ForceAndEnergy {
-  real energy;
-  Vec3<real> force;
-
-  inline static ForceAndEnergy zero() { return {0.0, {0.0, 0.0, 0.0}}; };
-};
-
-/**
- * Abstract implementation of a Pair Potential.
- * Pair potentials are potentials which depend solely on the distance
- * between two particles. These do not include multi-body potentials such as
- * EAM
- *
- */
-struct PairPotential {
-  real m_rcutoffsq;
-
-  PairPotential(real rcutoff) : m_rcutoffsq(rcutoff * rcutoff) {};
-  virtual ~PairPotential() = 0;
-
-  /**
-   * Calculate the force and energy for a specific atom pair based on a
-   * displacement vector r.
-   */
-  virtual ForceAndEnergy calc_force_and_energy(Vec3<real> r) = 0;
-};
-
-struct LennardJones : PairPotential {
-  real m_epsilon;
-  real m_sigma;
-
-  LennardJones(real sigma, real epsilon, real rcutoff)
-      : PairPotential(rcutoff), m_epsilon(epsilon), m_sigma(sigma) {};
-
-  ForceAndEnergy calc_force_and_energy(Vec3<real> r);
-
-  ~LennardJones() {};
-};
-
-#endif

src/particle.hpp

@@ -1,18 +0,0 @@
-#ifndef PARTICLE_H
-#define PARTICLE_H
-
-#include "vec3.h"
-
-/**
- * Class representing a single molecular dynamics particle.
- * This class is only used on the host side of the code and is converted
- * to the device arrays.
- */
-template <typename T = float> struct Particle {
-  Vec3<T> pos;
-  Vec3<T> vel;
-  Vec3<T> force;
-  T mass;
-};
-
-#endif

src/precision.hpp

@@ -1,15 +0,0 @@
-#ifndef PRECISION_H
-#define PRECISION_H
-
-#ifdef USE_FLOATS
-
-/*
- * If macro USE_FLOATS is set then the default type will be floating point
- * precision. Otherwise we use double precision by default
- */
-typedef float real;
-#else
-typedef double real;
-#endif
-
-#endif

src/simulation.hpp

@@ -1,17 +0,0 @@
-#ifndef SIMULATION_H
-#define SIMULATION_H
-
-#include "box.hpp"
-#include "particle.hpp"
-#include <vector>
-
-template <typename T> class Simulation {
-  // Simulation State variables
-  T timestep;
-  Box<T> box;
-
-  // Host Data
-  std::vector<Particle<T>> particles;
-};
-
-#endif

src/test.cpp

@@ -0,0 +1,4 @@
+#include "test.h"
+#include <iostream>
+
+void test_hello() { std::cout << "Hello!"; }

src/test.h

@@ -0,0 +1,2 @@
+#include <iostream>
+void test_hello();

tests/unit_tests/CMakeLists.txt

@@ -1,9 +1,8 @@
 include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
 
-add_executable(${NAME}_tests
-    test_potential.cpp
+add_executable(Unit_Tests_run
+    test_example.cpp
 )
 
-target_link_libraries(${NAME}_tests gtest gtest_main)
-target_link_libraries(${NAME}_tests ${CMAKE_PROJECT_NAME}_lib)
-add_test(NAME ${NAME}Tests COMMAND ${CMAKE_BINARY_DIR}/tests/unit_tests/${NAME}_tests)
+target_link_libraries(Unit_Tests_run gtest gtest_main)
+target_link_libraries(Unit_Tests_run ${CMAKE_PROJECT_NAME}_lib)

tests/unit_tests/test_potential.cpp

@@ -1,174 +0,0 @@
-#include "pair_potentials.hpp"
-#include "precision.hpp"
-#include "gtest/gtest.h"
-#include <cmath>
-
-class LennardJonesTest : public ::testing::Test {
-protected:
-  void SetUp() override {
-    // Default parameters
-    sigma = 1.0;
-    epsilon = 1.0;
-    r_cutoff = 2.5;
-
-    // Create default LennardJones object
-    lj = new LennardJones(sigma, epsilon, r_cutoff);
-  }
-
-  void TearDown() override { delete lj; }
-
-  real sigma;
-  real epsilon;
-  real r_cutoff;
-  LennardJones *lj;
-
-  // Helper function to compare Vec3 values with tolerance
-  void expect_vec3_near(const Vec3<real> &expected, const Vec3<real> &actual,
-                        real tolerance) {
-    EXPECT_NEAR(expected.x, actual.x, tolerance);
-    EXPECT_NEAR(expected.y, actual.y, tolerance);
-    EXPECT_NEAR(expected.z, actual.z, tolerance);
-  }
-};
-
-TEST_F(LennardJonesTest, ZeroDistance) {
-  // At zero distance, the calculation should return zero force and energy
-  Vec3<real> r = {0.0, 0.0, 0.0};
-  auto result = lj->calc_force_and_energy(r);
-
-  EXPECT_EQ(0.0, result.energy);
-  expect_vec3_near({0.0, 0.0, 0.0}, result.force, 1e-10);
-}
-
-TEST_F(LennardJonesTest, BeyondCutoff) {
-  // Distance beyond cutoff should return zero force and energy
-  Vec3<real> r = {3.0, 0.0, 0.0}; // 3.0 > r_cutoff (2.5)
-  auto result = lj->calc_force_and_energy(r);
-
-  EXPECT_EQ(0.0, result.energy);
-  expect_vec3_near({0.0, 0.0, 0.0}, result.force, 1e-10);
-}
-
-TEST_F(LennardJonesTest, AtMinimum) {
-  // The LJ potential has a minimum at r = 2^(1/6) * sigma
-  real min_dist = std::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);
-
-  // At minimum, force should be close to zero
-  EXPECT_NEAR(-epsilon, result.energy, 1e-10);
-  expect_vec3_near({0.0, 0.0, 0.0}, result.force, 1e-10);
-}
-
-TEST_F(LennardJonesTest, AtEquilibrium) {
-  // At r = sigma, the energy should be zero and force should be repulsive
-  Vec3<real> r = {sigma, 0.0, 0.0};
-  auto result = lj->calc_force_and_energy(r);
-
-  EXPECT_NEAR(0.0, result.energy, 1e-10);
-  EXPECT_GT(result.force.x,
-            0.0); // Force should be repulsive (positive x-direction)
-  EXPECT_NEAR(0.0, result.force.y, 1e-10);
-  EXPECT_NEAR(0.0, result.force.z, 1e-10);
-}
-
-TEST_F(LennardJonesTest, RepulsiveRegion) {
-  // Test in the repulsive region (r < sigma)
-  Vec3<real> r = {0.8 * sigma, 0.0, 0.0};
-  auto result = lj->calc_force_and_energy(r);
-
-  // Energy should be positive and force should be repulsive
-  EXPECT_GT(result.energy, 0.0);
-  EXPECT_GT(result.force.x, 0.0); // Force should be repulsive
-}
-
-TEST_F(LennardJonesTest, AttractiveRegion) {
-  // Test in the attractive region (sigma < r < r_min)
-  Vec3<real> r = {1.5 * sigma, 0.0, 0.0};
-  auto result = lj->calc_force_and_energy(r);
-
-  // Energy should be negative and force should be attractive
-  EXPECT_LT(result.energy, 0.0);
-  EXPECT_LT(result.force.x,
-            0.0); // Force should be attractive (negative x-direction)
-}
-
-TEST_F(LennardJonesTest, ArbitraryDirection) {
-  // Test with a vector in an arbitrary direction
-  Vec3<real> r = {1.0, 1.0, 1.0};
-  auto result = lj->calc_force_and_energy(r);
-
-  // The force should be in the same direction as r but opposite sign
-  // (attractive region)
-  real r_mag = std::sqrt(r.squared_norm2());
-
-  // Calculate expected force direction (should be along -r)
-  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;
-
-  // In this case, we're at r = sqrt(3) * sigma which is in attractive region
-  EXPECT_LT(force_dot_r, 0.0); // Force should be attractive
-
-  // Force should be symmetric in all dimensions for this vector
-  EXPECT_NEAR(result.force.x, result.force.y, 1e-10);
-  EXPECT_NEAR(result.force.y, result.force.z, 1e-10);
-}
-
-TEST_F(LennardJonesTest, ParameterVariation) {
-  // Test with different parameter values
-  real new_sigma = 2.0;
-  real new_epsilon = 0.5;
-  real new_r_cutoff = 5.0;
-
-  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);
-
-  // Results should be different with different parameters
-  EXPECT_NE(result1.energy, result2.energy);
-  EXPECT_NE(result1.force.x, result2.force.x);
-}
-
-TEST_F(LennardJonesTest, ExactValueCheck) {
-  // Test with pre-calculated values for a specific case
-  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);
-
-  // Pre-calculated values (you may need to adjust these based on your specific
-  // implementation)
-  real expected_energy =
-      4.0 * (std::pow(1.0 / 1.5, 12) - std::pow(1.0 / 1.5, 6));
-  real expected_force =
-      24.0 * (std::pow(1.0 / 1.5, 6) - 2.0 * std::pow(1.0 / 1.5, 12)) / 1.5;
-
-  EXPECT_NEAR(expected_energy, result.energy, 1e-10);
-  EXPECT_NEAR(-expected_force, result.force.x,
-              1e-10); // Negative because force is attractive
-  EXPECT_NEAR(0.0, result.force.y, 1e-10);
-  EXPECT_NEAR(0.0, result.force.z, 1e-10);
-}
-
-TEST_F(LennardJonesTest, NearCutoff) {
-  // Test behavior just inside and just outside the cutoff
-  real inside_cutoff = r_cutoff - 0.01;
-  real outside_cutoff = r_cutoff + 0.01;
-
-  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);
-
-  // Inside should have non-zero values
-  EXPECT_NE(0.0, result_inside.energy);
-  EXPECT_NE(0.0, result_inside.force.x);
-
-  // Outside should be zero
-  EXPECT_EQ(0.0, result_outside.energy);
-  expect_vec3_near({0.0, 0.0, 0.0}, result_outside.force, 1e-10);
-}