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

Merge remote-tracking branch 'lammps-ro/master' into lammps-icms

Browse Source 
Resolved Conflicts:
	doc/Manual.html
	doc/Manual.txt
	src/MISC/fix_efield.cpp
	src/fix_addforce.cpp
	src/fix_move.cpp
	src/fix_setforce.cpp
This commit is contained in:
Axel Kohlmeyer
2014-05-08 08:49:17 -04:00
parent fc62bdc5cb cf0cd2e912
commit 4acacd8e3b
61 changed files with 224 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
doc/Manual.html
View File

@ -1,7 +1,7 @@
<HTML> <HTML>
<HEAD> <HEAD>
<TITLE>LAMMPS-ICMS Users Manual</TITLE> <TITLE>LAMMPS-ICMS Users Manual</TITLE>
<META NAME="docnumber" CONTENT="8 May 2014 version"> <META NAME="docnumber" CONTENT="9 May 2014 version">
<META NAME="author" CONTENT="http://lammps.sandia.gov - Sandia National Laboratories"> <META NAME="author" CONTENT="http://lammps.sandia.gov - Sandia National Laboratories">
<META NAME="copyright" CONTENT="Copyright (2003) Sandia Corporation. This software and manual is distributed under the GNU General Public License."> <META NAME="copyright" CONTENT="Copyright (2003) Sandia Corporation. This software and manual is distributed under the GNU General Public License.">
</HEAD> </HEAD>
@ -22,7 +22,7 @@
<CENTER><H3>LAMMPS-ICMS Documentation <CENTER><H3>LAMMPS-ICMS Documentation
</H3></CENTER> </H3></CENTER>
<CENTER><H4>8 May 2014 version <CENTER><H4>9 May 2014 version
</H4></CENTER> </H4></CENTER>
<H4>Version info: <H4>Version info:
</H4> </H4>

4
doc/Manual.txt
View File

@ -1,6 +1,6 @@
<HEAD> <HEAD>
<TITLE>LAMMPS-ICMS Users Manual</TITLE> <TITLE>LAMMPS-ICMS Users Manual</TITLE>
<META NAME="docnumber" CONTENT="8 May 2014 version"> <META NAME="docnumber" CONTENT="9 May 2014 version">
<META NAME="author" CONTENT="http://lammps.sandia.gov - Sandia National Laboratories"> <META NAME="author" CONTENT="http://lammps.sandia.gov - Sandia National Laboratories">
<META NAME="copyright" CONTENT="Copyright (2003) Sandia Corporation. This software and manual is distributed under the GNU General Public License."> <META NAME="copyright" CONTENT="Copyright (2003) Sandia Corporation. This software and manual is distributed under the GNU General Public License.">
</HEAD> </HEAD>
@ -18,7 +18,7 @@
<H1></H1> <H1></H1>
LAMMPS-ICMS Documentation :c,h3 LAMMPS-ICMS Documentation :c,h3
8 May 2014 version :c,h4 9 May 2014 version :c,h4
Version info: :h4 Version info: :h4

19
examples/VISCOSITY/in.gk.2d
View File

@ -49,17 +49,28 @@ unfix 2
reset_timestep 0 reset_timestep 0
# Define distinct components of symmetric traceless stress tensor
variable pxy equal pxy variable pxy equal pxy
variable pxx equal pxx-press
fix SS all ave/correlate $s $p $d & fix SS all ave/correlate $s $p $d &
v_pxy type auto file profile.gk.2d ave running v_pxy v_pxx type auto file profile.gk.2d ave running
# Diagonal components of SS are larger by factor 2-2/d,
# which is 4/3 for d=3, but 1 for d=2.
# See Daivis and Evans, J.Chem.Phys, 100, 541-547 (1994)
variable scale equal 1.0/$t*vol*$s*dt variable scale equal 1.0/$t*vol*$s*dt
variable v11 equal trap(f_SS[3])*${scale} variable diagfac equal 2-2/2
variable vxy equal trap(f_SS[3])*${scale}
variable vxx equal trap(f_SS[4])*${scale}/${diagfac}
thermo_style custom step temp press pxy v_v11 thermo_style custom step temp press pxy v_vxy v_vxx
run 500000 run 500000
variable eta equal v_v11 variable etaxy equal v_vxy
variable etaxx equal v_vxx
variable eta equal 0.5*(${etaxy}+${etaxx})
print "running average viscosity: ${eta}" print "running average viscosity: ${eta}"

7
src/ASPHERE/compute_temp_asphere.cpp
View File

@ -25,7 +25,6 @@
#include "force.h" #include "force.h"
#include "domain.h" #include "domain.h"
#include "modify.h" #include "modify.h"
#include "fix.h"
#include "group.h" #include "group.h"
#include "memory.h" #include "memory.h"
#include "error.h" #include "error.h"
@ -128,9 +127,7 @@ void ComputeTempAsphere::init()
void ComputeTempAsphere::setup() void ComputeTempAsphere::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -138,6 +135,8 @@ void ComputeTempAsphere::setup()
void ComputeTempAsphere::dof_compute() void ComputeTempAsphere::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
// 6 dof for 3d, 3 dof for 2d // 6 dof for 3d, 3 dof for 2d
// which dof are included also depends on mode // which dof are included also depends on mode
// assume full rotation of extended particles // assume full rotation of extended particles

2
src/ASPHERE/compute_temp_asphere.h
View File

