/*************************************************************************************************************
 The MIT License

 Copyright (C) 2006-2019 David Dubbeldam, Sofia Calero, Thijs Vlugt, Donald E. Ellis, and Randall Q. Snurr.

     D.Dubbeldam@uva.nl            http://www.uva.nl/profiel/d/u/d.dubbeldam/d.dubbeldam.html
     scaldia@upo.es                http://www.upo.es/raspa/
     t.j.h.vlugt@tudelft.nl        http://homepage.tudelft.nl/v9k6y
     don-ellis@northwestern.edu    http://dvworld.northwestern.edu/
     snurr@northwestern.edu        http://zeolites.cqe.northwestern.edu/

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
 restriction, including without limitation the rights to use,
 copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:

 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "constants.h"
#include "molecule.h"
#include "framework.h"
#include "framework_energy.h"
#include "simulation.h"
#include "ewald.h"
#include "potentials.h"
#include "utils.h"
#include "output.h"
#include "cbmc.h"
#include "mc_moves.h"
#include "grids.h"
#include "spacegroup.h"

// the routines for VDW and charge-charge interaction are splitted. The VDW interactions can potentially shift the
// actual interaction site across a bond (see e.g. MM3).

// Calculate the Energy of a bead of type "typeA" at a position "posA".
// posA is defined in xyz (also for triclinic).
REAL CalculateFrameworkVDWEnergyAtPosition(POINT posA,int typeA,REAL scaling)
{
  int i,j,typeB,f1;
  REAL rr;
  REAL UVDW;
  VECTOR posB,dr,s;
  int icell,icell0;
  int ncell;

  UVDW=0.0;

  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA]))   // grid-interpolating for rigid frameworks
    {
      UVDW=InterpolateVDWGrid(typeA,posA);
      return UVDW;
    }
    else if(UseCellLists[CurrentSystem]) // energy using cell-lists
    {
      // convert from xyz to abc
      s.x=InverseBox[CurrentSystem].ax*posA.x+InverseBox[CurrentSystem].bx*posA.y+InverseBox[CurrentSystem].cx*posA.z;
      s.y=InverseBox[CurrentSystem].ay*posA.x+InverseBox[CurrentSystem].by*posA.y+InverseBox[CurrentSystem].cy*posA.z;
      s.z=InverseBox[CurrentSystem].az*posA.x+InverseBox[CurrentSystem].bz*posA.y+InverseBox[CurrentSystem].cz*posA.z;

      // apply boundary condition
      s.x-=(REAL)NINT(s.x);
      s.y-=(REAL)NINT(s.y);
      s.z-=(REAL)NINT(s.z);

      // s between 0 and 1
      s.x+=0.5;
      s.y+=0.5;
      s.z+=0.5;

      // compute the corresponding cell-id
      icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
             ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
             ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        // loop over cells
        for(i=0;i<27;i++)
        {
          icell=CellListMap[CurrentSystem][icell0][i];

          j=Framework[CurrentSystem].CellListHead[f1][icell];

          while(j>=0)
          {
            typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
            posB=Framework[CurrentSystem].Atoms[f1][j].AnisotropicPosition;

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

            if(rr<CutOffVDWSquared)
              UVDW+=PotentialValue(typeA,typeB,rr,scaling);

            j=Framework[CurrentSystem].CellList[f1][j];
          }
        }
      }
    }
    else if(UseReplicas[CurrentSystem]) // energy using replicas
    {
      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
        {
          typeB=Framework[CurrentSystem].Atoms[f1][i].Type;
          posB=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;

          for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
          {
            dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

            if(rr<CutOffVDWSquared)
              UVDW+=PotentialValue(typeA,typeB,rr,scaling);
          }
        }
      }
    }
    else // regular energy calculation
    {
      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
        {
          typeB=Framework[CurrentSystem].Atoms[f1][i].Type;
          posB=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;

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

          if(rr<CutOffVDWSquared)
            UVDW+=PotentialValue(typeA,typeB,rr,scaling);
        }
      }
    }
  }
  return UVDW;
}


void CalculateFrameworkChargeEnergyAtPosition(POINT posA,int typeA,REAL *UChargeCharge,REAL *UchargeBondDipole,REAL scaling)
{
  int i,typeB,f1,k;
  int B1,B2;
  REAL r,rr,chargeA,chargeB;
  REAL DipoleMagnitudeB,temp;
  VECTOR posB,posB1,posB2,dr,dipoleB;
  int ncell;

  (*UChargeCharge)=0.0;
  (*UchargeBondDipole)=0.0;

  if(ChargeMethod==NONE) return;

  if(!PseudoAtoms[typeA].HasCharges) return;

  chargeA=scaling*PseudoAtoms[typeA].Charge1;
  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid))
    {
      (*UChargeCharge)=InterpolateCoulombGrid(typeA,posA);
    }
    else if(UseReplicas[CurrentSystem])
    {
      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
        {
          typeB=Framework[CurrentSystem].Atoms[f1][i].Type;
          posB=Framework[CurrentSystem].Atoms[f1][i].Position;

          for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
          {
            dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

            if(rr<CutOffChargeChargeSquared[CurrentSystem])
            {
              r=sqrt(rr);
              chargeB=Framework[CurrentSystem].Atoms[f1][i].Charge;

              (*UChargeCharge)+=PotentialValueCoulombic(chargeA,chargeB,r);
            }
          }
        }

        for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
          B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
          B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
          posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
          posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          dipoleB=ApplyReplicaBoundaryCondition(dipoleB);
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

          for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
          {
            dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

            if(rr<CutOffChargeBondDipoleSquared)
              (*UchargeBondDipole)+=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));
          }
        }
      }
    }
    else
    {
      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
        {
          typeB=Framework[CurrentSystem].Atoms[f1][i].Type;
          posB=Framework[CurrentSystem].Atoms[f1][i].Position;
          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
          {
            r=sqrt(rr);
            chargeB=Framework[CurrentSystem].Atoms[f1][i].Charge;

            (*UChargeCharge)+=PotentialValueCoulombic(chargeA,chargeB,r);
          }
        }

        for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
          B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
          B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
          posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
          posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          dipoleB=ApplyBoundaryCondition(dipoleB);
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

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

          if(rr<CutOffChargeBondDipoleSquared)
            (*UchargeBondDipole)+=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));
        }
      }
    }
  }
}

void CalculateFrameworkBondDipoleEnergyAtPosition(VECTOR posA1,VECTOR posA2,REAL DipoleMagnitudeA,REAL *UchargeBondDipole,REAL *UBondDipoleBondDipole)
{
  int k,f1;
  int B1,B2;
  int TypeB;
  VECTOR posA,posB,posB1,posB2,dr;
  REAL DipoleMagnitudeB,chargeB;
  REAL ri2,rk2,rr,length,temp;
  VECTOR dipoleA,dipoleB;
  int ncell;

  (*UchargeBondDipole)=0.0;
  (*UBondDipoleBondDipole)=0.0;

  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;

  if(UseReplicas[CurrentSystem])
  {
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
      {
        TypeB=Framework[CurrentSystem].Atoms[f1][k].Type;

        if(PseudoAtoms[TypeB].HasCharges)
        {
          posB=Framework[CurrentSystem].Atoms[f1][k].Position;
          chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

          for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
          {
            dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA.z-(posB.z+ReplicaShift[ncell].x);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

            if(rr<CutOffChargeBondDipoleSquared)
              (*UchargeBondDipole)-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
          }
        }
      }

      for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
      {
        DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
        B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
        B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
        posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
        posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

        dipoleB.x=posB2.x-posB1.x;
        dipoleB.y=posB2.y-posB1.y;
        dipoleB.z=posB2.z-posB1.z;
        dipoleB=ApplyBoundaryCondition(dipoleB);
        posB.x=posB1.x+0.5*dipoleB.x;
        posB.y=posB1.y+0.5*dipoleB.y;
        posB.z=posB1.z+0.5*dipoleB.z;
        rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
        length=sqrt(rk2);
        temp=DipoleMagnitudeB/length;
        dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

        for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
        {
          dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
          dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
          dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
          dr=ApplyReplicaBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffBondDipoleBondDipoleSquared)
            (*UBondDipoleBondDipole)+=PotentialValueBondDipoleBondDipole(dipoleA,dipoleB,dr,sqrt(rr));
        }
      }
    }
  }
  else
  {
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
      {
        TypeB=Framework[CurrentSystem].Atoms[f1][k].Type;

        if(PseudoAtoms[TypeB].HasCharges)
        {
          posB=Framework[CurrentSystem].Atoms[f1][k].Position;
          chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

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

          if(rr<CutOffChargeBondDipoleSquared)
            (*UchargeBondDipole)-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
        }
      }

      for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
      {
        DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
        B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
        B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
        posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
        posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

        dipoleB.x=posB2.x-posB1.x;
        dipoleB.y=posB2.y-posB1.y;
        dipoleB.z=posB2.z-posB1.z;
        dipoleB=ApplyBoundaryCondition(dipoleB);
        posB.x=posB1.x+0.5*dipoleB.x;
        posB.y=posB1.y+0.5*dipoleB.y;
        posB.z=posB1.z+0.5*dipoleB.z;
        rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
        length=sqrt(rk2);
        temp=DipoleMagnitudeB/length;
        dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

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

        if(rr<CutOffBondDipoleBondDipoleSquared)
          (*UBondDipoleBondDipole)+=PotentialValueBondDipoleBondDipole(dipoleA,dipoleB,dr,sqrt(rr));
      }
    }
  }
}


// Monte-Carlo full energy routines
// ================================

REAL CalculateFrameworkBondEnergy(int flag,int f2,int atom_id)
{
  int i,f1;
  REAL r,rr,r1,U;
  REAL temp,temp2,exp_term;
  REAL *parms,UHostBond;
  VECTOR posA,posB,dr;
  int A,B;

  UHostBond=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBonds[f1];i++)
      {
        A=Framework[CurrentSystem].Bonds[f1][i].A;
        B=Framework[CurrentSystem].Bonds[f1][i].B;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;

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

          parms=(REAL*)&Framework[CurrentSystem].BondArguments[f1][i];

          switch(Framework[CurrentSystem].BondType[f1][i])
          {
            case HARMONIC_BOND:
              // 0.5*p0*SQR(r-p1);
              // ===============================================
              // p_0/k_B [K/A^2]   force constant
              // p_1     [A]       reference bond distance
              U=0.5*parms[0]*SQR(r-parms[1]);
              break;
            case CORE_SHELL_SPRING:
              U=0.5*parms[0]*SQR(r);
              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);
              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;
              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));
              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;
              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);
              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);
              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);
              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);
              break;
            case MEASURE_BOND:
              U=0.0;
              break;
            case RIGID_BOND:
              U=0.0;
              break;
            case FIXED_BOND:
              U=0.0;
              break;
            default:
              fprintf(stderr, "Undefined Bond potential in routine 'CalculateFrameworkBondEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // add contribution to the Adsorbate stretch energy
          UHostBond+=U;
        }
      }
    }
  }
  return UHostBond;
}

REAL CalculateFrameworkUreyBradleyEnergy(int flag,int f2,int atom_id)
{
  int i,f1;
  REAL r,rr,r1,U;
  REAL temp,temp2,exp_term;
  VECTOR dr,posA,posC;
  REAL *parms,UHostUreyBradley;
  int A,C;

  UHostUreyBradley=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfUreyBradleys[f1];i++)
      {
        A=Framework[CurrentSystem].UreyBradleys[f1][i].A;
        C=Framework[CurrentSystem].UreyBradleys[f1][i].C;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||C==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;

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

          parms=(REAL*)&Framework[CurrentSystem].UreyBradleyArguments[f1][i];

          switch(Framework[CurrentSystem].UreyBradleyType[f1][i])
          {
            case HARMONIC_UREYBRADLEY:
              // 0.5*p0*SQR(r-p1);
              // ===============================================
              // p_0/k_B [K/A^2]   force constant
              // p_1     [A]       reference bond distance
              U=0.5*parms[0]*SQR(r-parms[1]);
              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);
              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;
              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));
              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;
              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);
              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);
              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);
              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);
              break;
            case RIGID_UREYBRADLEY:
              U=0.0;
              break;
            case FIXED_UREYBRADLEY:
              U=0.0;
              break;
            default:
              fprintf(stderr, "Undefined Urey-Bradley potential in routine 'CalculateFrameworkUreyBradleyEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // add contribution to the Adsorbate Urey-Bradley energy
          UHostUreyBradley+=U;
        }
      }
    }
  }
  return UHostUreyBradley;
}

REAL CalculateFrameworkBendEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  REAL *parms,U,temp,temp2;
  REAL CosTheta,Theta,SinTheta;
  REAL rab,rbc,rac,DTDX,UHostBend;
  VECTOR posA,posB,posC,posD;
  VECTOR Rab,Rbc,Rac;
  VECTOR Rad,Rbd,Rcd,t,ip,ap,cp;
  REAL delta,rt2,rap2,rcp2;

  UHostBend=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBends[f1];i++)
      {
        A=Framework[CurrentSystem].Bends[f1][i].A;
        B=Framework[CurrentSystem].Bends[f1][i].B;
        C=Framework[CurrentSystem].Bends[f1][i].C;
        D=Framework[CurrentSystem].Bends[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&((A==atom_id)||(B==atom_id)||(C==atom_id)||(D==atom_id))))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;

          switch(Framework[CurrentSystem].BendType[f1][i])
          {
            case MM3_IN_PLANE_BEND:
              D=Framework[CurrentSystem].Bends[f1][i].D;
              posD=Framework[CurrentSystem].Atoms[f1][D].Position;
              Rad.x=posA.x-posD.x;
              Rad.y=posA.y-posD.y;
              Rad.z=posA.z-posD.z;
              Rad=ApplyBoundaryCondition(Rad);

              Rbd.x=posB.x-posD.x;
              Rbd.y=posB.y-posD.y;
              Rbd.z=posB.z-posD.z;
              Rbd=ApplyBoundaryCondition(Rbd);

              Rcd.x=posC.x-posD.x;
              Rcd.y=posC.y-posD.y;
              Rcd.z=posC.z-posD.z;
              Rcd=ApplyBoundaryCondition(Rcd);

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

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

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

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

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

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

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

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

          parms=Framework[CurrentSystem].BendArguments[f1][i];

          switch(Framework[CurrentSystem].BendType[f1][i])
          {
            case HARMONIC_BEND:
              // (1/2)p_0*(theta-p_1)^2
              // ===============================================
              // p_0/k_B [K/rad^2]
              // p_1     [degrees]
              U=0.5*parms[0]*SQR(Theta-parms[1]);
              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]);
              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);
              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);
              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]);
              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));
              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));
              break;
            case MM3_BEND:
            case MM3_IN_PLANE_BEND:
              // p_0*(theta-p_1)^2(1-0.014*(theta-p_1)+5.6e-5*(theta-p_1)^2-7e-7*(theta-p_1)^3+2.2e-8(theta-p_1)^4)
              // =================================================================================================
              // p_0/k_B [mdyne A/rad^2]
              // p_1     [degrees]
              temp=RAD2DEG*(Theta-parms[1]);
              temp2=SQR(temp);
              U=parms[0]*temp2*(1.0-0.014*temp+5.6e-5*temp2-7.0e-7*temp*temp2+2.2e-8*SQR(temp2));
              break;
            case FIXED_BEND:
              U=0.0;
              break;
            case MEASURE_BEND:
              U=0.0;
              break;
            default:
              fprintf(stderr, "Undefined Bend potential in routine 'CalculateFrameworkBendEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // add contribution to the energy
          UHostBend+=U;
        }
      }
    }
  }
  return UHostBend;
}

REAL CalculateFrameworkInversionBendEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  REAL *parms;
  REAL c,e;
  REAL rrab,rab2;
  REAL CosChi,Chi,energy;
  REAL temp,temp2,UHostInversionBend;
  VECTOR Rab,Rbc,Rbd,Rcd,Rad;
  POINT posA,posB,posC,posD;

  UHostInversionBend=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfInversionBends[f1];i++)
      {
        A=Framework[CurrentSystem].InversionBends[f1][i].A;
        B=Framework[CurrentSystem].InversionBends[f1][i].B;
        C=Framework[CurrentSystem].InversionBends[f1][i].C;
        D=Framework[CurrentSystem].InversionBends[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id||D==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;
          posD=Framework[CurrentSystem].Atoms[f1][D].Position;

          Rab.x=posA.x-posB.x;
          Rab.y=posA.y-posB.y;
          Rab.z=posA.z-posB.z;
          Rab=ApplyBoundaryCondition(Rab);
          rab2=Rab.x*Rab.x+Rab.y*Rab.y+Rab.z*Rab.z;
          rrab=sqrt(rab2);

          Rbc.x=posC.x-posB.x;
          Rbc.y=posC.y-posB.y;
          Rbc.z=posC.z-posB.z;
          Rbc=ApplyBoundaryCondition(Rbc);

          Rbd.x=posD.x-posB.x;
          Rbd.y=posD.y-posB.y;
          Rbd.z=posD.z-posB.z;
          Rbd=ApplyBoundaryCondition(Rbd);

          Rcd.x=posD.x-posC.x;
          Rcd.y=posD.y-posC.y;
          Rcd.z=posD.z-posC.z;
          Rcd=ApplyBoundaryCondition(Rcd);

          Rad.x=posD.x-posA.x;
          Rad.y=posD.y-posA.y;
          Rad.z=posD.z-posA.z;
          Rad=ApplyBoundaryCondition(Rad);

          switch(Framework[CurrentSystem].InversionBendType[f1][i])
          {
            case HARMONIC_INVERSION:
            case HARMONIC_COSINE_INVERSION:
            case PLANAR_INVERSION:
              // w is a vector perpendicular to the B-C-D plane
              // c=w.w=(Rbc x Rbd).(Rbc x Rbd)= r_bc^2 r_bd^2 - (r_cb . r_bd)^2
              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 HARMONIC_INVERSION2:
            case HARMONIC_COSINE_INVERSION2:
            case PLANAR_INVERSION2:
            case MM3_INVERSION:
              // 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
              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*(Rbd.y*Rbc.z-Rbd.z*Rbc.y)+Rab.y*(Rbd.z*Rbc.x-Rbd.x*Rbc.z)+Rab.z*(Rbd.x*Rbc.y-Rbd.y*Rbc.x);
          CosChi=sqrt((Rab.x*Rab.x+Rab.y*Rab.y+Rab.z*Rab.z)-SQR(e)/c)/rrab;

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

          parms=Framework[CurrentSystem].InversionBendArguments[f1][i];

          switch(Framework[CurrentSystem].InversionBendType[f1][i])
          {
            case HARMONIC_INVERSION:
            case HARMONIC_INVERSION2:
              // (1/2)*p_0*(chi-p_1)^2
              // ===============================================
              // p_0/k_B [K]
              // p_1     [degrees]
              Chi=acos(CosChi);
              energy=0.5*parms[0]*SQR(Chi-parms[1]);
              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]
              energy=0.5*parms[0]*SQR(CosChi-parms[1]);
              break;
            case PLANAR_INVERSION:
            case PLANAR_INVERSION2:
              // (1/2)*p_0*(1-cos(phi))
              // ===============================================
              // p_0/k_B [K]
              energy=parms[0]*(1.0-CosChi);
              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));
              break;
            default:
              fprintf(stderr, "Undefined Inversion-Bend potential in routine 'CalculateFrameworkInversionBendEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // energy
          UHostInversionBend+=energy;
        }
      }
    }
  }
  return UHostInversionBend;
}

REAL CalculateFrameworkTorsionEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  POINT posA,posB,posC,posD;
  REAL rbc,U;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,UHostTorsion;
  REAL ShiftedCosPhi,ShiftedCosPhi2;
  VECTOR Pb,Pc;
  REAL *parms;

  UHostTorsion=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
      {
        A=Framework[CurrentSystem].Torsions[f1][i].A;
        B=Framework[CurrentSystem].Torsions[f1][i].B;
        C=Framework[CurrentSystem].Torsions[f1][i].C;
        D=Framework[CurrentSystem].Torsions[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id||D==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;
          posD=Framework[CurrentSystem].Atoms[f1][D].Position;

          Dab.x=posA.x-posB.x;
          Dab.y=posA.y-posB.y;
          Dab.z=posA.z-posB.z;
          Dab=ApplyBoundaryCondition(Dab);

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

          Ddc.x=posD.x-posC.x;
          Ddc.y=posD.y-posC.y;
          Ddc.z=posD.z-posC.z;
          Ddc=ApplyBoundaryCondition(Ddc);

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

          dr.x=Dab.x-dot_ab*Dcb.x;
          dr.y=Dab.y-dot_ab*Dcb.y;
          dr.z=Dab.z-dot_ab*Dcb.z;
          r=MAX2((REAL)1.0e-8,sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z)));
          dr.x/=r; dr.y/=r; dr.z/=r;

          ds.x=Ddc.x-dot_cd*Dcb.x;
          ds.y=Ddc.y-dot_cd*Dcb.y;
          ds.z=Ddc.z-dot_cd*Dcb.z;
          s=MAX2((REAL)1.0e-8,sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z)));
          ds.x/=s; ds.y/=s; ds.z/=s;

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

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

          parms=Framework[CurrentSystem].TorsionArguments[f1][i];

          switch(Framework[CurrentSystem].TorsionType[f1][i])
          {
            case HARMONIC_DIHEDRAL:
              // (1/2)*p_0*(phi-p_1)^2
              // ===============================================
              // p_0/k_B [K/rad^2]
              // p_1     [degrees]
              // potential defined in terms of 'phi' and therefore contains a singularity
              // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
              // same direction as Rbc, and negative otherwise
              Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
              Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
              Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
              Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
              Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
              Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
              sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
                    +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
              Phi=SIGN(acos(CosPhi),sign);
              SinPhi=sin(Phi);
              Phi-=parms[1];
              Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
              SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
              U=0.5*parms[0]*SQR(Phi);
              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-cos(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);
              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);
              break;
            case CVFF_BLOCKED_DIHEDRAL:
              //
              // ========================================================================
              // p_0     [rad]
              // p_1     [K]
              // p_2     [-]
              // p_3     [rad]
              // p_4     [rad]
              U=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);
              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));
              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;
              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));
              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);
              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);
              Phi-=parms[4];           // shift Phi as Phi+parms[4]
              Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
              ShiftedCosPhi=cos(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;
              break;
            case CVFF_DIHEDRAL:
              // p_0*(1+cos(p_1*phi-p_2))
              // ========================
              // p_0/k_B [K]
              // p_1     [-]
              // p_2     [degrees]
              // potential defined in terms of 'phi' and therefore contains a singularity
              // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
              // same direction as Dbc, and negative otherwise
              Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
              Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
              Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
              Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
              Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
              Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
              sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
                    +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
              Phi=SIGN(acos(CosPhi),sign);
              SinPhi=sin(Phi);
              SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi);  // remove singularity
              U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
              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)));
              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));
              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)))));
              break;
            default:
              fprintf(stderr, "Undefined Torsion potential in routine 'CalculateFrameworkTorsionEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // energy
          UHostTorsion+=U;
        }
      }
    }
  }
  return UHostTorsion;
}

REAL CalculateFrameworkImproperTorsionEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  POINT posA,posB,posC,posD;
  REAL rbc,U;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,sign;
  REAL CosPhi,Phi,CosPhi2,SinPhi,UHostImproperTorsion;
  VECTOR Pb,Pc;
  REAL *parms;

  UHostImproperTorsion=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfImproperTorsions[f1];i++)
      {
        A=Framework[CurrentSystem].ImproperTorsions[f1][i].A;
        B=Framework[CurrentSystem].ImproperTorsions[f1][i].B;
        C=Framework[CurrentSystem].ImproperTorsions[f1][i].C;
        D=Framework[CurrentSystem].ImproperTorsions[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id||D==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;
          posD=Framework[CurrentSystem].Atoms[f1][D].Position;

          Dab.x=posA.x-posB.x;
          Dab.y=posA.y-posB.y;
          Dab.z=posA.z-posB.z;
          Dab=ApplyBoundaryCondition(Dab);

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

          Ddc.x=posD.x-posC.x;
          Ddc.y=posD.y-posC.y;
          Ddc.z=posD.z-posC.z;
          Ddc=ApplyBoundaryCondition(Ddc);

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

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

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

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

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

          parms=Framework[CurrentSystem].ImproperTorsionArguments[f1][i];

          switch(Framework[CurrentSystem].ImproperTorsionType[f1][i])
          {
            case HARMONIC_IMPROPER_DIHEDRAL:
              // (1/2)*p_0*(phi-p_1)^2
              // ===============================================
              // p_0/k_B [K/rad^2]
              // p_1     [degrees]
              // potential defined in terms of 'phi' and therefore contains a singularity
              // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
              // same direction as Rbc, and negative otherwise
              Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
              Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
              Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
              Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
              Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
              Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
              sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
                    +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
              Phi=SIGN(acos(CosPhi),sign);
              SinPhi=sin(Phi);
              Phi-=parms[1];
              Phi-=NINT(Phi/(2.0*M_PI))*2.0*M_PI;
              SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi); // remove singularity
              U=0.5*parms[0]*SQR(Phi);
              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-cos(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);
              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);
              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);
              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));
              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;
              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));
              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);
              break;
            case CVFF_IMPROPER_DIHEDRAL:
              // p_0*(1+cos(p_1*phi-p_2))
              // ========================
              // p_0/k_B [K]
              // p_1     [-]
              // p_2     [degrees]
              // potential defined in terms of 'phi' and therefore contains a singularity
              // the sign of the angle-phi is positive if (Rab x Rbc) x (Rbc x Rcd) is in the
              // same direction as Dbc, and negative otherwise
              Pb.x=Dab.z*Dcb.y-Dab.y*Dcb.z;
              Pb.y=Dab.x*Dcb.z-Dab.z*Dcb.x;
              Pb.z=Dab.y*Dcb.x-Dab.x*Dcb.y;
              Pc.x=Dcb.y*Ddc.z-Dcb.z*Ddc.y;
              Pc.y=Dcb.z*Ddc.x-Dcb.x*Ddc.z;
              Pc.z=Dcb.x*Ddc.y-Dcb.y*Ddc.x;
              sign=(Dcb.x*(Pc.z*Pb.y-Pc.y*Pb.z)+Dcb.y*(Pb.z*Pc.x-Pb.x*Pc.z)
                    +Dcb.z*(Pc.y*Pb.x-Pc.x*Pb.y));
              Phi=SIGN(acos(CosPhi),sign);
              SinPhi=sin(Phi);
              SinPhi=SIGN(MAX2((REAL)1.0e-8,fabs(SinPhi)),SinPhi);  // remove singularity
              U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]));
              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)));
              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));
              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)))));
              break;
            case FIXED_IMPROPER_DIHEDRAL:
              U=0.0;
              break;
            default:
              fprintf(stderr, "Undefined Improper-Torsion potential in routine 'CalculateFrameworkImproperTorsionEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // energy
          UHostImproperTorsion+=U;
        }
      }
    }
  }
  return UHostImproperTorsion;
}

REAL CalculateFrameworkBondBondEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,f1;
  REAL *parms;
  REAL energy;
  REAL rab,rbc,UHostBondBond;
  VECTOR posA,posB,posC;
  VECTOR Rab,Rbc;

  UHostBondBond=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBondBonds[f1];i++)
      {
        A=Framework[CurrentSystem].BondBonds[f1][i].A;
        B=Framework[CurrentSystem].BondBonds[f1][i].B;
        C=Framework[CurrentSystem].BondBonds[f1][i].C;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;

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

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

          parms=Framework[CurrentSystem].BondBondArguments[f1][i];

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

          // add contribution to the energy
          UHostBondBond+=energy;
        }
      }
    }
  }
  return UHostBondBond;
}

REAL CalculateFrameworkBondBendEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,f1;
  REAL *parms,U;
  REAL cost,theta,sint;
  REAL rab,rbc,rac,UHostBondBend;
  VECTOR posA,posB,posC;
  VECTOR Rab,Rbc,Rac;

  UHostBondBend=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBondBends[f1];i++)
      {
        A=Framework[CurrentSystem].BondBends[f1][i].A;
        B=Framework[CurrentSystem].BondBends[f1][i].B;
        C=Framework[CurrentSystem].BondBends[f1][i].C;

        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;

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

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

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

          cost=(Rab.x*Rbc.x+Rab.y*Rbc.y+Rab.z*Rbc.z);
          cost=SIGN(MIN2(fabs(cost),(REAL)1.0),cost);
          theta=acos(cost);
          sint=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(cost)));

          parms=Framework[CurrentSystem].BondBendArguments[f1][i];

          switch(Framework[CurrentSystem].BondBendType[f1][i])
          {
            case CVFF_BOND_BEND_CROSS:
            case CFF_BOND_BEND_CROSS:
              // (Theta-p_0)*(p_1*(rab-p_2)+p_3*(rbc-p_4))
              // =========================================
              // p_0     [degrees]
              // p_1/k_B [K/A/rad]
              // p_2     [A]
              // p_3/k_B [K/A/rad]
              // p_4     [A]
              U=(theta-parms[0])*(parms[1]*(rab-parms[2])+parms[3]*(rbc-parms[4]));
              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]
              U=parms[0]*((rab-parms[1])+(rbc-parms[2]))*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]
              U=0.5*parms[0]*SQR(theta-parms[1])*exp(-(pow(rab,8)+pow(rbc,8))/pow(parms[2],8));
              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]
              U=0.5*parms[0]*SQR(theta-parms[1])*exp(-(rab/parms[2]+rbc/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]
              U=(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]));
              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]
              U=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));
              break;
            default:
              fprintf(stderr, "Undefined Bond-Bend potential in routine 'CalculateFrameworkBondBendEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // energy
          UHostBondBend+=U;
        }
      }
    }
  }
  return UHostBondBend;
}

// Bend/Bend cross term for a centered atom B
// the first angle is A-B-C
// the second angle is A-B-D
REAL CalculateFrameworkBendBendEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  POINT posA,posB,posC,posD;
  REAL U,rab,rbc,rbd;
  VECTOR Dab,Dbc,Dbd;
  REAL dot_abc,dot_abd,UHostBendBend;
  REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
  REAL *parms;

  UHostBendBend=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBendBends[f1];i++)
      {
        A=Framework[CurrentSystem].BendBends[f1][i].A;
        B=Framework[CurrentSystem].BendBends[f1][i].B;
        C=Framework[CurrentSystem].BendBends[f1][i].C;
        D=Framework[CurrentSystem].BendBends[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id||D==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;
          posD=Framework[CurrentSystem].Atoms[f1][D].Position;

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

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

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

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

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

          parms=(REAL*)&Framework[CurrentSystem].BendBendArguments[f1][i];

          switch(Framework[CurrentSystem].BendBendType[f1][i])
          {
            case CVFF_BEND_BEND_CROSS:
            case CFF_BEND_BEND_CROSS:
              // p_0*(Theta1-p_1)*(Theta2-p_2)
              // ===================================
              // p_0/k_B [K/rad^2)]
              // p_1     [degrees]
              // p_2     [degrees]
              U=parms[0]*(Theta1-parms[1])*(Theta2-parms[2]);
              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]
              U=-parms[0]*SQR(RAD2DEG)*(Theta1-parms[1])*(Theta2-parms[2]);
              break;
            default:
              fprintf(stderr, "Undefined Bend-Bend potential in routine 'CalculateFrameworkBendBendEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }
          // energy
          UHostBendBend+=U;
        }
      }
    }
  }
  return UHostBendBend;
}

REAL CalculateFrameworkBondTorsionEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  POINT posA,posB,posC,posD;
  REAL U,rab,rbc,rcd;
  VECTOR Dab,Dcb,Ddc,dr,ds;
  REAL dot_ab,dot_cd,r,s,temp;
  REAL CosPhi,CosPhi2;
  REAL *parms,UHostBondTorsion;

  UHostBondTorsion=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBondTorsions[f1];i++)
      {
        A=Framework[CurrentSystem].BondTorsions[f1][i].A;
        B=Framework[CurrentSystem].BondTorsions[f1][i].B;
        C=Framework[CurrentSystem].BondTorsions[f1][i].C;
        D=Framework[CurrentSystem].BondTorsions[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id||D==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;
          posD=Framework[CurrentSystem].Atoms[f1][D].Position;

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

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

          parms=(REAL*)&Framework[CurrentSystem].BondTorsionArguments[f1][i];

          switch(Framework[CurrentSystem].BondTorsionType[f1][i])
          {
            case MM3_BOND_TORSION_CROSS:
              // (1/2)p_0(r-p_3)(1+cos(phi))+(1/2)p_1(r-p_3)(1+cos(2phi))+(1/2)p_2(r-p_3)(1+cos(3phi))
              // =====================================================================================
              // p_0     [kcal/A mole]
              // p_1     [kcal/A mole]
              // p_2     [kcal/A mole]
              // p_3     [A]
              temp=(rbc-parms[3]);
              U=parms[0]*temp*CosPhi+parms[1]*temp*(2.0*CosPhi2-1.0)+parms[2]*temp*(4.0*CosPhi2*CosPhi-3.0*CosPhi);
              break;
            default:
              fprintf(stderr, "Undefined Bond-Torsion potential in routine 'CalculateFrameworkBondTorsionEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // energy
          UHostBondTorsion+=U;
        }
      }
    }
  }
  return UHostBondTorsion;
}

REAL CalculateFrameworkBendTorsionEnergy(int flag,int f2,int atom_id)
{
  int i,A,B,C,D,f1;
  POINT posA,posB,posC,posD;
  REAL U,rab,rbc,rcd;
  VECTOR Dab,Dbc,Dcd,dr,ds,Pb,Pc;
  REAL dot_ab,dot_cd,r,s;
  REAL CosPhi,CosPhi2;
  REAL CosTheta1,CosTheta2,Theta1,Theta2,SinTheta1,SinTheta2;
  REAL sign,Phi,SinPhi;
  REAL *parms,UHostBendTorsion;

  UHostBendTorsion=0.0;
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBendTorsions[f1];i++)
      {
        A=Framework[CurrentSystem].BendTorsions[f1][i].A;
        B=Framework[CurrentSystem].BendTorsions[f1][i].B;
        C=Framework[CurrentSystem].BendTorsions[f1][i].C;
        D=Framework[CurrentSystem].BendTorsions[f1][i].D;

        // if flag is 'false', only execute when atom 'atom_id' is involved
        // else compute total energy
        if(flag||((f1==f2)&&(A==atom_id||B==atom_id||C==atom_id||D==atom_id)))
        {
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;
          posC=Framework[CurrentSystem].Atoms[f1][C].Position;
          posD=Framework[CurrentSystem].Atoms[f1][D].Position;

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

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

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

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

          dot_cd=Dcd.x*Dbc.x+Dcd.y*Dbc.y+Dcd.z*Dbc.z;
          CosTheta2=-dot_cd/rcd;
          CosTheta2=MAX2(MIN2(CosTheta2,(REAL)1.0),-1.0);
          Theta2=acos(CosTheta2);
          SinTheta2=MAX2((REAL)1.0e-8,sqrt(1.0-SQR(CosTheta2)));

          dr.x=Dab.x-dot_ab*Dbc.x;
          dr.y=Dab.y-dot_ab*Dbc.y;
          dr.z=Dab.z-dot_ab*Dbc.z;
          r=MAX2((REAL)1.0e-8,sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z)));
          dr.x/=r; dr.y/=r; dr.z/=r;

          ds.x=Dcd.x-dot_cd*Dbc.x;
          ds.y=Dcd.y-dot_cd*Dbc.y;
          ds.z=Dcd.z-dot_cd*Dbc.z;
          s=MAX2((REAL)1.0e-8,sqrt(SQR(ds.x)+SQR(ds.y)+SQR(ds.z)));
          ds.x/=s; ds.y/=s; ds.z/=s;

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

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

          parms=(REAL*)&Framework[CurrentSystem].BendTorsionArguments[f1][i];

          switch(Framework[CurrentSystem].BendTorsionType[f1][i])
          {
            case CVFF_BEND_TORSION_CROSS:
            case CFF_BEND_TORSION_CROSS:
              // p_0*(Theta1-p_1)*(Theta2-p_2)*cos(Phi)
              // =====================================================================================
              // p_0/k_B [K/rad^3]
              // p_1     [degrees]
              // p_2     [degrees]
              U=parms[0]*(Theta1-parms[1])*(Theta2-parms[2])*CosPhi;
              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
              U=parms[0]*(1.0+cos(parms[1]*Phi-parms[2]))*Smoothing(Theta1)*Smoothing(Theta2);
              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]
              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))*
                     Smoothing(Theta1)*Smoothing(Theta2);
              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]
              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))*
                     Smoothing(Theta1);
              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]
              U=(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);
              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]
              U=(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);
              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]
              U=parms[0]*(Theta1-parms[1])*(Theta2-parms[2])*CosPhi*Smoothing(Theta1)*Smoothing(Theta2);
              break;
            default:
              fprintf(stderr, "Undefined Bend-Torsion potential in routine 'CalculateFrameworkBendTorsionEnergy' ('framework_energy.c')\n");
              exit(0);
              break;
          }

          // energy
          UHostBendTorsion+=U;
        }
      }
    }
  }
  return UHostBendTorsion;
}

int CalculateFrameworkIntraVDWEnergy(void)
{
  int i,j,typeA,typeB,A,B;
  REAL rr;
  VECTOR posA,posB,dr;
  int f1,f2;
  REAL *parms;

  // Framework-Framework energy
  UHostHostVDW[CurrentSystem]=0.0;

  if(!InternalFrameworkLennardJonesInteractions) return 0;

  // contributions from intra-framework
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
      {
        typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
        posA=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;

        for(j=i+1;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],0))
          {
            typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
            posB=Framework[CurrentSystem].Atoms[f1][j].AnisotropicPosition;

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

            if(rr<CutOffVDWSquared)
              UHostHostVDW[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);
          }
        }
      }
    }
  }

  // contributions from interactions between the frameworks
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
      {
        typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
        posA=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;

        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
        {
          typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
          posB=Framework[CurrentSystem].Atoms[f2][j].AnisotropicPosition;

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

          if(rr<CutOffVDWSquared)
            UHostHostVDW[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);
        }
      }
    }
  }

  // contributions from interactions 1-4 torsions
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
      {
        parms=Framework[CurrentSystem].TorsionArguments[f1][i];
        if(fabs(parms[6])>1e-8)
        {
          A=Framework[CurrentSystem].Torsions[f1][i].A;
          typeA=Framework[CurrentSystem].Atoms[f1][A].Type;
          posA=Framework[CurrentSystem].Atoms[f1][A].Position;

          B=Framework[CurrentSystem].Torsions[f1][i].D;
          typeB=Framework[CurrentSystem].Atoms[f1][B].Type;
          posB=Framework[CurrentSystem].Atoms[f1][B].Position;

          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
          {
            dr.x=posA.x-posB.x;
            dr.y=posA.y-posB.y;
            dr.z=posA.z-posB.z;
            dr=ApplyBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            UHostHostVDW[CurrentSystem]+=parms[6]*PotentialValue(typeA,typeB,rr,1.0);
          }
        }
      }
    }
  }

  return 0;
}

int CalculateFrameworkIntraChargeChargeEnergy(void)
{
  int i,j,typeA,typeB;
  REAL chargeA,chargeB;
  REAL r,rr;
  VECTOR posA,posB,dr;
  int f1,f2,A,B;
  REAL *parms;
  REAL alpha;

  // Framework-Framework energy
  UHostHostChargeChargeReal[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
      {
        typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
        posA=Framework[CurrentSystem].Atoms[f1][i].Position;
        chargeA=Framework[CurrentSystem].Atoms[f1][i].Charge;

        for(j=i+1;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],1))
          {
            typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
            posB=Framework[CurrentSystem].Atoms[f1][j].Position;

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

            if(rr<CutOffChargeChargeSquared[CurrentSystem])
            {
              r=sqrt(rr);
              chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

              UHostHostChargeChargeReal[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,r);
            }
          }
        }
      }
    }
  }


  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
      {
        typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
        posA=Framework[CurrentSystem].Atoms[f1][i].Position;
        chargeA=Framework[CurrentSystem].Atoms[f1][i].Charge;

        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
        {
          typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
          posB=Framework[CurrentSystem].Atoms[f2][j].Position;

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

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
          {
            r=sqrt(rr);
            chargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;

            UHostHostChargeChargeReal[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,r);
          }
        }
      }
    }
  }

  // contributions from interactions 1-4 torsions
  alpha=Alpha[CurrentSystem];
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
      {
        parms=Framework[CurrentSystem].TorsionArguments[f1][i];

        if(fabs(parms[7])>1e-8)
        {
          A=Framework[CurrentSystem].Torsions[f1][i].A;
          chargeA=Framework[CurrentSystem].Atoms[f1][A].Charge;
          posA=Framework[CurrentSystem].Atoms[f1][A].AnisotropicPosition;

          B=Framework[CurrentSystem].Torsions[f1][i].D;
          chargeB=Framework[CurrentSystem].Atoms[f1][B].Charge;
          posB=Framework[CurrentSystem].Atoms[f1][B].AnisotropicPosition;

          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
          {
            dr.x=posA.x-posB.x;
            dr.y=posA.y-posB.y;
            dr.z=posA.z-posB.z;
            dr=ApplyBoundaryCondition(dr);
            r=sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z));

            UHostHostChargeChargeReal[CurrentSystem]+=parms[7]*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/r;
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkIntraChargeBondDipoleEnergy(void)
{
  int i,j,f1,f2;
  int A1,A2;
  int Type;
  VECTOR posA,posB,posA1,posA2,dr;
  REAL rr,ri2,temp,length,chargeB;
  VECTOR dipoleA;
  REAL Bt1;
  REAL DipoleMagnitudeA;
  REAL_MATRIX3x3 v;

  Bt1=0.0;
  v.ax=v.bx=v.cx=0.0;
  v.ay=v.by=v.cy=0.0;
  v.az=v.bz=v.cz=0.0;

  UHostHostChargeBondDipoleReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
      {
        DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
        A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
        A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
        posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
        posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
        dipoleA.x=posA2.x-posA1.x;
        dipoleA.y=posA2.y-posA1.y;
        dipoleA.z=posA2.z-posA1.z;
        dipoleA=ApplyBoundaryCondition(dipoleA);
        posA.x=posA1.x+0.5*dipoleA.x;
        posA.y=posA1.y+0.5*dipoleA.y;
        posA.z=posA1.z+0.5*dipoleA.z;
        ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
        length=sqrt(ri2);
        temp=DipoleMagnitudeA/length;
        dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          // if framework are different, or if they are the same but not excluded within the framework
          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][j][i],2))
          {
            Type=Framework[CurrentSystem].Atoms[f1][j].Type;
            if(PseudoAtoms[Type].HasCharges)
            {
              posB=Framework[CurrentSystem].Atoms[f1][j].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

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

              if(rr<CutOffChargeBondDipoleSquared)
                UHostHostChargeBondDipoleReal[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
            }
          }
        }
      }
    }
  }

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(f2=0;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
    {
      if(f1!=f2)
      {
        for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
        {
          DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
          A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
          A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
          posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
          posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
          dipoleA.x=posA2.x-posA1.x;
          dipoleA.y=posA2.y-posA1.y;
          dipoleA.z=posA2.z-posA1.z;
          dipoleA=ApplyBoundaryCondition(dipoleA);
          posA.x=posA1.x+0.5*dipoleA.x;
          posA.y=posA1.y+0.5*dipoleA.y;
          posA.z=posA1.z+0.5*dipoleA.z;
          ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
          length=sqrt(ri2);
          temp=DipoleMagnitudeA/length;
          dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

          for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
          {
            Type=Framework[CurrentSystem].Atoms[f2][j].Type;
            if(PseudoAtoms[Type].HasCharges)
            {
              posB=Framework[CurrentSystem].Atoms[f2][j].Position;
              chargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;

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

              if(rr<CutOffChargeBondDipoleSquared)
                UHostHostChargeBondDipoleReal[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkIntraBondDipoleBondDipoleEnergy(void)
{
  int i,j,f1,f2;
  int A1,A2,B1,B2;
  VECTOR posA,posB,posA1,posA2,posB1,posB2,dr;
  REAL rr,ri2,rk2,temp,length;
  VECTOR dipoleA,dipoleB;
  REAL Bt1,Bt2;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;
  REAL_MATRIX3x3 v;

  Bt1=Bt2=0.0;
  v.ax=v.bx=v.cx=0.0;
  v.ay=v.by=v.cy=0.0;
  v.az=v.bz=v.cz=0.0;

  UHostHostBondDipoleBondDipoleReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
      {
        DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
        A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
        A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
        posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
        posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
        dipoleA.x=posA2.x-posA1.x;
        dipoleA.y=posA2.y-posA1.y;
        dipoleA.z=posA2.z-posA1.z;
        dipoleA=ApplyBoundaryCondition(dipoleA);
        posA.x=posA1.x+0.5*dipoleA.x;
        posA.y=posA1.y+0.5*dipoleA.y;
        posA.z=posA1.z+0.5*dipoleA.z;
        ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
        length=sqrt(ri2);
        temp=DipoleMagnitudeA/length;
        dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

        for(j=i+1;j<Framework[CurrentSystem].NumberOfBondDipoles[f1];j++)
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][j];
          B1=Framework[CurrentSystem].BondDipoles[f1][j].A;
          B2=Framework[CurrentSystem].BondDipoles[f1][j].B;

          // if framework are different, or if they are the same but not excluded within the framework
          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],3))
          {
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

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

            if(rr<CutOffBondDipoleBondDipoleSquared)
              UHostHostBondDipoleBondDipoleReal[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA,dipoleB,dr,sqrt(rr));
          }
        }
      }
    }
  }

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
      {
        DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
        A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
        A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
        posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
        posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
        dipoleA.x=posA2.x-posA1.x;
        dipoleA.y=posA2.y-posA1.y;
        dipoleA.z=posA2.z-posA1.z;
        dipoleA=ApplyBoundaryCondition(dipoleA);
        posA.x=posA1.x+0.5*dipoleA.x;
        posA.y=posA1.y+0.5*dipoleA.y;
        posA.z=posA1.z+0.5*dipoleA.z;
        ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
        length=sqrt(ri2);
        temp=DipoleMagnitudeA/length;
        dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

        for(j=0;j<Framework[CurrentSystem].NumberOfBondDipoles[f2];j++)
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f2][j];
          B1=Framework[CurrentSystem].BondDipoles[f2][j].A;
          B2=Framework[CurrentSystem].BondDipoles[f2][j].B;

          // if framework are different, or if they are the same but not excluded within the framework
          posB1=Framework[CurrentSystem].Atoms[f2][B1].Position;
          posB2=Framework[CurrentSystem].Atoms[f2][B2].Position;

          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          dipoleB=ApplyBoundaryCondition(dipoleB);
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
          length=sqrt(rk2);
          temp=DipoleMagnitudeB/length;
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

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

          if(rr<CutOffBondDipoleBondDipoleSquared)
            UHostHostBondDipoleBondDipoleReal[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA,dipoleB,dr,sqrt(rr));
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkAdsorbateVDWEnergy(void)
{
  int i,j,k,l,f1;
  int typeA,typeB,type;
  REAL rr,scalingA,energy;
  VECTOR posA,posB,dr;
  VECTOR s;
  int icell0,icell;

  UHostAdsorbateVDW[CurrentSystem]=0.0;
  for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
  {
    type=Adsorbates[CurrentSystem][i].Type;
    for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
      posA=Adsorbates[CurrentSystem][i].Atoms[j].AnisotropicPosition;
      scalingA=Adsorbates[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&(!IsFractionalAdsorbateMolecule(i)))
      {
        UHostAdsorbateVDW[CurrentSystem]+=InterpolateVDWGrid(typeA,posA);
      }
      else
      {
        if(UseCellLists[CurrentSystem])
        {
          // convert from xyz to abc
          s.x=InverseBox[CurrentSystem].ax*posA.x+InverseBox[CurrentSystem].bx*posA.y+InverseBox[CurrentSystem].cx*posA.z;
          s.y=InverseBox[CurrentSystem].ay*posA.x+InverseBox[CurrentSystem].by*posA.y+InverseBox[CurrentSystem].cy*posA.z;
          s.z=InverseBox[CurrentSystem].az*posA.x+InverseBox[CurrentSystem].bz*posA.y+InverseBox[CurrentSystem].cz*posA.z;

          // apply boundary condition
          s.x-=(REAL)NINT(s.x);
          s.y-=(REAL)NINT(s.y);
          s.z-=(REAL)NINT(s.z);

          // s between 0 and 1
          s.x+=0.5;
          s.y+=0.5;
          s.z+=0.5;

          // compute the corresponding cell-id
          icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
                 ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
                 ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            // loop over cells
            for(l=0;l<27;l++)
            {
              icell=CellListMap[CurrentSystem][icell0][l];

              k=Framework[CurrentSystem].CellListHead[f1][icell];

              while(k>=0)
              {
                posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
                typeB=Framework[CurrentSystem].Atoms[f1][k].Type;

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

                if(rr<CutOffVDWSquared)
                  UHostAdsorbateVDW[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);

                k=Framework[CurrentSystem].CellList[f1][k];
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;

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

              if(rr<CutOffVDWSquared)
              {
                energy=PotentialValue(typeA,typeB,rr,scalingA);;
                if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                UHostAdsorbateVDW[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkCationVDWEnergy(void)
{
  int i,j,k,l,f1;
  int typeA,typeB,type;
  REAL rr,scalingA,energy;
  VECTOR posA,posB,dr;
  VECTOR s;
  int icell0,icell;

  UHostCationVDW[CurrentSystem]=0.0;
  for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
  {
    type=Cations[CurrentSystem][i].Type;
    for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Cations[CurrentSystem][i].Atoms[j].Type;
      posA=Cations[CurrentSystem][i].Atoms[j].AnisotropicPosition;
      scalingA=Cations[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&(!IsFractionalCationMolecule(i)))
      {
        UHostCationVDW[CurrentSystem]+=scalingA*InterpolateVDWGrid(typeA,posA);
      }
      else
      {
        if(UseCellLists[CurrentSystem])
        {
          // convert from xyz to abc
          s.x=InverseBox[CurrentSystem].ax*posA.x+InverseBox[CurrentSystem].bx*posA.y+InverseBox[CurrentSystem].cx*posA.z;
          s.y=InverseBox[CurrentSystem].ay*posA.x+InverseBox[CurrentSystem].by*posA.y+InverseBox[CurrentSystem].cy*posA.z;
          s.z=InverseBox[CurrentSystem].az*posA.x+InverseBox[CurrentSystem].bz*posA.y+InverseBox[CurrentSystem].cz*posA.z;

          // apply boundary condition
          s.x-=(REAL)NINT(s.x);
          s.y-=(REAL)NINT(s.y);
          s.z-=(REAL)NINT(s.z);

          // s between 0 and 1
          s.x+=0.5;
          s.y+=0.5;
          s.z+=0.5;

          // compute the corresponding cell-id
          icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
                 ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
                 ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            // loop over cells
            for(l=0;l<27;l++)
            {
              icell=CellListMap[CurrentSystem][icell0][l];

              k=Framework[CurrentSystem].CellListHead[f1][icell];

              while(k>=0)
              {
                posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
                typeB=Framework[CurrentSystem].Atoms[f1][k].Type;

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

                if(rr<CutOffVDWSquared)
                  UHostCationVDW[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);

                k=Framework[CurrentSystem].CellList[f1][k];
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;

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

              if(rr<CutOffVDWSquared)
              {
                energy=PotentialValue(typeA,typeB,rr,scalingA);
                if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                UHostCationVDW[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkAdsorbateChargeChargeEnergy(void)
{
  int i,j,k;
  int typeA,typeB,type;
  REAL r,rr;
  REAL chargeA,chargeB;
  VECTOR posA,posB,dr;
  REAL scalingA;

  UHostAdsorbateChargeChargeReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
  {
    type=Adsorbates[CurrentSystem][i].Type;
    for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
      scalingA=Adsorbates[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
      chargeA=scalingA*Adsorbates[CurrentSystem][i].Atoms[j].Charge;
      posA=Adsorbates[CurrentSystem][i].Atoms[j].Position;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&(!IsFractionalAdsorbateMolecule(i)))
      {
        UHostAdsorbateChargeChargeReal[CurrentSystem]+=InterpolateCoulombGrid(typeA,posA);
      }
      else
      {
        for(CurrentFramework=0;CurrentFramework<Framework[CurrentSystem].NumberOfFrameworks;CurrentFramework++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];k++)
          {
            posB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Position;
            typeB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Type;

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

            if(rr<CutOffChargeChargeSquared[CurrentSystem])
            {
              r=sqrt(rr);
              chargeB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Charge;

              UHostAdsorbateChargeChargeReal[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,r);
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkCationChargeChargeEnergy(void)
{
  int i,j,k;
  int typeA,typeB,type;
  REAL r,rr;
  REAL chargeA,chargeB;
  VECTOR posA,posB,dr;
  REAL scalingA;

  UHostCationChargeChargeReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
  {
    type=Cations[CurrentSystem][i].Type;
    for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Cations[CurrentSystem][i].Atoms[j].Type;
      scalingA=Cations[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
      chargeA=scalingA*Cations[CurrentSystem][i].Atoms[j].Charge;
      posA=Cations[CurrentSystem][i].Atoms[j].Position;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&(!IsFractionalCationMolecule(i)))
      {
        UHostCationChargeChargeReal[CurrentSystem]+=InterpolateCoulombGrid(typeA,posA);
      }
      else
      {
        for(CurrentFramework=0;CurrentFramework<Framework[CurrentSystem].NumberOfFrameworks;CurrentFramework++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];k++)
          {
            posB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Position;
            typeB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Type;

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

            if(rr<CutOffChargeChargeSquared[CurrentSystem])
            {
              r=sqrt(rr);
              chargeB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Charge;

              UHostCationChargeChargeReal[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,r);
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkAdsorbateChargeBondDipoleEnergy(void)
{
  int i,j,k,f1;
  int A1,A2;
  int Type,TypeA;
  VECTOR posA,posB,posA1,posA2,dr;
  REAL rr,ri2,temp,length,chargeB;
  VECTOR dipoleA;
  REAL Bt0,Bt1;
  REAL DipoleMagnitudeA;
  REAL_MATRIX3x3 v;

  UHostAdsorbateChargeBondDipoleReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  Bt0=Bt1=0.0;
  v.ax=v.bx=v.cx=0.0;
  v.ay=v.by=v.cy=0.0;
  v.az=v.bz=v.cz=0.0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
    {
      DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
      A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
      A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
      posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
      posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
      dipoleA.x=posA2.x-posA1.x;
      dipoleA.y=posA2.y-posA1.y;
      dipoleA.z=posA2.z-posA1.z;
      dipoleA=ApplyBoundaryCondition(dipoleA);
      posA.x=posA1.x+0.5*dipoleA.x;
      posA.y=posA1.y+0.5*dipoleA.y;
      posA.z=posA1.z+0.5*dipoleA.z;
      ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
      length=sqrt(ri2);
      temp=DipoleMagnitudeA/length;
      dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

      for(j=0;j<NumberOfAdsorbateMolecules[CurrentSystem];j++)
      {
        for(k=0;k<Adsorbates[CurrentSystem][j].NumberOfAtoms;k++)
        {
          Type=Adsorbates[CurrentSystem][j].Atoms[k].Type;
          if(PseudoAtoms[Type].HasCharges)
          {
            posB=Adsorbates[CurrentSystem][j].Atoms[k].Position;
            chargeB=Adsorbates[CurrentSystem][j].Atoms[k].Charge;

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

            if(rr<CutOffChargeBondDipoleSquared)
              UHostAdsorbateChargeBondDipoleReal[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
          }
        }
      }
    }
  }

  for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
  {
    TypeA=Adsorbates[CurrentSystem][i].Type;
    for(j=0;j<Components[TypeA].NumberOfBondDipoles;j++)
    {
      A1=Components[TypeA].BondDipoles[j].A;
      A2=Components[TypeA].BondDipoles[j].B;
      posA1=Adsorbates[CurrentSystem][i].Atoms[A1].Position;
      posA2=Adsorbates[CurrentSystem][i].Atoms[A2].Position;
      DipoleMagnitudeA=Components[TypeA].BondDipoleMagnitude[j];
      dipoleA.x=posA2.x-posA1.x;
      dipoleA.y=posA2.y-posA1.y;
      dipoleA.z=posA2.z-posA1.z;
      posA.x=posA1.x+0.5*dipoleA.x;
      posA.y=posA1.y+0.5*dipoleA.y;
      posA.z=posA1.z+0.5*dipoleA.z;
      ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
      length=sqrt(ri2);
      temp=DipoleMagnitudeA/length;
      dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

      for(CurrentFramework=0;CurrentFramework<Framework[CurrentSystem].NumberOfFrameworks;CurrentFramework++)
      {
        for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];k++)
        {
          posB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Position;
          Type=Framework[CurrentSystem].Atoms[CurrentFramework][k].Type;
          chargeB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Charge;

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

          if(rr<CutOffChargeBondDipoleSquared)
            UHostAdsorbateChargeBondDipoleReal[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
        }
      }
    }
  }

  return 0;
}

int CalculateFrameworkCationChargeBondDipoleEnergy(void)
{
  int i,j,k,f1;
  int A1,A2;
  int Type,TypeA;
  VECTOR posA,posB,posA1,posA2,dr;
  REAL rr,ri2,temp,length,chargeB;
  VECTOR dipoleA;
  REAL Bt0,Bt1;
  REAL DipoleMagnitudeA;
  REAL_MATRIX3x3 v;

  UHostCationChargeBondDipoleReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  Bt0=Bt1=0.0;
  v.ax=v.bx=v.cx=0.0;
  v.ay=v.by=v.cy=0.0;
  v.az=v.bz=v.cz=0.0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
    {
      DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
      A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
      A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
      posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
      posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
      dipoleA.x=posA2.x-posA1.x;
      dipoleA.y=posA2.y-posA1.y;
      dipoleA.z=posA2.z-posA1.z;
      dipoleA=ApplyBoundaryCondition(dipoleA);
      posA.x=posA1.x+0.5*dipoleA.x;
      posA.y=posA1.y+0.5*dipoleA.y;
      posA.z=posA1.z+0.5*dipoleA.z;
      ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
      length=sqrt(ri2);
      temp=DipoleMagnitudeA/length;
      dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

      for(j=0;j<NumberOfCationMolecules[CurrentSystem];j++)
      {
        for(k=0;k<Cations[CurrentSystem][j].NumberOfAtoms;k++)
        {
          Type=Cations[CurrentSystem][j].Atoms[k].Type;
          if(PseudoAtoms[Type].HasCharges)
          {
            posB=Cations[CurrentSystem][j].Atoms[k].Position;
            chargeB=Cations[CurrentSystem][j].Atoms[k].Charge;

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

            if(rr<CutOffChargeBondDipoleSquared)
              UHostCationChargeBondDipoleReal[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
          }
        }
      }
    }
  }

  for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
  {
    TypeA=Cations[CurrentSystem][i].Type;
    for(j=0;j<Components[TypeA].NumberOfBondDipoles;j++)
    {
      A1=Components[TypeA].BondDipoles[j].A;
      A2=Components[TypeA].BondDipoles[j].B;
      posA1=Cations[CurrentSystem][i].Atoms[A1].Position;
      posA2=Cations[CurrentSystem][i].Atoms[A2].Position;
      DipoleMagnitudeA=Components[TypeA].BondDipoleMagnitude[j];
      dipoleA.x=posA2.x-posA1.x;
      dipoleA.y=posA2.y-posA1.y;
      dipoleA.z=posA2.z-posA1.z;
      posA.x=posA1.x+0.5*dipoleA.x;
      posA.y=posA1.y+0.5*dipoleA.y;
      posA.z=posA1.z+0.5*dipoleA.z;
      ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
      length=sqrt(ri2);
      temp=DipoleMagnitudeA/length;
      dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

      for(CurrentFramework=0;CurrentFramework<Framework[CurrentSystem].NumberOfFrameworks;CurrentFramework++)
      {
        for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];k++)
        {
          posB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Position;
          Type=Framework[CurrentSystem].Atoms[CurrentFramework][k].Type;
          chargeB=Framework[CurrentSystem].Atoms[CurrentFramework][k].Charge;

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

          if(rr<CutOffChargeBondDipoleSquared)
            UHostCationChargeBondDipoleReal[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA,dr,sqrt(rr));
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkAdsorbateBondDipoleBondDipoleEnergy(void)
{
  int i,k,l,f1;
  int A1,A2,B1,B2;
  int TypeB;
  VECTOR posA,posB,posA1,posA2,posB1,posB2,dr;
  REAL r2,ri2,rk2,temp,length;
  VECTOR dipoleA,dipoleB;
  REAL Bt0,Bt1,Bt2;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;

  UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  Bt0=Bt1=Bt2=0.0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
    {
      DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
      A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
      A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
      posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
      posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
      dipoleA.x=posA2.x-posA1.x;
      dipoleA.y=posA2.y-posA1.y;
      dipoleA.z=posA2.z-posA1.z;
      dipoleA=ApplyBoundaryCondition(dipoleA);
      posA.x=posA1.x+0.5*dipoleA.x;
      posA.y=posA1.y+0.5*dipoleA.y;
      posA.z=posA1.z+0.5*dipoleA.z;
      ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
      length=sqrt(ri2);
      temp=DipoleMagnitudeA/length;
      dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

      for(k=0;k<NumberOfAdsorbateMolecules[CurrentSystem];k++)
      {
        TypeB=Adsorbates[CurrentSystem][k].Type;
        for(l=0;l<Components[TypeB].NumberOfBondDipoles;l++)
        {
          B1=Components[TypeB].BondDipoles[l].A;
          B2=Components[TypeB].BondDipoles[l].B;
          posB1=Adsorbates[CurrentSystem][k].Atoms[B1].Position;
          posB2=Adsorbates[CurrentSystem][k].Atoms[B2].Position;
          DipoleMagnitudeB=Components[TypeB].BondDipoleMagnitude[l];
          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
          length=sqrt(rk2);
          temp=DipoleMagnitudeB/length;
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          r2=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(r2<CutOffBondDipoleBondDipoleSquared)
            UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA,dipoleB,dr,sqrt(r2));
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkCationBondDipoleBondDipoleEnergy(void)
{
  int i,k,l,f1;
  int A1,A2,B1,B2;
  int TypeB;
  VECTOR posA,posB,posA1,posA2,posB1,posB2,dr;
  REAL r2,ri2,rk2,temp,length;
  VECTOR dipoleA,dipoleB;
  REAL Bt0,Bt1,Bt2;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;

  UHostCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
  if(ChargeMethod==NONE) return 0;

  Bt0=Bt1=Bt2=0.0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[f1];i++)
    {
      DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[f1][i];
      A1=Framework[CurrentSystem].BondDipoles[f1][i].A;
      A2=Framework[CurrentSystem].BondDipoles[f1][i].B;
      posA1=Framework[CurrentSystem].Atoms[f1][A1].Position;
      posA2=Framework[CurrentSystem].Atoms[f1][A2].Position;
      dipoleA.x=posA2.x-posA1.x;
      dipoleA.y=posA2.y-posA1.y;
      dipoleA.z=posA2.z-posA1.z;
      dipoleA=ApplyBoundaryCondition(dipoleA);
      posA.x=posA1.x+0.5*dipoleA.x;
      posA.y=posA1.y+0.5*dipoleA.y;
      posA.z=posA1.z+0.5*dipoleA.z;
      ri2=SQR(dipoleA.x)+SQR(dipoleA.y)+SQR(dipoleA.z);
      length=sqrt(ri2);
      temp=DipoleMagnitudeA/length;
      dipoleA.x*=temp; dipoleA.y*=temp; dipoleA.z*=temp;

      for(k=0;k<NumberOfCationMolecules[CurrentSystem];k++)
      {
        TypeB=Cations[CurrentSystem][k].Type;
        for(l=0;l<Components[TypeB].NumberOfBondDipoles;l++)
        {
          B1=Components[TypeB].BondDipoles[l].A;
          B2=Components[TypeB].BondDipoles[l].B;
          posB1=Cations[CurrentSystem][k].Atoms[B1].Position;
          posB2=Cations[CurrentSystem][k].Atoms[B2].Position;
          DipoleMagnitudeB=Components[TypeB].BondDipoleMagnitude[l];
          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
          length=sqrt(rk2);
          temp=DipoleMagnitudeB/length;
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          r2=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(r2<CutOffBondDipoleBondDipoleSquared)
            UHostCationBondDipoleBondDipoleReal[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA,dipoleB,dr,sqrt(r2));
        }
      }
    }
  }
  return 0;
}

void CalculateFrameworkShiftEnergyDifferenceAdsorbateVDW(void)
{
  int i,j,m,typeA,typeB;
  POINT posB,posA_new,posA_old;
  REAL rr;
  VECTOR dr;

  // Framework-Adsorbate energy
  UAdsorbateVDWDelta[CurrentSystem]=0.0;
  for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];i++)
  {
    typeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Type;
    posA_new=Framework[CurrentSystem].Atoms[CurrentFramework][i].AnisotropicPosition;
    posA_old=Framework[CurrentSystem].Atoms[CurrentFramework][i].ReferenceAnisotropicPosition;

    for(m=0;m<NumberOfAdsorbateMolecules[CurrentSystem];m++)
    {
      for(j=0;j<Adsorbates[CurrentSystem][m].NumberOfAtoms;j++)
      {
        typeB=Adsorbates[CurrentSystem][m].Atoms[j].Type;
        posB=Adsorbates[CurrentSystem][m].Atoms[j].AnisotropicPosition;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
        if(rr<CutOffVDWSquared)
          UAdsorbateVDWDelta[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
        if(rr<CutOffVDWSquared)
          UAdsorbateVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,1.0);

      }
    }
  }
}

void CalculateFrameworkShiftEnergyDifferenceAdsorbateCharge(void)
{
  int i,j,m,typeA,typeB;
  int A1,A2,B1,B2,TypeMolB;
  POINT posB,posA_new,posA_old;
  REAL rr,r,chargeA,chargeB;
  VECTOR posA1,posA2,dipoleA_new,dipoleA_old;
  VECTOR posB1,posB2,dipoleB;
  REAL DipoleMagnitudeA,DipoleMagnitudeB,temp;
  VECTOR dr;

  // Framework-Adsorbate energy
  UAdsorbateChargeChargeRealDelta[CurrentSystem]=0.0;
  UAdsorbateChargeBondDipoleRealDelta[CurrentSystem]=0.0;
  UAdsorbateBondDipoleBondDipoleRealDelta[CurrentSystem]=0.0;


  for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];i++)
  {
    typeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Type;
    posA_new=Framework[CurrentSystem].Atoms[CurrentFramework][i].Position;
    posA_old=Framework[CurrentSystem].Atoms[CurrentFramework][i].ReferencePosition;
    chargeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Charge;

    for(m=0;m<NumberOfAdsorbateMolecules[CurrentSystem];m++)
    {
      for(j=0;j<Adsorbates[CurrentSystem][m].NumberOfAtoms;j++)
      {
        typeB=Adsorbates[CurrentSystem][m].Atoms[j].Type;
        posB=Adsorbates[CurrentSystem][m].Atoms[j].Position;
        chargeB=Adsorbates[CurrentSystem][m].Atoms[j].Charge;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeChargeSquared[CurrentSystem])
        {
          r=sqrt(rr);

          UAdsorbateChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,r);
        }

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeChargeSquared[CurrentSystem])
        {
          r=sqrt(rr);

          UAdsorbateChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA,chargeB,r);
        }
      }

      TypeMolB=Adsorbates[CurrentSystem][m].Type;
      for(j=0;j<Components[TypeMolB].NumberOfBondDipoles;j++)
      {
        B1=Components[TypeMolB].BondDipoles[j].A;
        B2=Components[TypeMolB].BondDipoles[j].B;
        posB1=Adsorbates[CurrentSystem][m].Atoms[B1].Position;
        posB2=Adsorbates[CurrentSystem][m].Atoms[B2].Position;
        DipoleMagnitudeB=Components[TypeMolB].BondDipoleMagnitude[j];
        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;
        temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
        dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UAdsorbateChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UAdsorbateChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));
      }
    }
  }

  for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[CurrentFramework];i++)
  {
    DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[CurrentFramework][i];
    A1=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].A;
    A2=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].B;

    posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].Position;
    posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].Position;
    dipoleA_new.x=posA2.x-posA1.x;
    dipoleA_new.y=posA2.y-posA1.y;
    dipoleA_new.z=posA2.z-posA1.z;
    dipoleA_new=ApplyBoundaryCondition(dipoleA_new);
    posA_new.x=posA1.x+0.5*dipoleA_new.x;
    posA_new.y=posA1.y+0.5*dipoleA_new.y;
    posA_new.z=posA1.z+0.5*dipoleA_new.z;
    temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z));
    dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;

    posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].ReferencePosition;
    posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].ReferencePosition;
    dipoleA_old.x=posA2.x-posA1.x;
    dipoleA_old.y=posA2.y-posA1.y;
    dipoleA_old.z=posA2.z-posA1.z;
    dipoleA_old=ApplyBoundaryCondition(dipoleA_old);
    posA_old.x=posA1.x+0.5*dipoleA_old.x;
    posA_old.y=posA1.y+0.5*dipoleA_old.y;
    posA_old.z=posA1.z+0.5*dipoleA_old.z;
    temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z));
    dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;

    for(m=0;m<NumberOfAdsorbateMolecules[CurrentSystem];m++)
    {
      TypeMolB=Adsorbates[CurrentSystem][m].Type;
      for(j=0;j<Adsorbates[CurrentSystem][m].NumberOfAtoms;j++)
      {
        typeB=Adsorbates[CurrentSystem][m].Atoms[j].Type;
        posB=Adsorbates[CurrentSystem][m].Atoms[j].Position;
        chargeB=Adsorbates[CurrentSystem][m].Atoms[j].Charge;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UAdsorbateChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UAdsorbateChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_old,dr,sqrt(rr));
      }

      for(j=0;j<Components[TypeMolB].NumberOfBondDipoles;j++)
      {
        B1=Components[TypeMolB].BondDipoles[j].A;
        B2=Components[TypeMolB].BondDipoles[j].B;
        posB1=Adsorbates[CurrentSystem][m].Atoms[B1].Position;
        posB2=Adsorbates[CurrentSystem][m].Atoms[B2].Position;
        DipoleMagnitudeB=Components[TypeMolB].BondDipoleMagnitude[j];
        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;
        temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
        dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffBondDipoleBondDipoleSquared)
          UAdsorbateBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffBondDipoleBondDipoleSquared)
          UAdsorbateBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
      }
    }
  }
}

void CalculateFrameworkShiftEnergyDifferenceCationVDW(void)
{
  int i,j,m,typeA,typeB;
  POINT posB,posA_new,posA_old;
  REAL rr;
  VECTOR dr;

  // Framework-Cation energy
  UCationVDWDelta[CurrentSystem]=0.0;
  for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];i++)
  {
    typeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Type;
    posA_new=Framework[CurrentSystem].Atoms[CurrentFramework][i].AnisotropicPosition;
    posA_old=Framework[CurrentSystem].Atoms[CurrentFramework][i].ReferenceAnisotropicPosition;

    for(m=0;m<NumberOfCationMolecules[CurrentSystem];m++)
    {
      for(j=0;j<Cations[CurrentSystem][m].NumberOfAtoms;j++)
      {
        typeB=Cations[CurrentSystem][m].Atoms[j].Type;
        posB=Cations[CurrentSystem][m].Atoms[j].AnisotropicPosition;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
        if(rr<CutOffVDWSquared)
          UCationVDWDelta[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
        if(rr<CutOffVDWSquared)
          UCationVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,1.0);
      }
    }
  }
}


void CalculateFrameworkShiftEnergyDifferenceCationCharge(void)
{
  int i,j,m,typeA,typeB;
  int A1,A2,B1,B2,TypeMolB;
  POINT posB,posA_new,posA_old;
  REAL rr,r,chargeA,chargeB;
  VECTOR posA1,posA2,dipoleA_new,dipoleA_old;
  VECTOR posB1,posB2,dipoleB;
  REAL DipoleMagnitudeA,DipoleMagnitudeB,temp;
  VECTOR dr;

  // Framework-Cation energy
  UCationChargeChargeRealDelta[CurrentSystem]=0.0;
  UCationChargeBondDipoleRealDelta[CurrentSystem]=0.0;
  UCationBondDipoleBondDipoleRealDelta[CurrentSystem]=0.0;


  for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];i++)
  {
    typeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Type;
    posA_new=Framework[CurrentSystem].Atoms[CurrentFramework][i].Position;
    posA_old=Framework[CurrentSystem].Atoms[CurrentFramework][i].ReferencePosition;
    chargeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Type;

    for(m=0;m<NumberOfCationMolecules[CurrentSystem];m++)
    {
      for(j=0;j<Cations[CurrentSystem][m].NumberOfAtoms;j++)
      {
        typeB=Cations[CurrentSystem][m].Atoms[j].Type;
        posB=Cations[CurrentSystem][m].Atoms[j].Position;
        chargeB=Cations[CurrentSystem][m].Atoms[j].Charge;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeChargeSquared[CurrentSystem])
        {
          r=sqrt(rr);
          UCationChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,r);
        }

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeChargeSquared[CurrentSystem])
        {
          r=sqrt(rr);

          UCationChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA,chargeB,r);
        }
      }

      TypeMolB=Cations[CurrentSystem][m].Type;
      for(j=0;j<Components[TypeMolB].NumberOfBondDipoles;j++)
      {
        B1=Components[TypeMolB].BondDipoles[j].A;
        B2=Components[TypeMolB].BondDipoles[j].B;
        posB1=Cations[CurrentSystem][m].Atoms[B1].Position;
        posB2=Cations[CurrentSystem][m].Atoms[B2].Position;
        DipoleMagnitudeB=Components[TypeMolB].BondDipoleMagnitude[j];
        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;
        temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
        dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UCationChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UCationChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));
      }
    }
  }

  for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[CurrentFramework];i++)
  {
    DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[CurrentFramework][i];
    A1=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].A;
    A2=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].B;

    posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].Position;
    posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].Position;
    dipoleA_new.x=posA2.x-posA1.x;
    dipoleA_new.y=posA2.y-posA1.y;
    dipoleA_new.z=posA2.z-posA1.z;
    dipoleA_new=ApplyBoundaryCondition(dipoleA_new);
    posA_new.x=posA1.x+0.5*dipoleA_new.x;
    posA_new.y=posA1.y+0.5*dipoleA_new.y;
    posA_new.z=posA1.z+0.5*dipoleA_new.z;
    temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z));
    dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;

    posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].ReferencePosition;
    posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].ReferencePosition;
    dipoleA_old.x=posA2.x-posA1.x;
    dipoleA_old.y=posA2.y-posA1.y;
    dipoleA_old.z=posA2.z-posA1.z;
    dipoleA_old=ApplyBoundaryCondition(dipoleA_old);
    posA_old.x=posA1.x+0.5*dipoleA_old.x;
    posA_old.y=posA1.y+0.5*dipoleA_old.y;
    posA_old.z=posA1.z+0.5*dipoleA_old.z;
    temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z));
    dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;

    for(m=0;m<NumberOfCationMolecules[CurrentSystem];m++)
    {
      TypeMolB=Cations[CurrentSystem][m].Type;
      for(j=0;j<Cations[CurrentSystem][m].NumberOfAtoms;j++)
      {
        typeB=Cations[CurrentSystem][m].Atoms[j].Type;
        posB=Cations[CurrentSystem][m].Atoms[j].Position;
        chargeB=Cations[CurrentSystem][m].Atoms[j].Charge;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UCationChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffChargeBondDipoleSquared)
          UCationChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_old,dr,sqrt(rr));
      }

      for(j=0;j<Components[TypeMolB].NumberOfBondDipoles;j++)
      {
        B1=Components[TypeMolB].BondDipoles[j].A;
        B2=Components[TypeMolB].BondDipoles[j].B;
        posB1=Cations[CurrentSystem][m].Atoms[B1].Position;
        posB2=Cations[CurrentSystem][m].Atoms[B2].Position;
        DipoleMagnitudeB=Components[TypeMolB].BondDipoleMagnitude[j];
        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;
        temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
        dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

        dr.x=posA_new.x-posB.x;
        dr.y=posA_new.y-posB.y;
        dr.z=posA_new.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffBondDipoleBondDipoleSquared)
          UCationBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));

        dr.x=posA_old.x-posB.x;
        dr.y=posA_old.y-posB.y;
        dr.z=posA_old.z-posB.z;
        dr=ApplyBoundaryCondition(dr);
        rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

        if(rr<CutOffBondDipoleBondDipoleSquared)
          UCationBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
      }
    }
  }
}


REAL CalculateEnergyDifferenceFrameworkMoveVDW(int atom_id,VECTOR posA,int typeA)
{
  int j,f1,typeB;
  REAL rr;
  VECTOR dr,posB;
  REAL UHostVDW;
  int ncell;
  int index_j;

  UHostVDW=0.0;
  if(!InternalFrameworkLennardJonesInteractions) return 0.0;

  // loop over all frameworks
  if(UseReplicas[CurrentSystem])
  {
    for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];j++)
    {
      for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
      {
        if(j!=atom_id) // no self-contribution for a single atom
        {
          index_j=j+ncell*Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];
          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[CurrentFramework][atom_id][index_j],0))
          {
            posB=Framework[CurrentSystem].Atoms[CurrentFramework][j].AnisotropicPosition;
            typeB=Framework[CurrentSystem].Atoms[CurrentFramework][j].Type;

            dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            if(rr<CutOffVDWSquared)
              UHostVDW+=PotentialValue(typeA,typeB,rr,1.0);
          }
        }
      }
    }
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      if(f1!=CurrentFramework)
      {
        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          posB=Framework[CurrentSystem].Atoms[f1][j].AnisotropicPosition;
          typeB=Framework[CurrentSystem].Atoms[f1][j].Type;

          for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
          {
            dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            if(rr<CutOffVDWSquared)
              UHostVDW+=PotentialValue(typeA,typeB,rr,1.0);
          }
        }
      }
    }
  }
  else
  {
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
      {
        if(f1!=CurrentFramework?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][atom_id][j],0))
        {
          posB=Framework[CurrentSystem].Atoms[f1][j].AnisotropicPosition;
          typeB=Framework[CurrentSystem].Atoms[f1][j].Type;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
            UHostVDW+=PotentialValue(typeA,typeB,rr,1.0);
        }
      }
    }
  }
  return UHostVDW;
}

void CalculateEnergyDifferenceFrameworkMoveCharge(int atom_id)
{
  int i,j,f1,typeA,typeB;
  int A1,A2,B1,B2;
  REAL rr;
  VECTOR dr,posB;
  VECTOR posA_new,posA_old;
  REAL chargeA,chargeB;
  VECTOR posA1,posA2,posB1,posB2,posB_new,posB_old;
  VECTOR dipoleB,dipoleA_new,dipoleA_old,dipoleB_new,dipoleB_old;
  REAL temp;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;
  int ncell;
  int index_j;

  UHostChargeChargeRealDelta[CurrentSystem]=0.0;
  UHostChargeBondDipoleRealDelta[CurrentSystem]=0.0;
  UHostBondDipoleBondDipoleRealDelta[CurrentSystem]=0.0;

  posA_new=Framework[CurrentSystem].Atoms[CurrentFramework][atom_id].Position;
  posA_old=Framework[CurrentSystem].Atoms[CurrentFramework][atom_id].ReferencePosition;
  typeA=Framework[CurrentSystem].Atoms[CurrentFramework][atom_id].Type;
  chargeA=Framework[CurrentSystem].Atoms[CurrentFramework][atom_id].Charge;

  // loop over all frameworks
  if(UseReplicas[CurrentSystem])
  {
    for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];j++)
    {
      for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
      {
        if(j!=atom_id) // no self-contribution for a single atom
        {
          index_j=j+ncell*Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];
          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[CurrentFramework][atom_id][index_j],1))
          {
            posB=Framework[CurrentSystem].Atoms[CurrentFramework][j].Position;
            typeB=Framework[CurrentSystem].Atoms[CurrentFramework][j].Type;
            chargeB=Framework[CurrentSystem].Atoms[CurrentFramework][j].Charge;

            dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            if(rr<CutOffChargeChargeSquared[CurrentSystem])
              UHostChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

            dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            if(rr<CutOffChargeChargeSquared[CurrentSystem])
              UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));
          }
        }
      }
    }
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      if(f1!=CurrentFramework)
      {
        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          posB=Framework[CurrentSystem].Atoms[f1][j].AnisotropicPosition;
          typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
          chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

          for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
          {
            dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            if(rr<CutOffChargeChargeSquared[CurrentSystem])
              UHostChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

            dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
            dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
            dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
            dr=ApplyReplicaBoundaryCondition(dr);
            rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
            if(rr<CutOffChargeChargeSquared[CurrentSystem])
              UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));
          }
        }
      }
    }
  }
  else
  {
    // loop over all frameworks
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
      {
        if(f1!=CurrentFramework?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][atom_id][j],1))
        {
          posB=Framework[CurrentSystem].Atoms[f1][j].Position;
          typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
          chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

          dr.x=posA_new.x-posB.x;
          dr.y=posA_new.y-posB.y;
          dr.z=posA_new.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
            UHostChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

          dr.x=posA_old.x-posB.x;
          dr.y=posA_old.y-posB.y;
          dr.z=posA_old.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
            UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));
        }
      }

      // compute the charge-bond-dipole interactions
      for(j=0;j<Framework[CurrentSystem].NumberOfBondDipoles[f1];j++)
      {
        if(f1!=CurrentFramework?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][atom_id][j],2))
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][j];
          B1=Framework[CurrentSystem].BondDipoles[f1][j].A;
          B2=Framework[CurrentSystem].BondDipoles[f1][j].B;
          posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
          posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          dipoleB=ApplyBoundaryCondition(dipoleB);
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

          dr.x=posA_new.x-posB.x;
          dr.y=posA_new.y-posB.y;
          dr.z=posA_new.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeBondDipoleSquared)
            UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));

          dr.x=posA_old.x-posB.x;
          dr.y=posA_old.y-posB.y;
          dr.z=posA_old.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeBondDipoleSquared)
            UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));
        }
      }
    }

    // loop over all the atoms of the currently selected framework
    for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[CurrentFramework];i++)
    {
      DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[CurrentFramework][i];
      A1=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].A;
      A2=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].B;

      // check if the current-atom is part of the current bond-dipole i
      if((atom_id==A1)||(atom_id==A2))
      {
        posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].Position;
        posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].Position;
        dipoleA_new.x=posA2.x-posA1.x;
        dipoleA_new.y=posA2.y-posA1.y;
        dipoleA_new.z=posA2.z-posA1.z;
        dipoleA_new=ApplyBoundaryCondition(dipoleA_new);
        posA_new.x=posA1.x+0.5*dipoleA_new.x;
        posA_new.y=posA1.y+0.5*dipoleA_new.y;
        posA_new.z=posA1.z+0.5*dipoleA_new.z;
        temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z));
        dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;

        posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].ReferencePosition;
        posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].ReferencePosition;
        dipoleA_old.x=posA2.x-posA1.x;
        dipoleA_old.y=posA2.y-posA1.y;
        dipoleA_old.z=posA2.z-posA1.z;
        dipoleA_old=ApplyBoundaryCondition(dipoleA_old);
        posA_old.x=posA1.x+0.5*dipoleA_old.x;
        posA_old.y=posA1.y+0.5*dipoleA_old.y;
        posA_old.z=posA1.z+0.5*dipoleA_old.z;
        temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z));
        dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;

        // loop over all frameworks
        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
          {
            if(f1!=CurrentFramework?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][j][i],2))
            {
              posB_new=Framework[CurrentSystem].Atoms[f1][j].Position;
              posB_old=Framework[CurrentSystem].Atoms[f1][j].ReferencePosition;
              typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
              chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

              dr.x=posA_new.x-posB_new.x;
              dr.y=posA_new.y-posB_new.y;
              dr.z=posA_new.z-posB_new.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeBondDipoleSquared)
                UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));

              dr.x=posA_old.x-posB_old.x;
              dr.y=posA_old.y-posB_old.y;
              dr.z=posA_old.z-posB_old.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeBondDipoleSquared)
                UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_old,dr,sqrt(rr));
            }
          }

          // compute the bond-dipole-bond-dipole interactions
          for(j=0;j<Framework[CurrentSystem].NumberOfBondDipoles[f1];j++)
          {
            if(f1!=CurrentFramework?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][j],3))
            {
              DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][j];
              B1=Framework[CurrentSystem].BondDipoles[f1][j].A;
              B2=Framework[CurrentSystem].BondDipoles[f1][j].B;

              posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
              posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;
              dipoleB_new.x=posB2.x-posB1.x;
              dipoleB_new.y=posB2.y-posB1.y;
              dipoleB_new.z=posB2.z-posB1.z;
              dipoleB_new=ApplyBoundaryCondition(dipoleB_new);
              posB_new.x=posB1.x+0.5*dipoleB_new.x;
              posB_new.y=posB1.y+0.5*dipoleB_new.y;
              posB_new.z=posB1.z+0.5*dipoleB_new.z;
              temp=DipoleMagnitudeB/sqrt(SQR(dipoleB_new.x)+SQR(dipoleB_new.y)+SQR(dipoleB_new.z));
              dipoleB_new.x*=temp; dipoleB_new.y*=temp; dipoleB_new.z*=temp;

              posB1=Framework[CurrentSystem].Atoms[f1][B1].ReferencePosition;
              posB2=Framework[CurrentSystem].Atoms[f1][B2].ReferencePosition;
              dipoleB_old.x=posB2.x-posB1.x;
              dipoleB_old.y=posB2.y-posB1.y;
              dipoleB_old.z=posB2.z-posB1.z;
              dipoleB_old=ApplyBoundaryCondition(dipoleB_old);
              posB_old.x=posB1.x+0.5*dipoleB_old.x;
              posB_old.y=posB1.y+0.5*dipoleB_old.y;
              posB_old.z=posB1.z+0.5*dipoleB_old.z;
              temp=DipoleMagnitudeB/sqrt(SQR(dipoleB_old.x)+SQR(dipoleB_old.y)+SQR(dipoleB_old.z));
              dipoleB_old.x*=temp; dipoleB_old.y*=temp; dipoleB_old.z*=temp;

              dr.x=posA_new.x-posB_new.x;
              dr.y=posA_new.y-posB_new.y;
              dr.z=posA_new.z-posB_new.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB_new,dr,sqrt(rr));

              dr.x=posA_old.x-posB_old.x;
              dr.y=posA_old.y-posB_old.y;
              dr.z=posA_old.z-posB_old.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB_old,dr,sqrt(rr));
            }
          }
        }
      }
    }
  }
}



void CalculateFrameworkEnergyDifferenceShiftedFramework(void)
{
  int i,j,f1,typeA,typeB;
  int A1,A2,B1,B2;
  REAL rr,chargeA,chargeB;
  VECTOR dr,posA_new,posA_old,posB,posA1,posA2,posB1,posB2;
  VECTOR dipoleB,dipoleA_new,dipoleA_old;
  REAL temp;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;

  // Framework-Adsorbate energy
  UHostVDWDelta[CurrentSystem]=0.0;
  UHostChargeChargeRealDelta[CurrentSystem]=0.0;
  UHostChargeBondDipoleRealDelta[CurrentSystem]=0.0;
  UHostBondDipoleBondDipoleRealDelta[CurrentSystem]=0.0;

  // loop over all the atoms of the currently selected framework
  for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[CurrentFramework];i++)
  {
    posA_new=Framework[CurrentSystem].Atoms[CurrentFramework][i].Position;
    posA_old=Framework[CurrentSystem].Atoms[CurrentFramework][i].ReferencePosition;
    typeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Type;
    chargeA=Framework[CurrentSystem].Atoms[CurrentFramework][i].Charge;

    // loop over all frameworks
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      // except the current one (no self-interaction, simple translation of the whole framework)
      if(f1!=CurrentFramework)
      {
        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          posB=Framework[CurrentSystem].Atoms[f1][j].Position;
          typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
          chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

          dr.x=posA_new.x-posB.x;
          dr.y=posA_new.y-posB.y;
          dr.z=posA_new.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
            if(InternalFrameworkLennardJonesInteractions)
              UHostVDWDelta[CurrentSystem]+=PotentialValue(typeA,typeB,rr,1.0);

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
            UHostChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

          dr.x=posA_old.x-posB.x;
          dr.y=posA_old.y-posB.y;
          dr.z=posA_old.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
            if(InternalFrameworkLennardJonesInteractions)
              UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,1.0);

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
            UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));
        }

        // compute the charge-bond-dipole interactions
        for(j=0;j<Framework[CurrentSystem].NumberOfBondDipoles[f1];j++)
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][j];
          B1=Framework[CurrentSystem].BondDipoles[f1][j].A;
          B2=Framework[CurrentSystem].BondDipoles[f1][j].B;
          posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
          posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          dipoleB=ApplyBoundaryCondition(dipoleB);
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

          dr.x=posA_new.x-posB.x;
          dr.y=posA_new.y-posB.y;
          dr.z=posA_new.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeBondDipoleSquared)
            UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));

          dr.x=posA_old.x-posB.x;
          dr.y=posA_old.y-posB.y;
          dr.z=posA_old.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeBondDipoleSquared)
            UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA,dipoleB,dr,sqrt(rr));
        }
      }
    }
  }

  // loop over all the atoms of the currently selected framework
  for(i=0;i<Framework[CurrentSystem].NumberOfBondDipoles[CurrentFramework];i++)
  {
    DipoleMagnitudeA=Framework[CurrentSystem].BondDipoleMagnitude[CurrentFramework][i];
    A1=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].A;
    A2=Framework[CurrentSystem].BondDipoles[CurrentFramework][i].B;

    posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].Position;
    posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].Position;
    dipoleA_new.x=posA2.x-posA1.x;
    dipoleA_new.y=posA2.y-posA1.y;
    dipoleA_new.z=posA2.z-posA1.z;
    dipoleA_new=ApplyBoundaryCondition(dipoleA_new);
    posA_new.x=posA1.x+0.5*dipoleA_new.x;
    posA_new.y=posA1.y+0.5*dipoleA_new.y;
    posA_new.z=posA1.z+0.5*dipoleA_new.z;
    temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z));
    dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;

    posA1=Framework[CurrentSystem].Atoms[CurrentFramework][A1].ReferencePosition;
    posA2=Framework[CurrentSystem].Atoms[CurrentFramework][A2].ReferencePosition;
    dipoleA_old.x=posA2.x-posA1.x;
    dipoleA_old.y=posA2.y-posA1.y;
    dipoleA_old.z=posA2.z-posA1.z;
    dipoleA_old=ApplyBoundaryCondition(dipoleA_old);
    posA_old.x=posA1.x+0.5*dipoleA_old.x;
    posA_old.y=posA1.y+0.5*dipoleA_old.y;
    posA_old.z=posA1.z+0.5*dipoleA_old.z;
    temp=DipoleMagnitudeA/sqrt(SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z));
    dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;


    // loop over all frameworks
    for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
    {
      // except the current one (no self-interaction, simple translation of the whole framework)
      if(f1!=CurrentFramework)
      {
        for(j=0;j<Framework[CurrentSystem].NumberOfAtoms[f1];j++)
        {
          posB=Framework[CurrentSystem].Atoms[f1][j].Position;
          typeB=Framework[CurrentSystem].Atoms[f1][j].Type;
          chargeB=Framework[CurrentSystem].Atoms[f1][j].Charge;

          dr.x=posA_new.x-posB.x;
          dr.y=posA_new.y-posB.y;
          dr.z=posA_new.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeBondDipoleSquared)
            UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));

          dr.x=posA_old.x-posB.x;
          dr.y=posA_old.y-posB.y;
          dr.z=posA_old.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeBondDipoleSquared)
            UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_old,dr,sqrt(rr));
        }

        // compute the bond-dipole-bond-dipole interactions
        for(j=0;j<Framework[CurrentSystem].NumberOfBondDipoles[f1];j++)
        {
          DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][j];
          B1=Framework[CurrentSystem].BondDipoles[f1][j].A;
          B2=Framework[CurrentSystem].BondDipoles[f1][j].B;
          posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
          posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

          dipoleB.x=posB2.x-posB1.x;
          dipoleB.y=posB2.y-posB1.y;
          dipoleB.z=posB2.z-posB1.z;
          dipoleB=ApplyBoundaryCondition(dipoleB);
          posB.x=posB1.x+0.5*dipoleB.x;
          posB.y=posB1.y+0.5*dipoleB.y;
          posB.z=posB1.z+0.5*dipoleB.z;
          temp=DipoleMagnitudeB/sqrt(SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z));
          dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

          dr.x=posA_new.x-posB.x;
          dr.y=posA_new.y-posB.y;
          dr.z=posA_new.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffBondDipoleBondDipoleSquared)
            UHostBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));

          dr.x=posA_old.x-posB.x;
          dr.y=posA_old.y-posB.y;
          dr.z=posA_old.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffBondDipoleBondDipoleSquared)
            UHostBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
        }
      }
    }
  }
}

int CalculateFrameworkIntraReplicaVDWEnergy(void)
{
  int i,j,typeA,typeB,start;
  REAL energy,rr;
  VECTOR posA,posB,dr;
  int f1,f2,ncell,index_j;
  int A,B;
  REAL *parms;

  // Framework-Framework energy
  UHostHostVDW[CurrentSystem]=0.0;

  if(!InternalFrameworkLennardJonesInteractions) return 0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(f2=f1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
      {
        typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
        posA=Framework[CurrentSystem].Atoms[f1][i].AnisotropicPosition;

        for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
        {
          if((f1==f2)&&(ncell==0)) start=i+1;
          else start=0;

          for(j=start;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
          {
            index_j=j+ncell*Framework[CurrentSystem].NumberOfAtoms[f2];
            if(f1!=f2?TRUE:(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][index_j],0)))
            {
              typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
              posB=Framework[CurrentSystem].Atoms[f2][j].AnisotropicPosition;

              dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffVDWSquared)
              {
                energy=PotentialValue(typeA,typeB,rr,1.0);

                if(ncell==0)
                  UHostHostVDW[CurrentSystem]+=energy;
                else
                  UHostHostVDW[CurrentSystem]+=0.5*energy;
              }
            }
          }
        }
      }
    }
  }

  // contributions from interactions 1-4 torsions
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
      {
        parms=Framework[CurrentSystem].TorsionArguments[f1][i];

        if(fabs(parms[6])>1e-8)
        {
          A=MIN2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);
          B=MAX2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);

          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
          {
            typeA=Framework[CurrentSystem].Atoms[f1][A].Type;
            posA=Framework[CurrentSystem].Atoms[f1][A].AnisotropicPosition;

            typeB=Framework[CurrentSystem].Atoms[f1][B].Type;
            posB=Framework[CurrentSystem].Atoms[f1][B].AnisotropicPosition;

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

            if(rr<CutOffVDWSquared)
            {
              UHostHostVDW[CurrentSystem]+=parms[6]*PotentialValue(typeA,typeB,rr,1.0);
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkIntraReplicaChargeChargeEnergy(void)
{
  int i,j,typeA,typeB,start;
  REAL chargeA,chargeB;
  REAL r,rr,energy;
  VECTOR posA,posB,dr;
  int f1,f2,ncell,index_j;
  int A,B;
  REAL alpha;
  REAL *parms;

  // Framework-Framework energy
  UHostHostChargeChargeReal[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    for(f2=f1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
      {
        typeA=Framework[CurrentSystem].Atoms[f1][i].Type;
        posA=Framework[CurrentSystem].Atoms[f1][i].Position;
        chargeA=Framework[CurrentSystem].Atoms[f1][i].Charge;

        for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
        {
          if((f1==f2)&&(ncell==0)) start=i+1;
          else start=0;
          for(j=start;j<Framework[CurrentSystem].NumberOfAtoms[f2];j++)
          {
            index_j=j+ncell*Framework[CurrentSystem].NumberOfAtoms[f2];
            if(f1!=f2?TRUE:!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][i][index_j],1))
            {
              typeB=Framework[CurrentSystem].Atoms[f2][j].Type;
              posB=Framework[CurrentSystem].Atoms[f2][j].Position;
              chargeB=Framework[CurrentSystem].Atoms[f2][j].Charge;

              dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
              {
                energy=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

                if(ncell==0)
                  UHostHostChargeChargeReal[CurrentSystem]+=energy;
                else
                  UHostHostChargeChargeReal[CurrentSystem]+=0.5*energy;
              }
            }
          }
        }
      }
    }
  }


  // contributions from interactions 1-4 torsions
  alpha=Alpha[CurrentSystem];
  for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
  {
    if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
    {
      for(i=0;i<Framework[CurrentSystem].NumberOfTorsions[f1];i++)
      {
        parms=Framework[CurrentSystem].TorsionArguments[f1][i];

        if(fabs(parms[7])>1e-8)
        {
          A=MIN2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);
          B=MAX2(Framework[CurrentSystem].Torsions[f1][i].A,Framework[CurrentSystem].Torsions[f1][i].D);

          if(!BITVAL(Framework[CurrentSystem].ExclusionMatrix[f1][A][B],7))
          {
            chargeA=Framework[CurrentSystem].Atoms[f1][A].Charge;
            posA=Framework[CurrentSystem].Atoms[f1][A].AnisotropicPosition;

            chargeB=Framework[CurrentSystem].Atoms[f1][B].Charge;
            posB=Framework[CurrentSystem].Atoms[f1][B].AnisotropicPosition;

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

            if(rr<CutOffChargeChargeSquared[CurrentSystem])
            {
              r=sqrt(rr);
              UHostHostChargeChargeReal[CurrentSystem]+=parms[7]*COULOMBIC_CONVERSION_FACTOR*chargeA*chargeB/r;
            }
          }
        }
      }
    }
  }
  return 0;
}


int CalculateFrameworkAdsorbateReplicaVDWEnergy(void)
{
  int i,j,k,f1;
  int typeA,typeB,type;
  REAL rr,scaling;
  VECTOR posA,posB,dr;
  int ncell;

  UHostAdsorbateVDW[CurrentSystem]=0.0;
  for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
  {
    type=Adsorbates[CurrentSystem][i].Type;
    for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
      posA=Adsorbates[CurrentSystem][i].Atoms[j].AnisotropicPosition;
      scaling=Adsorbates[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA]))
      {
        UHostAdsorbateVDW[CurrentSystem]+=InterpolateVDWGrid(typeA,posA);
      }
      else
      {
        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
            typeB=Framework[CurrentSystem].Atoms[f1][k].Type;

            for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
            {
              dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffVDWSquared)
                UHostAdsorbateVDW[CurrentSystem]+=PotentialValue(typeA,typeB,rr,scaling);
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkCationReplicaVDWEnergy(void)
{
  int i,j,k,f1;
  int typeA,typeB,type;
  REAL rr,scaling;
  VECTOR posA,posB,dr;
  int ncell;

  UHostCationVDW[CurrentSystem]=0.0;
  for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
  {
    type=Cations[CurrentSystem][i].Type;
    for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Cations[CurrentSystem][i].Atoms[j].Type;
      posA=Cations[CurrentSystem][i].Atoms[j].AnisotropicPosition;
      scaling=Cations[CurrentSystem][i].Atoms[j].CFVDWScalingParameter;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA]))
      {
        UHostCationVDW[CurrentSystem]+=InterpolateVDWGrid(typeA,posA);
      }
      else
      {
        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;
            typeB=Framework[CurrentSystem].Atoms[f1][k].Type;

            for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
            {
              dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffVDWSquared)
                UHostCationVDW[CurrentSystem]+=PotentialValue(typeA,typeB,rr,scaling);
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkAdsorbateReplicaChargeChargeEnergy(void)
{
  int i,j,k,f1;
  int typeA,typeB,type;
  REAL rr,chargeA,chargeB;
  REAL energy,scaling;
  VECTOR posA,posB,dr;
  int ncell;

  UHostAdsorbateChargeChargeReal[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
  {
    type=Adsorbates[CurrentSystem][i].Type;
    for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Adsorbates[CurrentSystem][i].Atoms[j].Type;
      posA=Adsorbates[CurrentSystem][i].Atoms[j].Position;
      scaling=Adsorbates[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
      chargeA=scaling*Adsorbates[CurrentSystem][i].Atoms[j].Charge;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid))
      {
        UHostAdsorbateChargeChargeReal[CurrentSystem]+=InterpolateCoulombGrid(typeA,posA);
      }
      else
      {
        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            posB=Framework[CurrentSystem].Atoms[f1][k].Position;
            typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
            chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

            for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
            {
              dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
              {
                energy=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

                // energy
                UHostAdsorbateChargeChargeReal[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }
  return 0;
}

int CalculateFrameworkCationReplicaChargeChargeEnergy(void)
{
  int i,j,k,f1;
  int typeA,typeB,type;
  REAL rr,chargeA,chargeB;
  REAL energy,scaling;
  VECTOR posA,posB,dr;
  int ncell;

  UHostCationChargeChargeReal[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
  {
    type=Cations[CurrentSystem][i].Type;
    for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
    {
      typeA=Cations[CurrentSystem][i].Atoms[j].Type;
      posA=Cations[CurrentSystem][i].Atoms[j].Position;
      scaling=Cations[CurrentSystem][i].Atoms[j].CFChargeScalingParameter;
      chargeA=scaling*Cations[CurrentSystem][i].Atoms[j].Charge;

      if((Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid))
      {
        UHostCationChargeChargeReal[CurrentSystem]+=InterpolateCoulombGrid(typeA,posA);
      }
      else
      {
        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            posB=Framework[CurrentSystem].Atoms[f1][k].Position;
            typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
            chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

            for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
            {
              dr.x=posA.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
              {
                energy=PotentialValueCoulombic(chargeA,chargeB,sqrt(rr));

                // energy
                UHostCationChargeChargeReal[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }
  return 0;
}

// Monte Carlo routines
// ====================


/*********************************************************************************************************
 * Name       | CalculateFrameworkAdsorbateVDWEnergyDifference                                           *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single adsorbate molecule:          *
 *            | 1) New=TRUE, Old=FAlse, computes the VDW energy of the new molecule (positions in        *
 *            |    'TrialAnisotropicPosition' and the molecule is of type 'comp'                         *
 *            | 2) New=FALSE, Old=TRUE, computes the VDW energy of molecule 'm' of type 'comp'           *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in VDW energy of the molecule 'm' with    *
 *            |    the new positions in 'TrialAnisotropicPosition' and the old positions                 *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the VDW energy of the new positions stored in             *
 *            |      'TrialAnisotropicPosition'                                                          *
 *            | False: whether or not to compute the VDW energy of the old positions of molecule 'm'     *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveAdsorbate(void)                                                       *
 *            | int RandomTranslationMoveAdsorbate(void)                                                 *
 *            | int RotationMoveAdsorbate(void)                                                          *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkAdsorbateVDWEnergyDifference(int m,int comp,int New,int Old,int CanUseGridNew, int CanUseGridOld)
{
  int i,j,k,nr_atoms,typeA,typeB,f1;
  POINT posA_new,posA_old,posB;
  REAL rr,energy,scaling_new,scaling_old;
  VECTOR dr,s;
  int icell0,icell;
  int ncell;

  // Framework-Adsorbate energy
  OVERLAP=FALSE;
  UHostVDWDelta[CurrentSystem]=0.0;

  if(New)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      nr_atoms=Components[comp].NumberOfAtoms;
      for(j=0;j<nr_atoms;j++)
      {
        typeA=Components[comp].Type[j];
        posA_new=TrialAnisotropicPosition[CurrentSystem][j];
        scaling_new=CFVDWScaling[j];

        if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&CanUseGridNew)
          UHostVDWDelta[CurrentSystem]+=InterpolateVDWGrid(typeA,posA_new);
        else if(UseCellLists[CurrentSystem])
        {
          // convert from xyz to abc
          s.x=InverseBox[CurrentSystem].ax*posA_new.x+InverseBox[CurrentSystem].bx*posA_new.y+InverseBox[CurrentSystem].cx*posA_new.z;
          s.y=InverseBox[CurrentSystem].ay*posA_new.x+InverseBox[CurrentSystem].by*posA_new.y+InverseBox[CurrentSystem].cy*posA_new.z;
          s.z=InverseBox[CurrentSystem].az*posA_new.x+InverseBox[CurrentSystem].bz*posA_new.y+InverseBox[CurrentSystem].cz*posA_new.z;

          // apply boundary condition
          s.x-=(REAL)NINT(s.x);
          s.y-=(REAL)NINT(s.y);
          s.z-=(REAL)NINT(s.z);

          // s between 0 and 1
          s.x+=0.5;
          s.y+=0.5;
          s.z+=0.5;

          // compute the corresponding cell-id
          icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
                 ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
                 ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            // loop over cells
            for(i=0;i<27;i++)
            {
              icell=CellListMap[CurrentSystem][icell0][i];

              k=Framework[CurrentSystem].CellListHead[f1][icell];

              while(k>=0)
              {
                typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
                posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

                dr.x=posA_new.x-posB.x;
                dr.y=posA_new.y-posB.y;
                dr.z=posA_new.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffVDWSquared)
                {
                  energy=PotentialValue(typeA,typeB,rr,1.0);
                  if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                  UHostVDWDelta[CurrentSystem]+=energy;
                }

                k=Framework[CurrentSystem].CellList[f1][k];
              }
            }
          }
        }
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffVDWSquared)
                {
                  energy=PotentialValue(typeA,typeB,rr,scaling_new);
                  if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                  UHostVDWDelta[CurrentSystem]+=energy;
                }
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffVDWSquared)
              {
                energy=PotentialValue(typeA,typeB,rr,scaling_new);
                if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                UHostVDWDelta[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }


  if(Old)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      nr_atoms=Components[comp].NumberOfAtoms;
      for(j=0;j<nr_atoms;j++)
      {
        typeA=Components[comp].Type[j];
        posA_old=Adsorbates[CurrentSystem][m].Atoms[j].AnisotropicPosition;
        scaling_old=Adsorbates[CurrentSystem][m].Atoms[j].CFVDWScalingParameter;

        if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&CanUseGridOld)
          UHostVDWDelta[CurrentSystem]-=InterpolateVDWGrid(typeA,posA_old);
        else if(UseCellLists[CurrentSystem])
        {
          // convert from xyz to abc
          s.x=InverseBox[CurrentSystem].ax*posA_old.x+InverseBox[CurrentSystem].bx*posA_old.y+InverseBox[CurrentSystem].cx*posA_old.z;
          s.y=InverseBox[CurrentSystem].ay*posA_old.x+InverseBox[CurrentSystem].by*posA_old.y+InverseBox[CurrentSystem].cy*posA_old.z;
          s.z=InverseBox[CurrentSystem].az*posA_old.x+InverseBox[CurrentSystem].bz*posA_old.y+InverseBox[CurrentSystem].cz*posA_old.z;

          // apply boundary condition
          s.x-=(REAL)NINT(s.x);
          s.y-=(REAL)NINT(s.y);
          s.z-=(REAL)NINT(s.z);

          // s between 0 and 1
          s.x+=0.5;
          s.y+=0.5;
          s.z+=0.5;

          // compute the corresponding cell-id
          icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
                 ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
                 ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            // loop over cells
            for(i=0;i<27;i++)
            {
              icell=CellListMap[CurrentSystem][icell0][i];

              k=Framework[CurrentSystem].CellListHead[f1][icell];

              while(k>=0)
              {
                typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
                posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

                dr.x=posA_old.x-posB.x;
                dr.y=posA_old.y-posB.y;
                dr.z=posA_old.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
                if(rr<CutOffVDWSquared)
                  UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,1.0);

                k=Framework[CurrentSystem].CellList[f1][k];
              }
            }
          }
        }
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
                if(rr<CutOffVDWSquared)
                  UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,scaling_old);
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
              if(rr<CutOffVDWSquared)
                UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,scaling_old);
            }
          }
        }
      }
    }
  }

  return 0;
}


/*********************************************************************************************************
 * Name       | CalculateFrameworkCationVDWEnergyDifference                                              *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single cation molecule:             *
 *            | 1) New=TRUE, Old=FAlse, computes the VDW energy of the new molecule (positions in        *
 *            |    'TrialAnisotropicPosition' and the molecule is of type 'comp'                         *
 *            | 2) New=FALSE, Old=TRUE, computes the VDW energy of molecule 'm' of type 'comp'           *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in VDW energy of the molecule 'm' with    *
 *            |    the new positions in 'TrialAnisotropicPosition' and the old positions                 *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the VDW energy of the new positions stored in             *
 *            |      'TrialAnisotropicPosition'                                                          *
 *            | False: whether or not to compute the VDW energy of the old positions of molecule 'm'     *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveCation(void)                                                          *
 *            | int RandomTranslationMoveCation(void)                                                    *
 *            | int RotationMoveCation(void)                                                             *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkCationVDWEnergyDifference(int m,int comp,int New,int Old,int CanUseGridNew, int CanUseGridOld)
{
  int i,j,k,nr_atoms,typeA,typeB,f1;
  POINT posA_new,posA_old,posB;
  REAL rr,energy,scaling_new,scaling_old;
  VECTOR dr,s;
  int icell0,icell;
  int ncell;

  // Framework-Cation energy
  OVERLAP=FALSE;
  UHostVDWDelta[CurrentSystem]=0.0;
  if(New)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      nr_atoms=Components[comp].NumberOfAtoms;
      for(j=0;j<nr_atoms;j++)
      {
        typeA=Components[comp].Type[j];
        posA_new=TrialAnisotropicPosition[CurrentSystem][j];
        scaling_new=CFVDWScaling[j];

        if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&CanUseGridNew)
          UHostVDWDelta[CurrentSystem]+=InterpolateVDWGrid(typeA,posA_new);
        else if(UseCellLists[CurrentSystem])
        {
          // convert from xyz to abc
          s.x=InverseBox[CurrentSystem].ax*posA_new.x+InverseBox[CurrentSystem].bx*posA_new.y+InverseBox[CurrentSystem].cx*posA_new.z;
          s.y=InverseBox[CurrentSystem].ay*posA_new.x+InverseBox[CurrentSystem].by*posA_new.y+InverseBox[CurrentSystem].cy*posA_new.z;
          s.z=InverseBox[CurrentSystem].az*posA_new.x+InverseBox[CurrentSystem].bz*posA_new.y+InverseBox[CurrentSystem].cz*posA_new.z;

          // apply boundary condition
          s.x-=(REAL)NINT(s.x);
          s.y-=(REAL)NINT(s.y);
          s.z-=(REAL)NINT(s.z);

          // s between 0 and 1
          s.x+=0.5;
          s.y+=0.5;
          s.z+=0.5;

          // compute the corresponding cell-id
          icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
                 ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
                 ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            // loop over cells
            for(i=0;i<27;i++)
            {
              icell=CellListMap[CurrentSystem][icell0][i];

              k=Framework[CurrentSystem].CellListHead[f1][icell];

              while(k>=0)
              {
                typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
                posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

                dr.x=posA_new.x-posB.x;
                dr.y=posA_new.y-posB.y;
                dr.z=posA_new.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffVDWSquared)
                {
                  energy=PotentialValue(typeA,typeB,rr,1.0);
                  if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                  UHostVDWDelta[CurrentSystem]+=energy;
                }

                k=Framework[CurrentSystem].CellList[f1][k];
              }
            }
          }
        }
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffVDWSquared)
                {
                  energy=PotentialValue(typeA,typeB,rr,scaling_new);
                  if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                  UHostVDWDelta[CurrentSystem]+=energy;
                }
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffVDWSquared)
              {
                energy=PotentialValue(typeA,typeB,rr,scaling_new);
                if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                UHostVDWDelta[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }

  if(Old)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      nr_atoms=Components[comp].NumberOfAtoms;
      for(j=0;j<nr_atoms;j++)
      {
        typeA=Components[comp].Type[j];
        posA_old=Cations[CurrentSystem][m].Atoms[j].AnisotropicPosition;
        scaling_old=Cations[CurrentSystem][m].Atoms[j].CFVDWScalingParameter;

        if((Framework[CurrentSystem].FrameworkModel==GRID)&&(VDWGrid[typeA])&&CanUseGridOld)
          UHostVDWDelta[CurrentSystem]-=InterpolateVDWGrid(typeA,posA_old);
        else if(UseCellLists[CurrentSystem])
        {
          // convert from xyz to abc
          s.x=InverseBox[CurrentSystem].ax*posA_old.x+InverseBox[CurrentSystem].bx*posA_old.y+InverseBox[CurrentSystem].cx*posA_old.z;
          s.y=InverseBox[CurrentSystem].ay*posA_old.x+InverseBox[CurrentSystem].by*posA_old.y+InverseBox[CurrentSystem].cy*posA_old.z;
          s.z=InverseBox[CurrentSystem].az*posA_old.x+InverseBox[CurrentSystem].bz*posA_old.y+InverseBox[CurrentSystem].cz*posA_old.z;

          // apply boundary condition
          s.x-=(REAL)NINT(s.x);
          s.y-=(REAL)NINT(s.y);
          s.z-=(REAL)NINT(s.z);

          // s between 0 and 1
          s.x+=0.5;
          s.y+=0.5;
          s.z+=0.5;

          // compute the corresponding cell-id
          icell0=(int)(s.x*NumberOfCellListCells[CurrentSystem].x)+
                 ((int)(s.y*NumberOfCellListCells[CurrentSystem].y))*NumberOfCellListCells[CurrentSystem].x+
                 ((int)(s.z*NumberOfCellListCells[CurrentSystem].z))*NumberOfCellListCells[CurrentSystem].x*NumberOfCellListCells[CurrentSystem].y;

          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            // loop over cells
            for(i=0;i<27;i++)
            {
              icell=CellListMap[CurrentSystem][icell0][i];

              k=Framework[CurrentSystem].CellListHead[f1][icell];

              while(k>=0)
              {
                typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
                posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

                dr.x=posA_old.x-posB.x;
                dr.y=posA_old.y-posB.y;
                dr.z=posA_old.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
                if(rr<CutOffVDWSquared)
                  UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,1.0);

                k=Framework[CurrentSystem].CellList[f1][k];
              }
            }
          }
        }
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
                if(rr<CutOffVDWSquared)
                  UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,scaling_old);
              }
              
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              typeB=Framework[CurrentSystem].Atoms[f1][k].Type;
              posB=Framework[CurrentSystem].Atoms[f1][k].AnisotropicPosition;

              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
              if(rr<CutOffVDWSquared)
                UHostVDWDelta[CurrentSystem]-=PotentialValue(typeA,typeB,rr,scaling_old);
              
            }
          }
        }
      }
    }
  }

  return 0;
}

/*********************************************************************************************************
 * Name       | CalculateFrameworkAdsorbateChargeChargeEnergyDifference                                  *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single adsorbate molecule:          *
 *            | 1) New=TRUE, Old=FAlse, computes the charge-charge energy of the new molecule (positions *
 *            |    in 'TrialPosition' and the molecule is of type 'comp'                                 *
 *            | 2) New=FALSE, Old=TRUE, computes the charge-charge energy of molecule 'm' of type 'comp' *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in charge-charge energy of the molecule   *
 *            |    'm' with the new positions in 'TrialPosition' and the old positions                   *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the charge-charge energy of the new positions stored in   *
 *            |      'TrialPosition'                                                                     *
 *            | False: whether or not to compute the charge-charge energy of the old positions of        *
 *            |        molecule 'm'                                                                      *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveAdsorbate(void)                                                       *
 *            | int RandomTranslationMoveAdsorbate(void)                                                 *
 *            | int RotationMoveAdsorbate(void)                                                          *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkAdsorbateChargeChargeEnergyDifference(int m,int comp,int New,int Old,int CanUseGridNew, int CanUseGridOld)
{
  int j,k,f1,typeA;
  POINT posA_new,posA_old,posB;
  REAL rr,chargeB,energy;
  REAL chargeA_old,chargeA_new;
  VECTOR dr;
  int ncell;

  // Framework-Adsorbate energy
  UHostChargeChargeRealDelta[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  if(New)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        posA_new=TrialPosition[CurrentSystem][j];
        typeA=Components[comp].Type[j];
        chargeA_new=CFChargeScaling[j]*PseudoAtoms[typeA].Charge1;

        if((ChargeMethod!=NONE)&&(Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&CanUseGridNew)
          UHostChargeChargeRealDelta[CurrentSystem]+=InterpolateCoulombGrid(typeA,posA_new);
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeChargeSquared[CurrentSystem])
                {
                  energy=PotentialValueCoulombic(chargeA_new,chargeB,sqrt(rr));
                  if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                  UHostChargeChargeRealDelta[CurrentSystem]+=energy;
                }
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
              {
                energy=PotentialValueCoulombic(chargeA_new,chargeB,sqrt(rr));
                if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
                UHostChargeChargeRealDelta[CurrentSystem]+=energy;
              }
            }
          }
        }
      }
    }
  }

  if(Old)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        posA_old=Adsorbates[CurrentSystem][m].Atoms[j].Position;
        typeA=Adsorbates[CurrentSystem][m].Atoms[j].Type;
        chargeA_old=Adsorbates[CurrentSystem][m].Atoms[j].CFChargeScalingParameter*Adsorbates[CurrentSystem][m].Atoms[j].Charge;
        
        if((ChargeMethod!=NONE)&&(Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&CanUseGridOld)
          UHostChargeChargeRealDelta[CurrentSystem]-=InterpolateCoulombGrid(typeA,posA_old);
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeChargeSquared[CurrentSystem])
                  UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA_old,chargeB,sqrt(rr));
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
                UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA_old,chargeB,sqrt(rr));
            }
          }
        }
      }
    }
  }

  return 0;
}

/*********************************************************************************************************
 * Name       | CalculateFrameworkCationChargeChargeEnergyDifference                                     *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single cation molecule:             *
 *            | 1) New=TRUE, Old=FAlse, computes the charge-charge energy of the new molecule (positions *
 *            |    in 'TrialPosition' and the molecule is of type 'comp'                                 *
 *            | 2) New=FALSE, Old=TRUE, computes the charge-charge energy of molecule 'm' of type 'comp' *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in charge-charge energy of the molecule   *
 *            |    'm' with the new positions in 'TrialPosition' and the old positions                   *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the charge-charge energy of the new positions stored in   *
 *            |      'TrialPosition'                                                                     *
 *            | False: whether or not to compute the charge-charge energy of the old positions of        *
 *            |        molecule 'm'                                                                      *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveAdsorbate(void)                                                       *
 *            | int RandomTranslationMoveAdsorbate(void)                                                 *
 *            | int RotationMoveAdsorbate(void)                                                          *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkCationChargeChargeEnergyDifference(int m,int comp,int New,int Old,int CanUseGridNew, int CanUseGridOld)
{
  int j,k,f1,typeA;
  POINT posA_new,posA_old,posB;
  REAL rr,chargeB;
  REAL chargeA_old,chargeA_new;
  VECTOR dr;
  int ncell;

  // Framework-Cation energy
  UHostChargeChargeRealDelta[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  if(New)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        posA_new=TrialPosition[CurrentSystem][j];
        typeA=Components[comp].Type[j];
        chargeA_new=CFChargeScaling[j]*PseudoAtoms[typeA].Charge1;;
        
        if((ChargeMethod!=NONE)&&(Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&CanUseGridNew)
          UHostChargeChargeRealDelta[CurrentSystem]+=InterpolateCoulombGrid(typeA,posA_new);
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeChargeSquared[CurrentSystem])
                  UHostChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA_new,chargeB,sqrt(rr));
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
                UHostChargeChargeRealDelta[CurrentSystem]+=PotentialValueCoulombic(chargeA_new,chargeB,sqrt(rr));
            }
          }
        }
      }
    }
  }

  if(Old)
  {
    if(Framework[CurrentSystem].FrameworkModel!=NONE)
    {
      // grid interpolation; transfer to the correct coordinates
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        posA_old=Cations[CurrentSystem][m].Atoms[j].Position;
        typeA=Cations[CurrentSystem][m].Atoms[j].Type;
        chargeA_old=Cations[CurrentSystem][m].Atoms[j].CFChargeScalingParameter*Cations[CurrentSystem][m].Atoms[j].Charge;
        
        if((ChargeMethod!=NONE)&&(Framework[CurrentSystem].FrameworkModel==GRID)&&(CoulombGrid)&&CanUseGridOld)
          UHostChargeChargeRealDelta[CurrentSystem]-=InterpolateCoulombGrid(typeA,posA_old);
        else if(UseReplicas[CurrentSystem])
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeChargeSquared[CurrentSystem])
                  UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA_old,chargeB,sqrt(rr));
              }
            }
          }
        }
        else
        {
          for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
          {
            for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeChargeSquared[CurrentSystem])
                UHostChargeChargeRealDelta[CurrentSystem]-=PotentialValueCoulombic(chargeA_old,chargeB,sqrt(rr));
              
            }
          }
        }
      }
    }
  }

  return 0;
}


/*********************************************************************************************************
 * Name       | CalculateFrameworkAdsorbateChargeBondDipoleEnergyDifference                              *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single adsorbate molecule:          *
 *            | 1) New=TRUE, Old=FAlse, computes the charge-bonddipole energy of the new molecule        *
 *            |    (positions in 'TrialPosition' and the molecule is of type 'comp'                      *
 *            | 2) New=FALSE, Old=TRUE, computes the charge-bonddipole energy of molecule 'm' of type    *
 *            |    'comp'                                                                                *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in charge-bonddipole energy of the        *
 *            |    molecule 'm' with the new positions in 'TrialPosition' and the old positions          *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the charge-bonddipole energy of the new positions stored  *
 *            |      in 'TrialPosition'                                                                  *
 *            | False: whether or not to compute the charge-bonddipole energy of the old positions of    *
 *            |        molecule 'm'                                                                      *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveAdsorbate(void)                                                       *
 *            | int RandomTranslationMoveAdsorbate(void)                                                 *
 *            | int RotationMoveAdsorbate(void)                                                          *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkAdsorbateChargeBondDipoleEnergyDifference(int m,int comp,int New,int Old)
{
  int j,k,f1;
  int A1,A2,B1,B2;
  int Type;
  VECTOR posA_new,posA_old,posB,posA1,posA2,posB1,posB2,dr;
  REAL rr,ri2,rk2,temp,length,chargeB,chargeA_new,chargeA_old;
  VECTOR dipoleA_new,dipoleA_old,dipoleB;
  REAL scalingA1,scalingA2;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;
  int ncell;

  UHostChargeBondDipoleRealDelta[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if(UseReplicas[CurrentSystem])
    {
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        if(New)
        {
          posA_new=TrialPosition[CurrentSystem][j];
          chargeA_new=CFChargeScaling[j]*PseudoAtoms[Components[comp].Type[j]].Charge1;
        }

        if(Old)
        {
          chargeA_old=Adsorbates[CurrentSystem][m].Atoms[j].CFChargeScalingParameter*Adsorbates[CurrentSystem][m].Atoms[j].Charge;
          posA_old=Adsorbates[CurrentSystem][m].Atoms[j].Position;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            if(New)
            {
              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);;
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA_new,dipoleB,dr,sqrt(rr));
              }
            }

            if(Old)
            {
              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA_old,dipoleB,dr,sqrt(rr));
              }
            }
          }
        }
      }

      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1*scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Adsorbates[CurrentSystem][m].Atoms[A1].Position;
          posA2=Adsorbates[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Adsorbates[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Adsorbates[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            Type=Framework[CurrentSystem].Atoms[f1][k].Type;

            if(PseudoAtoms[Type].HasCharges)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              if(New)
              {
                for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
                {
                  dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                  dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                  dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
                  dr=ApplyReplicaBoundaryCondition(dr);
                  rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                  if(rr<CutOffChargeBondDipoleSquared)
                    UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));
                }
              }

              if(Old)
              {
                for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
                {
                  dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                  dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                  dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                  dr=ApplyReplicaBoundaryCondition(dr);
                  rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                  if(rr<CutOffChargeBondDipoleSquared)
                    UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_old,dr,sqrt(rr));
                }
              }
            }
          }
        }
      }
    }
    else
    {
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        if(New)
        {
          posA_new=TrialPosition[CurrentSystem][j];
          chargeA_new=CFChargeScaling[j]*PseudoAtoms[Components[comp].Type[j]].Charge1;
        }

        if(Old)
        {
          chargeA_old=Adsorbates[CurrentSystem][m].Atoms[j].CFChargeScalingParameter*Adsorbates[CurrentSystem][m].Atoms[j].Charge;
          posA_old=Adsorbates[CurrentSystem][m].Atoms[j].Position;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            if(New)
            {
              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeBondDipoleSquared)
                UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA_new,dipoleB,dr,sqrt(rr));
            }

            if(Old)
            {
              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeBondDipoleSquared)
                UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA_old,dipoleB,dr,sqrt(rr));
            }
          }
        }
      }

      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Adsorbates[CurrentSystem][m].Atoms[A1].Position;
          posA2=Adsorbates[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Adsorbates[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Adsorbates[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            Type=Framework[CurrentSystem].Atoms[f1][k].Type;

            if(PseudoAtoms[Type].HasCharges)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              if(New)
              {
                dr.x=posA_new.x-posB.x;
                dr.y=posA_new.y-posB.y;
                dr.z=posA_new.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));
              }

              if(Old)
              {
                dr.x=posA_old.x-posB.x;
                dr.y=posA_old.y-posB.y;
                dr.z=posA_old.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));
              }
            }
          }
        }
      }
    }
  }
  return 0;
}


/*********************************************************************************************************
 * Name       | CalculateFrameworkCationChargeBondDipoleEnergyDifference                                 *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single cation molecule:             *
 *            | 1) New=TRUE, Old=FAlse, computes the charge-bonddipole energy of the new molecule        *
 *            |    (positions in 'TrialPosition' and the molecule is of type 'comp'                      *
 *            | 2) New=FALSE, Old=TRUE, computes the charge-bonddipole energy of molecule 'm' of type    *
 *            |    'comp'                                                                                *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in charge-bonddipole energy of the        *
 *            |    molecule 'm' with the new positions in 'TrialPosition' and the old positions          *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the charge-bonddipole energy of the new positions stored  *
 *            |      in 'TrialPosition'                                                                  *
 *            | False: whether or not to compute the charge-bonddipole energy of the old positions of    *
 *            |        molecule 'm'                                                                      *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveCation(void)                                                          *
 *            | int RandomTranslationMoveCation(void)                                                    *
 *            | int RotationMoveCation(void)                                                             *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkCationChargeBondDipoleEnergyDifference(int m,int comp,int New,int Old)
{
  int j,k,f1;
  int A1,A2,B1,B2;
  int Type;
  VECTOR posA_new,posA_old,posB,posA1,posA2,posB1,posB2,dr;
  REAL rr,ri2,rk2,temp,length,chargeB,chargeA_new,chargeA_old;
  VECTOR dipoleA_new,dipoleA_old,dipoleB;
  REAL scalingA1,scalingA2;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;
  int ncell;

  UHostChargeBondDipoleRealDelta[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if(UseReplicas[CurrentSystem])
    {
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        if(New)
        {
          posA_new=TrialPosition[CurrentSystem][j];
          chargeA_new=CFChargeScaling[j]*PseudoAtoms[Components[comp].Type[j]].Charge1;
        }

        if(Old)
        {
          chargeA_old=Cations[CurrentSystem][m].Atoms[j].CFChargeScalingParameter*Cations[CurrentSystem][m].Atoms[j].Charge;
          posA_old=Cations[CurrentSystem][m].Atoms[j].Position;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            if(New)
            {
              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);;
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA_new,dipoleB,dr,sqrt(rr));
              }
            }

            if(Old)
            {
              for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
              {
                dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                dr=ApplyReplicaBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA_old,dipoleB,dr,sqrt(rr));
              }
            }
          }
        }
      }

      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1*scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Cations[CurrentSystem][m].Atoms[A1].Position;
          posA2=Cations[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Cations[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Cations[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            Type=Framework[CurrentSystem].Atoms[f1][k].Type;

            if(PseudoAtoms[Type].HasCharges)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              if(New)
              {
                for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
                {
                  dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
                  dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
                  dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
                  dr=ApplyReplicaBoundaryCondition(dr);
                  rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                  if(rr<CutOffChargeBondDipoleSquared)
                    UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));
                }
              }

              if(Old)
              {
                for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
                {
                  dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
                  dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
                  dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
                  dr=ApplyReplicaBoundaryCondition(dr);
                  rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                  if(rr<CutOffChargeBondDipoleSquared)
                    UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_old,dr,sqrt(rr));
                }
              }
            }
          }
        }
      }
    }
    else
    {
      for(j=0;j<Components[comp].NumberOfAtoms;j++)
      {
        if(New)
        {
          posA_new=TrialPosition[CurrentSystem][j];
          chargeA_new=CFChargeScaling[j]*PseudoAtoms[Components[comp].Type[j]].Charge1;
        }

        if(Old)
        {
          chargeA_old=Cations[CurrentSystem][m].Atoms[j].CFChargeScalingParameter*Cations[CurrentSystem][m].Atoms[j].Charge;
          posA_old=Cations[CurrentSystem][m].Atoms[j].Position;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            if(New)
            {
              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeBondDipoleSquared)
                UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeA_new,dipoleB,dr,sqrt(rr));
            }

            if(Old)
            {
              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffChargeBondDipoleSquared)
                UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeA_old,dipoleB,dr,sqrt(rr));
            }
          }
        }
      }

      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Cations[CurrentSystem][m].Atoms[A1].Position;
          posA2=Cations[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Cations[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Cations[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfAtoms[f1];k++)
          {
            Type=Framework[CurrentSystem].Atoms[f1][k].Type;

            if(PseudoAtoms[Type].HasCharges)
            {
              posB=Framework[CurrentSystem].Atoms[f1][k].Position;
              chargeB=Framework[CurrentSystem].Atoms[f1][k].Charge;

              if(New)
              {
                dr.x=posA_new.x-posB.x;
                dr.y=posA_new.y-posB.y;
                dr.z=posA_new.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]-=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));
              }

              if(Old)
              {
                dr.x=posA_old.x-posB.x;
                dr.y=posA_old.y-posB.y;
                dr.z=posA_old.z-posB.z;
                dr=ApplyBoundaryCondition(dr);
                rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

                if(rr<CutOffChargeBondDipoleSquared)
                  UHostChargeBondDipoleRealDelta[CurrentSystem]+=PotentialValueChargeBondDipole(chargeB,dipoleA_new,dr,sqrt(rr));
              }
            }
          }
        }
      }
    }
  }
  return 0;
}


/*********************************************************************************************************
 * Name       | CalculateFrameworkAdsorbateBondDipoleBondDipoleEnergyDifference                          *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single adsorbate molecule:          *
 *            | 1) New=TRUE, Old=FAlse, computes the bonddipole-bonddipole energy of the new molecule    *
 *            |    (positions in 'TrialPosition' and the molecule is of type 'comp'                      *
 *            | 2) New=FALSE, Old=TRUE, computes the bonddipole-bonddipole energy of molecule 'm' of     *
 *            |    type 'comp'                                                                           *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in bonddipole-bonddipole energy of the    *
 *            |    molecule 'm' with the new positions in 'TrialPosition' and the old positions          *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the bonddipole-bonddipole energy of the new positions     *
 *            |      stored in 'TrialPosition'                                                           *
 *            | False: whether or not to compute the bonddipole-bonddipole energy of the old positions   *
 *            |        of molecule 'm'                                                                   *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveAdsorbate(void)                                                       *
 *            | int RandomTranslationMoveAdsorbate(void)                                                 *
 *            | int RotationMoveAdsorbate(void)                                                          *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkAdsorbateBondDipoleBondDipoleEnergyDifference(int m,int comp,int New,int Old)
{
  int j,k,f1;
  int A1,A2,B1,B2;
  VECTOR posA_new,posA_old,posB,posA1,posA2,posB1,posB2,dr;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;
  REAL ri2,rk2,rr,length,temp;
  REAL scalingA1,scalingA2;
  VECTOR dipoleA_new,dipoleA_old,dipoleB;
  int ncell;

  OVERLAP=FALSE;
  UHostBondDipoleBondDipoleRealDelta[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if(UseReplicas[CurrentSystem])
    {
      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Adsorbates[CurrentSystem][m].Atoms[A1].Position;
          posA2=Adsorbates[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Adsorbates[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Adsorbates[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
            {
              dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));

              dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
            }
          }
        }
      }
    }
    else
    {
      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Adsorbates[CurrentSystem][m].Atoms[A1].Position;
          posA2=Adsorbates[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Adsorbates[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Adsorbates[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            if(New)
            {
              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));
            }

            if(Old)
            {
              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
            }
          }
        }
      }
    }
  }
  return 0;
}


/*********************************************************************************************************
 * Name       | CalculateFrameworkCationBondDipoleBondDipoleEnergyDifference                             *
 * ----------------------------------------------------------------------------------------------------- *
 * Function   | Computes framework-molecule energy differences for a single cation molecule:             *
 *            | 1) New=TRUE, Old=FAlse, computes the bonddipole-bonddipole energy of the new molecule    *
 *            |    (positions in 'TrialPosition' and the molecule is of type 'comp'                      *
 *            | 2) New=FALSE, Old=TRUE, computes the bonddipole-bonddipole energy of molecule 'm' of     *
 *            |    type 'comp'                                                                           *
 *            | 3) New=TRUE, Old=TRUE, computes the difference in bonddipole-bonddipole energy of the    *
 *            |    molecule 'm' with the new positions in 'TrialPosition' and the old positions          *
 * Parameters | m: the molecule-id                                                                       *
 *            | comp: the component-type                                                                 *
 *            | New: whether or not to compute the bonddipole-bonddipole energy of the new positions     *
 *            |      stored in 'TrialPosition'                                                           *
 *            | False: whether or not to compute the bonddipole-bonddipole energy of the old positions   *
 *            |        of molecule 'm'                                                                   *
 * Note       |                                                                                          *
 * Used       | int TranslationMoveAdsorbate(void)                                                       *
 *            | int RandomTranslationMoveAdsorbate(void)                                                 *
 *            | int RotationMoveAdsorbate(void)                                                          *
 *            | int CFSwapLambaMove(void)                                                                *
 *            | int CBCFSwapLambaMove(void)                                                              *
 *********************************************************************************************************/

