diff --git a/src/USER-REAXC/pair_reaxc.cpp b/src/USER-REAXC/pair_reaxc.cpp
index a9501dac9d..8b36019881 100644
--- a/src/USER-REAXC/pair_reaxc.cpp
+++ b/src/USER-REAXC/pair_reaxc.cpp
@@ -141,10 +141,10 @@ PairReaxC::~PairReaxC()
 
     if (control->tabulate ) Deallocate_Lookup_Tables( system);
 
-    if (control->hbond_cut > 0 )  Delete_List( lists+HBONDS, world);
-    Delete_List( lists+BONDS, world );
-    Delete_List( lists+THREE_BODIES, world );
-    Delete_List( lists+FAR_NBRS, world );
+    if (control->hbond_cut > 0 )  Delete_List( lists+HBONDS );
+    Delete_List( lists+BONDS );
+    Delete_List( lists+THREE_BODIES );
+    Delete_List( lists+FAR_NBRS );
 
     DeAllocate_Workspace( control, workspace );
     DeAllocate_System( system );
@@ -439,12 +439,12 @@ void PairReaxC::setup( )
 
     // initialize my data structures
 
-    PreAllocate_Space( system, control, workspace, world );
+    PreAllocate_Space( system, control, workspace );
     write_reax_atoms();
 
     int num_nbrs = estimate_reax_lists();
     if(!Make_List(system->total_cap, num_nbrs, TYP_FAR_NEIGHBOR,
-                  lists+FAR_NBRS, world))
+                  lists+FAR_NBRS))
       error->one(FLERR,"Pair reax/c problem in far neighbor list");
     (lists+FAR_NBRS)->error_ptr=lmp->error;
 
@@ -469,7 +469,7 @@ void PairReaxC::setup( )
 
     // check if I need to shrink/extend my data-structs
 
-    ReAllocate( system, control, data, workspace, &lists, mpi_data );
+    ReAllocate( system, control, data, workspace, &lists );
   }
 
   bigint local_ngroup = list->inum;
@@ -521,7 +521,7 @@ void PairReaxC::compute(int eflag, int vflag)
 
   setup();
 
-  Reset( system, control, data, workspace, &lists, world );
+  Reset( system, control, data, workspace, &lists );
   workspace->realloc.num_far = write_reax_lists();
   // timing for filling in the reax lists
   if (comm->me == 0) {
diff --git a/src/USER-REAXC/reaxc_allocate.cpp b/src/USER-REAXC/reaxc_allocate.cpp
index 8784c854b5..7649c110ef 100644
--- a/src/USER-REAXC/reaxc_allocate.cpp
+++ b/src/USER-REAXC/reaxc_allocate.cpp
@@ -44,7 +44,7 @@ using namespace LAMMPS_NS;
    process's box throughout the whole simulation. therefore
    we need to make upper bound estimates for various data structures */
 int PreAllocate_Space( reax_system *system, control_params * /*control*/,
-                       storage * workspace, MPI_Comm comm )
+                       storage * workspace )
 {
   int mincap = system->mincap;
   double safezone = system->safezone;
@@ -55,7 +55,7 @@ int PreAllocate_Space( reax_system *system, control_params * /*control*/,
   system->total_cap = MAX( (int)(system->N * safezone), mincap );
 
   system->my_atoms = (reax_atom*)
-    scalloc(system->error_ptr,  system->total_cap, sizeof(reax_atom), "my_atoms", comm );
+    scalloc(system->error_ptr,  system->total_cap, sizeof(reax_atom), "my_atoms");
 
   // Nullify some arrays only used in omp styles
   // Should be safe to do here since called in pair->setup();
@@ -212,7 +212,7 @@ void DeAllocate_Workspace( control_params * control, storage *workspace )
 
 int Allocate_Workspace( reax_system * /*system*/, control_params * control,
                         storage *workspace, int local_cap, int total_cap,
-                        MPI_Comm comm, char * /*msg*/ )
+                        char * /*msg*/ )
 {
   int i, total_real, total_rvec, local_rvec;
 
@@ -224,84 +224,84 @@ int Allocate_Workspace( reax_system * /*system*/, control_params * control,
   /* communication storage */
   for( i = 0; i < MAX_NBRS; ++i ) {
     workspace->tmp_dbl[i] = (double*)
-      scalloc(control->error_ptr,  total_cap, sizeof(double), "tmp_dbl", comm );
+      scalloc(control->error_ptr,  total_cap, sizeof(double), "tmp_dbl");
     workspace->tmp_rvec[i] = (rvec*)
-      scalloc(control->error_ptr,  total_cap, sizeof(rvec), "tmp_rvec", comm );
+      scalloc(control->error_ptr,  total_cap, sizeof(rvec), "tmp_rvec");
     workspace->tmp_rvec2[i] = (rvec2*)
-      scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "tmp_rvec2", comm );
+      scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "tmp_rvec2");
   }
 
   /* bond order related storage  */
   workspace->within_bond_box = (int*)
-    scalloc(control->error_ptr,  total_cap, sizeof(int), "skin", comm );
-  workspace->total_bond_order = (double*) smalloc(control->error_ptr,  total_real, "total_bo", comm );
-  workspace->Deltap = (double*) smalloc(control->error_ptr,  total_real, "Deltap", comm );
-  workspace->Deltap_boc = (double*) smalloc(control->error_ptr,  total_real, "Deltap_boc", comm );
-  workspace->dDeltap_self = (rvec*) smalloc(control->error_ptr,  total_rvec, "dDeltap_self", comm );
-  workspace->Delta = (double*) smalloc(control->error_ptr,  total_real, "Delta", comm );
-  workspace->Delta_lp = (double*) smalloc(control->error_ptr,  total_real, "Delta_lp", comm );
+    scalloc(control->error_ptr,  total_cap, sizeof(int), "skin");
+  workspace->total_bond_order = (double*) smalloc(control->error_ptr,  total_real, "total_bo");
+  workspace->Deltap = (double*) smalloc(control->error_ptr,  total_real, "Deltap");
+  workspace->Deltap_boc = (double*) smalloc(control->error_ptr,  total_real, "Deltap_boc");
+  workspace->dDeltap_self = (rvec*) smalloc(control->error_ptr,  total_rvec, "dDeltap_self");
+  workspace->Delta = (double*) smalloc(control->error_ptr,  total_real, "Delta");
+  workspace->Delta_lp = (double*) smalloc(control->error_ptr,  total_real, "Delta_lp");
   workspace->Delta_lp_temp = (double*)
-    smalloc(control->error_ptr,  total_real, "Delta_lp_temp", comm );
-  workspace->dDelta_lp = (double*) smalloc(control->error_ptr,  total_real, "dDelta_lp", comm );
+    smalloc(control->error_ptr,  total_real, "Delta_lp_temp");
+  workspace->dDelta_lp = (double*) smalloc(control->error_ptr,  total_real, "dDelta_lp");
   workspace->dDelta_lp_temp = (double*)
-    smalloc(control->error_ptr,  total_real, "dDelta_lp_temp", comm );
-  workspace->Delta_e = (double*) smalloc(control->error_ptr,  total_real, "Delta_e", comm );
-  workspace->Delta_boc = (double*) smalloc(control->error_ptr,  total_real, "Delta_boc", comm );
-  workspace->Delta_val = (double*) smalloc(control->error_ptr,  total_real, "Delta_val", comm );
-  workspace->nlp = (double*) smalloc(control->error_ptr,  total_real, "nlp", comm );
-  workspace->nlp_temp = (double*) smalloc(control->error_ptr,  total_real, "nlp_temp", comm );
-  workspace->Clp = (double*) smalloc(control->error_ptr,  total_real, "Clp", comm );
-  workspace->vlpex = (double*) smalloc(control->error_ptr,  total_real, "vlpex", comm );
+    smalloc(control->error_ptr,  total_real, "dDelta_lp_temp");
+  workspace->Delta_e = (double*) smalloc(control->error_ptr,  total_real, "Delta_e");
+  workspace->Delta_boc = (double*) smalloc(control->error_ptr,  total_real, "Delta_boc");
+  workspace->Delta_val = (double*) smalloc(control->error_ptr,  total_real, "Delta_val");
+  workspace->nlp = (double*) smalloc(control->error_ptr,  total_real, "nlp");
+  workspace->nlp_temp = (double*) smalloc(control->error_ptr,  total_real, "nlp_temp");
+  workspace->Clp = (double*) smalloc(control->error_ptr,  total_real, "Clp");
+  workspace->vlpex = (double*) smalloc(control->error_ptr,  total_real, "vlpex");
   workspace->bond_mark = (int*)
-    scalloc(control->error_ptr,  total_cap, sizeof(int), "bond_mark", comm );
+    scalloc(control->error_ptr,  total_cap, sizeof(int), "bond_mark");
   workspace->done_after = (int*)
-    scalloc(control->error_ptr,  total_cap, sizeof(int), "done_after", comm );
+    scalloc(control->error_ptr,  total_cap, sizeof(int), "done_after");
 
   /* QEq storage */
   workspace->Hdia_inv = (double*)
-    scalloc(control->error_ptr,  total_cap, sizeof(double), "Hdia_inv", comm );
-  workspace->b_s = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_s", comm );
-  workspace->b_t = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_t", comm );
-  workspace->b_prc = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_prc", comm );
-  workspace->b_prm = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_prm", comm );
-  workspace->s = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "s", comm );
-  workspace->t = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "t", comm );
+    scalloc(control->error_ptr,  total_cap, sizeof(double), "Hdia_inv");
+  workspace->b_s = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_s");
+  workspace->b_t = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_t");
+  workspace->b_prc = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_prc");
+  workspace->b_prm = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "b_prm");
+  workspace->s = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "s");
+  workspace->t = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "t");
   workspace->droptol = (double*)
