void
replace_coordinates(struct atomgrp* ag, const char* pdb_path)
{
struct atomgrp* ag_new = read_pdb_nopar(pdb_path);
if (ag_new->natoms != ag->natoms) {
_mol_error("new atomgroup has %d atoms, old has %d atoms", ag_new->natoms, ag->natoms);
exit(EXIT_FAILURE);
}
int list[ag->natoms];
for (int i=0; i<ag->natoms; i++) {
list[i] = i;
}
setup_subag(ag, ag_new, ag->natoms, list);
free_atomgrp(ag_new);
}
void accs2(struct atomgrp* ag, float r_solv, short cont_acc, float* as)
{
const int NAC=5000; /* max number of atoms in a cube */
/* integration increment */
const float P=0.01;
int i, sint=sizeof(int), sflo=sizeof(float);
int n_at1=ag->natoms;
float xmin, xmax, ymin, ymax, zmin, zmax;
float rmax=0;
float pi=acos(-1.0);
float pix2=2.0*pi;
float ri, xi, yi, zi;
float *x;
float *y;
float *z;
float *r;
float *r2;
float *dx;
float *dy;
float *d;
float *dsq;
float *arcif;
int *inov;
float dmax;
int idim;
int jidim;
int kjidim;
int *itab;
int *natm;
int* cube;
int j, k, l, m, n, kji;
int ir, io, in, mkji, nm, nzp, karc;
float area, xr, yr, zr, rr, rrx2, rr2, b, zres, zgrid;
float rsec2r, rsecr, rsec2n, rsecn;
float calpha, alpha, beta, ti, tf, arcsum, parea, t, tt;
/* eliminate atoms with zero radii */
int n_at=0;
int *restat;
i=n_at1*sint;
restat=_mol_malloc(i);
for(i=0; i<n_at1; i++)
{
as[i]=0.0;
ri=ag->atoms[i].rminh;
if(ri>0.0)restat[n_at++]=i;
}
/* initialize boundary constants */
xmin=ag->atoms[restat[0]].X;
xmax=xmin;
ymin=ag->atoms[restat[0]].Y;
ymax=ymin;
zmin=ag->atoms[restat[0]].Z;
zmax=zmin;
/* allocate general atom related arrays */
i=n_at*sflo;
x=_mol_malloc(i);
y=_mol_malloc(i);
z=_mol_malloc(i);
r=_mol_malloc(i);
r2=_mol_malloc(i);
/* allocate arrays for neighbouring atoms */
dx=_mol_malloc(i);
dy=_mol_malloc(i);
d=_mol_malloc(i);
dsq=_mol_malloc(i);
arcif=_mol_malloc(2*2*i);
i=n_at*sint;
inov=_mol_malloc(i);
/* calculate sizes and dimensions*/
for(i=0; i<n_at; i++)
{
ri=ag->atoms[restat[i]].rminh;
ri=ri+r_solv;
r[i]=ri;
r2[i]=ri*ri;
if(ri>rmax)rmax=ri;
x[i]=ag->atoms[restat[i]].X;
if(xmin>x[i])xmin=x[i];
if(xmax<x[i])xmax=x[i];
y[i]=ag->atoms[restat[i]].Y;
if(ymin>y[i])ymin=y[i];
if(ymax<y[i])ymax=y[i];
z[i]=ag->atoms[restat[i]].Z;
if(zmin>z[i])zmin=z[i];
if(zmax<z[i])zmax=z[i];
}
dmax=rmax*2.0;
i=(xmax-xmin)/dmax+1;
idim=i<3?3:i;
i=(ymax-ymin)/dmax+1;
jidim=i<3?3:i;
jidim*=idim;
i=(zmax-zmin)/dmax+1;
kjidim=i<3?3:i;
kjidim*=jidim; /* total number of cubes */
/* map atoms to adjacent cubes */
/* allocate cubical arrays */
i=kjidim*sint;
itab=_mol_malloc(i); /* number of atoms in each cube */
for(i=0; i<kjidim; i++)itab[i]=0;
i=NAC*kjidim*sint;
natm=_mol_malloc(i); /* atom index in each cube */
i=n_at*sint;
cube=_mol_malloc(i); /* cube number for each atom */
for(l=0; l<n_at; l++)
{
i=(x[l]-xmin)/dmax;
j=(y[l]-ymin)/dmax;
k=(z[l]-zmin)/dmax;
kji=k*jidim+j*idim+i; /* cube number */
n=itab[kji]+1;
if(n>NAC)
{
_mol_error("number of atoms in a cube %d is above the maximum NAC= %d\n", n, NAC);
exit(EXIT_FAILURE);
}
itab[kji]=n;
natm[kji*NAC+n-1]=l;
cube[l]=kji;
}
/* main loop over atoms */
zi=1.0/P+0.5;
nzp=zi; /* number of z planes */
for (ir=0; ir<n_at; ir++)
{
kji=cube[ir];
io=0; /* number of neighbouring atoms */
area=0.0;
xr=x[ir];
yr=y[ir];
zr=z[ir];
rr=r[ir];
rrx2=rr*2;
rr2=r2[ir];
/* loops over neighbouring cubes */
for (k=-1; k<2; k++)
{
for(j=-1; j<2; j++)
{
for(i=-1; i<2; i++)
{
mkji=kji+k*jidim+j*idim+i;
if(mkji<0)continue;
if(mkji>=kjidim)goto esc_cubes;
nm=itab[mkji];
if(nm<1)continue;
for(m=0; m<nm; m++)
{
in=natm[mkji*NAC+m];
if(in!=ir)
{
xi=xr-x[in];
yi=yr-y[in];
dx[io]=xi;
dy[io]=yi;
ri=xi*xi+yi*yi;
dsq[io]=ri;
d[io]=sqrtf(ri);
inov[io]=in;
io++;
}
}
}
}
}
esc_cubes:
if(io!=0)
{
zres=rrx2/nzp; /* separation between planes */
zgrid=z[ir]-rr-zres/2.0; /* z level */
for(i=0; i<nzp; i++)
{
zgrid+=zres;
/* radius of the circle intersection with a z-plane */
zi=zgrid-zr;
rsec2r=rr2-zi*zi;
rsecr=sqrtf(rsec2r);
karc=0;
for(j=0; j<io; j++)
{
in=inov[j];
/* radius of the circle for a neighbour */
zi=zgrid-z[in];
rsec2n=r2[in]-zi*zi;
if(rsec2n<=0.0)continue;
rsecn=sqrtf(rsec2n);
/* are they close? */
if(d[j]>=rsecr+rsecn)continue;
/* do they intersect? */
b=rsecr-rsecn;
if(b<=0.0)
{
if(d[j]<=-b)goto next_plane;
}
else
{
if(d[j]<=b)continue;
}
calpha=(dsq[j]+rsec2r-rsec2n)/(2.0*d[j]*rsecr);
if(calpha>=1.0)continue;
/* yes, they do */
alpha=acosf(calpha);
beta=atan2f(dy[j],dx[j])+pi;
ti=beta-alpha;
tf=beta+alpha;
if(ti<0.0)ti+=pix2;
if(tf>pix2)tf-=pix2;
arcif[karc]=ti;
if(tf<ti)
{
arcif[karc+1]=pix2;
karc+=2;
arcif[karc]=0.0;
}
arcif[karc+1]=tf;
karc+=2;
}
/* find the atom accessible surface increment in z-plane */
karc/=2;
if(karc==0)
arcsum=pix2;
else
{
qsort(arcif, karc, 2*sizeof(arcif[0]), accs_comp);
arcsum=arcif[0];
t=arcif[1];
if(karc>1)
{
for(k=2; k<karc*2; k+=2)
{
if(t<arcif[k])arcsum+=(arcif[k]-t);
tt=arcif[k+1];
if(tt>t)t=tt;
}
}
arcsum+=(pix2-t);
}
parea=arcsum*zres;
area+=parea;
next_plane:;
}
}
else
{
area=pix2*rrx2;
}
ri=rr-r_solv;
if(cont_acc)
b=area*ri*ri/rr;
else
b=area*rr;
as[restat[ir]]=b;
}
/* free all */
free(x);
free(y);
free(z);
free(r);
free(r2);
free(dx);
free(dy);
free(d);
free(dsq);
free(arcif);
free(inov);
free(itab);
free(natm);
free(cube);
free(restat);
}