int CalculateFrameworkCationBondDipoleBondDipoleEnergyDifference(int m,int comp,int New,int Old)
{
  int j,k,f1;
  int A1,A2,B1,B2;
  VECTOR posA_new,posA_old,posB,posA1,posA2,posB1,posB2,dr;
  REAL DipoleMagnitudeA,DipoleMagnitudeB;
  REAL ri2,rk2,rr,length,temp;
  REAL scalingA1,scalingA2;
  VECTOR dipoleA_new,dipoleA_old,dipoleB;
  int ncell;

  OVERLAP=FALSE;
  UHostBondDipoleBondDipoleRealDelta[CurrentSystem]=0.0;

  if(ChargeMethod==NONE) return 0;

  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if(UseReplicas[CurrentSystem])
    {
      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Cations[CurrentSystem][m].Atoms[A1].Position;
          posA2=Cations[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Cations[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Cations[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            for(ncell=0;ncell<TotalNumberOfReplicaCells[CurrentSystem];ncell++)
            {
              dr.x=posA_new.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA_new.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA_new.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));

              dr.x=posA_old.x-(posB.x+ReplicaShift[ncell].x);
              dr.y=posA_old.y-(posB.y+ReplicaShift[ncell].y);
              dr.z=posA_old.z-(posB.z+ReplicaShift[ncell].z);
              dr=ApplyReplicaBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
            }
          }
        }
      }
    }
    else
    {
      for(j=0;j<Components[comp].NumberOfBondDipoles;j++)
      {
        A1=Components[comp].BondDipoles[j].A;
        A2=Components[comp].BondDipoles[j].B;
        DipoleMagnitudeA=Components[comp].BondDipoleMagnitude[j];

        if(New)
        {
          posA1=TrialPosition[CurrentSystem][A1];
          posA2=TrialPosition[CurrentSystem][A2];
          scalingA1=CFChargeScaling[A1];
          scalingA2=CFChargeScaling[A2];
          dipoleA_new.x=posA2.x-posA1.x;
          dipoleA_new.y=posA2.y-posA1.y;
          dipoleA_new.z=posA2.z-posA1.z;
          posA_new.x=posA1.x+0.5*dipoleA_new.x;
          posA_new.y=posA1.y+0.5*dipoleA_new.y;
          posA_new.z=posA1.z+0.5*dipoleA_new.z;
          ri2=SQR(dipoleA_new.x)+SQR(dipoleA_new.y)+SQR(dipoleA_new.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_new.x*=temp; dipoleA_new.y*=temp; dipoleA_new.z*=temp;
        }

        if(Old)
        {
          posA1=Cations[CurrentSystem][m].Atoms[A1].Position;
          posA2=Cations[CurrentSystem][m].Atoms[A2].Position;
          scalingA1=Cations[CurrentSystem][m].Atoms[A1].CFChargeScalingParameter;
          scalingA2=Cations[CurrentSystem][m].Atoms[A2].CFChargeScalingParameter;
          dipoleA_old.x=posA2.x-posA1.x;
          dipoleA_old.y=posA2.y-posA1.y;
          dipoleA_old.z=posA2.z-posA1.z;
          posA_old.x=posA1.x+0.5*dipoleA_old.x;
          posA_old.y=posA1.y+0.5*dipoleA_old.y;
          posA_old.z=posA1.z+0.5*dipoleA_old.z;
          ri2=SQR(dipoleA_old.x)+SQR(dipoleA_old.y)+SQR(dipoleA_old.z);
          length=sqrt(ri2);
          temp=0.5*(scalingA1+scalingA2)*DipoleMagnitudeA/length;
          dipoleA_old.x*=temp; dipoleA_old.y*=temp; dipoleA_old.z*=temp;
        }

        for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
        {
          for(k=0;k<Framework[CurrentSystem].NumberOfBondDipoles[f1];k++)
          {
            DipoleMagnitudeB=Framework[CurrentSystem].BondDipoleMagnitude[f1][k];
            B1=Framework[CurrentSystem].BondDipoles[f1][k].A;
            B2=Framework[CurrentSystem].BondDipoles[f1][k].B;
            posB1=Framework[CurrentSystem].Atoms[f1][B1].Position;
            posB2=Framework[CurrentSystem].Atoms[f1][B2].Position;

            dipoleB.x=posB2.x-posB1.x;
            dipoleB.y=posB2.y-posB1.y;
            dipoleB.z=posB2.z-posB1.z;
            dipoleB=ApplyBoundaryCondition(dipoleB);
            posB.x=posB1.x+0.5*dipoleB.x;
            posB.y=posB1.y+0.5*dipoleB.y;
            posB.z=posB1.z+0.5*dipoleB.z;
            rk2=SQR(dipoleB.x)+SQR(dipoleB.y)+SQR(dipoleB.z);
            length=sqrt(rk2);
            temp=DipoleMagnitudeB/length;
            dipoleB.x*=temp; dipoleB.y*=temp; dipoleB.z*=temp;

            if(New)
            {
              dr.x=posA_new.x-posB.x;
              dr.y=posA_new.y-posB.y;
              dr.z=posA_new.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]+=PotentialValueBondDipoleBondDipole(dipoleA_new,dipoleB,dr,sqrt(rr));
            }

            if(Old)
            {
              dr.x=posA_old.x-posB.x;
              dr.y=posA_old.y-posB.y;
              dr.z=posA_old.z-posB.z;
              dr=ApplyBoundaryCondition(dr);
              rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

              if(rr<CutOffBondDipoleBondDipoleSquared)
                UHostBondDipoleBondDipoleRealDelta[CurrentSystem]-=PotentialValueBondDipoleBondDipole(dipoleA_old,dipoleB,dr,sqrt(rr));
            }
          }
        }
      }
    }
  }
  return 0;
}


