forked from lijiext/lammps
cleanup
This commit is contained in:
Christian Negre
parent
a58f7631c0
commit
967cdd947e
|
|
@ -6,7 +6,7 @@
|
|||
# PROGRESS: https://github.com/losalamos/qmd-progress
|
||||
# METIS: http://glaros.dtc.umn.edu/gkhome/metis/metis/download
|
||||
|
||||
latte_PATH = ${HOME}/exaalt/LATTE
|
||||
latte_PATH = ${HOME}/exaalt/LATTE_dev
|
||||
progress_PATH = ${HOME}/qmd-progress
|
||||
bml_PATH = ${HOME}/bml
|
||||
metis_PATH = ${HOME}/Programs/metis-5.1.0
|
||||
|
|
@ -16,6 +16,9 @@ latte_SYSLIB = -fopenmp ${latte_PATH}/src/latte_c_bind.o ${latte_PATH}/liblatte
|
|||
-lm -Wl,--no-as-needed -L${MKLROOT}/lib/intel64 -lmkl_lapack95_lp64 -lmkl_gf_lp64 \
|
||||
-lmkl_gnu_thread -lmkl_core -lmkl_gnu_thread -lmkl_core -ldl -lpthread -lm
|
||||
|
||||
latte_SYSLIB = -fopenmp ${latte_PATH}/src/latte_c_bind.o ${latte_PATH}/liblatte.a -lgfortran \
|
||||
-llapack -lblas
|
||||
|
||||
# Uncomment the following line to use PROGRESS/BML
|
||||
latte_SYSLIB += -L${progress_PATH}/install/lib -lprogress -L${bml_PATH}/install/lib -lbml -L${metis_PATH}/install -lmetis
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,338 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
// NOTES on possible future issues:
|
||||
// LATTE compute and return 6-value virial tensor
|
||||
// can LATTE compute per-atom energy and per-atom virial
|
||||
// for minimize, what about charge DOFs
|
||||
// implement charge DOF integration
|
||||
// pass neighbor list to LATTE: half or full
|
||||
// will we ever auto-adjust the timestep in reset_dt()
|
||||
// could pass an input file to LATTE, specified in LAMMPS input script
|
||||
// what units options can LAMMPS be using
|
||||
// should LATTE take triclinic box from LAMMPS
|
||||
// does Coulomb potential = pe[i]/q[i], is it 0 when q = 0
|
||||
// how will this work for serial/parallel LAMMPS with serial/parallel LATTE
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "fix_latte.h"
|
||||
#include "atom.h"
|
||||
#include "comm.h"
|
||||
#include "update.h"
|
||||
#include "neighbor.h"
|
||||
#include "domain.h"
|
||||
#include "force.h"
|
||||
#include "neigh_request.h"
|
||||
#include "neigh_list.h"
|
||||
#include "modify.h"
|
||||
#include "compute.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace FixConst;
|
||||
|
||||
extern "C" {
|
||||
void latte(int *, int *, double *, int *, int *,
|
||||
double *, double *, double *, double *, int*, double *, double *, double*);
|
||||
}
|
||||
|
||||
#define INVOKED_PERATOM 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
FixLatte::FixLatte(LAMMPS *lmp, int narg, char **arg) :
|
||||
Fix(lmp, narg, arg)
|
||||
{
|
||||
if (narg != 4) error->all(FLERR,"Illegal fix latte command");
|
||||
|
||||
if (comm->nprocs != 1)
|
||||
error->all(FLERR,"Fix latte currently runs only in serial");
|
||||
|
||||
scalar_flag = 1;
|
||||
global_freq = 1;
|
||||
extscalar = 1;
|
||||
virial_flag = 1;
|
||||
|
||||
// store ID of compute pe/atom used to generate Coulomb potential for LATTE
|
||||
// NULL means LATTE will compute Coulombic potential
|
||||
|
||||
coulomb = 0;
|
||||
id_pe = NULL;
|
||||
|
||||
if (strcmp(arg[3],"NULL") != 0) {
|
||||
coulomb = 1;
|
||||
|
||||
int n = strlen(arg[3]) + 1;
|
||||
id_pe = new char[n];
|
||||
strcpy(id_pe,arg[3]);
|
||||
|
||||
int ipe = modify->find_compute(id_pe);
|
||||
if (ipe < 0) error->all(FLERR,"Could not find fix latte compute ID");
|
||||
if (modify->compute[ipe]->peatomflag == 0)
|
||||
error->all(FLERR,"Fix latte compute ID does not compute pe/atom");
|
||||
}
|
||||
|
||||
// initializations
|
||||
|
||||
nmax = 0;
|
||||
qpotential = NULL;
|
||||
flatte = NULL;
|
||||
|
||||
latte_energy = 0.0;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
FixLatte::~FixLatte()
|
||||
{
|
||||
delete [] id_pe;
|
||||
memory->destroy(qpotential);
|
||||
memory->destroy(flatte);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
int FixLatte::setmask()
|
||||
{
|
||||
int mask = 0;
|
||||
//mask |= INITIAL_INTEGRATE;
|
||||
//mask |= FINAL_INTEGRATE;
|
||||
mask |= PRE_REVERSE;
|
||||
mask |= POST_FORCE;
|
||||
mask |= MIN_POST_FORCE;
|
||||
mask |= THERMO_ENERGY;
|
||||
return mask;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::init()
|
||||
{
|
||||
// error checks
|
||||
|
||||
if (domain->dimension == 2)
|
||||
error->all(FLERR,"Fix latte requires 3d problem");
|
||||
|
||||
if (coulomb) {
|
||||
if (atom->q_flag == 0 || force->pair == NULL || force->kspace == NULL)
|
||||
error->all(FLERR,"Fix latte cannot compute Coulombic potential");
|
||||
|
||||
int ipe = modify->find_compute(id_pe);
|
||||
if (ipe < 0) error->all(FLERR,"Could not find fix latte compute ID");
|
||||
c_pe = modify->compute[ipe];
|
||||
}
|
||||
|
||||
// must be fully periodic or fully non-periodic
|
||||
|
||||
if (domain->nonperiodic == 0) pbcflag = 1;
|
||||
else if (!domain->xperiodic && !domain->yperiodic && !domain->zperiodic)
|
||||
pbcflag = 0;
|
||||
else error->all(FLERR,"Fix latte requires 3d simulation");
|
||||
|
||||
// create qpotential & flatte if needed
|
||||
// for now, assume nlocal will never change
|
||||
|
||||
if (coulomb && qpotential == NULL) {
|
||||
memory->create(qpotential,atom->nlocal,"latte:qpotential");
|
||||
memory->create(flatte,atom->nlocal,3,"latte:flatte");
|
||||
}
|
||||
|
||||
/*
|
||||
// warn if any integrate fix comes after this one
|
||||
// is it actually necessary for q(n) update to come after x,v update ??
|
||||
|
||||
int after = 0;
|
||||
int flag = 0;
|
||||
for (int i = 0; i < modify->nfix; i++) {
|
||||
if (strcmp(id,modify->fix[i]->id) == 0) after = 1;
|
||||
else if ((modify->fmask[i] & INITIAL_INTEGRATE) && after) flag = 1;
|
||||
}
|
||||
if (flag && comm->me == 0)
|
||||
error->warning(FLERR,"Fix latte should come after all other "
|
||||
"integration fixes");
|
||||
*/
|
||||
|
||||
/*
|
||||
// need a full neighbor list
|
||||
// could we use a half list?
|
||||
// perpetual list, built whenever re-neighboring occurs
|
||||
|
||||
int irequest = neighbor->request(this,instance_me);
|
||||
neighbor->requests[irequest]->pair = 0;
|
||||
neighbor->requests[irequest]->fix = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
*/
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::init_list(int id, NeighList *ptr)
|
||||
{
|
||||
// list = ptr;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::setup(int vflag)
|
||||
{
|
||||
post_force(vflag);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::min_setup(int vflag)
|
||||
{
|
||||
post_force(vflag);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
integrate electronic degrees of freedom
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::initial_integrate(int vflag) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
store eflag, so can use it in post_force to tally per-atom energies
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::pre_reverse(int eflag, int vflag)
|
||||
{
|
||||
eflag_caller = eflag;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::post_force(int vflag)
|
||||
{
|
||||
int eflag = eflag_caller;
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = 0;
|
||||
|
||||
// compute Coulombic potential = pe[i]/q[i]
|
||||
// invoke compute pe/atom
|
||||
// wrap with clear/add and trigger pe/atom calculation every step
|
||||
|
||||
if (coulomb) {
|
||||
modify->clearstep_compute();
|
||||
|
||||
if (!(c_pe->invoked_flag & INVOKED_PERATOM)) {
|
||||
c_pe->compute_peratom();
|
||||
c_pe->invoked_flag |= INVOKED_PERATOM;
|
||||
}
|
||||
|
||||
modify->addstep_compute(update->ntimestep+1);
|
||||
|
||||
double *pe = c_pe->vector_atom;
|
||||
double *q = atom->q;
|
||||
int nlocal = atom->nlocal;
|
||||
|
||||
for (int i = 0; i < nlocal; i++)
|
||||
if (q[i]) qpotential[i] = pe[i]/q[i];
|
||||
else qpotential[i] = 0.0;
|
||||
}
|
||||
|
||||
// hardwire these unsupported flags for now
|
||||
|
||||
int coulombflag = 0;
|
||||
pe_peratom = 0;
|
||||
virial_global = 0; // set via vflag_global at some point
|
||||
virial_peratom = 0;
|
||||
neighflag = 0;
|
||||
|
||||
// set flags used by LATTE
|
||||
|
||||
int flags[6];
|
||||
|
||||
flags[0] = pbcflag; // 1 for fully periodic, 0 for fully non-periodic
|
||||
flags[1] = coulombflag; // 1 for LAMMPS computes Coulombics, 0 for LATTE
|
||||
flags[2] = pe_peratom; // 1 to return per-atom energies, 0 for no
|
||||
flags[3] = virial_global; // 1 to return global virial 0 for no
|
||||
flags[4] = virial_peratom; // 1 to return per-atom virial, 0 for no
|
||||
flags[5] = neighflag; // 1 to pass neighbor list to LATTE, 0 for no
|
||||
|
||||
// setup LATTE arguments
|
||||
|
||||
int natoms = atom->nlocal;
|
||||
double *coords = &atom->x[0][0];
|
||||
int *type = atom->type;
|
||||
int ntypes = atom->ntypes;
|
||||
double *mass = &atom->mass[1];
|
||||
double *boxlo = domain->boxlo;
|
||||
double *boxhi = domain->boxhi;
|
||||
|
||||
double *forces;
|
||||
if (coulomb) forces = &flatte[0][0];
|
||||
else forces = &atom->f[0][0];
|
||||
|
||||
// invoke LATTE
|
||||
|
||||
int maxiter = -1;
|
||||
double *dt_latte = &update->dt;
|
||||
double dt_latte_ang = *dt_latte * 1000.0; // Units of DT must be in Angstroms
|
||||
|
||||
// latte(flags,&natoms,coords,type,&ntypes,mass,boxlo,boxhi,
|
||||
// forces,&maxiter, &latte_energy, &atom->v[0][0],&update->dt);
|
||||
|
||||
latte(flags,&natoms,coords,type,&ntypes,mass,boxlo,boxhi,
|
||||
forces,&maxiter, &latte_energy, &atom->v[0][0], &dt_latte_ang);
|
||||
|
||||
// sum LATTE forces to LAMMPS (Coulombic) forces
|
||||
|
||||
if (coulomb) {
|
||||
double **f = atom->f;
|
||||
int nlocal = atom->nlocal;
|
||||
for (int i = 0; i < nlocal; i++) {
|
||||
f[i][0] += flatte[i][0];
|
||||
f[i][1] += flatte[i][1];
|
||||
f[i][2] += flatte[i][2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
integrate electronic degrees of freedom
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::final_integrate() {}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
void FixLatte::reset_dt()
|
||||
{
|
||||
//dtv = update->dt;
|
||||
//dtf = 0.5 * update->dt * force->ftm2v;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
DFTB energy from LATTE
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
double FixLatte::compute_scalar()
|
||||
{
|
||||
return latte_energy;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
memory usage of local arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
double FixLatte::memory_usage()
|
||||
{
|
||||
double bytes = 0.0;
|
||||
if (coulomb) bytes += nmax * sizeof(double);
|
||||
if (coulomb) bytes += nmax*3 * sizeof(double);
|
||||
return bytes;
|
||||
}
|
||||
Loading…
Reference in New Issue