-    scalloc(control->error_ptr,  total_cap, sizeof(double), "droptol", comm );
-  workspace->b = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "b", comm );
-  workspace->x = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "x", comm );
+    scalloc(control->error_ptr,  total_cap, sizeof(double), "droptol");
+  workspace->b = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "b");
+  workspace->x = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "x");
 
   /* GMRES storage */
-  workspace->y = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "y", comm );
-  workspace->z = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "z", comm );
-  workspace->g = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "g", comm );
-  workspace->h = (double**) scalloc(control->error_ptr,  RESTART+1, sizeof(double*), "h", comm );
-  workspace->hs = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "hs", comm );
-  workspace->hc = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "hc", comm );
-  workspace->v = (double**) scalloc(control->error_ptr,  RESTART+1, sizeof(double*), "v", comm );
+  workspace->y = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "y");
+  workspace->z = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "z");
+  workspace->g = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "g");
+  workspace->h = (double**) scalloc(control->error_ptr,  RESTART+1, sizeof(double*), "h");
+  workspace->hs = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "hs");
+  workspace->hc = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "hc");
+  workspace->v = (double**) scalloc(control->error_ptr,  RESTART+1, sizeof(double*), "v");
 
   for( i = 0; i < RESTART+1; ++i ) {
-    workspace->h[i] = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "h[i]", comm );
-    workspace->v[i] = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "v[i]", comm );
+    workspace->h[i] = (double*) scalloc(control->error_ptr,  RESTART+1, sizeof(double), "h[i]");
+    workspace->v[i] = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "v[i]");
   }
 
   /* CG storage */
-  workspace->r = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "r", comm );
-  workspace->d = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "d", comm );
-  workspace->q = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "q", comm );
-  workspace->p = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "p", comm );
-  workspace->r2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "r2", comm );
-  workspace->d2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "d2", comm );
-  workspace->q2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "q2", comm );
-  workspace->p2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "p2", comm );
+  workspace->r = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "r");
+  workspace->d = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "d");
+  workspace->q = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "q");
+  workspace->p = (double*) scalloc(control->error_ptr,  total_cap, sizeof(double), "p");
+  workspace->r2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "r2");
+  workspace->d2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "d2");
+  workspace->q2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "q2");
+  workspace->p2 = (rvec2*) scalloc(control->error_ptr,  total_cap, sizeof(rvec2), "p2");
 
   /* integrator storage */
-  workspace->v_const = (rvec*) smalloc(control->error_ptr,  local_rvec, "v_const", comm );
+  workspace->v_const = (rvec*) smalloc(control->error_ptr,  local_rvec, "v_const");
 
   /* force related storage */
-  workspace->f = (rvec*) scalloc(control->error_ptr,  total_cap, sizeof(rvec), "f", comm );
+  workspace->f = (rvec*) scalloc(control->error_ptr,  total_cap, sizeof(rvec), "f");
   workspace->CdDelta = (double*)
-    scalloc(control->error_ptr,  total_cap, sizeof(double), "CdDelta", comm );
+    scalloc(control->error_ptr,  total_cap, sizeof(double), "CdDelta");
 
   // storage for reductions with multiple threads
 #ifdef LMP_USER_OMP
@@ -322,17 +322,16 @@ int Allocate_Workspace( reax_system * /*system*/, control_params * control,
 
 
 static void Reallocate_Neighbor_List( reax_list *far_nbrs, int n,
-                                      int num_intrs, MPI_Comm comm )
+                                      int num_intrs )
 {
-  Delete_List( far_nbrs, comm );
-  if(!Make_List( n, num_intrs, TYP_FAR_NEIGHBOR, far_nbrs, comm )){
+  Delete_List( far_nbrs);
+  if(!Make_List( n, num_intrs, TYP_FAR_NEIGHBOR, far_nbrs )){
     far_nbrs->error_ptr->one(FLERR,"Problem in initializing far neighbors list");
   }
 }
 
 
-static int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds,
-                                   MPI_Comm comm )
+static int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds )
 {
   int i, total_hbonds;
 
@@ -346,8 +345,8 @@ static int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds,
     }
   total_hbonds = (int)(MAX( total_hbonds*saferzone, mincap*MIN_HBONDS ));
 