int CalculateFrameworkAdsorbateVDWEnergyDifferenceRXCM(int reaction,REAL Lambda1,REAL Lambda2,REAL LambdaNew,int **LambdaRetraceMolecules,int direction)
{
  int i,j,k,l,m,f1;
  int typeA,typeB;
  REAL rr,energy,scalingA_new,scalingA_old;
  VECTOR posA,posB,dr;
  int TypeMolA;
  int NumberOfRXMCMolecules;
  int RXMCMoleculeNumbers[256];
  int RXMCMoleculeType[256];

  OVERLAP=FALSE;
  UHostVDWDelta[CurrentSystem]=0.0;

  NumberOfRXMCMolecules=0;
  for(j=0;j<NumberOfComponents;j++)
  {
    for(k=0;k<ReactantsStoichiometry[reaction][j];k++)
    {
      RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ReactantFractionalMolecules[CurrentSystem][reaction][k];
      RXMCMoleculeType[NumberOfRXMCMolecules]=j;

      for(l=0;l<Components[j].NumberOfAtoms;l++)
        CFVDWScalingRXMC[NumberOfRXMCMolecules][l]=Lambda1;

      NumberOfRXMCMolecules++;
    }
  }
  for(j=0;j<NumberOfComponents;j++)
  {
    for(k=0;k<ProductsStoichiometry[reaction][j];k++)
    {
      RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ProductFractionalMolecules[CurrentSystem][reaction][k];
      RXMCMoleculeType[NumberOfRXMCMolecules]=j;

      for(l=0;l<Components[j].NumberOfAtoms;l++)
        CFVDWScalingRXMC[NumberOfRXMCMolecules][l]=Lambda2;
      NumberOfRXMCMolecules++;
    }
  }

  // add retrace molecules to list
  switch(direction)
  {
    case FORWARD:
      for(i=0;i<NumberOfComponents;i++)
      {
        for(k=0;k<ReactantsStoichiometry[reaction][i];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=LambdaRetraceMolecules[i][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=Adsorbates[CurrentSystem][LambdaRetraceMolecules[i][k]].Type;

          for(l=0;l<Components[i].NumberOfAtoms;l++)
            CFVDWScalingRXMC[NumberOfRXMCMolecules][l]=1.0-LambdaNew;
          NumberOfRXMCMolecules++;
        }
      }
      break;
    case BACKWARD:
      for(i=0;i<NumberOfComponents;i++)
      {
        for(k=0;k<ProductsStoichiometry[reaction][i];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=LambdaRetraceMolecules[i][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=Adsorbates[CurrentSystem][LambdaRetraceMolecules[i][k]].Type;

          for(l=0;l<Components[i].NumberOfAtoms;l++)
            CFVDWScalingRXMC[NumberOfRXMCMolecules][l]=1.0-LambdaNew;
          NumberOfRXMCMolecules++;
        }
      }
      break;
    case NO_FORWARD_OR_BACKWARD:
    default:
      break;
  }

  for(m=0;m<NumberOfRXMCMolecules;m++)
  {
    TypeMolA=RXMCMoleculeType[m];
    for(k=0;k<Components[TypeMolA].NumberOfAtoms;k++)
    {
      typeA=Components[TypeMolA].Type[k];

      posA=Adsorbates[CurrentSystem][RXMCMoleculeNumbers[m]].Atoms[k].AnisotropicPosition;
      scalingA_new=CFVDWScalingRXMC[m][k];
      scalingA_old=Adsorbates[CurrentSystem][RXMCMoleculeNumbers[m]].Atoms[k].CFVDWScalingParameter;

      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(l=0;l<Framework[CurrentSystem].NumberOfAtoms[f1];l++)
        {
          typeB=Framework[CurrentSystem].Atoms[f1][l].Type;
          posB=Framework[CurrentSystem].Atoms[f1][l].AnisotropicPosition;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
          {
            energy=PotentialValue(typeA,typeB,rr,scalingA_new);
            if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
            UHostVDWDelta[CurrentSystem]+=energy;

            energy=PotentialValue(typeA,typeB,rr,scalingA_old);
            if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
            UHostVDWDelta[CurrentSystem]-=energy;
          }
        }
      }
    }
  }
  return FALSE;
}

int CalculateFrameworkAdsorbateVDWEnergyDifferenceNewRXCM(int reaction,REAL LambdaNew,int direction)
{
  int i,j,k,l,f1;
  int typeA,typeB;
  int TypeMolA;
  REAL rr,energy;
  VECTOR posA,posB,dr;
  REAL scalingA_new;
  int NumberOfRXMCMolecules;
  int RXMCMoleculeNumbers[256];
  int RXMCMoleculeType[256];


  OVERLAP=FALSE;
  UHostVDWDelta[CurrentSystem]=0.0;

  NumberOfRXMCMolecules=0;
  switch(direction)
  {
    case FORWARD:
      for(j=0;j<NumberOfComponents;j++)
      {
        for(k=0;k<ProductsStoichiometry[reaction][j];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ProductFractionalMolecules[CurrentSystem][reaction][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=j;

          for(l=0;l<Components[j].NumberOfAtoms;l++)
            CFVDWScalingRXMC[NumberOfRXMCMolecules][l]=LambdaNew;
          NumberOfRXMCMolecules++;
        }
      }
      break;
    case BACKWARD:
      for(j=0;j<NumberOfComponents;j++)
      {
        for(k=0;k<ReactantsStoichiometry[reaction][j];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ReactantFractionalMolecules[CurrentSystem][reaction][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=j;

          for(l=0;l<Components[j].NumberOfAtoms;l++)
            CFVDWScalingRXMC[NumberOfRXMCMolecules][l]=LambdaNew;
          NumberOfRXMCMolecules++;
        }
      }
      break;
    default:
      break;
  }

  for(i=0;i<NumberOfRXMCMolecules;i++)
  {
    TypeMolA=RXMCMoleculeType[i];
    for(k=0;k<Components[TypeMolA].NumberOfAtoms;k++)
    {
      typeA=Components[TypeMolA].Type[k];
      posA=RXMCTrialAnisotropicPositions[CurrentSystem][i][k];
      scalingA_new=CFVDWScalingRXMC[i][k];

      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(l=0;l<Framework[CurrentSystem].NumberOfAtoms[f1];l++)
        {
          typeB=Framework[CurrentSystem].Atoms[f1][l].Type;
          posB=Framework[CurrentSystem].Atoms[f1][l].AnisotropicPosition;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
          {
            energy=PotentialValue(typeA,typeB,rr,scalingA_new);
            if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
            UHostVDWDelta[CurrentSystem]+=energy;
          }
        }
      }
    }
  }
  return FALSE;
}

int CalculateFrameworkAdsorbateChargeChargeEnergyDifferenceRXCM(int reaction,REAL Lambda1,REAL Lambda2,REAL LambdaNew,int **LambdaRetraceMolecules,int direction)
{
  int i,j,k,l,m,f1;
  REAL rr,energy,scalingA_new,scalingA_old;
  VECTOR posA,posB,dr;
  int TypeMolA;
  int NumberOfRXMCMolecules;
  int RXMCMoleculeNumbers[256];
  int RXMCMoleculeType[256];
  REAL chargeA,chargeB,chargeA_new,chargeA_old;

  OVERLAP=FALSE;
  UHostChargeChargeRealDelta[CurrentSystem]=0.0;

  NumberOfRXMCMolecules=0;
  for(j=0;j<NumberOfComponents;j++)
  {
    for(k=0;k<ReactantsStoichiometry[reaction][j];k++)
    {
      RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ReactantFractionalMolecules[CurrentSystem][reaction][k];
      RXMCMoleculeType[NumberOfRXMCMolecules]=j;

      for(l=0;l<Components[j].NumberOfAtoms;l++)
        CFChargeScalingRXMC[NumberOfRXMCMolecules][l]=pow(Lambda1,5);

      NumberOfRXMCMolecules++;
    }
  }
  for(j=0;j<NumberOfComponents;j++)
  {
    for(k=0;k<ProductsStoichiometry[reaction][j];k++)
    {
      RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ProductFractionalMolecules[CurrentSystem][reaction][k];
      RXMCMoleculeType[NumberOfRXMCMolecules]=j;

      for(l=0;l<Components[j].NumberOfAtoms;l++)
        CFChargeScalingRXMC[NumberOfRXMCMolecules][l]=pow(Lambda2,5);
      NumberOfRXMCMolecules++;
    }
  }

  // add retrace molecules to list
  switch(direction)
  {
    case FORWARD:
      for(i=0;i<NumberOfComponents;i++)
      {
        for(k=0;k<ReactantsStoichiometry[reaction][i];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=LambdaRetraceMolecules[i][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=Adsorbates[CurrentSystem][LambdaRetraceMolecules[i][k]].Type;

          for(l=0;l<Components[i].NumberOfAtoms;l++)
            CFChargeScalingRXMC[NumberOfRXMCMolecules][l]=pow(1.0-LambdaNew,5);
          NumberOfRXMCMolecules++;
        }
      }
      break;
    case BACKWARD:
      for(i=0;i<NumberOfComponents;i++)
      {
        for(k=0;k<ProductsStoichiometry[reaction][i];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=LambdaRetraceMolecules[i][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=Adsorbates[CurrentSystem][LambdaRetraceMolecules[i][k]].Type;

          for(l=0;l<Components[i].NumberOfAtoms;l++)
            CFChargeScalingRXMC[NumberOfRXMCMolecules][l]=pow(1.0-LambdaNew,5);
          NumberOfRXMCMolecules++;
        }
      }
      break;
    case NO_FORWARD_OR_BACKWARD:
    default:
      break;
  }

  for(m=0;m<NumberOfRXMCMolecules;m++)
  {
    TypeMolA=RXMCMoleculeType[m];
    for(k=0;k<Components[TypeMolA].NumberOfAtoms;k++)
    {
      chargeA=Components[TypeMolA].Charge[k];

      posA=Adsorbates[CurrentSystem][RXMCMoleculeNumbers[m]].Atoms[k].AnisotropicPosition;
      scalingA_new=CFChargeScalingRXMC[m][k];
      scalingA_old=Adsorbates[CurrentSystem][RXMCMoleculeNumbers[m]].Atoms[k].CFChargeScalingParameter;
      chargeA_new=scalingA_new*chargeA;
      chargeA_old=scalingA_old*chargeA;

      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(l=0;l<Framework[CurrentSystem].NumberOfAtoms[f1];l++)
        {
          chargeB=Framework[CurrentSystem].Atoms[f1][l].Charge;
          posB=Framework[CurrentSystem].Atoms[f1][l].AnisotropicPosition;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
          {
            energy=PotentialValueCoulombic(chargeA_new,chargeB,sqrt(rr));
            if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
            UHostChargeChargeRealDelta[CurrentSystem]+=energy;

            energy=PotentialValueCoulombic(chargeA_old,chargeB,sqrt(rr));
            if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
            UHostChargeChargeRealDelta[CurrentSystem]-=energy;
          }
        }
      }
    }
  }
  return FALSE;
}

int CalculateFrameworkAdsorbateChargeChargeEnergyDifferenceNewRXCM(int reaction,REAL LambdaNew,int direction)
{
  int i,j,k,l,f1;
  int TypeMolA;
  REAL rr,energy;
  VECTOR posA,posB,dr;
  REAL scalingA_new;
  int NumberOfRXMCMolecules;
  int RXMCMoleculeNumbers[256];
  int RXMCMoleculeType[256];
  REAL chargeA_new,chargeB;

  OVERLAP=FALSE;
  UHostChargeChargeRealDelta[CurrentSystem]=0.0;

  NumberOfRXMCMolecules=0;
  switch(direction)
  {
    case FORWARD:
      for(j=0;j<NumberOfComponents;j++)
      {
        for(k=0;k<ProductsStoichiometry[reaction][j];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ProductFractionalMolecules[CurrentSystem][reaction][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=j;

          for(l=0;l<Components[j].NumberOfAtoms;l++)
            CFChargeScalingRXMC[NumberOfRXMCMolecules][l]=pow(LambdaNew,5);
          NumberOfRXMCMolecules++;
        }
      }
      break;
    case BACKWARD:
      for(j=0;j<NumberOfComponents;j++)
      {
        for(k=0;k<ReactantsStoichiometry[reaction][j];k++)
        {
          RXMCMoleculeNumbers[NumberOfRXMCMolecules]=Components[j].ReactantFractionalMolecules[CurrentSystem][reaction][k];
          RXMCMoleculeType[NumberOfRXMCMolecules]=j;

          for(l=0;l<Components[j].NumberOfAtoms;l++)
            CFChargeScalingRXMC[NumberOfRXMCMolecules][l]=pow(LambdaNew,5);
          NumberOfRXMCMolecules++;
        }
      }
      break;
    default:
      break;
  }

  for(i=0;i<NumberOfRXMCMolecules;i++)
  {
    TypeMolA=RXMCMoleculeType[i];
    for(k=0;k<Components[TypeMolA].NumberOfAtoms;k++)
    {
      posA=RXMCTrialAnisotropicPositions[CurrentSystem][i][k];
      scalingA_new=CFChargeScalingRXMC[i][k];
      chargeA_new=scalingA_new*Components[TypeMolA].Charge[k];

      for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
      {
        for(l=0;l<Framework[CurrentSystem].NumberOfAtoms[f1];l++)
        {
          chargeB=Framework[CurrentSystem].Atoms[f1][l].Charge;
          posB=Framework[CurrentSystem].Atoms[f1][l].AnisotropicPosition;

          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);
          if(rr<CutOffVDWSquared)
          {
            energy=PotentialValueCoulombic(chargeA_new,chargeB,sqrt(rr));
            if(energy>=EnergyOverlapCriteria) return OVERLAP=TRUE;
            UHostChargeChargeRealDelta[CurrentSystem]+=energy;
          }
        }
      }
    }
  }
  return FALSE;
}


REAL CalculateFrameworkElectrostaticPotential(POINT posA)
{
  int i,typeB,f;
  REAL r,rr,chargeB;
  VECTOR posB,dr;
  REAL ElectrostaticPotential;

  ElectrostaticPotential=0.0;

  if(Framework[CurrentSystem].FrameworkModel!=NONE)
  {
    if(ChargeMethod!=NONE)
    {
      for(f=0;f<Framework[CurrentSystem].NumberOfFrameworks;f++)
      {
        for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f];i++)
        {
          typeB=Framework[CurrentSystem].Atoms[f][i].Type;
          posB=Framework[CurrentSystem].Atoms[f][i].Position;
          dr.x=posA.x-posB.x;
          dr.y=posA.y-posB.y;
          dr.z=posA.z-posB.z;
          dr=ApplyBoundaryCondition(dr);
          rr=SQR(dr.x)+SQR(dr.y)+SQR(dr.z);

          if(rr<CutOffChargeChargeSquared[CurrentSystem])
          {
            r=sqrt(rr);
            chargeB=Framework[CurrentSystem].Atoms[f][i].Charge;

            ElectrostaticPotential+=PotentialValueCoulombic(1.0,chargeB,r);
          }
        }
      }
    }
  }
  return ElectrostaticPotential;
}

REAL CalculateFrameworkVDWEnergyCorrection(VECTOR* Positions,VECTOR *AnisotropicPositions,REAL *scaling)
{
  int k;
  int typeA;
  REAL UVDWDelta;
  VECTOR posA;

  UVDWDelta=0.0;
  for(k=0;k<Components[CurrentComponent].NumberOfAtoms;k++)
  {
    typeA=Components[CurrentComponent].Type[k];

    if(PseudoAtoms[typeA].AnisotropicCorrection)
    {
      posA=AnisotropicPositions[k];
      UVDWDelta+=CalculateFrameworkVDWEnergyAtPosition(posA,typeA,scaling[k]);

      posA=Positions[k];
      UVDWDelta-=CalculateFrameworkVDWEnergyAtPosition(posA,typeA,scaling[k]);
    }
  }
  return UVDWDelta;
}