/*************************************************************************************************************
The MIT License
Copyright (C) 2006-2019 David Dubbeldam, Sofia Calero, Thijs Vlugt, Donald E. Ellis, and Randall Q. Snurr.
D.Dubbeldam@uva.nl http://www.uva.nl/profiel/d/u/d.dubbeldam/d.dubbeldam.html
scaldia@upo.es http://www.upo.es/raspa/
t.j.h.vlugt@tudelft.nl http://homepage.tudelft.nl/v9k6y
don-ellis@northwestern.edu http://dvworld.northwestern.edu/
snurr@northwestern.edu http://zeolites.cqe.northwestern.edu/
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "constants.h"
#include "molecule.h"
#include "framework.h"
#include "framework_energy.h"
#include "framework_force.h"
#include "simulation.h"
#include "ewald.h"
#include "potentials.h"
#include "utils.h"
#include "output.h"
#include "cbmc.h"
#include "mc_moves.h"
#include "grids.h"
#include "spacegroup.h"
#include "spectra.h"
#include "molecule.h"
// not used
void CalculateFrameworkFullForce(int m)
{
POINT pos1,pos2;
REAL energy,force_factor,rr;
int i,j,f1,typeA,typeB;
VECTOR dr,f;
UAdsorbateAdsorbateVDW[CurrentSystem]=0.0;
for(i=0;i<Adsorbates[CurrentSystem][m].NumberOfAtoms;i++)
{
pos1=Adsorbates[CurrentSystem][m].Atoms[i].Position;
typeA=Adsorbates[CurrentSystem][m].Atoms[i].Type;
Adsorbates[CurrentSystem][m].Atoms[i].Force.x=0.0;
Adsorbates[CurrentSystem][m].Atoms[i].Force.y=0.0;
Adsorbates[CurrentSystem][m].Atoms[i].Force.z=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
{
pos2=Framework[CurrentSystem].Atoms[f1][j].Position;
dr.x=pos1.x-pos2.x;
dr.y=pos1.y-pos2.y;
dr.z=pos1.z-pos2.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
// energy
UAdsorbateAdsorbateVDW[CurrentSystem]+=energy;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Adsorbates[CurrentSystem][m].Atoms[i].Force.x-=f.x;
Adsorbates[CurrentSystem][m].Atoms[i].Force.y-=f.y;
Adsorbates[CurrentSystem][m].Atoms[i].Force.z-=f.z;
}
}
}
}
}
// Calculate the Energy of a bead of type "typeA" at a position "posA".
// posA is defined in xyz (also for MONOCLINIC).
void CalculateFrameworkForceAtPosition(POINT pos,int typeA,REAL *UVDW,VECTOR *Force,REAL *UCoulomb,VECTOR *CoulombForce)
{
int i,typeB,f1;
REAL rr,chargeA,chargeB;
REAL energy,force_factor,temp;
VECTOR dr;
*UVDW=0.0;
*UCoulomb=0.0;
Force->x=0.0;
Force->y=0.0;
Force->z=0.0;
CoulombForce->x=0.0;
CoulombForce->y=0.0;
CoulombForce->z=0.0;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA]))
{
*UVDW=InterpolateVDWForceGrid(typeA,pos,Force);
if((ChargeMethod!=NONE)&&CoulombGrid)
*UCoulomb=InterpolateCoulombForceGrid(typeA,pos,CoulombForce);
}
else
{
chargeA=PseudoAtoms[typeA].Charge1;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeB=Framework[CurrentSystem].Atoms[f1][i].Type;
dr.x=pos.x-Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition.x;
dr.y=pos.y-Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition.y;
dr.z=pos.z-Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
(*UVDW)+=energy;
Force->x-=force_factor*dr.x;
Force->y-=force_factor*dr.y;
Force->z-=force_factor*dr.z;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x+=force_factor*dr.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y+=force_factor*dr.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z+=force_factor*dr.z;
}
}
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
chargeB=Framework[CurrentSystem].Atoms[f1][i].Charge;
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&temp);
(*UCoulomb)+=energy;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x+=temp*dr.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y+=temp*dr.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z+=temp*dr.z;
}
CoulombForce->x-=temp*dr.x;
CoulombForce->y-=temp*dr.y;
CoulombForce->z-=temp*dr.z;
}
}
}
}
}
void CalculateFrameworkBondForce(void)
{
int i,f1;
REAL r,rr,r1,DF,U;
REAL temp,temp2,exp_term;
REAL *parms;
VECTOR posA,posB,dr,f;
int A,B;
UHostBond[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBonds[f1];i++)
{
A=Framework[CurrentSystem].Bonds[f1][i].A;
B=Framework[CurrentSystem].Bonds[f1][i].B;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
r=sqrt(rr);
parms=(REAL*)&Framework[CurrentSystem].BondArguments[f1][i];
switch(Framework[CurrentSystem].BondType[f1][i])
{
case HARMONIC_BOND:
// 0.5*p0*SQR(r-p1);
// ===============================================
// p_0/k_B [K/A^2] force constant
// p_1 [A] reference bond distance
U=0.5*parms[0]*SQR(r-parms[1]);
DF=parms[0]*(r-parms[1])/r;
break;
case CORE_SHELL_SPRING:
U=0.5*parms[0]*SQR(r);
DF=parms[0];
break;
case MORSE_BOND:
// p_0*[(1.0-{exp(-p_1*(r-p_2))})^2-1.0]
// ===============================================
// p_0/k_B [K] force constant
// p_1 [A^-1] parameter
// p_2 [A] reference bond distance
temp=exp(parms[1]*(parms[2]-r));
U=parms[0]*(SQR(1.0-temp)-1.0);
DF=2.0*parms[0]*parms[1]*(1.0-temp)*temp/r;
break;
case LJ_12_6_BOND:
// A/r_ij^12-B/r_ij^6
// ===============================================
// p_0/k_B [K A^12]
// p_1/k_B [K A^6]
temp=CUBE(1.0/rr);
U=parms[0]*SQR(temp)-parms[1]*temp;
DF=6.0*(parms[1]*temp-2.0*parms[0]*SQR(temp))/rr;
break;
case LENNARD_JONES_BOND:
// 4*p_0*((p_1/r)^12-(p_1/r)^6)
// ===============================================
// p_0/k_B [K]
// p_1 [A]
temp=CUBE(parms[1]/rr);
U=4.0*parms[0]*(temp*(temp-1.0));
DF=24.0*parms[0]*(temp*(1.0-2.0*temp))/rr;
break;
case BUCKINGHAM_BOND:
// p_0*exp(-p_1 r)-p_2/r^6
// ===============================================
// p_0/k_B [K]
// p_1 [A^-1]
// p_2/k_B [K A^6]
temp=parms[2]*CUBE(1.0/rr);
exp_term=parms[0]*exp(-parms[1]*r);
U=-temp+exp_term;
DF=(6.0/rr)*temp-parms[1]*exp_term/r;
break;
case RESTRAINED_HARMONIC_BOND:
// 0.5*p_0*(r-p_1)^2 |r-p_1|<=p_2
// 0.5*p_0*p_2^2+p_0*p_2*(|r-p_1|-p_2) |r-p_1|>p_2
// ===============================================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2 [A]
r1=r-parms[1];
U=0.5*parms[0]*SQR(MIN2(fabs(r1),parms[2]))
+parms[0]*parms[2]*MAX2(fabs(r1)-parms[2],(REAL)0.0);
DF=-parms[0]*(SIGN(MIN2(fabs(r1),parms[2]),r1))/r;
break;
case QUARTIC_BOND:
// (1/2)*p_0*(r-p_1)^2+(1/3)*p_2*(r-p_1)^3+(1/4)*p_3*(r-p_1)^4
// ===========================================================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2/k_B [K/A^3]
// p_3/k_B [K/A^4]
temp=r-parms[1];
temp2=SQR(r-parms[1]);
U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
DF=temp*(parms[0]+parms[2]*temp+parms[3]*temp2)/r;
break;
case CFF_QUARTIC_BOND:
// p_0*(r-p_1)^2+p_2*(r-p_1)^3+p_3*(r-p_1)^4
// ===============================================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2/k_B [K/A^3]
// p_3/k_B [K/A^4]
temp=r-parms[1];
temp2=SQR(r-parms[1]);
U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
DF=temp*(2.0*parms[0]+3.0*parms[2]*temp+4.0*parms[3]*temp2)/r;
break;
case MM3_BOND:
// p_0*(r-p_1)^2*(1.0-2.55*(r-p_1)+(7.0/12.0)*2.55^2*(r-p_1)^2)
// =================================================================
// p_0 [mdyne/A molecule]
// p_1 [A]
temp=r-parms[1];
temp2=SQR(temp);
U=parms[0]*temp2*(1.0-2.55*temp+(7.0/12.0)*SQR(2.55)*temp2);
DF=parms[0]*(2.0+2.55*(4.0*2.55*(7.0/12.0)*temp-3.0)*temp)*temp/r;
break;
case MEASURE_BOND:
U=DF=0.0;
break;
case RIGID_BOND:
U=DF=0.0;
break;
case FIXED_BOND:
U=DF=0.0;
break;
default:
fprintf(stderr, "Undefined Bond potential in routine 'CalculateFrameworkBondForce' ('framework_force.c')\n");
exit(0);
break;
}
// add contribution to the Adsorbate stretch energy
UHostBond[CurrentSystem]+=U;
// forces are oppositely directed to the gradient
f.x=-DF*dr.x;
f.y=-DF*dr.y;
f.z=-DF*dr.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=f.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=f.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;
StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;
StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
}
}
}
}
void CalculateFrameworkUreyBradleyForce(void)
{
int i,f1;
REAL r,rr,r1,DF,U;
REAL temp,temp2,exp_term;
VECTOR dr,f,posA,posC;
REAL *parms;
int A,C;
UHostUreyBradley[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfUreyBradleys[f1];i++)
{
A=Framework[CurrentSystem].UreyBradleys[f1][i].A;
C=Framework[CurrentSystem].UreyBradleys[f1][i].C;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
dr.x=posA.x-posC.x;
dr.y=posA.y-posC.y;
dr.z=posA.z-posC.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
r=sqrt(rr);
parms=(REAL*)&Framework[CurrentSystem].UreyBradleyArguments[f1][i];
switch(Framework[CurrentSystem].UreyBradleyType[f1][i])
{
case HARMONIC_UREYBRADLEY:
// 0.5*p0*SQR(r-p1);
// ===============================================
// p_0/k_B [K/A^2] force constant
// p_1 [A] reference bond distance
U=0.5*parms[0]*SQR(r-parms[1]);
DF=parms[0]*(r-parms[1])/r;
break;
case MORSE_UREYBRADLEY:
// p_0*[(1.0-{exp(-p_1*(r-p_2))})^2-1.0]
// ===============================================
// p_0/k_B [K] force constant
// p_1 [A^-1] parameter
// p_2 [A] reference bond distance
temp=exp(parms[1]*(parms[2]-r));
U=parms[0]*(SQR(1.0-temp)-1.0);
DF=2.0*parms[0]*parms[1]*(1.0-temp)*temp/r;
break;
case LJ_12_6_UREYBRADLEY:
// A/r_ij^12-B/r_ij^6
// ===============================================
// p_0/k_B [K A^12]
// p_1/k_B [K A^6]
temp=CUBE(1.0/rr);
U=parms[0]*SQR(temp)-parms[1]*temp;
DF=6.0*(parms[1]*temp-2.0*parms[0]*SQR(temp))/rr;
break;
case LENNARD_JONES_UREYBRADLEY:
// 4*p_0*((p_1/r)^12-(p_1/r)^6)
// ===============================================
// p_0/k_B [K]
// p_1 [A]
temp=CUBE(parms[1]/rr);
U=4.0*parms[0]*(temp*(temp-1.0));
DF=24.0*parms[0]*(temp*(1.0-2.0*temp))/rr;
break;
case BUCKINGHAM_UREYBRADLEY:
// p_0*exp(-p_1 r)-p_2/r^6
// ===============================================
// p_0/k_B [K]
// p_1 [A^-1]
// p_2/k_B [K A^6]
temp=parms[2]*CUBE(1.0/rr);
exp_term=parms[0]*exp(-parms[1]*r);
U=-temp+exp_term;
DF=(6.0/rr)*temp-parms[1]*exp_term/r;
break;
case RESTRAINED_HARMONIC_UREYBRADLEY:
// 0.5*p_0*(r-p_1)^2 |r-p_1|<=p_2
// 0.5*p_0*p_2^2+p_0*p_2*(|r-p_1|-p_2) |r-p_1|>p_2
// ===============================================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2 [A]
r1=r-parms[1];
U=0.5*parms[0]*SQR(MIN2(fabs(r1),parms[2]))
+parms[0]*parms[2]*MAX2(fabs(r1)-parms[2],(REAL)0.0);
DF=-parms[0]*(SIGN(MIN2(fabs(r1),parms[2]),r1))/r;
break;
case QUARTIC_UREYBRADLEY:
// (1/2)*p_0*(r-p_1)^2+(1/3)*p_2*(r-p_1)^3+(1/4)*p_3*(r-p_1)^4
// ===========================================================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2/k_B [K/A^3]
// p_3/k_B [K/A^4]
temp=r-parms[1];
temp2=SQR(r-parms[1]);
U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
DF=temp*(parms[0]+parms[2]*temp+parms[3]*temp2)/r;
break;
case CFF_QUARTIC_UREYBRADLEY:
// p_0*(r-p_1)^2+p_2*(r-p_1)^3+p_3*(r-p_1)^4
// ===============================================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2/k_B [K/A^3]
// p_3/k_B [K/A^4]
temp=r-parms[1];
temp2=SQR(r-parms[1]);
U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
DF=temp*(2.0*parms[0]+3.0*parms[2]*temp+4.0*parms[3]*temp2)/r;
break;
case MM3_UREYBRADLEY:
// p_0*(r-p_1)^2*(1.0-2.55*(r-p_1)+(7.0/12.0)*2.55^2*(r-p_1)^2)
// =================================================================
// p_0 [mdyne/A molecule]
// p_1 [A]
temp=r-parms[1];
temp2=SQR(temp);
U=parms[0]*temp2*(1.0-2.55*temp+(7.0/12.0)*SQR(2.55)*temp2);
DF=parms[0]*(2.0+2.55*(4.0*2.55*(7.0/12.0)*temp-3.0)*temp)*temp/r;
break;
case RIGID_UREYBRADLEY:
U=DF=0.0;
break;
case FIXED_UREYBRADLEY:
U=DF=0.0;
break;
default:
fprintf(stderr, "Undefined Urey-Bradley potential in routine 'CalculateFrameworkUreyBradleyForce' ('framework_force.c')\n");
exit(0);
break;
}
// add contribution to the Adsorbate Urey-Bradley energy
UHostUreyBradley[CurrentSystem]+=U;
// forces are oppositely directed to the gradient
f.x=-DF*dr.x;
f.y=-DF*dr.y;
f.z=-DF*dr.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=f.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z-=f.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;
StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;
StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
}
}
}
}
void CalculateFrameworkBendForce(void)
{
int i,A,B,C,D,f1;
REAL *parms,DF,U,temp,temp2;
REAL CosTheta,Theta,SinTheta;
REAL rab,rbc,rac,DTDX;
VECTOR posA,posB,posC,posD;
VECTOR Rab,Rbc,Rac,fa,fb,fc,dtA,dtB,dtC;;
VECTOR Rad,Rbd,Rcd,t,ip,ap,cp;
REAL rt2,rap2,rcp2;
REAL terma,termc,delta,delta2,rm,ptrt2,term;
VECTOR dpdia,dpdic,m,dedip,fd;
Rab.x=Rab.y=Rab.z=0.0;
Rad.x=Rad.y=Rad.z=0.0;
Rcd.x=Rcd.y=Rcd.z=0.0;
Rbd.x=Rbd.y=Rbd.z=0.0;
Rbc.x=Rbc.y=Rbc.z=0.0;
ap.x=ap.y=ap.z=0.0;
cp.x=cp.y=cp.z=0.0;
t.x=t.y=t.z=0.0;
delta=rcp2=rap2=rt2=0.0;
rbc=rab=temp=0.0;
UHostBend[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBends[f1];i++)
{
A=Framework[CurrentSystem].Bends[f1][i].A;
B=Framework[CurrentSystem].Bends[f1][i].B;
C=Framework[CurrentSystem].Bends[f1][i].C;
D=Framework[CurrentSystem].Bends[f1][i].D;
parms=Framework[CurrentSystem].BendArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][D].Position;
switch(Framework[CurrentSystem].BendType[f1][i])
{
case MM3_IN_PLANE_BEND:
Rad.x=posA.x-posD.x;
Rad.y=posA.y-posD.y;
Rad.z=posA.z-posD.z;
Rad=ApplyBoundaryCondition(Rad);
Rbd.x=posB.x-posD.x;
Rbd.y=posB.y-posD.y;
Rbd.z=posB.z-posD.z;
Rbd=ApplyBoundaryCondition(Rbd);
Rcd.x=posC.x-posD.x;
Rcd.y=posC.y-posD.y;
Rcd.z=posC.z-posD.z;
Rcd=ApplyBoundaryCondition(Rcd);
t.x=Rad.y*Rcd.z-Rad.z*Rcd.y;
t.y=Rad.z*Rcd.x-Rad.x*Rcd.z;
t.z=Rad.x*Rcd.y-Rad.y*Rcd.x;
rt2=t.x*t.x+t.y*t.y+t.z*t.z;
delta=-(t.x*Rbd.x+t.y*Rbd.y+t.z*Rbd.z)/rt2;
ip.x=posB.x+t.x*delta;
ip.y=posB.y+t.y*delta;
ip.z=posB.z+t.z*delta;
ap.x=posA.x-ip.x;
ap.y=posA.y-ip.y;
ap.z=posA.z-ip.z;
cp.x=posC.x-ip.x;
cp.y=posC.y-ip.y;
cp.z=posC.z-ip.z;
ap=ApplyBoundaryCondition(ap);
cp=ApplyBoundaryCondition(cp);
rap2=ap.x*ap.x+ap.y*ap.y+ap.z*ap.z;
rcp2=cp.x*cp.x+cp.y*cp.y+cp.z*cp.z;
CosTheta=(ap.x*cp.x+ap.y*cp.y+ap.z*cp.z)/sqrt(rap2*rcp2);
break;
default:
Rab.x=posA.x-posB.x;
Rab.y=posA.y-posB.y;
Rab.z=posA.z-posB.z;
Rab=ApplyBoundaryCondition(Rab);
rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
Rab.x/=rab;
Rab.y/=rab;
Rab.z/=rab;
Rbc.x=posC.x-posB.x;
Rbc.y=posC.y-posB.y;
Rbc.z=posC.z-posB.z;
Rbc=ApplyBoundaryCondition(Rbc);
rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
Rbc.x/=rbc;
Rbc.y/=rbc;
Rbc.z/=rbc;
Rac.x=posC.x-posA.x;
Rac.y=posC.y-posA.y;
Rac.z=posC.z-posA.z;
Rac=ApplyBoundaryCondition(Rac);
rac=sqrt(SQR(Rac.x)+SQR(Rac.y)+SQR(Rac.z));
Rac.x/=rac;
Rac.y/=rac;
Rac.z/=rac;
CosTheta=(Rab.x*Rbc.x+Rab.y*Rbc.y+Rab.z*Rbc.z);
break;
}
CosTheta=MIN2(1.0,MAX2(-1.0,CosTheta));
Theta=acos(CosTheta);
SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));
DTDX=-1.0/sqrt(1.0-SQR(CosTheta));
parms=Framework[CurrentSystem].BendArguments[f1][i];
switch(Framework[CurrentSystem].BendType[f1][i])
{
case HARMONIC_BEND:
// (1/2)p_0*(theta-p_1)^2
// ===============================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
U=0.5*parms[0]*SQR(Theta-parms[1]);
DF=parms[0]*(Theta-parms[1])*DTDX;
break;
case CORE_SHELL_BEND:
// (1/2)p_0*(theta-p_1)^2
// ===============================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
U=0.5*parms[0]*SQR(Theta-parms[1]);
DF=parms[0]*(Theta-parms[1])*DTDX;
break;
case QUARTIC_BEND:
// (1/2)p_0*(theta-p_1)^2+(1/3)*p_2*(theta-p_1)^3+(1/4)*p_2*(theta-p_1)^4
// ======================================================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// p_2/k_B [K/rad^3]
// p_3/k_B [K/rad^4]
temp=(Theta-parms[1]);
temp2=SQR(temp);
U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
DF=(parms[0]*temp+parms[2]*temp2+parms[3]*temp*temp2)*DTDX;
break;
case CFF_QUARTIC_BEND:
// p_0*(theta-p_1)^2+p_2*(theta-p_1)^3+p_3*(theta-p_1)^4
// =====================================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// p_2/k_B [K/rad^3]
// p_3/k_B [K/rad^4]
temp=(Theta-parms[1]);
temp2=SQR(temp);
U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
DF=(2.0*parms[0]*temp+3.0*parms[2]*temp2+4.0*parms[3]*temp*temp2)*DTDX;
break;
case HARMONIC_COSINE_BEND:
// (1/2)*p_0*(cos(theta)-cos(p_1))^2
// ===============================================
// p_0/k_B [K]
// p_1 [degrees]
U=0.5*parms[0]*SQR(CosTheta-parms[1]);
DF=parms[0]*(CosTheta-parms[1]);
break;
case COSINE_BEND:
// p_0*(1+cos(p_1*theta-p_2))
// ===============================================
// p_0/k_B [K]
// p_1 [-]
// p_2 [degrees]
temp=parms[1]*Theta-parms[2];
U=parms[0]*(1.0+cos(temp));
DF=-(parms[0]*parms[1]*sin(temp))*DTDX;
break;
case TAFIPOLSKY_BEND:
// 0.5*p_0*(1+cos(theta))*(1+cos(2*theta))
// ===============================================
// p_0/k_B [K]
U=0.5*parms[0]*(1.0+cos(Theta))*(1.0+cos(2.0*Theta));
DF=parms[0]*CosTheta*(2.0+3.0*CosTheta);
break;
case MM3_BEND:
case MM3_IN_PLANE_BEND:
// p_0*(theta-p_1)^2(1-0.014*(theta-p_1)+5.6e-5*(theta-p_1)^2-7e-7*(theta-p_1)^3+2.2e-8(theta-p_1)^4)
// =================================================================================================
// p_0/k_B [mdyne A/rad^2]
// p_1 [degrees]
U=DF=0;
temp=RAD2DEG*(Theta-parms[1]);
temp2=SQR(temp);
U=parms[0]*temp2*(1.0-0.014*temp+5.6e-5*temp2-7.0e-7*temp*temp2+2.2e-8*SQR(temp2));
DF=parms[0]*RAD2DEG*(2.0-(3.0*0.014-(4.0*5.6e-5-(5.0*7.0e-7-6.0*2.2e-8*temp)*temp)*temp)*temp)*temp*DTDX;
break;
case FIXED_BEND:
U=DF=0.0;
break;
case MEASURE_BEND:
U=DF=0.0;
break;
default:
fprintf(stderr, "Undefined Bend potential in routine 'CalculateFrameworkBendForce' ('framework_force.c')\n");
exit(0);
break;
}
// add contribution to the energy
UHostBend[CurrentSystem]+=U;
switch(Framework[CurrentSystem].BendType[f1][i])
{
case MM3_IN_PLANE_BEND:
DF=parms[0]*RAD2DEG*(2.0-(3.0*0.014-(4.0*5.6e-5-(5.0*7.0e-7-6.0*2.2e-8*temp)*temp)*temp)*temp)*temp;
m.x=cp.y*ap.z-cp.z*ap.y;
m.y=cp.z*ap.x-cp.x*ap.z;
m.z=cp.x*ap.y-cp.y*ap.x;
rm=sqrt(m.x*m.x+m.y*m.y+m.z*m.z);
rm=MAX2(rm,0.000001);
terma=-DF/(rap2*rm);
termc=DF/(rcp2*rm);
fa.x=terma*(ap.y*m.z-ap.z*m.y);
fa.y=terma*(ap.z*m.x-ap.x*m.z);
fa.z=terma*(ap.x*m.y-ap.y*m.x);
fc.x=termc*(cp.y*m.z-cp.z*m.y);
fc.y=termc*(cp.z*m.x-cp.x*m.z);
fc.z=termc*(cp.x*m.y-cp.y*m.x);
dedip.x=-(fa.x+fc.x);
dedip.y=-(fa.y+fc.y);
dedip.z=-(fa.z+fc.z);
delta2=2.0*delta;
ptrt2=(dedip.x*t.x+dedip.y*t.y+dedip.z*t.z)/rt2;
term=(Rcd.z*Rbd.y-Rcd.y*Rbd.z)+delta2*(t.y*Rcd.z-t.z*Rcd.y);
dpdia.x=delta*(Rcd.y*dedip.z-Rcd.z*dedip.y)+term*ptrt2;
term=(Rcd.x*Rbd.z-Rcd.z*Rbd.x)+delta2*(t.z*Rcd.x-t.x*Rcd.z);
dpdia.y=delta*(Rcd.z*dedip.x-Rcd.x*dedip.z)+term*ptrt2;
term=(Rcd.y*Rbd.x-Rcd.x*Rbd.y)+delta2*(t.x*Rcd.y-t.y*Rcd.x);
dpdia.z=delta*(Rcd.x*dedip.y-Rcd.y*dedip.x)+term*ptrt2;
term=(Rad.y*Rbd.z-Rad.z*Rbd.y)+delta2*(t.z*Rad.y-t.y*Rad.z);
dpdic.x=delta*(Rad.z*dedip.y-Rad.y*dedip.z)+term*ptrt2;
term=(Rad.z*Rbd.x-Rad.x*Rbd.z)+delta2*(t.x*Rad.z-t.z*Rad.x);
dpdic.y=delta*(Rad.x*dedip.z-Rad.z*dedip.x)+term*ptrt2;
term=(Rad.x*Rbd.y-Rad.y*Rbd.x)+delta2*(t.y*Rad.x-t.x*Rad.y);
dpdic.z=delta*(Rad.y*dedip.x-Rad.x*dedip.y)+term*ptrt2;
fa.x=fa.x+dpdia.x;
fa.y=fa.y+dpdia.y;
fa.z=fa.z+dpdia.z;
fb.x=dedip.x;
fb.y=dedip.y;
fb.z=dedip.z;
fc.x=fc.x+dpdic.x;
fc.y=fc.y+dpdic.y;
fc.z=fc.z+dpdic.z;
fd.x=-(fa.x+fb.x+fc.x);
fd.y=-(fa.y+fb.y+fc.y);
fd.z=-(fa.z+fb.z+fc.z);
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=fb.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x-=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y-=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z-=fc.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x-=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y-=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z-=fd.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax+=Rad.x*fa.x+Rbd.x*fb.x+Rcd.x*fc.x;
StrainDerivativeTensor[CurrentSystem].bx+=Rad.y*fa.x+Rbd.y*fb.x+Rcd.y*fc.x;
StrainDerivativeTensor[CurrentSystem].cx+=Rad.z*fa.x+Rbd.z*fb.x+Rcd.z*fc.x;
StrainDerivativeTensor[CurrentSystem].ay+=Rad.x*fa.y+Rbd.x*fb.y+Rcd.x*fc.y;
StrainDerivativeTensor[CurrentSystem].by+=Rad.y*fa.y+Rbd.y*fb.y+Rcd.y*fc.y;
StrainDerivativeTensor[CurrentSystem].cy+=Rad.z*fa.y+Rbd.z*fb.y+Rcd.z*fc.y;
StrainDerivativeTensor[CurrentSystem].az+=Rad.x*fa.z+Rbd.x*fb.z+Rcd.x*fc.z;
StrainDerivativeTensor[CurrentSystem].bz+=Rad.y*fa.z+Rbd.y*fb.z+Rcd.y*fc.z;
StrainDerivativeTensor[CurrentSystem].cz+=Rad.z*fa.z+Rbd.z*fb.z+Rcd.z*fc.z;
break;
default:
// Calculate the components of the derivatives.
dtA.x=(Rbc.x-CosTheta*Rab.x)/rab;
dtA.y=(Rbc.y-CosTheta*Rab.y)/rab;
dtA.z=(Rbc.z-CosTheta*Rab.z)/rab;
dtC.x=(Rab.x-CosTheta*Rbc.x)/rbc;
dtC.y=(Rab.y-CosTheta*Rbc.y)/rbc;
dtC.z=(Rab.z-CosTheta*Rbc.z)/rbc;
dtB.x=-(dtA.x+dtC.x);
dtB.y=-(dtA.y+dtC.y);
dtB.z=-(dtA.z+dtC.z);
// forces are oppositely directed to the gradient
fa.x=-DF*dtA.x;
fa.y=-DF*dtA.y;
fa.z=-DF*dtA.z;
fb.x=-DF*dtB.x;
fb.y=-DF*dtB.y;
fb.z=-DF*dtB.z;
fc.x=-DF*dtC.x;
fc.y=-DF*dtC.y;
fc.z=-DF*dtC.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=(fa.x+fc.x);
Framework[CurrentSystem].Atoms[f1][B].Force.y-=(fa.y+fc.y);
Framework[CurrentSystem].Atoms[f1][B].Force.z-=(fa.z+fc.z);
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
// add contribution to the stress tensor
// Note: rab and rbc are here because the vectors were normalized before
StrainDerivativeTensor[CurrentSystem].ax-=rab*Rab.x*fa.x+rbc*Rbc.x*fc.x;
StrainDerivativeTensor[CurrentSystem].bx-=rab*Rab.y*fa.x+rbc*Rbc.y*fc.x;
StrainDerivativeTensor[CurrentSystem].cx-=rab*Rab.z*fa.x+rbc*Rbc.z*fc.x;
StrainDerivativeTensor[CurrentSystem].ay-=rab*Rab.x*fa.y+rbc*Rbc.x*fc.y;
StrainDerivativeTensor[CurrentSystem].by-=rab*Rab.y*fa.y+rbc*Rbc.y*fc.y;
StrainDerivativeTensor[CurrentSystem].cy-=rab*Rab.z*fa.y+rbc*Rbc.z*fc.y;
StrainDerivativeTensor[CurrentSystem].az-=rab*Rab.x*fa.z+rbc*Rbc.x*fc.z;
StrainDerivativeTensor[CurrentSystem].bz-=rab*Rab.y*fa.z+rbc*Rbc.y*fc.z;
StrainDerivativeTensor[CurrentSystem].cz-=rab*Rab.z*fa.z+rbc*Rbc.z*fc.z;
break;
}
}
}
}
}
void CalculateFrameworkInversionBendForce(void)
{
int i,A,B,C,D,f1;
REAL *parms;
REAL c,e;
REAL rrab,rab2,rrbc,rbc2,rbd2,rad2,rac2,dot;
REAL CosChi,Chi,energy;
REAL temp,temp2;
VECTOR Rab,Rbc,Rbd,Rad,Rac;
POINT posA,posB,posC,posD;
VECTOR fa,fb,fc,fd;
REAL term,dedcos;
VECTOR dccdia,dccdic,dccdid;
VECTOR deedia,deedic,deedid;
UHostInversionBend[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfInversionBends[f1];i++)
{
A=Framework[CurrentSystem].InversionBends[f1][i].A;
B=Framework[CurrentSystem].InversionBends[f1][i].B;
C=Framework[CurrentSystem].InversionBends[f1][i].C;
D=Framework[CurrentSystem].InversionBends[f1][i].D;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][D].Position;
Rab.x=posA.x-posB.x;
Rab.y=posA.y-posB.y;
Rab.z=posA.z-posB.z;
Rab=ApplyBoundaryCondition(Rab);
rab2=Rab.x*Rab.x+Rab.y*Rab.y+Rab.z*Rab.z;
rrab=sqrt(rab2);
Rbc.x=posC.x-posB.x;
Rbc.y=posC.y-posB.y;
Rbc.z=posC.z-posB.z;
Rbc=ApplyBoundaryCondition(Rbc);
rbc2=Rbc.x*Rbc.x+Rbc.y*Rbc.y+Rbc.z*Rbc.z;
rrbc=sqrt(rbc2);
Rbd.x=posD.x-posB.x;
Rbd.y=posD.y-posB.y;
Rbd.z=posD.z-posB.z;
Rbd=ApplyBoundaryCondition(Rbd);
rbd2=Rbd.x*Rbd.x+Rbd.y*Rbd.y+Rbd.z*Rbd.z;
Rac.x=posC.x-posA.x;
Rac.y=posC.y-posA.y;
Rac.z=posC.z-posA.z;
Rac=ApplyBoundaryCondition(Rac);
rac2=Rac.x*Rac.x+Rac.y*Rac.y+Rac.z*Rac.z;
Rad.x=posD.x-posA.x;
Rad.y=posD.y-posA.y;
Rad.z=posD.z-posA.z;
Rad=ApplyBoundaryCondition(Rad);
rad2=Rad.x*Rad.x+Rad.y*Rad.y+Rad.z*Rad.z;
switch(Framework[CurrentSystem].InversionBendType[f1][i])
{
case HARMONIC_INVERSION:
case HARMONIC_COSINE_INVERSION:
case PLANAR_INVERSION:
// w is a vector perpendicular to the B-C-D plane
// c=w.w=(Rbc x Rbd).(Rbc x Rbd)= r_bc^2 r_bd^2 - (r_cb . r_bd)^2
dot=Rbc.x*Rbd.x+Rbc.y*Rbd.y+Rbc.z*Rbd.z;
c=rbc2*rbd2-SQR(dot);
//c=(Rbc.x*Rbc.x+Rbc.y*Rbc.y+Rbc.z*Rbc.z)*(Rbd.x*Rbd.x+Rbd.y*Rbd.y+Rbd.z*Rbd.z)-SQR(Rbc.x*Rbd.x+Rbc.y*Rbd.y+Rbc.z*Rbd.z);
break;
case MM3_INVERSION:
case HARMONIC_INVERSION2:
case HARMONIC_COSINE_INVERSION2:
case PLANAR_INVERSION2:
// w is a vector perpendicular to the A-C-D plane
// c=w.w=(Rcd x Rad).(Rcd x Rad)=r_cd^2 r_ad^2 - (r_da . r_cd)^2
dot=Rac.x*Rad.x+Rac.y*Rad.y+Rac.z*Rad.z;
c=rac2*rad2-SQR(dot);
//c=(Rcd.x*Rcd.x+Rcd.y*Rcd.y+Rcd.z*Rcd.z)*(Rad.x*Rad.x+Rad.y*Rad.y+Rad.z*Rad.z)-SQR(Rad.x*Rcd.x+Rad.y*Rcd.y+Rad.z*Rcd.z);
break;
default:
fprintf(stderr, "Undefined Inversion-Bend potential in routine 'CalculateFrameworkInversionBendEnergy' ('framework_energy.c')\n");
exit(0);
break;
}
e=Rab.x*(Rbc.y*Rbd.z-Rbc.z*Rbd.y)+Rab.y*(Rbc.z*Rbd.x-Rbc.x*Rbd.z)+Rab.z*(Rbc.x*Rbd.y-Rbc.y*Rbd.x);
CosChi=sqrt((Rab.x*Rab.x+Rab.y*Rab.y+Rab.z*Rab.z)-SQR(e)/c)/rrab;
// Ensure CosChi is between -1 and 1.
CosChi=SIGN(MIN2(fabs(CosChi),(REAL)1.0),CosChi);
parms=Framework[CurrentSystem].InversionBendArguments[f1][i];
switch(Framework[CurrentSystem].InversionBendType[f1][i])
{
case HARMONIC_INVERSION:
case HARMONIC_INVERSION2:
// (1/2)*p_0*(chi-p_1)^2
// ===============================================
// p_0/k_B [K]
// p_1 [degrees]
Chi=acos(CosChi);
energy=0.5*parms[0]*SQR(Chi-parms[1]);
dedcos=-SIGN(1.0,e)*(parms[0]*(Chi-parms[1])/sqrt(c*(rab2-e*e/c)));
break;
case HARMONIC_COSINE_INVERSION:
case HARMONIC_COSINE_INVERSION2:
// (1/2)*p_0*(cos(phi)-cos(p_1))^2
// ===============================================
// p_0/k_B [K]
// p_1 [degrees]
Chi=acos(CosChi);
energy=0.5*parms[0]*SQR(CosChi-parms[1]);
dedcos=SIGN(1.0,e)*parms[0]*(CosChi-parms[1])*sin(Chi)/sqrt(c*(rab2-e*e/c));
break;
case PLANAR_INVERSION:
case PLANAR_INVERSION2:
// (1/2)*p_0*(1-cos(phi))
// ===============================================
// p_0/k_B [K]
Chi=acos(CosChi);
energy=parms[0]*(1.0-CosChi);
dedcos=-SIGN(1.0,e)*parms[0]*sin(Chi)/sqrt(c*(rab2-e*e/c));
break;
case MM3_INVERSION:
// p_0*(chi-p_1)^2(1-0.014*(chi-p_1)+5.6e-5*(chi-p_1)^2-7e-7*(chi-p_1)^3+2.2e-8(chi-p_1)^4)
// =================================================================================================
// p_0/k_B [mdyne A/rad^2]
// p_1 [degrees]
Chi=acos(CosChi);
temp=RAD2DEG*(Chi-parms[1]);
temp2=SQR(temp);
energy=parms[0]*temp2*(1.0-0.014*temp+5.6e-5*temp2-7.0e-7*temp*temp2+2.2e-8*SQR(temp2));
dedcos=-SIGN(1.0,e)*parms[0]*temp*RAD2DEG*(2.0-3.0*0.014*temp+4.0*5.6e-5*temp2-5.0*7.0e-7*temp*temp2+6.0*2.2e-8*SQR(temp2))/sqrt(c*(rab2-e*e/c));
break;
default:
fprintf(stderr, "Undefined Inversion-Bend potential in routine 'CalculateFrameworkInversionBendEnergy' ('framework_energy.c')\n");
exit(0);
break;
}
// energy
UHostInversionBend[CurrentSystem]+=energy;
switch(Framework[CurrentSystem].InversionBendType[f1][i])
{
case HARMONIC_COSINE_INVERSION:
case PLANAR_INVERSION:
case HARMONIC_INVERSION:
term=e/c;
dccdia.x=0.0;
dccdia.y=0.0;
dccdia.z=0.0;
dccdic.x=(Rbc.x*rbd2-Rbd.x*dot)*term;
dccdic.y=(Rbc.y*rbd2-Rbd.y*dot)*term;
dccdic.z=(Rbc.z*rbd2-Rbd.z*dot)*term;
dccdid.x=(Rbd.x*rbc2-Rbc.x*dot)*term;
dccdid.y=(Rbd.y*rbc2-Rbc.y*dot)*term;
dccdid.z=(Rbd.z*rbc2-Rbc.z*dot)*term;
break;
case HARMONIC_INVERSION2:
case HARMONIC_COSINE_INVERSION2:
case PLANAR_INVERSION2:
case MM3_INVERSION:
term=e/c;
dccdic.x=(Rac.x*rad2-Rad.x*dot)*term;
dccdic.y=(Rac.y*rad2-Rad.y*dot)*term;
dccdic.z=(Rac.z*rad2-Rad.z*dot)*term;
dccdid.x=(Rad.x*rac2-Rac.x*dot)*term;
dccdid.y=(Rad.y*rac2-Rac.y*dot)*term;
dccdid.z=(Rad.z*rac2-Rac.z*dot)*term;
dccdia.x=-(dccdic.x+dccdid.x);
dccdia.y=-(dccdic.y+dccdid.y);
dccdia.z=-(dccdic.z+dccdid.z);
break;
default:
fprintf(stderr, "Undefined Inversion-Bend potential in routine 'CalculateFrameworkInversionBendEnergy' ('framework_energy.c')\n");
exit(0);
break;
}
term=e/rab2;
deedia.x=Rbd.y*Rbc.z-Rbd.z*Rbc.y+Rab.x*term;
deedia.y=Rbd.z*Rbc.x-Rbd.x*Rbc.z+Rab.y*term;
deedia.z=Rbd.x*Rbc.y-Rbd.y*Rbc.x+Rab.z*term;
deedic.x=Rab.y*Rbd.z-Rab.z*Rbd.y;
deedic.y=Rab.z*Rbd.x-Rab.x*Rbd.z;
deedic.z=Rab.x*Rbd.y-Rab.y*Rbd.x;
deedid.x=Rbc.y*Rab.z-Rbc.z*Rab.y;
deedid.y=Rbc.z*Rab.x-Rbc.x*Rab.z;
deedid.z=Rbc.x*Rab.y-Rbc.y*Rab.x;
fa.x=dedcos*(dccdia.x+deedia.x);
fa.y=dedcos*(dccdia.y+deedia.y);
fa.z=dedcos*(dccdia.z+deedia.z);
fc.x=dedcos*(dccdic.x+deedic.x);
fc.y=dedcos*(dccdic.y+deedic.y);
fc.z=dedcos*(dccdic.z+deedic.z);
fd.x=dedcos*(dccdid.x+deedid.x);
fd.y=dedcos*(dccdid.y+deedid.y);
fd.z=dedcos*(dccdid.z+deedid.z);
fb.x=-(fa.x+fc.x+fd.x);
fb.y=-(fa.y+fc.y+fd.y);
fb.z=-(fa.z+fc.z+fd.z);
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=fb.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x-=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y-=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z-=fc.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x-=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y-=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z-=fd.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax+=Rab.x*fa.x+Rbc.x*fc.x+Rbd.x*fd.x;
StrainDerivativeTensor[CurrentSystem].ay+=Rab.x*fa.y+Rbc.x*fc.y+Rbd.x*fd.y;
StrainDerivativeTensor[CurrentSystem].az+=Rab.x*fa.z+Rbc.x*fc.z+Rbd.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bx+=Rab.y*fa.x+Rbc.y*fc.x+Rbd.y*fd.x;
StrainDerivativeTensor[CurrentSystem].by+=Rab.y*fa.y+Rbc.y*fc.y+Rbd.y*fd.y;
StrainDerivativeTensor[CurrentSystem].bz+=Rab.y*fa.z+Rbc.y*fc.z+Rbd.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cx+=Rab.z*fa.x+Rbc.z*fc.x+Rbd.z*fd.x;
StrainDerivativeTensor[CurrentSystem].cy+=Rab.z*fa.y+Rbc.z*fc.y+Rbd.z*fd.y;
StrainDerivativeTensor[CurrentSystem].cz+=Rab.z*fa.z+Rbc.z*fc.z+Rbd.z*fd.z;
}
}
}
}
void CalculateFrameworkTorsionForce(void)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL d,e,rbc,U,DF;
VECTOR Dab,Dcb,Ddc,dr,ds;
REAL dot_ab,dot_cd,r,s,sign;
REAL CosPhi,Phi,CosPhi2,SinPhi;
REAL ShiftedCosPhi,ShiftedCosPhi2,ShiftedSinPhi;
VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
VECTOR fa,fb,fc,fd;
REAL *parms;
UHostTorsion[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
{
A=Framework[CurrentSystem].Torsions[f1][i].A;
B=Framework[CurrentSystem].Torsions[f1][i].B;
C=Framework[CurrentSystem].Torsions[f1][i].C;
D=Framework[CurrentSystem].Torsions[f1][i].D;
parms=Framework[CurrentSystem].TorsionArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][D].Position;
Dab.x=posA.x-posB.x;
Dab.y=posA.y-posB.y;
Dab.z=posA.z-posB.z;
Dab=ApplyBoundaryCondition(Dab);
Dcb.x=posC.x-posB.x;
Dcb.y=posC.y-posB.y;
Dcb.z=posC.z-posB.z;
Dcb=ApplyBoundaryCondition(Dcb);
rbc=sqrt(SQR(Dcb.x)+SQR(Dcb.y)+SQR(Dcb.z));
Dcb.x/=rbc; Dcb.y/=rbc; Dcb.z/=rbc;
Ddc.x=posD.x-posC.x;
Ddc.y=posD.y-posC.y;
Ddc.z=posD.z-posC.z;
Ddc=ApplyBoundaryCondition(Ddc);
dot_ab=Dab.x*Dcb.x+Dab.y*Dcb.y+Dab.z*Dcb.z;
dot_cd=Ddc.x*Dcb.x+Ddc.y*Dcb.y+Ddc.z*Dcb.z;
dr.x=Dab.x-dot_ab*Dcb.x;
dr.y=Dab.y-dot_ab*Dcb.y;
dr.z=Dab.z-dot_ab*Dcb.z;
r=MAX2((REAL)1.0e-8,sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z)));
dr.x/=r; dr.y/=r; dr.z/=r;
ds.x=Ddc.x-dot_cd*Dcb.x;
ds.y=Ddc.y-dot_cd*Dcb.y;
ds.z=Ddc.z-dot_cd*Dcb.z;
s=MAX2((REAL)1.0e-8,sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z)));
ds.x/=s; ds.y/=s; ds.z/=s;
// compute Cos(Phi)
// Phi is defined in protein convention Phi(trans)=Pi
CosPhi=dr.x*ds.x+dr.y*ds.y+dr.z*ds.z;
// Ensure CosPhi is between -1 and 1.
CosPhi=SIGN(MIN2(fabs(CosPhi),(REAL)1.0),CosPhi);
CosPhi2=SQR(CosPhi);
switch(Framework[CurrentSystem].TorsionType[f1][i])
{
case HARMONIC_DIHEDRAL:
// (1/2)*p_0*(phi-p_1)^2
// ===============================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// potential defined in terms of 'phi' and therefore contains a singularity
// the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
// same direction as Rbc, and negative otherwise
Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
+Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
Phi=SIGN(acos(CosPhi),sign);
SinPhi=sin(Phi);
Phi-=parms[1];
Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
U=0.5*parms[0]*SQR(Phi);
DF=-parms[0]*Phi/SinPhi;
break;
case HARMONIC_COSINE_DIHEDRAL:
// (1/2)*p_0*(cos(phi)-cos(p_1))^2
// ===============================================
// p_0/k_B [K]
// p_1 [degrees]
U=0.5*parms[0]*SQR(CosPhi-parms[1]);
DF=parms[0]*(CosPhi-parms[1]);
break;
case THREE_COSINE_DIHEDRAL:
// (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
// ========================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
break;
case MM3_DIHEDRAL:
// (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
// ========================================================================
// p_0 [kcal/mol]
// p_1 [kcal/mol]
// p_2 [kcal/mol]
U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
break;
case CVFF_BLOCKED_DIHEDRAL:
//
// ========================================================================
// p_0 [rad]
// p_1 [K]
// p_2 [-]
// p_3 [rad]
// p_4 [rad]
U=0.0;
DF=0.0;
break;
case CFF_DIHEDRAL:
// p_0*(1-cos(phi))+p_1*(1-cos(2*phi))+p_2*(1-cos(3*phi))
// ======================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
U=parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2);
DF=-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2);
break;
case CFF_DIHEDRAL2:
// p_0*(1+cos(phi))+p_1*(1+cos(2*phi))+p_2*(1+cos(3*phi))
// ======================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
U=parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi));
DF=parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi);
break;
case SIX_COSINE_DIHEDRAL:
// Prod_i=0^5 p_i*cos(phi)^i
// =========================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
// p_5/k_B [K]
// the Ryckaert-Bellemans potentials is often used for alkanes, the use implies exclusion of VDW-interactions
// between the first and last atoms of the dihedral, and Phi'=Phi-pi is defined accoording to the
// polymer convention Phi'(trans)=0.
U=parms[0]-parms[1]*CosPhi+parms[2]*CosPhi2-parms[3]*CosPhi*CosPhi2+
parms[4]*SQR(CosPhi2)-parms[5]*SQR(CosPhi2)*CosPhi;
DF=-parms[1]+2.0*parms[2]*CosPhi-3.0*parms[3]*CosPhi2+4.0*parms[4]*CosPhi2*CosPhi-5.0*parms[5]*SQR(CosPhi2);
break;
case TRAPPE_DIHEDRAL:
// p_0+p_1*(1+cos(phi))+p_2*(1-cos(2*phi))+p_3*(1+cos(3*phi))
// ==========================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
U=parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi));
DF=parms[1]-4.0*parms[2]*CosPhi+3.0*parms[3]*(4.0*CosPhi2-1.0);
break;
case TRAPPE_DIHEDRAL_EXTENDED:
// p_0+p_1*cos(phi)+p_2*cos(2*phi)+p_3*cos(3*phi)+p_4*cos(4*phi)
// =============================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
U=parms[0]-parms[2]+parms[4]+(parms[1]-3.0*parms[3])*CosPhi+(2.0*parms[2]-8.0*parms[4])*CosPhi2+4.0*parms[3]*CosPhi2*CosPhi+8.0*parms[4]*SQR(CosPhi2);
DF=parms[1]-3.0*parms[3]+4.0*(parms[2]-4.0*parms[4])*CosPhi+12.0*parms[3]*CosPhi2+32.0*parms[4]*CosPhi2*CosPhi;
break;
case MOD_TRAPPE_DIHEDRAL:
/* Salvador modification: 16/08/2016
add phase in cos function:
p_0+p_1*(1+cos(phi-p_4))+p_2*(1-cos(2*(phi-p_4)))+p_3*(1+cos(3*(phi-p_4)))
*/
Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
+Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
Phi=SIGN(acos(CosPhi),sign);
SinPhi=sin(Phi);
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
Phi-=parms[4]; // shift Phi as Phi+parms[4]
Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
ShiftedCosPhi=cos(Phi);
ShiftedSinPhi=sin(Phi);
ShiftedCosPhi2=SQR(ShiftedCosPhi);
U=parms[0]+parms[1]+parms[3]+(parms[1]-3.0*parms[3])*ShiftedCosPhi -2.0*parms[2]*ShiftedCosPhi2 +4.0*parms[3]*ShiftedCosPhi*ShiftedCosPhi2;
DF=((parms[1]-3.0*parms[3])*sin(Phi) -4.0*parms[2]*ShiftedCosPhi*ShiftedSinPhi + 12.0*parms[3]*ShiftedCosPhi2*ShiftedSinPhi)/SinPhi;
break;
case CVFF_DIHEDRAL:
// p_0*(1+cos(p_1*phi-p_2))
// ========================
// p_0/k_B [K]
// p_1 [-]
// p_2 [degrees]
// potential defined in terms of 'phi' and therefore contains a singularity
// the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
// same direction as Dbc, and negative otherwise
Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
+Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
Phi=SIGN(acos(CosPhi),sign);
SinPhi=sin(Phi);
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
break;
case OPLS_DIHEDRAL:
// (1/2)p_0[0]+(1/2)p_1*(1+cos(phi))+(1/2)p_2*(1-cos(2*phi))+(1/2)p_3*(1+cos(3*phi))
// =================================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
U=0.5*(parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi)));
DF=0.5*parms[1]-2.0*parms[2]*CosPhi+1.5*parms[3]*(4.0*CosPhi2-1.0);
break;
case FOURIER_SERIES_DIHEDRAL:
// (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
// (1/2)p_3*(1-cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
// =======================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
// p_5/k_B [K]
U=0.5*(parms[0]+2.0*parms[1]+parms[2]+parms[4]+2.0*parms[5]+(parms[0]-3.0*parms[2]+5.0*parms[4])*CosPhi-
2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi2+4.0*(parms[2]-5.0*parms[4])*CosPhi2*CosPhi-
8.0*(parms[3]-6.0*parms[5])*SQR(CosPhi2)+16.0*parms[4]*SQR(CosPhi2)*CosPhi-32.0*parms[5]*CUBE(CosPhi2));
DF=0.5*(parms[0]-3.0*parms[2]+5.0*parms[4])-2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi+
6.0*(parms[2]-5.0*parms[4])*CosPhi2-16.0*(parms[3]-6.0*parms[5])*CosPhi2*CosPhi+40.0*parms[4]*SQR(CosPhi2)-96.0*parms[5]*CosPhi2*CUBE(CosPhi);
break;
case FOURIER_SERIES_DIHEDRAL2:
// (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
// (1/2)p_3*(1+cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
// =======================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
// p_5/k_B [K]
U=0.5*(parms[2]+2.0*parms[3]+parms[4]-3.0*parms[2]*CosPhi+5.0*parms[4]*CosPhi+parms[0]*(1.0+CosPhi)+
2.0*(parms[1]-parms[1]*CosPhi2+CosPhi2*(parms[5]*SQR(3.0-4.0*CosPhi2)+4.0*parms[3]*(CosPhi2-1.0)+
2.0*CosPhi*(parms[2]+parms[4]*(4.0*CosPhi2-5.0)))));
DF=0.5*parms[0]+parms[2]*(6.0*CosPhi2-1.5)+parms[4]*(2.5-30.0*CosPhi2+40.0*SQR(CosPhi2))+
CosPhi*(-2.0*parms[1]+parms[3]*(16.0*CosPhi2-8.0)+parms[5]*(18.0-96.0*CosPhi2+96.0*SQR(CosPhi2)));
break;
default:
fprintf(stderr, "Undefined Torsion potential in routine 'CalculateFrameworkTorsionForce' ('framework_force.c')\n");
exit(0);
break;
}
// energy
UHostTorsion[CurrentSystem]+=U;
// virial
// pure torsion has *no* contributions to the virial
// Calculate the first derivative vectors.
d=dot_ab/rbc;
e=dot_cd/rbc;
dtA.x=(ds.x-CosPhi*dr.x)/r;
dtA.y=(ds.y-CosPhi*dr.y)/r;
dtA.z=(ds.z-CosPhi*dr.z)/r;
dtD.x=(dr.x-CosPhi*ds.x)/s;
dtD.y=(dr.y-CosPhi*ds.y)/s;
dtD.z=(dr.z-CosPhi*ds.z)/s;
dtB.x=dtA.x*(d-1.0)+e*dtD.x;
dtB.y=dtA.y*(d-1.0)+e*dtD.y;
dtB.z=dtA.z*(d-1.0)+e*dtD.z;
dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
dtC.z=-dtD.z*(e+1.0)-d*dtA.z;
// forces are oppositely directed to the gradient
fa.x=-DF*dtA.x;
fa.y=-DF*dtA.y;
fa.z=-DF*dtA.z;
fb.x=-DF*dtB.x;
fb.y=-DF*dtB.y;
fb.z=-DF*dtB.z;
fc.x=-DF*dtC.x;
fc.y=-DF*dtC.y;
fc.z=-DF*dtC.z;
fd.x=-DF*dtD.x;
fd.y=-DF*dtD.y;
fd.z=-DF*dtD.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x+=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y+=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z+=fd.z;
// add contribution to the stress tensor
// Note: rbc is here because the vector was normalized before
StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;
StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;
StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
}
}
}
}
void CalculateFrameworkImproperTorsionForce(void)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL d,e,rbc,U,DF;
VECTOR Dab,Dcb,Ddc,dr,ds;
REAL dot_ab,dot_cd,r,s,sign;
REAL CosPhi,Phi,CosPhi2,SinPhi;
VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
VECTOR fa,fb,fc,fd;
REAL *parms;
UHostImproperTorsion[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfImproperTorsions[f1];i++)
{
A=Framework[CurrentSystem].ImproperTorsions[f1][i].A;
B=Framework[CurrentSystem].ImproperTorsions[f1][i].B;
C=Framework[CurrentSystem].ImproperTorsions[f1][i].C;
D=Framework[CurrentSystem].ImproperTorsions[f1][i].D;
parms=Framework[CurrentSystem].ImproperTorsionArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][D].Position;
Dab.x=posA.x-posB.x;
Dab.y=posA.y-posB.y;
Dab.z=posA.z-posB.z;
Dab=ApplyBoundaryCondition(Dab);
Dcb.x=posC.x-posB.x;
Dcb.y=posC.y-posB.y;
Dcb.z=posC.z-posB.z;
Dcb=ApplyBoundaryCondition(Dcb);
rbc=sqrt(SQR(Dcb.x)+SQR(Dcb.y)+SQR(Dcb.z));
Dcb.x/=rbc; Dcb.y/=rbc; Dcb.z/=rbc;
Ddc.x=posD.x-posC.x;
Ddc.y=posD.y-posC.y;
Ddc.z=posD.z-posC.z;
Ddc=ApplyBoundaryCondition(Ddc);
dot_ab=Dab.x*Dcb.x+Dab.y*Dcb.y+Dab.z*Dcb.z;
dot_cd=Ddc.x*Dcb.x+Ddc.y*Dcb.y+Ddc.z*Dcb.z;
dr.x=Dab.x-dot_ab*Dcb.x;
dr.y=Dab.y-dot_ab*Dcb.y;
dr.z=Dab.z-dot_ab*Dcb.z;
r=sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z));
dr.x/=r; dr.y/=r; dr.z/=r;
ds.x=Ddc.x-dot_cd*Dcb.x;
ds.y=Ddc.y-dot_cd*Dcb.y;
ds.z=Ddc.z-dot_cd*Dcb.z;
s=sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z));
ds.x/=s; ds.y/=s; ds.z/=s;
// compute Cos(Phi)
// Phi is defined in protein convention Phi(trans)=Pi
CosPhi=dr.x*ds.x+dr.y*ds.y+dr.z*ds.z;
// Ensure CosPhi is between -1 and 1.
CosPhi=SIGN(MIN2(fabs(CosPhi),(REAL)1.0),CosPhi);
CosPhi2=SQR(CosPhi);
switch(Framework[CurrentSystem].ImproperTorsionType[f1][i])
{
case HARMONIC_IMPROPER_DIHEDRAL:
// (1/2)*p_0*(phi-p_1)^2
// ===============================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// potential defined in terms of 'phi' and therefore contains a singularity
// the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
// same direction as Rbc, and negative otherwise
Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
+Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
Phi=SIGN(acos(CosPhi),sign);
SinPhi=sin(Phi);
Phi-=parms[1];
Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
U=0.5*parms[0]*SQR(Phi);
DF=-parms[0]*Phi/SinPhi;
break;
case HARMONIC_COSINE_IMPROPER_DIHEDRAL:
// (1/2)*p_0*(cos(phi)-cos(p_1))^2
// ===============================================
// p_0/k_B [K]
// p_1 [degrees]
U=0.5*parms[0]*SQR(CosPhi-parms[1]);
DF=parms[0]*(CosPhi-parms[1]);
break;
case THREE_COSINE_IMPROPER_DIHEDRAL:
// (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
// ========================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
break;
case MM3_IMPROPER_DIHEDRAL:
// (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
// ========================================================================
// p_0 [kcal/mol]
// p_1 [kcal/mol]
// p_2 [kcal/mol]
U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
break;
case CFF_IMPROPER_DIHEDRAL:
// p_0*(1-cos(phi))+p_1*(1-cos(2*phi))+p_2*(1-cos(3*phi))
// ======================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
U=parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2);
DF=-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2);
break;
case CFF_IMPROPER_DIHEDRAL2:
// p_0*(1+cos(phi))+p_1*(1+cos(2*phi))+p_2*(1+cos(3*phi))
// ======================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
U=parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi));
DF=parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi);
break;
case SIX_COSINE_IMPROPER_DIHEDRAL:
// Prod_i=0^5 p_i*cos(phi)^i
// =========================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
// p_5/k_B [K]
// the Ryckaert-Bellemans potentials is often used for alkanes, the use implies exclusion of VDW-interactions
// between the first and last atoms of the dihedral, and Phi'=Phi-pi is defined accoording to the
// polymer convention Phi'(trans)=0.
U=parms[0]-parms[1]*CosPhi+parms[2]*CosPhi2-parms[3]*CosPhi*CosPhi2+
parms[4]*SQR(CosPhi2)-parms[5]*SQR(CosPhi2)*CosPhi;
DF=-parms[1]+2.0*parms[2]*CosPhi-3.0*parms[3]*CosPhi2+4.0*parms[4]*CosPhi2*CosPhi-5.0*parms[5]*SQR(CosPhi2);
break;
case TRAPPE_IMPROPER_DIHEDRAL:
// p_0+p_1*(1+cos(phi))+p_2*(1-cos(2*phi))+p_3*(1+cos(3*phi))
// ==========================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
U=parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi));
DF=parms[1]-4.0*parms[2]*CosPhi+3.0*parms[3]*(4.0*CosPhi2-1.0);
break;
case TRAPPE_IMPROPER_DIHEDRAL_EXTENDED:
// p_0+p_1*cos(phi)+p_2*cos(2*phi)+p_3*cos(3*phi)+p_4*cos(4*phi)
// =============================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
U=parms[0]-parms[2]+parms[4]+(parms[1]-3.0*parms[3])*CosPhi+(2.0*parms[2]-8.0*parms[4])*CosPhi2+4.0*parms[3]*CosPhi2*CosPhi+8.0*parms[4]*SQR(CosPhi2);
DF=parms[1]-3.0*parms[3]+4.0*(parms[2]-4.0*parms[4])*CosPhi+12.0*parms[3]*CosPhi2+32.0*parms[4]*CosPhi2*CosPhi;
break;
case CVFF_IMPROPER_DIHEDRAL:
// p_0*(1+cos(p_1*phi-p_2))
// ========================
// p_0/k_B [K]
// p_1 [-]
// p_2 [degrees]
// potential defined in terms of 'phi' and therefore contains a singularity
// the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
// same direction as Dbc, and negative otherwise
Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
+Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
Phi=SIGN(acos(CosPhi),sign);
SinPhi=sin(Phi);
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
break;
case OPLS_IMPROPER_DIHEDRAL:
// (1/2)p_0[0]+(1/2)p_1*(1+cos(phi))+(1/2)p_2*(1-cos(2*phi))+(1/2)p_3*(1+cos(3*phi))
// =================================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
U=0.5*(parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi)));
DF=0.5*parms[1]-2.0*parms[2]*CosPhi+1.5*parms[3]*(4.0*CosPhi2-1.0);
break;
case FOURIER_SERIES_IMPROPER_DIHEDRAL:
// (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
// (1/2)p_3*(1-cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
// =======================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
// p_5/k_B [K]
U=0.5*(parms[0]+2.0*parms[1]+parms[2]+parms[4]+2.0*parms[5]+(parms[0]-3.0*parms[2]+5.0*parms[4])*CosPhi-
2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi2+4.0*(parms[2]-5.0*parms[4])*CosPhi2*CosPhi-
8.0*(parms[3]-6.0*parms[5])*SQR(CosPhi2)+16.0*parms[4]*SQR(CosPhi2)*CosPhi-32.0*parms[5]*CUBE(CosPhi2));
DF=0.5*(parms[0]-3.0*parms[2]+5.0*parms[4])-2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi+
6.0*(parms[2]-5.0*parms[4])*CosPhi2-16.0*(parms[3]-6.0*parms[5])*CosPhi2*CosPhi+40.0*parms[4]*SQR(CosPhi2)-96.0*parms[5]*CosPhi2*CUBE(CosPhi);
break;
case FOURIER_SERIES_IMPROPER_DIHEDRAL2:
// (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
// (1/2)p_3*(1+cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
// =======================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
// p_3/k_B [K]
// p_4/k_B [K]
// p_5/k_B [K]
U=0.5*(parms[2]+2.0*parms[3]+parms[4]-3.0*parms[2]*CosPhi+5.0*parms[4]*CosPhi+parms[0]*(1.0+CosPhi)+
2.0*(parms[1]-parms[1]*CosPhi2+CosPhi2*(parms[5]*SQR(3.0-4.0*CosPhi2)+4.0*parms[3]*(CosPhi2-1.0)+
2.0*CosPhi*(parms[2]+parms[4]*(4.0*CosPhi2-5.0)))));
DF=0.5*parms[0]+parms[2]*(6.0*CosPhi2-1.5)+parms[4]*(2.5-30.0*CosPhi2+40.0*SQR(CosPhi2))+
CosPhi*(-2.0*parms[1]+parms[3]*(16.0*CosPhi2-8.0)+parms[5]*(18.0-96.0*CosPhi2+96.0*SQR(CosPhi2)));
break;
case FIXED_IMPROPER_DIHEDRAL:
U=DF=0.0;
break;
default:
fprintf(stderr, "Undefined Improper-Torsion potential in routine 'CalculateFrameworkImproperTorsionForce' ('framework_force.c')\n");
exit(0);
break;
}
// energy
UHostImproperTorsion[CurrentSystem]+=U;
// virial
// pure torsion has *no* contributions to the virial
// Calculate the first derivative vectors.
d=dot_ab/rbc;
e=dot_cd/rbc;
dtA.x=(ds.x-CosPhi*dr.x)/r;
dtA.y=(ds.y-CosPhi*dr.y)/r;
dtA.z=(ds.z-CosPhi*dr.z)/r;
dtD.x=(dr.x-CosPhi*ds.x)/s;
dtD.y=(dr.y-CosPhi*ds.y)/s;
dtD.z=(dr.z-CosPhi*ds.z)/s;
dtB.x=dtA.x*(d-1.0)+e*dtD.x;
dtB.y=dtA.y*(d-1.0)+e*dtD.y;
dtB.z=dtA.z*(d-1.0)+e*dtD.z;
dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
dtC.z=-dtD.z*(e+1.0)-d*dtA.z;
// forces are oppositely directed to the gradient
fa.x=-DF*dtA.x;
fa.y=-DF*dtA.y;
fa.z=-DF*dtA.z;
fb.x=-DF*dtB.x;
fb.y=-DF*dtB.y;
fb.z=-DF*dtB.z;
fc.x=-DF*dtC.x;
fc.y=-DF*dtC.y;
fc.z=-DF*dtC.z;
fd.x=-DF*dtD.x;
fd.y=-DF*dtD.y;
fd.z=-DF*dtD.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x+=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y+=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z+=fd.z;
// add contribution to the stress tensor
// Note: rbc is here because the vector was normalized before
StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;
StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;
StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
}
}
}
}
void CalculateFrameworkBondBondForce(void)
{
int i,A,B,C,f1;
REAL *parms,gamma,gammc;
REAL energy;
REAL rab,rbc;
VECTOR posA,posB,posC;
VECTOR Rab,Rbc,fa,fc;
UHostBondBond[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondBonds[f1];i++)
{
A=Framework[CurrentSystem].BondBonds[f1][i].A;
B=Framework[CurrentSystem].BondBonds[f1][i].B;
C=Framework[CurrentSystem].BondBonds[f1][i].C;
parms=Framework[CurrentSystem].BondBondArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
Rab.x=posA.x-posB.x;
Rab.y=posA.y-posB.y;
Rab.z=posA.z-posB.z;
Rab=ApplyBoundaryCondition(Rab);
rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
Rbc.x=posC.x-posB.x;
Rbc.y=posC.y-posB.y;
Rbc.z=posC.z-posB.z;
Rbc=ApplyBoundaryCondition(Rbc);
rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
switch(Framework[CurrentSystem].BondBondType[f1][i])
{
case CVFF_BOND_BOND_CROSS:
case CFF_BOND_BOND_CROSS:
// p_0*(rab-p_1)*(rbc-p_2)
// =======================
// p_0/k_B [K/A^2]
// p_1 [A]
// p_2 [A]
energy=parms[0]*(rab-parms[1])*(rbc-parms[2]);
gamma=-parms[0]*(rbc-parms[2])/rab;
gammc=-parms[0]*(rab-parms[1])/rbc;
break;
default:
fprintf(stderr, "Undefined Bond-Bond potential in routine 'CalculateFrameworkBondBondForce' ('framework_force.c')\n");
exit(0);
break;
}
// add contribution to the energy
UHostBondBond[CurrentSystem]+=energy;
// forces
fa.x=gamma*Rab.x;
fa.y=gamma*Rab.y;
fa.z=gamma*Rab.z;
fc.x=gammc*Rbc.x;
fc.y=gammc*Rbc.y;
fc.z=gammc*Rbc.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=(fa.x+fc.x);
Framework[CurrentSystem].Atoms[f1][B].Force.y-=(fa.y+fc.y);
Framework[CurrentSystem].Atoms[f1][B].Force.z-=(fa.z+fc.z);
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax-=Rab.x*fa.x+Rbc.x*fc.x;
StrainDerivativeTensor[CurrentSystem].bx-=Rab.y*fa.x+Rbc.y*fc.x;
StrainDerivativeTensor[CurrentSystem].cx-=Rab.z*fa.x+Rbc.z*fc.x;
StrainDerivativeTensor[CurrentSystem].ay-=Rab.x*fa.y+Rbc.x*fc.y;
StrainDerivativeTensor[CurrentSystem].by-=Rab.y*fa.y+Rbc.y*fc.y;
StrainDerivativeTensor[CurrentSystem].cy-=Rab.z*fa.y+Rbc.z*fc.y;
StrainDerivativeTensor[CurrentSystem].az-=Rab.x*fa.z+Rbc.x*fc.z;
StrainDerivativeTensor[CurrentSystem].bz-=Rab.y*fa.z+Rbc.y*fc.z;
StrainDerivativeTensor[CurrentSystem].cz-=Rab.z*fa.z+Rbc.z*fc.z;
}
}
}
}
void CalculateFrameworkBondBendForce(void)
{
int i,A,B,C,f1;
REAL *parms,gamma,gamsa,gamsc,pterm,vterm;
REAL cost,theta,sint;
REAL rab,rbc,rac;
VECTOR posA,posB,posC;
VECTOR Rab,Rbc,Rac,fa,fc;
UHostBondBend[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondBends[f1];i++)
{
A=Framework[CurrentSystem].BondBends[f1][i].A;
B=Framework[CurrentSystem].BondBends[f1][i].B;
C=Framework[CurrentSystem].BondBends[f1][i].C;
parms=Framework[CurrentSystem].BondBendArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
Rab.x=posA.x-posB.x;
Rab.y=posA.y-posB.y;
Rab.z=posA.z-posB.z;
Rab=ApplyBoundaryCondition(Rab);
rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
Rab.x/=rab;
Rab.y/=rab;
Rab.z/=rab;
Rbc.x=posC.x-posB.x;
Rbc.y=posC.y-posB.y;
Rbc.z=posC.z-posB.z;
Rbc=ApplyBoundaryCondition(Rbc);
rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
Rbc.x/=rbc;
Rbc.y/=rbc;
Rbc.z/=rbc;
Rac.x=posC.x-posA.x;
Rac.y=posC.y-posA.y;
Rac.z=posC.z-posA.z;
Rac=ApplyBoundaryCondition(Rac);
rac=sqrt(SQR(Rac.x)+SQR(Rac.y)+SQR(Rac.z));
Rac.x/=rac;
Rac.y/=rac;
Rac.z/=rac;
cost=(Rab.x*Rbc.x+Rab.y*Rbc.y+Rab.z*Rbc.z);
cost=MIN2(1.0,MAX2(-1.0,cost));
theta=acos(cost);
sint=sqrt(1.0-SQR(cost));
//sint=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(cost)));
switch(Framework[CurrentSystem].BondBendType[f1][i])
{
case CVFF_BOND_BEND_CROSS:
case CFF_BOND_BEND_CROSS:
// (Theta-p_0)*(p_1*(rab-p_2)+p_3*(rbc-p_4))
// =========================================
// p_0 [degrees]
// p_1/k_B [K/A/rad]
// p_2 [A]
// p_3/k_B [K/A/rad]
// p_4 [A]
pterm=(theta-parms[0])*(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]));
vterm=0.0;
gamma=(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]))/sint;
gamsa=-parms[1]*(theta-parms[0]);
gamsc=-parms[3]*(theta-parms[0]);
break;
case MM3_BOND_BEND_CROSS:
// p_0*[(rab-p_1)+(rbc-p_2)]*(Theta-p_3)
// =====================================
// p_0 [mdyne/rad]
// p_1 [A]
// p_2 [A]
// p_3 [degrees]
pterm=parms[0]*((rab-parms[1])+(rbc-parms[2]))*RAD2DEG*(theta-parms[3]);
vterm=0.0;
gamma=parms[0]*RAD2DEG*((rab-parms[1])+(rbc-parms[2]))/sint;
gamsa=-parms[0]*RAD2DEG*(theta-parms[3]);
gamsc=-parms[0]*RAD2DEG*(theta-parms[3]);
break;
case TRUNCATED_HARMONIC:
// (1/2)*p_0*(Theta-p_1)^2*exp(-(pow(rab,8)+pow(rbc,8))/pow(p_2,8))
// ================================================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// p_2 [A]
pterm=0.5*parms[0]*SQR(theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8));
vterm=-8.0*pterm*(pow(rab,8)+pow(rbc,8))/pow(parms[2],8);
gamma=(parms[0]*(theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8)))/sint;
gamsa=(8.0*pterm/pow(parms[2],8))*pow(rab,7);
gamsc=(8.0*pterm/pow(parms[2],8))*pow(rbc,7);
break;
case SCREENED_HARMONIC:
// (1/2)*p_0*(Theta-p_1)^2*exp(-(rab/p_2+rbc/p_3))
// ===============================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// p_2 [A]
// p_3 [A]
pterm=0.5*parms[0]*SQR(theta-parms[1])*exp(-(rab/parms[2]+rbc/parms[3]));
vterm=-pterm*(rab/parms[2]+rbc/parms[3]);
gamma=(parms[0]*(theta-parms[1])*exp(-(rab/parms[2]+rbc/parms[3])))/sint;
gamsa=(pterm/parms[2]);
gamsc=(pterm/parms[3]);
break;
case SCREENED_VESSAL:
// (p_0/(8.0*(Theta-PI)^2))*((p_1-PI)^2-(Theta-PI)^2)^2*exp(-(rab/p_2+rbc/p_3))
// ============================================================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
// p_2 [A]
// p_3 [A]
pterm=(parms[0]/(8.0*SQR(theta-M_PI)))*SQR(SQR(parms[1]-M_PI)-SQR(theta-M_PI))
*exp(-(rab/parms[2]+rbc/parms[3]));
vterm=-pterm*(rab/parms[2]+rbc/parms[3]);
gamma=(parms[0]/(2.0*SQR(theta-M_PI))*(SQR(parms[1]-M_PI)-SQR(theta-M_PI))*(theta-M_PI)
*exp(-(rab/parms[2]+rbc/parms[3])))/sint;
gamsa=(pterm/parms[2]);
gamsc=(pterm/parms[3]);
break;
case TRUNCATED_VESSAL:
// p_0*[pow(theta,p_2)*(theta-p_1)^2*(theta+p_1-2.0*PI)^2-0.5*p_2*pow(PI,p_2-1.0)*(theta-p_1)^2*pow(PI-p_1,3)]
// *exp(-(pow(rab,8)+pow(rbc,8))/pow(p_3,8))
// ============================================================================
// p_0/k_B [K/rad^(4+p_2)]
// p_1 [degrees]
// p_2 [-]
// p_3 [A]
pterm=parms[0]*(pow(theta,parms[2])*SQR(theta-parms[1])*SQR(theta+parms[1]-2.0*M_PI)
-0.5*parms[2]*pow((REAL)M_PI,(parms[2]-1.0))*SQR(theta-parms[1])*pow(M_PI-parms[1],(REAL)3.0))
*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[3],8));
vterm=-8.0*pterm*(pow(rab,8)+pow(rbc,8))/pow(parms[3],8);
gamma=(parms[0]*(pow(theta,(parms[2]-1.0))*(theta-parms[1])*(theta+parms[1]-2.0*M_PI)
*((parms[2]+4.0)*SQR(theta)-2.0*M_PI*(parms[2]+2.0)*theta+parms[2]*parms[1]*
(2.0*M_PI-parms[1]))-parms[2]*pow((REAL)M_PI,(parms[2]-1.0))*(theta-parms[1])*
pow(M_PI-parms[1],3))*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[3],8)))/sint;
gamsa=(8.0*pterm/pow(parms[3],8))*pow(rab,7);
gamsc=(8.0*pterm/pow(parms[3],8))*pow(rbc,7);
break;
default:
fprintf(stderr, "Undefined Bond-Bend potential in routine 'CalculateFrameworkBondBendForce' ('framework_force.c')\n");
exit(0);
break;
}
// energy
UHostBondBend[CurrentSystem]+=pterm;
// forces
fa.x=gamma*(Rbc.x-Rab.x*cost)/rab+gamsa*Rab.x;
fa.y=gamma*(Rbc.y-Rab.y*cost)/rab+gamsa*Rab.y;
fa.z=gamma*(Rbc.z-Rab.z*cost)/rab+gamsa*Rab.z;
fc.x=gamma*(Rab.x-Rbc.x*cost)/rbc+gamsc*Rbc.x;
fc.y=gamma*(Rab.y-Rbc.y*cost)/rbc+gamsc*Rbc.y;
fc.z=gamma*(Rab.z-Rbc.z*cost)/rbc+gamsc*Rbc.z;
// add contribution to the forces
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=(fa.x+fc.x);
Framework[CurrentSystem].Atoms[f1][B].Force.y-=(fa.y+fc.y);
Framework[CurrentSystem].Atoms[f1][B].Force.z-=(fa.z+fc.z);
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax-=(rab*Rab.x*fa.x+rbc*Rbc.x*fc.x);
StrainDerivativeTensor[CurrentSystem].ay-=(rab*Rab.x*fa.y+rbc*Rbc.x*fc.y);
StrainDerivativeTensor[CurrentSystem].az-=(rab*Rab.x*fa.z+rbc*Rbc.x*fc.z);
StrainDerivativeTensor[CurrentSystem].bx-=(rab*Rab.y*fa.x+rbc*Rbc.y*fc.x);
StrainDerivativeTensor[CurrentSystem].by-=(rab*Rab.y*fa.y+rbc*Rbc.y*fc.y);
StrainDerivativeTensor[CurrentSystem].bz-=(rab*Rab.y*fa.z+rbc*Rbc.y*fc.z);
StrainDerivativeTensor[CurrentSystem].cx-=(rab*Rab.z*fa.x+rbc*Rbc.z*fc.x);
StrainDerivativeTensor[CurrentSystem].cy-=(rab*Rab.z*fa.y+rbc*Rbc.z*fc.y);
StrainDerivativeTensor[CurrentSystem].cz-=(rab*Rab.z*fa.z+rbc*Rbc.z*fc.z);
}
}
}
}
// Bend/Bend cross term for a centered atom B
// the first angle is A-B-C
// the second angle is A-B-D
void CalculateFrameworkBendBendForce(void)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL energy,rab,rbc,rbd;
VECTOR Dab,Dbc,Dbd;
REAL dot_abc,dot_abd;
VECTOR fa,fb,fc,fd;
REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
REAL DTheta1,DTheta2;
REAL *parms;
UHostBendBend[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBendBends[f1];i++)
{
A=Framework[CurrentSystem].BendBends[f1][i].A;
B=Framework[CurrentSystem].BendBends[f1][i].B;
C=Framework[CurrentSystem].BendBends[f1][i].C;
D=Framework[CurrentSystem].BendBends[f1][i].D;
parms=(REAL*)&Framework[CurrentSystem].BendBendArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][D].Position;
Dab.x=posA.x-posB.x;
Dab.y=posA.y-posB.y;
Dab.z=posA.z-posB.z;
Dab=ApplyBoundaryCondition(Dab);
rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
Dbc.x=posC.x-posB.x;
Dbc.y=posC.y-posB.y;
Dbc.z=posC.z-posB.z;
Dbc=ApplyBoundaryCondition(Dbc);
rbc=sqrt(SQR(Dbc.x)+SQR(Dbc.y)+SQR(Dbc.z));
Dbc.x/=rbc; Dbc.y/=rbc; Dbc.z/=rbc;
Dbd.x=posD.x-posB.x;
Dbd.y=posD.y-posB.y;
Dbd.z=posD.z-posB.z;
Dbd=ApplyBoundaryCondition(Dbd);
rbd=sqrt(SQR(Dbd.x)+SQR(Dbd.y)+SQR(Dbd.z));
Dbd.x/=rbd; Dbd.y/=rbd; Dbd.z/=rbd;
dot_abc=Dab.x*Dbc.x+Dab.y*Dbc.y+Dab.z*Dbc.z;
CosTheta1=dot_abc;
CosTheta1=SIGN(MIN2(fabs(CosTheta1),(REAL)1.0),CosTheta1);
Theta1=acos(CosTheta1);
SinTheta1=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta1)));
dot_abd=Dab.x*Dbd.x+Dab.y*Dbd.y+Dab.z*Dbd.z;
CosTheta2=dot_abd;
CosTheta2=SIGN(MIN2(fabs(CosTheta2),(REAL)1.0),CosTheta2);
Theta2=acos(CosTheta2);
SinTheta2=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta2)));
switch(Framework[CurrentSystem].BendBendType[f1][i])
{
case CVFF_BEND_BEND_CROSS:
case CFF_BEND_BEND_CROSS:
// p_0*(Theta1-p_1)*(Theta2-p_2)
// ===================================
// p_0/k_B [K/rad^2)]
// p_1 [degrees]
// p_2 [degrees]
energy=parms[0]*(Theta1-parms[1])*(Theta2-parms[2]);
DTheta1=parms[0]*(Theta2-parms[2])/SinTheta1;
DTheta2=parms[0]*(Theta1-parms[1])/SinTheta2;
break;
case MM3_BEND_BEND_CROSS:
// -p_0*(Theta1-p_1)*(Theta2-p_2)
// ===================================
// p_0 [mdyne A/rad^2]
// p_1 [degrees]
// p_2 [degrees]
energy=-parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])*(Theta2-parms[2]);
DTheta1=-parms[0]*SQR(RAD2DEG)*(Theta2-parms[2])/SinTheta1;
DTheta2=-parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])/SinTheta2;
break;
default:
fprintf(stderr, "Undefined Bend-Bend potential in routine 'CalculateFrameworkBendBendForce' ('framework_force.c')\n");
exit(0);
break;
}
// energy
UHostBendBend[CurrentSystem]+=energy;
// forces bend
fa.x=DTheta1*(Dbc.x-CosTheta1*Dab.x)/rab;
fa.y=DTheta1*(Dbc.y-CosTheta1*Dab.y)/rab;
fa.z=DTheta1*(Dbc.z-CosTheta1*Dab.z)/rab;
fc.x=DTheta1*(Dab.x-CosTheta1*Dbc.x)/rbc;
fc.y=DTheta1*(Dab.y-CosTheta1*Dbc.y)/rbc;
fc.z=DTheta1*(Dab.z-CosTheta1*Dbc.z)/rbc;
fb.x=-DTheta1*(fa.x+fc.x);
fb.y=-DTheta1*(fa.y+fc.y);
fb.z=-DTheta1*(fa.z+fc.z);
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=fa.x+fc.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=fa.y+fc.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=fa.z+fc.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x;
StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x;
StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x;
StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y;
StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y;
StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y;
StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z;
StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z;
StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z;
fa.x=DTheta2*(Dbd.x-CosTheta2*Dab.x)/rab;
fa.y=DTheta2*(Dbd.y-CosTheta2*Dab.y)/rab;
fa.z=DTheta2*(Dbd.z-CosTheta2*Dab.z)/rab;
fd.x=DTheta2*(Dab.x-CosTheta2*Dbd.x)/rbd;
fd.y=DTheta2*(Dab.y-CosTheta2*Dbd.y)/rbd;
fd.z=DTheta2*(Dab.z-CosTheta2*Dbd.z)/rbd;
fb.x=-DTheta2*(fa.x+fd.x);
fb.y=-DTheta2*(fa.y+fd.y);
fb.z=-DTheta2*(fa.z+fd.z);
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=fa.x+fd.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=fa.y+fd.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=fa.z+fd.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x+=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y+=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z+=fd.z;
StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbd*Dbd.x*fd.x;
StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbd*Dbd.y*fd.x;
StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbd*Dbd.z*fd.x;
StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbd*Dbd.x*fd.y;
StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbd*Dbd.y*fd.y;
StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbd*Dbd.z*fd.y;
StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbd*Dbd.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbd*Dbd.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbd*Dbd.z*fd.z;
}
}
}
}
// the Bend/Torsion cross term makes no contribution to the stress
void CalculateFrameworkBendTorsionForce(void)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL d,e, energy,rab,rbc,rcd;
VECTOR Dab,Dbc,Dcd,dr,ds;
REAL dot_ab,dot_cd,r,s;
REAL CosPhi,CosPhi2,DCos;
VECTOR dtA,dtB,dtC,dtD,fa,fb,fc,fd,Pb,Pc;
REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
REAL DTheta1,DTheta2,sign,Phi,SinPhi;
REAL *parms;
UHostBendTorsion[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBendTorsions[f1];i++)
{
A=Framework[CurrentSystem].BendTorsions[f1][i].A;
B=Framework[CurrentSystem].BendTorsions[f1][i].B;
C=Framework[CurrentSystem].BendTorsions[f1][i].C;
D=Framework[CurrentSystem].BendTorsions[f1][i].D;
parms=(REAL*)&Framework[CurrentSystem].BendTorsionArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][D].Position;
Dab.x=posA.x-posB.x;
Dab.y=posA.y-posB.y;
Dab.z=posA.z-posB.z;
Dab=ApplyBoundaryCondition(Dab);
rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
Dbc.x=posC.x-posB.x;
Dbc.y=posC.y-posB.y;
Dbc.z=posC.z-posB.z;
Dbc=ApplyBoundaryCondition(Dbc);
rbc=sqrt(SQR(Dbc.x)+SQR(Dbc.y)+SQR(Dbc.z));
Dbc.x/=rbc; Dbc.y/=rbc; Dbc.z/=rbc;
Dcd.x=posD.x-posC.x;
Dcd.y=posD.y-posC.y;
Dcd.z=posD.z-posC.z;
Dcd=ApplyBoundaryCondition(Dcd);
rcd=sqrt(SQR(Dcd.x)+SQR(Dcd.y)+SQR(Dcd.z));
dot_ab=Dab.x*Dbc.x+Dab.y*Dbc.y+Dab.z*Dbc.z;
CosTheta1=dot_ab/rab;
CosTheta1=MAX2(MIN2(CosTheta1,(REAL)1.0),-1.0);
Theta1=acos(CosTheta1);
SinTheta1=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta1)));
dot_cd=Dcd.x*Dbc.x+Dcd.y*Dbc.y+Dcd.z*Dbc.z;
CosTheta2=-dot_cd/rcd;
CosTheta2=MAX2(MIN2(CosTheta2,(REAL)1.0),-1.0);
Theta2=acos(CosTheta2);
SinTheta2=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta2)));
dr.x=Dab.x-dot_ab*Dbc.x;
dr.y=Dab.y-dot_ab*Dbc.y;
dr.z=Dab.z-dot_ab*Dbc.z;
r=MAX2((REAL)1.0e-8,sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z)));
dr.x/=r; dr.y/=r; dr.z/=r;
ds.x=Dcd.x-dot_cd*Dbc.x;
ds.y=Dcd.y-dot_cd*Dbc.y;
ds.z=Dcd.z-dot_cd*Dbc.z;
s=MAX2((REAL)1.0e-8,sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z)));
ds.x/=s; ds.y/=s; ds.z/=s;
// compute Cos(Phi)
// Phi is defined in protein convention Phi(trans)=Pi
CosPhi=dr.x*ds.x+dr.y*ds.y+dr.z*ds.z;
// Ensure CosPhi is between -1 and 1.
CosPhi=SIGN(MIN2(fabs(CosPhi),(REAL)1.0),CosPhi);
CosPhi2=SQR(CosPhi);
switch(Framework[CurrentSystem].BendTorsionType[f1][i])
{
case CVFF_BEND_TORSION_CROSS:
case CFF_BEND_TORSION_CROSS:
// p_0*(Theta1-p_1)*(Theta2-p_2)*cos(Phi)
// =====================================================================================
// p_0/k_B [K/rad^3]
// p_1 [degrees]
// p_2 [degrees]
energy=parms[0]*(Theta1-parms[1])*(Theta2-parms[2])*CosPhi;
DCos=parms[0]*(Theta1-parms[1])*(Theta2-parms[2]);
DTheta1=parms[0]*(Theta2-parms[2])*CosPhi/SinTheta1;
DTheta2=parms[0]*(Theta1-parms[1])*CosPhi/SinTheta2;
break;
case SMOOTHED_DIHEDRAL:
// S(Theta1)*[p_0(1+cos(p_1*Phi-p_2)]*S(Theta2)
// ======================================================================================
// p_0/k_B [K/rad^2]
// p_1 [-]
// p_2 [degrees]
Pb.x=Dab.z*Dbc.y-Dab.y*Dbc.z;
Pb.y=Dab.x*Dbc.z-Dab.z*Dbc.x;
Pb.z=Dab.y*Dbc.x-Dab.x*Dbc.y;
Pc.x=Dbc.y*Dcd.z-Dbc.z*Dcd.y;
Pc.y=Dbc.z*Dcd.x-Dbc.x*Dcd.z;
Pc.z=Dbc.x*Dcd.y-Dbc.y*Dcd.x;
sign=(Dbc.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dbc.y*(Pb.z*Pc.x-Pb.x*Pc.z)
+Dbc.z*(Pc.y*Pb.x-Pc.x*Pb.y));
Phi=SIGN(acos(CosPhi),sign);
SinPhi=sin(Phi);
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
energy=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]))*Smoothing(Theta1)*Smoothing(Theta2);
DCos=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))*Smoothing(Theta1)*Smoothing(Theta2)/SinPhi;
DTheta1=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]))*SmoothingDerivative(Theta1)*Smoothing(Theta2)/SinTheta1;
DTheta2=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]))*Smoothing(Theta1)*SmoothingDerivative(Theta2)/SinTheta2;
break;
case SMOOTHED_THREE_COSINE_DIHEDRAL:
// S(Theta1)*[(1/2)*(1+cos(Phi))+(1/2)*p_1*(1-cos(2*Phi))+(1/2)*(1+cos(3*Phi))]*S(Theta2)
// ======================================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
energy=(0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2))*
Smoothing(Theta1)*Smoothing(Theta2);
DCos=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0)*Smoothing(Theta1)*Smoothing(Theta2);
DTheta1=(0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2))*
SmoothingDerivative(Theta1)*Smoothing(Theta2)/SinTheta1;
DTheta2=(0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2))*
SmoothingDerivative(Theta2)*Smoothing(Theta1)/SinTheta2;
break;
case NICHOLAS_DIHEDRAL:
// S(Theta1)*[(1/2)*(1+cos(Phi))+(1/2)*p_1*(1-cos(2*Phi))+(1/2)*(1+cos(3*Phi))]*S(Theta2)
// ======================================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
energy=(0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2))*
Smoothing(Theta1);
DCos=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0)*Smoothing(Theta1);
DTheta1=(0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2))*
SmoothingDerivative(Theta1)/SinTheta1;
DTheta2=0.0;
break;
case SMOOTHED_CFF_DIHEDRAL:
// S(Theta1)*[(1-cos(Phi))+p_1*(1-cos(2*Phi))+(1-cos(3*Phi))]*S(Theta2)
// ======================================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
energy=(parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2))*Smoothing(Theta1)*Smoothing(Theta2);
DCos=(-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2))*Smoothing(Theta1)*Smoothing(Theta2);
DTheta1=(parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2))*
SmoothingDerivative(Theta1)*Smoothing(Theta2)/SinTheta1;
DTheta2=(parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2))*
Smoothing(Theta1)*SmoothingDerivative(Theta2)/SinTheta2;
break;
case SMOOTHED_CFF_DIHEDRAL2:
// S(Theta1)*[(1+cos(Phi))+p_1*(1+cos(2*Phi))+(1+cos(3*Phi))]*S(Theta2)
// ======================================================================================
// p_0/k_B [K]
// p_1/k_B [K]
// p_2/k_B [K]
energy=(parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi)))*Smoothing(Theta1)*Smoothing(Theta2);
DCos=(parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi))*Smoothing(Theta1)*Smoothing(Theta2);
DTheta1=(parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi)))*
SmoothingDerivative(Theta1)*Smoothing(Theta2)/SinTheta1;
DTheta2=(parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi)))*
Smoothing(Theta1)*SmoothingDerivative(Theta2)/SinTheta2;
break;
case SMOOTHED_CFF_BEND_TORSION_CROSS:
// S(Theta1)*[p_0*(Theta1-p_1)*(Theta2-p_2)*cos(Phi)]*S(Theta2)
// ======================================================================================
// p_0/k_B [K/rad^3]
// p_1 [degrees]
// p_2 [degrees]
energy=parms[0]*(Theta1-parms[1])*(Theta2-parms[2])*CosPhi*Smoothing(Theta1)*Smoothing(Theta2);
DCos=parms[0]*(Theta1-parms[1])*(Theta2-parms[2])*Smoothing(Theta1)*Smoothing(Theta2);
DTheta1=CosPhi*parms[0]*(Theta2-parms[2])*Smoothing(Theta2)*(Smoothing(Theta1)+(Theta1-parms[1])*SmoothingDerivative(Theta1))/SinTheta1;
DTheta2=CosPhi*parms[0]*(Theta1-parms[1])*Smoothing(Theta1)*(Smoothing(Theta2)+(Theta2-parms[2])*SmoothingDerivative(Theta2))/SinTheta2;
break;
default:
fprintf(stderr, "Undefined Bend-Torsion potential in routine 'CalculateFrameworkBendTorsionForce' ('framework_force.c')\n");
exit(0);
break;
}
// energy
UHostBendTorsion[CurrentSystem]+=energy;
// Calculate the first derivative vectors.
d=dot_ab/rbc;
e=dot_cd/rbc;
dtA.x=(ds.x-CosPhi*dr.x)/r;
dtA.y=(ds.y-CosPhi*dr.y)/r;
dtA.z=(ds.z-CosPhi*dr.z)/r;
dtD.x=(dr.x-CosPhi*ds.x)/s;
dtD.y=(dr.y-CosPhi*ds.y)/s;
dtD.z=(dr.z-CosPhi*ds.z)/s;
dtB.x=dtA.x*(d-1.0)+e*dtD.x;
dtB.y=dtA.y*(d-1.0)+e*dtD.y;
dtB.z=dtA.z*(d-1.0)+e*dtD.z;
dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
dtC.z=-dtD.z*(e+1.0)-d*dtA.z;
// forces are oppositely directed to the gradient
fa.x=-DCos*dtA.x;
fa.y=-DCos*dtA.y;
fa.z=-DCos*dtA.z;
fb.x=-DCos*dtB.x;
fb.y=-DCos*dtB.y;
fb.z=-DCos*dtB.z;
fc.x=-DCos*dtC.x;
fc.y=-DCos*dtC.y;
fc.z=-DCos*dtC.z;
fd.x=-DCos*dtD.x;
fd.y=-DCos*dtD.y;
fd.z=-DCos*dtD.z;
// forces torsion
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x+=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y+=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z+=fd.z;
// add contribution to the stress tensor
// Note: rbc is here because the vector was normalized before
StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dbc.x*rbc*(fc.x+fd.x)+Dcd.x*fd.x;
StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dbc.y*rbc*(fc.x+fd.x)+Dcd.y*fd.x;
StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dbc.z*rbc*(fc.x+fd.x)+Dcd.z*fd.x;
StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dbc.x*rbc*(fc.y+fd.y)+Dcd.x*fd.y;
StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dbc.y*rbc*(fc.y+fd.y)+Dcd.y*fd.y;
StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dbc.z*rbc*(fc.y+fd.y)+Dcd.z*fd.y;
StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dbc.x*rbc*(fc.z+fd.z)+Dcd.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dbc.y*rbc*(fc.z+fd.z)+Dcd.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dbc.z*rbc*(fc.z+fd.z)+Dcd.z*fd.z;
Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
Dcd.x/=rcd; Dcd.y/=rcd; Dcd.z/=rcd;
// forces bends
fa.x=DTheta1*(Dbc.x-Dab.x*CosTheta1)/rab;
fa.y=DTheta1*(Dbc.y-Dab.y*CosTheta1)/rab;
fa.z=DTheta1*(Dbc.z-Dab.z*CosTheta1)/rab;
fb.x=DTheta2*(Dcd.x+Dbc.x*CosTheta2)/rbc;
fb.y=DTheta2*(Dcd.y+Dbc.y*CosTheta2)/rbc;
fb.z=DTheta2*(Dcd.z+Dbc.z*CosTheta2)/rbc;
fc.x=DTheta1*(Dab.x-Dbc.x*CosTheta1)/rbc;
fc.y=DTheta1*(Dab.y-Dbc.y*CosTheta1)/rbc;
fc.z=DTheta1*(Dab.z-Dbc.z*CosTheta1)/rbc;
fd.x=DTheta2*(-Dbc.x-Dcd.x*CosTheta2)/rcd;
fd.y=DTheta2*(-Dbc.y-Dcd.y*CosTheta2)/rcd;
fd.z=DTheta2*(-Dbc.z-Dcd.z*CosTheta2)/rcd;
Framework[CurrentSystem].Atoms[f1][A].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x+=fb.x-fa.x-fc.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y+=fb.y-fa.y-fc.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z+=fb.z-fa.z-fc.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x+=fc.x-fb.x-fd.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y+=fc.y-fb.y-fd.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z+=fc.z-fb.z-fd.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x+=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y+=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z+=fd.z;
StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x+rbc*Dbc.x*fb.x+rcd*Dcd.x*fd.x;
StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x+rbc*Dbc.y*fb.x+rcd*Dcd.y*fd.x;
StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x+rbc*Dbc.z*fb.x+rcd*Dcd.z*fd.x;
StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y+rbc*Dbc.x*fb.y+rcd*Dcd.x*fd.y;
StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y+rbc*Dbc.y*fb.y+rcd*Dcd.y*fd.y;
StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y+rbc*Dbc.z*fb.y+rcd*Dcd.z*fd.y;
StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z+rbc*Dbc.x*fb.z+rcd*Dcd.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z+rbc*Dbc.y*fb.z+rcd*Dcd.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z+rbc*Dbc.z*fb.z+rcd*Dcd.z*fd.z;
}
}
}
}
void CalculateFrameworkBondTorsionForce(void)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL d,e, energy,rab,rbc,rcd;
VECTOR Dab,Dcb,Ddc,dr,ds;
REAL dot_ab,dot_cd,r,s;
REAL CosPhi,CosPhi2,DCos,temp;
VECTOR dtA,dtB,dtC,dtD,fa,fb,fc,fd;
REAL *parms,gamsa,gamsb,gamsc;
UHostBondTorsion[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondTorsions[f1];i++)
{
A=Framework[CurrentSystem].BondTorsions[f1][i].A;
B=Framework[CurrentSystem].BondTorsions[f1][i].B;
C=Framework[CurrentSystem].BondTorsions[f1][i].C;
D=Framework[CurrentSystem].BondTorsions[f1][i].D;
parms=(REAL*)&Framework[CurrentSystem].BondTorsionArguments[f1][i];
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
posC=Framework[CurrentSystem].Atoms[f1][C].Position;
posD=Framework[CurrentSystem].Atoms[f1][C].Position;
Dab.x=posA.x-posB.x;
Dab.y=posA.y-posB.y;
Dab.z=posA.z-posB.z;
Dab=ApplyBoundaryCondition(Dab);
rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
Dcb.x=posC.x-posB.x;
Dcb.y=posC.y-posB.y;
Dcb.z=posC.z-posB.z;
Dcb=ApplyBoundaryCondition(Dcb);
rbc=sqrt(SQR(Dcb.x)+SQR(Dcb.y)+SQR(Dcb.z));
Dcb.x/=rbc; Dcb.y/=rbc; Dcb.z/=rbc;
Ddc.x=posD.x-posC.x;
Ddc.y=posD.y-posC.y;
Ddc.z=posD.z-posC.z;
Ddc=ApplyBoundaryCondition(Ddc);
rcd=sqrt(SQR(Ddc.x)+SQR(Ddc.y)+SQR(Ddc.z));
dot_ab=Dab.x*Dcb.x+Dab.y*Dcb.y+Dab.z*Dcb.z;
dot_cd=Ddc.x*Dcb.x+Ddc.y*Dcb.y+Ddc.z*Dcb.z;
dr.x=Dab.x-dot_ab*Dcb.x;
dr.y=Dab.y-dot_ab*Dcb.y;
dr.z=Dab.z-dot_ab*Dcb.z;
r=sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z));
dr.x/=r; dr.y/=r; dr.z/=r;
ds.x=Ddc.x-dot_cd*Dcb.x;
ds.y=Ddc.y-dot_cd*Dcb.y;
ds.z=Ddc.z-dot_cd*Dcb.z;
s=sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z));
ds.x/=s; ds.y/=s; ds.z/=s;
// compute Cos(Phi)
// Phi is defined in protein convention Phi(trans)=Pi
CosPhi=dr.x*ds.x+dr.y*ds.y+dr.z*ds.z;
// Ensure CosPhi is between -1 and 1.
CosPhi=SIGN(MIN2(fabs(CosPhi),(REAL)1.0),CosPhi);
CosPhi2=SQR(CosPhi);
switch(Framework[CurrentSystem].BondTorsionType[f1][i])
{
case MM3_BOND_TORSION_CROSS:
// (1/2)p_0(r-p_3)(1+cos(phi))+(1/2)p_1(r-p_3)(1+cos(2phi))+(1/2)p_2(r-p_3)(1+cos(3phi))
// =====================================================================================
// p_0 [kcal/A mole]
// p_1 [kcal/A mole]
// p_2 [kcal/A mole]
// p_3 [A]
temp=(rbc-parms[3]);
energy=parms[0]*temp*CosPhi+parms[1]*temp*(2.0*CosPhi2-1.0)+parms[2]*temp*(4.0*CosPhi2*CosPhi-3.0*CosPhi);
DCos=parms[0]*temp+4.0*parms[1]*temp*CosPhi+parms[2]*temp*(12.0*CosPhi2-3.0);
gamsa=0.0;
gamsb=-(parms[0]*CosPhi+parms[1]*(2.0*CosPhi2-1.0)+parms[2]*(4.0*CosPhi2*CosPhi-3.0*CosPhi));
gamsc=0.0;
break;
default:
fprintf(stderr, "Undefined Bond-Torsion potential in routine 'CalculateFrameworkBondTorsionForce' ('framework_force.c')\n");
exit(0);
break;
}
// energy
UHostBondTorsion[CurrentSystem]+=energy;
// Calculate the first derivative vectors.
d=dot_ab/rbc;
e=dot_cd/rbc;
dtA.x=(ds.x-CosPhi*dr.x)/r;
dtA.y=(ds.y-CosPhi*dr.y)/r;
dtA.z=(ds.z-CosPhi*dr.z)/r;
dtD.x=(dr.x-CosPhi*ds.x)/s;
dtD.y=(dr.y-CosPhi*ds.y)/s;
dtD.z=(dr.z-CosPhi*ds.z)/s;
dtB.x=dtA.x*(d-1.0)+e*dtD.x;
dtB.y=dtA.y*(d-1.0)+e*dtD.y;
dtB.z=dtA.z*(d-1.0)+e*dtD.z;
dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
dtC.z=-dtD.z*(e+1.0)-d*dtA.z;
Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
Ddc.x/=rcd; Ddc.y/=rcd; Ddc.z/=rcd;
fa.x=DCos*dtA.x-gamsa*Dab.x;
fa.y=DCos*dtA.y-gamsa*Dab.y;
fa.z=DCos*dtA.z-gamsa*Dab.z;
fb.x=DCos*dtB.x+gamsb*Dcb.x+gamsa*Dab.x;
fb.y=DCos*dtB.y+gamsb*Dcb.y+gamsa*Dab.y;
fb.z=DCos*dtB.z+gamsb*Dcb.z+gamsa*Dab.z;
fc.x=DCos*dtC.x-gamsb*Dcb.x+gamsc*Ddc.x;
fc.y=DCos*dtC.y-gamsb*Dcb.y+gamsc*Ddc.y;
fc.z=DCos*dtC.z-gamsb*Dcb.z+gamsc*Ddc.z;
fd.x=DCos*dtD.x-gamsc*Ddc.x;
fd.y=DCos*dtD.y-gamsc*Ddc.y;
fd.z=DCos*dtD.z-gamsc*Ddc.z;
// forces torsion
Framework[CurrentSystem].Atoms[f1][A].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=fb.z;
Framework[CurrentSystem].Atoms[f1][C].Force.x-=fc.x;
Framework[CurrentSystem].Atoms[f1][C].Force.y-=fc.y;
Framework[CurrentSystem].Atoms[f1][C].Force.z-=fc.z;
Framework[CurrentSystem].Atoms[f1][D].Force.x-=fd.x;
Framework[CurrentSystem].Atoms[f1][D].Force.y-=fd.y;
Framework[CurrentSystem].Atoms[f1][D].Force.z-=fd.z;
// add contribution to the stress tensor
StrainDerivativeTensor[CurrentSystem].ax+=rbc*Dcb.x*(fc.x+fd.x)+rab*Dab.x*fa.x+rcd*Ddc.x*fd.x;
StrainDerivativeTensor[CurrentSystem].ay+=rbc*Dcb.x*(fc.y+fd.y)+rab*Dab.x*fa.y+rcd*Ddc.x*fd.y;
StrainDerivativeTensor[CurrentSystem].az+=rbc*Dcb.x*(fc.z+fd.z)+rab*Dab.x*fa.z+rcd*Ddc.x*fd.z;
StrainDerivativeTensor[CurrentSystem].bx+=rbc*Dcb.y*(fc.x+fd.x)+rab*Dab.y*fa.x+rcd*Ddc.y*fd.x;
StrainDerivativeTensor[CurrentSystem].by+=rbc*Dcb.y*(fc.y+fd.y)+rab*Dab.y*fa.y+rcd*Ddc.y*fd.y;
StrainDerivativeTensor[CurrentSystem].bz+=rbc*Dcb.y*(fc.z+fd.z)+rab*Dab.y*fa.z+rcd*Ddc.y*fd.z;
StrainDerivativeTensor[CurrentSystem].cx+=rbc*Dcb.z*(fc.x+fd.x)+rab*Dab.z*fa.x+rcd*Ddc.z*fd.x;
StrainDerivativeTensor[CurrentSystem].cy+=rbc*Dcb.z*(fc.y+fd.y)+rab*Dab.z*fa.y+rcd*Ddc.z*fd.y;
StrainDerivativeTensor[CurrentSystem].cz+=rbc*Dcb.z*(fc.z+fd.z)+rab*Dab.z*fa.z+rcd*Ddc.z*fd.z;
}
}
}
}
int CalculateFrameworkIntraVDWForce(void)
{
int i,j,typeA,typeB;
REAL energy,force_factor;
REAL rr,ReductionA,ReductionB;
VECTOR pos,posA,posB,dr,f;
VECTOR posA1,posA2,posB1,posB2;
VECTOR drA,drB,fa,fb,v,w;
int ConnectedAtomA1,ConnectedAtomA2;
int ConnectedAtomB1,ConnectedAtomB2;
REAL ra,rb,length_v,length_w,dot_product;
int f1,f2,A,B;
REAL *parms;
// Framework-Framework energy
UHostHostVDW[CurrentSystem]=0.0;
if(!InternalFrameworkLennardJonesInteractions) return 0;
// contributions from intra-framework
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
posA=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;
ReductionA=0.0;
ConnectedAtomA1=ConnectedAtomA2=-1;
ra=drA.x=drA.y=drA.z=0.0;
v.x=v.y=v.z=length_v=0.0;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][i])
{
case 0:
break;
case 1:
ConnectedAtomA1=Framework[CurrentSystem].Neighbours[f1][i][0];
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
ReductionA=1.0+PseudoAtoms[typeA].AnisotropicDisplacement;
else
{
posA1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Position;
pos=Framework[CurrentSystem].Atoms[f1][i].Position;
drA.x=posA1.x-pos.x;
drA.y=posA1.y-pos.y;
drA.z=posA1.z-pos.z;
drA=ApplyBoundaryCondition(drA);
ra=sqrt(SQR(drA.x)+SQR(drA.y)+SQR(drA.z));
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
}
break;
case 2:
switch(Framework[CurrentSystem].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
ConnectedAtomA1=Framework[CurrentSystem].Neighbours[f1][i][0];
ConnectedAtomA2=Framework[CurrentSystem].Neighbours[f1][i][1];
pos=Framework[CurrentSystem].Atoms[f1][i].Position;
posA1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Position;
v.x=pos.x-0.5*(posA1.x+posA2.x);
v.y=pos.y-0.5*(posA1.y+posA2.y);
v.z=pos.z-0.5*(posA1.z+posA2.z);
v=ApplyBoundaryCondition(v);
length_v=sqrt(SQR(v.x)+SQR(v.y)+SQR(v.z));
break;
default:
fprintf(stderr, "ERROR: unknown Anisotropy type in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
break;
default:
break;
}
}
for(j=i+1;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
{
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],0))
{
typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
posB=Framework[CurrentSystem].Atoms[f1][j].AnisotropicPosition;
ReductionB=0.0;
ConnectedAtomB1=ConnectedAtomB2=-1;
rb=drB.x=drB.y=drB.z=0.0;
w.x=w.y=w.z=length_w=0.0;
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][j])
{
case 0:
break;
case 1:
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f1][j][0];
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
ReductionB=1.0+PseudoAtoms[typeB].AnisotropicDisplacement;
else
{
posB1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Position;
pos=Framework[CurrentSystem].Atoms[f1][j].Position;
drB.x=posB1.x-pos.x;
drB.y=posB1.y-pos.y;
drB.z=posB1.z-pos.z;
drB=ApplyBoundaryCondition(drB);
rb=sqrt(SQR(drB.x)+SQR(drB.y)+SQR(drB.z));
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
}
break;
case 2:
switch(Framework[CurrentSystem].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f1][j][0];
ConnectedAtomB2=Framework[CurrentSystem].Neighbours[f1][j][1];
pos=Framework[CurrentSystem].Atoms[f1][j].Position;
posB1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Position;
posB2=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Position;
w.x=pos.x-0.5*(posB1.x+posB2.x);
w.y=pos.y-0.5*(posB1.y+posB2.y);
w.z=pos.z-0.5*(posB1.z+posB2.z);
w=ApplyBoundaryCondition(w);
length_w=sqrt(SQR(w.x)+SQR(w.y)+SQR(w.z));
break;
default:
fprintf(stderr, "ERROR: unknown Anisotropy type in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
break;
default:
break;
}
}
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
UHostHostVDW[CurrentSystem]+=energy;
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][i])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x-=ReductionA*f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=ReductionA*f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=ReductionA*f.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.x-=(1.0-ReductionA)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.y-=(1.0-ReductionA)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.z-=(1.0-ReductionA)*f.z;
}
else
{
dot_product=dr.x*drA.x+dr.y*drA.y+dr.z*drA.z;
fa.x=(-(ReductionA*drA.x*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.x))*force_factor;
fa.y=(-(ReductionA*drA.y*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.y))*force_factor;
fa.z=(-(ReductionA*drA.z*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.z))*force_factor;
fb.x=(ReductionA*drA.x*dot_product/CUBE(ra)-(ReductionA/ra)*dr.x)*force_factor;
fb.y=(ReductionA*drA.y*dot_product/CUBE(ra)-(ReductionA/ra)*dr.y)*force_factor;
fb.z=(ReductionA*drA.z*dot_product/CUBE(ra)-(ReductionA/ra)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][i].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.z-=fb.z;
}
break;
case 2:
dot_product=v.x*dr.x+v.y*dr.y+v.z*dr.z;
fa.x=0.5*(ReductionA*v.x*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.x)*force_factor;
fa.y=0.5*(ReductionA*v.y*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.y)*force_factor;
fa.z=0.5*(ReductionA*v.z*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.z)*force_factor;
fb.x=(-ReductionA*v.x*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.x)*force_factor;
fb.y=(-ReductionA*v.y*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.y)*force_factor;
fb.z=(-ReductionA*v.z*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][i].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=fb.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Force.z-=fa.z;
break;
default:
fprintf(stderr, "ERROR: Not yet implemented in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
}
else
{
Framework[CurrentSystem].Atoms[f1][i].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=f.z;
}
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][j])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
{
Framework[CurrentSystem].Atoms[f1][j].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z+=ReductionB*f.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=(1.0-ReductionB)*f.z;
}
else
{
dot_product=dr.x*drB.x+dr.y*drB.y+dr.z*drB.z;
fa.x=(-(ReductionB*drA.x*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.x))*force_factor;
fa.y=(-(ReductionB*drA.y*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.y))*force_factor;
fa.z=(-(ReductionB*drA.z*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.z))*force_factor;
fb.x=(ReductionB*drB.x*dot_product/CUBE(rb)-(ReductionB/rb)*dr.x)*force_factor;
fb.y=(ReductionB*drB.y*dot_product/CUBE(rb)-(ReductionB/rb)*dr.y)*force_factor;
fb.z=(ReductionB*drB.z*dot_product/CUBE(rb)-(ReductionB/rb)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][j].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=fb.z;
}
break;
case 2:
dot_product=w.x*dr.x+w.y*dr.y+w.z*dr.z;
fa.x=0.5*(ReductionB*w.x*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.x)*force_factor;
fa.y=0.5*(ReductionB*w.y*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.y)*force_factor;
fa.z=0.5*(ReductionB*w.z*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.z)*force_factor;
fb.x=(-ReductionB*w.x*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.x)*force_factor;
fb.y=(-ReductionB*w.y*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.y)*force_factor;
fb.z=(-ReductionB*w.z*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][j].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.z+=fa.z;
break;
default:
fprintf(stderr, "ERROR: Not yet implemented in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
}
else
{
Framework[CurrentSystem].Atoms[f1][j].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z+=f.z;
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
}
}
}
// contributions from interactions between the frameworks
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
posA=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;
ReductionA=0.0;
ConnectedAtomA1=ConnectedAtomA2=-1;
ra=drA.x=drA.y=drA.z=0.0;
v.x=v.y=v.z=length_v=0.0;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][i])
{
case 0:
break;
case 1:
ConnectedAtomA1=Framework[CurrentSystem].Neighbours[f1][i][0];
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
ReductionA=1.0+PseudoAtoms[typeA].AnisotropicDisplacement;
else
{
posA1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Position;
pos=Framework[CurrentSystem].Atoms[f1][i].Position;
drA.x=posA1.x-pos.x;
drA.y=posA1.y-pos.y;
drA.z=posA1.z-pos.z;
drA=ApplyBoundaryCondition(drA);
ra=sqrt(SQR(drA.x)+SQR(drA.y)+SQR(drA.z));
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
}
break;
case 2:
switch(Framework[CurrentSystem].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
ConnectedAtomA1=Framework[CurrentSystem].Neighbours[f1][i][0];
ConnectedAtomA2=Framework[CurrentSystem].Neighbours[f1][i][1];
pos=Framework[CurrentSystem].Atoms[f1][i].Position;
posA1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Position;
v.x=pos.x-0.5*(posA1.x+posA2.x);
v.y=pos.y-0.5*(posA1.y+posA2.y);
v.z=pos.z-0.5*(posA1.z+posA2.z);
v=ApplyBoundaryCondition(v);
length_v=sqrt(SQR(v.x)+SQR(v.y)+SQR(v.z));
break;
default:
fprintf(stderr, "ERROR: unknown Anisotropy type in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
break;
default:
break;
}
}
for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
{
typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
posB=Framework[CurrentSystem].Atoms[f2][j].AnisotropicPosition;
ReductionB=0.0;
ConnectedAtomB1=ConnectedAtomB2=-1;
rb=drB.x=drB.y=drB.z=0.0;
w.x=w.y=w.z=length_w=0.0;
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f2][j])
{
case 0:
break;
case 1:
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f2][j][0];
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
ReductionB=1.0+PseudoAtoms[typeB].AnisotropicDisplacement;
else
{
posB1=Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Position;
pos=Framework[CurrentSystem].Atoms[f2][j].Position;
drB.x=posB1.x-pos.x;
drB.y=posB1.y-pos.y;
drB.z=posB1.z-pos.z;
drB=ApplyBoundaryCondition(drB);
rb=sqrt(SQR(drB.x)+SQR(drB.y)+SQR(drB.z));
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
}
break;
case 2:
switch(Framework[CurrentSystem].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f2][j][0];
ConnectedAtomB2=Framework[CurrentSystem].Neighbours[f2][j][1];
pos=Framework[CurrentSystem].Atoms[f2][j].Position;
posB1=Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Position;
posB2=Framework[CurrentSystem].Atoms[f2][ConnectedAtomB2].Position;
w.x=pos.x-0.5*(posB1.x+posB2.x);
w.y=pos.y-0.5*(posB1.y+posB2.y);
w.z=pos.z-0.5*(posB1.z+posB2.z);
w=ApplyBoundaryCondition(w);
length_w=sqrt(SQR(w.x)+SQR(w.y)+SQR(w.z));
break;
default:
fprintf(stderr, "ERROR: unknown Anisotropy type in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
break;
default:
break;
}
}
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
UHostHostVDW[CurrentSystem]+=energy;
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][i])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x-=ReductionA*f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=ReductionA*f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=ReductionA*f.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.x-=(1.0-ReductionA)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.y-=(1.0-ReductionA)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.z-=(1.0-ReductionA)*f.z;
}
else
{
dot_product=dr.x*drA.x+dr.y*drA.y+dr.z*drA.z;
fa.x=(-(ReductionA*drA.x*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.x))*force_factor;
fa.y=(-(ReductionA*drA.y*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.y))*force_factor;
fa.z=(-(ReductionA*drA.z*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.z))*force_factor;
fb.x=(ReductionA*drA.x*dot_product/CUBE(ra)-(ReductionA/ra)*dr.x)*force_factor;
fb.y=(ReductionA*drA.y*dot_product/CUBE(ra)-(ReductionA/ra)*dr.y)*force_factor;
fb.z=(ReductionA*drA.z*dot_product/CUBE(ra)-(ReductionA/ra)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][i].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.z-=fb.z;
}
break;
case 2:
dot_product=v.x*dr.x+v.y*dr.y+v.z*dr.z;
fa.x=0.5*(ReductionA*v.x*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.x)*force_factor;
fa.y=0.5*(ReductionA*v.y*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.y)*force_factor;
fa.z=0.5*(ReductionA*v.z*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.z)*force_factor;
fb.x=(-ReductionA*v.x*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.x)*force_factor;
fb.y=(-ReductionA*v.y*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.y)*force_factor;
fb.z=(-ReductionA*v.z*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA1].Force.z-=fa.z;
Framework[CurrentSystem].Atoms[f1][i].Force.x-=fb.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=fb.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=fb.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Force.x-=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Force.y-=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA2].Force.z-=fa.z;
break;
default:
fprintf(stderr, "ERROR: Not yet implemented in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
}
else
{
Framework[CurrentSystem].Atoms[f1][i].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=f.z;
}
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f2][j])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
{
Framework[CurrentSystem].Atoms[f2][j].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z+=ReductionB*f.z;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.z+=(1.0-ReductionB)*f.z;
}
else
{
dot_product=dr.x*drB.x+dr.y*drB.y+dr.z*drB.z;
fa.x=(-(ReductionB*drA.x*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.x))*force_factor;
fa.y=(-(ReductionB*drA.y*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.y))*force_factor;
fa.z=(-(ReductionB*drA.z*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.z))*force_factor;
fb.x=(ReductionB*drB.x*dot_product/CUBE(rb)-(ReductionB/rb)*dr.x)*force_factor;
fb.y=(ReductionB*drB.y*dot_product/CUBE(rb)-(ReductionB/rb)*dr.y)*force_factor;
fb.z=(ReductionB*drB.z*dot_product/CUBE(rb)-(ReductionB/rb)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f2][j].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.z+=fb.z;
}
break;
case 2:
dot_product=w.x*dr.x+w.y*dr.y+w.z*dr.z;
fa.x=0.5*(ReductionB*w.x*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.x)*force_factor;
fa.y=0.5*(ReductionB*w.y*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.y)*force_factor;
fa.z=0.5*(ReductionB*w.z*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.z)*force_factor;
fb.x=(-ReductionB*w.x*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.x)*force_factor;
fb.y=(-ReductionB*w.y*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.y)*force_factor;
fb.z=(-ReductionB*w.z*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB1].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f2][j].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB2].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB2].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB2].Force.z+=fa.z;
break;
default:
fprintf(stderr, "ERROR: Not yet implemented in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
}
else
{
Framework[CurrentSystem].Atoms[f2][j].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z+=f.z;
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
}
}
// contributions from interactions 1-4 torsions
// TODO: fix to handle anisotropic sites
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
{
parms=Framework[CurrentSystem].TorsionArguments[f1][i];
if(fabs(parms[6])>1e-8)
{
A=Framework[CurrentSystem].Torsions[f1][i].A;
typeA=Framework[CurrentSystem].Atoms[f1][A].Type;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
B=Framework[CurrentSystem].Torsions[f1][i].D;
typeB=Framework[CurrentSystem].Atoms[f1][B].Type;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
{
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
UHostHostVDW[CurrentSystem]+=parms[6]*energy;
force_factor=parms[6]*force_factor;
StrainDerivativeTensor[CurrentSystem].ax+=force_factor*dr.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=force_factor*dr.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=force_factor*dr.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=force_factor*dr.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=force_factor*dr.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=force_factor*dr.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=force_factor*dr.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=force_factor*dr.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=force_factor*dr.z*dr.z;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Framework[CurrentSystem].Atoms[f1][A].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z-=f.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z+=f.z;
}
}
}
}
}
return 0;
}
int CalculateFrameworkIntraChargeChargeForce(void)
{
int i,j,typeA,typeB;
REAL chargeA,chargeB;
REAL r,rr,energy,DF;
VECTOR posA,posB,dr,f;
int f1,f2,A,B;
REAL *parms;
REAL alpha;
// Framework-Framework energy
UHostHostChargeChargeReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
// contributions from intra-framework
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
chargeA=Framework[CurrentSystem].Atoms[f1][i].Charge;
for(j=i+1;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
{
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],1))
{
typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
posB=Framework[CurrentSystem].Atoms[f1][j].Position;
chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&DF);
UHostHostChargeChargeReal[CurrentSystem]+=energy;
f.x=-DF*dr.x;
f.y=-DF*dr.y;
f.z=-DF*dr.z;
Framework[CurrentSystem].Atoms[f1][i].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z+=f.z;
Framework[CurrentSystem].Atoms[f1][j].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z-=f.z;
StrainDerivativeTensor[CurrentSystem].ax-=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx-=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx-=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay-=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by-=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy-=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az-=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz-=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz-=f.z*dr.z;
}
}
}
}
}
}
// contributions from interactions between the frameworks
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
chargeA=Framework[CurrentSystem].Atoms[f1][i].Charge;
for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
{
typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
posB=Framework[CurrentSystem].Atoms[f2][j].Position;
chargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&DF);
UHostHostChargeChargeReal[CurrentSystem]+=energy;
f.x=-DF*dr.x;
f.y=-DF*dr.y;
f.z=-DF*dr.z;
Framework[CurrentSystem].Atoms[f1][i].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z+=f.z;
Framework[CurrentSystem].Atoms[f2][j].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z-=f.z;
StrainDerivativeTensor[CurrentSystem].ax-=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx-=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx-=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay-=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by-=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy-=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az-=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz-=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz-=f.z*dr.z;
}
}
}
}
}
// contributions from interactions 1-4 torsions
// TODO: fix to handle anisotropic sites
alpha=Alpha[CurrentSystem];
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
{
parms=Framework[CurrentSystem].TorsionArguments[f1][i];
if(fabs(parms[7])>1e-8)
{
A=Framework[CurrentSystem].Torsions[f1][i].A;
chargeA=Framework[CurrentSystem].Atoms[f1][A].Charge;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
B=Framework[CurrentSystem].Torsions[f1][i].D;
chargeB=Framework[CurrentSystem].Atoms[f1][B].Charge;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
{
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
r=sqrt(rr);
// note: no cutoff used here
switch(ChargeMethod)
{
case NONE:
DF=0.0;
break;
case SHIFTED_COULOMB:
case TRUNCATED_COULOMB:
case EWALD:
default:
UHostHostChargeChargeReal[CurrentSystem]+=parms[7]*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/r;
DF=parms[7]*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/(rr*r);
break;
}
StrainDerivativeTensor[CurrentSystem].ax-=DF*dr.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx-=DF*dr.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx-=DF*dr.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay-=DF*dr.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by-=DF*dr.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy-=DF*dr.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az-=DF*dr.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz-=DF*dr.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz-=DF*dr.z*dr.z;
Framework[CurrentSystem].Atoms[f1][A].Force.x+=DF*dr.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=DF*dr.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=DF*dr.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=DF*dr.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=DF*dr.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=DF*dr.z;
}
}
}
}
}
return 0;
}
int CalculateFrameworkIntraChargeBondDipoleForce(void)
{
int i,j,f1,f2;
int A1,A2;
int Type;
VECTOR posA,posB,posA1,posA2,dr;
REAL rr,ri2,energy,temp,length,chargeB;
VECTOR dipoleA,fb1,fa1,fa2,term;
REAL DipoleMagnitudeA;
REAL_MATRIX3x3 v;
v.ax=v.bx=v.cx=0.0;
v.ay=v.by=v.cy=0.0;
v.az=v.bz=v.cz=0.0;
UHostHostChargeBondDipoleReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
// contributions from intra-framework
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
dipoleA=ApplyBoundaryCondition(dipoleA);
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
{
// if framework are different, or if they are the same but not excluded within the framework
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][j][i],2))
{
Type=Framework[CurrentSystem].Atoms[f1][j].Type;
if(PseudoAtoms[Type].HasCharges)
{
posB=Framework[CurrentSystem].Atoms[f1][j].Position;
chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeBondDipoleSquared)
{
PotentialGradientChargeBondDipole(chargeB,DipoleMagnitudeA,length,dipoleA,dr,rr,&energy,&fa1,&fa2,&fb1,&term);
UHostHostChargeBondDipoleReal[CurrentSystem]-=energy;
Framework[CurrentSystem].Atoms[f1][j].Force.x+=fb1.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y+=fb1.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z+=fb1.z;
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
// convert forces on atoms to molecular virial
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
}
}
// contributions from interactions between the frameworks
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(f2=0;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
if(f1!=f2)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
dipoleA=ApplyBoundaryCondition(dipoleA);
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
{
Type=Framework[CurrentSystem].Atoms[f2][j].Type;
if(PseudoAtoms[Type].HasCharges)
{
posB=Framework[CurrentSystem].Atoms[f2][j].Position;
chargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeBondDipoleSquared)
{
PotentialGradientChargeBondDipole(chargeB,DipoleMagnitudeA,length,dipoleA,dr,rr,&energy,&fa1,&fa2,&fb1,&term);
UHostHostChargeBondDipoleReal[CurrentSystem]-=energy;
Framework[CurrentSystem].Atoms[f1][j].Force.x+=fb1.x;
Framework[CurrentSystem].Atoms[f1][j].Force.y+=fb1.y;
Framework[CurrentSystem].Atoms[f1][j].Force.z+=fb1.z;
Framework[CurrentSystem].Atoms[f2][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f2][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f2][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f2][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f2][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f2][A2].Force.z+=fa2.z;
// convert forces on atoms to molecular virial
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
}
}
return 0;
}
int CalculateFrameworkIntraBondDipoleBondDipoleForce(void)
{
int i,j,f1,f2;
int A1,A2,B1,B2;
VECTOR posA,posB,posA1,posA2,posB1,posB2,dr;
REAL ri2,rk2,energy,temp,length;
VECTOR dipoleA,dipoleB,fb1,fb2,fa1,fa2,term;
REAL DipoleMagnitudeA,DipoleMagnitudeB;
REAL_MATRIX3x3 v;
REAL r2;
v.ax=v.bx=v.cx=0.0;
v.ay=v.by=v.cy=0.0;
v.az=v.bz=v.cz=0.0;
UHostHostBondDipoleBondDipoleReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
// contributions from intra-framework
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
dipoleA=ApplyBoundaryCondition(dipoleA);
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(j=i+1;j<Framework[CurrentSystem].NumberOfBondDipoles[f1];j++)
{
DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][j];
B1=Framework[CurrentSystem].BondDipoles[f1][j].A;
B2=Framework[CurrentSystem].BondDipoles[f1][j].B;
// if framework are different, or if they are the same but not excluded within the framework
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],3))
{
posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;
dipoleB.x=posB2.x-posB1.x;
dipoleB.y=posB2.y-posB1.y;
dipoleB.z=posB2.z-posB1.z;
dipoleB=ApplyBoundaryCondition(dipoleB);
posB.x=posB1.x+0.5*dipoleB.x;
posB.y=posB1.y+0.5*dipoleB.y;
posB.z=posB1.z+0.5*dipoleB.z;
rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
length=sqrt(rk2);
temp=DipoleMagnitudeB/length;
dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
r2=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(r2<CutOffBondDipoleBondDipoleSquared)
{
PotentialGradientBondDipoleBondDipole(DipoleMagnitudeA,ri2,dipoleA,DipoleMagnitudeB,rk2,dipoleB,dr,r2,
&energy,&fa1,&fa2,&fb1,&fb2,&term);
UHostHostBondDipoleBondDipoleReal[CurrentSystem]+=energy;
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
Framework[CurrentSystem].Atoms[f1][B1].Force.x+=fb1.x;
Framework[CurrentSystem].Atoms[f1][B1].Force.y+=fb1.y;
Framework[CurrentSystem].Atoms[f1][B1].Force.z+=fb1.z;
Framework[CurrentSystem].Atoms[f1][B2].Force.x+=fb2.x;
Framework[CurrentSystem].Atoms[f1][B2].Force.y+=fb2.y;
Framework[CurrentSystem].Atoms[f1][B2].Force.z+=fb2.z;
// convert forces on atoms to molecular virial
// usually this conversion produces a torque on the center of mass and an asymmetric stress
// by making it symmetric we regain the 'atomic' strain derivative
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x)+fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x)+fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x)+fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y)+fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y)+fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y)+fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z)+fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z)+fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z)+fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
}
// contributions from interactions between the frameworks
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
dipoleA=ApplyBoundaryCondition(dipoleA);
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(j=0;j<Framework[CurrentSystem].NumberOfBondDipoles[f2];j++)
{
DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f2][j];
B1=Framework[CurrentSystem].BondDipoles[f2][j].A;
B2=Framework[CurrentSystem].BondDipoles[f2][j].B;
posB1=Framework[CurrentSystem].Atoms[f2][B1].Position;
posB2=Framework[CurrentSystem].Atoms[f2][B2].Position;
dipoleB.x=posB2.x-posB1.x;
dipoleB.y=posB2.y-posB1.y;
dipoleB.z=posB2.z-posB1.z;
dipoleB=ApplyBoundaryCondition(dipoleB);
posB.x=posB1.x+0.5*dipoleB.x;
posB.y=posB1.y+0.5*dipoleB.y;
posB.z=posB1.z+0.5*dipoleB.z;
rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
length=sqrt(rk2);
temp=DipoleMagnitudeB/length;
dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
r2=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(r2<CutOffBondDipoleBondDipoleSquared)
{
PotentialGradientBondDipoleBondDipole(DipoleMagnitudeA,ri2,dipoleA,DipoleMagnitudeB,rk2,dipoleB,dr,r2,
&energy,&fa1,&fa2,&fb1,&fb2,&term);
UHostHostBondDipoleBondDipoleReal[CurrentSystem]+=energy;
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
Framework[CurrentSystem].Atoms[f2][B1].Force.x+=fb1.x;
Framework[CurrentSystem].Atoms[f2][B1].Force.y+=fb1.y;
Framework[CurrentSystem].Atoms[f2][B1].Force.z+=fb1.z;
Framework[CurrentSystem].Atoms[f2][B2].Force.x+=fb2.x;
Framework[CurrentSystem].Atoms[f2][B2].Force.y+=fb2.y;
Framework[CurrentSystem].Atoms[f2][B2].Force.z+=fb2.z;
// convert forces on atoms to molecular virial
// usually this conversion produces a torque on the center of mass and an asymmetric stress
// by making it symmetric we regain the 'atomic' strain derivative
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x)+fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x)+fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x)+fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y)+fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y)+fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y)+fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z)+fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z)+fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z)+fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
return 0;
}
void CalculateFrameworkAdsorbateVDWForce(void)
{
int i,j,k,f1;
int typeA,typeB,TypeMolA;
REAL rr,scalingA;
REAL energy,force_factor;
VECTOR posA,posB,dr,f;
REAL ReductionA,ReductionB;
VECTOR drA,drB,fa,fb;
VECTOR pos,posA1,posA2,posB1,posB2;
REAL ra,rb;
int ConnectedAtomA1,ConnectedAtomA2;
int ConnectedAtomB1,ConnectedAtomB2;
VECTOR v,w;
REAL length_v,length_w;
REAL dot_product;
UHostAdsorbateVDW[CurrentSystem]=0.0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
TypeMolA=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
posA=Adsorbates[CurrentSystem][i].Atoms[j].AnisotropicPosition;
scalingA=Adsorbates[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;
ReductionA=0.0;
ConnectedAtomA1=ConnectedAtomA2=-1;
ra=drA.x=drA.y=drA.z=0.0;
v.x=v.y=v.z=length_v=0.0;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Components[TypeMolA].Connectivity[j])
{
case 0:
break;
case 1:
ConnectedAtomA1=Components[TypeMolA].ConnectivityList[j][0];
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
ReductionA=1.0+PseudoAtoms[typeA].AnisotropicDisplacement;
else
{
posA1=Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Position;
pos=Adsorbates[CurrentSystem][i].Atoms[j].Position;
drA.x=posA1.x-pos.x;
drA.y=posA1.y-pos.y;
drA.z=posA1.z-pos.z;
ra=sqrt(SQR(drA.x)+SQR(drA.y)+SQR(drA.z));
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
}
break;
case 2:
switch(Components[TypeMolA].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateTotalInterVDWForce' (inter_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
ConnectedAtomA1=Components[TypeMolA].ConnectivityList[j][0];
ConnectedAtomA2=Components[TypeMolA].ConnectivityList[j][1];
pos=Adsorbates[CurrentSystem][i].Atoms[j].Position;
posA1=Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Position;
posA2=Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA2].Position;
v.x=pos.x-0.5*(posA1.x+posA2.x);
v.y=pos.y-0.5*(posA1.y+posA2.y);
v.z=pos.z-0.5*(posA1.z+posA2.z);
length_v=sqrt(SQR(v.x)+SQR(v.y)+SQR(v.z));
break;
default:
fprintf(stderr, "ERROR!\n");
exit(0);
break;
}
break;
default:
break;
}
}
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&(!IsFractionalAdsorbateMolecule(i)))
{
UHostAdsorbateVDW[CurrentSystem]+=InterpolateVDWForceGrid(typeA,posA,&f);
Adsorbates[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
ReductionB=0.0;
ConnectedAtomB1=ConnectedAtomB2=-1;
rb=drB.x=drB.y=drB.z=0.0;
w.x=w.y=w.z=length_w=0.0;
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][k])
{
case 0:
break;
case 1:
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f1][k][0];
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
ReductionB=1.0+PseudoAtoms[typeB].AnisotropicDisplacement;
else
{
posB1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Position;
pos=Framework[CurrentSystem].Atoms[f1][k].Position;
drB.x=posB1.x-pos.x;
drB.y=posB1.y-pos.y;
drB.z=posB1.z-pos.z;
drB=ApplyBoundaryCondition(drB);
rb=sqrt(SQR(drB.x)+SQR(drB.y)+SQR(drB.z));
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
}
break;
case 2:
switch(Framework[CurrentSystem].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f1][k][0];
ConnectedAtomB2=Framework[CurrentSystem].Neighbours[f1][k][1];
pos=Framework[CurrentSystem].Atoms[f1][k].Position;
posB1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Position;
posB2=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Position;
w.x=pos.x-0.5*(posB1.x+posB2.x);
w.y=pos.y-0.5*(posB1.y+posB2.y);
w.z=pos.z-0.5*(posB1.z+posB2.z);
w=ApplyBoundaryCondition(w);
length_w=sqrt(SQR(w.x)+SQR(w.y)+SQR(w.z));
break;
default:
fprintf(stderr, "ERROR: unknown Anisotropy type in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
break;
default:
break;
}
}
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
// compute the energy and force-factor
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,scalingA);
// energy
UHostAdsorbateVDW[CurrentSystem]+=energy;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Components[TypeMolA].Connectivity[j])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
{
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=ReductionA*f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=ReductionA*f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=ReductionA*f.z;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.x-=(1.0-ReductionA)*f.x;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.y-=(1.0-ReductionA)*f.y;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.z-=(1.0-ReductionA)*f.z;
}
else
{
dot_product=dr.x*drA.x+dr.y*drA.y+dr.z*drA.z;
fa.x=(-ReductionA*drA.x*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.x)*force_factor;
fa.y=(-ReductionA*drA.y*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.y)*force_factor;
fa.z=(-ReductionA*drA.z*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.z)*force_factor;
fb.x=(ReductionA*drA.x*dot_product/CUBE(ra)-(ReductionA/ra)*dr.x)*force_factor;
fb.y=(ReductionA*drA.y*dot_product/CUBE(ra)-(ReductionA/ra)*dr.y)*force_factor;
fb.z=(ReductionA*drA.z*dot_product/CUBE(ra)-(ReductionA/ra)*dr.z)*force_factor;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.x-=fb.x;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.y-=fb.y;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.z-=fb.z;
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=fa.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=fa.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=fa.z;
}
break;
case 2:
dot_product=v.x*dr.x+v.y*dr.y+v.z*dr.z;
fa.x=0.5*(ReductionA*v.x*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.x)*force_factor;
fa.y=0.5*(ReductionA*v.y*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.y)*force_factor;
fa.z=0.5*(ReductionA*v.z*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.z)*force_factor;
fb.x=(-ReductionA*v.x*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.x)*force_factor;
fb.y=(-ReductionA*v.y*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.y)*force_factor;
fb.z=(-ReductionA*v.z*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.z)*force_factor;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.x-=fa.x;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.y-=fa.y;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.z-=fa.z;
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=fb.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=fb.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=fb.z;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA2].Force.x-=fa.x;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA2].Force.y-=fa.y;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA2].Force.z-=fa.z;
break;
default:
fprintf(stderr, "Not yet implemented in routine 'CalculateTotalInterVDWForce'\n");
exit(0);
break;
}
}
else
{
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=f.z;
}
// only if the framework is flexible do we need to compute the forces on the framework atoms
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][k])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=ReductionB*f.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=(1.0-ReductionB)*f.z;
}
else
{
dot_product=dr.x*drB.x+dr.y*drB.y+dr.z*drB.z;
fa.x=(-(ReductionB*drA.x*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.x))*force_factor;
fa.y=(-(ReductionB*drA.y*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.y))*force_factor;
fa.z=(-(ReductionB*drA.z*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.z))*force_factor;
fb.x=(ReductionB*drB.x*dot_product/CUBE(rb)-(ReductionB/rb)*dr.x)*force_factor;
fb.y=(ReductionB*drB.y*dot_product/CUBE(rb)-(ReductionB/rb)*dr.y)*force_factor;
fb.z=(ReductionB*drB.z*dot_product/CUBE(rb)-(ReductionB/rb)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][k].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=fb.z;
}
break;
case 2:
dot_product=w.x*dr.x+w.y*dr.y+w.z*dr.z;
fa.x=0.5*(ReductionB*w.x*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.x)*force_factor;
fa.y=0.5*(ReductionB*w.y*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.y)*force_factor;
fa.z=0.5*(ReductionB*w.z*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.z)*force_factor;
fb.x=(-ReductionB*w.x*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.x)*force_factor;
fb.y=(-ReductionB*w.y*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.y)*force_factor;
fb.z=(-ReductionB*w.z*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][k].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.z+=fa.z;
break;
default:
fprintf(stderr, "ERROR: Not yet implemented in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
}
else
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=f.z;
}
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
}
}
}
}
void CalculateFrameworkCationVDWForce(void)
{
int i,j,k,f1;
int typeA,typeB,TypeMolA;
REAL rr,scalingA;
REAL energy,force_factor;
VECTOR posA,posB,dr,f;
REAL ReductionA,ReductionB;
VECTOR drA,drB,fa,fb;
VECTOR pos,posA1,posA2,posB1,posB2;
REAL ra,rb;
int ConnectedAtomA1,ConnectedAtomA2;
int ConnectedAtomB1,ConnectedAtomB2;
VECTOR v,w;
REAL length_v,length_w;
REAL dot_product;
UHostCationVDW[CurrentSystem]=0.0;
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
TypeMolA=Cations[CurrentSystem][i].Type;
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Cations[CurrentSystem][i].Atoms[j].Type;
posA=Cations[CurrentSystem][i].Atoms[j].AnisotropicPosition;
scalingA=Cations[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;
ReductionA=0.0;
ConnectedAtomA1=ConnectedAtomA2=-1;
ra=drA.x=drA.y=drA.z=0.0;
v.x=v.y=v.z=length_v=0.0;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Components[TypeMolA].Connectivity[j])
{
case 0:
break;
case 1:
ConnectedAtomA1=Components[TypeMolA].ConnectivityList[j][0];
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
ReductionA=1.0+PseudoAtoms[typeA].AnisotropicDisplacement;
else
{
posA1=Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Position;
pos=Cations[CurrentSystem][i].Atoms[j].Position;
drA.x=posA1.x-pos.x;
drA.y=posA1.y-pos.y;
drA.z=posA1.z-pos.z;
ra=sqrt(SQR(drA.x)+SQR(drA.y)+SQR(drA.z));
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
}
break;
case 2:
switch(Components[TypeMolA].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateTotalInterVDWForce' (inter_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionA=PseudoAtoms[typeA].AnisotropicDisplacement;
ConnectedAtomA1=Components[TypeMolA].ConnectivityList[j][0];
ConnectedAtomA2=Components[TypeMolA].ConnectivityList[j][1];
pos=Cations[CurrentSystem][i].Atoms[j].Position;
posA1=Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Position;
posA2=Cations[CurrentSystem][i].Atoms[ConnectedAtomA2].Position;
v.x=pos.x-0.5*(posA1.x+posA2.x);
v.y=pos.y-0.5*(posA1.y+posA2.y);
v.z=pos.z-0.5*(posA1.z+posA2.z);
length_v=sqrt(SQR(v.x)+SQR(v.y)+SQR(v.z));
break;
default:
fprintf(stderr, "ERROR!\n");
exit(0);
break;
}
break;
default:
break;
}
}
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&(!IsFractionalCationMolecule(i)))
{
UHostCationVDW[CurrentSystem]+=InterpolateVDWForceGrid(typeA,posA,&f);
Cations[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
ReductionB=0.0;
ConnectedAtomB1=ConnectedAtomB2=-1;
rb=drB.x=drB.y=drB.z=0.0;
w.x=w.y=w.z=length_w=0.0;
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][k])
{
case 0:
break;
case 1:
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f1][k][0];
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
ReductionB=1.0+PseudoAtoms[typeB].AnisotropicDisplacement;
else
{
posB1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Position;
pos=Framework[CurrentSystem].Atoms[f1][k].Position;
drB.x=posB1.x-pos.x;
drB.y=posB1.y-pos.y;
drB.z=posB1.z-pos.z;
drB=ApplyBoundaryCondition(drB);
rb=sqrt(SQR(drB.x)+SQR(drB.y)+SQR(drB.z));
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
}
break;
case 2:
switch(Framework[CurrentSystem].AnisotropicType)
{
case ANISOTROPIC_BISECTION:
fprintf(stderr, "ERROR: 'ANISOTROPIC_BISECTION' not implemented yet in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
case ANISOTROPIC_MID_POINT:
ReductionB=PseudoAtoms[typeB].AnisotropicDisplacement;
ConnectedAtomB1=Framework[CurrentSystem].Neighbours[f1][k][0];
ConnectedAtomB2=Framework[CurrentSystem].Neighbours[f1][k][1];
pos=Framework[CurrentSystem].Atoms[f1][k].Position;
posB1=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Position;
posB2=Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Position;
w.x=pos.x-0.5*(posB1.x+posB2.x);
w.y=pos.y-0.5*(posB1.y+posB2.y);
w.z=pos.z-0.5*(posB1.z+posB2.z);
w=ApplyBoundaryCondition(w);
length_w=sqrt(SQR(w.x)+SQR(w.y)+SQR(w.z));
break;
default:
fprintf(stderr, "ERROR: unknown Anisotropy type in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
break;
default:
break;
}
}
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
// compute the energy and force-factor
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,scalingA);
// energy
UHostCationVDW[CurrentSystem]+=energy;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
if(PseudoAtoms[typeA].AnisotropicCorrection)
{
switch(Components[TypeMolA].Connectivity[j])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeA].AnisotropicType==RELATIVE)
{
Cations[CurrentSystem][i].Atoms[j].Force.x-=ReductionA*f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=ReductionA*f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=ReductionA*f.z;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.x-=(1.0-ReductionA)*f.x;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.y-=(1.0-ReductionA)*f.y;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.z-=(1.0-ReductionA)*f.z;
}
else
{
dot_product=dr.x*drA.x+dr.y*drA.y+dr.z*drA.z;
fa.x=(-ReductionA*drA.x*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.x)*force_factor;
fa.y=(-ReductionA*drA.y*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.y)*force_factor;
fa.z=(-ReductionA*drA.z*dot_product/CUBE(ra)+(1.0+ReductionA/ra)*dr.z)*force_factor;
fb.x=(ReductionA*drA.x*dot_product/CUBE(ra)-(ReductionA/ra)*dr.x)*force_factor;
fb.y=(ReductionA*drA.y*dot_product/CUBE(ra)-(ReductionA/ra)*dr.y)*force_factor;
fb.z=(ReductionA*drA.z*dot_product/CUBE(ra)-(ReductionA/ra)*dr.z)*force_factor;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.x-=fb.x;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.y-=fb.y;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.z-=fb.z;
Cations[CurrentSystem][i].Atoms[j].Force.x-=fa.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=fa.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=fa.z;
}
break;
case 2:
dot_product=v.x*dr.x+v.y*dr.y+v.z*dr.z;
fa.x=0.5*(ReductionA*v.x*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.x)*force_factor;
fa.y=0.5*(ReductionA*v.y*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.y)*force_factor;
fa.z=0.5*(ReductionA*v.z*dot_product/CUBE(length_v)-(ReductionA/length_v)*dr.z)*force_factor;
fb.x=(-ReductionA*v.x*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.x)*force_factor;
fb.y=(-ReductionA*v.y*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.y)*force_factor;
fb.z=(-ReductionA*v.z*dot_product/CUBE(length_v)+(1.0+ReductionA/length_v)*dr.z)*force_factor;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.x-=fa.x;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.y-=fa.y;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA1].Force.z-=fa.z;
Cations[CurrentSystem][i].Atoms[j].Force.x-=fb.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=fb.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=fb.z;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA2].Force.x-=fa.x;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA2].Force.y-=fa.y;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA2].Force.z-=fa.z;
break;
default:
fprintf(stderr, "Not yet implemented in routine 'CalculateTotalInterVDWForce'\n");
exit(0);
break;
}
}
else
{
Cations[CurrentSystem][i].Atoms[j].Force.x-=f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=f.z;
}
// only if the framework is flexible do we need to compute the forces on the framework atoms
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
if(PseudoAtoms[typeB].AnisotropicCorrection)
{
switch(Framework[CurrentSystem].Connectivity[f1][k])
{
case 0:
break;
case 1:
if(PseudoAtoms[typeB].AnisotropicType==RELATIVE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=ReductionB*f.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=(1.0-ReductionB)*f.z;
}
else
{
dot_product=dr.x*drB.x+dr.y*drB.y+dr.z*drB.z;
fa.x=(-(ReductionB*drA.x*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.x))*force_factor;
fa.y=(-(ReductionB*drA.y*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.y))*force_factor;
fa.z=(-(ReductionB*drA.z*dot_product/CUBE(rb)+(1.0+ReductionB/rb)*dr.z))*force_factor;
fb.x=(ReductionB*drB.x*dot_product/CUBE(rb)-(ReductionB/rb)*dr.x)*force_factor;
fb.y=(ReductionB*drB.y*dot_product/CUBE(rb)-(ReductionB/rb)*dr.y)*force_factor;
fb.z=(ReductionB*drB.z*dot_product/CUBE(rb)-(ReductionB/rb)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][k].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=fb.z;
}
break;
case 2:
dot_product=w.x*dr.x+w.y*dr.y+w.z*dr.z;
fa.x=0.5*(ReductionB*w.x*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.x)*force_factor;
fa.y=0.5*(ReductionB*w.y*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.y)*force_factor;
fa.z=0.5*(ReductionB*w.z*dot_product/CUBE(length_w)-(ReductionB/length_w)*dr.z)*force_factor;
fb.x=(-ReductionB*w.x*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.x)*force_factor;
fb.y=(-ReductionB*w.y*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.y)*force_factor;
fb.z=(-ReductionB*w.z*dot_product/CUBE(length_w)+(1.0+ReductionB/length_w)*dr.z)*force_factor;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB1].Force.z+=fa.z;
Framework[CurrentSystem].Atoms[f1][k].Force.x+=fb.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=fb.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=fb.z;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.x+=fa.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.y+=fa.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB2].Force.z+=fa.z;
break;
default:
fprintf(stderr, "ERROR: Not yet implemented in routine 'CalculateFrameworkIntraVDWForce' (framework_force.c)\n");
exit(0);
break;
}
}
else
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=f.z;
}
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
}
}
}
}
int CalculateFrameworkAdsorbateChargeChargeForce(void)
{
int i,j,k,f1;
int typeA,typeB;
REAL rr;
REAL energy,chargeA,chargeB,temp;
VECTOR posA,posB,dr,f;
REAL scalingA;
int TypeMolA;
UHostAdsorbateChargeChargeReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
TypeMolA=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
scalingA=Adsorbates[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
chargeA=scalingA*Adsorbates[CurrentSystem][i].Atoms[j].Charge;
posA=Adsorbates[CurrentSystem][i].Atoms[j].Position;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&(!IsFractionalAdsorbateMolecule(i)))
{
UHostAdsorbateChargeChargeReal[CurrentSystem]+=InterpolateCoulombForceGrid(typeA,posA,&f);
Adsorbates[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
// energy
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&temp);
UHostAdsorbateChargeChargeReal[CurrentSystem]+=energy;
// forces
f.x=temp*dr.x;
f.y=temp*dr.y;
f.z=temp*dr.z;
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=f.z;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=f.z;
}
// stress-tensor
StrainDerivativeTensor[CurrentSystem].ax+=temp*dr.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=temp*dr.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=temp*dr.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=temp*dr.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=temp*dr.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=temp*dr.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=temp*dr.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=temp*dr.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=temp*dr.z*dr.z;
}
}
}
}
}
}
return 0;
}
int CalculateFrameworkCationChargeChargeForce(void)
{
int i,j,k,f1;
int typeA,typeB;
REAL energy,rr;
REAL chargeA,chargeB,temp;
VECTOR posA,posB,dr,f;
REAL scalingA;
int TypeMolA;
UHostCationChargeChargeReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
TypeMolA=Cations[CurrentSystem][i].Type;
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Cations[CurrentSystem][i].Atoms[j].Type;
scalingA=Cations[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
chargeA=scalingA*Cations[CurrentSystem][i].Atoms[j].Charge;
posA=Cations[CurrentSystem][i].Atoms[j].Position;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&(!IsFractionalCationMolecule(i)))
{
UHostCationChargeChargeReal[CurrentSystem]+=InterpolateCoulombForceGrid(typeA,posA,&f);
Cations[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
// energy
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&temp);
UHostCationChargeChargeReal[CurrentSystem]+=energy;
// forces
f.x=temp*dr.x;
f.y=temp*dr.y;
f.z=temp*dr.z;
Cations[CurrentSystem][i].Atoms[j].Force.x-=f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=f.z;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=f.z;
}
// stress-tensor
StrainDerivativeTensor[CurrentSystem].ax+=temp*dr.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=temp*dr.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=temp*dr.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=temp*dr.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=temp*dr.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=temp*dr.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=temp*dr.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=temp*dr.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=temp*dr.z*dr.z;
}
}
}
}
}
}
return 0;
}
int CalculateFrameworkAdsorbateChargeBondDipoleForce(void)
{
int i,j,k,f1;
int A1,A2;
int Type,TypeA;
VECTOR posA,posB,posA1,posA2,dr;
REAL rr,ri2,energy,temp,length,chargeB;
VECTOR dipoleA,fb1,fa1,fa2,term;
REAL DipoleMagnitudeA;
REAL_MATRIX3x3 v;
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
v.ax=v.bx=v.cx=0.0;
v.ay=v.by=v.cy=0.0;
v.az=v.bz=v.cz=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(j=0;j<NumberOfAdsorbateMolecules[CurrentSystem];j++)
{
for(k=0;k<Adsorbates[CurrentSystem][j].NumberOfAtoms;k++)
{
Type=Adsorbates[CurrentSystem][j].Atoms[k].Type;
if(PseudoAtoms[Type].HasCharges)
{
posB=Adsorbates[CurrentSystem][j].Atoms[k].Position;
chargeB=Adsorbates[CurrentSystem][j].Atoms[k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeBondDipoleSquared)
{
PotentialGradientChargeBondDipole(chargeB,DipoleMagnitudeA,length,dipoleA,dr,rr,&energy,&fa1,&fa2,&fb1,&term);
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]-=energy;
Adsorbates[CurrentSystem][j].Atoms[k].Force.x+=fb1.x;
Adsorbates[CurrentSystem][j].Atoms[k].Force.y+=fb1.y;
Adsorbates[CurrentSystem][j].Atoms[k].Force.z+=fb1.z;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
// convert forces on atoms to molecular virial
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z);
}
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
TypeA=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Components[TypeA].NumberOfBondDipoles;j++)
{
A1=Components[TypeA].BondDipoles[j].A;
A2=Components[TypeA].BondDipoles[j].B;
posA1=Adsorbates[CurrentSystem][i].Atoms[A1].Position;
posA2=Adsorbates[CurrentSystem][i].Atoms[A2].Position;
DipoleMagnitudeA=Components[TypeA].BondDipoleMagnitude[j];
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
Type=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeBondDipoleSquared)
{
PotentialGradientChargeBondDipole(chargeB,DipoleMagnitudeA,length,dipoleA,dr,rr,&energy,&fa1,&fa2,&fb1,&term);
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]-=energy;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=fb1.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=fb1.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=fb1.z;
}
Adsorbates[CurrentSystem][i].Atoms[A1].Force.x+=fa1.x;
Adsorbates[CurrentSystem][i].Atoms[A1].Force.y+=fa1.y;
Adsorbates[CurrentSystem][i].Atoms[A1].Force.z+=fa1.z;
Adsorbates[CurrentSystem][i].Atoms[A2].Force.x+=fa2.x;
Adsorbates[CurrentSystem][i].Atoms[A2].Force.y+=fa2.y;
Adsorbates[CurrentSystem][i].Atoms[A2].Force.z+=fa2.z;
// convert forces on atoms to molecular virial
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
return 0;
}
int CalculateFrameworkCationChargeBondDipoleForce(void)
{
int i,j,k,f1;
int A1,A2;
int Type,TypeA;
VECTOR posA,posB,posA1,posA2,dr;
REAL rr,ri2,energy,temp,length,chargeB;
VECTOR dipoleA,fb1,fa1,fa2,term;
REAL DipoleMagnitudeA;
REAL_MATRIX3x3 v;
UHostCationChargeBondDipoleReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
v.ax=v.bx=v.cx=0.0;
v.ay=v.by=v.cy=0.0;
v.az=v.bz=v.cz=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(j=0;j<NumberOfCationMolecules[CurrentSystem];j++)
{
for(k=0;k<Cations[CurrentSystem][j].NumberOfAtoms;k++)
{
Type=Cations[CurrentSystem][j].Atoms[k].Type;
if(PseudoAtoms[Type].HasCharges)
{
posB=Cations[CurrentSystem][j].Atoms[k].Position;
chargeB=Cations[CurrentSystem][j].Atoms[k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeBondDipoleSquared)
{
PotentialGradientChargeBondDipole(chargeB,DipoleMagnitudeA,length,dipoleA,dr,rr,&energy,&fa1,&fa2,&fb1,&term);
Cations[CurrentSystem][j].Atoms[k].Force.x+=fb1.x;
Cations[CurrentSystem][j].Atoms[k].Force.y+=fb1.y;
Cations[CurrentSystem][j].Atoms[k].Force.z+=fb1.z;
UHostCationChargeBondDipoleReal[CurrentSystem]-=energy;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
}
// convert forces on atoms to molecular virial
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
TypeA=Cations[CurrentSystem][i].Type;
for(j=0;j<Components[TypeA].NumberOfBondDipoles;j++)
{
A1=Components[TypeA].BondDipoles[j].A;
A2=Components[TypeA].BondDipoles[j].B;
posA1=Cations[CurrentSystem][i].Atoms[A1].Position;
posA2=Cations[CurrentSystem][i].Atoms[A2].Position;
DipoleMagnitudeA=Components[TypeA].BondDipoleMagnitude[j];
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
Type=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeBondDipoleSquared)
{
PotentialGradientChargeBondDipole(chargeB,DipoleMagnitudeA,length,dipoleA,dr,rr,&energy,&fa1,&fa2,&fb1,&term);
UHostCationChargeBondDipoleReal[CurrentSystem]-=energy;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=fb1.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=fb1.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=fb1.z;
}
Cations[CurrentSystem][i].Atoms[A1].Force.x+=fa1.x;
Cations[CurrentSystem][i].Atoms[A1].Force.y+=fa1.y;
Cations[CurrentSystem][i].Atoms[A1].Force.z+=fa1.z;
Cations[CurrentSystem][i].Atoms[A2].Force.x+=fa2.x;
Cations[CurrentSystem][i].Atoms[A2].Force.y+=fa2.y;
Cations[CurrentSystem][i].Atoms[A2].Force.z+=fa2.z;
// convert forces on atoms to molecular virial
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
return 0;
}
int CalculateFrameworkAdsorbateBondDipoleBondDipoleForce(void)
{
int i,k,l,f1;
int A1,A2,B1,B2;
int TypeB;
VECTOR posA,posB,posA1,posA2,posB1,posB2,dr;
REAL rr,ri2,rk2,energy,temp,length;
VECTOR dipoleA,dipoleB,fb1,fb2,fa1,fa2,term;
REAL DipoleMagnitudeA,DipoleMagnitudeB;
REAL_MATRIX3x3 v;
UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
v.ax=v.bx=v.cx=0.0;
v.ay=v.by=v.cy=0.0;
v.az=v.bz=v.cz=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
dipoleA=ApplyBoundaryCondition(dipoleA);
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(k=0;k<NumberOfAdsorbateMolecules[CurrentSystem];k++)
{
TypeB=Adsorbates[CurrentSystem][k].Type;
for(l=0;l<Components[TypeB].NumberOfBondDipoles;l++)
{
B1=Components[TypeB].BondDipoles[l].A;
B2=Components[TypeB].BondDipoles[l].B;
posB1=Adsorbates[CurrentSystem][k].Atoms[B1].Position;
posB2=Adsorbates[CurrentSystem][k].Atoms[B2].Position;
DipoleMagnitudeB=Components[TypeB].BondDipoleMagnitude[l];
dipoleB.x=posB2.x-posB1.x;
dipoleB.y=posB2.y-posB1.y;
dipoleB.z=posB2.z-posB1.z;
posB.x=posB1.x+0.5*dipoleB.x;
posB.y=posB1.y+0.5*dipoleB.y;
posB.z=posB1.z+0.5*dipoleB.z;
rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
length=sqrt(rk2);
temp=DipoleMagnitudeB/length;
dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffBondDipoleBondDipoleSquared)
{
PotentialGradientBondDipoleBondDipole(DipoleMagnitudeA,ri2,dipoleA,DipoleMagnitudeB,rk2,dipoleB,dr,rr,
&energy,&fa1,&fa2,&fb1,&fb2,&term);
UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]+=energy;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
}
Adsorbates[CurrentSystem][k].Atoms[B1].Force.x+=fb1.x;
Adsorbates[CurrentSystem][k].Atoms[B1].Force.y+=fb1.y;
Adsorbates[CurrentSystem][k].Atoms[B1].Force.z+=fb1.z;
Adsorbates[CurrentSystem][k].Atoms[B2].Force.x+=fb2.x;
Adsorbates[CurrentSystem][k].Atoms[B2].Force.y+=fb2.y;
Adsorbates[CurrentSystem][k].Atoms[B2].Force.z+=fb2.z;
// convert forces on atoms to molecular virial
// usually this conversion produces a torque on the center of mass and an asymmetric stress
// by making it symmetric we regain the 'atomic' strain derivative
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x)+fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x)+fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x)+fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y)+fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y)+fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y)+fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z)+fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z)+fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z)+fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
return 0;
}
int CalculateFrameworkCationBondDipoleBondDipoleForce(void)
{
int i,k,l,f1;
int A1,A2,B1,B2;
int TypeB;
VECTOR posA,posB,posA1,posA2,posB1,posB2,dr;
REAL rr,ri2,rk2,energy,temp,length;
VECTOR dipoleA,dipoleB,fb1,fb2,fa1,fa2,term;
REAL DipoleMagnitudeA,DipoleMagnitudeB;
REAL_MATRIX3x3 v;
UHostCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
v.ax=v.bx=v.cx=0.0;
v.ay=v.by=v.cy=0.0;
v.az=v.bz=v.cz=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
{
DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
dipoleA.x=posA2.x-posA1.x;
dipoleA.y=posA2.y-posA1.y;
dipoleA.z=posA2.z-posA1.z;
dipoleA=ApplyBoundaryCondition(dipoleA);
posA.x=posA1.x+0.5*dipoleA.x;
posA.y=posA1.y+0.5*dipoleA.y;
posA.z=posA1.z+0.5*dipoleA.z;
ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
length=sqrt(ri2);
temp=DipoleMagnitudeA/length;
dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;
for(k=0;k<NumberOfCationMolecules[CurrentSystem];k++)
{
TypeB=Cations[CurrentSystem][k].Type;
for(l=0;l<Components[TypeB].NumberOfBondDipoles;l++)
{
B1=Components[TypeB].BondDipoles[l].A;
B2=Components[TypeB].BondDipoles[l].B;
posB1=Cations[CurrentSystem][k].Atoms[B1].Position;
posB2=Cations[CurrentSystem][k].Atoms[B2].Position;
DipoleMagnitudeB=Components[TypeB].BondDipoleMagnitude[l];
dipoleB.x=posB2.x-posB1.x;
dipoleB.y=posB2.y-posB1.y;
dipoleB.z=posB2.z-posB1.z;
posB.x=posB1.x+0.5*dipoleB.x;
posB.y=posB1.y+0.5*dipoleB.y;
posB.z=posB1.z+0.5*dipoleB.z;
rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
length=sqrt(rk2);
temp=DipoleMagnitudeB/length;
dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffBondDipoleBondDipoleSquared)
{
PotentialGradientBondDipoleBondDipole(DipoleMagnitudeA,ri2,dipoleA,DipoleMagnitudeB,rk2,dipoleB,dr,rr,
&energy,&fa1,&fa2,&fb1,&fb2,&term);
UHostCationBondDipoleBondDipoleReal[CurrentSystem]+=energy;
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][A1].Force.x+=fa1.x;
Framework[CurrentSystem].Atoms[f1][A1].Force.y+=fa1.y;
Framework[CurrentSystem].Atoms[f1][A1].Force.z+=fa1.z;
Framework[CurrentSystem].Atoms[f1][A2].Force.x+=fa2.x;
Framework[CurrentSystem].Atoms[f1][A2].Force.y+=fa2.y;
Framework[CurrentSystem].Atoms[f1][A2].Force.z+=fa2.z;
}
Cations[CurrentSystem][k].Atoms[B1].Force.x+=fb1.x;
Cations[CurrentSystem][k].Atoms[B1].Force.y+=fb1.y;
Cations[CurrentSystem][k].Atoms[B1].Force.z+=fb1.z;
Cations[CurrentSystem][k].Atoms[B2].Force.x+=fb2.x;
Cations[CurrentSystem][k].Atoms[B2].Force.y+=fb2.y;
Cations[CurrentSystem][k].Atoms[B2].Force.z+=fb2.z;
// convert forces on atoms to molecular virial
// usually this conversion produces a torque on the center of mass and an asymmetric stress
// by making it symmetric we regain the 'atomic' strain derivative
v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x)+fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x)+fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x)+fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);
v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y)+fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y)+fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y)+fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);
v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z)+fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z)+fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z)+fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);
// the strain derivative
StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x-v.ax;
StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x-v.bx;
StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x-v.cx;
StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y-v.ay;
StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y-v.by;
StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y-v.cy;
StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z-v.az;
StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z-v.bz;
StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z-v.cz;
}
}
}
}
}
return 0;
}
int CalculateFrameworkChargeChargeElectricFieldMC(int New,int excl_ads,int excl_cation)
{
int i,j,k,f1;
int typeA,typeB;
REAL rr;
REAL chargeA,chargeB,temp,energy, force_factor;
REAL force_factor_A,force_factor_B;
VECTOR posA,posB,dr;
if(ChargeMethod==NONE) return 0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
if(i!=excl_ads)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
posA=Adsorbates[CurrentSystem][i].Atoms[j].Position;
chargeA=Adsorbates[CurrentSystem][i].Atoms[j].Charge;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(1.0,1.0,rr,&energy,&force_factor);
// forces
force_factor_A=force_factor*chargeB;
force_factor_B=force_factor*chargeA;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.x-=2.0*force_factor_A*dr.x;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.y-=2.0*force_factor_A*dr.y;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.z-=2.0*force_factor_A*dr.z;
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][k].ElectricField.x+=2.0*force_factor_B*dr.x;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.y+=2.0*force_factor_B*dr.y;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.z+=2.0*force_factor_B*dr.z;
}
}
}
}
}
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
if(i!=excl_cation)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Cations[CurrentSystem][i].Atoms[j].Type;
posA=Cations[CurrentSystem][i].Atoms[j].Position;
chargeA=Cations[CurrentSystem][i].Atoms[j].Charge;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(1.0,1.0,rr,&energy,&force_factor);
// forces
force_factor_A=force_factor*chargeB;
force_factor_B=force_factor*chargeA;
Cations[CurrentSystem][i].Atoms[j].ElectricField.x-=2.0*force_factor_A*dr.x;
Cations[CurrentSystem][i].Atoms[j].ElectricField.y-=2.0*force_factor_A*dr.y;
Cations[CurrentSystem][i].Atoms[j].ElectricField.z-=2.0*force_factor_A*dr.z;
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModel==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][k].ElectricField.x+=2.0*force_factor_B*dr.x;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.y+=2.0*force_factor_B*dr.y;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.z+=2.0*force_factor_B*dr.z;
}
}
}
}
}
}
}
if(New)
{
for(i=0;i<Components[CurrentComponent].NumberOfAtoms;i++)
{
posA=TrialPosition[CurrentSystem][i];
typeA=Components[CurrentComponent].Type[i];
chargeA=PseudoAtoms[typeA].Charge1;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(1.0,1.0,rr,&energy,&force_factor);
// forces
force_factor_A=force_factor*chargeB;
force_factor_B=force_factor*chargeA;
ElectricFieldAtTrialPosition[CurrentSystem][i].x-=2.0*force_factor_A*dr.x;
ElectricFieldAtTrialPosition[CurrentSystem][i].y-=2.0*force_factor_A*dr.y;
ElectricFieldAtTrialPosition[CurrentSystem][i].z-=2.0*force_factor_A*dr.z;
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][k].ElectricField.x+=2.0*force_factor_B*dr.x;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.y+=2.0*force_factor_B*dr.y;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.z+=2.0*force_factor_B*dr.z;
}
}
}
}
}
}
return 0;
}
int CalculateFrameworkAdsorbateElectricFieldFromInducedDipole(void)
{
int i,k,l,f1;
int TypeB;
VECTOR posA,posB,dr;
REAL rr;
VECTOR dipoleA,dipoleB;
VECTOR termA,termB;
if(ChargeMethod==NONE) return 0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
dipoleA=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
for(k=0;k<NumberOfAdsorbateMolecules[CurrentSystem];k++)
{
TypeB=Adsorbates[CurrentSystem][k].Type;
for(l=0;l<Adsorbates[CurrentSystem][k].NumberOfAtoms;l++)
{
posB=Adsorbates[CurrentSystem][k].Atoms[l].Position;
dipoleB=Adsorbates[CurrentSystem][k].Atoms[l].InducedDipole;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleB,dr,rr,&termA,&termB);
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x+=termA.x;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y+=termA.y;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z+=termA.z;
}
Adsorbates[CurrentSystem][k].Atoms[l].ElectricField.x+=termB.x;
Adsorbates[CurrentSystem][k].Atoms[l].ElectricField.y+=termB.y;
Adsorbates[CurrentSystem][k].Atoms[l].ElectricField.z+=termB.z;
}
}
}
}
}
return 0;
}
int CalculateFrameworkCationElectricFieldFromInducedDipole(void)
{
int i,k,l,f1;
int TypeB;
VECTOR posA,posB,dr;
REAL rr;
VECTOR dipoleA,dipoleB;
VECTOR termA,termB;
if(ChargeMethod==NONE) return 0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
dipoleA=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
for(k=0;k<NumberOfCationMolecules[CurrentSystem];k++)
{
TypeB=Cations[CurrentSystem][k].Type;
for(l=0;l<Cations[CurrentSystem][k].NumberOfAtoms;l++)
{
posB=Cations[CurrentSystem][k].Atoms[l].Position;
dipoleB=Cations[CurrentSystem][k].Atoms[l].InducedDipole;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleB,dr,rr,&termA,&termB);
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x+=termA.x;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y+=termA.y;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z+=termA.z;
}
Cations[CurrentSystem][k].Atoms[l].ElectricField.x+=termB.x;
Cations[CurrentSystem][k].Atoms[l].ElectricField.y+=termB.y;
Cations[CurrentSystem][k].Atoms[l].ElectricField.z+=termB.z;
}
}
}
}
}
return 0;
}
int CalculateFrameworkMoleculeElectricFieldFromInducedDipoleMC(int New,int excl_ads,int excl_cation)
{
int i,k,l,f1;
int TypeB;
VECTOR posA,posB,dr;
REAL rr;
VECTOR dipoleA,dipoleB;
VECTOR termA,termB;
if(ChargeMethod==NONE) return 0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
dipoleA=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
for(k=0;k<NumberOfAdsorbateMolecules[CurrentSystem];k++)
{
if(k!=excl_ads)
{
TypeB=Adsorbates[CurrentSystem][k].Type;
for(l=0;l<Adsorbates[CurrentSystem][k].NumberOfAtoms;l++)
{
posB=Adsorbates[CurrentSystem][k].Atoms[l].Position;
dipoleB=Adsorbates[CurrentSystem][k].Atoms[l].InducedDipole;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleB,dr,rr,&termA,&termB);
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x+=termB.x;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y+=termB.y;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z+=termB.z;
}
Adsorbates[CurrentSystem][k].Atoms[l].ElectricField.x+=termA.x;
Adsorbates[CurrentSystem][k].Atoms[l].ElectricField.y+=termA.y;
Adsorbates[CurrentSystem][k].Atoms[l].ElectricField.z+=termA.z;
}
}
}
}
for(k=0;k<NumberOfCationMolecules[CurrentSystem];k++)
{
if(k!=excl_cation)
{
TypeB=Cations[CurrentSystem][k].Type;
for(l=0;l<Cations[CurrentSystem][k].NumberOfAtoms;l++)
{
posB=Cations[CurrentSystem][k].Atoms[l].Position;
dipoleB=Cations[CurrentSystem][k].Atoms[l].InducedDipole;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleB,dr,rr,&termA,&termB);
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModel==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x+=termB.x;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y+=termB.y;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z+=termB.z;
}
Cations[CurrentSystem][k].Atoms[l].ElectricField.x+=termA.x;
Cations[CurrentSystem][k].Atoms[l].ElectricField.y+=termA.y;
Cations[CurrentSystem][k].Atoms[l].ElectricField.z+=termA.z;
}
}
}
}
}
}
if(New)
{
for(i=0;i<Components[CurrentComponent].NumberOfAtoms;i++)
{
posA=TrialPosition[CurrentSystem][i];
dipoleA=InducedDipoleAtTrialPosition[CurrentSystem][i];
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
dipoleB=Framework[CurrentSystem].Atoms[f1][k].InducedDipole;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleB,dr,rr,&termA,&termB);
ElectricFieldAtTrialPosition[CurrentSystem][i].x+=termB.x;
ElectricFieldAtTrialPosition[CurrentSystem][i].y+=termB.y;
ElectricFieldAtTrialPosition[CurrentSystem][i].z+=termB.z;
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE))
{
Framework[CurrentSystem].Atoms[f1][k].ElectricField.x+=termA.x;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.y+=termA.y;
Framework[CurrentSystem].Atoms[f1][k].ElectricField.z+=termA.z;
}
}
}
}
}
}
return 0;
}
int CalculateFrameworkAdsorbateChargeInducedDipoleForce(void)
{
int i,j,k,f1;
int Type,TypeA;
VECTOR posA,posB,dr;
REAL r,rr,chargeB;
VECTOR dipoleA,termA,termB;
if(ChargeMethod==NONE) return 0;
if(BackPolarization)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
dipoleA=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
for(j=0;j<NumberOfAdsorbateMolecules[CurrentSystem];j++)
{
for(k=0;k<Adsorbates[CurrentSystem][j].NumberOfAtoms;k++)
{
Type=Adsorbates[CurrentSystem][j].Atoms[k].Type;
if(PseudoAtoms[Type].HasCharges)
{
posB=Adsorbates[CurrentSystem][j].Atoms[k].Position;
chargeB=Adsorbates[CurrentSystem][j].Atoms[k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleA,dr,rr,&termA,&termB);
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x-=chargeB*termA.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=chargeB*termA.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=chargeB*termA.z;
}
Adsorbates[CurrentSystem][j].Atoms[k].Force.x+=chargeB*termA.x;
Adsorbates[CurrentSystem][j].Atoms[k].Force.y+=chargeB*termA.y;
Adsorbates[CurrentSystem][j].Atoms[k].Force.z+=chargeB*termA.z;
}
}
}
}
}
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
TypeA=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
posA=Adsorbates[CurrentSystem][i].Atoms[j].Position;
dipoleA=Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].Position;
Type=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
r=sqrt(rr);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialElectricFieldBondDipoleBondDipole(dipoleA,dipoleA,dr,rr,&termA,&termB);
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=chargeB*termA.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=chargeB*termA.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=chargeB*termA.z;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=chargeB*termA.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=chargeB*termA.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=chargeB*termA.z;
}
}
}
}
}
}
return 0;
}
int CalculateFrameworkAdsorbateInducedDipoleInducedDipoleForce(void)
{
int i,k,l,f1;
int TypeB;
VECTOR posA,posB,dr;
REAL energy,rr;
VECTOR dipoleA,dipoleB,term;
if(ChargeMethod==NONE) return 0;
if(!BackPolarization) return 0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
dipoleA=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
for(k=0;k<NumberOfAdsorbateMolecules[CurrentSystem];k++)
{
TypeB=Adsorbates[CurrentSystem][k].Type;
for(l=0;l<Adsorbates[CurrentSystem][k].NumberOfAtoms;l++)
{
posB=Adsorbates[CurrentSystem][k].Atoms[l].Position;
dipoleB=Adsorbates[CurrentSystem][k].Atoms[l].InducedDipole;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientInducedDipoleInducedDipole(dipoleA,dipoleB,dr,rr,&energy,&term);
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x-=term.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=term.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=term.z;
}
Adsorbates[CurrentSystem][k].Atoms[l].Force.x+=term.x;
Adsorbates[CurrentSystem][k].Atoms[l].Force.y+=term.y;
Adsorbates[CurrentSystem][k].Atoms[l].Force.z+=term.z;
}
}
}
}
}
return 0;
}
int CalculateFrameworkIntraReplicaVDWForce(void)
{
int i,j,typeA,typeB,start;
REAL energy,force_factor;
REAL rr,ReductionA,ReductionB;
VECTOR posA,posB,dr,f;
int ConnectedAtomA,ConnectedAtomB;
int f1,f2,k1,k2,k3,ncell,index_j;
int A,B;
REAL *parms;
// Framework-Framework energy
UHostHostVDW[CurrentSystem]=0.0;
if(!InternalFrameworkLennardJonesInteractions) return 0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(f2=f1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
posA=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;
ReductionA=1.0;
ConnectedAtomA=-1;
ncell=0;
for(k1=0;k1<NumberOfReplicaCells[CurrentSystem].x;k1++)
for(k2=0;k2<NumberOfReplicaCells[CurrentSystem].y;k2++)
for(k3=0;k3<NumberOfReplicaCells[CurrentSystem].z;k3++)
{
if((f1==f2)&&(ncell==0)) start=i+1;
else start=0;
for(j=start;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
{
index_j=j+ncell*Framework[CurrentSystem].NumberOfAtoms[f2];
if(f1!=f2?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][index_j],0))
{
typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
posB=Framework[CurrentSystem].Atoms[f2][j].AnisotropicPosition;
posB.x+=ReplicaShift[ncell].x;
posB.y+=ReplicaShift[ncell].y;
posB.z+=ReplicaShift[ncell].z;
ReductionB=1.0;
ConnectedAtomB=-1;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyReplicaBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
if(ncell==0)
UHostHostVDW[CurrentSystem]+=energy;
else
UHostHostVDW[CurrentSystem]+=0.5*energy;
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Framework[CurrentSystem].Atoms[f1][i].Force.x-=ReductionA*f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y-=ReductionA*f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z-=ReductionA*f.z;
if(ConnectedAtomA>=0)
{
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA].Force.x-=(1.0-ReductionA)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA].Force.y-=(1.0-ReductionA)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomA].Force.z-=(1.0-ReductionA)*f.z;
}
if(ncell==0)
{
Framework[CurrentSystem].Atoms[f2][j].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z+=ReductionB*f.z;
if(ConnectedAtomB>=0)
{
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f2][ConnectedAtomB].Force.z+=(1.0-ReductionB)*f.z;
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
else
{
// no force on particle outside the main unit cell
// only the interaction on 'i' in the unit cell counts
StrainDerivativeTensor[CurrentSystem].ax+=0.5*f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=0.5*f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=0.5*f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=0.5*f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=0.5*f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=0.5*f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=0.5*f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=0.5*f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=0.5*f.z*dr.z;
}
}
}
}
ncell++;
}
}
}
}
// contributions from interactions 1-4 torsions
// TODO: fix to handle anisotropic sites
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
{
parms=Framework[CurrentSystem].TorsionArguments[f1][i];
if(fabs(parms[6])>1e-8)
{
A=MIN2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);
B=MAX2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
{
typeA=Framework[CurrentSystem].Atoms[f1][A].Type;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
typeB=Framework[CurrentSystem].Atoms[f1][B].Type;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
UHostHostVDW[CurrentSystem]+=parms[6]*energy;
force_factor=parms[6]*force_factor;
StrainDerivativeTensor[CurrentSystem].ax+=force_factor*dr.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=force_factor*dr.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=force_factor*dr.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=force_factor*dr.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=force_factor*dr.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=force_factor*dr.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=force_factor*dr.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=force_factor*dr.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=force_factor*dr.z*dr.z;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Framework[CurrentSystem].Atoms[f1][A].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z-=f.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z+=f.z;
}
}
}
}
}
return 0;
}
int CalculateFrameworkIntraReplicaChargeChargeForce(void)
{
int i,j,typeA,typeB,start;
REAL chargeA,chargeB;
REAL rr,energy,DF;
VECTOR posA,posB,dr,f;
int f1,f2,ncell,k1,k2,k3,index_j;
int A,B;
REAL *parms;
REAL alpha,r;
// Framework-Framework energy
UHostHostChargeChargeReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(f2=f1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
posA=Framework[CurrentSystem].Atoms[f1][i].Position;
chargeA=Framework[CurrentSystem].Atoms[f1][i].Charge;
ncell=-1;
for(k1=0;k1<NumberOfReplicaCells[CurrentSystem].x;k1++)
for(k2=0;k2<NumberOfReplicaCells[CurrentSystem].y;k2++)
for(k3=0;k3<NumberOfReplicaCells[CurrentSystem].z;k3++)
{
ncell++;
if((f1==f2)&&(ncell==0)) start=i+1;
else start=0;
for(j=start;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
{
index_j=j+ncell*Framework[CurrentSystem].NumberOfAtoms[f2];
if(f1!=f2?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][index_j],1))
{
typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
posB=Framework[CurrentSystem].Atoms[f2][j].Position;
chargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;
posB.x+=ReplicaShift[ncell].x;
posB.y+=ReplicaShift[ncell].y;
posB.z+=ReplicaShift[ncell].z;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyReplicaBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&DF);
if(ncell==0)
UHostHostChargeChargeReal[CurrentSystem]+=energy;
else
UHostHostChargeChargeReal[CurrentSystem]+=0.5*energy;
f.x=-DF*dr.x;
f.y=-DF*dr.y;
f.z=-DF*dr.z;
Framework[CurrentSystem].Atoms[f1][i].Force.x+=f.x;
Framework[CurrentSystem].Atoms[f1][i].Force.y+=f.y;
Framework[CurrentSystem].Atoms[f1][i].Force.z+=f.z;
if(ncell==0)
{
Framework[CurrentSystem].Atoms[f2][j].Force.x-=f.x;
Framework[CurrentSystem].Atoms[f2][j].Force.y-=f.y;
Framework[CurrentSystem].Atoms[f2][j].Force.z-=f.z;
StrainDerivativeTensor[CurrentSystem].ax-=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx-=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx-=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay-=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by-=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy-=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az-=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz-=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz-=f.z*dr.z;
}
else
{
StrainDerivativeTensor[CurrentSystem].ax-=0.5*f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx-=0.5*f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx-=0.5*f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay-=0.5*f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by-=0.5*f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy-=0.5*f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az-=0.5*f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz-=0.5*f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz-=0.5*f.z*dr.z;
}
}
}
}
}
}
}
}
// contributions from interactions 1-4 torsions
// TODO: fix to handle anisotropic sites
alpha=Alpha[CurrentSystem];
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
{
parms=Framework[CurrentSystem].TorsionArguments[f1][i];
if(fabs(parms[7])>1e-8)
{
A=MIN2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);
B=MAX2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);
if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
{
chargeA=Framework[CurrentSystem].Atoms[f1][A].Charge;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
chargeB=Framework[CurrentSystem].Atoms[f1][B].Charge;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
r=sqrt(rr);
// note: no cutoff used here
switch(ChargeMethod)
{
case NONE:
DF=0.0;
break;
case SHIFTED_COULOMB:
case TRUNCATED_COULOMB:
case EWALD:
default:
UHostHostChargeChargeReal[CurrentSystem]+=parms[7]*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/r;
DF=parms[7]*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/(rr*r);
break;
}
StrainDerivativeTensor[CurrentSystem].ax-=DF*dr.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx-=DF*dr.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx-=DF*dr.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay-=DF*dr.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by-=DF*dr.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy-=DF*dr.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az-=DF*dr.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz-=DF*dr.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz-=DF*dr.z*dr.z;
Framework[CurrentSystem].Atoms[f1][A].Force.x+=DF*dr.x;
Framework[CurrentSystem].Atoms[f1][A].Force.y+=DF*dr.y;
Framework[CurrentSystem].Atoms[f1][A].Force.z+=DF*dr.z;
Framework[CurrentSystem].Atoms[f1][B].Force.x-=DF*dr.x;
Framework[CurrentSystem].Atoms[f1][B].Force.y-=DF*dr.y;
Framework[CurrentSystem].Atoms[f1][B].Force.z-=DF*dr.z;
}
}
}
}
}
return 0;
}
void CalculateFrameworkAdsorbateReplicaVDWForce(void)
{
int i,j,k,f1;
int typeA,typeB,type;
REAL rr,scaling;
REAL energy,force_factor;
VECTOR posA,posB,dr,f;
int ConnectedAtomA,ConnectedAtomB;
REAL ReductionA,ReductionB;
int ncell,k1,k2,k3;
UHostAdsorbateVDW[CurrentSystem]=0.0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
type=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
posA=Adsorbates[CurrentSystem][i].Atoms[j].AnisotropicPosition;
scaling=Adsorbates[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;
ReductionA=1.0;
ConnectedAtomA=-1;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA]))
{
UHostAdsorbateVDW[CurrentSystem]+=InterpolateVDWForceGrid(typeA,posA,&f);
Adsorbates[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
ncell=0;
for(k1=0;k1<NumberOfReplicaCells[CurrentSystem].x;k1++)
for(k2=0;k2<NumberOfReplicaCells[CurrentSystem].y;k2++)
for(k3=0;k3<NumberOfReplicaCells[CurrentSystem].z;k3++)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
posB.x+=ReplicaShift[ncell].x;
posB.y+=ReplicaShift[ncell].y;
posB.z+=ReplicaShift[ncell].z;
ReductionB=1.0;
ConnectedAtomB=-1;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyReplicaBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
// compute the energy and force-factor
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,scaling);
// energy
UHostAdsorbateVDW[CurrentSystem]+=energy;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=ReductionA*f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=ReductionA*f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=ReductionA*f.z;
if(ConnectedAtomA>=0)
{
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA].Force.x-=(1.0-ReductionA)*f.x;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA].Force.y-=(1.0-ReductionA)*f.y;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA].Force.z-=(1.0-ReductionA)*f.z;
}
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=ReductionB*f.z;
if(ConnectedAtomB>=0)
{
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.z+=(1.0-ReductionB)*f.z;
}
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
ncell++;
}
}
}
}
}
void CalculateFrameworkCationReplicaVDWForce(void)
{
int i,j,k,f1;
int typeA,typeB,type;
REAL rr,scaling;
REAL energy,force_factor;
VECTOR posA,posB,dr,f;
int ConnectedAtomA,ConnectedAtomB;
REAL ReductionA,ReductionB;
int ncell,k1,k2,k3;
UHostCationVDW[CurrentSystem]=0.0;
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
type=Cations[CurrentSystem][i].Type;
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Cations[CurrentSystem][i].Atoms[j].Type;
posA=Cations[CurrentSystem][i].Atoms[j].AnisotropicPosition;
scaling=Cations[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;
ReductionA=1.0;
ConnectedAtomA=-1;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA]))
{
UHostCationVDW[CurrentSystem]+=InterpolateVDWForceGrid(typeA,posA,&f);
Cations[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
ncell=0;
for(k1=0;k1<NumberOfReplicaCells[CurrentSystem].x;k1++)
for(k2=0;k2<NumberOfReplicaCells[CurrentSystem].y;k2++)
for(k3=0;k3<NumberOfReplicaCells[CurrentSystem].z;k3++)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
posB.x+=ReplicaShift[ncell].x;
posB.y+=ReplicaShift[ncell].y;
posB.z+=ReplicaShift[ncell].z;
ReductionB=1.0;
ConnectedAtomB=-1;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyReplicaBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
// compute the energy and force-factor
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,scaling);
// energy
UHostCationVDW[CurrentSystem]+=energy;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Cations[CurrentSystem][i].Atoms[j].Force.x-=ReductionA*f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=ReductionA*f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=ReductionA*f.z;
if(ConnectedAtomA>=0)
{
Cations[CurrentSystem][i].Atoms[ConnectedAtomA].Force.x-=(1.0-ReductionA)*f.x;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA].Force.y-=(1.0-ReductionA)*f.y;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA].Force.z-=(1.0-ReductionA)*f.z;
}
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=ReductionB*f.z;
if(ConnectedAtomB>=0)
{
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.z+=(1.0-ReductionB)*f.z;
}
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
ncell++;
}
}
}
}
}
int CalculateFrameworkAdsorbateReplicaChargeChargeForce(void)
{
int i,j,k,f1;
int typeA,typeB,type;
REAL rr,chargeA,chargeB;
REAL energy,DF,scaling;
VECTOR posA,posB,dr,f;
int ConnectedAtomA,ConnectedAtomB;
REAL ReductionA,ReductionB;
int ncell,k1,k2,k3;
UHostAdsorbateChargeChargeReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
type=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
posA=Adsorbates[CurrentSystem][i].Atoms[j].AnisotropicPosition;
scaling=Adsorbates[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
chargeA=scaling*Adsorbates[CurrentSystem][i].Atoms[j].Charge;
ReductionA=1.0;
ConnectedAtomA=-1;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid))
{
UHostAdsorbateChargeChargeReal[CurrentSystem]+=InterpolateCoulombForceGrid(typeA,posA,&f);
Adsorbates[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
ncell=0;
for(k1=0;k1<NumberOfReplicaCells[CurrentSystem].x;k1++)
for(k2=0;k2<NumberOfReplicaCells[CurrentSystem].y;k2++)
for(k3=0;k3<NumberOfReplicaCells[CurrentSystem].z;k3++)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
posB.x+=ReplicaShift[ncell].x;
posB.y+=ReplicaShift[ncell].y;
posB.z+=ReplicaShift[ncell].z;
ReductionB=1.0;
ConnectedAtomB=-1;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyReplicaBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&DF);
// energy
UHostAdsorbateChargeChargeReal[CurrentSystem]+=energy;
// forces
f.x=DF*dr.x;
f.y=DF*dr.y;
f.z=DF*dr.z;
Adsorbates[CurrentSystem][i].Atoms[j].Force.x-=ReductionA*f.x;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y-=ReductionA*f.y;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z-=ReductionA*f.z;
if(ConnectedAtomA>=0)
{
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA].Force.x-=(1.0-ReductionA)*f.x;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA].Force.y-=(1.0-ReductionA)*f.y;
Adsorbates[CurrentSystem][i].Atoms[ConnectedAtomA].Force.z-=(1.0-ReductionA)*f.z;
}
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=ReductionB*f.z;
if(ConnectedAtomB>=0)
{
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.z+=(1.0-ReductionB)*f.z;
}
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
ncell++;
}
}
}
}
return 0;
}
int CalculateFrameworkCationReplicaChargeChargeForce(void)
{
int i,j,k,f1;
int typeA,typeB,type;
REAL rr,chargeA,chargeB;
REAL energy,DF,scaling;
VECTOR posA,posB,dr,f;
int ConnectedAtomA,ConnectedAtomB;
REAL ReductionA,ReductionB;
int ncell,k1,k2,k3;
UHostCationChargeChargeReal[CurrentSystem]=0.0;
if(ChargeMethod==NONE) return 0;
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
type=Cations[CurrentSystem][i].Type;
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
typeA=Cations[CurrentSystem][i].Atoms[j].Type;
posA=Cations[CurrentSystem][i].Atoms[j].AnisotropicPosition;
scaling=Cations[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
chargeA=scaling*Cations[CurrentSystem][i].Atoms[j].Charge;
ReductionA=1.0;
ConnectedAtomA=-1;
if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid))
{
UHostCationChargeChargeReal[CurrentSystem]+=InterpolateCoulombForceGrid(typeA,posA,&f);
Cations[CurrentSystem][i].Atoms[j].Force.x+=f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y+=f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z+=f.z;
}
else
{
ncell=0;
for(k1=0;k1<NumberOfReplicaCells[CurrentSystem].x;k1++)
for(k2=0;k2<NumberOfReplicaCells[CurrentSystem].y;k2++)
for(k3=0;k3<NumberOfReplicaCells[CurrentSystem].z;k3++)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
{
posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;
posB.x+=ReplicaShift[ncell].x;
posB.y+=ReplicaShift[ncell].y;
posB.z+=ReplicaShift[ncell].z;
ReductionB=1.0;
ConnectedAtomB=-1;
dr.x=posA.x-posB.x;
dr.y=posA.y-posB.y;
dr.z=posA.z-posB.z;
dr=ApplyReplicaBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
PotentialGradientCoulombic(chargeA,chargeB,rr,&energy,&DF);
// energy
UHostCationChargeChargeReal[CurrentSystem]+=energy;
// forces
f.x=DF*dr.x;
f.y=DF*dr.y;
f.z=DF*dr.z;
Cations[CurrentSystem][i].Atoms[j].Force.x-=ReductionA*f.x;
Cations[CurrentSystem][i].Atoms[j].Force.y-=ReductionA*f.y;
Cations[CurrentSystem][i].Atoms[j].Force.z-=ReductionA*f.z;
if(ConnectedAtomA>=0)
{
Cations[CurrentSystem][i].Atoms[ConnectedAtomA].Force.x-=(1.0-ReductionA)*f.x;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA].Force.y-=(1.0-ReductionA)*f.y;
Cations[CurrentSystem][i].Atoms[ConnectedAtomA].Force.z-=(1.0-ReductionA)*f.z;
}
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
Framework[CurrentSystem].Atoms[f1][k].Force.x+=ReductionB*f.x;
Framework[CurrentSystem].Atoms[f1][k].Force.y+=ReductionB*f.y;
Framework[CurrentSystem].Atoms[f1][k].Force.z+=ReductionB*f.z;
if(ConnectedAtomB>=0)
{
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.x+=(1.0-ReductionB)*f.x;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.y+=(1.0-ReductionB)*f.y;
Framework[CurrentSystem].Atoms[f1][ConnectedAtomB].Force.z+=(1.0-ReductionB)*f.z;
}
}
StrainDerivativeTensor[CurrentSystem].ax+=f.x*dr.x;
StrainDerivativeTensor[CurrentSystem].bx+=f.y*dr.x;
StrainDerivativeTensor[CurrentSystem].cx+=f.z*dr.x;
StrainDerivativeTensor[CurrentSystem].ay+=f.x*dr.y;
StrainDerivativeTensor[CurrentSystem].by+=f.y*dr.y;
StrainDerivativeTensor[CurrentSystem].cy+=f.z*dr.y;
StrainDerivativeTensor[CurrentSystem].az+=f.x*dr.z;
StrainDerivativeTensor[CurrentSystem].bz+=f.y*dr.z;
StrainDerivativeTensor[CurrentSystem].cz+=f.z*dr.z;
}
}
}
ncell++;
}
}
}
}
return 0;
}
/*************************************************************************************************************
The MIT License
Copyright (C) 2006-2019 David Dubbeldam, Sofia Calero, Thijs Vlugt, Donald E. Ellis, and Randall Q. Snurr.
D.Dubbeldam@uva.nl http://www.uva.nl/profiel/d/u/d.dubbeldam/d.dubbeldam.html
scaldia@upo.es http://www.upo.es/raspa/
t.j.h.vlugt@tudelft.nl http://homepage.tudelft.nl/v9k6y
don-ellis@northwestern.edu http://dvworld.northwestern.edu/
snurr@northwestern.edu http://zeolites.cqe.northwestern.edu/
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************************************************/
// not used
void CalculateFrameworkFullForce(int m)
{
POINT pos1,pos2;
REAL energy,force_factor,rr;
int i,j,f1,typeA,typeB;
VECTOR dr,f;
UAdsorbateAdsorbateVDW[CurrentSystem]=0.0;
for(i=0;i<Adsorbates[CurrentSystem][m].NumberOfAtoms;i++)
{
pos1=Adsorbates[CurrentSystem][m].Atoms[i].Position;
typeA=Adsorbates[CurrentSystem][m].Atoms[i].Type;
Adsorbates[CurrentSystem][m].Atoms[i].Force.x=0.0;
Adsorbates[CurrentSystem][m].Atoms[i].Force.y=0.0;
Adsorbates[CurrentSystem][m].Atoms[i].Force.z=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
{
pos2=Framework[CurrentSystem].Atoms[f1][j].Position;
dr.x=pos1.x-pos2.x;
dr.y=pos1.y-pos2.y;
dr.z=pos1.z-pos2.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
// energy
UAdsorbateAdsorbateVDW[CurrentSystem]+=energy;
// forces
f.x=force_factor*dr.x;
f.y=force_factor*dr.y;
f.z=force_factor*dr.z;
Adsorbates[CurrentSystem][m].Atoms[i].Force.x-=f.x;