@ -39,7 +39,7 @@ class ComputeTempAsphere : public Compute {
void restore_bias_thr(int, double *, double *); void restore_bias_thr(int, double *, double *);
private: private:
int fix_dof,mode; int mode;
double tfactor; double tfactor;
char *id_bias; char *id_bias;
class Compute *tbias; // ptr to additional bias compute class Compute *tbias; // ptr to additional bias compute

6
src/DIPOLE/atom_vec_dipole.cpp
View File

@ -24,8 +24,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecDipole::AtomVecDipole(LAMMPS *lmp) : AtomVec(lmp) AtomVecDipole::AtomVecDipole(LAMMPS *lmp) : AtomVec(lmp)
@ -48,13 +46,13 @@ AtomVecDipole::AtomVecDipole(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecDipole::grow(int n) void AtomVecDipole::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

28
src/MISC/fix_efield.cpp
View File

@ -114,8 +114,8 @@ FixEfield::FixEfield(LAMMPS *lmp, int narg, char **arg) :
force_flag = 0; force_flag = 0;
fsum[0] = fsum[1] = fsum[2] = fsum[3] = 0.0; fsum[0] = fsum[1] = fsum[2] = fsum[3] = 0.0;
maxatom = -1; maxatom = atom->nmax;
efield = NULL; memory->create(efield,maxatom,4,"efield:efield");
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -332,24 +332,16 @@ void FixEfield::post_force(int vflag)
modify->clearstep_compute(); modify->clearstep_compute();
if (xstyle == EQUAL) ex = qe2f * input->variable->compute_equal(xvar); if (xstyle == EQUAL) ex = qe2f * input->variable->compute_equal(xvar);
else if (xstyle == ATOM) { else if (xstyle == ATOM)
if (efield) input->variable->compute_atom(xvar,igroup,&efield[0][0],3,0); input->variable->compute_atom(xvar,igroup,&efield[0][0],3,0);
else input->variable->compute_atom(xvar,igroup,NULL,3,0);
}
if (ystyle == EQUAL) ey = qe2f * input->variable->compute_equal(yvar); if (ystyle == EQUAL) ey = qe2f * input->variable->compute_equal(yvar);
else if (ystyle == ATOM) { else if (ystyle == ATOM)
if (efield) input->variable->compute_atom(yvar,igroup,&efield[0][1],3,0); input->variable->compute_atom(yvar,igroup,&efield[0][1],3,0);
else input->variable->compute_atom(yvar,igroup,NULL,3,0);
}
if (zstyle == EQUAL) ez = qe2f * input->variable->compute_equal(zvar); if (zstyle == EQUAL) ez = qe2f * input->variable->compute_equal(zvar);
else if (zstyle == ATOM) { else if (zstyle == ATOM)
if (efield) input->variable->compute_atom(zvar,igroup,&efield[0][2],3,0); input->variable->compute_atom(zvar,igroup,&efield[0][2],3,0);
else input->variable->compute_atom(zvar,igroup,NULL,3,0); if (estyle == ATOM)
} input->variable->compute_atom(evar,igroup,&efield[0][3],4,0);
if (estyle == ATOM) {
if (efield) input->variable->compute_atom(evar,igroup,&efield[0][3],4,0);
else input->variable->compute_atom(evar,igroup,NULL,4,0);
}
modify->addstep_compute(update->ntimestep + 1); modify->addstep_compute(update->ntimestep + 1);

6
src/MOLECULE/atom_vec_angle.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp) AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp)
@ -47,13 +45,13 @@ AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecAngle::grow(int n) void AtomVecAngle::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

6
src/MOLECULE/atom_vec_bond.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp) AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp)
@ -47,13 +45,13 @@ AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecBond::grow(int n) void AtomVecBond::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

6
src/MOLECULE/atom_vec_full.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp) AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp)
@ -47,13 +45,13 @@ AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecFull::grow(int n) void AtomVecFull::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

6
src/MOLECULE/atom_vec_molecular.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp) AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp)
@ -47,13 +45,13 @@ AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecMolecular::grow(int n) void AtomVecMolecular::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

6
src/MOLECULE/atom_vec_template.cpp
View File

@ -25,8 +25,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp) AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp)
@ -90,13 +88,13 @@ void AtomVecTemplate::process_args(int narg, char **arg)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecTemplate::grow(int n) void AtomVecTemplate::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

6
src/PERI/atom_vec_peri.cpp
View File