-  Delete_List( hbonds, comm );
-  if (!Make_List( system->Hcap, total_hbonds, TYP_HBOND, hbonds, comm )) {
+  Delete_List( hbonds);
+  if (!Make_List( system->Hcap, total_hbonds, TYP_HBOND, hbonds )) {
     hbonds->error_ptr->one(FLERR, "Not enough space for hydrogen bonds list");
   }
 
@@ -356,8 +355,7 @@ static int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds,
 
 
 static int Reallocate_Bonds_List( reax_system *system, reax_list *bonds,
-                                  int *total_bonds, int *est_3body,
-                                  MPI_Comm comm )
+                                  int *total_bonds, int *est_3body )
 {
   int i;
 
@@ -378,8 +376,8 @@ static int Reallocate_Bonds_List( reax_system *system, reax_list *bonds,
       sfree(system->error_ptr, bonds->select.bond_list[i].bo_data.CdboReduction, "CdboReduction");
 #endif
 
-  Delete_List( bonds, comm );
-  if(!Make_List(system->total_cap, *total_bonds, TYP_BOND, bonds, comm)) {
+  Delete_List( bonds);
+  if(!Make_List(system->total_cap, *total_bonds, TYP_BOND, bonds)) {
     bonds->error_ptr->one(FLERR, "Not enough space for bonds list");
   }
 
@@ -401,14 +399,12 @@ static int Reallocate_Bonds_List( reax_system *system, reax_list *bonds,
 
 
 void ReAllocate( reax_system *system, control_params *control,
-                 simulation_data *data, storage *workspace, reax_list **lists,
-                 mpi_datatypes *mpi_data )
+                 simulation_data *data, storage *workspace, reax_list **lists )
 {
   int num_bonds, est_3body, Hflag, ret;
   int renbr, newsize;
   reallocate_data *realloc;
   reax_list *far_nbrs;
-  MPI_Comm comm;
   char msg[200];
 
   int mincap = system->mincap;
@@ -416,7 +412,6 @@ void ReAllocate( reax_system *system, control_params *control,
   double saferzone = system->saferzone;
 
   realloc = &(workspace->realloc);
-  comm = mpi_data->world;
 
   if( system->n >= DANGER_ZONE * system->local_cap ||
       (0 && system->n <= LOOSE_ZONE * system->local_cap) ) {
@@ -434,18 +429,18 @@ void ReAllocate( reax_system *system, control_params *control,
     /* system */
     ret = Allocate_System( system, system->local_cap, system->total_cap, msg );
     if (ret != SUCCESS) {
-      char errmsg[128];
-      snprintf(errmsg, 128, "Not enough space for atom_list: total_cap=%d", system->total_cap);
+      char errmsg[256];
+      snprintf(errmsg, 256, "Not enough space for atom_list: total_cap=%d", system->total_cap);
       system->error_ptr->one(FLERR, errmsg);
     }
 
     /* workspace */
     DeAllocate_Workspace( control, workspace );
     ret = Allocate_Workspace( system, control, workspace, system->local_cap,
-                              system->total_cap, comm, msg );
+                              system->total_cap, msg );
     if (ret != SUCCESS) {
-      char errmsg[128];
-      snprintf(errmsg, 128, "Not enough space for workspace: local_cap=%d total_cap=%d", system->local_cap, system->total_cap);
+      char errmsg[256];
+      snprintf(errmsg, 256, "Not enough space for workspace: local_cap=%d total_cap=%d", system->local_cap, system->total_cap);
       system->error_ptr->one(FLERR, errmsg);
     }
   }
@@ -458,15 +453,15 @@ void ReAllocate( reax_system *system, control_params *control,
 
     if (Nflag || realloc->num_far >= far_nbrs->num_intrs * DANGER_ZONE) {
       if (realloc->num_far > far_nbrs->num_intrs) {
-        char errmsg[128];
-        snprintf(errmsg, 128, "step%d-ran out of space on far_nbrs: top=%d, max=%d", data->step, realloc->num_far, far_nbrs->num_intrs);
+        char errmsg[256];
+        snprintf(errmsg, 256, "step%d-ran out of space on far_nbrs: top=%d, max=%d", data->step, realloc->num_far, far_nbrs->num_intrs);
         system->error_ptr->one(FLERR, errmsg);
       }
 
       newsize = static_cast<int>
         (MAX( realloc->num_far*safezone, mincap*MIN_NBRS ));
 
-      Reallocate_Neighbor_List( far_nbrs, system->total_cap, newsize, comm );
+      Reallocate_Neighbor_List( far_nbrs, system->total_cap, newsize);
       realloc->num_far = 0;
     }
   }
@@ -481,7 +476,7 @@ void ReAllocate( reax_system *system, control_params *control,
     }
 
     if (Hflag || realloc->hbonds) {
-      ret = Reallocate_HBonds_List( system, (*lists)+HBONDS, comm );
+      ret = Reallocate_HBonds_List( system, (*lists)+HBONDS);
       realloc->hbonds = 0;
     }
   }
@@ -490,14 +485,14 @@ void ReAllocate( reax_system *system, control_params *control,
   num_bonds = est_3body = -1;
   if (Nflag || realloc->bonds) {
     Reallocate_Bonds_List( system, (*lists)+BONDS, &num_bonds,
-                           &est_3body, comm );
+                           &est_3body);
     realloc->bonds = 0;
     realloc->num_3body = MAX( realloc->num_3body, est_3body ) * 2;
   }
 
   /* 3-body list */
   if (realloc->num_3body > 0) {
-    Delete_List( (*lists)+THREE_BODIES, comm );
+    Delete_List( (*lists)+THREE_BODIES);
 
     if (num_bonds == -1)
       num_bonds = ((*lists)+BONDS)->num_intrs;
@@ -505,7 +500,7 @@ void ReAllocate( reax_system *system, control_params *control,
     realloc->num_3body = (int)(MAX(realloc->num_3body*safezone, MIN_3BODIES));
 
     if( !Make_List( num_bonds, realloc->num_3body, TYP_THREE_BODY,
-                    (*lists)+THREE_BODIES, comm ) ) {
+                    (*lists)+THREE_BODIES ) ) {
       system->error_ptr->one(FLERR, "Problem in initializing angles list");
     }
     realloc->num_3body = -1;
diff --git a/src/USER-REAXC/reaxc_allocate.h b/src/USER-REAXC/reaxc_allocate.h
index f813204006..be203340f6 100644
--- a/src/USER-REAXC/reaxc_allocate.h
+++ b/src/USER-REAXC/reaxc_allocate.h
@@ -28,20 +28,15 @@
 #define __ALLOCATE_H_
 
 #include "reaxc_types.h"
-
-#include "lammps.h"
-#include "error.h"
-using namespace LAMMPS_NS;
-
-int  PreAllocate_Space( reax_system*, control_params*, storage*, MPI_Comm );
+int  PreAllocate_Space( reax_system*, control_params*, storage* );
 
 int  Allocate_System( reax_system*, int, int, char* );
 void DeAllocate_System( reax_system* );
 
 int  Allocate_Workspace( reax_system*, control_params*, storage*,
-                         int, int, MPI_Comm, char* );
+                         int, int, char* );
 void DeAllocate_Workspace( control_params*, storage* );
 
 void ReAllocate( reax_system*, control_params*, simulation_data*, storage*,
-                 reax_list**, mpi_datatypes* );
+                 reax_list** );
 #endif
diff --git a/src/USER-REAXC/reaxc_control.cpp b/src/USER-REAXC/reaxc_control.cpp
index 14b28615fb..0caae40156 100644
--- a/src/USER-REAXC/reaxc_control.cpp
+++ b/src/USER-REAXC/reaxc_control.cpp
@@ -28,7 +28,6 @@
 #include "reaxc_control.h"
 #include "reaxc_tool_box.h"
 
-
 char Read_Control_File( char *control_file, control_params* control,
                         output_controls *out_control )
 {
diff --git a/src/USER-REAXC/reaxc_control.h b/src/USER-REAXC/reaxc_control.h
index 47627aed61..b2b455d6b8 100644
--- a/src/USER-REAXC/reaxc_control.h
+++ b/src/USER-REAXC/reaxc_control.h
@@ -29,9 +29,6 @@
 
 #include "reaxc_types.h"
 
-#include "lammps.h"
-#include "error.h"
-
 char Read_Control_File( char*, control_params*, output_controls* );
 
 #endif
diff --git a/src/USER-REAXC/reaxc_ffield.cpp b/src/USER-REAXC/reaxc_ffield.cpp
index 987a11d252..28bc0429cc 100644
--- a/src/USER-REAXC/reaxc_ffield.cpp
+++ b/src/USER-REAXC/reaxc_ffield.cpp
@@ -44,7 +44,6 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
   double     val;
   MPI_Comm comm;
   int me;
-  
   comm = MPI_COMM_WORLD;
   MPI_Comm_rank(comm, &me);
 
@@ -99,55 +98,45 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
 
   /* Allocating structures in reax_interaction */
   reax->sbp = (single_body_parameters*)
-    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(single_body_parameters), "sbp",
-             comm );
+    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(single_body_parameters), "sbp");
   reax->tbp = (two_body_parameters**)
-    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(two_body_parameters*), "tbp", comm );
+    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(two_body_parameters*), "tbp");
   reax->thbp= (three_body_header***)
