void init_state(t_state *state,int natoms,int ngtc)
{
int i;
state->natoms = natoms;
state->nrng = 0;
state->flags = 0;
state->lambda = 0;
clear_mat(state->box);
clear_mat(state->box_rel);
clear_mat(state->boxv);
clear_mat(state->pres_prev);
init_gtc_state(state,ngtc);
state->nalloc = state->natoms;
if (state->nalloc > 0) {
snew(state->x,state->nalloc);
snew(state->v,state->nalloc);
} else {
state->x = NULL;
state->v = NULL;
}
state->sd_X = NULL;
state->cg_p = NULL;
init_ekinstate(&state->ekinstate);
init_energyhistory(&state->enerhist);
state->ddp_count = 0;
state->ddp_count_cg_gl = 0;
state->cg_gl = NULL;
state->cg_gl_nalloc = 0;
}
static void init_grptcstat(int ngtc, t_grp_tcstat tcstat[])
{
int i, j;
for (i = 0; (i < ngtc); i++)
{
tcstat[i].T = 0;
clear_mat(tcstat[i].ekinh);
clear_mat(tcstat[i].ekinh_old);
clear_mat(tcstat[i].ekinf);
}
}
static void calc_x_times_f(int nxf, const rvec x[], const rvec f[],
gmx_bool bScrewPBC, const matrix box,
matrix x_times_f)
{
clear_mat(x_times_f);
for (int i = 0; i < nxf; i++)
{
for (int d = 0; d < DIM; d++)
{
for (int n = 0; n < DIM; n++)
{
x_times_f[d][n] += x[i][d]*f[i][n];
}
}
if (bScrewPBC)
{
int isx = IS2X(i);
/* We should correct all odd x-shifts, but the range of isx is -2 to 2 */
if (isx == 1 || isx == -1)
{
for (int d = 0; d < DIM; d++)
{
for (int n = 0; n < DIM; n++)
{
x_times_f[d][n] += box[d][d]*f[i][n];
}
}
}
}
}
}
static void calc_virial(FILE *fplog,int start,int homenr,rvec x[],rvec f[],
tensor vir_part,t_graph *graph,matrix box,
t_nrnb *nrnb,const t_forcerec *fr,int ePBC)
{
int i,j;
tensor virtest;
/* The short-range virial from surrounding boxes */
clear_mat(vir_part);
calc_vir(fplog,SHIFTS,fr->shift_vec,fr->fshift,vir_part,ePBC==epbcSCREW,box);
inc_nrnb(nrnb,eNR_VIRIAL,SHIFTS);
/* Calculate partial virial, for local atoms only, based on short range.
* Total virial is computed in global_stat, called from do_md
*/
f_calc_vir(fplog,start,start+homenr,x,f,vir_part,graph,box);
inc_nrnb(nrnb,eNR_VIRIAL,homenr);
/* Add position restraint contribution */
for(i=0; i<DIM; i++) {
vir_part[i][i] += fr->vir_diag_posres[i];
}
/* Add wall contribution */
for(i=0; i<DIM; i++) {
vir_part[i][ZZ] += fr->vir_wall_z[i];
}
if (debug)
pr_rvecs(debug,0,"vir_part",vir_part,DIM);
}
static int xyz_first_x(t_trxstatus *status, FILE *fp, const output_env_t oenv,
real *t, rvec **x, matrix box)
/* Reads fp, mallocs x, and returns x and box
* Returns natoms when successful, FALSE otherwise
*/
{
int m;
initcount(status);
clear_mat(box);
choose_file_format(fp);
for (m = 0; (m < DIM); m++)
{
box[m][m] = status->BOX[m];
}
snew(*x, status->NATOMS);
*t = status->DT;
if (!xyz_next_x(status, fp, oenv, t, status->NATOMS, *x, box))
{
return 0;
}
*t = 0.0;
return status->NATOMS;
}
static void rotate_x(int natom,rvec xin[],real angle,rvec xout[],
gmx_bool bZ,gmx_bool bUpsideDown,real dz)
{
int i;
matrix mat;
angle *= DEG2RAD;
clear_mat(mat);
if (bZ) {
mat[XX][XX] = cos(angle);
mat[XX][YY] = sin(angle);
mat[YY][XX] = -sin(angle);
mat[YY][YY] = cos(angle);
mat[ZZ][ZZ] = 1;
}
else {
mat[XX][XX] = 1;
mat[YY][YY] = cos(angle);
mat[YY][ZZ] = sin(angle);
mat[ZZ][YY] = -sin(angle);
mat[ZZ][ZZ] = cos(angle);
}
for(i=0; (i<natom); i++) {
mvmul(mat,xin[i],xout[i]);
if (bUpsideDown)
xout[i][ZZ] *= -1;
xout[i][ZZ] += dz;
}
}
void clear_trxframe(t_trxframe *fr,gmx_bool bFirst)
{
fr->not_ok = 0;
fr->bTitle = FALSE;
fr->bStep = FALSE;
fr->bTime = FALSE;
fr->bLambda = FALSE;
fr->bAtoms = FALSE;
fr->bPrec = FALSE;
fr->bX = FALSE;
fr->bV = FALSE;
fr->bF = FALSE;
fr->bBox = FALSE;
if (bFirst) {
fr->flags = 0;
fr->bDouble= FALSE;
fr->natoms = -1;
fr->t0 = 0;
fr->tpf = 0;
fr->tppf = 0;
fr->title = NULL;
fr->step = 0;
fr->time = 0;
fr->lambda = 0;
fr->atoms = NULL;
fr->prec = 0;
fr->x = NULL;
fr->v = NULL;
fr->f = NULL;
clear_mat(fr->box);
fr->bPBC = FALSE;
fr->ePBC = -1;
}
}
PyObject *wrap_calc_fit_R(PyObject *self,PyObject *args)
{
PyObject *cs1, *cs2, *mass;
if(!PyArg_ParseTuple(args,"OOO",&cs1, &cs2, &mass))
return NULL;
int natoms1 = PySequence_Length(cs1);
int natoms2 = PySequence_Length(cs2);
if( natoms1 != natoms2 ) {
Error("Cannot fit coordinate sets with different lengths");
}
rvec x1[natoms1];
rvec x2[natoms1];
real m[natoms1];
PyObject2rvec( cs1, x1, natoms1);
PyObject2rvec( cs2, x2, natoms2);
PyObject2real_array(mass, m, natoms1);
center(x1, natoms1);
center(x2, natoms1);
matrix R;
clear_mat(R);
calc_fit_R(natoms1,m,x1,x2,R);
PyObject *ret = matrix2PyObject(R);
return ret;
}
// -----------------------------------------------------------------
// Take log of hermitian part of decomposition to define scalar field
void matrix_log(matrix *in, matrix *out) {
char V = 'V'; // Ask LAPACK for both eigenvalues and eigenvectors
char U = 'U'; // Have LAPACK store upper triangle of in
int row, col, Npt = NCOL, stat = 0, Nwork = 2 * NCOL;
matrix evecs, tmat;
// Convert in to column-major double array used by LAPACK
for (row = 0; row < NCOL; row++) {
for (col = 0; col < NCOL; col++) {
store[2 * (col * NCOL + row)] = in->e[row][col].real;
store[2 * (col * NCOL + row) + 1] = in->e[row][col].imag;
}
}
// Compute eigenvalues and eigenvectors of in
zheev_(&V, &U, &Npt, store, &Npt, eigs, work, &Nwork, Rwork, &stat);
if (stat != 0)
printf("WARNING: zheev returned error message %d\n", stat);
// Move the results back into matrix structures
// Use evecs to hold the eigenvectors for projection
clear_mat(out);
for (row = 0; row < NCOL; row++) {
for (col = 0; col < NCOL; col++) {
evecs.e[row][col].real = store[2 * (col * NCOL + row)];
evecs.e[row][col].imag = store[2 * (col * NCOL + row) + 1];
}
out->e[row][row].real = log(eigs[row]);
}
// Inverse of eigenvector matrix is simply adjoint
mult_na(out, &evecs, &tmat);
mult_nn(&evecs, &tmat, out);
}
void clear_trxframe(t_trxframe *fr, gmx_bool bFirst)
{
fr->not_ok = 0;
fr->bStep = FALSE;
fr->bTime = FALSE;
fr->bLambda = FALSE;
fr->bFepState = FALSE;
fr->bAtoms = FALSE;
fr->bPrec = FALSE;
fr->bX = FALSE;
fr->bV = FALSE;
fr->bF = FALSE;
fr->bBox = FALSE;
if (bFirst)
{
fr->bDouble = FALSE;
fr->natoms = -1;
fr->step = 0;
fr->time = 0;
fr->lambda = 0;
fr->fep_state = 0;
fr->atoms = nullptr;
fr->prec = 0;
fr->x = nullptr;
fr->v = nullptr;
fr->f = nullptr;
clear_mat(fr->box);
fr->bPBC = FALSE;
fr->ePBC = -1;
}
}
/* Center of mass code for groups */
void calc_vcm_grp(int start, int homenr, t_mdatoms *md,
rvec x[], rvec v[], t_vcm *vcm)
{
int i, g, m;
real m0;
rvec j0;
if (vcm->mode != ecmNO)
{
/* Also clear a possible rest group */
for (g = 0; (g < vcm->nr+1); g++)
{
/* Reset linear momentum */
vcm->group_mass[g] = 0;
clear_rvec(vcm->group_p[g]);
if (vcm->mode == ecmANGULAR)
{
/* Reset anular momentum */
clear_rvec(vcm->group_j[g]);
clear_rvec(vcm->group_x[g]);
clear_rvec(vcm->group_w[g]);
clear_mat(vcm->group_i[g]);
}
}
g = 0;
for (i = start; (i < start+homenr); i++)
{
m0 = md->massT[i];
if (md->cVCM)
{
g = md->cVCM[i];
}
/* Calculate linear momentum */
vcm->group_mass[g] += m0;
for (m = 0; (m < DIM); m++)
{
vcm->group_p[g][m] += m0*v[i][m];
}
if (vcm->mode == ecmANGULAR)
{
/* Calculate angular momentum */
cprod(x[i], v[i], j0);
for (m = 0; (m < DIM); m++)
{
vcm->group_j[g][m] += m0*j0[m];
vcm->group_x[g][m] += m0*x[i][m];
}
/* Update inertia tensor */
update_tensor(x[i], m0, vcm->group_i[g]);
}
}
}
}
void get_enx_state(char *fn, real t, gmx_groups_t *groups, t_inputrec *ir,
t_state *state)
{
/* Should match the names in mdebin.c */
static const char *boxvel_nm[] = {
"Box-Vel-XX", "Box-Vel-YY", "Box-Vel-ZZ",
"Box-Vel-YX", "Box-Vel-ZX", "Box-Vel-ZY"
};
static const char *pcouplmu_nm[] = {
"Pcoupl-Mu-XX", "Pcoupl-Mu-YY", "Pcoupl-Mu-ZZ",
"Pcoupl-Mu-YX", "Pcoupl-Mu-ZX", "Pcoupl-Mu-ZY"
};
int ind0[] = { XX,YY,ZZ,YY,ZZ,ZZ };
int ind1[] = { XX,YY,ZZ,XX,XX,YY };
int in,nre,nfr,i,ni,npcoupl;
char buf[STRLEN];
gmx_enxnm_t *enm;
t_enxframe *fr;
in = open_enx(fn,"r");
do_enxnms(in,&nre,&enm);
snew(fr,1);
nfr = 0;
while ((nfr==0 || fr->t != t) && do_enx(in,fr)) {
nfr++;
}
close_enx(in);
fprintf(stderr,"\n");
if (nfr == 0 || fr->t != t)
gmx_fatal(FARGS,"Could not find frame with time %f in '%s'",t,fn);
npcoupl = TRICLINIC(ir->compress) ? 6 : 3;
if (ir->epc == epcPARRINELLORAHMAN) {
clear_mat(state->boxv);
for(i=0; i<npcoupl; i++) {
state->boxv[ind0[i]][ind1[i]] =
find_energy(boxvel_nm[i],nre,enm,fr);
}
fprintf(stderr,"\nREAD %d BOX VELOCITIES FROM %s\n\n",npcoupl,fn);
}
if (ir->etc == etcNOSEHOOVER) {
for(i=0; i<state->ngtc; i++) {
ni = groups->grps[egcTC].nm_ind[i];
sprintf(buf,"Xi-%s",*(groups->grpname[ni]));
state->nosehoover_xi[i] = find_energy(buf,nre,enm,fr);
}
fprintf(stderr,"\nREAD %d NOSE-HOOVER Xi's FROM %s\n\n",state->ngtc,fn);
}
free_enxnms(nre,enm);
free_enxframe(fr);
sfree(fr);
}
real calc_cm(FILE *log,int natoms,real mass[],rvec x[],rvec v[],
rvec xcm,rvec vcm,rvec acm,matrix L)
{
rvec dx,a0;
real tm,m0;
int i,m;
clear_rvec(xcm);
clear_rvec(vcm);
clear_rvec(acm);
tm=0.0;
for(i=0; (i<natoms); i++) {
m0=mass[i];
tm+=m0;
cprod(x[i],v[i],a0);
for(m=0; (m<DIM); m++) {
xcm[m]+=m0*x[i][m]; /* c.o.m. position */
vcm[m]+=m0*v[i][m]; /* c.o.m. velocity */
acm[m]+=m0*a0[m]; /* rotational velocity around c.o.m. */
}
}
cprod(xcm,vcm,a0);
for(m=0; (m<DIM); m++) {
xcm[m]/=tm;
vcm[m]/=tm;
acm[m]-=a0[m]/tm;
}
#define PVEC(str,v) fprintf(log,\
"%s[X]: %10.5e %s[Y]: %10.5e %s[Z]: %10.5e\n", \
str,v[0],str,v[1],str,v[2])
#ifdef DEBUG
PVEC("xcm",xcm);
PVEC("acm",acm);
PVEC("vcm",vcm);
#endif
clear_mat(L);
for(i=0; (i<natoms); i++) {
m0=mass[i];
for(m=0; (m<DIM); m++)
dx[m]=x[i][m]-xcm[m];
L[XX][XX]+=dx[XX]*dx[XX]*m0;
L[XX][YY]+=dx[XX]*dx[YY]*m0;
L[XX][ZZ]+=dx[XX]*dx[ZZ]*m0;
L[YY][YY]+=dx[YY]*dx[YY]*m0;
L[YY][ZZ]+=dx[YY]*dx[ZZ]*m0;
L[ZZ][ZZ]+=dx[ZZ]*dx[ZZ]*m0;
}
#ifdef DEBUG
PVEC("L-x",L[XX]);
PVEC("L-y",L[YY]);
PVEC("L-z",L[ZZ]);
#endif
return tm;
}
/* the non-mass-weighted mean-squared displacement calcuation */
static real calc1_norm(t_corr *curr, int nx, atom_id index[], int nx0, rvec xc[],
rvec dcom, gmx_bool bTen, matrix mat)
{
int i, ix, m, m2;
real g, r, r2;
rvec rv;
g = 0.0;
clear_mat(mat);
for (i = 0; (i < nx); i++)
{
ix = index[i];
r2 = 0.0;
switch (curr->type)
{
case NORMAL:
for (m = 0; (m < DIM); m++)
{
rv[m] = xc[ix][m] - curr->x0[nx0][ix][m] - dcom[m];
r2 += rv[m]*rv[m];
if (bTen)
{
for (m2 = 0; m2 <= m; m2++)
{
mat[m][m2] += rv[m]*rv[m2];
}
}
}
break;
case X:
case Y:
case Z:
r = xc[ix][curr->type-X] - curr->x0[nx0][ix][curr->type-X] -
dcom[curr->type-X];
r2 += r*r;
break;
case LATERAL:
for (m = 0; (m < DIM); m++)
{
if (m != curr->axis)
{
r = xc[ix][m] - curr->x0[nx0][ix][m] - dcom[m];
r2 += r*r;
}
}
break;
default:
gmx_fatal(FARGS, "Error: did not expect option value %d", curr->type);
}
g += r2;
}
g /= nx;
msmul(mat, 1.0/nx, mat);
return g;
}
void set_box_rel(t_inputrec *ir,t_state *state)
{
/* Make sure the box obeys the restrictions before we fix the ratios */
correct_box(NULL,0,state->box,NULL);
clear_mat(state->box_rel);
if (PRESERVE_SHAPE(*ir))
do_box_rel(ir,state->box_rel,state->box,TRUE);
}
void
write_eigenvectors(char *trnname,int natoms,real mat[],
bool bReverse,int begin,int end,
int WriteXref,rvec *xref,bool bDMR,
rvec xav[], bool bDMA,real eigval[])
{
int trnout;
int ndim,i,j,d,vec;
matrix zerobox;
rvec *x;
ndim = natoms*DIM;
clear_mat(zerobox);
snew(x,natoms);
fprintf (stderr,
"\nWriting %saverage structure & eigenvectors %d--%d to %s\n",
(WriteXref==eWXR_YES) ? "reference, " : "",
begin,end,trnname);
trnout = open_tpx(trnname,"w");
if (WriteXref == eWXR_YES)
{
/* misuse lambda: 0/1 mass weighted fit no/yes */
fwrite_trn(trnout,-1,-1,bDMR ? 1.0 : 0.0,zerobox,natoms,xref,NULL,NULL);
}
else if (WriteXref == eWXR_NOFIT)
{
/* misuse lambda: -1 no fit */
fwrite_trn(trnout,-1,-1,-1.0,zerobox,natoms,x,NULL,NULL);
}
/* misuse lambda: 0/1 mass weighted analysis no/yes */
fwrite_trn(trnout,0,0,bDMA ? 1.0 : 0.0,zerobox,natoms,xav,NULL,NULL);
for(i=0; i<=(end-begin); i++)
{
if (!bReverse)
vec = i;
else
vec = ndim-i-1;
for (j=0; j<natoms; j++)
for(d=0; d<DIM; d++)
x[j][d]=mat[vec*ndim+DIM*j+d];
/* Store the eigenvalue in the time field */
fwrite_trn(trnout,begin+i,eigval[vec],0,zerobox,natoms,x,NULL,NULL);
}
close_trn(trnout);
sfree(x);
}
void set_box_rel(t_inputrec *ir, t_state *state)
{
/* Make sure the box obeys the restrictions before we fix the ratios */
correct_box(NULL, 0, state->box, NULL);
clear_mat(state->box_rel);
if (inputrecPreserveShape(ir))
{
do_box_rel(ir, state->box_rel, state->box, TRUE);
}
}
void calc_ke_part_visc(matrix box,rvec x[],rvec v[],
t_grpopts *opts,t_mdatoms *md,
gmx_ekindata_t *ekind,
t_nrnb *nrnb,real lambda)
{
int start=md->start,homenr=md->homenr;
int g,d,n,gt=0;
rvec v_corrt;
real hm;
t_grp_tcstat *tcstat=ekind->tcstat;
t_cos_acc *cosacc=&(ekind->cosacc);
real dekindl;
real fac,cosz;
double mvcos;
for(g=0; g<opts->ngtc; g++) {
copy_mat(ekind->tcstat[g].ekinh,ekind->tcstat[g].ekinh_old);
clear_mat(ekind->tcstat[g].ekinh);
}
ekind->dekindl_old = ekind->dekindl;
fac = 2*M_PI/box[ZZ][ZZ];
mvcos = 0;
dekindl = 0;
for(n=start; n<start+homenr; n++) {
if (md->cTC)
gt = md->cTC[n];
hm = 0.5*md->massT[n];
/* Note that the times of x and v differ by half a step */
cosz = cos(fac*x[n][ZZ]);
/* Calculate the amplitude of the new velocity profile */
mvcos += 2*cosz*md->massT[n]*v[n][XX];
copy_rvec(v[n],v_corrt);
/* Subtract the profile for the kinetic energy */
v_corrt[XX] -= cosz*cosacc->vcos;
for(d=0; (d<DIM); d++) {
tcstat[gt].ekinh[XX][d]+=hm*v_corrt[XX]*v_corrt[d];
tcstat[gt].ekinh[YY][d]+=hm*v_corrt[YY]*v_corrt[d];
tcstat[gt].ekinh[ZZ][d]+=hm*v_corrt[ZZ]*v_corrt[d];
}
if(md->nPerturbed && md->bPerturbed[n])
dekindl -= 0.5*(md->massB[n] - md->massA[n])*iprod(v_corrt,v_corrt);
}
ekind->dekindl = dekindl;
cosacc->mvcos = mvcos;
inc_nrnb(nrnb,eNR_EKIN,homenr);
}
void init_state(t_state *state, int natoms, int ngtc, int nnhpres, int nhchainlength, int dfhistNumLambda)
{
int i;
state->natoms = natoms;
state->flags = 0;
state->fep_state = 0;
state->lambda = 0;
snew(state->lambda, efptNR);
for (i = 0; i < efptNR; i++)
{
state->lambda[i] = 0;
}
state->veta = 0;
clear_mat(state->box);
clear_mat(state->box_rel);
clear_mat(state->boxv);
clear_mat(state->pres_prev);
clear_mat(state->svir_prev);
clear_mat(state->fvir_prev);
init_gtc_state(state, ngtc, nnhpres, nhchainlength);
state->nalloc = state->natoms;
if (state->nalloc > 0)
{
/* We need to allocate one element extra, since we might use
* (unaligned) 4-wide SIMD loads to access rvec entries.
*/
snew(state->x, state->nalloc + 1);
snew(state->v, state->nalloc + 1);
}
else
{
state->x = NULL;
state->v = NULL;
}
state->cg_p = NULL;
zero_history(&state->hist);
zero_ekinstate(&state->ekinstate);
snew(state->enerhist, 1);
init_energyhistory(state->enerhist);
if (dfhistNumLambda > 0)
{
snew(state->dfhist, 1);
init_df_history(state->dfhist, dfhistNumLambda);
}
else
{
state->dfhist = NULL;
}
state->swapstate = NULL;
state->edsamstate = NULL;
state->ddp_count = 0;
state->ddp_count_cg_gl = 0;
state->cg_gl = NULL;
state->cg_gl_nalloc = 0;
}
/* the normal, mass-weighted mean-squared displacement calcuation */
static real calc1_mw(t_corr *curr,int nx,atom_id index[],int nx0,rvec xc[],
rvec dcom,gmx_bool bTen,matrix mat,const output_env_t oenv)
{
int i;
real g,tm;
g=tm=0.0;
clear_mat(mat);
for(i=0; (i<nx); i++)
g += calc_one_mw(curr,index[i],nx0,xc,&tm,dcom,bTen,mat);
g/=tm;
if (bTen)
msmul(mat,1/tm,mat);
return g;
}
void calc_ke_part(rvec v[],t_grpopts *opts,t_mdatoms *md,
gmx_ekindata_t *ekind,
t_nrnb *nrnb,real lambda)
{
int start=md->start,homenr=md->homenr;
int g,d,n,ga=0,gt=0;
rvec v_corrt;
real hm;
t_grp_tcstat *tcstat=ekind->tcstat;
t_grp_acc *grpstat=ekind->grpstat;
real dekindl;
/* group velocities are calculated in update_ekindata and
* accumulated in acumulate_groups.
* Now the partial global and groups ekin.
*/
for(g=0; (g<opts->ngtc); g++) {
copy_mat(ekind->tcstat[g].ekinh,ekind->tcstat[g].ekinh_old);
clear_mat(ekind->tcstat[g].ekinh);
}
ekind->dekindl_old = ekind->dekindl;
dekindl = 0;
for(n=start; (n<start+homenr); n++) {
if (md->cACC)
ga = md->cACC[n];
if (md->cTC)
gt = md->cTC[n];
hm = 0.5*md->massT[n];
for(d=0; (d<DIM); d++) {
v_corrt[d] = v[n][d] - grpstat[ga].u[d];
}
for(d=0; (d<DIM); d++) {
tcstat[gt].ekinh[XX][d]+=hm*v_corrt[XX]*v_corrt[d];
tcstat[gt].ekinh[YY][d]+=hm*v_corrt[YY]*v_corrt[d];
tcstat[gt].ekinh[ZZ][d]+=hm*v_corrt[ZZ]*v_corrt[d];
}
if (md->nMassPerturbed && md->bPerturbed[n])
dekindl -= 0.5*(md->massB[n] - md->massA[n])*iprod(v_corrt,v_corrt);
}
ekind->dekindl = dekindl;
inc_nrnb(nrnb,eNR_EKIN,homenr);
}
static real calc1_mol(t_corr *curr,int nx,atom_id index[],int nx0,rvec xc[],
rvec dcom,gmx_bool bTen,matrix mat, const output_env_t oenv)
{
int i;
real g,tm,gtot,tt;
tt = curr->time[in_data(curr,nx0)];
gtot = 0;
tm = 0;
clear_mat(mat);
for(i=0; (i<nx); i++) {
g = calc_one_mw(curr,i,nx0,xc,&tm,dcom,bTen,mat);
/* We don't need to normalize as the mass was set to 1 */
gtot += g;
if (tt >= curr->beginfit && (curr->endfit < 0 || tt <= curr->endfit))
gmx_stats_add_point(curr->lsq[nx0][i],tt,g,0,0);
}
msmul(mat,1.0/nx,mat);
return gtot/nx;
}
/* the normal, mass-weighted mean-squared displacement calcuation */
static real calc1_mw(t_corr *curr, int nx, int index[], int nx0, rvec xc[],
rvec dcom, gmx_bool bTen, matrix mat)
{
int i;
real g, tm;
g = tm = 0.0;
clear_mat(mat);
for (i = 0; (i < nx); i++)
{
g += calc_one_mw(curr, index[i], nx0, xc, &tm, dcom, bTen, mat);
}
g /= tm;
if (bTen)
{
msmul(mat, 1/tm, mat);
}
return g;
}
real calc_pres(int ePBC,int nwall,matrix box,tensor ekin,tensor vir,
tensor pres,real Elr)
{
int n,m;
real fac,Plr;
if (ePBC==epbcNONE || (ePBC==epbcXY && nwall!=2))
clear_mat(pres);
else {
/* Uitzoeken welke ekin hier van toepassing is, zie Evans & Morris - E.
* Wrs. moet de druktensor gecorrigeerd worden voor de netto stroom in
* het systeem...
*/
/* Long range correction for periodic systems, see
* Neumann et al. JCP
* divide by 6 because it is multiplied by fac later on.
* If Elr = 0, no correction is made.
*/
/* This formula should not be used with Ewald or PME,
* where the full long-range virial is calculated. EL 990823
*/
Plr = Elr/6.0;
fac=PRESFAC*2.0/det(box);
for(n=0; (n<DIM); n++)
for(m=0; (m<DIM); m++)
pres[n][m]=(ekin[n][m]-vir[n][m]+Plr)*fac;
if (debug) {
pr_rvecs(debug,0,"PC: pres",pres,DIM);
pr_rvecs(debug,0,"PC: ekin",ekin,DIM);
pr_rvecs(debug,0,"PC: vir ",vir, DIM);
pr_rvecs(debug,0,"PC: box ",box, DIM);
}
}
return trace(pres)/3.0;
}
void calc_virial(FILE *log,int start,int homenr,rvec x[],rvec f[],
tensor vir_part,tensor pme_vir,
t_graph *graph,matrix box,
t_nrnb *nrnb,t_forcerec *fr,bool bTweak)
{
int i,j;
tensor virtest;
/* Now it is time for the short range virial. At this timepoint vir_part
* already contains the virial from surrounding boxes.
* Calculate partial virial, for local atoms only, based on short range.
* Total virial is computed in global_stat, called from do_md
*/
f_calc_vir(log,start,start+homenr,x,f,vir_part,graph,box);
inc_nrnb(nrnb,eNR_VIRIAL,homenr);
/* Add up the long range forces if necessary */
/* if (!bTweak) {
sum_lrforces(f,fr,start,homenr);
}*/
/* Add up virial if necessary */
if (EEL_LR(fr->eeltype) && (fr->eeltype != eelPPPM)) {
if (debug && bTweak) {
clear_mat(virtest);
f_calc_vir(log,start,start+homenr,x,fr->f_pme,virtest,graph,box);
pr_rvecs(debug,0,"virtest",virtest,DIM);
pr_rvecs(debug,0,"pme_vir",pme_vir,DIM);
}
/* PPPM virial sucks */
if (!bTweak)
for(i=0; (i<DIM); i++)
for(j=0; (j<DIM); j++)
vir_part[i][j]+=pme_vir[i][j];
}
if (debug)
pr_rvecs(debug,0,"vir_part",vir_part,DIM);
}
void init_state(t_state *state, int natoms, int ngtc, int nnhpres, int nhchainlength, int nlambda)
{
int i;
state->natoms = natoms;
state->flags = 0;
state->fep_state = 0;
state->lambda = 0;
snew(state->lambda, efptNR);
for (i = 0; i < efptNR; i++)
{
state->lambda[i] = 0;
}
state->veta = 0;
clear_mat(state->box);
clear_mat(state->box_rel);
clear_mat(state->boxv);
clear_mat(state->pres_prev);
clear_mat(state->svir_prev);
clear_mat(state->fvir_prev);
init_gtc_state(state, ngtc, nnhpres, nhchainlength);
state->nalloc = state->natoms;
if (state->nalloc > 0)
{
snew(state->x, state->nalloc);
snew(state->v, state->nalloc);
}
else
{
state->x = NULL;
state->v = NULL;
}
state->sd_X = NULL;
state->cg_p = NULL;
zero_history(&state->hist);
zero_ekinstate(&state->ekinstate);
snew(state->enerhist, 1);
init_energyhistory(state->enerhist);
init_df_history(&state->dfhist, nlambda);
init_swapstate(&state->swapstate);
state->ddp_count = 0;
state->ddp_count_cg_gl = 0;
state->cg_gl = NULL;
state->cg_gl_nalloc = 0;
}
int gmx_genbox(int argc, char *argv[])
{
const char *desc[] = {
"[TT]genbox[tt] can do one of 3 things:[PAR]",
"1) Generate a box of solvent. Specify [TT]-cs[tt] and [TT]-box[tt]. Or specify [TT]-cs[tt] and",
"[TT]-cp[tt] with a structure file with a box, but without atoms.[PAR]",
"2) Solvate a solute configuration, e.g. a protein, in a bath of solvent ",
"molecules. Specify [TT]-cp[tt] (solute) and [TT]-cs[tt] (solvent). ",
"The box specified in the solute coordinate file ([TT]-cp[tt]) is used,",
"unless [TT]-box[tt] is set.",
"If you want the solute to be centered in the box,",
"the program [TT]editconf[tt] has sophisticated options",
"to change the box dimensions and center the solute.",
"Solvent molecules are removed from the box where the ",
"distance between any atom of the solute molecule(s) and any atom of ",
"the solvent molecule is less than the sum of the van der Waals radii of ",
"both atoms. A database ([TT]vdwradii.dat[tt]) of van der Waals radii is ",
"read by the program, and atoms not in the database are ",
"assigned a default distance [TT]-vdwd[tt].",
"Note that this option will also influence the distances between",
"solvent molecules if they contain atoms that are not in the database.",
"[PAR]",
"3) Insert a number ([TT]-nmol[tt]) of extra molecules ([TT]-ci[tt]) ",
"at random positions.",
"The program iterates until [TT]nmol[tt] molecules",
"have been inserted in the box. To test whether an insertion is ",
"successful the same van der Waals criterium is used as for removal of ",
"solvent molecules. When no appropriately-sized ",
"holes (holes that can hold an extra molecule) are available, the ",
"program tries for [TT]-nmol[tt] * [TT]-try[tt] times before giving up. ",
"Increase [TT]-try[tt] if you have several small holes to fill.[PAR]",
"If you need to do more than one of the above operations, it can be",
"best to call [TT]genbox[tt] separately for each operation, so that",
"you are sure of the order in which the operations occur.[PAR]",
"The default solvent is Simple Point Charge water (SPC), with coordinates ",
"from [TT]$GMXLIB/spc216.gro[tt]. These coordinates can also be used",
"for other 3-site water models, since a short equibilibration will remove",
"the small differences between the models.",
"Other solvents are also supported, as well as mixed solvents. The",
"only restriction to solvent types is that a solvent molecule consists",
"of exactly one residue. The residue information in the coordinate",
"files is used, and should therefore be more or less consistent.",
"In practice this means that two subsequent solvent molecules in the ",
"solvent coordinate file should have different residue number.",
"The box of solute is built by stacking the coordinates read from",
"the coordinate file. This means that these coordinates should be ",
"equlibrated in periodic boundary conditions to ensure a good",
"alignment of molecules on the stacking interfaces.",
"The [TT]-maxsol[tt] option simply adds only the first [TT]-maxsol[tt]",
"solvent molecules and leaves out the rest that would have fitted",
"into the box. This can create a void that can cause problems later.",
"Choose your volume wisely.[PAR]",
"The program can optionally rotate the solute molecule to align the",
"longest molecule axis along a box edge. This way the amount of solvent",
"molecules necessary is reduced.",
"It should be kept in mind that this only works for",
"short simulations, as e.g. an alpha-helical peptide in solution can ",
"rotate over 90 degrees, within 500 ps. In general it is therefore ",
"better to make a more or less cubic box.[PAR]",
"Setting [TT]-shell[tt] larger than zero will place a layer of water of",
"the specified thickness (nm) around the solute. Hint: it is a good",
"idea to put the protein in the center of a box first (using [TT]editconf[tt]).",
"[PAR]",
"Finally, [TT]genbox[tt] will optionally remove lines from your topology file in ",
"which a number of solvent molecules is already added, and adds a ",
"line with the total number of solvent molecules in your coordinate file."
};
const char *bugs[] = {
"Molecules must be whole in the initial configurations.",
};
/* parameter data */
gmx_bool bSol, bProt, bBox;
const char *conf_prot, *confout;
int bInsert;
real *r;
char *title_ins;
gmx_atomprop_t aps;
/* protein configuration data */
char *title = NULL;
t_atoms atoms;
rvec *x, *v = NULL;
int ePBC = -1;
matrix box;
t_pbc pbc;
/* other data types */
int atoms_added, residues_added;
t_filenm fnm[] = {
{ efSTX, "-cp", "protein", ffOPTRD },
{ efSTX, "-cs", "spc216", ffLIBOPTRD},
{ efSTX, "-ci", "insert", ffOPTRD},
{ efSTO, NULL, NULL, ffWRITE},
{ efTOP, NULL, NULL, ffOPTRW},
};
#define NFILE asize(fnm)
static int nmol_ins = 0, nmol_try = 10, seed = 1997;
static real r_distance = 0.105, r_shell = 0;
static rvec new_box = {0.0, 0.0, 0.0};
static gmx_bool bReadV = FALSE;
static int max_sol = 0;
output_env_t oenv;
t_pargs pa[] = {
{ "-box", FALSE, etRVEC, {new_box},
"Box size" },
{ "-nmol", FALSE, etINT, {&nmol_ins},
"Number of extra molecules to insert" },
{ "-try", FALSE, etINT, {&nmol_try},
"Try inserting [TT]-nmol[tt] times [TT]-try[tt] times" },
{ "-seed", FALSE, etINT, {&seed},
"Random generator seed"},
{ "-vdwd", FALSE, etREAL, {&r_distance},
"Default van der Waals distance"},
{ "-shell", FALSE, etREAL, {&r_shell},
"Thickness of optional water layer around solute" },
{ "-maxsol", FALSE, etINT, {&max_sol},
"Maximum number of solvent molecules to add if they fit in the box. If zero (default) this is ignored" },
{ "-vel", FALSE, etBOOL, {&bReadV},
"Keep velocities from input solute and solvent" }
};
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_BE_NICE, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bInsert = opt2bSet("-ci", NFILE, fnm) && (nmol_ins > 0);
bSol = opt2bSet("-cs", NFILE, fnm);
bProt = opt2bSet("-cp", NFILE, fnm);
bBox = opt2parg_bSet("-box", asize(pa), pa);
/* check input */
if (bInsert && nmol_ins <= 0)
{
gmx_fatal(FARGS, "When specifying inserted molecules (-ci), "
"-nmol must be larger than 0");
}
if (!bInsert && nmol_ins > 0)
{
gmx_fatal(FARGS,
"You tried to insert molecules with -nmol, but did not supply "
"a molecule to insert with -ci.");
}
if (!bProt && !bBox)
{
gmx_fatal(FARGS, "When no solute (-cp) is specified, "
"a box size (-box) must be specified");
}
aps = gmx_atomprop_init();
if (bProt)
{
/*generate a solute configuration */
conf_prot = opt2fn("-cp", NFILE, fnm);
title = read_prot(conf_prot, &atoms, &x, bReadV ? &v : NULL, &r, &ePBC, box,
aps, r_distance);
if (bReadV && !v)
{
fprintf(stderr, "Note: no velocities found\n");
}
if (atoms.nr == 0)
{
fprintf(stderr, "Note: no atoms in %s\n", conf_prot);
bProt = FALSE;
}
}
if (!bProt)
{
atoms.nr = 0;
atoms.nres = 0;
atoms.resinfo = NULL;
atoms.atomname = NULL;
atoms.atom = NULL;
atoms.pdbinfo = NULL;
x = NULL;
r = NULL;
}
if (bBox)
{
ePBC = epbcXYZ;
clear_mat(box);
box[XX][XX] = new_box[XX];
box[YY][YY] = new_box[YY];
box[ZZ][ZZ] = new_box[ZZ];
}
if (det(box) == 0)
{
gmx_fatal(FARGS, "Undefined solute box.\nCreate one with editconf "
"or give explicit -box command line option");
}
/* add nmol_ins molecules of atoms_ins
in random orientation at random place */
if (bInsert)
{
title_ins = insert_mols(opt2fn("-ci", NFILE, fnm), nmol_ins, nmol_try, seed,
&atoms, &x, &r, ePBC, box, aps, r_distance, r_shell,
oenv);
}
else
{
title_ins = strdup("Generated by genbox");
}
/* add solvent */
if (bSol)
{
add_solv(opt2fn("-cs", NFILE, fnm), &atoms, &x, v ? &v : NULL, &r, ePBC, box,
aps, r_distance, &atoms_added, &residues_added, r_shell, max_sol,
oenv);
}
/* write new configuration 1 to file confout */
confout = ftp2fn(efSTO, NFILE, fnm);
fprintf(stderr, "Writing generated configuration to %s\n", confout);
if (bProt)
{
write_sto_conf(confout, title, &atoms, x, v, ePBC, box);
/* print box sizes and box type to stderr */
fprintf(stderr, "%s\n", title);
}
else
{
write_sto_conf(confout, title_ins, &atoms, x, v, ePBC, box);
}
/* print size of generated configuration */
fprintf(stderr, "\nOutput configuration contains %d atoms in %d residues\n",
atoms.nr, atoms.nres);
update_top(&atoms, box, NFILE, fnm, aps);
gmx_atomprop_destroy(aps);
thanx(stderr);
return 0;
}
gmx_bool constrain(FILE *fplog, gmx_bool bLog, gmx_bool bEner,
struct gmx_constr *constr,
t_idef *idef, t_inputrec *ir, gmx_ekindata_t *ekind,
t_commrec *cr,
gmx_int64_t step, int delta_step,
t_mdatoms *md,
rvec *x, rvec *xprime, rvec *min_proj,
gmx_bool bMolPBC, matrix box,
real lambda, real *dvdlambda,
rvec *v, tensor *vir,
t_nrnb *nrnb, int econq, gmx_bool bPscal,
real veta, real vetanew)
{
gmx_bool bOK, bDump;
int start, homenr, nrend;
int i, j, d;
int ncons, settle_error;
tensor vir_r_m_dr;
rvec *vstor;
real invdt, vir_fac, t;
t_ilist *settle;
int nsettle;
t_pbc pbc, *pbc_null;
char buf[22];
t_vetavars vetavar;
int nth, th;
if (econq == econqForceDispl && !EI_ENERGY_MINIMIZATION(ir->eI))
{
gmx_incons("constrain called for forces displacements while not doing energy minimization, can not do this while the LINCS and SETTLE constraint connection matrices are mass weighted");
}
bOK = TRUE;
bDump = FALSE;
start = 0;
homenr = md->homenr;
nrend = start+homenr;
/* set constants for pressure control integration */
init_vetavars(&vetavar, econq != econqCoord,
veta, vetanew, ir, ekind, bPscal);
if (ir->delta_t == 0)
{
invdt = 0;
}
else
{
invdt = 1/ir->delta_t;
}
if (ir->efep != efepNO && EI_DYNAMICS(ir->eI))
{
/* Set the constraint lengths for the step at which this configuration
* is meant to be. The invmasses should not be changed.
*/
lambda += delta_step*ir->fepvals->delta_lambda;
}
if (vir != NULL)
{
clear_mat(vir_r_m_dr);
}
where();
settle = &idef->il[F_SETTLE];
nsettle = settle->nr/(1+NRAL(F_SETTLE));
if (nsettle > 0)
{
nth = gmx_omp_nthreads_get(emntSETTLE);
}
else
{
nth = 1;
}
if (nth > 1 && constr->vir_r_m_dr_th == NULL)
{
snew(constr->vir_r_m_dr_th, nth);
snew(constr->settle_error, nth);
}
settle_error = -1;
/* We do not need full pbc when constraints do not cross charge groups,
* i.e. when dd->constraint_comm==NULL.
* Note that PBC for constraints is different from PBC for bondeds.
* For constraints there is both forward and backward communication.
*/
if (ir->ePBC != epbcNONE &&
(cr->dd || bMolPBC) && !(cr->dd && cr->dd->constraint_comm == NULL))
{
/* With pbc=screw the screw has been changed to a shift
* by the constraint coordinate communication routine,
* so that here we can use normal pbc.
*/
pbc_null = set_pbc_dd(&pbc, ir->ePBC, cr->dd, FALSE, box);
}
else
{
pbc_null = NULL;
}
/* Communicate the coordinates required for the non-local constraints
* for LINCS and/or SETTLE.
*/
if (cr->dd)
{
dd_move_x_constraints(cr->dd, box, x, xprime, econq == econqCoord);
}
if (constr->lincsd != NULL)
{
bOK = constrain_lincs(fplog, bLog, bEner, ir, step, constr->lincsd, md, cr,
x, xprime, min_proj,
box, pbc_null, lambda, dvdlambda,
invdt, v, vir != NULL, vir_r_m_dr,
econq, nrnb,
constr->maxwarn, &constr->warncount_lincs);
if (!bOK && constr->maxwarn >= 0)
{
if (fplog != NULL)
{
fprintf(fplog, "Constraint error in algorithm %s at step %s\n",
econstr_names[econtLINCS], gmx_step_str(step, buf));
}
bDump = TRUE;
}
}
if (constr->nblocks > 0)
{
switch (econq)
{
case (econqCoord):
bOK = bshakef(fplog, constr->shaked,
md->invmass, constr->nblocks, constr->sblock,
idef, ir, x, xprime, nrnb,
constr->lagr, lambda, dvdlambda,
invdt, v, vir != NULL, vir_r_m_dr,
constr->maxwarn >= 0, econq, &vetavar);
break;
case (econqVeloc):
bOK = bshakef(fplog, constr->shaked,
md->invmass, constr->nblocks, constr->sblock,
idef, ir, x, min_proj, nrnb,
constr->lagr, lambda, dvdlambda,
invdt, NULL, vir != NULL, vir_r_m_dr,
constr->maxwarn >= 0, econq, &vetavar);
break;
default:
gmx_fatal(FARGS, "Internal error, SHAKE called for constraining something else than coordinates");
break;
}
if (!bOK && constr->maxwarn >= 0)
{
if (fplog != NULL)
{
fprintf(fplog, "Constraint error in algorithm %s at step %s\n",
econstr_names[econtSHAKE], gmx_step_str(step, buf));
}
bDump = TRUE;
}
}
if (nsettle > 0)
{
int calcvir_atom_end;
if (vir == NULL)
{
calcvir_atom_end = 0;
}
else
{
calcvir_atom_end = md->homenr;
}
switch (econq)
{
case econqCoord:
#pragma omp parallel for num_threads(nth) schedule(static)
for (th = 0; th < nth; th++)
{
int start_th, end_th;
if (th > 0)
{
clear_mat(constr->vir_r_m_dr_th[th]);
}
start_th = (nsettle* th )/nth;
end_th = (nsettle*(th+1))/nth;
if (start_th >= 0 && end_th - start_th > 0)
{
csettle(constr->settled,
end_th-start_th,
settle->iatoms+start_th*(1+NRAL(F_SETTLE)),
pbc_null,
x[0], xprime[0],
invdt, v ? v[0] : NULL, calcvir_atom_end,
th == 0 ? vir_r_m_dr : constr->vir_r_m_dr_th[th],
th == 0 ? &settle_error : &constr->settle_error[th],
&vetavar);
}
}
inc_nrnb(nrnb, eNR_SETTLE, nsettle);
if (v != NULL)
{
inc_nrnb(nrnb, eNR_CONSTR_V, nsettle*3);
}
if (vir != NULL)
{
inc_nrnb(nrnb, eNR_CONSTR_VIR, nsettle*3);
}
break;
case econqVeloc:
case econqDeriv:
case econqForce:
case econqForceDispl:
#pragma omp parallel for num_threads(nth) schedule(static)
for (th = 0; th < nth; th++)
{
int start_th, end_th;
if (th > 0)
{
clear_mat(constr->vir_r_m_dr_th[th]);
}
start_th = (nsettle* th )/nth;
end_th = (nsettle*(th+1))/nth;
if (start_th >= 0 && end_th - start_th > 0)
{
settle_proj(constr->settled, econq,
end_th-start_th,
settle->iatoms+start_th*(1+NRAL(F_SETTLE)),
pbc_null,
x,
xprime, min_proj, calcvir_atom_end,
th == 0 ? vir_r_m_dr : constr->vir_r_m_dr_th[th],
&vetavar);
}
}
/* This is an overestimate */
inc_nrnb(nrnb, eNR_SETTLE, nsettle);
break;
case econqDeriv_FlexCon:
/* Nothing to do, since the are no flexible constraints in settles */
break;
default:
gmx_incons("Unknown constraint quantity for settle");
}
}
if (settle->nr > 0)
{
/* Combine virial and error info of the other threads */
for (i = 1; i < nth; i++)
{
m_add(vir_r_m_dr, constr->vir_r_m_dr_th[i], vir_r_m_dr);
settle_error = constr->settle_error[i];
}
if (econq == econqCoord && settle_error >= 0)
{
bOK = FALSE;
if (constr->maxwarn >= 0)
{
char buf[256];
sprintf(buf,
"\nstep " "%"GMX_PRId64 ": Water molecule starting at atom %d can not be "
"settled.\nCheck for bad contacts and/or reduce the timestep if appropriate.\n",
step, ddglatnr(cr->dd, settle->iatoms[settle_error*(1+NRAL(F_SETTLE))+1]));
if (fplog)
{
fprintf(fplog, "%s", buf);
}
fprintf(stderr, "%s", buf);
constr->warncount_settle++;
if (constr->warncount_settle > constr->maxwarn)
{
too_many_constraint_warnings(-1, constr->warncount_settle);
}
bDump = TRUE;
}
}
}
free_vetavars(&vetavar);
if (vir != NULL)
{
switch (econq)
{
case econqCoord:
vir_fac = 0.5/(ir->delta_t*ir->delta_t);
break;
case econqVeloc:
vir_fac = 0.5/ir->delta_t;
break;
case econqForce:
case econqForceDispl:
vir_fac = 0.5;
break;
default:
vir_fac = 0;
gmx_incons("Unsupported constraint quantity for virial");
}
if (EI_VV(ir->eI))
{
vir_fac *= 2; /* only constraining over half the distance here */
}
for (i = 0; i < DIM; i++)
{
for (j = 0; j < DIM; j++)
{
(*vir)[i][j] = vir_fac*vir_r_m_dr[i][j];
}
}
}
if (bDump)
{
dump_confs(fplog, step, constr->warn_mtop, start, homenr, cr, x, xprime, box);
}
if (econq == econqCoord)
{
if (ir->ePull == epullCONSTRAINT)
{
if (EI_DYNAMICS(ir->eI))
{
t = ir->init_t + (step + delta_step)*ir->delta_t;
}
else
{
t = ir->init_t;
}
set_pbc(&pbc, ir->ePBC, box);
pull_constraint(ir->pull, md, &pbc, cr, ir->delta_t, t, x, xprime, v, *vir);
}
if (constr->ed && delta_step > 0)
{
/* apply the essential dynamcs constraints here */
do_edsam(ir, step, cr, xprime, v, box, constr->ed);
}
}
return bOK;
}
static void do_my_pme(FILE *fp,real tm,gmx_bool bVerbose,t_inputrec *ir,
rvec x[],rvec xbuf[],rvec f[],
real charge[],real qbuf[],real qqbuf[],
matrix box,gmx_bool bSort,
t_commrec *cr,t_nsborder *nsb,t_nrnb *nrnb,
t_block *excl,real qtot,
t_forcerec *fr,int index[],FILE *fp_xvg,
int ngroups,unsigned short cENER[])
{
real ener,vcorr,q,xx,dvdl=0,vdip,vcharge;
tensor vir,vir_corr,vir_tot;
rvec mu_tot[2];
int i,m,ii,ig,jg;
real **epme,*qptr;
/* Initiate local variables */
fr->f_el_recip = f;
clear_mat(vir);
clear_mat(vir_corr);
if (ngroups > 1) {
fprintf(fp,"There are %d energy groups\n",ngroups);
snew(epme,ngroups);
for(i=0; (i<ngroups); i++)
snew(epme[i],ngroups);
}
/* Put x is in the box, this part needs to be parallellized properly */
/*put_atoms_in_box(box,nsb->natoms,x);*/
/* Here sorting of X (and q) is done.
* Alternatively, one could just put the atoms in one of the
* cr->nnodes slabs. That is much cheaper than sorting.
*/
for(i=0; (i<nsb->natoms); i++)
index[i] = i;
if (bSort) {
xptr = x;
qsort(index,nsb->natoms,sizeof(index[0]),comp_xptr);
xptr = NULL; /* To trap unintentional use of the ptr */
}
/* After sorting we only need the part that is to be computed on
* this processor. We also compute the mu_tot here (system dipole)
*/
clear_rvec(mu_tot[0]);
for(i=START(nsb); (i<START(nsb)+HOMENR(nsb)); i++) {
ii = index[i];
q = charge[ii];
qbuf[i] = q;
for(m=0; (m<DIM); m++) {
xx = x[ii][m];
xbuf[i][m] = xx;
mu_tot[0][m] += q*xx;
}
clear_rvec(f[ii]);
}
copy_rvec(mu_tot[0],mu_tot[1]);
if (debug) {
pr_rvec(debug,0,"qbuf",qbuf,nsb->natoms,TRUE);
pr_rvecs(debug,0,"xbuf",xbuf,nsb->natoms);
pr_rvecs(debug,0,"box",box,DIM);
}
for(ig=0; (ig<ngroups); ig++) {
for(jg=ig; (jg<ngroups); jg++) {
if (ngroups > 1) {
for(i=START(nsb); (i<START(nsb)+HOMENR(nsb)); i++) {
if ((cENER[i] == ig) || (cENER[i] == jg))
qqbuf[i] = qbuf[i];
else
qqbuf[i] = 0;
}
qptr = qqbuf;
}
else
qptr = qbuf;
ener = do_pme(fp,bVerbose,ir,xbuf,f,qptr,qptr,box,cr,
nsb,nrnb,vir,fr->ewaldcoeff,FALSE,0,&dvdl,FALSE);
vcorr = ewald_LRcorrection(fp,nsb,cr,fr,qptr,qptr,excl,xbuf,box,mu_tot,
ir->ewald_geometry,ir->epsilon_surface,
0,&dvdl,&vdip,&vcharge);
gmx_sum(1,&ener,cr);
gmx_sum(1,&vcorr,cr);
if (ngroups > 1)
epme[ig][jg] = ener+vcorr;
}
}
if (ngroups > 1) {
if (fp_xvg)
fprintf(fp_xvg,"%10.3f",tm);
for(ig=0; (ig<ngroups); ig++) {
for(jg=ig; (jg<ngroups); jg++) {
if (ig != jg)
epme[ig][jg] -= epme[ig][ig]+epme[jg][jg];
if (fp_xvg)
fprintf(fp_xvg," %12.5e",epme[ig][jg]);
}
}
if (fp_xvg)
fprintf(fp_xvg,"\n");
}
else {
fprintf(fp,"Time: %10.3f Energy: %12.5e Correction: %12.5e Total: %12.5e\n",
tm,ener,vcorr,ener+vcorr);
if (fp_xvg)
fprintf(fp_xvg,"%10.3f %12.5e %12.5e %12.5e\n",tm,ener+vcorr,vdip,vcharge);
if (bVerbose) {
m_add(vir,vir_corr,vir_tot);
gmx_sum(9,vir_tot[0],cr);
pr_rvecs(fp,0,"virial",vir_tot,DIM);
}
fflush(fp);
}
}
real sum_ekin(t_grpopts *opts, gmx_ekindata_t *ekind, real *dekindlambda,
gmx_bool bEkinAveVel, gmx_bool bSaveEkinOld, gmx_bool bScaleEkin)
{
int i, j, m, ngtc;
real T, ek;
t_grp_tcstat *tcstat;
real nrdf, nd, *ndf;
ngtc = opts->ngtc;
ndf = opts->nrdf;
T = 0;
nrdf = 0;
clear_mat(ekind->ekin);
for (i = 0; (i < ngtc); i++)
{
nd = ndf[i];
tcstat = &ekind->tcstat[i];
/* Sometimes a group does not have degrees of freedom, e.g.
* when it consists of shells and virtual sites, then we just
* set the temperatue to 0 and also neglect the kinetic
* energy, which should be zero anyway.
*/
if (nd > 0)
{
if (bEkinAveVel)
{
if (!bScaleEkin)
{
/* in this case, kinetic energy is from the current velocities already */
msmul(tcstat->ekinf, tcstat->ekinscalef_nhc, tcstat->ekinf);
}
}
else
{
/* Calculate the full step Ekin as the average of the half steps */
for (j = 0; (j < DIM); j++)
{
for (m = 0; (m < DIM); m++)
{
tcstat->ekinf[j][m] =
0.5*(tcstat->ekinh[j][m]*tcstat->ekinscaleh_nhc + tcstat->ekinh_old[j][m]);
}
}
}
m_add(tcstat->ekinf, ekind->ekin, ekind->ekin);
tcstat->Th = calc_temp(trace(tcstat->ekinh), nd);
tcstat->T = calc_temp(trace(tcstat->ekinf), nd);
/* after the scaling factors have been multiplied in, we can remove them */
if (bEkinAveVel)
{
tcstat->ekinscalef_nhc = 1.0;
}
else
{
tcstat->ekinscaleh_nhc = 1.0;
}
}
else
{
tcstat->T = 0;
tcstat->Th = 0;
}
T += nd*tcstat->T;
nrdf += nd;
}
if (nrdf > 0)
{
T /= nrdf;
}
if (dekindlambda)
{
*dekindlambda = 0.5*(ekind->dekindl + ekind->dekindl_old);
}
return T;
}