@ -29,8 +29,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
static const char cite_peri_package[] = static const char cite_peri_package[] =
"PERI package for Peridynamics:\n\n" "PERI package for Peridynamics:\n\n"
"@Article{Parks08,\n" "@Article{Parks08,\n"
@ -66,13 +64,13 @@ AtomVecPeri::AtomVecPeri(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecPeri::grow(int n) void AtomVecPeri::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

6
src/USER-AWPMD/atom_vec_wavepacket.cpp
View File

@ -29,8 +29,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecWavepacket::AtomVecWavepacket(LAMMPS *lmp) : AtomVec(lmp) AtomVecWavepacket::AtomVecWavepacket(LAMMPS *lmp) : AtomVec(lmp)
@ -58,13 +56,13 @@ AtomVecWavepacket::AtomVecWavepacket(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom-electron arrays grow atom-electron arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecWavepacket::grow(int n) void AtomVecWavepacket::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;

1
src/USER-CUDA/atom_vec_angle_cuda.cpp
View File

@ -52,7 +52,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define BUFFACTOR 1.5 #define BUFFACTOR 1.5
#define BUFEXTRA 1000 #define BUFEXTRA 1000
#define NCUDAEXCHANGE 12 //nextra x y z vx vy vz tag type mask image molecule #define NCUDAEXCHANGE 12 //nextra x y z vx vy vz tag type mask image molecule

1
src/USER-CUDA/atom_vec_atomic_cuda.cpp
View File

@ -51,7 +51,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define BUFFACTOR 1.5 #define BUFFACTOR 1.5
#define BUFEXTRA 1000 #define BUFEXTRA 1000
#define NCUDAEXCHANGE 11 //nextra x y z vx vy vz tag type mask image #define NCUDAEXCHANGE 11 //nextra x y z vx vy vz tag type mask image

1
src/USER-CUDA/atom_vec_charge_cuda.cpp
View File

@ -51,7 +51,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define BUFFACTOR 1.5 #define BUFFACTOR 1.5
#define BUFEXTRA 1000 #define BUFEXTRA 1000
#define NCUDAEXCHANGE 12 //nextra x y z vx vy vz tag type mask image q #define NCUDAEXCHANGE 12 //nextra x y z vx vy vz tag type mask image q

1
src/USER-CUDA/atom_vec_full_cuda.cpp
View File

@ -52,7 +52,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define BUFFACTOR 1.5 #define BUFFACTOR 1.5
#define BUFEXTRA 1000 #define BUFEXTRA 1000
#define NCUDAEXCHANGE 13 //nextra x y z vx vy vz tag type mask image q molecule #define NCUDAEXCHANGE 13 //nextra x y z vx vy vz tag type mask image q molecule

6
src/USER-EFF/atom_vec_electron.cpp
View File

@ -30,8 +30,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
static const char cite_user_eff_package[] = static const char cite_user_eff_package[] =
"USER-EFF package:\n\n" "USER-EFF package:\n\n"
"@Article{Jaramillo-Botero11,\n" "@Article{Jaramillo-Botero11,\n"
@ -71,13 +69,13 @@ AtomVecElectron::AtomVecElectron(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom-electron arrays grow atom-electron arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecElectron::grow(int n) void AtomVecElectron::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;

7
src/USER-EFF/compute_temp_eff.cpp
View File

@ -23,8 +23,6 @@
#include "update.h" #include "update.h"
#include "force.h" #include "force.h"
#include "domain.h" #include "domain.h"
#include "modify.h"
#include "fix.h"
#include "group.h" #include "group.h"
#include "error.h" #include "error.h"
@ -58,9 +56,7 @@ ComputeTempEff::~ComputeTempEff()
void ComputeTempEff::setup() void ComputeTempEff::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -68,6 +64,7 @@ void ComputeTempEff::setup()
void ComputeTempEff::dof_compute() void ComputeTempEff::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
dof = domain->dimension * natoms; dof = domain->dimension * natoms;
dof -= extra_dof + fix_dof; dof -= extra_dof + fix_dof;

7
src/USER-MISC/compute_temp_rotate.cpp
View File

@ -23,8 +23,6 @@
#include "update.h" #include "update.h"
#include "force.h" #include "force.h"
#include "group.h" #include "group.h"
#include "modify.h"
#include "fix.h"
#include "domain.h" #include "domain.h"
#include "lattice.h" #include "lattice.h"
#include "error.h" #include "error.h"
@ -70,9 +68,7 @@ void ComputeTempRotate::init()
void ComputeTempRotate::setup() void ComputeTempRotate::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -80,6 +76,7 @@ void ComputeTempRotate::setup()
void ComputeTempRotate::dof_compute() void ComputeTempRotate::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
int nper = domain->dimension; int nper = domain->dimension;
dof = nper * natoms; dof = nper * natoms;

13
src/USER-SPH/atom_vec_meso.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecMeso::AtomVecMeso(LAMMPS *lmp) : AtomVec(lmp) AtomVecMeso::AtomVecMeso(LAMMPS *lmp) : AtomVec(lmp)
@ -50,15 +48,14 @@ AtomVecMeso::AtomVecMeso(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecMeso::grow(int n) { void AtomVecMeso::grow(int n)
if (n == 0) {
nmax += DELTA; if (n == 0) grow_nmax();
else else nmax = n;
nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)
error->one(FLERR,"Per-processor system is too big"); error->one(FLERR,"Per-processor system is too big");

47
src/atom.cpp
View File

@ -330,17 +330,12 @@ void Atom::create_avec(const char *style, int narg, char **arg, char *suffix)
// create instance of AtomVec // create instance of AtomVec
// use grow() to initialize atom-based arrays to length 1 // use grow() to initialize atom-based arrays to length 1
// so that x[0][0] can always be referenced even if proc has no atoms // so that x[0][0] can always be referenced even if proc has no atoms
// but reset nmax = 0
// so 2d arrays like bond_type will later be allocated correctly
// since currently, 2nd dimension bond_per_atom = 0
int sflag; int sflag;
avec = new_avec(style,suffix,sflag); avec = new_avec(style,suffix,sflag);
avec->store_args(narg,arg); avec->store_args(narg,arg);
avec->process_args(narg,arg); avec->process_args(narg,arg);
avec->grow(1); avec->grow(1);
nmax = 0;
avec->reset();
if (sflag) { if (sflag) {
char estyle[256]; char estyle[256];
@ -640,6 +635,48 @@ int Atom::count_words(const char *line)
return n; return n;
} }
/* ----------------------------------------------------------------------
deallocate molecular topology arrays
done before realloc with (possibly) new 2nd dimension set to
correctly initialized per-atom values, e.g. bond_per_atom
needs to be called whenever 2nd dimensions are changed
and these arrays are already pre-allocated,
e.g. due to grow(1) in create_avec()
------------------------------------------------------------------------- */
void Atom::deallocate_topology()
{
memory->destroy(atom->bond_type);
memory->destroy(atom->bond_atom);
atom->bond_type = NULL;
atom->bond_atom = NULL;
memory->destroy(atom->angle_type);
memory->destroy(atom->angle_atom1);
memory->destroy(atom->angle_atom2);
memory->destroy(atom->angle_atom3);
atom->angle_type = NULL;
atom->angle_atom1 = atom->angle_atom2 = atom->angle_atom3 = NULL;
memory->destroy(atom->dihedral_type);
memory->destroy(atom->dihedral_atom1);
memory->destroy(atom->dihedral_atom2);
memory->destroy(atom->dihedral_atom3);
memory->destroy(atom->dihedral_atom4);
atom->dihedral_type = NULL;
atom->dihedral_atom1 = atom->dihedral_atom2 =
atom->dihedral_atom3 = atom->dihedral_atom4 = NULL;
memory->destroy(atom->improper_type);
memory->destroy(atom->improper_atom1);
memory->destroy(atom->improper_atom2);
memory->destroy(atom->improper_atom3);
memory->destroy(atom->improper_atom4);
atom->improper_type = NULL;
atom->improper_atom1 = atom->improper_atom2 =
atom->improper_atom3 = atom->improper_atom4 = NULL;
}
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
unpack n lines from Atom section of data file unpack n lines from Atom section of data file
call style-specific routine to parse line call style-specific routine to parse line

2
src/atom.h
View File

@ -176,6 +176,8 @@ class Atom : protected Pointers {
int parse_data(const char *); int parse_data(const char *);
int count_words(const char *); int count_words(const char *);
void deallocate_topology();
void data_atoms(int, char *); void data_atoms(int, char *);
void data_vels(int, char *); void data_vels(int, char *);

21
src/atom_vec.cpp
View File

@ -21,6 +21,9 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 16384
#define DELTA_BONUS 8192
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVec::AtomVec(LAMMPS *lmp) : Pointers(lmp) AtomVec::AtomVec(LAMMPS *lmp) : Pointers(lmp)
@ -82,12 +85,24 @@ void AtomVec::init()
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
reset nmax = 0, called by Atom::create_avec() when new atom style created grow nmax so it is a multiple of DELTA
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVec::reset() void AtomVec::grow_nmax()
{ {
nmax = 0; nmax = nmax/DELTA * DELTA;
nmax += DELTA;
}
/* ----------------------------------------------------------------------
grow nmax_bonus so it is a multiple of DELTA_BONUS
------------------------------------------------------------------------- */
int AtomVec::grow_nmax_bonus(int nmax_bonus)
{
nmax_bonus = nmax_bonus/DELTA_BONUS * DELTA_BONUS;
nmax_bonus += DELTA_BONUS;
return nmax_bonus;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------

4
src/atom_vec.h
View File

@ -103,7 +103,6 @@ class AtomVec : protected Pointers {
virtual void write_vel(FILE *, int, double **); virtual void write_vel(FILE *, int, double **);
virtual int write_vel_hybrid(FILE *, double *) {return 0;} virtual int write_vel_hybrid(FILE *, double *) {return 0;}
void reset();
int pack_bond(tagint **); int pack_bond(tagint **);
void write_bond(FILE *, int, tagint **, int); void write_bond(FILE *, int, tagint **, int);
int pack_angle(tagint **); int pack_angle(tagint **);
@ -139,6 +138,9 @@ class AtomVec : protected Pointers {
ubuf(int64_t arg) : i(arg) {} ubuf(int64_t arg) : i(arg) {}
ubuf(int arg) : i(arg) {} ubuf(int arg) : i(arg) {}
}; };
void grow_nmax();
int grow_nmax_bonus(int);
}; };
} }

6
src/atom_vec_atomic.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecAtomic::AtomVecAtomic(LAMMPS *lmp) : AtomVec(lmp) AtomVecAtomic::AtomVecAtomic(LAMMPS *lmp) : AtomVec(lmp)
@ -44,13 +42,13 @@ AtomVecAtomic::AtomVecAtomic(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecAtomic::grow(int n) void AtomVecAtomic::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

9
src/atom_vec_body.cpp
View File

@ -28,9 +28,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define DELTA_BONUS 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecBody::AtomVecBody(LAMMPS *lmp) : AtomVec(lmp) AtomVecBody::AtomVecBody(LAMMPS *lmp) : AtomVec(lmp)
@ -109,13 +106,13 @@ void AtomVecBody::process_args(int narg, char **arg)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecBody::grow(int n) void AtomVecBody::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)
@ -158,7 +155,7 @@ void AtomVecBody::grow_reset()
void AtomVecBody::grow_bonus() void AtomVecBody::grow_bonus()
{ {
nmax_bonus += DELTA_BONUS; nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT) if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT)
error->one(FLERR,"Per-processor system is too big"); error->one(FLERR,"Per-processor system is too big");

6
src/atom_vec_charge.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecCharge::AtomVecCharge(LAMMPS *lmp) : AtomVec(lmp) AtomVecCharge::AtomVecCharge(LAMMPS *lmp) : AtomVec(lmp)
@ -46,13 +44,13 @@ AtomVecCharge::AtomVecCharge(LAMMPS *lmp) : AtomVec(lmp)
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecCharge::grow(int n) void AtomVecCharge::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

9
src/atom_vec_ellipsoid.cpp
View File

@ -31,9 +31,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
using namespace MathConst; using namespace MathConst;
#define DELTA 10000
#define DELTA_BONUS 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecEllipsoid::AtomVecEllipsoid(LAMMPS *lmp) : AtomVec(lmp) AtomVecEllipsoid::AtomVecEllipsoid(LAMMPS *lmp) : AtomVec(lmp)
@ -66,13 +63,13 @@ AtomVecEllipsoid::~AtomVecEllipsoid()
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecEllipsoid::grow(int n) void AtomVecEllipsoid::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)
@ -115,7 +112,7 @@ void AtomVecEllipsoid::grow_reset()
void AtomVecEllipsoid::grow_bonus() void AtomVecEllipsoid::grow_bonus()
{ {
nmax_bonus += DELTA_BONUS; nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT) if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT)
error->one(FLERR,"Per-processor system is too big"); error->one(FLERR,"Per-processor system is too big");

6
src/atom_vec_hybrid.cpp
View File

@ -23,8 +23,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp) {} AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp) {}
@ -135,13 +133,13 @@ void AtomVecHybrid::init()
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecHybrid::grow(int n) void AtomVecHybrid::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

8
src/atom_vec_line.cpp
View File

@ -26,8 +26,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define DELTA_BONUS 10000
#define EPSILON 0.001 #define EPSILON 0.001
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -73,13 +71,13 @@ void AtomVecLine::init()
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecLine::grow(int n) void AtomVecLine::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)
@ -124,7 +122,7 @@ void AtomVecLine::grow_reset()
void AtomVecLine::grow_bonus() void AtomVecLine::grow_bonus()
{ {
nmax_bonus += DELTA_BONUS; nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT) if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT)
error->one(FLERR,"Per-processor system is too big"); error->one(FLERR,"Per-processor system is too big");