-    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(three_body_header**), "thbp", comm );
+    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(three_body_header**), "thbp");
   reax->hbp = (hbond_parameters***)
-    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(hbond_parameters**), "hbp", comm );
+    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(hbond_parameters**), "hbp");
   reax->fbp = (four_body_header****)
-    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header***), "fbp", comm );
+    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header***), "fbp");
   tor_flag  = (char****)
-    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char***), "tor_flag", comm );
+    scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char***), "tor_flag");
 
   for( i = 0; i < reax->num_atom_types; i++ ) {
     reax->tbp[i] = (two_body_parameters*)
-      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(two_body_parameters), "tbp[i]",
-               comm );
+      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(two_body_parameters), "tbp[i]");
     reax->thbp[i]= (three_body_header**)
-      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(three_body_header*), "thbp[i]",
-               comm );
+      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(three_body_header*), "thbp[i]");
     reax->hbp[i] = (hbond_parameters**)
-      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(hbond_parameters*), "hbp[i]",
-               comm );
+      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(hbond_parameters*), "hbp[i]");
     reax->fbp[i] = (four_body_header***)
-      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header**), "fbp[i]",
-               comm );
+      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header**), "fbp[i]");
     tor_flag[i]  = (char***)
-      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char**), "tor_flag[i]", comm );
+      scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char**), "tor_flag[i]");
 
     for( j = 0; j < reax->num_atom_types; j++ ) {
       reax->thbp[i][j]= (three_body_header*)
-        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(three_body_header), "thbp[i,j]",
-                 comm );
+        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(three_body_header), "thbp[i,j]");
       reax->hbp[i][j] = (hbond_parameters*)
-        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(hbond_parameters), "hbp[i,j]",
-                 comm );
+        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(hbond_parameters), "hbp[i,j]");
       reax->fbp[i][j] = (four_body_header**)
-        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header*), "fbp[i,j]",
-                 comm );
+        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header*), "fbp[i,j]");
       tor_flag[i][j]  = (char**)
-        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char*), "tor_flag[i,j]", comm );
+        scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char*), "tor_flag[i,j]");
 
       for (k=0; k < reax->num_atom_types; k++) {
         reax->fbp[i][j][k] = (four_body_header*)
-          scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header), "fbp[i,j,k]",
-                   comm );
+          scalloc(control->error_ptr,  reax->num_atom_types, sizeof(four_body_header), "fbp[i,j,k]");
         tor_flag[i][j][k]  = (char*)
-          scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char), "tor_flag[i,j,k]",
-                   comm );
+          scalloc(control->error_ptr,  reax->num_atom_types, sizeof(char), "tor_flag[i,j,k]");
       }
     }
   }
@@ -163,7 +152,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
     /* Sanity checks */
     
     if (c < 9) {
-      control->error_ptr->one(FLERR,"Inconsistent ffield file");
+      control->error_ptr->all(FLERR,"Inconsistent ffield file");
     }
 
     for( j = 0; j < (int)(strlen(tmp[0])); ++j )
@@ -185,7 +174,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
 
     /* Sanity check */
     if (c < 8) {
-      control->error_ptr->one(FLERR,"Inconsistent ffield file");
+      control->error_ptr->all(FLERR,"Inconsistent ffield file");
     }
 
     val = atof(tmp[0]); reax->sbp[i].alpha      = val;
@@ -203,7 +192,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
 
     /* Sanity check */
     if (c < 8) {
-      control->error_ptr->one(FLERR,"Inconsistent ffield file");
+      control->error_ptr->all(FLERR,"Inconsistent ffield file");
     }
 
     val = atof(tmp[0]); reax->sbp[i].r_pi_pi    = val;
@@ -221,7 +210,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
 
     /* Sanity check */
     if (c < 8) {
-      control->error_ptr->one(FLERR,"Inconsistent ffield file");
+      control->error_ptr->all(FLERR,"Inconsistent ffield file");
     }
 
     val = atof(tmp[0]); reax->sbp[i].p_ovun2    = val;
@@ -240,7 +229,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
 
       /* Sanity check */
       if (c > 2) {
-        control->error_ptr->one(FLERR,"Force field file incompatible with 'lgvdw yes'");
+        control->error_ptr->all(FLERR,"Force field file incompatible with 'lgvdw yes'");
       }
 
       val = atof(tmp[0]); reax->sbp[i].lgcij           = val;
@@ -337,8 +326,6 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
     fgets(s,MAX_LINE,fp);
     c=Tokenize(s,&tmp);
 
-    
-
     j = atoi(tmp[0]) - 1;
     k = atoi(tmp[1]) - 1;
 
