ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed unnecessary MPI_comm

Browse Source
This commit is contained in:
mkanski
2019-03-25 16:45:59 +01:00
parent 83e458af0b
commit a89a2de9d4
20 changed files with 192 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/USER-REAXC/pair_reaxc.cpp
View File

@ -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) {

159
src/USER-REAXC/reaxc_allocate.cpp
View File

@ -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;

11
src/USER-REAXC/reaxc_allocate.h
View File

@ -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

1
src/USER-REAXC/reaxc_control.cpp
View File

@ -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 )
{

3
src/USER-REAXC/reaxc_control.h
View File

@ -29,9 +29,6 @@
#include "reaxc_types.h"
#include "lammps.h"
#include "error.h"
char Read_Control_File( char*, control_params*, output_controls* );
#endif

57
src/USER-REAXC/reaxc_ffield.cpp
View File

@ -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;

12
src/USER-REAXC/reaxc_forces.cpp
View File

@ -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,

2
src/USER-REAXC/reaxc_forces.h
View File

@ -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

20
src/USER-REAXC/reaxc_init_md.cpp
View File

@ -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);

2
src/USER-REAXC/reaxc_init_md.h
View File

@ -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 );

22
src/USER-REAXC/reaxc_list.cpp
View File

@ -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;

4
src/USER-REAXC/reaxc_list.h
View File

@ -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* );

74
src/USER-REAXC/reaxc_lookup.cpp
View File

@ -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;
}

6
src/USER-REAXC/reaxc_lookup.h
View File

@ -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* );

15
src/USER-REAXC/reaxc_reset_tools.cpp
View File

@ -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 );
}

4
src/USER-REAXC/reaxc_reset_tools.h
View File

@ -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

4
src/USER-REAXC/reaxc_tool_box.cpp
View File

@ -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];

4
src/USER-REAXC/reaxc_tool_box.h
View File

@ -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

15
src/USER-REAXC/reaxc_traj.cpp
View File

@ -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;

2
src/USER-REAXC/reaxc_valence_angles.h
View File

@ -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* );