6
src/atom_vec_sphere.cpp
View File

@ -29,8 +29,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
using namespace MathConst; using namespace MathConst;
#define DELTA 10000
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp) AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp)
@ -77,13 +75,13 @@ void AtomVecSphere::init()
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecSphere::grow(int n) void AtomVecSphere::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)

8
src/atom_vec_tri.cpp
View File

@ -27,8 +27,6 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
#define DELTA 10000
#define DELTA_BONUS 10000
#define EPSILON 0.001 #define EPSILON 0.001
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -74,13 +72,13 @@ void AtomVecTri::init()
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
grow atom arrays grow atom arrays
n = 0 grows arrays by DELTA n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n n > 0 allocates arrays to size n
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecTri::grow(int n) void AtomVecTri::grow(int n)
{ {
if (n == 0) nmax += DELTA; if (n == 0) grow_nmax();
else nmax = n; else nmax = n;
atom->nmax = nmax; atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT) if (nmax < 0 || nmax > MAXSMALLINT)
@ -125,7 +123,7 @@ void AtomVecTri::grow_reset()
void AtomVecTri::grow_bonus() void AtomVecTri::grow_bonus()
{ {
nmax_bonus += DELTA_BONUS; nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT) if (nmax_bonus < 0 || nmax_bonus > MAXSMALLINT)
error->one(FLERR,"Per-processor system is too big"); error->one(FLERR,"Per-processor system is too big");

13
src/compute.cpp
View File

@ -21,6 +21,8 @@
#include "domain.h" #include "domain.h"
#include "comm.h" #include "comm.h"
#include "group.h" #include "group.h"
#include "modify.h"
#include "fix.h"
#include "atom_masks.h" #include "atom_masks.h"
#include "memory.h" #include "memory.h"
#include "error.h" #include "error.h"
@ -131,6 +133,17 @@ void Compute::modify_params(int narg, char **arg)
} }
} }
/* ----------------------------------------------------------------------
calculate adjustment in DOF due to fixes
------------------------------------------------------------------------- */
void Compute::adjust_dof_fix()
{
fix_dof = 0;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
}
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
reset extra_dof to its default value reset extra_dof to its default value
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */

2
src/compute.h
View File

@ -86,6 +86,7 @@ class Compute : protected Pointers {
Compute(class LAMMPS *, int, char **); Compute(class LAMMPS *, int, char **);
virtual ~Compute(); virtual ~Compute();
void modify_params(int, char **); void modify_params(int, char **);
void adjust_dof_fix();
void reset_extra_dof(); void reset_extra_dof();
virtual void init() = 0; virtual void init() = 0;
@ -124,6 +125,7 @@ class Compute : protected Pointers {
protected: protected:
int extra_dof; // extra DOF for temperature computes int extra_dof; // extra DOF for temperature computes
int fix_dof; // DOF due to fixes
int dynamic; // recount atoms for temperature computes int dynamic; // recount atoms for temperature computes
int thermoflag; // 1 if include fix PE for PE computes int thermoflag; // 1 if include fix PE for PE computes

7
src/compute_temp.cpp
View File

@ -18,8 +18,6 @@
#include "update.h" #include "update.h"
#include "force.h" #include "force.h"
#include "domain.h" #include "domain.h"
#include "modify.h"
#include "fix.h"
#include "group.h" #include "group.h"
#include "error.h" #include "error.h"
@ -52,9 +50,7 @@ ComputeTemp::~ComputeTemp()
void ComputeTemp::setup() void ComputeTemp::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -62,6 +58,7 @@ void ComputeTemp::setup()
void ComputeTemp::dof_compute() void ComputeTemp::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
dof = domain->dimension * natoms; dof = domain->dimension * natoms;
dof -= static_cast<double>(extra_dof + fix_dof); dof -= static_cast<double>(extra_dof + fix_dof);

1
src/compute_temp.h
View File

@ -34,7 +34,6 @@ class ComputeTemp : public Compute {
void compute_vector(); void compute_vector();
protected: protected:
int fix_dof;
double tfactor; double tfactor;
virtual void dof_compute(); virtual void dof_compute();

7
src/compute_temp_com.cpp
View File

@ -19,8 +19,6 @@
#include "update.h" #include "update.h"
#include "force.h" #include "force.h"
#include "group.h" #include "group.h"
#include "modify.h"
#include "fix.h"
#include "domain.h" #include "domain.h"
#include "lattice.h" #include "lattice.h"
#include "error.h" #include "error.h"
@ -62,9 +60,7 @@ void ComputeTempCOM::init()
void ComputeTempCOM::setup() void ComputeTempCOM::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -72,6 +68,7 @@ void ComputeTempCOM::setup()
void ComputeTempCOM::dof_compute() void ComputeTempCOM::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
int nper = domain->dimension; int nper = domain->dimension;
dof = nper * natoms; dof = nper * natoms;

1
src/compute_temp_com.h
View File

@ -41,7 +41,6 @@ class ComputeTempCOM : public Compute {
void restore_bias_thr(int, double *, double *); void restore_bias_thr(int, double *, double *);
private: private:
int fix_dof;
double tfactor,masstotal; double tfactor,masstotal;
void dof_compute(); void dof_compute();

5
src/compute_temp_deform.cpp
View File

@ -86,9 +86,7 @@ void ComputeTempDeform::init()
void ComputeTempDeform::setup() void ComputeTempDeform::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -96,6 +94,7 @@ void ComputeTempDeform::setup()
void ComputeTempDeform::dof_compute() void ComputeTempDeform::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
dof = domain->dimension * natoms; dof = domain->dimension * natoms;
dof -= extra_dof + fix_dof; dof -= extra_dof + fix_dof;

1
src/compute_temp_deform.h
View File

@ -42,7 +42,6 @@ class ComputeTempDeform : public Compute {
double memory_usage(); double memory_usage();
protected: protected:
int fix_dof;
double tfactor; double tfactor;
virtual void dof_compute(); virtual void dof_compute();

7
src/compute_temp_partial.cpp
View File

@ -18,8 +18,6 @@
#include "update.h" #include "update.h"
#include "force.h" #include "force.h"
#include "domain.h" #include "domain.h"
#include "modify.h"
#include "fix.h"
#include "group.h" #include "group.h"
#include "memory.h" #include "memory.h"
#include "error.h" #include "error.h"
@ -63,9 +61,7 @@ ComputeTempPartial::~ComputeTempPartial()
void ComputeTempPartial::setup() void ComputeTempPartial::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -76,6 +72,7 @@ void ComputeTempPartial::setup()
void ComputeTempPartial::dof_compute() void ComputeTempPartial::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
int nper = xflag+yflag+zflag; int nper = xflag+yflag+zflag;
dof = nper * natoms; dof = nper * natoms;

1
src/compute_temp_partial.h
View File

@ -44,7 +44,6 @@ class ComputeTempPartial : public Compute {
protected: protected:
int xflag,yflag,zflag; int xflag,yflag,zflag;
int fix_dof;
double tfactor; double tfactor;
void dof_compute(); void dof_compute();

9
src/compute_temp_profile.cpp
View File

@ -161,9 +161,7 @@ ComputeTempProfile::~ComputeTempProfile()
void ComputeTempProfile::init() void ComputeTempProfile::init()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
// ptrs to domain data // ptrs to domain data
@ -189,9 +187,7 @@ void ComputeTempProfile::init()
void ComputeTempProfile::setup() void ComputeTempProfile::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -199,6 +195,7 @@ void ComputeTempProfile::setup()
void ComputeTempProfile::dof_compute() void ComputeTempProfile::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
int nper = domain->dimension; int nper = domain->dimension;
dof = nper * natoms; dof = nper * natoms;

1
src/compute_temp_profile.h
View File

@ -46,7 +46,6 @@ class ComputeTempProfile : public Compute {
int xflag,yflag,zflag,ncount,outflag; int xflag,yflag,zflag,ncount,outflag;
int nbinx,nbiny,nbinz,nbins; int nbinx,nbiny,nbinz,nbins;
int ivx,ivy,ivz; int ivx,ivy,ivz;
int fix_dof;
double tfactor; double tfactor;
int box_change,triclinic; int box_change,triclinic;

5
src/compute_temp_ramp.cpp
View File

@ -117,9 +117,7 @@ ComputeTempRamp::~ComputeTempRamp()
void ComputeTempRamp::setup() void ComputeTempRamp::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -127,6 +125,7 @@ void ComputeTempRamp::setup()
void ComputeTempRamp::dof_compute() void ComputeTempRamp::dof_compute()
{ {
if (fix_dof) adjust_dof_fix();
double natoms = group->count(igroup); double natoms = group->count(igroup);
int nper = domain->dimension; int nper = domain->dimension;
dof = nper * natoms; dof = nper * natoms;

2
src/compute_temp_ramp.h
View File

@ -46,7 +46,7 @@ class ComputeTempRamp : public Compute {
double coord_lo,coord_hi; double coord_lo,coord_hi;
int v_dim; int v_dim;
double v_lo,v_hi; double v_lo,v_hi;
int scaleflag,fix_dof; int scaleflag;
double tfactor,xscale,yscale,zscale; double tfactor,xscale,yscale,zscale;
void dof_compute(); void dof_compute();

1
src/compute_temp_region.cpp
View File

@ -17,7 +17,6 @@
#include "atom.h" #include "atom.h"
#include "update.h" #include "update.h"
#include "force.h" #include "force.h"
#include "modify.h"
#include "domain.h" #include "domain.h"
#include "region.h" #include "region.h"
#include "memory.h" #include "memory.h"

7
src/compute_temp_sphere.cpp
View File

@ -20,7 +20,6 @@
#include "force.h" #include "force.h"
#include "domain.h" #include "domain.h"
#include "modify.h" #include "modify.h"
#include "fix.h"
#include "group.h" #include "group.h"
#include "error.h" #include "error.h"
@ -109,9 +108,7 @@ void ComputeTempSphere::init()
void ComputeTempSphere::setup() void ComputeTempSphere::setup()
{ {
fix_dof = 0; fix_dof = -1;
for (int i = 0; i < modify->nfix; i++)
fix_dof += modify->fix[i]->dof(igroup);
dof_compute(); dof_compute();
} }
@ -121,6 +118,8 @@ void ComputeTempSphere::dof_compute()
{ {
int count,count_all; int count,count_all;
if (fix_dof) adjust_dof_fix();
// 6 or 3 dof for extended/point particles for 3d // 6 or 3 dof for extended/point particles for 3d
// 3 or 2 dof for extended/point particles for 2d // 3 or 2 dof for extended/point particles for 2d
// which dof are included also depends on mode // which dof are included also depends on mode

2
src/compute_temp_sphere.h
View File

@ -39,7 +39,7 @@ class ComputeTempSphere : public Compute {
void restore_bias_thr(int, double *, double *); void restore_bias_thr(int, double *, double *);
private: private:
int fix_dof,mode; int mode;
double tfactor; double tfactor;
char *id_bias; char *id_bias;
Compute *tbias; // ptr to additional bias compute Compute *tbias; // ptr to additional bias compute

5
src/create_box.cpp
View File

@ -164,11 +164,14 @@ void CreateBox::command(int narg, char **arg)
} }
// problem setup using info from header // problem setup using info from header
// no call to atom->grow since create_atoms or fixes will do it // deallocate/grow insures any extra settings are used for topology arrays
// necessary in case no create_atoms is performed
update->ntimestep = 0; update->ntimestep = 0;
atom->allocate_type_arrays(); atom->allocate_type_arrays();
atom->deallocate_topology();
atom->avec->grow(1);
domain->print_box("Created "); domain->print_box("Created ");
domain->set_initial_box(); domain->set_initial_box();

2
src/fix_adapt.cpp
View File

@ -370,7 +370,7 @@ void FixAdapt::change_settings()
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
restore pair,kspace.atom parameters to original values restore pair,kspace,atom parameters to original values
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void FixAdapt::restore_settings() void FixAdapt::restore_settings()

28
src/fix_addforce.cpp
View File

@ -104,8 +104,8 @@ FixAddForce::FixAddForce(LAMMPS *lmp, int narg, char **arg) :
force_flag = 0; force_flag = 0;
foriginal[0] = foriginal[1] = foriginal[2] = foriginal[3] = 0.0; foriginal[0] = foriginal[1] = foriginal[2] = foriginal[3] = 0.0;
maxatom = -1; maxatom = atom->nmax;
sforce = NULL; memory->create(sforce,maxatom,4,"addforce:sforce");
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -274,24 +274,16 @@ void FixAddForce::post_force(int vflag)
modify->clearstep_compute(); modify->clearstep_compute();
if (xstyle == EQUAL) xvalue = input->variable->compute_equal(xvar); if (xstyle == EQUAL) xvalue = input->variable->compute_equal(xvar);
else if (xstyle == ATOM) { else if (xstyle == ATOM)
if (sforce) input->variable->compute_atom(xvar,igroup,&sforce[0][0],4,0); input->variable->compute_atom(xvar,igroup,&sforce[0][0],4,0);
else input->variable->compute_atom(xvar,igroup,NULL,4,0);
}
if (ystyle == EQUAL) yvalue = input->variable->compute_equal(yvar); if (ystyle == EQUAL) yvalue = input->variable->compute_equal(yvar);
else if (ystyle == ATOM) { else if (ystyle == ATOM)
if (sforce) input->variable->compute_atom(yvar,igroup,&sforce[0][1],4,0); input->variable->compute_atom(yvar,igroup,&sforce[0][1],4,0);
else input->variable->compute_atom(yvar,igroup,NULL,4,0);
}
if (zstyle == EQUAL) zvalue = input->variable->compute_equal(zvar); if (zstyle == EQUAL) zvalue = input->variable->compute_equal(zvar);
else if (zstyle == ATOM) { else if (zstyle == ATOM)
if (sforce) input->variable->compute_atom(zvar,igroup,&sforce[0][2],4,0); input->variable->compute_atom(zvar,igroup,&sforce[0][2],4,0);
else input->variable->compute_atom(zvar,igroup,NULL,4,0); if (estyle == ATOM)
} input->variable->compute_atom(evar,igroup,&sforce[0][3],4,0);
if (estyle == ATOM) {
if (sforce) input->variable->compute_atom(evar,igroup,&sforce[0][3],4,0);
else input->variable->compute_atom(evar,igroup,NULL,4,0);
}
modify->addstep_compute(update->ntimestep + 1); modify->addstep_compute(update->ntimestep + 1);

35
src/fix_move.cpp
View File

@ -242,8 +242,9 @@ FixMove::FixMove(LAMMPS *lmp, int narg, char **arg) :
atom->add_callback(0); atom->add_callback(0);
atom->add_callback(1); atom->add_callback(1);
maxatom = -1; maxatom = atom->nmax;
displace = velocity = NULL; if (displaceflag) memory->create(displace,maxatom,3,"move:displace");
if (velocityflag) memory->create(velocity,maxatom,3,"move:velocity");
// xoriginal = initial unwrapped positions of atoms // xoriginal = initial unwrapped positions of atoms
@ -581,45 +582,27 @@ void FixMove::initial_integrate(int vflag)
if (xvarstr) { if (xvarstr) {
if (xvarstyle == EQUAL) dx = input->variable->compute_equal(xvar); if (xvarstyle == EQUAL) dx = input->variable->compute_equal(xvar);
else if (displace) else input->variable->compute_atom(xvar,igroup,&displace[0][0],3,0);
input->variable->compute_atom(xvar,igroup,&displace[0][0],3,0);
else
input->variable->compute_atom(xvar,igroup,NULL,3,0);
} }
if (yvarstr) { if (yvarstr) {
if (yvarstyle == EQUAL) dy = input->variable->compute_equal(yvar); if (yvarstyle == EQUAL) dy = input->variable->compute_equal(yvar);
else if (displace) else input->variable->compute_atom(yvar,igroup,&displace[0][1],3,0);
input->variable->compute_atom(yvar,igroup,&displace[0][1],3,0);
else
input->variable->compute_atom(yvar,igroup,NULL,3,0);
} }
if (zvarstr) { if (zvarstr) {
if (zvarstyle == EQUAL) dz = input->variable->compute_equal(zvar); if (zvarstyle == EQUAL) dz = input->variable->compute_equal(zvar);
else if (displace) else input->variable->compute_atom(zvar,igroup,&displace[0][2],3,0);
input->variable->compute_atom(zvar,igroup,&displace[0][2],3,0);
else
input->variable->compute_atom(zvar,igroup,NULL,3,0);
} }
if (vxvarstr) { if (vxvarstr) {
if (vxvarstyle == EQUAL) vx = input->variable->compute_equal(vxvar); if (vxvarstyle == EQUAL) vx = input->variable->compute_equal(vxvar);
else if (velocity) else input->variable->compute_atom(vxvar,igroup,&velocity[0][0],3,0);
input->variable->compute_atom(vxvar,igroup,&velocity[0][0],3,0);
else
input->variable->compute_atom(vxvar,igroup,NULL,3,0);
} }
if (vyvarstr) { if (vyvarstr) {
if (vyvarstyle == EQUAL) vy = input->variable->compute_equal(vyvar); if (vyvarstyle == EQUAL) vy = input->variable->compute_equal(vyvar);
else if (velocity) else input->variable->compute_atom(vyvar,igroup,&velocity[0][1],3,0);
input->variable->compute_atom(vyvar,igroup,&velocity[0][1],3,0);
else
input->variable->compute_atom(vyvar,igroup,NULL,3,0);
} }
if (vzvarstr) { if (vzvarstr) {
if (vzvarstyle == EQUAL) vz = input->variable->compute_equal(vzvar); if (vzvarstyle == EQUAL) vz = input->variable->compute_equal(vzvar);
else if (velocity) else input->variable->compute_atom(vzvar,igroup,&velocity[0][2],3,0);
input->variable->compute_atom(vzvar,igroup,&velocity[0][2],3,0);
else
input->variable->compute_atom(vzvar,igroup,NULL,3,0);
} }
modify->addstep_compute(update->ntimestep + 1); modify->addstep_compute(update->ntimestep + 1);

22
src/fix_setforce.cpp
View File

@ -99,8 +99,8 @@ FixSetForce::FixSetForce(LAMMPS *lmp, int narg, char **arg) :
force_flag = 0; force_flag = 0;
foriginal[0] = foriginal[1] = foriginal[2] = 0.0; foriginal[0] = foriginal[1] = foriginal[2] = 0.0;
maxatom = -1; maxatom = atom->nmax;
sforce = NULL; memory->create(sforce,maxatom,3,"setforce:sforce");
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -257,20 +257,14 @@ void FixSetForce::post_force(int vflag)
modify->clearstep_compute(); modify->clearstep_compute();
if (xstyle == EQUAL) xvalue = input->variable->compute_equal(xvar); if (xstyle == EQUAL) xvalue = input->variable->compute_equal(xvar);
else if (xstyle == ATOM) { else if (xstyle == ATOM)
if (sforce) input->variable->compute_atom(xvar,igroup,&sforce[0][0],3,0); input->variable->compute_atom(xvar,igroup,&sforce[0][0],3,0);
else input->variable->compute_atom(xvar,igroup,NULL,3,0);
}
if (ystyle == EQUAL) yvalue = input->variable->compute_equal(yvar); if (ystyle == EQUAL) yvalue = input->variable->compute_equal(yvar);
else if (ystyle == ATOM) { else if (ystyle == ATOM)
if (sforce) input->variable->compute_atom(yvar,igroup,&sforce[0][1],3,0); input->variable->compute_atom(yvar,igroup,&sforce[0][1],3,0);
else input->variable->compute_atom(yvar,igroup,NULL,3,0);
}
if (zstyle == EQUAL) zvalue = input->variable->compute_equal(zvar); if (zstyle == EQUAL) zvalue = input->variable->compute_equal(zvar);
else if (zstyle == ATOM) { else if (zstyle == ATOM)
if (sforce) input->variable->compute_atom(zvar,igroup,&sforce[0][2],3,0); input->variable->compute_atom(zvar,igroup,&sforce[0][2],3,0);
else input->variable->compute_atom(zvar,igroup,NULL,3,0);
}
modify->addstep_compute(update->ntimestep + 1); modify->addstep_compute(update->ntimestep + 1);

8
src/fix_store_state.cpp
View File

@ -467,11 +467,9 @@ void FixStoreState::end_of_step()
// evaluate atom-style variable // evaluate atom-style variable
} else if (which[m] == VARIABLE) } else if (which[m] == VARIABLE) {
if (values) input->variable->compute_atom(n,igroup,&values[0][m],nvalues,0);
input->variable->compute_atom(n,igroup,&values[0][m],nvalues,0); }
else
input->variable->compute_atom(n,igroup,NULL,nvalues,0);
} }
} }

2
src/modify.cpp
View File

@ -271,7 +271,7 @@ void Modify::init()
void Modify::setup(int vflag) void Modify::setup(int vflag)
{ {
// compute setup needs to come before fix setup // compute setup needs to come before fix setup
// b/c NH fixes need use DOF of temperature computes // b/c NH fixes need DOF of temperature computes
for (int i = 0; i < ncompute; i++) compute[i]->setup(); for (int i = 0; i < ncompute; i++) compute[i]->setup();

53
src/read_data.cpp
View File

@ -206,9 +206,9 @@ void ReadData::command(int narg, char **arg)
domain->box_exist = 1; domain->box_exist = 1;
update->ntimestep = 0; update->ntimestep = 0;
// insure extra settings are applied before grow(), // apply extra settings before grow(), even if no topology in file
// even if no topology in file // deallocate() insures new settings are used for topology arrays
// if topology is in file, realloc and another grow() is done below // if per-atom topology is in file, another grow() is done below
atom->bond_per_atom = atom->extra_bond_per_atom; atom->bond_per_atom = atom->extra_bond_per_atom;
atom->angle_per_atom = atom->extra_angle_per_atom; atom->angle_per_atom = atom->extra_angle_per_atom;
@ -220,6 +220,7 @@ void ReadData::command(int narg, char **arg)
else n = static_cast<int> (LB_FACTOR * atom->natoms / comm->nprocs); else n = static_cast<int> (LB_FACTOR * atom->natoms / comm->nprocs);
atom->allocate_type_arrays(); atom->allocate_type_arrays();
atom->deallocate_topology();
atom->avec->grow(n); atom->avec->grow(n);
domain->print_box(" "); domain->print_box(" ");
@ -497,49 +498,11 @@ void ReadData::command(int narg, char **arg)
firstpass = 0; firstpass = 0;
// reallocate bond,angle,diehdral,improper arrays via grow() // reallocate bond,angle,diehdral,improper arrays via grow()
// use new bond,angle,dihedral,improper per-atom values from 1st pass // will use new bond,angle,dihedral,improper per-atom values from 1st pass
// should leave other atom arrays unchanged, since already nmax in length // will also observe extra settings even if bond/etc topology not in file
// if bonds/etc not in data file, initialize per-atom size // leaves other atom arrays unchanged, since already nmax in length
// with extra settings before grow() of these topology arrays
if (bondflag) {
memory->destroy(atom->bond_type);
memory->destroy(atom->bond_atom);
atom->bond_type = NULL;
atom->bond_atom = NULL;
}
if (angleflag) {
memory->destroy(atom->angle_type);
memory->destroy(atom->angle_atom1);
memory->destroy(atom->angle_atom2);
memory->destroy(atom->angle_atom3);
atom->angle_type = NULL;
atom->angle_atom1 = atom->angle_atom2 = atom->angle_atom3 = NULL;
}
if (dihedralflag) {
memory->destroy(atom->dihedral_type);
memory->destroy(atom->dihedral_atom1);
memory->destroy(atom->dihedral_atom2);
memory->destroy(atom->dihedral_atom3);
memory->destroy(atom->dihedral_atom4);
atom->dihedral_type = NULL;
atom->dihedral_atom1 = atom->dihedral_atom2 =
atom->dihedral_atom3 = atom->dihedral_atom4 = NULL;
}
if (improperflag) {
memory->destroy(atom->improper_type);
memory->destroy(atom->improper_atom1);
memory->destroy(atom->improper_atom2);
memory->destroy(atom->improper_atom3);
memory->destroy(atom->improper_atom4);
atom->improper_type = NULL;
atom->improper_atom1 = atom->improper_atom2 =
atom->improper_atom3 = atom->improper_atom4 = NULL;
}
atom->deallocate_topology();
atom->avec->grow(atom->nmax); atom->avec->grow(atom->nmax);
} }

1
src/read_restart.cpp
View File

@ -151,6 +151,7 @@ void ReadRestart::command(int narg, char **arg)
else n = static_cast<int> (LB_FACTOR * atom->natoms / nprocs); else n = static_cast<int> (LB_FACTOR * atom->natoms / nprocs);
atom->allocate_type_arrays(); atom->allocate_type_arrays();
atom->deallocate_topology();
atom->avec->grow(n); atom->avec->grow(n);
n = atom->nmax; n = atom->nmax;

2
src/version.h
View File

@ -1 +1 @@
#define LAMMPS_VERSION "8 May 2014" #define LAMMPS_VERSION "9 May 2014"