Change CUDA API

sphericart/include/sphericart_cuda.hpp

@@ -31,15 +31,8 @@ template <typename T> class SphericalHarmonics {
      *
      *  @param l_max
      *      The maximum degree of the spherical harmonics to be calculated.
-     *  @param normalized
-     *      If `false` (default) computes the scaled spherical harmonics, which
-     * are homogeneous polynomials in the Cartesian coordinates of the input
-     * points. If `true`, computes the normalized spherical harmonics that are
-     * evaluated on the unit sphere. In practice, this simply computes the
-     * scaled harmonics at the normalized coordinates \f$(x/r, y/r, z/r)\f$, and
-     * adapts the derivatives accordingly.
      */
-    SphericalHarmonics(size_t l_max, bool normalized = false);
+    SphericalHarmonics(size_t l_max);
 
     /** Default constructor
      * Required so sphericart_torch can conditionally instantiate  this class
@@ -96,6 +89,7 @@ template <typename T> class SphericalHarmonics {
         void* cuda_stream = nullptr
     );
 
+    template <typename U> friend class SolidHarmonics;
     /* @cond */
   private:
     size_t l_max; // maximum l value computed by this class
@@ -112,6 +106,17 @@ template <typename T> class SphericalHarmonics {
     /* @endcond */
 };
 
+template <typename T> class SolidHarmonics : public SphericalHarmonics<T> {
+  public:
+    /** Initialize the SolidHarmonics class setting maximum degree and
+     * normalization
+     *
+     *  @param l_max
+     *      The maximum degree of the spherical harmonics to be calculated.
+     */
+    SolidHarmonics(size_t l_max);
+};
+
 } // namespace cuda
 
 /* @cond */

sphericart/src/sphericart.cpp

@@ -382,10 +382,6 @@ void SphericalHarmonics<T>::compute_sample_with_hessians(
     );
 }
 
-// instantiates the SphericalHarmonics class for basic floating point types
-template class sphericart::SphericalHarmonics<float>;
-template class sphericart::SphericalHarmonics<double>;
-
 template <typename T>
 SolidHarmonics<T>::SolidHarmonics(size_t l_max) : SphericalHarmonics<T>(l_max) {
     /*
@@ -445,6 +441,9 @@ SolidHarmonics<T>::SolidHarmonics(size_t l_max) : SphericalHarmonics<T>(l_max) {
     }
 }
 
-// instantiates the SolidHarmonics class for basic floating point types
+// instantiates the SphericalHarmonics and SolidHarmonics classes
+// for basic floating point types
+template class sphericart::SphericalHarmonics<float>;
+template class sphericart::SphericalHarmonics<double>;
 template class sphericart::SolidHarmonics<float>;
 template class sphericart::SolidHarmonics<double>;

sphericart/src/sphericart_cuda.cu

@@ -24,15 +24,15 @@ using namespace sphericart::cuda;
         }                                                                                          \
     } while (0)
 
-template <typename T> SphericalHarmonics<T>::SphericalHarmonics(size_t l_max, bool normalized) {
+template <typename T> SphericalHarmonics<T>::SphericalHarmonics(size_t l_max) {
     /*
         This is the constructor of the SphericalHarmonics class. It initizlizes
        buffer space, compute prefactors, and sets the function pointers that are
        used for the actual calls
     */
     this->l_max = (int)l_max;
     this->nprefactors = (int)(l_max + 1) * (l_max + 2);
-    this->normalized = normalized;
+    this->normalized = true; // SphericalHarmonics class
     this->prefactors_cpu = new T[this->nprefactors];
 
     CUDA_CHECK(cudaGetDeviceCount(&this->device_count));
@@ -211,6 +211,14 @@ void SphericalHarmonics<T>::compute(
     CUDA_CHECK(cudaSetDevice(current_device));
 }
 
-// instantiates the SphericalHarmonics class for basic floating point types
+template <typename T>
+SolidHarmonics<T>::SolidHarmonics(size_t l_max) : SphericalHarmonics<T>(l_max) {
+    this->normalized = false; // SolidHarmonics class
+}
+
+// instantiates the SphericalHarmonics and SolidHarmonics classes
+// for basic floating point types
 template class sphericart::cuda::SphericalHarmonics<float>;
 template class sphericart::cuda::SphericalHarmonics<double>;
+template class sphericart::cuda::SolidHarmonics<float>;
+template class sphericart::cuda::SolidHarmonics<double>;

sphericart/src/sphericart_cuda_stub.cpp

@@ -4,8 +4,7 @@
 
 using namespace sphericart::cuda;
 
-template <typename T>
-SphericalHarmonics<T>::SphericalHarmonics(size_t /*l_max*/, bool /*normalized*/) {}
+template <typename T> SphericalHarmonics<T>::SphericalHarmonics(size_t /*l_max*/) {}
 
 template <typename T> SphericalHarmonics<T>::~SphericalHarmonics() {}
 
@@ -23,6 +22,12 @@ void SphericalHarmonics<T>::compute(
     throw std::runtime_error("sphericart was not compiled with CUDA support");
 }
 
-// instantiates the SphericalHarmonics class for basic floating point types
+template <typename T>
+SolidHarmonics<T>::SolidHarmonics(size_t l_max) : SphericalHarmonics<T>(l_max) {}
+
+// instantiates the SphericalHarmonics and SolidHarmonics classes
+// for basic floating point types
 template class sphericart::cuda::SphericalHarmonics<float>;
 template class sphericart::cuda::SphericalHarmonics<double>;
+template class sphericart::cuda::SolidHarmonics<float>;
+template class sphericart::cuda::SolidHarmonics<double>;