/*************************************************************************************************************
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 <float.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 "rigid.h"
#include "minimization.h"
#include "internal_hessian.h"
#include "numerical.h"
void CalculateDerivativesAtPositionVDW(VECTOR pos,int typeA,REAL *value,VECTOR *first_derivative,
REAL_MATRIX3x3 *second_derivative,REAL *third_derivative)
{
int i,f;
int typeB;
VECTOR dr;
REAL rr,F,DF,DDF,DDDF;
*value=0;
first_derivative->x=0.0;
first_derivative->y=0.0;
first_derivative->z=0.0;
second_derivative->ax=second_derivative->bx=second_derivative->cx=0.0;
second_derivative->ay=second_derivative->by=second_derivative->cy=0.0;
second_derivative->az=second_derivative->bz=second_derivative->cz=0.0;
*third_derivative=0.0;
for(f=0;f<Framework[CurrentSystem].NumberOfFrameworks;f++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f];i++)
{
typeB=Framework[CurrentSystem].Atoms[f][i].Type;
dr.x=pos.x-Framework[CurrentSystem].Atoms[f][i].AnisotropicPosition.x;
dr.y=pos.y-Framework[CurrentSystem].Atoms[f][i].AnisotropicPosition.y;
dr.z=pos.z-Framework[CurrentSystem].Atoms[f][i].AnisotropicPosition.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
PotentialThirdDerivative(typeA,typeB,rr,&F,&DF,&DDF,&DDDF);
*value+=F;
first_derivative->x+=dr.x*DF;
first_derivative->y+=dr.y*DF;
first_derivative->z+=dr.z*DF;
// add contribution to the second derivatives (Hessian matrix)
second_derivative->ax+=DDF*dr.x*dr.x+DF; second_derivative->bx+=DDF*dr.y*dr.x; second_derivative->cx+=DDF*dr.z*dr.x;
second_derivative->ay+=DDF*dr.x*dr.y; second_derivative->by+=DDF*dr.y*dr.y+DF; second_derivative->cy+=DDF*dr.z*dr.y;
second_derivative->az+=DDF*dr.x*dr.z; second_derivative->bz+=DDF*dr.y*dr.z; second_derivative->cz+=DDF*dr.z*dr.z+DF;
*third_derivative+=DDDF*dr.x*dr.y*dr.z;
}
}
}
}
REAL CalculateDerivativesAtPositionReal(VECTOR pos,int typeA,REAL *value,VECTOR *first_derivative,
REAL_MATRIX3x3 *second_derivative,REAL *third_derivative)
{
int i,f;
int typeB;
VECTOR dr;
REAL ChargeA,ChargeB;
REAL r,rr,F,DF,DDF,DDDF;
REAL smallest_r;
*value=0;
first_derivative->x=0.0;
first_derivative->y=0.0;
first_derivative->z=0.0;
second_derivative->ax=second_derivative->bx=second_derivative->cx=0.0;
second_derivative->ay=second_derivative->by=second_derivative->cy=0.0;
second_derivative->az=second_derivative->bz=second_derivative->cz=0.0;
*third_derivative=0.0;
ChargeA=1.0;
smallest_r=DBL_MAX;
for(f=0;f<Framework[CurrentSystem].NumberOfFrameworks;f++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f];i++)
{
typeB=Framework[CurrentSystem].Atoms[f][i].Type;
ChargeB=Framework[CurrentSystem].Atoms[f][i].Charge;
dr.x=pos.x-Framework[CurrentSystem].Atoms[f][i].Position.x;
dr.y=pos.y-Framework[CurrentSystem].Atoms[f][i].Position.y;
dr.z=pos.z-Framework[CurrentSystem].Atoms[f][i].Position.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
r=sqrt(rr);
if(r<smallest_r) smallest_r=r;
F=COULOMBIC_CONVERSION_FACTOR*ChargeA*ChargeB*(erfc(Alpha[CurrentSystem]*r)/r);
DF=-COULOMBIC_CONVERSION_FACTOR*ChargeA*ChargeB*
(2.0*Alpha[CurrentSystem]*r*exp(-SQR(Alpha[CurrentSystem])*rr)/sqrt(M_PI)+erfc(Alpha[CurrentSystem]*r))/
(r*rr);
DDF=ChargeA*ChargeB*COULOMBIC_CONVERSION_FACTOR*
(2.0*Alpha[CurrentSystem]*exp(-SQR(Alpha[CurrentSystem])*rr)*r*(3.0+2.0*SQR(Alpha[CurrentSystem])*rr)/sqrt(M_PI)+
3.0*erfc(Alpha[CurrentSystem]*r))/(rr*rr*r);
DDDF=ChargeA*ChargeB*COULOMBIC_CONVERSION_FACTOR*
(-2.0*Alpha[CurrentSystem]*exp(-SQR(Alpha[CurrentSystem])*rr)*r*(15.0+10.0*SQR(Alpha[CurrentSystem])*rr+4.0*SQR(SQR(Alpha[CurrentSystem])*rr))/sqrt(M_PI)
-15.0*erfc(Alpha[CurrentSystem]*r))/(rr*rr*rr*r);
*value+=F;
first_derivative->x+=dr.x*DF;
first_derivative->y+=dr.y*DF;
first_derivative->z+=dr.z*DF;
// add contribution to the second derivatives (Hessian matrix)
second_derivative->ax+=DDF*dr.x*dr.x+DF; second_derivative->bx+=DDF*dr.y*dr.x; second_derivative->cx+=DDF*dr.z*dr.x;
second_derivative->ay+=DDF*dr.x*dr.y; second_derivative->by+=DDF*dr.y*dr.y+DF; second_derivative->cy+=DDF*dr.z*dr.y;
second_derivative->az+=DDF*dr.x*dr.z; second_derivative->bz+=DDF*dr.y*dr.z; second_derivative->cz+=DDF*dr.z*dr.z+DF;
*third_derivative+=DDDF*dr.x*dr.y*dr.z;
}
}
}
return smallest_r;
}
// Hessian: Center of mass - Center of mass
// ========================================
static inline void HessianAtomicPositionPosition(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_i,INT_VECTOR3 index_j,REAL f1,REAL f2,VECTOR dr,REAL ReplicaFactor)
{
REAL_MATRIX3x3 Hessian;
Hessian.ax=f2*dr.x*dr.x+f1; Hessian.bx=f2*dr.y*dr.x; Hessian.cx=f2*dr.z*dr.x;
Hessian.ay=f2*dr.x*dr.y; Hessian.by=f2*dr.y*dr.y+f1; Hessian.cy=f2*dr.z*dr.y;
Hessian.az=f2*dr.x*dr.z; Hessian.bz=f2*dr.y*dr.z; Hessian.cz=f2*dr.z*dr.z+f1;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if((index_i.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_i.x][index_i.x]+=ReplicaFactor*Hessian.ax;
if((index_i.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.x][index_i.y]+=ReplicaFactor*Hessian.ay;
if((index_i.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.x][index_i.z]+=ReplicaFactor*Hessian.az;
if((index_i.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.y][index_i.y]+=ReplicaFactor*Hessian.by;
if((index_i.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.y][index_i.z]+=ReplicaFactor*Hessian.bz;
if((index_i.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.z][index_i.z]+=ReplicaFactor*Hessian.cz;
}
if((index_j.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_j.x][index_j.x]+=ReplicaFactor*Hessian.ax;
if((index_j.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.x][index_j.y]+=ReplicaFactor*Hessian.ay;
if((index_j.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.x][index_j.z]+=ReplicaFactor*Hessian.az;
if((index_j.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.y][index_j.y]+=ReplicaFactor*Hessian.by;
if((index_j.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.y][index_j.z]+=ReplicaFactor*Hessian.bz;
if((index_j.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.z][index_j.z]+=ReplicaFactor*Hessian.cz;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if((index_i.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.x][index_j.x]-=Hessian.ax;
if((index_i.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.x][index_j.y]-=Hessian.ay;
if((index_i.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.x][index_j.z]-=Hessian.az;
if((index_i.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.y][index_j.x]-=Hessian.ay;
if((index_i.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.y][index_j.y]-=Hessian.by;
if((index_i.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.y][index_j.z]-=Hessian.bz;
if((index_i.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.z][index_j.x]-=Hessian.az;
if((index_i.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.z][index_j.y]-=Hessian.bz;
if((index_i.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.z][index_j.z]-=Hessian.cz;
}
}
// Hessian: Center of mass - Orientation
// =====================================
static inline void HessianCenterOfMassOrientationJ(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_i,INT_VECTOR3 index_j,INT_VECTOR3 index_j2,int index2,REAL f1,REAL f2,VECTOR dr)
{
REAL_MATRIX3x3 Hessian;
VECTOR vecj1,vecj2,vecj3;
vecj1=DVecX[index2];
vecj2=DVecY[index2];
vecj3=DVecZ[index2];
Hessian.ax=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.x+f1*vecj1.x;
Hessian.ay=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.x+f1*vecj2.x;
Hessian.az=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.x+f1*vecj3.x;
Hessian.bx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.y+f1*vecj1.y;
Hessian.by=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.y+f1*vecj2.y;
Hessian.bz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.y+f1*vecj3.y;
Hessian.cx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.z+f1*vecj1.z;
Hessian.cy=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.z+f1*vecj2.z;
Hessian.cz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.z+f1*vecj3.z;
if((index_j.x>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_j.x][index_j2.x]+=Hessian.ax;
if((index_j.x>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_j.x][index_j2.y]+=Hessian.ay;
if((index_j.x>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_j.x][index_j2.z]+=Hessian.az;
if((index_j.y>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_j.y][index_j2.x]+=Hessian.bx;
if((index_j.y>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_j.y][index_j2.y]+=Hessian.by;
if((index_j.y>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_j.y][index_j2.z]+=Hessian.bz;
if((index_j.z>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_j.z][index_j2.x]+=Hessian.cx;
if((index_j.z>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_j.z][index_j2.y]+=Hessian.cy;
if((index_j.z>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_j.z][index_j2.z]+=Hessian.cz;
Hessian.ax=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.x+f1*vecj1.x;
Hessian.ay=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.x+f1*vecj2.x;
Hessian.az=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.x+f1*vecj3.x;
Hessian.bx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.y+f1*vecj1.y;
Hessian.by=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.y+f1*vecj2.y;
Hessian.bz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.y+f1*vecj3.y;
Hessian.cx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.z+f1*vecj1.z;
Hessian.cy=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.z+f1*vecj2.z;
Hessian.cz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.z+f1*vecj3.z;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if((index_i.x>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_i.x][index_j2.x]-=Hessian.ax;
if((index_i.x>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_i.x][index_j2.y]-=Hessian.ay;
if((index_i.x>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_i.x][index_j2.z]-=Hessian.az;
if((index_i.y>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_i.y][index_j2.x]-=Hessian.bx;
if((index_i.y>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_i.y][index_j2.y]-=Hessian.by;
if((index_i.y>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_i.y][index_j2.z]-=Hessian.bz;
if((index_i.z>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_i.z][index_j2.x]-=Hessian.cx;
if((index_i.z>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_i.z][index_j2.y]-=Hessian.cy;
if((index_i.z>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_i.z][index_j2.z]-=Hessian.cz;
}
}
// Hessian: Orientation - Orientation
// ==================================
static inline void HessianOrientationOrientationJ(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_j2,int index2,REAL f1,REAL f2,VECTOR dr)
{
REAL_MATRIX3x3 Hessian;
VECTOR vecj1,vecj2,vecj3;
VECTOR DDvecJAX,DDvecJBY,DDvecJCZ,DDvecJAY,DDvecJAZ,DDvecJBZ;
vecj1=DVecX[index2];
vecj2=DVecY[index2];
vecj3=DVecZ[index2];
DDvecJAX=DDVecAX[index2];
DDvecJBY=DDVecBY[index2];
DDvecJCZ=DDVecCZ[index2];
DDvecJAY=DDVecAY[index2];
DDvecJAZ=DDVecAZ[index2];
DDvecJBZ=DDVecBZ[index2];
Hessian.ax=-f1*(dr.x*DDvecJAX.x+dr.y*DDvecJAX.y+dr.z*DDvecJAX.z)
+f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)
+f1*(vecj1.x*vecj1.x+vecj1.y*vecj1.y+vecj1.z*vecj1.z);
Hessian.by=-f1*(dr.x*DDvecJBY.x+dr.y*DDvecJBY.y+dr.z*DDvecJBY.z)+
f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)+
f1*(vecj2.x*vecj2.x+vecj2.y*vecj2.y+vecj2.z*vecj2.z);
Hessian.cz=-f1*(dr.x*DDvecJCZ.x+dr.y*DDvecJCZ.y+dr.z*DDvecJCZ.z)+
f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)+
f1*(vecj3.x*vecj3.x+vecj3.y*vecj3.y+vecj3.z*vecj3.z);
Hessian.ay=-f1*(dr.x*DDvecJAY.x+dr.y*DDvecJAY.y+dr.z*DDvecJAY.z)+
f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)+
f1*(vecj1.x*vecj2.x+vecj1.y*vecj2.y+vecj1.z*vecj2.z);
Hessian.az=-f1*(dr.x*DDvecJAZ.x+dr.y*DDvecJAZ.y+dr.z*DDvecJAZ.z)+
f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)+
f1*(vecj1.x*vecj3.x+vecj1.y*vecj3.y+vecj1.z*vecj3.z);
Hessian.bz=-f1*(dr.x*DDvecJBZ.x+dr.y*DDvecJBZ.y+dr.z*DDvecJBZ.z)+
f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)+
f1*(vecj2.x*vecj3.x+vecj2.y*vecj3.y+vecj2.z*vecj3.z);
if((index_j2.x>=0)&&(index_j2.x>=0)) HessianMatrix.element[index_j2.x][index_j2.x]+=Hessian.ax;
if((index_j2.y>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_j2.y][index_j2.y]+=Hessian.by;
if((index_j2.z>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_j2.z][index_j2.z]+=Hessian.cz;
if((index_j2.x>=0)&&(index_j2.y>=0)) HessianMatrix.element[index_j2.x][index_j2.y]+=Hessian.ay;
if((index_j2.x>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_j2.x][index_j2.z]+=Hessian.az;
if((index_j2.y>=0)&&(index_j2.z>=0)) HessianMatrix.element[index_j2.y][index_j2.z]+=Hessian.bz;
}
// Hessian: Center of mass - Strain (part I)
// =========================================
static inline void HessianAtomicPositionStrain(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_i,INT_VECTOR3 index_j,REAL f1,REAL f2,VECTOR dr)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x+f2*dr.y*dr.y*dr.x+f2*dr.z*dr.z*dr.x; // xx x + yy x + zz x
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=f2*dr.x*dr.x*dr.y+f2*dr.y*dr.y*dr.y+2.0*f1*dr.y+f2*dr.z*dr.z*dr.y; // xx y + yy y + zz y
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=f2*dr.x*dr.x*dr.z+f2*dr.y*dr.y*dr.z+f2*dr.z*dr.z*dr.z+2.0*f1*dr.z; // xx z + yy z + zz z
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x+f2*dr.y*dr.y*dr.x+f2*dr.z*dr.z*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=f2*dr.x*dr.x*dr.y+f2*dr.y*dr.y*dr.y+2.0*f1*dr.y+f2*dr.z*dr.z*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=f2*dr.x*dr.x*dr.z+f2*dr.y*dr.y*dr.z+f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=f2*dr.y*dr.y*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=f2*dr.z*dr.z*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=f2*dr.x*dr.x*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=f2*dr.z*dr.z*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=f2*dr.x*dr.x*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=f2*dr.y*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=f2*dr.y*dr.y*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=f2*dr.z*dr.z*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=f2*dr.x*dr.x*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=f2*dr.z*dr.z*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=f2*dr.x*dr.x*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=f2*dr.y*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
break;
case REGULAR:
case REGULAR_UPPER_TRIANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=f2*dr.x*dr.y*dr.x+f1*dr.y;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=f2*dr.x*dr.z*dr.x+f1*dr.z;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=f2*dr.y*dr.y*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+4]+=f2*dr.y*dr.z*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+5]+=f2*dr.z*dr.z*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=f2*dr.x*dr.x*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=f2*dr.x*dr.y*dr.y+f1*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=f2*dr.x*dr.z*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+4]+=f2*dr.y*dr.z*dr.y+f1*dr.z;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+5]+=f2*dr.z*dr.z*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=f2*dr.x*dr.x*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=f2*dr.x*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=f2*dr.x*dr.z*dr.z+f1*dr.x;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=f2*dr.y*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+4]+=f2*dr.y*dr.z*dr.z+f1*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+5]+=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=f2*dr.x*dr.y*dr.x+f1*dr.y;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=f2*dr.x*dr.z*dr.x+f1*dr.z;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=f2*dr.y*dr.y*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+4]-=f2*dr.y*dr.z*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+5]-=f2*dr.z*dr.z*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=f2*dr.x*dr.x*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=f2*dr.x*dr.y*dr.y+f1*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=f2*dr.x*dr.z*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+4]-=f2*dr.y*dr.z*dr.y+f1*dr.z;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+5]-=f2*dr.z*dr.z*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=f2*dr.x*dr.x*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=f2*dr.x*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=f2*dr.x*dr.z*dr.z+f1*dr.x;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=f2*dr.y*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+4]-=f2*dr.y*dr.z*dr.z+f1*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+5]-=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
break;
case MONOCLINIC:
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=f2*dr.y*dr.y*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=f2*dr.y*dr.z*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=f2*dr.z*dr.z*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=f2*dr.x*dr.x*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=f2*dr.y*dr.z*dr.y+f1*dr.z;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=f2*dr.z*dr.z*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=f2*dr.x*dr.x*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=f2*dr.y*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=f2*dr.y*dr.z*dr.z+f1*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=f2*dr.y*dr.y*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=f2*dr.y*dr.z*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=f2*dr.z*dr.z*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=f2*dr.x*dr.x*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=f2*dr.y*dr.z*dr.y+f1*dr.z;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=f2*dr.z*dr.z*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=f2*dr.x*dr.x*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=f2*dr.y*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=f2*dr.y*dr.z*dr.z+f1*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
break;
case MONOCLINIC_BETA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=f2*dr.x*dr.z*dr.x+f1*dr.z;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=f2*dr.y*dr.y*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=f2*dr.z*dr.z*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=f2*dr.x*dr.x*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=f2*dr.x*dr.z*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=f2*dr.z*dr.z*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=f2*dr.x*dr.x*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=f2*dr.x*dr.z*dr.z+f1*dr.x;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=f2*dr.y*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=f2*dr.x*dr.z*dr.x+f1*dr.z;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=f2*dr.y*dr.y*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=f2*dr.z*dr.z*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=f2*dr.x*dr.x*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=f2*dr.x*dr.z*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=f2*dr.z*dr.z*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=f2*dr.x*dr.x*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=f2*dr.x*dr.z*dr.z+f1*dr.x;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=f2*dr.y*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
break;
case MONOCLINIC_GAMMA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=f2*dr.x*dr.y*dr.x+f1*dr.y;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=f2*dr.y*dr.y*dr.x;
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=f2*dr.z*dr.z*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=f2*dr.x*dr.x*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=f2*dr.x*dr.y*dr.y+f1*dr.x;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=f2*dr.z*dr.z*dr.y;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=f2*dr.x*dr.x*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=f2*dr.x*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=f2*dr.y*dr.y*dr.z;
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=f2*dr.x*dr.x*dr.x+2.0*f1*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=f2*dr.x*dr.y*dr.x+f1*dr.y;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=f2*dr.y*dr.y*dr.x;
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=f2*dr.z*dr.z*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=f2*dr.x*dr.x*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=f2*dr.x*dr.y*dr.y+f1*dr.x;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=f2*dr.y*dr.y*dr.y+2.0*f1*dr.y;
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=f2*dr.z*dr.z*dr.y;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=f2*dr.x*dr.x*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=f2*dr.x*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=f2*dr.y*dr.y*dr.z;
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=f2*dr.z*dr.z*dr.z+2.0*f1*dr.z;
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
// Hessian: Center of mass - Strain (part II)
// ==========================================
static inline void HessianCenterOfMassStrainJ(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_i,INT_VECTOR3 index_j,REAL f1,REAL f2,VECTOR dr,VECTOR posB,VECTOR comB)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1)+(posB.y-comB.y)*(f2*dr.x*dr.y)+(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=(posB.x-comB.x)*(f2*dr.y*dr.x)+(posB.y-comB.y)*(f2*dr.y*dr.y+f1)+(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=(posB.x-comB.x)*(f2*dr.z*dr.x)+(posB.y-comB.y)*(f2*dr.z*dr.y)+(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1)+(posB.y-comB.y)*(f2*dr.x*dr.y)+(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=(posB.x-comB.x)*(f2*dr.y*dr.x)+(posB.y-comB.y)*(f2*dr.y*dr.y+f1)+(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=(posB.x-comB.x)*(f2*dr.z*dr.x)+(posB.y-comB.y)*(f2*dr.z*dr.y)+(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case REGULAR:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=0.5*((posB.y-comB.y)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.y));
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=0.5*((posB.z-comB.z)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.z));
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+4]+=0.5*((posB.z-comB.z)*(f2*dr.x*dr.y)+(posB.y-comB.y)*(f2*dr.x*dr.z));
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+5]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=0.5*((posB.y-comB.y)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.y+f1));
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=0.5*((posB.z-comB.z)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.z));
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+4]+=0.5*((posB.z-comB.z)*(f2*dr.y*dr.y+f1)+(posB.y-comB.y)*(f2*dr.y*dr.z));
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+5]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=0.5*((posB.y-comB.y)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.y));
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=0.5*((posB.z-comB.z)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.z+f1));
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+4]+=0.5*((posB.z-comB.z)*(f2*dr.z*dr.y)+(posB.y-comB.y)*(f2*dr.z*dr.z+f1));
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+5]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=0.5*((posB.y-comB.y)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.y));
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=0.5*((posB.z-comB.z)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.z));
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+4]-=0.5*((posB.z-comB.z)*(f2*dr.x*dr.y)+(posB.y-comB.y)*(f2*dr.x*dr.z));
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+5]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=0.5*((posB.y-comB.y)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.y+f1));
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=0.5*((posB.z-comB.z)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.z));
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+4]-=0.5*((posB.z-comB.z)*(f2*dr.y*dr.y+f1)+(posB.y-comB.y)*(f2*dr.y*dr.z));
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+5]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=0.5*((posB.y-comB.y)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.y));
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=0.5*((posB.z-comB.z)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.z+f1));
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+4]-=0.5*((posB.z-comB.z)*(f2*dr.z*dr.y)+(posB.y-comB.y)*(f2*dr.z*dr.z+f1));
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+5]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case REGULAR_UPPER_TRIANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n ]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=(posB.y-comB.y)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.z-comB.z)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+4]+=(posB.z-comB.z)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+5]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n ]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=(posB.y-comB.y)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.z-comB.z)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+4]+=(posB.z-comB.z)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+5]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n ]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=(posB.y-comB.y)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.z-comB.z)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+4]+=(posB.z-comB.z)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+5]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n ]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=(posB.y-comB.y)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.z-comB.z)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+4]-=(posB.z-comB.z)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+5]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n ]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=(posB.y-comB.y)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.z-comB.z)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+4]-=(posB.z-comB.z)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+5]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n ]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=(posB.y-comB.y)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.z-comB.z)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+4]-=(posB.z-comB.z)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+5]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case MONOCLINIC:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=0.5*((posB.z-comB.z)*(f2*dr.x*dr.y)+(posB.y-comB.y)*(f2*dr.x*dr.z));
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=0.5*((posB.z-comB.z)*(f2*dr.y*dr.y+f1)+(posB.y-comB.y)*(f2*dr.y*dr.z));
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=0.5*((posB.z-comB.z)*(f2*dr.z*dr.y)+(posB.y-comB.y)*(f2*dr.z*dr.z+f1));
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=0.5*((posB.z-comB.z)*(f2*dr.x*dr.y)+(posB.y-comB.y)*(f2*dr.x*dr.z));
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=0.5*((posB.z-comB.z)*(f2*dr.y*dr.y+f1)+(posB.y-comB.y)*(f2*dr.y*dr.z));
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=0.5*((posB.z-comB.z)*(f2*dr.z*dr.y)+(posB.y-comB.y)*(f2*dr.z*dr.z+f1));
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case MONOCLINIC_BETA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=0.5*((posB.z-comB.z)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.z));
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=0.5*((posB.z-comB.z)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.z));
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=0.5*((posB.z-comB.z)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.z+f1));
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=0.5*((posB.z-comB.z)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.z));
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=0.5*((posB.z-comB.z)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.z));
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=0.5*((posB.z-comB.z)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.z+f1));
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case MONOCLINIC_GAMMA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=0.5*((posB.y-comB.y)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.y));
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=0.5*((posB.y-comB.y)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.y+f1));
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=0.5*((posB.y-comB.y)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.y));
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=0.5*((posB.y-comB.y)*(f2*dr.x*dr.x+f1)+(posB.x-comB.x)*(f2*dr.x*dr.y));
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=0.5*((posB.y-comB.y)*(f2*dr.y*dr.x)+(posB.x-comB.x)*(f2*dr.y*dr.y+f1));
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=0.5*((posB.y-comB.y)*(f2*dr.z*dr.x)+(posB.x-comB.x)*(f2*dr.z*dr.y));
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
}
break;
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n ]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.z-comB.z)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n ]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.z-comB.z)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n ]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.z-comB.z)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n ]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.z-comB.z)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n ]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.z-comB.z)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n ]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.z-comB.z)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case MONOCLINIC_BETA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n ]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=(posB.z-comB.z)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n ]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=(posB.z-comB.z)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n ]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=(posB.z-comB.z)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n ]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=(posB.z-comB.z)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n ]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=(posB.z-comB.z)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n ]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=(posB.z-comB.z)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
case MONOCLINIC_GAMMA_ANGLE:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][n ]+=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+1]+=(posB.y-comB.y)*(f2*dr.x*dr.x+f1);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+2]+=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_i.x>=0) HessianMatrix.element[index_i.x][n+3]+=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n ]+=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+1]+=(posB.y-comB.y)*(f2*dr.y*dr.x);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+2]+=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_i.y>=0) HessianMatrix.element[index_i.y][n+3]+=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n ]+=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+1]+=(posB.y-comB.y)*(f2*dr.z*dr.x);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+2]+=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_i.z>=0) HessianMatrix.element[index_i.z][n+3]+=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
}
if(index_j.x>=0) HessianMatrix.element[index_j.x][n ]-=(posB.x-comB.x)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+1]-=(posB.y-comB.y)*(f2*dr.x*dr.x+f1);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+2]-=(posB.y-comB.y)*(f2*dr.x*dr.y);
if(index_j.x>=0) HessianMatrix.element[index_j.x][n+3]-=(posB.z-comB.z)*(f2*dr.x*dr.z);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n ]-=(posB.x-comB.x)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+1]-=(posB.y-comB.y)*(f2*dr.y*dr.x);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+2]-=(posB.y-comB.y)*(f2*dr.y*dr.y+f1);
if(index_j.y>=0) HessianMatrix.element[index_j.y][n+3]-=(posB.z-comB.z)*(f2*dr.y*dr.z);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n ]-=(posB.x-comB.x)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+1]-=(posB.y-comB.y)*(f2*dr.z*dr.x);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+2]-=(posB.y-comB.y)*(f2*dr.z*dr.y);
if(index_j.z>=0) HessianMatrix.element[index_j.z][n+3]-=(posB.z-comB.z)*(f2*dr.z*dr.z+f1);
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
// Hessian: Orientation - Strain (part I)
// ======================================
static inline void HessianOrientationStrainJ(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_j2,int index2,REAL f1,REAL f2,VECTOR dr)
{
int n;
REAL_MATRIX3x3 Hessian;
VECTOR vecj1,vecj2,vecj3;
n=NumberOfCoordinatesMinimizationVariables;
vecj1=DVecX[index2];
vecj2=DVecY[index2];
vecj3=DVecZ[index2];
Hessian.ax=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.x+f1*vecj1.x;
Hessian.ay=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.x+f1*vecj2.x;
Hessian.az=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.x+f1*vecj3.x;
Hessian.bx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.y+f1*vecj1.y;
Hessian.by=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.y+f1*vecj2.y;
Hessian.bz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.y+f1*vecj3.y;
Hessian.cx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.z+f1*vecj1.z;
Hessian.cy=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.z+f1*vecj2.z;
Hessian.cz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.z+f1*vecj3.z;
switch(Ensemble[CurrentSystem])
{
case NPT:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=Hessian.ax*dr.x+Hessian.bx*dr.y+Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=Hessian.ay*dr.x+Hessian.by*dr.y+Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=Hessian.az*dr.x+Hessian.bz*dr.y+Hessian.cz*dr.z;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.cz*dr.z;
break;
case REGULAR:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=0.5*(Hessian.ax*dr.y+Hessian.bx*dr.x);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=0.5*(Hessian.ax*dr.z+Hessian.cx*dr.x);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+4]-=0.5*(Hessian.bx*dr.z+Hessian.cx*dr.y);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+5]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=0.5*(Hessian.ay*dr.y+Hessian.by*dr.x);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=0.5*(Hessian.ay*dr.z+Hessian.cy*dr.x);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+4]-=0.5*(Hessian.by*dr.z+Hessian.cy*dr.y);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+5]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=0.5*(Hessian.az*dr.y+Hessian.bz*dr.x);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=0.5*(Hessian.az*dr.z+Hessian.cz*dr.x);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+4]-=0.5*(Hessian.bz*dr.z+Hessian.cz*dr.y);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+5]-=Hessian.cz*dr.z;
break;
case REGULAR_UPPER_TRIANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=Hessian.ax*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.ax*dr.z;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+4]-=Hessian.bx*dr.z;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+5]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=Hessian.ay*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.ay*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+4]-=Hessian.by*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+5]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=Hessian.az*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.az*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+4]-=Hessian.bz*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+5]-=Hessian.cz*dr.z;
break;
case MONOCLINIC:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=0.5*(Hessian.bx*dr.z+Hessian.cx*dr.y);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=0.5*(Hessian.by*dr.z+Hessian.cy*dr.y);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=0.5*(Hessian.bz*dr.z+Hessian.cz*dr.y);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.cz*dr.z;
break;
case MONOCLINIC_BETA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=0.5*(Hessian.ax*dr.z+Hessian.cx*dr.x);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=0.5*(Hessian.ay*dr.z+Hessian.cy*dr.x);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=0.5*(Hessian.az*dr.z+Hessian.cz*dr.x);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.cz*dr.z;
break;
case MONOCLINIC_GAMMA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=0.5*(Hessian.ax*dr.y+Hessian.bx*dr.x);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=0.5*(Hessian.ay*dr.y+Hessian.by*dr.x);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=0.5*(Hessian.az*dr.y+Hessian.bz*dr.x);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.cz*dr.z;
break;
}
break;
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.bx*dr.z;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.by*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.bz*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.cz*dr.z;
break;
case MONOCLINIC_BETA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=Hessian.ax*dr.z;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=Hessian.ay*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=Hessian.az*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.cz*dr.z;
break;
case MONOCLINIC_GAMMA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=Hessian.ax*dr.x;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=Hessian.ax*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=Hessian.bx*dr.y;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=Hessian.cx*dr.z;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=Hessian.ay*dr.x;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=Hessian.ay*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=Hessian.by*dr.y;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=Hessian.cy*dr.z;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=Hessian.az*dr.x;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=Hessian.az*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=Hessian.bz*dr.y;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=Hessian.cz*dr.z;
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
// Hessian: Orientation - Strain (part II)
// =======================================
static inline void HessianOrientationStrainJ_FR(REAL_MATRIX HessianMatrix,INT_VECTOR3 index_j2,int index2,REAL f1,REAL f2,
VECTOR posB,VECTOR comB,VECTOR dr)
{
int n;
REAL_MATRIX3x3 Hessian;
VECTOR vecj1,vecj2,vecj3;
n=NumberOfCoordinatesMinimizationVariables;
vecj1=DVecX[index2];
vecj2=DVecY[index2];
vecj3=DVecZ[index2];
Hessian.ax=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.x+f1*vecj1.x;
Hessian.ay=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.x+f1*vecj2.x;
Hessian.az=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.x+f1*vecj3.x;
Hessian.bx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.y+f1*vecj1.y;
Hessian.by=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.y+f1*vecj2.y;
Hessian.bz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.y+f1*vecj3.y;
Hessian.cx=f2*(dr.x*vecj1.x+dr.y*vecj1.y+dr.z*vecj1.z)*dr.z+f1*vecj1.z;
Hessian.cy=f2*(dr.x*vecj2.x+dr.y*vecj2.y+dr.z*vecj2.z)*dr.z+f1*vecj2.z;
Hessian.cz=f2*(dr.x*vecj3.x+dr.y*vecj3.y+dr.z*vecj3.z)*dr.z+f1*vecj3.z;
switch(Ensemble[CurrentSystem])
{
case NPT:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=(posB.x-comB.x)*Hessian.ax+(posB.y-comB.y)*Hessian.bx+(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=(posB.x-comB.x)*Hessian.ay+(posB.y-comB.y)*Hessian.by+(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=(posB.x-comB.x)*Hessian.az+(posB.y-comB.y)*Hessian.bz+(posB.z-comB.z)*Hessian.cz;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.z-comB.z)*Hessian.cz;
break;
case REGULAR:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=0.5*((posB.y-comB.y)*Hessian.ax+(posB.x-comB.x)*Hessian.bx);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=0.5*((posB.z-comB.z)*Hessian.ax+(posB.x-comB.x)*Hessian.cx);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+4]-=0.5*((posB.z-comB.z)*Hessian.bx+(posB.y-comB.y)*Hessian.cx);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+5]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=0.5*((posB.y-comB.y)*Hessian.ay+(posB.x-comB.x)*Hessian.by);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=0.5*((posB.z-comB.z)*Hessian.ay+(posB.x-comB.x)*Hessian.cy);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+4]-=0.5*((posB.z-comB.z)*Hessian.by+(posB.y-comB.y)*Hessian.cy);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+5]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=0.5*((posB.y-comB.y)*Hessian.az+(posB.x-comB.x)*Hessian.bz);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=0.5*((posB.z-comB.z)*Hessian.az+(posB.x-comB.x)*Hessian.cz);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+4]-=0.5*((posB.z-comB.z)*Hessian.bz+(posB.y-comB.y)*Hessian.cz);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+5]-=(posB.z-comB.z)*Hessian.cz;
break;
case REGULAR_UPPER_TRIANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=(posB.y-comB.y)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.z-comB.z)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+4]-=(posB.z-comB.z)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+5]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=(posB.y-comB.y)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.z-comB.z)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+4]-=(posB.z-comB.z)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+5]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=(posB.y-comB.y)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.z-comB.z)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+4]-=(posB.z-comB.z)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+5]-=(posB.z-comB.z)*Hessian.cz;
break;
case MONOCLINIC:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=0.5*((posB.z-comB.z)*Hessian.bx+(posB.y-comB.y)*Hessian.cx);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=0.5*((posB.z-comB.z)*Hessian.by+(posB.y-comB.y)*Hessian.cy);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=0.5*((posB.z-comB.z)*Hessian.bz+(posB.y-comB.y)*Hessian.cz);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.z-comB.z)*Hessian.cz;
break;
case MONOCLINIC_BETA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=0.5*((posB.z-comB.z)*Hessian.ax+(posB.x-comB.x)*Hessian.cx);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=0.5*((posB.z-comB.z)*Hessian.ay+(posB.x-comB.x)*Hessian.cy);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=0.5*((posB.z-comB.z)*Hessian.az+(posB.x-comB.x)*Hessian.cz);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.z-comB.z)*Hessian.cz;
break;
case MONOCLINIC_GAMMA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=0.5*((posB.y-comB.y)*Hessian.ax+(posB.x-comB.x)*Hessian.bx);
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=0.5*((posB.y-comB.y)*Hessian.ay+(posB.x-comB.x)*Hessian.by);
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=0.5*((posB.y-comB.y)*Hessian.az+(posB.x-comB.x)*Hessian.bz);
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.z-comB.z)*Hessian.cz;
break;
}
break;
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.z-comB.z)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.z-comB.z)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.z-comB.z)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.z-comB.z)*Hessian.cz;
break;
case MONOCLINIC_BETA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=(posB.z-comB.z)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=(posB.z-comB.z)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=(posB.z-comB.z)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.z-comB.z)*Hessian.cz;
break;
case MONOCLINIC_GAMMA_ANGLE:
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n ]-=(posB.x-comB.x)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+1]-=(posB.y-comB.y)*Hessian.ax;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+2]-=(posB.y-comB.y)*Hessian.bx;
if(index_j2.x>=0) HessianMatrix.element[index_j2.x][n+3]-=(posB.z-comB.z)*Hessian.cx;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n ]-=(posB.x-comB.x)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+1]-=(posB.y-comB.y)*Hessian.ay;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+2]-=(posB.y-comB.y)*Hessian.by;
if(index_j2.y>=0) HessianMatrix.element[index_j2.y][n+3]-=(posB.z-comB.z)*Hessian.cy;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n ]-=(posB.x-comB.x)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+1]-=(posB.y-comB.y)*Hessian.az;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+2]-=(posB.y-comB.y)*Hessian.bz;
if(index_j2.z>=0) HessianMatrix.element[index_j2.z][n+3]-=(posB.z-comB.z)*Hessian.cz;
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
// Hessian: Strain - Strain
// ========================
static inline void HessianAtomicStrainStrain(REAL_MATRIX HessianMatrix,REAL f1,REAL f2,VECTOR dr)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
HessianMatrix.element[n][n]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x+2.0*f2*dr.x*dr.x*dr.y*dr.y+2.0*f2*dr.x*dr.x*dr.z*dr.z+
f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y+2.0*f2*dr.y*dr.y*dr.z*dr.z+f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case REGULAR:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.x*dr.y+f1*dr.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.x*dr.z+f1*dr.x*dr.z; // xxxz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+4]+=f2*dr.x*dr.x*dr.y*dr.z; // xxyz
HessianMatrix.element[n ][n+5]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dr.y*dr.x*dr.y+0.5*f1*(dr.x*dr.x+dr.y*dr.y); // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dr.y*dr.x*dr.z+0.5*f1*dr.y*dr.z; // xyxz
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dr.y*dr.y*dr.y+f1*dr.x*dr.y; // xyyy
HessianMatrix.element[n+1][n+4]+=f2*dr.x*dr.y*dr.y*dr.z+0.5*f1*(dr.x*dr.z); // xyyz
HessianMatrix.element[n+1][n+5]+=f2*dr.x*dr.y*dr.z*dr.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.x*dr.z*dr.x*dr.z+0.5*f1*(dr.x*dr.x+dr.z*dr.z); // xzxz
HessianMatrix.element[n+2][n+3]+=f2*dr.x*dr.z*dr.y*dr.y; // xzyy
HessianMatrix.element[n+2][n+4]+=f2*dr.x*dr.z*dr.y*dr.z+0.5*f1*dr.x*dr.y; // xzyz
HessianMatrix.element[n+2][n+5]+=f2*dr.x*dr.z*dr.z*dr.z+f1*dr.x*dr.z; // xzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+3][n+4]+=f2*dr.y*dr.y*dr.y*dr.z+f1*dr.y*dr.z; // yyyz
HessianMatrix.element[n+3][n+5]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+4][n+4]+=f2*dr.y*dr.z*dr.y*dr.z+0.5*f1*(dr.y*dr.y+dr.z*dr.z); // yzyz
HessianMatrix.element[n+4][n+5]+=f2*dr.y*dr.z*dr.z*dr.z+f1*dr.y*dr.z; // yzzz
HessianMatrix.element[n+5][n+5]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case REGULAR_UPPER_TRIANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.x*dr.y+f1*dr.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.x*dr.z+f1*dr.x*dr.z; // xxxz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+4]+=f2*dr.x*dr.x*dr.y*dr.z; // xxyz
HessianMatrix.element[n ][n+5]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dr.y*dr.x*dr.y+f1*dr.y*dr.y; // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dr.y*dr.x*dr.z+f1*dr.y*dr.z; // xyxz
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dr.y*dr.y*dr.y; // xyyy
HessianMatrix.element[n+1][n+4]+=f2*dr.x*dr.y*dr.y*dr.z; // xyyz
HessianMatrix.element[n+1][n+5]+=f2*dr.x*dr.y*dr.z*dr.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.x*dr.z*dr.x*dr.z+f1*dr.z*dr.z; // xzxz
HessianMatrix.element[n+2][n+3]+=f2*dr.x*dr.z*dr.y*dr.y; // xzyy
HessianMatrix.element[n+2][n+4]+=f2*dr.x*dr.z*dr.y*dr.z; // xzyz
HessianMatrix.element[n+2][n+5]+=f2*dr.x*dr.z*dr.z*dr.z; // xzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+3][n+4]+=f2*dr.y*dr.y*dr.y*dr.z+f1*dr.y*dr.z; // yyyz
HessianMatrix.element[n+3][n+5]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+4][n+4]+=f2*dr.y*dr.z*dr.y*dr.z+f1*dr.z*dr.z; // yzyz
HessianMatrix.element[n+4][n+5]+=f2*dr.y*dr.z*dr.z*dr.z; // yzzz
HessianMatrix.element[n+5][n+5]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case MONOCLINIC:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.y*dr.z; // xxyz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*dr.y*dr.y*dr.z+f1*dr.y*dr.z; // yyyz
HessianMatrix.element[n+1][n+3]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.z*dr.y*dr.z+0.5*f1*(dr.y*dr.y+dr.z*dr.z); // yzyz
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dr.z*dr.z*dr.z+f1*dr.y*dr.z; // yzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case MONOCLINIC_BETA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.x*dr.z+f1*dr.x*dr.z; // xxxz
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dr.z*dr.x*dr.z+0.5*f1*(dr.x*dr.x+dr.z*dr.z); // xzxz
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dr.z*dr.y*dr.y; // xzyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dr.z*dr.z*dr.z+f1*dr.x*dr.z; // xzzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case MONOCLINIC_GAMMA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.x*dr.y+f1*dr.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dr.y*dr.x*dr.y+0.5*f1*(dr.x*dr.x+dr.y*dr.y); // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dr.y*dr.y*dr.y+f1*dr.x*dr.y; // xyyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dr.y*dr.z*dr.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
}
break;
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.y*dr.z; // xxyz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*dr.y*dr.y*dr.z+f1*dr.y*dr.z; // yyyz
HessianMatrix.element[n+1][n+3]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.z*dr.y*dr.z+f1*dr.z*dr.z; // yzyz
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dr.z*dr.z*dr.z; // yzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case MONOCLINIC_BETA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.x*dr.z+f1*dr.x*dr.z; // xxxz
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dr.z*dr.x*dr.z+f1*dr.z*dr.z; // xzxz
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dr.z*dr.y*dr.y; // xzyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dr.z*dr.z*dr.z; // xzzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
case MONOCLINIC_GAMMA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dr.x*dr.x+2.0*f1*dr.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dr.x*dr.y+f1*dr.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dr.y*dr.x*dr.y+f1*dr.y*dr.y; // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dr.y*dr.y*dr.y; // xyyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dr.y*dr.z*dr.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.y*dr.y*dr.y+2.0*f1*dr.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dr.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dr.z*dr.z*dr.z+2.0*f1*dr.z*dr.z; // zzzz
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
// Hessian: Strain - Strain (part II)
// ==================================
static inline void HessianCorrectionStrainStrain(REAL_MATRIX HessianMatrix,REAL f1,REAL f2,VECTOR dr,VECTOR posB,VECTOR comB)
{
int n;
VECTOR dB,drJ;
n=NumberOfCoordinatesMinimizationVariables;
dB.x=posB.x-comB.x;
dB.y=posB.y-comB.y;
dB.z=posB.z-comB.z;
drJ.x=dr.x+dB.x;
drJ.y=dr.y+dB.y;
drJ.z=dr.z+dB.z;
switch(Ensemble[CurrentSystem])
{
case NPT:
// atomic correction
HessianMatrix.element[n][n]+=f2*dr.x*dB.x*dr.x*dr.x+2.0*f1*dB.x*dr.x; // xxxy
HessianMatrix.element[n][n]+=2.0*f2*dr.x*dB.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n][n]+=2.0*f2*dr.x*dB.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n][n]+=f2*dr.y*dB.y*dr.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n][n]+=2.0*f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n][n]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z; // zzzz
// rigid correction
HessianMatrix.element[n][n]+=f2*dr.x*drJ.x*dr.x*dB.x+f1*drJ.x*dB.x; // xxxy
HessianMatrix.element[n][n]+=2.0*f2*dr.x*drJ.x*dr.y*dB.y; // xxyy
HessianMatrix.element[n][n]+=2.0*f2*dr.x*drJ.x*dr.z*dB.z; // xxzz
HessianMatrix.element[n][n]+=f2*dr.y*drJ.y*dr.y*dB.y+f1*drJ.y*dB.y; // yyyy
HessianMatrix.element[n][n]+=2.0*f2*dr.y*drJ.y*dr.z*dB.z; // yyzz
HessianMatrix.element[n][n]+=f2*dr.z*drJ.z*dr.z*dB.z+f1*drJ.z*dB.z; // zzzz
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
// atomic correction
HessianMatrix.element[n ][n ]+=f2*dr.x*dB.x*dr.x*dr.x+2.0*f1*dB.x*dr.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*dB.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dB.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*dB.y*dr.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z; // zzzz
// rigid correction
HessianMatrix.element[n ][n ]+=f2*dr.x*drJ.x*dr.x*dB.x+f1*drJ.x*dB.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*drJ.x*dr.y*dB.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*drJ.x*dr.z*dB.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*drJ.y*dr.y*dB.y+f1*drJ.y*dB.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*drJ.y*dr.z*dB.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.z*drJ.z*dr.z*dB.z+f1*drJ.z*dB.z; // zzzz
break;
case REGULAR:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dB.x*dr.x+2.0*f1*dB.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dB.x*dr.y+f1*dB.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.x*dB.x*dr.z+f1*dB.x*dr.z; // xxxz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.y*dB.x*dr.y; // xxyy
HessianMatrix.element[n ][n+4]+=f2*dr.x*dr.y*dB.x*dr.z; // xxyz
HessianMatrix.element[n ][n+5]+=f2*dr.x*dr.z*dB.x*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=0.5*(f2*(dr.x*dB.y*dr.x*dr.y+dr.y*dB.x*dr.x*dr.y)+f1*(dB.x*dr.x+dB.y*dr.y)); // xyxy
HessianMatrix.element[n+1][n+2]+=0.5*(f2*(dr.x*dB.y*dr.x*dr.z+dr.y*dB.x*dr.x*dr.z)+f1*(dB.y*dr.z)); // xyxz
HessianMatrix.element[n+1][n+3]+=0.5*f2*(dr.x*dB.y*dr.y*dr.y+dr.y*dB.x*dr.y*dr.y)+f1*(dB.x*dr.y); // xyyy
HessianMatrix.element[n+1][n+4]+=0.5*f2*(dr.x*dB.y*dr.y*dr.z+dr.y*dB.x*dr.y*dr.z)+0.5*f1*(dB.x*dr.z); // xyyz
HessianMatrix.element[n+1][n+5]+=0.5*f2*(dr.x*dB.y*dr.z*dr.z+dr.y*dB.x*dr.z*dr.z); // xyzz
HessianMatrix.element[n+2][n+2]+=0.5*(f2*(dr.x*dB.z*dr.x*dr.z+dr.z*dB.x*dr.x*dr.z)+f1*(dB.x*dr.x+dB.z*dr.z)); // xzxz
HessianMatrix.element[n+2][n+3]+=0.5*f2*(dr.x*dB.z*dr.y*dr.y+dB.x*dr.z*dr.y*dr.y); // xzyy
HessianMatrix.element[n+2][n+4]+=0.5*(f2*(dr.x*dB.z*dr.y*dr.z+dB.x*dr.z*dr.y*dr.z)+f1*dB.x*dr.y); // xzyz
HessianMatrix.element[n+2][n+5]+=0.5*f2*(dr.x*dB.z*dr.z*dr.z+dB.x*dr.z*dr.z*dr.z)+f1*dB.x*dr.z; // xzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.y*dr.y*dB.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+3][n+4]+=f2*dr.y*dB.y*dr.y*dr.z+f1*dB.y*dr.z; // yyyz
HessianMatrix.element[n+3][n+5]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+4][n+4]+=0.5*(f2*(dr.y*dB.z*dr.y*dr.z+dB.y*dr.z*dr.y*dr.z)+f1*(dB.y*dr.y+dB.z*dr.z)); // yzyz
HessianMatrix.element[n+4][n+5]+=0.5*f2*(dr.y*dB.z*dr.z*dr.z+dB.y*dr.z*dr.z*dr.z)+f1*dB.y*dr.z; // yzzz
HessianMatrix.element[n+5][n+5]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z;
HessianMatrix.element[n][n]+=f2*dr.x*dB.x*drJ.x*dr.x+f1*dB.x*drJ.x;
HessianMatrix.element[n][n+1]+=0.5*f2*(dr.x*dB.y+dr.y*dB.x)*drJ.x*dr.x+0.5*f1*dB.y*(drJ.x);
HessianMatrix.element[n][n+2]+=0.5*f2*(dr.x*dB.z+dr.z*dB.x)*drJ.x*dr.x+0.5*f1*dB.z*(drJ.x);
HessianMatrix.element[n][n+3]+=0.5*(dr.y*dB.y+dr.y*dB.y)*f2*drJ.x*dr.x;
HessianMatrix.element[n][n+4]+=0.5*(dr.y*dB.z+dr.z*dB.y)*f2*drJ.x*dr.x;
HessianMatrix.element[n][n+5]+=0.5*(dr.z*dB.z+dr.z*dB.z)*f2*drJ.x*dr.x;
HessianMatrix.element[n+1][n+1]+=0.25*f2*(dr.x*dB.y+dr.y*dB.x)*(drJ.x*dr.y+drJ.y*dr.x)+
0.25*f1*(dB.y*drJ.y+dB.x*drJ.x);
HessianMatrix.element[n+1][n+2]+=0.25*f2*(dr.x*dB.z+dr.z*dB.x)*(drJ.x*dr.y+drJ.y*dr.x)+0.25*f1*dB.z*drJ.y;
HessianMatrix.element[n+1][n+3]+=0.25*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.x*dr.y+drJ.y*dr.x)
+0.25*f1*(dB.y*drJ.x+dB.y*drJ.x);
HessianMatrix.element[n+1][n+4]+=0.25*f2*(dr.y*dB.z+dr.z*dB.y)*(drJ.x*dr.y+drJ.y*dr.x)+0.25*f1*dB.z*drJ.x;
HessianMatrix.element[n+1][n+5]+=0.25*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.x*dr.y+drJ.y*dr.x);
HessianMatrix.element[n+2][n+2]+=0.25*f2*(dr.x*dB.z+dr.z*dB.x)*(drJ.x*dr.z+drJ.z*dr.x)+
0.25*f1*(dB.z*drJ.z+dB.x*drJ.x);
HessianMatrix.element[n+2][n+3]+=0.25*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.x*dr.z+drJ.z*dr.x);
HessianMatrix.element[n+2][n+4]+=0.25*f2*(dr.y*dB.z+dr.z*dB.y)*(drJ.x*dr.z+drJ.z*dr.x)+0.25*f1*dB.y*drJ.x;
HessianMatrix.element[n+2][n+5]+=0.25*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.x*dr.z+drJ.z*dr.x)+
0.25*f1*(dB.z*drJ.x+dB.z*drJ.x);
HessianMatrix.element[n+3][n+3]+=0.5*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.y*dr.y)+0.5*f1*(dB.y*drJ.y+dB.y*drJ.y);
HessianMatrix.element[n+3][n+4]+=0.5*f2*(dr.y*dB.z+dr.z*dB.y)*(drJ.y*dr.y)+0.5*f1*dB.z*drJ.y;
HessianMatrix.element[n+3][n+5]+=0.5*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.y*dr.y);
HessianMatrix.element[n+4][n+4]+=0.25*f2*(dr.y*dB.z+dr.z*dB.y)*(drJ.y*dr.z+drJ.z*dr.y)+
0.25*f1*(dB.z*drJ.z+dB.y*drJ.y);
HessianMatrix.element[n+4][n+5]+=0.25*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.y*dr.z+drJ.z*dr.y)+
0.25*f1*(dB.z*drJ.y+dB.z*drJ.y);
HessianMatrix.element[n+5][n+5]+=f2*dr.z*dB.z*drJ.z*dr.z+f1*dB.z*drJ.z;
break;
case REGULAR_UPPER_TRIANGLE:
// atomic correction
HessianMatrix.element[n ][n ]+=f2*dr.x*dB.x*dr.x*dr.x+2.0*f1*dB.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dB.x*dr.x*dr.y+f1*dB.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dB.x*dr.x*dr.z+f1*dB.x*dr.z; // xxxz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dB.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+4]+=f2*dr.x*dB.x*dr.y*dr.z; // xxyz
HessianMatrix.element[n ][n+5]+=f2*dr.x*dB.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dB.y*dr.x*dr.y+f1*dB.y*dr.y; // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dB.y*dr.x*dr.z+f1*dB.y*dr.z; // xyxz
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dB.y*dr.y*dr.y; // xyyy
HessianMatrix.element[n+1][n+4]+=f2*dr.x*dB.y*dr.y*dr.z; // xyyz
HessianMatrix.element[n+1][n+5]+=f2*dr.x*dB.y*dr.z*dr.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.x*dB.z*dr.x*dr.z+f1*dB.z*dr.z; // xzxz
HessianMatrix.element[n+2][n+3]+=f2*dr.x*dB.z*dr.y*dr.y; // xzyy
HessianMatrix.element[n+2][n+4]+=f2*dr.x*dB.z*dr.y*dr.z; // xzyz
HessianMatrix.element[n+2][n+5]+=f2*dr.x*dB.z*dr.z*dr.z; // xzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.y*dB.y*dr.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+3][n+4]+=f2*dr.y*dB.y*dr.y*dr.z+f1*dB.y*dr.z; // yyyz
HessianMatrix.element[n+3][n+5]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+4][n+4]+=f2*dr.y*dB.z*dr.y*dr.z+f1*dB.z*dr.z; // yzyz
HessianMatrix.element[n+4][n+5]+=f2*dr.y*dB.z*dr.z*dr.z; // yzzz
HessianMatrix.element[n+5][n+5]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z; // zzzz
// rigid correction
HessianMatrix.element[n ][n ]+=f2*dr.x*drJ.x*dr.x*dB.x+f1*drJ.x*dB.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*drJ.x*dr.x*dB.y+f1*drJ.x*dB.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*drJ.x*dr.x*dB.z+f1*drJ.x*dB.z; // xxxz
HessianMatrix.element[n ][n+3]+=f2*dr.x*drJ.x*dr.y*dB.y; // xxyy
HessianMatrix.element[n ][n+4]+=f2*dr.x*drJ.x*dr.y*dB.z; // xxyz
HessianMatrix.element[n ][n+5]+=f2*dr.x*drJ.x*dr.z*dB.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*drJ.y*dr.x*dB.y+f1*drJ.y*dB.y; // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*drJ.y*dr.x*dB.z+f1*drJ.y*dB.z; // xyxz
HessianMatrix.element[n+1][n+3]+=f2*dr.x*drJ.y*dr.y*dB.y; // xyyy
HessianMatrix.element[n+1][n+4]+=f2*dr.x*drJ.y*dr.y*dB.z; // xyyz
HessianMatrix.element[n+1][n+5]+=f2*dr.x*drJ.y*dr.z*dB.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.x*drJ.z*dr.x*dB.z+f1*drJ.z*dB.z; // xzxz
HessianMatrix.element[n+2][n+3]+=f2*dr.x*drJ.z*dr.y*dB.y; // xzyy
HessianMatrix.element[n+2][n+4]+=f2*dr.x*drJ.z*dr.y*dB.z; // xzyz
HessianMatrix.element[n+2][n+5]+=f2*dr.x*drJ.z*dr.z*dB.z; // xzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.y*drJ.y*dr.y*dB.y+f1*drJ.y*dB.y; // yyyy
HessianMatrix.element[n+3][n+4]+=f2*dr.y*drJ.y*dr.y*dB.z+f1*drJ.y*dB.z; // yyyz
HessianMatrix.element[n+3][n+5]+=f2*dr.y*drJ.y*dr.z*dB.z; // yyzz
HessianMatrix.element[n+4][n+4]+=f2*dr.y*drJ.z*dr.y*dB.z+f1*drJ.z*dB.z; // yzyz
HessianMatrix.element[n+4][n+5]+=f2*dr.y*drJ.z*dr.z*dB.z; // yzzz
HessianMatrix.element[n+5][n+5]+=f2*dr.z*drJ.z*dr.z*dB.z+f1*drJ.z*dB.z; // zzzz
break;
case MONOCLINIC:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dB.x*dr.x+2.0*f1*dB.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.y*dB.x*dr.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.y*dB.x*dr.z; // xxyz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.z*dB.x*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*dr.y*dB.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*dB.y*dr.y*dr.z+f1*dB.y*dr.z; // yyyz
HessianMatrix.element[n+1][n+3]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+2][n+2]+=0.5*(f2*(dr.y*dB.z*dr.y*dr.z+dB.y*dr.z*dr.y*dr.z)+f1*(dB.y*dr.y+dB.z*dr.z)); // yzyz
HessianMatrix.element[n+2][n+3]+=0.5*f2*(dr.y*dB.z*dr.z*dr.z+dB.y*dr.z*dr.z*dr.z)+f1*dB.y*dr.z; // yzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z;
HessianMatrix.element[n][n]+=f2*dr.x*dB.x*drJ.x*dr.x+f1*dB.x*drJ.x;
HessianMatrix.element[n][n+1]+=0.5*(dr.y*dB.y+dr.y*dB.y)*f2*drJ.x*dr.x;
HessianMatrix.element[n][n+2]+=0.5*(dr.y*dB.z+dr.z*dB.y)*f2*drJ.x*dr.x;
HessianMatrix.element[n][n+3]+=0.5*(dr.z*dB.z+dr.z*dB.z)*f2*drJ.x*dr.x;
HessianMatrix.element[n+1][n+1]+=0.5*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.y*dr.y)+0.5*f1*(dB.y*drJ.y+dB.y*drJ.y);
HessianMatrix.element[n+1][n+2]+=0.5*f2*(dr.y*dB.z+dr.z*dB.y)*(drJ.y*dr.y)+0.5*f1*dB.z*drJ.y;
HessianMatrix.element[n+1][n+3]+=0.5*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.y*dr.y);
HessianMatrix.element[n+2][n+2]+=0.25*f2*(dr.y*dB.z+dr.z*dB.y)*(drJ.y*dr.z+drJ.z*dr.y)+
0.25*f1*(dB.z*drJ.z+dB.y*drJ.y);
HessianMatrix.element[n+2][n+3]+=0.25*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.y*dr.z+drJ.z*dr.y)+
0.25*f1*(dB.z*drJ.y+dB.z*drJ.y);
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*drJ.z*dr.z+f1*dB.z*drJ.z;
break;
case MONOCLINIC_BETA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dB.x*dr.x+2.0*f1*dB.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dB.x*dr.z+f1*dB.x*dr.z; // xxxz
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.y*dB.x*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.z*dB.x*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=0.5*(f2*(dr.x*dB.z*dr.x*dr.z+dr.z*dB.x*dr.x*dr.z)+f1*(dB.x*dr.x+dB.z*dr.z)); // xzxz
HessianMatrix.element[n+1][n+2]+=0.5*f2*(dr.x*dB.z*dr.y*dr.y+dB.x*dr.z*dr.y*dr.y); // xzyy
HessianMatrix.element[n+1][n+3]+=0.5*f2*(dr.x*dB.z*dr.z*dr.z+dB.x*dr.z*dr.z*dr.z)+f1*dB.x*dr.z; // xzzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.y*dB.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z;
HessianMatrix.element[n][n]+=f2*dr.x*dB.x*drJ.x*dr.x+f1*dB.x*drJ.x;
HessianMatrix.element[n][n+1]+=0.5*f2*(dr.x*dB.z+dr.z*dB.x)*drJ.x*dr.x+0.5*f1*dB.z*(drJ.x);
HessianMatrix.element[n][n+2]+=0.5*(dr.y*dB.y+dr.y*dB.y)*f2*drJ.x*dr.x;
HessianMatrix.element[n][n+3]+=0.5*(dr.z*dB.z+dr.z*dB.z)*f2*drJ.x*dr.x;
HessianMatrix.element[n+1][n+1]+=0.25*f2*(dr.x*dB.z+dr.z*dB.x)*(drJ.x*dr.z+drJ.z*dr.x)+
0.25*f1*(dB.z*drJ.z+dB.x*drJ.x);
HessianMatrix.element[n+1][n+2]+=0.25*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.x*dr.z+drJ.z*dr.x);
HessianMatrix.element[n+1][n+3]+=0.25*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.x*dr.z+drJ.z*dr.x)+
0.25*f1*(dB.z*drJ.x+dB.z*drJ.x);
HessianMatrix.element[n+2][n+2]+=0.5*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.y*dr.y)+0.5*f1*(dB.y*drJ.y+dB.y*drJ.y);
HessianMatrix.element[n+2][n+3]+=0.5*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.y*dr.y);
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*drJ.z*dr.z+f1*dB.z*drJ.z;
break;
case MONOCLINIC_GAMMA_ANGLE:
HessianMatrix.element[n ][n ]+=f2*dr.x*dr.x*dB.x*dr.x+2.0*f1*dB.x*dr.x; // xxxx
HessianMatrix.element[n ][n+1]+=f2*dr.x*dr.x*dB.x*dr.y+f1*dB.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dr.y*dB.x*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dr.z*dB.x*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=0.5*(f2*(dr.x*dB.y*dr.x*dr.y+dr.y*dB.x*dr.x*dr.y)+f1*(dB.x*dr.x+dB.y*dr.y)); // xyxy
HessianMatrix.element[n+1][n+2]+=0.5*f2*(dr.x*dB.y*dr.y*dr.y+dr.y*dB.x*dr.y*dr.y)+f1*(dB.x*dr.y); // xyyy
HessianMatrix.element[n+1][n+3]+=0.5*f2*(dr.x*dB.y*dr.z*dr.z+dr.y*dB.x*dr.z*dr.z); // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dr.y*dB.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z;
HessianMatrix.element[n][n]+=f2*dr.x*dB.x*drJ.x*dr.x+f1*dB.x*drJ.x;
HessianMatrix.element[n][n+1]+=0.5*f2*(dr.x*dB.y+dr.y*dB.x)*drJ.x*dr.x+0.5*f1*dB.y*(drJ.x);
HessianMatrix.element[n][n+2]+=0.5*(dr.y*dB.y+dr.y*dB.y)*f2*drJ.x*dr.x;
HessianMatrix.element[n][n+3]+=0.5*(dr.z*dB.z+dr.z*dB.z)*f2*drJ.x*dr.x;
HessianMatrix.element[n+1][n+1]+=0.25*f2*(dr.x*dB.y+dr.y*dB.x)*(drJ.x*dr.y+drJ.y*dr.x)+
0.25*f1*(dB.y*drJ.y+dB.x*drJ.x);
HessianMatrix.element[n+1][n+2]+=0.25*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.x*dr.y+drJ.y*dr.x)
+0.25*f1*(dB.y*drJ.x+dB.y*drJ.x);
HessianMatrix.element[n+1][n+3]+=0.25*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.x*dr.y+drJ.y*dr.x);
HessianMatrix.element[n+2][n+2]+=0.5*f2*(dr.y*dB.y+dr.y*dB.y)*(drJ.y*dr.y)+0.5*f1*(dB.y*drJ.y+dB.y*drJ.y);
HessianMatrix.element[n+2][n+3]+=0.5*f2*(dr.z*dB.z+dr.z*dB.z)*(drJ.y*dr.y);
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*drJ.z*dr.z+f1*dB.z*drJ.z;
break;
}
break;
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
// atomic correction
HessianMatrix.element[n ][n ]+=f2*dr.x*dB.x*dr.x*dr.x+2.0*f1*dB.x*dr.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*dB.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dB.x*dr.y*dr.z; // xxyz
HessianMatrix.element[n ][n+3]+=f2*dr.x*dB.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*dB.y*dr.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*dB.y*dr.y*dr.z+f1*dB.y*dr.z; // yyyz
HessianMatrix.element[n+1][n+3]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dB.z*dr.y*dr.z+f1*dB.z*dr.z; // yzyz
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dB.z*dr.z*dr.z; // yzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z; // zzzz
// rigid correction
HessianMatrix.element[n ][n ]+=f2*dr.x*drJ.x*dr.x*dB.x+f1*drJ.x*dB.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*drJ.x*dr.y*dB.y; // xxyy
HessianMatrix.element[n ][n+2]+=f2*dr.x*drJ.x*dr.y*dB.z; // xxyz
HessianMatrix.element[n ][n+3]+=f2*dr.x*drJ.x*dr.z*dB.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.y*drJ.y*dr.y*dB.y+f1*drJ.y*dB.y; // yyyy
HessianMatrix.element[n+1][n+2]+=f2*dr.y*drJ.y*dr.y*dB.z+f1*drJ.y*dB.z; // yyyz
HessianMatrix.element[n+1][n+3]+=f2*dr.y*drJ.y*dr.z*dB.z; // yyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*drJ.z*dr.y*dB.z+f1*drJ.z*dB.z; // yzyz
HessianMatrix.element[n+2][n+3]+=f2*dr.y*drJ.z*dr.z*dB.z; // yzzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*drJ.z*dr.z*dB.z+f1*drJ.z*dB.z; // zzzz
break;
case MONOCLINIC_BETA_ANGLE:
// atomic correction
HessianMatrix.element[n ][n ]+=f2*dr.x*dB.x*dr.x*dr.x+2.0*f1*dB.x*dr.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*dB.x*dr.x*dr.z+f1*dB.x*dr.z; // xxxz
HessianMatrix.element[n ][n+2]+=f2*dr.x*dB.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dB.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dB.z*dr.x*dr.z+f1*dB.z*dr.z; // xzxz
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dB.z*dr.y*dr.y; // xzyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dB.z*dr.z*dr.z; // xzzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dB.y*dr.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z; // zzzz
// rigid correction
HessianMatrix.element[n ][n ]+=f2*dr.x*drJ.x*dr.x*dB.x+f1*drJ.x*dB.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*drJ.x*dr.x*dB.z+f1*drJ.x*dB.z; // xxxz
HessianMatrix.element[n ][n+2]+=f2*dr.x*drJ.x*dr.y*dB.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*drJ.x*dr.z*dB.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*drJ.z*dr.x*dB.z+f1*drJ.z*dB.z; // xzxz
HessianMatrix.element[n+1][n+2]+=f2*dr.x*drJ.z*dr.y*dB.y; // xzyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*drJ.z*dr.z*dB.z; // xzzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*drJ.y*dr.y*dB.y+f1*drJ.y*dB.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*drJ.y*dr.z*dB.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*drJ.z*dr.z*dB.z+f1*drJ.z*dB.z; // zzzz
break;
case MONOCLINIC_GAMMA_ANGLE:
// atomic correction
HessianMatrix.element[n ][n ]+=f2*dr.x*dB.x*dr.x*dr.x+2.0*f1*dB.x*dr.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*dB.x*dr.x*dr.y+f1*dB.x*dr.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*dB.x*dr.y*dr.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*dB.x*dr.z*dr.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*dB.y*dr.x*dr.y+f1*dB.y*dr.y; // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*dB.y*dr.y*dr.y; // xyyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*dB.y*dr.z*dr.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*dB.y*dr.y*dr.y+2.0*f1*dB.y*dr.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*dB.y*dr.z*dr.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*dB.z*dr.z*dr.z+2.0*f1*dB.z*dr.z; // zzzz
// rigid correction
HessianMatrix.element[n ][n ]+=f2*dr.x*drJ.x*dr.x*dB.x+f1*drJ.x*dB.x; // xxxy
HessianMatrix.element[n ][n+1]+=f2*dr.x*drJ.x*dr.x*dB.y+f1*drJ.x*dB.y; // xxxy
HessianMatrix.element[n ][n+2]+=f2*dr.x*drJ.x*dr.y*dB.y; // xxyy
HessianMatrix.element[n ][n+3]+=f2*dr.x*drJ.x*dr.z*dB.z; // xxzz
HessianMatrix.element[n+1][n+1]+=f2*dr.x*drJ.y*dr.x*dB.y+f1*drJ.y*dB.y; // xyxy
HessianMatrix.element[n+1][n+2]+=f2*dr.x*drJ.y*dr.y*dB.y; // xyyy
HessianMatrix.element[n+1][n+3]+=f2*dr.x*drJ.y*dr.z*dB.z; // xyzz
HessianMatrix.element[n+2][n+2]+=f2*dr.y*drJ.y*dr.y*dB.y+f1*drJ.y*dB.y; // yyyy
HessianMatrix.element[n+2][n+3]+=f2*dr.y*drJ.y*dr.z*dB.z; // yyzz
HessianMatrix.element[n+3][n+3]+=f2*dr.z*drJ.z*dr.z*dB.z+f1*drJ.z*dB.z; // zzzz
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
static inline void GradientStrain(REAL *Gradient,REAL f1,VECTOR dr)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
Gradient[n]+=f1*(dr.x*dr.x+dr.y*dr.y+dr.z*dr.z); // xx + yy + zz
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
Gradient[n ]+=f1*dr.x*dr.x; // xx
Gradient[n+1]+=f1*dr.y*dr.y; // yy
Gradient[n+2]+=f1*dr.z*dr.z; // zz
break;
case REGULAR:
case REGULAR_UPPER_TRIANGLE:
Gradient[n ]+=f1*dr.x*dr.x; // xx
Gradient[n+1]+=f1*dr.x*dr.y; // xy
Gradient[n+2]+=f1*dr.x*dr.z; // xz
Gradient[n+3]+=f1*dr.y*dr.y; // yy
Gradient[n+4]+=f1*dr.y*dr.z; // yz
Gradient[n+5]+=f1*dr.z*dr.z; // zz
break;
case MONOCLINIC:
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
Gradient[n ]+=f1*dr.x*dr.x; // xx
Gradient[n+1]+=f1*dr.y*dr.y; // yy
Gradient[n+2]+=f1*dr.y*dr.z; // yz
Gradient[n+3]+=f1*dr.z*dr.z; // zz
break;
case MONOCLINIC_BETA_ANGLE:
Gradient[n ]+=f1*dr.x*dr.x; // xx
Gradient[n+1]+=f1*dr.x*dr.z; // xz
Gradient[n+2]+=f1*dr.y*dr.y; // yy
Gradient[n+3]+=f1*dr.z*dr.z; // zz
break;
case MONOCLINIC_GAMMA_ANGLE:
Gradient[n ]+=f1*dr.x*dr.x; // xx
Gradient[n+1]+=f1*dr.x*dr.y; // xy
Gradient[n+2]+=f1*dr.y*dr.y; // yy
Gradient[n+3]+=f1*dr.z*dr.z; // zz
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
static inline void GradientStrainJ(REAL *Gradient,REAL f1,VECTOR dr,VECTOR posB,VECTOR comB)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
Gradient[n ]+=f1*(dr.x*(posB.x-comB.x)+dr.y*(posB.y-comB.y)+dr.z*(posB.z-comB.z)); // xx + yy + zz
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*dr.y*(posB.y-comB.y); // yy
Gradient[n+2]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case REGULAR:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*0.5*(dr.x*(posB.y-comB.y)+dr.y*(posB.x-comB.x)); // xy
Gradient[n+2]+=f1*0.5*(dr.x*(posB.z-comB.z)+dr.z*(posB.x-comB.x)); // xz
Gradient[n+3]+=f1*(posB.y-comB.y)*dr.y; // yy
Gradient[n+4]+=f1*0.5*(dr.y*(posB.z-comB.z)+dr.z*(posB.y-comB.y)); // yz
Gradient[n+5]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case REGULAR_UPPER_TRIANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*dr.x*(posB.y-comB.y); // xy
Gradient[n+2]+=f1*dr.x*(posB.z-comB.z); // xz
Gradient[n+3]+=f1*dr.y*(posB.y-comB.y); // yy
Gradient[n+4]+=f1*dr.y*(posB.z-comB.z); // yz
Gradient[n+5]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case MONOCLINIC:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*(posB.y-comB.y)*dr.y; // yy
Gradient[n+2]+=f1*0.5*(dr.y*(posB.z-comB.z)+dr.z*(posB.y-comB.y)); // yz
Gradient[n+3]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case MONOCLINIC_BETA_ANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*0.5*(dr.x*(posB.z-comB.z)+dr.z*(posB.x-comB.x)); // xz
Gradient[n+2]+=f1*(posB.y-comB.y)*dr.y; // yy
Gradient[n+3]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case MONOCLINIC_GAMMA_ANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*0.5*(dr.x*(posB.y-comB.y)+dr.y*(posB.x-comB.x)); // xy
Gradient[n+2]+=f1*(posB.y-comB.y)*dr.y; // yy
Gradient[n+3]+=f1*dr.z*(posB.z-comB.z); // zz
break;
}
break;
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*dr.y*(posB.y-comB.y); // yy
Gradient[n+2]+=f1*dr.y*(posB.z-comB.z); // yz
Gradient[n+3]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case MONOCLINIC_BETA_ANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*dr.x*(posB.z-comB.z); // xz
Gradient[n+2]+=f1*dr.y*(posB.y-comB.y); // yy
Gradient[n+3]+=f1*dr.z*(posB.z-comB.z); // zz
break;
case MONOCLINIC_GAMMA_ANGLE:
Gradient[n ]+=f1*dr.x*(posB.x-comB.x); // xx
Gradient[n+1]+=f1*dr.x*(posB.y-comB.y); // xy
Gradient[n+2]+=f1*dr.y*(posB.y-comB.y); // yy
Gradient[n+3]+=f1*dr.z*(posB.z-comB.z); // zz
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
/*********************************************************************************************************
* Name | ComputeFrameworkAdsorbateVDWHessian *
* ----------------------------------------------------------------------------------------------------- *
* Function | Computes the contributions of the framework-adsorbate Van der Waals interactions to the *
* | total energy, gradient, and Hessian-matrix. *
* | interactions. *
* Parameters | Energy: pointer to the total energy *
* | Gradient: array of the gradients *
* | HessianMatrix: the Hessian matrix *
* | StrainDerivative: pointer to a 3x3x matrix of the strain derivative *
* | ComputeGradient: Boolean whether or not to compute the gradient *
* | ComputeHessian: Boolean whether or not to compute the Hessian matrix *
* Note | *
* Used in | void EvaluateDerivatives(...) *
*********************************************************************************************************/
void ComputeFrameworkAdsorbateVDWHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,
REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int J,i,j,jg,ja,fr;
int typeA,typeB;
int TypeMolB;
REAL rr;
REAL energy,f1,f2;
VECTOR posA,posB,dr;
INT_VECTOR3 index_i,index_j,index_j2;
int index2;
REAL ChargeA,ChargeB;
VECTOR pos,comB;
REAL r,temp1,temp2,temp3;
int ncell,k1,k2,k3;
REAL scalingB;
f1=f2=0.0;
index2=0;
// first loop over adsorbate molecules
for(fr=0;fr<Framework[CurrentSystem].NumberOfFrameworks;fr++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[fr];i++)
{
index_i=Framework[CurrentSystem].Atoms[fr][i].HessianIndex;
posA=Framework[CurrentSystem].Atoms[fr][i].Position;
typeA=Framework[CurrentSystem].Atoms[fr][i].Type;
ChargeA=Framework[CurrentSystem].Atoms[fr][i].Charge;
// second loop over adsorbates
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(J=0;J<NumberOfAdsorbateMolecules[CurrentSystem];J++)
{
TypeMolB=Adsorbates[CurrentSystem][J].Type;
for(jg=0;jg<Components[TypeMolB].NumberOfGroups;jg++)
{
for(ja=0;ja<Components[TypeMolB].Groups[jg].NumberOfGroupAtoms;ja++)
{
j=Components[TypeMolB].Groups[jg].Atoms[ja];
if(Components[TypeMolB].Groups[jg].Rigid)
{
index_j=Adsorbates[CurrentSystem][J].Groups[jg].HessianIndex;
index_j2=Adsorbates[CurrentSystem][J].Groups[jg].HessianIndexOrientation;
index2=Adsorbates[CurrentSystem][J].Atoms[j].HessianAtomIndex;
}
else
{
index_j=Adsorbates[CurrentSystem][J].Atoms[j].HessianIndex;
index_j2=UNDEFINED_INT_VECTOR3;
index2=-1;
}
typeB=Adsorbates[CurrentSystem][J].Atoms[j].Type;
posB=Adsorbates[CurrentSystem][J].Atoms[j].Position;
ChargeB=Adsorbates[CurrentSystem][J].Atoms[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);
r=sqrt(rr);
if(rr<CutOffVDWSquared)
{
scalingB=Adsorbates[CurrentSystem][J].Atoms[j].CFVDWScalingParameter;
PotentialSecondDerivative(typeA,typeB,rr,&energy,&f1,&f2,scalingB);
// add contribution to the energy
*Energy+=energy;
//if((index_i<0)&&(index_j<0)&&(index_j2<0)) continue;
StrainDerivative->ax+=f1*dr.x*dr.x;
StrainDerivative->bx+=f1*dr.x*dr.y;
StrainDerivative->cx+=f1*dr.x*dr.z;
StrainDerivative->ay+=f1*dr.y*dr.x;
StrainDerivative->by+=f1*dr.y*dr.y;
StrainDerivative->cy+=f1*dr.y*dr.z;
StrainDerivative->az+=f1*dr.z*dr.x;
StrainDerivative->bz+=f1*dr.z*dr.y;
StrainDerivative->cz+=f1*dr.z*dr.z;
if(Components[TypeMolB].Groups[jg].Rigid)
{
comB=Adsorbates[CurrentSystem][J].Groups[jg].CenterOfMassPosition;
comB.x+=ReplicaShift[ncell].x;
comB.y+=ReplicaShift[ncell].y;
comB.z+=ReplicaShift[ncell].z;
pos=Components[TypeMolB].Positions[j];
temp1=0.5*((posB.y-comB.y)*f1*dr.x+(posB.x-comB.x)*f1*dr.y);
temp2=0.5*((posB.z-comB.z)*f1*dr.x+(posB.x-comB.x)*f1*dr.z);
temp3=0.5*((posB.z-comB.z)*f1*dr.y+(posB.y-comB.y)*f1*dr.z);
StrainDerivative->ax+=(posB.x-comB.x)*f1*dr.x;
StrainDerivative->ay+=temp1;
StrainDerivative->az+=temp2;
StrainDerivative->bx+=temp1;
StrainDerivative->by+=(posB.y-comB.y)*f1*dr.y;
StrainDerivative->bz+=temp3;
StrainDerivative->cx+=temp2;
StrainDerivative->cy+=temp3;
StrainDerivative->cz+=(posB.z-comB.z)*f1*dr.z;
}
// add contribution to the first derivatives
if(ComputeGradient)
{
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) Gradient[index_i.x]+=f1*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=f1*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=f1*dr.z;
}
if(index_j.x>=0) Gradient[index_j.x]-=f1*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=f1*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=f1*dr.z;
GradientStrain(Gradient,f1,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
GradientStrainJ(Gradient,f1,dr,posB,comB);
// add contribution to the first derivatives
if(index_j2.x>=0) Gradient[index_j2.x]-=f1*(dr.x*DVecX[index2].x+dr.y*DVecX[index2].y+dr.z*DVecX[index2].z);
if(index_j2.y>=0) Gradient[index_j2.y]-=f1*(dr.x*DVecY[index2].x+dr.y*DVecY[index2].y+dr.z*DVecY[index2].z);
if(index_j2.z>=0) Gradient[index_j2.z]-=f1*(dr.x*DVecZ[index2].x+dr.y*DVecZ[index2].y+dr.z*DVecZ[index2].z);
}
}
if(ComputeHessian)
{
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,f1,f2,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,f1,f2,dr);
HessianAtomicStrainStrain(HessianMatrix,f1,f2,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
HessianCenterOfMassOrientationJ(HessianMatrix,index_i,index_j,index_j2,index2,f1,f2,dr);
HessianOrientationOrientationJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianCenterOfMassStrainJ(HessianMatrix,index_i,index_j,f1,f2,dr,posB,comB);
HessianOrientationStrainJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianOrientationStrainJ_FR(HessianMatrix,index_j2,index2,f1,f2,posB,comB,dr);
HessianCorrectionStrainStrain(HessianMatrix,f1,f2,dr,posB,comB);
}
}
}
}
}
}
ncell++;
}
}
}
}
void ComputeFrameworkAdsorbateChargeChargeHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,
REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int J,i,j,jg,ja,fr;
int typeA,typeB;
int TypeMolB;
REAL rr,U;
REAL f1,f2;
VECTOR posA,posB,dr;
INT_VECTOR3 index_i,index_j,index_j2;
int index2;
REAL ChargeA,ChargeB;
VECTOR comB;
REAL r,temp1,temp2,temp3;
int ncell,k1,k2,k3;
REAL scalingB;
f1=f2=0.0;
index2=0;
// first loop over adsorbate molecules
for(fr=0;fr<Framework[CurrentSystem].NumberOfFrameworks;fr++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[fr];i++)
{
index_i=Framework[CurrentSystem].Atoms[fr][i].HessianIndex;
posA=Framework[CurrentSystem].Atoms[fr][i].Position;
typeA=Framework[CurrentSystem].Atoms[fr][i].Type;
ChargeA=Framework[CurrentSystem].Atoms[fr][i].Charge;
// second loop over adsorbates
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(J=0;J<NumberOfAdsorbateMolecules[CurrentSystem];J++)
{
TypeMolB=Adsorbates[CurrentSystem][J].Type;
for(jg=0;jg<Components[TypeMolB].NumberOfGroups;jg++)
{
for(ja=0;ja<Components[TypeMolB].Groups[jg].NumberOfGroupAtoms;ja++)
{
j=Components[TypeMolB].Groups[jg].Atoms[ja];
if(Components[TypeMolB].Groups[jg].Rigid)
{
index_j=Adsorbates[CurrentSystem][J].Groups[jg].HessianIndex;
index_j2=Adsorbates[CurrentSystem][J].Groups[jg].HessianIndexOrientation;
index2=Adsorbates[CurrentSystem][J].Atoms[j].HessianAtomIndex;
}
else
{
index_j=Adsorbates[CurrentSystem][J].Atoms[j].HessianIndex;
index_j2=UNDEFINED_INT_VECTOR3;
index2=-1;
}
typeB=Adsorbates[CurrentSystem][J].Atoms[j].Type;
posB=Adsorbates[CurrentSystem][J].Atoms[j].Position;
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);
r=sqrt(rr);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
scalingB=Adsorbates[CurrentSystem][J].Atoms[j].CFChargeScalingParameter;
ChargeB=scalingB*Adsorbates[CurrentSystem][J].Atoms[j].Charge;
PotentialSecondDerivativeCoulombic(ChargeA,ChargeB,rr,&U,&f1,&f2);
*Energy+=U;
StrainDerivative->ax+=f1*dr.x*dr.x;
StrainDerivative->bx+=f1*dr.x*dr.y;
StrainDerivative->cx+=f1*dr.x*dr.z;
StrainDerivative->ay+=f1*dr.y*dr.x;
StrainDerivative->by+=f1*dr.y*dr.y;
StrainDerivative->cy+=f1*dr.y*dr.z;
StrainDerivative->az+=f1*dr.z*dr.x;
StrainDerivative->bz+=f1*dr.z*dr.y;
StrainDerivative->cz+=f1*dr.z*dr.z;
if(Components[TypeMolB].Groups[jg].Rigid)
{
comB=Adsorbates[CurrentSystem][J].Groups[jg].CenterOfMassPosition;
comB.x+=ReplicaShift[ncell].x;
comB.y+=ReplicaShift[ncell].y;
comB.z+=ReplicaShift[ncell].z;
temp1=0.5*((posB.y-comB.y)*f1*dr.x+(posB.x-comB.x)*f1*dr.y);
temp2=0.5*((posB.z-comB.z)*f1*dr.x+(posB.x-comB.x)*f1*dr.z);
temp3=0.5*((posB.z-comB.z)*f1*dr.y+(posB.y-comB.y)*f1*dr.z);
StrainDerivative->ax+=(posB.x-comB.x)*f1*dr.x;
StrainDerivative->ay+=temp1;
StrainDerivative->az+=temp2;
StrainDerivative->bx+=temp1;
StrainDerivative->by+=(posB.y-comB.y)*f1*dr.y;
StrainDerivative->bz+=temp3;
StrainDerivative->cx+=temp2;
StrainDerivative->cy+=temp3;
StrainDerivative->cz+=(posB.z-comB.z)*f1*dr.z;
}
// add contribution to the first derivatives
if(ComputeGradient)
{
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) Gradient[index_i.x]+=f1*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=f1*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=f1*dr.z;
}
if(index_j.x>=0) Gradient[index_j.x]-=f1*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=f1*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=f1*dr.z;
GradientStrain(Gradient,f1,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
GradientStrainJ(Gradient,f1,dr,posB,comB);
// add contribution to the first derivatives
if(index_j2.x>=0) Gradient[index_j2.x]-=f1*(dr.x*DVecX[index2].x+dr.y*DVecX[index2].y+dr.z*DVecX[index2].z);
if(index_j2.y>=0) Gradient[index_j2.y]-=f1*(dr.x*DVecY[index2].x+dr.y*DVecY[index2].y+dr.z*DVecY[index2].z);
if(index_j2.z>=0) Gradient[index_j2.z]-=f1*(dr.x*DVecZ[index2].x+dr.y*DVecZ[index2].y+dr.z*DVecZ[index2].z);
}
}
if(ComputeHessian)
{
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,f1,f2,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,f1,f2,dr);
HessianAtomicStrainStrain(HessianMatrix,f1,f2,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
HessianCenterOfMassOrientationJ(HessianMatrix,index_i,index_j,index_j2,index2,f1,f2,dr);
HessianOrientationOrientationJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianCenterOfMassStrainJ(HessianMatrix,index_i,index_j,f1,f2,dr,posB,comB);
HessianOrientationStrainJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianOrientationStrainJ_FR(HessianMatrix,index_j2,index2,f1,f2,posB,comB,dr);
HessianCorrectionStrainStrain(HessianMatrix,f1,f2,dr,posB,comB);
}
}
}
}
}
}
ncell++;
}
}
}
}
/*********************************************************************************************************
* Name | ComputeFrameworkCationVDWHessian *
* ----------------------------------------------------------------------------------------------------- *
* Function | Computes the contributions of the framework-cation Van der Waals interactions to the *
* | total energy, gradient, and Hessian-matrix. *
* | interactions. *
* Parameters | Energy: pointer to the total energy *
* | Gradient: array of the gradients *
* | HessianMatrix: the Hessian matrix *
* | StrainDerivative: pointer to a 3x3x matrix of the strain derivative *
* | ComputeGradient: Boolean whether or not to compute the gradient *
* | ComputeHessian: Boolean whether or not to compute the Hessian matrix *
* Note | *
* Used in | void EvaluateDerivatives(...) *
*********************************************************************************************************/
void ComputeFrameworkCationVDWHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,
REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int J,i,j,jg,ja,fr;
int typeA,typeB;
int TypeMolB;
REAL rr;
REAL energy,f1,f2;
VECTOR posA,posB,dr;
INT_VECTOR3 index_i,index_j,index_j2;
int index2;
REAL ChargeA,ChargeB;
VECTOR pos,comB;
REAL r,temp1,temp2,temp3;
int ncell,k1,k2,k3;
REAL scalingB;
f1=f2=0.0;
index2=0;
// first loop over framework atoms
for(fr=0;fr<Framework[CurrentSystem].NumberOfFrameworks;fr++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[fr];i++)
{
index_i=Framework[CurrentSystem].Atoms[fr][i].HessianIndex;
posA=Framework[CurrentSystem].Atoms[fr][i].Position;
typeA=Framework[CurrentSystem].Atoms[fr][i].Type;
ChargeA=Framework[CurrentSystem].Atoms[fr][i].Charge;
// second loop over adsorbates
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(J=0;J<NumberOfCationMolecules[CurrentSystem];J++)
{
TypeMolB=Cations[CurrentSystem][J].Type;
for(jg=0;jg<Components[TypeMolB].NumberOfGroups;jg++)
{
for(ja=0;ja<Components[TypeMolB].Groups[jg].NumberOfGroupAtoms;ja++)
{
j=Components[TypeMolB].Groups[jg].Atoms[ja];
if(Components[TypeMolB].Groups[jg].Rigid)
{
index_j=Cations[CurrentSystem][J].Groups[jg].HessianIndex;
index_j2=Cations[CurrentSystem][J].Groups[jg].HessianIndexOrientation;
index2=Cations[CurrentSystem][J].Atoms[j].HessianAtomIndex;
}
else
{
index_j=Cations[CurrentSystem][J].Atoms[j].HessianIndex;
index_j2=UNDEFINED_INT_VECTOR3;
index2=-1;
}
typeB=Cations[CurrentSystem][J].Atoms[j].Type;
posB=Cations[CurrentSystem][J].Atoms[j].Position;
ChargeB=Cations[CurrentSystem][J].Atoms[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);
r=sqrt(rr);
if(rr<CutOffVDWSquared)
{
scalingB=Cations[CurrentSystem][J].Atoms[j].CFVDWScalingParameter;
PotentialSecondDerivative(typeA,typeB,rr,&energy,&f1,&f2,scalingB);
// add contribution to the energy
*Energy+=energy;
//if((index_i<0)&&(index_j<0)&&(index_j2<0)) continue;
StrainDerivative->ax+=f1*dr.x*dr.x;
StrainDerivative->bx+=f1*dr.x*dr.y;
StrainDerivative->cx+=f1*dr.x*dr.z;
StrainDerivative->ay+=f1*dr.y*dr.x;
StrainDerivative->by+=f1*dr.y*dr.y;
StrainDerivative->cy+=f1*dr.y*dr.z;
StrainDerivative->az+=f1*dr.z*dr.x;
StrainDerivative->bz+=f1*dr.z*dr.y;
StrainDerivative->cz+=f1*dr.z*dr.z;
if(Components[TypeMolB].Groups[jg].Rigid)
{
comB=Cations[CurrentSystem][J].Groups[jg].CenterOfMassPosition;
comB.x+=ReplicaShift[ncell].x;
comB.y+=ReplicaShift[ncell].y;
comB.z+=ReplicaShift[ncell].z;
pos=Components[TypeMolB].Positions[j];
temp1=0.5*((posB.y-comB.y)*f1*dr.x+(posB.x-comB.x)*f1*dr.y);
temp2=0.5*((posB.z-comB.z)*f1*dr.x+(posB.x-comB.x)*f1*dr.z);
temp3=0.5*((posB.z-comB.z)*f1*dr.y+(posB.y-comB.y)*f1*dr.z);
StrainDerivative->ax+=(posB.x-comB.x)*f1*dr.x;
StrainDerivative->ay+=temp1;
StrainDerivative->az+=temp2;
StrainDerivative->bx+=temp1;
StrainDerivative->by+=(posB.y-comB.y)*f1*dr.y;
StrainDerivative->bz+=temp3;
StrainDerivative->cx+=temp2;
StrainDerivative->cy+=temp3;
StrainDerivative->cz+=(posB.z-comB.z)*f1*dr.z;
}
// add contribution to the first derivatives
if(ComputeGradient)
{
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) Gradient[index_i.x]+=f1*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=f1*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=f1*dr.z;
}
if(index_j.x>=0) Gradient[index_j.x]-=f1*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=f1*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=f1*dr.z;
GradientStrain(Gradient,f1,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
GradientStrainJ(Gradient,f1,dr,posB,comB);
// add contribution to the first derivatives
if(index_j2.x>=0) Gradient[index_j2.x]-=f1*(dr.x*DVecX[index2].x+dr.y*DVecX[index2].y+dr.z*DVecX[index2].z);
if(index_j2.y>=0) Gradient[index_j2.y]-=f1*(dr.x*DVecY[index2].x+dr.y*DVecY[index2].y+dr.z*DVecY[index2].z);
if(index_j2.z>=0) Gradient[index_j2.z]-=f1*(dr.x*DVecZ[index2].x+dr.y*DVecZ[index2].y+dr.z*DVecZ[index2].z);
}
}
if(ComputeHessian)
{
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,f1,f2,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,f1,f2,dr);
HessianAtomicStrainStrain(HessianMatrix,f1,f2,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
HessianCenterOfMassOrientationJ(HessianMatrix,index_i,index_j,index_j2,index2,f1,f2,dr);
HessianOrientationOrientationJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianCenterOfMassStrainJ(HessianMatrix,index_i,index_j,f1,f2,dr,posB,comB);
HessianOrientationStrainJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianOrientationStrainJ_FR(HessianMatrix,index_j2,index2,f1,f2,posB,comB,dr);
HessianCorrectionStrainStrain(HessianMatrix,f1,f2,dr,posB,comB);
}
}
}
}
}
}
ncell++;
}
}
}
}
void ComputeFrameworkCationChargeChargeHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,
REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int J,i,j,jg,ja,fr;
int typeA,typeB;
int TypeMolB;
REAL rr,U;
REAL f1,f2;
VECTOR posA,posB,dr;
INT_VECTOR3 index_i,index_j,index_j2;
int index2;
REAL ChargeA,ChargeB;
VECTOR comB;
REAL r,temp1,temp2,temp3;
int ncell,k1,k2,k3;
REAL scalingB;
f1=f2=0.0;
index2=0;
for(fr=0;fr<Framework[CurrentSystem].NumberOfFrameworks;fr++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[fr];i++)
{
index_i=Framework[CurrentSystem].Atoms[fr][i].HessianIndex;
posA=Framework[CurrentSystem].Atoms[fr][i].Position;
typeA=Framework[CurrentSystem].Atoms[fr][i].Type;
ChargeA=Framework[CurrentSystem].Atoms[fr][i].Charge;
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(J=0;J<NumberOfCationMolecules[CurrentSystem];J++)
{
TypeMolB=Cations[CurrentSystem][J].Type;
for(jg=0;jg<Components[TypeMolB].NumberOfGroups;jg++)
{
for(ja=0;ja<Components[TypeMolB].Groups[jg].NumberOfGroupAtoms;ja++)
{
j=Components[TypeMolB].Groups[jg].Atoms[ja];
if(Components[TypeMolB].Groups[jg].Rigid)
{
index_j=Cations[CurrentSystem][J].Groups[jg].HessianIndex;
index_j2=Cations[CurrentSystem][J].Groups[jg].HessianIndexOrientation;
index2=Cations[CurrentSystem][J].Atoms[j].HessianAtomIndex;
}
else
{
index_j=Cations[CurrentSystem][J].Atoms[j].HessianIndex;
index_j2=UNDEFINED_INT_VECTOR3;
index2=-1;
}
typeB=Cations[CurrentSystem][J].Atoms[j].Type;
posB=Cations[CurrentSystem][J].Atoms[j].Position;
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);
r=sqrt(rr);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
scalingB=Cations[CurrentSystem][J].Atoms[j].CFChargeScalingParameter;
ChargeB=scalingB*Cations[CurrentSystem][J].Atoms[j].Charge;
PotentialSecondDerivativeCoulombic(ChargeA,ChargeB,rr,&U,&f1,&f2);
*Energy+=U;
StrainDerivative->ax+=f1*dr.x*dr.x;
StrainDerivative->bx+=f1*dr.x*dr.y;
StrainDerivative->cx+=f1*dr.x*dr.z;
StrainDerivative->ay+=f1*dr.y*dr.x;
StrainDerivative->by+=f1*dr.y*dr.y;
StrainDerivative->cy+=f1*dr.y*dr.z;
StrainDerivative->az+=f1*dr.z*dr.x;
StrainDerivative->bz+=f1*dr.z*dr.y;
StrainDerivative->cz+=f1*dr.z*dr.z;
if(Components[TypeMolB].Groups[jg].Rigid)
{
comB=Cations[CurrentSystem][J].Groups[jg].CenterOfMassPosition;
comB.x+=ReplicaShift[ncell].x;
comB.y+=ReplicaShift[ncell].y;
comB.z+=ReplicaShift[ncell].z;
temp1=0.5*((posB.y-comB.y)*f1*dr.x+(posB.x-comB.x)*f1*dr.y);
temp2=0.5*((posB.z-comB.z)*f1*dr.x+(posB.x-comB.x)*f1*dr.z);
temp3=0.5*((posB.z-comB.z)*f1*dr.y+(posB.y-comB.y)*f1*dr.z);
StrainDerivative->ax+=(posB.x-comB.x)*f1*dr.x;
StrainDerivative->ay+=temp1;
StrainDerivative->az+=temp2;
StrainDerivative->bx+=temp1;
StrainDerivative->by+=(posB.y-comB.y)*f1*dr.y;
StrainDerivative->bz+=temp3;
StrainDerivative->cx+=temp2;
StrainDerivative->cy+=temp3;
StrainDerivative->cz+=(posB.z-comB.z)*f1*dr.z;
}
// add contribution to the first derivatives
if(ComputeGradient)
{
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
if(index_i.x>=0) Gradient[index_i.x]+=f1*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=f1*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=f1*dr.z;
}
if(index_j.x>=0) Gradient[index_j.x]-=f1*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=f1*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=f1*dr.z;
GradientStrain(Gradient,f1,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
GradientStrainJ(Gradient,f1,dr,posB,comB);
// add contribution to the first derivatives
if(index_j2.x>=0) Gradient[index_j2.x]-=f1*(dr.x*DVecX[index2].x+dr.y*DVecX[index2].y+dr.z*DVecX[index2].z);
if(index_j2.y>=0) Gradient[index_j2.y]-=f1*(dr.x*DVecY[index2].x+dr.y*DVecY[index2].y+dr.z*DVecY[index2].z);
if(index_j2.z>=0) Gradient[index_j2.z]-=f1*(dr.x*DVecZ[index2].x+dr.y*DVecZ[index2].y+dr.z*DVecZ[index2].z);
}
}
if(ComputeHessian)
{
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,f1,f2,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,f1,f2,dr);
HessianAtomicStrainStrain(HessianMatrix,f1,f2,dr);
if(Components[TypeMolB].Groups[jg].Rigid)
{
HessianCenterOfMassOrientationJ(HessianMatrix,index_i,index_j,index_j2,index2,f1,f2,dr);
HessianOrientationOrientationJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianCenterOfMassStrainJ(HessianMatrix,index_i,index_j,f1,f2,dr,posB,comB);
HessianOrientationStrainJ(HessianMatrix,index_j2,index2,f1,f2,dr);
HessianOrientationStrainJ_FR(HessianMatrix,index_j2,index2,f1,f2,posB,comB,dr);
HessianCorrectionStrainStrain(HessianMatrix,f1,f2,dr,posB,comB);
}
}
}
}
}
}
ncell++;
}
}
}
}
void ComputeFrameworkIntraVDWHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,
REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i,j,typeA,typeB,f1,f2,start;
REAL energy,DF,DDF;
REAL rr;
VECTOR posA,posB,dr;
INT_VECTOR3 index_i,index_j;
int A,B;
int ncell,k1,k2,k3,indj;
REAL ReplicaFactor;
REAL *parms;
if(!InternalFrameworkLennardJonesInteractions) return;
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;
index_i=Framework[CurrentSystem].Atoms[f1][i].HessianIndex;
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++)
{
indj=j+ncell*Framework[CurrentSystem].NumberOfAtoms[f2];
if(f1!=f2?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][indj],0))
{
typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
posB=Framework[CurrentSystem].Atoms[f2][j].Position;
index_j=Framework[CurrentSystem].Atoms[f2][j].HessianIndex;
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<CutOffVDWSquared)
{
if(ncell==0) ReplicaFactor=1.0;
else ReplicaFactor=0.5;
PotentialSecondDerivative(typeA,typeB,rr,&energy,&DF,&DDF,1.0);
// add contribution to the energy
*Energy+=ReplicaFactor*energy;
if(ComputeGradient)
{
// add contribution to the first derivatives
if(index_i.x>=0) Gradient[index_i.x]+=DF*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dr.z;
if(ncell==0)
{
if(index_j.x>=0) Gradient[index_j.x]-=DF*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=DF*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=DF*dr.z;
}
GradientStrain(Gradient,ReplicaFactor*DF,dr);
}
// add contribution to the strain derivative tensor
StrainDerivative->ax+=ReplicaFactor*DF*dr.x*dr.x;
StrainDerivative->bx+=ReplicaFactor*DF*dr.y*dr.x;
StrainDerivative->cx+=ReplicaFactor*DF*dr.z*dr.x;
StrainDerivative->ay+=ReplicaFactor*DF*dr.x*dr.y;
StrainDerivative->by+=ReplicaFactor*DF*dr.y*dr.y;
StrainDerivative->cy+=ReplicaFactor*DF*dr.z*dr.y;
StrainDerivative->az+=ReplicaFactor*DF*dr.x*dr.z;
StrainDerivative->bz+=ReplicaFactor*DF*dr.y*dr.z;
StrainDerivative->cz+=ReplicaFactor*DF*dr.z*dr.z;
if(ComputeHessian)
{
// add contribution to the second derivatives (Hessian matrix)
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,DF,DDF,dr,ReplicaFactor);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,ReplicaFactor*DF,ReplicaFactor*DDF,dr);
HessianAtomicStrainStrain(HessianMatrix,ReplicaFactor*DF,ReplicaFactor*DDF,dr);
}
}
}
}
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;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
typeB=Framework[CurrentSystem].Atoms[f1][B].Type;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
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);
PotentialSecondDerivative(typeA,typeB,rr,&energy,&DF,&DDF,1.0);
energy*=parms[6];
DF*=parms[6];
DDF*=parms[6];
// add contribution to the energy
*Energy+=energy;
if(ComputeGradient)
{
// add contribution to the first derivatives
if(index_i.x>=0) Gradient[index_i.x]+=DF*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dr.z;
if(index_j.x>=0) Gradient[index_j.x]-=DF*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=DF*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=DF*dr.z;
GradientStrain(Gradient,DF,dr);
}
// add contribution to the strain derivative tensor
StrainDerivative->ax+=DF*dr.x*dr.x;
StrainDerivative->bx+=DF*dr.y*dr.x;
StrainDerivative->cx+=DF*dr.z*dr.x;
StrainDerivative->ay+=DF*dr.x*dr.y;
StrainDerivative->by+=DF*dr.y*dr.y;
StrainDerivative->cy+=DF*dr.z*dr.y;
StrainDerivative->az+=DF*dr.x*dr.z;
StrainDerivative->bz+=DF*dr.y*dr.z;
StrainDerivative->cz+=DF*dr.z*dr.z;
if(ComputeHessian)
{
// add contribution to the second derivatives (Hessian matrix)
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,DF,DDF,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,DF,DDF,dr);
HessianAtomicStrainStrain(HessianMatrix,DF,DDF,dr);
}
}
}
}
}
}
}
void ComputeFrameworkIntraChargeChargeHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,
REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i,j,typeA,typeB,f1,f2,start;
REAL ChargeA,ChargeB,DF,DDF;
REAL rr,r,U;
VECTOR posA,posB,dr;
INT_VECTOR3 index_i,index_j;
int A,B;
int ncell,k1,k2,k3,indj;
REAL ReplicaFactor;
REAL *parms;
if(ChargeMethod==NONE) return;
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;
index_i=Framework[CurrentSystem].Atoms[f1][i].HessianIndex;
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++)
{
indj=j+ncell*Framework[CurrentSystem].NumberOfAtoms[f2];
if(f1!=f2?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][indj],1))
{
typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
posB=Framework[CurrentSystem].Atoms[f2][j].Position;
ChargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;
index_j=Framework[CurrentSystem].Atoms[f2][j].HessianIndex;
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);
r=sqrt(rr);
if(rr<CutOffChargeChargeSquared[CurrentSystem])
{
if(ncell==0) ReplicaFactor=1.0;
else ReplicaFactor=0.5;
PotentialSecondDerivativeCoulombic(ChargeA,ChargeB,rr,&U,&DF,&DDF);
*Energy+=ReplicaFactor*U;
if(ComputeGradient)
{
// add contribution to the first derivatives
if(index_i.x>=0) Gradient[index_i.x]+=DF*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dr.z;
if(ncell==0)
{
if(index_j.x>=0) Gradient[index_j.x]-=DF*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=DF*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=DF*dr.z;
}
GradientStrain(Gradient,ReplicaFactor*DF,dr);
}
// add contribution to the strain derivative tensor
StrainDerivative->ax+=ReplicaFactor*DF*dr.x*dr.x;
StrainDerivative->bx+=ReplicaFactor*DF*dr.y*dr.x;
StrainDerivative->cx+=ReplicaFactor*DF*dr.z*dr.x;
StrainDerivative->ay+=ReplicaFactor*DF*dr.x*dr.y;
StrainDerivative->by+=ReplicaFactor*DF*dr.y*dr.y;
StrainDerivative->cy+=ReplicaFactor*DF*dr.z*dr.y;
StrainDerivative->az+=ReplicaFactor*DF*dr.x*dr.z;
StrainDerivative->bz+=ReplicaFactor*DF*dr.y*dr.z;
StrainDerivative->cz+=ReplicaFactor*DF*dr.z*dr.z;
if(ComputeHessian)
{
// add contribution to the second derivatives (Hessian matrix)
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,DF,DDF,dr,ReplicaFactor);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,ReplicaFactor*DF,ReplicaFactor*DDF,dr);
HessianAtomicStrainStrain(HessianMatrix,ReplicaFactor*DF,ReplicaFactor*DDF,dr);
}
}
}
}
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[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))
{
typeA=Framework[CurrentSystem].Atoms[f1][A].Type;
posA=Framework[CurrentSystem].Atoms[f1][A].Position;
ChargeA=Framework[CurrentSystem].Atoms[f1][A].Charge;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
typeB=Framework[CurrentSystem].Atoms[f1][B].Type;
posB=Framework[CurrentSystem].Atoms[f1][B].Position;
ChargeB=Framework[CurrentSystem].Atoms[f1][B].Charge;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
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);
// add contribution to the energy
*Energy+=parms[7]*COULOMBIC_CONVERSION_FACTOR*ChargeA*ChargeB*(1.0/r);
DF=-parms[7]*COULOMBIC_CONVERSION_FACTOR*ChargeA*ChargeB/(rr*r);
DDF=parms[7]*3.0*COULOMBIC_CONVERSION_FACTOR*ChargeA*ChargeB/(SQR(rr)*r);
//if((index_i<0)&&(index_j)<0) continue;
if(ComputeGradient)
{
// add contribution to the first derivatives
if(index_i.x>=0) Gradient[index_i.x]+=DF*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dr.z;
if(index_j.x>=0) Gradient[index_j.x]-=DF*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=DF*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=DF*dr.z;
GradientStrain(Gradient,DF,dr);
}
// add contribution to the strain derivative tensor
StrainDerivative->ax+=DF*dr.x*dr.x;
StrainDerivative->bx+=DF*dr.y*dr.x;
StrainDerivative->cx+=DF*dr.z*dr.x;
StrainDerivative->ay+=DF*dr.x*dr.y;
StrainDerivative->by+=DF*dr.y*dr.y;
StrainDerivative->cy+=DF*dr.z*dr.y;
StrainDerivative->az+=DF*dr.x*dr.z;
StrainDerivative->bz+=DF*dr.y*dr.z;
StrainDerivative->cz+=DF*dr.z*dr.z;
if(ComputeHessian)
{
// add contribution to the second derivatives (Hessian matrix)
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,DF,DDF,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,DF,DDF,dr);
HessianAtomicStrainStrain(HessianMatrix,DF,DDF,dr);
}
}
}
}
}
}
}
void ComputeFrameworkBondHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i; // loop variable
int f1; // loop over all frameworks
REAL r; // distance
REAL rr; // distance squared
REAL temp,temp2; // temporary
REAL exp_term; // temporary
REAL U; // energy of a specific interaction
REAL DF; // first derivative
REAL DDF; // second derivative
VECTOR dr; // atoms separation vector
int A,B; // atom-indices
INT_VECTOR3 index_i,index_j; // indices of the Hessian
REAL *parms; // pointer to potential parameter
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfBonds[f1];i++)
{
A=Framework[CurrentSystem].Bonds[f1][i].A;
B=Framework[CurrentSystem].Bonds[f1][i].B;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
dr.x=Framework[CurrentSystem].Atoms[f1][A].Position.x-
Framework[CurrentSystem].Atoms[f1][B].Position.x;
dr.y=Framework[CurrentSystem].Atoms[f1][A].Position.y-
Framework[CurrentSystem].Atoms[f1][B].Position.y;
dr.z=Framework[CurrentSystem].Atoms[f1][A].Position.z-
Framework[CurrentSystem].Atoms[f1][B].Position.z;
// apply boundary condition
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;
DDF=(parms[0]*parms[1])/(r*rr);
//DDF=(parms[0]/r-DF)/rr;
break;
case CORE_SHELL_SPRING:
U=0.5*parms[0]*SQR(r);
DF=parms[0];
DDF=0.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;
DDF=2.0*parms[0]*parms[1]*temp*((1.0+2.0*parms[1]*r)*temp-parms[1]*r-1.0)/(r*rr);
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;
DDF=24.0*(7.0*parms[0]*SQR(temp)-2.0*parms[1]*temp)/SQR(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;
DDF=96.0*parms[0]*(temp*(7.0*temp-2.0))/SQR(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;
DDF=(-48.0*temp/rr+parms[1]*(1.0+parms[1]*r)*exp_term/r)/rr;
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]
temp=r-parms[1];
U=0.5*parms[0]*SQR(MIN2(fabs(temp),parms[2]))
+parms[0]*parms[2]*MAX2(fabs(temp)-parms[2],(REAL)0.0);
DF=-parms[0]*(SIGN(MIN2(fabs(temp),parms[2]),temp))/r;
DDF=fabs(temp)<parms[2]?-parms[0]*parms[1]/(r*rr):parms[0]*SIGN(parms[2],temp)/(r*rr);
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;
DDF=2.0*parms[3]+(parms[2]-3.0*parms[1]*parms[3])/r+(parms[1]*(parms[0]+parms[1]*(parms[1]*parms[3]-parms[2])))/(r*rr);
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;
DDF=8.0*parms[3]+(3.0*parms[2]-3.0*parms[1]*4.0*parms[3])/r+(parms[1]*(2.0*parms[0]+parms[1]*(parms[1]*4.0*parms[3]-3.0*parms[2])))/(r*rr);
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;
DDF=(parms[0]*(SQR(2.55)*4.0*7.0*temp2*(parms[1]+2.0*r)+12.0*(2.0*parms[1]+2.55*3.0*(SQR(parms[1])-SQR(r)))))/(12.0*SQR(r)*r);
break;
case RIGID_BOND:
U=DF=DDF=0.0;
break;
case FIXED_BOND:
U=DF=DDF=0.0;
break;
case MEASURE_BOND:
U=DF=DDF=0.0;
break;
default:
fprintf(stderr, "Undefined Bond potential in routine 'CalculateFrameworkBondHessian' ('framework_hessian.c')\n");
exit(0);
break;
}
// add contribution to the energy
*Energy+=U;
//if((index_i<0)&&(index_j<0)) continue;
if(ComputeGradient)
{
// add contribution to the first derivatives
if(index_i.x>=0) Gradient[index_i.x]+=DF*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dr.z;
if(index_j.x>=0) Gradient[index_j.x]-=DF*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=DF*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=DF*dr.z;
GradientStrain(Gradient,DF,dr);
}
// add contribution to the strain derivative tensor
StrainDerivative->ax+=dr.x*DF*dr.x;
StrainDerivative->bx+=dr.y*DF*dr.x;
StrainDerivative->cx+=dr.z*DF*dr.x;
StrainDerivative->ay+=dr.x*DF*dr.y;
StrainDerivative->by+=dr.y*DF*dr.y;
StrainDerivative->cy+=dr.z*DF*dr.y;
StrainDerivative->az+=dr.x*DF*dr.z;
StrainDerivative->bz+=dr.y*DF*dr.z;
StrainDerivative->cz+=dr.z*DF*dr.z;
if(ComputeHessian)
{
// add contribution to the second derivatives (Hessian matrix)
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,DF,DDF,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,DF,DDF,dr);
HessianAtomicStrainStrain(HessianMatrix,DF,DDF,dr);
}
}
}
}
void ComputeFrameworkUreyBradleyHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i; // loop variable
int f1; // loop over all frameworks
REAL r; // distance
REAL rr; // distance squared
REAL temp,temp2; // temporary
REAL exp_term; // temporary
REAL U; // energy of a specific interaction
REAL DF; // first derivative
REAL DDF; // second derivative
VECTOR dr; // atoms separation vector
int A,C; // atom-indices
INT_VECTOR3 index_i,index_j; // indices of the Hessian
REAL *parms; // pointer to potential parameter
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfUreyBradleys[f1];i++)
{
A=Framework[CurrentSystem].UreyBradleys[f1][i].A;
C=Framework[CurrentSystem].UreyBradleys[f1][i].C;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][C].HessianIndex;
dr.x=Framework[CurrentSystem].Atoms[f1][A].Position.x-
Framework[CurrentSystem].Atoms[f1][C].Position.x;
dr.y=Framework[CurrentSystem].Atoms[f1][A].Position.y-
Framework[CurrentSystem].Atoms[f1][C].Position.y;
dr.z=Framework[CurrentSystem].Atoms[f1][A].Position.z-
Framework[CurrentSystem].Atoms[f1][C].Position.z;
// apply boundary condition
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;
DDF=(parms[0]*parms[1])/(r*rr);
//DDF=(parms[0]/r-DF)/rr;
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;
DDF=2.0*parms[0]*parms[1]*temp*((1.0+2.0*parms[1]*r)*temp-parms[1]*r-1.0)/(r*rr);
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;
DDF=24.0*(7.0*parms[0]*SQR(temp)-2.0*parms[1]*temp)/SQR(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;
DDF=96.0*parms[0]*(temp*(7.0*temp-2.0))/SQR(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;
DDF=(-48.0*temp/rr+parms[1]*(1.0+parms[1]*r)*exp_term/r)/rr;
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]
temp=r-parms[1];
U=0.5*parms[0]*SQR(MIN2(fabs(temp),parms[2]))
+parms[0]*parms[2]*MAX2(fabs(temp)-parms[2],(REAL)0.0);
DF=-parms[0]*(SIGN(MIN2(fabs(temp),parms[2]),temp))/r;
DDF=fabs(temp)<parms[2]?-parms[0]*parms[1]/(r*rr):parms[0]*SIGN(parms[2],temp)/(r*rr);
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;
DDF=2.0*parms[3]+(parms[2]-3.0*parms[1]*parms[3])/r+(parms[1]*(parms[0]+parms[1]*(parms[1]*parms[3]-parms[2])))/(r*rr);
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;
DDF=8.0*parms[3]+(3.0*parms[2]-3.0*parms[1]*4.0*parms[3])/r+(parms[1]*(2.0*parms[0]+parms[1]*(parms[1]*4.0*parms[3]-3.0*parms[2])))/(r*rr);
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;
DDF=(parms[0]*(SQR(2.55)*4.0*7.0*temp2*(parms[1]+2.0*r)+12.0*(2.0*parms[1]+2.55*3.0*(SQR(parms[1])-SQR(r)))))/(12.0*SQR(r)*r);
break;
case RIGID_UREYBRADLEY:
U=DF=DDF=0.0;
break;
case FIXED_UREYBRADLEY:
U=DF=DDF=0.0;
break;
case MEASURE_UREYBRADLEY:
U=DF=DDF=0.0;
break;
default:
fprintf(stderr, "Undefined UreyBradley potential in routine 'CalculateFrameworkUreyBradleyHessian' ('framework_hessian.c')\n");
exit(0);
break;
}
// add contribution to the energy
*Energy+=U;
//if((index_i<0)&&(index_j<0)) continue;
if(ComputeGradient)
{
// add contribution to the first derivatives
if(index_i.x>=0) Gradient[index_i.x]+=DF*dr.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dr.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dr.z;
if(index_j.x>=0) Gradient[index_j.x]-=DF*dr.x;
if(index_j.y>=0) Gradient[index_j.y]-=DF*dr.y;
if(index_j.z>=0) Gradient[index_j.z]-=DF*dr.z;
GradientStrain(Gradient,DF,dr);
}
// add contribution to the strain derivative tensor
StrainDerivative->ax+=dr.x*DF*dr.x;
StrainDerivative->bx+=dr.y*DF*dr.x;
StrainDerivative->cx+=dr.z*DF*dr.x;
StrainDerivative->ay+=dr.x*DF*dr.y;
StrainDerivative->by+=dr.y*DF*dr.y;
StrainDerivative->cy+=dr.z*DF*dr.y;
StrainDerivative->az+=dr.x*DF*dr.z;
StrainDerivative->bz+=dr.y*DF*dr.z;
StrainDerivative->cz+=dr.z*DF*dr.z;
if(ComputeHessian)
{
// add contribution to the second derivatives (Hessian matrix)
HessianAtomicPositionPosition(HessianMatrix,index_i,index_j,DF,DDF,dr,1.0);
HessianAtomicPositionStrain(HessianMatrix,index_i,index_j,DF,DDF,dr);
HessianAtomicStrainStrain(HessianMatrix,DF,DDF,dr);
}
}
}
}
static inline void GradientStrainBend(REAL *Gradient,REAL_MATRIX3x3 S)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
Gradient[n]+=S.ax+S.by+S.cz;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.by;
Gradient[n+2]+=S.cz;
break;
case REGULAR:
case REGULAR_UPPER_TRIANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.bx;
Gradient[n+2]+=S.cx;
Gradient[n+3]+=S.by;
Gradient[n+4]+=S.cy;
Gradient[n+5]+=S.cz;
break;
case MONOCLINIC:
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.by;
Gradient[n+2]+=S.cy;
Gradient[n+3]+=S.cz;
break;
case MONOCLINIC_BETA_ANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.cx;
Gradient[n+2]+=S.by;
Gradient[n+3]+=S.cz;
break;
case MONOCLINIC_GAMMA_ANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.bx;
Gradient[n+2]+=S.by;
Gradient[n+3]+=S.cz;
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
void ComputeFrameworkBendHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i,f1,A,B,C;
REAL *parms,U;
REAL CosTheta,Theta,SinTheta,temp,temp2;
REAL rab,rbc,rac;
POINT posA,posB,posC;
VECTOR Rab,Rbc,Rac;
INT_VECTOR3 index_i,index_j,index_k;
int index1,index2,index3;
REAL DTDX,DF,DDF;
REAL_MATRIX3x3 D2I,D2K,D2IK;
VECTOR dtA,dtB,dtC;
REAL_MATRIX3x3 S;
VECTOR vec_u,vec_v;
REAL u,v;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
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;
parms=Framework[CurrentSystem].BendArguments[f1][i];
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
index_k=Framework[CurrentSystem].Atoms[f1][C].HessianIndex;
index1=Framework[CurrentSystem].Atoms[f1][A].HessianAtomIndex;
index2=Framework[CurrentSystem].Atoms[f1][B].HessianAtomIndex;
index3=Framework[CurrentSystem].Atoms[f1][C].HessianAtomIndex;
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);
vec_u=Rab;
rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
u=rab;
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);
vec_v=Rbc;
rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
v=rbc;
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);
Theta=acos(CosTheta);
SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));
DTDX=-1.0/SinTheta;
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]
temp=Theta-parms[1];
U=0.5*parms[0]*SQR(temp);
DF=parms[0]*temp*DTDX;
DDF=parms[0]*SQR(DTDX)+parms[0]*temp*CosTheta*CUBE(DTDX);
break;
case CORE_SHELL_BEND:
// (1/2)p_0*(theta-p_1)^2
// ===============================================
// p_0/k_B [K/rad^2]
// p_1 [degrees]
temp=Theta-parms[1];
U=0.5*parms[0]*SQR(temp);
DF=parms[0]*temp*DTDX;
DDF=parms[0]*SQR(DTDX)+parms[0]*temp*CosTheta*CUBE(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;
DDF=parms[0]*SQR(DTDX)+parms[0]*temp*CosTheta*CUBE(DTDX)
+2.0*parms[2]*temp*SQR(DTDX)+parms[2]*temp2*CosTheta*CUBE(DTDX)
+3.0*parms[3]*temp2*SQR(DTDX)+parms[3]*temp*temp2*CosTheta*CUBE(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;
DDF=2.0*parms[0]*SQR(DTDX)+2.0*parms[0]*temp*CosTheta*CUBE(DTDX)
+6.0*parms[2]*temp*SQR(DTDX)+3.0*parms[2]*temp2*CosTheta*CUBE(DTDX)
+12.0*parms[3]*temp2*SQR(DTDX)+4.0*parms[3]*temp*temp2*CosTheta*CUBE(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]);
DDF=parms[0];
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;
DDF=-parms[0]*parms[1]*(parms[1]*cos(temp)+sin(temp)*CosTheta*DTDX)*SQR(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);
DDF=2.0*parms[0]*(1.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]
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;
fprintf(stderr, "TO BE DONE!\n");
exit(0);
break;
case FIXED_BEND:
U=DF=DDF=0.0;
break;
case MEASURE_BEND:
U=DF=DDF=0.0;
break;
default:
U=DF=DDF=0.0;
fprintf(stderr, "Undefined Bend potential\n");
exit(0);
break;
}
// add contribution to the energy
*Energy+=U;
//if((index_i<0)&&(index_j<0)&&(index_k<0)) continue;
// 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);
S.ax=rab*Rab.x*DF*dtA.x+rbc*Rbc.x*DF*dtC.x;
S.bx=rab*Rab.y*DF*dtA.x+rbc*Rbc.y*DF*dtC.x;
S.cx=rab*Rab.z*DF*dtA.x+rbc*Rbc.z*DF*dtC.x;
S.ay=rab*Rab.x*DF*dtA.y+rbc*Rbc.x*DF*dtC.y;
S.by=rab*Rab.y*DF*dtA.y+rbc*Rbc.y*DF*dtC.y;
S.cy=rab*Rab.z*DF*dtA.y+rbc*Rbc.z*DF*dtC.y;
S.az=rab*Rab.x*DF*dtA.z+rbc*Rbc.x*DF*dtC.z;
S.bz=rab*Rab.y*DF*dtA.z+rbc*Rbc.y*DF*dtC.z;
S.cz=rab*Rab.z*DF*dtA.z+rbc*Rbc.z*DF*dtC.z;
StrainDerivative->ax+=S.ax;
StrainDerivative->bx+=S.bx;
StrainDerivative->cx+=S.cx;
StrainDerivative->ay+=S.ay;
StrainDerivative->by+=S.by;
StrainDerivative->cy+=S.cy;
StrainDerivative->az+=S.az;
StrainDerivative->bz+=S.bz;
StrainDerivative->cz+=S.cz;
// add contribution to the first derivatives
if(ComputeGradient)
{
if(index_i.x>=0) Gradient[index_i.x]+=DF*dtA.x;
if(index_i.y>=0) Gradient[index_i.y]+=DF*dtA.y;
if(index_i.z>=0) Gradient[index_i.z]+=DF*dtA.z;
if(index_j.x>=0) Gradient[index_j.x]+=DF*dtB.x;
if(index_j.y>=0) Gradient[index_j.y]+=DF*dtB.y;
if(index_j.z>=0) Gradient[index_j.z]+=DF*dtB.z;
if(index_k.x>=0) Gradient[index_k.x]+=DF*dtC.x;
if(index_k.y>=0) Gradient[index_k.y]+=DF*dtC.y;
if(index_k.z>=0) Gradient[index_k.z]+=DF*dtC.z;
GradientStrainBend(Gradient,S);
}
if(ComputeHessian)
{
// Calculate some diagonal Hessian terms for A
D2I.ax=-DF*(2.0*dtA.x*Rab.x+CosTheta*(1.0-Rab.x*Rab.x)/rab)/rab;
D2I.by=-DF*(2.0*dtA.y*Rab.y+CosTheta*(1.0-Rab.y*Rab.y)/rab)/rab;
D2I.cz=-DF*(2.0*dtA.z*Rab.z+CosTheta*(1.0-Rab.z*Rab.z)/rab)/rab;
D2I.ay=DF*(CosTheta*Rab.x*Rab.y/rab-dtA.x*Rab.y-dtA.y*Rab.x)/rab;
D2I.az=DF*(CosTheta*Rab.x*Rab.z/rab-dtA.x*Rab.z-dtA.z*Rab.x)/rab;
D2I.bz=DF*(CosTheta*Rab.y*Rab.z/rab-dtA.y*Rab.z-dtA.z*Rab.y)/rab;
// Calculate some diagonal Hessian terms for C
D2K.ax=-DF*(2.0*dtC.x*Rbc.x+CosTheta*(1.0-Rbc.x*Rbc.x)/rbc)/rbc;
D2K.by=-DF*(2.0*dtC.y*Rbc.y+CosTheta*(1.0-Rbc.y*Rbc.y)/rbc)/rbc;
D2K.cz=-DF*(2.0*dtC.z*Rbc.z+CosTheta*(1.0-Rbc.z*Rbc.z)/rbc)/rbc;
D2K.ay=DF*(CosTheta*Rbc.x*Rbc.y/rbc-dtC.x*Rbc.y-dtC.y*Rbc.x)/rbc;
D2K.az=DF*(CosTheta*Rbc.x*Rbc.z/rbc-dtC.x*Rbc.z-dtC.z*Rbc.x)/rbc;
D2K.bz=DF*(CosTheta*Rbc.y*Rbc.z/rbc-dtC.y*Rbc.z-dtC.z*Rbc.y)/rbc;
// Calculate the AC off-diagonal terms.
D2IK.ax=DF*(CosTheta*Rab.x*Rbc.x-Rab.x*Rab.x-Rbc.x*Rbc.x+1.0)/(rab*rbc);
D2IK.ay=DF*(CosTheta*Rab.x*Rbc.y-Rab.x*Rab.y-Rbc.x*Rbc.y)/(rab*rbc);
D2IK.az=DF*(CosTheta*Rab.x*Rbc.z-Rab.x*Rab.z-Rbc.x*Rbc.z)/(rab*rbc);
D2IK.bx=DF*(CosTheta*Rab.y*Rbc.x-Rab.y*Rab.x-Rbc.y*Rbc.x)/(rab*rbc);
D2IK.by=DF*(CosTheta*Rab.y*Rbc.y-Rab.y*Rab.y-Rbc.y*Rbc.y+1.0)/(rab*rbc);
D2IK.bz=DF*(CosTheta*Rab.y*Rbc.z-Rab.y*Rab.z-Rbc.y*Rbc.z)/(rab*rbc);
D2IK.cx=DF*(CosTheta*Rab.z*Rbc.x-Rab.z*Rab.x-Rbc.z*Rbc.x)/(rab*rbc);
D2IK.cy=DF*(CosTheta*Rab.z*Rbc.y-Rab.z*Rab.y-Rbc.z*Rbc.y)/(rab*rbc);
D2IK.cz=DF*(CosTheta*Rab.z*Rbc.z-Rab.z*Rab.z-Rbc.z*Rbc.z+1.0)/(rab*rbc);
// Calculate AA-block of the Hessian
if((index_i.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_i.x][index_i.x]+=DDF*dtA.x*dtA.x+D2I.ax;
if((index_i.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.x][index_i.y]+=DDF*dtA.x*dtA.y+D2I.ay;
if((index_i.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.y][index_i.y]+=DDF*dtA.y*dtA.y+D2I.by;
if((index_i.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.x][index_i.z]+=DDF*dtA.x*dtA.z+D2I.az;
if((index_i.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.y][index_i.z]+=DDF*dtA.y*dtA.z+D2I.bz;
if((index_i.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.z][index_i.z]+=DDF*dtA.z*dtA.z+D2I.cz;
// Calculate BB-block of the Hessian
if((index_j.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_j.x][index_j.x]+=DDF*dtB.x*dtB.x+(D2I.ax+D2K.ax+2.0*D2IK.ax);
if((index_j.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.x][index_j.y]+=DDF*dtB.x*dtB.y+(D2I.ay+D2K.ay+D2IK.ay+D2IK.bx);
if((index_j.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.y][index_j.y]+=DDF*dtB.y*dtB.y+(D2I.by+D2K.by+2.0*D2IK.by);
if((index_j.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.x][index_j.z]+=DDF*dtB.x*dtB.z+(D2I.az+D2K.az+D2IK.az+D2IK.cx);
if((index_j.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.y][index_j.z]+=DDF*dtB.y*dtB.z+(D2I.bz+D2K.bz+D2IK.bz+D2IK.cy);
if((index_j.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.z][index_j.z]+=DDF*dtB.z*dtB.z+(D2I.cz+D2K.cz+2.0*D2IK.cz);
// Calculate the CC-block of the Hessian
if((index_k.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_k.x][index_k.x]+=DDF*dtC.x*dtC.x+D2K.ax;
if((index_k.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_k.x][index_k.y]+=DDF*dtC.x*dtC.y+D2K.ay;
if((index_k.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_k.y][index_k.y]+=DDF*dtC.y*dtC.y+D2K.by;
if((index_k.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.x][index_k.z]+=DDF*dtC.x*dtC.z+D2K.az;
if((index_k.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.y][index_k.z]+=DDF*dtC.y*dtC.z+D2K.bz;
if((index_k.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.z][index_k.z]+=DDF*dtC.z*dtC.z+D2K.cz;
// Calculate the AB-block of the Hessian
if(index1<index2)
{
if((index_i.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.x][index_j.x]+=DDF*dtA.x*dtB.x-D2I.ax-D2IK.ax;
if((index_i.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.x][index_j.y]+=DDF*dtA.x*dtB.y-D2I.ay-D2IK.ay;
if((index_i.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.x][index_j.z]+=DDF*dtA.x*dtB.z-D2I.az-D2IK.az;
if((index_i.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.y][index_j.x]+=DDF*dtA.y*dtB.x-D2I.ay-D2IK.bx;
if((index_i.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.y][index_j.y]+=DDF*dtA.y*dtB.y-D2I.by-D2IK.by;
if((index_i.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.y][index_j.z]+=DDF*dtA.y*dtB.z-D2I.bz-D2IK.bz;
if((index_i.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.z][index_j.x]+=DDF*dtA.z*dtB.x-D2I.az-D2IK.cx;
if((index_i.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.z][index_j.y]+=DDF*dtA.z*dtB.y-D2I.bz-D2IK.cy;
if((index_i.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.z][index_j.z]+=DDF*dtA.z*dtB.z-D2I.cz-D2IK.cz;
}
else
{
if((index_j.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.x][index_i.x]+=DDF*dtA.x*dtB.x-D2I.ax-D2IK.ax;
if((index_j.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.x][index_i.y]+=DDF*dtA.y*dtB.x-D2I.ay-D2IK.bx;
if((index_j.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.x][index_i.z]+=DDF*dtA.z*dtB.x-D2I.az-D2IK.cx;
if((index_j.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.y][index_i.x]+=DDF*dtA.x*dtB.y-D2I.ay-D2IK.ay;
if((index_j.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.y][index_i.y]+=DDF*dtA.y*dtB.y-D2I.by-D2IK.by;
if((index_j.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.y][index_i.z]+=DDF*dtA.z*dtB.y-D2I.bz-D2IK.cy;
if((index_j.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.z][index_i.x]+=DDF*dtA.x*dtB.z-D2I.az-D2IK.az;
if((index_j.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.z][index_i.y]+=DDF*dtA.y*dtB.z-D2I.bz-D2IK.bz;
if((index_j.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.z][index_i.z]+=DDF*dtA.z*dtB.z-D2I.cz-D2IK.cz;
}
// Calculate the AC-block of the Hessian
if(index1<index3)
{
if((index_i.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.x][index_k.x]+=DDF*dtA.x*dtC.x+D2IK.ax;
if((index_i.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.x][index_k.y]+=DDF*dtA.x*dtC.y+D2IK.ay;
if((index_i.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.x][index_k.z]+=DDF*dtA.x*dtC.z+D2IK.az;
if((index_i.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.y][index_k.x]+=DDF*dtA.y*dtC.x+D2IK.bx;
if((index_i.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.y][index_k.y]+=DDF*dtA.y*dtC.y+D2IK.by;
if((index_i.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.y][index_k.z]+=DDF*dtA.y*dtC.z+D2IK.bz;
if((index_i.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.z][index_k.x]+=DDF*dtA.z*dtC.x+D2IK.cx;
if((index_i.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.z][index_k.y]+=DDF*dtA.z*dtC.y+D2IK.cy;
if((index_i.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.z][index_k.z]+=DDF*dtA.z*dtC.z+D2IK.cz;
}
else
{
if((index_k.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.x][index_i.x]+=DDF*dtA.x*dtC.x+D2IK.ax;
if((index_k.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.x][index_i.y]+=DDF*dtA.y*dtC.x+D2IK.bx;
if((index_k.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.x][index_i.z]+=DDF*dtA.z*dtC.x+D2IK.cx;
if((index_k.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.y][index_i.x]+=DDF*dtA.x*dtC.y+D2IK.ay;
if((index_k.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.y][index_i.y]+=DDF*dtA.y*dtC.y+D2IK.by;
if((index_k.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.y][index_i.z]+=DDF*dtA.z*dtC.y+D2IK.cy;
if((index_k.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.z][index_i.x]+=DDF*dtA.x*dtC.z+D2IK.az;
if((index_k.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.z][index_i.y]+=DDF*dtA.y*dtC.z+D2IK.bz;
if((index_k.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.z][index_i.z]+=DDF*dtA.z*dtC.z+D2IK.cz;
}
// Calculate the BC-block of the Hessian
if(index3<index2)
{
if((index_k.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.x][index_j.x]+=DDF*dtC.x*dtB.x-D2K.ax-D2IK.ax;
if((index_k.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.x][index_j.y]+=DDF*dtC.x*dtB.y-D2K.ay-D2IK.bx;
if((index_k.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.x][index_j.z]+=DDF*dtC.x*dtB.z-D2K.az-D2IK.cx;
if((index_k.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.y][index_j.x]+=DDF*dtC.y*dtB.x-D2K.ay-D2IK.ay;
if((index_k.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.y][index_j.y]+=DDF*dtC.y*dtB.y-D2K.by-D2IK.by;
if((index_k.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.y][index_j.z]+=DDF*dtC.y*dtB.z-D2K.bz-D2IK.cy;
if((index_k.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.z][index_j.x]+=DDF*dtC.z*dtB.x-D2K.az-D2IK.az;
if((index_k.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.z][index_j.y]+=DDF*dtC.z*dtB.y-D2K.bz-D2IK.bz;
if((index_k.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.z][index_j.z]+=DDF*dtC.z*dtB.z-D2K.cz-D2IK.cz;
}
else
{
if((index_j.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.x][index_k.x]+=DDF*dtC.x*dtB.x-D2K.ax-D2IK.ax;
if((index_j.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.x][index_k.y]+=DDF*dtC.y*dtB.x-D2K.ay-D2IK.ay;
if((index_j.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.x][index_k.z]+=DDF*dtC.z*dtB.x-D2K.az-D2IK.az;
if((index_j.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.y][index_k.x]+=DDF*dtC.x*dtB.y-D2K.ay-D2IK.bx;
if((index_j.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.y][index_k.y]+=DDF*dtC.y*dtB.y-D2K.by-D2IK.by;
if((index_j.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.y][index_k.z]+=DDF*dtC.z*dtB.y-D2K.bz-D2IK.bz;
if((index_j.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.z][index_k.x]+=DDF*dtC.x*dtB.z-D2K.az-D2IK.cx;
if((index_j.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.z][index_k.y]+=DDF*dtC.y*dtB.z-D2K.bz-D2IK.cy;
if((index_j.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.z][index_k.z]+=DDF*dtC.z*dtB.z-D2K.cz-D2IK.cz;
}
HessianBendStrainPosition(index_i,index_j,index_k,HessianMatrix,vec_u,vec_v,u,v,
rab,rbc,Rab,Rbc,dtA,dtC,DF,DDF,S,CosTheta);
HessianBendStrainStrain(HessianMatrix,vec_u,vec_v,u,v,DF,DDF,S,CosTheta);
}
}
}
}
static inline void GradientStrainTorsion(REAL *Gradient,REAL_MATRIX3x3 S)
{
int n;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
Gradient[n]+=S.ax+S.by+S.cz;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
case ANISOTROPIC:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.by;
Gradient[n+2]+=S.cz;
break;
case REGULAR:
case REGULAR_UPPER_TRIANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.bx;
Gradient[n+2]+=S.cx;
Gradient[n+3]+=S.by;
Gradient[n+4]+=S.cy;
Gradient[n+5]+=S.cz;
break;
case MONOCLINIC:
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.by;
Gradient[n+2]+=S.cy;
Gradient[n+3]+=S.cz;
break;
case MONOCLINIC_BETA_ANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.cx;
Gradient[n+2]+=S.by;
Gradient[n+3]+=S.cz;
break;
case MONOCLINIC_GAMMA_ANGLE:
Gradient[n]+=S.ax;
Gradient[n+1]+=S.bx;
Gradient[n+2]+=S.by;
Gradient[n+3]+=S.cz;
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
void ComputeFrameworkTorsionHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL d,e,rbc;
VECTOR Dab,Dcb,Ddc,dr,ds;
REAL dot_ab,dot_cd,r,s,sign;
REAL U,CosPhi,Phi,CosPhi2,SinPhi;
REAL ShiftedCosPhi,ShiftedCosPhi2,ShiftedSinPhi;
VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
REAL *parms;
INT_VECTOR3 index_i,index_j,index_k,index_l;
int index1,index2,index3,index4;
REAL_MATRIX3x3 D2I,D2L,D2IL,D2IJ,D2IK,D2JL;
REAL_MATRIX3x3 D2KL,D2J,D2K,D2JK,S;
VECTOR DIL,DDJ,DDK,DEJ,DEK;
REAL DF,DDF;
VECTOR vec_u,vec_v,vec_w;
REAL u,w,v;
VECTOR fa,fb,fc,fd;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
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;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
index_k=Framework[CurrentSystem].Atoms[f1][C].HessianIndex;
index_l=Framework[CurrentSystem].Atoms[f1][D].HessianIndex;
index1=Framework[CurrentSystem].Atoms[f1][A].HessianAtomIndex;
index2=Framework[CurrentSystem].Atoms[f1][B].HessianAtomIndex;
index3=Framework[CurrentSystem].Atoms[f1][C].HessianAtomIndex;
index4=Framework[CurrentSystem].Atoms[f1][D].HessianAtomIndex;
vec_u.x=posB.x-posC.x;
vec_u.y=posB.y-posC.y;
vec_u.z=posB.z-posC.z;
vec_u=ApplyBoundaryCondition(vec_u);
u=sqrt(SQR(vec_u.x)+SQR(vec_u.y)+SQR(vec_u.z));
vec_v.x=posD.x-posC.x;
vec_v.y=posD.y-posC.y;
vec_v.z=posD.z-posC.z;
vec_v=ApplyBoundaryCondition(vec_v);
v=sqrt(SQR(vec_v.x)+SQR(vec_v.y)+SQR(vec_v.z));
vec_w.x=posA.x-posB.x;
vec_w.y=posA.y-posB.y;
vec_w.z=posA.z-posB.z;
vec_w=ApplyBoundaryCondition(vec_w);
w=sqrt(SQR(vec_w.x)+SQR(vec_w.y)+SQR(vec_w.z));
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].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;
DDF=-parms[0]*(Phi*CosPhi-SinPhi)/CUBE(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]);
DDF=parms[0];
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);
DDF=-2.0*(parms[1]-6.0*parms[2]*CosPhi);
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);
DDF=-2.0*(parms[1]-6.0*parms[2]*CosPhi);
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;
DDF=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);
DDF=-4.0*(parms[1]+6.0*parms[2]*CosPhi);
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);
DDF=4.0*(parms[1]+6.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);
DDF=2.0*parms[2]-6.0*parms[3]*CosPhi+12.0*parms[4]*CosPhi2-20.0*parms[5]*CosPhi2*CosPhi;
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);
DDF=-4.0*(parms[2]-6.0*parms[3]*CosPhi);
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;
DDF=4.0*parms[2]-16.0*parms[4]+24.0*parms[3]*CosPhi+96.0*parms[4]*CosPhi2;
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])*ShiftedSinPhi -4.0*parms[2]*ShiftedCosPhi*ShiftedSinPhi + 12.0*parms[3]*ShiftedCosPhi2*ShiftedSinPhi)/SinPhi;
DDF=-(parms[1]-3.0*parms[3])*sin(parms[4])/CUBE(SinPhi)+
4.0*parms[2]*(ShiftedCosPhi2-ShiftedCosPhi*ShiftedSinPhi*CosPhi/SinPhi-SQR(ShiftedSinPhi))/SQR(SinPhi)+
12.0*parms[3]*ShiftedCosPhi*(-ShiftedCosPhi2+ShiftedCosPhi*ShiftedSinPhi*CosPhi/SinPhi+2.0*SQR(ShiftedSinPhi))/SQR(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);
U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
if(fabs(SinPhi)<1.0e-8)
{
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
DF=parms[0]*parms[1]*cos(parms[2])*SIGN(parms[1],sin(parms[1]*Phi)*Phi)+parms[0]*parms[1]*cos(parms[1]*Phi)*sin(parms[2])/SinPhi;
}
else
DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
DDF=-parms[0]*parms[1]*(parms[1]*cos(-parms[1]*Phi+parms[2])+sin(-parms[1]*Phi+parms[2])*CosPhi/SinPhi)/SQR(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);
DDF=-2.0*(parms[2]-6.0*parms[3]*CosPhi);
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);
DDF=-2.0*parms[1]+8.0*parms[3]-18.0*parms[5]+12.0*(parms[2]-5.0*parms[4])*CosPhi
-48.0*(parms[3]-6.0*parms[5])*CosPhi2+160.0*parms[4]*CosPhi2*CosPhi-480.0*parms[5]*SQR(CosPhi2);
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)));
DDF=-2.0*parms[1]+12.0*parms[2]*CosPhi+parms[3]*(48.0*CosPhi2-8.0)+parms[4]*CosPhi*(160.0*CosPhi2-60.0)
+parms[5]*(18.0-288.0*CosPhi2+480.0*SQR(CosPhi2));
break;
default:
fprintf(stderr, "Undefined Torsion potential in 'framework_hessian.c'\n");
U=DF=DDF=0.0;
exit(0);
break;
}
*Energy+=U;
//if((index_i<0)&&(index_j<0)&&(index_k<0)&&(index_l<0)) continue;
// 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 strain derivative tensor
// Note: rbc is here because the vector was normalized before
S.ax=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
S.bx=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
S.cx=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;
S.ay=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
S.by=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
S.cy=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;
S.az=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
S.bz=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
S.cz=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
StrainDerivative->ax+=S.ax;
StrainDerivative->bx+=S.bx;
StrainDerivative->cx+=S.cx;
StrainDerivative->ay+=S.ay;
StrainDerivative->by+=S.by;
StrainDerivative->cy+=S.cy;
StrainDerivative->az+=S.az;
StrainDerivative->bz+=S.bz;
StrainDerivative->cz+=S.cz;
if(ComputeGradient)
{
if(index_i.x>=0) Gradient[index_i.x]+=fa.x;
if(index_i.y>=0) Gradient[index_i.y]+=fa.y;
if(index_i.z>=0) Gradient[index_i.z]+=fa.z;
if(index_j.x>=0) Gradient[index_j.x]+=fb.x;
if(index_j.y>=0) Gradient[index_j.y]+=fb.y;
if(index_j.z>=0) Gradient[index_j.z]+=fb.z;
if(index_k.x>=0) Gradient[index_k.x]+=fc.x;
if(index_k.y>=0) Gradient[index_k.y]+=fc.y;
if(index_k.z>=0) Gradient[index_k.z]+=fc.z;
if(index_l.x>=0) Gradient[index_l.x]+=fd.x;
if(index_l.y>=0) Gradient[index_l.y]+=fd.y;
if(index_l.z>=0) Gradient[index_l.z]+=fd.z;
GradientStrainTorsion(Gradient,S);
}
if(ComputeHessian)
{
// Calculate the derivatives of DOTIJ and DOTLK.
DIL.x=DF*Dcb.x/rbc;
DIL.y=DF*Dcb.y/rbc;
DIL.z=DF*Dcb.z/rbc;
DDJ.x=DF*((2.0*d-1.0)*Dcb.x-Dab.x/rbc)/rbc;
DDJ.y=DF*((2.0*d-1.0)*Dcb.y-Dab.y/rbc)/rbc;
DDJ.z=DF*((2.0*d-1.0)*Dcb.z-Dab.z/rbc)/rbc;
DDK.x=-DF*(2.0*d*Dcb.x-Dab.x/rbc)/rbc;
DDK.y=-DF*(2.0*d*Dcb.y-Dab.y/rbc)/rbc;
DDK.z=-DF*(2.0*d*Dcb.z-Dab.z/rbc)/rbc;
DEJ.x=DF*(2.0*e*Dcb.x-Ddc.x/rbc)/rbc;
DEJ.y=DF*(2.0*e*Dcb.y-Ddc.y/rbc)/rbc;
DEJ.z=DF*(2.0*e*Dcb.z-Ddc.z/rbc)/rbc;
DEK.x=-DF*((2.0*e+1.0)*Dcb.x-Ddc.x/rbc)/rbc;
DEK.y=-DF*((2.0*e+1.0)*Dcb.y-Ddc.y/rbc)/rbc;
DEK.z=-DF*((2.0*e+1.0)*Dcb.z-Ddc.z/rbc)/rbc;
// Calculate some diagonal Hessian terms for I.
D2I.ax=DF*(CosPhi*(dr.x*dr.x+Dcb.x*Dcb.x-1.0)/r-2.0*dr.x*dtA.x)/r;
D2I.by=DF*(CosPhi*(dr.y*dr.y+Dcb.y*Dcb.y-1.0)/r-2.0*dr.y*dtA.y)/r;
D2I.cz=DF*(CosPhi*(dr.z*dr.z+Dcb.z*Dcb.z-1.0)/r-2.0*dr.z*dtA.z)/r;
D2I.ay=DF*(CosPhi*(dr.x*dr.y+Dcb.x*Dcb.y)/r-dr.x*dtA.y-dr.y*dtA.x)/r;
D2I.az=DF*(CosPhi*(dr.x*dr.z+Dcb.x*Dcb.z)/r-dr.x*dtA.z-dr.z*dtA.x)/r;
D2I.bz=DF*(CosPhi*(dr.y*dr.z+Dcb.y*Dcb.z)/r-dr.y*dtA.z-dr.z*dtA.y)/r;
D2I.bx=D2I.cx=D2I.cy=0.0;
// Calculate some diagonal Hessian terms for L.
D2L.ax=DF*(CosPhi*(ds.x*ds.x+Dcb.x*Dcb.x-1.0)/s-2.0*ds.x*dtD.x)/s;
D2L.by=DF*(CosPhi*(ds.y*ds.y+Dcb.y*Dcb.y-1.0)/s-2.0*ds.y*dtD.y)/s;
D2L.cz=DF*(CosPhi*(ds.z*ds.z+Dcb.z*Dcb.z-1.0)/s-2.0*ds.z*dtD.z)/s;
D2L.ay=DF*(CosPhi*(ds.x*ds.y+Dcb.x*Dcb.y)/s-ds.x*dtD.y-ds.y*dtD.x)/s;
D2L.az=DF*(CosPhi*(ds.x*ds.z+Dcb.x*Dcb.z)/s-ds.x*dtD.z-ds.z*dtD.x)/s;
D2L.bz=DF*(CosPhi*(ds.y*ds.z+Dcb.y*Dcb.z)/s-ds.y*dtD.z-ds.z*dtD.y)/s;
D2L.bx=D2L.cx=D2L.cy=0.0;
// Calculate the IL off-diagonal terms.
D2IL.ax=DF*(CosPhi*dr.x*ds.x-dr.x*dr.x-ds.x*ds.x-Dcb.x*Dcb.x+1.0)/(r*s);
D2IL.ay=DF*(CosPhi*dr.x*ds.y-dr.x*dr.y-ds.x*ds.y-Dcb.x*Dcb.y)/(r*s);
D2IL.az=DF*(CosPhi*dr.x*ds.z-dr.x*dr.z-ds.x*ds.z-Dcb.x*Dcb.z)/(r*s);
D2IL.bx=DF*(CosPhi*dr.y*ds.x-dr.y*dr.x-ds.y*ds.x-Dcb.y*Dcb.x)/(r*s);
D2IL.by=DF*(CosPhi*dr.y*ds.y-dr.y*dr.y-ds.y*ds.y-Dcb.y*Dcb.y+1.0)/(r*s);
D2IL.bz=DF*(CosPhi*dr.y*ds.z-dr.y*dr.z-ds.y*ds.z-Dcb.y*Dcb.z)/(r*s);
D2IL.cx=DF*(CosPhi*dr.z*ds.x-dr.z*dr.x-ds.z*ds.x-Dcb.z*Dcb.x)/(r*s);
D2IL.cy=DF*(CosPhi*dr.z*ds.y-dr.z*dr.y-ds.z*ds.y-Dcb.z*Dcb.y)/(r*s);
D2IL.cz=DF*(CosPhi*dr.z*ds.z-dr.z*dr.z-ds.z*ds.z-Dcb.z*Dcb.z+1.0)/(r*s);
// Calculate the IJ off-diagonal terms.
D2IJ.ax=D2I.ax*(d-1.0)+D2IL.ax*e+DIL.x*dtA.x;
D2IJ.ay=D2I.ay*(d-1.0)+D2IL.ay*e+DIL.x*dtA.y;
D2IJ.az=D2I.az*(d-1.0)+D2IL.az*e+DIL.x*dtA.z;
D2IJ.bx=D2I.ay*(d-1.0)+D2IL.bx*e+DIL.y*dtA.x;
D2IJ.by=D2I.by*(d-1.0)+D2IL.by*e+DIL.y*dtA.y;
D2IJ.bz=D2I.bz*(d-1.0)+D2IL.bz*e+DIL.y*dtA.z;
D2IJ.cx=D2I.az*(d-1.0)+D2IL.cx*e+DIL.z*dtA.x;
D2IJ.cy=D2I.bz*(d-1.0)+D2IL.cy*e+DIL.z*dtA.y;
D2IJ.cz=D2I.cz*(d-1.0)+D2IL.cz*e+DIL.z*dtA.z;
// Calculate the IK off-diagonal terms.
D2IK.ax=-D2I.ax*d-D2IL.ax*(e+1.0)-DIL.x*dtA.x;
D2IK.ay=-D2I.ay*d-D2IL.ay*(e+1.0)-DIL.x*dtA.y;
D2IK.az=-D2I.az*d-D2IL.az*(e+1.0)-DIL.x*dtA.z;
D2IK.bx=-D2I.ay*d-D2IL.bx*(e+1.0)-DIL.y*dtA.x;
D2IK.by=-D2I.by*d-D2IL.by*(e+1.0)-DIL.y*dtA.y;
D2IK.bz=-D2I.bz*d-D2IL.bz*(e+1.0)-DIL.y*dtA.z;
D2IK.cx=-D2I.az*d-D2IL.cx*(e+1.0)-DIL.z*dtA.x;
D2IK.cy=-D2I.bz*d-D2IL.cy*(e+1.0)-DIL.z*dtA.y;
D2IK.cz=-D2I.cz*d-D2IL.cz*(e+1.0)-DIL.z*dtA.z;
// Calculate the JL off-diagonal terms.
D2JL.ax=D2IL.ax*(d-1.0)+D2L.ax*e+DIL.x*dtD.x;
D2JL.ay=D2IL.ay*(d-1.0)+D2L.ay*e+DIL.y*dtD.x;
D2JL.az=D2IL.az*(d-1.0)+D2L.az*e+DIL.z*dtD.x;
D2JL.bx=D2IL.bx*(d-1.0)+D2L.ay*e+DIL.x*dtD.y;
D2JL.by=D2IL.by*(d-1.0)+D2L.by*e+DIL.y*dtD.y;
D2JL.bz=D2IL.bz*(d-1.0)+D2L.bz*e+DIL.z*dtD.y;
D2JL.cx=D2IL.cx*(d-1.0)+D2L.az*e+DIL.x*dtD.z;
D2JL.cy=D2IL.cy*(d-1.0)+D2L.bz*e+DIL.y*dtD.z;
D2JL.cz=D2IL.cz*(d-1.0)+D2L.cz*e+DIL.z*dtD.z;
// Calculate the KL off-diagonal terms.
D2KL.ax=-D2IL.ax*d-D2L.ax*(e+1.0)-DIL.x*dtD.x;
D2KL.ay=-D2IL.ay*d-D2L.ay*(e+1.0)-DIL.y*dtD.x;
D2KL.az=-D2IL.az*d-D2L.az*(e+1.0)-DIL.z*dtD.x;
D2KL.bx=-D2IL.bx*d-D2L.ay*(e+1.0)-DIL.x*dtD.y;
D2KL.by=-D2IL.by*d-D2L.by*(e+1.0)-DIL.y*dtD.y;
D2KL.bz=-D2IL.bz*d-D2L.bz*(e+1.0)-DIL.z*dtD.y;
D2KL.cx=-D2IL.cx*d-D2L.az*(e+1.0)-DIL.x*dtD.z;
D2KL.cy=-D2IL.cy*d-D2L.bz*(e+1.0)-DIL.y*dtD.z;
D2KL.cz=-D2IL.cz*d-D2L.cz*(e+1.0)-DIL.z*dtD.z;
// Calculate the JJ diagonal terms.
D2J.ax=D2IJ.ax*(d-1.0)+D2JL.ax*e+DDJ.x*dtA.x+DEJ.x*dtD.x;
D2J.by=D2IJ.by*(d-1.0)+D2JL.by*e+DDJ.y*dtA.y+DEJ.y*dtD.y;
D2J.cz=D2IJ.cz*(d-1.0)+D2JL.cz*e+DDJ.z*dtA.z+DEJ.z*dtD.z;
D2J.ay=D2IJ.ay*(d-1.0)+D2JL.bx*e+DDJ.y*dtA.x+DEJ.y*dtD.x;
D2J.az=D2IJ.az*(d-1.0)+D2JL.cx*e+DDJ.z*dtA.x+DEJ.z*dtD.x;
D2J.bz=D2IJ.bz*(d-1.0)+D2JL.cy*e+DDJ.z*dtA.y+DEJ.z*dtD.y;
D2J.bx=D2J.cx=D2J.cy=0.0;
// Calculate the KK diagonal terms.
D2K.ax=-D2KL.ax*(e+1.0)-D2IK.ax*d-DDK.x*dtA.x-DEK.x*dtD.x;
D2K.by=-D2KL.by*(e+1.0)-D2IK.by*d-DDK.y*dtA.y-DEK.y*dtD.y;
D2K.cz=-D2KL.cz*(e+1.0)-D2IK.cz*d-DDK.z*dtA.z-DEK.z*dtD.z;
D2K.ay=-D2KL.ay*(e+1.0)-D2IK.bx*d-DDK.x*dtA.y-DEK.x*dtD.y;
D2K.az=-D2KL.az*(e+1.0)-D2IK.cx*d-DDK.x*dtA.z-DEK.x*dtD.z;
D2K.bz=-D2KL.bz*(e+1.0)-D2IK.cy*d-DDK.y*dtA.z-DEK.y*dtD.z;
D2K.bx=D2K.cx=D2K.cy=0.0;
// Calculate the JK off-diagonal terms.
D2JK.ax=-D2IJ.ax*d-D2JL.ax*(e+1.0)-DDJ.x*dtA.x-DEJ.x*dtD.x;
D2JK.ay=-D2IJ.bx*d-D2JL.ay*(e+1.0)-DDJ.x*dtA.y-DEJ.x*dtD.y;
D2JK.az=-D2IJ.cx*d-D2JL.az*(e+1.0)-DDJ.x*dtA.z-DEJ.x*dtD.z;
D2JK.bx=-D2IJ.ay*d-D2JL.bx*(e+1.0)-DDJ.y*dtA.x-DEJ.y*dtD.x;
D2JK.by=-D2IJ.by*d-D2JL.by*(e+1.0)-DDJ.y*dtA.y-DEJ.y*dtD.y;
D2JK.bz=-D2IJ.cy*d-D2JL.bz*(e+1.0)-DDJ.y*dtA.z-DEJ.y*dtD.z;
D2JK.cx=-D2IJ.az*d-D2JL.cx*(e+1.0)-DDJ.z*dtA.x-DEJ.z*dtD.x;
D2JK.cy=-D2IJ.bz*d-D2JL.cy*(e+1.0)-DDJ.z*dtA.y-DEJ.z*dtD.y;
D2JK.cz=-D2IJ.cz*d-D2JL.cz*(e+1.0)-DDJ.z*dtA.z-DEJ.z*dtD.z;
// Calculate the diagonal blocks of the hessian.
if((index_i.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_i.x][index_i.x]+=DDF*dtA.x*dtA.x+D2I.ax;
if((index_i.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.x][index_i.y]+=DDF*dtA.x*dtA.y+D2I.ay;
if((index_i.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.y][index_i.y]+=DDF*dtA.y*dtA.y+D2I.by;
if((index_i.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.x][index_i.z]+=DDF*dtA.x*dtA.z+D2I.az;
if((index_i.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.y][index_i.z]+=DDF*dtA.y*dtA.z+D2I.bz;
if((index_i.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.z][index_i.z]+=DDF*dtA.z*dtA.z+D2I.cz;
if((index_j.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_j.x][index_j.x]+=DDF*dtB.x*dtB.x+D2J.ax;
if((index_j.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.x][index_j.y]+=DDF*dtB.x*dtB.y+D2J.ay;
if((index_j.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.y][index_j.y]+=DDF*dtB.y*dtB.y+D2J.by;
if((index_j.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.x][index_j.z]+=DDF*dtB.x*dtB.z+D2J.az;
if((index_j.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.y][index_j.z]+=DDF*dtB.y*dtB.z+D2J.bz;
if((index_j.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.z][index_j.z]+=DDF*dtB.z*dtB.z+D2J.cz;
if((index_k.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_k.x][index_k.x]+=DDF*dtC.x*dtC.x+D2K.ax;
if((index_k.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_k.x][index_k.y]+=DDF*dtC.x*dtC.y+D2K.ay;
if((index_k.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_k.y][index_k.y]+=DDF*dtC.y*dtC.y+D2K.by;
if((index_k.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.x][index_k.z]+=DDF*dtC.x*dtC.z+D2K.az;
if((index_k.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.y][index_k.z]+=DDF*dtC.y*dtC.z+D2K.bz;
if((index_k.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.z][index_k.z]+=DDF*dtC.z*dtC.z+D2K.cz;
if((index_l.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_l.x][index_l.x]+=DDF*dtD.x*dtD.x+D2L.ax;
if((index_l.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_l.x][index_l.y]+=DDF*dtD.x*dtD.y+D2L.ay;
if((index_l.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_l.y][index_l.y]+=DDF*dtD.y*dtD.y+D2L.by;
if((index_l.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_l.x][index_l.z]+=DDF*dtD.x*dtD.z+D2L.az;
if((index_l.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_l.y][index_l.z]+=DDF*dtD.y*dtD.z+D2L.bz;
if((index_l.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_l.z][index_l.z]+=DDF*dtD.z*dtD.z+D2L.cz;
if(index1<index2)
{
if((index_i.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.x][index_j.x]+=DDF*dtA.x*dtB.x+D2IJ.ax;
if((index_i.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.x][index_j.y]+=DDF*dtA.x*dtB.y+D2IJ.ay;
if((index_i.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.x][index_j.z]+=DDF*dtA.x*dtB.z+D2IJ.az;
if((index_i.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.y][index_j.x]+=DDF*dtA.y*dtB.x+D2IJ.bx;
if((index_i.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.y][index_j.y]+=DDF*dtA.y*dtB.y+D2IJ.by;
if((index_i.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.y][index_j.z]+=DDF*dtA.y*dtB.z+D2IJ.bz;
if((index_i.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.z][index_j.x]+=DDF*dtA.z*dtB.x+D2IJ.cx;
if((index_i.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.z][index_j.y]+=DDF*dtA.z*dtB.y+D2IJ.cy;
if((index_i.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.z][index_j.z]+=DDF*dtA.z*dtB.z+D2IJ.cz;
}
else
{
if((index_j.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.x][index_i.x]+=DDF*dtA.x*dtB.x+D2IJ.ax;
if((index_j.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.x][index_i.y]+=DDF*dtA.y*dtB.x+D2IJ.bx;
if((index_j.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.x][index_i.z]+=DDF*dtA.z*dtB.x+D2IJ.cx;
if((index_j.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.y][index_i.x]+=DDF*dtA.x*dtB.y+D2IJ.ay;
if((index_j.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.y][index_i.y]+=DDF*dtA.y*dtB.y+D2IJ.by;
if((index_j.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.y][index_i.z]+=DDF*dtA.z*dtB.y+D2IJ.cy;
if((index_j.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.z][index_i.x]+=DDF*dtA.x*dtB.z+D2IJ.az;
if((index_j.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.z][index_i.y]+=DDF*dtA.y*dtB.z+D2IJ.bz;
if((index_j.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.z][index_i.z]+=DDF*dtA.z*dtB.z+D2IJ.cz;
}
if(index1<index3)
{
if((index_i.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.x][index_k.x]+=DDF*dtA.x*dtC.x+D2IK.ax;
if((index_i.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.x][index_k.y]+=DDF*dtA.x*dtC.y+D2IK.ay;
if((index_i.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.x][index_k.z]+=DDF*dtA.x*dtC.z+D2IK.az;
if((index_i.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.y][index_k.x]+=DDF*dtA.y*dtC.x+D2IK.bx;
if((index_i.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.y][index_k.y]+=DDF*dtA.y*dtC.y+D2IK.by;
if((index_i.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.y][index_k.z]+=DDF*dtA.y*dtC.z+D2IK.bz;
if((index_i.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.z][index_k.x]+=DDF*dtA.z*dtC.x+D2IK.cx;
if((index_i.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.z][index_k.y]+=DDF*dtA.z*dtC.y+D2IK.cy;
if((index_i.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.z][index_k.z]+=DDF*dtA.z*dtC.z+D2IK.cz;
}
else
{
if((index_k.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.x][index_i.x]+=DDF*dtA.x*dtC.x+D2IK.ax;
if((index_k.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.x][index_i.y]+=DDF*dtA.y*dtC.x+D2IK.bx;
if((index_k.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.x][index_i.z]+=DDF*dtA.z*dtC.x+D2IK.cx;
if((index_k.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.y][index_i.x]+=DDF*dtA.x*dtC.y+D2IK.ay;
if((index_k.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.y][index_i.y]+=DDF*dtA.y*dtC.y+D2IK.by;
if((index_k.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.y][index_i.z]+=DDF*dtA.z*dtC.y+D2IK.cy;
if((index_k.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.z][index_i.x]+=DDF*dtA.x*dtC.z+D2IK.az;
if((index_k.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.z][index_i.y]+=DDF*dtA.y*dtC.z+D2IK.bz;
if((index_k.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.z][index_i.z]+=DDF*dtA.z*dtC.z+D2IK.cz;
}
if(index1<index4)
{
if((index_i.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_i.x][index_l.x]+=DDF*dtA.x*dtD.x+D2IL.ax;
if((index_i.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_i.x][index_l.y]+=DDF*dtA.x*dtD.y+D2IL.ay;
if((index_i.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_i.x][index_l.z]+=DDF*dtA.x*dtD.z+D2IL.az;
if((index_i.y>=0)&&(index_l.x>=0)) HessianMatrix.element[index_i.y][index_l.x]+=DDF*dtA.y*dtD.x+D2IL.bx;
if((index_i.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_i.y][index_l.y]+=DDF*dtA.y*dtD.y+D2IL.by;
if((index_i.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_i.y][index_l.z]+=DDF*dtA.y*dtD.z+D2IL.bz;
if((index_i.z>=0)&&(index_l.x>=0)) HessianMatrix.element[index_i.z][index_l.x]+=DDF*dtA.z*dtD.x+D2IL.cx;
if((index_i.z>=0)&&(index_l.y>=0)) HessianMatrix.element[index_i.z][index_l.y]+=DDF*dtA.z*dtD.y+D2IL.cy;
if((index_i.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_i.z][index_l.z]+=DDF*dtA.z*dtD.z+D2IL.cz;
}
else
{
if((index_l.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_l.x][index_i.x]+=DDF*dtA.x*dtD.x+D2IL.ax;
if((index_l.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_l.x][index_i.y]+=DDF*dtA.y*dtD.x+D2IL.bx;
if((index_l.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_l.x][index_i.z]+=DDF*dtA.z*dtD.x+D2IL.cx;
if((index_l.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_l.y][index_i.x]+=DDF*dtA.x*dtD.y+D2IL.ay;
if((index_l.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_l.y][index_i.y]+=DDF*dtA.y*dtD.y+D2IL.by;
if((index_l.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_l.y][index_i.z]+=DDF*dtA.z*dtD.y+D2IL.cy;
if((index_l.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_l.z][index_i.x]+=DDF*dtA.x*dtD.z+D2IL.az;
if((index_l.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_l.z][index_i.y]+=DDF*dtA.y*dtD.z+D2IL.bz;
if((index_l.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_l.z][index_i.z]+=DDF*dtA.z*dtD.z+D2IL.cz;
}
if(index2<index3)
{
if((index_j.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.x][index_k.x]+=DDF*dtB.x*dtC.x+D2JK.ax;
if((index_j.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.x][index_k.y]+=DDF*dtB.x*dtC.y+D2JK.ay;
if((index_j.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.x][index_k.z]+=DDF*dtB.x*dtC.z+D2JK.az;
if((index_j.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.y][index_k.x]+=DDF*dtB.y*dtC.x+D2JK.bx;
if((index_j.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.y][index_k.y]+=DDF*dtB.y*dtC.y+D2JK.by;
if((index_j.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.y][index_k.z]+=DDF*dtB.y*dtC.z+D2JK.bz;
if((index_j.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.z][index_k.x]+=DDF*dtB.z*dtC.x+D2JK.cx;
if((index_j.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.z][index_k.y]+=DDF*dtB.z*dtC.y+D2JK.cy;
if((index_j.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.z][index_k.z]+=DDF*dtB.z*dtC.z+D2JK.cz;
}
else
{
if((index_k.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.x][index_j.x]+=DDF*dtB.x*dtC.x+D2JK.ax;
if((index_k.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.x][index_j.y]+=DDF*dtB.y*dtC.x+D2JK.bx;
if((index_k.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.x][index_j.z]+=DDF*dtB.z*dtC.x+D2JK.cx;
if((index_k.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.y][index_j.x]+=DDF*dtB.x*dtC.y+D2JK.ay;
if((index_k.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.y][index_j.y]+=DDF*dtB.y*dtC.y+D2JK.by;
if((index_k.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.y][index_j.z]+=DDF*dtB.z*dtC.y+D2JK.cy;
if((index_k.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.z][index_j.x]+=DDF*dtB.x*dtC.z+D2JK.az;
if((index_k.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.z][index_j.y]+=DDF*dtB.y*dtC.z+D2JK.bz;
if((index_k.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.z][index_j.z]+=DDF*dtB.z*dtC.z+D2JK.cz;
}
if(index2<index4)
{
if((index_j.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_j.x][index_l.x]+=DDF*dtB.x*dtD.x+D2JL.ax;
if((index_j.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_j.x][index_l.y]+=DDF*dtB.x*dtD.y+D2JL.ay;
if((index_j.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_j.x][index_l.z]+=DDF*dtB.x*dtD.z+D2JL.az;
if((index_j.y>=0)&&(index_l.x>=0)) HessianMatrix.element[index_j.y][index_l.x]+=DDF*dtB.y*dtD.x+D2JL.bx;
if((index_j.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_j.y][index_l.y]+=DDF*dtB.y*dtD.y+D2JL.by;
if((index_j.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_j.y][index_l.z]+=DDF*dtB.y*dtD.z+D2JL.bz;
if((index_j.z>=0)&&(index_l.x>=0)) HessianMatrix.element[index_j.z][index_l.x]+=DDF*dtB.z*dtD.x+D2JL.cx;
if((index_j.z>=0)&&(index_l.y>=0)) HessianMatrix.element[index_j.z][index_l.y]+=DDF*dtB.z*dtD.y+D2JL.cy;
if((index_j.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_j.z][index_l.z]+=DDF*dtB.z*dtD.z+D2JL.cz;
}
else
{
if((index_l.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_l.x][index_j.x]+=DDF*dtB.x*dtD.x+D2JL.ax;
if((index_l.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_l.x][index_j.y]+=DDF*dtB.y*dtD.x+D2JL.bx;
if((index_l.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_l.x][index_j.z]+=DDF*dtB.z*dtD.x+D2JL.cx;
if((index_l.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_l.y][index_j.x]+=DDF*dtB.x*dtD.y+D2JL.ay;
if((index_l.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_l.y][index_j.y]+=DDF*dtB.y*dtD.y+D2JL.by;
if((index_l.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_l.y][index_j.z]+=DDF*dtB.z*dtD.y+D2JL.cy;
if((index_l.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_l.z][index_j.x]+=DDF*dtB.x*dtD.z+D2JL.az;
if((index_l.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_l.z][index_j.y]+=DDF*dtB.y*dtD.z+D2JL.bz;
if((index_l.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_l.z][index_j.z]+=DDF*dtB.z*dtD.z+D2JL.cz;
}
if(index3<index4)
{
if((index_k.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_k.x][index_l.x]+=DDF*dtC.x*dtD.x+D2KL.ax;
if((index_k.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_k.x][index_l.y]+=DDF*dtC.x*dtD.y+D2KL.ay;
if((index_k.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_k.x][index_l.z]+=DDF*dtC.x*dtD.z+D2KL.az;
if((index_k.y>=0)&&(index_l.x>=0)) HessianMatrix.element[index_k.y][index_l.x]+=DDF*dtC.y*dtD.x+D2KL.bx;
if((index_k.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_k.y][index_l.y]+=DDF*dtC.y*dtD.y+D2KL.by;
if((index_k.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_k.y][index_l.z]+=DDF*dtC.y*dtD.z+D2KL.bz;
if((index_k.z>=0)&&(index_l.x>=0)) HessianMatrix.element[index_k.z][index_l.x]+=DDF*dtC.z*dtD.x+D2KL.cx;
if((index_k.z>=0)&&(index_l.y>=0)) HessianMatrix.element[index_k.z][index_l.y]+=DDF*dtC.z*dtD.y+D2KL.cy;
if((index_k.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_k.z][index_l.z]+=DDF*dtC.z*dtD.z+D2KL.cz;
}
else
{
if((index_l.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_l.x][index_k.x]+=DDF*dtC.x*dtD.x+D2KL.ax;
if((index_l.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_l.x][index_k.y]+=DDF*dtC.y*dtD.x+D2KL.bx;
if((index_l.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_l.x][index_k.z]+=DDF*dtC.z*dtD.x+D2KL.cx;
if((index_l.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_l.y][index_k.x]+=DDF*dtC.x*dtD.y+D2KL.ay;
if((index_l.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_l.y][index_k.y]+=DDF*dtC.y*dtD.y+D2KL.by;
if((index_l.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_l.y][index_k.z]+=DDF*dtC.z*dtD.y+D2KL.cy;
if((index_l.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_l.z][index_k.x]+=DDF*dtC.x*dtD.z+D2KL.az;
if((index_l.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_l.z][index_k.y]+=DDF*dtC.y*dtD.z+D2KL.bz;
if((index_l.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_l.z][index_k.z]+=DDF*dtC.z*dtD.z+D2KL.cz;
}
HessianTorsionStrainPosition(HessianMatrix,index_i,index_j,index_k,index_l,
vec_u,vec_v,vec_w,u,v,w,fa,fc,fd,Dab,Dcb,Ddc,rbc,D2I,D2K,D2L,
D2IJ,D2IK,D2IL,D2JK,D2JL,D2KL,dtA,dtB,dtC,dtD,DDF,S,CosPhi);
HessianTorsionStrainStrain(HessianMatrix,vec_u,vec_v,vec_w,u,v,w,DF,DDF,S,CosPhi);
}
}
}
}
void ComputeFrameworkImproperTorsionHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivative,int ComputeGradient,int ComputeHessian)
{
int i,A,B,C,D,f1;
POINT posA,posB,posC,posD;
REAL d,e,rbc;
VECTOR Dab,Dcb,Ddc,dr,ds;
REAL dot_ab,dot_cd,r,s,sign;
REAL U,CosPhi,Phi,CosPhi2,SinPhi;
VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
REAL *parms;
INT_VECTOR3 index_i,index_j,index_k,index_l;
int index1,index2,index3,index4;
REAL_MATRIX3x3 D2I,D2L,D2IL,D2IJ,D2IK,D2JL;
REAL_MATRIX3x3 D2KL,D2J,D2K,D2JK,S;
VECTOR DIL,DDJ,DDK,DEJ,DEK;
REAL DF,DDF;
REAL u,w,v;
VECTOR vec_u,vec_v,vec_w;
VECTOR fa,fb,fc,fd;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
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;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
index_k=Framework[CurrentSystem].Atoms[f1][C].HessianIndex;
index_l=Framework[CurrentSystem].Atoms[f1][D].HessianIndex;
index1=Framework[CurrentSystem].Atoms[f1][A].HessianAtomIndex;
index2=Framework[CurrentSystem].Atoms[f1][B].HessianAtomIndex;
index3=Framework[CurrentSystem].Atoms[f1][C].HessianAtomIndex;
index4=Framework[CurrentSystem].Atoms[f1][D].HessianAtomIndex;
vec_u.x=posB.x-posC.x;
vec_u.y=posB.y-posC.y;
vec_u.z=posB.z-posC.z;
vec_u=ApplyBoundaryCondition(vec_u);
u=sqrt(SQR(vec_u.x)+SQR(vec_u.y)+SQR(vec_u.z));
vec_v.x=posD.x-posC.x;
vec_v.y=posD.y-posC.y;
vec_v.z=posD.z-posC.z;
vec_v=ApplyBoundaryCondition(vec_v);
v=sqrt(SQR(vec_v.x)+SQR(vec_v.y)+SQR(vec_v.z));
vec_w.x=posA.x-posB.x;
vec_w.y=posA.y-posB.y;
vec_w.z=posA.z-posB.z;
vec_w=ApplyBoundaryCondition(vec_w);
w=sqrt(SQR(vec_w.x)+SQR(vec_w.y)+SQR(vec_w.z));
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;
DDF=-parms[0]*(Phi*CosPhi-SinPhi)/CUBE(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]);
DDF=parms[0];
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);
DDF=-2.0*(parms[1]-6.0*parms[2]*CosPhi);
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);
DDF=-2.0*(parms[1]-6.0*parms[2]*CosPhi);
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);
DDF=-4.0*(parms[1]+6.0*parms[2]*CosPhi);
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);
DDF=4.0*(parms[1]+6.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);
DDF=2.0*parms[2]-6.0*parms[3]*CosPhi+12.0*parms[4]*CosPhi2-20.0*parms[5]*CosPhi2*CosPhi;
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);
DDF=-4.0*(parms[2]-6.0*parms[3]*CosPhi);
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;
DDF=4.0*parms[2]-16.0*parms[4]+24.0*parms[3]*CosPhi+96.0*parms[4]*CosPhi2;
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);
U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
if(fabs(SinPhi)<1.0e-8)
{
SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
DF=parms[0]*parms[1]*cos(parms[2])*SIGN(parms[1],sin(parms[1]*Phi)*Phi)+parms[0]*parms[1]*cos(parms[1]*Phi)*sin(parms[2])/SinPhi;
}
else
DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
DDF=-parms[0]*parms[1]*(parms[1]*cos(-parms[1]*Phi+parms[2])+sin(-parms[1]*Phi+parms[2])*CosPhi/SinPhi)/SQR(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);
DDF=-2.0*(parms[2]-6.0*parms[3]*CosPhi);
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);
DDF=-2.0*parms[1]+8.0*parms[3]-18.0*parms[5]+12.0*(parms[2]-5.0*parms[4])*CosPhi
-48.0*(parms[3]-6.0*parms[5])*CosPhi2+160.0*parms[4]*CosPhi2*CosPhi-480.0*parms[5]*SQR(CosPhi2);
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)));
DDF=-2.0*parms[1]+12.0*parms[2]*CosPhi+parms[3]*(48.0*CosPhi2-8.0)+parms[4]*CosPhi*(160.0*CosPhi2-60.0)
+parms[5]*(18.0-288.0*CosPhi2+480.0*SQR(CosPhi2));
break;
case FIXED_IMPROPER_DIHEDRAL:
U=DF=DDF=0.0;
break;
default:
fprintf(stderr, "Undefined Improper Torsion potential in 'framework_hessian.c'\n");
U=DF=DDF=0.0;
exit(0);
break;
}
*Energy+=U;
//if((index_i<0)&&(index_j<0)&&(index_k<0)&&(index_l<0)) continue;
// 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 strain derivative tensor
// Note: rbc is here because the vector was normalized before
S.ax=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
S.bx=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
S.cx=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;
S.ay=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
S.by=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
S.cy=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;
S.az=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
S.bz=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
S.cz=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
StrainDerivative->ax+=S.ax;
StrainDerivative->bx+=S.bx;
StrainDerivative->cx+=S.cx;
StrainDerivative->ay+=S.ay;
StrainDerivative->by+=S.by;
StrainDerivative->cy+=S.cy;
StrainDerivative->az+=S.az;
StrainDerivative->bz+=S.bz;
StrainDerivative->cz+=S.cz;
if(ComputeGradient)
{
if(index_i.x>=0) Gradient[index_i.x]+=fa.x;
if(index_i.y>=0) Gradient[index_i.y]+=fa.y;
if(index_i.z>=0) Gradient[index_i.z]+=fa.z;
if(index_j.x>=0) Gradient[index_j.x]+=fb.x;
if(index_j.y>=0) Gradient[index_j.y]+=fb.y;
if(index_j.z>=0) Gradient[index_j.z]+=fb.z;
if(index_k.x>=0) Gradient[index_k.x]+=fc.x;
if(index_k.y>=0) Gradient[index_k.y]+=fc.y;
if(index_k.z>=0) Gradient[index_k.z]+=fc.z;
if(index_l.x>=0) Gradient[index_l.x]+=fd.x;
if(index_l.y>=0) Gradient[index_l.y]+=fd.y;
if(index_l.z>=0) Gradient[index_l.z]+=fd.z;
GradientStrainTorsion(Gradient,S);
}
if(ComputeHessian)
{
// Calculate the derivatives of DOTIJ and DOTLK.
DIL.x=DF*Dcb.x/rbc;
DIL.y=DF*Dcb.y/rbc;
DIL.z=DF*Dcb.z/rbc;
DDJ.x=DF*((2.0*d-1.0)*Dcb.x-Dab.x/rbc)/rbc;
DDJ.y=DF*((2.0*d-1.0)*Dcb.y-Dab.y/rbc)/rbc;
DDJ.z=DF*((2.0*d-1.0)*Dcb.z-Dab.z/rbc)/rbc;
DDK.x=-DF*(2.0*d*Dcb.x-Dab.x/rbc)/rbc;
DDK.y=-DF*(2.0*d*Dcb.y-Dab.y/rbc)/rbc;
DDK.z=-DF*(2.0*d*Dcb.z-Dab.z/rbc)/rbc;
DEJ.x=DF*(2.0*e*Dcb.x-Ddc.x/rbc)/rbc;
DEJ.y=DF*(2.0*e*Dcb.y-Ddc.y/rbc)/rbc;
DEJ.z=DF*(2.0*e*Dcb.z-Ddc.z/rbc)/rbc;
DEK.x=-DF*((2.0*e+1.0)*Dcb.x-Ddc.x/rbc)/rbc;
DEK.y=-DF*((2.0*e+1.0)*Dcb.y-Ddc.y/rbc)/rbc;
DEK.z=-DF*((2.0*e+1.0)*Dcb.z-Ddc.z/rbc)/rbc;
// Calculate some diagonal Hessian terms for I.
D2I.ax=DF*(CosPhi*(dr.x*dr.x+Dcb.x*Dcb.x-1.0)/r-2.0*dr.x*dtA.x)/r;
D2I.by=DF*(CosPhi*(dr.y*dr.y+Dcb.y*Dcb.y-1.0)/r-2.0*dr.y*dtA.y)/r;
D2I.cz=DF*(CosPhi*(dr.z*dr.z+Dcb.z*Dcb.z-1.0)/r-2.0*dr.z*dtA.z)/r;
D2I.ay=DF*(CosPhi*(dr.x*dr.y+Dcb.x*Dcb.y)/r-dr.x*dtA.y-dr.y*dtA.x)/r;
D2I.az=DF*(CosPhi*(dr.x*dr.z+Dcb.x*Dcb.z)/r-dr.x*dtA.z-dr.z*dtA.x)/r;
D2I.bz=DF*(CosPhi*(dr.y*dr.z+Dcb.y*Dcb.z)/r-dr.y*dtA.z-dr.z*dtA.y)/r;
D2I.bx=D2I.cx=D2I.cy=0.0;
// Calculate some diagonal Hessian terms for L.
D2L.ax=DF*(CosPhi*(ds.x*ds.x+Dcb.x*Dcb.x-1.0)/s-2.0*ds.x*dtD.x)/s;
D2L.by=DF*(CosPhi*(ds.y*ds.y+Dcb.y*Dcb.y-1.0)/s-2.0*ds.y*dtD.y)/s;
D2L.cz=DF*(CosPhi*(ds.z*ds.z+Dcb.z*Dcb.z-1.0)/s-2.0*ds.z*dtD.z)/s;
D2L.ay=DF*(CosPhi*(ds.x*ds.y+Dcb.x*Dcb.y)/s-ds.x*dtD.y-ds.y*dtD.x)/s;
D2L.az=DF*(CosPhi*(ds.x*ds.z+Dcb.x*Dcb.z)/s-ds.x*dtD.z-ds.z*dtD.x)/s;
D2L.bz=DF*(CosPhi*(ds.y*ds.z+Dcb.y*Dcb.z)/s-ds.y*dtD.z-ds.z*dtD.y)/s;
D2L.bx=D2L.cx=D2L.cy=0.0;
// Calculate the IL off-diagonal terms.
D2IL.ax=DF*(CosPhi*dr.x*ds.x-dr.x*dr.x-ds.x*ds.x-Dcb.x*Dcb.x+1.0)/(r*s);
D2IL.ay=DF*(CosPhi*dr.x*ds.y-dr.x*dr.y-ds.x*ds.y-Dcb.x*Dcb.y)/(r*s);
D2IL.az=DF*(CosPhi*dr.x*ds.z-dr.x*dr.z-ds.x*ds.z-Dcb.x*Dcb.z)/(r*s);
D2IL.bx=DF*(CosPhi*dr.y*ds.x-dr.y*dr.x-ds.y*ds.x-Dcb.y*Dcb.x)/(r*s);
D2IL.by=DF*(CosPhi*dr.y*ds.y-dr.y*dr.y-ds.y*ds.y-Dcb.y*Dcb.y+1.0)/(r*s);
D2IL.bz=DF*(CosPhi*dr.y*ds.z-dr.y*dr.z-ds.y*ds.z-Dcb.y*Dcb.z)/(r*s);
D2IL.cx=DF*(CosPhi*dr.z*ds.x-dr.z*dr.x-ds.z*ds.x-Dcb.z*Dcb.x)/(r*s);
D2IL.cy=DF*(CosPhi*dr.z*ds.y-dr.z*dr.y-ds.z*ds.y-Dcb.z*Dcb.y)/(r*s);
D2IL.cz=DF*(CosPhi*dr.z*ds.z-dr.z*dr.z-ds.z*ds.z-Dcb.z*Dcb.z+1.0)/(r*s);
// Calculate the IJ off-diagonal terms.
D2IJ.ax=D2I.ax*(d-1.0)+D2IL.ax*e+DIL.x*dtA.x;
D2IJ.ay=D2I.ay*(d-1.0)+D2IL.ay*e+DIL.x*dtA.y;
D2IJ.az=D2I.az*(d-1.0)+D2IL.az*e+DIL.x*dtA.z;
D2IJ.bx=D2I.ay*(d-1.0)+D2IL.bx*e+DIL.y*dtA.x;
D2IJ.by=D2I.by*(d-1.0)+D2IL.by*e+DIL.y*dtA.y;
D2IJ.bz=D2I.bz*(d-1.0)+D2IL.bz*e+DIL.y*dtA.z;
D2IJ.cx=D2I.az*(d-1.0)+D2IL.cx*e+DIL.z*dtA.x;
D2IJ.cy=D2I.bz*(d-1.0)+D2IL.cy*e+DIL.z*dtA.y;
D2IJ.cz=D2I.cz*(d-1.0)+D2IL.cz*e+DIL.z*dtA.z;
// Calculate the IK off-diagonal terms.
D2IK.ax=-D2I.ax*d-D2IL.ax*(e+1.0)-DIL.x*dtA.x;
D2IK.ay=-D2I.ay*d-D2IL.ay*(e+1.0)-DIL.x*dtA.y;
D2IK.az=-D2I.az*d-D2IL.az*(e+1.0)-DIL.x*dtA.z;
D2IK.bx=-D2I.ay*d-D2IL.bx*(e+1.0)-DIL.y*dtA.x;
D2IK.by=-D2I.by*d-D2IL.by*(e+1.0)-DIL.y*dtA.y;
D2IK.bz=-D2I.bz*d-D2IL.bz*(e+1.0)-DIL.y*dtA.z;
D2IK.cx=-D2I.az*d-D2IL.cx*(e+1.0)-DIL.z*dtA.x;
D2IK.cy=-D2I.bz*d-D2IL.cy*(e+1.0)-DIL.z*dtA.y;
D2IK.cz=-D2I.cz*d-D2IL.cz*(e+1.0)-DIL.z*dtA.z;
// Calculate the JL off-diagonal terms.
D2JL.ax=D2IL.ax*(d-1.0)+D2L.ax*e+DIL.x*dtD.x;
D2JL.ay=D2IL.ay*(d-1.0)+D2L.ay*e+DIL.y*dtD.x;
D2JL.az=D2IL.az*(d-1.0)+D2L.az*e+DIL.z*dtD.x;
D2JL.bx=D2IL.bx*(d-1.0)+D2L.ay*e+DIL.x*dtD.y;
D2JL.by=D2IL.by*(d-1.0)+D2L.by*e+DIL.y*dtD.y;
D2JL.bz=D2IL.bz*(d-1.0)+D2L.bz*e+DIL.z*dtD.y;
D2JL.cx=D2IL.cx*(d-1.0)+D2L.az*e+DIL.x*dtD.z;
D2JL.cy=D2IL.cy*(d-1.0)+D2L.bz*e+DIL.y*dtD.z;
D2JL.cz=D2IL.cz*(d-1.0)+D2L.cz*e+DIL.z*dtD.z;
// Calculate the KL off-diagonal terms.
D2KL.ax=-D2IL.ax*d-D2L.ax*(e+1.0)-DIL.x*dtD.x;
D2KL.ay=-D2IL.ay*d-D2L.ay*(e+1.0)-DIL.y*dtD.x;
D2KL.az=-D2IL.az*d-D2L.az*(e+1.0)-DIL.z*dtD.x;
D2KL.bx=-D2IL.bx*d-D2L.ay*(e+1.0)-DIL.x*dtD.y;
D2KL.by=-D2IL.by*d-D2L.by*(e+1.0)-DIL.y*dtD.y;
D2KL.bz=-D2IL.bz*d-D2L.bz*(e+1.0)-DIL.z*dtD.y;
D2KL.cx=-D2IL.cx*d-D2L.az*(e+1.0)-DIL.x*dtD.z;
D2KL.cy=-D2IL.cy*d-D2L.bz*(e+1.0)-DIL.y*dtD.z;
D2KL.cz=-D2IL.cz*d-D2L.cz*(e+1.0)-DIL.z*dtD.z;
// Calculate the JJ diagonal terms.
D2J.ax=D2IJ.ax*(d-1.0)+D2JL.ax*e+DDJ.x*dtA.x+DEJ.x*dtD.x;
D2J.by=D2IJ.by*(d-1.0)+D2JL.by*e+DDJ.y*dtA.y+DEJ.y*dtD.y;
D2J.cz=D2IJ.cz*(d-1.0)+D2JL.cz*e+DDJ.z*dtA.z+DEJ.z*dtD.z;
D2J.ay=D2IJ.ay*(d-1.0)+D2JL.bx*e+DDJ.y*dtA.x+DEJ.y*dtD.x;
D2J.az=D2IJ.az*(d-1.0)+D2JL.cx*e+DDJ.z*dtA.x+DEJ.z*dtD.x;
D2J.bz=D2IJ.bz*(d-1.0)+D2JL.cy*e+DDJ.z*dtA.y+DEJ.z*dtD.y;
D2J.bx=D2J.cx=D2J.cy=0.0;
// Calculate the KK diagonal terms.
D2K.ax=-D2KL.ax*(e+1.0)-D2IK.ax*d-DDK.x*dtA.x-DEK.x*dtD.x;
D2K.by=-D2KL.by*(e+1.0)-D2IK.by*d-DDK.y*dtA.y-DEK.y*dtD.y;
D2K.cz=-D2KL.cz*(e+1.0)-D2IK.cz*d-DDK.z*dtA.z-DEK.z*dtD.z;
D2K.ay=-D2KL.ay*(e+1.0)-D2IK.bx*d-DDK.x*dtA.y-DEK.x*dtD.y;
D2K.az=-D2KL.az*(e+1.0)-D2IK.cx*d-DDK.x*dtA.z-DEK.x*dtD.z;
D2K.bz=-D2KL.bz*(e+1.0)-D2IK.cy*d-DDK.y*dtA.z-DEK.y*dtD.z;
D2K.bx=D2K.cx=D2K.cy=0.0;
// Calculate the JK off-diagonal terms.
D2JK.ax=-D2IJ.ax*d-D2JL.ax*(e+1.0)-DDJ.x*dtA.x-DEJ.x*dtD.x;
D2JK.ay=-D2IJ.bx*d-D2JL.ay*(e+1.0)-DDJ.x*dtA.y-DEJ.x*dtD.y;
D2JK.az=-D2IJ.cx*d-D2JL.az*(e+1.0)-DDJ.x*dtA.z-DEJ.x*dtD.z;
D2JK.bx=-D2IJ.ay*d-D2JL.bx*(e+1.0)-DDJ.y*dtA.x-DEJ.y*dtD.x;
D2JK.by=-D2IJ.by*d-D2JL.by*(e+1.0)-DDJ.y*dtA.y-DEJ.y*dtD.y;
D2JK.bz=-D2IJ.cy*d-D2JL.bz*(e+1.0)-DDJ.y*dtA.z-DEJ.y*dtD.z;
D2JK.cx=-D2IJ.az*d-D2JL.cx*(e+1.0)-DDJ.z*dtA.x-DEJ.z*dtD.x;
D2JK.cy=-D2IJ.bz*d-D2JL.cy*(e+1.0)-DDJ.z*dtA.y-DEJ.z*dtD.y;
D2JK.cz=-D2IJ.cz*d-D2JL.cz*(e+1.0)-DDJ.z*dtA.z-DEJ.z*dtD.z;
// Calculate the diagonal blocks of the hessian.
if((index_i.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_i.x][index_i.x]+=DDF*dtA.x*dtA.x+D2I.ax;
if((index_i.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.x][index_i.y]+=DDF*dtA.x*dtA.y+D2I.ay;
if((index_i.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_i.y][index_i.y]+=DDF*dtA.y*dtA.y+D2I.by;
if((index_i.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.x][index_i.z]+=DDF*dtA.x*dtA.z+D2I.az;
if((index_i.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.y][index_i.z]+=DDF*dtA.y*dtA.z+D2I.bz;
if((index_i.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_i.z][index_i.z]+=DDF*dtA.z*dtA.z+D2I.cz;
if((index_j.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_j.x][index_j.x]+=DDF*dtB.x*dtB.x+D2J.ax;
if((index_j.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.x][index_j.y]+=DDF*dtB.x*dtB.y+D2J.ay;
if((index_j.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_j.y][index_j.y]+=DDF*dtB.y*dtB.y+D2J.by;
if((index_j.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.x][index_j.z]+=DDF*dtB.x*dtB.z+D2J.az;
if((index_j.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.y][index_j.z]+=DDF*dtB.y*dtB.z+D2J.bz;
if((index_j.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_j.z][index_j.z]+=DDF*dtB.z*dtB.z+D2J.cz;
if((index_k.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_k.x][index_k.x]+=DDF*dtC.x*dtC.x+D2K.ax;
if((index_k.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_k.x][index_k.y]+=DDF*dtC.x*dtC.y+D2K.ay;
if((index_k.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_k.y][index_k.y]+=DDF*dtC.y*dtC.y+D2K.by;
if((index_k.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.x][index_k.z]+=DDF*dtC.x*dtC.z+D2K.az;
if((index_k.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.y][index_k.z]+=DDF*dtC.y*dtC.z+D2K.bz;
if((index_k.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_k.z][index_k.z]+=DDF*dtC.z*dtC.z+D2K.cz;
if((index_l.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_l.x][index_l.x]+=DDF*dtD.x*dtD.x+D2L.ax;
if((index_l.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_l.x][index_l.y]+=DDF*dtD.x*dtD.y+D2L.ay;
if((index_l.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_l.y][index_l.y]+=DDF*dtD.y*dtD.y+D2L.by;
if((index_l.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_l.x][index_l.z]+=DDF*dtD.x*dtD.z+D2L.az;
if((index_l.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_l.y][index_l.z]+=DDF*dtD.y*dtD.z+D2L.bz;
if((index_l.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_l.z][index_l.z]+=DDF*dtD.z*dtD.z+D2L.cz;
if(index1<index2)
{
if((index_i.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.x][index_j.x]+=DDF*dtA.x*dtB.x+D2IJ.ax;
if((index_i.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.x][index_j.y]+=DDF*dtA.x*dtB.y+D2IJ.ay;
if((index_i.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.x][index_j.z]+=DDF*dtA.x*dtB.z+D2IJ.az;
if((index_i.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.y][index_j.x]+=DDF*dtA.y*dtB.x+D2IJ.bx;
if((index_i.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.y][index_j.y]+=DDF*dtA.y*dtB.y+D2IJ.by;
if((index_i.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.y][index_j.z]+=DDF*dtA.y*dtB.z+D2IJ.bz;
if((index_i.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_i.z][index_j.x]+=DDF*dtA.z*dtB.x+D2IJ.cx;
if((index_i.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_i.z][index_j.y]+=DDF*dtA.z*dtB.y+D2IJ.cy;
if((index_i.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_i.z][index_j.z]+=DDF*dtA.z*dtB.z+D2IJ.cz;
}
else
{
if((index_j.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.x][index_i.x]+=DDF*dtA.x*dtB.x+D2IJ.ax;
if((index_j.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.x][index_i.y]+=DDF*dtA.y*dtB.x+D2IJ.bx;
if((index_j.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.x][index_i.z]+=DDF*dtA.z*dtB.x+D2IJ.cx;
if((index_j.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.y][index_i.x]+=DDF*dtA.x*dtB.y+D2IJ.ay;
if((index_j.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.y][index_i.y]+=DDF*dtA.y*dtB.y+D2IJ.by;
if((index_j.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.y][index_i.z]+=DDF*dtA.z*dtB.y+D2IJ.cy;
if((index_j.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_j.z][index_i.x]+=DDF*dtA.x*dtB.z+D2IJ.az;
if((index_j.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_j.z][index_i.y]+=DDF*dtA.y*dtB.z+D2IJ.bz;
if((index_j.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_j.z][index_i.z]+=DDF*dtA.z*dtB.z+D2IJ.cz;
}
if(index1<index3)
{
if((index_i.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.x][index_k.x]+=DDF*dtA.x*dtC.x+D2IK.ax;
if((index_i.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.x][index_k.y]+=DDF*dtA.x*dtC.y+D2IK.ay;
if((index_i.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.x][index_k.z]+=DDF*dtA.x*dtC.z+D2IK.az;
if((index_i.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.y][index_k.x]+=DDF*dtA.y*dtC.x+D2IK.bx;
if((index_i.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.y][index_k.y]+=DDF*dtA.y*dtC.y+D2IK.by;
if((index_i.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.y][index_k.z]+=DDF*dtA.y*dtC.z+D2IK.bz;
if((index_i.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_i.z][index_k.x]+=DDF*dtA.z*dtC.x+D2IK.cx;
if((index_i.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_i.z][index_k.y]+=DDF*dtA.z*dtC.y+D2IK.cy;
if((index_i.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_i.z][index_k.z]+=DDF*dtA.z*dtC.z+D2IK.cz;
}
else
{
if((index_k.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.x][index_i.x]+=DDF*dtA.x*dtC.x+D2IK.ax;
if((index_k.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.x][index_i.y]+=DDF*dtA.y*dtC.x+D2IK.bx;
if((index_k.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.x][index_i.z]+=DDF*dtA.z*dtC.x+D2IK.cx;
if((index_k.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.y][index_i.x]+=DDF*dtA.x*dtC.y+D2IK.ay;
if((index_k.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.y][index_i.y]+=DDF*dtA.y*dtC.y+D2IK.by;
if((index_k.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.y][index_i.z]+=DDF*dtA.z*dtC.y+D2IK.cy;
if((index_k.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_k.z][index_i.x]+=DDF*dtA.x*dtC.z+D2IK.az;
if((index_k.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_k.z][index_i.y]+=DDF*dtA.y*dtC.z+D2IK.bz;
if((index_k.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_k.z][index_i.z]+=DDF*dtA.z*dtC.z+D2IK.cz;
}
if(index1<index4)
{
if((index_i.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_i.x][index_l.x]+=DDF*dtA.x*dtD.x+D2IL.ax;
if((index_i.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_i.x][index_l.y]+=DDF*dtA.x*dtD.y+D2IL.ay;
if((index_i.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_i.x][index_l.z]+=DDF*dtA.x*dtD.z+D2IL.az;
if((index_i.y>=0)&&(index_l.x>=0)) HessianMatrix.element[index_i.y][index_l.x]+=DDF*dtA.y*dtD.x+D2IL.bx;
if((index_i.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_i.y][index_l.y]+=DDF*dtA.y*dtD.y+D2IL.by;
if((index_i.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_i.y][index_l.z]+=DDF*dtA.y*dtD.z+D2IL.bz;
if((index_i.z>=0)&&(index_l.x>=0)) HessianMatrix.element[index_i.z][index_l.x]+=DDF*dtA.z*dtD.x+D2IL.cx;
if((index_i.z>=0)&&(index_l.y>=0)) HessianMatrix.element[index_i.z][index_l.y]+=DDF*dtA.z*dtD.y+D2IL.cy;
if((index_i.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_i.z][index_l.z]+=DDF*dtA.z*dtD.z+D2IL.cz;
}
else
{
if((index_l.x>=0)&&(index_i.x>=0)) HessianMatrix.element[index_l.x][index_i.x]+=DDF*dtA.x*dtD.x+D2IL.ax;
if((index_l.x>=0)&&(index_i.y>=0)) HessianMatrix.element[index_l.x][index_i.y]+=DDF*dtA.y*dtD.x+D2IL.bx;
if((index_l.x>=0)&&(index_i.z>=0)) HessianMatrix.element[index_l.x][index_i.z]+=DDF*dtA.z*dtD.x+D2IL.cx;
if((index_l.y>=0)&&(index_i.x>=0)) HessianMatrix.element[index_l.y][index_i.x]+=DDF*dtA.x*dtD.y+D2IL.ay;
if((index_l.y>=0)&&(index_i.y>=0)) HessianMatrix.element[index_l.y][index_i.y]+=DDF*dtA.y*dtD.y+D2IL.by;
if((index_l.y>=0)&&(index_i.z>=0)) HessianMatrix.element[index_l.y][index_i.z]+=DDF*dtA.z*dtD.y+D2IL.cy;
if((index_l.z>=0)&&(index_i.x>=0)) HessianMatrix.element[index_l.z][index_i.x]+=DDF*dtA.x*dtD.z+D2IL.az;
if((index_l.z>=0)&&(index_i.y>=0)) HessianMatrix.element[index_l.z][index_i.y]+=DDF*dtA.y*dtD.z+D2IL.bz;
if((index_l.z>=0)&&(index_i.z>=0)) HessianMatrix.element[index_l.z][index_i.z]+=DDF*dtA.z*dtD.z+D2IL.cz;
}
if(index2<index3)
{
if((index_j.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.x][index_k.x]+=DDF*dtB.x*dtC.x+D2JK.ax;
if((index_j.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.x][index_k.y]+=DDF*dtB.x*dtC.y+D2JK.ay;
if((index_j.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.x][index_k.z]+=DDF*dtB.x*dtC.z+D2JK.az;
if((index_j.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.y][index_k.x]+=DDF*dtB.y*dtC.x+D2JK.bx;
if((index_j.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.y][index_k.y]+=DDF*dtB.y*dtC.y+D2JK.by;
if((index_j.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.y][index_k.z]+=DDF*dtB.y*dtC.z+D2JK.bz;
if((index_j.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_j.z][index_k.x]+=DDF*dtB.z*dtC.x+D2JK.cx;
if((index_j.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_j.z][index_k.y]+=DDF*dtB.z*dtC.y+D2JK.cy;
if((index_j.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_j.z][index_k.z]+=DDF*dtB.z*dtC.z+D2JK.cz;
}
else
{
if((index_k.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.x][index_j.x]+=DDF*dtB.x*dtC.x+D2JK.ax;
if((index_k.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.x][index_j.y]+=DDF*dtB.y*dtC.x+D2JK.bx;
if((index_k.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.x][index_j.z]+=DDF*dtB.z*dtC.x+D2JK.cx;
if((index_k.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.y][index_j.x]+=DDF*dtB.x*dtC.y+D2JK.ay;
if((index_k.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.y][index_j.y]+=DDF*dtB.y*dtC.y+D2JK.by;
if((index_k.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.y][index_j.z]+=DDF*dtB.z*dtC.y+D2JK.cy;
if((index_k.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_k.z][index_j.x]+=DDF*dtB.x*dtC.z+D2JK.az;
if((index_k.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_k.z][index_j.y]+=DDF*dtB.y*dtC.z+D2JK.bz;
if((index_k.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_k.z][index_j.z]+=DDF*dtB.z*dtC.z+D2JK.cz;
}
if(index2<index4)
{
if((index_j.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_j.x][index_l.x]+=DDF*dtB.x*dtD.x+D2JL.ax;
if((index_j.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_j.x][index_l.y]+=DDF*dtB.x*dtD.y+D2JL.ay;
if((index_j.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_j.x][index_l.z]+=DDF*dtB.x*dtD.z+D2JL.az;
if((index_j.y>=0)&&(index_l.x>=0)) HessianMatrix.element[index_j.y][index_l.x]+=DDF*dtB.y*dtD.x+D2JL.bx;
if((index_j.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_j.y][index_l.y]+=DDF*dtB.y*dtD.y+D2JL.by;
if((index_j.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_j.y][index_l.z]+=DDF*dtB.y*dtD.z+D2JL.bz;
if((index_j.z>=0)&&(index_l.x>=0)) HessianMatrix.element[index_j.z][index_l.x]+=DDF*dtB.z*dtD.x+D2JL.cx;
if((index_j.z>=0)&&(index_l.y>=0)) HessianMatrix.element[index_j.z][index_l.y]+=DDF*dtB.z*dtD.y+D2JL.cy;
if((index_j.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_j.z][index_l.z]+=DDF*dtB.z*dtD.z+D2JL.cz;
}
else
{
if((index_l.x>=0)&&(index_j.x>=0)) HessianMatrix.element[index_l.x][index_j.x]+=DDF*dtB.x*dtD.x+D2JL.ax;
if((index_l.x>=0)&&(index_j.y>=0)) HessianMatrix.element[index_l.x][index_j.y]+=DDF*dtB.y*dtD.x+D2JL.bx;
if((index_l.x>=0)&&(index_j.z>=0)) HessianMatrix.element[index_l.x][index_j.z]+=DDF*dtB.z*dtD.x+D2JL.cx;
if((index_l.y>=0)&&(index_j.x>=0)) HessianMatrix.element[index_l.y][index_j.x]+=DDF*dtB.x*dtD.y+D2JL.ay;
if((index_l.y>=0)&&(index_j.y>=0)) HessianMatrix.element[index_l.y][index_j.y]+=DDF*dtB.y*dtD.y+D2JL.by;
if((index_l.y>=0)&&(index_j.z>=0)) HessianMatrix.element[index_l.y][index_j.z]+=DDF*dtB.z*dtD.y+D2JL.cy;
if((index_l.z>=0)&&(index_j.x>=0)) HessianMatrix.element[index_l.z][index_j.x]+=DDF*dtB.x*dtD.z+D2JL.az;
if((index_l.z>=0)&&(index_j.y>=0)) HessianMatrix.element[index_l.z][index_j.y]+=DDF*dtB.y*dtD.z+D2JL.bz;
if((index_l.z>=0)&&(index_j.z>=0)) HessianMatrix.element[index_l.z][index_j.z]+=DDF*dtB.z*dtD.z+D2JL.cz;
}
if(index3<index4)
{
if((index_k.x>=0)&&(index_l.x>=0)) HessianMatrix.element[index_k.x][index_l.x]+=DDF*dtC.x*dtD.x+D2KL.ax;
if((index_k.x>=0)&&(index_l.y>=0)) HessianMatrix.element[index_k.x][index_l.y]+=DDF*dtC.x*dtD.y+D2KL.ay;
if((index_k.x>=0)&&(index_l.z>=0)) HessianMatrix.element[index_k.x][index_l.z]+=DDF*dtC.x*dtD.z+D2KL.az;
if((index_k.y>=0)&&(index_l.x>=0)) HessianMatrix.element[index_k.y][index_l.x]+=DDF*dtC.y*dtD.x+D2KL.bx;
if((index_k.y>=0)&&(index_l.y>=0)) HessianMatrix.element[index_k.y][index_l.y]+=DDF*dtC.y*dtD.y+D2KL.by;
if((index_k.y>=0)&&(index_l.z>=0)) HessianMatrix.element[index_k.y][index_l.z]+=DDF*dtC.y*dtD.z+D2KL.bz;
if((index_k.z>=0)&&(index_l.x>=0)) HessianMatrix.element[index_k.z][index_l.x]+=DDF*dtC.z*dtD.x+D2KL.cx;
if((index_k.z>=0)&&(index_l.y>=0)) HessianMatrix.element[index_k.z][index_l.y]+=DDF*dtC.z*dtD.y+D2KL.cy;
if((index_k.z>=0)&&(index_l.z>=0)) HessianMatrix.element[index_k.z][index_l.z]+=DDF*dtC.z*dtD.z+D2KL.cz;
}
else
{
if((index_l.x>=0)&&(index_k.x>=0)) HessianMatrix.element[index_l.x][index_k.x]+=DDF*dtC.x*dtD.x+D2KL.ax;
if((index_l.x>=0)&&(index_k.y>=0)) HessianMatrix.element[index_l.x][index_k.y]+=DDF*dtC.y*dtD.x+D2KL.bx;
if((index_l.x>=0)&&(index_k.z>=0)) HessianMatrix.element[index_l.x][index_k.z]+=DDF*dtC.z*dtD.x+D2KL.cx;
if((index_l.y>=0)&&(index_k.x>=0)) HessianMatrix.element[index_l.y][index_k.x]+=DDF*dtC.x*dtD.y+D2KL.ay;
if((index_l.y>=0)&&(index_k.y>=0)) HessianMatrix.element[index_l.y][index_k.y]+=DDF*dtC.y*dtD.y+D2KL.by;
if((index_l.y>=0)&&(index_k.z>=0)) HessianMatrix.element[index_l.y][index_k.z]+=DDF*dtC.z*dtD.y+D2KL.cy;
if((index_l.z>=0)&&(index_k.x>=0)) HessianMatrix.element[index_l.z][index_k.x]+=DDF*dtC.x*dtD.z+D2KL.az;
if((index_l.z>=0)&&(index_k.y>=0)) HessianMatrix.element[index_l.z][index_k.y]+=DDF*dtC.y*dtD.z+D2KL.bz;
if((index_l.z>=0)&&(index_k.z>=0)) HessianMatrix.element[index_l.z][index_k.z]+=DDF*dtC.z*dtD.z+D2KL.cz;
}
HessianTorsionStrainPosition(HessianMatrix,index_i,index_j,index_k,index_l,
vec_u,vec_v,vec_w,u,v,w,fa,fc,fd,Dab,Dcb,Ddc,rbc,D2I,D2K,D2L,
D2IJ,D2IK,D2IL,D2JK,D2JL,D2KL,dtA,dtB,dtC,dtD,DDF,S,CosPhi);
HessianTorsionStrainStrain(HessianMatrix,vec_u,vec_v,vec_w,u,v,w,DF,DDF,S,CosPhi);
}
}
}
}
// Numerical routines
// TODO: convert them to analytical expressions
void CalculateFrameworkInversionBendForces(int f1,int i,VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD,REAL *Energy,VECTOR *fa,VECTOR *fb,VECTOR *fc,VECTOR *fd,REAL_MATRIX3x3 *strain_derivative)
{
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;
REAL term,dedcos;
VECTOR dccdia,dccdic,dccdid;
VECTOR deedia,deedic,deedid;
parms=Framework[CurrentSystem].InversionBendArguments[f1][i];
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
*Energy=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);
strain_derivative->ax=Rab.x*fa->x+Rbc.x*fc->x+Rbd.x*fd->x;
strain_derivative->ay=Rab.x*fa->y+Rbc.x*fc->y+Rbd.x*fd->y;
strain_derivative->az=Rab.x*fa->z+Rbc.x*fc->z+Rbd.x*fd->z;
strain_derivative->bx=Rab.y*fa->x+Rbc.y*fc->x+Rbd.y*fd->x;
strain_derivative->by=Rab.y*fa->y+Rbc.y*fc->y+Rbd.y*fd->y;
strain_derivative->bz=Rab.y*fa->z+Rbc.y*fc->z+Rbd.y*fd->z;
strain_derivative->cx=Rab.z*fa->x+Rbc.z*fc->x+Rbd.z*fd->x;
strain_derivative->cy=Rab.z*fa->y+Rbc.z*fc->y+Rbd.z*fd->y;
strain_derivative->cz=Rab.z*fa->z+Rbc.z*fc->z+Rbd.z*fd->z;
}
void ComputeFrameworkInversionBendHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivativeTensor,int ComputeGradient,int ComputeHessian)
{
int i,f1;
int A,B,C,D;
const REAL Delta=1e-7;
VECTOR posA0,posB0,posC0,posD0;
VECTOR posA,posB,posC,posD;
VECTOR fa0,fb0,fc0,fd0,fa[4],fb[4],fc[4],fd[4];
INT_VECTOR3 index_i,index_j,index_k,index_l;
REAL U;
REAL_MATRIX3x3 strain_derivative;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
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;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
index_k=Framework[CurrentSystem].Atoms[f1][C].HessianIndex;
index_l=Framework[CurrentSystem].Atoms[f1][D].HessianIndex;
posA0=Framework[CurrentSystem].Atoms[f1][A].Position;
posB0=Framework[CurrentSystem].Atoms[f1][B].Position;
posC0=Framework[CurrentSystem].Atoms[f1][C].Position;
posD0=Framework[CurrentSystem].Atoms[f1][D].Position;
CalculateFrameworkInversionBendForces(f1,i,posA0,posB0,posC0,posD0,&U,&fa0,&fb0,&fc0,&fd0,&strain_derivative);
*Energy+=U;
StrainDerivativeTensor->ax+=strain_derivative.ax;
StrainDerivativeTensor->ay+=strain_derivative.ay;
StrainDerivativeTensor->az+=strain_derivative.az;
StrainDerivativeTensor->bx+=strain_derivative.bx;
StrainDerivativeTensor->by+=strain_derivative.by;
StrainDerivativeTensor->bz+=strain_derivative.bz;
StrainDerivativeTensor->cx+=strain_derivative.cx;
StrainDerivativeTensor->cy+=strain_derivative.cy;
StrainDerivativeTensor->cz+=strain_derivative.cz;
// add contribution to the first derivatives
if(ComputeGradient)
{
if(index_i.x>=0) Gradient[index_i.x]-=fa0.x;
if(index_i.y>=0) Gradient[index_i.y]-=fa0.y;
if(index_i.z>=0) Gradient[index_i.z]-=fa0.z;
if(index_j.x>=0) Gradient[index_j.x]-=fb0.x;
if(index_j.y>=0) Gradient[index_j.y]-=fb0.y;
if(index_j.z>=0) Gradient[index_j.z]-=fb0.z;
if(index_k.x>=0) Gradient[index_k.x]-=fc0.x;
if(index_k.y>=0) Gradient[index_k.y]-=fc0.y;
if(index_k.z>=0) Gradient[index_k.z]-=fc0.z;
if(index_l.x>=0) Gradient[index_l.x]-=fd0.x;
if(index_l.y>=0) Gradient[index_l.y]-=fd0.y;
if(index_l.z>=0) Gradient[index_l.z]-=fd0.z;
}
if(ComputeHessian)
{
// Atom A
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_i.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_i.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_i.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_i.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_i.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_i.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_i.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_i.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_i.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_i.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_i.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_i.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_i.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_i.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_i.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_i.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_i.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_i.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_i.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_i.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_i.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_i.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_i.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_i.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_i.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_i.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_i.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_i.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_i.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_i.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_i.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_i.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_i.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_i.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_i.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_i.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_i.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_i.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
// Atom B
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_j.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_j.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_j.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_j.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_j.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_j.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_j.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_j.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_j.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_j.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_j.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_j.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_j.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_j.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_j.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_j.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_j.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_j.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_j.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_j.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_j.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_j.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_j.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_j.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_j.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_j.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_j.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_j.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_j.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_j.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_j.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_j.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_j.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_j.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_j.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_j.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_j.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_j.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_j.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
// Atom C
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_k.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_k.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_k.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_k.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_k.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_k.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_k.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_k.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_k.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_k.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_k.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_k.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_k.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_k.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_k.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_k.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_k.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_k.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_k.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_k.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_k.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_k.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_k.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_k.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_k.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_k.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_k.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_k.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_k.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_k.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_k.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_k.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_k.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_k.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_k.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_k.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_k.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_k.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_k.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
// Atom D
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_l.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_l.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_l.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_l.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_l.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_l.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_l.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_l.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_l.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_l.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_l.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_l.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_l.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_l.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_l.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_l.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_l.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_l.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_l.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_l.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_l.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_l.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_l.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_l.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_l.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_l.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z+=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z+=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z-=0.5*Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z-=Delta;
CalculateFrameworkInversionBendForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_l.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_l.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_l.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_l.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_l.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_l.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_l.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_l.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_l.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_l.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_l.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_l.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_l.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
}
}
}
}
void CalculateFrameworkBendTorsionForces(int f1,int i,VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD,REAL *Energy,VECTOR *fan,VECTOR *fbn,VECTOR *fcn,VECTOR *fdn,REAL_MATRIX3x3 *strain_derivativen)
{
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,Pb,Pc;
REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
REAL DTheta1,DTheta2,sign,Phi,SinPhi;
REAL *parms;
VECTOR fa,fb,fc,fd;
fan->x=fbn->x=fcn->x=fdn->x=0.0;
fan->y=fbn->y=fcn->y=fdn->y=0.0;
fan->z=fbn->z=fcn->z=fdn->z=0.0;
strain_derivativen->ax=strain_derivativen->bx=strain_derivativen->cx=0.0;
strain_derivativen->ay=strain_derivativen->by=strain_derivativen->cy=0.0;
strain_derivativen->az=strain_derivativen->bz=strain_derivativen->cz=0.0;
parms=(REAL*)&Framework[CurrentSystem].BendTorsionArguments[f1][i];
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
*Energy=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 torsion 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;
fan->x+=fa.x; fan->y+=fa.y; fan->z+=fa.z;
fbn->x+=fb.x; fbn->y+=fb.y; fbn->z+=fb.z;
fcn->x+=fc.x; fcn->y+=fc.y; fcn->z+=fc.z;
fdn->x+=fd.x; fdn->y+=fd.y; fdn->z+=fd.z;
// add contribution to the stress tensor
// Note: rbc is here because the vector was normalized before
strain_derivativen->ax-=Dab.x*fa.x+Dbc.x*rbc*(fc.x+fd.x)+Dcd.x*fd.x;
strain_derivativen->bx-=Dab.y*fa.x+Dbc.y*rbc*(fc.x+fd.x)+Dcd.y*fd.x;
strain_derivativen->cx-=Dab.z*fa.x+Dbc.z*rbc*(fc.x+fd.x)+Dcd.z*fd.x;
strain_derivativen->ay-=Dab.x*fa.y+Dbc.x*rbc*(fc.y+fd.y)+Dcd.x*fd.y;
strain_derivativen->by-=Dab.y*fa.y+Dbc.y*rbc*(fc.y+fd.y)+Dcd.y*fd.y;
strain_derivativen->cy-=Dab.z*fa.y+Dbc.z*rbc*(fc.y+fd.y)+Dcd.z*fd.y;
strain_derivativen->az-=Dab.x*fa.z+Dbc.x*rbc*(fc.z+fd.z)+Dcd.x*fd.z;
strain_derivativen->bz-=Dab.y*fa.z+Dbc.y*rbc*(fc.z+fd.z)+Dcd.y*fd.z;
strain_derivativen->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;
fan->x+=fa.x;
fan->y+=fa.y;
fan->z+=fa.z;
fbn->x+=fb.x-fa.x-fc.x;
fbn->y+=fb.y-fa.y-fc.y;
fbn->z+=fb.z-fa.z-fc.z;
fcn->x+=fc.x-fb.x-fd.x;
fcn->y+=fc.y-fb.y-fd.y;
fcn->z+=fc.z-fb.z-fd.z;
fdn->x+=fd.x;
fdn->y+=fd.y;
fdn->z+=fd.z;
strain_derivativen->ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x+rbc*Dbc.x*fb.x+rcd*Dcd.x*fd.x;
strain_derivativen->bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x+rbc*Dbc.y*fb.x+rcd*Dcd.y*fd.x;
strain_derivativen->cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x+rbc*Dbc.z*fb.x+rcd*Dcd.z*fd.x;
strain_derivativen->ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y+rbc*Dbc.x*fb.y+rcd*Dcd.x*fd.y;
strain_derivativen->by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y+rbc*Dbc.y*fb.y+rcd*Dcd.y*fd.y;
strain_derivativen->cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y+rbc*Dbc.z*fb.y+rcd*Dcd.z*fd.y;
strain_derivativen->az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z+rbc*Dbc.x*fb.z+rcd*Dcd.x*fd.z;
strain_derivativen->bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z+rbc*Dbc.y*fb.z+rcd*Dcd.y*fd.z;
strain_derivativen->cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z+rbc*Dbc.z*fb.z+rcd*Dcd.z*fd.z;
}
void ComputeFrameworkBendTorsionHessian(REAL *Energy,REAL* Gradient,REAL_MATRIX HessianMatrix,REAL_MATRIX3x3 *StrainDerivativeTensor,int ComputeGradient,int ComputeHessian)
{
int i,f1;
int A,B,C,D;
const REAL Delta=1e-7;
VECTOR posA0,posB0,posC0,posD0;
VECTOR posA,posB,posC,posD;
VECTOR fa0,fb0,fc0,fd0,fa[4],fb[4],fc[4],fd[4];
INT_VECTOR3 index_i,index_j,index_k,index_l;
REAL U;
REAL_MATRIX3x3 strain_derivative;
int n;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
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;
index_i=Framework[CurrentSystem].Atoms[f1][A].HessianIndex;
index_j=Framework[CurrentSystem].Atoms[f1][B].HessianIndex;
index_k=Framework[CurrentSystem].Atoms[f1][C].HessianIndex;
index_l=Framework[CurrentSystem].Atoms[f1][D].HessianIndex;
posA0=Framework[CurrentSystem].Atoms[f1][A].Position;
posB0=Framework[CurrentSystem].Atoms[f1][B].Position;
posC0=Framework[CurrentSystem].Atoms[f1][C].Position;
posD0=Framework[CurrentSystem].Atoms[f1][D].Position;
CalculateFrameworkBendTorsionForces(f1,i,posA0,posB0,posC0,posD0,&U,&fa0,&fb0,&fc0,&fd0,&strain_derivative);
*Energy+=U;
StrainDerivativeTensor->ax+=strain_derivative.ax;
StrainDerivativeTensor->ay+=strain_derivative.ay;
StrainDerivativeTensor->az+=strain_derivative.az;
StrainDerivativeTensor->bx+=strain_derivative.bx;
StrainDerivativeTensor->by+=strain_derivative.by;
StrainDerivativeTensor->bz+=strain_derivative.bz;
StrainDerivativeTensor->cx+=strain_derivative.cx;
StrainDerivativeTensor->cy+=strain_derivative.cy;
StrainDerivativeTensor->cz+=strain_derivative.cz;
// add contribution to the first derivatives
if(ComputeGradient)
{
if(index_i.x>=0) Gradient[index_i.x]-=fa0.x;
if(index_i.y>=0) Gradient[index_i.y]-=fa0.y;
if(index_i.z>=0) Gradient[index_i.z]-=fa0.z;
if(index_j.x>=0) Gradient[index_j.x]-=fb0.x;
if(index_j.y>=0) Gradient[index_j.y]-=fb0.y;
if(index_j.z>=0) Gradient[index_j.z]-=fb0.z;
if(index_k.x>=0) Gradient[index_k.x]-=fc0.x;
if(index_k.y>=0) Gradient[index_k.y]-=fc0.y;
if(index_k.z>=0) Gradient[index_k.z]-=fc0.z;
if(index_l.x>=0) Gradient[index_l.x]-=fd0.x;
if(index_l.y>=0) Gradient[index_l.y]-=fd0.y;
if(index_l.z>=0) Gradient[index_l.z]-=fd0.z;
n=NumberOfCoordinatesMinimizationVariables;
switch(Ensemble[CurrentSystem])
{
case NPT:
Gradient[n]+=strain_derivative.ax;
break;
case NPTPR:
case NPHPR:
switch(NPTPRCellType[CurrentSystem])
{
case ISOTROPIC:
Gradient[n ]+=(strain_derivative.ax+strain_derivative.by+strain_derivative.cz)/3.0; // xx
Gradient[n+1]+=(strain_derivative.ax+strain_derivative.by+strain_derivative.cz)/3.0; // xx
Gradient[n+2]+=(strain_derivative.ax+strain_derivative.by+strain_derivative.cz)/3.0; // xx
break;
case ANISOTROPIC:
Gradient[n ]+=strain_derivative.ax; // xx
Gradient[n+1]+=strain_derivative.by; // yy
Gradient[n+2]+=strain_derivative.cz; // zz
break;
case REGULAR:
case REGULAR_UPPER_TRIANGLE:
Gradient[n ]+=strain_derivative.ax; // xx
Gradient[n+1]+=strain_derivative.ay; // xy
Gradient[n+2]+=strain_derivative.az; // xz
Gradient[n+3]+=strain_derivative.by; // yy
Gradient[n+4]+=strain_derivative.bz; // yz
Gradient[n+5]+=strain_derivative.cz; // zz
break;
case MONOCLINIC:
case MONOCLINIC_UPPER_TRIANGLE:
switch(MonoclinicAngleType[CurrentSystem])
{
case MONOCLINIC_ALPHA_ANGLE:
Gradient[n]+=strain_derivative.ax;
Gradient[n+1]+=strain_derivative.by;
Gradient[n+2]+=strain_derivative.bz;
Gradient[n+3]+=strain_derivative.cz;
break;
case MONOCLINIC_BETA_ANGLE:
Gradient[n]+=strain_derivative.ax;
Gradient[n+1]+=strain_derivative.az;
Gradient[n+2]+=strain_derivative.by;
Gradient[n+3]+=strain_derivative.cz;
break;
case MONOCLINIC_GAMMA_ANGLE:
default:
Gradient[n]+=strain_derivative.ax;
Gradient[n+1]+=strain_derivative.ay;
Gradient[n+2]+=strain_derivative.by;
Gradient[n+3]+=strain_derivative.cz;
break;
}
break;
default:
fprintf(stderr, "Unknown NPTPRCellType\n");
exit(0);
break;
}
break;
case NVT:
case NVE:
break;
}
}
if(ComputeHessian)
{
// Atom A
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.x-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_i.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_i.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_i.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_i.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_i.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_i.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_i.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_i.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_i.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_i.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_i.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_i.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_i.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.y-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_i.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_i.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_i.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_i.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_i.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_i.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_i.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_i.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_i.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_i.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_i.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_i.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_i.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posA.z-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_i.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_i.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_i.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_i.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_i.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_i.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_i.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_i.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_i.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_i.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_i.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_i.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_i.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
// Atom B
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.x-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_j.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_j.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_j.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_j.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_j.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_j.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_j.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_j.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_j.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_j.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_j.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_j.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_j.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.y-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_j.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_j.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_j.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_j.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_j.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_j.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_j.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_j.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_j.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_j.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_j.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_j.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_j.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posB.z-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_j.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_j.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_j.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_j.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_j.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_j.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_j.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_j.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_j.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_j.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_j.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_j.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_j.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
// Atom C
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.x-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_k.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_k.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_k.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_k.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_k.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_k.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_k.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_k.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_k.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_k.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_k.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_k.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_k.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.y-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_k.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_k.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_k.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_k.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_k.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_k.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_k.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_k.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_k.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_k.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_k.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_k.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_k.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posC.z-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_k.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_k.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_k.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_k.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_k.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_k.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_k.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_k.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_k.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_k.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_k.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_k.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_k.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
// Atom D
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.x-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_l.x>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_l.x][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_l.x][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_l.x][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_l.x][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_l.x][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_l.x][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_l.x][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_l.x][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_l.x][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_l.x][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_l.x][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_l.x][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.y-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_l.y>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_l.y][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_l.y][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_l.y][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_l.y][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_l.y][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_l.y][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_l.y][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_l.y][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_l.y][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_l.y][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_l.y][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_l.y][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z+=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[0],&fb[0],&fc[0],&fd[0],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z+=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[1],&fb[1],&fc[1],&fd[1],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z-=0.5*Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[2],&fb[2],&fc[2],&fd[2],&strain_derivative);
posA=posA0; posB=posB0; posC=posC0; posD=posD0;
posD.z-=Delta;
CalculateFrameworkBendTorsionForces(f1,i,posA,posB,posC,posD,&U,&fa[3],&fb[3],&fc[3],&fd[3],&strain_derivative);
if(index_l.z>=0)
{
if(index_i.x>=0) HessianMatrix.element[index_l.z][index_i.x]-=(-fa[0].x+8.0*fa[1].x-8.0*fa[2].x+fa[3].x)/(6.0*Delta);
if(index_i.y>=0) HessianMatrix.element[index_l.z][index_i.y]-=(-fa[0].y+8.0*fa[1].y-8.0*fa[2].y+fa[3].y)/(6.0*Delta);
if(index_i.z>=0) HessianMatrix.element[index_l.z][index_i.z]-=(-fa[0].z+8.0*fa[1].z-8.0*fa[2].z+fa[3].z)/(6.0*Delta);
if(index_j.x>=0) HessianMatrix.element[index_l.z][index_j.x]-=(-fb[0].x+8.0*fb[1].x-8.0*fb[2].x+fb[3].x)/(6.0*Delta);
if(index_j.y>=0) HessianMatrix.element[index_l.z][index_j.y]-=(-fb[0].y+8.0*fb[1].y-8.0*fb[2].y+fb[3].y)/(6.0*Delta);
if(index_j.z>=0) HessianMatrix.element[index_l.z][index_j.z]-=(-fb[0].z+8.0*fb[1].z-8.0*fb[2].z+fb[3].z)/(6.0*Delta);
if(index_k.x>=0) HessianMatrix.element[index_l.z][index_k.x]-=(-fc[0].x+8.0*fc[1].x-8.0*fc[2].x+fc[3].x)/(6.0*Delta);
if(index_k.y>=0) HessianMatrix.element[index_l.z][index_k.y]-=(-fc[0].y+8.0*fc[1].y-8.0*fc[2].y+fc[3].y)/(6.0*Delta);
if(index_k.z>=0) HessianMatrix.element[index_l.z][index_k.z]-=(-fc[0].z+8.0*fc[1].z-8.0*fc[2].z+fc[3].z)/(6.0*Delta);
if(index_l.x>=0) HessianMatrix.element[index_l.z][index_l.x]-=(-fd[0].x+8.0*fd[1].x-8.0*fd[2].x+fd[3].x)/(6.0*Delta);
if(index_l.y>=0) HessianMatrix.element[index_l.z][index_l.y]-=(-fd[0].y+8.0*fd[1].y-8.0*fd[2].y+fd[3].y)/(6.0*Delta);
if(index_l.z>=0) HessianMatrix.element[index_l.z][index_l.z]-=(-fd[0].z+8.0*fd[1].z-8.0*fd[2].z+fd[3].z)/(6.0*Delta);
}
}
}
}
}
/*************************************************************************************************************
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.
**************************************************************************************************************/
void CalculateDerivativesAtPositionVDW(VECTOR pos,int typeA,REAL *value,VECTOR *first_derivative,
REAL_MATRIX3x3 *second_derivative,REAL *third_derivative)
{
int i,f;
int typeB;
VECTOR dr;
REAL rr,F,DF,DDF,DDDF;
*value=0;
first_derivative->x=0.0;
first_derivative->y=0.0;
first_derivative->z=0.0;
second_derivative->ax=second_derivative->bx=second_derivative->cx=0.0;
second_derivative->ay=second_derivative->by=second_derivative->cy=0.0;
second_derivative->az=second_derivative->bz=second_derivative->cz=0.0;
*third_derivative=0.0;
for(f=0;f<Framework[CurrentSystem].NumberOfFrameworks;f++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f];i++)
{
typeB=Framework[CurrentSystem].Atoms[f][i].Type;
dr.x=pos.x-Framework[CurrentSystem].Atoms[f][i].AnisotropicPosition.x;
dr.y=pos.y-Framework[CurrentSystem].Atoms[f][i].AnisotropicPosition.y;
dr.z=pos.z-Framework[CurrentSystem].Atoms[f][i].AnisotropicPosition.z;
dr=ApplyBoundaryCondition(dr);
rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
if(rr<CutOffVDWSquared)
{
PotentialThirdDerivative(typeA,typeB,rr,&F,&DF,&DDF,&DDDF);
*value+=F;
first_derivative->x+=dr.x*DF;
first_derivative->y+=dr.y*DF;
first_derivative->z+=dr.z*DF;
// add contribution to the second derivatives (Hessian matrix)