/*************************************************************************************************************
 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.
**************************************************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "potentials.h"
#include "molecule.h"
#include "cbmc.h"
#include "utils.h"
#include "internal_force.h"
#include "ewald.h"
#include "matrix.h"
#include "spectra.h"
#include "minimization.h"
#include "rigid.h"

REAL ReturnBondDistance(VECTOR posA,VECTOR posB)
{
  VECTOR dr;
  REAL rr;

  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);
  return sqrt(rr);
}

REAL ReturnBendAngle(VECTOR posA,VECTOR posB,VECTOR posC)
{
  REAL CosTheta;
  VECTOR e12,e32;
  REAL r12,r32;

  e12.x=posA.x-posB.x;
  e12.y=posA.y-posB.y;
  e12.z=posA.z-posB.z;
  e12=ApplyBoundaryCondition(e12);
  r12=sqrt(SQR(e12.x)+SQR(e12.y)+SQR(e12.z));
  e12.x/=r12;
  e12.y/=r12;
  e12.z/=r12;

  e32.x=posC.x-posB.x;
  e32.y=posC.y-posB.y;
  e32.z=posC.z-posB.z;
  e32=ApplyBoundaryCondition(e32);
  r32=sqrt(SQR(e32.x)+SQR(e32.y)+SQR(e32.z));
  e32.x/=r32;
  e32.y/=r32;
  e32.z/=r32;

  CosTheta=(e12.x*e32.x+e12.y*e32.y+e12.z*e32.z);
  return acos(CosTheta);
}

REAL ReturnDihedralAngle(VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD)
{
  REAL rbc;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi;
  VECTOR Pb,Pc;
  VECTOR vec_u,vec_v,vec_w;
  REAL u,w,v;

  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);

  // 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);
  return Phi;
}


REAL ReturnInversionBendAngle(VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD)
{
  REAL r;
  VECTOR cross_product_dc,cross_product_ad,cross_product_ca;
  REAL dot_product;
  VECTOR Dab,Dcb,Ddb;
  REAL ChiA,ChiC,ChiD;

  Dab.x=posA.x-posB.x;
  Dab.y=posA.y-posB.y;
  Dab.z=posA.z-posB.z;
  Dab=ApplyBoundaryCondition(Dab);
  r=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
  Dab.x/=r;
  Dab.y/=r;
  Dab.z/=r;

  Dcb.x=posC.x-posB.x;
  Dcb.y=posC.y-posB.y;
  Dcb.z=posC.z-posB.z;
  Dcb=ApplyBoundaryCondition(Dcb);
  r=sqrt(SQR(Dcb.x)+SQR(Dcb.y)+SQR(Dcb.z));
  Dcb.x/=r;
  Dcb.y/=r;
  Dcb.z/=r;

  Ddb.x=posD.x-posB.x;
  Ddb.y=posD.y-posB.y;
  Ddb.z=posD.z-posB.z;
  Ddb=ApplyBoundaryCondition(Ddb);
  r=sqrt(SQR(Ddb.x)+SQR(Ddb.y)+SQR(Ddb.z));
  Ddb.x/=r;
  Ddb.y/=r;
  Ddb.z/=r;

  cross_product_dc.x=Ddb.y*Dcb.z-Ddb.z*Dcb.y;
  cross_product_dc.y=Ddb.z*Dcb.x-Ddb.x*Dcb.z;
  cross_product_dc.z=Ddb.x*Dcb.y-Ddb.y*Dcb.x;
  dot_product=cross_product_dc.x*Dab.x+cross_product_dc.y*Dab.y+cross_product_dc.z*Dab.z;
  ChiA=asin(dot_product/sin(ReturnBendAngle(posC,posB,posD)));

  cross_product_ad.x=Dab.y*Ddb.z-Dab.z*Ddb.y;
  cross_product_ad.y=Dab.z*Ddb.x-Dab.x*Ddb.z;
  cross_product_ad.z=Dab.x*Ddb.y-Dab.y*Ddb.x;
  dot_product=cross_product_ad.x*Dcb.x+cross_product_ad.y*Dcb.y+cross_product_ad.z*Dcb.z;
  ChiC=asin(dot_product/sin(ReturnBendAngle(posA,posB,posD)));

  cross_product_ca.x=Dcb.y*Dab.z-Dcb.z*Dab.y;
  cross_product_ca.y=Dcb.z*Dab.x-Dcb.x*Dab.z;
  cross_product_ca.z=Dcb.x*Dab.y-Dcb.y*Dab.x;
  dot_product=cross_product_ca.x*Ddb.x+cross_product_ca.y*Ddb.y+cross_product_ca.z*Ddb.z;
  ChiD=asin(dot_product/sin(ReturnBendAngle(posA,posB,posC)));

  //return (ChiA+ChiC+ChiD)/3.0;
  return ChiA;
}

REAL ReturnOutOfPlaneDistance(VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD)
{
  return 0.0;
}

// the Wilson vectors are the conversion from internal bond-distance derivative to Cartesian derivatives: d\phi\dr_{1,2}
void ReturnWilsonVectorsBond(VECTOR posA,VECTOR posB,VECTOR *wa,VECTOR *wb)
{
  VECTOR e12;
  REAL r12;

  e12.x=posA.x-posB.x;
  e12.y=posA.y-posB.y;
  e12.z=posA.z-posB.z;
  e12=ApplyBoundaryCondition(e12);
  r12=sqrt(SQR(e12.x)+SQR(e12.y)+SQR(e12.z));
  e12.x/=r12;
  e12.y/=r12;
  e12.z/=r12;

  wa->x=e12.x;
  wa->y=e12.y;
  wa->z=e12.z;
  wb->x=-e12.x;
  wb->y=-e12.y;
  wb->z=-e12.z;
}


// the Wilson vectors are the conversion from internal theta-angle derivative to Cartesian derivatives: d\phi\dr_{1,2,3}
void ReturnWilsonVectorsBend(VECTOR posA,VECTOR posB,VECTOR posC,VECTOR *wa,VECTOR *wb,VECTOR *wc)
{
  VECTOR dtA,dtB,dtC;
  VECTOR e12,e32;
  REAL r12,r32;
  REAL CosTheta,SinTheta;

  e12.x=posA.x-posB.x;
  e12.y=posA.y-posB.y;
  e12.z=posA.z-posB.z;
  e12=ApplyBoundaryCondition(e12);
  r12=sqrt(SQR(e12.x)+SQR(e12.y)+SQR(e12.z));
  e12.x/=r12;
  e12.y/=r12;
  e12.z/=r12;

  e32.x=posC.x-posB.x;
  e32.y=posC.y-posB.y;
  e32.z=posC.z-posB.z;
  e32=ApplyBoundaryCondition(e32);
  r32=sqrt(SQR(e32.x)+SQR(e32.y)+SQR(e32.z));
  e32.x/=r32;
  e32.y/=r32;
  e32.z/=r32;

  CosTheta=(e12.x*e32.x+e12.y*e32.y+e12.z*e32.z);
  SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));

  // Calculate the components of the derivatives.
  dtA.x=(CosTheta*e12.x-e32.x)/(r12*SinTheta);
  dtA.y=(CosTheta*e12.y-e32.y)/(r12*SinTheta);
  dtA.z=(CosTheta*e12.z-e32.z)/(r12*SinTheta);

  dtC.x=(CosTheta*e32.x-e12.x)/(r32*SinTheta);
  dtC.y=(CosTheta*e32.y-e12.y)/(r32*SinTheta);
  dtC.z=(CosTheta*e32.z-e12.z)/(r32*SinTheta);

  dtB.x=-(dtA.x+dtC.x);
  dtB.y=-(dtA.y+dtC.y);
  dtB.z=-(dtA.z+dtC.z);

  wa->x=dtA.x;
  wa->y=dtA.y;
  wa->z=dtA.z;

  wb->x=dtB.x;
  wb->y=dtB.y;
  wb->z=dtB.z;

  wc->x=dtC.x;
  wc->y=dtC.y;
  wc->z=dtC.z;
}

// the Wilson vectors are the conversion from internal phi-angle derivative to Cartesian derivatives: d\phi\dr_{1,2,3,4}
void ReturnWilsonVectorsTorsion(VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD,VECTOR *wa,VECTOR *wb,VECTOR *wc,VECTOR *wd)
{
  REAL CosTheta1,CosTheta2;
  REAL SinTheta1,SinTheta2;
  VECTOR e12,e23,e32,e34,e43;
  REAL r12,r23,r34,temp1,temp2;

  e12.x=posB.x-posA.x;
  e12.y=posB.y-posA.y;
  e12.z=posB.z-posA.z;
  e12=ApplyBoundaryCondition(e12);
  r12=sqrt(SQR(e12.x)+SQR(e12.y)+SQR(e12.z));
  e12.x/=r12;
  e12.y/=r12;
  e12.z/=r12;

  e23.x=posC.x-posB.x;
  e23.y=posC.y-posB.y;
  e23.z=posC.z-posB.z;
  e23=ApplyBoundaryCondition(e23);
  r23=sqrt(SQR(e23.x)+SQR(e23.y)+SQR(e23.z));
  e23.x/=r23;
  e23.y/=r23;
  e23.z/=r23;
  e32.x=-e23.x;
  e32.y=-e23.y;
  e32.z=-e23.z;

  e34.x=posD.x-posC.x;
  e34.y=posD.y-posC.y;
  e34.z=posD.z-posC.z;
  e34=ApplyBoundaryCondition(e34);
  r34=sqrt(SQR(e34.x)+SQR(e34.y)+SQR(e34.z));
  e34.x/=r34;
  e34.y/=r34;
  e34.z/=r34;
  e43.x=-e34.x;
  e43.y=-e34.y;
  e43.z=-e34.z;

  CosTheta1=(e12.x*e32.x+e12.y*e32.y+e12.z*e32.z);
  SinTheta1=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta1)));

  CosTheta2=(e23.x*e43.x+e23.y*e43.y+e23.z*e43.z);
  SinTheta2=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta2)));

  temp1=1.0/(r12*SQR(SinTheta1));
  wa->x=-temp1*(e12.y*e23.z-e12.z*e23.y);
  wa->y=-temp1*(e12.z*e23.x-e12.x*e23.z);
  wa->z=-temp1*(e12.x*e23.y-e12.y*e23.x);

  temp1=(r23-r12*CosTheta1)/(r23*r12*SQR(SinTheta1));
  temp2=CosTheta2/(r23*SQR(SinTheta2));
  wb->x=temp1*(e12.y*e23.z-e12.z*e23.y)+temp2*(e43.y*e32.z-e43.z*e32.y);
  wb->y=temp1*(e12.z*e23.x-e12.x*e23.z)+temp2*(e43.z*e32.x-e43.x*e32.z);
  wb->z=temp1*(e12.x*e23.y-e12.y*e23.x)+temp2*(e43.x*e32.y-e43.y*e32.x);

  temp1=(r23-r34*CosTheta2)/(r23*r34*SQR(SinTheta2));
  temp2=CosTheta1/(r23*SQR(SinTheta1));
  wc->x=temp1*(e43.y*e32.z-e43.z*e32.y)+temp2*(e12.y*e23.z-e12.z*e23.y);
  wc->y=temp1*(e43.z*e32.x-e43.x*e32.z)+temp2*(e12.z*e23.x-e12.x*e23.z);
  wc->z=temp1*(e43.x*e32.y-e43.y*e32.x)+temp2*(e12.x*e23.y-e12.y*e23.x);

  temp1=1.0/(r34*SQR(SinTheta2));
  wd->x=-temp1*(e43.y*e32.z-e43.z*e32.y);
  wd->y=-temp1*(e43.z*e32.x-e43.x*e32.z);
  wd->z=-temp1*(e43.x*e32.y-e43.y*e32.x);
}

void ReturnWilsonVectorsInversionBend(VECTOR posA,VECTOR posB,VECTOR posC,VECTOR posD,VECTOR *wa,VECTOR *wb,VECTOR *wc,VECTOR *wd)
{
  REAL rab,rbc,rbd;
  VECTOR cross_product_dc,cross_product_ad,cross_product_ca;
  REAL dot_product;
  REAL ThetaA,SinThetaA,CosThetaA,ChiA,CosChiA,TanChiA;
  REAL ThetaC,SinThetaC,CosThetaC,ChiC,CosChiC,TanChiC;
  REAL ThetaD,SinThetaD,CosThetaD,ChiD,CosChiD,TanChiD;
  VECTOR Dab,Dcb,Ddb;

  Dab.x=posA.x-posB.x;
  Dab.y=posA.y-posB.y;
  Dab.z=posA.z-posB.z;
  Dab=ApplyBoundaryCondition(Dab);
  rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
  Dab.x/=rab;
  Dab.y/=rab;
  Dab.z/=rab;

  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;

  Ddb.x=posD.x-posB.x;
  Ddb.y=posD.y-posB.y;
  Ddb.z=posD.z-posB.z;
  Ddb=ApplyBoundaryCondition(Ddb);
  rbd=sqrt(SQR(Ddb.x)+SQR(Ddb.y)+SQR(Ddb.z));
  Ddb.x/=rbd;
  Ddb.y/=rbd;
  Ddb.z/=rbd;

  ThetaA=ReturnBendAngle(posC,posB,posD);
  CosThetaA=cos(ReturnBendAngle(posC,posB,posD));
  SinThetaA=sin(ReturnBendAngle(posC,posB,posD));

  ThetaC=ReturnBendAngle(posA,posB,posD);
  CosThetaC=cos(ReturnBendAngle(posA,posB,posD));
  SinThetaC=sin(ReturnBendAngle(posA,posB,posD));

  ThetaD=ReturnBendAngle(posA,posB,posC);
  CosThetaD=cos(ReturnBendAngle(posA,posB,posC));
  SinThetaD=sin(ReturnBendAngle(posA,posB,posC));

  cross_product_dc.x=Ddb.y*Dcb.z-Ddb.z*Dcb.y;
  cross_product_dc.y=Ddb.z*Dcb.x-Ddb.x*Dcb.z;
  cross_product_dc.z=Ddb.x*Dcb.y-Ddb.y*Dcb.x;
  dot_product=cross_product_dc.x*Dab.x+cross_product_dc.y*Dab.y+cross_product_dc.z*Dab.z;
  ChiA=asin(dot_product/SinThetaA);
  CosChiA=cos(ChiA);
  TanChiA=tan(ChiA);

  cross_product_ad.x=Dab.y*Ddb.z-Dab.z*Ddb.y;
  cross_product_ad.y=Dab.z*Ddb.x-Dab.x*Ddb.z;
  cross_product_ad.z=Dab.x*Ddb.y-Dab.y*Ddb.x;
  dot_product=cross_product_ad.x*Dcb.x+cross_product_ad.y*Dcb.y+cross_product_ad.z*Dcb.z;
  ChiC=asin(dot_product/sin(ReturnBendAngle(posA,posB,posD)));
  CosChiC=cos(ChiC);
  TanChiC=tan(ChiC);

  cross_product_ca.x=Dcb.y*Dab.z-Dcb.z*Dab.y;
  cross_product_ca.y=Dcb.z*Dab.x-Dcb.x*Dab.z;
  cross_product_ca.z=Dcb.x*Dab.y-Dcb.y*Dab.x;
  dot_product=cross_product_ca.x*Ddb.x+cross_product_ca.y*Ddb.y+cross_product_ca.z*Ddb.z;
  ChiD=asin(dot_product/sin(ReturnBendAngle(posA,posB,posC)));
  CosChiD=cos(ChiD);
  TanChiD=tan(ChiD);

  wa->x=(cross_product_dc.x/(CosChiA*SinThetaA)-Dab.x*TanChiA)/(3.0*rab);
  wa->y=(cross_product_dc.y/(CosChiA*SinThetaA)-Dab.y*TanChiA)/(3.0*rab);
  wa->z=(cross_product_dc.z/(CosChiA*SinThetaA)-Dab.z*TanChiA)/(3.0*rab);

  wc->x=(cross_product_ad.x/(CosChiA*SinThetaA)-(TanChiA/(SQR(SinThetaA)))*(Dcb.x-Ddb.x*CosThetaA))/(3.0*rbc);
  wc->y=(cross_product_ad.y/(CosChiA*SinThetaA)-(TanChiA/(SQR(SinThetaA)))*(Dcb.y-Ddb.y*CosThetaA))/(3.0*rbc);
  wc->z=(cross_product_ad.z/(CosChiA*SinThetaA)-(TanChiA/(SQR(SinThetaA)))*(Dcb.z-Ddb.z*CosThetaA))/(3.0*rbc);

  wd->x=(cross_product_ca.x/(CosChiA*SinThetaA)-(TanChiA/(SQR(SinThetaA)))*(Ddb.x-Dcb.x*CosThetaA))/(3.0*rbd);
  wd->y=(cross_product_ca.y/(CosChiA*SinThetaA)-(TanChiA/(SQR(SinThetaA)))*(Ddb.y-Dcb.y*CosThetaA))/(3.0*rbd);
  wd->z=(cross_product_ca.z/(CosChiA*SinThetaA)-(TanChiA/(SQR(SinThetaA)))*(Ddb.z-Dcb.z*CosThetaA))/(3.0*rbd);


  wc->x+=(cross_product_ad.x/(CosChiC*SinThetaC)-Dcb.x*TanChiC)/(3.0*rbc);
  wc->y+=(cross_product_ad.y/(CosChiC*SinThetaC)-Dcb.y*TanChiC)/(3.0*rbc);
  wc->z+=(cross_product_ad.z/(CosChiC*SinThetaC)-Dcb.z*TanChiC)/(3.0*rbc);

  wd->x+=(cross_product_ca.x/(CosChiC*SinThetaC)-(TanChiC/(SQR(SinThetaC)))*(Ddb.x-Dab.x*CosThetaC))/(3.0*rbd);
  wd->y+=(cross_product_ca.y/(CosChiC*SinThetaC)-(TanChiC/(SQR(SinThetaC)))*(Ddb.y-Dab.y*CosThetaC))/(3.0*rbd);
  wd->z+=(cross_product_ca.z/(CosChiC*SinThetaC)-(TanChiC/(SQR(SinThetaC)))*(Ddb.z-Dab.z*CosThetaC))/(3.0*rbd);

  wa->x+=(cross_product_dc.x/(CosChiC*SinThetaC)-(TanChiC/(SQR(SinThetaC)))*(Dab.x-Ddb.x*CosThetaC))/(3.0*rab);
  wa->y+=(cross_product_dc.y/(CosChiC*SinThetaC)-(TanChiC/(SQR(SinThetaC)))*(Dab.y-Ddb.y*CosThetaC))/(3.0*rab);
  wa->z+=(cross_product_dc.z/(CosChiC*SinThetaC)-(TanChiC/(SQR(SinThetaC)))*(Dab.z-Ddb.z*CosThetaC))/(3.0*rab);


  wd->x+=(cross_product_ca.x/(CosChiD*SinThetaD)-Ddb.x*TanChiD)/(3.0*rbd);
  wd->y+=(cross_product_ca.y/(CosChiD*SinThetaD)-Ddb.y*TanChiD)/(3.0*rbd);
  wd->z+=(cross_product_ca.z/(CosChiD*SinThetaD)-Ddb.z*TanChiD)/(3.0*rbd);

  wa->x+=(cross_product_dc.x/(CosChiD*SinThetaD)-(TanChiD/(SQR(SinThetaD)))*(Dab.x-Dcb.x*CosThetaD))/(3.0*rab);
  wa->y+=(cross_product_dc.y/(CosChiD*SinThetaD)-(TanChiD/(SQR(SinThetaD)))*(Dab.y-Dcb.y*CosThetaD))/(3.0*rab);
  wa->z+=(cross_product_dc.z/(CosChiD*SinThetaD)-(TanChiD/(SQR(SinThetaD)))*(Dab.z-Dcb.z*CosThetaD))/(3.0*rab);

  wc->x+=(cross_product_ad.x/(CosChiD*SinThetaD)-(TanChiD/(SQR(SinThetaD)))*(Dcb.x-Dab.x*CosThetaD))/(3.0*rbc);
  wc->y+=(cross_product_ad.y/(CosChiD*SinThetaD)-(TanChiD/(SQR(SinThetaD)))*(Dcb.y-Dab.y*CosThetaD))/(3.0*rbc);
  wc->z+=(cross_product_ad.z/(CosChiD*SinThetaD)-(TanChiD/(SQR(SinThetaD)))*(Dcb.z-Dab.z*CosThetaD))/(3.0*rbc);




  wb->x=-(wa->x+wc->x+wd->x);
  wb->y=-(wa->y+wc->y+wd->y);
  wb->z=-(wa->z+wc->z+wd->z);
}

// Calculate Bondforce
void CalculateAdsorbateBondForce(int m)
{
  int i,Type,NumberOfBonds,A,B;
  REAL U,DF,r,rr,temp,temp2,exp_term,r1;
  REAL *parms;
  POINT posA,posB;
  VECTOR dr,f;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfBonds=Components[Type].NumberOfBonds;
  for(i=0;i<NumberOfBonds;i++)
  {
    A=Components[Type].Bonds[i].A;
    B=Components[Type].Bonds[i].B;

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;

    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    parms=(REAL*)&Components[Type].BondArguments[i];

    switch(Components[Type].BondType[i])
    {
      case HARMONIC_BOND:
        // 0.5*p0*SQR(r-p1);
        // ===============================================
        // p_0/k_B [K/A^2]   force constant
        // p_1     [A]       reference bond distance
        U=0.5*parms[0]*SQR(r-parms[1]);
        DF=parms[0]*(r-parms[1])/r;
        break;
      case CORE_SHELL_SPRING:
        U=0.5*parms[0]*SQR(r);
        DF=parms[0];
        break;
      case MORSE_BOND:
        // p_0*[(1.0-{exp(-p_1*(r-p_2))})^2-1.0]
        // ===============================================
        // p_0/k_B [K]       force constant
        // p_1     [A^-1]    parameter
        // p_2     [A]       reference bond distance
        temp=exp(parms[1]*(parms[2]-r));
        U=parms[0]*(SQR(1.0-temp)-1.0);
        DF=2.0*parms[0]*parms[1]*(1.0-temp)*temp/r;
        break;
      case LJ_12_6_BOND:
        // A/r_ij^12-B/r_ij^6
        // ===============================================
        // p_0/k_B [K A^12]
        // p_1/k_B [K A^6]
        temp=CUBE(1.0/rr);
        U=parms[0]*SQR(temp)-parms[1]*temp;
        DF=6.0*(parms[1]*temp-2.0*parms[0]*SQR(temp))/rr;
        break;
      case LENNARD_JONES_BOND:
        // 4*p_0*((p_1/r)^12-(p_1/r)^6)
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A]
        temp=CUBE(parms[1]/rr);
        U=4.0*parms[0]*(temp*(temp-1.0));
        DF=24.0*parms[0]*(temp*(1.0-2.0*temp))/rr;
        break;
      case BUCKINGHAM_BOND:
        // p_0*exp(-p_1 r)-p_2/r^6
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A^-1]
        // p_2/k_B [K A^6]
        temp=parms[2]*CUBE(1.0/rr);
        exp_term=parms[0]*exp(-parms[1]*r);
        U=-temp+exp_term;
        DF=(6.0/rr)*temp-parms[1]*exp_term/r;
        break;
      case RESTRAINED_HARMONIC_BOND:
        // 0.5*p_0*(r-p_1)^2                   |r-p_1|<=p_2
        // 0.5*p_0*p_2^2+p_0*p_2*(|r-p_1|-p_2) |r-p_1|>p_2
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2     [A]
        r1=r-parms[1];
        U=0.5*parms[0]*SQR(MIN2(fabs(r1),parms[2]))
              +parms[0]*parms[2]*MAX2(fabs(r1)-parms[2],(REAL)0.0);
        DF=-parms[0]*(SIGN(MIN2(fabs(r1),parms[2]),r1))/r;
        break;
      case QUARTIC_BOND:
        // (1/2)*p_0*(r-p_1)^2+(1/3)*p_2*(r-p_1)^3+(1/4)*p_3*(r-p_1)^4
        // ===========================================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
        DF=temp*(parms[0]+parms[2]*temp+parms[3]*temp2)/r;
        break;
      case CFF_QUARTIC_BOND:
        // p_0*(r-p_1)^2+p_2*(r-p_1)^3+p_3*(r-p_1)^4
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
        DF=temp*(2.0*parms[0]+3.0*parms[2]*temp+4.0*parms[3]*temp2)/r;
        break;
      case MM3_BOND:
        // p_0*(r-p_1)^2*(1.0-2.55*(r-p_1)+(7.0/12.0)*2.55^2*(r-p_1)^2)
        // =================================================================
        // p_0     [mdyne/A molecule]
        // p_1     [A]
        temp=r-parms[1];
        temp2=SQR(temp);
        U=parms[0]*temp2*(1.0-2.55*temp+(7.0/12.0)*SQR(2.55)*temp2);
        DF=parms[0]*(2.0+2.55*(4.0*2.55*(7.0/12.0)*temp-3.0)*temp)*temp/r;
        break;
      case RIGID_BOND:
        U=DF=0.0;
        break;
      case FIXED_BOND:
        U=DF=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Bond potential in routine 'CalculateAdsorbateBondForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // add contribution to the Adsorbate stretch energy
    UAdsorbateBond[CurrentSystem]+=U;

    // forces are oppositely directed to the gradient
    f.x=-DF*dr.x;
    f.y=-DF*dr.y;
    f.z=-DF*dr.z;

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=f.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=f.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=f.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=f.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=f.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=f.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
    StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
    StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;

    StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
    StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
    StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;

    StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
    StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
    StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
  }
}

// Calculate Bondforce
void CalculateCationBondForce(int m)
{
  int i,Type,NumberOfBonds,A,B;
  REAL U,DF,r,rr,temp,temp2,exp_term,r1;
  REAL *parms;
  POINT posA,posB;
  VECTOR dr,f;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfBonds=Components[Type].NumberOfBonds;
  for(i=0;i<NumberOfBonds;i++)
  {
    A=Components[Type].Bonds[i].A;
    B=Components[Type].Bonds[i].B;

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;

    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    parms=(REAL*)&Components[Type].BondArguments[i];

    switch(Components[Type].BondType[i])
    {
      case HARMONIC_BOND:
        // 0.5*p0*SQR(r-p1);
        // ===============================================
        // p_0/k_B [K/A^2]   force constant
        // p_1     [A]       reference bond distance
        U=0.5*parms[0]*SQR(r-parms[1]);
        DF=parms[0]*(r-parms[1])/r;
        break;
      case CORE_SHELL_SPRING:
        U=0.5*parms[0]*SQR(r);
        DF=parms[0];
        break;
      case MORSE_BOND:
        // p_0*[(1.0-{exp(-p_1*(r-p_2))})^2-1.0]
        // ===============================================
        // p_0/k_B [K]       force constant
        // p_1     [A^-1]    parameter
        // p_2     [A]       reference bond distance
        temp=exp(parms[1]*(parms[2]-r));
        U=parms[0]*(SQR(1.0-temp)-1.0);
        DF=2.0*parms[0]*parms[1]*(1.0-temp)*temp/r;
        break;
      case LJ_12_6_BOND:
        // A/r_ij^12-B/r_ij^6
        // ===============================================
        // p_0/k_B [K A^12]
        // p_1/k_B [K A^6]
        temp=CUBE(1.0/rr);
        U=parms[0]*SQR(temp)-parms[1]*temp;
        DF=6.0*(parms[1]*temp-2.0*parms[0]*SQR(temp))/rr;
        break;
      case LENNARD_JONES_BOND:
        // 4*p_0*((p_1/r)^12-(p_1/r)^6)
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A]
        temp=CUBE(parms[1]/rr);
        U=4.0*parms[0]*(temp*(temp-1.0));
        DF=24.0*parms[0]*(temp*(1.0-2.0*temp))/rr;
        break;
      case BUCKINGHAM_BOND:
        // p_0*exp(-p_1 r)-p_2/r^6
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A^-1]
        // p_2/k_B [K A^6]
        temp=parms[2]*CUBE(1.0/rr);
        exp_term=parms[0]*exp(-parms[1]*r);
        U=-temp+exp_term;
        DF=(6.0/rr)*temp-parms[1]*exp_term/r;
        break;
      case RESTRAINED_HARMONIC_BOND:
        // 0.5*p_0*(r-p_1)^2                   |r-p_1|<=p_2
        // 0.5*p_0*p_2^2+p_0*p_2*(|r-p_1|-p_2) |r-p_1|>p_2
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2     [A]
        r1=r-parms[1];
        U=0.5*parms[0]*SQR(MIN2(fabs(r1),parms[2]))
              +parms[0]*parms[2]*MAX2(fabs(r1)-parms[2],(REAL)0.0);
        DF=-parms[0]*(SIGN(MIN2(fabs(r1),parms[2]),r1))/r;
        break;
      case QUARTIC_BOND:
        // (1/2)*p_0*(r-p_1)^2+(1/3)*p_2*(r-p_1)^3+(1/4)*p_3*(r-p_1)^4
        // ===========================================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
        DF=temp*(parms[0]+parms[2]*temp+parms[3]*temp2)/r;
        break;
      case CFF_QUARTIC_BOND:
        // p_0*(r-p_1)^2+p_2*(r-p_1)^3+p_3*(r-p_1)^4
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
        DF=temp*(2.0*parms[0]+3.0*parms[2]*temp+4.0*parms[3]*temp2)/r;
        break;
      case MM3_BOND:
        // p_0*(r-p_1)^2*(1.0-2.55*(r-p_1)+(7.0/12.0)*2.55^2*(r-p_1)^2)
        // =================================================================
        // p_0     [mdyne/A molecule]
        // p_1     [A]
        temp=r-parms[1];
        temp2=SQR(temp);
        U=parms[0]*temp2*(1.0-2.55*temp+(7.0/12.0)*SQR(2.55)*temp2);
        DF=parms[0]*(2.0+2.55*(4.0*2.55*(7.0/12.0)*temp-3.0)*temp)*temp/r;
        break;
      case RIGID_BOND:
        U=DF=0.0;
        break;
      case FIXED_BOND:
        U=DF=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Bond potential in routine 'CalculateCationBondForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // add contribution to the Cation stretch energy
    UCationBond[CurrentSystem]+=U;

    // forces are oppositely directed to the gradient
    f.x=-DF*dr.x;
    f.y=-DF*dr.y;
    f.z=-DF*dr.z;

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x+=f.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=f.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=f.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=f.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y-=f.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z-=f.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
    StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
    StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;

    StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
    StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
    StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;

    StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
    StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
    StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
  }
}

// Calculate Urey-Bradley force
void CalculateAdsorbateUreyBradleyForce(int m)
{
  int i,Type,NumberOfUreyBradleys,A,C;
  REAL U,DF,r,rr,temp,temp2,exp_term,r1;
  REAL *parms;
  POINT posA,posC;
  VECTOR dr,f;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfUreyBradleys=Components[Type].NumberOfUreyBradleys;
  for(i=0;i<NumberOfUreyBradleys;i++)
  {
    A=Components[Type].UreyBradleys[i].A;
    C=Components[Type].UreyBradleys[i].C;

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;

    dr.x=posA.x-posC.x;
    dr.y=posA.y-posC.y;
    dr.z=posA.z-posC.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    parms=(REAL*)&Components[Type].UreyBradleyArguments[i];

    switch(Components[Type].UreyBradleyType[i])
    {
      case HARMONIC_UREYBRADLEY:
        // 0.5*p0*SQR(r-p1);
        // ===============================================
        // p_0/k_B [K/A^2]   force constant
        // p_1     [A]       reference bond distance
        U=0.5*parms[0]*SQR(r-parms[1]);
        DF=parms[0]*(r-parms[1])/r;
        break;
      case MORSE_UREYBRADLEY:
        // p_0*[(1.0-{exp(-p_1*(r-p_2))})^2-1.0]
        // ===============================================
        // p_0/k_B [K]       force constant
        // p_1     [A^-1]    parameter
        // p_2     [A]       reference bond distance
        temp=exp(parms[1]*(parms[2]-r));
        U=parms[0]*(SQR(1.0-temp)-1.0);
        DF=2.0*parms[0]*parms[1]*(1.0-temp)*temp/r;
        break;
      case LJ_12_6_UREYBRADLEY:
        // A/r_ij^12-B/r_ij^6
        // ===============================================
        // p_0/k_B [K A^12]
        // p_1/k_B [K A^6]
        temp=CUBE(1.0/rr);
        U=parms[0]*SQR(temp)-parms[1]*temp;
        DF=6.0*(parms[1]*temp-2.0*parms[0]*SQR(temp))/rr;
        break;
      case LENNARD_JONES_UREYBRADLEY:
        // 4*p_0*((p_1/r)^12-(p_1/r)^6)
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A]
        temp=CUBE(parms[1]/rr);
        U=4.0*parms[0]*(temp*(temp-1.0));
        DF=24.0*parms[0]*(temp*(1.0-2.0*temp))/rr;
        break;
      case BUCKINGHAM_UREYBRADLEY:
        // p_0*exp(-p_1 r)-p_2/r^6
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A^-1]
        // p_2/k_B [K A^6]
        temp=parms[2]*CUBE(1.0/rr);
        exp_term=parms[0]*exp(-parms[1]*r);
        U=-temp+exp_term;
        DF=(6.0/rr)*temp-parms[1]*exp_term/r;
        break;
      case RESTRAINED_HARMONIC_UREYBRADLEY:
        // 0.5*p_0*(r-p_1)^2                   |r-p_1|<=p_2
        // 0.5*p_0*p_2^2+p_0*p_2*(|r-p_1|-p_2) |r-p_1|>p_2
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2     [A]
        r1=r-parms[1];
        U=0.5*parms[0]*SQR(MIN2(fabs(r1),parms[2]))
              +parms[0]*parms[2]*MAX2(fabs(r1)-parms[2],(REAL)0.0);
        DF=-parms[0]*(SIGN(MIN2(fabs(r1),parms[2]),r1))/r;
        break;
      case QUARTIC_UREYBRADLEY:
        // (1/2)*p_0*(r-p_1)^2+(1/3)*p_2*(r-p_1)^3+(1/4)*p_3*(r-p_1)^4
        // ===========================================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
        DF=temp*(parms[0]+parms[2]*temp+parms[3]*temp2)/r;
        break;
      case CFF_QUARTIC_UREYBRADLEY:
        // p_0*(r-p_1)^2+p_2*(r-p_1)^3+p_3*(r-p_1)^4
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
        DF=temp*(2.0*parms[0]+3.0*parms[2]*temp+4.0*parms[3]*temp2)/r;
        break;
      case MM3_UREYBRADLEY:
        // p_0*(r-p_1)^2*(1.0-2.55*(r-p_1)+(7.0/12.0)*2.55^2*(r-p_1)^2)
        // =================================================================
        // p_0     [mdyne/A molecule]
        // p_1     [A]
        temp=r-parms[1];
        temp2=SQR(temp);
        U=parms[0]*temp2*(1.0-2.55*temp+(7.0/12.0)*SQR(2.55)*temp2);
        DF=parms[0]*(2.0+2.55*(4.0*2.55*(7.0/12.0)*temp-3.0)*temp)*temp/r;
        break;
      case RIGID_UREYBRADLEY:
        U=DF=0.0;
        break;
      case FIXED_UREYBRADLEY:
        U=DF=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Urey-Bradley potential in routine 'CalculateAdsorbateUreyBradleyForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // add contribution to the Adsorbate Urey-Bradley energy
    UAdsorbateUreyBradley[CurrentSystem]+=U;

    // forces are oppositely directed to the gradient
    f.x=-DF*dr.x;
    f.y=-DF*dr.y;
    f.z=-DF*dr.z;

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=f.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=f.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=f.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x-=f.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y-=f.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z-=f.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
    StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
    StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;

    StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
    StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
    StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;

    StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
    StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
    StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
  }
}

// Calculate Urey-Bradley force
void CalculateCationUreyBradleyForce(int m)
{
  int i,Type,NumberOfUreyBradleys,A,C;
  REAL U,DF,r,rr,temp,temp2,exp_term,r1;
  REAL *parms;
  POINT posA,posC;
  VECTOR dr,f;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfUreyBradleys=Components[Type].NumberOfUreyBradleys;
  for(i=0;i<NumberOfUreyBradleys;i++)
  {
    A=Components[Type].UreyBradleys[i].A;
    C=Components[Type].UreyBradleys[i].C;

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;

    dr.x=posA.x-posC.x;
    dr.y=posA.y-posC.y;
    dr.z=posA.z-posC.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    parms=(REAL*)&Components[Type].UreyBradleyArguments[i];

    switch(Components[Type].UreyBradleyType[i])
    {
      case HARMONIC_UREYBRADLEY:
        // 0.5*p0*SQR(r-p1);
        // ===============================================
        // p_0/k_B [K/A^2]   force constant
        // p_1     [A]       reference bond distance
        U=0.5*parms[0]*SQR(r-parms[1]);
        DF=parms[0]*(r-parms[1])/r;
        break;
      case MORSE_UREYBRADLEY:
        // p_0*[(1.0-{exp(-p_1*(r-p_2))})^2-1.0]
        // ===============================================
        // p_0/k_B [K]       force constant
        // p_1     [A^-1]    parameter
        // p_2     [A]       reference bond distance
        temp=exp(parms[1]*(parms[2]-r));
        U=parms[0]*(SQR(1.0-temp)-1.0);
        DF=2.0*parms[0]*parms[1]*(1.0-temp)*temp/r;
        break;
      case LJ_12_6_UREYBRADLEY:
        // A/r_ij^12-B/r_ij^6
        // ===============================================
        // p_0/k_B [K A^12]
        // p_1/k_B [K A^6]
        temp=CUBE(1.0/rr);
        U=parms[0]*SQR(temp)-parms[1]*temp;
        DF=6.0*(parms[1]*temp-2.0*parms[0]*SQR(temp))/rr;
        break;
      case LENNARD_JONES_UREYBRADLEY:
        // 4*p_0*((p_1/r)^12-(p_1/r)^6)
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A]
        temp=CUBE(parms[1]/rr);
        U=4.0*parms[0]*(temp*(temp-1.0));
        DF=24.0*parms[0]*(temp*(1.0-2.0*temp))/rr;
        break;
      case BUCKINGHAM_UREYBRADLEY:
        // p_0*exp(-p_1 r)-p_2/r^6
        // ===============================================
        // p_0/k_B [K]
        // p_1     [A^-1]
        // p_2/k_B [K A^6]
        temp=parms[2]*CUBE(1.0/rr);
        exp_term=parms[0]*exp(-parms[1]*r);
        U=-temp+exp_term;
        DF=(6.0/rr)*temp-parms[1]*exp_term/r;
        break;
      case RESTRAINED_HARMONIC_UREYBRADLEY:
        // 0.5*p_0*(r-p_1)^2                   |r-p_1|<=p_2
        // 0.5*p_0*p_2^2+p_0*p_2*(|r-p_1|-p_2) |r-p_1|>p_2
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2     [A]
        r1=r-parms[1];
        U=0.5*parms[0]*SQR(MIN2(fabs(r1),parms[2]))
              +parms[0]*parms[2]*MAX2(fabs(r1)-parms[2],(REAL)0.0);
        DF=-parms[0]*(SIGN(MIN2(fabs(r1),parms[2]),r1))/r;
        break;
      case QUARTIC_UREYBRADLEY:
        // (1/2)*p_0*(r-p_1)^2+(1/3)*p_2*(r-p_1)^3+(1/4)*p_3*(r-p_1)^4
        // ===========================================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
        DF=temp*(parms[0]+parms[2]*temp+parms[3]*temp2)/r;
        break;
      case CFF_QUARTIC_UREYBRADLEY:
        // p_0*(r-p_1)^2+p_2*(r-p_1)^3+p_3*(r-p_1)^4
        // ===============================================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2/k_B [K/A^3]
        // p_3/k_B [K/A^4]
        temp=r-parms[1];
        temp2=SQR(r-parms[1]);
        U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
        DF=temp*(2.0*parms[0]+3.0*parms[2]*temp+4.0*parms[3]*temp2)/r;
        break;
      case MM3_UREYBRADLEY:
        // p_0*(r-p_1)^2*(1.0-2.55*(r-p_1)+(7.0/12.0)*2.55^2*(r-p_1)^2)
        // =================================================================
        // p_0     [mdyne/A molecule]
        // p_1     [A]
        temp=r-parms[1];
        temp2=SQR(temp);
        U=parms[0]*temp2*(1.0-2.55*temp+(7.0/12.0)*SQR(2.55)*temp2);
        DF=parms[0]*(2.0+2.55*(4.0*2.55*(7.0/12.0)*temp-3.0)*temp)*temp/r;
        break;
      case RIGID_UREYBRADLEY:
        U=DF=0.0;
        break;
      case FIXED_UREYBRADLEY:
        U=DF=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Urey-Bradley potential in routine 'CalculateCationUreyBradleyForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // add contribution to the Cation Urey-Bradley energy
    UCationUreyBradley[CurrentSystem]+=U;

    // forces are oppositely directed to the gradient
    f.x=-DF*dr.x;
    f.y=-DF*dr.y;
    f.z=-DF*dr.z;

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x+=f.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=f.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=f.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x-=f.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y-=f.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z-=f.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
    StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
    StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;

    StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
    StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
    StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;

    StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
    StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
    StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
  }
}


void CalculateAdsorbateBendForce(int m)
{
  int Type,NumberOfBends;
  int i,A,B,C,D;
  REAL *parms,DF,U,temp,temp2;
  REAL CosTheta,Theta,SinTheta;
  REAL rab,rbc,rac,DTDX;
  VECTOR posA,posB,posC,posD;
  VECTOR Rab,Rbc,Rac,fa,fb,fc,dtA,dtB,dtC;;
  VECTOR Rad,Rbd,Rcd,t,ip,ap,cp;
  REAL rt2,rap2,rcp2;
  REAL terma,termc,delta,delta2,rm,ptrt2,term;
  VECTOR dpdia,dpdic,dedip,fd,n;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfBends=Components[Type].NumberOfBends;
  for(i=0;i<NumberOfBends;i++)
  {
    A=Components[Type].Bends[i].A;
    B=Components[Type].Bends[i].B;
    C=Components[Type].Bends[i].C;
    D=Components[Type].Bends[i].D;
    parms=Components[Type].BendArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Rab.x=Rab.y=Rab.z=0.0;
    Rcd.x=Rcd.y=Rcd.z=0.0;
    Rbd.x=Rbd.y=Rbd.z=0.0;
    Rad.x=Rad.y=Rad.z=0.0;
    Rbc.x=Rbc.y=Rbc.z=0.0;
    ap.x=ap.y=ap.z=0.0;
    cp.x=cp.y=cp.z=0.0;
    t.x=t.y=t.z=0.0;
    delta=rcp2=rap2=rt2=rab=rbc=temp=0.0;
    switch(Components[Type].BendType[i])
    {
      case MM3_IN_PLANE_BEND:
        Rad.x=posA.x-posD.x;
        Rad.y=posA.y-posD.y;
        Rad.z=posA.z-posD.z;

        Rbd.x=posB.x-posD.x;
        Rbd.y=posB.y-posD.y;
        Rbd.z=posB.z-posD.z;

        Rcd.x=posC.x-posD.x;
        Rcd.y=posC.y-posD.y;
        Rcd.z=posC.z-posD.z;

        t.x=Rad.y*Rcd.z-Rad.z*Rcd.y;
        t.y=Rad.z*Rcd.x-Rad.x*Rcd.z;
        t.z=Rad.x*Rcd.y-Rad.y*Rcd.x;
        rt2=t.x*t.x+t.y*t.y+t.z*t.z;
        delta=-(t.x*Rbd.x+t.y*Rbd.y+t.z*Rbd.z)/rt2;

        ip.x=posB.x+t.x*delta;
        ip.y=posB.y+t.y*delta;
        ip.z=posB.z+t.z*delta;
        ap.x=posA.x-ip.x;
        ap.y=posA.y-ip.y;
        ap.z=posA.z-ip.z;
        cp.x=posC.x-ip.x;
        cp.y=posC.y-ip.y;
        cp.z=posC.z-ip.z;
        ap=ApplyBoundaryCondition(ap);
        cp=ApplyBoundaryCondition(cp);

        rap2=ap.x*ap.x+ap.y*ap.y+ap.z*ap.z;
        rcp2=cp.x*cp.x+cp.y*cp.y+cp.z*cp.z;

        CosTheta=(ap.x*cp.x+ap.y*cp.y+ap.z*cp.z)/sqrt(rap2*rcp2);
        break;
      default:
        Rab.x=posA.x-posB.x;
        Rab.y=posA.y-posB.y;
        Rab.z=posA.z-posB.z;
        rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
        Rab.x/=rab;
        Rab.y/=rab;
        Rab.z/=rab;

        Rbc.x=posC.x-posB.x;
        Rbc.y=posC.y-posB.y;
        Rbc.z=posC.z-posB.z;
        rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
        Rbc.x/=rbc;
        Rbc.y/=rbc;
        Rbc.z/=rbc;

        Rac.x=posC.x-posA.x;
        Rac.y=posC.y-posA.y;
        Rac.z=posC.z-posA.z;
        rac=sqrt(SQR(Rac.x)+SQR(Rac.y)+SQR(Rac.z));
        Rac.x/=rac;
        Rac.y/=rac;
        Rac.z/=rac;

        CosTheta=(Rab.x*Rbc.x+Rab.y*Rbc.y+Rab.z*Rbc.z);
        break;
    }

    CosTheta=MIN2(1.0,MAX2(-1.0,CosTheta));
    Theta=acos(CosTheta);
    SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));
    DTDX=-1.0/sqrt(1.0-SQR(CosTheta));

    switch(Components[Type].BendType[i])
    {
      case HARMONIC_BEND:
        // (1/2)p_0*(theta-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(Theta-parms[1]);
        DF=parms[0]*(Theta-parms[1])*DTDX;
        break;
      case CORE_SHELL_BEND:
        // (1/2)p_0*(theta-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(Theta-parms[1]);
        DF=parms[0]*(Theta-parms[1])*DTDX;
        break;
      case QUARTIC_BEND:
        // (1/2)p_0*(theta-p_1)^2+(1/3)*p_2*(theta-p_1)^3+(1/4)*p_2*(theta-p_1)^4
        // ======================================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2/k_B [K/rad^3]
        // p_3/k_B [K/rad^4]
        temp=(Theta-parms[1]);
        temp2=SQR(temp);
        U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
        DF=(parms[0]*temp+parms[2]*temp2+parms[3]*temp*temp2)*DTDX;
        break;
      case CFF_QUARTIC_BEND:
        // p_0*(theta-p_1)^2+p_2*(theta-p_1)^3+p_3*(theta-p_1)^4
        // =====================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2/k_B [K/rad^3]
        // p_3/k_B [K/rad^4]
        temp=(Theta-parms[1]);
        temp2=SQR(temp);
        U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
        DF=(2.0*parms[0]*temp+3.0*parms[2]*temp2+4.0*parms[3]*temp*temp2)*DTDX;
        break;
      case HARMONIC_COSINE_BEND:
        // (1/2)*p_0*(cos(theta)-cos(p_1))^2
        // ===============================================
        // p_0/k_B [K]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(CosTheta-parms[1]);
        DF=parms[0]*(CosTheta-parms[1]);
        break;
      case COSINE_BEND:
        // p_0*(1+cos(p_1*theta-p_2))
        // ===============================================
        // p_0/k_B [K]
        // p_1     [-]
        // p_2     [degrees]
        temp=parms[1]*Theta-parms[2];
        U=parms[0]*(1.0+cos(temp));
        DF=-(parms[0]*parms[1]*sin(temp))*DTDX;
        break;
      case TAFIPOLSKY_BEND:
        // 0.5*p_0*(1+cos(theta))*(1+cos(2*theta))
        // ===============================================
        // p_0/k_B [K]
        U=0.5*parms[0]*(1.0+cos(Theta))*(1.0+cos(2.0*Theta));
        DF=parms[0]*CosTheta*(2.0+3.0*CosTheta);
        break;
      case MM3_BEND:
      case MM3_IN_PLANE_BEND:
        // p_0*(theta-p_1)^2(1-0.014*(theta-p_1)+5.6e-5*(theta-p_1)^2-7e-7*(theta-p_1)^3+2.2e-8(theta-p_1)^4)
        // =================================================================================================
        // p_0/k_B [mdyne A/rad^2]
        // p_1     [degrees]
        U=DF=0;
        temp=RAD2DEG*(Theta-parms[1]);
        temp2=SQR(temp);
        U=parms[0]*temp2*(1.0-0.014*temp+5.6e-5*temp2-7.0e-7*temp*temp2+2.2e-8*SQR(temp2));
        DF=parms[0]*RAD2DEG*(2.0-(3.0*0.014-(4.0*5.6e-5-(5.0*7.0e-7-6.0*2.2e-8*temp)*temp)*temp)*temp)*temp*DTDX;
        break;
      case FIXED_BEND:
        U=DF=0.0;
        break;
      case MEASURE_BEND:
        U=DF=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Bend potential in routine 'CalculateFrameworkBendForce' ('framework_force.c')\n");
        exit(0);
        break;
    }

    // add contribution to the energy
    UAdsorbateBend[CurrentSystem]+=U;

    switch(Components[Type].BendType[i])
    {
      case MM3_IN_PLANE_BEND:
        DF=parms[0]*RAD2DEG*(2.0-(3.0*0.014-(4.0*5.6e-5-(5.0*7.0e-7-6.0*2.2e-8*temp)*temp)*temp)*temp)*temp;
        n.x=cp.y*ap.z-cp.z*ap.y;
        n.y=cp.z*ap.x-cp.x*ap.z;
        n.z=cp.x*ap.y-cp.y*ap.x;
        rm=sqrt(n.x*n.x+n.y*n.y+n.z*n.z);
        rm=MAX2(rm,0.000001);

        terma=-DF/(rap2*rm);
        termc=DF/(rcp2*rm);
        fa.x=terma*(ap.y*n.z-ap.z*n.y);
        fa.y=terma*(ap.z*n.x-ap.x*n.z);
        fa.z=terma*(ap.x*n.y-ap.y*n.x);
        fc.x=termc*(cp.y*n.z-cp.z*n.y);
        fc.y=termc*(cp.z*n.x-cp.x*n.z);
        fc.z=termc*(cp.x*n.y-cp.y*n.x);
        dedip.x=-(fa.x+fc.x);
        dedip.y=-(fa.y+fc.y);
        dedip.z=-(fa.z+fc.z);

        delta2=2.0*delta;
        ptrt2=(dedip.x*t.x+dedip.y*t.y+dedip.z*t.z)/rt2;

        term=(Rcd.z*Rbd.y-Rcd.y*Rbd.z)+delta2*(t.y*Rcd.z-t.z*Rcd.y);
        dpdia.x=delta*(Rcd.y*dedip.z-Rcd.z*dedip.y)+term*ptrt2;

        term=(Rcd.x*Rbd.z-Rcd.z*Rbd.x)+delta2*(t.z*Rcd.x-t.x*Rcd.z);
        dpdia.y=delta*(Rcd.z*dedip.x-Rcd.x*dedip.z)+term*ptrt2;

        term=(Rcd.y*Rbd.x-Rcd.x*Rbd.y)+delta2*(t.x*Rcd.y-t.y*Rcd.x);
        dpdia.z=delta*(Rcd.x*dedip.y-Rcd.y*dedip.x)+term*ptrt2;

        term=(Rad.y*Rbd.z-Rad.z*Rbd.y)+delta2*(t.z*Rad.y-t.y*Rad.z);
        dpdic.x=delta*(Rad.z*dedip.y-Rad.y*dedip.z)+term*ptrt2;

        term=(Rad.z*Rbd.x-Rad.x*Rbd.z)+delta2*(t.x*Rad.z-t.z*Rad.x);
        dpdic.y=delta*(Rad.x*dedip.z-Rad.z*dedip.x)+term*ptrt2;

        term=(Rad.x*Rbd.y-Rad.y*Rbd.x)+delta2*(t.y*Rad.x-t.x*Rad.y);
        dpdic.z=delta*(Rad.y*dedip.x-Rad.x*dedip.y)+term*ptrt2;

        fa.x=fa.x+dpdia.x;
        fa.y=fa.y+dpdia.y;
        fa.z=fa.z+dpdia.z;
        fb.x=dedip.x;
        fb.y=dedip.y;
        fb.z=dedip.z;
        fc.x=fc.x+dpdic.x;
        fc.y=fc.y+dpdic.y;
        fc.z=fc.z+dpdic.z;
        fd.x=-(fa.x+fb.x+fc.x);
        fd.y=-(fa.y+fb.y+fc.y);
        fd.z=-(fa.z+fb.z+fc.z);

        // add contribution to the forces
        Adsorbates[CurrentSystem][m].Atoms[A].Force.x-=fa.x;
        Adsorbates[CurrentSystem][m].Atoms[A].Force.y-=fa.y;
        Adsorbates[CurrentSystem][m].Atoms[A].Force.z-=fa.z;

        Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=fb.x;
        Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=fb.y;
        Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=fb.z;

        Adsorbates[CurrentSystem][m].Atoms[C].Force.x-=fc.x;
        Adsorbates[CurrentSystem][m].Atoms[C].Force.y-=fc.y;
        Adsorbates[CurrentSystem][m].Atoms[C].Force.z-=fc.z;

        Adsorbates[CurrentSystem][m].Atoms[D].Force.x-=fd.x;
        Adsorbates[CurrentSystem][m].Atoms[D].Force.y-=fd.y;
        Adsorbates[CurrentSystem][m].Atoms[D].Force.z-=fd.z;

        // add contribution to the stress tensor
        StrainDerivativeTensor[CurrentSystem].ax+=Rad.x*fa.x+Rbd.x*fb.x+Rcd.x*fc.x;
        StrainDerivativeTensor[CurrentSystem].bx+=Rad.y*fa.x+Rbd.y*fb.x+Rcd.y*fc.x;
        StrainDerivativeTensor[CurrentSystem].cx+=Rad.z*fa.x+Rbd.z*fb.x+Rcd.z*fc.x;

        StrainDerivativeTensor[CurrentSystem].ay+=Rad.x*fa.y+Rbd.x*fb.y+Rcd.x*fc.y;
        StrainDerivativeTensor[CurrentSystem].by+=Rad.y*fa.y+Rbd.y*fb.y+Rcd.y*fc.y;
        StrainDerivativeTensor[CurrentSystem].cy+=Rad.z*fa.y+Rbd.z*fb.y+Rcd.z*fc.y;

        StrainDerivativeTensor[CurrentSystem].az+=Rad.x*fa.z+Rbd.x*fb.z+Rcd.x*fc.z;
        StrainDerivativeTensor[CurrentSystem].bz+=Rad.y*fa.z+Rbd.y*fb.z+Rcd.y*fc.z;
        StrainDerivativeTensor[CurrentSystem].cz+=Rad.z*fa.z+Rbd.z*fb.z+Rcd.z*fc.z;
        break;
      default:
        // Calculate the components of the derivatives.
        dtA.x=(Rbc.x-CosTheta*Rab.x)/rab;
        dtA.y=(Rbc.y-CosTheta*Rab.y)/rab;
        dtA.z=(Rbc.z-CosTheta*Rab.z)/rab;

        dtC.x=(Rab.x-CosTheta*Rbc.x)/rbc;
        dtC.y=(Rab.y-CosTheta*Rbc.y)/rbc;
        dtC.z=(Rab.z-CosTheta*Rbc.z)/rbc;

        dtB.x=-(dtA.x+dtC.x);
        dtB.y=-(dtA.y+dtC.y);
        dtB.z=-(dtA.z+dtC.z);

        // forces are oppositely directed to the gradient
        fa.x=-DF*dtA.x;
        fa.y=-DF*dtA.y;
        fa.z=-DF*dtA.z;

        fb.x=-DF*dtB.x;
        fb.y=-DF*dtB.y;
        fb.z=-DF*dtB.z;

        fc.x=-DF*dtC.x;
        fc.y=-DF*dtC.y;
        fc.z=-DF*dtC.z;

          // add contribution to the forces
        Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
        Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
        Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

        Adsorbates[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
        Adsorbates[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
        Adsorbates[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

        Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
        Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
        Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

        // add contribution to the stress tensor
        // Note: rab and rbc are here because the vectors were normalized before
        StrainDerivativeTensor[CurrentSystem].ax-=rab*Rab.x*fa.x+rbc*Rbc.x*fc.x;
        StrainDerivativeTensor[CurrentSystem].bx-=rab*Rab.y*fa.x+rbc*Rbc.y*fc.x;
        StrainDerivativeTensor[CurrentSystem].cx-=rab*Rab.z*fa.x+rbc*Rbc.z*fc.x;

        StrainDerivativeTensor[CurrentSystem].ay-=rab*Rab.x*fa.y+rbc*Rbc.x*fc.y;
        StrainDerivativeTensor[CurrentSystem].by-=rab*Rab.y*fa.y+rbc*Rbc.y*fc.y;
        StrainDerivativeTensor[CurrentSystem].cy-=rab*Rab.z*fa.y+rbc*Rbc.z*fc.y;

        StrainDerivativeTensor[CurrentSystem].az-=rab*Rab.x*fa.z+rbc*Rbc.x*fc.z;
        StrainDerivativeTensor[CurrentSystem].bz-=rab*Rab.y*fa.z+rbc*Rbc.y*fc.z;
        StrainDerivativeTensor[CurrentSystem].cz-=rab*Rab.z*fa.z+rbc*Rbc.z*fc.z;
        break;
    }
  }
}

void CalculateCationBendForce(int m)
{
  int Type,NumberOfBends;
  int i,A,B,C,D;
  REAL *parms,DF,U,temp,temp2;
  REAL CosTheta,Theta,SinTheta;
  REAL rab,rbc,rac,DTDX;
  VECTOR posA,posB,posC,posD;
  VECTOR Rab,Rbc,Rac,fa,fb,fc,dtA,dtB,dtC;;
  VECTOR Rad,Rbd,Rcd,t,ip,ap,cp;
  REAL rt2,rap2,rcp2;
  REAL terma,termc,delta,delta2,rm,ptrt2,term;
  VECTOR dpdia,dpdic,dedip,fd,n;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfBends=Components[Type].NumberOfBends;
  for(i=0;i<NumberOfBends;i++)
  {
    A=Components[Type].Bends[i].A;
    B=Components[Type].Bends[i].B;
    C=Components[Type].Bends[i].C;
    D=Components[Type].Bends[i].D;
    parms=Components[Type].BendArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Rab.x=Rab.y=Rab.z=0.0;
    Rcd.x=Rcd.y=Rcd.z=0.0;
    Rbd.x=Rbd.y=Rbd.z=0.0;
    Rad.x=Rad.y=Rad.z=0.0;
    Rbc.x=Rbc.y=Rbc.z=0.0;
    ap.x=ap.y=ap.z=0.0;
    cp.x=cp.y=cp.z=0.0;
    t.x=t.y=t.z=0.0;
    delta=rcp2=rap2=rt2=rab=rbc=temp=0.0;
    switch(Components[Type].BendType[i])
    {
      case MM3_IN_PLANE_BEND:
        Rad.x=posA.x-posD.x;
        Rad.y=posA.y-posD.y;
        Rad.z=posA.z-posD.z;

        Rbd.x=posB.x-posD.x;
        Rbd.y=posB.y-posD.y;
        Rbd.z=posB.z-posD.z;

        Rcd.x=posC.x-posD.x;
        Rcd.y=posC.y-posD.y;
        Rcd.z=posC.z-posD.z;

        t.x=Rad.y*Rcd.z-Rad.z*Rcd.y;
        t.y=Rad.z*Rcd.x-Rad.x*Rcd.z;
        t.z=Rad.x*Rcd.y-Rad.y*Rcd.x;
        rt2=t.x*t.x+t.y*t.y+t.z*t.z;
        delta=-(t.x*Rbd.x+t.y*Rbd.y+t.z*Rbd.z)/rt2;

        ip.x=posB.x+t.x*delta;
        ip.y=posB.y+t.y*delta;
        ip.z=posB.z+t.z*delta;
        ap.x=posA.x-ip.x;
        ap.y=posA.y-ip.y;
        ap.z=posA.z-ip.z;
        cp.x=posC.x-ip.x;
        cp.y=posC.y-ip.y;
        cp.z=posC.z-ip.z;
        ap=ApplyBoundaryCondition(ap);
        cp=ApplyBoundaryCondition(cp);

        rap2=ap.x*ap.x+ap.y*ap.y+ap.z*ap.z;
        rcp2=cp.x*cp.x+cp.y*cp.y+cp.z*cp.z;

        CosTheta=(ap.x*cp.x+ap.y*cp.y+ap.z*cp.z)/sqrt(rap2*rcp2);
        break;
      default:
        Rab.x=posA.x-posB.x;
        Rab.y=posA.y-posB.y;
        Rab.z=posA.z-posB.z;
        rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
        Rab.x/=rab;
        Rab.y/=rab;
        Rab.z/=rab;

        Rbc.x=posC.x-posB.x;
        Rbc.y=posC.y-posB.y;
        Rbc.z=posC.z-posB.z;
        rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
        Rbc.x/=rbc;
        Rbc.y/=rbc;
        Rbc.z/=rbc;

        Rac.x=posC.x-posA.x;
        Rac.y=posC.y-posA.y;
        Rac.z=posC.z-posA.z;
        rac=sqrt(SQR(Rac.x)+SQR(Rac.y)+SQR(Rac.z));
        Rac.x/=rac;
        Rac.y/=rac;
        Rac.z/=rac;

        CosTheta=(Rab.x*Rbc.x+Rab.y*Rbc.y+Rab.z*Rbc.z);
        break;
    }

    CosTheta=MIN2(1.0,MAX2(-1.0,CosTheta));
    Theta=acos(CosTheta);
    SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));
    DTDX=-1.0/sqrt(1.0-SQR(CosTheta));

    switch(Components[Type].BendType[i])
    {
      case HARMONIC_BEND:
        // (1/2)p_0*(theta-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(Theta-parms[1]);
        DF=parms[0]*(Theta-parms[1])*DTDX;
        break;
      case CORE_SHELL_BEND:
        // (1/2)p_0*(theta-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(Theta-parms[1]);
        DF=parms[0]*(Theta-parms[1])*DTDX;
        break;
      case QUARTIC_BEND:
        // (1/2)p_0*(theta-p_1)^2+(1/3)*p_2*(theta-p_1)^3+(1/4)*p_2*(theta-p_1)^4
        // ======================================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2/k_B [K/rad^3]
        // p_3/k_B [K/rad^4]
        temp=(Theta-parms[1]);
        temp2=SQR(temp);
        U=0.5*parms[0]*temp2+(1.0/3.0)*parms[2]*temp*temp2+0.25*parms[3]*SQR(temp2);
        DF=(parms[0]*temp+parms[2]*temp2+parms[3]*temp*temp2)*DTDX;
        break;
      case CFF_QUARTIC_BEND:
        // p_0*(theta-p_1)^2+p_2*(theta-p_1)^3+p_3*(theta-p_1)^4
        // =====================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2/k_B [K/rad^3]
        // p_3/k_B [K/rad^4]
        temp=(Theta-parms[1]);
        temp2=SQR(temp);
        U=parms[0]*temp2+parms[2]*temp*temp2+parms[3]*SQR(temp2);
        DF=(2.0*parms[0]*temp+3.0*parms[2]*temp2+4.0*parms[3]*temp*temp2)*DTDX;
        break;
      case HARMONIC_COSINE_BEND:
        // (1/2)*p_0*(cos(theta)-cos(p_1))^2
        // ===============================================
        // p_0/k_B [K]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(CosTheta-parms[1]);
        DF=parms[0]*(CosTheta-parms[1]);
        break;
      case COSINE_BEND:
        // p_0*(1+cos(p_1*theta-p_2))
        // ===============================================
        // p_0/k_B [K]
        // p_1     [-]
        // p_2     [degrees]
        temp=parms[1]*Theta-parms[2];
        U=parms[0]*(1.0+cos(temp));
        DF=-(parms[0]*parms[1]*sin(temp))*DTDX;
        break;
      case TAFIPOLSKY_BEND:
        // 0.5*p_0*(1+cos(theta))*(1+cos(2*theta))
        // ===============================================
        // p_0/k_B [K]
        U=0.5*parms[0]*(1.0+cos(Theta))*(1.0+cos(2.0*Theta));
        DF=parms[0]*CosTheta*(2.0+3.0*CosTheta);
        break;
      case MM3_BEND:
      case MM3_IN_PLANE_BEND:
        // p_0*(theta-p_1)^2(1-0.014*(theta-p_1)+5.6e-5*(theta-p_1)^2-7e-7*(theta-p_1)^3+2.2e-8(theta-p_1)^4)
        // =================================================================================================
        // p_0/k_B [mdyne A/rad^2]
        // p_1     [degrees]
        U=DF=0;
        temp=RAD2DEG*(Theta-parms[1]);
        temp2=SQR(temp);
        U=parms[0]*temp2*(1.0-0.014*temp+5.6e-5*temp2-7.0e-7*temp*temp2+2.2e-8*SQR(temp2));
        DF=parms[0]*RAD2DEG*(2.0-(3.0*0.014-(4.0*5.6e-5-(5.0*7.0e-7-6.0*2.2e-8*temp)*temp)*temp)*temp)*temp*DTDX;
        break;
      case FIXED_BEND:
        U=DF=0.0;
        break;
      case MEASURE_BEND:
        U=DF=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Bend potential in routine 'CalculateFrameworkBendForce' ('framework_force.c')\n");
        exit(0);
        break;
    }

    // add contribution to the energy
    UCationBend[CurrentSystem]+=U;

    switch(Components[Type].BendType[i])
    {
      case MM3_IN_PLANE_BEND:
        DF=parms[0]*RAD2DEG*(2.0-(3.0*0.014-(4.0*5.6e-5-(5.0*7.0e-7-6.0*2.2e-8*temp)*temp)*temp)*temp)*temp;
        n.x=cp.y*ap.z-cp.z*ap.y;
        n.y=cp.z*ap.x-cp.x*ap.z;
        n.z=cp.x*ap.y-cp.y*ap.x;
        rm=sqrt(n.x*n.x+n.y*n.y+n.z*n.z);
        rm=MAX2(rm,0.000001);

        terma=-DF/(rap2*rm);
        termc=DF/(rcp2*rm);
        fa.x=terma*(ap.y*n.z-ap.z*n.y);
        fa.y=terma*(ap.z*n.x-ap.x*n.z);
        fa.z=terma*(ap.x*n.y-ap.y*n.x);
        fc.x=termc*(cp.y*n.z-cp.z*n.y);
        fc.y=termc*(cp.z*n.x-cp.x*n.z);
        fc.z=termc*(cp.x*n.y-cp.y*n.x);
        dedip.x=-(fa.x+fc.x);
        dedip.y=-(fa.y+fc.y);
        dedip.z=-(fa.z+fc.z);

        delta2=2.0*delta;
        ptrt2=(dedip.x*t.x+dedip.y*t.y+dedip.z*t.z)/rt2;

        term=(Rcd.z*Rbd.y-Rcd.y*Rbd.z)+delta2*(t.y*Rcd.z-t.z*Rcd.y);
        dpdia.x=delta*(Rcd.y*dedip.z-Rcd.z*dedip.y)+term*ptrt2;

        term=(Rcd.x*Rbd.z-Rcd.z*Rbd.x)+delta2*(t.z*Rcd.x-t.x*Rcd.z);
        dpdia.y=delta*(Rcd.z*dedip.x-Rcd.x*dedip.z)+term*ptrt2;

        term=(Rcd.y*Rbd.x-Rcd.x*Rbd.y)+delta2*(t.x*Rcd.y-t.y*Rcd.x);
        dpdia.z=delta*(Rcd.x*dedip.y-Rcd.y*dedip.x)+term*ptrt2;

        term=(Rad.y*Rbd.z-Rad.z*Rbd.y)+delta2*(t.z*Rad.y-t.y*Rad.z);
        dpdic.x=delta*(Rad.z*dedip.y-Rad.y*dedip.z)+term*ptrt2;

        term=(Rad.z*Rbd.x-Rad.x*Rbd.z)+delta2*(t.x*Rad.z-t.z*Rad.x);
        dpdic.y=delta*(Rad.x*dedip.z-Rad.z*dedip.x)+term*ptrt2;

        term=(Rad.x*Rbd.y-Rad.y*Rbd.x)+delta2*(t.y*Rad.x-t.x*Rad.y);
        dpdic.z=delta*(Rad.y*dedip.x-Rad.x*dedip.y)+term*ptrt2;

        fa.x=fa.x+dpdia.x;
        fa.y=fa.y+dpdia.y;
        fa.z=fa.z+dpdia.z;
        fb.x=dedip.x;
        fb.y=dedip.y;
        fb.z=dedip.z;
        fc.x=fc.x+dpdic.x;
        fc.y=fc.y+dpdic.y;
        fc.z=fc.z+dpdic.z;
        fd.x=-(fa.x+fb.x+fc.x);
        fd.y=-(fa.y+fb.y+fc.y);
        fd.z=-(fa.z+fb.z+fc.z);

        // add contribution to the forces
        Cations[CurrentSystem][m].Atoms[A].Force.x-=fa.x;
        Cations[CurrentSystem][m].Atoms[A].Force.y-=fa.y;
        Cations[CurrentSystem][m].Atoms[A].Force.z-=fa.z;

        Cations[CurrentSystem][m].Atoms[B].Force.x-=fb.x;
        Cations[CurrentSystem][m].Atoms[B].Force.y-=fb.y;
        Cations[CurrentSystem][m].Atoms[B].Force.z-=fb.z;

        Cations[CurrentSystem][m].Atoms[C].Force.x-=fc.x;
        Cations[CurrentSystem][m].Atoms[C].Force.y-=fc.y;
        Cations[CurrentSystem][m].Atoms[C].Force.z-=fc.z;

        Cations[CurrentSystem][m].Atoms[D].Force.x-=fd.x;
        Cations[CurrentSystem][m].Atoms[D].Force.y-=fd.y;
        Cations[CurrentSystem][m].Atoms[D].Force.z-=fd.z;

        // add contribution to the stress tensor
        StrainDerivativeTensor[CurrentSystem].ax+=Rad.x*fa.x+Rbd.x*fb.x+Rcd.x*fc.x;
        StrainDerivativeTensor[CurrentSystem].bx+=Rad.y*fa.x+Rbd.y*fb.x+Rcd.y*fc.x;
        StrainDerivativeTensor[CurrentSystem].cx+=Rad.z*fa.x+Rbd.z*fb.x+Rcd.z*fc.x;

        StrainDerivativeTensor[CurrentSystem].ay+=Rad.x*fa.y+Rbd.x*fb.y+Rcd.x*fc.y;
        StrainDerivativeTensor[CurrentSystem].by+=Rad.y*fa.y+Rbd.y*fb.y+Rcd.y*fc.y;
        StrainDerivativeTensor[CurrentSystem].cy+=Rad.z*fa.y+Rbd.z*fb.y+Rcd.z*fc.y;

        StrainDerivativeTensor[CurrentSystem].az+=Rad.x*fa.z+Rbd.x*fb.z+Rcd.x*fc.z;
        StrainDerivativeTensor[CurrentSystem].bz+=Rad.y*fa.z+Rbd.y*fb.z+Rcd.y*fc.z;
        StrainDerivativeTensor[CurrentSystem].cz+=Rad.z*fa.z+Rbd.z*fb.z+Rcd.z*fc.z;
        break;
      default:
        // Calculate the components of the derivatives.
        dtA.x=(Rbc.x-CosTheta*Rab.x)/rab;
        dtA.y=(Rbc.y-CosTheta*Rab.y)/rab;
        dtA.z=(Rbc.z-CosTheta*Rab.z)/rab;

        dtC.x=(Rab.x-CosTheta*Rbc.x)/rbc;
        dtC.y=(Rab.y-CosTheta*Rbc.y)/rbc;
        dtC.z=(Rab.z-CosTheta*Rbc.z)/rbc;

        dtB.x=-(dtA.x+dtC.x);
        dtB.y=-(dtA.y+dtC.y);
        dtB.z=-(dtA.z+dtC.z);

        // forces are oppositely directed to the gradient
        fa.x=-DF*dtA.x;
        fa.y=-DF*dtA.y;
        fa.z=-DF*dtA.z;

        fb.x=-DF*dtB.x;
        fb.y=-DF*dtB.y;
        fb.z=-DF*dtB.z;

        fc.x=-DF*dtC.x;
        fc.y=-DF*dtC.y;
        fc.z=-DF*dtC.z;

          // add contribution to the forces
        Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
        Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
        Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

        Cations[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
        Cations[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
        Cations[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

        Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
        Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
        Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

        // add contribution to the stress tensor
        // Note: rab and rbc are here because the vectors were normalized before
        StrainDerivativeTensor[CurrentSystem].ax-=rab*Rab.x*fa.x+rbc*Rbc.x*fc.x;
        StrainDerivativeTensor[CurrentSystem].bx-=rab*Rab.y*fa.x+rbc*Rbc.y*fc.x;
        StrainDerivativeTensor[CurrentSystem].cx-=rab*Rab.z*fa.x+rbc*Rbc.z*fc.x;

        StrainDerivativeTensor[CurrentSystem].ay-=rab*Rab.x*fa.y+rbc*Rbc.x*fc.y;
        StrainDerivativeTensor[CurrentSystem].by-=rab*Rab.y*fa.y+rbc*Rbc.y*fc.y;
        StrainDerivativeTensor[CurrentSystem].cy-=rab*Rab.z*fa.y+rbc*Rbc.z*fc.y;

        StrainDerivativeTensor[CurrentSystem].az-=rab*Rab.x*fa.z+rbc*Rbc.x*fc.z;
        StrainDerivativeTensor[CurrentSystem].bz-=rab*Rab.y*fa.z+rbc*Rbc.y*fc.z;
        StrainDerivativeTensor[CurrentSystem].cz-=rab*Rab.z*fa.z+rbc*Rbc.z*fc.z;
        break;
    }
  }
}


// derivative results verified by mathematica 4.1
void CalculateAdsorbateInversionBendForce(int m)
{
  int i,A,B,C,D;
  int Type,NumberOfInversionBends;
  REAL *parms;
  REAL c,e;
  REAL rrab,rab2,rrbc,rbc2,rbd2,rad2,rac2,dot;
  REAL CosChi,Chi,energy;
  REAL temp,temp2;
  VECTOR Rab,Rbc,Rbd,Rad,Rac;
  POINT posA,posB,posC,posD;
  VECTOR fa,fb,fc,fd;
  REAL term,dedcos;
  VECTOR dccdia,dccdic,dccdid;
  VECTOR deedia,deedic,deedid;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfInversionBends=Components[Type].NumberOfInversionBends;
  for(i=0;i<NumberOfInversionBends;i++)
  {
    A=Components[Type].InversionBends[i].A;
    B=Components[Type].InversionBends[i].B;
    C=Components[Type].InversionBends[i].C;
    D=Components[Type].InversionBends[i].D;
    parms=Components[Type].InversionBendArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    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;
    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;
    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;
    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;
    rad2=Rad.x*Rad.x+Rad.y*Rad.y+Rad.z*Rad.z;

    switch(Components[Type].InversionBendType[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);

    switch(Components[Type].InversionBendType[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
    UAdsorbateInversionBend[CurrentSystem]+=energy;

    switch(Components[Type].InversionBendType[i])
    {
      case HARMONIC_COSINE_INVERSION:
      case PLANAR_INVERSION:
      case HARMONIC_INVERSION:
        term=e/c;
        dccdia.x=0.0;
        dccdia.y=0.0;
        dccdia.z=0.0;
        dccdic.x=(Rbc.x*rbd2-Rbd.x*dot)*term;
        dccdic.y=(Rbc.y*rbd2-Rbd.y*dot)*term;
        dccdic.z=(Rbc.z*rbd2-Rbd.z*dot)*term;
        dccdid.x=(Rbd.x*rbc2-Rbc.x*dot)*term;
        dccdid.y=(Rbd.y*rbc2-Rbc.y*dot)*term;
        dccdid.z=(Rbd.z*rbc2-Rbc.z*dot)*term;
        break;
      case HARMONIC_INVERSION2:
      case HARMONIC_COSINE_INVERSION2:
      case PLANAR_INVERSION2:
      case MM3_INVERSION:
        term=e/c;
        dccdic.x=(Rac.x*rad2-Rad.x*dot)*term;
        dccdic.y=(Rac.y*rad2-Rad.y*dot)*term;
        dccdic.z=(Rac.z*rad2-Rad.z*dot)*term;
        dccdid.x=(Rad.x*rac2-Rac.x*dot)*term;
        dccdid.y=(Rad.y*rac2-Rac.y*dot)*term;
        dccdid.z=(Rad.z*rac2-Rac.z*dot)*term;
        dccdia.x=-(dccdic.x+dccdid.x);
        dccdia.y=-(dccdic.y+dccdid.y);
        dccdia.z=-(dccdic.z+dccdid.z);
        break;
      default:
        fprintf(stderr, "Undefined Inversion-Bend potential in routine 'CalculateFrameworkInversionBendEnergy' ('framework_energy.c')\n");
        exit(0);
        break;
    }


    term=e/rab2;
    deedia.x=Rbd.y*Rbc.z-Rbd.z*Rbc.y+Rab.x*term;
    deedia.y=Rbd.z*Rbc.x-Rbd.x*Rbc.z+Rab.y*term;
    deedia.z=Rbd.x*Rbc.y-Rbd.y*Rbc.x+Rab.z*term;
    deedic.x=Rab.y*Rbd.z-Rab.z*Rbd.y;
    deedic.y=Rab.z*Rbd.x-Rab.x*Rbd.z;
    deedic.z=Rab.x*Rbd.y-Rab.y*Rbd.x;
    deedid.x=Rbc.y*Rab.z-Rbc.z*Rab.y;
    deedid.y=Rbc.z*Rab.x-Rbc.x*Rab.z;
    deedid.z=Rbc.x*Rab.y-Rbc.y*Rab.x;

    fa.x=dedcos*(dccdia.x+deedia.x);
    fa.y=dedcos*(dccdia.y+deedia.y);
    fa.z=dedcos*(dccdia.z+deedia.z);
    fc.x=dedcos*(dccdic.x+deedic.x);
    fc.y=dedcos*(dccdic.y+deedic.y);
    fc.z=dedcos*(dccdic.z+deedic.z);
    fd.x=dedcos*(dccdid.x+deedid.x);
    fd.y=dedcos*(dccdid.y+deedid.y);
    fd.z=dedcos*(dccdid.z+deedid.z);

    fb.x=-(fa.x+fc.x+fd.x);
    fb.y=-(fa.y+fc.y+fd.y);
    fb.z=-(fa.z+fc.z+fd.z);

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x-=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y-=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z-=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=fb.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=fb.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=fb.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x-=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y-=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z-=fc.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x-=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y-=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z-=fd.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax+=Rab.x*fa.x+Rbc.x*fc.x+Rbd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].ay+=Rab.x*fa.y+Rbc.x*fc.y+Rbd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].az+=Rab.x*fa.z+Rbc.x*fc.z+Rbd.x*fd.z;

    StrainDerivativeTensor[CurrentSystem].bx+=Rab.y*fa.x+Rbc.y*fc.x+Rbd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].by+=Rab.y*fa.y+Rbc.y*fc.y+Rbd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].bz+=Rab.y*fa.z+Rbc.y*fc.z+Rbd.y*fd.z;

    StrainDerivativeTensor[CurrentSystem].cx+=Rab.z*fa.x+Rbc.z*fc.x+Rbd.z*fd.x;
    StrainDerivativeTensor[CurrentSystem].cy+=Rab.z*fa.y+Rbc.z*fc.y+Rbd.z*fd.y;
    StrainDerivativeTensor[CurrentSystem].cz+=Rab.z*fa.z+Rbc.z*fc.z+Rbd.z*fd.z;
  }
}


// derivative results verified by mathematica 4.1
void CalculateCationInversionBendForce(int m)
{
  int i,A,B,C,D;
  int Type,NumberOfInversionBends;
  REAL *parms;
  REAL c,e;
  REAL rrab,rab2,rrbc,rbc2,rbd2,rad2,rac2,dot;
  REAL CosChi,Chi,energy;
  REAL temp,temp2;
  VECTOR Rab,Rbc,Rbd,Rad,Rac;
  POINT posA,posB,posC,posD;
  VECTOR fa,fb,fc,fd;
  REAL term,dedcos;
  VECTOR dccdia,dccdic,dccdid;
  VECTOR deedia,deedic,deedid;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfInversionBends=Components[Type].NumberOfInversionBends;
  for(i=0;i<NumberOfInversionBends;i++)
  {
    A=Components[Type].InversionBends[i].A;
    B=Components[Type].InversionBends[i].B;
    C=Components[Type].InversionBends[i].C;
    D=Components[Type].InversionBends[i].D;
    parms=Components[Type].InversionBendArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    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;
    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;
    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;
    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;
    rad2=Rad.x*Rad.x+Rad.y*Rad.y+Rad.z*Rad.z;

    switch(Components[Type].InversionBendType[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);

    switch(Components[Type].InversionBendType[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
    UCationInversionBend[CurrentSystem]+=energy;

    switch(Components[Type].InversionBendType[i])
    {
      case HARMONIC_COSINE_INVERSION:
      case PLANAR_INVERSION:
      case HARMONIC_INVERSION:
        term=e/c;
        dccdia.x=0.0;
        dccdia.y=0.0;
        dccdia.z=0.0;
        dccdic.x=(Rbc.x*rbd2-Rbd.x*dot)*term;
        dccdic.y=(Rbc.y*rbd2-Rbd.y*dot)*term;
        dccdic.z=(Rbc.z*rbd2-Rbd.z*dot)*term;
        dccdid.x=(Rbd.x*rbc2-Rbc.x*dot)*term;
        dccdid.y=(Rbd.y*rbc2-Rbc.y*dot)*term;
        dccdid.z=(Rbd.z*rbc2-Rbc.z*dot)*term;
        break;
      case HARMONIC_INVERSION2:
      case HARMONIC_COSINE_INVERSION2:
      case PLANAR_INVERSION2:
      case MM3_INVERSION:
        term=e/c;
        dccdic.x=(Rac.x*rad2-Rad.x*dot)*term;
        dccdic.y=(Rac.y*rad2-Rad.y*dot)*term;
        dccdic.z=(Rac.z*rad2-Rad.z*dot)*term;
        dccdid.x=(Rad.x*rac2-Rac.x*dot)*term;
        dccdid.y=(Rad.y*rac2-Rac.y*dot)*term;
        dccdid.z=(Rad.z*rac2-Rac.z*dot)*term;
        dccdia.x=-(dccdic.x+dccdid.x);
        dccdia.y=-(dccdic.y+dccdid.y);
        dccdia.z=-(dccdic.z+dccdid.z);
        break;
      default:
        fprintf(stderr, "Undefined Inversion-Bend potential in routine 'CalculateFrameworkInversionBendEnergy' ('framework_energy.c')\n");
        exit(0);
        break;
    }


    term=e/rab2;
    deedia.x=Rbd.y*Rbc.z-Rbd.z*Rbc.y+Rab.x*term;
    deedia.y=Rbd.z*Rbc.x-Rbd.x*Rbc.z+Rab.y*term;
    deedia.z=Rbd.x*Rbc.y-Rbd.y*Rbc.x+Rab.z*term;
    deedic.x=Rab.y*Rbd.z-Rab.z*Rbd.y;
    deedic.y=Rab.z*Rbd.x-Rab.x*Rbd.z;
    deedic.z=Rab.x*Rbd.y-Rab.y*Rbd.x;
    deedid.x=Rbc.y*Rab.z-Rbc.z*Rab.y;
    deedid.y=Rbc.z*Rab.x-Rbc.x*Rab.z;
    deedid.z=Rbc.x*Rab.y-Rbc.y*Rab.x;

    fa.x=dedcos*(dccdia.x+deedia.x);
    fa.y=dedcos*(dccdia.y+deedia.y);
    fa.z=dedcos*(dccdia.z+deedia.z);
    fc.x=dedcos*(dccdic.x+deedic.x);
    fc.y=dedcos*(dccdic.y+deedic.y);
    fc.z=dedcos*(dccdic.z+deedic.z);
    fd.x=dedcos*(dccdid.x+deedid.x);
    fd.y=dedcos*(dccdid.y+deedid.y);
    fd.z=dedcos*(dccdid.z+deedid.z);

    fb.x=-(fa.x+fc.x+fd.x);
    fb.y=-(fa.y+fc.y+fd.y);
    fb.z=-(fa.z+fc.z+fd.z);

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x-=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y-=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z-=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=fb.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y-=fb.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z-=fb.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x-=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y-=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z-=fc.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x-=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y-=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z-=fd.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax+=Rab.x*fa.x+Rbc.x*fc.x+Rbd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].ay+=Rab.x*fa.y+Rbc.x*fc.y+Rbd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].az+=Rab.x*fa.z+Rbc.x*fc.z+Rbd.x*fd.z;

    StrainDerivativeTensor[CurrentSystem].bx+=Rab.y*fa.x+Rbc.y*fc.x+Rbd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].by+=Rab.y*fa.y+Rbc.y*fc.y+Rbd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].bz+=Rab.y*fa.z+Rbc.y*fc.z+Rbd.y*fd.z;

    StrainDerivativeTensor[CurrentSystem].cx+=Rab.z*fa.x+Rbc.z*fc.x+Rbd.z*fd.x;
    StrainDerivativeTensor[CurrentSystem].cy+=Rab.z*fa.y+Rbc.z*fc.y+Rbd.z*fd.y;
    StrainDerivativeTensor[CurrentSystem].cz+=Rab.z*fa.z+Rbc.z*fc.z+Rbd.z*fd.z;
  }
}


void CalculateAdsorbateTorsionForce(int m)
{
  int i,Type,NumberOfTorsions,A,B,C,D;
  POINT posA,posB,posC,posD;
  REAL d,e,rbc;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,U,DF;
  REAL ShiftedCosPhi,ShiftedCosPhi2,ShiftedSinPhi;
  VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
  VECTOR fa,fb,fc,fd;
  REAL *parms;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfTorsions=Components[Type].NumberOfTorsions;
  for(i=0;i<NumberOfTorsions;i++)
  {
    A=Components[Type].Torsions[i].A;
    B=Components[Type].Torsions[i].B;
    C=Components[Type].Torsions[i].C;
    D=Components[Type].Torsions[i].D;
    parms=(REAL*)&Components[Type].TorsionArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    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;
    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(Components[Type].TorsionType[i])
    {
      case HARMONIC_DIHEDRAL:
        // (1/2)*p_0*(phi-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as Rbc, and negative otherwise
        Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
        Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
        Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
        Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
        Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
        Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
        sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
              +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
        Phi=SIGN(acos(CosPhi),sign);
        SinPhi=sin(Phi);
        Phi-=parms[1];
        Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
        U=0.5*parms[0]*SQR(Phi);
        DF=-parms[0]*(Phi)/SinPhi;
        break;
      case HARMONIC_COSINE_DIHEDRAL:
        // (1/2)*p_0*(cos(phi)-cos(p_1))^2
        // ===============================================
        // p_0/k_B [K]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(CosPhi-parms[1]);
        DF=parms[0]*(CosPhi-parms[1]);
        break;
      case THREE_COSINE_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case MM3_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0     [kcal/mol]
        // p_1     [kcal/mol]
        // p_2     [kcal/mol]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case CVFF_BLOCKED_DIHEDRAL:
        //
        // ========================================================================
        // p_0     [rad]
        // p_1     [K]
        // p_2     [-]
        // p_3     [rad]
        // p_4     [rad]
        U=0.0;
        DF=0.0;
        break;
      case CFF_DIHEDRAL:
        // p_0*(1-cos(phi))+p_1*(1-cos(2*phi))+p_2*(1-cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2);
        DF=-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2);
        break;
      case CFF_DIHEDRAL2:
        // p_0*(1+cos(phi))+p_1*(1+cos(2*phi))+p_2*(1+cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi));
        DF=parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi);
        break;
      case SIX_COSINE_DIHEDRAL:
        // Prod_i=0^5 p_i*cos(phi)^i
        // =========================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        // the Ryckaert-Bellemans potentials is often used for alkanes, the use implies exclusion of VDW-interactions
        // between the first and last atoms of the dihedral, and Phi'=Phi-Pi is defined accoording to the
        // polymer convention Phi'(trans)=0.
        U=parms[0]-parms[1]*CosPhi+parms[2]*CosPhi2-parms[3]*CosPhi*CosPhi2+
               parms[4]*SQR(CosPhi2)-parms[5]*SQR(CosPhi2)*CosPhi;
        DF=-parms[1]+2.0*parms[2]*CosPhi-3.0*parms[3]*CosPhi2+4.0*parms[4]*CosPhi2*CosPhi-5.0*parms[5]*SQR(CosPhi2);
        break;
      case TRAPPE_DIHEDRAL:
        // p_0+p_1*(1+cos(phi))+p_2*(1-cos(2*phi))+p_3*(1+cos(3*phi))
        // ==========================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi));
        DF=parms[1]-4.0*parms[2]*CosPhi+3.0*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case TRAPPE_DIHEDRAL_EXTENDED:
        // p_0+p_1*cos(phi)+p_2*cos(2*phi)+p_3*cos(3*phi)+p_4*cos(4*phi)
        // =============================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        U=parms[0]-parms[2]+parms[4]+(parms[1]-3.0*parms[3])*CosPhi+(2.0*parms[2]-8.0*parms[4])*CosPhi2+4.0*parms[3]*CosPhi2*CosPhi+8.0*parms[4]*SQR(CosPhi2);
        DF=parms[1]-3.0*parms[3]+4.0*(parms[2]-4.0*parms[4])*CosPhi+12.0*parms[3]*CosPhi2+32.0*parms[4]*CosPhi2*CosPhi;
        break;
      case MOD_TRAPPE_DIHEDRAL:
        /* Salvador modification: 16/08/2016
         add phase in cos function:
         p_0+p_1*(1+cos(phi-p_4))+p_2*(1-cos(2*(phi-p_4)))+p_3*(1+cos(3*(phi-p_4)))
        */
        Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
        Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
        Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
        Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
        Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
        Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
        sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
              +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
        Phi=SIGN(acos(CosPhi),sign);
        SinPhi=sin(Phi);
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
        Phi-=parms[4];           // shift Phi as Phi+parms[4]
        Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
        ShiftedCosPhi=cos(Phi);
        ShiftedSinPhi=sin(Phi);
        ShiftedCosPhi2=SQR(ShiftedCosPhi);
        U=parms[0]+parms[1]+parms[3]+(parms[1]-3.0*parms[3])*ShiftedCosPhi -2.0*parms[2]*ShiftedCosPhi2 +4.0*parms[3]*ShiftedCosPhi*ShiftedCosPhi2;
        DF=((parms[1]-3.0*parms[3])*sin(Phi) -4.0*parms[2]*ShiftedCosPhi*ShiftedSinPhi + 12.0*parms[3]*ShiftedCosPhi2*ShiftedSinPhi)/SinPhi;
        break;
      case CVFF_DIHEDRAL:
        // p_0*(1+cos(p_1*phi-p_2))
        // ========================
        // p_0/k_B [K]
        // p_1     [-]
        // p_2     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as 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);
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi);  // remove singularity
        U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
        DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
        break;
      case OPLS_DIHEDRAL:
        // (1/2)p_0[0]+(1/2)p_1*(1+cos(phi))+(1/2)p_2*(1-cos(2*phi))+(1/2)p_3*(1+cos(3*phi))
        // =================================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=0.5*(parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi)));
        DF=0.5*parms[1]-2.0*parms[2]*CosPhi+1.5*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case FOURIER_SERIES_DIHEDRAL:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1-cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[0]+2.0*parms[1]+parms[2]+parms[4]+2.0*parms[5]+(parms[0]-3.0*parms[2]+5.0*parms[4])*CosPhi-
               2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi2+4.0*(parms[2]-5.0*parms[4])*CosPhi2*CosPhi-
               8.0*(parms[3]-6.0*parms[5])*SQR(CosPhi2)+16.0*parms[4]*SQR(CosPhi2)*CosPhi-32.0*parms[5]*CUBE(CosPhi2));
        DF=0.5*(parms[0]-3.0*parms[2]+5.0*parms[4])-2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi+
           6.0*(parms[2]-5.0*parms[4])*CosPhi2-16.0*(parms[3]-6.0*parms[5])*CosPhi2*CosPhi+40.0*parms[4]*SQR(CosPhi2)-96.0*parms[5]*CosPhi2*CUBE(CosPhi);
        break;
      case FOURIER_SERIES_DIHEDRAL2:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1+cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[2]+2.0*parms[3]+parms[4]-3.0*parms[2]*CosPhi+5.0*parms[4]*CosPhi+parms[0]*(1.0+CosPhi)+
          2.0*(parms[1]-parms[1]*CosPhi2+CosPhi2*(parms[5]*SQR(3.0-4.0*CosPhi2)+4.0*parms[3]*(CosPhi2-1.0)+
          2.0*CosPhi*(parms[2]+parms[4]*(4.0*CosPhi2-5.0)))));
        DF=0.5*parms[0]+parms[2]*(6.0*CosPhi2-1.5)+parms[4]*(2.5-30.0*CosPhi2+40.0*SQR(CosPhi2))+
           CosPhi*(-2.0*parms[1]+parms[3]*(16.0*CosPhi2-8.0)+parms[5]*(18.0-96.0*CosPhi2+96.0*SQR(CosPhi2)));
        break;
      case FIXED_DIHEDRAL:
        U=DF=0;
        break;
      default:
        fprintf(stderr, "Undefined Torsion potential in routine 'CalculateAdsorbateTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UAdsorbateTorsion[CurrentSystem]+=U;

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DF*dtA.x;
    fa.y=-DF*dtA.y;
    fa.z=-DF*dtA.z;

    fb.x=-DF*dtB.x;
    fb.y=-DF*dtB.y;
    fb.z=-DF*dtB.z;

    fc.x=-DF*dtC.x;
    fc.y=-DF*dtC.y;
    fc.z=-DF*dtC.z;

    fd.x=-DF*dtD.x;
    fd.y=-DF*dtD.y;
    fd.z=-DF*dtD.z;

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
  }
}