diff --git a/src/USER-REAXC/reaxc_forces.cpp b/src/USER-REAXC/reaxc_forces.cpp
index ff1dd839fb..afe9a059ed 100644
--- a/src/USER-REAXC/reaxc_forces.cpp
+++ b/src/USER-REAXC/reaxc_forces.cpp
@@ -116,7 +116,7 @@ void Compute_Total_Force( reax_system *system, control_params *control,
 }
 
 void Validate_Lists( reax_system *system, storage * /*workspace*/, reax_list **lists,
-                     int step, int /*n*/, int N, int numH, MPI_Comm comm )
+                     int step, int /*n*/, int N, int numH )
 {
   int i, comp, Hindex;
   reax_list *bonds, *hbonds;
@@ -176,8 +176,7 @@ void Validate_Lists( reax_system *system, storage * /*workspace*/, reax_list **l
 
 void Init_Forces_noQEq( reax_system *system, control_params *control,
                         simulation_data *data, storage *workspace,
-                        reax_list **lists, output_controls * /*out_control*/,
-                        MPI_Comm comm ) {
+                        reax_list **lists, output_controls * /*out_control*/ ) {
   int i, j, pj;
   int start_i, end_i;
   int type_i, type_j;
@@ -311,13 +310,13 @@ void Init_Forces_noQEq( reax_system *system, control_params *control,
   workspace->realloc.num_hbonds = num_hbonds;
 
   Validate_Lists( system, workspace, lists, data->step,
-                  system->n, system->N, system->numH, comm );
+                  system->n, system->N, system->numH);
 }
 
 
 void Estimate_Storages( reax_system *system, control_params *control,
                         reax_list **lists, int *Htop, int *hb_top,
-                        int *bond_top, int *num_3body, MPI_Comm /*comm*/ )
+                        int *bond_top, int *num_3body )
 {
   int i, j, pj;
   int start_i, end_i;
@@ -439,10 +438,9 @@ void Compute_Forces( reax_system *system, control_params *control,
                      reax_list **lists, output_controls *out_control,
                      mpi_datatypes *mpi_data )
 {
-  MPI_Comm comm = mpi_data->world;
 
   Init_Forces_noQEq( system, control, data, workspace,
-                       lists, out_control, comm );
+                       lists, out_control);
 
   /********* bonded interactions ************/
   Compute_Bonded_Forces( system, control, data, workspace,
diff --git a/src/USER-REAXC/reaxc_forces.h b/src/USER-REAXC/reaxc_forces.h
index 6c839a7023..bfad2e9b71 100644
--- a/src/USER-REAXC/reaxc_forces.h
+++ b/src/USER-REAXC/reaxc_forces.h
@@ -36,5 +36,5 @@ void Init_Force_Functions( control_params* );
 void Compute_Forces( reax_system*, control_params*, simulation_data*,
                      storage*, reax_list**, output_controls*, mpi_datatypes* );
 void Estimate_Storages( reax_system*, control_params*, reax_list**,
-                        int*, int*, int*, int*, MPI_Comm );
+                        int*, int*, int*, int* );
 #endif
diff --git a/src/USER-REAXC/reaxc_init_md.cpp b/src/USER-REAXC/reaxc_init_md.cpp
index 27e60c580c..913bc241de 100644
--- a/src/USER-REAXC/reaxc_init_md.cpp
+++ b/src/USER-REAXC/reaxc_init_md.cpp
@@ -81,7 +81,7 @@ int Init_Simulation_Data( reax_system *system, control_params *control,
   return SUCCESS;
 }
 
-void Init_Taper( control_params *control,  storage *workspace, MPI_Comm comm )
+void Init_Taper( control_params *control,  storage *workspace )
 {
   double d1, d7;
   double swa, swa2, swa3;
@@ -122,12 +122,12 @@ void Init_Taper( control_params *control,  storage *workspace, MPI_Comm comm )
 
 
 int Init_Workspace( reax_system *system, control_params *control,
-                    storage *workspace, MPI_Comm comm, char *msg )
+                    storage *workspace, char *msg )
 {
   int ret;
 
   ret = Allocate_Workspace( system, control, workspace,
-                            system->local_cap, system->total_cap, comm, msg );
+                            system->local_cap, system->total_cap, msg );
   if (ret != SUCCESS)
     return ret;
 
@@ -135,7 +135,7 @@ int Init_Workspace( reax_system *system, control_params *control,
   Reset_Workspace( system, workspace );
 
   /* Initialize the Taper function */
-  Init_Taper( control, workspace, comm );
+  Init_Taper( control, workspace);
 
   return SUCCESS;
 }
@@ -159,17 +159,15 @@ int  Init_Lists( reax_system *system, control_params *control,
 {
   int i, total_hbonds, total_bonds, bond_cap, num_3body, cap_3body, Htop;
   int *hb_top, *bond_top;
-  MPI_Comm comm;
 
   int mincap = system->mincap;
   double safezone = system->safezone;
   double saferzone = system->saferzone;
 
-  comm = mpi_data->world;
   bond_top = (int*) calloc( system->total_cap, sizeof(int) );
   hb_top = (int*) calloc( system->local_cap, sizeof(int) );
   Estimate_Storages( system, control, lists,
-                     &Htop, hb_top, bond_top, &num_3body, comm );
+                     &Htop, hb_top, bond_top, &num_3body);
 
   if (control->hbond_cut > 0) {
     /* init H indexes */
@@ -181,7 +179,7 @@ int  Init_Lists( reax_system *system, control_params *control,
     total_hbonds = (int)(MAX( total_hbonds*saferzone, mincap*MIN_HBONDS ));
 
     if( !Make_List( system->Hcap, total_hbonds, TYP_HBOND,
-                    *lists+HBONDS, comm ) ) {
+                    *lists+HBONDS ) ) {
       control->error_ptr->one(FLERR, "Not enough space for hbonds list.");
     }
     (*lists+HBONDS)->error_ptr = system->error_ptr;
@@ -195,7 +193,7 @@ int  Init_Lists( reax_system *system, control_params *control,
   bond_cap = (int)(MAX( total_bonds*safezone, mincap*MIN_BONDS ));
 
   if( !Make_List( system->total_cap, bond_cap, TYP_BOND,
-                  *lists+BONDS, comm ) ) {
+                  *lists+BONDS ) ) {
     control->error_ptr->one(FLERR, "Not enough space for bonds list.");
   }
   (*lists+BONDS)->error_ptr = system->error_ptr;
@@ -203,7 +201,7 @@ int  Init_Lists( reax_system *system, control_params *control,
   /* 3bodies list */
   cap_3body = (int)(MAX( num_3body*safezone, MIN_3BODIES ));
   if( !Make_List( bond_cap, cap_3body, TYP_THREE_BODY,
-                  *lists+THREE_BODIES, comm ) ){
+                  *lists+THREE_BODIES ) ){
     control->error_ptr->one(FLERR,"Problem in initializing angles list.");
   }
   (*lists+THREE_BODIES)->error_ptr = system->error_ptr;
@@ -242,7 +240,7 @@ void Initialize( reax_system *system, control_params *control,
     control->error_ptr->one(FLERR,errmsg);
   }
 
-  if (Init_Workspace( system, control, workspace, mpi_data->world, msg ) ==
+  if (Init_Workspace( system, control, workspace, msg ) ==
       FAILURE) {
     snprintf(errmsg, 128, "Workspace could not be initialized on thread %d",
               system->my_rank);
diff --git a/src/USER-REAXC/reaxc_init_md.h b/src/USER-REAXC/reaxc_init_md.h
index 546a9e33c9..ab519a4c72 100644
--- a/src/USER-REAXC/reaxc_init_md.h
+++ b/src/USER-REAXC/reaxc_init_md.h
@@ -29,8 +29,6 @@
 
 #include "reaxc_types.h"
 
-#include "lammps.h"
-#include "error.h"
 
 void Initialize( reax_system*, control_params*, simulation_data*, storage*,
                  reax_list**, output_controls*, mpi_datatypes*, MPI_Comm );
diff --git a/src/USER-REAXC/reaxc_list.cpp b/src/USER-REAXC/reaxc_list.cpp
index f103e520e8..d0143ec9ae 100644
--- a/src/USER-REAXC/reaxc_list.cpp
+++ b/src/USER-REAXC/reaxc_list.cpp
@@ -29,7 +29,7 @@
 #include "reaxc_tool_box.h"
 
 /************* allocate list space ******************/
-int Make_List( int n, int num_intrs, int type, reax_list *l, MPI_Comm comm)
+int Make_List(int n, int num_intrs, int type, reax_list *l )
 {
   l->allocated = 1;
 
@@ -38,52 +38,52 @@ int Make_List( int n, int num_intrs, int type, reax_list *l, MPI_Comm comm)
 
   if (l->index) sfree(l->error_ptr, l->index, "list:index");
   if (l->end_index) sfree(l->error_ptr, l->end_index, "list:end_index");
-  l->index = (int*) smalloc(l->error_ptr,  n * sizeof(int), "list:index", comm );
-  l->end_index = (int*) smalloc(l->error_ptr,  n * sizeof(int), "list:end_index", comm );
+  l->index = (int*) smalloc(l->error_ptr,  n * sizeof(int), "list:index");
+  l->end_index = (int*) smalloc(l->error_ptr,  n * sizeof(int), "list:end_index");
 
   l->type = type;
 
   switch(l->type) {
   case TYP_VOID:
     if (l->select.v) sfree(l->error_ptr, l->select.v, "list:v");
-    l->select.v = (void*) smalloc(l->error_ptr, l->num_intrs * sizeof(void*), "list:v", comm);
+    l->select.v = (void*) smalloc(l->error_ptr, l->num_intrs * sizeof(void*), "list:v");
     break;
 
   case TYP_THREE_BODY:
     if (l->select.three_body_list) sfree(l->error_ptr, l->select.three_body_list,"list:three_bodies");
     l->select.three_body_list = (three_body_interaction_data*)
       smalloc(l->error_ptr,  l->num_intrs * sizeof(three_body_interaction_data),
-               "list:three_bodies", comm );
+               "list:three_bodies");
     break;
 
   case TYP_BOND:
     if (l->select.bond_list) sfree(l->error_ptr, l->select.bond_list,"list:bonds");
     l->select.bond_list = (bond_data*)
-      smalloc(l->error_ptr,  l->num_intrs * sizeof(bond_data), "list:bonds", comm );
+      smalloc(l->error_ptr,  l->num_intrs * sizeof(bond_data), "list:bonds");
     break;
 
   case TYP_DBO:
     if (l->select.dbo_list) sfree(l->error_ptr, l->select.dbo_list,"list:dbonds");
     l->select.dbo_list = (dbond_data*)
-      smalloc(l->error_ptr,  l->num_intrs * sizeof(dbond_data), "list:dbonds", comm );
+      smalloc(l->error_ptr,  l->num_intrs * sizeof(dbond_data), "list:dbonds");
     break;
 
   case TYP_DDELTA:
     if (l->select.dDelta_list) sfree(l->error_ptr, l->select.dDelta_list,"list:dDeltas");
     l->select.dDelta_list = (dDelta_data*)
-      smalloc(l->error_ptr,  l->num_intrs * sizeof(dDelta_data), "list:dDeltas", comm );
+      smalloc(l->error_ptr,  l->num_intrs * sizeof(dDelta_data), "list:dDeltas");
     break;
 
   case TYP_FAR_NEIGHBOR:
     if (l->select.far_nbr_list) sfree(l->error_ptr, l->select.far_nbr_list,"list:far_nbrs");
     l->select.far_nbr_list = (far_neighbor_data*)
-      smalloc(l->error_ptr, l->num_intrs * sizeof(far_neighbor_data), "list:far_nbrs", comm);
+      smalloc(l->error_ptr, l->num_intrs * sizeof(far_neighbor_data), "list:far_nbrs");
     break;
 
   case TYP_HBOND:
     if (l->select.hbond_list) sfree(l->error_ptr, l->select.hbond_list,"list:hbonds");
     l->select.hbond_list = (hbond_data*)
-      smalloc(l->error_ptr,  l->num_intrs * sizeof(hbond_data), "list:hbonds", comm );
+      smalloc(l->error_ptr,  l->num_intrs * sizeof(hbond_data), "list:hbonds");
     break;
 
   default:
@@ -96,7 +96,7 @@ int Make_List( int n, int num_intrs, int type, reax_list *l, MPI_Comm comm)
 }
 
 
-void Delete_List( reax_list *l, MPI_Comm comm )
+void Delete_List( reax_list *l )
 {
   if (l->allocated == 0)
     return;
diff --git a/src/USER-REAXC/reaxc_list.h b/src/USER-REAXC/reaxc_list.h
index ab7fbce19c..28567252da 100644
--- a/src/USER-REAXC/reaxc_list.h
+++ b/src/USER-REAXC/reaxc_list.h
@@ -29,8 +29,8 @@
 
 #include "reaxc_types.h"
 
-int  Make_List( int, int, int, reax_list*, MPI_Comm );
-void Delete_List( reax_list*, MPI_Comm );
+int  Make_List( int, int, int, reax_list* );
+void Delete_List( reax_list* );
 
 inline int  Num_Entries(int,reax_list*);
 inline int  Start_Index( int, reax_list* );
diff --git a/src/USER-REAXC/reaxc_lookup.cpp b/src/USER-REAXC/reaxc_lookup.cpp
index b140b0cadf..74d8176522 100644
--- a/src/USER-REAXC/reaxc_lookup.cpp
+++ b/src/USER-REAXC/reaxc_lookup.cpp
@@ -51,18 +51,17 @@ void Tridiagonal_Solve( const double *a, const double *b,
 
 
 void Natural_Cubic_Spline( LAMMPS_NS::Error* error_ptr, const double *h, const double *f,
-                           cubic_spline_coef *coef, unsigned int n,
-                           MPI_Comm comm )
+                           cubic_spline_coef *coef, unsigned int n )
 {
   int i;
   double *a, *b, *c, *d, *v;
 
   /* allocate space for the linear system */
-  a = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  b = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  c = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  d = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  v = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
+  a = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  b = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  c = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  d = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  v = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
 
   /* build the linear system */
   a[0] = a[1] = a[n-1] = 0;
@@ -102,18 +101,17 @@ void Natural_Cubic_Spline( LAMMPS_NS::Error* error_ptr, const double *h, const d
 
 
 void Complete_Cubic_Spline( LAMMPS_NS::Error* error_ptr, const double *h, const double *f, double v0, double vlast,
-                            cubic_spline_coef *coef, unsigned int n,
-                            MPI_Comm comm )
+                            cubic_spline_coef *coef, unsigned int n )
 {
   int i;
   double *a, *b, *c, *d, *v;
 
   /* allocate space for the linear system */
-  a = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  b = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  c = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  d = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
-  v = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a", comm );
+  a = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  b = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  c = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  d = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
+  v = (double*) smalloc(error_ptr,  n * sizeof(double), "cubic_spline:a");
 
   /* build the linear system */
   a[0] = 0;
@@ -159,35 +157,33 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
   double dr;
   double *h, *fh, *fvdw, *fele, *fCEvd, *fCEclmb;
   double v0_vdw, v0_ele, vlast_vdw, vlast_ele;
-  MPI_Comm comm;
 
   /* initializations */
   v0_vdw = 0;
   v0_ele = 0;
   vlast_vdw = 0;
   vlast_ele = 0;
-  comm = mpi_data->world;
 
   num_atom_types = system->reax_param.num_atom_types;
   dr = control->nonb_cut / control->tabulate;
   h = (double*)
-    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:h", comm );
+    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:h");
   fh = (double*)
-    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fh", comm );
+    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fh");
   fvdw = (double*)
-    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fvdw", comm );
+    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fvdw");
   fCEvd = (double*)
-    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fCEvd", comm );
+    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fCEvd");
   fele = (double*)
-    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fele", comm );
+    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fele");
   fCEclmb = (double*)
-    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fCEclmb", comm );
+    smalloc(system->error_ptr,  (control->tabulate+2) * sizeof(double), "lookup:fCEclmb");
 
   LR = (LR_lookup_table**)
-    scalloc(system->error_ptr,  num_atom_types, sizeof(LR_lookup_table*), "lookup:LR", comm );
+    scalloc(system->error_ptr,  num_atom_types, sizeof(LR_lookup_table*), "lookup:LR");
   for( i = 0; i < num_atom_types; ++i )
     LR[i] = (LR_lookup_table*)
-      scalloc(system->error_ptr,  num_atom_types, sizeof(LR_lookup_table), "lookup:LR[i]", comm );
+      scalloc(system->error_ptr,  num_atom_types, sizeof(LR_lookup_table), "lookup:LR[i]");
 
   for( i = 0; i < MAX_ATOM_TYPES; ++i )
     existing_types[i] = 0;
@@ -207,22 +203,18 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
           LR[i][j].dx = dr;
           LR[i][j].inv_dx = control->tabulate / control->nonb_cut;
           LR[i][j].y = (LR_data*)
-            smalloc(system->error_ptr,  LR[i][j].n * sizeof(LR_data), "lookup:LR[i,j].y", comm );
+            smalloc(system->error_ptr,  LR[i][j].n * sizeof(LR_data), "lookup:LR[i,j].y");
           LR[i][j].H = (cubic_spline_coef*)
-            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].H" ,
-                     comm );
+            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].H");
           LR[i][j].vdW = (cubic_spline_coef*)
-            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].vdW",
-                     comm);
+            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].vdW");
           LR[i][j].CEvd = (cubic_spline_coef*)
-            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].CEvd",
-                     comm);
+            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].CEvd");
           LR[i][j].ele = (cubic_spline_coef*)
