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

All errors and warning are now printed through LAMMPS

Browse Source
This commit is contained in:
mkanski
2019-03-12 20:19:56 +01:00
parent 146e2f283a
commit 3a4bb6f980
33 changed files with 506 additions and 502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -137,15 +137,15 @@ PairReaxC::~PairReaxC()
// deallocate reax data-structures // deallocate reax data-structures
if (control->tabulate ) Deallocate_Lookup_Tables( system); if (control->tabulate ) Deallocate_Lookup_Tables( lmp, system);
if (control->hbond_cut > 0 ) Delete_List( lists+HBONDS, world); if (control->hbond_cut > 0 ) Delete_List( lmp, lists+HBONDS, world);
Delete_List( lists+BONDS, world ); Delete_List( lmp, lists+BONDS, world );
Delete_List( lists+THREE_BODIES, world ); Delete_List( lmp, lists+THREE_BODIES, world );
Delete_List( lists+FAR_NBRS, world ); Delete_List( lmp, lists+FAR_NBRS, world );
DeAllocate_Workspace( control, workspace ); DeAllocate_Workspace( lmp, control, workspace );
DeAllocate_System( system ); DeAllocate_System( lmp, system );
} }
memory->destroy( system ); memory->destroy( system );
@ -223,7 +223,7 @@ void PairReaxC::settings(int narg, char **arg)
out_control->atom_info = 0; out_control->atom_info = 0;
out_control->bond_info = 0; out_control->bond_info = 0;
out_control->angle_info = 0; out_control->angle_info = 0;
} else Read_Control_File(arg[0], control, out_control); } else Read_Control_File(lmp, arg[0], control, out_control);
// default values // default values
@ -298,7 +298,7 @@ void PairReaxC::coeff( int nargs, char **args )
FILE *fp; FILE *fp;
fp = force->open_potential(file); fp = force->open_potential(file);
if (fp != NULL) if (fp != NULL)
Read_Force_Field(fp, &(system->reax_param), control); Read_Force_Field(lmp, fp, &(system->reax_param), control);
else { else {
char str[128]; char str[128];
snprintf(str,128,"Cannot open ReaxFF potential file %s",file); snprintf(str,128,"Cannot open ReaxFF potential file %s",file);
@ -394,7 +394,7 @@ void PairReaxC::init_style( )
"increased neighbor list skin."); "increased neighbor list skin.");
for( int i = 0; i < LIST_N; ++i ) for( int i = 0; i < LIST_N; ++i )
if (lists[i].allacated != 1) if (lists[i].allocated != 1)
lists[i].allocated = 0; lists[i].allocated = 0;
if (fix_reax == NULL) { if (fix_reax == NULL) {
@ -437,13 +437,13 @@ void PairReaxC::setup( )
// initialize my data structures // initialize my data structures
PreAllocate_Space( system, control, workspace, world ); PreAllocate_Space( lmp, system, control, workspace, world );
write_reax_atoms(); write_reax_atoms();
int num_nbrs = estimate_reax_lists(); int num_nbrs = estimate_reax_lists();
if(!Make_List(system->total_cap, num_nbrs, TYP_FAR_NEIGHBOR, if(!Make_List(lmp, system->total_cap, num_nbrs, TYP_FAR_NEIGHBOR,
lists+FAR_NBRS, world)) lists+FAR_NBRS, world))
error->all(FLERR,"Pair reax/c problem in far neighbor list"); error->one(FLERR,"Pair reax/c problem in far neighbor list");
write_reax_lists(); write_reax_lists();
Initialize( lmp, system, control, data, workspace, &lists, out_control, Initialize( lmp, system, control, data, workspace, &lists, out_control,
@ -582,7 +582,7 @@ void PairReaxC::compute(int eflag, int vflag)
data->step = update->ntimestep; data->step = update->ntimestep;
Output_Results( system, control, data, &lists, out_control, mpi_data ); Output_Results( lmp, system, control, data, &lists, out_control, mpi_data );
// populate tmpid and tmpbo arrays for fix reax/c/species // populate tmpid and tmpbo arrays for fix reax/c/species
int i, j; int i, j;

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

@ -43,7 +43,7 @@ using namespace LAMMPS_NS;
important: we cannot know the exact number of atoms that will fall into a important: we cannot know the exact number of atoms that will fall into a
process's box throughout the whole simulation. therefore process's box throughout the whole simulation. therefore
we need to make upper bound estimates for various data structures */ we need to make upper bound estimates for various data structures */
int PreAllocate_Space( reax_system *system, control_params * /*control*/, int PreAllocate_Space( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params * /*control*/,
storage * workspace, MPI_Comm comm ) storage * workspace, MPI_Comm comm )
{ {
int mincap = system->mincap; int mincap = system->mincap;
@ -55,7 +55,7 @@ int PreAllocate_Space( reax_system *system, control_params * /*control*/,
system->total_cap = MAX( (int)(system->N * safezone), mincap ); system->total_cap = MAX( (int)(system->N * safezone), mincap );
system->my_atoms = (reax_atom*) system->my_atoms = (reax_atom*)
scalloc( system->total_cap, sizeof(reax_atom), "my_atoms", comm ); scalloc(lmp, system->total_cap, sizeof(reax_atom), "my_atoms", comm );
// Nullify some arrays only used in omp styles // Nullify some arrays only used in omp styles
// Should be safe to do here since called in pair->setup(); // Should be safe to do here since called in pair->setup();
@ -84,45 +84,45 @@ int Allocate_System( reax_system *system, int /*local_cap*/, int total_cap,
} }
void DeAllocate_System( reax_system *system ) void DeAllocate_System( LAMMPS_NS::LAMMPS *lmp, reax_system *system )
{ {
int i, j, k; int i, j, k;
int ntypes; int ntypes;
reax_interaction *ff_params; reax_interaction *ff_params;
// dealloocate the atom list // dealloocate the atom list
sfree( system->my_atoms, "system->my_atoms" ); sfree(lmp, system->my_atoms, "system->my_atoms" );
// deallocate the ffield parameters storage // deallocate the ffield parameters storage
ff_params = &(system->reax_param); ff_params = &(system->reax_param);
ntypes = ff_params->num_atom_types; ntypes = ff_params->num_atom_types;
sfree( ff_params->gp.l, "ff:globals" ); sfree(lmp, ff_params->gp.l, "ff:globals" );
for( i = 0; i < ntypes; ++i ) { for( i = 0; i < ntypes; ++i ) {
for( j = 0; j < ntypes; ++j ) { for( j = 0; j < ntypes; ++j ) {
for( k = 0; k < ntypes; ++k ) { for( k = 0; k < ntypes; ++k ) {
sfree( ff_params->fbp[i][j][k], "ff:fbp[i,j,k]" ); sfree(lmp, ff_params->fbp[i][j][k], "ff:fbp[i,j,k]" );
} }
sfree( ff_params->fbp[i][j], "ff:fbp[i,j]" ); sfree(lmp, ff_params->fbp[i][j], "ff:fbp[i,j]" );
sfree( ff_params->thbp[i][j], "ff:thbp[i,j]" ); sfree(lmp, ff_params->thbp[i][j], "ff:thbp[i,j]" );
sfree( ff_params->hbp[i][j], "ff:hbp[i,j]" ); sfree(lmp, ff_params->hbp[i][j], "ff:hbp[i,j]" );
} }
sfree( ff_params->fbp[i], "ff:fbp[i]" ); sfree(lmp, ff_params->fbp[i], "ff:fbp[i]" );
sfree( ff_params->thbp[i], "ff:thbp[i]" ); sfree(lmp, ff_params->thbp[i], "ff:thbp[i]" );
sfree( ff_params->hbp[i], "ff:hbp[i]" ); sfree(lmp, ff_params->hbp[i], "ff:hbp[i]" );
sfree( ff_params->tbp[i], "ff:tbp[i]" ); sfree(lmp, ff_params->tbp[i], "ff:tbp[i]" );
} }
sfree( ff_params->fbp, "ff:fbp" ); sfree(lmp, ff_params->fbp, "ff:fbp" );
sfree( ff_params->thbp, "ff:thbp" ); sfree(lmp, ff_params->thbp, "ff:thbp" );
sfree( ff_params->hbp, "ff:hbp" ); sfree(lmp, ff_params->hbp, "ff:hbp" );
sfree( ff_params->tbp, "ff:tbp" ); sfree(lmp, ff_params->tbp, "ff:tbp" );
sfree( ff_params->sbp, "ff:sbp" ); sfree(lmp, ff_params->sbp, "ff:sbp" );
} }
/************* workspace *************/ /************* workspace *************/
void DeAllocate_Workspace( control_params * /*control*/, storage *workspace ) void DeAllocate_Workspace( LAMMPS_NS::LAMMPS* lmp, control_params * /*control*/, storage *workspace )
{ {
int i; int i;
@ -133,84 +133,84 @@ void DeAllocate_Workspace( control_params * /*control*/, storage *workspace )
/* communication storage */ /* communication storage */
for( i = 0; i < MAX_NBRS; ++i ) { for( i = 0; i < MAX_NBRS; ++i ) {
sfree( workspace->tmp_dbl[i], "tmp_dbl[i]" ); sfree(lmp, workspace->tmp_dbl[i], "tmp_dbl[i]" );
sfree( workspace->tmp_rvec[i], "tmp_rvec[i]" ); sfree(lmp, workspace->tmp_rvec[i], "tmp_rvec[i]" );
sfree( workspace->tmp_rvec2[i], "tmp_rvec2[i]" ); sfree(lmp, workspace->tmp_rvec2[i], "tmp_rvec2[i]" );
} }
/* bond order storage */ /* bond order storage */
sfree( workspace->within_bond_box, "skin" ); sfree(lmp, workspace->within_bond_box, "skin" );
sfree( workspace->total_bond_order, "total_bo" ); sfree(lmp, workspace->total_bond_order, "total_bo" );
sfree( workspace->Deltap, "Deltap" ); sfree(lmp, workspace->Deltap, "Deltap" );
sfree( workspace->Deltap_boc, "Deltap_boc" ); sfree(lmp, workspace->Deltap_boc, "Deltap_boc" );
sfree( workspace->dDeltap_self, "dDeltap_self" ); sfree(lmp, workspace->dDeltap_self, "dDeltap_self" );
sfree( workspace->Delta, "Delta" ); sfree(lmp, workspace->Delta, "Delta" );
sfree( workspace->Delta_lp, "Delta_lp" ); sfree(lmp, workspace->Delta_lp, "Delta_lp" );
sfree( workspace->Delta_lp_temp, "Delta_lp_temp" ); sfree(lmp, workspace->Delta_lp_temp, "Delta_lp_temp" );
sfree( workspace->dDelta_lp, "dDelta_lp" ); sfree(lmp, workspace->dDelta_lp, "dDelta_lp" );
sfree( workspace->dDelta_lp_temp, "dDelta_lp_temp" ); sfree(lmp, workspace->dDelta_lp_temp, "dDelta_lp_temp" );
sfree( workspace->Delta_e, "Delta_e" ); sfree(lmp, workspace->Delta_e, "Delta_e" );
sfree( workspace->Delta_boc, "Delta_boc" ); sfree(lmp, workspace->Delta_boc, "Delta_boc" );
sfree( workspace->Delta_val, "Delta_val" ); sfree(lmp, workspace->Delta_val, "Delta_val" );
sfree( workspace->nlp, "nlp" ); sfree(lmp, workspace->nlp, "nlp" );
sfree( workspace->nlp_temp, "nlp_temp" ); sfree(lmp, workspace->nlp_temp, "nlp_temp" );
sfree( workspace->Clp, "Clp" ); sfree(lmp, workspace->Clp, "Clp" );
sfree( workspace->vlpex, "vlpex" ); sfree(lmp, workspace->vlpex, "vlpex" );
sfree( workspace->bond_mark, "bond_mark" ); sfree(lmp, workspace->bond_mark, "bond_mark" );
sfree( workspace->done_after, "done_after" ); sfree(lmp, workspace->done_after, "done_after" );
/* QEq storage */ /* QEq storage */
sfree( workspace->Hdia_inv, "Hdia_inv" ); sfree(lmp, workspace->Hdia_inv, "Hdia_inv" );
sfree( workspace->b_s, "b_s" ); sfree(lmp, workspace->b_s, "b_s" );
sfree( workspace->b_t, "b_t" ); sfree(lmp, workspace->b_t, "b_t" );
sfree( workspace->b_prc, "b_prc" ); sfree(lmp, workspace->b_prc, "b_prc" );
sfree( workspace->b_prm, "b_prm" ); sfree(lmp, workspace->b_prm, "b_prm" );
sfree( workspace->s, "s" ); sfree(lmp, workspace->s, "s" );
sfree( workspace->t, "t" ); sfree(lmp, workspace->t, "t" );
sfree( workspace->droptol, "droptol" ); sfree(lmp, workspace->droptol, "droptol" );
sfree( workspace->b, "b" ); sfree(lmp, workspace->b, "b" );
sfree( workspace->x, "x" ); sfree(lmp, workspace->x, "x" );
/* GMRES storage */ /* GMRES storage */
for( i = 0; i < RESTART+1; ++i ) { for( i = 0; i < RESTART+1; ++i ) {
sfree( workspace->h[i], "h[i]" ); sfree(lmp, workspace->h[i], "h[i]" );
sfree( workspace->v[i], "v[i]" ); sfree(lmp, workspace->v[i], "v[i]" );
} }
sfree( workspace->h, "h" ); sfree(lmp, workspace->h, "h" );
sfree( workspace->v, "v" ); sfree(lmp, workspace->v, "v" );
sfree( workspace->y, "y" ); sfree(lmp, workspace->y, "y" );
sfree( workspace->z, "z" ); sfree(lmp, workspace->z, "z" );
sfree( workspace->g, "g" ); sfree(lmp, workspace->g, "g" );
sfree( workspace->hs, "hs" ); sfree(lmp, workspace->hs, "hs" );
sfree( workspace->hc, "hc" ); sfree(lmp, workspace->hc, "hc" );
/* CG storage */ /* CG storage */
sfree( workspace->r, "r" ); sfree(lmp, workspace->r, "r" );
sfree( workspace->d, "d" ); sfree(lmp, workspace->d, "d" );
sfree( workspace->q, "q" ); sfree(lmp, workspace->q, "q" );
sfree( workspace->p, "p" ); sfree(lmp, workspace->p, "p" );
sfree( workspace->r2, "r2" ); sfree(lmp, workspace->r2, "r2" );
sfree( workspace->d2, "d2" ); sfree(lmp, workspace->d2, "d2" );
sfree( workspace->q2, "q2" ); sfree(lmp, workspace->q2, "q2" );
sfree( workspace->p2, "p2" ); sfree(lmp, workspace->p2, "p2" );
/* integrator storage */ /* integrator storage */
sfree( workspace->v_const, "v_const" ); sfree(lmp, workspace->v_const, "v_const" );
/* force related storage */ /* force related storage */
sfree( workspace->f, "f" ); sfree(lmp, workspace->f, "f" );
sfree( workspace->CdDelta, "CdDelta" ); sfree(lmp, workspace->CdDelta, "CdDelta" );
/* reductions */ /* reductions */
#ifdef LMP_USER_OMP #ifdef LMP_USER_OMP
if (workspace->CdDeltaReduction) sfree( workspace->CdDeltaReduction, "cddelta_reduce" ); if (workspace->CdDeltaReduction) sfree(lmp, workspace->CdDeltaReduction, "cddelta_reduce" );
if (workspace->forceReduction) sfree( workspace->forceReduction, "f_reduce" ); if (workspace->forceReduction) sfree(lmp, workspace->forceReduction, "f_reduce" );
if (workspace->valence_angle_atom_myoffset) sfree( workspace->valence_angle_atom_myoffset, "valence_angle_atom_myoffset"); if (workspace->valence_angle_atom_myoffset) sfree(lmp, workspace->valence_angle_atom_myoffset, "valence_angle_atom_myoffset");
if (workspace->my_ext_pressReduction) sfree( workspace->my_ext_pressReduction, "ext_press_reduce"); if (workspace->my_ext_pressReduction) sfree(lmp, workspace->my_ext_pressReduction, "ext_press_reduce");
#endif #endif
} }
int Allocate_Workspace( reax_system * /*system*/, control_params * control, int Allocate_Workspace( LAMMPS_NS::LAMMPS* lmp, reax_system * /*system*/, control_params * control,
storage *workspace, int local_cap, int total_cap, storage *workspace, int local_cap, int total_cap,
MPI_Comm comm, char * /*msg*/ ) MPI_Comm comm, char * /*msg*/ )
{ {
@ -224,94 +224,94 @@ int Allocate_Workspace( reax_system * /*system*/, control_params * control,
/* communication storage */ /* communication storage */
for( i = 0; i < MAX_NBRS; ++i ) { for( i = 0; i < MAX_NBRS; ++i ) {
workspace->tmp_dbl[i] = (double*) workspace->tmp_dbl[i] = (double*)
scalloc( total_cap, sizeof(double), "tmp_dbl", comm ); scalloc(lmp, total_cap, sizeof(double), "tmp_dbl", comm );
workspace->tmp_rvec[i] = (rvec*) workspace->tmp_rvec[i] = (rvec*)
scalloc( total_cap, sizeof(rvec), "tmp_rvec", comm ); scalloc(lmp, total_cap, sizeof(rvec), "tmp_rvec", comm );
workspace->tmp_rvec2[i] = (rvec2*) workspace->tmp_rvec2[i] = (rvec2*)
scalloc( total_cap, sizeof(rvec2), "tmp_rvec2", comm ); scalloc(lmp, total_cap, sizeof(rvec2), "tmp_rvec2", comm );
} }
/* bond order related storage */ /* bond order related storage */
workspace->within_bond_box = (int*) workspace->within_bond_box = (int*)
scalloc( total_cap, sizeof(int), "skin", comm ); scalloc(lmp, total_cap, sizeof(int), "skin", comm );
workspace->total_bond_order = (double*) smalloc( total_real, "total_bo", comm ); workspace->total_bond_order = (double*) smalloc(lmp, total_real, "total_bo", comm );
workspace->Deltap = (double*) smalloc( total_real, "Deltap", comm ); workspace->Deltap = (double*) smalloc(lmp, total_real, "Deltap", comm );
workspace->Deltap_boc = (double*) smalloc( total_real, "Deltap_boc", comm ); workspace->Deltap_boc = (double*) smalloc(lmp, total_real, "Deltap_boc", comm );
workspace->dDeltap_self = (rvec*) smalloc( total_rvec, "dDeltap_self", comm ); workspace->dDeltap_self = (rvec*) smalloc(lmp, total_rvec, "dDeltap_self", comm );
workspace->Delta = (double*) smalloc( total_real, "Delta", comm ); workspace->Delta = (double*) smalloc(lmp, total_real, "Delta", comm );
workspace->Delta_lp = (double*) smalloc( total_real, "Delta_lp", comm ); workspace->Delta_lp = (double*) smalloc(lmp, total_real, "Delta_lp", comm );
workspace->Delta_lp_temp = (double*) workspace->Delta_lp_temp = (double*)
smalloc( total_real, "Delta_lp_temp", comm ); smalloc(lmp, total_real, "Delta_lp_temp", comm );
workspace->dDelta_lp = (double*) smalloc( total_real, "dDelta_lp", comm ); workspace->dDelta_lp = (double*) smalloc(lmp, total_real, "dDelta_lp", comm );
workspace->dDelta_lp_temp = (double*) workspace->dDelta_lp_temp = (double*)
smalloc( total_real, "dDelta_lp_temp", comm ); smalloc(lmp, total_real, "dDelta_lp_temp", comm );
workspace->Delta_e = (double*) smalloc( total_real, "Delta_e", comm ); workspace->Delta_e = (double*) smalloc(lmp, total_real, "Delta_e", comm );
workspace->Delta_boc = (double*) smalloc( total_real, "Delta_boc", comm ); workspace->Delta_boc = (double*) smalloc(lmp, total_real, "Delta_boc", comm );
workspace->Delta_val = (double*) smalloc( total_real, "Delta_val", comm ); workspace->Delta_val = (double*) smalloc(lmp, total_real, "Delta_val", comm );
workspace->nlp = (double*) smalloc( total_real, "nlp", comm ); workspace->nlp = (double*) smalloc(lmp, total_real, "nlp", comm );
workspace->nlp_temp = (double*) smalloc( total_real, "nlp_temp", comm ); workspace->nlp_temp = (double*) smalloc(lmp, total_real, "nlp_temp", comm );
workspace->Clp = (double*) smalloc( total_real, "Clp", comm ); workspace->Clp = (double*) smalloc(lmp, total_real, "Clp", comm );
workspace->vlpex = (double*) smalloc( total_real, "vlpex", comm ); workspace->vlpex = (double*) smalloc(lmp, total_real, "vlpex", comm );
workspace->bond_mark = (int*) workspace->bond_mark = (int*)
scalloc( total_cap, sizeof(int), "bond_mark", comm ); scalloc(lmp, total_cap, sizeof(int), "bond_mark", comm );
workspace->done_after = (int*) workspace->done_after = (int*)
scalloc( total_cap, sizeof(int), "done_after", comm ); scalloc(lmp, total_cap, sizeof(int), "done_after", comm );
/* QEq storage */ /* QEq storage */
workspace->Hdia_inv = (double*) workspace->Hdia_inv = (double*)
scalloc( total_cap, sizeof(double), "Hdia_inv", comm ); scalloc(lmp, total_cap, sizeof(double), "Hdia_inv", comm );
workspace->b_s = (double*) scalloc( total_cap, sizeof(double), "b_s", comm ); workspace->b_s = (double*) scalloc(lmp, total_cap, sizeof(double), "b_s", comm );
workspace->b_t = (double*) scalloc( total_cap, sizeof(double), "b_t", comm ); workspace->b_t = (double*) scalloc(lmp, total_cap, sizeof(double), "b_t", comm );
workspace->b_prc = (double*) scalloc( total_cap, sizeof(double), "b_prc", comm ); workspace->b_prc = (double*) scalloc(lmp, total_cap, sizeof(double), "b_prc", comm );
workspace->b_prm = (double*) scalloc( total_cap, sizeof(double), "b_prm", comm ); workspace->b_prm = (double*) scalloc(lmp, total_cap, sizeof(double), "b_prm", comm );
workspace->s = (double*) scalloc( total_cap, sizeof(double), "s", comm ); workspace->s = (double*) scalloc(lmp, total_cap, sizeof(double), "s", comm );
workspace->t = (double*) scalloc( total_cap, sizeof(double), "t", comm ); workspace->t = (double*) scalloc(lmp, total_cap, sizeof(double), "t", comm );
workspace->droptol = (double*) workspace->droptol = (double*)
scalloc( total_cap, sizeof(double), "droptol", comm ); scalloc(lmp, total_cap, sizeof(double), "droptol", comm );
workspace->b = (rvec2*) scalloc( total_cap, sizeof(rvec2), "b", comm ); workspace->b = (rvec2*) scalloc(lmp, total_cap, sizeof(rvec2), "b", comm );
workspace->x = (rvec2*) scalloc( total_cap, sizeof(rvec2), "x", comm ); workspace->x = (rvec2*) scalloc(lmp, total_cap, sizeof(rvec2), "x", comm );
/* GMRES storage */ /* GMRES storage */
workspace->y = (double*) scalloc( RESTART+1, sizeof(double), "y", comm ); workspace->y = (double*) scalloc(lmp, RESTART+1, sizeof(double), "y", comm );
workspace->z = (double*) scalloc( RESTART+1, sizeof(double), "z", comm ); workspace->z = (double*) scalloc(lmp, RESTART+1, sizeof(double), "z", comm );
workspace->g = (double*) scalloc( RESTART+1, sizeof(double), "g", comm ); workspace->g = (double*) scalloc(lmp, RESTART+1, sizeof(double), "g", comm );
workspace->h = (double**) scalloc( RESTART+1, sizeof(double*), "h", comm ); workspace->h = (double**) scalloc(lmp, RESTART+1, sizeof(double*), "h", comm );
workspace->hs = (double*) scalloc( RESTART+1, sizeof(double), "hs", comm ); workspace->hs = (double*) scalloc(lmp, RESTART+1, sizeof(double), "hs", comm );
workspace->hc = (double*) scalloc( RESTART+1, sizeof(double), "hc", comm ); workspace->hc = (double*) scalloc(lmp, RESTART+1, sizeof(double), "hc", comm );
workspace->v = (double**) scalloc( RESTART+1, sizeof(double*), "v", comm ); workspace->v = (double**) scalloc(lmp, RESTART+1, sizeof(double*), "v", comm );
for( i = 0; i < RESTART+1; ++i ) { for( i = 0; i < RESTART+1; ++i ) {
workspace->h[i] = (double*) scalloc( RESTART+1, sizeof(double), "h[i]", comm ); workspace->h[i] = (double*) scalloc(lmp, RESTART+1, sizeof(double), "h[i]", comm );
workspace->v[i] = (double*) scalloc( total_cap, sizeof(double), "v[i]", comm ); workspace->v[i] = (double*) scalloc(lmp, total_cap, sizeof(double), "v[i]", comm );
} }
/* CG storage */ /* CG storage */
workspace->r = (double*) scalloc( total_cap, sizeof(double), "r", comm ); workspace->r = (double*) scalloc(lmp, total_cap, sizeof(double), "r", comm );
workspace->d = (double*) scalloc( total_cap, sizeof(double), "d", comm ); workspace->d = (double*) scalloc(lmp, total_cap, sizeof(double), "d", comm );
workspace->q = (double*) scalloc( total_cap, sizeof(double), "q", comm ); workspace->q = (double*) scalloc(lmp, total_cap, sizeof(double), "q", comm );
workspace->p = (double*) scalloc( total_cap, sizeof(double), "p", comm ); workspace->p = (double*) scalloc(lmp, total_cap, sizeof(double), "p", comm );
workspace->r2 = (rvec2*) scalloc( total_cap, sizeof(rvec2), "r2", comm ); workspace->r2 = (rvec2*) scalloc(lmp, total_cap, sizeof(rvec2), "r2", comm );
workspace->d2 = (rvec2*) scalloc( total_cap, sizeof(rvec2), "d2", comm ); workspace->d2 = (rvec2*) scalloc(lmp, total_cap, sizeof(rvec2), "d2", comm );
workspace->q2 = (rvec2*) scalloc( total_cap, sizeof(rvec2), "q2", comm ); workspace->q2 = (rvec2*) scalloc(lmp, total_cap, sizeof(rvec2), "q2", comm );
workspace->p2 = (rvec2*) scalloc( total_cap, sizeof(rvec2), "p2", comm ); workspace->p2 = (rvec2*) scalloc(lmp, total_cap, sizeof(rvec2), "p2", comm );
/* integrator storage */ /* integrator storage */
workspace->v_const = (rvec*) smalloc( local_rvec, "v_const", comm ); workspace->v_const = (rvec*) smalloc(lmp, local_rvec, "v_const", comm );
/* force related storage */ /* force related storage */
workspace->f = (rvec*) scalloc( total_cap, sizeof(rvec), "f", comm ); workspace->f = (rvec*) scalloc(lmp, total_cap, sizeof(rvec), "f", comm );
workspace->CdDelta = (double*) workspace->CdDelta = (double*)
scalloc( total_cap, sizeof(double), "CdDelta", comm ); scalloc(lmp, total_cap, sizeof(double), "CdDelta", comm );
// storage for reductions with multiple threads // storage for reductions with multiple threads
#ifdef LMP_USER_OMP #ifdef LMP_USER_OMP
workspace->CdDeltaReduction = (double *) scalloc(sizeof(double), total_cap*control->nthreads, workspace->CdDeltaReduction = (double *) scalloc(lmp, sizeof(double), total_cap*control->nthreads,
"cddelta_reduce", comm); "cddelta_reduce", comm);
workspace->forceReduction = (rvec *) scalloc(sizeof(rvec), total_cap*control->nthreads, workspace->forceReduction = (rvec *) scalloc(lmp, sizeof(rvec), total_cap*control->nthreads,
"forceReduction", comm); "forceReduction", comm);
workspace->valence_angle_atom_myoffset = (int *) scalloc(sizeof(int), total_cap, "valence_angle_atom_myoffset", comm); workspace->valence_angle_atom_myoffset = (int *) scalloc(lmp, sizeof(int), total_cap, "valence_angle_atom_myoffset", comm);
workspace->my_ext_pressReduction = (rvec *) calloc(sizeof(rvec), control->nthreads); workspace->my_ext_pressReduction = (rvec *) calloc(sizeof(rvec), control->nthreads);
#else #else
LMP_UNUSED_PARAM(control); LMP_UNUSED_PARAM(control);
@ -321,18 +321,17 @@ int Allocate_Workspace( reax_system * /*system*/, control_params * control,
} }
static void Reallocate_Neighbor_List( reax_list *far_nbrs, int n, static void Reallocate_Neighbor_List( LAMMPS* lmp, reax_list *far_nbrs, int n,
int num_intrs, MPI_Comm comm ) int num_intrs, MPI_Comm comm )
{ {
Delete_List( far_nbrs, comm ); Delete_List( lmp, far_nbrs, comm );
if(!Make_List( n, num_intrs, TYP_FAR_NEIGHBOR, far_nbrs, comm )){ if(!Make_List( lmp, n, num_intrs, TYP_FAR_NEIGHBOR, far_nbrs, comm )){
fprintf(stderr, "Problem in initializing far nbrs list. Terminating!\n"); lmp->error->one(FLERR,"Problem in initializing far neighbors list");
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
} }
static int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds, static int Reallocate_HBonds_List( LAMMPS *lmp, reax_system *system, reax_list *hbonds,
MPI_Comm comm ) MPI_Comm comm )
{ {
int i, total_hbonds; int i, total_hbonds;
@ -347,10 +346,9 @@ static int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds,
} }
total_hbonds = (int)(MAX( total_hbonds*saferzone, mincap*MIN_HBONDS )); total_hbonds = (int)(MAX( total_hbonds*saferzone, mincap*MIN_HBONDS ));
Delete_List( hbonds, comm ); Delete_List( lmp, hbonds, comm );
if (!Make_List( system->Hcap, total_hbonds, TYP_HBOND, hbonds, comm )) { if (!Make_List( lmp, system->Hcap, total_hbonds, TYP_HBOND, hbonds, comm )) {
fprintf( stderr, "not enough space for hbonds list. terminating!\n" ); lmp->error->one(FLERR, "Not enough space for hydrogen bonds list");
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
return total_hbonds; return total_hbonds;
@ -377,13 +375,12 @@ static int Reallocate_Bonds_List( LAMMPS *lmp, reax_system *system, reax_list *b
#ifdef LMP_USER_OMP #ifdef LMP_USER_OMP
if (system->omp_active) if (system->omp_active)
for (i = 0; i < bonds->num_intrs; ++i) for (i = 0; i < bonds->num_intrs; ++i)
sfree(bonds->select.bond_list[i].bo_data.CdboReduction, "CdboReduction"); sfree(lmp, bonds->select.bond_list[i].bo_data.CdboReduction, "CdboReduction");
#endif #endif
Delete_List( bonds, comm ); Delete_List( lmp, bonds, comm );
if(!Make_List(system->total_cap, *total_bonds, TYP_BOND, bonds, comm)) { if(!Make_List(lmp, system->total_cap, *total_bonds, TYP_BOND, bonds, comm)) {
fprintf( stderr, "not enough space for bonds list. terminating!\n" ); lmp->error->one(FLERR, "Not enough space for bonds list");
lmp->error->all(FLERR, "Can't allocate space for hbonds.");
} }
#ifdef LMP_USER_OMP #ifdef LMP_USER_OMP
@ -396,7 +393,7 @@ static int Reallocate_Bonds_List( LAMMPS *lmp, reax_system *system, reax_list *b
if (system->omp_active) if (system->omp_active)
for (i = 0; i < bonds->num_intrs; ++i) for (i = 0; i < bonds->num_intrs; ++i)
bonds->select.bond_list[i].bo_data.CdboReduction = bonds->select.bond_list[i].bo_data.CdboReduction =
(double*) smalloc(sizeof(double)*nthreads, "CdboReduction", comm); (double*) smalloc(lmp, sizeof(double)*nthreads, "CdboReduction", comm);
#endif #endif
return SUCCESS; return SUCCESS;
@ -437,21 +434,19 @@ void ReAllocate( LAMMPS *lmp, reax_system *system, control_params *control,
/* system */ /* system */
ret = Allocate_System( system, system->local_cap, system->total_cap, msg ); ret = Allocate_System( system, system->local_cap, system->total_cap, msg );
if (ret != SUCCESS) { if (ret != SUCCESS) {
fprintf( stderr, "not enough space for atom_list: total_cap=%d", char errmsg[128];
system->total_cap ); snprintf(errmsg, 128, "Not enough space for atom_list: total_cap=%d", system->total_cap);
fprintf( stderr, "terminating...\n" ); lmp->error->one(FLERR, errmsg);
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
/* workspace */ /* workspace */
DeAllocate_Workspace( control, workspace ); DeAllocate_Workspace( lmp, control, workspace );
ret = Allocate_Workspace( system, control, workspace, system->local_cap, ret = Allocate_Workspace( lmp, system, control, workspace, system->local_cap,
system->total_cap, comm, msg ); system->total_cap, comm, msg );
if (ret != SUCCESS) { if (ret != SUCCESS) {
fprintf( stderr, "no space for workspace: local_cap=%d total_cap=%d", char errmsg[128];
system->local_cap, system->total_cap ); snprintf(errmsg, 128, "Not enough space for workspace: local_cap=%d total_cap=%d", system->local_cap, system->total_cap);
fprintf( stderr, "terminating...\n" ); lmp->error->one(FLERR, errmsg);
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
} }
@ -463,15 +458,15 @@ void ReAllocate( LAMMPS *lmp, reax_system *system, control_params *control,
if (Nflag || realloc->num_far >= far_nbrs->num_intrs * DANGER_ZONE) { if (Nflag || realloc->num_far >= far_nbrs->num_intrs * DANGER_ZONE) {
if (realloc->num_far > far_nbrs->num_intrs) { if (realloc->num_far > far_nbrs->num_intrs) {
fprintf( stderr, "step%d-ran out of space on far_nbrs: top=%d, max=%d", char errmsg[128];
data->step, realloc->num_far, far_nbrs->num_intrs ); 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);
MPI_Abort( comm, INSUFFICIENT_MEMORY ); lmp->error->one(FLERR, errmsg);
} }
newsize = static_cast<int> newsize = static_cast<int>
(MAX( realloc->num_far*safezone, mincap*MIN_NBRS )); (MAX( realloc->num_far*safezone, mincap*MIN_NBRS ));
Reallocate_Neighbor_List( far_nbrs, system->total_cap, newsize, comm ); Reallocate_Neighbor_List( lmp, far_nbrs, system->total_cap, newsize, comm );
realloc->num_far = 0; realloc->num_far = 0;
} }
} }
@ -486,7 +481,7 @@ void ReAllocate( LAMMPS *lmp, reax_system *system, control_params *control,
} }
if (Hflag || realloc->hbonds) { if (Hflag || realloc->hbonds) {
ret = Reallocate_HBonds_List( system, (*lists)+HBONDS, comm ); ret = Reallocate_HBonds_List( lmp, system, (*lists)+HBONDS, comm );
realloc->hbonds = 0; realloc->hbonds = 0;
} }
} }
@ -502,17 +497,16 @@ void ReAllocate( LAMMPS *lmp, reax_system *system, control_params *control,
/* 3-body list */ /* 3-body list */
if (realloc->num_3body > 0) { if (realloc->num_3body > 0) {
Delete_List( (*lists)+THREE_BODIES, comm ); Delete_List( lmp, (*lists)+THREE_BODIES, comm );
if (num_bonds == -1) if (num_bonds == -1)
num_bonds = ((*lists)+BONDS)->num_intrs; num_bonds = ((*lists)+BONDS)->num_intrs;
realloc->num_3body = (int)(MAX(realloc->num_3body*safezone, MIN_3BODIES)); realloc->num_3body = (int)(MAX(realloc->num_3body*safezone, MIN_3BODIES));
if( !Make_List( num_bonds, realloc->num_3body, TYP_THREE_BODY, if( !Make_List( lmp, num_bonds, realloc->num_3body, TYP_THREE_BODY,
(*lists)+THREE_BODIES, comm ) ) { (*lists)+THREE_BODIES, comm ) ) {
fprintf( stderr, "Problem in initializing angles list. Terminating!\n" ); lmp->error->one(FLERR, "Problem in initializing angles list");
MPI_Abort( comm, CANNOT_INITIALIZE );
} }
realloc->num_3body = -1; realloc->num_3body = -1;
} }

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

@ -33,14 +33,14 @@
#include "error.h" #include "error.h"
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
int PreAllocate_Space( reax_system*, control_params*, storage*, MPI_Comm ); int PreAllocate_Space( LAMMPS_NS::LAMMPS*, reax_system*, control_params*, storage*, MPI_Comm );
int Allocate_System( reax_system*, int, int, char* ); int Allocate_System( reax_system*, int, int, char* );
void DeAllocate_System( reax_system* ); void DeAllocate_System( LAMMPS_NS::LAMMPS*, reax_system* );
int Allocate_Workspace( reax_system*, control_params*, storage*, int Allocate_Workspace( LAMMPS_NS::LAMMPS*, reax_system*, control_params*, storage*,
int, int, MPI_Comm, char* ); int, int, MPI_Comm, char* );
void DeAllocate_Workspace( control_params*, storage* ); void DeAllocate_Workspace( LAMMPS_NS::LAMMPS*, control_params*, storage* );
void ReAllocate( LAMMPS *lmp, reax_system*, control_params*, simulation_data*, storage*, void ReAllocate( LAMMPS *lmp, reax_system*, control_params*, simulation_data*, storage*,
reax_list**, mpi_datatypes* ); reax_list**, mpi_datatypes* );

3
src/USER-REAXC/reaxc_bond_orders.cpp
View File

@ -360,7 +360,8 @@ int BOp( storage *workspace, reax_list *bonds, double bo_cut,
void BO( reax_system *system, control_params * /*control*/, simulation_data * /*data*/, void BO( reax_system *system, control_params * /*control*/, simulation_data * /*data*/,
storage *workspace, reax_list **lists, output_controls * /*out_control*/ ) storage *workspace, reax_list **lists, output_controls * /*out_control*/,
LAMMPS_NS::LAMMPS* lmp )
{ {
int i, j, pj, type_i, type_j; int i, j, pj, type_i, type_j;
int start_i, end_i, sym_index; int start_i, end_i, sym_index;

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

@ -42,5 +42,5 @@ void Add_dBond_to_Forces_NPT( int, int, simulation_data*,
int BOp(storage*, reax_list*, double, int, int, far_neighbor_data*, int BOp(storage*, reax_list*, double, int, int, far_neighbor_data*,
single_body_parameters*, single_body_parameters*, two_body_parameters*); single_body_parameters*, single_body_parameters*, two_body_parameters*);
void BO( reax_system*, control_params*, simulation_data*, void BO( reax_system*, control_params*, simulation_data*,
storage*, reax_list**, output_controls* ); storage*, reax_list**, output_controls*, LAMMPS_NS::LAMMPS* = NULL );
#endif #endif

2
src/USER-REAXC/reaxc_bonds.cpp
View File

@ -33,7 +33,7 @@
void Bonds( reax_system *system, control_params * /*control*/, void Bonds( reax_system *system, control_params * /*control*/,
simulation_data *data, storage *workspace, reax_list **lists, simulation_data *data, storage *workspace, reax_list **lists,
output_controls * /*out_control*/ ) output_controls * /*out_control*/, LAMMPS_NS::LAMMPS* lmp )
{ {
int i, j, pj, natoms; int i, j, pj, natoms;
int start_i, end_i; int start_i, end_i;

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

@ -30,5 +30,5 @@
#include "reaxc_types.h" #include "reaxc_types.h"
void Bonds( reax_system*, control_params*, simulation_data*, void Bonds( reax_system*, control_params*, simulation_data*,
storage*, reax_list**, output_controls* ); storage*, reax_list**, output_controls*, LAMMPS_NS::LAMMPS* = NULL );
#endif #endif

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

@ -28,7 +28,9 @@
#include "reaxc_control.h" #include "reaxc_control.h"
#include "reaxc_tool_box.h" #include "reaxc_tool_box.h"
char Read_Control_File( char *control_file, control_params* control, using namespace LAMMPS_NS;
char Read_Control_File( LAMMPS *lmp, char *control_file, control_params* control,
output_controls *out_control ) output_controls *out_control )
{ {
FILE *fp; FILE *fp;
@ -38,8 +40,7 @@ char Read_Control_File( char *control_file, control_params* control,
/* open control file */ /* open control file */
if ( (fp = fopen( control_file, "r" ) ) == NULL ) { if ( (fp = fopen( control_file, "r" ) ) == NULL ) {
fprintf( stderr, "error opening the control file! terminating...\n" ); lmp->error->all(FLERR, "The control file cannot be opened");
MPI_Abort( MPI_COMM_WORLD, FILE_NOT_FOUND );
} }
/* assign default values */ /* assign default values */
@ -364,8 +365,9 @@ char Read_Control_File( char *control_file, control_params* control,
control->restrict_type = ival; control->restrict_type = ival;
} }
else { else {
fprintf( stderr, "WARNING: unknown parameter %s\n", tmp[0] ); char errmsg[128];
MPI_Abort( MPI_COMM_WORLD, 15 ); snprintf(errmsg,128,"Unknown parameter %s in the control file", tmp[0]);
lmp->error->all(FLERR, errmsg);
} }
} }

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

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

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

@ -29,7 +29,10 @@
#include "reaxc_ffield.h" #include "reaxc_ffield.h"
#include "reaxc_tool_box.h" #include "reaxc_tool_box.h"
char Read_Force_Field( FILE *fp, reax_interaction *reax, #include "lammps.h"
#include "error.h"
char Read_Force_Field( LAMMPS_NS::LAMMPS* lmp, FILE *fp, reax_interaction *reax,
control_params *control ) control_params *control )
{ {
char *s; char *s;
@ -61,7 +64,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
n = atoi(tmp[0]); n = atoi(tmp[0]);
if (n < 1) { if (n < 1) {
if (me == 0) if (me == 0)
fprintf( stderr, "WARNING: number of globals in ffield file is 0!\n" ); lmp->error->warning( FLERR, "Number of globals in ffield file is 0" );
fclose(fp); fclose(fp);
free(s); free(s);
free(tmp); free(tmp);
@ -96,54 +99,54 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
/* Allocating structures in reax_interaction */ /* Allocating structures in reax_interaction */
reax->sbp = (single_body_parameters*) reax->sbp = (single_body_parameters*)
scalloc( reax->num_atom_types, sizeof(single_body_parameters), "sbp", scalloc(lmp, reax->num_atom_types, sizeof(single_body_parameters), "sbp",
comm ); comm );
reax->tbp = (two_body_parameters**) reax->tbp = (two_body_parameters**)
scalloc( reax->num_atom_types, sizeof(two_body_parameters*), "tbp", comm ); scalloc(lmp, reax->num_atom_types, sizeof(two_body_parameters*), "tbp", comm );
reax->thbp= (three_body_header***) reax->thbp= (three_body_header***)
scalloc( reax->num_atom_types, sizeof(three_body_header**), "thbp", comm ); scalloc(lmp, reax->num_atom_types, sizeof(three_body_header**), "thbp", comm );
reax->hbp = (hbond_parameters***) reax->hbp = (hbond_parameters***)
scalloc( reax->num_atom_types, sizeof(hbond_parameters**), "hbp", comm ); scalloc(lmp, reax->num_atom_types, sizeof(hbond_parameters**), "hbp", comm );
reax->fbp = (four_body_header****) reax->fbp = (four_body_header****)
scalloc( reax->num_atom_types, sizeof(four_body_header***), "fbp", comm ); scalloc(lmp, reax->num_atom_types, sizeof(four_body_header***), "fbp", comm );
tor_flag = (char****) tor_flag = (char****)
scalloc( reax->num_atom_types, sizeof(char***), "tor_flag", comm ); scalloc(lmp, reax->num_atom_types, sizeof(char***), "tor_flag", comm );
for( i = 0; i < reax->num_atom_types; i++ ) { for( i = 0; i < reax->num_atom_types; i++ ) {
reax->tbp[i] = (two_body_parameters*) reax->tbp[i] = (two_body_parameters*)
scalloc( reax->num_atom_types, sizeof(two_body_parameters), "tbp[i]", scalloc(lmp, reax->num_atom_types, sizeof(two_body_parameters), "tbp[i]",
comm ); comm );
reax->thbp[i]= (three_body_header**) reax->thbp[i]= (three_body_header**)
scalloc( reax->num_atom_types, sizeof(three_body_header*), "thbp[i]", scalloc(lmp, reax->num_atom_types, sizeof(three_body_header*), "thbp[i]",
comm ); comm );
reax->hbp[i] = (hbond_parameters**) reax->hbp[i] = (hbond_parameters**)
scalloc( reax->num_atom_types, sizeof(hbond_parameters*), "hbp[i]", scalloc(lmp, reax->num_atom_types, sizeof(hbond_parameters*), "hbp[i]",
comm ); comm );
reax->fbp[i] = (four_body_header***) reax->fbp[i] = (four_body_header***)
scalloc( reax->num_atom_types, sizeof(four_body_header**), "fbp[i]", scalloc(lmp, reax->num_atom_types, sizeof(four_body_header**), "fbp[i]",
comm ); comm );
tor_flag[i] = (char***) tor_flag[i] = (char***)
scalloc( reax->num_atom_types, sizeof(char**), "tor_flag[i]", comm ); scalloc(lmp, reax->num_atom_types, sizeof(char**), "tor_flag[i]", comm );
for( j = 0; j < reax->num_atom_types; j++ ) { for( j = 0; j < reax->num_atom_types; j++ ) {
reax->thbp[i][j]= (three_body_header*) reax->thbp[i][j]= (three_body_header*)
scalloc( reax->num_atom_types, sizeof(three_body_header), "thbp[i,j]", scalloc(lmp, reax->num_atom_types, sizeof(three_body_header), "thbp[i,j]",
comm ); comm );
reax->hbp[i][j] = (hbond_parameters*) reax->hbp[i][j] = (hbond_parameters*)
scalloc( reax->num_atom_types, sizeof(hbond_parameters), "hbp[i,j]", scalloc(lmp, reax->num_atom_types, sizeof(hbond_parameters), "hbp[i,j]",
comm ); comm );
reax->fbp[i][j] = (four_body_header**) reax->fbp[i][j] = (four_body_header**)
scalloc( reax->num_atom_types, sizeof(four_body_header*), "fbp[i,j]", scalloc(lmp, reax->num_atom_types, sizeof(four_body_header*), "fbp[i,j]",
comm ); comm );
tor_flag[i][j] = (char**) tor_flag[i][j] = (char**)
scalloc( reax->num_atom_types, sizeof(char*), "tor_flag[i,j]", comm ); scalloc(lmp, reax->num_atom_types, sizeof(char*), "tor_flag[i,j]", comm );
for (k=0; k < reax->num_atom_types; k++) { for (k=0; k < reax->num_atom_types; k++) {
reax->fbp[i][j][k] = (four_body_header*) reax->fbp[i][j][k] = (four_body_header*)
scalloc( reax->num_atom_types, sizeof(four_body_header), "fbp[i,j,k]", scalloc(lmp, reax->num_atom_types, sizeof(four_body_header), "fbp[i,j,k]",
comm ); comm );
tor_flag[i][j][k] = (char*) tor_flag[i][j][k] = (char*)
scalloc( reax->num_atom_types, sizeof(char), "tor_flag[i,j,k]", scalloc(lmp, reax->num_atom_types, sizeof(char), "tor_flag[i,j,k]",
comm ); comm );
} }
} }
@ -158,15 +161,9 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
c = Tokenize( s, &tmp ); c = Tokenize( s, &tmp );
/* Sanity checks */ /* Sanity checks */
if (c == 2 && !lgflag) {
if (me == 0)
fprintf(stderr, "Force field file requires using 'lgvdw yes'\n");
MPI_Abort( comm, FILE_NOT_FOUND );
}
if (c < 9) { if (c < 9) {
if (me == 0) lmp->error->one(FLERR,"Inconsistent ffield file");
fprintf(stderr, "Inconsistent ffield file (reaxc_ffield.cpp) \n");
MPI_Abort( comm, FILE_NOT_FOUND );
} }
for( j = 0; j < (int)(strlen(tmp[0])); ++j ) for( j = 0; j < (int)(strlen(tmp[0])); ++j )
@ -188,9 +185,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
/* Sanity check */ /* Sanity check */
if (c < 8) { if (c < 8) {
if (me == 0) lmp->error->one(FLERR,"Inconsistent ffield file");
fprintf(stderr, "Inconsistent ffield file (reaxc_ffield.cpp) \n");
MPI_Abort( comm, FILE_NOT_FOUND );
} }
val = atof(tmp[0]); reax->sbp[i].alpha = val; val = atof(tmp[0]); reax->sbp[i].alpha = val;
@ -208,9 +203,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
/* Sanity check */ /* Sanity check */
if (c < 8) { if (c < 8) {
if (me == 0) lmp->error->one(FLERR,"Inconsistent ffield file");
fprintf(stderr, "Inconsistent ffield file (reaxc_ffield.cpp) \n");
MPI_Abort( comm, FILE_NOT_FOUND );
} }
val = atof(tmp[0]); reax->sbp[i].r_pi_pi = val; val = atof(tmp[0]); reax->sbp[i].r_pi_pi = val;
@ -228,9 +221,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
/* Sanity check */ /* Sanity check */
if (c < 8) { if (c < 8) {
if (me == 0) lmp->error->one(FLERR,"Inconsistent ffield file");
fprintf(stderr, "Inconsistent ffield file (reaxc_ffield.cpp) \n");
MPI_Abort( comm, FILE_NOT_FOUND );
} }
val = atof(tmp[0]); reax->sbp[i].p_ovun2 = val; val = atof(tmp[0]); reax->sbp[i].p_ovun2 = val;
@ -249,9 +240,7 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
/* Sanity check */ /* Sanity check */
if (c > 2) { if (c > 2) {
if (me == 0) lmp->error->one(FLERR,"Force field file incompatible with 'lgvdw yes'");
fprintf(stderr, "Force field file incompatible with 'lgvdw yes'\n");
MPI_Abort( comm, FILE_NOT_FOUND );
} }
val = atof(tmp[0]); reax->sbp[i].lgcij = val; val = atof(tmp[0]); reax->sbp[i].lgcij = val;
@ -261,28 +250,32 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
if (reax->sbp[i].rcore2>0.01 && reax->sbp[i].acore2>0.01) { // Inner-wall if (reax->sbp[i].rcore2>0.01 && reax->sbp[i].acore2>0.01) { // Inner-wall
if (reax->sbp[i].gamma_w>0.5) { // Shielding vdWaals if (reax->sbp[i].gamma_w>0.5) { // Shielding vdWaals
if (reax->gp.vdw_type != 0 && reax->gp.vdw_type != 3) { if (reax->gp.vdw_type != 0 && reax->gp.vdw_type != 3) {
if (errorflag && (me == 0)) if (errorflag && (me == 0)) {
fprintf( stderr, "Warning: inconsistent vdWaals-parameters\n" \ char errmsg[512];
"Force field parameters for element %s\n" \ snprintf(errmsg, 512, "VdWaals-parameters for element %s "
"indicate inner wall+shielding, but earlier\n" \ "indicate inner wall+shielding, but earlier "
"atoms indicate different vdWaals-method.\n" \ "atoms indicate different vdWaals-method. "
"This may cause division-by-zero errors.\n" \ "This may cause division-by-zero errors. "
"Keeping vdWaals-setting for earlier atoms.\n", "Keeping vdWaals-setting for earlier atoms.",
reax->sbp[i].name); reax->sbp[i].name);
lmp->error->warning(FLERR,errmsg);
}
errorflag = 0; errorflag = 0;
} else { } else {
reax->gp.vdw_type = 3; reax->gp.vdw_type = 3;
} }
} else { // No shielding vdWaals parameters present } else { // No shielding vdWaals parameters present
if (reax->gp.vdw_type != 0 && reax->gp.vdw_type != 2) { if (reax->gp.vdw_type != 0 && reax->gp.vdw_type != 2) {
if (me == 0) if (me == 0) {
fprintf( stderr, "Warning: inconsistent vdWaals-parameters\n" \ char errmsg[512];
"Force field parameters for element %s\n" \ snprintf(errmsg, 512, "VdWaals-parameters for element %s "
"indicate inner wall without shielding, but earlier\n" \ "indicate inner wall without shielding, but earlier "
"atoms indicate different vdWaals-method.\n" \ "atoms indicate different vdWaals-method. "
"This may cause division-by-zero errors.\n" \ "This may cause division-by-zero errors. "
"Keeping vdWaals-setting for earlier atoms.\n", "Keeping vdWaals-setting for earlier atoms.",
reax->sbp[i].name); reax->sbp[i].name);
lmp->error->warning(FLERR,errmsg);
}
} else { } else {
reax->gp.vdw_type = 2; reax->gp.vdw_type = 2;
} }
@ -290,23 +283,25 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
} else { // No Inner wall parameters present } else { // No Inner wall parameters present
if (reax->sbp[i].gamma_w>0.5) { // Shielding vdWaals if (reax->sbp[i].gamma_w>0.5) { // Shielding vdWaals
if (reax->gp.vdw_type != 0 && reax->gp.vdw_type != 1) { if (reax->gp.vdw_type != 0 && reax->gp.vdw_type != 1) {
if (me == 0) if (me == 0) {
fprintf( stderr, "Warning: inconsistent vdWaals-parameters\n" \ char errmsg[512];
"Force field parameters for element %s\n" \ snprintf(errmsg, 512, "VdWaals parameters for element %s "
"indicate shielding without inner wall, but earlier\n" \ "indicate shielding without inner wall, but earlier "
"atoms indicate different vdWaals-method.\n" \ "elements indicate different vdWaals-method. "
"This may cause division-by-zero errors.\n" \ "This may cause division-by-zero errors. "
"Keeping vdWaals-setting for earlier atoms.\n", "Keeping vdWaals-setting for earlier atoms.",
reax->sbp[i].name); reax->sbp[i].name);
lmp->error->warning(FLERR,errmsg);
}
} else { } else {
reax->gp.vdw_type = 1; reax->gp.vdw_type = 1;
} }
} else { } else {
if (me == 0) char errmsg[256];
fprintf( stderr, "Error: inconsistent vdWaals-parameters\n" \ snprintf(errmsg, 256, "Inconsistent vdWaals-parameters "
"No shielding or inner-wall set for element %s\n", "No shielding or inner-wall set for element %s",
reax->sbp[i].name); reax->sbp[i].name);
MPI_Abort( comm, INVALID_INPUT ); lmp->error->all(FLERR, errmsg);
} }
} }
} }
@ -315,15 +310,23 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
for( i = 0; i < reax->num_atom_types; i++ ) for( i = 0; i < reax->num_atom_types; i++ )
if( reax->sbp[i].mass < 21 && if( reax->sbp[i].mass < 21 &&
reax->sbp[i].valency_val != reax->sbp[i].valency_boc ) { reax->sbp[i].valency_val != reax->sbp[i].valency_boc ) {
if (me == 0) if (me == 0) {
fprintf(stderr,"Warning: changed valency_val to valency_boc for %s\n", char errmsg[256];
snprintf(errmsg, 256, "Changed valency_val to valency_boc for %s",
reax->sbp[i].name); reax->sbp[i].name);
lmp->error->warning(FLERR,errmsg);
}
reax->sbp[i].valency_val = reax->sbp[i].valency_boc; reax->sbp[i].valency_val = reax->sbp[i].valency_boc;
} }
/* next line is number of two body combination and some comments */ /* next line is number of two body combination and some comments */
fgets(s,MAX_LINE,fp); fgets(s,MAX_LINE,fp);
c=Tokenize(s,&tmp); c=Tokenize(s,&tmp);
if (c == 2 && !lgflag) {
lmp->error->all(FLERR, "Force field file requires using 'lgvdw yes'");
}
l = atoi(tmp[0]); l = atoi(tmp[0]);
/* a line of comments */ /* a line of comments */
@ -334,6 +337,8 @@ char Read_Force_Field( FILE *fp, reax_interaction *reax,
fgets(s,MAX_LINE,fp); fgets(s,MAX_LINE,fp);
c=Tokenize(s,&tmp); c=Tokenize(s,&tmp);
j = atoi(tmp[0]) - 1; j = atoi(tmp[0]) - 1;
k = atoi(tmp[1]) - 1; k = atoi(tmp[1]) - 1;

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

@ -29,6 +29,6 @@
#include "reaxc_types.h" #include "reaxc_types.h"
char Read_Force_Field( FILE*, reax_interaction*, control_params* ); char Read_Force_Field( LAMMPS_NS::LAMMPS*, FILE*, reax_interaction*, control_params* );
#endif #endif

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

@ -39,15 +39,12 @@
#include "reaxc_valence_angles.h" #include "reaxc_valence_angles.h"
#include "reaxc_vector.h" #include "reaxc_vector.h"
#include "lammps.h"
#include "error.h"
interaction_function Interaction_Functions[NUM_INTRS]; interaction_function Interaction_Functions[NUM_INTRS];
using namespace LAMMPS_NS;
void Dummy_Interaction( reax_system * /*system*/, control_params * /*control*/, void Dummy_Interaction( reax_system * /*system*/, control_params * /*control*/,
simulation_data * /*data*/, storage * /*workspace*/, simulation_data * /*data*/, storage * /*workspace*/,
reax_list **/*lists*/, output_controls * /*out_control*/ ) reax_list ** /*lists*/, output_controls * /*out_control*/, LAMMPS_NS::LAMMPS* = NULL )
{ {
} }
@ -79,7 +76,7 @@ void Compute_Bonded_Forces( reax_system *system, control_params *control,
/* Implement all force calls as function pointers */ /* Implement all force calls as function pointers */
for( i = 0; i < NUM_INTRS; i++ ) { for( i = 0; i < NUM_INTRS; i++ ) {
(Interaction_Functions[i])( system, control, data, workspace, (Interaction_Functions[i])( system, control, data, workspace,
lists, out_control ); lists, out_control, NULL );
} }
} }
@ -118,7 +115,7 @@ void Compute_Total_Force( reax_system *system, control_params *control,
} }
void Validate_Lists( LAMMPS *lmp, reax_system *system, storage * /*workspace*/, reax_list **lists, void Validate_Lists( LAMMPS_NS::LAMMPS *lmp, 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, MPI_Comm comm )
{ {
int i, comp, Hindex; int i, comp, Hindex;
@ -138,9 +135,10 @@ void Validate_Lists( LAMMPS *lmp, reax_system *system, storage * /*workspace*/,
else comp = bonds->num_intrs; else comp = bonds->num_intrs;
if (End_Index(i, bonds) > comp) { if (End_Index(i, bonds) > comp) {
fprintf( stderr, "step%d-bondchk failed: i=%d end(i)=%d str(i+1)=%d\n", char errmsg[256];
snprintf(errmsg, 256, "step%d-bondchk failed: i=%d end(i)=%d str(i+1)=%d\n",
step, i, End_Index(i,bonds), comp ); step, i, End_Index(i,bonds), comp );
lmp->error->all(FLERR,"Failure in bond list."); lmp->error->all(FLERR,errmsg);
} }
} }
} }
@ -165,9 +163,10 @@ void Validate_Lists( LAMMPS *lmp, reax_system *system, storage * /*workspace*/,
else comp = hbonds->num_intrs; else comp = hbonds->num_intrs;
if (End_Index(Hindex, hbonds) > comp) { if (End_Index(Hindex, hbonds) > comp) {
fprintf(stderr,"step%d-hbondchk failed: H=%d end(H)=%d str(H+1)=%d\n", char errmsg[256];
snprintf(errmsg, 256, "step%d-hbondchk failed: H=%d end(H)=%d str(H+1)=%d\n",
step, Hindex, End_Index(Hindex,hbonds), comp ); step, Hindex, End_Index(Hindex,hbonds), comp );
lmp->error->all(FLERR, "Failure in hydrogen bonds."); lmp->error->all(FLERR, errmsg);
} }
} }
} }
@ -175,7 +174,7 @@ void Validate_Lists( LAMMPS *lmp, reax_system *system, storage * /*workspace*/,
} }
void Init_Forces_noQEq( LAMMPS *lmp, reax_system *system, control_params *control, void Init_Forces_noQEq( LAMMPS_NS::LAMMPS *lmp, reax_system *system, control_params *control,
simulation_data *data, storage *workspace, simulation_data *data, storage *workspace,
reax_list **lists, output_controls * /*out_control*/, reax_list **lists, output_controls * /*out_control*/,
MPI_Comm comm ) { MPI_Comm comm ) {
@ -435,7 +434,7 @@ void Estimate_Storages( reax_system *system, control_params *control,
} }
void Compute_Forces( LAMMPS *lmp, reax_system *system, control_params *control, void Compute_Forces( LAMMPS_NS::LAMMPS *lmp, reax_system *system, control_params *control,
simulation_data *data, storage *workspace, simulation_data *data, storage *workspace,
reax_list **lists, output_controls *out_control, reax_list **lists, output_controls *out_control,
mpi_datatypes *mpi_data ) mpi_datatypes *mpi_data )

2
src/USER-REAXC/reaxc_hydrogen_bonds.cpp
View File

@ -33,7 +33,7 @@
void Hydrogen_Bonds( reax_system *system, control_params *control, void Hydrogen_Bonds( reax_system *system, control_params *control,
simulation_data *data, storage *workspace, simulation_data *data, storage *workspace,
reax_list **lists, output_controls * /*out_control*/ ) reax_list **lists, output_controls * /*out_control*/, LAMMPS_NS::LAMMPS* lmp )
{ {
int i, j, k, pi, pk; int i, j, k, pi, pk;
int type_i, type_j, type_k; int type_i, type_j, type_k;

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

@ -30,6 +30,6 @@
#include "reaxc_types.h" #include "reaxc_types.h"
void Hydrogen_Bonds( reax_system*, control_params*, simulation_data*, void Hydrogen_Bonds( reax_system*, control_params*, simulation_data*,
storage*, reax_list**, output_controls* ); storage*, reax_list**, output_controls*, LAMMPS_NS::LAMMPS* = NULL );
#endif #endif

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

@ -82,7 +82,7 @@ int Init_Simulation_Data( reax_system *system, control_params *control,
return SUCCESS; return SUCCESS;
} }
void Init_Taper( control_params *control, storage *workspace, MPI_Comm comm ) void Init_Taper( LAMMPS_NS::LAMMPS* lmp, control_params *control, storage *workspace, MPI_Comm comm )
{ {
double d1, d7; double d1, d7;
double swa, swa2, swa3; double swa, swa2, swa3;
@ -92,14 +92,16 @@ void Init_Taper( control_params *control, storage *workspace, MPI_Comm comm )
swb = control->nonb_cut; swb = control->nonb_cut;
if (fabs( swa ) > 0.01) if (fabs( swa ) > 0.01)
fprintf( stderr, "Warning: non-zero lower Taper-radius cutoff\n" ); lmp->error->warning( FLERR, "Non-zero lower Taper-radius cutoff" );
if (swb < 0) { if (swb < 0) {
fprintf( stderr, "Negative upper Taper-radius cutoff\n" ); lmp->error->all(FLERR,"Negative upper Taper-radius cutoff");
MPI_Abort( comm, INVALID_INPUT ); }
else if( swb < 5 ) {
char errmsg[256];
snprintf(errmsg, 256, "Very low Taper-radius cutoff: %f", swb );
lmp->error->warning( FLERR, errmsg );
} }
else if( swb < 5 )
fprintf( stderr, "Warning: very low Taper-radius cutoff: %f\n", swb );
d1 = swb - swa; d1 = swb - swa;
d7 = pow( d1, 7.0 ); d7 = pow( d1, 7.0 );
@ -120,12 +122,12 @@ void Init_Taper( control_params *control, storage *workspace, MPI_Comm comm )
} }
int Init_Workspace( reax_system *system, control_params *control, int Init_Workspace( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
storage *workspace, MPI_Comm comm, char *msg ) storage *workspace, MPI_Comm comm, char *msg )
{ {
int ret; int ret;
ret = Allocate_Workspace( system, control, workspace, ret = Allocate_Workspace( lmp, system, control, workspace,
system->local_cap, system->total_cap, comm, msg ); system->local_cap, system->total_cap, comm, msg );
if (ret != SUCCESS) if (ret != SUCCESS)
return ret; return ret;
@ -134,7 +136,7 @@ int Init_Workspace( reax_system *system, control_params *control,
Reset_Workspace( system, workspace ); Reset_Workspace( system, workspace );
/* Initialize the Taper function */ /* Initialize the Taper function */
Init_Taper( control, workspace, comm ); Init_Taper( lmp, control, workspace, comm );
return SUCCESS; return SUCCESS;
} }
@ -179,10 +181,9 @@ int Init_Lists( LAMMPS *lmp, reax_system *system, control_params *control,
} }
total_hbonds = (int)(MAX( total_hbonds*saferzone, mincap*MIN_HBONDS )); total_hbonds = (int)(MAX( total_hbonds*saferzone, mincap*MIN_HBONDS ));
if( !Make_List( system->Hcap, total_hbonds, TYP_HBOND, if( !Make_List( lmp, system->Hcap, total_hbonds, TYP_HBOND,
*lists+HBONDS, comm ) ) { *lists+HBONDS, comm ) ) {
fprintf( stderr, "not enough space for hbonds list. terminating!\n" ); lmp->error->one(FLERR, "Not enough space for hbonds list.");
lmp->error->all(FLERR, "Can't allocate space for hbonds.");
} }
} }
@ -193,18 +194,16 @@ int Init_Lists( LAMMPS *lmp, reax_system *system, control_params *control,
} }
bond_cap = (int)(MAX( total_bonds*safezone, mincap*MIN_BONDS )); bond_cap = (int)(MAX( total_bonds*safezone, mincap*MIN_BONDS ));
if( !Make_List( system->total_cap, bond_cap, TYP_BOND, if( !Make_List( lmp, system->total_cap, bond_cap, TYP_BOND,
*lists+BONDS, comm ) ) { *lists+BONDS, comm ) ) {
fprintf( stderr, "not enough space for bonds list. terminating!\n" ); lmp->error->one(FLERR, "Not enough space for bonds list.");
lmp->error->all(FLERR, "Can't allocate space for hbonds.");
} }
/* 3bodies list */ /* 3bodies list */
cap_3body = (int)(MAX( num_3body*safezone, MIN_3BODIES )); cap_3body = (int)(MAX( num_3body*safezone, MIN_3BODIES ));
if( !Make_List( bond_cap, cap_3body, TYP_THREE_BODY, if( !Make_List( lmp, bond_cap, cap_3body, TYP_THREE_BODY,
*lists+THREE_BODIES, comm ) ){ *lists+THREE_BODIES, comm ) ){
fprintf( stderr, "Problem in initializing angles list. Terminating!\n" ); lmp->error->one(FLERR,"Problem in initializing angles list.");
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
free( hb_top ); free( hb_top );
@ -219,60 +218,53 @@ void Initialize( LAMMPS *lmp, reax_system *system, control_params *control,
mpi_datatypes *mpi_data, MPI_Comm comm ) mpi_datatypes *mpi_data, MPI_Comm comm )
{ {
char msg[MAX_STR]; char msg[MAX_STR];
char errmsg[128];
if (Init_MPI_Datatypes(system, workspace, mpi_data, comm, msg) == FAILURE) { if (Init_MPI_Datatypes(system, workspace, mpi_data, comm, msg) == FAILURE) {
fprintf( stderr, "p%d: init_mpi_datatypes: could not create datatypes\n",
snprintf(errmsg, 128, "Could not create datatypes on thread %d",
system->my_rank); system->my_rank);
fprintf( stderr, "p%d: mpi_data couldn't be initialized! terminating.\n", lmp->error->one(FLERR,errmsg);
system->my_rank );
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE );
} }
if (Init_System(system, control, msg) == FAILURE) { if (Init_System(system, control, msg) == FAILURE) {
fprintf( stderr, "p%d: %s\n", system->my_rank, msg ); snprintf(errmsg, 128, "System could not be initialized on thread %d",
fprintf( stderr, "p%d: system could not be initialized! terminating.\n",
system->my_rank); system->my_rank);
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE ); lmp->error->one(FLERR,errmsg);
} }
if (Init_Simulation_Data( system, control, data, msg ) == FAILURE) { if (Init_Simulation_Data( system, control, data, msg ) == FAILURE) {
fprintf( stderr, "p%d: %s\n", system->my_rank, msg ); snprintf(errmsg, 128, "Sim_data could not be initialized on thread %d",
fprintf( stderr, "p%d: sim_data couldn't be initialized! terminating.\n",
system->my_rank); system->my_rank);
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE ); lmp->error->one(FLERR,errmsg);
} }
if (Init_Workspace( system, control, workspace, mpi_data->world, msg ) == if (Init_Workspace( lmp, system, control, workspace, mpi_data->world, msg ) ==
FAILURE) { FAILURE) {
fprintf( stderr, "p%d:init_workspace: not enough memory\n", snprintf(errmsg, 128, "Workspace could not be initialized on thread %d",
system->my_rank); system->my_rank);
fprintf( stderr, "p%d:workspace couldn't be initialized! terminating.\n", lmp->error->one(FLERR,errmsg);
system->my_rank );
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE );
} }
if (Init_Lists( lmp, system, control, data, workspace, lists, mpi_data, msg ) == if (Init_Lists( lmp, system, control, data, workspace, lists, mpi_data, msg ) ==
FAILURE) { FAILURE) {
fprintf( stderr, "p%d: %s\n", system->my_rank, msg ); snprintf(errmsg, 128, "System could not be initialized on thread %d",
fprintf( stderr, "p%d: system could not be initialized! terminating.\n",
system->my_rank); system->my_rank);
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE ); lmp->error->one(FLERR,errmsg);
} }
if (Init_Output_Files(system,control,out_control,mpi_data,msg)== FAILURE) { if (Init_Output_Files(lmp, system,control,out_control,mpi_data,msg)== FAILURE) {
fprintf( stderr, "p%d: %s\n", system->my_rank, msg ); snprintf(errmsg, 128, "Could not open output files on thread %d",
fprintf( stderr, "p%d: could not open output files! terminating...\n",
system->my_rank); system->my_rank);
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE ); lmp->error->one(FLERR,errmsg);
} }
if (control->tabulate) { if (control->tabulate) {
if (Init_Lookup_Tables( system, control, workspace, mpi_data, msg ) == FAILURE) { if (Init_Lookup_Tables( lmp, system, control, workspace, mpi_data, msg ) == FAILURE) {
fprintf( stderr, "p%d: %s\n", system->my_rank, msg ); snprintf(errmsg, 128, "Lookup table could not be created on thread %d",
fprintf( stderr, "p%d: couldn't create lookup table! terminating.\n",
system->my_rank); system->my_rank);
MPI_Abort( mpi_data->world, CANNOT_INITIALIZE ); lmp->error->one(FLERR,errmsg);
} }
} }

8
src/USER-REAXC/reaxc_io_tools.cpp
View File

@ -34,7 +34,7 @@
#include "reaxc_traj.h" #include "reaxc_traj.h"
#include "reaxc_vector.h" #include "reaxc_vector.h"
int Init_Output_Files( reax_system *system, control_params *control, int Init_Output_Files( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
output_controls *out_control, mpi_datatypes *mpi_data, output_controls *out_control, mpi_datatypes *mpi_data,
char *msg ) char *msg )
{ {
@ -42,7 +42,7 @@ int Init_Output_Files( reax_system *system, control_params *control,
int ret; int ret;
if (out_control->write_steps > 0) { if (out_control->write_steps > 0) {
ret = Init_Traj( system, control, out_control, mpi_data, msg ); ret = Init_Traj( lmp, system, control, out_control, mpi_data, msg );
if (ret == FAILURE) if (ret == FAILURE)
return ret; return ret;
} }
@ -107,7 +107,7 @@ int Close_Output_Files( reax_system *system, control_params *control,
} }
void Output_Results( reax_system *system, control_params *control, void Output_Results( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
simulation_data *data, reax_list **lists, simulation_data *data, reax_list **lists,
output_controls *out_control, mpi_datatypes *mpi_data ) output_controls *out_control, mpi_datatypes *mpi_data )
{ {
@ -146,7 +146,7 @@ void Output_Results( reax_system *system, control_params *control,
/* write current frame */ /* write current frame */
if( out_control->write_steps > 0 && if( out_control->write_steps > 0 &&
(data->step-data->prev_steps) % out_control->write_steps == 0 ) { (data->step-data->prev_steps) % out_control->write_steps == 0 ) {
Append_Frame( system, control, data, lists, out_control, mpi_data ); Append_Frame( lmp, system, control, data, lists, out_control, mpi_data );
} }
} }

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

@ -29,10 +29,10 @@
#include "reaxc_types.h" #include "reaxc_types.h"
int Init_Output_Files( reax_system*, control_params*, int Init_Output_Files( LAMMPS_NS::LAMMPS*, reax_system*, control_params*,
output_controls*, mpi_datatypes*, char* ); output_controls*, mpi_datatypes*, char* );
int Close_Output_Files( reax_system*, control_params*, int Close_Output_Files( reax_system*, control_params*,
output_controls*, mpi_datatypes* ); output_controls*, mpi_datatypes* );
void Output_Results( reax_system*, control_params*, simulation_data*, void Output_Results( LAMMPS_NS::LAMMPS*, reax_system*, control_params*, simulation_data*,
reax_list**, output_controls*, mpi_datatypes* ); reax_list**, output_controls*, mpi_datatypes* );
#endif #endif

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

@ -29,116 +29,118 @@
#include "reaxc_tool_box.h" #include "reaxc_tool_box.h"
/************* allocate list space ******************/ /************* allocate list space ******************/
int Make_List(int n, int num_intrs, int type, reax_list *l, MPI_Comm comm) int Make_List( LAMMPS_NS::LAMMPS *lmp, int n, int num_intrs, int type, reax_list *l, MPI_Comm comm)
{ {
l->allocated = 1; l->allocated = 1;
l->n = n; l->n = n;
l->num_intrs = num_intrs; l->num_intrs = num_intrs;
if (l->index) sfree(l->index, "list:index"); if (l->index) sfree(lmp, l->index, "list:index");
if (l->end_index) sfree(l->end_index, "list:end_index"); if (l->end_index) sfree(lmp, l->end_index, "list:end_index");
l->index = (int*) smalloc( n * sizeof(int), "list:index", comm ); l->index = (int*) smalloc(lmp, n * sizeof(int), "list:index", comm );
l->end_index = (int*) smalloc( n * sizeof(int), "list:end_index", comm ); l->end_index = (int*) smalloc(lmp, n * sizeof(int), "list:end_index", comm );
l->type = type; l->type = type;
switch(l->type) { switch(l->type) {
case TYP_VOID: case TYP_VOID:
if (l->select.v) sfree(l->select.v, "list:v"); if (l->select.v) sfree(lmp, l->select.v, "list:v");
l->select.v = (void*) smalloc(l->num_intrs * sizeof(void*), "list:v", comm); l->select.v = (void*) smalloc(lmp, l->num_intrs * sizeof(void*), "list:v", comm);
break; break;
case TYP_THREE_BODY: case TYP_THREE_BODY:
if (l->select.three_body_list) sfree(l->select.three_body_list,"list:three_bodies"); if (l->select.three_body_list) sfree(lmp, l->select.three_body_list,"list:three_bodies");
l->select.three_body_list = (three_body_interaction_data*) l->select.three_body_list = (three_body_interaction_data*)
smalloc( l->num_intrs * sizeof(three_body_interaction_data), smalloc(lmp, l->num_intrs * sizeof(three_body_interaction_data),
"list:three_bodies", comm ); "list:three_bodies", comm );
break; break;
case TYP_BOND: case TYP_BOND:
if (l->select.bond_list) sfree(l->select.bond_list,"list:bonds"); if (l->select.bond_list) sfree(lmp, l->select.bond_list,"list:bonds");
l->select.bond_list = (bond_data*) l->select.bond_list = (bond_data*)
smalloc( l->num_intrs * sizeof(bond_data), "list:bonds", comm ); smalloc(lmp, l->num_intrs * sizeof(bond_data), "list:bonds", comm );
break; break;
case TYP_DBO: case TYP_DBO:
if (l->select.dbo_list) sfree(l->select.dbo_list,"list:dbonds"); if (l->select.dbo_list) sfree(lmp, l->select.dbo_list,"list:dbonds");
l->select.dbo_list = (dbond_data*) l->select.dbo_list = (dbond_data*)
smalloc( l->num_intrs * sizeof(dbond_data), "list:dbonds", comm ); smalloc(lmp, l->num_intrs * sizeof(dbond_data), "list:dbonds", comm );
break; break;
case TYP_DDELTA: case TYP_DDELTA:
if (l->select.dDelta_list) sfree(l->select.dDelta_list,"list:dDeltas"); if (l->select.dDelta_list) sfree(lmp, l->select.dDelta_list,"list:dDeltas");
l->select.dDelta_list = (dDelta_data*) l->select.dDelta_list = (dDelta_data*)
smalloc( l->num_intrs * sizeof(dDelta_data), "list:dDeltas", comm ); smalloc(lmp, l->num_intrs * sizeof(dDelta_data), "list:dDeltas", comm );
break; break;
case TYP_FAR_NEIGHBOR: case TYP_FAR_NEIGHBOR:
if (l->select.far_nbr_list) sfree(l->select.far_nbr_list,"list:far_nbrs"); if (l->select.far_nbr_list) sfree(lmp, l->select.far_nbr_list,"list:far_nbrs");
l->select.far_nbr_list = (far_neighbor_data*) l->select.far_nbr_list = (far_neighbor_data*)
smalloc(l->num_intrs * sizeof(far_neighbor_data), "list:far_nbrs", comm); smalloc(lmp, l->num_intrs * sizeof(far_neighbor_data), "list:far_nbrs", comm);
break; break;
case TYP_HBOND: case TYP_HBOND:
if (l->select.hbond_list) sfree(l->select.hbond_list,"list:hbonds"); if (l->select.hbond_list) sfree(lmp, l->select.hbond_list,"list:hbonds");
l->select.hbond_list = (hbond_data*) l->select.hbond_list = (hbond_data*)
smalloc( l->num_intrs * sizeof(hbond_data), "list:hbonds", comm ); smalloc(lmp, l->num_intrs * sizeof(hbond_data), "list:hbonds", comm );
break; break;
default: default:
fprintf( stderr, "ERROR: no %d list type defined!\n", l->type ); char errmsg[128];
MPI_Abort( comm, INVALID_INPUT ); snprintf(errmsg, 128, "No %d list type defined", l->type);
lmp->error->all(FLERR,errmsg);
} }
return SUCCESS; return SUCCESS;
} }
void Delete_List( reax_list *l, MPI_Comm comm ) void Delete_List( LAMMPS_NS::LAMMPS *lmp, reax_list *l, MPI_Comm comm )
{ {
if (l->allocated == 0) if (l->allocated == 0)
return; return;
l->allocated = 0; l->allocated = 0;
sfree( l->index, "list:index" ); sfree(lmp, l->index, "list:index" );
sfree( l->end_index, "list:end_index" ); sfree(lmp, l->end_index, "list:end_index" );
l->index = NULL; l->index = NULL;
l->end_index = NULL; l->end_index = NULL;
switch(l->type) { switch(l->type) {
case TYP_VOID: case TYP_VOID:
sfree( l->select.v, "list:v" ); sfree(lmp, l->select.v, "list:v" );
l->select.v = NULL; l->select.v = NULL;
break; break;
case TYP_HBOND: case TYP_HBOND:
sfree( l->select.hbond_list, "list:hbonds" ); sfree(lmp, l->select.hbond_list, "list:hbonds" );
l->select.hbond_list = NULL; l->select.hbond_list = NULL;
break; break;
case TYP_FAR_NEIGHBOR: case TYP_FAR_NEIGHBOR:
sfree( l->select.far_nbr_list, "list:far_nbrs" ); sfree(lmp, l->select.far_nbr_list, "list:far_nbrs" );
l->select.far_nbr_list = NULL; l->select.far_nbr_list = NULL;
break; break;
case TYP_BOND: case TYP_BOND:
sfree( l->select.bond_list, "list:bonds" ); sfree(lmp, l->select.bond_list, "list:bonds" );
l->select.bond_list = NULL; l->select.bond_list = NULL;
break; break;
case TYP_DBO: case TYP_DBO:
sfree( l->select.dbo_list, "list:dbos" ); sfree(lmp, l->select.dbo_list, "list:dbos" );
l->select.dbo_list = NULL; l->select.dbo_list = NULL;
break; break;
case TYP_DDELTA: case TYP_DDELTA:
sfree( l->select.dDelta_list, "list:dDeltas" ); sfree(lmp, l->select.dDelta_list, "list:dDeltas" );
l->select.dDelta_list = NULL; l->select.dDelta_list = NULL;
break; break;
case TYP_THREE_BODY: case TYP_THREE_BODY:
sfree( l->select.three_body_list, "list:three_bodies" ); sfree(lmp, l->select.three_body_list, "list:three_bodies" );
l->select.three_body_list = NULL; l->select.three_body_list = NULL;
break; break;
default: default:
fprintf( stderr, "ERROR: no %d list type defined!\n", l->type ); char errmsg[128];
MPI_Abort( comm, INVALID_INPUT ); snprintf(errmsg, 128, "No %d list type defined", l->type);
lmp->error->all(FLERR,errmsg);
} }
} }

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

@ -29,8 +29,8 @@
#include "reaxc_types.h" #include "reaxc_types.h"
int Make_List( int, int, int, reax_list*, MPI_Comm ); int Make_List( LAMMPS_NS::LAMMPS*, int, int, int, reax_list*, MPI_Comm );
void Delete_List( reax_list*, MPI_Comm ); void Delete_List( LAMMPS_NS::LAMMPS*, reax_list*, MPI_Comm );
inline int Num_Entries(int,reax_list*); inline int Num_Entries(int,reax_list*);
inline int Start_Index( int, reax_list* ); inline int Start_Index( int, reax_list* );

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

@ -50,7 +50,7 @@ void Tridiagonal_Solve( const double *a, const double *b,
} }
void Natural_Cubic_Spline( const double *h, const double *f, void Natural_Cubic_Spline( LAMMPS_NS::LAMMPS* lmp, const double *h, const double *f,
cubic_spline_coef *coef, unsigned int n, cubic_spline_coef *coef, unsigned int n,
MPI_Comm comm ) MPI_Comm comm )
{ {
@ -58,11 +58,11 @@ void Natural_Cubic_Spline( const double *h, const double *f,
double *a, *b, *c, *d, *v; double *a, *b, *c, *d, *v;
/* allocate space for the linear system */ /* allocate space for the linear system */
a = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); a = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
b = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); b = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
c = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); c = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
d = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); d = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
v = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); v = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
/* build the linear system */ /* build the linear system */
a[0] = a[1] = a[n-1] = 0; a[0] = a[1] = a[n-1] = 0;
@ -92,16 +92,16 @@ void Natural_Cubic_Spline( const double *h, const double *f,
coef[i-1].a = f[i]; coef[i-1].a = f[i];
} }
sfree( a, "cubic_spline:a" ); sfree(lmp, a, "cubic_spline:a" );
sfree( b, "cubic_spline:b" ); sfree(lmp, b, "cubic_spline:b" );
sfree( c, "cubic_spline:c" ); sfree(lmp, c, "cubic_spline:c" );
sfree( d, "cubic_spline:d" ); sfree(lmp, d, "cubic_spline:d" );
sfree( v, "cubic_spline:v" ); sfree(lmp, v, "cubic_spline:v" );
} }
void Complete_Cubic_Spline( const double *h, const double *f, double v0, double vlast, void Complete_Cubic_Spline( LAMMPS_NS::LAMMPS* lmp, const double *h, const double *f, double v0, double vlast,
cubic_spline_coef *coef, unsigned int n, cubic_spline_coef *coef, unsigned int n,
MPI_Comm comm ) MPI_Comm comm )
{ {
@ -109,11 +109,11 @@ void Complete_Cubic_Spline( const double *h, const double *f, double v0, double
double *a, *b, *c, *d, *v; double *a, *b, *c, *d, *v;
/* allocate space for the linear system */ /* allocate space for the linear system */
a = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); a = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
b = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); b = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
c = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); c = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
d = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); d = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
v = (double*) smalloc( n * sizeof(double), "cubic_spline:a", comm ); v = (double*) smalloc(lmp, n * sizeof(double), "cubic_spline:a", comm );
/* build the linear system */ /* build the linear system */
a[0] = 0; a[0] = 0;
@ -142,15 +142,15 @@ void Complete_Cubic_Spline( const double *h, const double *f, double v0, double
coef[i-1].a = f[i]; coef[i-1].a = f[i];
} }
sfree( a, "cubic_spline:a" ); sfree(lmp, a, "cubic_spline:a" );
sfree( b, "cubic_spline:b" ); sfree(lmp, b, "cubic_spline:b" );
sfree( c, "cubic_spline:c" ); sfree(lmp, c, "cubic_spline:c" );
sfree( d, "cubic_spline:d" ); sfree(lmp, d, "cubic_spline:d" );
sfree( v, "cubic_spline:v" ); sfree(lmp, v, "cubic_spline:v" );
} }
int Init_Lookup_Tables( reax_system *system, control_params *control, int Init_Lookup_Tables( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
storage *workspace, mpi_datatypes *mpi_data, char * /*msg*/ ) storage *workspace, mpi_datatypes *mpi_data, char * /*msg*/ )
{ {
int i, j, r; int i, j, r;
@ -171,23 +171,23 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
num_atom_types = system->reax_param.num_atom_types; num_atom_types = system->reax_param.num_atom_types;
dr = control->nonb_cut / control->tabulate; dr = control->nonb_cut / control->tabulate;
h = (double*) h = (double*)
smalloc( (control->tabulate+2) * sizeof(double), "lookup:h", comm ); smalloc(lmp, (control->tabulate+2) * sizeof(double), "lookup:h", comm );
fh = (double*) fh = (double*)
smalloc( (control->tabulate+2) * sizeof(double), "lookup:fh", comm ); smalloc(lmp, (control->tabulate+2) * sizeof(double), "lookup:fh", comm );
fvdw = (double*) fvdw = (double*)
smalloc( (control->tabulate+2) * sizeof(double), "lookup:fvdw", comm ); smalloc(lmp, (control->tabulate+2) * sizeof(double), "lookup:fvdw", comm );
fCEvd = (double*) fCEvd = (double*)
smalloc( (control->tabulate+2) * sizeof(double), "lookup:fCEvd", comm ); smalloc(lmp, (control->tabulate+2) * sizeof(double), "lookup:fCEvd", comm );
fele = (double*) fele = (double*)
smalloc( (control->tabulate+2) * sizeof(double), "lookup:fele", comm ); smalloc(lmp, (control->tabulate+2) * sizeof(double), "lookup:fele", comm );
fCEclmb = (double*) fCEclmb = (double*)
smalloc( (control->tabulate+2) * sizeof(double), "lookup:fCEclmb", comm ); smalloc(lmp, (control->tabulate+2) * sizeof(double), "lookup:fCEclmb", comm );
LR = (LR_lookup_table**) LR = (LR_lookup_table**)
scalloc( num_atom_types, sizeof(LR_lookup_table*), "lookup:LR", comm ); scalloc(lmp, num_atom_types, sizeof(LR_lookup_table*), "lookup:LR", comm );
for( i = 0; i < num_atom_types; ++i ) for( i = 0; i < num_atom_types; ++i )
LR[i] = (LR_lookup_table*) LR[i] = (LR_lookup_table*)
scalloc( num_atom_types, sizeof(LR_lookup_table), "lookup:LR[i]", comm ); scalloc(lmp, num_atom_types, sizeof(LR_lookup_table), "lookup:LR[i]", comm );
for( i = 0; i < MAX_ATOM_TYPES; ++i ) for( i = 0; i < MAX_ATOM_TYPES; ++i )
existing_types[i] = 0; existing_types[i] = 0;
@ -207,21 +207,21 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
LR[i][j].dx = dr; LR[i][j].dx = dr;
LR[i][j].inv_dx = control->tabulate / control->nonb_cut; LR[i][j].inv_dx = control->tabulate / control->nonb_cut;
LR[i][j].y = (LR_data*) LR[i][j].y = (LR_data*)
smalloc( LR[i][j].n * sizeof(LR_data), "lookup:LR[i,j].y", comm ); smalloc(lmp, LR[i][j].n * sizeof(LR_data), "lookup:LR[i,j].y", comm );
LR[i][j].H = (cubic_spline_coef*) LR[i][j].H = (cubic_spline_coef*)
smalloc( LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].H" , smalloc(lmp, LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].H" ,
comm ); comm );
LR[i][j].vdW = (cubic_spline_coef*) LR[i][j].vdW = (cubic_spline_coef*)
smalloc( LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].vdW", smalloc(lmp, LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].vdW",
comm); comm);
LR[i][j].CEvd = (cubic_spline_coef*) LR[i][j].CEvd = (cubic_spline_coef*)
smalloc( LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].CEvd", smalloc(lmp, LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].CEvd",
comm); comm);
LR[i][j].ele = (cubic_spline_coef*) LR[i][j].ele = (cubic_spline_coef*)
smalloc( LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].ele", smalloc(lmp, LR[i][j].n*sizeof(cubic_spline_coef),"lookup:LR[i,j].ele",
comm ); comm );
LR[i][j].CEclmb = (cubic_spline_coef*) LR[i][j].CEclmb = (cubic_spline_coef*)
smalloc( LR[i][j].n*sizeof(cubic_spline_coef), smalloc(lmp, LR[i][j].n*sizeof(cubic_spline_coef),
"lookup:LR[i,j].CEclmb", comm ); "lookup:LR[i,j].CEclmb", comm );
for( r = 1; r <= control->tabulate; ++r ) { for( r = 1; r <= control->tabulate; ++r ) {
@ -246,22 +246,22 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
vlast_vdw = fCEvd[r-1]; vlast_vdw = fCEvd[r-1];
vlast_ele = fele[r-1]; vlast_ele = fele[r-1];
Natural_Cubic_Spline( &h[1], &fh[1], Natural_Cubic_Spline( lmp, &h[1], &fh[1],
&(LR[i][j].H[1]), control->tabulate+1, comm ); &(LR[i][j].H[1]), control->tabulate+1, comm );
Complete_Cubic_Spline( &h[1], &fvdw[1], v0_vdw, vlast_vdw, Complete_Cubic_Spline( lmp, &h[1], &fvdw[1], v0_vdw, vlast_vdw,
&(LR[i][j].vdW[1]), control->tabulate+1, &(LR[i][j].vdW[1]), control->tabulate+1,
comm ); comm );
Natural_Cubic_Spline( &h[1], &fCEvd[1], Natural_Cubic_Spline( lmp, &h[1], &fCEvd[1],
&(LR[i][j].CEvd[1]), control->tabulate+1, &(LR[i][j].CEvd[1]), control->tabulate+1,
comm ); comm );
Complete_Cubic_Spline( &h[1], &fele[1], v0_ele, vlast_ele, Complete_Cubic_Spline( lmp, &h[1], &fele[1], v0_ele, vlast_ele,
&(LR[i][j].ele[1]), control->tabulate+1, &(LR[i][j].ele[1]), control->tabulate+1,
comm ); comm );
Natural_Cubic_Spline( &h[1], &fCEclmb[1], Natural_Cubic_Spline( lmp, &h[1], &fCEclmb[1],
&(LR[i][j].CEclmb[1]), control->tabulate+1, &(LR[i][j].CEclmb[1]), control->tabulate+1,
comm ); comm );
} else { } else {
@ -281,7 +281,7 @@ int Init_Lookup_Tables( reax_system *system, control_params *control,
} }
void Deallocate_Lookup_Tables( reax_system *system ) void Deallocate_Lookup_Tables( LAMMPS_NS::LAMMPS* lmp, reax_system *system )
{ {
int i, j; int i, j;
int ntypes; int ntypes;
@ -291,14 +291,14 @@ void Deallocate_Lookup_Tables( reax_system *system )
for( i = 0; i < ntypes; ++i ) { for( i = 0; i < ntypes; ++i ) {
for( j = i; j < ntypes; ++j ) for( j = i; j < ntypes; ++j )
if (LR[i][j].n) { if (LR[i][j].n) {
sfree( LR[i][j].y, "LR[i,j].y" ); sfree(lmp, LR[i][j].y, "LR[i,j].y" );
sfree( LR[i][j].H, "LR[i,j].H" ); sfree(lmp, LR[i][j].H, "LR[i,j].H" );
sfree( LR[i][j].vdW, "LR[i,j].vdW" ); sfree(lmp, LR[i][j].vdW, "LR[i,j].vdW" );
sfree( LR[i][j].CEvd, "LR[i,j].CEvd" ); sfree(lmp, LR[i][j].CEvd, "LR[i,j].CEvd" );
sfree( LR[i][j].ele, "LR[i,j].ele" ); sfree(lmp, LR[i][j].ele, "LR[i,j].ele" );
sfree( LR[i][j].CEclmb, "LR[i,j].CEclmb" ); sfree(lmp, LR[i][j].CEclmb, "LR[i,j].CEclmb" );
} }
sfree( LR[i], "LR[i]" ); sfree(lmp, LR[i], "LR[i]" );
} }
sfree( LR, "LR" ); sfree(lmp, LR, "LR" );
} }

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

@ -32,17 +32,17 @@
void Tridiagonal_Solve( const double *a, const double *b, void Tridiagonal_Solve( const double *a, const double *b,
double *c, double *d, double *x, unsigned int n); double *c, double *d, double *x, unsigned int n);
void Natural_Cubic_Spline( const double *h, const double *f, void Natural_Cubic_Spline( LAMMPS_NS::LAMMPS*, const double *h, const double *f,
cubic_spline_coef *coef, unsigned int n, cubic_spline_coef *coef, unsigned int n,
MPI_Comm comm ); MPI_Comm comm );
void Complete_Cubic_Spline( const double *h, const double *f, double v0, double vlast, void Complete_Cubic_Spline( LAMMPS_NS::LAMMPS*, const double *h, const double *f, double v0, double vlast,
cubic_spline_coef *coef, unsigned int n, cubic_spline_coef *coef, unsigned int n,
MPI_Comm comm ); MPI_Comm comm );
int Init_Lookup_Tables( reax_system*, control_params*, storage*, int Init_Lookup_Tables( LAMMPS_NS::LAMMPS*, reax_system*, control_params*, storage*,
mpi_datatypes*, char* ); mpi_datatypes*, char* );
void Deallocate_Lookup_Tables( reax_system* ); void Deallocate_Lookup_Tables( LAMMPS_NS::LAMMPS*, reax_system* );
#endif #endif

2
src/USER-REAXC/reaxc_multi_body.cpp
View File

@ -32,7 +32,7 @@
void Atom_Energy( reax_system *system, control_params *control, void Atom_Energy( reax_system *system, control_params *control,
simulation_data *data, storage *workspace, reax_list **lists, simulation_data *data, storage *workspace, reax_list **lists,
output_controls * /*out_control*/ ) output_controls * /*out_control*/, LAMMPS_NS::LAMMPS* lmp )
{ {
int i, j, pj, type_i, type_j; int i, j, pj, type_i, type_j;
double Delta_lpcorr, dfvl; double Delta_lpcorr, dfvl;

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

@ -30,6 +30,6 @@
#include "reaxc_types.h" #include "reaxc_types.h"
void Atom_Energy( reax_system*, control_params*, simulation_data*, void Atom_Energy( reax_system*, control_params*, simulation_data*,
storage*, reax_list**, output_controls* ); storage*, reax_list**, output_controls*, LAMMPS_NS::LAMMPS* = NULL );
#endif #endif

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

@ -144,10 +144,10 @@ void Reset_Neighbor_Lists( LAMMPS *lmp, reax_system *system, control_params *con
if (total_bonds >= bonds->num_intrs * DANGER_ZONE) { if (total_bonds >= bonds->num_intrs * DANGER_ZONE) {
workspace->realloc.bonds = 1; workspace->realloc.bonds = 1;
if (total_bonds >= bonds->num_intrs) { if (total_bonds >= bonds->num_intrs) {
fprintf(stderr, char errmsg[256];
"p%d: not enough space for bonds! total=%d allocated=%d\n", snprintf(errmsg, 256, "p%d: not enough space for bonds! total=%d allocated=%d\n",
system->my_rank, total_bonds, bonds->num_intrs); system->my_rank, total_bonds, bonds->num_intrs);
lmp->error->all(FLERR, "Can't allocate space for hbonds."); lmp->error->one(FLERR, errmsg);
} }
} }
} }
@ -170,10 +170,10 @@ void Reset_Neighbor_Lists( LAMMPS *lmp, reax_system *system, control_params *con
if (total_hbonds >= hbonds->num_intrs * 0.90/*DANGER_ZONE*/) { if (total_hbonds >= hbonds->num_intrs * 0.90/*DANGER_ZONE*/) {
workspace->realloc.hbonds = 1; workspace->realloc.hbonds = 1;
if (total_hbonds >= hbonds->num_intrs) { if (total_hbonds >= hbonds->num_intrs) {
fprintf(stderr, char errmsg[256];
"p%d: not enough space for hbonds! total=%d allocated=%d\n", snprintf(errmsg, 256, "p%d: not enough space for hbonds! total=%d allocated=%d\n",
system->my_rank, total_hbonds, hbonds->num_intrs); system->my_rank, total_hbonds, hbonds->num_intrs);
lmp->error->all(FLERR, "Can't allocate space for hbonds."); lmp->error->one(FLERR, errmsg);
} }
} }
} }

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

@ -53,23 +53,25 @@ int Tokenize( char* s, char*** tok )
return count; return count;
} }
/* safe malloc */ /* safe malloc */
void *smalloc( rc_bigint n, const char *name, MPI_Comm comm ) void *smalloc( LAMMPS_NS::LAMMPS *lmp, rc_bigint n, const char *name, MPI_Comm comm )
{ {
void *ptr; void *ptr;
char errmsg[256];
if (n <= 0) { if (n <= 0) {
fprintf( stderr, "WARNING: trying to allocate %ld bytes for array %s. ", snprintf(errmsg, 256, "Trying to allocate %ld bytes for array %s. "
n, name ); "returning NULL.", n, name);
fprintf( stderr, "returning NULL.\n" ); lmp->error->warning(FLERR,errmsg);
return NULL; return NULL;
} }
ptr = malloc( n ); ptr = malloc( n );
if (ptr == NULL) { if (ptr == NULL) {
fprintf( stderr, "ERROR: failed to allocate %ld bytes for array %s", snprintf(errmsg, 256, "Failed to allocate %ld bytes for array %s", n, name);
n, name ); lmp->error->one(FLERR,errmsg);
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
return ptr; return ptr;
@ -77,29 +79,30 @@ void *smalloc( rc_bigint n, const char *name, MPI_Comm comm )
/* safe calloc */ /* safe calloc */
void *scalloc( rc_bigint n, rc_bigint size, const char *name, MPI_Comm comm ) void *scalloc( LAMMPS_NS::LAMMPS *lmp, rc_bigint n, rc_bigint size, const char *name, MPI_Comm comm )
{ {
void *ptr; void *ptr;
char errmsg[256];
if (n <= 0) { if (n <= 0) {
fprintf( stderr, "WARNING: trying to allocate %ld elements for array %s. ", snprintf(errmsg, 256, "Trying to allocate %ld elements for array %s. "
n, name ); "returning NULL.\n", n, name );
fprintf( stderr, "returning NULL.\n" ); lmp->error->warning(FLERR,errmsg);
return NULL; return NULL;
} }
if (size <= 0) { if (size <= 0) {
fprintf( stderr, "WARNING: elements size for array %s is %ld. ", snprintf(errmsg, 256, "Elements size for array %s is %ld. "
name, size ); "returning NULL", name, size );
fprintf( stderr, "returning NULL.\n" ); lmp->error->warning(FLERR,errmsg);
return NULL; return NULL;
} }
ptr = calloc( n, size ); ptr = calloc( n, size );
if (ptr == NULL) { if (ptr == NULL) {
fprintf( stderr, "ERROR: failed to allocate %ld bytes for array %s", char errmsg[256];
n*size, name ); snprintf(errmsg, 256, "Failed to allocate %ld bytes for array %s", n*size, name);
MPI_Abort( comm, INSUFFICIENT_MEMORY ); lmp->error->one(FLERR,errmsg);
} }
return ptr; return ptr;
@ -107,11 +110,12 @@ void *scalloc( rc_bigint n, rc_bigint size, const char *name, MPI_Comm comm )
/* safe free */ /* safe free */
void sfree( void *ptr, const char *name ) void sfree( LAMMPS_NS::LAMMPS* lmp, void *ptr, const char *name )
{ {
if (ptr == NULL) { if (ptr == NULL) {
fprintf( stderr, "WARNING: trying to free the already NULL pointer %s!\n", char errmsg[256];
name ); snprintf(errmsg, 256, "Trying to free the already NULL pointer %s", name );
lmp->error->one(FLERR,errmsg);
return; return;
} }

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

@ -37,7 +37,7 @@ double Get_Time( );
int Tokenize( char*, char*** ); int Tokenize( char*, char*** );
/* from lammps */ /* from lammps */
void *smalloc( rc_bigint, const char*, MPI_Comm ); void *smalloc( LAMMPS_NS::LAMMPS*, rc_bigint, const char*, MPI_Comm );
void *scalloc( rc_bigint, rc_bigint, const char*, MPI_Comm ); void *scalloc( LAMMPS_NS::LAMMPS*, rc_bigint, rc_bigint, const char*, MPI_Comm );
void sfree( void*, const char* ); void sfree( LAMMPS_NS::LAMMPS*, void*, const char* );
#endif #endif

3
src/USER-REAXC/reaxc_torsion_angles.cpp
View File

@ -120,7 +120,8 @@ double Calculate_Omega( rvec dvec_ij, double r_ij,
void Torsion_Angles( reax_system *system, control_params *control, void Torsion_Angles( reax_system *system, control_params *control,
simulation_data *data, storage *workspace, simulation_data *data, storage *workspace,
reax_list **lists, output_controls *out_control ) reax_list **lists, output_controls *out_control,
LAMMPS_NS::LAMMPS* lmp )
{ {
int i, j, k, l, pi, pj, pk, pl, pij, plk, natoms; int i, j, k, l, pi, pj, pk, pl, pij, plk, natoms;
int type_i, type_j, type_k, type_l; int type_i, type_j, type_k, type_l;

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

@ -30,6 +30,7 @@
#include "reaxc_types.h" #include "reaxc_types.h"
void Torsion_Angles( reax_system*, control_params*, simulation_data*, void Torsion_Angles( reax_system*, control_params*, simulation_data*,
storage*, reax_list**, output_controls* ); storage*, reax_list**, output_controls*,
LAMMPS_NS::LAMMPS* = NULL );
#endif #endif

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

@ -29,7 +29,7 @@
#include "reaxc_list.h" #include "reaxc_list.h"
#include "reaxc_tool_box.h" #include "reaxc_tool_box.h"
int Reallocate_Output_Buffer( output_controls *out_control, int req_space, int Reallocate_Output_Buffer( LAMMPS_NS::LAMMPS *lmp, output_controls *out_control, int req_space,
MPI_Comm comm ) MPI_Comm comm )
{ {
if (out_control->buffer_len > 0) if (out_control->buffer_len > 0)
@ -38,10 +38,9 @@ int Reallocate_Output_Buffer( output_controls *out_control, int req_space,
out_control->buffer_len = (int)(req_space*SAFE_ZONE); out_control->buffer_len = (int)(req_space*SAFE_ZONE);
out_control->buffer = (char*) malloc(out_control->buffer_len*sizeof(char)); out_control->buffer = (char*) malloc(out_control->buffer_len*sizeof(char));
if (out_control->buffer == NULL) { if (out_control->buffer == NULL) {
fprintf( stderr, char errmsg[256];
"insufficient memory for required buffer size %d. terminating!\n", snprintf(errmsg, 256, "Insufficient memory for required buffer size %d", (int) (req_space*SAFE_ZONE));
(int) (req_space*SAFE_ZONE) ); lmp->error->one(FLERR,errmsg);
MPI_Abort( comm, INSUFFICIENT_MEMORY );
} }
return SUCCESS; return SUCCESS;
@ -57,7 +56,7 @@ void Write_Skip_Line( output_controls *out_control, mpi_datatypes * /*mpi_data*/
} }
int Write_Header( reax_system *system, control_params *control, int Write_Header( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
output_controls *out_control, mpi_datatypes *mpi_data ) output_controls *out_control, mpi_datatypes *mpi_data )
{ {
int num_hdr_lines, my_hdr_lines, buffer_req; int num_hdr_lines, my_hdr_lines, buffer_req;
@ -83,7 +82,7 @@ int Write_Header( reax_system *system, control_params *control,
my_hdr_lines = num_hdr_lines * ( system->my_rank == MASTER_NODE ); my_hdr_lines = num_hdr_lines * ( system->my_rank == MASTER_NODE );
buffer_req = my_hdr_lines * HEADER_LINE_LEN; buffer_req = my_hdr_lines * HEADER_LINE_LEN;
if (buffer_req > out_control->buffer_len * DANGER_ZONE) if (buffer_req > out_control->buffer_len * DANGER_ZONE)
Reallocate_Output_Buffer( out_control, buffer_req, mpi_data->world ); Reallocate_Output_Buffer( lmp, out_control, buffer_req, mpi_data->world );
/* only the master node writes into trajectory header */ /* only the master node writes into trajectory header */
if (system->my_rank == MASTER_NODE) { if (system->my_rank == MASTER_NODE) {
@ -259,7 +258,7 @@ int Write_Header( reax_system *system, control_params *control,
} }
int Write_Init_Desc( reax_system *system, control_params * /*control*/, int Write_Init_Desc( LAMMPS_NS::LAMMPS *lmp, reax_system *system, control_params * /*control*/,
output_controls *out_control, mpi_datatypes *mpi_data ) output_controls *out_control, mpi_datatypes *mpi_data )
{ {
int i, me, np, cnt, buffer_len, buffer_req; int i, me, np, cnt, buffer_len, buffer_req;
@ -278,7 +277,7 @@ int Write_Init_Desc( reax_system *system, control_params * /*control*/,
else buffer_req = system->n * INIT_DESC_LEN + 1; else buffer_req = system->n * INIT_DESC_LEN + 1;
if (buffer_req > out_control->buffer_len * DANGER_ZONE) if (buffer_req > out_control->buffer_len * DANGER_ZONE)
Reallocate_Output_Buffer( out_control, buffer_req, mpi_data->world ); Reallocate_Output_Buffer( lmp, out_control, buffer_req, mpi_data->world );
out_control->line[0] = 0; out_control->line[0] = 0;
out_control->buffer[0] = 0; out_control->buffer[0] = 0;
@ -311,7 +310,7 @@ int Write_Init_Desc( reax_system *system, control_params * /*control*/,
} }
int Init_Traj( reax_system *system, control_params *control, int Init_Traj( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
output_controls *out_control, mpi_datatypes *mpi_data, output_controls *out_control, mpi_datatypes *mpi_data,
char *msg ) char *msg )
{ {
@ -348,14 +347,14 @@ int Init_Traj( reax_system *system, control_params *control,
strcpy( msg, "init_traj: unknown trajectory option" ); strcpy( msg, "init_traj: unknown trajectory option" );
return FAILURE; return FAILURE;
} }
Write_Header( system, control, out_control, mpi_data ); Write_Header( lmp, system, control, out_control, mpi_data );
Write_Init_Desc( system, control, out_control, mpi_data ); Write_Init_Desc( lmp, system, control, out_control, mpi_data );
return SUCCESS; return SUCCESS;
} }
int Write_Frame_Header( reax_system *system, control_params *control, int Write_Frame_Header( LAMMPS_NS::LAMMPS *lmp, reax_system *system, control_params *control,
simulation_data *data, output_controls *out_control, simulation_data *data, output_controls *out_control,
mpi_datatypes *mpi_data ) mpi_datatypes *mpi_data )
{ {
@ -367,7 +366,7 @@ int Write_Frame_Header( reax_system *system, control_params *control,
my_frm_hdr_lines = num_frm_hdr_lines * ( me == MASTER_NODE ); my_frm_hdr_lines = num_frm_hdr_lines * ( me == MASTER_NODE );
buffer_req = my_frm_hdr_lines * HEADER_LINE_LEN; buffer_req = my_frm_hdr_lines * HEADER_LINE_LEN;
if (buffer_req > out_control->buffer_len * DANGER_ZONE) if (buffer_req > out_control->buffer_len * DANGER_ZONE)
Reallocate_Output_Buffer( out_control, buffer_req, mpi_data->world ); Reallocate_Output_Buffer( lmp, out_control, buffer_req, mpi_data->world );
/* only the master node writes into trajectory header */ /* only the master node writes into trajectory header */
if (me == MASTER_NODE) { if (me == MASTER_NODE) {
@ -481,7 +480,7 @@ int Write_Frame_Header( reax_system *system, control_params *control,
int Write_Atoms( reax_system *system, control_params * /*control*/, int Write_Atoms( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params * /*control*/,
output_controls *out_control, mpi_datatypes *mpi_data ) output_controls *out_control, mpi_datatypes *mpi_data )
{ {
int i, me, np, line_len, buffer_len, buffer_req, cnt; int i, me, np, line_len, buffer_len, buffer_req, cnt;
@ -500,7 +499,7 @@ int Write_Atoms( reax_system *system, control_params * /*control*/,
else buffer_req = system->n * line_len + 1; else buffer_req = system->n * line_len + 1;
if (buffer_req > out_control->buffer_len * DANGER_ZONE) if (buffer_req > out_control->buffer_len * DANGER_ZONE)
Reallocate_Output_Buffer( out_control, buffer_req, mpi_data->world ); Reallocate_Output_Buffer( lmp, out_control, buffer_req, mpi_data->world );
/* fill in buffer */ /* fill in buffer */
out_control->line[0] = 0; out_control->line[0] = 0;
@ -531,9 +530,7 @@ int Write_Atoms( reax_system *system, control_params * /*control*/,
p_atom->f[0], p_atom->f[1], p_atom->f[2], p_atom->q ); p_atom->f[0], p_atom->f[1], p_atom->f[2], p_atom->q );
break; break;
default: default:
fprintf( stderr, lmp->error->all(FLERR,"Write_traj_atoms: unknown atom trajectory format");
"write_traj_atoms: unknown atom trajectroy format!\n");
MPI_Abort( mpi_data->world, UNKNOWN_OPTION );
} }
strncpy( out_control->buffer + i*line_len, out_control->line, line_len+1 ); strncpy( out_control->buffer + i*line_len, out_control->line, line_len+1 );
@ -559,7 +556,7 @@ int Write_Atoms( reax_system *system, control_params * /*control*/,
} }
int Write_Bonds(reax_system *system, control_params *control, reax_list *bonds, int Write_Bonds( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control, reax_list *bonds,
output_controls *out_control, mpi_datatypes *mpi_data) output_controls *out_control, mpi_datatypes *mpi_data)
{ {
int i, j, pj, me, np; int i, j, pj, me, np;
@ -592,7 +589,7 @@ int Write_Bonds(reax_system *system, control_params *control, reax_list *bonds,
else buffer_req = my_bonds * line_len + 1; else buffer_req = my_bonds * line_len + 1;
if (buffer_req > out_control->buffer_len * DANGER_ZONE) if (buffer_req > out_control->buffer_len * DANGER_ZONE)
Reallocate_Output_Buffer( out_control, buffer_req, mpi_data->world ); Reallocate_Output_Buffer( lmp, out_control, buffer_req, mpi_data->world );
/* fill in the buffer */ /* fill in the buffer */
out_control->line[0] = 0; out_control->line[0] = 0;
@ -619,8 +616,7 @@ int Write_Bonds(reax_system *system, control_params *control, reax_list *bonds,
bo_ij->bo_data.BO_pi, bo_ij->bo_data.BO_pi2 ); bo_ij->bo_data.BO_pi, bo_ij->bo_data.BO_pi2 );
break; break;
default: default:
fprintf(stderr, "write_traj_bonds: FATAL! invalid bond_info option"); lmp->error->all(FLERR, "Write_traj_bonds: FATAL! invalid bond_info option");
MPI_Abort( mpi_data->world, UNKNOWN_OPTION );
} }
strncpy( out_control->buffer + my_bonds*line_len, strncpy( out_control->buffer + my_bonds*line_len,
out_control->line, line_len+1 ); out_control->line, line_len+1 );
@ -649,7 +645,7 @@ int Write_Bonds(reax_system *system, control_params *control, reax_list *bonds,
} }
int Write_Angles( reax_system *system, control_params *control, int Write_Angles( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
reax_list *bonds, reax_list *thb_intrs, reax_list *bonds, reax_list *thb_intrs,
output_controls *out_control, mpi_datatypes *mpi_data ) output_controls *out_control, mpi_datatypes *mpi_data )
{ {
@ -693,7 +689,7 @@ int Write_Angles( reax_system *system, control_params *control,
else buffer_req = my_angles * line_len + 1; else buffer_req = my_angles * line_len + 1;
if (buffer_req > out_control->buffer_len * DANGER_ZONE) if (buffer_req > out_control->buffer_len * DANGER_ZONE)
Reallocate_Output_Buffer( out_control, buffer_req, mpi_data->world ); Reallocate_Output_Buffer( lmp, out_control, buffer_req, mpi_data->world );
/* fill in the buffer */ /* fill in the buffer */
my_angles = 0; my_angles = 0;
@ -744,20 +740,20 @@ int Write_Angles( reax_system *system, control_params *control,
} }
int Append_Frame( reax_system *system, control_params *control, int Append_Frame( LAMMPS_NS::LAMMPS* lmp, reax_system *system, control_params *control,
simulation_data *data, reax_list **lists, simulation_data *data, reax_list **lists,
output_controls *out_control, mpi_datatypes *mpi_data ) output_controls *out_control, mpi_datatypes *mpi_data )
{ {
Write_Frame_Header( system, control, data, out_control, mpi_data ); Write_Frame_Header( lmp, system, control, data, out_control, mpi_data );
if (out_control->write_atoms) if (out_control->write_atoms)
Write_Atoms( system, control, out_control, mpi_data ); Write_Atoms( lmp, system, control, out_control, mpi_data );
if (out_control->write_bonds) if (out_control->write_bonds)
Write_Bonds( system, control, (*lists + BONDS), out_control, mpi_data ); Write_Bonds( lmp, system, control, (*lists + BONDS), out_control, mpi_data );
if (out_control->write_angles) if (out_control->write_angles)
Write_Angles( system, control, (*lists + BONDS), (*lists + THREE_BODIES), Write_Angles( lmp, system, control, (*lists + BONDS), (*lists + THREE_BODIES),
out_control, mpi_data ); out_control, mpi_data );
return SUCCESS; return SUCCESS;

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

@ -73,11 +73,11 @@ enum BOND_LINE_OPTS { OPT_NOBOND, OPT_BOND_BASIC, OPT_BOND_FULL, NR_OPT_BOND };
enum ANGLE_LINE_OPTS { OPT_NOANGLE, OPT_ANGLE_BASIC, NR_OPT_ANGLE }; enum ANGLE_LINE_OPTS { OPT_NOANGLE, OPT_ANGLE_BASIC, NR_OPT_ANGLE };
int Init_Traj( reax_system*, control_params*, output_controls*, int Init_Traj( LAMMPS_NS::LAMMPS*, reax_system*, control_params*, output_controls*,
mpi_datatypes*, char* ); mpi_datatypes*, char* );
int End_Traj( int, output_controls* ); int End_Traj( int, output_controls* );
int Append_Frame( reax_system*, control_params*, simulation_data*, int Append_Frame( LAMMPS_NS::LAMMPS*, reax_system*, control_params*, simulation_data*,
reax_list**, output_controls*, mpi_datatypes* ); reax_list**, output_controls*, mpi_datatypes* );
#endif #endif

5
src/USER-REAXC/reaxc_types.h
View File

@ -39,6 +39,9 @@
#include <sys/time.h> #include <sys/time.h>
#include "accelerator_kokkos.h" #include "accelerator_kokkos.h"
#include "lammps.h"
#include "error.h"
#if defined LMP_USER_OMP #if defined LMP_USER_OMP
#define OMP_TIMING 0 #define OMP_TIMING 0
@ -901,7 +904,7 @@ typedef void (*evolve_function)(reax_system*, control_params*,
typedef void (*interaction_function) ( reax_system*, control_params*, typedef void (*interaction_function) ( reax_system*, control_params*,
simulation_data*, storage*, simulation_data*, storage*,
reax_list**, output_controls*); reax_list**, output_controls*, LAMMPS_NS::LAMMPS*);
typedef void (*print_interaction)(reax_system*, control_params*, typedef void (*print_interaction)(reax_system*, control_params*,
simulation_data*, storage*, simulation_data*, storage*,

7
src/USER-REAXC/reaxc_valence_angles.cpp
View File

@ -76,7 +76,7 @@ void Calculate_dCos_Theta( rvec dvec_ji, double d_ji, rvec dvec_jk, double d_jk,
void Valence_Angles( reax_system *system, control_params *control, void Valence_Angles( reax_system *system, control_params *control,
simulation_data *data, storage *workspace, simulation_data *data, storage *workspace,
reax_list **lists, output_controls * /*out_control*/ ) reax_list **lists, output_controls * /*out_control*/, LAMMPS_NS::LAMMPS* lmp)
{ {
int i, j, pi, k, pk, t; int i, j, pi, k, pk, t;
int type_i, type_j, type_k; int type_i, type_j, type_k;
@ -405,9 +405,10 @@ void Valence_Angles( reax_system *system, control_params *control,
if (num_thb_intrs >= thb_intrs->num_intrs * DANGER_ZONE) { if (num_thb_intrs >= thb_intrs->num_intrs * DANGER_ZONE) {
workspace->realloc.num_3body = num_thb_intrs; workspace->realloc.num_3body = num_thb_intrs;
if (num_thb_intrs > thb_intrs->num_intrs) { if (num_thb_intrs > thb_intrs->num_intrs) {
fprintf( stderr, "step%d-ran out of space on angle_list: top=%d, max=%d", char errmsg[128];
snprintf(errmsg, 128, "step%d-ran out of space on angle_list: top=%d, max=%d",
data->step, num_thb_intrs, thb_intrs->num_intrs); data->step, num_thb_intrs, thb_intrs->num_intrs);
MPI_Abort( MPI_COMM_WORLD, INSUFFICIENT_MEMORY ); lmp->error->one(FLERR, errmsg);
} }
} }

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

@ -30,7 +30,7 @@
#include "reaxc_types.h" #include "reaxc_types.h"
void Valence_Angles( reax_system*, control_params*, simulation_data*, void Valence_Angles( reax_system*, control_params*, simulation_data*,
storage*, reax_list**, output_controls* ); storage*, reax_list**, output_controls*, LAMMPS_NS::LAMMPS* = NULL);
void Calculate_Theta( rvec, double, rvec, double, double*, double* ); void Calculate_Theta( rvec, double, rvec, double, double*, double* );