void CalculateCationTorsionForce(int m)
{
  int i,Type,NumberOfTorsions,A,B,C,D;
  POINT posA,posB,posC,posD;
  REAL d,e,rbc;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,U,DF;
  REAL ShiftedCosPhi,ShiftedCosPhi2,ShiftedSinPhi;
  VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
  VECTOR fa,fb,fc,fd;
  REAL *parms;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfTorsions=Components[Type].NumberOfTorsions;
  for(i=0;i<NumberOfTorsions;i++)
  {
    A=Components[Type].Torsions[i].A;
    B=Components[Type].Torsions[i].B;
    C=Components[Type].Torsions[i].C;
    D=Components[Type].Torsions[i].D;
    parms=(REAL*)&Components[Type].TorsionArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    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;
    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(Components[Type].TorsionType[i])
    {
      case HARMONIC_DIHEDRAL:
        // (1/2)*p_0*(phi-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as Rbc, and negative otherwise
        Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
        Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
        Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
        Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
        Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
        Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
        sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
              +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
        Phi=SIGN(acos(CosPhi),sign);
        SinPhi=sin(Phi);
        Phi-=parms[1];
        Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
        U=0.5*parms[0]*SQR(Phi);
        DF=-parms[0]*(Phi)/SinPhi;
        break;
      case HARMONIC_COSINE_DIHEDRAL:
        // (1/2)*p_0*(cos(phi)-cos(p_1))^2
        // ===============================================
        // p_0/k_B [K]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(CosPhi-parms[1]);
        DF=parms[0]*(CosPhi-parms[1]);
        break;
      case THREE_COSINE_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case MM3_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0     [kcal/mol]
        // p_1     [kcal/mol]
        // p_2     [kcal/mol]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case CVFF_BLOCKED_DIHEDRAL:
        //
        // ========================================================================
        // p_0     [rad]
        // p_1     [K]
        // p_2     [-]
        // p_3     [rad]
        // p_4     [rad]
        U=0.0;
        DF=0.0;
        break;
      case CFF_DIHEDRAL:
        // p_0*(1-cos(phi))+p_1*(1-cos(2*phi))+p_2*(1-cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2);
        DF=-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2);
        break;
      case CFF_DIHEDRAL2:
        // p_0*(1+cos(phi))+p_1*(1+cos(2*phi))+p_2*(1+cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi));
        DF=parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi);
        break;
      case SIX_COSINE_DIHEDRAL:
        // Prod_i=0^5 p_i*cos(phi)^i
        // =========================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        // the Ryckaert-Bellemans potentials is often used for alkanes, the use implies exclusion of VDW-interactions
        // between the first and last atoms of the dihedral, and Phi'=Phi-Pi is defined accoording to the
        // polymer convention Phi'(trans)=0.
        U=parms[0]-parms[1]*CosPhi+parms[2]*CosPhi2-parms[3]*CosPhi*CosPhi2+
               parms[4]*SQR(CosPhi2)-parms[5]*SQR(CosPhi2)*CosPhi;
        DF=-parms[1]+2.0*parms[2]*CosPhi-3.0*parms[3]*CosPhi2+4.0*parms[4]*CosPhi2*CosPhi-5.0*parms[5]*SQR(CosPhi2);
        break;
      case TRAPPE_DIHEDRAL:
        // p_0+p_1*(1+cos(phi))+p_2*(1-cos(2*phi))+p_3*(1+cos(3*phi))
        // ==========================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi));
        DF=parms[1]-4.0*parms[2]*CosPhi+3.0*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case TRAPPE_DIHEDRAL_EXTENDED:
        // p_0+p_1*cos(phi)+p_2*cos(2*phi)+p_3*cos(3*phi)+p_4*cos(4*phi)
        // =============================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        U=parms[0]-parms[2]+parms[4]+(parms[1]-3.0*parms[3])*CosPhi+(2.0*parms[2]-8.0*parms[4])*CosPhi2+4.0*parms[3]*CosPhi2*CosPhi+8.0*parms[4]*SQR(CosPhi2);
        DF=parms[1]-3.0*parms[3]+4.0*(parms[2]-4.0*parms[4])*CosPhi+12.0*parms[3]*CosPhi2+32.0*parms[4]*CosPhi2*CosPhi;
        break;
      case MOD_TRAPPE_DIHEDRAL:
        /* Salvador modification: 16/08/2016
         add phase in cos function:
         p_0+p_1*(1+cos(phi-p_4))+p_2*(1-cos(2*(phi-p_4)))+p_3*(1+cos(3*(phi-p_4)))
        */
        Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
        Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
        Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
        Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
        Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
        Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
        sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
              +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
        Phi=SIGN(acos(CosPhi),sign);
        SinPhi=sin(Phi);
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
        Phi-=parms[4];           // shift Phi as Phi+parms[4]
        Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
        ShiftedCosPhi=cos(Phi);
        ShiftedSinPhi=sin(Phi);
        ShiftedCosPhi2=SQR(ShiftedCosPhi);
        U=parms[0]+parms[1]+parms[3]+(parms[1]-3.0*parms[3])*ShiftedCosPhi -2.0*parms[2]*ShiftedCosPhi2 +4.0*parms[3]*ShiftedCosPhi*ShiftedCosPhi2;
        DF=((parms[1]-3.0*parms[3])*sin(Phi) -4.0*parms[2]*ShiftedCosPhi*ShiftedSinPhi + 12.0*parms[3]*ShiftedCosPhi2*ShiftedSinPhi)/SinPhi;
        break;
      case CVFF_DIHEDRAL:
        // p_0*(1+cos(p_1*phi-p_2))
        // ========================
        // p_0/k_B [K]
        // p_1     [-]
        // p_2     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as 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);
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi);  // remove singularity
        U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
        DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
        break;
      case OPLS_DIHEDRAL:
        // (1/2)p_0[0]+(1/2)p_1*(1+cos(phi))+(1/2)p_2*(1-cos(2*phi))+(1/2)p_3*(1+cos(3*phi))
        // =================================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=0.5*(parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi)));
        DF=0.5*parms[1]-2.0*parms[2]*CosPhi+1.5*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case FOURIER_SERIES_DIHEDRAL:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1-cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[0]+2.0*parms[1]+parms[2]+parms[4]+2.0*parms[5]+(parms[0]-3.0*parms[2]+5.0*parms[4])*CosPhi-
               2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi2+4.0*(parms[2]-5.0*parms[4])*CosPhi2*CosPhi-
               8.0*(parms[3]-6.0*parms[5])*SQR(CosPhi2)+16.0*parms[4]*SQR(CosPhi2)*CosPhi-32.0*parms[5]*CUBE(CosPhi2));
        DF=0.5*(parms[0]-3.0*parms[2]+5.0*parms[4])-2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi+
           6.0*(parms[2]-5.0*parms[4])*CosPhi2-16.0*(parms[3]-6.0*parms[5])*CosPhi2*CosPhi+40.0*parms[4]*SQR(CosPhi2)-96.0*parms[5]*CosPhi2*CUBE(CosPhi);
        break;
      case FOURIER_SERIES_DIHEDRAL2:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1+cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[2]+2.0*parms[3]+parms[4]-3.0*parms[2]*CosPhi+5.0*parms[4]*CosPhi+parms[0]*(1.0+CosPhi)+
          2.0*(parms[1]-parms[1]*CosPhi2+CosPhi2*(parms[5]*SQR(3.0-4.0*CosPhi2)+4.0*parms[3]*(CosPhi2-1.0)+
          2.0*CosPhi*(parms[2]+parms[4]*(4.0*CosPhi2-5.0)))));
        DF=0.5*parms[0]+parms[2]*(6.0*CosPhi2-1.5)+parms[4]*(2.5-30.0*CosPhi2+40.0*SQR(CosPhi2))+
           CosPhi*(-2.0*parms[1]+parms[3]*(16.0*CosPhi2-8.0)+parms[5]*(18.0-96.0*CosPhi2+96.0*SQR(CosPhi2)));
        break;
      case FIXED_DIHEDRAL:
        U=DF=0;
        break;
      default:
        fprintf(stderr, "Undefined Torsion potential in routine 'CalculateCationTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UCationTorsion[CurrentSystem]+=U;

    // virial
    // pure torsion has *no* contributions to the virial

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DF*dtA.x;
    fa.y=-DF*dtA.y;
    fa.z=-DF*dtA.z;

    fb.x=-DF*dtB.x;
    fb.y=-DF*dtB.y;
    fb.z=-DF*dtB.z;

    fc.x=-DF*dtC.x;
    fc.y=-DF*dtC.y;
    fc.z=-DF*dtC.z;

    fd.x=-DF*dtD.x;
    fd.y=-DF*dtD.y;
    fd.z=-DF*dtD.z;

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
  }
}



