diff --git a/include/tadah/models/cutoffs.h b/include/tadah/models/cutoffs.h
index eb668917dae8858d87a78a2a998a1bc9e8dde170..eac3891a6a243d9657fb6dd4d40593771381d2ee 100644
--- a/include/tadah/models/cutoffs.h
+++ b/include/tadah/models/cutoffs.h
@@ -131,10 +131,10 @@ class Cut_Tanh : public Cut_Base {
 };
 
 /**
- * @class Cut_Poly2
+ * @class Cut_PolyS
  * @brief Polynomial cutoff function ensuring smoothness up to the second derivative.
  *
- * The `Cut_Poly2` class implements a polynomial cutoff function defined as:
+ * The `Cut_PolyS` class implements a polynomial cutoff function defined as:
 
  * \f[
  * f_c(r) =
@@ -156,14 +156,14 @@ class Cut_Tanh : public Cut_Base {
 
  * Singraber, A., Behler, J., & Dellago, C. (2019). *Library-Based LAMMPS Implementation of High-Dimensional Neural Network Potentials*. Journal of Chemical Theory and Computation, 15(1), 182–190. [DOI:10.1021/acs.jctc.8b00770](https://doi.org/10.1021/acs.jctc.8b00770)
  */
-class Cut_Poly2 : public Cut_Base {
+class Cut_PolyS : public Cut_Base {
     private:
-        std::string lab = "Cut_Poly2";
+        std::string lab = "Cut_PolyS";
         double rcut, rcut_sq, rcut_inv;
         double rcut_inner;
     public:
-        Cut_Poly2();
-        Cut_Poly2(double rcut);
+        Cut_PolyS();
+        Cut_PolyS(double rcut);
         std::string label() ;
         void set_rcut(const double r);
         double get_rcut();
@@ -172,7 +172,7 @@ class Cut_Poly2 : public Cut_Base {
         double calc_prime(double r);
 };
 /**
- * @class Cut_Poly1
+ * @class Cut_Poly
  * @brief Represents a 5th order polynomial cutoff function with zero first and second derivatives at the cutoff radius.
  *
  * This class implements a smooth cutoff function defined by:
@@ -198,13 +198,13 @@ class Cut_Poly2 : public Cut_Base {
  * The function smoothly transitions from 1 to 0 within the cutoff radius \f$ r_{\text{cut}} \f$, ensuring that the function and its first and second derivatives are zero at \f$ r \geq r_{\text{cut}} \f$.
  *
  */
-class Cut_Poly1 : public Cut_Base {
+class Cut_Poly : public Cut_Base {
     private:
-        std::string lab = "Cut_Poly1";
+        std::string lab = "Cut_Poly";
         double rcut, rcut_sq, rcut_inv;
     public:
-        Cut_Poly1();
-        Cut_Poly1(double rcut);
+        Cut_Poly();
+        Cut_Poly(double rcut);
         std::string label() ;
         void set_rcut(const double r);
         double get_rcut();
@@ -213,10 +213,10 @@ class Cut_Poly1 : public Cut_Base {
         double calc_prime(double r);
 };
 /**
- * @class Cut_Cos_S
+ * @class Cut_CosS
  * @brief Smooth cosine cutoff function with a smoothing interval.
  *
- * The `Cut_Cos_S` class implements a smooth cosine cutoff function that transitions smoothly from 1 to 0 over a specified smoothing interval between the inner cutoff radius \f$ r_{\text{inner}} \f$ and the outer cutoff radius \f$ r_{\text{cut}} \f$ The function is defined as:
+ * The `Cut_CosS` class implements a smooth cosine cutoff function that transitions smoothly from 1 to 0 over a specified smoothing interval between the inner cutoff radius \f$ r_{\text{inner}} \f$ and the outer cutoff radius \f$ r_{\text{cut}} \f$ The function is defined as:
  *
  * \f[
  * f(r) =
@@ -251,14 +251,14 @@ class Cut_Poly1 : public Cut_Base {
  *
  * **Note:** The function ensures continuity and smoothness in simulations or calculations where a smooth cutoff is required.
  */
-class Cut_Cos_S : public Cut_Base {
+class Cut_CosS : public Cut_Base {
     private:
-        std::string lab = "Cut_Cos_S";
+        std::string lab = "Cut_CosS";
         double rcut, rcut_sq, rcut_inv;
         double rcut_inner;
     public:
-        Cut_Cos_S();
-        Cut_Cos_S(double rcut);
+        Cut_CosS();
+        Cut_CosS(double rcut);
         std::string label() ;
         void set_rcut(const double r);
         double get_rcut();
diff --git a/src/cutoffs.cpp b/src/cutoffs.cpp
index 82033cf5eeb9bf6bec7025d5d467ac271d4b02f7..7b17adbe57251e4ff0881e4e4765f99d9945626a 100644
--- a/src/cutoffs.cpp
+++ b/src/cutoffs.cpp
@@ -5,12 +5,12 @@
 
 template<> CONFIG::Registry<Cut_Base,double>::Map CONFIG::Registry<Cut_Base,double>::registry{};
 CONFIG::Registry<Cut_Base,double>::Register<Cut_Cos> Cut_Cos_1( "Cut_Cos" );
-CONFIG::Registry<Cut_Base,double>::Register<Cut_Cos_S> Cut_Cos_S_1( "Cut_Cos_S" );
-CONFIG::Registry<Cut_Base,double>::Register<Cut_Tanh> Cut_Tanh_1( "Cut_Tanh" );
-CONFIG::Registry<Cut_Base,double>::Register<Cut_Poly1> Cut_Poly_1( "Cut_Poly1" );
-CONFIG::Registry<Cut_Base,double>::Register<Cut_Poly2> Cut_Poly_2( "Cut_Poly2" );
+CONFIG::Registry<Cut_Base,double>::Register<Cut_CosS> Cut_Cos_2( "Cut_CosS" );
 CONFIG::Registry<Cut_Base,double>::Register<Cut_Dummy> Cut_Dummy_1( "Cut_Dummy" );
+CONFIG::Registry<Cut_Base,double>::Register<Cut_Poly> Cut_Poly_1( "Cut_Poly" );
+CONFIG::Registry<Cut_Base,double>::Register<Cut_PolyS> Cut_Poly_2( "Cut_PolyS" );
 CONFIG::Registry<Cut_Base,double>::Register<Cut_PT> Cut_PT_1( "Cut_PT" );
+CONFIG::Registry<Cut_Base,double>::Register<Cut_Tanh> Cut_Tanh_1( "Cut_Tanh" );
 
 
 Cut_Base::~Cut_Base() {}
@@ -126,81 +126,81 @@ double Cut_Tanh::calc_prime(double r) {
     return -3.0*t*t*rcut_inv*s*s;
 }
 
-Cut_Poly2::Cut_Poly2() {}
-Cut_Poly2::Cut_Poly2(double rcut)
+Cut_PolyS::Cut_PolyS() {}
+Cut_PolyS::Cut_PolyS(double rcut)
 {
     if (rcut<=1.0)
         throw std::runtime_error(
-                "Cut_Poly2 cutoff distance cannot be smaller than 1.0.");
+                "Cut_PolyS cutoff distance cannot be smaller than 1.0.");
     set_rcut(rcut);
     test_rcut(rcut);
 }
 
-std::string Cut_Poly2::label() {
+std::string Cut_PolyS::label() {
     return lab;
 }
 
-void Cut_Poly2::set_rcut(const double r) {
+void Cut_PolyS::set_rcut(const double r) {
     test_rcut(r);
     rcut=r;
     rcut_sq=r*r;
     rcut_inv= r<=0 ? 0.0 : 1.0/r;
     rcut_inner=rcut-1.0;
 }
-double Cut_Poly2::get_rcut() {
+double Cut_PolyS::get_rcut() {
     return rcut;
 }
 
-double Cut_Poly2::get_rcut_sq() {
+double Cut_PolyS::get_rcut_sq() {
     return rcut_sq;
 }
 
-double Cut_Poly2::calc(double r) {
+double Cut_PolyS::calc(double r) {
     if (r>=rcut) return 0.0;
     else if (r<= rcut_inner) return 1.0;
     double rs=r-rcut_inner;
     return rs*rs*rs*(rs*(15.0-6.0*rs)-10.0)+1;
 }
-double Cut_Poly2::calc_prime(double r) {
+double Cut_PolyS::calc_prime(double r) {
     if (r>=rcut) return 0.0;
     else if (r<= rcut_inner) return 0.0;
     double rs=r-rcut_inner;
     return -30.0*(rs-1.0)*(rs-1.0)*rs*rs;
 }
 
-Cut_Cos_S::Cut_Cos_S() {}
-Cut_Cos_S::Cut_Cos_S(double rcut)
+Cut_CosS::Cut_CosS() {}
+Cut_CosS::Cut_CosS(double rcut)
 {
     set_rcut(rcut);
     test_rcut(rcut);
 }
 
-std::string Cut_Cos_S::label() {
+std::string Cut_CosS::label() {
     return lab;
 }
 
-void Cut_Cos_S::set_rcut(const double r) {
+void Cut_CosS::set_rcut(const double r) {
     test_rcut(r);
     rcut=r;
     rcut_sq=r*r;
     rcut_inv= r<=0 ? 0.0 : 1.0/r;
     rcut_inner=rcut-1.0;
 }
-double Cut_Cos_S::get_rcut() {
+double Cut_CosS::get_rcut() {
     return rcut;
 }
 
-double Cut_Cos_S::get_rcut_sq() {
+double Cut_CosS::get_rcut_sq() {
     return rcut_sq;
 }
 
-double Cut_Cos_S::calc(double r) {
+double Cut_CosS::calc(double r) {
   if (r>=rcut) return 0.0;
   else if (r<= rcut_inner) return 1.0;
   double rs = (r-rcut_inner)/(rcut-rcut_inner);
   return 0.5*(1+std::cos(M_PI*rs));
 }
-double Cut_Cos_S::calc_prime(double r) {
+double Cut_CosS::calc_prime(double r) {
   if (r>=rcut || r<= rcut_inner) return 0.0;
   else {
     double rs = (r - rcut_inner) / (rcut - rcut_inner);
@@ -249,26 +249,26 @@ double Cut_PT::calc_prime(double r) {
 
   return - (rcut / 4.0) * sech2_u * sum_terms;
 }
-Cut_Poly1::Cut_Poly1() {}
-Cut_Poly1::Cut_Poly1(double rcut_value) {
+Cut_Poly::Cut_Poly() {}
+Cut_Poly::Cut_Poly(double rcut_value) {
   set_rcut(rcut_value);
 }
-std::string Cut_Poly1::label() {
+std::string Cut_Poly::label() {
     return lab;
 }
-void Cut_Poly1::set_rcut(const double r) {
+void Cut_Poly::set_rcut(const double r) {
     test_rcut(r);
     rcut = r;
     rcut_sq = r * r;
     rcut_inv= r<=0 ? 0.0 : 1.0/r;
 }
-double Cut_Poly1::get_rcut() {
+double Cut_Poly::get_rcut() {
     return rcut;
 }
-double Cut_Poly1::get_rcut_sq() {
+double Cut_Poly::get_rcut_sq() {
     return rcut_sq;
 }
-double Cut_Poly1::calc(double r) {
+double Cut_Poly::calc(double r) {
     if (r >= rcut) {
         return 0.0;
     } else {
@@ -279,7 +279,7 @@ double Cut_Poly1::calc(double r) {
         return 1.0 - 10.0 * x3 + 15.0 * x4 - 6.0 * x5;
     }
 }
-double Cut_Poly1::calc_prime(double r) {
+double Cut_Poly::calc_prime(double r) {
     if (r >= rcut) {
         return 0.0;
     } else {
diff --git a/tests/test_cutoffs.cpp b/tests/test_cutoffs.cpp
index b90be3b6be8de57e4fe5f1b6a93ed9f945371133..1127f2871276b77e4248a3a5693be8c8a371d0db 100644
--- a/tests/test_cutoffs.cpp
+++ b/tests/test_cutoffs.cpp
@@ -119,13 +119,13 @@ TEST_CASE( "Testing Cutoffs: Cut_Tanh", "[Cut_Tanh]" ) {
 
     delete c2b;
 }
-TEST_CASE( "Testing Cutoffs: Cut_Poly2", "[Cut_Poly2]" ) {
+TEST_CASE( "Testing Cutoffs: Cut_PolyS", "[Cut_PolyS]" ) {
 
-    REQUIRE_NOTHROW(Cut_Poly2());
+    REQUIRE_NOTHROW(Cut_PolyS());
     double rcut2b = 6.2;
     double rcut2bsq = rcut2b*rcut2b;
-    using Cut = Cut_Poly2;
-    std::string cuttype = "Cut_Poly2";
+    using Cut = Cut_PolyS;
+    std::string cuttype = "Cut_PolyS";
     Cut_Base *c2b = new Cut( rcut2b );
 
     REQUIRE( c2b->label() == cuttype );
@@ -162,13 +162,13 @@ TEST_CASE( "Testing Cutoffs: Cut_Poly2", "[Cut_Poly2]" ) {
                Catch::Matchers::WithinAbs(-1.728, 1e-12));
     delete c2b;
 }
-TEST_CASE( "Testing Cutoffs: Cut_Cos_s", "[Cut_Cos_S]" ) {
+TEST_CASE( "Testing Cutoffs: Cut_CosS", "[Cut_CosS]" ) {
 
-    REQUIRE_NOTHROW(Cut_Cos_S());
+    REQUIRE_NOTHROW(Cut_CosS());
     double rcut2b = 6.2;
     double rcut2bsq = rcut2b*rcut2b;
-    using Cut = Cut_Cos_S;
-    std::string cuttype = "Cut_Cos_S";
+    using Cut = Cut_CosS;
+    std::string cuttype = "Cut_CosS";
     Cut_Base *c2b = new Cut( rcut2b );
 
     REQUIRE( c2b->label() == cuttype );
diff --git a/tests/test_d2.cpp b/tests/test_d2.cpp
index 84faae1792def1f4ed44f0dec4f6747da653d05a..d703644e9c4f5d7c37e2e45d55a321d3977deabd 100644
--- a/tests/test_d2.cpp
+++ b/tests/test_d2.cpp
@@ -75,7 +75,7 @@ void test_D2(Config &c) {
       test_d2<D,Cut_Dummy>(c,r);
       test_d2<D,Cut_Cos>(c,r);
       test_d2<D,Cut_Tanh>(c,r);
-      test_d2<D,Cut_Poly2>(c,r);
+      test_d2<D,Cut_PolyS>(c,r);
     }
   }
   Config c2; // INIT2B=false
diff --git a/tests/test_dm.cpp b/tests/test_dm.cpp
index 1800b4c1e71cb3c58f56ddea67cc212bb0111df0..1e93f0418e0c095ed4259cf2d2b9c1e20889a5a8 100644
--- a/tests/test_dm.cpp
+++ b/tests/test_dm.cpp
@@ -315,7 +315,7 @@ TEST_CASE_METHOD(TestFixture, "Testing DM_EAD 1", "[DM]") {
     test_case<DM_EAD, Cut_Dummy>(config_mb, "DM_EAD", 3 * 2);
     test_case<DM_EAD, Cut_Cos>(config_mb, "DM_EAD", 3 * 2);
     test_case<DM_EAD, Cut_Tanh>(config_mb, "DM_EAD", 3 * 2);
-    test_case<DM_EAD, Cut_Poly2>(config_mb, "DM_EAD", 3 * 2);
+    test_case<DM_EAD, Cut_PolyS>(config_mb, "DM_EAD", 3 * 2);
 }
 
 TEST_CASE_METHOD(TestFixture, "Testing DM_EAD 2", "[DM]") {
@@ -332,7 +332,7 @@ TEST_CASE_METHOD(TestFixture, "Testing DM_EAD 2", "[DM]") {
     test_case<DM_EAD, Cut_Dummy>(config_mb, "DM_EAD", 4 * 3);
     test_case<DM_EAD, Cut_Cos>(config_mb, "DM_EAD", 4 * 3);
     test_case<DM_EAD, Cut_Tanh>(config_mb, "DM_EAD", 4 * 3);
-    test_case<DM_EAD, Cut_Poly2>(config_mb, "DM_EAD", 4 * 3);
+    test_case<DM_EAD, Cut_PolyS>(config_mb, "DM_EAD", 4 * 3);
 }
 
 TEST_CASE_METHOD(TestFixture, "Testing DM_Blip 1", "[DM]") {
@@ -349,7 +349,7 @@ TEST_CASE_METHOD(TestFixture, "Testing DM_Blip 1", "[DM]") {
     test_case<DM_Blip, Cut_Dummy>(config_mb, "DM_Blip", 3 * 2);
     test_case<DM_Blip, Cut_Cos>(config_mb, "DM_Blip", 3 * 2);
     test_case<DM_Blip, Cut_Tanh>(config_mb, "DM_Blip", 3 * 2);
-    test_case<DM_Blip, Cut_Poly2>(config_mb, "DM_Blip", 3 * 2);
+    test_case<DM_Blip, Cut_PolyS>(config_mb, "DM_Blip", 3 * 2);
 }
 
 TEST_CASE_METHOD(TestFixture, "Testing DM_Blip 2", "[DM]") {
@@ -366,7 +366,7 @@ TEST_CASE_METHOD(TestFixture, "Testing DM_Blip 2", "[DM]") {
     test_case<DM_Blip, Cut_Dummy>(config_mb, "DM_Blip", 4 * 3);
     test_case<DM_Blip, Cut_Cos>(config_mb, "DM_Blip", 4 * 3);
     test_case<DM_Blip, Cut_Tanh>(config_mb, "DM_Blip", 4 * 3);
-    test_case<DM_Blip, Cut_Poly2>(config_mb, "DM_Blip", 4 * 3);
+    test_case<DM_Blip, Cut_PolyS>(config_mb, "DM_Blip", 4 * 3);
 }
 
 TEST_CASE_METHOD(TestFixture, "Testing DM_EAM 1", "[DM]") {