diff --git a/src/KOKKOS/pair_pod_kokkos.cpp b/src/KOKKOS/pair_pod_kokkos.cpp
index 563eaf38d6..dee4f7a03b 100644
--- a/src/KOKKOS/pair_pod_kokkos.cpp
+++ b/src/KOKKOS/pair_pod_kokkos.cpp
@@ -13,10 +13,10 @@
 ------------------------------------------------------------------------- */
 
 /* ----------------------------------------------------------------------
-   Contributing author: Stan Moore (SNL)
+   Contributing author: Ngoc Cuong Nguyen (MIT)
 ------------------------------------------------------------------------- */
 
-#include "eapod.h" 
+#include "eapod.h"
 #include "pair_pod_kokkos.h"
 
 #include "atom_kokkos.h"
@@ -55,12 +55,12 @@ PairPODKokkos<DeviceType>::PairPODKokkos(LAMMPS *lmp) : PairPOD(lmp)
   ni = 0;
   nimax = 0;
   nij = 0;
-  nijmax = 0;  
+  nijmax = 0;
   atomBlockSize = 2048;
   nAtomBlocks = 0;
   timing = 1;
   for (int i=0; i<100; i++) comptime[i] = 0;
-  
+
   host_flag = (execution_space == Host);
 }
 
@@ -70,17 +70,17 @@ PairPODKokkos<DeviceType>::PairPODKokkos(LAMMPS *lmp) : PairPOD(lmp)
 
 template<class DeviceType>
 PairPODKokkos<DeviceType>::~PairPODKokkos()