void CalculateAdsorbateImproperTorsionForce(int m)
{
  int i,Type,NumberOfImproperTorsions,A,B,C,D;
  POINT posA,posB,posC,posD;
  REAL d,e,rbc;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,U,DF;
  VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
  VECTOR fa,fb,fc,fd;
  REAL *parms;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfImproperTorsions=Components[Type].NumberOfImproperTorsions;
  for(i=0;i<NumberOfImproperTorsions;i++)
  {
    A=Components[Type].ImproperTorsions[i].A;
    B=Components[Type].ImproperTorsions[i].B;
    C=Components[Type].ImproperTorsions[i].C;
    D=Components[Type].ImproperTorsions[i].D;
    parms=(REAL*)&Components[Type].ImproperTorsionArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    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;
    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(Components[Type].ImproperTorsionType[i])
    {
      case HARMONIC_IMPROPER_DIHEDRAL:
        // (1/2)*p_0*(phi-p_1)^2
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as Rbc, and negative otherwise
        Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
        Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
        Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
        Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
        Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
        Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
        sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
              +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
        Phi=SIGN(acos(CosPhi),sign);
        SinPhi=sin(Phi);
        Phi-=parms[1];
        Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
        U=0.5*parms[0]*SQR(Phi);
        DF=-parms[0]*(Phi)/SinPhi;
        break;
      case HARMONIC_COSINE_IMPROPER_DIHEDRAL:
        // (1/2)*p_0*(cos(phi)-cos(p_1))^2
        // ===============================================
        // p_0/k_B [K]
        // p_1     [degrees]
        U=0.5*parms[0]*SQR(CosPhi-parms[1]);
        DF=parms[0]*(CosPhi-parms[1]);
        break;
      case THREE_COSINE_IMPROPER_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case MM3_IMPROPER_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0     [kcal/mol]
        // p_1     [kcal/mol]
        // p_2     [kcal/mol]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case CFF_IMPROPER_DIHEDRAL:
        // p_0*(1-cos(phi))+p_1*(1-cos(2*phi))+p_2*(1-cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2);
        DF=-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2);
        break;
      case CFF_IMPROPER_DIHEDRAL2:
        // p_0*(1+cos(phi))+p_1*(1+cos(2*phi))+p_2*(1+cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi));
        DF=parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi);
        break;
      case SIX_COSINE_IMPROPER_DIHEDRAL:
        // Prod_i=0^5 p_i*cos(phi)^i
        // =========================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        // the Ryckaert-Bellemans potentials is often used for alkanes, the use implies exclusion of VDW-interactions
        // between the first and last atoms of the dihedral, and Phi'=Phi-Pi is defined accoording to the
        // polymer convention Phi'(trans)=0.
        U=parms[0]-parms[1]*CosPhi+parms[2]*CosPhi2-parms[3]*CosPhi*CosPhi2+
               parms[4]*SQR(CosPhi2)-parms[5]*SQR(CosPhi2)*CosPhi;
        DF=-parms[1]+2.0*parms[2]*CosPhi-3.0*parms[3]*CosPhi2+4.0*parms[4]*CosPhi2*CosPhi-5.0*parms[5]*SQR(CosPhi2);
        break;
      case TRAPPE_IMPROPER_DIHEDRAL:
        // p_0+p_1*(1+cos(phi))+p_2*(1-cos(2*phi))+p_3*(1+cos(3*phi))
        // ==========================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi));
        DF=parms[1]-4.0*parms[2]*CosPhi+3.0*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case TRAPPE_IMPROPER_DIHEDRAL_EXTENDED:
        // p_0+p_1*cos(phi)+p_2*cos(2*phi)+p_3*cos(3*phi)+p_4*cos(4*phi)
        // =============================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        U=parms[0]-parms[2]+parms[4]+(parms[1]-3.0*parms[3])*CosPhi+(2.0*parms[2]-8.0*parms[4])*CosPhi2+4.0*parms[3]*CosPhi2*CosPhi+8.0*parms[4]*SQR(CosPhi2);
        DF=parms[1]-3.0*parms[3]+4.0*(parms[2]-4.0*parms[4])*CosPhi+12.0*parms[3]*CosPhi2+32.0*parms[4]*CosPhi2*CosPhi;
        break;
      case CVFF_IMPROPER_DIHEDRAL:
        // p_0*(1+cos(p_1*phi-p_2))
        // ========================
        // p_0/k_B [K]
        // p_1     [-]
        // p_2     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as 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);
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi);  // remove singularity
        U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
        DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
        break;
      case OPLS_IMPROPER_DIHEDRAL:
        // (1/2)p_0[0]+(1/2)p_1*(1+cos(phi))+(1/2)p_2*(1-cos(2*phi))+(1/2)p_3*(1+cos(3*phi))
        // =================================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=0.5*(parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi)));
        DF=0.5*parms[1]-2.0*parms[2]*CosPhi+1.5*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case FOURIER_SERIES_IMPROPER_DIHEDRAL:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1-cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[0]+2.0*parms[1]+parms[2]+parms[4]+2.0*parms[5]+(parms[0]-3.0*parms[2]+5.0*parms[4])*CosPhi-
               2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi2+4.0*(parms[2]-5.0*parms[4])*CosPhi2*CosPhi-
               8.0*(parms[3]-6.0*parms[5])*SQR(CosPhi2)+16.0*parms[4]*SQR(CosPhi2)*CosPhi-32.0*parms[5]*CUBE(CosPhi2));
        DF=0.5*(parms[0]-3.0*parms[2]+5.0*parms[4])-2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi+
           6.0*(parms[2]-5.0*parms[4])*CosPhi2-16.0*(parms[3]-6.0*parms[5])*CosPhi2*CosPhi+40.0*parms[4]*SQR(CosPhi2)-96.0*parms[5]*CosPhi2*CUBE(CosPhi);
        break;
      case FOURIER_SERIES_IMPROPER_DIHEDRAL2:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1+cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[2]+2.0*parms[3]+parms[4]-3.0*parms[2]*CosPhi+5.0*parms[4]*CosPhi+parms[0]*(1.0+CosPhi)+
          2.0*(parms[1]-parms[1]*CosPhi2+CosPhi2*(parms[5]*SQR(3.0-4.0*CosPhi2)+4.0*parms[3]*(CosPhi2-1.0)+
          2.0*CosPhi*(parms[2]+parms[4]*(4.0*CosPhi2-5.0)))));
        DF=0.5*parms[0]+parms[2]*(6.0*CosPhi2-1.5)+parms[4]*(2.5-30.0*CosPhi2+40.0*SQR(CosPhi2))+
           CosPhi*(-2.0*parms[1]+parms[3]*(16.0*CosPhi2-8.0)+parms[5]*(18.0-96.0*CosPhi2+96.0*SQR(CosPhi2)));
        break;
      case FIXED_IMPROPER_DIHEDRAL:
        U=DF=0;
        break;
      default:
        fprintf(stderr, "Undefined Improper-Torsion potential in routine 'CalculateAdsorbateImproperTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UAdsorbateImproperTorsion[CurrentSystem]+=U;

    // virial
    // pure torsion has *no* contributions to the virial

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DF*dtA.x;
    fa.y=-DF*dtA.y;
    fa.z=-DF*dtA.z;

    fb.x=-DF*dtB.x;
    fb.y=-DF*dtB.y;
    fb.z=-DF*dtB.z;

    fc.x=-DF*dtC.x;
    fc.y=-DF*dtC.y;
    fc.z=-DF*dtC.z;

    fd.x=-DF*dtD.x;
    fd.y=-DF*dtD.y;
    fd.z=-DF*dtD.z;

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
  }
}


