Homec4science
Diffusion lammps (lammm-master-deprecated) Browse

lammps/src/USER-REAXC/reaxc_reset_tools.cpp
1ba04dabf6c9lammm-master-deprecated

Last Change
Raw File

reaxc_reset_tools.cpp
View Options

/*----------------------------------------------------------------------
PuReMD - Purdue ReaxFF Molecular Dynamics Program
Copyright (2010) Purdue University
Hasan Metin Aktulga, hmaktulga@lbl.gov
Joseph Fogarty, jcfogart@mail.usf.edu
Sagar Pandit, pandit@usf.edu
Ananth Y Grama, ayg@cs.purdue.edu
Please cite the related publication:
H. M. Aktulga, J. C. Fogarty, S. A. Pandit, A. Y. Grama,
"Parallel Reactive Molecular Dynamics: Numerical Methods and
Algorithmic Techniques", Parallel Computing, in press.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details:
<http://www.gnu.org/licenses/>.
----------------------------------------------------------------------*/
#include "pair_reax_c.h"
#if defined(PURE_REAX)
#include "reset_tools.h"
#include "list.h"
#include "tool_box.h"
#include "vector.h"
#elif defined(LAMMPS_REAX)
#include "reaxc_reset_tools.h"
#include "reaxc_list.h"
#include "reaxc_tool_box.h"
#include "reaxc_vector.h"
#endif
void Reset_Atoms( reax_system* system, control_params *control )
{
int i;
reax_atom *atom;
system->numH = 0;
if( control->hbond_cut > 0 )
for( i = 0; i < system->n; ++i ) {
atom = &(system->my_atoms[i]);
if( system->reax_param.sbp[ atom->type ].p_hbond == 1 )
atom->Hindex = system->numH++;
else atom->Hindex = -1;
}
}
void Reset_Energies( energy_data *en )
{
en->e_bond = 0;
en->e_ov = 0;
en->e_un = 0;
en->e_lp = 0;
en->e_ang = 0;
en->e_pen = 0;
en->e_coa = 0;
en->e_hb = 0;
en->e_tor = 0;
en->e_con = 0;
en->e_vdW = 0;
en->e_ele = 0;
en->e_pol = 0;
en->e_pot = 0;
en->e_kin = 0;
en->e_tot = 0;
}
void Reset_Temperatures( simulation_data *data )
{
data->therm.T = 0;
}
void Reset_Pressures( simulation_data *data )
{
data->flex_bar.P_scalar = 0;
rtensor_MakeZero( data->flex_bar.P );
data->iso_bar.P = 0;
rvec_MakeZero( data->int_press );
rvec_MakeZero( data->my_ext_press );
rvec_MakeZero( data->ext_press );
}
void Reset_Simulation_Data( simulation_data* data, int virial )
{
Reset_Energies( &data->my_en );
Reset_Energies( &data->sys_en );
Reset_Temperatures( data );
//if( virial )
Reset_Pressures( data );
}
void Reset_Timing( reax_timing *rt )
{
rt->total = Get_Time();
rt->comm = 0;
rt->nbrs = 0;
rt->init_forces = 0;
rt->bonded = 0;
rt->nonb = 0;
rt->qEq = 0;
rt->s_matvecs = 0;
rt->t_matvecs = 0;
}
#ifdef TEST_FORCES
void Reset_Test_Forces( reax_system *system, storage *workspace )
{
memset( workspace->f_ele, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_vdw, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_bo, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_be, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_lp, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_ov, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_un, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_ang, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_coa, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_pen, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_hb, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_tor, 0, system->total_cap * sizeof(rvec) );
memset( workspace->f_con, 0, system->total_cap * sizeof(rvec) );
}
#endif
void Reset_Workspace( reax_system *system, storage *workspace )
{
memset( workspace->total_bond_order, 0, system->total_cap * sizeof( real ) );
memset( workspace->dDeltap_self, 0, system->total_cap * sizeof( rvec ) );
memset( workspace->CdDelta, 0, system->total_cap * sizeof( real ) );
memset( workspace->f, 0, system->total_cap * sizeof( rvec ) );
#ifdef TEST_FORCES
memset( workspace->dDelta, 0, sizeof(rvec) * system->total_cap );
Reset_Test_Forces( system, workspace );
#endif
}
void Reset_Grid( grid *g )
{
int i, j, k;
for( i = 0; i < g->ncells[0]; i++ )
for( j = 0; j < g->ncells[1]; j++ )
for( k = 0; k < g->ncells[2]; k++ ) {
g->cells[i][j][k].top = 0;
g->cells[i][j][k].str = 0;
g->cells[i][j][k].end = 0;
}
}
void Reset_Out_Buffers( mpi_out_data *out_buf, int n )
{
int i;
for( i = 0; i < n; ++i )
out_buf[i].cnt = 0;
}
void Reset_Neighbor_Lists( reax_system *system, control_params *control,
storage *workspace, reax_list **lists,
MPI_Comm comm )
{
int i, total_bonds, Hindex, total_hbonds;
reax_list *bonds, *hbonds;
/* bonds list */
if( system->N > 0 ){
bonds = (*lists) + BONDS;
total_bonds = 0;
/* reset start-end indexes */
for( i = 0; i < system->N; ++i ) {
Set_Start_Index( i, total_bonds, bonds );
Set_End_Index( i, total_bonds, bonds );
total_bonds += system->my_atoms[i].num_bonds;
}
/* is reallocation needed? */
if( total_bonds >= bonds->num_intrs * DANGER_ZONE ) {
workspace->realloc.bonds = 1;
if( total_bonds >= bonds->num_intrs ) {
fprintf(stderr,
"p%d: not enough space for bonds! total=%d allocated=%d\n",
system->my_rank, total_bonds, bonds->num_intrs );
MPI_Abort( comm, INSUFFICIENT_MEMORY );
}
}
}
// fprintf( stderr, "p%d: n:%d num_intrs:%d num_H:%d\n",
// system->my_rank, hbonds->n, hbonds->num_intrs, workspace->num_H );
// MPI_Barrier( comm );
/* hbonds list */
if( control->hbond_cut > 0 && system->numH > 0 ) {
hbonds = (*lists) + HBONDS;
total_hbonds = 0;
/* reset start-end indexes */
for( i = 0; i < system->n; ++i ) {
Hindex = system->my_atoms[i].Hindex;
if( Hindex > -1 ) {
Set_Start_Index( Hindex, total_hbonds, hbonds );
Set_End_Index( Hindex, total_hbonds, hbonds );
total_hbonds += system->my_atoms[i].num_hbonds;
}
}
/* is reallocation needed? */
if( total_hbonds >= hbonds->num_intrs * 0.90/*DANGER_ZONE*/ ) {
workspace->realloc.hbonds = 1;
if( total_hbonds >= hbonds->num_intrs ) {
fprintf(stderr,
"p%d: not enough space for hbonds! total=%d allocated=%d\n",
system->my_rank, total_hbonds, hbonds->num_intrs );
MPI_Abort( comm, INSUFFICIENT_MEMORY );
}
}
}
// fprintf( stderr, "p%d: cleared hbonds\n", system->my_rank );
// MPI_Barrier( comm );
}
void Reset( reax_system *system, control_params *control, simulation_data *data,
storage *workspace, reax_list **lists, MPI_Comm comm )
{
Reset_Atoms( system, control );
Reset_Simulation_Data( data, control->virial );
Reset_Workspace( system, workspace );
Reset_Neighbor_Lists( system, control, workspace, lists, comm );
#if defined(DEBUG_FOCUS)
fprintf( stderr, "p%d @ step%d: reset done\n", system->my_rank, data->step );
MPI_Barrier( comm );
#endif
}
c4science · Help