-            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].ele",
-                     comm );
+            smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].ele");
           LR[i][j].CEclmb = (cubic_spline_coef*)
             smalloc(system->error_ptr,  LR[i][j].n*sizeof(cubic_spline_coef),
-                     "lookup:LR[i,j].CEclmb", comm );
+                     "lookup:LR[i,j].CEclmb");
 
           for( r = 1; r <= control->tabulate; ++r ) {
             LR_vdW_Coulomb( system, workspace, control, i, j, r * dr, &(LR[i][j].y[r]) );
@@ -247,23 +239,19 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
           vlast_ele = fele[r-1];
 
           Natural_Cubic_Spline( control->error_ptr, &h[1], &fh[1],
-                                &(LR[i][j].H[1]), control->tabulate+1, comm );
+                                &(LR[i][j].H[1]), control->tabulate+1);
 
           Complete_Cubic_Spline( control->error_ptr, &h[1], &fvdw[1], v0_vdw, vlast_vdw,
-                                 &(LR[i][j].vdW[1]), control->tabulate+1,
-                                 comm );
+                                 &(LR[i][j].vdW[1]), control->tabulate+1);
 
           Natural_Cubic_Spline( control->error_ptr, &h[1], &fCEvd[1],
-                                &(LR[i][j].CEvd[1]), control->tabulate+1,
-                                comm );
+                                &(LR[i][j].CEvd[1]), control->tabulate+1);
 
           Complete_Cubic_Spline( control->error_ptr, &h[1], &fele[1], v0_ele, vlast_ele,
-                                 &(LR[i][j].ele[1]), control->tabulate+1,
-                                 comm );
+                                 &(LR[i][j].ele[1]), control->tabulate+1);
 
           Natural_Cubic_Spline( control->error_ptr, &h[1], &fCEclmb[1],
-                                &(LR[i][j].CEclmb[1]), control->tabulate+1,
-                                comm );
+                                &(LR[i][j].CEclmb[1]), control->tabulate+1);
         } else {
           LR[i][j].n = 0;
         }