void CalculateCationImproperTorsionForce(int m)
{
  int i,Type,NumberOfImproperTorsions,A,B,C,D;
  POINT posA,posB,posC,posD;
  REAL d,e,rbc;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,U,DF;
  VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
  VECTOR fa,fb,fc,fd;
  REAL *parms;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfImproperTorsions=Components[Type].NumberOfImproperTorsions;
  for(i=0;i<NumberOfImproperTorsions;i++)
  {
    A=Components[Type].ImproperTorsions[i].A;
    B=Components[Type].ImproperTorsions[i].B;
    C=Components[Type].ImproperTorsions[i].C;
    D=Components[Type].ImproperTorsions[i].D;
    parms=(REAL*)&Components[Type].ImproperTorsionArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    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;
    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(Components[Type].ImproperTorsionType[i])
    {
      case HARMONIC_COSINE_IMPROPER_DIHEDRAL:
        U=0.5*parms[0]*SQR(CosPhi-cos(parms[1]));
        DF=parms[0]*(CosPhi-cos(parms[1]));
        break;
      case HARMONIC_IMPROPER_DIHEDRAL:
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as Rbc, and negative otherwise
        Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
        Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
        Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
        Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
        Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
        Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
        sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
              +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
        Phi=SIGN(acos(CosPhi),sign);
        SinPhi=sin(Phi);
        Phi-=parms[1];
        Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
        U=0.5*parms[0]*SQR(Phi);
        DF=-parms[0]*(Phi)/SinPhi;
        break;
      case THREE_COSINE_IMPROPER_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case MM3_IMPROPER_DIHEDRAL:
        // (1/2)*p_0*(1+cos(phi))+(1/2)*p_1*(1-cos(2*phi))+(1/2)*p_2*(1+cos(3*phi))
        // ========================================================================
        // p_0     [kcal/mol]
        // p_1     [kcal/mol]
        // p_2     [kcal/mol]
        U=0.5*parms[0]*(1.0+CosPhi)+parms[1]*(1.0-CosPhi2)+0.5*parms[2]*(1.0-3.0*CosPhi+4.0*CosPhi*CosPhi2);
        DF=0.5*parms[0]-2.0*parms[1]*CosPhi+1.5*parms[2]*(4.0*CosPhi2-1.0);
        break;
      case CFF_IMPROPER_DIHEDRAL:
        // p_0*(1-cos(phi))+p_1*(1-cos(2*phi))+p_2*(1-cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0-CosPhi)+2.0*parms[1]*(1.0-CosPhi2)+parms[2]*(1.0+3.0*CosPhi-4.0*CosPhi*CosPhi2);
        DF=-parms[0]-4.0*parms[1]*CosPhi+3.0*parms[2]*(1.0-4.0*CosPhi2);
        break;
      case CFF_IMPROPER_DIHEDRAL2:
        // p_0*(1+cos(phi))+p_1*(1+cos(2*phi))+p_2*(1+cos(3*phi))
        // ======================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        U=parms[0]*(1.0+CosPhi)+parms[2]+CosPhi*(-3.0*parms[2]+2.0*CosPhi*(parms[1]+2.0*parms[2]*CosPhi));
        DF=parms[0]-3.0*parms[2]+4.0*CosPhi*(parms[1]+3.0*parms[2]*CosPhi);
        break;
      case SIX_COSINE_IMPROPER_DIHEDRAL:
        // Prod_i=0^5 p_i*cos(phi)^i
        // =========================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        // the Ryckaert-Bellemans potentials is often used for alkanes, the use implies exclusion of VDW-interactions
        // between the first and last atoms of the dihedral, and Phi'=Phi-Pi is defined accoording to the
        // polymer convention Phi'(trans)=0.
        U=parms[0]-parms[1]*CosPhi+parms[2]*CosPhi2-parms[3]*CosPhi*CosPhi2+
               parms[4]*SQR(CosPhi2)-parms[5]*SQR(CosPhi2)*CosPhi;
        DF=-parms[1]+2.0*parms[2]*CosPhi-3.0*parms[3]*CosPhi2+4.0*parms[4]*CosPhi2*CosPhi-5.0*parms[5]*SQR(CosPhi2);
        break;
      case TRAPPE_IMPROPER_DIHEDRAL:
        // p_0+p_1*(1+cos(phi))+p_2*(1-cos(2*phi))+p_3*(1+cos(3*phi))
        // ==========================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi));
        DF=parms[1]-4.0*parms[2]*CosPhi+3.0*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case TRAPPE_IMPROPER_DIHEDRAL_EXTENDED:
        // p_0+p_1*cos(phi)+p_2*cos(2*phi)+p_3*cos(3*phi)+p_4*cos(4*phi)
        // =============================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        U=parms[0]-parms[2]+parms[4]+(parms[1]-3.0*parms[3])*CosPhi+(2.0*parms[2]-8.0*parms[4])*CosPhi2+4.0*parms[3]*CosPhi2*CosPhi+8.0*parms[4]*SQR(CosPhi2);
        DF=parms[1]-3.0*parms[3]+4.0*(parms[2]-4.0*parms[4])*CosPhi+12.0*parms[3]*CosPhi2+32.0*parms[4]*CosPhi2*CosPhi;
        break;
      case CVFF_IMPROPER_DIHEDRAL:
        // p_0*(1+cos(p_1*phi-p_2))
        // ========================
        // p_0/k_B [K]
        // p_1     [-]
        // p_2     [degrees]
        // potential defined in terms of 'phi' and therefore contains a singularity
        // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
        // same direction as 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);
        SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi);  // remove singularity
        U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
        DF=(parms[0]*parms[1]*sin(parms[1]*Phi-parms[2]))/SinPhi;
        break;
      case OPLS_IMPROPER_DIHEDRAL:
        // (1/2)p_0[0]+(1/2)p_1*(1+cos(phi))+(1/2)p_2*(1-cos(2*phi))+(1/2)p_3*(1+cos(3*phi))
        // =================================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        U=0.5*(parms[0]+(1.0+CosPhi)*(parms[1]+parms[3]-2.0*(CosPhi-1.0)*(parms[2]-2.0*parms[3]*CosPhi)));
        DF=0.5*parms[1]-2.0*parms[2]*CosPhi+1.5*parms[3]*(4.0*CosPhi2-1.0);
        break;
      case FOURIER_SERIES_IMPROPER_DIHEDRAL:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1-cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[0]+2.0*parms[1]+parms[2]+parms[4]+2.0*parms[5]+(parms[0]-3.0*parms[2]+5.0*parms[4])*CosPhi-
               2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi2+4.0*(parms[2]-5.0*parms[4])*CosPhi2*CosPhi-
               8.0*(parms[3]-6.0*parms[5])*SQR(CosPhi2)+16.0*parms[4]*SQR(CosPhi2)*CosPhi-32.0*parms[5]*CUBE(CosPhi2));
        DF=0.5*(parms[0]-3.0*parms[2]+5.0*parms[4])-2.0*(parms[1]-4.0*parms[3]+9.0*parms[5])*CosPhi+
           6.0*(parms[2]-5.0*parms[4])*CosPhi2-16.0*(parms[3]-6.0*parms[5])*CosPhi2*CosPhi+40.0*parms[4]*SQR(CosPhi2)-96.0*parms[5]*CosPhi2*CUBE(CosPhi);
        break;
      case FOURIER_SERIES_IMPROPER_DIHEDRAL2:
        // (1/2)p_0*(1+cos(phi))+(1/2)p_1(1-cos(2*phi))+(1/2)*p2_2*(1+cos(3*phi))+
        // (1/2)p_3*(1+cos(4*phi))+(1/2)p_4*(1+cos(5*phi))+(1/2)p_5*(1+cos(6*phi))
        // =======================================================================
        // p_0/k_B [K]
        // p_1/k_B [K]
        // p_2/k_B [K]
        // p_3/k_B [K]
        // p_4/k_B [K]
        // p_5/k_B [K]
        U=0.5*(parms[2]+2.0*parms[3]+parms[4]-3.0*parms[2]*CosPhi+5.0*parms[4]*CosPhi+parms[0]*(1.0+CosPhi)+
          2.0*(parms[1]-parms[1]*CosPhi2+CosPhi2*(parms[5]*SQR(3.0-4.0*CosPhi2)+4.0*parms[3]*(CosPhi2-1.0)+
          2.0*CosPhi*(parms[2]+parms[4]*(4.0*CosPhi2-5.0)))));
        DF=0.5*parms[0]+parms[2]*(6.0*CosPhi2-1.5)+parms[4]*(2.5-30.0*CosPhi2+40.0*SQR(CosPhi2))+
           CosPhi*(-2.0*parms[1]+parms[3]*(16.0*CosPhi2-8.0)+parms[5]*(18.0-96.0*CosPhi2+96.0*SQR(CosPhi2)));
        break;
      case FIXED_IMPROPER_DIHEDRAL:
        U=DF=0;
        break;
      default:
        fprintf(stderr, "Undefined Improper-Torsion potential in routine 'CalculateCationImproperTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UCationImproperTorsion[CurrentSystem]+=U;

    // virial
    // pure torsion has *no* contributions to the virial

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DF*dtA.x;
    fa.y=-DF*dtA.y;
    fa.z=-DF*dtA.z;

    fb.x=-DF*dtB.x;
    fb.y=-DF*dtB.y;
    fb.z=-DF*dtB.z;

    fc.x=-DF*dtC.x;
    fc.y=-DF*dtC.y;
    fc.z=-DF*dtC.z;

    fd.x=-DF*dtD.x;
    fd.y=-DF*dtD.y;
    fd.z=-DF*dtD.z;

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
  }
}