-{  
+{
   if (timing == 1) {
     printf("\n begin timing \n");
-    for (int i=0; i<10; i++) printf("%g  ", comptime[i]); 
+    for (int i=0; i<10; i++) printf("%g  ", comptime[i]);
     printf("\n");
-    for (int i=10; i<20; i++) printf("%g  ", comptime[i]); 
+    for (int i=10; i<20; i++) printf("%g  ", comptime[i]);
 //     printf("\n");
-//     for (int i=20; i<30; i++) printf("%g  ", comptime[i]); 
+//     for (int i=20; i<30; i++) printf("%g  ", comptime[i]);
     printf("\n end timing \n");
-  }    
-  
+  }
+
   if (copymode) return;
 
   memoryKK->destroy_kokkos(k_eatom,eatom);
@@ -141,10 +141,10 @@ template<class DeviceType>
 void PairPODKokkos<DeviceType>::coeff(int narg, char **arg)
 {
   if (narg < 7) utils::missing_cmd_args(FLERR, "pair_coeff", error);
-    
+
   PairPOD::coeff(narg,arg); // create a PairPOD object
-    
-  copy_from_pod_class(PairPOD::fastpodptr); // copy parameters and arrays from pod class 
+
+  copy_from_pod_class(PairPOD::fastpodptr); // copy parameters and arrays from pod class
 
   int n = atom->ntypes + 1;
   MemKK::realloc_kokkos(d_map, "pair_pod:map", n);
@@ -154,15 +154,15 @@ void PairPODKokkos<DeviceType>::coeff(int narg, char **arg)
 
   MemKK::realloc_kokkos(k_scale, "pair_pod:scale", n, n);
   d_scale = k_scale.template view<DeviceType>();
-  
-  // Set up element lists  
-  
+
+  // Set up element lists
+
   auto h_map = Kokkos::create_mirror_view(d_map);
-  
+
   for (int i = 1; i <= atom->ntypes; i++)
     h_map(i) = map[i];
-  
-  Kokkos::deep_copy(d_map,h_map);      
+
+  Kokkos::deep_copy(d_map,h_map);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -200,14 +200,14 @@ void PairPODKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
 //     atomKK->modified(Host,F_MASK);
 //     return;
 //   }
-  
+
   eflag = eflag_in;
   vflag = vflag_in;
 
   if (neighflag == FULL) no_virial_fdotr_compute = 1;
 
   ev_init(eflag,vflag,0);
-  
+
   // reallocate per-atom arrays if necessary
   if (eflag_atom) {
     memoryKK->destroy_kokkos(k_eatom,eatom);
@@ -220,41 +220,41 @@ void PairPODKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
     d_vatom = k_vatom.view<DeviceType>();
   }
 
-  copymode = 1;  
+  copymode = 1;
   int newton_pair = force->newton_pair;
   if (newton_pair == false)
     error->all(FLERR,"PairPODKokkos requires 'newton on'");
-  
-  atomKK->sync(execution_space,X_MASK|F_MASK|TYPE_MASK);    
-  x = atomKK->k_x.view<DeviceType>();    
+
+  atomKK->sync(execution_space,X_MASK|F_MASK|TYPE_MASK);
+  x = atomKK->k_x.view<DeviceType>();
   f = atomKK->k_f.view<DeviceType>();
   type = atomKK->k_type.view<DeviceType>();
   //k_cutsq.template sync<DeviceType>();
- 
+
   maxneigh = 0;
-  if (host_flag) {        
-    inum = list->inum;    
+  if (host_flag) {
+    inum = list->inum;
     d_numneigh = typename ArrayTypes<DeviceType>::t_int_1d("pair_pod:numneigh",inum);
-    for (int i=0; i<inum; i++) d_numneigh(i) = list->numneigh[i];    
+    for (int i=0; i<inum; i++) d_numneigh(i) = list->numneigh[i];
     d_ilist = typename ArrayTypes<DeviceType>::t_int_1d("pair_pod:ilist",inum);
-    for (int i=0; i<inum; i++) d_ilist(i) = list->ilist[i];    
-    
+    for (int i=0; i<inum; i++) d_ilist(i) = list->ilist[i];
+
     int maxn = 0;
-    for (int i=0; i<inum; i++) 
-      if (maxn < list->numneigh[i]) maxn = list->numneigh[i];    
+    for (int i=0; i<inum; i++)
+      if (maxn < list->numneigh[i]) maxn = list->numneigh[i];
     MemoryKokkos::realloc_kokkos(d_neighbors,"neighlist:neighbors",inum,maxn);
     for (int i=0; i<inum; i++) {
       int gi = list->ilist[i];
-      int m = list->numneigh[gi];   
+      int m = list->numneigh[gi];
       if (maxneigh<m) maxneigh = m;
-      for (int l = 0; l < m; l++) {           // loop over each atom around atom i        
+      for (int l = 0; l < m; l++) {           // loop over each atom around atom i
         d_neighbors(gi, l) = list->firstneigh[gi][l];
       }
-    }    
+    }
   }
   else {
-    NeighListKokkos<DeviceType>* k_list = static_cast<NeighListKokkos<DeviceType>*>(list);  
-    d_numneigh = k_list->d_numneigh; 
+    NeighListKokkos<DeviceType>* k_list = static_cast<NeighListKokkos<DeviceType>*>(list);
+    d_numneigh = k_list->d_numneigh;
     d_neighbors = k_list->d_neighbors;
     d_ilist = k_list->d_ilist;
     inum = list->inum;
@@ -263,67 +263,67 @@ void PairPODKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
     maxneigh = maxneighs;
   }
 
-  auto begin = std::chrono::high_resolution_clock::now(); 
+  auto begin = std::chrono::high_resolution_clock::now();
   auto end = std::chrono::high_resolution_clock::now();
-              
+
   // determine the number of atom blocks and divide atoms into blocks
   nAtomBlocks = calculateNumberOfIntervals(inum, atomBlockSize);
-  if (nAtomBlocks > 100) nAtomBlocks = 100; 
+  if (nAtomBlocks > 100) nAtomBlocks = 100;
   divideInterval(atomBlocks, inum, nAtomBlocks);
-      
+
   int nmax = 0;
-  for (int block=0; block<nAtomBlocks; block++) {    
-    int n = atomBlocks[block+1] - atomBlocks[block]; 
+  for (int block=0; block<nAtomBlocks; block++) {
+    int n = atomBlocks[block+1] - atomBlocks[block];
     if (nmax < n) nmax = n;
-  }        
-  grow_atoms(nmax); 
-  grow_pairs(nmax*maxneigh); 
-  
-  rcutsq = rcut*rcut;  
+  }
+  grow_atoms(nmax);
+  grow_pairs(nmax*maxneigh);
+
+  rcutsq = rcut*rcut;
   for (int block=0; block<nAtomBlocks; block++) {
     int gi1 = atomBlocks[block]-1;
     int gi2 = atomBlocks[block+1]-1;
     ni = gi2 - gi1; // total number of atoms in the current atom block
-    
-    begin = std::chrono::high_resolution_clock::now();               
-    // calculate the total number of pairs (i,j) in the current atom block        
-    nij = NeighborCount(numij, rcutsq, gi1, ni);                           
+
+    begin = std::chrono::high_resolution_clock::now();
+    // calculate the total number of pairs (i,j) in the current atom block
+    nij = NeighborCount(numij, rcutsq, gi1, ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[0] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;        
-                           
-    begin = std::chrono::high_resolution_clock::now();     
-    // obtain the neighbors within rcut     
-    NeighborList(rij, numij, typeai, idxi, ai, aj, ti, tj, rcutsq, gi1, ni);              
+    end = std::chrono::high_resolution_clock::now();
+    comptime[0] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+    begin = std::chrono::high_resolution_clock::now();
+    // obtain the neighbors within rcut
+    NeighborList(rij, numij, typeai, idxi, ai, aj, ti, tj, rcutsq, gi1, ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[1] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;        
-        
+    end = std::chrono::high_resolution_clock::now();
+    comptime[1] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
     // compute atomic energy and force for the current atom block
-    begin = std::chrono::high_resolution_clock::now();       
+    begin = std::chrono::high_resolution_clock::now();
     blockatom_energyforce(ei, fij, ni, nij);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[2] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;        
+    end = std::chrono::high_resolution_clock::now();
+    comptime[2] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
 
-    begin = std::chrono::high_resolution_clock::now();       
+    begin = std::chrono::high_resolution_clock::now();
     // tally atomic energy to global energy
     tallyenergy(ei, gi1, ni);
-        
+
     // tally atomic force to global force
     tallyforce(fij, ai, aj, nij);
-    
+
     // tally atomic stress
     if (vflag) {
       tallystress(fij, rij, ai, aj, nij);
-    }    
+    }
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[3] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;        
-    
+    end = std::chrono::high_resolution_clock::now();
+    comptime[3] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
     //savedatafordebugging();
-  }    
-    
+  }
+
   if (vflag_fdotr) pair_virial_fdotr_compute(this);
 
   if (eflag_atom) {
@@ -342,9 +342,9 @@ void PairPODKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::copy_from_pod_class(EAPOD *podptr) 
+void PairPODKokkos<DeviceType>::copy_from_pod_class(EAPOD *podptr)
 {
-  nelements = podptr->nelements; // number of elements 
+  nelements = podptr->nelements; // number of elements
   onebody = podptr->onebody;   // one-body descriptors
   besseldegree = podptr->besseldegree; // degree of Bessel functions
   inversedegree = podptr->inversedegree; // degree of inverse functions
@@ -365,30 +365,30 @@ void PairPODKokkos<DeviceType>::copy_from_pod_class(EAPOD *podptr)
   nrbf4 = podptr->nrbf4;
   nrbfmax = podptr->nrbfmax; // number of radial basis functions
   nabf3 = podptr->nabf3;     // number of three-body angular basis functions
-  nabf4 = podptr->nabf4;     // number of four-body angular basis functions  
+  nabf4 = podptr->nabf4;     // number of four-body angular basis functions
   K3 = podptr->K3;           // number of three-body monomials
   K4 = podptr->K4;           // number of four-body monomials
   Q4 = podptr->Q4;           // number of four-body monomial coefficients
   nClusters = podptr->nClusters; // number of environment clusters
   nComponents = podptr->nComponents; // number of principal components
-  Mdesc = podptr->Mdesc; // number of base descriptors 
+  Mdesc = podptr->Mdesc; // number of base descriptors
 
   rin = podptr->rin;
   rcut = podptr->rcut;
-  rmax = rcut - rin;  
-    
-  MemKK::realloc_kokkos(besselparams, "pair_pod:besselparams", 3); 
-  auto h_besselparams = Kokkos::create_mirror_view(besselparams);  
+  rmax = rcut - rin;
+
+  MemKK::realloc_kokkos(besselparams, "pair_pod:besselparams", 3);
+  auto h_besselparams = Kokkos::create_mirror_view(besselparams);
   h_besselparams[0] = podptr->besselparams[0];
   h_besselparams[1] = podptr->besselparams[1];
-  h_besselparams[2] = podptr->besselparams[2];   
-  Kokkos::deep_copy(besselparams, h_besselparams);    
-   
+  h_besselparams[2] = podptr->besselparams[2];
+  Kokkos::deep_copy(besselparams, h_besselparams);
+
   MemKK::realloc_kokkos(elemindex, "pair_pod:elemindex", nelements*nelements);
   auto h_elemindex = Kokkos::create_mirror_view(elemindex);
   for (int i=0; i<nelements*nelements; i++) h_elemindex[i] = podptr->elemindex[i];
   Kokkos::deep_copy(elemindex, h_elemindex);
-  
+
   MemKK::realloc_kokkos(Phi, "pair_pod:Phi", ns*ns);
   auto h_Phi = Kokkos::create_mirror_view(Phi);
   for (int i=0; i<ns*ns; i++) h_Phi[i] = podptr->Phi[i];
@@ -408,15 +408,15 @@ void PairPODKokkos<DeviceType>::copy_from_pod_class(EAPOD *podptr)
     MemKK::realloc_kokkos(Centroids, "pair_pod:Centroids",  nClusters * nComponents * nelements);
     auto h_Centroids = Kokkos::create_mirror_view(Centroids);
     for (int i=0; i<nClusters * nComponents * nelements; i++) h_Centroids[i] = podptr->Centroids[i];
-    Kokkos::deep_copy(Centroids, h_Centroids);    
+    Kokkos::deep_copy(Centroids, h_Centroids);
   }
-  
+
   MemKK::realloc_kokkos(pn3, "pair_pod:pn3", nabf3+1); // array stores the number of monomials for each degree
   MemKK::realloc_kokkos(pq3, "pair_pod:pq3", K3*2); // array needed for the recursive computation of the angular basis functions
   MemKK::realloc_kokkos(pc3, "pair_pod:pc3", K3);   // array needed for the computation of the three-body descriptors
   MemKK::realloc_kokkos(pa4, "pair_pod:pa4", nabf4+1); // this array is a subset of the array {0, 1, 4, 10, 19, 29, 47, 74, 89, 119, 155, 209, 230, 275, 335, 425, 533, 561, 624, 714, 849, 949, 1129, 1345}
   MemKK::realloc_kokkos(pb4, "pair_pod:pb4", Q4*3); // array stores the indices of the monomials needed for the computation of the angular basis functions
-  MemKK::realloc_kokkos(pc4, "pair_pod:pc4", Q4);   // array of monomial coefficients needed for the computation of the four-body descriptors  
+  MemKK::realloc_kokkos(pc4, "pair_pod:pc4", Q4);   // array of monomial coefficients needed for the computation of the four-body descriptors
 
   auto h_pn3 = Kokkos::create_mirror_view(pn3);
   for (int i=0; i<nabf3+1; i++) h_pn3[i] = podptr->pn3[i];
@@ -448,7 +448,7 @@ void PairPODKokkos<DeviceType>::copy_from_pod_class(EAPOD *podptr)
   MemKK::realloc_kokkos(ind34r, "pair_pod:ind34r", nl34);
   MemKK::realloc_kokkos(ind44l, "pair_pod:ind44l", nl44);
   MemKK::realloc_kokkos(ind44r, "pair_pod:ind44r", nl44);
-  
+
   auto h_ind33l = Kokkos::create_mirror_view(ind33l);
   for (int i = 0; i < nl33; i++) h_ind33l[i] = podptr->ind33l[i];
   Kokkos::deep_copy(ind33l, h_ind33l);
@@ -471,11 +471,11 @@ void PairPODKokkos<DeviceType>::copy_from_pod_class(EAPOD *podptr)
 
   auto h_ind44r = Kokkos::create_mirror_view(ind44r);
   for (int i = 0; i < nl44; i++) h_ind44r[i] = podptr->ind44r[i];
-  Kokkos::deep_copy(ind44r, h_ind44r); 
+  Kokkos::deep_copy(ind44r, h_ind44r);
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::divideInterval(int *intervals, int N, int M) 
+void PairPODKokkos<DeviceType>::divideInterval(int *intervals, int N, int M)
 {
   int intervalSize = N / M; // Basic size of each interval
   int remainder = N % M;    // Remainder to distribute
@@ -485,11 +485,11 @@ void PairPODKokkos<DeviceType>::divideInterval(int *intervals, int N, int M)
     if (remainder > 0) {
       remainder--;
     }
-  }  
+  }
 }
 
 template<class DeviceType>
-int PairPODKokkos<DeviceType>::calculateNumberOfIntervals(int N, int intervalSize) 
+int PairPODKokkos<DeviceType>::calculateNumberOfIntervals(int N, int intervalSize)
 {
   if (intervalSize <= 0) {
     printf("Interval size must be a positive integer.\n");
@@ -509,7 +509,7 @@ void PairPODKokkos<DeviceType>::grow_atoms(int Ni)
 {
   if (Ni > nimax) {
     nimax = Ni;
-    MemKK::realloc_kokkos(numij, "pair_pod:numij", nimax+1);        
+    MemKK::realloc_kokkos(numij, "pair_pod:numij", nimax+1);
     MemKK::realloc_kokkos(ei, "pair_pod:ei", nimax);
     MemKK::realloc_kokkos(typeai, "pair_pod:typeai", nimax);
     int n = nimax * nelements * K3 * nrbfmax;
@@ -517,8 +517,8 @@ void PairPODKokkos<DeviceType>::grow_atoms(int Ni)
     MemKK::realloc_kokkos(forcecoeff, "pair_pod:forcecoeff", n);
     MemKK::realloc_kokkos(bd, "pair_pod:bd", nimax * Mdesc);
     MemKK::realloc_kokkos(cb, "pair_pod:cb", nimax * Mdesc);
-    if (nClusters > 1)MemKK::realloc_kokkos(pd, "pair_pod:pd", nimax * (1 + nComponents + 3*nClusters));    
-    Kokkos::deep_copy(numij, 0);       
+    if (nClusters > 1)MemKK::realloc_kokkos(pd, "pair_pod:pd", nimax * (1 + nComponents + 3*nClusters));
+    Kokkos::deep_copy(numij, 0);
   }
 }
 
@@ -528,7 +528,7 @@ void PairPODKokkos<DeviceType>::grow_pairs(int Nij)
   if (Nij > nijmax) {
     nijmax = Nij;
     MemKK::realloc_kokkos(rij, "pair_pod:r_ij", 3 * nijmax);
-    MemKK::realloc_kokkos(fij, "pair_pod:f_ij", 3 * nijmax);  
+    MemKK::realloc_kokkos(fij, "pair_pod:f_ij", 3 * nijmax);
     MemKK::realloc_kokkos(idxi, "pair_pod:idxi", nijmax);
     MemKK::realloc_kokkos(ai, "pair_pod:ai", nijmax);
     MemKK::realloc_kokkos(aj, "pair_pod:aj", nijmax);
@@ -542,14 +542,14 @@ void PairPODKokkos<DeviceType>::grow_pairs(int Nij)
     MemKK::realloc_kokkos(abf, "pair_pod:abf", nijmax * kmax);
     MemKK::realloc_kokkos(abfx, "pair_pod:abfx", nijmax * kmax);
     MemKK::realloc_kokkos(abfy, "pair_pod:abfy", nijmax * kmax);
-    MemKK::realloc_kokkos(abfz, "pair_pod:abfz", nijmax * kmax);    
+    MemKK::realloc_kokkos(abfz, "pair_pod:abfz", nijmax * kmax);
   }
 }
 
 template<class DeviceType>
 int PairPODKokkos<DeviceType>::NeighborCount(t_pod_1i l_numij, double l_rcutsq, int gi1, int Ni)
 {
-  // create local shadow views for KOKKOS_LAMBDA to pass them into parallel_for   
+  // create local shadow views for KOKKOS_LAMBDA to pass them into parallel_for
   auto l_ilist = d_ilist;
   auto l_x = x;
   auto l_numneigh = d_numneigh;
@@ -559,10 +559,10 @@ int PairPODKokkos<DeviceType>::NeighborCount(t_pod_1i l_numij, double l_rcutsq,
   Kokkos::parallel_for("NeighborCount", Kokkos::TeamPolicy<>(Ni, Kokkos::AUTO), KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team) {
     int i = team.league_rank();
     int gi = l_ilist(gi1 + i);
-    double xi0 = l_x(gi, 0);    
-    double xi1 = l_x(gi, 1);    
-    double xi2 = l_x(gi, 2);        
-    int jnum = l_numneigh(gi);   
+    double xi0 = l_x(gi, 0);
+    double xi1 = l_x(gi, 1);
+    double xi2 = l_x(gi, 2);
+    int jnum = l_numneigh(gi);
     int ncount = 0;
     Kokkos::parallel_reduce(Kokkos::TeamThreadRange(team,jnum),
         [&] (const int jj, int& count) {
@@ -572,50 +572,50 @@ int PairPODKokkos<DeviceType>::NeighborCount(t_pod_1i l_numij, double l_rcutsq,
       double dely = xi1 - l_x(j,1);
       double delz = xi2 - l_x(j,2);
       double rsq = delx*delx + dely*dely + delz*delz;
-      if (rsq < l_rcutsq) count++;    
+      if (rsq < l_rcutsq) count++;
     },ncount);
 
-    l_numij(i+1) = ncount;    
+    l_numij(i+1) = ncount;
   });
-      
+
   // accumalative sum
   Kokkos::parallel_scan("InclusivePrefixSum", Ni + 1, KOKKOS_LAMBDA(int i, int& update, const bool final) {
-    if (i > 0) { 
+    if (i > 0) {
       update += l_numij(i);
       if (final) {
         l_numij(i) = update;
       }
     }
-  });      
+  });
 
   int total_neighbors = 0;
-  Kokkos::deep_copy(Kokkos::View<int,Kokkos::HostSpace>(&total_neighbors), Kokkos::subview(l_numij, Ni));  
-  
+  Kokkos::deep_copy(Kokkos::View<int,Kokkos::HostSpace>(&total_neighbors), Kokkos::subview(l_numij, Ni));
+
   return total_neighbors;
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::NeighborList(t_pod_1d l_rij, t_pod_1i l_numij,  t_pod_1i l_typeai, 
+void PairPODKokkos<DeviceType>::NeighborList(t_pod_1d l_rij, t_pod_1i l_numij,  t_pod_1i l_typeai,
   t_pod_1i l_idxi, t_pod_1i l_ai, t_pod_1i l_aj, t_pod_1i l_ti, t_pod_1i l_tj, double l_rcutsq, int gi1, int Ni)
-{  
-  // create local shadow views for KOKKOS_LAMBDA to pass them into parallel_for   
+{
+  // create local shadow views for KOKKOS_LAMBDA to pass them into parallel_for
   auto l_ilist = d_ilist;
   auto l_x = x;
   auto l_numneigh = d_numneigh;
   auto l_neighbors = d_neighbors;
-  auto l_map = d_map; 
-  auto l_type = type;     
-  
+  auto l_map = d_map;
+  auto l_type = type;
+
   Kokkos::parallel_for("NeighborList", Kokkos::TeamPolicy<>(Ni, Kokkos::AUTO), KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team) {
     int i = team.league_rank();
     int gi = l_ilist(gi1 + i);
-    double xi0 = l_x(gi, 0);    
-    double xi1 = l_x(gi, 1);    
-    double xi2 = l_x(gi, 2);        
+    double xi0 = l_x(gi, 0);
+    double xi1 = l_x(gi, 1);
+    double xi2 = l_x(gi, 2);
     int itype = l_map(l_type(gi)) + 1; //map[atomtypes[gi]] + 1;
-    l_typeai(i) = itype;        
-    int jnum = l_numneigh(gi);   
-    int nij0 = l_numij(i);    
+    l_typeai(i) = itype;
+    int jnum = l_numneigh(gi);
+    int nij0 = l_numij(i);
     Kokkos::parallel_scan(Kokkos::TeamThreadRange(team,jnum),
         [&] (const int jj, int& offset, bool final) {
       int gj = l_neighbors(gi,jj);
@@ -634,17 +634,17 @@ void PairPODKokkos<DeviceType>::NeighborList(t_pod_1d l_rij, t_pod_1i l_numij,
         l_ai(nij1) = gi;
         l_aj(nij1) = gj;
         l_ti(nij1) = itype;
-        l_tj(nij1) = l_map(l_type(gj)) + 1; //map[atomtypes[gj)) + 1;      
+        l_tj(nij1) = l_map(l_type(gj)) + 1; //map[atomtypes[gj)) + 1;
       }
       offset++;
-    });    
-  });    
+    });
+  });
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::radialbasis(t_pod_1d rbft, t_pod_1d rbftx, t_pod_1d rbfty, t_pod_1d rbftz, 
-    t_pod_1d l_rij, t_pod_1d l_besselparams, double l_rin, double l_rmax, int l_besseldegree, 
-    int l_inversedegree, int l_nbesselpars, int l_ns,  int Nij) 
+void PairPODKokkos<DeviceType>::radialbasis(t_pod_1d rbft, t_pod_1d rbftx, t_pod_1d rbfty, t_pod_1d rbftz,
+    t_pod_1d l_rij, t_pod_1d l_besselparams, double l_rin, double l_rmax, int l_besseldegree,
+    int l_inversedegree, int l_nbesselpars, int l_ns,  int Nij)
 {
   Kokkos::parallel_for("ComputeRadialBasis", Nij, KOKKOS_LAMBDA(int n) {
     double xij1 = l_rij(0+3*n);
@@ -724,13 +724,13 @@ void PairPODKokkos<DeviceType>::radialbasis(t_pod_1d rbft, t_pod_1d rbftx, t_pod
       rbfty(idxni) = drbftdr*dr2;
       rbftz(idxni) = drbftdr*dr3;
     }
-  
+
     // Calculate fcut/dij and dfcut/dij
     f1 = fcut/dij;
     double a = 1.0;
     for (int i=0; i<l_inversedegree; i++) {
       int p = l_besseldegree*l_nbesselpars + i;
-      int idxni = n + Nij*p;      
+      int idxni = n + Nij*p;
       a = a*dij;
 
       rbft(idxni) = fcut/a;
@@ -744,7 +744,7 @@ void PairPODKokkos<DeviceType>::radialbasis(t_pod_1d rbft, t_pod_1d rbftx, t_pod
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::matrixMultiply(t_pod_1d a, t_pod_1d b, t_pod_1d c, int r1, int c1, int c2) 
+void PairPODKokkos<DeviceType>::matrixMultiply(t_pod_1d a, t_pod_1d b, t_pod_1d c, int r1, int c1, int c2)
 {
     Kokkos::parallel_for("MatrixMultiply", r1 * c2, KOKKOS_LAMBDA(int idx) {
         int j = idx / r1;  // Calculate column index
@@ -754,13 +754,13 @@ void PairPODKokkos<DeviceType>::matrixMultiply(t_pod_1d a, t_pod_1d b, t_pod_1d
             sum += a(i + r1*k) * b(k + c1*j);  // Manually calculate the 1D index
         }
         c(i + r1*j) = sum;  // Manually calculate the 1D index for c
-    });        
+    });
 }
 
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::angularbasis(t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
-        t_pod_1d l_rij, t_pod_1i l_pq3, int l_K3, int N) 
-{  
+        t_pod_1d l_rij, t_pod_1i l_pq3, int l_K3, int N)
+{
   Kokkos::parallel_for("AngularBasis", N, KOKKOS_LAMBDA(int j) {
     double x = l_rij(j*3 + 0);
     double y = l_rij(j*3 + 1);
@@ -795,12 +795,12 @@ void PairPODKokkos<DeviceType>::angularbasis(t_pod_1d l_abf, t_pod_1d l_abfx, t_
     l_abf(idxa) = 1.0;
     l_abfx(idxa) = 0.0;
     l_abfy(idxa) = 0.0;
-    l_abfz(idxa) = 0.0;    
-    
+    l_abfz(idxa) = 0.0;
+
     // Loop over all angular basis functions
     for (int n=1; n<l_K3; n++) {
       // Get indices for angular basis function
-      int d = l_pq3(n + l_K3);      
+      int d = l_pq3(n + l_K3);
       int mj = j + N*(l_pq3(n)-1);
       idxa = j + N*n;
       // Calculate angular basis function and its derivatives using recursion relation
@@ -821,24 +821,24 @@ void PairPODKokkos<DeviceType>::angularbasis(t_pod_1d l_abf, t_pod_1d l_abfx, t_
         l_abfx(idxa) = l_abfx(mj)*w;
         l_abfy(idxa) = l_abfy(mj)*w;
         l_abfz(idxa) = l_abfz(mj)*w + l_abf(mj);
-      }            
+      }
     }
-    for (int n=1; n<l_K3; n++) {      
+    for (int n=1; n<l_K3; n++) {
       idxa = j + N*n;
       x = l_abfx(idxa);
       y = l_abfy(idxa);
       z = l_abfz(idxa);
       l_abfx(idxa) = x*dudx + y*dvdx + z*dwdx;
       l_abfy(idxa) = x*dudy + y*dvdy + z*dwdy;
-      l_abfz(idxa) = x*dudz + y*dvdz + z*dwdz;      
+      l_abfz(idxa) = x*dudz + y*dvdz + z*dwdz;
     }
   });
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::radialangularsum(t_pod_1d l_sumU, t_pod_1d l_rbf, t_pod_1d l_abf, t_pod_1i l_tj, 
-    t_pod_1i l_numij, const int l_nelements, const int l_nrbf3, const int l_K3, const int Ni, const int Nij) 
-{  
+void PairPODKokkos<DeviceType>::radialangularsum(t_pod_1d l_sumU, t_pod_1d l_rbf, t_pod_1d l_abf, t_pod_1i l_tj,
+    t_pod_1i l_numij, const int l_nelements, const int l_nrbf3, const int l_K3, const int Ni, const int Nij)
+{
   int totalIterations = l_nrbf3 * l_K3 * Ni;
   if (l_nelements==1) {
     Kokkos::parallel_for("RadialAngularSum", totalIterations, KOKKOS_LAMBDA(int idx) {
@@ -849,14 +849,14 @@ void PairPODKokkos<DeviceType>::radialangularsum(t_pod_1d l_sumU, t_pod_1d l_rbf
       int kmi = k + l_K3*m + l_K3*l_nrbf3*i;
 
       int start = l_numij(i);
-      int nj = l_numij(i+1)-start;    
+      int nj = l_numij(i+1)-start;
       double sum=0.0;
       for (int j=0; j<nj; j++) {
         int n = start + j;
-        sum += l_rbf(n + Nij * m) * l_abf(n + Nij * k);    
-      }    
+        sum += l_rbf(n + Nij * m) * l_abf(n + Nij * k);
+      }
       l_sumU(kmi) = sum;
-    });    
+    });
   }
   else {
     Kokkos::parallel_for("RadialAngularSum", totalIterations, KOKKOS_LAMBDA(int idx) {
@@ -866,26 +866,26 @@ void PairPODKokkos<DeviceType>::radialangularsum(t_pod_1d l_sumU, t_pod_1d l_rbf
       int i = temp / l_nrbf3;
       int kmi = l_nelements*k + l_nelements*l_K3*m + l_nelements*l_K3*l_nrbf3*i;
       int start = l_numij(i);
-      int nj = l_numij(i+1)-start;    
+      int nj = l_numij(i+1)-start;
 
       double tm[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       for (int j=0; j<nj; j++) {
         int n = start + j;
         int ia = n + Nij * k;
-        int ib = n + Nij * m;            
+        int ib = n + Nij * m;
         int tn = l_tj(n) - 1; // offset the atom type by 1, since atomtype is 1-based
-        tm[tn] += l_rbf(ib) * l_abf(ia);    
-      }        
+        tm[tn] += l_rbf(ib) * l_abf(ia);
+      }
       for (int j=0; j<l_nelements; j++) l_sumU(j + kmi) = tm[j];
     });
   }
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::twobodydesc(t_pod_1d d2,  t_pod_1d l_rbf, t_pod_1i l_idxi, t_pod_1i l_tj, 
-        int l_nrbf2, const int Ni, const int Nij) 
+void PairPODKokkos<DeviceType>::twobodydesc(t_pod_1d d2,  t_pod_1d l_rbf, t_pod_1i l_idxi, t_pod_1i l_tj,
+        int l_nrbf2, const int Ni, const int Nij)
 {
-  int totalIterations = l_nrbf2 * Nij;    
+  int totalIterations = l_nrbf2 * Nij;
   Kokkos::parallel_for("twobodydesc", totalIterations, KOKKOS_LAMBDA(int idx) {
     int n = idx / l_nrbf2; // pair index
     int m = idx % l_nrbf2; // rbd index
@@ -895,10 +895,10 @@ void PairPODKokkos<DeviceType>::twobodydesc(t_pod_1d d2,  t_pod_1d l_rbf, t_pod_
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::twobody_forces(t_pod_1d fij, t_pod_1d cb2, t_pod_1d l_rbfx, t_pod_1d l_rbfy, 
-        t_pod_1d l_rbfz, t_pod_1i l_idxi, t_pod_1i l_tj, int l_nrbf2, const int Ni, const int Nij) 
+void PairPODKokkos<DeviceType>::twobody_forces(t_pod_1d fij, t_pod_1d cb2, t_pod_1d l_rbfx, t_pod_1d l_rbfy,
+        t_pod_1d l_rbfz, t_pod_1i l_idxi, t_pod_1i l_tj, int l_nrbf2, const int Ni, const int Nij)
 {
-  int totalIterations = l_nrbf2 * Nij;    
+  int totalIterations = l_nrbf2 * Nij;
   Kokkos::parallel_for("twobody_forces", totalIterations, KOKKOS_LAMBDA(int idx) {
     int n = idx / l_nrbf2; // pair index
     int m = idx % l_nrbf2; // rbd index
@@ -907,18 +907,18 @@ void PairPODKokkos<DeviceType>::twobody_forces(t_pod_1d fij, t_pod_1d cb2, t_pod
     double c = cb2(l_idxi(n) + Ni*m + Ni*l_nrbf2*(l_tj(n) - 1));
     Kokkos::atomic_add(&fij(0 + i1), c*l_rbfx(i2)); // Add the derivative with respect to x to the corresponding descriptor derivative
     Kokkos::atomic_add(&fij(1 + i1), c*l_rbfy(i2)); // Add the derivative with respect to y to the corresponding descriptor derivative
-    Kokkos::atomic_add(&fij(2 + i1), c*l_rbfz(i2)); // Add the derivative with respect to z to the corresponding descriptor derivative    
+    Kokkos::atomic_add(&fij(2 + i1), c*l_rbfz(i2)); // Add the derivative with respect to z to the corresponding descriptor derivative
   });
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::threebodydesc(t_pod_1d d3, t_pod_1d l_sumU, t_pod_1i l_pc3, t_pod_1i l_pn3, 
-        int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, const int Ni) 
+void PairPODKokkos<DeviceType>::threebodydesc(t_pod_1d d3, t_pod_1d l_sumU, t_pod_1i l_pc3, t_pod_1i l_pn3,
+        int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, const int Ni)
 {
   int totalIterations = l_nrbf3 * Ni;
   Kokkos::parallel_for("ThreeBodyDesc", totalIterations, KOKKOS_LAMBDA(int idx) {
     int m = idx % l_nrbf3;
-    int i = idx / l_nrbf3;        
+    int i = idx / l_nrbf3;
     int nmi = l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3*i;
     for (int p = 0; p < l_nabf3; p++) {
       int n1 = l_pn3(p);
@@ -926,24 +926,24 @@ void PairPODKokkos<DeviceType>::threebodydesc(t_pod_1d d3, t_pod_1d l_sumU, t_po
       int nn = n2 - n1;
       int ipm = i + Ni * (p + l_nabf3 * m);
       int k = 0;
-      for (int i1 = 0; i1 < l_nelements; i1++) {                  
+      for (int i1 = 0; i1 < l_nelements; i1++) {
         for (int i2 = i1; i2 < l_nelements; i2++) {
           double tmp=0;
-          for (int q = 0; q < nn; q++) {            
-            tmp += l_pc3(n1 + q) * l_sumU(i1 + l_nelements * (n1 + q) + nmi) * l_sumU(i2 + l_nelements * (n1 + q) + nmi);            
+          for (int q = 0; q < nn; q++) {
+            tmp += l_pc3(n1 + q) * l_sumU(i1 + l_nelements * (n1 + q) + nmi) * l_sumU(i2 + l_nelements * (n1 + q) + nmi);
           }
           d3(ipm + totalIterations * l_nabf3 * k) = tmp;
           k += 1;
         }
       }
     }
-  });  
+  });
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::threebody_forces(t_pod_1d fij, t_pod_1d cb3, t_pod_1d l_rbf, t_pod_1d l_rbfx, 
-    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, 
-    t_pod_1d l_sumU, t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pc3, t_pod_1i l_pn3, t_pod_1i l_elemindex, 
+void PairPODKokkos<DeviceType>::threebody_forces(t_pod_1d fij, t_pod_1d cb3, t_pod_1d l_rbf, t_pod_1d l_rbfx,
+    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
+    t_pod_1d l_sumU, t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pc3, t_pod_1i l_pn3, t_pod_1i l_elemindex,
     int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, int Ni, int Nij)
 {
   int totalIterations = l_nrbf3 * Nij;
@@ -958,89 +958,89 @@ void PairPODKokkos<DeviceType>::threebody_forces(t_pod_1d fij, t_pod_1d cb3, t_p
       double rbfzBase = l_rbfz(idxR);
       double fx = 0;
       double fy = 0;
-      double fz = 0;      
+      double fz = 0;
       for (int p = 0; p < l_nabf3; p++) {
         double c3 = 2.0 * cb3(l_idxi(j) + Ni*p + Ni*l_nabf3*m);
-        int n1 = l_pn3(p);        
-        int nn = l_pn3(p + 1) - n1;        
+        int n1 = l_pn3(p);
+        int nn = l_pn3(p + 1) - n1;
         int idxU = l_K3 * m + l_K3*l_nrbf3*l_idxi(j);
-        for (int q = 0; q < nn; q++) {                  
-          int idxNQ = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU          
-          double f = c3 * l_pc3(idxNQ) * l_sumU(idxNQ + idxU);                             
-          int idxA = j + Nij*idxNQ;  // Pre-compute the index for abf          
-          double abfA = l_abf(idxA);  
+        for (int q = 0; q < nn; q++) {
+          int idxNQ = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU
+          double f = c3 * l_pc3(idxNQ) * l_sumU(idxNQ + idxU);
+          int idxA = j + Nij*idxNQ;  // Pre-compute the index for abf
+          double abfA = l_abf(idxA);
 
           // Use the pre-computed indices to update dd3
           fx += f * (l_abfx(idxA) * rbfBase + rbfxBase * abfA);
           fy += f * (l_abfy(idxA) * rbfBase + rbfyBase * abfA);
-          fz += f * (l_abfz(idxA) * rbfBase + rbfzBase * abfA);          
+          fz += f * (l_abfz(idxA) * rbfBase + rbfzBase * abfA);
         }
       }
-      int ii = 3 * j;  // Pre-compute the base index for dd3        
+      int ii = 3 * j;  // Pre-compute the base index for dd3
       Kokkos::atomic_add(&fij(0 + ii), fx); // Add the derivative with respect to x to the corresponding descriptor derivative
       Kokkos::atomic_add(&fij(1 + ii), fy); // Add the derivative with respect to y to the corresponding descriptor derivative
-      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative          
+      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative
     });
   }
   else {
     int N3 = Ni *  l_nabf3 * l_nrbf3;
     Kokkos::parallel_for("threebody_forces2", totalIterations, KOKKOS_LAMBDA(int idx) {
       int j = idx / l_nrbf3;  // Derive the original j value
-      int m = idx % l_nrbf3;  // Derive the original m value      
+      int m = idx % l_nrbf3;  // Derive the original m value
       int i2 = l_tj(j) - 1;
-      int idxK = l_nelements * l_K3 * m + l_nelements*l_K3*l_nrbf3*l_idxi(j);      
-      int idxR = j + Nij * m;  // Pre-compute the index for rbf      
+      int idxK = l_nelements * l_K3 * m + l_nelements*l_K3*l_nrbf3*l_idxi(j);
+      int idxR = j + Nij * m;  // Pre-compute the index for rbf
       double rbfBase = l_rbf(idxR);
       double rbfxBase = l_rbfx(idxR);
       double rbfyBase = l_rbfy(idxR);
       double rbfzBase = l_rbfz(idxR);
       double fx = 0;
       double fy = 0;
-      double fz = 0;            
+      double fz = 0;
       for (int p = 0; p < l_nabf3; p++) {
         int n1 = l_pn3(p);
-        int nn = l_pn3(p + 1) - n1;        
+        int nn = l_pn3(p + 1) - n1;
         int jmp = l_idxi(j) + Ni*(p + l_nabf3*m);
-        for (int i1 = 0; i1 < l_nelements; i1++) {                    
-          double c3 = (i1 == i2) ? 2.0 : 1.0;          
+        for (int i1 = 0; i1 < l_nelements; i1++) {
+          double c3 = (i1 == i2) ? 2.0 : 1.0;
           c3 = c3 * cb3(jmp + N3*l_elemindex(i2 + l_nelements * i1));
           for (int q = 0; q < nn; q++) {
-            int idxNQ = n1 + q;  // Combine n1 and q into a single index            
-            int idxA = j + Nij*idxNQ;  // Pre-compute the index for abf          
-            double abfA = l_abf(idxA);   
-            double f = c3 * l_pc3(idxNQ) * l_sumU(i1 + l_nelements * idxNQ + idxK);                                    
+            int idxNQ = n1 + q;  // Combine n1 and q into a single index
+            int idxA = j + Nij*idxNQ;  // Pre-compute the index for abf
+            double abfA = l_abf(idxA);
+            double f = c3 * l_pc3(idxNQ) * l_sumU(i1 + l_nelements * idxNQ + idxK);
             fx += f * (l_abfx(idxA) * rbfBase + rbfxBase * abfA);
             fy += f * (l_abfy(idxA) * rbfBase + rbfyBase * abfA);
-            fz += f * (l_abfz(idxA) * rbfBase + rbfzBase * abfA);          
-          }          
+            fz += f * (l_abfz(idxA) * rbfBase + rbfzBase * abfA);
+          }
         }
       }
-      int ii = 3 * j;  // Pre-compute the base index for dd3        
+      int ii = 3 * j;  // Pre-compute the base index for dd3
       Kokkos::atomic_add(&fij(0 + ii), fx); // Add the derivative with respect to x to the corresponding descriptor derivative
       Kokkos::atomic_add(&fij(1 + ii), fy); // Add the derivative with respect to y to the corresponding descriptor derivative
-      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative                
-    });    
+      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative
+    });
   }
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::threebody_forcecoeff(t_pod_1d fb3, t_pod_1d cb3,     
-    t_pod_1d l_sumU, t_pod_1i l_pc3, t_pod_1i l_pn3, t_pod_1i l_elemindex, 
+void PairPODKokkos<DeviceType>::threebody_forcecoeff(t_pod_1d fb3, t_pod_1d cb3,
+    t_pod_1d l_sumU, t_pod_1i l_pc3, t_pod_1i l_pn3, t_pod_1i l_elemindex,
     int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, int Ni)
 {
   int totalIterations = l_nrbf3 * Ni;
   if (l_nelements==1) {
     Kokkos::parallel_for("threebody_forcecoeff1", totalIterations, KOKKOS_LAMBDA(int idx) {
       int i = idx / l_nrbf3;       // Calculate j using integer division
-      int m = idx % l_nrbf3;       // Calculate m using modulo operation            
+      int m = idx % l_nrbf3;       // Calculate m using modulo operation
       for (int p = 0; p < l_nabf3; p++) {
         double c3 = 2.0 * cb3(i + Ni*p + Ni*l_nabf3*m);
-        int n1 = l_pn3(p);        
-        int nn = l_pn3(p + 1) - n1;        
+        int n1 = l_pn3(p);
+        int nn = l_pn3(p + 1) - n1;
         int idxU = l_K3 * m + l_K3*l_nrbf3*i;
-        for (int q = 0; q < nn; q++) {                  
-          int idxNQ = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU          
-          fb3(idxNQ + idxU) += c3 * l_pc3(idxNQ) * l_sumU(idxNQ + idxU);                                       
+        for (int q = 0; q < nn; q++) {
+          int idxNQ = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU
+          fb3(idxNQ + idxU) += c3 * l_pc3(idxNQ) * l_sumU(idxNQ + idxU);
         }
       }
     });
@@ -1049,76 +1049,76 @@ void PairPODKokkos<DeviceType>::threebody_forcecoeff(t_pod_1d fb3, t_pod_1d cb3,
     int N3 = Ni *  l_nabf3 * l_nrbf3;
     Kokkos::parallel_for("threebody_forcecoeff2", totalIterations, KOKKOS_LAMBDA(int idx) {
       int i = idx / l_nrbf3;  // Derive the original j value
-      int m = idx % l_nrbf3;  // Derive the original m value      
+      int m = idx % l_nrbf3;  // Derive the original m value
       for (int p = 0; p < l_nabf3; p++) {
         int n1 = l_pn3(p);
-        int nn = l_pn3(p + 1) - n1;        
+        int nn = l_pn3(p + 1) - n1;
         int jmp = i + Ni*(p + l_nabf3*m);
         for (int q = 0; q < nn; q++) {
-          int k = n1 + q;  // Combine n1 and q into a single index            
-          int idxU = l_nelements * k + l_nelements * l_K3 * m + l_nelements*l_K3*l_nrbf3*i;          
+          int k = n1 + q;  // Combine n1 and q into a single index
+          int idxU = l_nelements * k + l_nelements * l_K3 * m + l_nelements*l_K3*l_nrbf3*i;
           for (int i1 = 0; i1 < l_nelements; i1++) {
             double tm = l_pc3[k] * l_sumU[i1 + idxU];
             for (int i2 = i1; i2 < l_nelements; i2++) {
-              int em = l_elemindex[i2 + l_nelements * i1];       
+              int em = l_elemindex[i2 + l_nelements * i1];
               double t1 = tm * cb3[jmp + N3*em]; // Ni *  nabf3 * nrbf3 * nelements*(nelements+1)/2
-              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni         
+              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni
               fb3[i1 + idxU] += l_pc3[k] * cb3[jmp + N3*em] * l_sumU[i2 + idxU];
             }
-          }          
+          }
         }
       }
-    });    
+    });
   }
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::fourbodydesc(t_pod_1d d4,  t_pod_1d l_sumU, t_pod_1i l_pa4, t_pod_1i l_pb4, 
+void PairPODKokkos<DeviceType>::fourbodydesc(t_pod_1d d4,  t_pod_1d l_sumU, t_pod_1i l_pa4, t_pod_1i l_pb4,
     t_pod_1i l_pc4, int l_nelements, int l_nrbf3, int l_nrbf4, int l_nabf4, int l_K3, int l_Q4, int Ni)
 {
   int totalIterations = l_nrbf4 * Ni;
   Kokkos::parallel_for("fourbodydesc", totalIterations, KOKKOS_LAMBDA(int idx) {
     int m = idx % l_nrbf4;
-    int i = idx / l_nrbf4;            
+    int i = idx / l_nrbf4;
     int idxU = l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * i;
     for (int p = 0; p < l_nabf4; p++) {
       int n1 = l_pa4(p);
       int n2 = l_pa4(p + 1);
       int nn = n2 - n1;
       int k = 0;
-      for (int i1 = 0; i1 < l_nelements; i1++) {                  
-        for (int i2 = i1; i2 < l_nelements; i2++) {                                
-          for (int i3 = i2; i3 < l_nelements; i3++) {     
+      for (int i1 = 0; i1 < l_nelements; i1++) {
+        for (int i2 = i1; i2 < l_nelements; i2++) {
+          for (int i3 = i2; i3 < l_nelements; i3++) {
             double tmp = 0.0;
-            for (int q = 0; q < nn; q++) {         
+            for (int q = 0; q < nn; q++) {
               int c = l_pc4(n1 + q);
               int j1 = l_pb4(n1 + q);
               int j2 = l_pb4(n1 + q + l_Q4);
-              int j3 = l_pb4(n1 + q + 2 * l_Q4);              
+              int j3 = l_pb4(n1 + q + 2 * l_Q4);
               tmp += c * l_sumU(idxU + i1 + l_nelements * j1) * l_sumU(idxU + i2 + l_nelements * j2) * l_sumU(idxU + i3 + l_nelements * j3);
             }
-            int kk = p + l_nabf4 * m + l_nabf4 * l_nrbf4 * k;              
+            int kk = p + l_nabf4 * m + l_nabf4 * l_nrbf4 * k;
             d4(i + Ni * kk) = tmp;
-            k += 1;            
+            k += 1;
           }
         }
       }
     }
-  });  
+  });
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_pod_1d l_rbf, t_pod_1d l_rbfx, 
-    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, 
-    t_pod_1d l_sumU, t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, t_pod_1i l_elemindex, 
+void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_pod_1d l_rbf, t_pod_1d l_rbfx,
+    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
+    t_pod_1d l_sumU, t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, t_pod_1i l_elemindex,
     int l_nelements, int l_nrbf3, int l_nrbf4, int l_nabf4, int l_K3, int l_Q4, int Ni, int Nij)
 {
   int totalIterations = l_nrbf4 * Nij;
   if (l_nelements==1) {
     Kokkos::parallel_for("fourbody_forces1", totalIterations, KOKKOS_LAMBDA(int idx) {
       int j = idx / l_nrbf4;  // Derive the original j value
-      int m = idx % l_nrbf4;  // Derive the original m value      
-      int idxU = l_K3 * m + l_K3*l_nrbf3*l_idxi(j);      
+      int m = idx % l_nrbf4;  // Derive the original m value
+      int idxU = l_K3 * m + l_K3*l_nrbf3*l_idxi(j);
       int baseIdxJ = j + Nij * m;  // Pre-compute the index for rbf
       double rbfBase = l_rbf(baseIdxJ);
       double rbfxBase = l_rbfx(baseIdxJ);
@@ -1126,7 +1126,7 @@ void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_po
       double rbfzBase = l_rbfz(baseIdxJ);
       double fx = 0;
       double fy = 0;
-      double fz = 0;            
+      double fz = 0;
       for (int p = 0; p < l_nabf4; p++) {
         int n1 = l_pa4(p);
         int n2 = l_pa4(p + 1);
@@ -1134,22 +1134,22 @@ void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_po
         double c4 = cb4(l_idxi(j) + Ni*p + Ni*l_nabf4*m);
         for (int q = 0; q < nn; q++) {
           int idxNQ = n1 + q;  // Combine n1 and q into a single index
-          double c = c4 * l_pc4[idxNQ];          
+          double c = c4 * l_pc4[idxNQ];
           int j1 = l_pb4(idxNQ);
           int j2 = l_pb4(idxNQ + l_Q4);
           int j3 = l_pb4(idxNQ + 2 * l_Q4);
           double c1 = l_sumU(idxU + j1);
           double c2 = l_sumU(idxU + j2);
-          double c3 = l_sumU(idxU + j3);                    
-          double t12 = c * c1 * c2;          
+          double c3 = l_sumU(idxU + j3);
+          double t12 = c * c1 * c2;
           double t13 = c * c1 * c3;
           double t23 = c * c2 * c3;
-          
-          // Pre-calculate commonly used indices          
+
+          // Pre-calculate commonly used indices
           int baseIdxJ3 = j + Nij * j3; // Common index for j3 terms
           int baseIdxJ2 = j + Nij * j2; // Common index for j2 terms
           int baseIdxJ1 = j + Nij * j1; // Common index for j1 terms
-                    
+
           // Temporary variables to store repeated calculations
           double abfBaseJ1 = l_abf(baseIdxJ1);
           double abfBaseJ2 = l_abf(baseIdxJ2);
@@ -1166,54 +1166,54 @@ void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_po
                             + t23 * (l_abfz(baseIdxJ1) * rbfBase + rbfzBase * abfBaseJ1);
         }
       }
-      int ii = 3 * j;  // Pre-compute the base index for dd3        
+      int ii = 3 * j;  // Pre-compute the base index for dd3
       Kokkos::atomic_add(&fij(0 + ii), fx); // Add the derivative with respect to x to the corresponding descriptor derivative
       Kokkos::atomic_add(&fij(1 + ii), fy); // Add the derivative with respect to y to the corresponding descriptor derivative
-      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative                      
+      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative
     });
   }
-  else {        
+  else {
     int N3 = Ni * l_nabf4 * l_nrbf4;
     Kokkos::parallel_for("fourbody_forces2", totalIterations, KOKKOS_LAMBDA(int idx) {
       int j = idx / l_nrbf4;  // Derive the original j value
-      int m = idx % l_nrbf4;  // Derive the original m value          
+      int m = idx % l_nrbf4;  // Derive the original m value
       int idxM = j + Nij * m;
       double rbfM = l_rbf(idxM);
       double rbfxM = l_rbfx(idxM);
       double rbfyM = l_rbfy(idxM);
       double rbfzM = l_rbfz(idxM);
-      int typej = l_tj(j) - 1;      
+      int typej = l_tj(j) - 1;
       double fx = 0;
       double fy = 0;
-      double fz = 0;                  
+      double fz = 0;
       for (int p = 0; p < l_nabf4; p++)  {
         int n1 = l_pa4(p);
         int n2 = l_pa4(p + 1);
         int nn = n2 - n1;
         int jpm = l_idxi(j) + Ni*p + Ni*l_nabf4*m;
-        int k = 0;          
-        for (int i1 = 0; i1 < l_nelements; i1++) {                                 
-          for (int i2 = i1; i2 < l_nelements; i2++) {                          
-            for (int i3 = i2; i3 < l_nelements; i3++) {       
-              for (int q = 0; q < nn; q++) {  
-                double c = l_pc4(n1 + q) * cb4(jpm + N3*k);                
+        int k = 0;
+        for (int i1 = 0; i1 < l_nelements; i1++) {
+          for (int i2 = i1; i2 < l_nelements; i2++) {
+            for (int i3 = i2; i3 < l_nelements; i3++) {
+              for (int q = 0; q < nn; q++) {
+                double c = l_pc4(n1 + q) * cb4(jpm + N3*k);
                 int j1 = l_pb4(n1 + q);
                 int j2 = l_pb4(n1 + q + l_Q4);
                 int j3 = l_pb4(n1 + q + 2 * l_Q4);
-                
+
                 int idx1 = i1 + l_nelements * j1 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * l_idxi(j);
                 int idx2 = i2 + l_nelements * j2 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * l_idxi(j);
-                int idx3 = i3 + l_nelements * j3 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * l_idxi(j);                
+                int idx3 = i3 + l_nelements * j3 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * l_idxi(j);
                 double c1 = l_sumU(idx1);
                 double c2 = l_sumU(idx2 );
-                double c3 = l_sumU(idx3);     
-                double t12 = c*(c1 * c2);                  
+                double c3 = l_sumU(idx3);
+                double t12 = c*(c1 * c2);
                 double t13 = c*(c1 * c3);
-                double t23 = c*(c2 * c3);                
-                                
+                double t23 = c*(c2 * c3);
+
                 int idxJ3 = j + Nij * j3;
                 int idxJ2 = j + Nij * j2;
-                int idxJ1 = j + Nij * j1;                          
+                int idxJ1 = j + Nij * j1;
                 double abfJ1 = l_abf(idxJ1);
                 double abfJ2 = l_abf(idxJ2);
                 double abfJ3 = l_abf(idxJ3);
@@ -1226,7 +1226,7 @@ void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_po
                 double abfzJ1 = l_abfz(idxJ1);
                 double abfzJ2 = l_abfz(idxJ2);
                 double abfzJ3 = l_abfz(idxJ3);
-                
+
                 // Compute contributions for each condition
                 if (typej == i3) {
                     fx += t12 * (abfxJ3 * rbfM + rbfxM * abfJ3);
@@ -1242,32 +1242,32 @@ void PairPODKokkos<DeviceType>::fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_po
                     fx += t23 * (abfxJ1 * rbfM + rbfxM * abfJ1);
                     fy += t23 * (abfyJ1 * rbfM + rbfyM * abfJ1);
                     fz += t23 * (abfzJ1 * rbfM + rbfzM * abfJ1);
-                }                
+                }
               }
               k += 1;
             }
           }
         }
       }
-      int ii = 3 * j;  // Pre-compute the base index for dd3        
+      int ii = 3 * j;  // Pre-compute the base index for dd3
       Kokkos::atomic_add(&fij(0 + ii), fx); // Add the derivative with respect to x to the corresponding descriptor derivative
       Kokkos::atomic_add(&fij(1 + ii), fy); // Add the derivative with respect to y to the corresponding descriptor derivative
-      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative                            
-    });    
+      Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative
+    });
   }
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::fourbody_forcecoeff(t_pod_1d fb4, t_pod_1d cb4,     
-    t_pod_1d l_sumU, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, int l_nelements, 
+void PairPODKokkos<DeviceType>::fourbody_forcecoeff(t_pod_1d fb4, t_pod_1d cb4,
+    t_pod_1d l_sumU, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, int l_nelements,
         int l_nrbf3, int l_nrbf4, int l_nabf4, int l_K3, int l_Q4, int Ni)
 {
   int totalIterations = l_nrbf4 * Ni;
   if (l_nelements==1) {
     Kokkos::parallel_for("fourbody_forcecoeff1", totalIterations, KOKKOS_LAMBDA(int idx) {
       int i = idx / l_nrbf4;  // Derive the original j value
-      int m = idx % l_nrbf4;  // Derive the original m value      
-      int idxU = l_K3 * m + l_K3*l_nrbf3*i;      
+      int m = idx % l_nrbf4;  // Derive the original m value
+      int idxU = l_K3 * m + l_K3*l_nrbf3*i;
       for (int p = 0; p < l_nabf4; p++) {
         int n1 = l_pa4(p);
         int n2 = l_pa4(p + 1);
@@ -1275,62 +1275,62 @@ void PairPODKokkos<DeviceType>::fourbody_forcecoeff(t_pod_1d fb4, t_pod_1d cb4,
         double c4 = cb4(i + Ni*p + Ni*l_nabf4*m);
         for (int q = 0; q < nn; q++) {
           int idxNQ = n1 + q;  // Combine n1 and q into a single index
-          double c = c4 * l_pc4[idxNQ];          
+          double c = c4 * l_pc4[idxNQ];
           int j1 = idxU + l_pb4(idxNQ);
           int j2 = idxU + l_pb4(idxNQ + l_Q4);
           int j3 = idxU + l_pb4(idxNQ + 2 * l_Q4);
           double c1 = l_sumU(j1);
           double c2 = l_sumU(j2);
-          double c3 = l_sumU(j3);                    
-          fb4[j3] += c * c1 * c2;          
+          double c3 = l_sumU(j3);
+          fb4[j3] += c * c1 * c2;
           fb4[j2] += c * c1 * c3;
-          fb4[j1] += c * c2 * c3;          
+          fb4[j1] += c * c2 * c3;
         }
       }
     });
   }
-  else {        
+  else {
     int N3 = Ni * l_nabf4 * l_nrbf4;
     Kokkos::parallel_for("fourbody_forcecoeff2", totalIterations, KOKKOS_LAMBDA(int idx) {
       int i = idx / l_nrbf4;  // Derive the original j value
-      int m = idx % l_nrbf4;  // Derive the original m value          
+      int m = idx % l_nrbf4;  // Derive the original m value
       for (int p = 0; p < l_nabf4; p++)  {
         int n1 = l_pa4(p);
         int n2 = l_pa4(p + 1);
         int nn = n2 - n1;
-        int jpm = i + Ni*p + Ni*l_nabf4*m;        
-        for (int q = 0; q < nn; q++) {  
-          double c = l_pc4(n1 + q);                
+        int jpm = i + Ni*p + Ni*l_nabf4*m;
+        for (int q = 0; q < nn; q++) {
+          double c = l_pc4(n1 + q);
           int j1 = l_pb4(n1 + q);
           int j2 = l_pb4(n1 + q + l_Q4);
-          int j3 = l_pb4(n1 + q + 2 * l_Q4);     
+          int j3 = l_pb4(n1 + q + 2 * l_Q4);
           int idx1 = l_nelements * j1 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * i;
           int idx2 = l_nelements * j2 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * i;
-          int idx3 = l_nelements * j3 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * i;  
-          int k = 0;          
-          for (int i1 = 0; i1 < l_nelements; i1++) {        
+          int idx3 = l_nelements * j3 + l_nelements * l_K3 * m + l_nelements * l_K3 * l_nrbf3 * i;
+          int k = 0;
+          for (int i1 = 0; i1 < l_nelements; i1++) {
             double c1 = l_sumU[idx1 + i1];
-            for (int i2 = i1; i2 < l_nelements; i2++) {                          
-              double c2 = l_sumU[idx2 + i2];    
-              for (int i3 = i2; i3 < l_nelements; i3++) {                     
-                double c3 = l_sumU[idx3 + i3];          
+            for (int i2 = i1; i2 < l_nelements; i2++) {
+              double c2 = l_sumU[idx2 + i2];
+              for (int i3 = i2; i3 < l_nelements; i3++) {
+                double c3 = l_sumU[idx3 + i3];
                 double c4 = c * cb4[jpm + N3*k];
-                fb4[idx3 + i3] += c4*(c1 * c2);  
+                fb4[idx3 + i3] += c4*(c1 * c2);
                 fb4[idx2 + i2] += c4*(c1 * c3);
-                fb4[idx1 + i1] += c4*(c2 * c3);                                                
-                k += 1;                
-              }              
+                fb4[idx1 + i1] += c4*(c2 * c3);
+                k += 1;
+              }
             }
           }
         }
       }
-    });    
+    });
   }
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::allbody_forces(t_pod_1d fij, t_pod_1d l_forcecoeff, t_pod_1d l_rbf, t_pod_1d l_rbfx, 
-    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, 
+void PairPODKokkos<DeviceType>::allbody_forces(t_pod_1d fij, t_pod_1d l_forcecoeff, t_pod_1d l_rbf, t_pod_1d l_rbfx,
+    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
     t_pod_1i l_idxi, t_pod_1i l_tj, int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, int Nij)
 {
   int totalIterations = l_nrbf3 * Nij;
@@ -1345,23 +1345,23 @@ void PairPODKokkos<DeviceType>::allbody_forces(t_pod_1d fij, t_pod_1d l_forcecoe
     double rbfzBase = l_rbfz(idxR);
     double fx = 0;
     double fy = 0;
-    double fz = 0;      
+    double fz = 0;
     for (int k = 0; k < l_K3; k++) {
       int idxU = l_nelements * k + l_nelements * l_K3 * m + l_nelements*l_K3*l_nrbf3*l_idxi[j];
       double fc = l_forcecoeff[i2 + idxU];
-      int idxA = j + Nij*k;  // Pre-compute the index for abf          
-      double abfA = l_abf[idxA];   
+      int idxA = j + Nij*k;  // Pre-compute the index for abf
+      double abfA = l_abf[idxA];
       double abfxA = l_abfx[idxA];
       double abfyA = l_abfy[idxA];
-      double abfzA = l_abfz[idxA];        
-      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij 
+      double abfzA = l_abfz[idxA];
+      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij
       fy += fc * (abfyA * rbfBase + rbfyBase * abfA);
-      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);                        
-    }    
-    int ii = 3 * j;  // Pre-compute the base index for dd3        
+      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);
+    }
+    int ii = 3 * j;  // Pre-compute the base index for dd3
     Kokkos::atomic_add(&fij(0 + ii), fx); // Add the derivative with respect to x to the corresponding descriptor derivative
     Kokkos::atomic_add(&fij(1 + ii), fy); // Add the derivative with respect to y to the corresponding descriptor derivative
-    Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative          
+    Kokkos::atomic_add(&fij(2 + ii), fz); // Add the derivative with respect to z to the corresponding descriptor derivative
   });
 }
 
@@ -1378,9 +1378,9 @@ void PairPODKokkos<DeviceType>::crossdesc(t_pod_1d d12, t_pod_1d d1, t_pod_1d d2
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::crossdesc_reduction(t_pod_1d cb1, t_pod_1d cb2, t_pod_1d c12, t_pod_1d d1, 
+void PairPODKokkos<DeviceType>::crossdesc_reduction(t_pod_1d cb1, t_pod_1d cb2, t_pod_1d c12, t_pod_1d d1,
         t_pod_1d d2, t_pod_1i ind1, t_pod_1i ind2, int n12, int Ni)
-{  
+{
   int totalIterations = n12 * Ni;
   Kokkos::parallel_for("crossdesc_reduction", totalIterations, KOKKOS_LAMBDA(int idx) {
     int n = idx % Ni; // Ni
@@ -1389,9 +1389,9 @@ void PairPODKokkos<DeviceType>::crossdesc_reduction(t_pod_1d cb1, t_pod_1d cb2,
     int k2 = ind2(m); // dd2
     int m1 = n + Ni * k1; // d1
     int m2 = n + Ni * k2; // d2
-    double c = c12(n + Ni * m);            
-    Kokkos::atomic_add(&cb1(m1), c * d2(m2)); 
-    Kokkos::atomic_add(&cb2(m2), c * d1(m1)); 
+    double c = c12(n + Ni * m);
+    Kokkos::atomic_add(&cb1(m1), c * d2(m2));
+    Kokkos::atomic_add(&cb2(m2), c * d1(m1));
   });
 }
 
@@ -1400,123 +1400,123 @@ void PairPODKokkos<DeviceType>::set_array_to_zero(t_pod_1d a, int N)
 {
   Kokkos::parallel_for("initialize_array", N, KOKKOS_LAMBDA(int i) {
     a(i) = 0.0;
-  });  
+  });
 }
 
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::blockatom_base_descriptors(t_pod_1d bd, int Ni, int Nij)
-{  
-  auto begin = std::chrono::high_resolution_clock::now();           
-  auto end = std::chrono::high_resolution_clock::now();       
-     
+{
+  auto begin = std::chrono::high_resolution_clock::now();
+  auto end = std::chrono::high_resolution_clock::now();
+
   auto d2 = Kokkos::subview(bd, std::make_pair(0, Ni * nl2));
   auto d3 = Kokkos::subview(bd, std::make_pair(Ni * nl2, Ni * (nl2 + nl3)));
   auto d4 = Kokkos::subview(bd, std::make_pair(Ni * (nl2 + nl3), Ni * (nl2 + nl3 + nl4)));
   auto d33 = Kokkos::subview(bd, std::make_pair(Ni * (nl2 + nl3 + nl4), Ni * (nl2 + nl3 + nl4 + nl33)));
   auto d34 = Kokkos::subview(bd, std::make_pair(Ni * (nl2 + nl3 + nl4 + nl33), Ni * (nl2 + nl3 + nl4 + nl33 + nl34)));
   auto d44 = Kokkos::subview(bd, std::make_pair(Ni * (nl2 + nl3 + nl4 + nl33 + nl34), Ni * (nl2 + nl3 + nl4 + nl33 + nl34 + nl44)));
-  
-  begin = std::chrono::high_resolution_clock::now();           
-  radialbasis(abf, abfx, abfy, abfz, rij, besselparams, rin, rmax, 
+
+  begin = std::chrono::high_resolution_clock::now();
+  radialbasis(abf, abfx, abfy, abfz, rij, besselparams, rin, rmax,
         besseldegree, inversedegree, nbesselpars, ns, Nij);
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[10] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;              
-  
-  begin = std::chrono::high_resolution_clock::now();             
-  matrixMultiply(abf,  Phi, rbf, Nij, ns,  nrbfmax); 
-  matrixMultiply(abfx, Phi, rbfx, Nij, ns,  nrbfmax); 
-  matrixMultiply(abfy, Phi, rbfy, Nij, ns,  nrbfmax); 
+  end = std::chrono::high_resolution_clock::now();
+  comptime[10] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+  begin = std::chrono::high_resolution_clock::now();
+  matrixMultiply(abf,  Phi, rbf, Nij, ns,  nrbfmax);
+  matrixMultiply(abfx, Phi, rbfx, Nij, ns,  nrbfmax);
+  matrixMultiply(abfy, Phi, rbfy, Nij, ns,  nrbfmax);
   matrixMultiply(abfz, Phi, rbfz, Nij, ns,  nrbfmax);
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[11] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                          
+  end = std::chrono::high_resolution_clock::now();
+  comptime[11] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
 
-  begin = std::chrono::high_resolution_clock::now();       
+  begin = std::chrono::high_resolution_clock::now();
   set_array_to_zero(d2, Ni*nl2);
-  twobodydesc(d2, rbf, idxi, tj, nrbf2, Ni, Nij);    
+  twobodydesc(d2, rbf, idxi, tj, nrbf2, Ni, Nij);
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[12] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                  
-  
-  if ((nl3 > 0) && (Nij>1)) {      
-    begin = std::chrono::high_resolution_clock::now();   
+  end = std::chrono::high_resolution_clock::now();
+  comptime[12] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+  if ((nl3 > 0) && (Nij>1)) {
+    begin = std::chrono::high_resolution_clock::now();
     angularbasis(abf, abfx, abfy, abfz, rij, pq3, K3, Nij);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();       
-    comptime[13] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                  
+    end = std::chrono::high_resolution_clock::now();
+    comptime[13] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
 
-    begin = std::chrono::high_resolution_clock::now();  
-    set_array_to_zero(sumU, nelements * nrbf3 * K3 * Ni);    
+    begin = std::chrono::high_resolution_clock::now();
+    set_array_to_zero(sumU, nelements * nrbf3 * K3 * Ni);
     radialangularsum(sumU, rbf, abf, tj, numij, nelements, nrbf3, K3, Ni, Nij);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[14] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                  
+    end = std::chrono::high_resolution_clock::now();
+    comptime[14] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
 
-    begin = std::chrono::high_resolution_clock::now();   
+    begin = std::chrono::high_resolution_clock::now();
     //set_array_to_zero(d3, Ni*nl3);
     threebodydesc(d3, sumU, pc3, pn3, nelements, nrbf3, nabf3, K3, Ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();       
-    comptime[15] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                  
+    end = std::chrono::high_resolution_clock::now();
+    comptime[15] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
   }
-  
+
   if ((nl4 > 0) && (Nij>2)) {
-    begin = std::chrono::high_resolution_clock::now();   
-    //set_array_to_zero(d4, Ni*nl4);           
+    begin = std::chrono::high_resolution_clock::now();
+    //set_array_to_zero(d4, Ni*nl4);
     fourbodydesc(d4, sumU, pa4, pb4, pc4, nelements, nrbf3, nrbf4, nabf4, K3, Q4, Ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[16] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                           
+    end = std::chrono::high_resolution_clock::now();
+    comptime[16] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
   }
-  
+
   if ((nl33>0) && (Nij>3)) {
-    begin = std::chrono::high_resolution_clock::now();   
+    begin = std::chrono::high_resolution_clock::now();
     crossdesc(d33, d3, d3, ind33l, ind33r, nl33, Ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[17] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-  }  
-  
+    end = std::chrono::high_resolution_clock::now();
+    comptime[17] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+  }
+
   if ((nl34>0) && (Nij>4)) {
-    begin = std::chrono::high_resolution_clock::now();   
+    begin = std::chrono::high_resolution_clock::now();
     crossdesc(d34, d3, d4, ind34l, ind34r, nl34, Ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[18] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                                
+    end = std::chrono::high_resolution_clock::now();
+    comptime[18] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
   }
 
   if ((nl44>0) && (Nij>5)) {
-    begin = std::chrono::high_resolution_clock::now();   
+    begin = std::chrono::high_resolution_clock::now();
     crossdesc(d44, d4, d4, ind44l, ind44r, nl44, Ni);
     Kokkos::fence();
-    end = std::chrono::high_resolution_clock::now();   
-    comptime[19] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-  }    
+    end = std::chrono::high_resolution_clock::now();
+    comptime[19] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+  }
 }
 
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::blockatom_base_coefficients(t_pod_1d ei, t_pod_1d cb, t_pod_1d B, int Ni)
-{  
-  auto cefs = coefficients;  
-  auto tyai = typeai;    
+{
+  auto cefs = coefficients;
+  auto tyai = typeai;
   int nDes = Mdesc;
   int nCoeff = nCoeffPerElement;
-     
-  Kokkos::parallel_for("atomic_energies", Ni, KOKKOS_LAMBDA(int n) {    
+
+  Kokkos::parallel_for("atomic_energies", Ni, KOKKOS_LAMBDA(int n) {
     int nc = nCoeff*(tyai[n]-1);
     ei[n] = cefs[0 + nc];
-    for (int m=0; m<nDes; m++)     
+    for (int m=0; m<nDes; m++)
       ei[n] += cefs[1 + m + nc]*B[n + Ni*m];
-  });    
-  
+  });
+
   int totalIterations = Ni*nDes;
-  Kokkos::parallel_for("base_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {    
+  Kokkos::parallel_for("base_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {
     int n = idx % Ni;
     int m = idx / Ni;
-    int nc = nCoeff*(tyai[n]-1);                
-    cb[n + Ni*m] = cefs[1 + m + nc];      
-  });                    
+    int nc = nCoeff*(tyai[n]-1);
+    cb[n + Ni*m] = cefs[1 + m + nc];
+  });
 }
 
 template<class DeviceType>
@@ -1527,35 +1527,35 @@ void PairPODKokkos<DeviceType>::blockatom_environment_descriptors(t_pod_1d ei, t
   auto D = Kokkos::subview(pd, std::make_pair(2 * Ni * nClusters, 3 * Ni * nClusters));
   auto pca = Kokkos::subview(pd, std::make_pair(3 * Ni * nClusters, 3 * Ni * nClusters + Ni * nComponents));
   auto sumD = Kokkos::subview(pd, std::make_pair(3 * Ni * nClusters + Ni * nComponents, 3 * Ni * nClusters + Ni * nComponents + Ni));
-   
+
   auto proj = Proj;
   auto cent = Centroids;
-  auto cefs = coefficients;  
-  auto tyai = typeai;  
-  
+  auto cefs = coefficients;
+  auto tyai = typeai;
+
   int nCom = nComponents;
   int nCls = nClusters;
   int nDes = Mdesc;
   int nCoeff = nCoeffPerElement;
-  
+
   int totalIterations = Ni*nCom;
-  Kokkos::parallel_for("pca", totalIterations, KOKKOS_LAMBDA(int idx) {  
+  Kokkos::parallel_for("pca", totalIterations, KOKKOS_LAMBDA(int idx) {
     int i = idx % Ni;
-    int k = idx / Ni;         
+    int k = idx / Ni;
     double sum = 0.0;
     int typei = tyai[i]-1;
     for (int m = 0; m < nDes; m++) {
       sum += proj[k + nCom*m + nCom*nDes*typei] * B[i + Ni*m];
     }
-    pca[i + Ni*k] = sum;    
+    pca[i + Ni*k] = sum;
   });
-  
+
   totalIterations = Ni*nCls;
-  Kokkos::parallel_for("inverse_square_distances", totalIterations, KOKKOS_LAMBDA(int idx) {    
+  Kokkos::parallel_for("inverse_square_distances", totalIterations, KOKKOS_LAMBDA(int idx) {
     int i = idx % Ni;
-    int j = idx / Ni;         
+    int j = idx / Ni;
     int typei = tyai[i]-1;
-    double sum = 1e-20; 
+    double sum = 1e-20;
     for (int k = 0; k < nCom; k++) {
       double c = cent[k + j * nCom + nCls*nCom*typei];
       double p = pca[i + Ni*k];
@@ -1563,49 +1563,49 @@ void PairPODKokkos<DeviceType>::blockatom_environment_descriptors(t_pod_1d ei, t
     }
     D[i + Ni*j] = 1.0 / sum;
   });
-  
-  Kokkos::parallel_for("Probabilities", Ni, KOKKOS_LAMBDA(int i) {    
-    double sum = 0; 
-    for (int j = 0; j < nCls; j++) sum += D[i + Ni*j];    
+
+  Kokkos::parallel_for("Probabilities", Ni, KOKKOS_LAMBDA(int i) {
+    double sum = 0;
+    for (int j = 0; j < nCls; j++) sum += D[i + Ni*j];
     sumD[i] = sum;
-    for (int j = 0; j < nCls; j++) P[i + Ni*j] = D[i + Ni*j]/sum;    
+    for (int j = 0; j < nCls; j++) P[i + Ni*j] = D[i + Ni*j]/sum;
   });
-  
-  Kokkos::parallel_for("atomic_energies", Ni, KOKKOS_LAMBDA(int n) {    
+
+  Kokkos::parallel_for("atomic_energies", Ni, KOKKOS_LAMBDA(int n) {
     int nc = nCoeff*(tyai[n]-1);
     ei[n] = cefs[0 + nc];
     for (int k = 0; k<nCls; k++)
-      for (int m=0; m<nDes; m++)     
+      for (int m=0; m<nDes; m++)
         ei[n] += cefs[1 + m + nDes*k + nc]*B[n + Ni*m]*P[n + Ni*k];
-  });    
-  
-  Kokkos::parallel_for("env_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {    
+  });
+
+  Kokkos::parallel_for("env_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {
     int n = idx % Ni;
     int k = idx / Ni;
-    int nc = nCoeff*(tyai[n]-1);            
+    int nc = nCoeff*(tyai[n]-1);
     double sum = 0;
-    for (int m = 0; m<nDes; m++)     
+    for (int m = 0; m<nDes; m++)
       sum += cefs[1 + m + k*nDes + nc]*B[n + Ni*m];
     cp[n + Ni*k] = sum;
-  });            
+  });
 
   totalIterations = Ni*nDes;
-  Kokkos::parallel_for("base_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {    
+  Kokkos::parallel_for("base_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {
     int n = idx % Ni;
     int m = idx / Ni;
-    int nc = nCoeff*(tyai[n]-1);            
-    double sum = 0.0;    
-    for (int k = 0; k<nCls; k++)    
-      sum += cefs[1 + m + k*nDes + nc]*P[n + Ni*k];      
+    int nc = nCoeff*(tyai[n]-1);
+    double sum = 0.0;
+    for (int k = 0; k<nCls; k++)
+      sum += cefs[1 + m + k*nDes + nc]*P[n + Ni*k];
     cb[n + Ni*m] = sum;
-  });              
-  
-  Kokkos::parallel_for("base_env_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {    
+  });
+
+  Kokkos::parallel_for("base_env_coefficients", totalIterations, KOKKOS_LAMBDA(int idx) {
     int i = idx % Ni;
     int m = idx / Ni;
     int typei = tyai[i]-1;
     double S1 = 1/sumD[i];
-    double S2 = sumD[i]*sumD[i];   
+    double S2 = sumD[i]*sumD[i];
     double sum = 0.0;
     for (int j=0; j<nCls; j++) {
       double dP_dB = 0.0;
@@ -1615,96 +1615,96 @@ void PairPODKokkos<DeviceType>::blockatom_environment_descriptors(t_pod_1d ei, t
         double dD_dB = 0.0;
         double D2 = 2 * D[i + Ni*k] * D[i + Ni*k];
         for (int n = 0; n < nCom; n++) {
-          double dD_dpca = D2 * (cent[n + k * nCom + nCls*nCom*typei] - pca[i + Ni*n]);        
+          double dD_dpca = D2 * (cent[n + k * nCom + nCls*nCom*typei] - pca[i + Ni*n]);
           dD_dB += dD_dpca * proj[n + m * nCom + nCom*nDes*typei];
-        }                
+        }
         dP_dB += dP_dD * dD_dB;
-      }      
-      sum += cp[i + Ni*j]*dP_dB;      
+      }
+      sum += cp[i + Ni*j]*dP_dB;
     }
     cb[i + Ni*m] += sum;
-  });  
+  });
 }
 
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::blockatom_energyforce(t_pod_1d l_ei, t_pod_1d l_fij, int Ni, int Nij)
-{  
-  auto begin = std::chrono::high_resolution_clock::now();           
-  auto end = std::chrono::high_resolution_clock::now();       
-  
+{
+  auto begin = std::chrono::high_resolution_clock::now();
+  auto end = std::chrono::high_resolution_clock::now();
+
   // calculate base descriptors and their derivatives with respect to atom coordinates
-  begin = std::chrono::high_resolution_clock::now();  
-  blockatom_base_descriptors(bd, Ni, Nij);  
+  begin = std::chrono::high_resolution_clock::now();
+  blockatom_base_descriptors(bd, Ni, Nij);
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[4] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-  
-  begin = std::chrono::high_resolution_clock::now();    
-  if (nClusters > 1) {    
+  end = std::chrono::high_resolution_clock::now();
+  comptime[4] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+  begin = std::chrono::high_resolution_clock::now();
+  if (nClusters > 1) {
     blockatom_environment_descriptors(l_ei, cb, bd, Ni);
   }
   else {
     blockatom_base_coefficients(l_ei, cb, bd, Ni);
-  }      
+  }
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[5] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-  
-  begin = std::chrono::high_resolution_clock::now();    
+  end = std::chrono::high_resolution_clock::now();
+  comptime[5] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+  begin = std::chrono::high_resolution_clock::now();
   auto d3 = Kokkos::subview(bd, std::make_pair(Ni * nl2, Ni * (nl2 + nl3)));
-  auto d4 = Kokkos::subview(bd, std::make_pair(Ni * (nl2 + nl3), Ni * (nl2 + nl3 + nl4)));  
+  auto d4 = Kokkos::subview(bd, std::make_pair(Ni * (nl2 + nl3), Ni * (nl2 + nl3 + nl4)));
   auto cb2 = Kokkos::subview(cb, std::make_pair(0, Ni * nl2));
   auto cb3 = Kokkos::subview(cb, std::make_pair(Ni * nl2, Ni * (nl2 + nl3)));
   auto cb4 = Kokkos::subview(cb, std::make_pair(Ni * (nl2 + nl3), Ni * (nl2 + nl3 + nl4)));
   auto cb33 = Kokkos::subview(cb, std::make_pair(Ni * (nl2 + nl3 + nl4), Ni * (nl2 + nl3 + nl4 + nl33)));
   auto cb34 = Kokkos::subview(cb, std::make_pair(Ni * (nl2 + nl3 + nl4 + nl33), Ni * (nl2 + nl3 + nl4 + nl33 + nl34)));
   auto cb44 = Kokkos::subview(cb, std::make_pair(Ni * (nl2 + nl3 + nl4 + nl33 + nl34), Ni * (nl2 + nl3 + nl4 + nl33 + nl34 + nl44)));
-   
+
   if ((nl33>0) && (Nij>3)) {
-    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33, Ni);      
+    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33, Ni);
   }
   if ((nl34>0) && (Nij>4)) {
-    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34, Ni);      
-  }  
+    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34, Ni);
+  }
   if ((nl44>0) && (Nij>5)) {
-    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44, Ni);        
-  }     
+    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44, Ni);
+  }
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[6] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-    
-  begin = std::chrono::high_resolution_clock::now();    
-  set_array_to_zero(l_fij, 3*Nij);    
-  if ((nl2 > 0) && (Nij>0)) twobody_forces(l_fij, cb2, rbfx, rbfy, rbfz, idxi, tj, nrbf2, Ni, Nij);    
+  end = std::chrono::high_resolution_clock::now();
+  comptime[6] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+  begin = std::chrono::high_resolution_clock::now();
+  set_array_to_zero(l_fij, 3*Nij);
+  if ((nl2 > 0) && (Nij>0)) twobody_forces(l_fij, cb2, rbfx, rbfy, rbfz, idxi, tj, nrbf2, Ni, Nij);
   Kokkos::fence();
-  end = std::chrono::high_resolution_clock::now();   
-  comptime[7] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-  
-  set_array_to_zero(forcecoeff, nelements * nrbf3 * K3 * Ni);   
-  if ((nl3 > 0) && (Nij>1)) threebody_forcecoeff(forcecoeff, cb3, sumU, 
+  end = std::chrono::high_resolution_clock::now();
+  comptime[7] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+
+  set_array_to_zero(forcecoeff, nelements * nrbf3 * K3 * Ni);
+  if ((nl3 > 0) && (Nij>1)) threebody_forcecoeff(forcecoeff, cb3, sumU,
           pc3, pn3, elemindex, nelements, nrbf3, nabf3, K3, Ni);
-  if ((nl4 > 0) && (Nij>2)) fourbody_forcecoeff(forcecoeff, cb4, sumU, 
-      pa4, pb4, pc4, nelements, nrbf3, nrbf4, nabf4, K3, Q4, Ni);        
-  if ((nl3 > 0) && (Nij>1)) allbody_forces(l_fij, forcecoeff, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz, 
+  if ((nl4 > 0) && (Nij>2)) fourbody_forcecoeff(forcecoeff, cb4, sumU,
+      pa4, pb4, pc4, nelements, nrbf3, nrbf4, nabf4, K3, Q4, Ni);
+  if ((nl3 > 0) && (Nij>1)) allbody_forces(l_fij, forcecoeff, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz,
           idxi, tj, nelements, nrbf3, nabf3, K3, Nij);
-    
-//   begin = std::chrono::high_resolution_clock::now();    
-//   if ((nl3 > 0) && (Nij>1)) threebody_forces(l_fij, cb3, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz, sumU, 
+
+//   begin = std::chrono::high_resolution_clock::now();
+//   if ((nl3 > 0) && (Nij>1)) threebody_forces(l_fij, cb3, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz, sumU,
 //           idxi, tj, pc3, pn3, elemindex, nelements, nrbf3, nabf3, K3, Ni, Nij);
 //   Kokkos::fence();
-//   end = std::chrono::high_resolution_clock::now();   
-//   comptime[8] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                        
-//   
-//   begin = std::chrono::high_resolution_clock::now();    
-//   if ((nl4 > 0) && (Nij>2)) fourbody_forces(l_fij, cb4, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz, sumU, idxi, tj, 
-//       pa4, pb4, pc4, elemindex, nelements, nrbf3, nrbf4, nabf4, K3, Q4, Ni, Nij);        
+//   end = std::chrono::high_resolution_clock::now();
+//   comptime[8] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
+//
+//   begin = std::chrono::high_resolution_clock::now();
+//   if ((nl4 > 0) && (Nij>2)) fourbody_forces(l_fij, cb4, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz, sumU, idxi, tj,
+//       pa4, pb4, pc4, elemindex, nelements, nrbf3, nrbf4, nabf4, K3, Q4, Ni, Nij);
 //   Kokkos::fence();
-//   end = std::chrono::high_resolution_clock::now();   
-//   comptime[9] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;                          
+//   end = std::chrono::high_resolution_clock::now();
+//   comptime[9] += std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e6;
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::tallyforce(t_pod_1d l_fij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij) 
+void PairPODKokkos<DeviceType>::tallyforce(t_pod_1d l_fij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij)
 {
   auto l_f = f;
   Kokkos::parallel_for("TallyForce", Nij, KOKKOS_LAMBDA(int n) {
@@ -1724,7 +1724,7 @@ void PairPODKokkos<DeviceType>::tallyforce(t_pod_1d l_fij, t_pod_1i l_ai, t_pod_
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::tallyenergy(t_pod_1d l_ei, int istart, int Ni) 
+void PairPODKokkos<DeviceType>::tallyenergy(t_pod_1d l_ei, int istart, int Ni)
 {
   auto l_eatom = d_eatom;
 
@@ -1748,40 +1748,40 @@ void PairPODKokkos<DeviceType>::tallyenergy(t_pod_1d l_ei, int istart, int Ni)
 }
 
 template<class DeviceType>
-void PairPODKokkos<DeviceType>::tallystress(t_pod_1d l_fij, t_pod_1d l_rij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij) 
-{  
+void PairPODKokkos<DeviceType>::tallystress(t_pod_1d l_fij, t_pod_1d l_rij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij)
+{
   auto l_vatom = d_vatom;
 
   if (vflag_global) {
     for (int j=0; j<3; j++) {
-      F_FLOAT sum = 0.0;  
-      Kokkos::parallel_reduce("GlobalStressTally", Nij, KOKKOS_LAMBDA(int k, F_FLOAT& update) {          
+      F_FLOAT sum = 0.0;
+      Kokkos::parallel_reduce("GlobalStressTally", Nij, KOKKOS_LAMBDA(int k, F_FLOAT& update) {
         int k3 = 3*k;
         update += l_rij(j + k3) * l_fij(j + k3);
       }, sum);
-      virial[j] -= sum;    
+      virial[j] -= sum;
     }
 
-    F_FLOAT sum = 0.0;  
+    F_FLOAT sum = 0.0;
     Kokkos::parallel_reduce("GlobalStressTally", Nij, KOKKOS_LAMBDA(int k, F_FLOAT& update) {
       int k3 = 3*k;
       update += l_rij(k3) * l_fij(1 + k3);
     }, sum);
-    virial[3] -= sum;    
-    
-    sum = 0.0;  
+    virial[3] -= sum;
+
+    sum = 0.0;
     Kokkos::parallel_reduce("GlobalStressTally", Nij, KOKKOS_LAMBDA(int k, F_FLOAT& update) {
       int k3 = 3*k;
       update += l_rij(k3) * l_fij(2 + k3);
     }, sum);
-    virial[4] -= sum;    
-    
-    sum = 0.0;  
+    virial[4] -= sum;
+
+    sum = 0.0;
     Kokkos::parallel_reduce("GlobalStressTally", Nij, KOKKOS_LAMBDA(int k, F_FLOAT& update) {
       int k3 = 3*k;
       update += l_rij(1+k3) * l_fij(2+k3);
     }, sum);
-    virial[5] -= sum;    
+    virial[5] -= sum;
   }
 
   if (vflag_atom) {
@@ -1812,9 +1812,9 @@ void PairPODKokkos<DeviceType>::tallystress(t_pod_1d l_fij, t_pod_1d l_rij, t_po
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::savematrix2binfile(std::string filename, t_pod_1d d_A, int nrows, int ncols)
 {
-  auto A = Kokkos::create_mirror_view(d_A);  
-  Kokkos::deep_copy(A, d_A);          
-  
+  auto A = Kokkos::create_mirror_view(d_A);
+  Kokkos::deep_copy(A, d_A);
+
   FILE *fp = fopen(filename.c_str(), "wb");
   double sz[2];
   sz[0] = (double) nrows;
@@ -1827,9 +1827,9 @@ void PairPODKokkos<DeviceType>::savematrix2binfile(std::string filename, t_pod_1
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::saveintmatrix2binfile(std::string filename, t_pod_1i d_A, int nrows, int ncols)
 {
-  auto A = Kokkos::create_mirror_view(d_A);  
-  Kokkos::deep_copy(A, d_A);          
-  
+  auto A = Kokkos::create_mirror_view(d_A);
+  Kokkos::deep_copy(A, d_A);
+
   FILE *fp = fopen(filename.c_str(), "wb");
   int sz[2];
   sz[0] = nrows;
@@ -1842,28 +1842,28 @@ void PairPODKokkos<DeviceType>::saveintmatrix2binfile(std::string filename, t_po
 template<class DeviceType>
 void PairPODKokkos<DeviceType>::savedatafordebugging()
 {
-  saveintmatrix2binfile("podkktypeai.bin", typeai, ni, 1);  
-  saveintmatrix2binfile("podkknumij.bin", numij, ni+1, 1);  
-  saveintmatrix2binfile("podkkai.bin", ai, nij, 1);  
-  saveintmatrix2binfile("podkkaj.bin", aj, nij, 1);  
-  saveintmatrix2binfile("podkkti.bin", ti, nij, 1);  
-  saveintmatrix2binfile("podkktj.bin", tj, nij, 1);  
-  saveintmatrix2binfile("podkkidxi.bin", idxi, nij, 1);     
+  saveintmatrix2binfile("podkktypeai.bin", typeai, ni, 1);
+  saveintmatrix2binfile("podkknumij.bin", numij, ni+1, 1);
+  saveintmatrix2binfile("podkkai.bin", ai, nij, 1);
+  saveintmatrix2binfile("podkkaj.bin", aj, nij, 1);
+  saveintmatrix2binfile("podkkti.bin", ti, nij, 1);
+  saveintmatrix2binfile("podkktj.bin", tj, nij, 1);
+  saveintmatrix2binfile("podkkidxi.bin", idxi, nij, 1);
   savematrix2binfile("podkkrbf.bin", rbf, nrbfmax, nij);
   savematrix2binfile("podkkrbfx.bin", rbfx, nrbfmax, nij);
   savematrix2binfile("podkkrbfy.bin", rbfy, nrbfmax, nij);
-  savematrix2binfile("podkkrbfz.bin", rbfz, nrbfmax, nij);      
+  savematrix2binfile("podkkrbfz.bin", rbfz, nrbfmax, nij);
   int kmax = (K3 > ns) ? K3 : ns;
   savematrix2binfile("podkkabf.bin", abf,   kmax, nij);
   savematrix2binfile("podkkabfx.bin", abfx, kmax, nij);
   savematrix2binfile("podkkabfy.bin", abfy, kmax, nij);
-  savematrix2binfile("podkkabfz.bin", abfz, kmax, nij);            
-  savematrix2binfile("podkkbd.bin", bd, ni, Mdesc);      
-  savematrix2binfile("podkksumU.bin", sumU, nelements * K3 * nrbfmax, ni);      
+  savematrix2binfile("podkkabfz.bin", abfz, kmax, nij);
+  savematrix2binfile("podkkbd.bin", bd, ni, Mdesc);
+  savematrix2binfile("podkksumU.bin", sumU, nelements * K3 * nrbfmax, ni);
   savematrix2binfile("podkkrij.bin", rij, 3, nij);
   savematrix2binfile("podkkfij.bin", fij, 3, nij);
-  savematrix2binfile("podkkei.bin", ei, ni, 1);      
-  
+  savematrix2binfile("podkkei.bin", ei, ni, 1);
+
   error->all(FLERR, "Save data and stop the run for debugging");
 }
 
diff --git a/src/KOKKOS/pair_pod_kokkos.h b/src/KOKKOS/pair_pod_kokkos.h
index 41dc89cd30..ab6cd3f827 100644
--- a/src/KOKKOS/pair_pod_kokkos.h
+++ b/src/KOKKOS/pair_pod_kokkos.h
@@ -32,7 +32,7 @@ namespace LAMMPS_NS {
 
 template<class DeviceType>
 class PairPODKokkos : public PairPOD {
- public:   
+ public:
   typedef DeviceType device_type;
   typedef ArrayTypes<DeviceType> AT;
 
@@ -43,7 +43,7 @@ class PairPODKokkos : public PairPOD {
   void coeff(int, char **) override;
   void init_style() override;
   double init_one(int, int) override;
-  
+
  //protected:
   int inum, maxneigh;
   int host_flag;
@@ -53,7 +53,7 @@ class PairPODKokkos : public PairPOD {
 
   typename AT::t_neighbors_2d d_neighbors;
   typename AT::t_int_1d d_ilist;
-  typename AT::t_int_1d d_numneigh;  
+  typename AT::t_int_1d d_numneigh;
 //   typename AT::t_int_1d_randomread d_ilist;
 //   typename AT::t_int_1d_randomread d_numneigh;
 
@@ -74,34 +74,34 @@ class PairPODKokkos : public PairPOD {
 
   friend void pair_virial_fdotr_compute<PairPODKokkos>(PairPODKokkos*);
 
-  void grow(int, int);  
+  void grow(int, int);
   void copy_from_pod_class(EAPOD *podptr);
   void divideInterval(int *intervals, int N, int M);
-  int calculateNumberOfIntervals(int N, int intervalSize);     
+  int calculateNumberOfIntervals(int N, int intervalSize);
   void grow_atoms(int Ni);
   void grow_pairs(int Nij);
-   
+
   void allocate() override;
   double memory_usage() override;
 
-  typedef Kokkos::View<int*, DeviceType> t_pod_1i;  
+  typedef Kokkos::View<int*, DeviceType> t_pod_1i;
   typedef Kokkos::View<double*, DeviceType> t_pod_1d;
 //   typedef Kokkos::View<int**, DeviceType> t_pod_2i;
 //   typedef Kokkos::View<double**, DeviceType> t_pod_2d;
 //   typedef Kokkos::View<double**[3], DeviceType> t_pod_3d3;
-      
+
   int atomBlockSize;        // size of each atom block
   int nAtomBlocks;          // number of atoms blocks
   int atomBlocks[101];      // atom blocks
   double comptime[100];
   int timing;
-  
-  int ni;            // number of atoms i in the current atom block 
-  int nij;           // number of pairs (i,j) in the current atom block 
+
+  int ni;            // number of atoms i in the current atom block
+  int nij;           // number of pairs (i,j) in the current atom block
   int nimax;         // maximum number of atoms i
-  int nijmax;        // maximum number of pairs (i,j) 
-  
-  int nelements; // number of elements 
+  int nijmax;        // maximum number of pairs (i,j)
+
+  int nelements; // number of elements
   int onebody;   // one-body descriptors
   int besseldegree; // degree of Bessel functions
   int inversedegree; // degree of inverse functions
@@ -110,116 +110,116 @@ class PairPODKokkos : public PairPOD {
   int ns;      // number of snapshots for radial basis functions
   int nl1, nl2, nl3, nl4, nl23, nl33, nl34, nl44, nl;   // number of local descriptors
   int nrbf2, nrbf3, nrbf4, nrbfmax;            // number of radial basis functions
-  int nabf3, nabf4;                            // number of angular basis functions  
+  int nabf3, nabf4;                            // number of angular basis functions
   int K3, K4, Q4;                                  // number of monomials
-    
+
   // environmental variables
   int nClusters; // number of environment clusters
   int nComponents; // number of principal components
-  int Mdesc; // number of base descriptors 
+  int Mdesc; // number of base descriptors
 
   double rin;  // inner cut-off radius
   double rcut; // outer cut-off radius
-  double rmax; // rcut - rin  
+  double rmax; // rcut - rin
   double rcutsq;
-  
+
   t_pod_1d rij;         // (xj - xi) for all pairs (I, J)
   t_pod_1d fij;         // force for all pairs (I, J)
   t_pod_1d ei;          // energy for each atom I
   t_pod_1i typeai;         // types of atoms I only
-  t_pod_1i numij;          // number of pairs (I, J) for each atom I   
+  t_pod_1i numij;          // number of pairs (I, J) for each atom I
   t_pod_1i idxi;           // storing linear indices of atom I for all pairs (I, J)
   t_pod_1i ai;             // IDs of atoms I for all pairs (I, J)
   t_pod_1i aj;             // IDs of atoms J for all pairs (I, J)
   t_pod_1i ti;             // types of atoms I for all pairs (I, J)
-  t_pod_1i tj;             // types of atoms J for all pairs (I, J)  
+  t_pod_1i tj;             // types of atoms J for all pairs (I, J)
 
   t_pod_1d besselparams;
   t_pod_1d Phi;  // eigenvectors matrix ns x ns
-  t_pod_1d rbf;  // radial basis functions nij x nrbfmax  
-  t_pod_1d rbfx; // x-derivatives of radial basis functions nij x nrbfmax 
+  t_pod_1d rbf;  // radial basis functions nij x nrbfmax
+  t_pod_1d rbfx; // x-derivatives of radial basis functions nij x nrbfmax
   t_pod_1d rbfy; // y-derivatives of radial basis functions nij x nrbfmax
-  t_pod_1d rbfz; // z-derivatives of radial basis functions nij x nrbfmax   
+  t_pod_1d rbfz; // z-derivatives of radial basis functions nij x nrbfmax
   t_pod_1d abf;  // angular basis functions nij x K3
   t_pod_1d abfx; // x-derivatives of angular basis functions nij x K3
-  t_pod_1d abfy; // y-derivatives of angular basis functions nij x K3  
+  t_pod_1d abfy; // y-derivatives of angular basis functions nij x K3
   t_pod_1d abfz; // z-derivatives of angular basis functions nij x K3
   t_pod_1d sumU; // sum of radial basis functions ni x K3 x nrbfmax x nelements
   t_pod_1d forcecoeff; // force coefficients ni x K3 x nrbfmax x nelements
   t_pod_1d Proj; // PCA Projection matrix
-  t_pod_1d Centroids; // centroids of the clusters  
+  t_pod_1d Centroids; // centroids of the clusters
   t_pod_1d bd;   // base descriptors ni x Mdesc
   t_pod_1d cb;   // force coefficients for base descriptors ni x Mdesc
   t_pod_1d pd;   // environment probability descriptors ni x (1 + nComponents + 3*nClusters)
   t_pod_1d coefficients; // coefficients nCoeffPerElement x nelements
   t_pod_1i pq3, pn3, pc3; // arrays to compute 3-body angular basis functions
-  t_pod_1i pa4, pb4, pc4; // arrays to compute 4-body angular basis functions    
+  t_pod_1i pa4, pb4, pc4; // arrays to compute 4-body angular basis functions
   t_pod_1i ind33l, ind33r; // nl33
   t_pod_1i ind34l, ind34r; // nl34
   t_pod_1i ind44l, ind44r; // nl44
-  t_pod_1i elemindex;  
-  
+  t_pod_1i elemindex;
+
   void set_array_to_zero(t_pod_1d a, int N);
-  
+
   int NeighborCount(t_pod_1i, double, int, int);
-    
-  void NeighborList(t_pod_1d l_rij, t_pod_1i l_numij,  t_pod_1i l_typeai, t_pod_1i l_idxi, 
+
+  void NeighborList(t_pod_1d l_rij, t_pod_1i l_numij,  t_pod_1i l_typeai, t_pod_1i l_idxi,
     t_pod_1i l_ai, t_pod_1i l_aj, t_pod_1i l_ti, t_pod_1i l_tj, double l_rcutsq, int gi1, int Ni);
-   
-  void radialbasis(t_pod_1d rbft, t_pod_1d rbftx, t_pod_1d rbfty, t_pod_1d rbftz, 
-    t_pod_1d rij, t_pod_1d l_besselparams, double l_rin, double l_rmax, int l_besseldegree, 
-    int l_inversedegree, int l_nbesselpars, int l_ns,  int Nij); 
-      
-  void matrixMultiply(t_pod_1d a, t_pod_1d b, t_pod_1d c, int r1, int c1, int c2); 
-  
+
+  void radialbasis(t_pod_1d rbft, t_pod_1d rbftx, t_pod_1d rbfty, t_pod_1d rbftz,
+    t_pod_1d rij, t_pod_1d l_besselparams, double l_rin, double l_rmax, int l_besseldegree,
+    int l_inversedegree, int l_nbesselpars, int l_ns,  int Nij);
+
+  void matrixMultiply(t_pod_1d a, t_pod_1d b, t_pod_1d c, int r1, int c1, int c2);
+
   void angularbasis(t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
-        t_pod_1d l_rij, t_pod_1i l_pq3, int l_K3, int N);  
-   
-  void radialangularsum(t_pod_1d l_sumU, t_pod_1d l_rbf, t_pod_1d l_abf, t_pod_1i l_tj, 
+        t_pod_1d l_rij, t_pod_1i l_pq3, int l_K3, int N);
+
+  void radialangularsum(t_pod_1d l_sumU, t_pod_1d l_rbf, t_pod_1d l_abf, t_pod_1i l_tj,
     t_pod_1i l_numij, const int l_nelements, const int l_nrbf3, const int l_K3, const int Ni, const int Nij);
 
-  void twobodydesc(t_pod_1d d2, t_pod_1d l_rbf, t_pod_1i l_idxi, t_pod_1i l_tj, int l_nrbf2, const int Ni, const int Nij); 
-    
-  void threebodydesc(t_pod_1d d3, t_pod_1d l_sumU, t_pod_1i l_pc3, t_pod_1i l_pn3, 
+  void twobodydesc(t_pod_1d d2, t_pod_1d l_rbf, t_pod_1i l_idxi, t_pod_1i l_tj, int l_nrbf2, const int Ni, const int Nij);
+
+  void threebodydesc(t_pod_1d d3, t_pod_1d l_sumU, t_pod_1i l_pc3, t_pod_1i l_pn3,
         int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, const int Ni);
-  
-  void fourbodydesc(t_pod_1d d4,  t_pod_1d l_sumU, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, 
+
+  void fourbodydesc(t_pod_1d d4,  t_pod_1d l_sumU, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4,
       int l_nelements, int l_nrbf3, int l_nrbf4, int l_nabf4, int l_K3, int l_Q4, int Ni);
-     
+
   void crossdesc(t_pod_1d d12, t_pod_1d d1, t_pod_1d d2, t_pod_1i ind1, t_pod_1i ind2, int n12, int Ni);
-   
-  void crossdesc_reduction(t_pod_1d cb1, t_pod_1d cb2, t_pod_1d c12, t_pod_1d d1, 
-        t_pod_1d d2, t_pod_1i ind1, t_pod_1i ind2, int n12, int Ni);  
+
+  void crossdesc_reduction(t_pod_1d cb1, t_pod_1d cb2, t_pod_1d c12, t_pod_1d d1,
+        t_pod_1d d2, t_pod_1i ind1, t_pod_1i ind2, int n12, int Ni);
   void blockatom_base_descriptors(t_pod_1d bd, int Ni, int Nij);
   void blockatom_base_coefficients(t_pod_1d ei, t_pod_1d cb, t_pod_1d B, int Ni);
-  void blockatom_environment_descriptors(t_pod_1d ei, t_pod_1d cb, t_pod_1d B, int Ni);  
-  
-  void twobody_forces(t_pod_1d fij, t_pod_1d cb2, t_pod_1d l_rbfx, t_pod_1d l_rbfy, t_pod_1d l_rbfz, 
+  void blockatom_environment_descriptors(t_pod_1d ei, t_pod_1d cb, t_pod_1d B, int Ni);
+
+  void twobody_forces(t_pod_1d fij, t_pod_1d cb2, t_pod_1d l_rbfx, t_pod_1d l_rbfy, t_pod_1d l_rbfz,
           t_pod_1i l_idxi, t_pod_1i l_tj, int l_nrbf2, const int Ni, const int Nij);
-  void threebody_forces(t_pod_1d fij, t_pod_1d cb3, t_pod_1d l_rbf, t_pod_1d l_rbfx, 
-    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, 
-    t_pod_1d l_sumU, t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pc3, t_pod_1i l_pn3, t_pod_1i l_elemindex, 
+  void threebody_forces(t_pod_1d fij, t_pod_1d cb3, t_pod_1d l_rbf, t_pod_1d l_rbfx,
+    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
+    t_pod_1d l_sumU, t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pc3, t_pod_1i l_pn3, t_pod_1i l_elemindex,
     int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, int Ni, int Nij);
-  void fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_pod_1d l_rbf, t_pod_1d l_rbfx, t_pod_1d l_rbfy, 
-    t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, t_pod_1d l_sumU, 
-    t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, t_pod_1i l_elemindex, 
+  void fourbody_forces(t_pod_1d fij, t_pod_1d cb4, t_pod_1d l_rbf, t_pod_1d l_rbfx, t_pod_1d l_rbfy,
+    t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, t_pod_1d l_sumU,
+    t_pod_1i l_idxi, t_pod_1i l_tj, t_pod_1i l_pa4, t_pod_1i l_pb4, t_pod_1i l_pc4, t_pod_1i l_elemindex,
     int l_nelements, int l_nrbf3, int l_nrbf4, int l_nabf4, int l_K3, int l_Q4, int Ni, int Nij);
-  
-  void threebody_forcecoeff(t_pod_1d fb3, t_pod_1d cb3, t_pod_1d l_sumU, t_pod_1i l_pc3, 
+
+  void threebody_forcecoeff(t_pod_1d fb3, t_pod_1d cb3, t_pod_1d l_sumU, t_pod_1i l_pc3,
     t_pod_1i l_pn3, t_pod_1i l_elemindex, int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, int Ni);
-  
-  void fourbody_forcecoeff(t_pod_1d fb4, t_pod_1d cb4, t_pod_1d l_sumU, t_pod_1i l_pa4, 
+
+  void fourbody_forcecoeff(t_pod_1d fb4, t_pod_1d cb4, t_pod_1d l_sumU, t_pod_1i l_pa4,
     t_pod_1i l_pb4, t_pod_1i l_pc4, int l_nelements, int l_nrbf3, int l_nrbf4, int l_nabf4, int l_K3, int l_Q4, int Ni);
 
-  void allbody_forces(t_pod_1d fij, t_pod_1d l_forcecoeff, t_pod_1d l_rbf, t_pod_1d l_rbfx, 
-    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz, 
+  void allbody_forces(t_pod_1d fij, t_pod_1d l_forcecoeff, t_pod_1d l_rbf, t_pod_1d l_rbfx,
+    t_pod_1d l_rbfy, t_pod_1d l_rbfz, t_pod_1d l_abf, t_pod_1d l_abfx, t_pod_1d l_abfy, t_pod_1d l_abfz,
     t_pod_1i l_idxi, t_pod_1i l_tj, int l_nelements, int l_nrbf3, int l_nabf3, int l_K3, int Nij);
-  
+
   void blockatom_energyforce(t_pod_1d l_ei, t_pod_1d l_fij, int Ni, int Nij);
   void tallyenergy(t_pod_1d l_ei, int istart, int Ni);
-  void tallyforce(t_pod_1d l_fij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij); 
-  void tallystress(t_pod_1d l_fij, t_pod_1d l_rij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij); 
-    
+  void tallyforce(t_pod_1d l_fij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij);
+  void tallystress(t_pod_1d l_fij, t_pod_1d l_rij, t_pod_1i l_ai, t_pod_1i l_aj, int Nij);
+
   void savematrix2binfile(std::string filename, t_pod_1d d_A, int nrows, int ncols);
   void saveintmatrix2binfile(std::string filename, t_pod_1i d_A, int nrows, int ncols);
   void savedatafordebugging();
diff --git a/src/ML-POD/compute_pod_atom.cpp b/src/ML-POD/compute_pod_atom.cpp
index 3a2ef12b9a..29a6dc060a 100644
--- a/src/ML-POD/compute_pod_atom.cpp
+++ b/src/ML-POD/compute_pod_atom.cpp
@@ -34,33 +34,33 @@ enum{SCALAR,VECTOR,ARRAY};
 
 ComputePODAtom::ComputePODAtom(LAMMPS *lmp, int narg, char **arg) :
   Compute(lmp, narg, arg), list(nullptr), map(nullptr), pod(nullptr), elements(nullptr)
-{  
+{
 
   int nargmin = 7;
 
   if (narg < nargmin) error->all(FLERR, "Illegal compute {} command", style);
   if (comm->nprocs > 1) error->all(FLERR, "compute command does not support multi processors");
-  
+
   std::string pod_file = std::string(arg[3]);      // pod input file
   std::string coeff_file = "";    // coefficient input file
   std::string proj_file = std::string(arg[4]);    // coefficient input file
-  std::string centroid_file = std::string(arg[5]);    // coefficient input file              
-  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);   
-  
+  std::string centroid_file = std::string(arg[5]);    // coefficient input file
+  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);
+
   int ntypes = atom->ntypes;
   memory->create(map, ntypes + 1, "compute_pod_global:map");
-  map_element2type(narg - 6, arg + 6, podptr->nelements);    
-      
-  //size_array_rows = 1 + 3*atom->natoms;  
+  map_element2type(narg - 6, arg + 6, podptr->nelements);
+
+  //size_array_rows = 1 + 3*atom->natoms;
   //size_array_cols = podptr->nCoeffAll;
-  
+
   cutmax = podptr->rcut;
 
-  nmax = 0;  
+  nmax = 0;
   nijmax = 0;
   pod = nullptr;
-  elements = nullptr;  
-  
+  elements = nullptr;
+
   size_peratom_cols = podptr->Mdesc * podptr->nClusters;
   peratom_flag = 1;
 }
@@ -120,23 +120,23 @@ void ComputePODAtom::compute_peratom()
     for (int icoeff = 0; icoeff < size_peratom_cols; icoeff++) {
       pod[i][icoeff] = 0.0;
     }
-  
+
   // invoke full neighbor list (will copy or build if necessary)
 
   neighbor->build_one(list);
-  
+
   double **x = atom->x;
   int **firstneigh = list->firstneigh;
   int *numneigh = list->numneigh;
   int *type = atom->type;
   int *ilist = list->ilist;
-  int inum = list->inum;      
+  int inum = list->inum;
   int nClusters = podptr->nClusters;
   int Mdesc = podptr->Mdesc;
   double rcutsq = podptr->rcut*podptr->rcut;
-  
+
   for (int ii = 0; ii < inum; ii++) {
-    int i = ilist[ii];    
+    int i = ilist[ii];
     int jnum = numneigh[i];
 
     // allocate temporary memory
@@ -145,32 +145,32 @@ void ComputePODAtom::compute_peratom()
       podptr->free_temp_memory();
       podptr->allocate_temp_memory(nijmax);
     }
-    
-    rij = &podptr->tmpmem[0];    
-    tmpmem = &podptr->tmpmem[3*nijmax]; 
-    ai = &podptr->tmpint[0];      
-    aj = &podptr->tmpint[nijmax]; 
+
+    rij = &podptr->tmpmem[0];
+    tmpmem = &podptr->tmpmem[3*nijmax];
+    ai = &podptr->tmpint[0];
+    aj = &podptr->tmpint[nijmax];
     ti = &podptr->tmpint[2*nijmax];
     tj = &podptr->tmpint[3*nijmax];
 
     // get neighbor list for atom i
     lammpsNeighborList(x, firstneigh, atom->tag, type, numneigh, rcutsq, i);
-    
+
     if (nij > 0) {
       // peratom base descriptors
       double *bd = &podptr->bd[0];
       double *bdd = &podptr->bdd[0];
-      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);        
+      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);
 
       if (nClusters>1) {
         // peratom env descriptors
         double *pd = &podptr->pd[0];
         double *pdd = &podptr->pdd[0];
-        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);    
+        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);
         for (int k = 0; k < nClusters; k++)
           for (int m = 0; m < Mdesc; m++) {
             int mk = m + Mdesc*k;
-            pod[i][mk] = pd[k]*bd[m];     
+            pod[i][mk] = pd[k]*bd[m];
           //   for (int n=0; n<nij; n++) {
           //     int ain = 3*ai[n];
           //     int ajn = 3*aj[n];
@@ -182,7 +182,7 @@ void ComputePODAtom::compute_peratom()
           //     pod[1 + ajn][imk] -= bdd[0 + nm]*pd[k] + bd[m]*pdd[0+nk];
           //     pod[2 + ajn][imk] -= bdd[1 + nm]*pd[k] + bd[m]*pdd[1+nk];
           //     pod[3 + ajn][imk] -= bdd[2 + nm]*pd[k] + bd[m]*pdd[2+nk];
-          //   }                  
+          //   }
           }
       }
       else {
@@ -198,11 +198,11 @@ void ComputePODAtom::compute_peratom()
         //     pod[1 + ajn][im] -= bdd[0 + nm];
         //     pod[2 + ajn][im] -= bdd[1 + nm];
         //     pod[3 + ajn][im] -= bdd[2 + nm];
-        //   }       
+        //   }
         }
-      }    
+      }
     }
-  }  
+  }
 }
 
 /* ----------------------------------------------------------------------
@@ -217,7 +217,7 @@ double ComputePODAtom::memory_usage()
 }
 
 
-void ComputePODAtom::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes, 
+void ComputePODAtom::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes,
                                int *numneigh, double rcutsq, int gi)
 {
   nij = 0;
diff --git a/src/ML-POD/compute_pod_atom.h b/src/ML-POD/compute_pod_atom.h
index 0dcd46cbba..d5e3149345 100644
--- a/src/ML-POD/compute_pod_atom.h
+++ b/src/ML-POD/compute_pod_atom.h
@@ -35,7 +35,7 @@ class ComputePODAtom : public Compute {
   void lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtype, int *numneigh,
                         double rcutsq, int i);
   void map_element2type(int narg, char **arg, int nelements);
-  
+
  private:
   class NeighList *list;
   class EAPOD *podptr;
@@ -46,16 +46,16 @@ class ComputePODAtom : public Compute {
   int nijmax;
 
   double *tmpmem;      // temporary memory
-  double *rij;         // (xj - xi) for all pairs (I, J)  
+  double *rij;         // (xj - xi) for all pairs (I, J)
   char **elements;
   int *map;
   int *ai;             // IDs of atoms I for all pairs (I, J)
   int *aj;             // IDs of atoms J for all pairs (I, J)
   int *ti;             // types of atoms I for all pairs (I, J)
-  int *tj;             // types of atoms J  for all pairs (I, J)  
+  int *tj;             // types of atoms J  for all pairs (I, J)
 };
 
 }    // namespace LAMMPS_NS
 
 #endif
-#endif
\ No newline at end of file
+#endif
diff --git a/src/ML-POD/compute_pod_global.cpp b/src/ML-POD/compute_pod_global.cpp
index 68fe22f862..9865cc9afc 100644
--- a/src/ML-POD/compute_pod_global.cpp
+++ b/src/ML-POD/compute_pod_global.cpp
@@ -34,32 +34,32 @@ enum{SCALAR,VECTOR,ARRAY};
 
 ComputePODGlobal::ComputePODGlobal(LAMMPS *lmp, int narg, char **arg) :
   Compute(lmp, narg, arg), list(nullptr), map(nullptr), pod(nullptr), elements(nullptr)
-{  
+{
   array_flag = 1;
   extarray = 0;
-  
+
   int nargmin = 7;
 
-  if (narg < nargmin) error->all(FLERR, "Illegal compute {} command", style); 
+  if (narg < nargmin) error->all(FLERR, "Illegal compute {} command", style);
   if (comm->nprocs > 1) error->all(FLERR, "compute command does not support multi processors");
-          
+
   std::string pod_file = std::string(arg[3]);      // pod input file
   std::string coeff_file = "";    // coefficient input file
   std::string proj_file = std::string(arg[4]);    // coefficient input file
-  std::string centroid_file = std::string(arg[5]);    // coefficient input file              
-  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);   
-  
+  std::string centroid_file = std::string(arg[5]);    // coefficient input file
+  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);
+
   int ntypes = atom->ntypes;
   memory->create(map, ntypes + 1, "compute_pod_global:map");
-  map_element2type(narg - 6, arg + 6, podptr->nelements);    
-      
-  size_array_rows = 1 + 3*atom->natoms;  
+  map_element2type(narg - 6, arg + 6, podptr->nelements);
+
+  size_array_rows = 1 + 3*atom->natoms;
   size_array_cols = podptr->nCoeffAll;
   cutmax = podptr->rcut;
-    
+
   nijmax = 0;
   pod = nullptr;
-  elements = nullptr;  
+  elements = nullptr;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -87,7 +87,7 @@ void ComputePODGlobal::init()
 
   if (modify->get_compute_by_style("pod").size() > 1 && comm->me == 0)
     error->warning(FLERR,"More than one compute pod");
-  
+
  // allocate memory for global array
   memory->create(pod,size_array_rows,size_array_cols,
                  "compute_pod_global:pod");
@@ -105,7 +105,7 @@ void ComputePODGlobal::init_list(int /*id*/, NeighList *ptr)
 
 void ComputePODGlobal::compute_array()
 {
-  // int ntotal = atom->nlocal + atom->nghost;  
+  // int ntotal = atom->nlocal + atom->nghost;
   invoked_peratom = update->ntimestep;
 
   // clear global array
@@ -113,23 +113,23 @@ void ComputePODGlobal::compute_array()
   for (int irow = 0; irow < size_array_rows; irow++)
     for (int icoeff = 0; icoeff < size_array_cols; icoeff++)
       pod[irow][icoeff] = 0.0;
-    
+
   // invoke full neighbor list (will copy or build if necessary)
 
   neighbor->build_one(list);
-  
+
   double **x = atom->x;
   int **firstneigh = list->firstneigh;
   int *numneigh = list->numneigh;
   int *type = atom->type;
   int *ilist = list->ilist;
-  int inum = list->inum;  
+  int inum = list->inum;
   int nClusters = podptr->nClusters;
   int Mdesc = podptr->Mdesc;
   int nCoeffPerElement = podptr->nCoeffPerElement;
-  
+
   double rcutsq = podptr->rcut*podptr->rcut;
-  
+
   for (int ii = 0; ii < inum; ii++) {
     int i = ilist[ii];
     int jnum = numneigh[i];
@@ -140,22 +140,22 @@ void ComputePODGlobal::compute_array()
       podptr->free_temp_memory();
       podptr->allocate_temp_memory(nijmax);
     }
-    
-    rij = &podptr->tmpmem[0];    
-    tmpmem = &podptr->tmpmem[3*nijmax]; 
-    ai = &podptr->tmpint[0];      
-    aj = &podptr->tmpint[nijmax]; 
+
+    rij = &podptr->tmpmem[0];
+    tmpmem = &podptr->tmpmem[3*nijmax];
+    ai = &podptr->tmpint[0];
+    aj = &podptr->tmpint[nijmax];
     ti = &podptr->tmpint[2*nijmax];
     tj = &podptr->tmpint[3*nijmax];
-        
+
     // get neighbor list for atom i
     lammpsNeighborList(x, firstneigh, atom->tag, type, numneigh, rcutsq, i);
-    
+
     if (nij > 0) {
       // peratom base descriptors
       double *bd = &podptr->bd[0];
-      double *bdd = &podptr->bdd[0];    
-      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);        
+      double *bdd = &podptr->bdd[0];
+      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);
 
       pod[0][nCoeffPerElement*(ti[0]-1)] += 1.0; // one-body descriptor
 
@@ -163,7 +163,7 @@ void ComputePODGlobal::compute_array()
         // peratom env descriptors
         double *pd = &podptr->pd[0];
         double *pdd = &podptr->pdd[0];
-        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);    
+        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);
 
         for (int j = 0; j < nClusters; j++) {
           for (int m=0; m<Mdesc; m++) {
@@ -171,7 +171,7 @@ void ComputePODGlobal::compute_array()
             pod[0][k] += pd[j]*bd[m];
             for (int n=0; n<nij; n++) {
               int ain = 3*ai[n];
-              int ajn = 3*aj[n];     
+              int ajn = 3*aj[n];
               int nm = 3*n + 3*nij*m;
               int nj = 3*n + 3*nij*j;
               pod[1+ain][k] += bdd[0 + nm]*pd[j] + bd[m]*pdd[0 + nj];
@@ -182,7 +182,7 @@ void ComputePODGlobal::compute_array()
               pod[3+ajn][k] -= bdd[2 + nm]*pd[j] + bd[m]*pdd[2 + nj];
             }
           }
-        }      
+        }
       }
       else {
         for (int m=0; m<Mdesc; m++) {
@@ -190,7 +190,7 @@ void ComputePODGlobal::compute_array()
           pod[0][k] += bd[m];
           for (int n=0; n<nij; n++) {
             int ain = 3*ai[n];
-            int ajn = 3*aj[n];     
+            int ajn = 3*aj[n];
             int nm = 3*n + 3*nij*m;
             pod[1+ain][k] += bdd[0 + nm];
             pod[2+ain][k] += bdd[1 + nm];
@@ -199,10 +199,10 @@ void ComputePODGlobal::compute_array()
             pod[2+ajn][k] -= bdd[1 + nm];
             pod[3+ajn][k] -= bdd[2 + nm];
           }
-        }      
-      }    
+        }
+      }
     }
-  }    
+  }
 }
 
 /* ----------------------------------------------------------------------
@@ -217,7 +217,7 @@ double ComputePODGlobal::memory_usage()
 }
 
 
-void ComputePODGlobal::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes, 
+void ComputePODGlobal::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes,
                                int *numneigh, double rcutsq, int gi)
 {
   nij = 0;
diff --git a/src/ML-POD/compute_pod_global.h b/src/ML-POD/compute_pod_global.h
index 001c01eb5e..2b946b4765 100644
--- a/src/ML-POD/compute_pod_global.h
+++ b/src/ML-POD/compute_pod_global.h
@@ -35,7 +35,7 @@ class ComputePODGlobal : public Compute {
   void lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtype, int *numneigh,
                         double rcutsq, int i);
   void map_element2type(int narg, char **arg, int nelements);
-  
+
  private:
   class NeighList *list;
   class EAPOD *podptr;
@@ -43,7 +43,7 @@ class ComputePODGlobal : public Compute {
   double cutmax;
   int nij;
   int nijmax;
-     
+
   double *tmpmem;      // temporary memory
   double *rij;         // (xj - xi) for all pairs (I, J)
   char **elements;
@@ -51,7 +51,7 @@ class ComputePODGlobal : public Compute {
   int *ai;             // IDs of atoms I for all pairs (I, J)
   int *aj;             // IDs of atoms J for all pairs (I, J)
   int *ti;             // types of atoms I for all pairs (I, J)
-  int *tj;             // types of atoms J  for all pairs (I, J)  
+  int *tj;             // types of atoms J  for all pairs (I, J)
 };
 
 }    // namespace LAMMPS_NS
diff --git a/src/ML-POD/compute_pod_local.cpp b/src/ML-POD/compute_pod_local.cpp
index 408ce3254b..6e524ba4e1 100644
--- a/src/ML-POD/compute_pod_local.cpp
+++ b/src/ML-POD/compute_pod_local.cpp
@@ -34,34 +34,34 @@ enum{SCALAR,VECTOR,ARRAY};
 
 ComputePODLocal::ComputePODLocal(LAMMPS *lmp, int narg, char **arg) :
   Compute(lmp, narg, arg), list(nullptr), map(nullptr), pod(nullptr), elements(nullptr)
-{  
+{
   array_flag = 1;
   extarray = 0;
-  
+
   int nargmin = 7;
 
   if (narg < nargmin) error->all(FLERR, "Illegal compute {} command", style);
   if (comm->nprocs > 1) error->all(FLERR, "compute command does not support multi processors");
-  
+
   std::string pod_file = std::string(arg[3]);      // pod input file
   std::string coeff_file = "";    // coefficient input file
   std::string proj_file = std::string(arg[4]);    // coefficient input file
-  std::string centroid_file = std::string(arg[5]);    // coefficient input file              
-  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);   
-    
+  std::string centroid_file = std::string(arg[5]);    // coefficient input file
+  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);
+
   int ntypes = atom->ntypes;
   memory->create(map, ntypes + 1, "compute_pod_local:map");
-    
-  map_element2type(narg - 6, arg + 6, podptr->nelements);    
-      
+
+  map_element2type(narg - 6, arg + 6, podptr->nelements);
+
   int numdesc = podptr->Mdesc * podptr->nClusters;
-  size_array_rows = 1 + 3*atom->natoms;  
+  size_array_rows = 1 + 3*atom->natoms;
   size_array_cols = atom->natoms*numdesc;
   cutmax = podptr->rcut;
-    
+
   nijmax = 0;
   pod = nullptr;
-  elements = nullptr;  
+  elements = nullptr;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -89,7 +89,7 @@ void ComputePODLocal::init()
 
   if (modify->get_compute_by_style("pod").size() > 1 && comm->me == 0)
     error->warning(FLERR,"More than one compute pod");
-  
+
  // allocate memory for global array
   memory->create(pod,size_array_rows,size_array_cols,
                  "compute_pod_local:pod");
@@ -107,7 +107,7 @@ void ComputePODLocal::init_list(int /*id*/, NeighList *ptr)
 
 void ComputePODLocal::compute_array()
 {
-  // int ntotal = atom->nlocal + atom->nghost;    
+  // int ntotal = atom->nlocal + atom->nghost;
   invoked_peratom = update->ntimestep;
 
   // clear global array
@@ -115,22 +115,22 @@ void ComputePODLocal::compute_array()
   for (int irow = 0; irow < size_array_rows; irow++)
     for (int icoeff = 0; icoeff < size_array_cols; icoeff++)
       pod[irow][icoeff] = 0.0;
-    
+
   // invoke full neighbor list (will copy or build if necessary)
 
   neighbor->build_one(list);
-  
+
   double **x = atom->x;
   int **firstneigh = list->firstneigh;
   int *numneigh = list->numneigh;
   int *type = atom->type;
   int *ilist = list->ilist;
-  int inum = list->inum;  
+  int inum = list->inum;
   int nClusters = podptr->nClusters;
   int Mdesc = podptr->Mdesc;
-  
+
   double rcutsq = podptr->rcut*podptr->rcut;
-  
+
   for (int ii = 0; ii < inum; ii++) {
     int i = ilist[ii];
     int jnum = numneigh[i];
@@ -141,32 +141,32 @@ void ComputePODLocal::compute_array()
       podptr->free_temp_memory();
       podptr->allocate_temp_memory(nijmax);
     }
-    
-    rij = &podptr->tmpmem[0];    
-    tmpmem = &podptr->tmpmem[3*nijmax]; 
-    ai = &podptr->tmpint[0];      
-    aj = &podptr->tmpint[nijmax]; 
+
+    rij = &podptr->tmpmem[0];
+    tmpmem = &podptr->tmpmem[3*nijmax];
+    ai = &podptr->tmpint[0];
+    aj = &podptr->tmpint[nijmax];
     ti = &podptr->tmpint[2*nijmax];
     tj = &podptr->tmpint[3*nijmax];
-        
+
     // get neighbor list for atom i
     lammpsNeighborList(x, firstneigh, atom->tag, type, numneigh, rcutsq, i);
-    
+
     if (nij > 0) {
       // peratom base descriptors
       double *bd = &podptr->bd[0];
-      double *bdd = &podptr->bdd[0];    
-      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);        
+      double *bdd = &podptr->bdd[0];
+      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);
 
       if (nClusters>1) {
         // peratom env descriptors
         double *pd = &podptr->pd[0];
         double *pdd = &podptr->pdd[0];
-        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);    
+        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);
         for (int k = 0; k < nClusters; k++)
           for (int m = 0; m < Mdesc; m++) {
             int imk = m + Mdesc*k +  Mdesc*nClusters*i;
-            pod[0][imk] = pd[k]*bd[m];     
+            pod[0][imk] = pd[k]*bd[m];
             for (int n=0; n<nij; n++) {
               int ain = 3*ai[n];
               int ajn = 3*aj[n];
@@ -178,7 +178,7 @@ void ComputePODLocal::compute_array()
               pod[1 + ajn][imk] -= bdd[0 + nm]*pd[k] + bd[m]*pdd[0+nk];
               pod[2 + ajn][imk] -= bdd[1 + nm]*pd[k] + bd[m]*pdd[1+nk];
               pod[3 + ajn][imk] -= bdd[2 + nm]*pd[k] + bd[m]*pdd[2+nk];
-            }                  
+            }
           }
       }
       else {
@@ -195,11 +195,11 @@ void ComputePODLocal::compute_array()
             pod[1 + ajn][im] -= bdd[0 + nm];
             pod[2 + ajn][im] -= bdd[1 + nm];
             pod[3 + ajn][im] -= bdd[2 + nm];
-          }       
+          }
         }
-      }    
+      }
     }
-  }        
+  }
 }
 
 /* ----------------------------------------------------------------------
@@ -214,7 +214,7 @@ double ComputePODLocal::memory_usage()
 }
 
 
-void ComputePODLocal::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes, 
+void ComputePODLocal::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes,
                                int *numneigh, double rcutsq, int gi)
 {
   nij = 0;
@@ -259,7 +259,7 @@ void ComputePODLocal::map_element2type(int narg, char **arg, int nelements)
   }
   elements = new char*[ntypes];
   for (i = 0; i < ntypes; i++) elements[i] = nullptr;
-  
+
   nelements = 0;
   map[0] = -1;
   for (i = 1; i <= narg; i++) {
@@ -275,5 +275,5 @@ void ComputePODLocal::map_element2type(int narg, char **arg, int nelements)
       elements[j] = utils::strdup(entry);
       nelements++;
     }
-  }  
+  }
 }
diff --git a/src/ML-POD/compute_pod_local.h b/src/ML-POD/compute_pod_local.h
index 516d666e5e..706ffb72b3 100644
--- a/src/ML-POD/compute_pod_local.h
+++ b/src/ML-POD/compute_pod_local.h
@@ -35,7 +35,7 @@ class ComputePODLocal : public Compute {
   void lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtype, int *numneigh,
                         double rcutsq, int i);
   void map_element2type(int narg, char **arg, int nelements);
-  
+
  private:
   class NeighList *list;
   class EAPOD *podptr;
@@ -43,7 +43,7 @@ class ComputePODLocal : public Compute {
   double cutmax;
   int nij;
   int nijmax;
-     
+
   double *tmpmem;      // temporary memory
   double *rij;         // (xj - xi) for all pairs (I, J)
   char **elements;
@@ -51,7 +51,7 @@ class ComputePODLocal : public Compute {
   int *ai;             // IDs of atoms I for all pairs (I, J)
   int *aj;             // IDs of atoms J for all pairs (I, J)
   int *ti;             // types of atoms I for all pairs (I, J)
-  int *tj;             // types of atoms J  for all pairs (I, J)  
+  int *tj;             // types of atoms J  for all pairs (I, J)
 };
 
 }    // namespace LAMMPS_NS
diff --git a/src/ML-POD/compute_podd_atom.cpp b/src/ML-POD/compute_podd_atom.cpp
index 18387604a5..96f6bdab05 100644
--- a/src/ML-POD/compute_podd_atom.cpp
+++ b/src/ML-POD/compute_podd_atom.cpp
@@ -34,30 +34,30 @@ enum{SCALAR,VECTOR,ARRAY};
 
 ComputePODDAtom::ComputePODDAtom(LAMMPS *lmp, int narg, char **arg) :
   Compute(lmp, narg, arg), list(nullptr), map(nullptr), pod(nullptr), elements(nullptr)
-{  
+{
 
   int nargmin = 7;
 
   if (narg < nargmin) error->all(FLERR, "Illegal compute {} command", style);
   if (comm->nprocs > 1) error->all(FLERR, "compute command does not support multi processors");
-  
+
   std::string pod_file = std::string(arg[3]);      // pod input file
   std::string coeff_file = "";    // coefficient input file
   std::string proj_file = std::string(arg[4]);    // coefficient input file
-  std::string centroid_file = std::string(arg[5]);    // coefficient input file              
-  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);   
-  
+  std::string centroid_file = std::string(arg[5]);    // coefficient input file
+  podptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);
+
   int ntypes = atom->ntypes;
   memory->create(map, ntypes + 1, "compute_pod_global:map");
-  map_element2type(narg - 6, arg + 6, podptr->nelements);    
-        
+  map_element2type(narg - 6, arg + 6, podptr->nelements);
+
   cutmax = podptr->rcut;
 
-  nmax = 0;  
+  nmax = 0;
   nijmax = 0;
   pod = nullptr;
-  elements = nullptr;  
-  
+  elements = nullptr;
+
   size_peratom_cols = podptr->Mdesc * podptr->nClusters*3*atom->natoms;
   peratom_flag = 1;
 }
@@ -117,23 +117,23 @@ void ComputePODDAtom::compute_peratom()
     for (int icoeff = 0; icoeff < size_peratom_cols; icoeff++) {
       pod[i][icoeff] = 0.0;
     }
-  
+
   // invoke full neighbor list (will copy or build if necessary)
 
   neighbor->build_one(list);
-  
+
   double **x = atom->x;
   int **firstneigh = list->firstneigh;
   int *numneigh = list->numneigh;
   int *type = atom->type;
   int *ilist = list->ilist;
-  int inum = list->inum;  
+  int inum = list->inum;
   int nClusters = podptr->nClusters;
   int Mdesc = podptr->Mdesc;
   double rcutsq = podptr->rcut*podptr->rcut;
-  
+
   for (int ii = 0; ii < inum; ii++) {
-    int i = ilist[ii];    
+    int i = ilist[ii];
     int jnum = numneigh[i];
 
     // allocate temporary memory
@@ -142,34 +142,34 @@ void ComputePODDAtom::compute_peratom()
       podptr->free_temp_memory();
       podptr->allocate_temp_memory(nijmax);
     }
-    
-    rij = &podptr->tmpmem[0];    
-    tmpmem = &podptr->tmpmem[3*nijmax]; 
-    ai = &podptr->tmpint[0];      
-    aj = &podptr->tmpint[nijmax]; 
+
+    rij = &podptr->tmpmem[0];
+    tmpmem = &podptr->tmpmem[3*nijmax];
+    ai = &podptr->tmpint[0];
+    aj = &podptr->tmpint[nijmax];
     ti = &podptr->tmpint[2*nijmax];
     tj = &podptr->tmpint[3*nijmax];
 
     // get neighbor list for atom i
     lammpsNeighborList(x, firstneigh, atom->tag, type, numneigh, rcutsq, i);
-    
+
     if (nij > 0) {
       // peratom base descriptors
       double *bd = &podptr->bd[0];
       double *bdd = &podptr->bdd[0];
-      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);        
+      podptr->peratombase_descriptors(bd, bdd, rij, tmpmem, ti, tj, nij);
 
       if (nClusters>1) {
         // peratom env descriptors
         double *pd = &podptr->pd[0];
         double *pdd = &podptr->pdd[0];
-        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);    
+        podptr->peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  nij);
         for (int n=0; n<nij; n++) {
           int ain = 3*ai[n];
-          int ajn = 3*aj[n];      
+          int ajn = 3*aj[n];
           for (int k = 0; k < nClusters; k++) {
             for (int m = 0; m < Mdesc; m++) {
-              int mk = m + Mdesc*k;          
+              int mk = m + Mdesc*k;
               int nm = 3*n + 3*nij*m;
               int nk = 3*n + 3*nij*k;
               pod[i][mk + Mdesc*nClusters*0 + Mdesc*nClusters*ain] += bdd[0 + nm]*pd[k] + bd[m]*pdd[0+nk];
@@ -178,7 +178,7 @@ void ComputePODDAtom::compute_peratom()
               pod[i][mk + Mdesc*nClusters*0 + Mdesc*nClusters*ajn] -= bdd[0 + nm]*pd[k] + bd[m]*pdd[0+nk];
               pod[i][mk + Mdesc*nClusters*1 + Mdesc*nClusters*ajn] -= bdd[1 + nm]*pd[k] + bd[m]*pdd[1+nk];
               pod[i][mk + Mdesc*nClusters*2 + Mdesc*nClusters*ajn] -= bdd[2 + nm]*pd[k] + bd[m]*pdd[2+nk];
-            }                  
+            }
           }
         }
       }
@@ -194,11 +194,11 @@ void ComputePODDAtom::compute_peratom()
             pod[i][m + Mdesc*0 + Mdesc*ajn] -= bdd[0 + nm];
             pod[i][m + Mdesc*1 + Mdesc*ajn] -= bdd[1 + nm];
             pod[i][m + Mdesc*2 + Mdesc*ajn] -= bdd[2 + nm];
-          }       
+          }
         }
       }
-    }    
-  }  
+    }
+  }
 }
 
 /* ----------------------------------------------------------------------
@@ -213,7 +213,7 @@ double ComputePODDAtom::memory_usage()
 }
 
 
-void ComputePODDAtom::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes, 
+void ComputePODDAtom::lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtypes,
                                int *numneigh, double rcutsq, int gi)
 {
   nij = 0;
diff --git a/src/ML-POD/compute_podd_atom.h b/src/ML-POD/compute_podd_atom.h
index 1339ed9d26..43635cbf62 100644
--- a/src/ML-POD/compute_podd_atom.h
+++ b/src/ML-POD/compute_podd_atom.h
@@ -35,7 +35,7 @@ class ComputePODDAtom : public Compute {
   void lammpsNeighborList(double **x, int **firstneigh, int *atomid, int *atomtype, int *numneigh,
                         double rcutsq, int i);
   void map_element2type(int narg, char **arg, int nelements);
-  
+
  private:
   class NeighList *list;
   class EAPOD *podptr;
@@ -46,16 +46,16 @@ class ComputePODDAtom : public Compute {
   int nijmax;
 
   double *tmpmem;      // temporary memory
-  double *rij;         // (xj - xi) for all pairs (I, J)  
+  double *rij;         // (xj - xi) for all pairs (I, J)
   char **elements;
   int *map;
   int *ai;             // IDs of atoms I for all pairs (I, J)
   int *aj;             // IDs of atoms J for all pairs (I, J)
   int *ti;             // types of atoms I for all pairs (I, J)
-  int *tj;             // types of atoms J  for all pairs (I, J)  
+  int *tj;             // types of atoms J  for all pairs (I, J)
 };
 
 }    // namespace LAMMPS_NS
 
 #endif
-#endif
\ No newline at end of file
+#endif
diff --git a/src/ML-POD/eapod.cpp b/src/ML-POD/eapod.cpp
index b2ff5e83f8..4f97b05980 100644
--- a/src/ML-POD/eapod.cpp
+++ b/src/ML-POD/eapod.cpp
@@ -49,7 +49,7 @@ EAPOD::EAPOD(LAMMPS *_lmp, const std::string &pod_file, const std::string &coeff
   ind34r = nullptr;
   ind44l = nullptr;
   ind44r = nullptr;
-          
+
   rin = 0.5;
   rcut = 5.0;
   nClusters = 1;
@@ -101,20 +101,20 @@ EAPOD::EAPOD(LAMMPS *_lmp, const std::string &pod_file, const std::string &coeff
       error->all(FLERR,"number of coefficients in the coefficient file is not correct");
   }
   if (nClusters > 1) {
-    // read projection matrix file to podstruct 
+    // read projection matrix file to podstruct
     if (proj_file != "") {
       nproj = read_projection_matrix(proj_file);
       if (nproj != nComponents*Mdesc*nelements)
         error->all(FLERR,"number of coefficients in the projection file is not correct");
     }
-    
+
     // read centroids file to podstruct
     if (centroids_file != "") {
       ncentroids = read_centroids(centroids_file);
       if (ncentroids != nComponents*nClusters*nelements)
         error->all(FLERR,"number of coefficients in the projection file is not correct");
     }
-  }    
+  }
 }
 
 // destructor
@@ -129,7 +129,7 @@ EAPOD::~EAPOD()
   memory->destroy(bdd);
   memory->destroy(pd);
   memory->destroy(pdd);
-  memory->destroy(coeff);   
+  memory->destroy(coeff);
   memory->destroy(tmpmem);
   memory->destroy(tmpint);
   memory->destroy(pn3);
@@ -150,7 +150,7 @@ EAPOD::~EAPOD()
   memory->destroy(ind44l);
   memory->destroy(ind33r);
   memory->destroy(ind34r);
-  memory->destroy(ind44r);    
+  memory->destroy(ind44r);
 }
 
 void EAPOD::read_pod_file(std::string pod_file)
@@ -268,7 +268,7 @@ void EAPOD::read_pod_file(std::string pod_file)
   if (P4 < P44) error->all(FLERR,"seven-body angular degree must be equal or less than four-body angular degree");
 
   if (P3 > 12) error->all(FLERR,"three-body angular degree must be equal or less than 12");
-  if (P4 > 6) error->all(FLERR,"four-body angular degree must be equal or less than 6");  
+  if (P4 > 6) error->all(FLERR,"four-body angular degree must be equal or less than 6");
 
   int Ne = nelements;
   memory->create(elemindex, Ne*Ne, "elemindex");
@@ -416,7 +416,7 @@ void EAPOD::read_pod_file(std::string pod_file)
     utils::logmesg(lmp, "number of local descriptors per element for five-body potential: {}\n", nl33);
     utils::logmesg(lmp, "number of local descriptors per element for six-body potential: {}\n", nl34);
     utils::logmesg(lmp, "number of local descriptors per element for seven-body potential: {}\n", nl44);
-    utils::logmesg(lmp, "number of local descriptors per element for all potentials: {}\n", nl);    
+    utils::logmesg(lmp, "number of local descriptors per element for all potentials: {}\n", nl);
     utils::logmesg(lmp, "number of global descriptors: {}\n", nCoeffAll);
     utils::logmesg(lmp, "**************** End of POD Potentials ****************\n\n");
   }
@@ -702,7 +702,7 @@ void EAPOD::peratombase_descriptors(double *bd1, double *bdd1, double *rij, doub
   for (int i=0; i<3*Nj*Mdesc; i++) bdd1[i] = 0.0;
 
   if (Nj == 0) return;
-  
+
   double *d2 =  &bd1[0]; // nl2
   double *d3 =  &bd1[nl2]; // nl3
   double *d4 =  &bd1[nl2 + nl3]; // nl4
@@ -711,8 +711,8 @@ void EAPOD::peratombase_descriptors(double *bd1, double *bdd1, double *rij, doub
   double *d34 =  &bd1[nl2 + nl3 + nl4 + nl23 + nl33]; // nl34
   double *d44 =  &bd1[nl2 + nl3 + nl4 + nl23 + nl33 + nl34]; // nl44
 
-  double *dd2 = &bdd1[0]; // 3*Nj*nl2  
-  double *dd3 = &bdd1[3*Nj*nl2]; // 3*Nj*nl3  
+  double *dd2 = &bdd1[0]; // 3*Nj*nl2
+  double *dd3 = &bdd1[3*Nj*nl2]; // 3*Nj*nl3
   double *dd4 = &bdd1[3*Nj*(nl2+nl3)]; // 3*Nj*nl4
   double *dd23 = &bdd1[3*Nj*(nl2+nl3+nl4)]; // 3*Nj*nl23
   double *dd33 = &bdd1[3*Nj*(nl2+nl3+nl4+nl23)]; // 3*Nj*nl33
@@ -797,7 +797,7 @@ void EAPOD::peratombase_descriptors(double *bd1, double *bdd1, double *rij, doub
             }
       }
       fourbodydescderiv(d4, dd4, sumU, Ux, Uy, Uz, tj, Nj);
-      
+
       if ((nl34>0) && (Nj>4)) {
         crossdesc(d34, d3, d4, ind34l, ind34r, nl34);
         crossdescderiv(dd34, d3, d4, dd3, dd4, ind34l, ind34r, nl34, 3*Nj);
@@ -812,39 +812,39 @@ void EAPOD::peratombase_descriptors(double *bd1, double *bdd1, double *rij, doub
 }
 
 double EAPOD::peratombase_coefficients(double *cb, double *bd, int *ti)
-{    
+{
   int nc = nCoeffPerElement*(ti[0]-1);
-  
+
   double ei = coeff[0 + nc];
-  for (int m=0; m<Mdesc; m++) {    
-    ei += coeff[1 + m + nc]*bd[m];  
-    cb[m] = coeff[1 + m + nc];       
-  }      
-  
+  for (int m=0; m<Mdesc; m++) {
+    ei += coeff[1 + m + nc]*bd[m];
+    cb[m] = coeff[1 + m + nc];
+  }
+
   return ei;
 }
 
 double EAPOD::peratom_environment_descriptors(double *cb, double *bd, double *tm, int *ti)
-{  
-  double *P    = &tm[0];    // nClusters 
-  double *cp   = &tm[(nClusters)];  // nClusters  
+{
+  double *P    = &tm[0];    // nClusters
+  double *cp   = &tm[(nClusters)];  // nClusters
   double *D    = &tm[(2*nClusters)];   // nClusters
-  double *pca  = &tm[(3*nClusters)]; // nComponents 
-     
+  double *pca  = &tm[(3*nClusters)]; // nComponents
+
   double *proj = &Proj[0];
-  double *cent = &Centroids[0];  
+  double *cent = &Centroids[0];
   int typei = ti[0]-1;
-  
+
   for (int k=0; k<nComponents; k++) {
-    double sum = 0.0;    
+    double sum = 0.0;
     for (int m = 0; m < Mdesc; m++) {
       sum += proj[k + nComponents*m + nComponents*Mdesc*typei] * bd[m];
     }
-    pca[k] = sum;    
+    pca[k] = sum;
   }
-  
+
   for (int j=0; j<nClusters; j++) {
-    double sum = 1e-20; 
+    double sum = 1e-20;
     for (int k = 0; k < nComponents; k++) {
       double c = cent[k + j * nComponents + nClusters*nComponents*typei];
       double p = pca[k];
@@ -852,35 +852,35 @@ double EAPOD::peratom_environment_descriptors(double *cb, double *bd, double *tm
     }
     D[j] = 1.0 / sum;
   }
-  
-  double sum = 0; 
-  for (int j = 0; j < nClusters; j++) sum += D[j];    
+
+  double sum = 0;
+  for (int j = 0; j < nClusters; j++) sum += D[j];
   double sumD = sum;
-  for (int j = 0; j < nClusters; j++) P[j] = D[j]/sum;    
-  
+  for (int j = 0; j < nClusters; j++) P[j] = D[j]/sum;
+
   int nc = nCoeffPerElement*(ti[0]-1);
   double ei = coeff[0 + nc];
   for (int k = 0; k<nClusters; k++)
-    for (int m=0; m<Mdesc; m++)     
+    for (int m=0; m<Mdesc; m++)
       ei += coeff[1 + m + Mdesc*k + nc]*bd[m]*P[k];
-  
-  for (int k=0; k<nClusters; k++) {        
+
+  for (int k=0; k<nClusters; k++) {
     double sum = 0;
-    for (int m = 0; m<Mdesc; m++)     
+    for (int m = 0; m<Mdesc; m++)
       sum += coeff[1 + m + k*Mdesc + nc]*bd[m];
     cp[k] = sum;
-  }            
+  }
 
   for (int m = 0; m<Mdesc; m++) {
-    double sum = 0.0;    
-    for (int k = 0; k<nClusters; k++)    
-      sum += coeff[1 + m + k*Mdesc + nc]*P[k];      
+    double sum = 0.0;
+    for (int k = 0; k<nClusters; k++)
+      sum += coeff[1 + m + k*Mdesc + nc]*P[k];
     cb[m] = sum;
-  }              
-  
+  }
+
   for (int m = 0; m<Mdesc; m++) {
     double S1 = 1/sumD;
-    double S2 = sumD*sumD;   
+    double S2 = sumD*sumD;
     double sum = 0.0;
     for (int j=0; j<nClusters; j++) {
       double dP_dB = 0.0;
@@ -890,16 +890,16 @@ double EAPOD::peratom_environment_descriptors(double *cb, double *bd, double *tm
         double dD_dB = 0.0;
         double D2 = 2 * D[k] * D[k];
         for (int n = 0; n < nComponents; n++) {
-          double dD_dpca = D2 * (cent[n + k * nComponents + nClusters*nComponents*typei] - pca[n]);        
+          double dD_dpca = D2 * (cent[n + k * nComponents + nClusters*nComponents*typei] - pca[n]);
           dD_dB += dD_dpca * proj[n + m * nComponents + nComponents*Mdesc*typei];
-        }                
+        }
         dP_dB += dP_dD * dD_dB;
-      }      
-      sum += cp[j]*dP_dB;      
+      }
+      sum += cp[j]*dP_dB;
     }
     cb[m] += sum;
-  }  
-  
+  }
+
   return ei;
 }
 
@@ -912,7 +912,7 @@ void EAPOD::twobody_forces(double *fij, double *cb2, double *rbfx, double *rbfy,
     int m = idx % nrbf2; // Recalculate n
 
     int i2 = n + Nj * m; // Index of the radial basis function for atom n and RBF m
-    int i1 = 3*n; 
+    int i1 = 3*n;
     double c = cb2[m + nrbf2*(tj[n] - 1)];
     fij[0 + i1] += c*rbfx[i2]; // Add the derivative with respect to x to the corresponding descriptor derivative
     fij[1 + i1] += c*rbfy[i2]; // Add the derivative with respect to y to the corresponding descriptor derivative
@@ -925,20 +925,20 @@ void EAPOD::threebody_forcecoeff(double *fb3, double *cb3, double *sumU)
   if (nelements==1) {
     for (int m = 0; m < nrbf3; ++m) {
       for (int p = 0; p < nabf3; p++) {
-        double c3 = 2.0 * cb3[p + nabf3*m]; 
+        double c3 = 2.0 * cb3[p + nabf3*m];
         int n1 = pn3[p];
         int n2 = pn3[p + 1];
-        int nn = n2 - n1;        
-        int idxU = K3 * m; 
-        for (int q = 0; q < nn; q++) {                  
-          int k = n1 + q;  
-          fb3[k + idxU] += c3 * pc3[k] * sumU[k + idxU]; 
+        int nn = n2 - n1;
+        int idxU = K3 * m;
+        for (int q = 0; q < nn; q++) {
+          int k = n1 + q;
+          fb3[k + idxU] += c3 * pc3[k] * sumU[k + idxU];
         }
       }
     }
   }
   else {
-    int N3 = nabf3 * nrbf3;    
+    int N3 = nabf3 * nrbf3;
     for (int m = 0; m < nrbf3; ++m) {
       for (int p = 0; p < nabf3; p++) {
         int n1 = pn3[p];
@@ -947,13 +947,13 @@ void EAPOD::threebody_forcecoeff(double *fb3, double *cb3, double *sumU)
         int jmp = p + nabf3*m;
         for (int q = 0; q < nn; q++) {
           int k = n1 + q;  // Combine n1 and q into a single index
-          int idxU = nelements * k + nelements * K3 * m;          
+          int idxU = nelements * k + nelements * K3 * m;
           for (int i1 = 0; i1 < nelements; i1++) {
             double tm = pc3[k] * sumU[i1 + idxU];
             for (int i2 = i1; i2 < nelements; i2++) {
-              int em = elemindex[i2 + nelements * i1];       
+              int em = elemindex[i2 + nelements * i1];
               double t1 = tm * cb3[jmp + N3*em]; // Ni *  nabf3 * nrbf3 * nelements*(nelements+1)/2
-              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni         
+              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni
               fb3[i1 + idxU] += pc3[k] * cb3[jmp + N3*em] * sumU[i2 + idxU];
             }
           }
@@ -967,7 +967,7 @@ void EAPOD::fourbody_forcecoeff(double *fb4, double *cb4, double *sumU)
 {
   if (nelements==1) {
     for (int m = 0; m < nrbf4; ++m) {
-      int idxU = K3 * m;                  
+      int idxU = K3 * m;
       for (int p = 0; p < nabf4; p++) {
         int n1 = pa4[p];
         int n2 = pa4[p + 1];
@@ -981,21 +981,21 @@ void EAPOD::fourbody_forcecoeff(double *fb4, double *cb4, double *sumU)
           int j3 = idxU + pb4[idxNQ + 2 * Q4];
           double c1 = sumU[j1];
           double c2 = sumU[j2];
-          double c3 = sumU[j3];          
-          fb4[j3] += c * c1 * c2;          
+          double c3 = sumU[j3];
+          fb4[j3] += c * c1 * c2;
           fb4[j2] += c * c1 * c3;
-          fb4[j1] += c * c2 * c3;          
+          fb4[j1] += c * c2 * c3;
         }
       }
     }
   }
-  else {        
-    int N3 = nabf4 * nrbf4;    
+  else {
+    int N3 = nabf4 * nrbf4;
     for (int m = 0; m < nrbf4; ++m) {
       for (int p = 0; p < nabf4; p++)  {
         int n1 = pa4[p];
         int n2 = pa4[p + 1];
-        int nn = n2 - n1;        
+        int nn = n2 - n1;
         int jpm = p + nabf4*m;
         for (int q = 0; q < nn; q++) {
           int c = pc4[n1 + q];
@@ -1005,17 +1005,17 @@ void EAPOD::fourbody_forcecoeff(double *fb4, double *cb4, double *sumU)
           int idx1 = nelements * j1 + nelements * K3 * m;
           int idx2 = nelements * j2 + nelements * K3 * m;
           int idx3 = nelements * j3 + nelements * K3 * m;
-          int k = 0;          
-          for (int i1 = 0; i1 < nelements; i1++) {            
+          int k = 0;
+          for (int i1 = 0; i1 < nelements; i1++) {
             double c1 = sumU[idx1 + i1];
             for (int i2 = i1; i2 < nelements; i2++) {
-              double c2 = sumU[idx2 + i2];              
-              for (int i3 = i2; i3 < nelements; i3++) {                       
-                double c3 = sumU[idx3 + i3];          
+              double c2 = sumU[idx2 + i2];
+              for (int i3 = i2; i3 < nelements; i3++) {
+                double c3 = sumU[idx3 + i3];
                 double c4 = c * cb4[jpm + N3*k];
-                fb4[idx3 + i3] += c4*(c1 * c2);  
+                fb4[idx3 + i3] += c4*(c1 * c2);
                 fb4[idx2 + i2] += c4*(c1 * c3);
-                fb4[idx1 + i1] += c4*(c2 * c3);                                                
+                fb4[idx1 + i1] += c4*(c2 * c3);
                 k += 1;
               }
             }
@@ -1029,74 +1029,74 @@ void EAPOD::fourbody_forcecoeff(double *fb4, double *cb4, double *sumU)
 void EAPOD::allbody_forces(double *fij, double *forcecoeff, double *rbf, double *rbfx, double *rbfy, double *rbfz,
         double *abf, double *abfx, double *abfy, double *abfz, int *tj, int Nj)
 {
-  int totalIterations = nrbf3 * Nj;  
+  int totalIterations = nrbf3 * Nj;
   for (int idx = 0; idx < totalIterations; ++idx) {
     int j = idx / nrbf3;  // Derive the original j value
     int m = idx % nrbf3;  // Derive the original m value
     int idxR = m + nrbfmax * j;  // Pre-compute the index for rbf
-    int i2 = tj[j] - 1;   
+    int i2 = tj[j] - 1;
     double rbfBase = rbf[idxR];
     double rbfxBase = rbfx[idxR];
     double rbfyBase = rbfy[idxR];
     double rbfzBase = rbfz[idxR];
     double fx = 0;
     double fy = 0;
-    double fz = 0;            
+    double fz = 0;
     for (int k = 0; k < K3; k++) {
       int idxU = nelements * k + nelements * K3 * m;
       double fc = forcecoeff[i2 + idxU];
-      int idxA = k + K3 * j;  // Pre-compute the index for abf          
-      double abfA = abf[idxA];   
+      int idxA = k + K3 * j;  // Pre-compute the index for abf
+      double abfA = abf[idxA];
       double abfxA = abfx[idxA];
       double abfyA = abfy[idxA];
-      double abfzA = abfz[idxA];        
-      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij 
+      double abfzA = abfz[idxA];
+      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij
       fy += fc * (abfyA * rbfBase + rbfyBase * abfA);
-      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);                        
+      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);
     }
-    int baseIdx = 3 * j; 
+    int baseIdx = 3 * j;
     fij[baseIdx]     += fx;
     fij[baseIdx + 1] += fy;
-    fij[baseIdx + 2] += fz;                           
-  }  
+    fij[baseIdx + 2] += fz;
+  }
 }
 
 void EAPOD::allbody_forces(double *fij, double *forcecoeff, double *Ux, double *Uy, double *Uz, int *tj, int Nj)
 {
   for (int j = 0; j < Nj; ++j) {
-    int i2 = tj[j] - 1;   
+    int i2 = tj[j] - 1;
     double fx = 0;
     double fy = 0;
-    double fz = 0;            
-    for (int m = 0; m < nrbf3; m++) 
-      for (int k = 0; k < K3; k++) {      
+    double fz = 0;
+    for (int m = 0; m < nrbf3; m++)
+      for (int k = 0; k < K3; k++) {
         double fc = forcecoeff[i2 + nelements * k + nelements * K3 * m];
-        int idxU = j + Nj*k + Nj * K3 * m;  // Pre-compute the index for abf          
-        fx += fc * Ux[idxU]; // K3*nrbf3*Nij 
+        int idxU = j + Nj*k + Nj * K3 * m;  // Pre-compute the index for abf
+        fx += fc * Ux[idxU]; // K3*nrbf3*Nij
         fy += fc * Uy[idxU];
-        fz += fc * Uz[idxU];                        
+        fz += fc * Uz[idxU];
       }
-    int baseIdx = 3 * j; 
+    int baseIdx = 3 * j;
     fij[baseIdx]     += fx;
     fij[baseIdx + 1] += fy;
-    fij[baseIdx + 2] += fz;                           
-  }  
+    fij[baseIdx + 2] += fz;
+  }
 }
 
 double EAPOD::peratomenergyforce2(double *fij, double *rij, double *temp,
         int *ti, int *tj, int Nj)
 {
   if (Nj==0) {
-    return coeff[nCoeffPerElement*(ti[0]-1)];    
+    return coeff[nCoeffPerElement*(ti[0]-1)];
   }
- 
+
   int N = 3*Nj;
   for (int n=0; n<N; n++) fij[n] = 0.0;
-  
+
   //double *coeff1 = &coeff[nCoeffPerElement*(ti[0]-1)];
-  double e = 0.0;   
+  double e = 0.0;
   for (int i=0; i<Mdesc; i++) bd[i] = 0.0;
-  
+
   double *d2 =  &bd[0]; // nl2
   double *d3 =  &bd[nl2]; // nl3
   double *d4 =  &bd[nl2 + nl3]; // nl4
@@ -1126,7 +1126,7 @@ double EAPOD::peratomenergyforce2(double *fij, double *rij, double *temp,
   double *rbfxt = &temp[4*n1 + n5 + 4*n2 + n3]; // Nj*ns
   double *rbfyt = &temp[4*n1 + n5 + 4*n2 + 2*n3]; // Nj*ns
   double *rbfzt = &temp[4*n1 + n5 + 4*n2 + 3*n3]; // Nj*ns
-  
+
   radialbasis(rbft, rbfxt, rbfyt, rbfzt, rij, besselparams, rin, rcut-rin, pdegree[0], pdegree[1], nbesselpars, Nj);
 
   char chn = 'N';
@@ -1144,7 +1144,7 @@ double EAPOD::peratomenergyforce2(double *fij, double *rij, double *temp,
     double *abf = &temp[4*n1 + n5 + 4*n2]; // Nj*K3
     double *abfx = &temp[4*n1 + n5 + 4*n2 + n4]; // Nj*K3
     double *abfy = &temp[4*n1 + n5 + 4*n2 + 2*n4]; // Nj*K3
-    double *abfz = &temp[4*n1 + n5 + 4*n2 + 3*n4]; // Nj*K3      
+    double *abfz = &temp[4*n1 + n5 + 4*n2 + 3*n4]; // Nj*K3
     double *tm = &temp[4*n1 + n5 + 4*n2 + 4*n4]; // 4*K3
 
     angularbasis(abf, abfx, abfy, abfz, rij, tm, pq3, Nj, K3);
@@ -1164,7 +1164,7 @@ double EAPOD::peratomenergyforce2(double *fij, double *rij, double *temp,
 
     if ((nl4 > 0) && (Nj>2)) {
       fourbodydesc(d4, sumU);
-      
+
       if ((nl34>0) && (Nj>4)) {
         crossdesc(d34, d3, d4, ind34l, ind34r, nl34);
       }
@@ -1174,47 +1174,47 @@ double EAPOD::peratomenergyforce2(double *fij, double *rij, double *temp,
       }
     }
   }
-  
-  double *cb = &bdd[0];          
-  if (nClusters > 1) {    
+
+  double *cb = &bdd[0];
+  if (nClusters > 1) {
     e += peratom_environment_descriptors(cb, bd, &temp[4*n1 + n5 + 4*n2], ti);
   }
   else {
     e += peratombase_coefficients(cb, bd, ti);
-  }      
-    
+  }
+
   double *cb2 =  &cb[0]; // nl3
   double *cb3 =  &cb[nl2]; // nl3
   double *cb4 =  &cb[(nl2 + nl3)]; // nl4
   double *cb33 = &cb[(nl2 + nl3 + nl4)]; // nl33
   double *cb34 = &cb[(nl2 + nl3 + nl4 + nl33)]; // nl34
   double *cb44 = &cb[(nl2 + nl3 + nl4 + nl33 + nl34)]; // nl44
-  
+
   if ((nl33>0) && (Nj>3)) {
-    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33);      
+    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33);
   }
   if ((nl34>0) && (Nj>4)) {
-    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34);      
-  }  
+    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34);
+  }
   if ((nl44>0) && (Nj>5)) {
-    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44);        
-  }     
-    
-  if ((nl2 > 0) && (Nj>0)) twobody_forces(fij, cb2, rbfx, rbfy, rbfz, tj, Nj);  
+    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44);
+  }
+
+  if ((nl2 > 0) && (Nj>0)) twobody_forces(fij, cb2, rbfx, rbfy, rbfz, tj, Nj);
 //   print_matrix("cb2", 1, nl2, cb2, 1);
 //   print_matrix("rbfx", Nj, nrbf2, rbfx, Nj);
 //   print_matrix("rbfy", Nj, nrbf2, rbfy, Nj);
 //   print_matrix("rbfz", Nj, nrbf2, rbfz, Nj);
 //   print_matrix("fij", 3, Nj, fij, 3);
 //   error->all(FLERR,"stop");
-  
-  // Initialize forcecoeff to zero  
+
+  // Initialize forcecoeff to zero
   double *forcecoeff = &cb[(nl2 + nl3 + nl4)]; // nl33
   std::fill(forcecoeff, forcecoeff + nelements * K3 * nrbf3, 0.0);
   if ((nl3 > 0) && (Nj>1)) threebody_forcecoeff(forcecoeff, cb3, sumU);
   if ((nl4 > 0) && (Nj>2)) fourbody_forcecoeff(forcecoeff, cb4, sumU);
-  if ((nl3 > 0) && (Nj>1)) allbody_forces(fij, forcecoeff, Ux, Uy, Uz, tj, Nj);   
-      
+  if ((nl3 > 0) && (Nj>1)) allbody_forces(fij, forcecoeff, Ux, Uy, Uz, tj, Nj);
+
   return e;
 }
 
@@ -1222,51 +1222,51 @@ double EAPOD::peratomenergyforce(double *fij, double *rij, double *temp,
         int *ti, int *tj, int Nj)
 {
   if (Nj==0) {
-    return coeff[nCoeffPerElement*(ti[0]-1)];    
+    return coeff[nCoeffPerElement*(ti[0]-1)];
   }
- 
+
   int N = 3*Nj;
   for (int n=0; n<N; n++) fij[n] = 0.0;
-  
+
   double *coeff1 = &coeff[nCoeffPerElement*(ti[0]-1)];
   double e = coeff1[0];
-   
+
   // calculate base descriptors and their derivatives with respect to atom coordinates
-  peratombase_descriptors(bd, bdd, rij, temp, ti, tj, Nj);  
+  peratombase_descriptors(bd, bdd, rij, temp, ti, tj, Nj);
 
   if (nClusters > 1) { // multi-environment descriptors
     // calculate multi-environment descriptors and their derivatives with respect to atom coordinates
     peratomenvironment_descriptors(pd, pdd, bd, bdd, temp, ti[0] - 1,  Nj);
-    
+
     for (int j = 0; j<nClusters; j++)
-      for (int m=0; m<Mdesc; m++) 
+      for (int m=0; m<Mdesc; m++)
         e += coeff1[1 + m + j*Mdesc]*bd[m]*pd[j];
-          
+
     double *cb = &temp[0];
     double *cp = &temp[Mdesc];
-    for (int m = 0; m<Mdesc; m++) cb[m] = 0.0;    
+    for (int m = 0; m<Mdesc; m++) cb[m] = 0.0;
     for (int j = 0; j<nClusters; j++) cp[j] = 0.0;
-    for (int j = 0; j<nClusters; j++)  
-      for (int m = 0; m<Mdesc; m++)  {   
+    for (int j = 0; j<nClusters; j++)
+      for (int m = 0; m<Mdesc; m++)  {
         cb[m] += coeff1[1 + m + j*Mdesc]*pd[j];
         cp[j] += coeff1[1 + m + j*Mdesc]*bd[m];
       }
-    char chn = 'N';    
+    char chn = 'N';
     double alpha = 1.0, beta = 0.0;
     int inc1 = 1;
-    DGEMV(&chn, &N, &Mdesc, &alpha, bdd, &N, cb, &inc1, &beta, fij, &inc1);    
-    DGEMV(&chn, &N, &nClusters, &alpha, pdd, &N, cp, &inc1, &alpha, fij, &inc1);    
+    DGEMV(&chn, &N, &Mdesc, &alpha, bdd, &N, cb, &inc1, &beta, fij, &inc1);
+    DGEMV(&chn, &N, &nClusters, &alpha, pdd, &N, cp, &inc1, &alpha, fij, &inc1);
   }
   else { // single-environment descriptors
-    for (int m=0; m<Mdesc; m++) 
+    for (int m=0; m<Mdesc; m++)
       e += coeff1[1+m]*bd[m];
-      
-    char chn = 'N';    
+
+    char chn = 'N';
     double alpha = 1.0, beta = 0.0;
     int inc1 = 1;
-    DGEMV(&chn, &N, &Mdesc, &alpha, bdd, &N, &coeff1[1], &inc1, &beta, fij, &inc1);    
+    DGEMV(&chn, &N, &Mdesc, &alpha, bdd, &N, &coeff1[1], &inc1, &beta, fij, &inc1);
   }
-  
+
   return e;
 }
 
@@ -1333,7 +1333,7 @@ void EAPOD::base_descriptors(double *basedesc, double *x,
       int *tj = &tmpint[3*Nj]; // Nj
 
       myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);
-      
+
       // many-body descriptors
       peratombase_descriptors(bd, bdd, rij, &tmpmem[3*Nj], ti, tj, Nj);
 
@@ -1342,7 +1342,7 @@ void EAPOD::base_descriptors(double *basedesc, double *x,
       }
 
     }
-  }  
+  }
 }
 
 void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *x,
@@ -1376,7 +1376,7 @@ void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *x,
       int *tj = &tmpint[3*Nj]; // Nj
 
       myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);
-      
+
       // many-body descriptors
       peratombase_descriptors(bd, bdd, rij, &tmpmem[3*Nj], ti, tj, Nj);
 
@@ -1398,7 +1398,7 @@ void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *x,
       }
 
     }
-  }  
+  }
 }
 
 void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *probdesc, double *x,
@@ -1433,7 +1433,7 @@ void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *probd
       int *tj = &tmpint[3*Nj]; // Nj
 
       myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);
-      
+
       // many-body descriptors
       peratombase_descriptors(bd, bdd, rij, &tmpmem[3*Nj], ti, tj, Nj);
 
@@ -1462,7 +1462,7 @@ void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *probd
       }
 
     }
-  }  
+  }
 }
 
 void EAPOD::fourbodydesc23(double *d23, double *d2, double *d3)
@@ -1494,15 +1494,15 @@ void EAPOD::crossdescderiv(double *dd12, double *d1, double *d2, double *dd1, do
       dd12[n + N*i] = d1[ind1[i]]*dd2[n + N*ind2[i]] + dd1[n + N*ind1[i]]*d2[ind2[i]];
 }
 
-void EAPOD::crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1, 
+void EAPOD::crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1,
         double *d2, int *ind1, int *ind2, int n12)
-{  
+{
   for (int m = 0; m < n12; m++) {
     int k1 = ind1[m]; // dd1
     int k2 = ind2[m]; // dd2
-    double c = c12[m];        
-    cb1[k1] += c * d2[k2];        
-    cb2[k2] += c * d1[k1];     
+    double c = c12[m];
+    cb1[k1] += c * d2[k2];
+    cb2[k2] += c * d1[k1];
   }
 }
 
@@ -1550,14 +1550,14 @@ void EAPOD::fourbodydesc(double *d4, double *sumU)
             for (int i3 = i2; i3 < nelements; i3++) {
               double c3 = sumU[idxU + i3 + nelements * j3];
               int kk = p + nabf4 * m + nabf4 * nrbf4 * k;
-              d4[kk] += t12 * c3;              
+              d4[kk] += t12 * c3;
               k += 1;
             }
           }
         }
       }
     }
-  }   
+  }
 }
 
 void EAPOD::fourbodydescderiv(double *d4, double *dd4, double *sumU, double *Ux, double *Uy,
@@ -1587,7 +1587,7 @@ void EAPOD::fourbodydescderiv(double *d4, double *dd4, double *sumU, double *Ux,
           double c2 = c*sumU[j2 + K4*m];
           double t12 = c1*sumU[j2 + K4*m];
           double c3 = sumU[j3 + K4*m];
-          double t13 = c1*c3; 
+          double t13 = c1*c3;
           double t23 = c2*c3;
           int kk = p + nabf4*m;
           int ii = 3*N*(p + nabf4*m);
@@ -1956,7 +1956,7 @@ void EAPOD::radialbasis(double *rbf, double *rbfx, double *rbfy, double *rbfz, d
     for (int i=0; i<inversedegree; i++) {
       int p = besseldegree*nbesselpars + i;
       int nij = n + N*p;
-      double a = pow(dij, (double) (i+1.0));
+      double a = powint(dij, i+1);
 
       rbf[nij] = fcut/a;
 
@@ -2219,7 +2219,7 @@ void EAPOD::snapshots(double *rbf, double *xij, int N)
     double y2 = y*y;
     double y3 = 1.0 - y2*y;
     double y4 = y3*y3 + 1e-6;
-    double y5 = pow(y4, 0.5);
+    double y5 = sqrt(y4);
     double y6 = exp(-1.0/y5);
 
     // Compute the cutoff function
@@ -2493,7 +2493,7 @@ void EAPOD::allocate_temp_memory(int Nj)
   memory->create(bd, Mdesc, "bdd");
   memory->create(bdd, 3*Nj*Mdesc, "bdd");
   memory->create(pd, nClusters, "bdd");
-  memory->create(pdd, 3*Nj*nClusters, "bdd");  
+  memory->create(pdd, 3*Nj*nClusters, "bdd");
 }
 
 void EAPOD::free_temp_memory()
@@ -2684,7 +2684,7 @@ void EAPOD::MatMul(double *c, double *a, double *b, int r1, int c1, int c2)
         c[i + r1*j] += a[i + r1*k] * b[k + c1*j];
 }
 
-void EAPOD::peratomenvironment_descriptors(double *P, double *dP_dR, double *B, double *dB_dR, double *tmp, int elem, int nNeighbors) 
+void EAPOD::peratomenvironment_descriptors(double *P, double *dP_dR, double *B, double *dB_dR, double *tmp, int elem, int nNeighbors)
 {
   double *ProjMat = &Proj[nComponents*Mdesc*elem];
   double *centroids = &Centroids[nComponents*nClusters*elem];
@@ -2693,7 +2693,7 @@ void EAPOD::peratomenvironment_descriptors(double *P, double *dP_dR, double *B,
   double *dD_dpca = &tmp[nComponents + nClusters];
   double *dD_dB = &tmp[nComponents + nClusters + nClusters*nComponents];
   double *dP_dD = &tmp[nComponents + nClusters + nClusters*nComponents + nClusters*Mdesc];
-  double *dP_dB = &tmp[nComponents + nClusters + nClusters*nComponents + nClusters*Mdesc + nClusters*nClusters];      
+  double *dP_dB = &tmp[nComponents + nClusters + nClusters*nComponents + nClusters*Mdesc + nClusters*nClusters];
 
   // calculate principal components
   for (int k = 0; k < nComponents; k++) {
@@ -2731,7 +2731,7 @@ void EAPOD::peratomenvironment_descriptors(double *P, double *dP_dR, double *B,
   char cht = 'T';
   double alpha = 1.0, beta = 0.0;
   DGEMM(&chn, &chn, &nClusters, &Mdesc, &nComponents, &alpha, dD_dpca, &nClusters, ProjMat, &nComponents, &beta, dD_dB, &nClusters);
-  
+
   // calculate dP_dD
   double S1 = 1 / sumD;
   double S2 = sumD * sumD;
@@ -2744,12 +2744,12 @@ void EAPOD::peratomenvironment_descriptors(double *P, double *dP_dR, double *B,
     dP_dD[j + j * nClusters] += S1;
   }
 
-  // calculate dP_dB = dP_dD * dD_dB, which are derivatives of probabilities with respect to local descriptors 
+  // calculate dP_dB = dP_dD * dD_dB, which are derivatives of probabilities with respect to local descriptors
   DGEMM(&chn, &chn, &nClusters, &Mdesc, &nClusters, &alpha, dP_dD, &nClusters, dD_dB, &nClusters, &beta, dP_dB, &nClusters);
-  
-  // calculate dP_dR = dB_dR * dP_dB , which are derivatives of probabilities with respect to atomic coordinates  
+
+  // calculate dP_dR = dB_dR * dP_dB , which are derivatives of probabilities with respect to atomic coordinates
   int N = 3*nNeighbors;
-  DGEMM(&chn, &cht, &N, &nClusters, &Mdesc, &alpha, dB_dR, &N, dP_dB, &nClusters, &beta, dP_dR, &N);  
+  DGEMM(&chn, &cht, &N, &nClusters, &Mdesc, &alpha, dB_dR, &N, dP_dB, &nClusters, &beta, dP_dR, &N);
 }
 
 void EAPOD::init3bodyarray(int *np, int *pq, int *pc, int Pa)
diff --git a/src/ML-POD/eapod.h b/src/ML-POD/eapod.h
index b58114987d..0addbf416f 100644
--- a/src/ML-POD/eapod.h
+++ b/src/ML-POD/eapod.h
@@ -86,7 +86,7 @@ public:
   double rin;
   double rcut;
   int true4BodyDesc;
-  
+
 
   int nelements; // number of elements
   int pbc[3];
@@ -110,8 +110,8 @@ public:
   int nClusters; // number of environment clusters
   int nComponents; // number of principal components
   //int nNeighbors; // numbe of neighbors
-  int Mdesc; // number of base descriptors 
-  
+  int Mdesc; // number of base descriptors
+
   double *Proj; // PCA Projection matrix
   double *Centroids; // centroids of the clusters
   double *bd; // base descriptors
@@ -125,7 +125,7 @@ public:
   int Njmax;
   int nCoeffPerElement; // number of coefficients per element = (nl1 + Mdesc*nClusters)
   int nCoeffAll; // number of coefficients for all elements = (nl1 + Mdesc*nClusters)*nelements
-  int ncoeff;  // number of coefficients in the input file 
+  int ncoeff;  // number of coefficients in the input file
   int ns;      // number of snapshots for radial basis functions
   int nd1, nd2, nd3, nd4, nd5, nd6, nd7, nd;   // number of global descriptors
   int nl1, nl2, nl3, nl4, nl5, nl6, nl7, nl;   // number of local descriptors
@@ -167,19 +167,19 @@ public:
   int read_projection_matrix(std::string proj_file);
   int read_centroids(std::string centroids_file);
 
-  int estimate_temp_memory(int Nj);    
-  void free_temp_memory();  
+  int estimate_temp_memory(int Nj);
+  void free_temp_memory();
   void allocate_temp_memory(int Nj);
 
   //void mknewcoeff();
 
   void mknewcoeff(double *c, int nc);
 
-  void twobodydesc(double *d2, double *rbf, int *tj, int N);  
+  void twobodydesc(double *d2, double *rbf, int *tj, int N);
   void twobodydescderiv(double *d2, double *dd2, double *rbf, double *rbfx,
         double *rbfy, double *rbfz, int *tj, int N);
   void twobody_forces(double *fij, double *cb2, double *rbfx, double *rbfy, double *rbfz, int *tj, int Nj);
-  
+
   void threebodydesc(double *d3, double *sumU);
   void threebodydescderiv(double *dd3, double *sumU, double *Ux, double *Uy, double *Uz,
         int *atomtype, int N);
@@ -189,7 +189,7 @@ public:
   void fourbodydescderiv(double *d4, double *dd4, double *sumU, double *Ux, double *Uy, double *Uz,
       int *atomtype, int N);
   void fourbody_forcecoeff(double *fb4, double *cb4, double *sumU);
-  
+
   void allbody_forces(double *fij, double *forcecoeff, double *rbf, double *rbfx, double *rbfy, double *rbfz,
         double *abf, double *abfx, double *abfy, double *abfz, int *tj, int Nj);
   void allbody_forces(double *fij, double *forcecoeff, double *Ux, double *Uy, double *Uz, int *tj, int Nj);
@@ -204,7 +204,7 @@ public:
         int *ti, int *tj, int Nj);
   double peratombase_coefficients(double *cb, double *bd, int *ti);
   double peratom_environment_descriptors(double *cb, double *bd, double *tm, int *ti);
-  
+
   void peratomenvironment_descriptors(double *P, double *dP_dR, double *B, double *dB_dR, double *tmp, int elem, int nNeighbors);
 
   void base_descriptors(double *basedesc, double *x, int *atomtype, int *alist,
@@ -212,7 +212,7 @@ public:
 
   void descriptors(double *basedesc, double *probdesc, double *x, int *atomtype, int *alist,
           int *jlist, int *pairnumsum, int natom);
-  
+
   double peratomenergyforce(double *fij, double *rij, double *temp, int *ti, int *tj, int Nj);
   double peratomenergyforce2(double *fij, double *rij, double *temp, int *ti, int *tj, int Nj);
 
@@ -226,8 +226,8 @@ public:
 
   void crossdesc(double *d12, double *d1, double *d2, int *ind1, int *ind2, int n12);
   void crossdescderiv(double *dd12, double *d1, double *d2, double *dd1, double *dd2,
-        int *ind1, int *ind2, int n12, int N);  
-  void crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1, 
+        int *ind1, int *ind2, int n12, int N);
+  void crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1,
         double *d2, int *ind1, int *ind2, int n12);
 };
 
diff --git a/src/ML-POD/fitpod_command.cpp b/src/ML-POD/fitpod_command.cpp
index ca1b27e260..930843dc51 100644
--- a/src/ML-POD/fitpod_command.cpp
+++ b/src/ML-POD/fitpod_command.cpp
@@ -64,9 +64,9 @@ void FitPOD::command(int narg, char **arg)
     cent_file = std::string(arg[4]); // centroid input file
   else
     cent_file = "";
-  
-  fastpodptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, cent_file);        
-  
+
+  fastpodptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, cent_file);
+
   desc.nCoeffAll = fastpodptr->nCoeffAll;
   desc.nClusters = fastpodptr->nClusters;
   read_data_files(data_file, fastpodptr->species);
@@ -76,11 +76,11 @@ void FitPOD::command(int narg, char **arg)
   if (desc.nClusters > 1) estimate_memory_neighborstruct(envdata, fastpodptr->pbc, fastpodptr->rcut, fastpodptr->nelements);
   allocate_memory_neighborstruct();
   estimate_memory_fastpod(traindata);
-  estimate_memory_fastpod(testdata);  
+  estimate_memory_fastpod(testdata);
   allocate_memory_descriptorstruct(fastpodptr->nCoeffAll);
 
   if (coeff_file != "") podArrayCopy(desc.c, fastpodptr->coeff, fastpodptr->nCoeffAll);
-  
+
   if (compute_descriptors==0) {
 
     if (((int) envdata.data_path.size() > 1) && (desc.nClusters > 1)) {
@@ -631,7 +631,7 @@ void FitPOD::get_data(datastruct &data, const std::vector<std::string> &species)
   // Group weights have same size as energy.
   memory->create(data.we, n, "fitpod:we");
   memory->create(data.wf, n, "fitpod:wf");
-  
+
   n = data.num_atom_sum;
   memory->create(data.position, 3*n, "fitpod:position");
   memory->create(data.force, 3*n, "fitpod:force");
@@ -811,7 +811,7 @@ void FitPOD::select_data(datastruct &newdata, const datastruct &data)
   // Group weights have same size as energy.
   memory->create(newdata.we, n, "fitpod:we");
   memory->create(newdata.wf, n, "fitpod:wf");
-  
+
   n = newdata.num_atom_sum;
   memory->create(newdata.position, 3*n, "fitpod:newdata_position");
   memory->create(newdata.force, 3*n, "fitpod:newdata_force");
@@ -942,7 +942,7 @@ void FitPOD::read_data_files(const std::string& data_file, const std::vector<std
     compute_descriptors = 1;
     if (comm->me == 0)
       utils::logmesg(lmp, "**************** Begin of Environment Configuration Set ****************\n");
-    get_data(envdata, species);    
+    get_data(envdata, species);
     if (comm->me == 0)
       utils::logmesg(lmp, "**************** End of Environment Configuration Set ****************\n");
     compute_descriptors = tmp;
@@ -993,7 +993,7 @@ void FitPOD::read_data_files(const std::string& data_file, const std::vector<std
   }
   else {
     testdata.data_path = traindata.data_path;
-  }    
+  }
 }
 
 int FitPOD::latticecoords(double *y, int *alist, double *x, double *a1, double *a2, double *a3, double rcut, int *pbc, int nx)
@@ -1121,7 +1121,7 @@ void FitPOD::allocate_memory_neighborstruct()
 }
 
 void FitPOD::allocate_memory_descriptorstruct(int nCoeffAll)
-{  
+{
   memory->create(desc.bd, nb.natom_max*fastpodptr->Mdesc, "fitpod:desc_ld");
   memory->create(desc.pd, nb.natom_max*fastpodptr->nClusters, "fitpod:desc_ld");
   memory->create(desc.gd, nCoeffAll, "fitpod:desc_gd");
@@ -1280,21 +1280,21 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
 {
   if (comm->me == 0)
     utils::logmesg(lmp, "**************** Begin Calculating Environment Descriptor Matrix ****************\n");
-    
-  //printf("number of configurations = %d\n", (int) data.num_atom.size());  
+
+  //printf("number of configurations = %d\n", (int) data.num_atom.size());
 
   int nComponents = fastpodptr->nComponents;
   int Mdesc = fastpodptr->Mdesc;
   int nClusters = fastpodptr->nClusters;
-  int nelements = fastpodptr->nelements;  
+  int nelements = fastpodptr->nelements;
   memory->create(fastpodptr->Centroids, nClusters*nComponents*nelements, "fitpod:centroids");
   memory->create(fastpodptr->Proj, Mdesc*nComponents*nelements, "fitpod:P");
 
   int nAtoms = 0;
-  int nTotalAtoms = 0;  
+  int nTotalAtoms = 0;
   for (int ci=0; ci < (int) data.num_atom.size(); ci++) {
-    if ((ci % comm->nprocs) == comm->me) nAtoms += data.num_atom[ci];    
-    nTotalAtoms += data.num_atom[ci];    
+    if ((ci % comm->nprocs) == comm->me) nAtoms += data.num_atom[ci];
+    nTotalAtoms += data.num_atom[ci];
   }
 
   double *basedescmatrix = (double *) malloc(nAtoms*Mdesc*sizeof(double));
@@ -1314,19 +1314,19 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
   char chu = 'U';
   double alpha = 1.0, beta = 0.0;
 
-  for (int elem=0; elem < nelements; elem++) {    
+  for (int elem=0; elem < nelements; elem++) {
     nElemAtoms[elem] = 0; // number of atoms for this element
   }
   for (int ci=0; ci < (int) data.num_atom.size(); ci++) {
-    if ((ci % comm->nprocs) == comm->me) {        
+    if ((ci % comm->nprocs) == comm->me) {
     int natom = data.num_atom[ci];
     int natom_cumsum = data.num_atom_cumsum[ci];
     int *atomtype = &data.atomtype[natom_cumsum];
-    for (int n=0; n<natom; n++)         
-      nElemAtoms[atomtype[n]-1] += 1;                
+    for (int n=0; n<natom; n++)
+      nElemAtoms[atomtype[n]-1] += 1;
     }
   }
-  
+
   nElemAtomsCumSum[0] = 0;
   for (int elem=0; elem < nelements; elem++) {
     nElemAtomsCumSum[elem+1] = nElemAtomsCumSum[elem] + nElemAtoms[elem];
@@ -1338,7 +1338,7 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
 //   printf("%d %d %d\n",comm->me, nElemAtoms[0], nElemAtoms[1]);
 //   printf("%d %d %d\n",comm->me, nElemAtomsCount[0], nElemAtomsCount[1]);
 //   printf("%d %d %d %d\n",comm->me, nElemAtomsCumSum[0], nElemAtomsCumSum[1], nElemAtomsCumSum[2]);
-  
+
   MPI_Barrier(MPI_COMM_WORLD);
 
 // loop over each configuration in the data set
@@ -1352,45 +1352,45 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
       base_descriptors_fastpod(data, ci);
 
       // basedescmatrix is a Mdesc x nAtoms matrix
-      int natom =  data.num_atom[ci];      
+      int natom =  data.num_atom[ci];
       int natom_cumsum = data.num_atom_cumsum[ci];
       int *atomtype = &data.atomtype[natom_cumsum];
       for (int n=0; n<natom; n++) {
-        int elem = atomtype[n]-1;  // offset by 1 to match the element index in the C++ code    
+        int elem = atomtype[n]-1;  // offset by 1 to match the element index in the C++ code
         nElemAtomsCount[elem] += 1;
         int k = nElemAtomsCumSum[elem] + nElemAtomsCount[elem] - 1;
-        for (int m=0; m<Mdesc; m++)        
-          basedescmatrix[m + Mdesc*k] = desc.bd[n + natom*(m)];      
-      }      
+        for (int m=0; m<Mdesc; m++)
+          basedescmatrix[m + Mdesc*k] = desc.bd[n + natom*(m)];
+      }
     }
   }
-  
+
   MPI_Barrier(MPI_COMM_WORLD);
-  
+
 //   printf("%d %d %d\n",comm->me, nElemAtomsCount[0], nElemAtomsCount[1]);
 //   MPI_Barrier(MPI_COMM_WORLD);
-//   
-//   for (int elem=0; elem < nelements; elem++) {  // loop over each element   
+//
+//   for (int elem=0; elem < nelements; elem++) {  // loop over each element
 //     nAtoms = nElemAtoms[elem];
 //     nTotalAtoms = nAtoms;
-//     
+//
 //     MPI_Barrier(MPI_COMM_WORLD);
 //     MPI_Allreduce(MPI_IN_PLACE, &nTotalAtoms, 1, MPI_INT, MPI_SUM, world);
-// 
+//
 //     double *descmatrix = &basedescmatrix[Mdesc*nElemAtomsCumSum[elem]];
 //     DGEMM(&chn, &cht, &Mdesc, &Mdesc, &nAtoms, &alpha, descmatrix, &Mdesc, descmatrix, &Mdesc, &beta, A, &Mdesc);
-//     
-//     MPI_Barrier(MPI_COMM_WORLD);    
-//     MPI_Allreduce(MPI_IN_PLACE, A, Mdesc*Mdesc, MPI_DOUBLE, MPI_SUM, world);  
-//         
+//
+//     MPI_Barrier(MPI_COMM_WORLD);
+//     MPI_Allreduce(MPI_IN_PLACE, A, Mdesc*Mdesc, MPI_DOUBLE, MPI_SUM, world);
+//
 //     if (comm->me == 0) print_matrix("A", Mdesc, Mdesc, A, Mdesc);
 //   }
-//   
+//
 //   MPI_Barrier(MPI_COMM_WORLD);
 //   error->all(FLERR, "stop for debugging");
-  
+
   int save = 0;
-  for (int elem=0; elem < nelements; elem++) {  // loop over each element   
+  for (int elem=0; elem < nelements; elem++) {  // loop over each element
     nAtoms = nElemAtoms[elem];
     nTotalAtoms = nAtoms;
     MPI_Allreduce(MPI_IN_PLACE, &nTotalAtoms, 1, MPI_INT, MPI_SUM, world);
@@ -1400,11 +1400,11 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
     double *centroids = &fastpodptr->Centroids[nComponents*nClusters*elem];
 
     // Calculate covariance matrix A = basedescmatrix*basedescmatrix'. A is a Mdesc x Mdesc matrix
-    DGEMM(&chn, &cht, &Mdesc, &Mdesc, &nAtoms, &alpha, descmatrix, &Mdesc, descmatrix, &Mdesc, &beta, A, &Mdesc);        
-    MPI_Allreduce(MPI_IN_PLACE, A, Mdesc*Mdesc, MPI_DOUBLE, MPI_SUM, world);  
-        
+    DGEMM(&chn, &cht, &Mdesc, &Mdesc, &nAtoms, &alpha, descmatrix, &Mdesc, descmatrix, &Mdesc, &beta, A, &Mdesc);
+    MPI_Allreduce(MPI_IN_PLACE, A, Mdesc*Mdesc, MPI_DOUBLE, MPI_SUM, world);
+
     //if (comm->me == 0) print_matrix("A", Mdesc, Mdesc, A, Mdesc);
-    
+
     if ((comm->me == 0) && (save==1))
       savematrix2binfile(data.filenametag + "_covariance_matrix_elem" + std::to_string(elem+1) + ".bin", A, Mdesc, Mdesc);
 
@@ -1427,15 +1427,15 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
     // Calculate principal compoment analysis matrix pca = P*descmatrix. pca is a nComponents x nAtoms matrix
     DGEMM(&chn, &chn, &nComponents, &nAtoms, &Mdesc, &alpha, Proj, &nComponents, descmatrix, &Mdesc, &beta, pca, &nComponents);
 
-    // initialize centroids 
-    for (int i = 0; i < nClusters * nComponents; i++) centroids[i] = 0.0;  
-    for (int i=0; i < nAtoms; i++) {    
+    // initialize centroids
+    for (int i = 0; i < nClusters * nComponents; i++) centroids[i] = 0.0;
+    for (int i=0; i < nAtoms; i++) {
       int m = (i*nClusters)/nAtoms;
       for (int j=0; j < nComponents; j++)
         centroids[j + nComponents*m] += pca[j + nComponents*i];
     }
-    
-    MPI_Allreduce(MPI_IN_PLACE, centroids, nClusters * nComponents, MPI_DOUBLE, MPI_SUM, world);  
+
+    MPI_Allreduce(MPI_IN_PLACE, centroids, nClusters * nComponents, MPI_DOUBLE, MPI_SUM, world);
     double fac = ((double) nClusters)/((double) nTotalAtoms);
     for (int i = 0; i < nClusters * nComponents; i++) centroids[i] = centroids[i]*fac;
     //for (int i = 0; i < desc.nClusters * nComponents; i++) printf("centroids[%d] = %f\n", i, centroids[i]);
@@ -1449,21 +1449,21 @@ void FitPOD::environment_cluster_calculation(const datastruct &data)
         savematrix2binfile(data.filenametag + "_eigenvector_matrix_elem" + std::to_string(elem+1) + ".bin", A, Mdesc, Mdesc);
         savematrix2binfile(data.filenametag + "_eigenvalues_elem" + std::to_string(elem+1) + ".bin", b, Mdesc, 1);
       }
-      savematrix2binfile(data.filenametag + "_desc_matrix_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", descmatrix, Mdesc, nAtoms);  
+      savematrix2binfile(data.filenametag + "_desc_matrix_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", descmatrix, Mdesc, nAtoms);
       savematrix2binfile(data.filenametag + "_pca_matrix_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", pca, nComponents, nAtoms);
       saveintmatrix2binfile(data.filenametag + "_cluster_assignments_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", assignments, nAtoms, 1);
     }
     //savematrix2binfile(data.filenametag + "_pca_matrix_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", pca, nComponents, nAtoms);
-    //saveintmatrix2binfile(data.filenametag + "_cluster_assignments_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", assignments, nAtoms, 1);    
-    
+    //saveintmatrix2binfile(data.filenametag + "_cluster_assignments_elem" + std::to_string(elem+1) + "_proc" + std::to_string(comm->me+1) + ".bin", assignments, nAtoms, 1);
+
     MPI_Barrier(MPI_COMM_WORLD);
   }
 
   if (comm->me == 0) {
     savedata2textfile(data.filenametag + "_projection_matrix"  + ".pod", "projection_matrix: {}\n ", fastpodptr->Proj, nComponents*Mdesc*nelements, 1, 1);
-    savedata2textfile(data.filenametag + "_centroids"  + ".pod", "centroids: {} \n", fastpodptr->Centroids, nComponents*nClusters*nelements, 1, 1);  
+    savedata2textfile(data.filenametag + "_centroids"  + ".pod", "centroids: {} \n", fastpodptr->Centroids, nComponents*nClusters*nelements, 1, 1);
   }
-  
+
   free(basedescmatrix);
   free(pca);
   free(A);
@@ -1827,9 +1827,9 @@ void FitPOD::error_analysis(const datastruct &data, double *coeff)
       int natom = data.num_atom[ci];
       int nforce = dim*natom;
 
-      emae += outarray[4 + m*ci]; // sum_c |ePOD_c - eDFT_c|/natom_c 
-      essr += outarray[4 + m*ci]*outarray[4 + m*ci]; // sum_c |ePOD_c - eDFT_c|^2/(natom_c)^2 
-      fmae += outarray[7 + m*ci]*nforce;  // sum_c |fPOD_c - fDFT_c| 
+      emae += outarray[4 + m*ci]; // sum_c |ePOD_c - eDFT_c|/natom_c
+      essr += outarray[4 + m*ci]*outarray[4 + m*ci]; // sum_c |ePOD_c - eDFT_c|^2/(natom_c)^2
+      fmae += outarray[7 + m*ci]*nforce;  // sum_c |fPOD_c - fDFT_c|
       fssr += ssrarray[ci];
       nforceall += nforce;
       ci += 1;
@@ -1844,15 +1844,15 @@ void FitPOD::error_analysis(const datastruct &data, double *coeff)
     errors[3 + 4*q] = sqrt(fssr/nforceall);
 
     nf += nforceall;
-    errors[0] += emae; // sum_c |ePOD_c - eDFT_c|/natom_c 
-    errors[1] += essr; // sum_c |ePOD_c - eDFT_c|^2/(natom_c)^2 
+    errors[0] += emae; // sum_c |ePOD_c - eDFT_c|/natom_c
+    errors[1] += essr; // sum_c |ePOD_c - eDFT_c|^2/(natom_c)^2
     errors[2] += fmae;
     errors[3] += fssr;
   }
 
   if (nc == 0) nc = 1;
   if (nf == 0) nf = 1;
-  errors[0] = errors[0]/nc; // (1/Nc) * sum_c |ePOD_c - eDFT_c|/natom_c 
+  errors[0] = errors[0]/nc; // (1/Nc) * sum_c |ePOD_c - eDFT_c|/natom_c
   errors[1] = sqrt(errors[1]/nc); // sqrt { (1/Nc) *  sum_c |ePOD_c - eDFT_c|^2/(natom_c)^2 }
   errors[2] = errors[2]/nf;
   errors[3] = sqrt(errors[3]/nf);
@@ -2210,13 +2210,13 @@ void FitPOD::saveintmatrix2binfile(std::string filename, int *A, int nrows, int
 
 void FitPOD::savedata2textfile(std::string filename, std::string text, double *A, int n, int m, int dim)
 {
-  if (comm->me == 0) {     
+  if (comm->me == 0) {
     int precision = 15;
-    FILE *fp = fopen(filename.c_str(), "w");    
+    FILE *fp = fopen(filename.c_str(), "w");
     if (dim==1) {
       fmt::print(fp, text, n);
       for (int i = 0; i < n; i++)
-        fmt::print(fp, "{:<10.{}f} \n",  A[i], precision);      
+        fmt::print(fp, "{:<10.{}f} \n",  A[i], precision);
     }
     else if (dim==2) {
       fmt::print(fp, text, n);
diff --git a/src/ML-POD/fitpod_command.h b/src/ML-POD/fitpod_command.h
index c6a2e167c5..8f6ac11177 100644
--- a/src/ML-POD/fitpod_command.h
+++ b/src/ML-POD/fitpod_command.h
@@ -124,14 +124,14 @@ private:
     double *gdd=nullptr; // derivatives of global descriptors and peratom descriptors
     double *A=nullptr;  // least-square matrix for all descriptors
     double *b=nullptr;  // least-square vector for all descriptors
-    double *c=nullptr;  // coefficents of descriptors    
-    int szd = 0;    
+    double *c=nullptr;  // coefficents of descriptors
+    int szd = 0;
     int nCoeffAll = 0; // number of global descriptors
-    int nClusters = 0; // number of environment clusters 
+    int nClusters = 0; // number of environment clusters
   };
 
   int save_descriptors = 0;
-  int compute_descriptors = 0;  
+  int compute_descriptors = 0;
   datastruct traindata;
   datastruct testdata;
   datastruct envdata;
@@ -162,7 +162,7 @@ private:
   void matrix33_multiplication(double *xrot, double *Rmat, double *x, int natom);
   void matrix33_inverse(double *invA, double *A1, double *A2, double *A3);
 
-  double squareDistance(const double *a, const double *b, int DIMENSIONS);  
+  double squareDistance(const double *a, const double *b, int DIMENSIONS);
   void assignPointsToClusters(double *points, double *centroids, int *assignments, int *clusterSizes, int NUM_POINTS, int NUM_CLUSTERS, int DIMENSION);
   void updateCentroids(double *points, double *centroids, int *assignments, int *clusterSizes, int NUM_POINTS, int NUM_CLUSTERS, int DIMENSIONS);
   void KmeansClustering(double *points, double *centroids, int *assignments, int *clusterSizes, int NUM_POINTS, int NUM_CLUSTERS, int DIMENSIONS, int MAX_ITER);
@@ -196,7 +196,7 @@ private:
   void estimate_memory_neighborstruct(const datastruct &data, int *pbc, double rcut, int nelements);
   void allocate_memory_neighborstruct();
   void allocate_memory_descriptorstruct(int nd);
-  void estimate_memory_fastpod(const datastruct &data);  
+  void estimate_memory_fastpod(const datastruct &data);
   void local_descriptors_fastpod(const datastruct &data, int ci);
   void base_descriptors_fastpod(const datastruct &data, int ci);
   void least_squares_matrix(const datastruct &data, int ci);
@@ -204,7 +204,7 @@ private:
   void descriptors_calculation(const datastruct &data);
   void environment_cluster_calculation(const datastruct &data);
   void print_analysis(const datastruct &data, double *outarray, double *errors);
-  void error_analysis(const datastruct &data, double *coeff);  
+  void error_analysis(const datastruct &data, double *coeff);
   double energyforce_calculation_fastpod(double *force, const datastruct &data, int ci);
   void energyforce_calculation(const datastruct &data, double *coeff);
 };
diff --git a/src/ML-POD/pair_pod.cpp b/src/ML-POD/pair_pod.cpp
index 66f720273b..9b79e82416 100644
--- a/src/ML-POD/pair_pod.cpp
+++ b/src/ML-POD/pair_pod.cpp
@@ -54,7 +54,7 @@ PairPOD::PairPOD(LAMMPS *lmp) : Pair(lmp), fastpodptr(nullptr)
   ni = 0;
   nimax = 0;
   nij = 0;
-  nijmax = 0;  
+  nijmax = 0;
   atomBlockSize = 10;
   nAtomBlocks = 0;
 
@@ -81,7 +81,7 @@ PairPOD::PairPOD(LAMMPS *lmp) : Pair(lmp), fastpodptr(nullptr)
   forcecoeff = nullptr;
   Centroids = nullptr;
   Proj = nullptr;
-  bd = nullptr;  
+  bd = nullptr;
   cb = nullptr;
   bdd = nullptr;
   pd = nullptr;
@@ -98,7 +98,7 @@ PairPOD::PairPOD(LAMMPS *lmp) : Pair(lmp), fastpodptr(nullptr)
   ind34r = nullptr;
   ind44l = nullptr;
   ind44r = nullptr;
-  elemindex = nullptr;  
+  elemindex = nullptr;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -148,7 +148,7 @@ PairPOD::~PairPOD()
   memory->destroy(elemindex);
 
   delete fastpodptr;
-  
+
   if (allocated) {
     memory->destroy(setflag);
     memory->destroy(cutsq);
@@ -181,8 +181,8 @@ void PairPOD::compute(int eflag, int vflag)
   double rcutsq = rcut*rcut;
   double evdwl = 0.0;
 
-  int blockMode = 0;  
-  if (blockMode==0) {    
+  int blockMode = 0;
+  if (blockMode==0) {
   for (int ii = 0; ii < inum; ii++) {
     int i = ilist[ii];
     int jnum = numneigh[i];
@@ -194,17 +194,17 @@ void PairPOD::compute(int eflag, int vflag)
       fastpodptr->allocate_temp_memory(nijmax);
     }
 
-    double *rij1 = &fastpodptr->tmpmem[0];    
-    double *fij1 = &fastpodptr->tmpmem[3*nijmax];   
-    double *tmp = &fastpodptr->tmpmem[6*nijmax]; 
-    int *ai1 = &fastpodptr->tmpint[0];      
-    int *aj1 = &fastpodptr->tmpint[nijmax]; 
+    double *rij1 = &fastpodptr->tmpmem[0];
+    double *fij1 = &fastpodptr->tmpmem[3*nijmax];
+    double *tmp = &fastpodptr->tmpmem[6*nijmax];
+    int *ai1 = &fastpodptr->tmpint[0];
+    int *aj1 = &fastpodptr->tmpint[nijmax];
     int *ti1 = &fastpodptr->tmpint[2*nijmax];
-    int *tj1 = &fastpodptr->tmpint[3*nijmax];    
+    int *tj1 = &fastpodptr->tmpint[3*nijmax];
     lammpsNeighborList(rij1, ai1, aj1, ti1, tj1, x, firstneigh, type, map, numneigh, rcutsq, i);
-    
+
     evdwl = fastpodptr->peratomenergyforce2(fij1, rij1, tmp, ti1, tj1, nij);
-            
+
     // tally atomic energy to global energy
     ev_tally_full(i,2.0*evdwl,0.0,0.0,0.0,0.0,0.0);
 
@@ -219,34 +219,34 @@ void PairPOD::compute(int eflag, int vflag)
                     fij1[0 + 3*jj],fij1[1 + 3*jj],fij1[2 + 3*jj],
                     -rij1[0 + 3*jj], -rij1[1 + 3*jj], -rij1[2 + 3*jj]);
       }
-    }            
-  }  
+    }
+  }
   }
   else if (blockMode == 1) {
  // determine the number of atom blocks and divide atoms into blocks
   nAtomBlocks = calculateNumberOfIntervals(inum, atomBlockSize);
-  if (nAtomBlocks > 100) nAtomBlocks = 100; 
+  if (nAtomBlocks > 100) nAtomBlocks = 100;
   divideInterval(atomBlocks, inum, nAtomBlocks);
 
   int nmax = 0;
-  for (int block =0; block<nAtomBlocks; block++) {    
-    int n = atomBlocks[block+1] - atomBlocks[block]; 
+  for (int block =0; block<nAtomBlocks; block++) {
+    int n = atomBlocks[block+1] - atomBlocks[block];
     if (nmax < n) nmax = n;
   }
-  grow_atoms(nmax); // reallocate memory only if necessary  
-  
+  grow_atoms(nmax); // reallocate memory only if necessary
+
   for (int block =0; block<nAtomBlocks; block++) {
     int gi1 = atomBlocks[block]-1;
     int gi2 = atomBlocks[block+1]-1;
     ni = gi2 - gi1; // total number of atoms in the current atom block
-        
-    NeighborCount(x, firstneigh, ilist, numneigh, rcutsq, gi1, gi2);                    
-    nij = numberOfNeighbors(); // total number of pairs (i,j) in the current atom block        
+
+    NeighborCount(x, firstneigh, ilist, numneigh, rcutsq, gi1, gi2);
+    nij = numberOfNeighbors(); // total number of pairs (i,j) in the current atom block
     grow_pairs(nij); // reallocate memory only if necessary
 
     // get neighbor list for atoms i in the current atom block
-    NeighborList(x, firstneigh, type, map, ilist, numneigh, rcutsq, gi1, gi2);       
-    
+    NeighborList(x, firstneigh, type, map, ilist, numneigh, rcutsq, gi1, gi2);
+
     // compute atomic energy and force for the current atom block
     blockatomenergyforce(ei, fij, ni, nij);
 
@@ -258,11 +258,11 @@ void PairPOD::compute(int eflag, int vflag)
 
     // tally atomic stress
     if (vflag) tallystress(fij, rij, ai, aj, nlocal, nij);
-        
+
     //savedatafordebugging();
-  }    
   }
-  
+  }
+
   if (vflag_fdotr) virial_fdotr_compute();
 }
 
@@ -291,24 +291,24 @@ void PairPOD::coeff(int narg, char **arg)
   allocated = 1;
 
   if (narg < 7) utils::missing_cmd_args(FLERR, "pair_coeff", error);
-  
+
   std::string pod_file = std::string(arg[2]);      // pod input file
   std::string coeff_file = std::string(arg[3]);    // coefficient input file
   std::string proj_file = std::string(arg[4]);     // projection matrix file
   std::string centroid_file = std::string(arg[5]); // centroid matrix file
-  map_element2type(narg - 6, arg + 6);    
-  
+  map_element2type(narg - 6, arg + 6);
+
   delete fastpodptr;
   fastpodptr = new EAPOD(lmp, pod_file, coeff_file, proj_file, centroid_file);
 
   if (fastpodptr->nClusters > 1) {
-    if (proj_file == "") error->all(FLERR,"The projection file name can not be empty when the number of clusters is greater than 1.");    
+    if (proj_file == "") error->all(FLERR,"The projection file name can not be empty when the number of clusters is greater than 1.");
     if (centroid_file == "") error->all(FLERR,"The centroids file name can not be empty when the number of clusters is greater than 1.");
   }
-  
+
   copy_data_from_pod_class();
   rcut = fastpodptr->rcut;
-  
+
   memory->destroy(fastpodptr->tmpmem);
   memory->destroy(fastpodptr->tmpint);
 
@@ -361,7 +361,7 @@ double PairPOD::memory_usage()
   return bytes;
 }
 
-void PairPOD::lammpsNeighborList(double *rij1, int *ai1, int *aj1, int *ti1, int *tj1, 
+void PairPOD::lammpsNeighborList(double *rij1, int *ai1, int *aj1, int *ti1, int *tj1,
                                double **x, int **firstneigh, int *atomtypes, int *map,
                                int *numneigh, double rcutsq, int gi)
 {
@@ -389,12 +389,12 @@ void PairPOD::lammpsNeighborList(double *rij1, int *ai1, int *aj1, int *ti1, int
 }
 
 void PairPOD::NeighborCount(double **x, int **firstneigh, int *ilist, int *numneigh, double rcutsq, int gi1, int gi2)
-{  
+{
   for (int i=0; i<ni; i++) {
     int gi = ilist[gi1 + i];
-    double xi0 = x[gi][0];    
-    double xi1 = x[gi][1];    
-    double xi2 = x[gi][2];        
+    double xi0 = x[gi][0];
+    double xi1 = x[gi][1];
+    double xi2 = x[gi][2];
     int m = numneigh[gi];
     int n = 0;
     for (int l = 0; l < m; l++) {           // loop over each atom around atom i
@@ -403,35 +403,35 @@ void PairPOD::NeighborCount(double **x, int **firstneigh, int *ilist, int *numne
       double dely = x[gj][1] - xi1;    // xj - xi
       double delz = x[gj][2] - xi2;    // xj - xi
       double rsq = delx * delx + dely * dely + delz * delz;
-      if (rsq < rcutsq && rsq > 1e-20) n++;      
+      if (rsq < rcutsq && rsq > 1e-20) n++;
     }
     numij[1+i] = n;
-  }  
+  }
 }
 
 int PairPOD::numberOfNeighbors()
 {
   int n = 0;
   for (int i=1; i<=ni; i++) {
-    n += numij[i];  
-    numij[i] += numij[i-1];   
+    n += numij[i];
+    numij[i] += numij[i-1];
   }
   return n;
 }
 
 void PairPOD::NeighborList(double **x, int **firstneigh, int *atomtypes, int *map,
                                int *ilist, int *numneigh, double rcutsq, int gi1, int gi2)
-{  
+{
   for (int i=0; i<ni; i++) {
     int gi = ilist[gi1 + i];
-    double xi0 = x[gi][0];    
-    double xi1 = x[gi][1];    
-    double xi2 = x[gi][2];    
+    double xi0 = x[gi][0];
+    double xi1 = x[gi][1];
+    double xi2 = x[gi][2];
     int itype = map[atomtypes[gi]] + 1;
-    typeai[i] = itype;    
+    typeai[i] = itype;
     int m = numneigh[gi];
-    int nij0 = numij[i];    
-    int k = 0;    
+    int nij0 = numij[i];
+    int k = 0;
     for (int l = 0; l < m; l++) {           // loop over each atom around atom i
       int gj = firstneigh[gi][l];           // atom j
       double delx = x[gj][0] - xi0;    // xj - xi
@@ -451,7 +451,7 @@ void PairPOD::NeighborList(double **x, int **firstneigh, int *atomtypes, int *ma
         k++;
       }
     }
-  }  
+  }
 }
 
 void PairPOD::tallyforce(double **force, double *fij,  int *ai, int *aj, int N)
@@ -471,11 +471,11 @@ void PairPOD::tallyforce(double **force, double *fij,  int *ai, int *aj, int N)
 
 void PairPOD::tallyenergy(double *ei, int istart, int Ni)
 {
-  if (eflag_global)       
-    for (int k = 0; k < Ni; k++) eng_vdwl += ei[k];      
+  if (eflag_global)
+    for (int k = 0; k < Ni; k++) eng_vdwl += ei[k];
 
-  if (eflag_atom) 
-    for (int k = 0; k < Ni; k++) eatom[istart+k] += ei[k];            
+  if (eflag_atom)
+    for (int k = 0; k < Ni; k++) eatom[istart+k] += ei[k];
 }
 
 /* ----------------------------------------------------------------------
@@ -487,14 +487,14 @@ void PairPOD::tallystress(double *fij, double *rij, int *ai, int *aj, int nlocal
 {
   double v[6];
 
-  if (vflag_global) {      
+  if (vflag_global) {
     for (int k = 0; k < N; k++) {
       int k3 = 3*k;
       v[0] = -rij[0 + k3]*fij[0 + k3]; // delx*fx;
       v[1] = -rij[1 + k3]*fij[1 + k3]; // dely*fy;
       v[2] = -rij[2 + k3]*fij[2 + k3]; // delz*fz;
       v[3] = -rij[0 + k3]*fij[1 + k3]; // delx*fy;
-      v[4] = -rij[0 + k3]*fij[2 + k3]; // delx*fz;  
+      v[4] = -rij[0 + k3]*fij[2 + k3]; // delx*fz;
       v[5] = -rij[1 + k3]*fij[2 + k3]; // dely*fz;
       virial[0] += v[0];
       virial[1] += v[1];
@@ -502,7 +502,7 @@ void PairPOD::tallystress(double *fij, double *rij, int *ai, int *aj, int nlocal
       virial[3] += v[3];
       virial[4] += v[4];
       virial[5] += v[5];
-    }      
+    }
   }
 
   if (vflag_atom) {
@@ -514,7 +514,7 @@ void PairPOD::tallystress(double *fij, double *rij, int *ai, int *aj, int nlocal
       v[1] = -rij[1 + k3]*fij[1 + k3]; // dely*fy;
       v[2] = -rij[2 + k3]*fij[2 + k3]; // delz*fz;
       v[3] = -rij[0 + k3]*fij[1 + k3]; // delx*fy;
-      v[4] = -rij[0 + k3]*fij[2 + k3]; // delx*fz;  
+      v[4] = -rij[0 + k3]*fij[2 + k3]; // delx*fz;
       v[5] = -rij[1 + k3]*fij[2 + k3]; // dely*fz;
 
       if (i < nlocal) {
@@ -537,9 +537,9 @@ void PairPOD::tallystress(double *fij, double *rij, int *ai, int *aj, int nlocal
   }
 }
 
-void PairPOD::copy_data_from_pod_class() 
+void PairPOD::copy_data_from_pod_class()
 {
-  nelements = fastpodptr->nelements; // number of elements 
+  nelements = fastpodptr->nelements; // number of elements
   onebody = fastpodptr->onebody;   // one-body descriptors
   besseldegree = fastpodptr->besseldegree; // degree of Bessel functions
   inversedegree = fastpodptr->inversedegree; // degree of inverse functions
@@ -560,13 +560,13 @@ void PairPOD::copy_data_from_pod_class()
   nrbf4 = fastpodptr->nrbf4;
   nrbfmax = fastpodptr->nrbfmax; // number of radial basis functions
   nabf3 = fastpodptr->nabf3;     // number of three-body angular basis functions
-  nabf4 = fastpodptr->nabf4;     // number of four-body angular basis functions  
+  nabf4 = fastpodptr->nabf4;     // number of four-body angular basis functions
   K3 = fastpodptr->K3;           // number of three-body monomials
   K4 = fastpodptr->K4;           // number of four-body monomials
   Q4 = fastpodptr->Q4;           // number of four-body monomial coefficients
   nClusters = fastpodptr->nClusters; // number of environment clusters
   nComponents = fastpodptr->nComponents; // number of principal components
-  Mdesc = fastpodptr->Mdesc; // number of base descriptors 
+  Mdesc = fastpodptr->Mdesc; // number of base descriptors
 
   rin = fastpodptr->rin;
   rcut = fastpodptr->rcut;
@@ -574,13 +574,13 @@ void PairPOD::copy_data_from_pod_class()
   besselparams[0] = fastpodptr->besselparams[0];
   besselparams[1] = fastpodptr->besselparams[1];
   besselparams[2] = fastpodptr->besselparams[2];
-  
+
   memory->create(abftm, 4*K3, "abftm");
   memory->create(elemindex, nelements*nelements, "elemindex");
   for (int i=0; i<nelements*nelements; i++) elemindex[i] = fastpodptr->elemindex[i];
 
   memory->create(Phi, ns * ns, "pair_pod:Phi");
-  for (int i=0; i<ns*ns; i++)    
+  for (int i=0; i<ns*ns; i++)
     Phi[i] = fastpodptr->Phi[i];
 
   memory->create(coefficients, nCoeffPerElement * nelements, "pair_pod:coefficients");
@@ -596,7 +596,7 @@ void PairPOD::copy_data_from_pod_class()
     for (int i=0; i<nClusters * nComponents * nelements; i++)
       Centroids[i] = fastpodptr->Centroids[i];
   }
-  
+
   memory->create(pn3, nabf3+1, "pn3"); // array stores the number of monomials for each degree
   memory->create(pq3, K3*2, "pq3"); // array needed for the recursive computation of the angular basis functions
   memory->create(pc3, K3, "pc3");   // array needed for the computation of the three-body descriptors
@@ -608,8 +608,8 @@ void PairPOD::copy_data_from_pod_class()
   for (int i=0; i<K3*2; i++) pq3[i] = fastpodptr->pq3[i];
   for (int i=0; i<nabf4+1; i++) pa4[i] = fastpodptr->pa4[i];
   for (int i=0; i<Q4*3; i++) pb4[i] = fastpodptr->pb4[i];
-  for (int i=0; i<Q4; i++) pc4[i] = fastpodptr->pc4[i];  
-  
+  for (int i=0; i<Q4; i++) pc4[i] = fastpodptr->pc4[i];
+
   memory->create(ind33l, nl33, "pair_pod:ind33l");
   memory->create(ind33r, nl33, "pair_pod:ind33r");
   memory->create(ind34l, nl34, "pair_pod:ind34l");
@@ -621,7 +621,7 @@ void PairPOD::copy_data_from_pod_class()
   for (int i=0; i<nl34; i++) ind34l[i] = fastpodptr->ind34l[i];
   for (int i=0; i<nl34; i++) ind34r[i] = fastpodptr->ind34r[i];
   for (int i=0; i<nl44; i++) ind44l[i] = fastpodptr->ind44l[i];
-  for (int i=0; i<nl44; i++) ind44r[i] = fastpodptr->ind44r[i];  
+  for (int i=0; i<nl44; i++) ind44r[i] = fastpodptr->ind44r[i];
 }
 
 void PairPOD::grow_atoms(int Ni)
@@ -639,13 +639,13 @@ void PairPOD::grow_atoms(int Ni)
     memory->create(ei, nimax, "pair_pod:ei");
     memory->create(typeai, nimax, "pair_pod:typeai");
     memory->create(numij, nimax+1, "pair_pod:typeai");
-    int n = nimax * nelements * K3 * nrbfmax;    
+    int n = nimax * nelements * K3 * nrbfmax;
     memory->create(sumU, n , "pair_pod:sumU");
     memory->create(forcecoeff, n , "pair_pod:forcecoeff");
     memory->create(bd, nimax * Mdesc, "pair_pod:bd");
     memory->create(cb, nimax * Mdesc, "pair_pod:bd");
-    if (nClusters > 1) memory->create(pd, nimax * (1 + nComponents + 3*nClusters), "pair_pod:pd");    
-        
+    if (nClusters > 1) memory->create(pd, nimax * (1 + nComponents + 3*nClusters), "pair_pod:pd");
+
     for (int i=0; i<=nimax; i++) numij[i] = 0;
   }
 }
@@ -667,12 +667,12 @@ void PairPOD::grow_pairs(int Nij)
     memory->destroy(abf);
     memory->destroy(abfx);
     memory->destroy(abfy);
-    memory->destroy(abfz);    
+    memory->destroy(abfz);
 //     memory->destroy(bdd);
-//     memory->destroy(pdd);        
+//     memory->destroy(pdd);
     nijmax = Nij;
     memory->create(rij, 3 * nijmax,  "pair_pod:r_ij");
-    memory->create(fij, 3 * nijmax,  "pair_pod:f_ij");  
+    memory->create(fij, 3 * nijmax,  "pair_pod:f_ij");
     memory->create(idxi, nijmax, "pair_pod:idxi");
     memory->create(ai, nijmax, "pair_pod:ai");
     memory->create(aj, nijmax, "pair_pod:aj");
@@ -686,13 +686,13 @@ void PairPOD::grow_pairs(int Nij)
     memory->create(abf, nijmax * kmax, "pair_pod:abf");
     memory->create(abfx, nijmax * kmax, "pair_pod:abfx");
     memory->create(abfy, nijmax * kmax, "pair_pod:abfy");
-    memory->create(abfz, nijmax * kmax, "pair_pod:abfz");  
+    memory->create(abfz, nijmax * kmax, "pair_pod:abfz");
 //     memory->create(bdd, 3 * nijmax  * Mdesc, "pair_pod:bdd");
-//     memory->create(pdd, 3 * nijmax * nClusters, "pair_pod:pdd");      
+//     memory->create(pdd, 3 * nijmax * nClusters, "pair_pod:pdd");
   }
 }
 
-void PairPOD::divideInterval(int *intervals, int N, int M) 
+void PairPOD::divideInterval(int *intervals, int N, int M)
 {
   int intervalSize = N / M; // Basic size of each interval
   int remainder = N % M;    // Remainder to distribute
@@ -702,10 +702,10 @@ void PairPOD::divideInterval(int *intervals, int N, int M)
     if (remainder > 0) {
       remainder--;
     }
-  }  
+  }
 }
 
-int PairPOD::calculateNumberOfIntervals(int N, int intervalSize) 
+int PairPOD::calculateNumberOfIntervals(int N, int intervalSize)
 {
   if (intervalSize <= 0) {
     printf("Interval size must be a positive integer.\n");
@@ -805,12 +805,12 @@ void PairPOD::radialbasis(double *rbft, double *rbftx, double *rbfty, double *rb
       rbfty[idxni] = drbftdr*dr2;
       rbftz[idxni] = drbftdr*dr3;
     }
-  
+
     // Calculate fcut/dij and dfcut/dij
     f1 = fcut/dij;
     for (int i=0; i<inversedegree; i++) {
       int p = besseldegree*nbesselpars + i;
-      //int idxni = n + Nij*p;      
+      //int idxni = n + Nij*p;
       int idxni = p + ns*n;
       double a = powint(dij, i+1);
 
@@ -824,7 +824,7 @@ void PairPOD::radialbasis(double *rbft, double *rbftx, double *rbfty, double *rb
   }
 }
 
-void matrixMultiply(double *Phi, double *rbft, double *rbf, int nrbfmax, int ns, int Nij) 
+void matrixMultiply(double *Phi, double *rbft, double *rbf, int nrbfmax, int ns, int Nij)
 {
   for (int idx=0; idx<nrbfmax*Nij; idx++)  {
     int j = idx / nrbfmax;  // pair index index
@@ -834,20 +834,20 @@ void matrixMultiply(double *Phi, double *rbft, double *rbf, int nrbfmax, int ns,
         sum += rbft[k + ns*j] * Phi[k + ns*i];  // Manually calculate the 1D index
     }
     rbf[i + nrbfmax*j] = sum;  // Manually calculate the 1D index for c
-  }        
+  }
 }
 
 void PairPOD::orthogonalradialbasis(int Nij)
 {
   radialbasis(abf, abfx, abfy, abfz, rij, Nij);
-  matrixMultiply(Phi, abf, rbf, nrbfmax, ns,  Nij); 
-  matrixMultiply(Phi, abfx, rbfx, nrbfmax, ns,  Nij); 
-  matrixMultiply(Phi, abfy, rbfy, nrbfmax, ns,  Nij); 
-  matrixMultiply(Phi, abfz, rbfz, nrbfmax, ns,  Nij); 
+  matrixMultiply(Phi, abf, rbf, nrbfmax, ns,  Nij);
+  matrixMultiply(Phi, abfx, rbfx, nrbfmax, ns,  Nij);
+  matrixMultiply(Phi, abfy, rbfy, nrbfmax, ns,  Nij);
+  matrixMultiply(Phi, abfz, rbfz, nrbfmax, ns,  Nij);
 }
 
 void PairPOD::angularbasis(double *tm, double *tmu, double *tmv, double *tmw, int N)
-{  
+{
   // Initialize first angular basis function and its derivatives
   tm[0] = 1.0;
   tmu[0] = 0.0;
@@ -901,12 +901,12 @@ void PairPOD::angularbasis(double *tm, double *tmu, double *tmv, double *tmw, in
       int m = pq3[n]-1;
       int d = pq3[n + K3];
       int mj = m + K3*j;
-      double tmm = abf[mj]; 
+      double tmm = abf[mj];
       double tmum = abfx[mj];
       double tmvm = abfy[mj];
       double tmwm = abfz[mj];
 
-      double tmn, tmun, tmvn, tmwn;      
+      double tmn, tmun, tmvn, tmwn;
       // Calculate angular basis function and its derivatives using recursion relation
       if (d==1) {
         tmn = tmm*u;
@@ -932,16 +932,16 @@ void PairPOD::angularbasis(double *tm, double *tmu, double *tmv, double *tmw, in
       abfy[idxa] = tmvn;
       abfz[idxa] = tmwn;
     }
-    
+
     for (int n=1; n<K3; n++) {
-      double tmun, tmvn, tmwn;    
+      double tmun, tmvn, tmwn;
       idxa = n + K3*j;
       tmun = abfx[idxa];
       tmvn = abfy[idxa];
       tmwn = abfz[idxa];
       abfx[idxa] = tmun*dudx + tmvn*dvdx + tmwn*dwdx;
       abfy[idxa] = tmun*dudy + tmvn*dvdy + tmwn*dwdy;
-      abfz[idxa] = tmun*dudz + tmvn*dvdz + tmwn*dwdz;      
+      abfz[idxa] = tmun*dudz + tmvn*dvdz + tmwn*dwdz;
     }
   }
 }
@@ -958,7 +958,7 @@ void PairPOD::radialangularsum(int Ni, int Nij)
     int m = temp % nrbf3;
     int n = temp / nrbf3;
     int ia = k + K3 * n;
-    int ib = m + nrbfmax * n;      
+    int ib = m + nrbfmax * n;
 
       // Update sumU with atomtype adjustment
     int tn = tj[n] - 1; // offset the atom type by 1, since atomtype is 1-based
@@ -985,10 +985,10 @@ void PairPOD::radialangularsum2(int Ni, int Nij)
     for (int j=0; j<nj; j++) {
       int n = start + j;
       int ia = k + K3 * n;
-      int ib = m + nrbfmax * n;            
+      int ib = m + nrbfmax * n;
       int tn = tj[n] - 1; // offset the atom type by 1, since atomtype is 1-based
-      sum[tn] += rbf[ib] * abf[ia];    
-    }        
+      sum[tn] += rbf[ib] * abf[ia];
+    }
     for (int e=0; e<nelements; e++) sumU[e + kmi] = sum[e];
   }
 }
@@ -1047,7 +1047,7 @@ void PairPOD::twobody_forces(double *fij, double *cb2, int Ni, int Nij)
     int m = idx % nrbf2; // Recalculate n
 
     int i2 = m + nrbfmax * n; // Index of the radial basis function for atom n and RBF m
-    int i1 = 3*n; 
+    int i1 = 3*n;
     double c = cb2[idxi[n] + Ni*m + Ni*nrbf2*(tj[n] - 1)];
     fij[0 + i1] += c*rbfx[i2]; // Add the derivative with respect to x to the corresponding descriptor derivative
     fij[1 + i1] += c*rbfy[i2]; // Add the derivative with respect to y to the corresponding descriptor derivative
@@ -1060,8 +1060,8 @@ void PairPOD::threebodydesc(double *d3, int Ni)
   int totalIterations = nrbf3 * Ni;
   for (int idx = 0; idx < totalIterations; idx++) {
     int m = idx % nrbf3;
-    int i = idx / nrbf3;    
-    for (int p = 0; p < nabf3; p++) {   
+    int i = idx / nrbf3;
+    for (int p = 0; p < nabf3; p++) {
       int n1 = pn3[p];
       int n2 = pn3[p + 1];
       int nn = n2 - n1;
@@ -1101,21 +1101,21 @@ void PairPOD::threebodydescderiv(double *dd3, int Ni, int Nij)
         double tmp1 = 0;
         double tmp2 = 0;
         double tmp3 = 0;
-        for (int q = 0; q < nn; q++) {                  
+        for (int q = 0; q < nn; q++) {
           int idxNQ = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU
           double t1 = pc3[idxNQ] * sumU[idxNQ + idxU];
-          double f = 2.0 * t1;          
-          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf          
-          double abfA = abf[idxA];  
+          double f = 2.0 * t1;
+          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf
+          double abfA = abf[idxA];
 
           // Use the pre-computed indices to update dd3
           tmp1 += f * (abfx[idxA] * rbfBase + rbfxBase * abfA);
           tmp2 += f * (abfy[idxA] * rbfBase + rbfyBase * abfA);
-          tmp3 += f * (abfz[idxA] * rbfBase + rbfzBase * abfA);          
+          tmp3 += f * (abfz[idxA] * rbfBase + rbfzBase * abfA);
         }
         dd3[baseIdx]     = tmp1;
         dd3[baseIdx + 1] = tmp2;
-        dd3[baseIdx + 2] = tmp3;                  
+        dd3[baseIdx + 2] = tmp3;
       }
     }
   }
@@ -1137,8 +1137,8 @@ void PairPOD::threebodydescderiv(double *dd3, int Ni, int Nij)
         for (int q = 0; q < nn; q++) {
           int idxNQ = n1 + q;  // Combine n1 and q into a single index
           int idxU = nelements * idxNQ + nelements * K3 * m + nelements*K3*nrbf3*idxi[j];
-          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf          
-          double abfA = abf[idxA];   
+          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf
+          double abfA = abf[idxA];
           double abfxA = abfx[idxA];
           double abfyA = abfy[idxA];
           double abfzA = abfz[idxA];
@@ -1147,12 +1147,12 @@ void PairPOD::threebodydescderiv(double *dd3, int Ni, int Nij)
             int i2 = tj[j] - 1;
             int k = elemindex[i2 + nelements * i1];
             double f = (i1 == i2) ? 2.0 * t1 : t1;
-            int ii = jmp + N3 * k;                     
+            int ii = jmp + N3 * k;
 
             // Update dd3
             dd3[0 + ii] += f * (abfxA * rbfBase + rbfxBase * abfA);
             dd3[1 + ii] += f * (abfyA * rbfBase + rbfyBase * abfA);
-            dd3[2 + ii] += f * (abfzA * rbfBase + rbfzBase * abfA);          
+            dd3[2 + ii] += f * (abfzA * rbfBase + rbfzBase * abfA);
           }
         }
       }
@@ -1171,32 +1171,32 @@ void PairPOD::threebody_forces(double *fij, double *cb3, int Ni, int Nij)
       double rbfBase = rbf[idxR];
       double rbfxBase = rbfx[idxR];
       double rbfyBase = rbfy[idxR];
-      double rbfzBase = rbfz[idxR];            
+      double rbfzBase = rbfz[idxR];
       double fx = 0;
       double fy = 0;
-      double fz = 0;      
+      double fz = 0;
       for (int p = 0; p < nabf3; p++) {
         double c3 = 2.0 * cb3[idxi[j] + Ni*p + Ni*nabf3*m]; // Ni*nabf3*nrbf3
         int n1 = pn3[p];
         int n2 = pn3[p + 1];
-        int nn = n2 - n1;        
+        int nn = n2 - n1;
         int idxU = K3 * m + K3*nrbf3*idxi[j]; // K3*nrbf3*Ni
-        for (int q = 0; q < nn; q++) {                  
+        for (int q = 0; q < nn; q++) {
           int idxNQ = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU
-          double f = c3 * pc3[idxNQ] * sumU[idxNQ + idxU]; // K3*nrbf3*Ni         
-          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf          
-          double abfA = abf[idxA];  
+          double f = c3 * pc3[idxNQ] * sumU[idxNQ + idxU]; // K3*nrbf3*Ni
+          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf
+          double abfA = abf[idxA];
 
           // Use the pre-computed indices to update dd3
           fx += f * (abfx[idxA] * rbfBase + rbfxBase * abfA);
           fy += f * (abfy[idxA] * rbfBase + rbfyBase * abfA);
-          fz += f * (abfz[idxA] * rbfBase + rbfzBase * abfA);          
+          fz += f * (abfz[idxA] * rbfBase + rbfzBase * abfA);
         }
       }
-      int baseIdx = 3 * j; 
+      int baseIdx = 3 * j;
       fij[baseIdx]     += fx;
       fij[baseIdx + 1] += fy;
-      fij[baseIdx + 2] += fz;                        
+      fij[baseIdx + 2] += fz;
     }
   }
   else {
@@ -1205,14 +1205,14 @@ void PairPOD::threebody_forces(double *fij, double *cb3, int Ni, int Nij)
       int j = idx / nrbf3;  // Derive the original j value
       int m = idx % nrbf3;  // Derive the original m value
       int idxR = m + nrbfmax * j;  // Pre-compute the index for rbf
-      int i2 = tj[j] - 1;   
+      int i2 = tj[j] - 1;
       double rbfBase = rbf[idxR];
       double rbfxBase = rbfx[idxR];
       double rbfyBase = rbfy[idxR];
       double rbfzBase = rbfz[idxR];
       double fx = 0;
       double fy = 0;
-      double fz = 0;            
+      double fz = 0;
       for (int p = 0; p < nabf3; p++) {
         int n1 = pn3[p];
         int n2 = pn3[p + 1];
@@ -1221,26 +1221,26 @@ void PairPOD::threebody_forces(double *fij, double *cb3, int Ni, int Nij)
         for (int q = 0; q < nn; q++) {
           int idxNQ = n1 + q;  // Combine n1 and q into a single index
           int idxU = nelements * idxNQ + nelements * K3 * m + nelements*K3*nrbf3*idxi[j];
-          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf          
-          double abfA = abf[idxA];   
+          int idxA = idxNQ + K3 * j;  // Pre-compute the index for abf
+          double abfA = abf[idxA];
           double abfxA = abfx[idxA];
           double abfyA = abfy[idxA];
           double abfzA = abfz[idxA];
           for (int i1 = 0; i1 < nelements; i1++) {
-            int k = elemindex[i2 + nelements * i1];       
+            int k = elemindex[i2 + nelements * i1];
             double c3 = cb3[jmp + N3*k]; // Ni *  nabf3 * nrbf3 * k
-            double t1 = c3 * pc3[idxNQ] * sumU[i1 + idxU]; // nelements*K3*nrbf3*Ni                          
-            double f = (i1 == i2) ? 2.0 * t1 : t1;   // nelements*(nelements+1)/2*K3*nrbf3*Ni         
-            fx += f * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij 
+            double t1 = c3 * pc3[idxNQ] * sumU[i1 + idxU]; // nelements*K3*nrbf3*Ni
+            double f = (i1 == i2) ? 2.0 * t1 : t1;   // nelements*(nelements+1)/2*K3*nrbf3*Ni
+            fx += f * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij
             fy += f * (abfyA * rbfBase + rbfyBase * abfA);
-            fz += f * (abfzA * rbfBase + rbfzBase * abfA);          
+            fz += f * (abfzA * rbfBase + rbfzBase * abfA);
           }
         }
       }
-      int baseIdx = 3 * j; 
+      int baseIdx = 3 * j;
       fij[baseIdx]     += fx;
       fij[baseIdx + 1] += fy;
-      fij[baseIdx + 2] += fz;                          
+      fij[baseIdx + 2] += fz;
     }
   }
 }
@@ -1256,17 +1256,17 @@ void PairPOD::threebody_forcecoeff(double *fb3, double *cb3, int Ni)
         double c3 = 2.0 * cb3[i + Ni*p + Ni*nabf3*m]; // Ni*nabf3*nrbf3
         int n1 = pn3[p];
         int n2 = pn3[p + 1];
-        int nn = n2 - n1;        
+        int nn = n2 - n1;
         int idxU = K3 * m + K3*nrbf3*i; // K3*nrbf3*Ni
-        for (int q = 0; q < nn; q++) {                  
+        for (int q = 0; q < nn; q++) {
           int k = n1 + q;  // Combine n1 and q into a single index for pc3 and sumU
-          fb3[k + idxU] += c3 * pc3[k] * sumU[k + idxU]; // K3*nrbf3*Ni          
+          fb3[k + idxU] += c3 * pc3[k] * sumU[k + idxU]; // K3*nrbf3*Ni
         }
       }
     }
   }
   else {
-    int N3 = Ni *  nabf3 * nrbf3;    
+    int N3 = Ni *  nabf3 * nrbf3;
     for (int idx = 0; idx < totalIterations; ++idx) {
       int i = idx / nrbf3;  // Derive the original j value
       int m = idx % nrbf3;  // Derive the original m value
@@ -1277,13 +1277,13 @@ void PairPOD::threebody_forcecoeff(double *fb3, double *cb3, int Ni)
         int jmp = i + Ni*(p + nabf3*m);
         for (int q = 0; q < nn; q++) {
           int k = n1 + q;  // Combine n1 and q into a single index
-          int idxU = nelements * k + nelements * K3 * m + nelements*K3*nrbf3*i;          
+          int idxU = nelements * k + nelements * K3 * m + nelements*K3*nrbf3*i;
           for (int i1 = 0; i1 < nelements; i1++) {
             double tm = pc3[k] * sumU[i1 + idxU];
             for (int i2 = i1; i2 < nelements; i2++) {
-              int em = elemindex[i2 + nelements * i1];       
+              int em = elemindex[i2 + nelements * i1];
               double t1 = tm * cb3[jmp + N3*em]; // Ni *  nabf3 * nrbf3 * nelements*(nelements+1)/2
-              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni         
+              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni
               fb3[i1 + idxU] += pc3[k] * cb3[jmp + N3*em] * sumU[i2 + idxU];
             }
           }
@@ -1298,7 +1298,7 @@ void PairPOD::fourbodydesc(double *d4, int Ni)
   int totalIterations = nrbf4 * Ni;
   for (int idx = 0; idx < totalIterations; idx++) {
     int m = idx % nrbf4;
-    int i = idx / nrbf4;    
+    int i = idx / nrbf4;
     int idxU = nelements * K3 * m + nelements * K3 * nrbf3 * i;
     for (int p = 0; p < nabf4; p++) {
       int n1 = pa4[p];
@@ -1318,7 +1318,7 @@ void PairPOD::fourbodydesc(double *d4, int Ni)
             for (int i3 = i2; i3 < nelements; i3++) {
               double c3 = sumU[idxU + i3 + nelements * j3];
               int kk = p + nabf4 * m + nabf4 * nrbf4 * k;
-              d4[i + Ni * kk] += t12 * c3;              
+              d4[i + Ni * kk] += t12 * c3;
               k += 1;
             }
           }
@@ -1359,12 +1359,12 @@ void PairPOD::fourbodydescderiv(double *dd4, int Ni, int Nij)
           int j3 = pb4[idxNQ + 2 * Q4];
           double c1 = sumU[idxU + j1];
           double c2 = sumU[idxU + j2];
-          double c3 = sumU[idxU + j3];          
-          double t12 = c * c1 * c2;          
+          double c3 = sumU[idxU + j3];
+          double t12 = c * c1 * c2;
           double t13 = c * c1 * c3;
           double t23 = c * c2 * c3;
-          
-          // Pre-calculate commonly used indices          
+
+          // Pre-calculate commonly used indices
           int baseIdxJ3 = j3 + K3 * j; // Common index for j3 terms
           int baseIdxJ2 = j2 + K3 * j; // Common index for j2 terms
           int baseIdxJ1 = j1 + K3 * j; // Common index for j1 terms
@@ -1387,17 +1387,17 @@ void PairPOD::fourbodydescderiv(double *dd4, int Ni, int Nij)
         }
         dd4[baseIdx]     = tmp1;
         dd4[baseIdx + 1] = tmp2;
-        dd4[baseIdx + 2] = tmp3;                          
+        dd4[baseIdx + 2] = tmp3;
       }
     }
   }
-  else {        
+  else {
     int N3 = 3*Nij * nabf4 * nrbf4;
     int totalIterations = nrbf4 * Nij;
     for (int idx = 0; idx < totalIterations; idx++) {
       int j = idx / nrbf4;  // Derive the original j value
       int m = idx % nrbf4;  // Derive the original m value
-    
+
       int idxM = m + nrbfmax * j;
       // Temporary variables to store frequently used products
       double rbfM = rbf[idxM];
@@ -1420,7 +1420,7 @@ void PairPOD::fourbodydescderiv(double *dd4, int Ni, int Nij)
           // Pre-calculate commonly used indices for j3, j2, j1, and m
           int idxJ3 = j3 + K3 * j;
           int idxJ2 = j2 + K3 * j;
-          int idxJ1 = j1 + K3 * j;          
+          int idxJ1 = j1 + K3 * j;
           int idx1 = nelements * j1 + nelements * K3 * m + nelements * K3 * nrbf3 * idxi[j];
           int idx2 = nelements * j2 + nelements * K3 * m + nelements * K3 * nrbf3 * idxi[j];
           int idx3 = nelements * j3 + nelements * K3 * m + nelements * K3 * nrbf3 * idxi[j];
@@ -1439,18 +1439,18 @@ void PairPOD::fourbodydescderiv(double *dd4, int Ni, int Nij)
           double abfzJ2 = abfz[idxJ2];
           double abfzJ3 = abfz[idxJ3];
 
-          int k = 0;          
-          for (int i1 = 0; i1 < nelements; i1++) {            
+          int k = 0;
+          for (int i1 = 0; i1 < nelements; i1++) {
             double c1 = sumU[idx1 + i1];
             for (int i2 = i1; i2 < nelements; i2++) {
               double c2 = sumU[idx2 + i2];
-              double t12 = c*(c1 * c2);  
-              for (int i3 = i2; i3 < nelements; i3++) {                                                
-                double c3 = sumU[idx3 + i3];                
+              double t12 = c*(c1 * c2);
+              for (int i3 = i2; i3 < nelements; i3++) {
+                double c3 = sumU[idx3 + i3];
                 double t13 = c*(c1 * c3);
                 double t23 = c*(c2 * c3);
                 int baseIdx = jpm + N3 * k;
-                
+
                 // Compute contributions for each condition
                 if (typej == i3) {
                     dd4[0 + baseIdx] += t12 * (abfxJ3 * rbfM + rbfxM * abfJ3);
@@ -1491,7 +1491,7 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
       double rbfzBase = rbfz[baseIdxJ];
       double fx = 0;
       double fy = 0;
-      double fz = 0;            
+      double fz = 0;
       for (int p = 0; p < nabf4; p++) {
         int n1 = pa4[p];
         int n2 = pa4[p + 1];
@@ -1505,12 +1505,12 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
           int j3 = pb4[idxNQ + 2 * Q4];
           double c1 = sumU[idxU + j1];
           double c2 = sumU[idxU + j2];
-          double c3 = sumU[idxU + j3];          
-          double t12 = c * c1 * c2;          
+          double c3 = sumU[idxU + j3];
+          double t12 = c * c1 * c2;
           double t13 = c * c1 * c3;
           double t23 = c * c2 * c3;
-          
-          // Pre-calculate commonly used indices          
+
+          // Pre-calculate commonly used indices
           int baseIdxJ3 = j3 + K3 * j; // Common index for j3 terms
           int baseIdxJ2 = j2 + K3 * j; // Common index for j2 terms
           int baseIdxJ1 = j1 + K3 * j; // Common index for j1 terms
@@ -1535,16 +1535,16 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
       int baseIdx = 3 * j;
       fij[baseIdx]     += fx;
       fij[baseIdx + 1] += fy;
-      fij[baseIdx + 2] += fz;                                
+      fij[baseIdx + 2] += fz;
     }
   }
-  else {        
+  else {
     int N3 = Ni * nabf4 * nrbf4;
     int totalIterations = nrbf4 * Nij;
     for (int idx = 0; idx < totalIterations; idx++) {
       int j = idx / nrbf4;  // Derive the original j value
       int m = idx % nrbf4;  // Derive the original m value
-    
+
       int idxM = m + nrbfmax * j;
       // Temporary variables to store frequently used products
       double rbfM = rbf[idxM];
@@ -1554,11 +1554,11 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
       int typej = tj[j] - 1;
       double fx = 0;
       double fy = 0;
-      double fz = 0;            
+      double fz = 0;
       for (int p = 0; p < nabf4; p++)  {
         int n1 = pa4[p];
         int n2 = pa4[p + 1];
-        int nn = n2 - n1;        
+        int nn = n2 - n1;
         int jpm = idxi[j] + Ni*p + Ni*nabf4*m;
         for (int q = 0; q < nn; q++) {
           int c = pc4[n1 + q];
@@ -1568,7 +1568,7 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
           // Pre-calculate commonly used indices for j3, j2, j1, and m
           int idxJ3 = j3 + K3 * j;
           int idxJ2 = j2 + K3 * j;
-          int idxJ1 = j1 + K3 * j;          
+          int idxJ1 = j1 + K3 * j;
           int idx1 = nelements * j1 + nelements * K3 * m + nelements * K3 * nrbf3 * idxi[j];
           int idx2 = nelements * j2 + nelements * K3 * m + nelements * K3 * nrbf3 * idxi[j];
           int idx3 = nelements * j3 + nelements * K3 * m + nelements * K3 * nrbf3 * idxi[j];
@@ -1587,18 +1587,18 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
           double abfzJ2 = abfz[idxJ2];
           double abfzJ3 = abfz[idxJ3];
 
-          int k = 0;          
-          for (int i1 = 0; i1 < nelements; i1++) {            
+          int k = 0;
+          for (int i1 = 0; i1 < nelements; i1++) {
             double c1 = sumU[idx1 + i1];
             for (int i2 = i1; i2 < nelements; i2++) {
-              double c2 = sumU[idx2 + i2];              
-              for (int i3 = i2; i3 < nelements; i3++) {                       
-                double c3 = sumU[idx3 + i3];          
+              double c2 = sumU[idx2 + i2];
+              for (int i3 = i2; i3 < nelements; i3++) {
+                double c3 = sumU[idx3 + i3];
                 double c4 = c * cb4[jpm + N3*k];
-                double t12 = c4*(c1 * c2);  
+                double t12 = c4*(c1 * c2);
                 double t13 = c4*(c1 * c3);
-                double t23 = c4*(c2 * c3);                
-                                
+                double t23 = c4*(c2 * c3);
+
                 // Compute contributions for each condition
                 if (typej == i3) {
                     fx += t12 * (abfxJ3 * rbfM + rbfxM * abfJ3);
@@ -1624,7 +1624,7 @@ void PairPOD::fourbody_forces(double *fij, double *cb4, int Ni, int Nij)
       int baseIdx = 3 * j;
       fij[baseIdx]     += fx;
       fij[baseIdx + 1] += fy;
-      fij[baseIdx + 2] += fz;                                      
+      fij[baseIdx + 2] += fz;
     }
   }
 }
@@ -1635,7 +1635,7 @@ void PairPOD::fourbody_forcecoeff(double *fb4, double *cb4, int Ni)
     for (int idx = 0; idx < Ni * nrbf4; ++idx) {
       int i = idx / nrbf4;  // Derive the original j value
       int m = idx % nrbf4;  // Derive the original m value
-      int idxU = K3 * m + K3*nrbf3*i;                  
+      int idxU = K3 * m + K3*nrbf3*i;
       for (int p = 0; p < nabf4; p++) {
         int n1 = pa4[p];
         int n2 = pa4[p + 1];
@@ -1649,24 +1649,24 @@ void PairPOD::fourbody_forcecoeff(double *fb4, double *cb4, int Ni)
           int j3 = idxU + pb4[idxNQ + 2 * Q4];
           double c1 = sumU[j1];
           double c2 = sumU[j2];
-          double c3 = sumU[j3];          
-          fb4[j3] += c * c1 * c2;          
+          double c3 = sumU[j3];
+          fb4[j3] += c * c1 * c2;
           fb4[j2] += c * c1 * c3;
-          fb4[j1] += c * c2 * c3;          
+          fb4[j1] += c * c2 * c3;
         }
       }
     }
   }
-  else {        
+  else {
     int N3 = Ni * nabf4 * nrbf4;
     int totalIterations = nrbf4 * Ni;
     for (int idx = 0; idx < totalIterations; idx++) {
       int i = idx / nrbf4;  // Derive the original j value
-      int m = idx % nrbf4;  // Derive the original m value    
+      int m = idx % nrbf4;  // Derive the original m value
       for (int p = 0; p < nabf4; p++)  {
         int n1 = pa4[p];
         int n2 = pa4[p + 1];
-        int nn = n2 - n1;        
+        int nn = n2 - n1;
         int jpm = i + Ni*p + Ni*nabf4*m;
         for (int q = 0; q < nn; q++) {
           int c = pc4[n1 + q];
@@ -1677,17 +1677,17 @@ void PairPOD::fourbody_forcecoeff(double *fb4, double *cb4, int Ni)
           int idx1 = nelements * j1 + nelements * K3 * m + nelements * K3 * nrbf3 * i;
           int idx2 = nelements * j2 + nelements * K3 * m + nelements * K3 * nrbf3 * i;
           int idx3 = nelements * j3 + nelements * K3 * m + nelements * K3 * nrbf3 * i;
-          int k = 0;          
-          for (int i1 = 0; i1 < nelements; i1++) {            
+          int k = 0;
+          for (int i1 = 0; i1 < nelements; i1++) {
             double c1 = sumU[idx1 + i1];
             for (int i2 = i1; i2 < nelements; i2++) {
-              double c2 = sumU[idx2 + i2];              
-              for (int i3 = i2; i3 < nelements; i3++) {                       
-                double c3 = sumU[idx3 + i3];          
+              double c2 = sumU[idx2 + i2];
+              for (int i3 = i2; i3 < nelements; i3++) {
+                double c3 = sumU[idx3 + i3];
                 double c4 = c * cb4[jpm + N3*k];
-                fb4[idx3 + i3] += c4*(c1 * c2);  
+                fb4[idx3 + i3] += c4*(c1 * c2);
                 fb4[idx2 + i2] += c4*(c1 * c3);
-                fb4[idx1 + i1] += c4*(c2 * c3);                                                
+                fb4[idx1 + i1] += c4*(c2 * c3);
                 k += 1;
               }
             }
@@ -1700,36 +1700,36 @@ void PairPOD::fourbody_forcecoeff(double *fb4, double *cb4, int Ni)
 
 void PairPOD::allbody_forces(double *fij, double *forcecoeff, int Nij)
 {
-  int totalIterations = nrbf3 * Nij;  
+  int totalIterations = nrbf3 * Nij;
   for (int idx = 0; idx < totalIterations; ++idx) {
     int j = idx / nrbf3;  // Derive the original j value
     int m = idx % nrbf3;  // Derive the original m value
     int idxR = m + nrbfmax * j;  // Pre-compute the index for rbf
-    int i2 = tj[j] - 1;   
+    int i2 = tj[j] - 1;
     double rbfBase = rbf[idxR];
     double rbfxBase = rbfx[idxR];
     double rbfyBase = rbfy[idxR];
     double rbfzBase = rbfz[idxR];
     double fx = 0;
     double fy = 0;
-    double fz = 0;            
+    double fz = 0;
     for (int k = 0; k < K3; k++) {
       int idxU = nelements * k + nelements * K3 * m + nelements*K3*nrbf3*idxi[j];
       double fc = forcecoeff[i2 + idxU];
-      int idxA = k + K3 * j;  // Pre-compute the index for abf          
-      double abfA = abf[idxA];   
+      int idxA = k + K3 * j;  // Pre-compute the index for abf
+      double abfA = abf[idxA];
       double abfxA = abfx[idxA];
       double abfyA = abfy[idxA];
-      double abfzA = abfz[idxA];        
-      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij 
+      double abfzA = abfz[idxA];
+      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij
       fy += fc * (abfyA * rbfBase + rbfyBase * abfA);
-      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);                        
+      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);
     }
-    int baseIdx = 3 * j; 
+    int baseIdx = 3 * j;
     fij[baseIdx]     += fx;
     fij[baseIdx + 1] += fy;
-    fij[baseIdx + 2] += fz;                           
-  }  
+    fij[baseIdx + 2] += fz;
+  }
 }
 
 void PairPOD::crossdesc(double *d12, double *d1, double *d2, int *ind1, int *ind2, int n12, int Ni)
@@ -1745,7 +1745,7 @@ void PairPOD::crossdesc(double *d12, double *d1, double *d2, int *ind1, int *ind
 
 void PairPOD::crossdescderiv(double *dd12, double *d1, double *d2, double *dd1, double *dd2,
         int *ind1, int *ind2, int *idxi, int n12, int Ni, int Nij)
-{  
+{
   int totalIterations = n12 * Nij;
   for (int idx = 0; idx < totalIterations; idx++) {
     int n = idx % Nij;
@@ -1763,9 +1763,9 @@ void PairPOD::crossdescderiv(double *dd12, double *d1, double *d2, double *dd1,
   }
 }
 
-void PairPOD::crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1, 
+void PairPOD::crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1,
         double *d2, int *ind1, int *ind2, int n12, int Ni)
-{  
+{
   int totalIterations = n12 * Ni;
   for (int idx = 0; idx < totalIterations; idx++) {
     int n = idx % Ni; // Ni
@@ -1774,9 +1774,9 @@ void PairPOD::crossdesc_reduction(double *cb1, double *cb2, double *c12, double
     int k2 = ind2[m]; // dd2
     int m1 = n + Ni * k1; // d1
     int m2 = n + Ni * k2; // d2
-    double c = c12[n + Ni * m];        
-    cb1[m1] += c * d2[m2];        
-    cb2[m2] += c * d1[m1];     
+    double c = c12[n + Ni * m];
+    cb1[m1] += c * d2[m2];
+    cb2[m2] += c * d1[m1];
   }
 }
 
@@ -1790,7 +1790,7 @@ void PairPOD::blockatom_base_descriptors(double *bd1, int Ni, int Nij)
   double *d33 =  &bd1[Ni*(nl2 + nl3 + nl4 )]; // nl33
   double *d34 =  &bd1[Ni*(nl2 + nl3 + nl4 + nl33)]; // nl34
   double *d44 =  &bd1[Ni*(nl2 + nl3 + nl4 + nl33 + nl34)]; // nl44
-  
+
   orthogonalradialbasis(Nij);
 
   if ((nl2>0) && (Nij>0)) {
@@ -1805,9 +1805,9 @@ void PairPOD::blockatom_base_descriptors(double *bd1, int Ni, int Nij)
     if ((nl33>0) && (Nij>3)) {
       crossdesc(d33, d3, d3, ind33l, ind33r, nl33, Ni);
     }
-    
+
     if ((nl4 > 0) && (Nij>2)) {
-      if (K4 < K3) {        
+      if (K4 < K3) {
         fourbodydesc(d4, Ni);
       }
 
@@ -1834,8 +1834,8 @@ void PairPOD::blockatombase_descriptors(double *bd1, double *bdd1, int Ni, int N
   double *d34 =  &bd1[Ni*(nl2 + nl3 + nl4 + nl33)]; // nl34
   double *d44 =  &bd1[Ni*(nl2 + nl3 + nl4 + nl33 + nl34)]; // nl44
 
-  double *dd2 = &bdd1[0]; // 3*Nj*nl2  
-  double *dd3 = &bdd1[3*Nij*nl2]; // 3*Nj*nl3  
+  double *dd2 = &bdd1[0]; // 3*Nj*nl2
+  double *dd3 = &bdd1[3*Nij*nl2]; // 3*Nj*nl3
   double *dd4 = &bdd1[3*Nij*(nl2+nl3)]; // 3*Nj*nl4
   double *dd33 = &bdd1[3*Nij*(nl2+nl3+nl4)]; // 3*Nj*nl33
   double *dd34 = &bdd1[3*Nij*(nl2+nl3+nl4+nl33)]; // 3*Nj*nl34
@@ -1858,11 +1858,11 @@ void PairPOD::blockatombase_descriptors(double *bd1, double *bdd1, int Ni, int N
       crossdesc(d33, d3, d3, ind33l, ind33r, nl33, Ni);
       crossdescderiv(dd33, d3, d3, dd3, dd3, ind33l, ind33r, idxi, nl33, Ni, Nij);
     }
-    
+
     if ((nl4 > 0) && (Nij>2)) {
-      if (K4 < K3) {        
+      if (K4 < K3) {
         fourbodydesc(d4, Ni);
-        fourbodydescderiv(dd4, Ni, Nij);        
+        fourbodydescderiv(dd4, Ni, Nij);
       }
 
       if ((nl34>0) && (Nij>4)) {
@@ -1879,62 +1879,62 @@ void PairPOD::blockatombase_descriptors(double *bd1, double *bdd1, int Ni, int N
 }
 
 void PairPOD::blockatom_base_coefficients(double *ei, double *cb, double *B, int Ni)
-{  
-  double *cefs = &coefficients[0];  
-  int *tyai = &typeai[0];  
-  
+{
+  double *cefs = &coefficients[0];
+  int *tyai = &typeai[0];
+
   int nDes = Mdesc;
   int nCoeff = nCoeffPerElement;
-  
+
   for (int n=0; n<Ni; n++) {
     int nc = nCoeff*(tyai[n]-1);
     ei[n] = cefs[0 + nc];
-    for (int m=0; m<nDes; m++)     
+    for (int m=0; m<nDes; m++)
       ei[n] += cefs[1 + m + nc]*B[n + Ni*m];
-  }    
-  
+  }
+
   for (int idx=0; idx<Ni*nDes; idx++) {
     int n = idx % Ni;
     int m = idx / Ni;
-    int nc = nCoeff*(tyai[n]-1);            
-    cb[n + Ni*m] = cefs[1 + m + nc];     
-  }                    
+    int nc = nCoeff*(tyai[n]-1);
+    cb[n + Ni*m] = cefs[1 + m + nc];
+  }
 }
 
 void PairPOD::blockatom_environment_descriptors(double *ei, double *cb, double *B, int Ni)
-{  
-  double *P    = &pd[0];    // Ni*nClusters 
-  double *cp   = &pd[Ni*(nClusters)];  // Ni*nClusters  
+{
+  double *P    = &pd[0];    // Ni*nClusters
+  double *cp   = &pd[Ni*(nClusters)];  // Ni*nClusters
   double *D    = &pd[Ni*(2*nClusters)];   // Ni*nClusters
-  double *pca  = &pd[Ni*(3*nClusters)]; // Ni*nComponents 
+  double *pca  = &pd[Ni*(3*nClusters)]; // Ni*nComponents
   double *sumD = &pd[Ni*(nComponents + 3*nClusters)]; // Ni
-     
+
   double *proj = &Proj[0];
   double *cent = &Centroids[0];
-  double *cefs = &coefficients[0];  
-  int *tyai = &typeai[0];  
-  
+  double *cefs = &coefficients[0];
+  int *tyai = &typeai[0];
+
   int nCom = nComponents;
   int nCls = nClusters;
   int nDes = Mdesc;
   int nCoeff = nCoeffPerElement;
-  
+
   for (int idx=0; idx<Ni*nCom; idx++) {
     int k = idx % nCom;
-    int i = idx / nCom;     
+    int i = idx / nCom;
     double sum = 0.0;
     int typei = tyai[i]-1;
     for (int m = 0; m < nDes; m++) {
       sum += proj[k + nCom*m + nCom*nDes*typei] * B[i + Ni*m];
     }
-    pca[i + Ni*k] = sum;    
+    pca[i + Ni*k] = sum;
   }
-  
+
   for (int idx=0; idx<Ni*nCls; idx++) {
     int j = idx % nCls;
-    int i = idx / nCls;     
+    int i = idx / nCls;
     int typei = tyai[i]-1;
-    double sum = 1e-20; 
+    double sum = 1e-20;
     for (int k = 0; k < nCom; k++) {
       double c = cent[k + j * nCom + nCls*nCom*typei];
       double p = pca[i + Ni*k];
@@ -1942,48 +1942,48 @@ void PairPOD::blockatom_environment_descriptors(double *ei, double *cb, double *
     }
     D[i + Ni*j] = 1.0 / sum;
   }
-  
-  for (int i = 0; i< Ni; i++) {    
-    double sum = 0; 
-    for (int j = 0; j < nCls; j++) sum += D[i + Ni*j];    
+
+  for (int i = 0; i< Ni; i++) {
+    double sum = 0;
+    for (int j = 0; j < nCls; j++) sum += D[i + Ni*j];
     sumD[i] = sum;
-    for (int j = 0; j < nCls; j++) P[i + Ni*j] = D[i + Ni*j]/sum;    
+    for (int j = 0; j < nCls; j++) P[i + Ni*j] = D[i + Ni*j]/sum;
   }
-  
+
   for (int n=0; n<Ni; n++) {
     int nc = nCoeff*(tyai[n]-1);
     ei[n] = cefs[0 + nc];
     for (int k = 0; k<nCls; k++)
-      for (int m=0; m<nDes; m++)     
+      for (int m=0; m<nDes; m++)
         ei[n] += cefs[1 + m + nDes*k + nc]*B[n + Ni*m]*P[n + Ni*k];
-  }    
-  
+  }
+
   for (int idx=0; idx<Ni*nCls; idx++) {
     int n = idx % Ni;
     int k = idx / Ni;
-    int nc = nCoeff*(tyai[n]-1);            
+    int nc = nCoeff*(tyai[n]-1);
     double sum = 0;
-    for (int m = 0; m<nDes; m++)     
+    for (int m = 0; m<nDes; m++)
       sum += cefs[1 + m + k*nDes + nc]*B[n + Ni*m];
     cp[n + Ni*k] = sum;
-  }            
+  }
 
   for (int idx=0; idx<Ni*nDes; idx++) {
     int n = idx % Ni;
     int m = idx / Ni;
-    int nc = nCoeff*(tyai[n]-1);            
-    double sum = 0.0;    
-    for (int k = 0; k<nCls; k++)    
-      sum += cefs[1 + m + k*nDes + nc]*P[n + Ni*k];      
+    int nc = nCoeff*(tyai[n]-1);
+    double sum = 0.0;
+    for (int k = 0; k<nCls; k++)
+      sum += cefs[1 + m + k*nDes + nc]*P[n + Ni*k];
     cb[n + Ni*m] = sum;
-  }              
-  
+  }
+
   for (int idx=0; idx<Ni*nDes; idx++) {
     int i = idx % Ni;
     int m = idx / Ni;
     int typei = tyai[i]-1;
     double S1 = 1/sumD[i];
-    double S2 = sumD[i]*sumD[i];   
+    double S2 = sumD[i]*sumD[i];
     double sum = 0.0;
     for (int j=0; j<nCls; j++) {
       double dP_dB = 0.0;
@@ -1993,90 +1993,90 @@ void PairPOD::blockatom_environment_descriptors(double *ei, double *cb, double *
         double dD_dB = 0.0;
         double D2 = 2 * D[i + Ni*k] * D[i + Ni*k];
         for (int n = 0; n < nCom; n++) {
-          double dD_dpca = D2 * (cent[n + k * nCom + nCls*nCom*typei] - pca[i + Ni*n]);        
+          double dD_dpca = D2 * (cent[n + k * nCom + nCls*nCom*typei] - pca[i + Ni*n]);
           dD_dB += dD_dpca * proj[n + m * nCom + nCom*nDes*typei];
-        }                
+        }
         dP_dB += dP_dD * dD_dB;
-      }      
-      sum += cp[i + Ni*j]*dP_dB;      
+      }
+      sum += cp[i + Ni*j]*dP_dB;
     }
     cb[i + Ni*m] += sum;
-  }  
+  }
 }
 
 void PairPOD::blockatom_energies(double *ei, int Ni, int Nij)
-{  
+{
   // calculate base descriptors and their derivatives with respect to atom coordinates
-  blockatom_base_descriptors(bd, Ni, Nij);  
-  
-  if (nClusters > 1) {    
+  blockatom_base_descriptors(bd, Ni, Nij);
+
+  if (nClusters > 1) {
     blockatom_environment_descriptors(ei, cb, bd, Ni);
   }
   else {
     blockatom_base_coefficients(ei, cb, bd, Ni);
-  }        
+  }
 }
 
 void PairPOD::blockatom_forces(double *fij, int Ni, int Nij)
 {
-  
+
   int nld = nl2 + nl3 + nl4;
   for (int i=0; i<3*Nij*nld; i++) bdd[i] = 0.0;
-  
+
 //   double *d3 =  &bd[Ni*nl2]; // nl3
-//   double *d4 =  &bd[Ni*(nl2 + nl3)]; // nl4  
-  double *dd2 = &bdd[0]; // 3*Nj*nl2  
-  double *dd3 = &bdd[3*Nij*nl2]; // 3*Nj*nl3  
+//   double *d4 =  &bd[Ni*(nl2 + nl3)]; // nl4
+  double *dd2 = &bdd[0]; // 3*Nj*nl2
+  double *dd3 = &bdd[3*Nij*nl2]; // 3*Nj*nl3
   double *dd4 = &bdd[3*Nij*(nl2+nl3)]; // 3*Nj*nl4
 //   double *dd33 = &bdd[3*Nij*(nl2+nl3+nl4)]; // 3*Nj*nl33
 //   double *dd34 = &bdd[3*Nij*(nl2+nl3+nl4+nl33)]; // 3*Nj*nl34
 //   double *dd44 = &bdd[3*Nij*(nl2+nl3+nl4+nl33+nl34)]; // 3*Nj*nl44
 
   if ((nl2 > 0) && (Nij>0)) twobodydescderiv(dd2, Ni, Nij);
-  if ((nl3 > 0) && (Nij>1)) threebodydescderiv(dd3, Ni, Nij);    
-  if ((nl4 > 0) && (Nij>2)) fourbodydescderiv(dd4, Ni, Nij);                    
-  
+  if ((nl3 > 0) && (Nij>1)) threebodydescderiv(dd3, Ni, Nij);
+  if ((nl4 > 0) && (Nij>2)) fourbodydescderiv(dd4, Ni, Nij);
+
   double *d3 =  &bd[Ni*nl2]; // nl3
-  double *d4 =  &bd[Ni*(nl2 + nl3)]; // nl4    
+  double *d4 =  &bd[Ni*(nl2 + nl3)]; // nl4
   double *cb2 =  &cb[0]; // nl3
   double *cb3 =  &cb[Ni*nl2]; // nl3
   double *cb4 =  &cb[Ni*(nl2 + nl3)]; // nl4
   double *cb33 = &cb[Ni*(nl2 + nl3 + nl4)]; // nl33
   double *cb34 = &cb[Ni*(nl2 + nl3 + nl4 + nl33)]; // nl34
   double *cb44 = &cb[Ni*(nl2 + nl3 + nl4 + nl33 + nl34)]; // nl44
-  
+
   if (nl33>0) crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33, Ni);
-  
+
   if (nl34>0) crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34, Ni);
-  
-  if (nl44>0) crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44, Ni);    
-  
-//   for (int n=0; n<3*Nij; n++) fij[n] = 0;  
+
+  if (nl44>0) crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44, Ni);
+
+//   for (int n=0; n<3*Nij; n++) fij[n] = 0;
 //   twobody_forces(fij, cb2, Ni, Nij);
 //   threebody_forces(fij, cb3, Ni, Nij);
 //   fourbody_forces(fij, cb4, Ni, Nij);
-  
-  
-//   if ((nl33>0) && (Nij>3)) {      
+
+
+//   if ((nl33>0) && (Nij>3)) {
 //     crossdescderiv(dd33, d3, d3, dd3, dd3, ind33l, ind33r, idxi, nl33, Ni, Nij);
 //   }
-//     
+//
 //   if ((nl34>0) && (Nij>4)) {
 //     crossdescderiv(dd34, d3, d4, dd3, dd4, ind34l, ind34r, idxi, nl34, Ni, Nij);
 //   }
-// 
+//
 //   if ((nl44>0) && (Nij>5)) {
 //     crossdescderiv(dd44, d4, d4, dd4, dd4, ind44l, ind44r, idxi, nl44, Ni, Nij);
-//   }    
-    
+//   }
+
   int N3 = 3*Nij;
   for (int n=0; n<Nij; n++) {
     int n3 = 3*n;
     int i = idxi[n];
     double fx = 0.0;
     double fy = 0.0;
-    double fz = 0.0;            
-    for (int m=0; m<nld; m++) {    
+    double fz = 0.0;
+    for (int m=0; m<nld; m++) {
       double c = cb[i + Ni*m];
       fx += c*bdd[0 + n3 + N3*m];
       fy += c*bdd[1 + n3 + N3*m];
@@ -2084,75 +2084,75 @@ void PairPOD::blockatom_forces(double *fij, int Ni, int Nij)
     }
     fij[0 + n3] = fx;
     fij[1 + n3] = fy;
-    fij[2 + n3] = fz;      
-  }          
+    fij[2 + n3] = fz;
+  }
 }
 
 void PairPOD::blockatom_energyforce(double *ei, double *fij, int Ni, int Nij)
-{  
+{
   // calculate base descriptors and their derivatives with respect to atom coordinates
-  blockatom_base_descriptors(bd, Ni, Nij);  
-  
-  if (nClusters > 1) {    
+  blockatom_base_descriptors(bd, Ni, Nij);
+
+  if (nClusters > 1) {
     blockatom_environment_descriptors(ei, cb, bd, Ni);
   }
   else {
     blockatom_base_coefficients(ei, cb, bd, Ni);
-  }      
-  
+  }
+
   double *d3 =  &bd[Ni*nl2]; // nl3
-  double *d4 =  &bd[Ni*(nl2 + nl3)]; // nl4    
+  double *d4 =  &bd[Ni*(nl2 + nl3)]; // nl4
   double *cb2 =  &cb[0]; // nl3
   double *cb3 =  &cb[Ni*nl2]; // nl3
   double *cb4 =  &cb[Ni*(nl2 + nl3)]; // nl4
   double *cb33 = &cb[Ni*(nl2 + nl3 + nl4)]; // nl33
   double *cb34 = &cb[Ni*(nl2 + nl3 + nl4 + nl33)]; // nl34
   double *cb44 = &cb[Ni*(nl2 + nl3 + nl4 + nl33 + nl34)]; // nl44
-  
+
   if ((nl33>0) && (Nij>3)) {
-    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33, Ni);      
+    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33, Ni);
   }
   if ((nl34>0) && (Nij>4)) {
-    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34, Ni);      
-  }  
+    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34, Ni);
+  }
   if ((nl44>0) && (Nij>5)) {
-    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44, Ni);        
-  }     
-  
-  for (int n=0; n<3*Nij; n++) fij[n] = 0;  
-  if ((nl2 > 0) && (Nij>0)) twobody_forces(fij, cb2, Ni, Nij);  
+    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44, Ni);
+  }
+
+  for (int n=0; n<3*Nij; n++) fij[n] = 0;
+  if ((nl2 > 0) && (Nij>0)) twobody_forces(fij, cb2, Ni, Nij);
   //if ((nl3 > 0) && (Nij>1)) threebody_forces(fij, cb3, Ni, Nij);
-  //if ((nl4 > 0) && (Nij>2)) fourbody_forces(fij, cb4, Ni, Nij); 
-  
+  //if ((nl4 > 0) && (Nij>2)) fourbody_forces(fij, cb4, Ni, Nij);
+
     // Initialize forcecoeff to zero
    std::fill(forcecoeff, forcecoeff + Ni * nelements * K3 * nrbf3, 0.0);
    if ((nl3 > 0) && (Nij>1)) threebody_forcecoeff(forcecoeff, cb3, Ni);
    if ((nl4 > 0) && (Nij>2)) fourbody_forcecoeff(forcecoeff, cb4, Ni);
-   if ((nl3 > 0) && (Nij>1)) allbody_forces(fij, forcecoeff, Nij);    
+   if ((nl3 > 0) && (Nij>1)) allbody_forces(fij, forcecoeff, Nij);
 }
 
 void PairPOD::blockatomenergyforce(double *ei, double *fij, int Ni, int Nij)
-{  
+{
   blockatom_energyforce(ei, fij, Ni, Nij);
-  
-  //blockatom_energies(ei, Ni, Nij);  
-  //blockatom_forces(fij, Ni, Nij);  
-    
+
+  //blockatom_energies(ei, Ni, Nij);
+  //blockatom_forces(fij, Ni, Nij);
+
 //   // calculate base descriptors and their derivatives with respect to atom coordinates
-//   blockatombase_descriptors(bd, bdd, Ni, Nij);  
-//   
-//   if (nClusters > 1) {    
+//   blockatombase_descriptors(bd, bdd, Ni, Nij);
+//
+//   if (nClusters > 1) {
 //     //double *cb = &sumU[0];
 //     blockatom_environment_descriptors(ei, cb, bd, Ni);
-//     
+//
 //     int N3 = 3*Nij;
 //     for (int n=0; n<Nij; n++) {
 //       int n3 = 3*n;
 //       int i = idxi[n];
 //       double fx = 0.0;
 //       double fy = 0.0;
-//       double fz = 0.0;            
-//       for (int m=0; m<Mdesc; m++) {    
+//       double fz = 0.0;
+//       for (int m=0; m<Mdesc; m++) {
 //         double c = cb[i + Ni*m];
 //         fx += c*bdd[0 + n3 + N3*m];
 //         fy += c*bdd[1 + n3 + N3*m];
@@ -2160,16 +2160,16 @@ void PairPOD::blockatomenergyforce(double *ei, double *fij, int Ni, int Nij)
 //       }
 //       fij[0 + n3] = fx;
 //       fij[1 + n3] = fy;
-//       fij[2 + n3] = fz;      
-//     }        
+//       fij[2 + n3] = fz;
+//     }
 //   }
 //   else {
 //     for (int n=0; n<Ni; n++) {
 //       ei[n] = coefficients[0 + nCoeffPerElement*(typeai[n]-1)];
-//       for (int m=0; m<Mdesc; m++)     
+//       for (int m=0; m<Mdesc; m++)
 //         ei[n] += coefficients[1 + m + nCoeffPerElement*(typeai[n]-1)]*bd[n + Ni*m];
 //     }
-// 
+//
 //     for (int n=0; n<Nij; n++) {
 //       int n3 = 3*n;
 //       int nc = nCoeffPerElement*(ti[n]-1);
@@ -2177,12 +2177,12 @@ void PairPOD::blockatomenergyforce(double *ei, double *fij, int Ni, int Nij)
 //       fij[0 + n3] = 0.0;
 //       fij[1 + n3] = 0.0;
 //       fij[2 + n3] = 0.0;
-//       for (int m=0; m<Mdesc; m++) {    
+//       for (int m=0; m<Mdesc; m++) {
 //         fij[0 + n3] += coefficients[1 + m + nc]*bdd[0 + n3 + N3*m];
 //         fij[1 + n3] += coefficients[1 + m + nc]*bdd[1 + n3 + N3*m];
 //         fij[2 + n3] += coefficients[1 + m + nc]*bdd[2 + n3 + N3*m];
 //       }
-//     }      
+//     }
 //   }
 }
 
@@ -2210,28 +2210,28 @@ void PairPOD::saveintmatrix2binfile(std::string filename, int *A, int nrows, int
 
 void PairPOD::savedatafordebugging()
 {
-  saveintmatrix2binfile("podtypeai.bin", typeai, ni, 1);  
-  saveintmatrix2binfile("podnumij.bin", numij, ni+1, 1);  
-  saveintmatrix2binfile("podai.bin", ai, nij, 1);  
-  saveintmatrix2binfile("podaj.bin", aj, nij, 1);  
-  saveintmatrix2binfile("podti.bin", ti, nij, 1);  
-  saveintmatrix2binfile("podtj.bin", tj, nij, 1);  
-  saveintmatrix2binfile("podidxi.bin", idxi, nij, 1);     
+  saveintmatrix2binfile("podtypeai.bin", typeai, ni, 1);
+  saveintmatrix2binfile("podnumij.bin", numij, ni+1, 1);
+  saveintmatrix2binfile("podai.bin", ai, nij, 1);
+  saveintmatrix2binfile("podaj.bin", aj, nij, 1);
+  saveintmatrix2binfile("podti.bin", ti, nij, 1);
+  saveintmatrix2binfile("podtj.bin", tj, nij, 1);
+  saveintmatrix2binfile("podidxi.bin", idxi, nij, 1);
   savematrix2binfile("podrbf.bin", rbf, nrbfmax, nij);
   savematrix2binfile("podrbfx.bin", rbfx, nrbfmax, nij);
   savematrix2binfile("podrbfy.bin", rbfy, nrbfmax, nij);
-  savematrix2binfile("podrbfz.bin", rbfz, nrbfmax, nij);      
+  savematrix2binfile("podrbfz.bin", rbfz, nrbfmax, nij);
   int kmax = (K3 > ns) ? K3 : ns;
   savematrix2binfile("podabf.bin", abf,   kmax, nij);
   savematrix2binfile("podabfx.bin", abfx, kmax, nij);
   savematrix2binfile("podabfy.bin", abfy, kmax, nij);
-  savematrix2binfile("podabfz.bin", abfz, kmax, nij);            
-  savematrix2binfile("podbdd.bin", bdd, 3*nij, Mdesc);      
-  savematrix2binfile("podbd.bin", bd, ni, Mdesc);      
-  savematrix2binfile("podsumU.bin", sumU, nelements * K3 * nrbfmax, ni);      
+  savematrix2binfile("podabfz.bin", abfz, kmax, nij);
+  savematrix2binfile("podbdd.bin", bdd, 3*nij, Mdesc);
+  savematrix2binfile("podbd.bin", bd, ni, Mdesc);
+  savematrix2binfile("podsumU.bin", sumU, nelements * K3 * nrbfmax, ni);
   savematrix2binfile("podrij.bin", rij, 3, nij);
   savematrix2binfile("podfij.bin", fij, 3, nij);
-  savematrix2binfile("podei.bin", ei, ni, 1);           
+  savematrix2binfile("podei.bin", ei, ni, 1);
   error->all(FLERR, "Save data and stop the run for debugging");
 }
 
diff --git a/src/ML-POD/pair_pod.h b/src/ML-POD/pair_pod.h
index 9859d7e77c..00a0f32564 100644
--- a/src/ML-POD/pair_pod.h
+++ b/src/ML-POD/pair_pod.h
@@ -41,13 +41,13 @@ public:
   void NeighborCount(double **x, int **firstneigh, int *ilist, int *numneigh, double rcutsq, int i1, int i2);
   void NeighborList(double **x, int **firstneigh, int *atomtype, int *map, int *ilist, int *numneigh,
                         double rcutsq, int i1, int i2);
-  void tallyenergy(double *ei, int istart, int Ni);          
-  void tallystress(double *fij, double *rij, int *ai, int *aj, int nlocal, int N);              
+  void tallyenergy(double *ei, int istart, int Ni);
+  void tallystress(double *fij, double *rij, int *ai, int *aj, int nlocal, int N);
   void tallyforce(double **force, double *fij,  int *ai, int *aj, int N);
   void divideInterval(int *intervals, int N, int M);
-  int calculateNumberOfIntervals(int N, int intervalSize); 
+  int calculateNumberOfIntervals(int N, int intervalSize);
   int numberOfNeighbors();
-  
+
   void copy_data_from_pod_class();
   void radialbasis(double *rbft, double *rbftx, double *rbfty, double *rbftz, double *rij, int Nij);
   void orthogonalradialbasis(int Nij);
@@ -65,32 +65,32 @@ public:
   void crossdesc(double *d12, double *d1, double *d2, int *ind1, int *ind2, int n12, int Ni);
   void crossdescderiv(double *dd12, double *d1, double *d2, double *dd1, double *dd2,
         int *ind1, int *ind2, int *idxi, int n12, int Ni, int Nij);
-  void blockatombase_descriptors(double *bd1, double *bdd1, int Ni, int Nij);  
+  void blockatombase_descriptors(double *bd1, double *bdd1, int Ni, int Nij);
   void blockatomenergyforce(double *ei, double *fij, int Ni, int Nij);
 
-  void crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1, 
-        double *d2, int *ind1, int *ind2, int n12, int Ni);  
+  void crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1,
+        double *d2, int *ind1, int *ind2, int n12, int Ni);
   void blockatom_base_descriptors(double *bd1, int Ni, int Nij);
   void blockatom_base_coefficients(double *ei, double *cb, double *B, int Ni);
   void blockatom_environment_descriptors(double *ei, double *cb, double *B, int Ni);
   void blockatom_energyforce(double *ei, double *fij, int Ni, int Nij);
   void blockatom_energies(double *ei, int Ni, int Nij);
-  void blockatom_forces(double *fij, int Ni, int Nij);  
-  
+  void blockatom_forces(double *fij, int Ni, int Nij);
+
   void twobody_forces(double *fij, double *cb2, int Ni, int Nij);
   void threebody_forces(double *fij, double *cb3, int Ni, int Nij);
   void fourbody_forces(double *fij, double *cb4, int Ni, int Nij);
-  
+
   void threebody_forcecoeff(double *fb3, double *cb3, int Ni);
   void fourbody_forcecoeff(double *fb4, double *cb4, int Ni);
   void allbody_forces(double *fij, double *forcecoeff, int Nij);
-  
+
   void savematrix2binfile(std::string filename, double *A, int nrows, int ncols);
-  void saveintmatrix2binfile(std::string filename, int *A, int nrows, int ncols);  
-  void savedatafordebugging();    
+  void saveintmatrix2binfile(std::string filename, int *A, int nrows, int ncols);
+  void savedatafordebugging();
 
 protected:
-  class EAPOD *fastpodptr;  
+  class EAPOD *fastpodptr;
   virtual void allocate();
   void grow_atoms(int Ni);
   void grow_pairs(int Nij);
@@ -98,13 +98,13 @@ protected:
   int atomBlockSize;        // size of each atom block
   int nAtomBlocks;          // number of atoms blocks
   int atomBlocks[101];      // atom blocks
-  
+
   int ni;            // total number of atoms i
   int nij;           // total number of pairs (i,j)
   int nimax;         // maximum number of atoms i
   int nijmax;        // maximum number of pairs (i,j)
 
-  int nelements; // number of elements 
+  int nelements; // number of elements
   int onebody;   // one-body descriptors
   int besseldegree; // degree of Bessel functions
   int inversedegree; // degree of inverse functions
@@ -113,57 +113,57 @@ protected:
   int ns;      // number of snapshots for radial basis functions
   int nl1, nl2, nl3, nl4, nl23, nl33, nl34, nl44, nl;   // number of local descriptors
   int nrbf2, nrbf3, nrbf4, nrbfmax;            // number of radial basis functions
-  int nabf3, nabf4;                            // number of angular basis functions  
+  int nabf3, nabf4;                            // number of angular basis functions
   int K3, K4, Q4;                                  // number of monomials
-    
+
   // environmental variables
   int nClusters; // number of environment clusters
   int nComponents; // number of principal components
-  int Mdesc; // number of base descriptors 
+  int Mdesc; // number of base descriptors
 
   double rin;  // inner cut-off radius
   double rcut; // outer cut-off radius
   double rmax; // rcut - rin
-  
+
   double *rij;         // (xj - xi) for all pairs (I, J)
   double *fij;         // force for all pairs (I, J)
   double *ei;          // energy for each atom I
   int *typeai;         // types of atoms I only
-  int *numij;          // number of pairs (I, J) for each atom I   
+  int *numij;          // number of pairs (I, J) for each atom I
   int *idxi;           // storing linear indices of atom I for all pairs (I, J)
   int *ai;             // IDs of atoms I for all pairs (I, J)
   int *aj;             // IDs of atoms J for all pairs (I, J)
   int *ti;             // types of atoms I for all pairs (I, J)
-  int *tj;             // types of atoms J  for all pairs (I, J)  
+  int *tj;             // types of atoms J  for all pairs (I, J)
 
   double besselparams[3];
   double *Phi ;  // eigenvectors matrix ns x ns
-  double *rbf;  // radial basis functions nij x nrbfmax  
-  double *rbfx; // x-derivatives of radial basis functions nij x nrbfmax 
+  double *rbf;  // radial basis functions nij x nrbfmax
+  double *rbfx; // x-derivatives of radial basis functions nij x nrbfmax
   double *rbfy; // y-derivatives of radial basis functions nij x nrbfmax
-  double *rbfz; // z-derivatives of radial basis functions nij x nrbfmax   
+  double *rbfz; // z-derivatives of radial basis functions nij x nrbfmax
   double *abf;  // angular basis functions nij x K3
   double *abfx; // x-derivatives of angular basis functions nij x K3
-  double *abfy; // y-derivatives of angular basis functions nij x K3  
+  double *abfy; // y-derivatives of angular basis functions nij x K3
   double *abfz; // z-derivatives of angular basis functions nij x K3
   double *abftm ; // angular basis functions 4 x K3
   double *sumU; // sum of radial basis functions ni x K3 x nrbfmax x nelements
   double *forcecoeff; // force coefficients ni x K3 x nrbfmax x nelements
   double *Proj; // PCA Projection matrix
-  double *Centroids; // centroids of the clusters  
+  double *Centroids; // centroids of the clusters
   double *bd;   // base descriptors ni x Mdesc
   double *cb;   // force coefficients for base descriptors ni x Mdesc
   double *pd;   // environment probability descriptors ni x nClusters
-  double *bdd;  // base descriptors derivatives 3 x nij x Mdesc   
+  double *bdd;  // base descriptors derivatives 3 x nij x Mdesc
   double *pdd;  // environment probability descriptors derivatives 3 x nij x nClusters
   double *coefficients; // coefficients nCoeffPerElement x nelements
   int *pq3, *pn3, *pc3;       // arrays to compute 3-body angular basis functions
-  int *pa4, *pb4, *pc4; // arrays to compute 4-body angular basis functions    
+  int *pa4, *pb4, *pc4; // arrays to compute 4-body angular basis functions
   int *ind33l, *ind33r; // nl33
   int *ind34l, *ind34r; // nl34
   int *ind44l, *ind44r; // nl44
   int *elemindex;
-     
+
   bool peratom_warn;    // print warning about missing per-atom energies or stresses
 };