diff --git a/src/USER-REAXC/reaxc_lookup.h b/src/USER-REAXC/reaxc_lookup.h
index 9b1b14a34d..6d6aae2f8e 100644
--- a/src/USER-REAXC/reaxc_lookup.h
+++ b/src/USER-REAXC/reaxc_lookup.h
@@ -33,12 +33,10 @@ void Tridiagonal_Solve( const double *a, const double *b,
                         double *c, double *d, double *x, unsigned int n);
 
 void Natural_Cubic_Spline( LAMMPS_NS::LAMMPS*, const double *h, const double *f,
-                           cubic_spline_coef *coef, unsigned int n,
-                           MPI_Comm comm );
+                           cubic_spline_coef *coef, unsigned int n );
 
 void Complete_Cubic_Spline( LAMMPS_NS::LAMMPS*, const double *h, const double *f, double v0, double vlast,
-                            cubic_spline_coef *coef, unsigned int n,
-                            MPI_Comm comm );
+                            cubic_spline_coef *coef, unsigned int n );
 
 int Init_Lookup_Tables( reax_system*, control_params*, storage*,
                         mpi_datatypes*, char* );
diff --git a/src/USER-REAXC/reaxc_reset_tools.cpp b/src/USER-REAXC/reaxc_reset_tools.cpp
index d273a417f8..8954e344df 100644
--- a/src/USER-REAXC/reaxc_reset_tools.cpp
+++ b/src/USER-REAXC/reaxc_reset_tools.cpp
@@ -121,8 +121,7 @@ void Reset_Workspace( reax_system *system, storage *workspace )
 
 
 void Reset_Neighbor_Lists( reax_system *system, control_params *control,
-                           storage *workspace, reax_list **lists,
-                           MPI_Comm comm )
+                           storage *workspace, reax_list **lists )
 {
   int i, total_bonds, Hindex, total_hbonds;
   reax_list *bonds, *hbonds;
@@ -144,8 +143,8 @@ void Reset_Neighbor_Lists( reax_system *system, control_params *control,
       workspace->realloc.bonds = 1;
       if (total_bonds >= bonds->num_intrs) {
         char errmsg[256]; 
-        snprintf(errmsg, 256, "p%d: not enough space for bonds! total=%d allocated=%d\n",
-                system->my_rank, total_bonds, bonds->num_intrs);
+        snprintf(errmsg, 256, "Not enough space for bonds! total=%d allocated=%d\n",
+                total_bonds, bonds->num_intrs);
         control->error_ptr->one(FLERR, errmsg);
       }
     }
@@ -170,8 +169,8 @@ void Reset_Neighbor_Lists( reax_system *system, control_params *control,
       workspace->realloc.hbonds = 1;
       if (total_hbonds >= hbonds->num_intrs) {
         char errmsg[256]; 
-        snprintf(errmsg, 256, "p%d: not enough space for hbonds! total=%d allocated=%d\n",
-                system->my_rank, total_hbonds, hbonds->num_intrs);
+        snprintf(errmsg, 256, "Not enough space for hbonds! total=%d allocated=%d\n",
+                total_hbonds, hbonds->num_intrs);
         control->error_ptr->one(FLERR, errmsg);
       }
     }
@@ -180,7 +179,7 @@ void Reset_Neighbor_Lists( reax_system *system, control_params *control,
 
 
 void Reset( reax_system *system, control_params *control, simulation_data *data,
-            storage *workspace, reax_list **lists, MPI_Comm comm )
+            storage *workspace, reax_list **lists )
 {
   Reset_Atoms( system, control );
 
@@ -188,6 +187,6 @@ void Reset( reax_system *system, control_params *control, simulation_data *data,
 
   Reset_Workspace( system, workspace );
 
-  Reset_Neighbor_Lists( system, control, workspace, lists, comm );
+  Reset_Neighbor_Lists( system, control, workspace, lists );
 
 }
diff --git a/src/USER-REAXC/reaxc_reset_tools.h b/src/USER-REAXC/reaxc_reset_tools.h
index c2a90072d5..20d1ab6964 100644
--- a/src/USER-REAXC/reaxc_reset_tools.h
+++ b/src/USER-REAXC/reaxc_reset_tools.h
@@ -34,7 +34,7 @@ void Reset_Simulation_Data( simulation_data*, int );
 void Reset_Timing( reax_timing* );
 void Reset_Workspace( reax_system*, storage* );
 void Reset_Neighbor_Lists( reax_system*, control_params*, storage*,
-                           reax_list**, MPI_Comm );
+                           reax_list** );
 void Reset( reax_system*, control_params*, simulation_data*, storage*,
-            reax_list**, MPI_Comm );
+            reax_list** );
 #endif