void CalculateAdsorbateBondBondForce(int m)
{
  int i,A,B,C;
  int NumberOfBondBonds,Type;
  REAL *parms,gamma,gammc;
  REAL energy;
  REAL rab,rbc;
  VECTOR posA,posB,posC;
  VECTOR Rab,Rbc,fa,fc;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfBondBonds=Components[Type].NumberOfBondBonds;
  for(i=0;i<NumberOfBondBonds;i++)
  {
    A=Components[Type].BondBonds[i].A;
    B=Components[Type].BondBonds[i].B;
    C=Components[Type].BondBonds[i].C;
    parms=(REAL*)&Components[Type].BondBondArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));

    Rbc.x=posC.x-posB.x;
    Rbc.y=posC.y-posB.y;
    Rbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));

    switch(Components[Type].BondBondType[i])
    {
      case CVFF_BOND_BOND_CROSS:
      case CFF_BOND_BOND_CROSS:
        // p_0*(rab-p_1)*(rbc-p_2)
        // =======================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2     [A]
        energy=parms[0]*(rab-parms[1])*(rbc-parms[2]);
        gamma=-parms[0]*(rbc-parms[2])/rab;
        gammc=-parms[0]*(rab-parms[1])/rbc;
        break;
      default:
        fprintf(stderr, "Undefined Bond-Bond potential in routine 'CalculateAdsorbateBondBondForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    UAdsorbateBondBond[CurrentSystem]+=energy;

    // forces
    fa.x=gamma*Rab.x;
    fa.y=gamma*Rab.y;
    fa.z=gamma*Rab.z;

    fc.x=gammc*Rbc.x;
    fc.y=gammc*Rbc.y;
    fc.z=gammc*Rbc.z;

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=(fa.x+fc.x);
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=(fa.y+fc.y);
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=(fa.z+fc.z);

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=Rab.x*fa.x+Rbc.x*fc.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Rab.y*fa.x+Rbc.y*fc.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Rab.z*fa.x+Rbc.z*fc.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Rab.x*fa.y+Rbc.x*fc.y;
    StrainDerivativeTensor[CurrentSystem].by-=Rab.y*fa.y+Rbc.y*fc.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Rab.z*fa.y+Rbc.z*fc.y;

    StrainDerivativeTensor[CurrentSystem].az-=Rab.x*fa.z+Rbc.x*fc.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Rab.y*fa.z+Rbc.y*fc.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Rab.z*fa.z+Rbc.z*fc.z;
  }
}

void CalculateCationBondBondForce(int m)
{
  int i,A,B,C;
  int NumberOfBondBonds,Type;
  REAL *parms,gamma,gammc;
  REAL energy;
  REAL rab,rbc;
  VECTOR posA,posB,posC;
  VECTOR Rab,Rbc,fa,fc;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfBondBonds=Components[Type].NumberOfBondBonds;
  for(i=0;i<NumberOfBondBonds;i++)
  {
    A=Components[Type].BondBonds[i].A;
    B=Components[Type].BondBonds[i].B;
    C=Components[Type].BondBonds[i].C;
    parms=(REAL*)&Components[Type].BondBondArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));

    Rbc.x=posC.x-posB.x;
    Rbc.y=posC.y-posB.y;
    Rbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));

    switch(Components[Type].BondBondType[i])
    {
      case CVFF_BOND_BOND_CROSS:
      case CFF_BOND_BOND_CROSS:
        // p_0*(rab-p_1)*(rbc-p_2)
        // =======================
        // p_0/k_B [K/A^2]
        // p_1     [A]
        // p_2     [A]
        energy=parms[0]*(rab-parms[1])*(rbc-parms[2]);
        gamma=-parms[0]*(rbc-parms[2])/rab;
        gammc=-parms[0]*(rab-parms[1])/rbc;
        break;
      default:
        fprintf(stderr, "Undefined Bond-Bond potential in routine 'CalculateCationBondBondForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    UCationBondBond[CurrentSystem]+=energy;

    // forces
    fa.x=gamma*Rab.x;
    fa.y=gamma*Rab.y;
    fa.z=gamma*Rab.z;

    fc.x=gammc*Rbc.x;
    fc.y=gammc*Rbc.y;
    fc.z=gammc*Rbc.z;

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=(fa.x+fc.x);
    Cations[CurrentSystem][m].Atoms[B].Force.y-=(fa.y+fc.y);
    Cations[CurrentSystem][m].Atoms[B].Force.z-=(fa.z+fc.z);

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=Rab.x*fa.x+Rbc.x*fc.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Rab.y*fa.x+Rbc.y*fc.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Rab.z*fa.x+Rbc.z*fc.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Rab.x*fa.y+Rbc.x*fc.y;
    StrainDerivativeTensor[CurrentSystem].by-=Rab.y*fa.y+Rbc.y*fc.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Rab.z*fa.y+Rbc.z*fc.y;

    StrainDerivativeTensor[CurrentSystem].az-=Rab.x*fa.z+Rbc.x*fc.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Rab.y*fa.z+Rbc.y*fc.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Rab.z*fa.z+Rbc.z*fc.z;
  }
}



void CalculateAdsorbateBondBendForce(int m)
{
  int i,Type,NumberOfBondBends,A,B,C;
  REAL *parms,gamma,gamsa,gamsc,pterm,vterm;
  REAL CosTheta,Theta,SinTheta;
  REAL rab,rbc,rac;
  POINT posA,posB,posC;
  VECTOR Rab,Rbc,Rac,fa,fc;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfBondBends=Components[Type].NumberOfBondBends;
  for(i=0;i<NumberOfBondBends;i++)
  {
    A=Components[Type].BondBends[i].A;
    B=Components[Type].BondBends[i].B;
    C=Components[Type].BondBends[i].C;
    parms=(REAL*)&Components[Type].BondBendArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
    Rab.x/=rab;
    Rab.y/=rab;
    Rab.z/=rab;

    Rbc.x=posC.x-posB.x;
    Rbc.y=posC.y-posB.y;
    Rbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
    Rbc.x/=rbc;
    Rbc.y/=rbc;
    Rbc.z/=rbc;

    Rac.x=posC.x-posA.x;
    Rac.y=posC.y-posA.y;
    Rac.z=posC.z-posA.z;
    rac=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);
    CosTheta=SIGN(MIN2(fabs(CosTheta),(REAL)1.0),CosTheta);
    Theta=acos(CosTheta);
    SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));

    switch(Components[Type].BondBendType[i])
    {
      case CVFF_BOND_BEND_CROSS:
      case CFF_BOND_BEND_CROSS:
        // (Theta-p_0)*(p_1*(rab-p_2)+p_3*(rbc-p_4))
        // =========================================
        // p_0     [degrees]
        // p_1/k_B [K/A/rad]
        // p_2     [A]
        // p_3/k_B [K/A/rad]
        // p_4     [A]
        pterm=(Theta-parms[0])*(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]));
        vterm=0.0;
        gamma=(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]))/SinTheta;
        gamsa=-parms[1]*(Theta-parms[0]);
        gamsc=-parms[3]*(Theta-parms[0]);
        break;
      case MM3_BOND_BEND_CROSS:
        // p_0*[(rab-p_1)+(rbc-p_2)]*(Theta-p_3)
        // =====================================
        // p_0     [mdyne/rad]
        // p_1     [A]
        // p_2     [A]
        // p_3     [degrees]
        pterm=parms[0]*((rab-parms[1])+(rbc-parms[2]))*RAD2DEG*(Theta-parms[3]);
        vterm=0.0;
        gamma=parms[0]*RAD2DEG*((rab-parms[1])+(rbc-parms[2]))/SinTheta;
        gamsa=-parms[0]*RAD2DEG*(Theta-parms[3]);
        gamsc=-parms[0]*RAD2DEG*(Theta-parms[3]);
        break;
      case TRUNCATED_HARMONIC:
        // (1/2)*p_0*(Theta-p_1)^2*exp(-(pow(rab,8)+pow(rbc,8))/pow(p_2,8))
        // ================================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2     [A]
        pterm=0.5*parms[0]*SQR(Theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8));
        vterm=-8.0*pterm*(pow(rab,8)+pow(rbc,8))/pow(parms[2],8);
        gamma=(parms[0]*(Theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8)))/SinTheta;
        gamsa=(8.0*pterm/pow(parms[2],8))*pow(rab,7);
        gamsc=(8.0*pterm/pow(parms[2],8))*pow(rbc,7);
        break;
      case SCREENED_HARMONIC:
        // (1/2)*p_0*(Theta-p_1)^2*exp(-(rab/p_2+rbc/p_3))
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2     [A]
        // p_3     [A]
        pterm=0.5*parms[0]*SQR(Theta-parms[1])*exp(-(rab/parms[2]+rbc/parms[3]));
        vterm=-pterm*(rab/parms[2]+rbc/parms[3]);
        gamma=(parms[0]*(Theta-parms[1])*exp(-(rab/parms[2]+rbc/parms[3])))/SinTheta;
        gamsa=(pterm/parms[2]);
        gamsc=(pterm/parms[3]);
        break;
      case SCREENED_VESSAL:
        // (p_0/(8.0*(Theta-PI)^2))*((p_1-PI)^2-(Theta-PI)^2)^2*exp(-(rab/p_2+rbc/p_3))
        // ============================================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2     [A]
        // p_3     [A]
        pterm=(parms[0]/(8.0*SQR(Theta-M_PI)))*SQR(SQR(parms[1]-M_PI)-SQR(Theta-M_PI))
              *exp(-(rab/parms[2]+rbc/parms[3]));
        vterm=-pterm*(rab/parms[2]+rbc/parms[3]);
        gamma=(parms[0]/(2.0*SQR(Theta-M_PI))*(SQR(parms[1]-M_PI)-SQR(Theta-M_PI))*(Theta-M_PI)
              *exp(-(rab/parms[2]+rbc/parms[3])))/SinTheta;
        gamsa=(pterm/parms[2]);
        gamsc=(pterm/parms[3]);
        break;
      case TRUNCATED_VESSAL:
        // p_0*[pow(theta,p_2)*(theta-p_1)^2*(theta+p_1-2.0*PI)^2-0.5*p_2*pow(PI,p_2-1.0)*(theta-p_1)^2*pow(PI-p_1,3)]
        //    *exp(-(pow(rab,8)+pow(rbc,8))/pow(p_3,8))
        // ============================================================================
        // p_0/k_B [K/rad^(4+p_2)]
        // p_1     [degrees]
        // p_2     [-]
        // p_3     [A]
        pterm=parms[0]*(pow(Theta,parms[2])*SQR(Theta-parms[1])*SQR(Theta+parms[1]-2.0*M_PI)
              -0.5*parms[2]*pow((REAL)M_PI,(parms[2]-1.0))*SQR(Theta-parms[1])*pow(M_PI-parms[1],(REAL)3.0))
              *exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[3],8));
        vterm=-8.0*pterm*(pow(rab,8)+pow(rbc,8))/pow(parms[3],8);
        gamma=(parms[0]*(pow(Theta,(parms[2]-1.0))*(Theta-parms[1])*(Theta+parms[1]-2.0*M_PI)
               *((parms[2]+4.0)*SQR(Theta)-2.0*M_PI*(parms[2]+2.0)*Theta+parms[2]*parms[1]*
               (2.0*M_PI-parms[1]))-parms[2]*pow((REAL)M_PI,(parms[2]-1.0))*(Theta-parms[1])*
               pow(M_PI-parms[1],3))*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[3],8)))/SinTheta;
        gamsa=(8.0*pterm/pow(parms[3],8))*pow(rab,7);
        gamsc=(8.0*pterm/pow(parms[3],8))*pow(rbc,7);
        break;
      default:
        fprintf(stderr, "Undefined Bond-Bend potential in routine 'CalculateAdsorbateBondBendForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UAdsorbateBondBend[CurrentSystem]+=pterm;

    // forces
    fa.x=gamma*(Rbc.x-Rab.x*CosTheta)/rab+gamsa*Rab.x;
    fa.y=gamma*(Rbc.y-Rab.y*CosTheta)/rab+gamsa*Rab.y;
    fa.z=gamma*(Rbc.z-Rab.z*CosTheta)/rab+gamsa*Rab.z;

    fc.x=gamma*(Rab.x-Rbc.x*CosTheta)/rbc+gamsc*Rbc.x;
    fc.y=gamma*(Rab.y-Rbc.y*CosTheta)/rbc+gamsc*Rbc.y;
    fc.z=gamma*(Rab.z-Rbc.z*CosTheta)/rbc+gamsc*Rbc.z;

    // add contribution to the forces
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=(fa.x+fc.x);
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=(fa.y+fc.y);
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=(fa.z+fc.z);

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=(rab*Rab.x*fa.x+rbc*Rbc.x*fc.x);
    StrainDerivativeTensor[CurrentSystem].ay-=(rab*Rab.x*fa.y+rbc*Rbc.x*fc.y);
    StrainDerivativeTensor[CurrentSystem].az-=(rab*Rab.x*fa.z+rbc*Rbc.x*fc.z);

    StrainDerivativeTensor[CurrentSystem].bx-=(rab*Rab.y*fa.x+rbc*Rbc.y*fc.x);
    StrainDerivativeTensor[CurrentSystem].by-=(rab*Rab.y*fa.y+rbc*Rbc.y*fc.y);
    StrainDerivativeTensor[CurrentSystem].bz-=(rab*Rab.y*fa.z+rbc*Rbc.y*fc.z);

    StrainDerivativeTensor[CurrentSystem].cx-=(rab*Rab.z*fa.x+rbc*Rbc.z*fc.x);
    StrainDerivativeTensor[CurrentSystem].cy-=(rab*Rab.z*fa.y+rbc*Rbc.z*fc.y);
    StrainDerivativeTensor[CurrentSystem].cz-=(rab*Rab.z*fa.z+rbc*Rbc.z*fc.z);
  }
}

void CalculateCationBondBendForce(int m)
{
  int i,Type,NumberOfBondBends,A,B,C;
  REAL *parms,gamma,gamsa,gamsc,pterm,vterm;
  REAL CosTheta,Theta,SinTheta;
  REAL rab,rbc,rac;
  POINT posA,posB,posC;
  VECTOR Rab,Rbc,Rac,fa,fc;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfBondBends=Components[Type].NumberOfBondBends;
  for(i=0;i<NumberOfBondBends;i++)
  {
    A=Components[Type].BondBends[i].A;
    B=Components[Type].BondBends[i].B;
    C=Components[Type].BondBends[i].C;
    parms=(REAL*)&Components[Type].BondBendArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
    Rab.x/=rab;
    Rab.y/=rab;
    Rab.z/=rab;

    Rbc.x=posC.x-posB.x;
    Rbc.y=posC.y-posB.y;
    Rbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
    Rbc.x/=rbc;
    Rbc.y/=rbc;
    Rbc.z/=rbc;

    Rac.x=posC.x-posA.x;
    Rac.y=posC.y-posA.y;
    Rac.z=posC.z-posA.z;
    rac=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);
    CosTheta=SIGN(MIN2(fabs(CosTheta),(REAL)1.0),CosTheta);
    Theta=acos(CosTheta);
    SinTheta=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta)));

    switch(Components[Type].BondBendType[i])
    {
      case CVFF_BOND_BEND_CROSS:
      case CFF_BOND_BEND_CROSS:
        // (Theta-p_0)*(p_1*(rab-p_2)+p_3*(rbc-p_4))
        // =========================================
        // p_0     [degrees]
        // p_1/k_B [K/A/rad]
        // p_2     [A]
        // p_3/k_B [K/A/rad]
        // p_4     [A]
        pterm=(Theta-parms[0])*(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]));
        vterm=0.0;
        gamma=(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]))/SinTheta;
        gamsa=-parms[1]*(Theta-parms[0]);
        gamsc=-parms[3]*(Theta-parms[0]);
        break;
      case MM3_BOND_BEND_CROSS:
        // p_0*[(rab-p_1)+(rbc-p_2)]*(Theta-p_3)
        // =====================================
        // p_0     [mdyne/rad]
        // p_1     [A]
        // p_2     [A]
        // p_3     [degrees]
        pterm=parms[0]*((rab-parms[1])+(rbc-parms[2]))*RAD2DEG*(Theta-parms[3]);
        vterm=0.0;
        gamma=parms[0]*RAD2DEG*((rab-parms[1])+(rbc-parms[2]))/SinTheta;
        gamsa=-parms[0]*RAD2DEG*(Theta-parms[3]);
        gamsc=-parms[0]*RAD2DEG*(Theta-parms[3]);
        break;
      case TRUNCATED_HARMONIC:
        // (1/2)*p_0*(Theta-p_1)^2*exp(-(pow(rab,8)+pow(rbc,8))/pow(p_2,8))
        // ================================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2     [A]
        pterm=0.5*parms[0]*SQR(Theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8));
        vterm=-8.0*pterm*(pow(rab,8)+pow(rbc,8))/pow(parms[2],8);
        gamma=(parms[0]*(Theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8)))/SinTheta;
        gamsa=(8.0*pterm/pow(parms[2],8))*pow(rab,7);
        gamsc=(8.0*pterm/pow(parms[2],8))*pow(rbc,7);
        break;
      case SCREENED_HARMONIC:
        // (1/2)*p_0*(Theta-p_1)^2*exp(-(rab/p_2+rbc/p_3))
        // ===============================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2     [A]
        // p_3     [A]
        pterm=0.5*parms[0]*SQR(Theta-parms[1])*exp(-(rab/parms[2]+rbc/parms[3]));
        vterm=-pterm*(rab/parms[2]+rbc/parms[3]);
        gamma=(parms[0]*(Theta-parms[1])*exp(-(rab/parms[2]+rbc/parms[3])))/SinTheta;
        gamsa=(pterm/parms[2]);
        gamsc=(pterm/parms[3]);
        break;
      case SCREENED_VESSAL:
        // (p_0/(8.0*(Theta-PI)^2))*((p_1-PI)^2-(Theta-PI)^2)^2*exp(-(rab/p_2+rbc/p_3))
        // ============================================================================
        // p_0/k_B [K/rad^2]
        // p_1     [degrees]
        // p_2     [A]
        // p_3     [A]
        pterm=(parms[0]/(8.0*SQR(Theta-M_PI)))*SQR(SQR(parms[1]-M_PI)-SQR(Theta-M_PI))
              *exp(-(rab/parms[2]+rbc/parms[3]));
        vterm=-pterm*(rab/parms[2]+rbc/parms[3]);
        gamma=(parms[0]/(2.0*SQR(Theta-M_PI))*(SQR(parms[1]-M_PI)-SQR(Theta-M_PI))*(Theta-M_PI)
              *exp(-(rab/parms[2]+rbc/parms[3])))/SinTheta;
        gamsa=(pterm/parms[2]);
        gamsc=(pterm/parms[3]);
        break;
      case TRUNCATED_VESSAL:
        // p_0*[pow(theta,p_2)*(theta-p_1)^2*(theta+p_1-2.0*PI)^2-0.5*p_2*pow(PI,p_2-1.0)*(theta-p_1)^2*pow(PI-p_1,3)]
        //    *exp(-(pow(rab,8)+pow(rbc,8))/pow(p_3,8))
        // ============================================================================
        // p_0/k_B [K/rad^(4+p_2)]
        // p_1     [degrees]
        // p_2     [-]
        // p_3     [A]
        pterm=parms[0]*(pow(Theta,parms[2])*SQR(Theta-parms[1])*SQR(Theta+parms[1]-2.0*M_PI)
              -0.5*parms[2]*pow((REAL)M_PI,(parms[2]-1.0))*SQR(Theta-parms[1])*pow(M_PI-parms[1],3))
              *exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[3],8));
        vterm=-8.0*pterm*(pow(rab,8)+pow(rbc,8))/pow(parms[3],8);
        gamma=(parms[0]*(pow(Theta,(parms[2]-1.0))*(Theta-parms[1])*(Theta+parms[1]-2.0*M_PI)
               *((parms[2]+4.0)*SQR(Theta)-2.0*M_PI*(parms[2]+2.0)*Theta+parms[2]*parms[1]*
               (2.0*M_PI-parms[1]))-parms[2]*pow((REAL)M_PI,(parms[2]-1.0))*(Theta-parms[1])*
               pow(M_PI-parms[1],3))*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[3],8)))/SinTheta;
        gamsa=(8.0*pterm/pow(parms[3],8))*pow(rab,7);
        gamsc=(8.0*pterm/pow(parms[3],8))*pow(rbc,7);
        break;
      default:
        fprintf(stderr, "Undefined Bond-Bend potential in routine 'CalculateCationBondBendForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UCationBondBend[CurrentSystem]+=pterm;

    // forces
    fa.x=gamma*(Rbc.x-Rab.x*CosTheta)/rab+gamsa*Rab.x;
    fa.y=gamma*(Rbc.y-Rab.y*CosTheta)/rab+gamsa*Rab.y;
    fa.z=gamma*(Rbc.z-Rab.z*CosTheta)/rab+gamsa*Rab.z;

    fc.x=gamma*(Rab.x-Rbc.x*CosTheta)/rbc+gamsc*Rbc.x;
    fc.y=gamma*(Rab.y-Rbc.y*CosTheta)/rbc+gamsc*Rbc.y;
    fc.z=gamma*(Rab.z-Rbc.z*CosTheta)/rbc+gamsc*Rbc.z;

    // add contribution to the forces
    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=(fa.x+fc.x);
    Cations[CurrentSystem][m].Atoms[B].Force.y-=(fa.y+fc.y);
    Cations[CurrentSystem][m].Atoms[B].Force.z-=(fa.z+fc.z);

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=(rab*Rab.x*fa.x+rbc*Rbc.x*fc.x);
    StrainDerivativeTensor[CurrentSystem].ay-=(rab*Rab.x*fa.y+rbc*Rbc.x*fc.y);
    StrainDerivativeTensor[CurrentSystem].az-=(rab*Rab.x*fa.z+rbc*Rbc.x*fc.z);

    StrainDerivativeTensor[CurrentSystem].bx-=(rab*Rab.y*fa.x+rbc*Rbc.y*fc.x);
    StrainDerivativeTensor[CurrentSystem].by-=(rab*Rab.y*fa.y+rbc*Rbc.y*fc.y);
    StrainDerivativeTensor[CurrentSystem].bz-=(rab*Rab.y*fa.z+rbc*Rbc.y*fc.z);

    StrainDerivativeTensor[CurrentSystem].cx-=(rab*Rab.z*fa.x+rbc*Rbc.z*fc.x);
    StrainDerivativeTensor[CurrentSystem].cy-=(rab*Rab.z*fa.y+rbc*Rbc.z*fc.y);
    StrainDerivativeTensor[CurrentSystem].cz-=(rab*Rab.z*fa.z+rbc*Rbc.z*fc.z);
  }
}

void CalculateAdsorbateBendBendForce(int m)
{
  int i,Type,NumberOfBendBends,A,B,C,D;
  POINT posA,posB,posC,posD;
  REAL energy,rab,rbc,rbd;
  VECTOR Dab,Dbc,Dbd;
  REAL dot_abc,dot_abd;
  VECTOR fa,fb,fc,fd;
  REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
  REAL DTheta1,DTheta2;
  REAL *parms;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfBendBends=Components[Type].NumberOfBendBends;
  for(i=0;i<NumberOfBendBends;i++)
  {
    A=Components[Type].BendBends[i].A;
    B=Components[Type].BendBends[i].B;
    C=Components[Type].BendBends[i].C;
    D=Components[Type].BendBends[i].D;
    parms=(REAL*)&Components[Type].BendBendArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;
    rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
    Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;

    Dbc.x=posC.x-posB.x;
    Dbc.y=posC.y-posB.y;
    Dbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Dbc.x)+SQR(Dbc.y)+SQR(Dbc.z));
    Dbc.x/=rbc; Dbc.y/=rbc; Dbc.z/=rbc;

    Dbd.x=posD.x-posB.x;
    Dbd.y=posD.y-posB.y;
    Dbd.z=posD.z-posB.z;
    rbd=sqrt(SQR(Dbd.x)+SQR(Dbd.y)+SQR(Dbd.z));
    Dbd.x/=rbd; Dbd.y/=rbd; Dbd.z/=rbd;

    dot_abc=Dab.x*Dbc.x+Dab.y*Dbc.y+Dab.z*Dbc.z;
    CosTheta1=dot_abc;
    CosTheta1=SIGN(MIN2(fabs(CosTheta1),(REAL)1.0),CosTheta1);
    Theta1=acos(CosTheta1);
    SinTheta1=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta1)));

    dot_abd=Dab.x*Dbd.x+Dab.y*Dbd.y+Dab.z*Dbd.z;
    CosTheta2=dot_abd;
    CosTheta2=SIGN(MIN2(fabs(CosTheta2),(REAL)1.0),CosTheta2);
    Theta2=acos(CosTheta2);
    SinTheta2=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta2)));

    switch(Components[Type].BendBendType[i])
    {
      case CVFF_BEND_BEND_CROSS:
      case CFF_BEND_BEND_CROSS:
        // p_0*(Theta1-p_1)*(Theta2-p_2)
        // ===================================
        // p_0/k_B [K/rad^2)]
        // p_1     [degrees]
        // p_2     [degrees]
        energy=parms[0]*(Theta1-parms[1])*(Theta2-parms[2]);
        DTheta1=parms[0]*(Theta2-parms[2])/SinTheta1;
        DTheta2=parms[0]*(Theta1-parms[1])/SinTheta2;
        break;
      case MM3_BEND_BEND_CROSS:
        // -p_0*(Theta1-p_1)*(Theta2-p_2)
        // ===================================
        // p_0     [mdyne A/rad^2]
        // p_1     [degrees]
        // p_2     [degrees]
        energy=parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])*(Theta2-parms[2]);
        DTheta1=parms[0]*SQR(RAD2DEG)*(Theta2-parms[2])/SinTheta1;
        DTheta2=parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])/SinTheta2;
        break;
      default:
        fprintf(stderr, "Undefined Bend-Bend potential in routine 'CalculateAdsorbateBendBendForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

      // energy
    UAdsorbateBendBend[CurrentSystem]+=energy;

    // forces bend
    fa.x=DTheta1*(Dbc.x-CosTheta1*Dab.x)/rab;
    fa.y=DTheta1*(Dbc.y-CosTheta1*Dab.y)/rab;
    fa.z=DTheta1*(Dbc.z-CosTheta1*Dab.z)/rab;

    fc.x=DTheta1*(Dab.x-CosTheta1*Dbc.x)/rbc;
    fc.y=DTheta1*(Dab.y-CosTheta1*Dbc.y)/rbc;
    fc.z=DTheta1*(Dab.z-CosTheta1*Dbc.z)/rbc;

    fb.x=-DTheta1*(fa.x+fc.x);
    fb.y=-DTheta1*(fa.y+fc.y);
    fb.z=-DTheta1*(fa.z+fc.z);

    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=fa.x+fc.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=fa.y+fc.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=fa.z+fc.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z;

    fa.x=DTheta2*(Dbd.x-CosTheta2*Dab.x)/rab;
    fa.y=DTheta2*(Dbd.y-CosTheta2*Dab.y)/rab;
    fa.z=DTheta2*(Dbd.z-CosTheta2*Dab.z)/rab;

    fd.x=DTheta2*(Dab.x-CosTheta2*Dbd.x)/rbd;
    fd.y=DTheta2*(Dab.y-CosTheta2*Dbd.y)/rbd;
    fd.z=DTheta2*(Dab.z-CosTheta2*Dbd.z)/rbd;

    fb.x=-DTheta2*(fa.x+fd.x);
    fb.y=-DTheta2*(fa.y+fd.y);
    fb.z=-DTheta2*(fa.z+fd.z);

    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=fa.x+fd.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=fa.y+fd.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=fa.z+fd.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbd*Dbd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbd*Dbd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbd*Dbd.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbd*Dbd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbd*Dbd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbd*Dbd.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbd*Dbd.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbd*Dbd.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbd*Dbd.z*fd.z;
  }
}

void CalculateCationBendBendForce(int m)
{
  int i,Type,NumberOfBendBends,A,B,C,D;
  POINT posA,posB,posC,posD;
  REAL energy,rab,rbc,rbd;
  VECTOR Dab,Dbc,Dbd;
  REAL dot_abc,dot_abd;
  VECTOR fa,fb,fc,fd;
  REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
  REAL DTheta1,DTheta2;
  REAL *parms;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfBendBends=Components[Type].NumberOfBendBends;
  for(i=0;i<NumberOfBendBends;i++)
  {
    A=Components[Type].BendBends[i].A;
    B=Components[Type].BendBends[i].B;
    C=Components[Type].BendBends[i].C;
    D=Components[Type].BendBends[i].D;
    parms=(REAL*)&Components[Type].BendBendArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;
    rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));
    Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;

    Dbc.x=posC.x-posB.x;
    Dbc.y=posC.y-posB.y;
    Dbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Dbc.x)+SQR(Dbc.y)+SQR(Dbc.z));
    Dbc.x/=rbc; Dbc.y/=rbc; Dbc.z/=rbc;

    Dbd.x=posD.x-posB.x;
    Dbd.y=posD.y-posB.y;
    Dbd.z=posD.z-posB.z;
    rbd=sqrt(SQR(Dbd.x)+SQR(Dbd.y)+SQR(Dbd.z));
    Dbd.x/=rbd; Dbd.y/=rbd; Dbd.z/=rbd;

    dot_abc=Dab.x*Dbc.x+Dab.y*Dbc.y+Dab.z*Dbc.z;
    CosTheta1=dot_abc;
    CosTheta1=SIGN(MIN2(fabs(CosTheta1),(REAL)1.0),CosTheta1);
    Theta1=acos(CosTheta1);
    SinTheta1=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta1)));

    dot_abd=Dab.x*Dbd.x+Dab.y*Dbd.y+Dab.z*Dbd.z;
    CosTheta2=dot_abd;
    CosTheta2=SIGN(MIN2(fabs(CosTheta2),(REAL)1.0),CosTheta2);
    Theta2=acos(CosTheta2);
    SinTheta2=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta2)));

    switch(Components[Type].BendBendType[i])
    {
      case CVFF_BEND_BEND_CROSS:
      case CFF_BEND_BEND_CROSS:
        // p_0*(Theta1-p_1)*(Theta2-p_2)
        // ===================================
        // p_0/k_B [K/rad^2)]
        // p_1     [degrees]
        // p_2     [degrees]
        energy=parms[0]*(Theta1-parms[1])*(Theta2-parms[2]);
        DTheta1=parms[0]*(Theta2-parms[2])/SinTheta1;
        DTheta2=parms[0]*(Theta1-parms[1])/SinTheta2;
        break;
      case MM3_BEND_BEND_CROSS:
        // -p_0*(Theta1-p_1)*(Theta2-p_2)
        // ===================================
        // p_0     [mdyne A/rad^2]
        // p_1     [degrees]
        // p_2     [degrees]
        energy=parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])*(Theta2-parms[2]);
        DTheta1=parms[0]*SQR(RAD2DEG)*(Theta2-parms[2])/SinTheta1;
        DTheta2=parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])/SinTheta2;
        break;
      default:
        fprintf(stderr, "Undefined Bend-Bend potential in routine 'CalculateCationBendBendForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UCationBendBend[CurrentSystem]+=energy;

    // forces bend
    fa.x=DTheta1*(Dbc.x-CosTheta1*Dab.x)/rab;
    fa.y=DTheta1*(Dbc.y-CosTheta1*Dab.y)/rab;
    fa.z=DTheta1*(Dbc.z-CosTheta1*Dab.z)/rab;

    fc.x=DTheta1*(Dab.x-CosTheta1*Dbc.x)/rbc;
    fc.y=DTheta1*(Dab.y-CosTheta1*Dbc.y)/rbc;
    fc.z=DTheta1*(Dab.z-CosTheta1*Dbc.z)/rbc;

    fb.x=-DTheta1*(fa.x+fc.x);
    fb.y=-DTheta1*(fa.y+fc.y);
    fb.z=-DTheta1*(fa.z+fc.z);

    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=fa.x+fc.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y-=fa.y+fc.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z-=fa.z+fc.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z;

    fa.x=DTheta2*(Dbd.x-CosTheta2*Dab.x)/rab;
    fa.y=DTheta2*(Dbd.y-CosTheta2*Dab.y)/rab;
    fa.z=DTheta2*(Dbd.z-CosTheta2*Dab.z)/rab;

    fd.x=DTheta2*(Dab.x-CosTheta2*Dbd.x)/rbd;
    fd.y=DTheta2*(Dab.y-CosTheta2*Dbd.y)/rbd;
    fd.z=DTheta2*(Dab.z-CosTheta2*Dbd.z)/rbd;

    fb.x=-DTheta2*(fa.x+fd.x);
    fb.y=-DTheta2*(fa.y+fd.y);
    fb.z=-DTheta2*(fa.z+fd.z);

    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=fa.x+fd.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y-=fa.y+fd.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z-=fa.z+fd.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbd*Dbd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbd*Dbd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbd*Dbd.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbd*Dbd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbd*Dbd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbd*Dbd.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbd*Dbd.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbd*Dbd.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbd*Dbd.z*fd.z;
  }
}

void CalculateAdsorbateBendTorsionForce(int m)
{
  int i,A,B,C,D,Type;
  POINT posA,posB,posC,posD;
  REAL d,e, energy,rab,rbc,rcd;
  VECTOR Dab,Dbc,Dcd,dr,ds;
  REAL dot_ab,dot_cd,r,s;
  REAL CosPhi,CosPhi2,DCos;
  VECTOR dtA,dtB,dtC,dtD,fa,fb,fc,fd,Pb,Pc;
  REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
  REAL DTheta1,DTheta2,sign,Phi,SinPhi;
  REAL *parms;

  Type=Adsorbates[CurrentSystem][m].Type;
  for(i=0;i<Components[Type].NumberOfBendTorsions;i++)
  {
    A=Components[Type].BendTorsions[i].A;
    B=Components[Type].BendTorsions[i].B;
    C=Components[Type].BendTorsions[i].C;
    D=Components[Type].BendTorsions[i].D;
    parms=(REAL*)&Components[Type].BendTorsionArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;
    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;
    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;
    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=SIGN(MIN2(fabs(CosTheta1),(REAL)1.0),CosTheta1);
    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=SIGN(MIN2(fabs(CosTheta2),(REAL)1.0),CosTheta2);
    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=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=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(Components[Type].BendTorsionType[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 'CalculateAdsorbateBendTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UAdsorbateBendTorsion[CurrentSystem]+=energy;

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DCos*dtA.x;
    fa.y=-DCos*dtA.y;
    fa.z=-DCos*dtA.z;

    fb.x=-DCos*dtB.x;
    fb.y=-DCos*dtB.y;
    fb.z=-DCos*dtB.z;

    fc.x=-DCos*dtC.x;
    fc.y=-DCos*dtC.y;
    fc.z=-DCos*dtC.z;

    fd.x=-DCos*dtD.x;
    fd.y=-DCos*dtD.y;
    fd.z=-DCos*dtD.z;

    // forces torsion
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dbc.x*rbc*(fc.x+fd.x)+Dcd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dbc.y*rbc*(fc.x+fd.x)+Dcd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dbc.z*rbc*(fc.x+fd.x)+Dcd.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dbc.x*rbc*(fc.y+fd.y)+Dcd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dbc.y*rbc*(fc.y+fd.y)+Dcd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dbc.z*rbc*(fc.y+fd.y)+Dcd.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dbc.x*rbc*(fc.z+fd.z)+Dcd.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dbc.y*rbc*(fc.z+fd.z)+Dcd.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dbc.z*rbc*(fc.z+fd.z)+Dcd.z*fd.z;

    Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
    Dcd.x/=rcd; Dcd.y/=rcd; Dcd.z/=rcd;

    // forces bends
    fa.x=DTheta1*(Dbc.x-Dab.x*CosTheta1)/rab;
    fa.y=DTheta1*(Dbc.y-Dab.y*CosTheta1)/rab;
    fa.z=DTheta1*(Dbc.z-Dab.z*CosTheta1)/rab;

    fb.x=DTheta2*(Dcd.x+Dbc.x*CosTheta2)/rbc;
    fb.y=DTheta2*(Dcd.y+Dbc.y*CosTheta2)/rbc;
    fb.z=DTheta2*(Dcd.z+Dbc.z*CosTheta2)/rbc;

    fc.x=DTheta1*(Dab.x-Dbc.x*CosTheta1)/rbc;
    fc.y=DTheta1*(Dab.y-Dbc.y*CosTheta1)/rbc;
    fc.z=DTheta1*(Dab.z-Dbc.z*CosTheta1)/rbc;

    fd.x=DTheta2*(-Dbc.x-Dcd.x*CosTheta2)/rcd;
    fd.y=DTheta2*(-Dbc.y-Dcd.y*CosTheta2)/rcd;
    fd.z=DTheta2*(-Dbc.z-Dcd.z*CosTheta2)/rcd;

    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x+=fb.x-fa.x-fc.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y+=fb.y-fa.y-fc.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z+=fb.z-fa.z-fc.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x+=fc.x-fb.x-fd.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y+=fc.y-fb.y-fd.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z+=fc.z-fb.z-fd.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x+rbc*Dbc.x*fb.x+rcd*Dcd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x+rbc*Dbc.y*fb.x+rcd*Dcd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x+rbc*Dbc.z*fb.x+rcd*Dcd.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y+rbc*Dbc.x*fb.y+rcd*Dcd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y+rbc*Dbc.y*fb.y+rcd*Dcd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y+rbc*Dbc.z*fb.y+rcd*Dcd.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z+rbc*Dbc.x*fb.z+rcd*Dcd.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z+rbc*Dbc.y*fb.z+rcd*Dcd.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z+rbc*Dbc.z*fb.z+rcd*Dcd.z*fd.z;
  }
}

void CalculateCationBendTorsionForce(int m)
{
  int i,A,B,C,D,Type;
  POINT posA,posB,posC,posD;
  REAL d,e, energy,rab,rbc,rcd;
  VECTOR Dab,Dbc,Dcd,dr,ds;
  REAL dot_ab,dot_cd,r,s;
  REAL CosPhi,CosPhi2,DCos;
  VECTOR dtA,dtB,dtC,dtD,fa,fb,fc,fd,Pb,Pc;
  REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
  REAL DTheta1,DTheta2,sign,Phi,SinPhi;
  REAL *parms;

  Type=Cations[CurrentSystem][m].Type;
  for(i=0;i<Components[Type].NumberOfBendTorsions;i++)
  {
    A=Components[Type].BendTorsions[i].A;
    B=Components[Type].BendTorsions[i].B;
    C=Components[Type].BendTorsions[i].C;
    D=Components[Type].BendTorsions[i].D;
    parms=(REAL*)&Components[Type].BendTorsionArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;
    Dab=ApplyBoundaryCondition(Dab);
    rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));

    Dbc.x=posC.x-posB.x;
    Dbc.y=posC.y-posB.y;
    Dbc.z=posC.z-posB.z;
    Dbc=ApplyBoundaryCondition(Dbc);
    rbc=sqrt(SQR(Dbc.x)+SQR(Dbc.y)+SQR(Dbc.z));
    Dbc.x/=rbc; Dbc.y/=rbc; Dbc.z/=rbc;

    Dcd.x=posD.x-posC.x;
    Dcd.y=posD.y-posC.y;
    Dcd.z=posD.z-posC.z;
    Dcd=ApplyBoundaryCondition(Dcd);
    rcd=sqrt(SQR(Dcd.x)+SQR(Dcd.y)+SQR(Dcd.z));

    dot_ab=Dab.x*Dbc.x+Dab.y*Dbc.y+Dab.z*Dbc.z;
    CosTheta1=dot_ab/rab;
    CosTheta1=SIGN(MIN2(fabs(CosTheta1),(REAL)1.0),CosTheta1);
    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=SIGN(MIN2(fabs(CosTheta2),(REAL)1.0),CosTheta2);
    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=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=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(Components[Type].BendTorsionType[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 'CalculateCationBendTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UCationBendTorsion[CurrentSystem]+=energy;

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DCos*dtA.x;
    fa.y=-DCos*dtA.y;
    fa.z=-DCos*dtA.z;

    fb.x=-DCos*dtB.x;
    fb.y=-DCos*dtB.y;
    fb.z=-DCos*dtB.z;

    fc.x=-DCos*dtC.x;
    fc.y=-DCos*dtC.y;
    fc.z=-DCos*dtC.z;

    fd.x=-DCos*dtD.x;
    fd.y=-DCos*dtD.y;
    fd.z=-DCos*dtD.z;

    // forces torsion
    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x+=fb.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y+=fb.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z+=fb.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dbc.x*rbc*(fc.x+fd.x)+Dcd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dbc.y*rbc*(fc.x+fd.x)+Dcd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dbc.z*rbc*(fc.x+fd.x)+Dcd.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dbc.x*rbc*(fc.y+fd.y)+Dcd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dbc.y*rbc*(fc.y+fd.y)+Dcd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dbc.z*rbc*(fc.y+fd.y)+Dcd.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dbc.x*rbc*(fc.z+fd.z)+Dcd.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dbc.y*rbc*(fc.z+fd.z)+Dcd.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dbc.z*rbc*(fc.z+fd.z)+Dcd.z*fd.z;

    Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
    Dcd.x/=rcd; Dcd.y/=rcd; Dcd.z/=rcd;

    // forces bends
    fa.x=DTheta1*(Dbc.x-Dab.x*CosTheta1)/rab;
    fa.y=DTheta1*(Dbc.y-Dab.y*CosTheta1)/rab;
    fa.z=DTheta1*(Dbc.z-Dab.z*CosTheta1)/rab;

    fb.x=DTheta2*(Dcd.x+Dbc.x*CosTheta2)/rbc;
    fb.y=DTheta2*(Dcd.y+Dbc.y*CosTheta2)/rbc;
    fb.z=DTheta2*(Dcd.z+Dbc.z*CosTheta2)/rbc;

    fc.x=DTheta1*(Dab.x-Dbc.x*CosTheta1)/rbc;
    fc.y=DTheta1*(Dab.y-Dbc.y*CosTheta1)/rbc;
    fc.z=DTheta1*(Dab.z-Dbc.z*CosTheta1)/rbc;

    fd.x=DTheta2*(-Dbc.x-Dcd.x*CosTheta2)/rcd;
    fd.y=DTheta2*(-Dbc.y-Dcd.y*CosTheta2)/rcd;
    fd.z=DTheta2*(-Dbc.z-Dcd.z*CosTheta2)/rcd;

    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x+=fb.x-fa.x-fc.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y+=fb.y-fa.y-fc.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z+=fb.z-fa.z-fc.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x+=fc.x-fb.x-fd.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y+=fc.y-fb.y-fd.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z+=fc.z-fb.z-fd.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x+=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y+=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z+=fd.z;

    StrainDerivativeTensor[CurrentSystem].ax-=rab*Dab.x*fa.x+rbc*Dbc.x*fc.x+rbc*Dbc.x*fb.x+rcd*Dcd.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Dab.y*fa.x+rbc*Dbc.y*fc.x+rbc*Dbc.y*fb.x+rcd*Dcd.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Dab.z*fa.x+rbc*Dbc.z*fc.x+rbc*Dbc.z*fb.x+rcd*Dcd.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Dab.x*fa.y+rbc*Dbc.x*fc.y+rbc*Dbc.x*fb.y+rcd*Dcd.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Dab.y*fa.y+rbc*Dbc.y*fc.y+rbc*Dbc.y*fb.y+rcd*Dcd.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Dab.z*fa.y+rbc*Dbc.z*fc.y+rbc*Dbc.z*fb.y+rcd*Dcd.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Dab.x*fa.z+rbc*Dbc.x*fc.z+rbc*Dbc.x*fb.z+rcd*Dcd.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Dab.y*fa.z+rbc*Dbc.y*fc.z+rbc*Dbc.y*fb.z+rcd*Dcd.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Dab.z*fa.z+rbc*Dbc.z*fc.z+rbc*Dbc.z*fb.z+rcd*Dcd.z*fd.z;
  }
}

void CalculateAdsorbateBondTorsionForce(int m)
{
  int i,A,B,C,D,Type;
  POINT posA,posB,posC,posD;
  REAL d,e, energy,rab,rbc,rcd,temp;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s;
  REAL CosPhi,CosPhi2,DCos;
  VECTOR dtA,dtB,dtC,dtD,fa,fb,fc,fd;
  REAL gamsa,gamsb,gamsc;
  REAL *parms;

  Type=Adsorbates[CurrentSystem][m].Type;
  for(i=0;i<Components[Type].NumberOfBondTorsions;i++)
  {
    A=Components[Type].BondTorsions[i].A;
    B=Components[Type].BondTorsions[i].B;
    C=Components[Type].BondTorsions[i].C;
    D=Components[Type].BondTorsions[i].D;
    parms=(REAL*)&Components[Type].BondTorsionArguments[i];

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    posC=Adsorbates[CurrentSystem][m].Atoms[C].Position;
    posD=Adsorbates[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;
    rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    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;
    rcd=sqrt(SQR(Ddc.x)+SQR(Ddc.y)+SQR(Ddc.z));

    dot_ab=Dab.x*Dcb.x+Dab.y*Dcb.y+Dab.z*Dcb.z;
    dot_cd=Ddc.x*Dcb.x+Ddc.y*Dcb.y+Ddc.z*Dcb.z;

    dr.x=Dab.x-dot_ab*Dcb.x;
    dr.y=Dab.y-dot_ab*Dcb.y;
    dr.z=Dab.z-dot_ab*Dcb.z;
    r=sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z));
    dr.x/=r; dr.y/=r; dr.z/=r;

    ds.x=Ddc.x-dot_cd*Dcb.x;
    ds.y=Ddc.y-dot_cd*Dcb.y;
    ds.z=Ddc.z-dot_cd*Dcb.z;
    s=sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z));
    ds.x/=s; ds.y/=s; ds.z/=s;

    // compute Cos(Phi)
    // Phi is defined in protein convention Phi(trans)=Pi
    CosPhi=dr.x*ds.x+dr.y*ds.y+dr.z*ds.z;

    // Ensure CosPhi is between -1 and 1.
    CosPhi=SIGN(MIN2(fabs(CosPhi),(REAL)1.0),CosPhi);
    CosPhi2=SQR(CosPhi);

    switch(Components[Type].BondTorsionType[i])
    {
      case MM3_BOND_TORSION_CROSS:
        // (1/2)p_0(r-p_3)(1+cos(phi))+(1/2)p_1(r-p_3)(1+cos(2phi))+(1/2)p_2(r-p_3)(1+cos(3phi))
        // =====================================================================================
        // p_0     [kcal/A mole]
        // p_1     [kcal/A mole]
        // p_2     [kcal/A mole]
        // p_3     [A]
        temp=(rbc-parms[3]);
        energy=parms[0]*temp*CosPhi+parms[1]*temp*(2.0*CosPhi2-1.0)+parms[2]*temp*(4.0*CosPhi2*CosPhi-3.0*CosPhi);
        DCos=parms[0]*temp+4.0*parms[1]*temp*CosPhi+parms[2]*temp*(12.0*CosPhi2-3.0);
        gamsa=0.0;
        gamsb=-(parms[0]*CosPhi+parms[1]*(2.0*CosPhi2-1.0)+parms[2]*(4.0*CosPhi2*CosPhi-3.0*CosPhi));
        gamsc=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Bond-Torsion potential in routine 'CalculateAdsorbateBondTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UAdsorbateBondTorsion[CurrentSystem]+=energy;

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
    Ddc.x/=rcd; Ddc.y/=rcd; Ddc.z/=rcd;

    fa.x=DCos*dtA.x-gamsa*Dab.x;
    fa.y=DCos*dtA.y-gamsa*Dab.y;
    fa.z=DCos*dtA.z-gamsa*Dab.z;

    fb.x=DCos*dtB.x+gamsb*Dcb.x+gamsa*Dab.x;
    fb.y=DCos*dtB.y+gamsb*Dcb.y+gamsa*Dab.y;
    fb.z=DCos*dtB.z+gamsb*Dcb.z+gamsa*Dab.z;

    fc.x=DCos*dtC.x-gamsb*Dcb.x+gamsc*Ddc.x;
    fc.y=DCos*dtC.y-gamsb*Dcb.y+gamsc*Ddc.y;
    fc.z=DCos*dtC.z-gamsb*Dcb.z+gamsc*Ddc.z;

    fd.x=DCos*dtD.x-gamsc*Ddc.x;
    fd.y=DCos*dtD.y-gamsc*Ddc.y;
    fd.z=DCos*dtD.z-gamsc*Ddc.z;

    // forces torsion
    Adsorbates[CurrentSystem][m].Atoms[A].Force.x-=fa.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y-=fa.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z-=fa.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=fb.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=fb.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=fb.z;

    Adsorbates[CurrentSystem][m].Atoms[C].Force.x-=fc.x;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.y-=fc.y;
    Adsorbates[CurrentSystem][m].Atoms[C].Force.z-=fc.z;

    Adsorbates[CurrentSystem][m].Atoms[D].Force.x-=fd.x;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.y-=fd.y;
    Adsorbates[CurrentSystem][m].Atoms[D].Force.z-=fd.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax+=rbc*Dcb.x*(fc.x+fd.x)+rab*Dab.x*fa.x+rcd*Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].ay+=rbc*Dcb.x*(fc.y+fd.y)+rab*Dab.x*fa.y+rcd*Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].az+=rbc*Dcb.x*(fc.z+fd.z)+rab*Dab.x*fa.z+rcd*Ddc.x*fd.z;

    StrainDerivativeTensor[CurrentSystem].bx+=rbc*Dcb.y*(fc.x+fd.x)+rab*Dab.y*fa.x+rcd*Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].by+=rbc*Dcb.y*(fc.y+fd.y)+rab*Dab.y*fa.y+rcd*Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].bz+=rbc*Dcb.y*(fc.z+fd.z)+rab*Dab.y*fa.z+rcd*Ddc.y*fd.z;

    StrainDerivativeTensor[CurrentSystem].cx+=rbc*Dcb.z*(fc.x+fd.x)+rab*Dab.z*fa.x+rcd*Ddc.z*fd.x;
    StrainDerivativeTensor[CurrentSystem].cy+=rbc*Dcb.z*(fc.y+fd.y)+rab*Dab.z*fa.y+rcd*Ddc.z*fd.y;
    StrainDerivativeTensor[CurrentSystem].cz+=rbc*Dcb.z*(fc.z+fd.z)+rab*Dab.z*fa.z+rcd*Ddc.z*fd.z;
  }
}