diff --git a/src/USER-REAXC/reaxc_tool_box.cpp b/src/USER-REAXC/reaxc_tool_box.cpp
index cd339af556..05ebc34c1b 100644
--- a/src/USER-REAXC/reaxc_tool_box.cpp
+++ b/src/USER-REAXC/reaxc_tool_box.cpp
@@ -56,7 +56,7 @@ int Tokenize( char* s, char*** tok )
 
 
 /* safe malloc */
-void *smalloc( LAMMPS_NS::Error *error_ptr, rc_bigint n, const char *name, MPI_Comm comm )
+void *smalloc( LAMMPS_NS::Error *error_ptr, rc_bigint n, const char *name )
 {
   void *ptr;
   char errmsg[256];
@@ -79,7 +79,7 @@ void *smalloc( LAMMPS_NS::Error *error_ptr, rc_bigint n, const char *name, MPI_C
 
 
 /* safe calloc */
-void *scalloc( LAMMPS_NS::Error *error_ptr, rc_bigint n, rc_bigint size, const char *name, MPI_Comm comm )
+void *scalloc( LAMMPS_NS::Error *error_ptr, rc_bigint n, rc_bigint size, const char *name )
 {
   void *ptr;
   char errmsg[256];
diff --git a/src/USER-REAXC/reaxc_tool_box.h b/src/USER-REAXC/reaxc_tool_box.h
index 257ff1813f..0465376dba 100644
--- a/src/USER-REAXC/reaxc_tool_box.h
+++ b/src/USER-REAXC/reaxc_tool_box.h
@@ -37,7 +37,7 @@ double Get_Time( );
 int   Tokenize( char*, char*** );
 
 /* from lammps */
-void *smalloc( LAMMPS_NS::Error*, rc_bigint, const char*, MPI_Comm );
-void *scalloc( LAMMPS_NS::Error*, rc_bigint, rc_bigint, const char*, MPI_Comm );
+void *smalloc( LAMMPS_NS::Error*, rc_bigint, const char* );
+void *scalloc( LAMMPS_NS::Error*, rc_bigint, rc_bigint, const char* );
 void sfree( LAMMPS_NS::Error*, void*, const char* );
 #endif
diff --git a/src/USER-REAXC/reaxc_traj.cpp b/src/USER-REAXC/reaxc_traj.cpp
index 90f3d1e668..27bebb6327 100644
--- a/src/USER-REAXC/reaxc_traj.cpp
+++ b/src/USER-REAXC/reaxc_traj.cpp
@@ -29,8 +29,7 @@
 #include "reaxc_list.h"
 #include "reaxc_tool_box.h"
 
-int Reallocate_Output_Buffer( LAMMPS_NS::Error *error_ptr, output_controls *out_control, int req_space,
-                              MPI_Comm comm )
+int Reallocate_Output_Buffer( LAMMPS_NS::Error *error_ptr, output_controls *out_control, int req_space )
 {
   if (out_control->buffer_len > 0)
     free( out_control->buffer );
@@ -82,7 +81,7 @@ int Write_Header( reax_system *system, control_params *control,
   my_hdr_lines = num_hdr_lines * ( system->my_rank == MASTER_NODE );
   buffer_req = my_hdr_lines * HEADER_LINE_LEN;
   if (buffer_req > out_control->buffer_len * DANGER_ZONE)
-    Reallocate_Output_Buffer( control->error_ptr, out_control, buffer_req, mpi_data->world );
+    Reallocate_Output_Buffer( control->error_ptr, out_control, buffer_req );
 
   /* only the master node writes into trajectory header */
   if (system->my_rank == MASTER_NODE) {
@@ -277,7 +276,7 @@ int Write_Init_Desc( reax_system *system, control_params * /*control*/,
   else buffer_req = system->n * INIT_DESC_LEN + 1;
 
   if (buffer_req > out_control->buffer_len * DANGER_ZONE)
-    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req, mpi_data->world );
+    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req );
 
   out_control->line[0] = 0;
   out_control->buffer[0] = 0;
@@ -366,7 +365,7 @@ int Write_Frame_Header( reax_system *system, control_params *control,
   my_frm_hdr_lines = num_frm_hdr_lines * ( me == MASTER_NODE );
   buffer_req = my_frm_hdr_lines * HEADER_LINE_LEN;
   if (buffer_req > out_control->buffer_len * DANGER_ZONE)
-    Reallocate_Output_Buffer( control->error_ptr, out_control, buffer_req, mpi_data->world );
+    Reallocate_Output_Buffer( control->error_ptr, out_control, buffer_req );
 
   /* only the master node writes into trajectory header */
   if (me == MASTER_NODE) {
@@ -499,7 +498,7 @@ int Write_Atoms( reax_system *system, control_params * /*control*/,
   else buffer_req = system->n * line_len + 1;
 
   if (buffer_req > out_control->buffer_len * DANGER_ZONE)
-    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req, mpi_data->world );
+    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req );
 
   /* fill in buffer */
   out_control->line[0] = 0;
@@ -589,7 +588,7 @@ int Write_Bonds(reax_system *system, control_params *control, reax_list *bonds,
   else buffer_req = my_bonds * line_len + 1;
 
   if (buffer_req > out_control->buffer_len * DANGER_ZONE)
-    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req, mpi_data->world );
+    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req );
 
   /* fill in the buffer */
   out_control->line[0] = 0;
@@ -689,7 +688,7 @@ int Write_Angles( reax_system *system, control_params *control,
   else buffer_req = my_angles * line_len + 1;
 
   if (buffer_req > out_control->buffer_len * DANGER_ZONE)
-    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req, mpi_data->world );
+    Reallocate_Output_Buffer( system->error_ptr, out_control, buffer_req );
 
   /* fill in the buffer */
   my_angles = 0;
diff --git a/src/USER-REAXC/reaxc_valence_angles.h b/src/USER-REAXC/reaxc_valence_angles.h
index 51eac5a95e..31936ba190 100644
--- a/src/USER-REAXC/reaxc_valence_angles.h
+++ b/src/USER-REAXC/reaxc_valence_angles.h
@@ -30,7 +30,7 @@
 #include "reaxc_types.h"
 
 void Valence_Angles( reax_system*, control_params*, simulation_data*,
-                     storage*, reax_list**, output_controls*);
+                     storage*, reax_list**, output_controls* );
 
 void Calculate_Theta( rvec, double, rvec, double, double*, double* );