void CalculateCationBondTorsionForce(int m)
{
  int i,A,B,C,D,Type;
  POINT posA,posB,posC,posD;
  REAL d,e, energy,rab,rbc,rcd,temp;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s;
  REAL CosPhi,CosPhi2,DCos;
  VECTOR dtA,dtB,dtC,dtD,fa,fb,fc,fd;
  REAL gamsa,gamsb,gamsc;
  REAL *parms;

  Type=Cations[CurrentSystem][m].Type;
  for(i=0;i<Components[Type].NumberOfBondTorsions;i++)
  {
    A=Components[Type].BondTorsions[i].A;
    B=Components[Type].BondTorsions[i].B;
    C=Components[Type].BondTorsions[i].C;
    D=Components[Type].BondTorsions[i].D;
    parms=(REAL*)&Components[Type].BondTorsionArguments[i];

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    posC=Cations[CurrentSystem][m].Atoms[C].Position;
    posD=Cations[CurrentSystem][m].Atoms[D].Position;

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;
    Dab=ApplyBoundaryCondition(Dab);
    rab=sqrt(SQR(Dab.x)+SQR(Dab.y)+SQR(Dab.z));

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    Dcb=ApplyBoundaryCondition(Dcb);
    rbc=sqrt(SQR(Dcb.x)+SQR(Dcb.y)+SQR(Dcb.z));
    Dcb.x/=rbc; Dcb.y/=rbc; Dcb.z/=rbc;

    Ddc.x=posD.x-posC.x;
    Ddc.y=posD.y-posC.y;
    Ddc.z=posD.z-posC.z;
    Ddc=ApplyBoundaryCondition(Ddc);
    rcd=sqrt(SQR(Ddc.x)+SQR(Ddc.y)+SQR(Ddc.z));

    dot_ab=Dab.x*Dcb.x+Dab.y*Dcb.y+Dab.z*Dcb.z;
    dot_cd=Ddc.x*Dcb.x+Ddc.y*Dcb.y+Ddc.z*Dcb.z;

    dr.x=Dab.x-dot_ab*Dcb.x;
    dr.y=Dab.y-dot_ab*Dcb.y;
    dr.z=Dab.z-dot_ab*Dcb.z;
    r=sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z));
    dr.x/=r; dr.y/=r; dr.z/=r;

    ds.x=Ddc.x-dot_cd*Dcb.x;
    ds.y=Ddc.y-dot_cd*Dcb.y;
    ds.z=Ddc.z-dot_cd*Dcb.z;
    s=sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z));
    ds.x/=s; ds.y/=s; ds.z/=s;

    // compute Cos(Phi)
    // Phi is defined in protein convention Phi(trans)=Pi
    CosPhi=dr.x*ds.x+dr.y*ds.y+dr.z*ds.z;

    // Ensure CosPhi is between -1 and 1.
    CosPhi=SIGN(MIN2(fabs(CosPhi),(REAL)1.0),CosPhi);
    CosPhi2=SQR(CosPhi);

    switch(Components[Type].BondTorsionType[i])
    {
      case MM3_BOND_TORSION_CROSS:
        // (1/2)p_0(r-p_3)(1+cos(phi))+(1/2)p_1(r-p_3)(1+cos(2phi))+(1/2)p_2(r-p_3)(1+cos(3phi))
        // =====================================================================================
        // p_0     [kcal/A mole]
        // p_1     [kcal/A mole]
        // p_2     [kcal/A mole]
        // p_3     [A]
        temp=(rbc-parms[3]);
        energy=parms[0]*temp*CosPhi+parms[1]*temp*(2.0*CosPhi2-1.0)+parms[2]*temp*(4.0*CosPhi2*CosPhi-3.0*CosPhi);
        DCos=parms[0]*temp+4.0*parms[1]*temp*CosPhi+parms[2]*temp*(12.0*CosPhi2-3.0);
        gamsa=0.0;
        gamsb=-(parms[0]*CosPhi+parms[1]*(2.0*CosPhi2-1.0)+parms[2]*(4.0*CosPhi2*CosPhi-3.0*CosPhi));
        gamsc=0.0;
        break;
      default:
        fprintf(stderr, "Undefined Bond-Torsion potential in routine 'CalculateCationBondTorsionForce' ('internal_force.c')\n");
        exit(0);
        break;
    }

    // energy
    UCationBondTorsion[CurrentSystem]+=energy;

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    Dab.x/=rab; Dab.y/=rab; Dab.z/=rab;
    Ddc.x/=rcd; Ddc.y/=rcd; Ddc.z/=rcd;

    fa.x=DCos*dtA.x-gamsa*Dab.x;
    fa.y=DCos*dtA.y-gamsa*Dab.y;
    fa.z=DCos*dtA.z-gamsa*Dab.z;

    fb.x=DCos*dtB.x+gamsb*Dcb.x+gamsa*Dab.x;
    fb.y=DCos*dtB.y+gamsb*Dcb.y+gamsa*Dab.y;
    fb.z=DCos*dtB.z+gamsb*Dcb.z+gamsa*Dab.z;

    fc.x=DCos*dtC.x-gamsb*Dcb.x+gamsc*Ddc.x;
    fc.y=DCos*dtC.y-gamsb*Dcb.y+gamsc*Ddc.y;
    fc.z=DCos*dtC.z-gamsb*Dcb.z+gamsc*Ddc.z;

    fd.x=DCos*dtD.x-gamsc*Ddc.x;
    fd.y=DCos*dtD.y-gamsc*Ddc.y;
    fd.z=DCos*dtD.z-gamsc*Ddc.z;

    // forces torsion
    Cations[CurrentSystem][m].Atoms[A].Force.x-=fa.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y-=fa.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z-=fa.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=fb.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y-=fb.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z-=fb.z;

    Cations[CurrentSystem][m].Atoms[C].Force.x-=fc.x;
    Cations[CurrentSystem][m].Atoms[C].Force.y-=fc.y;
    Cations[CurrentSystem][m].Atoms[C].Force.z-=fc.z;

    Cations[CurrentSystem][m].Atoms[D].Force.x-=fd.x;
    Cations[CurrentSystem][m].Atoms[D].Force.y-=fd.y;
    Cations[CurrentSystem][m].Atoms[D].Force.z-=fd.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax+=rbc*Dcb.x*(fc.x+fd.x)+rab*Dab.x*fa.x+rcd*Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].ay+=rbc*Dcb.x*(fc.y+fd.y)+rab*Dab.x*fa.y+rcd*Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].az+=rbc*Dcb.x*(fc.z+fd.z)+rab*Dab.x*fa.z+rcd*Ddc.x*fd.z;

    StrainDerivativeTensor[CurrentSystem].bx+=rbc*Dcb.y*(fc.x+fd.x)+rab*Dab.y*fa.x+rcd*Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].by+=rbc*Dcb.y*(fc.y+fd.y)+rab*Dab.y*fa.y+rcd*Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].bz+=rbc*Dcb.y*(fc.z+fd.z)+rab*Dab.y*fa.z+rcd*Ddc.y*fd.z;

    StrainDerivativeTensor[CurrentSystem].cx+=rbc*Dcb.z*(fc.x+fd.x)+rab*Dab.z*fa.x+rcd*Ddc.z*fd.x;
    StrainDerivativeTensor[CurrentSystem].cy+=rbc*Dcb.z*(fc.y+fd.y)+rab*Dab.z*fa.y+rcd*Ddc.z*fd.y;
    StrainDerivativeTensor[CurrentSystem].cz+=rbc*Dcb.z*(fc.z+fd.z)+rab*Dab.z*fa.z+rcd*Ddc.z*fd.z;
  }
}




// calculate intra LJ-force (status: tested and working)
void CalculateAdsorbateIntraVDWForce(int m)
{
  int i,NumberOfIntraVDW,Type,typeA,typeB,A,B;
  REAL rr,energy,force_factor,Scaling;
  VECTOR dr,f;
  POINT posA,posB;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfIntraVDW=Components[Type].NumberOfIntraVDW;
  for(i=0;i<NumberOfIntraVDW;i++)
  {
    A=Components[Type].IntraVDW[i].A;
    B=Components[Type].IntraVDW[i].B;
    Scaling=Components[Type].IntraVDWScaling[i];
    typeA=Adsorbates[CurrentSystem][m].Atoms[A].Type;
    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

    // note: a cutoff is also used for intra-van der Waals forces
    if(rr<CutOffVDWSquared)
    {
      typeB=Adsorbates[CurrentSystem][m].Atoms[B].Type;
      PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
      energy*=Scaling;
      force_factor*=Scaling;

      // energy
      UAdsorbateIntraVDW[CurrentSystem]+=energy;

      StrainDerivativeTensor[CurrentSystem].ax+=force_factor*dr.x*dr.x;
      StrainDerivativeTensor[CurrentSystem].bx+=force_factor*dr.y*dr.x;
      StrainDerivativeTensor[CurrentSystem].cx+=force_factor*dr.z*dr.x;

      StrainDerivativeTensor[CurrentSystem].ay+=force_factor*dr.x*dr.y;
      StrainDerivativeTensor[CurrentSystem].by+=force_factor*dr.y*dr.y;
      StrainDerivativeTensor[CurrentSystem].cy+=force_factor*dr.z*dr.y;

      StrainDerivativeTensor[CurrentSystem].az+=force_factor*dr.x*dr.z;
      StrainDerivativeTensor[CurrentSystem].bz+=force_factor*dr.y*dr.z;
      StrainDerivativeTensor[CurrentSystem].cz+=force_factor*dr.z*dr.z;

      // forces
      f.x=force_factor*dr.x;
      f.y=force_factor*dr.y;
      f.z=force_factor*dr.z;

      Adsorbates[CurrentSystem][m].Atoms[A].Force.x-=f.x;
      Adsorbates[CurrentSystem][m].Atoms[A].Force.y-=f.y;
      Adsorbates[CurrentSystem][m].Atoms[A].Force.z-=f.z;

      Adsorbates[CurrentSystem][m].Atoms[B].Force.x+=f.x;
      Adsorbates[CurrentSystem][m].Atoms[B].Force.y+=f.y;
      Adsorbates[CurrentSystem][m].Atoms[B].Force.z+=f.z;
    }
  }
}

// calculate intra LJ-force (status: tested and working)
void CalculateCationIntraVDWForce(int m)
{
  int i,NumberOfIntraVDW,Type,typeA,typeB,A,B;
  REAL rr,energy,force_factor,Scaling;
  VECTOR dr,f;
  POINT posA,posB;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfIntraVDW=Components[Type].NumberOfIntraVDW;
  for(i=0;i<NumberOfIntraVDW;i++)
  {
    A=Components[Type].IntraVDW[i].A;
    B=Components[Type].IntraVDW[i].B;
    Scaling=Components[Type].IntraVDWScaling[i];
    typeA=Cations[CurrentSystem][m].Atoms[A].Type;
    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

    // note: a cutoff is also used for intra-van der Waals forces
    if(rr<CutOffVDWSquared)
    {
      typeB=Cations[CurrentSystem][m].Atoms[B].Type;
      PotentialGradient(typeA,typeB,rr,&energy,&force_factor,1.0);
      energy*=Scaling;
      force_factor*=Scaling;

      // energy
      UCationIntraVDW[CurrentSystem]+=energy;

      StrainDerivativeTensor[CurrentSystem].ax+=force_factor*dr.x*dr.x;
      StrainDerivativeTensor[CurrentSystem].bx+=force_factor*dr.y*dr.x;
      StrainDerivativeTensor[CurrentSystem].cx+=force_factor*dr.z*dr.x;

      StrainDerivativeTensor[CurrentSystem].ay+=force_factor*dr.x*dr.y;
      StrainDerivativeTensor[CurrentSystem].by+=force_factor*dr.y*dr.y;
      StrainDerivativeTensor[CurrentSystem].cy+=force_factor*dr.z*dr.y;

      StrainDerivativeTensor[CurrentSystem].az+=force_factor*dr.x*dr.z;
      StrainDerivativeTensor[CurrentSystem].bz+=force_factor*dr.y*dr.z;
      StrainDerivativeTensor[CurrentSystem].cz+=force_factor*dr.z*dr.z;

      // forces
      f.x=force_factor*dr.x;
      f.y=force_factor*dr.y;
      f.z=force_factor*dr.z;

      Cations[CurrentSystem][m].Atoms[A].Force.x-=f.x;
      Cations[CurrentSystem][m].Atoms[A].Force.y-=f.y;
      Cations[CurrentSystem][m].Atoms[A].Force.z-=f.z;

      Cations[CurrentSystem][m].Atoms[B].Force.x+=f.x;
      Cations[CurrentSystem][m].Atoms[B].Force.y+=f.y;
      Cations[CurrentSystem][m].Atoms[B].Force.z+=f.z;
    }
  }
}

// calculate intra Coulomb-force
void CalculateAdsorbateIntraChargeChargeForce(int m)
{
  int i,NumberOfIntraChargeCharge,Type,typeA,typeB,A,B;
  REAL r,rr;
  VECTOR dr;
  POINT posA,posB;
  REAL chargeA,chargeB,temp,Scaling;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfIntraChargeCharge=Components[Type].NumberOfIntraChargeCharge;
  for(i=0;i<NumberOfIntraChargeCharge;i++)
  {
    A=Components[Type].IntraChargeCharge[i].A;
    B=Components[Type].IntraChargeCharge[i].B;
    Scaling=Components[Type].IntraChargeChargeScaling[i];

    typeA=Adsorbates[CurrentSystem][m].Atoms[A].Type;
    chargeA=Adsorbates[CurrentSystem][m].Atoms[A].Charge;
    typeB=Adsorbates[CurrentSystem][m].Atoms[B].Type;
    chargeB=Adsorbates[CurrentSystem][m].Atoms[B].Charge;

    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;
    posB=Adsorbates[CurrentSystem][m].Atoms[B].Position;
    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    // note: no cutoff used here
    switch(ChargeMethod)
    {
      case NONE:
        temp=0.0;
        break;
      case SHIFTED_COULOMB:
      case TRUNCATED_COULOMB:
      case EWALD:
      default:
        UAdsorbateIntraChargeCharge[CurrentSystem]+=Scaling*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/r;
        temp=Scaling*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/(rr*r);
        break;
    }

    StrainDerivativeTensor[CurrentSystem].ax-=temp*dr.x*dr.x;
    StrainDerivativeTensor[CurrentSystem].bx-=temp*dr.y*dr.x;
    StrainDerivativeTensor[CurrentSystem].cx-=temp*dr.z*dr.x;

    StrainDerivativeTensor[CurrentSystem].ay-=temp*dr.x*dr.y;
    StrainDerivativeTensor[CurrentSystem].by-=temp*dr.y*dr.y;
    StrainDerivativeTensor[CurrentSystem].cy-=temp*dr.z*dr.y;

    StrainDerivativeTensor[CurrentSystem].az-=temp*dr.x*dr.z;
    StrainDerivativeTensor[CurrentSystem].bz-=temp*dr.y*dr.z;
    StrainDerivativeTensor[CurrentSystem].cz-=temp*dr.z*dr.z;

    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=temp*dr.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=temp*dr.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=temp*dr.z;

    Adsorbates[CurrentSystem][m].Atoms[B].Force.x-=temp*dr.x;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.y-=temp*dr.y;
    Adsorbates[CurrentSystem][m].Atoms[B].Force.z-=temp*dr.z;
  }
}

// calculate intra Coulomb-force
void CalculateCationIntraChargeChargeForce(int m)
{
  int i,NumberOfIntraChargeCharge,Type,typeA,typeB,A,B;
  REAL r,rr;
  VECTOR dr;
  POINT posA,posB;
  REAL chargeA,chargeB,temp,Scaling;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfIntraChargeCharge=Components[Type].NumberOfIntraChargeCharge;
  for(i=0;i<NumberOfIntraChargeCharge;i++)
  {
    A=Components[Type].IntraChargeCharge[i].A;
    B=Components[Type].IntraChargeCharge[i].B;
    Scaling=Components[Type].IntraChargeChargeScaling[i];

    typeA=Cations[CurrentSystem][m].Atoms[A].Type;
    chargeA=Cations[CurrentSystem][m].Atoms[A].Charge;
    typeB=Cations[CurrentSystem][m].Atoms[B].Type;
    chargeB=Cations[CurrentSystem][m].Atoms[B].Charge;

    posA=Cations[CurrentSystem][m].Atoms[A].Position;
    posB=Cations[CurrentSystem][m].Atoms[B].Position;
    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    // note: no cutoff used here
    switch(ChargeMethod)
    {
      case NONE:
        temp=0.0;
        break;
      case SHIFTED_COULOMB:
      case TRUNCATED_COULOMB:
      case EWALD:
      default:
        UCationIntraChargeCharge[CurrentSystem]+=Scaling*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/r;
        temp=Scaling*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/(rr*r);
        break;
    }

    StrainDerivativeTensor[CurrentSystem].ax-=temp*dr.x*dr.x;
    StrainDerivativeTensor[CurrentSystem].bx-=temp*dr.y*dr.x;
    StrainDerivativeTensor[CurrentSystem].cx-=temp*dr.z*dr.x;

    StrainDerivativeTensor[CurrentSystem].ay-=temp*dr.x*dr.y;
    StrainDerivativeTensor[CurrentSystem].by-=temp*dr.y*dr.y;
    StrainDerivativeTensor[CurrentSystem].cy-=temp*dr.z*dr.y;

    StrainDerivativeTensor[CurrentSystem].az-=temp*dr.x*dr.z;
    StrainDerivativeTensor[CurrentSystem].bz-=temp*dr.y*dr.z;
    StrainDerivativeTensor[CurrentSystem].cz-=temp*dr.z*dr.z;

    Cations[CurrentSystem][m].Atoms[A].Force.x+=temp*dr.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=temp*dr.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=temp*dr.z;

    Cations[CurrentSystem][m].Atoms[B].Force.x-=temp*dr.x;
    Cations[CurrentSystem][m].Atoms[B].Force.y-=temp*dr.y;
    Cations[CurrentSystem][m].Atoms[B].Force.z-=temp*dr.z;
  }
}

// calculate intra Coulomb-force
void CalculateAdsorbateIntraChargeBondDipoleForce(int m)
{
  int i,NumberOfIntraChargeBondDipole,Type,A,B,B1,B2;
  REAL r,rr,ri2,length;
  REAL Bt0,Bt1,Bt2,cosB;
  VECTOR dr,dipoleB,term,fa1,fb1,fb2;
  POINT posA,posB,posB1,posB2;
  REAL ChargeA,temp;
  REAL DipoleMagnitudeB,energy;
  REAL fac1,fac2;
  REAL_MATRIX3x3 v;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfIntraChargeBondDipole=Components[Type].NumberOfIntraChargeBondDipole;
  for(i=0;i<NumberOfIntraChargeBondDipole;i++)
  {
    A=Components[Type].IntraChargeBondDipole[i].A;
    B=Components[Type].IntraChargeBondDipole[i].B;

    ChargeA=Adsorbates[CurrentSystem][m].Atoms[A].Charge;
    posA=Adsorbates[CurrentSystem][m].Atoms[A].Position;

    B1=Components[Type].BondDipoles[B].A;
    B2=Components[Type].BondDipoles[B].B;
    DipoleMagnitudeB=Components[Type].BondDipoleMagnitude[B];
    posB1=Adsorbates[CurrentSystem][m].Atoms[B1].Position;
    posB2=Adsorbates[CurrentSystem][m].Atoms[B2].Position;
    dipoleB.x=posB2.x-posB1.x;
    dipoleB.y=posB2.y-posB1.y;
    dipoleB.z=posB2.z-posB1.z;
    posB.x=posB1.x+0.5*dipoleB.x;
    posB.y=posB1.y+0.5*dipoleB.y;
    posB.z=posB1.z+0.5*dipoleB.z;
    ri2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
    length=sqrt(ri2);
    temp=DipoleMagnitudeB/length;
    dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

    dr.x=posB.x-posA.x;
    dr.y=posB.y-posA.y;
    dr.z=posB.z-posA.z;
    dr=ApplyBoundaryCondition(dr);
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    Bt0=1.0/(r);
    Bt1=1.0/(r*rr);
    Bt2=3.0/(r*rr*rr);
    cosB=dipoleB.x*dr.x+dipoleB.y*dr.y+dipoleB.z*dr.z;
    energy=COULOMBIC_CONVERSION_FACTOR*(Bt1*ChargeA*cosB);
    UAdsorbateIntraChargeBondDipole[CurrentSystem]-=energy;

    term.x=COULOMBIC_CONVERSION_FACTOR*ChargeA*(Bt2*cosB*dr.x-Bt1*dipoleB.x);
    term.y=COULOMBIC_CONVERSION_FACTOR*ChargeA*(Bt2*cosB*dr.y-Bt1*dipoleB.y);
    term.z=COULOMBIC_CONVERSION_FACTOR*ChargeA*(Bt2*cosB*dr.z-Bt1*dipoleB.z);

    fa1.x=term.x;
    fa1.y=term.y;
    fa1.z=term.z;

    Adsorbates[CurrentSystem][m].Atoms[A].Force.x+=fa1.x;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.y+=fa1.y;
    Adsorbates[CurrentSystem][m].Atoms[A].Force.z+=fa1.z;

    fac1=COULOMBIC_CONVERSION_FACTOR*ChargeA*Bt1*DipoleMagnitudeB/length;
    fac2=COULOMBIC_CONVERSION_FACTOR*ChargeA*Bt1*cosB/(DipoleMagnitudeB*length);

    fb1.x=0.5*term.x+fac1*dr.x-fac2*dipoleB.x;
    fb1.y=0.5*term.y+fac1*dr.y-fac2*dipoleB.y;
    fb1.z=0.5*term.z+fac1*dr.z-fac2*dipoleB.z;

    fb2.x=0.5*term.x-fac1*dr.x+fac2*dipoleB.x;
    fb2.y=0.5*term.y-fac1*dr.y+fac2*dipoleB.y;
    fb2.z=0.5*term.z-fac1*dr.z+fac2*dipoleB.z;

    Adsorbates[CurrentSystem][m].Atoms[B1].Force.x-=fb1.x;
    Adsorbates[CurrentSystem][m].Atoms[B1].Force.y-=fb1.y;
    Adsorbates[CurrentSystem][m].Atoms[B1].Force.z-=fb1.z;

    Adsorbates[CurrentSystem][m].Atoms[B2].Force.x-=fb2.x;
    Adsorbates[CurrentSystem][m].Atoms[B2].Force.y-=fb2.y;
    Adsorbates[CurrentSystem][m].Atoms[B2].Force.z-=fb2.z;

    // convert forces on atoms to molecular virial
    v.ax=fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
    v.bx=fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
    v.cx=fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);

    v.ay=fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
    v.by=fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
    v.cy=fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);

    v.az=fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
    v.bz=fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
    v.cz=fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);

    // the strain derivative
    StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x+v.ax;
    StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x+v.bx;
    StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x+v.cx;

    StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y+v.ay;
    StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y+v.by;
    StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y+v.cy;

    StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z+v.az;
    StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z+v.bz;
    StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z+v.cz;
  }
}

// calculate intra Coulomb-force
void CalculateCationIntraChargeBondDipoleForce(int m)
{
  int i,NumberOfIntraChargeBondDipole,Type,A,B,B1,B2;
  REAL r,rr,ri2,length;
  REAL Bt0,Bt1,Bt2,cosB;
  VECTOR dr,dipoleB,term,fa1,fb1,fb2;
  POINT posA,posB,posB1,posB2;
  REAL ChargeA,temp;
  REAL DipoleMagnitudeB,energy;
  REAL fac1,fac2;
  REAL_MATRIX3x3 v;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfIntraChargeBondDipole=Components[Type].NumberOfIntraChargeBondDipole;
  for(i=0;i<NumberOfIntraChargeBondDipole;i++)
  {
    A=Components[Type].IntraChargeBondDipole[i].A;
    B=Components[Type].IntraChargeBondDipole[i].B;

    ChargeA=Cations[CurrentSystem][m].Atoms[A].Charge;
    posA=Cations[CurrentSystem][m].Atoms[A].Position;

    B1=Components[Type].BondDipoles[B].A;
    B2=Components[Type].BondDipoles[B].B;
    DipoleMagnitudeB=Components[Type].BondDipoleMagnitude[B];
    posB1=Cations[CurrentSystem][m].Atoms[B1].Position;
    posB2=Cations[CurrentSystem][m].Atoms[B2].Position;
    dipoleB.x=posB2.x-posB1.x;
    dipoleB.y=posB2.y-posB1.y;
    dipoleB.z=posB2.z-posB1.z;
    posB.x=posB1.x+0.5*dipoleB.x;
    posB.y=posB1.y+0.5*dipoleB.y;
    posB.z=posB1.z+0.5*dipoleB.z;
    ri2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
    length=sqrt(ri2);
    temp=DipoleMagnitudeB/length;
    dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

    dr.x=posB.x-posA.x;
    dr.y=posB.y-posA.y;
    dr.z=posB.z-posA.z;
    dr=ApplyBoundaryCondition(dr);
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    Bt0=1.0/(r);
    Bt1=1.0/(r*rr);
    Bt2=3.0/(r*rr*rr);
    cosB=dipoleB.x*dr.x+dipoleB.y*dr.y+dipoleB.z*dr.z;
    energy=COULOMBIC_CONVERSION_FACTOR*(Bt1*ChargeA*cosB);
    UCationIntraChargeBondDipole[CurrentSystem]-=energy;

    term.x=COULOMBIC_CONVERSION_FACTOR*ChargeA*(Bt2*cosB*dr.x-Bt1*dipoleB.x);
    term.y=COULOMBIC_CONVERSION_FACTOR*ChargeA*(Bt2*cosB*dr.y-Bt1*dipoleB.y);
    term.z=COULOMBIC_CONVERSION_FACTOR*ChargeA*(Bt2*cosB*dr.z-Bt1*dipoleB.z);

    fa1.x=term.x;
    fa1.y=term.y;
    fa1.z=term.z;

    Cations[CurrentSystem][m].Atoms[A].Force.x+=fa1.x;
    Cations[CurrentSystem][m].Atoms[A].Force.y+=fa1.y;
    Cations[CurrentSystem][m].Atoms[A].Force.z+=fa1.z;

    fac1=COULOMBIC_CONVERSION_FACTOR*ChargeA*Bt1*DipoleMagnitudeB/length;
    fac2=COULOMBIC_CONVERSION_FACTOR*ChargeA*Bt1*cosB/(DipoleMagnitudeB*length);

    fb1.x=0.5*term.x+fac1*dr.x-fac2*dipoleB.x;
    fb1.y=0.5*term.y+fac1*dr.y-fac2*dipoleB.y;
    fb1.z=0.5*term.z+fac1*dr.z-fac2*dipoleB.z;

    fb2.x=0.5*term.x-fac1*dr.x+fac2*dipoleB.x;
    fb2.y=0.5*term.y-fac1*dr.y+fac2*dipoleB.y;
    fb2.z=0.5*term.z-fac1*dr.z+fac2*dipoleB.z;

    Cations[CurrentSystem][m].Atoms[B1].Force.x-=fb1.x;
    Cations[CurrentSystem][m].Atoms[B1].Force.y-=fb1.y;
    Cations[CurrentSystem][m].Atoms[B1].Force.z-=fb1.z;

    Cations[CurrentSystem][m].Atoms[B2].Force.x-=fb2.x;
    Cations[CurrentSystem][m].Atoms[B2].Force.y-=fb2.y;
    Cations[CurrentSystem][m].Atoms[B2].Force.z-=fb2.z;

    // convert forces on atoms to molecular virial
    v.ax=fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
    v.bx=fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
    v.cx=fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);

    v.ay=fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
    v.by=fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
    v.cy=fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);

    v.az=fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
    v.bz=fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
    v.cz=fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);

    // the strain derivative
    StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x+v.ax;
    StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x+v.bx;
    StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x+v.cx;

    StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y+v.ay;
    StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y+v.by;
    StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y+v.cy;

    StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z+v.az;
    StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z+v.bz;
    StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z+v.cz;
  }
}

// calculate intra Coulomb-force
void CalculateAdsorbateIntraBondDipoleBondDipoleForce(int m)
{
  int i,NumberOfIntraBondDipoleBondDipole,Type,A,B,A1,A2,B1,B2;
  REAL r,rr,ri2,rk2,length;
  REAL Bt0,Bt1,Bt2,Bt3,cosA,cosB,cosAB;
  VECTOR dr,dipoleA,dipoleB,term,termA,termB,fa1,fa2,fb1,fb2;
  POINT posA,posB,posA1,posA2,posB1,posB2;
  REAL temp;
  REAL DipoleMagnitudeA,DipoleMagnitudeB,energy;
  REAL_MATRIX3x3 v;

  Type=Adsorbates[CurrentSystem][m].Type;
  NumberOfIntraBondDipoleBondDipole=Components[Type].NumberOfIntraBondDipoleBondDipole;
  for(i=0;i<NumberOfIntraBondDipoleBondDipole;i++)
  {
    A=Components[Type].IntraBondDipoleBondDipole[i].A;
    B=Components[Type].IntraBondDipoleBondDipole[i].B;

    A1=Components[Type].BondDipoles[A].A;
    A2=Components[Type].BondDipoles[A].B;
    posA1=Adsorbates[CurrentSystem][m].Atoms[A1].Position;
    posA2=Adsorbates[CurrentSystem][m].Atoms[A2].Position;
    DipoleMagnitudeA=Components[Type].BondDipoleMagnitude[A];
    dipoleA.x=posA2.x-posA1.x;
    dipoleA.y=posA2.y-posA1.y;
    dipoleA.z=posA2.z-posA1.z;
    posA.x=posA1.x+0.5*dipoleA.x;
    posA.y=posA1.y+0.5*dipoleA.y;
    posA.z=posA1.z+0.5*dipoleA.z;
    ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
    length=sqrt(ri2);
    temp=DipoleMagnitudeA/length;
    dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

    B1=Components[Type].BondDipoles[B].A;
    B2=Components[Type].BondDipoles[B].B;
    posB1=Adsorbates[CurrentSystem][m].Atoms[B1].Position;
    posB2=Adsorbates[CurrentSystem][m].Atoms[B2].Position;
    DipoleMagnitudeB=Components[Type].BondDipoleMagnitude[B];
    dipoleB.x=posB2.x-posB1.x;
    dipoleB.y=posB2.y-posB1.y;
    dipoleB.z=posB2.z-posB1.z;
    posB.x=posB1.x+0.5*dipoleB.x;
    posB.y=posB1.y+0.5*dipoleB.y;
    posB.z=posB1.z+0.5*dipoleB.z;
    rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
    length=sqrt(rk2);
    temp=DipoleMagnitudeB/length;
    dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    dr=ApplyBoundaryCondition(dr);
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    Bt0=1.0/(r);
    Bt1=1.0/(r*rr);
    Bt2=3.0/(r*rr*rr);
    Bt3=15.0/(r*rr*rr*rr);

    cosAB=dipoleA.x*dipoleB.x+dipoleA.y*dipoleB.y+dipoleA.z*dipoleB.z;
    cosA=dipoleA.x*dr.x+dipoleA.y*dr.y+dipoleA.z*dr.z;
    cosB=dipoleB.x*dr.x+dipoleB.y*dr.y+dipoleB.z*dr.z;
    energy=COULOMBIC_CONVERSION_FACTOR*(Bt1*cosAB-Bt2*cosA*cosB);
    UAdsorbateIntraBondDipoleBondDipole[CurrentSystem]+=energy;

    term.x=COULOMBIC_CONVERSION_FACTOR*(Bt3*(cosA*cosB)*dr.x-Bt2*(cosAB*dr.x+cosB*dipoleA.x+cosA*dipoleB.x));
    term.y=COULOMBIC_CONVERSION_FACTOR*(Bt3*(cosA*cosB)*dr.y-Bt2*(cosAB*dr.y+cosB*dipoleA.y+cosA*dipoleB.y));
    term.z=COULOMBIC_CONVERSION_FACTOR*(Bt3*(cosA*cosB)*dr.z-Bt2*(cosAB*dr.z+cosB*dipoleA.z+cosA*dipoleB.z));

    termA.x=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleA.x/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt2*cosA*cosB*dipoleA.x/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt1*DipoleMagnitudeA*dipoleB.x/sqrt(ri2)
            +Bt2*DipoleMagnitudeA*cosB*dr.x/sqrt(ri2));

    termA.y=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleA.y/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt2*cosA*cosB*dipoleA.y/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt1*DipoleMagnitudeA*dipoleB.y/sqrt(ri2)
            +Bt2*DipoleMagnitudeA*cosB*dr.y/sqrt(ri2));

    termA.z=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleA.z/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt2*cosA*cosB*dipoleA.z/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt1*DipoleMagnitudeA*dipoleB.z/sqrt(ri2)
            +Bt2*DipoleMagnitudeA*cosB*dr.z/sqrt(ri2));

    termB.x=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleB.x/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt2*cosA*cosB*dipoleB.x/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt1*DipoleMagnitudeB*dipoleA.x/sqrt(rk2)
            +Bt2*DipoleMagnitudeB*cosA*dr.x/sqrt(rk2));

    termB.y=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleB.y/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt2*cosA*cosB*dipoleB.y/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt1*DipoleMagnitudeB*dipoleA.y/sqrt(rk2)
            +Bt2*DipoleMagnitudeB*cosA*dr.y/sqrt(rk2));

    termB.z=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleB.z/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt2*cosA*cosB*dipoleB.z/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt1*DipoleMagnitudeB*dipoleA.z/sqrt(rk2)
            +Bt2*DipoleMagnitudeB*cosA*dr.z/sqrt(rk2));

    fa1.x=0.5*term.x+termA.x;
    fa1.y=0.5*term.y+termA.y;
    fa1.z=0.5*term.z+termA.z;
    fa2.x=0.5*term.x-termA.x;
    fa2.y=0.5*term.y-termA.y;
    fa2.z=0.5*term.z-termA.z;

    fb1.x=-0.5*term.x+termB.x;
    fb1.y=-0.5*term.y+termB.y;
    fb1.z=-0.5*term.z+termB.z;
    fb2.x=-0.5*term.x-termB.x;
    fb2.y=-0.5*term.y-termB.y;
    fb2.z=-0.5*term.z-termB.z;

    Adsorbates[CurrentSystem][m].Atoms[A1].Force.x-=fa1.x;
    Adsorbates[CurrentSystem][m].Atoms[A1].Force.y-=fa1.y;
    Adsorbates[CurrentSystem][m].Atoms[A1].Force.z-=fa1.z;

    Adsorbates[CurrentSystem][m].Atoms[A2].Force.x-=fa2.x;
    Adsorbates[CurrentSystem][m].Atoms[A2].Force.y-=fa2.y;
    Adsorbates[CurrentSystem][m].Atoms[A2].Force.z-=fa2.z;

    Adsorbates[CurrentSystem][m].Atoms[B1].Force.x-=fb1.x;
    Adsorbates[CurrentSystem][m].Atoms[B1].Force.y-=fb1.y;
    Adsorbates[CurrentSystem][m].Atoms[B1].Force.z-=fb1.z;

    Adsorbates[CurrentSystem][m].Atoms[B2].Force.x-=fb2.x;
    Adsorbates[CurrentSystem][m].Atoms[B2].Force.y-=fb2.y;
    Adsorbates[CurrentSystem][m].Atoms[B2].Force.z-=fb2.z;

    // convert forces on atoms to molecular virial
    // usually this conversion produces a torque on the center of mass and an asymmetric stress
    // by making it symmetric we regain the 'atomic' strain derivative
    v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x)+fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
    v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x)+fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
    v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x)+fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);

    v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y)+fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
    v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y)+fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
    v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y)+fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);

    v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z)+fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
    v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z)+fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
    v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z)+fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);

    // the strain derivative
    StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x+v.ax;
    StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x+v.bx;
    StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x+v.cx;

    StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y+v.ay;
    StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y+v.by;
    StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y+v.cy;

    StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z+v.az;
    StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z+v.bz;
    StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z+v.cz;
  }
}

// calculate intra Coulomb-force
void CalculateCationIntraBondDipoleBondDipoleForce(int m)
{
  int i,NumberOfIntraBondDipoleBondDipole,Type,A,B,A1,A2,B1,B2;
  REAL r,rr,ri2,rk2,length;
  REAL Bt0,Bt1,Bt2,Bt3,cosA,cosB,cosAB;
  VECTOR dr,dipoleA,dipoleB,term,termA,termB,fa1,fa2,fb1,fb2;
  POINT posA,posB,posA1,posA2,posB1,posB2;
  REAL temp;
  REAL DipoleMagnitudeA,DipoleMagnitudeB,energy;
  REAL_MATRIX3x3 v;

  Type=Cations[CurrentSystem][m].Type;
  NumberOfIntraBondDipoleBondDipole=Components[Type].NumberOfIntraBondDipoleBondDipole;
  for(i=0;i<NumberOfIntraBondDipoleBondDipole;i++)
  {
    A=Components[Type].IntraBondDipoleBondDipole[i].A;
    B=Components[Type].IntraBondDipoleBondDipole[i].B;

    A1=Components[Type].BondDipoles[A].A;
    A2=Components[Type].BondDipoles[A].B;
    posA1=Cations[CurrentSystem][m].Atoms[A1].Position;
    posA2=Cations[CurrentSystem][m].Atoms[A2].Position;
    DipoleMagnitudeA=Components[Type].BondDipoleMagnitude[A];
    dipoleA.x=posA2.x-posA1.x;
    dipoleA.y=posA2.y-posA1.y;
    dipoleA.z=posA2.z-posA1.z;
    posA.x=posA1.x+0.5*dipoleA.x;
    posA.y=posA1.y+0.5*dipoleA.y;
    posA.z=posA1.z+0.5*dipoleA.z;
    ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
    length=sqrt(ri2);
    temp=DipoleMagnitudeA/length;
    dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

    B1=Components[Type].BondDipoles[B].A;
    B2=Components[Type].BondDipoles[B].B;
    posB1=Cations[CurrentSystem][m].Atoms[B1].Position;
    posB2=Cations[CurrentSystem][m].Atoms[B2].Position;
    DipoleMagnitudeB=Components[Type].BondDipoleMagnitude[B];
    dipoleB.x=posB2.x-posB1.x;
    dipoleB.y=posB2.y-posB1.y;
    dipoleB.z=posB2.z-posB1.z;
    posB.x=posB1.x+0.5*dipoleB.x;
    posB.y=posB1.y+0.5*dipoleB.y;
    posB.z=posB1.z+0.5*dipoleB.z;
    rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
    length=sqrt(rk2);
    temp=DipoleMagnitudeB/length;
    dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    dr=ApplyBoundaryCondition(dr);
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    Bt0=1.0/(r);
    Bt1=1.0/(r*rr);
    Bt2=3.0/(r*rr*rr);
    Bt3=15.0/(r*rr*rr*rr);

    cosAB=dipoleA.x*dipoleB.x+dipoleA.y*dipoleB.y+dipoleA.z*dipoleB.z;
    cosA=dipoleA.x*dr.x+dipoleA.y*dr.y+dipoleA.z*dr.z;
    cosB=dipoleB.x*dr.x+dipoleB.y*dr.y+dipoleB.z*dr.z;
    energy=COULOMBIC_CONVERSION_FACTOR*(Bt1*cosAB-Bt2*cosA*cosB);
    UCationIntraBondDipoleBondDipole[CurrentSystem]+=energy;

    term.x=COULOMBIC_CONVERSION_FACTOR*(Bt3*(cosA*cosB)*dr.x-Bt2*(cosAB*dr.x+cosB*dipoleA.x+cosA*dipoleB.x));
    term.y=COULOMBIC_CONVERSION_FACTOR*(Bt3*(cosA*cosB)*dr.y-Bt2*(cosAB*dr.y+cosB*dipoleA.y+cosA*dipoleB.y));
    term.z=COULOMBIC_CONVERSION_FACTOR*(Bt3*(cosA*cosB)*dr.z-Bt2*(cosAB*dr.z+cosB*dipoleA.z+cosA*dipoleB.z));

    termA.x=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleA.x/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt2*cosA*cosB*dipoleA.x/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt1*DipoleMagnitudeA*dipoleB.x/sqrt(ri2)
            +Bt2*DipoleMagnitudeA*cosB*dr.x/sqrt(ri2));

    termA.y=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleA.y/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt2*cosA*cosB*dipoleA.y/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt1*DipoleMagnitudeA*dipoleB.y/sqrt(ri2)
            +Bt2*DipoleMagnitudeA*cosB*dr.y/sqrt(ri2));

    termA.z=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleA.z/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt2*cosA*cosB*dipoleA.z/(sqrt(ri2)*DipoleMagnitudeA)
            -Bt1*DipoleMagnitudeA*dipoleB.z/sqrt(ri2)
            +Bt2*DipoleMagnitudeA*cosB*dr.z/sqrt(ri2));

    termB.x=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleB.x/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt2*cosA*cosB*dipoleB.x/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt1*DipoleMagnitudeB*dipoleA.x/sqrt(rk2)
            +Bt2*DipoleMagnitudeB*cosA*dr.x/sqrt(rk2));

    termB.y=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleB.y/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt2*cosA*cosB*dipoleB.y/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt1*DipoleMagnitudeB*dipoleA.y/sqrt(rk2)
            +Bt2*DipoleMagnitudeB*cosA*dr.y/sqrt(rk2));

    termB.z=COULOMBIC_CONVERSION_FACTOR*(
            Bt1*cosAB*dipoleB.z/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt2*cosA*cosB*dipoleB.z/(sqrt(rk2)*DipoleMagnitudeB)
            -Bt1*DipoleMagnitudeB*dipoleA.z/sqrt(rk2)
            +Bt2*DipoleMagnitudeB*cosA*dr.z/sqrt(rk2));

    fa1.x=0.5*term.x+termA.x;
    fa1.y=0.5*term.y+termA.y;
    fa1.z=0.5*term.z+termA.z;
    fa2.x=0.5*term.x-termA.x;
    fa2.y=0.5*term.y-termA.y;
    fa2.z=0.5*term.z-termA.z;

    fb1.x=-0.5*term.x+termB.x;
    fb1.y=-0.5*term.y+termB.y;
    fb1.z=-0.5*term.z+termB.z;
    fb2.x=-0.5*term.x-termB.x;
    fb2.y=-0.5*term.y-termB.y;
    fb2.z=-0.5*term.z-termB.z;

    Cations[CurrentSystem][m].Atoms[A1].Force.x-=fa1.x;
    Cations[CurrentSystem][m].Atoms[A1].Force.y-=fa1.y;
    Cations[CurrentSystem][m].Atoms[A1].Force.z-=fa1.z;

    Cations[CurrentSystem][m].Atoms[A2].Force.x-=fa2.x;
    Cations[CurrentSystem][m].Atoms[A2].Force.y-=fa2.y;
    Cations[CurrentSystem][m].Atoms[A2].Force.z-=fa2.z;

    Cations[CurrentSystem][m].Atoms[B1].Force.x-=fb1.x;
    Cations[CurrentSystem][m].Atoms[B1].Force.y-=fb1.y;
    Cations[CurrentSystem][m].Atoms[B1].Force.z-=fb1.z;

    Cations[CurrentSystem][m].Atoms[B2].Force.x-=fb2.x;
    Cations[CurrentSystem][m].Atoms[B2].Force.y-=fb2.y;
    Cations[CurrentSystem][m].Atoms[B2].Force.z-=fb2.z;

    // convert forces on atoms to molecular virial
    // usually this conversion produces a torque on the center of mass and an asymmetric stress
    // by making it symmetric we regain the 'atomic' strain derivative
    v.ax=fa1.x*(posA1.x-posA.x)+fa2.x*(posA2.x-posA.x)+fb1.x*(posB1.x-posB.x)+fb2.x*(posB2.x-posB.x);
    v.bx=fa1.y*(posA1.x-posA.x)+fa2.y*(posA2.x-posA.x)+fb1.y*(posB1.x-posB.x)+fb2.y*(posB2.x-posB.x);
    v.cx=fa1.z*(posA1.x-posA.x)+fa2.z*(posA2.x-posA.x)+fb1.z*(posB1.x-posB.x)+fb2.z*(posB2.x-posB.x);

    v.ay=fa1.x*(posA1.y-posA.y)+fa2.x*(posA2.y-posA.y)+fb1.x*(posB1.y-posB.y)+fb2.x*(posB2.y-posB.y);
    v.by=fa1.y*(posA1.y-posA.y)+fa2.y*(posA2.y-posA.y)+fb1.y*(posB1.y-posB.y)+fb2.y*(posB2.y-posB.y);
    v.cy=fa1.z*(posA1.y-posA.y)+fa2.z*(posA2.y-posA.y)+fb1.z*(posB1.y-posB.y)+fb2.z*(posB2.y-posB.y);

    v.az=fa1.x*(posA1.z-posA.z)+fa2.x*(posA2.z-posA.z)+fb1.x*(posB1.z-posB.z)+fb2.x*(posB2.z-posB.z);
    v.bz=fa1.y*(posA1.z-posA.z)+fa2.y*(posA2.z-posA.z)+fb1.y*(posB1.z-posB.z)+fb2.y*(posB2.z-posB.z);
    v.cz=fa1.z*(posA1.z-posA.z)+fa2.z*(posA2.z-posA.z)+fb1.z*(posB1.z-posB.z)+fb2.z*(posB2.z-posB.z);

    // the strain derivative
    StrainDerivativeTensor[CurrentSystem].ax+=term.x*dr.x+v.ax;
    StrainDerivativeTensor[CurrentSystem].bx+=term.y*dr.x+v.bx;
    StrainDerivativeTensor[CurrentSystem].cx+=term.z*dr.x+v.cx;

    StrainDerivativeTensor[CurrentSystem].ay+=term.x*dr.y+v.ay;
    StrainDerivativeTensor[CurrentSystem].by+=term.y*dr.y+v.by;
    StrainDerivativeTensor[CurrentSystem].cy+=term.z*dr.y+v.cy;

    StrainDerivativeTensor[CurrentSystem].az+=term.x*dr.z+v.az;
    StrainDerivativeTensor[CurrentSystem].bz+=term.y*dr.z+v.bz;
    StrainDerivativeTensor[CurrentSystem].cz+=term.z*dr.z+v.cz;
  }
}

void CalculateHarmonicBondConstraintForce(void)
{
  int m;
  REAL U,DF,r,rr;
  REAL parms0,parms1;
  POINT posA,posB;
  VECTOR dr,f;

  UDistanceConstraints[CurrentSystem]=0.0;
  for(m=0;m<NumberOfHarmonicDistanceConstraints[CurrentSystem];m++)
  {
    posA=HarmonicDistanceConstraints[CurrentSystem][m][0]->Position;
    posB=HarmonicDistanceConstraints[CurrentSystem][m][1]->Position;

    parms0=HarmonicDistanceConstraintParameters[CurrentSystem][m][0];
    parms1=HarmonicDistanceConstraintParameters[CurrentSystem][m][1];

    dr.x=posA.x-posB.x;
    dr.y=posA.y-posB.y;
    dr.z=posA.z-posB.z;
    rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
    r=sqrt(rr);

    U=0.5*parms0*SQR(r-parms1);
    DF=parms0*(r-parms1)/r;

    // add contribution to the energy
    UDistanceConstraints[CurrentSystem]+=U;

    // forces are oppositely directed to the gradient
    f.x=-DF*dr.x;
    f.y=-DF*dr.y;
    f.z=-DF*dr.z;

    // add contribution to the forces
    HarmonicDistanceConstraints[CurrentSystem][m][0]->Force.x+=f.x;
    HarmonicDistanceConstraints[CurrentSystem][m][0]->Force.y+=f.y;
    HarmonicDistanceConstraints[CurrentSystem][m][0]->Force.z+=f.z;

    HarmonicDistanceConstraints[CurrentSystem][m][1]->Force.x-=f.x;
    HarmonicDistanceConstraints[CurrentSystem][m][1]->Force.y-=f.y;
    HarmonicDistanceConstraints[CurrentSystem][m][1]->Force.z-=f.z;

    // add contribution to the stress tensor
    StrainDerivativeTensor[CurrentSystem].ax-=dr.x*f.x;
    StrainDerivativeTensor[CurrentSystem].bx-=dr.y*f.x;
    StrainDerivativeTensor[CurrentSystem].cx-=dr.z*f.x;

    StrainDerivativeTensor[CurrentSystem].ay-=dr.x*f.y;
    StrainDerivativeTensor[CurrentSystem].by-=dr.y*f.y;
    StrainDerivativeTensor[CurrentSystem].cy-=dr.z*f.y;

    StrainDerivativeTensor[CurrentSystem].az-=dr.x*f.z;
    StrainDerivativeTensor[CurrentSystem].bz-=dr.y*f.z;
    StrainDerivativeTensor[CurrentSystem].cz-=dr.z*f.z;
  }
}

void CalculateHarmonicAngleConstraintForce(void)
{
  int m;
  REAL DF,U;
  REAL CosTheta,Theta,SinTheta;
  REAL rab,rac,rbc,DTDX;
  POINT posA,posB,posC;
  VECTOR Rab,Rac,Rbc,fa,fb,fc,dtA,dtB,dtC;
  REAL parms0,parms1;

  UAngleConstraints[CurrentSystem]=0.0;
  for(m=0;m<NumberOfHarmonicAngleConstraints[CurrentSystem];m++)
  {
    posA=HarmonicAngleConstraints[CurrentSystem][m][0]->Position;
    posB=HarmonicAngleConstraints[CurrentSystem][m][1]->Position;
    posC=HarmonicAngleConstraints[CurrentSystem][m][2]->Position;

    parms0=HarmonicAngleConstraintParameters[CurrentSystem][m][0];
    parms1=HarmonicAngleConstraintParameters[CurrentSystem][m][1];

    Rab.x=posA.x-posB.x;
    Rab.y=posA.y-posB.y;
    Rab.z=posA.z-posB.z;
    rab=sqrt(SQR(Rab.x)+SQR(Rab.y)+SQR(Rab.z));
    Rab.x/=rab;
    Rab.y/=rab;
    Rab.z/=rab;

    Rbc.x=posC.x-posB.x;
    Rbc.y=posC.y-posB.y;
    Rbc.z=posC.z-posB.z;
    rbc=sqrt(SQR(Rbc.x)+SQR(Rbc.y)+SQR(Rbc.z));
    Rbc.x/=rbc;
    Rbc.y/=rbc;
    Rbc.z/=rbc;

    Rac.x=posC.x-posA.x;
    Rac.y=posC.y-posA.y;
    Rac.z=posC.z-posA.z;
    rac=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/sqrt(1.0-SQR(CosTheta));

    U=0.5*parms0*SQR(Theta-parms1);
    DF=parms0*(Theta-parms1)*DTDX;

    // add contribution to the energy
    UAngleConstraints[CurrentSystem]+=U;

    // Calculate the components of the derivatives.
    dtA.x=(Rbc.x-CosTheta*Rab.x)/rab;
    dtA.y=(Rbc.y-CosTheta*Rab.y)/rab;
    dtA.z=(Rbc.z-CosTheta*Rab.z)/rab;

    dtC.x=(Rab.x-CosTheta*Rbc.x)/rbc;
    dtC.y=(Rab.y-CosTheta*Rbc.y)/rbc;
    dtC.z=(Rab.z-CosTheta*Rbc.z)/rbc;

    dtB.x=-(dtA.x+dtC.x);
    dtB.y=-(dtA.y+dtC.y);
    dtB.z=-(dtA.z+dtC.z);

    // forces are oppositely directed to the gradient
    fa.x=-DF*dtA.x;
    fa.y=-DF*dtA.y;
    fa.z=-DF*dtA.z;

    fb.x=-DF*dtB.x;
    fb.y=-DF*dtB.y;
    fb.z=-DF*dtB.z;

    fc.x=-DF*dtC.x;
    fc.y=-DF*dtC.y;
    fc.z=-DF*dtC.z;

    // add contribution to the forces
    HarmonicAngleConstraints[CurrentSystem][m][0]->Force.x+=fa.x;
    HarmonicAngleConstraints[CurrentSystem][m][0]->Force.y+=fa.y;
    HarmonicAngleConstraints[CurrentSystem][m][0]->Force.z+=fa.z;

    HarmonicAngleConstraints[CurrentSystem][m][1]->Force.x-=(fa.x+fc.x);
    HarmonicAngleConstraints[CurrentSystem][m][1]->Force.y-=(fa.y+fc.y);
    HarmonicAngleConstraints[CurrentSystem][m][1]->Force.z-=(fa.z+fc.z);

    HarmonicAngleConstraints[CurrentSystem][m][2]->Force.x+=fc.x;
    HarmonicAngleConstraints[CurrentSystem][m][2]->Force.y+=fc.y;
    HarmonicAngleConstraints[CurrentSystem][m][2]->Force.z+=fc.z;

    // add contribution to the stress tensor
    // Note: rab and rbc are here because the vectors were normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=rab*Rab.x*fa.x+rbc*Rbc.x*fc.x;
    StrainDerivativeTensor[CurrentSystem].bx-=rab*Rab.y*fa.x+rbc*Rbc.y*fc.x;
    StrainDerivativeTensor[CurrentSystem].cx-=rab*Rab.z*fa.x+rbc*Rbc.z*fc.x;

    StrainDerivativeTensor[CurrentSystem].ay-=rab*Rab.x*fa.y+rbc*Rbc.x*fc.y;
    StrainDerivativeTensor[CurrentSystem].by-=rab*Rab.y*fa.y+rbc*Rbc.y*fc.y;
    StrainDerivativeTensor[CurrentSystem].cy-=rab*Rab.z*fa.y+rbc*Rbc.z*fc.y;

    StrainDerivativeTensor[CurrentSystem].az-=rab*Rab.x*fa.z+rbc*Rbc.x*fc.z;
    StrainDerivativeTensor[CurrentSystem].bz-=rab*Rab.y*fa.z+rbc*Rbc.y*fc.z;
    StrainDerivativeTensor[CurrentSystem].cz-=rab*Rab.z*fa.z+rbc*Rbc.z*fc.z;
  }
}

void CalculateHarmonicDihedralConstraintForce(void)
{
  int m;
  POINT posA,posB,posC,posD;
  REAL d,e,rbc;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,U,DF;
  VECTOR dtA,dtB,dtC,dtD,Pb,Pc;
  VECTOR fa,fb,fc,fd;
  REAL parms0,parms1;

  UDihedralConstraints[CurrentSystem]=0.0;
  for(m=0;m<NumberOfHarmonicDihedralConstraints[CurrentSystem];m++)
  {
    posA=HarmonicDihedralConstraints[CurrentSystem][m][0]->Position;
    posB=HarmonicDihedralConstraints[CurrentSystem][m][1]->Position;
    posC=HarmonicDihedralConstraints[CurrentSystem][m][2]->Position;
    posD=HarmonicDihedralConstraints[CurrentSystem][m][3]->Position;

    parms0=HarmonicDihedralConstraintParameters[CurrentSystem][m][0];
    parms1=HarmonicDihedralConstraintParameters[CurrentSystem][m][1];

    Dab.x=posA.x-posB.x;
    Dab.y=posA.y-posB.y;
    Dab.z=posA.z-posB.z;

    Dcb.x=posC.x-posB.x;
    Dcb.y=posC.y-posB.y;
    Dcb.z=posC.z-posB.z;
    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;
    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);

    // 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-=parms1;
    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*parms0*SQR(Phi);
    DF=-parms0*(Phi)/SinPhi;

    UDihedralConstraints[CurrentSystem]+=U;

    // Calculate the first derivative vectors.
    d=dot_ab/rbc;
    e=dot_cd/rbc;

    dtA.x=(ds.x-CosPhi*dr.x)/r;
    dtA.y=(ds.y-CosPhi*dr.y)/r;
    dtA.z=(ds.z-CosPhi*dr.z)/r;

    dtD.x=(dr.x-CosPhi*ds.x)/s;
    dtD.y=(dr.y-CosPhi*ds.y)/s;
    dtD.z=(dr.z-CosPhi*ds.z)/s;

    dtB.x=dtA.x*(d-1.0)+e*dtD.x;
    dtB.y=dtA.y*(d-1.0)+e*dtD.y;
    dtB.z=dtA.z*(d-1.0)+e*dtD.z;

    dtC.x=-dtD.x*(e+1.0)-d*dtA.x;
    dtC.y=-dtD.y*(e+1.0)-d*dtA.y;
    dtC.z=-dtD.z*(e+1.0)-d*dtA.z;

    // forces are oppositely directed to the gradient
    fa.x=-DF*dtA.x;
    fa.y=-DF*dtA.y;
    fa.z=-DF*dtA.z;

    fb.x=-DF*dtB.x;
    fb.y=-DF*dtB.y;
    fb.z=-DF*dtB.z;

    fc.x=-DF*dtC.x;
    fc.y=-DF*dtC.y;
    fc.z=-DF*dtC.z;

    fd.x=-DF*dtD.x;
    fd.y=-DF*dtD.y;
    fd.z=-DF*dtD.z;

    // add contribution to the forces
    HarmonicDihedralConstraints[CurrentSystem][m][0]->Force.x+=fa.x;
    HarmonicDihedralConstraints[CurrentSystem][m][0]->Force.y+=fa.y;
    HarmonicDihedralConstraints[CurrentSystem][m][0]->Force.z+=fa.z;

    HarmonicDihedralConstraints[CurrentSystem][m][1]->Force.x+=fb.x;
    HarmonicDihedralConstraints[CurrentSystem][m][1]->Force.y+=fb.y;
    HarmonicDihedralConstraints[CurrentSystem][m][1]->Force.z+=fb.z;

    HarmonicDihedralConstraints[CurrentSystem][m][2]->Force.x+=fc.x;
    HarmonicDihedralConstraints[CurrentSystem][m][2]->Force.y+=fc.y;
    HarmonicDihedralConstraints[CurrentSystem][m][2]->Force.z+=fc.z;

    HarmonicDihedralConstraints[CurrentSystem][m][3]->Force.x+=fd.x;
    HarmonicDihedralConstraints[CurrentSystem][m][3]->Force.y+=fd.y;
    HarmonicDihedralConstraints[CurrentSystem][m][3]->Force.z+=fd.z;

    // add contribution to the stress tensor
    // Note: rbc is here because the vector was normalized before
    StrainDerivativeTensor[CurrentSystem].ax-=Dab.x*fa.x+Dcb.x*rbc*(fc.x+fd.x)+Ddc.x*fd.x;
    StrainDerivativeTensor[CurrentSystem].bx-=Dab.y*fa.x+Dcb.y*rbc*(fc.x+fd.x)+Ddc.y*fd.x;
    StrainDerivativeTensor[CurrentSystem].cx-=Dab.z*fa.x+Dcb.z*rbc*(fc.x+fd.x)+Ddc.z*fd.x;

    StrainDerivativeTensor[CurrentSystem].ay-=Dab.x*fa.y+Dcb.x*rbc*(fc.y+fd.y)+Ddc.x*fd.y;
    StrainDerivativeTensor[CurrentSystem].by-=Dab.y*fa.y+Dcb.y*rbc*(fc.y+fd.y)+Ddc.y*fd.y;
    StrainDerivativeTensor[CurrentSystem].cy-=Dab.z*fa.y+Dcb.z*rbc*(fc.y+fd.y)+Ddc.z*fd.y;

    StrainDerivativeTensor[CurrentSystem].az-=Dab.x*fa.z+Dcb.x*rbc*(fc.z+fd.z)+Ddc.x*fd.z;
    StrainDerivativeTensor[CurrentSystem].bz-=Dab.y*fa.z+Dcb.y*rbc*(fc.z+fd.z)+Ddc.y*fd.z;
    StrainDerivativeTensor[CurrentSystem].cz-=Dab.z*fa.z+Dcb.z*rbc*(fc.z+fd.z)+Ddc.z*fd.z;
  }
}