/*************************************************************************************************************
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 <string.h>
#include <math.h>
#include "constants.h"
#include "utils.h"
#include "simulation.h"
#include "molecule.h"
#include "framework.h"
#include "framework_energy.h"
#include "framework_force.h"
#include "framework_born.h"
#include "integration.h"
#include "ewald.h"
#include "internal_energy.h"
#include "internal_force.h"
#include "internal_born.h"
#include "inter_energy.h"
#include "inter_force.h"
#include "inter_born.h"
#include "thermo_baro_stats.h"
#include "rigid.h"
#include "mc_moves.h"
#include "potentials.h"
#include "sample.h"
void ComputeKineticEnergySystem(void)
{
int i,j,l,f1;
int Type,A;
REAL Mass;
VECTOR I,Velocity;
QUATERNION p,q;
INT_VECTOR3 Fixed;
UHostKinetic[CurrentSystem]=0.0;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Mass=PseudoAtoms[Framework[CurrentSystem].Atoms[f1][i].Type].Mass;
if(!Framework[CurrentSystem].Atoms[f1][i].Fixed.x)
UHostKinetic[CurrentSystem]+=0.5*Mass*SQR(Framework[CurrentSystem].Atoms[f1][i].Velocity.x);
if(!Framework[CurrentSystem].Atoms[f1][i].Fixed.y)
UHostKinetic[CurrentSystem]+=0.5*Mass*SQR(Framework[CurrentSystem].Atoms[f1][i].Velocity.y);
if(!Framework[CurrentSystem].Atoms[f1][i].Fixed.z)
UHostKinetic[CurrentSystem]+=0.5*Mass*SQR(Framework[CurrentSystem].Atoms[f1][i].Velocity.z);
}
}
}
}
UAdsorbateTranslationalKinetic[CurrentSystem]=0.0;
UAdsorbateRotationalKinetic[CurrentSystem]=0.0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
I=Components[Type].Groups[l].InverseInertiaVector;
Velocity=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity;
Mass=Components[Type].Groups[l].Mass;
Fixed=Adsorbates[CurrentSystem][i].Groups[l].FixedCenterOfMass;
if(!Fixed.x) UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Velocity.x);
if(!Fixed.y) UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Velocity.y);
if(!Fixed.z) UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Velocity.z);
Fixed=Adsorbates[CurrentSystem][i].Groups[l].FixedOrientation;
if((!Fixed.x)||(!Fixed.y)||(!Fixed.z))
{
p=Adsorbates[CurrentSystem][i].Groups[l].QuaternionMomentum;
q=Adsorbates[CurrentSystem][i].Groups[l].Quaternion;
UAdsorbateRotationalKinetic[CurrentSystem]+=SQR(-p.r*q.i+p.i*q.r+p.j*q.k-p.k*q.j)*I.x/8.0;
UAdsorbateRotationalKinetic[CurrentSystem]+=SQR(-p.r*q.j-p.i*q.k+p.j*q.r+p.k*q.i)*I.y/8.0;
UAdsorbateRotationalKinetic[CurrentSystem]+=SQR(-p.r*q.k+p.i*q.j-p.j*q.i+p.k*q.r)*I.z/8.0;
}
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Mass=PseudoAtoms[Adsorbates[CurrentSystem][i].Atoms[A].Type].Mass;
Fixed=Adsorbates[CurrentSystem][i].Atoms[A].Fixed;
if(!Fixed.x) UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x);
if(!Fixed.y) UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y);
if(!Fixed.z) UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z);
}
}
}
}
UCationTranslationalKinetic[CurrentSystem]=0.0;
UCationRotationalKinetic[CurrentSystem]=0.0;
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
Type=Cations[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
I=Components[Cations[CurrentSystem][i].Type].Groups[l].InverseInertiaVector;
Velocity=Cations[CurrentSystem][i].Groups[l].CenterOfMassVelocity;
Mass=Components[Type].Groups[l].Mass;
Fixed=Cations[CurrentSystem][i].Groups[l].FixedCenterOfMass;
if(!Fixed.x) UCationTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Velocity.x);
if(!Fixed.y) UCationTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Velocity.y);
if(!Fixed.z) UCationTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Velocity.z);
Fixed=Cations[CurrentSystem][i].Groups[l].FixedOrientation;
if((!Fixed.x)||(!Fixed.y)||(!Fixed.z))
{
p=Cations[CurrentSystem][i].Groups[l].QuaternionMomentum;
q=Cations[CurrentSystem][i].Groups[l].Quaternion;
UCationRotationalKinetic[CurrentSystem]+=SQR(-p.r*q.i+p.i*q.r+p.j*q.k-p.k*q.j)*I.x/8.0;
UCationRotationalKinetic[CurrentSystem]+=SQR(-p.r*q.j-p.i*q.k+p.j*q.r+p.k*q.i)*I.y/8.0;
UCationRotationalKinetic[CurrentSystem]+=SQR(-p.r*q.k+p.i*q.j-p.j*q.i+p.k*q.r)*I.z/8.0;
}
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Mass=PseudoAtoms[Cations[CurrentSystem][i].Atoms[A].Type].Mass;
Fixed=Cations[CurrentSystem][i].Atoms[A].Fixed;
if(!Fixed.x) UCationTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Cations[CurrentSystem][i].Atoms[A].Velocity.x);
if(!Fixed.y) UCationTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Cations[CurrentSystem][i].Atoms[A].Velocity.y);
if(!Fixed.z) UCationTranslationalKinetic[CurrentSystem]+=0.5*Mass*SQR(Cations[CurrentSystem][i].Atoms[A].Velocity.z);
}
}
}
}
UAdsorbateKinetic[CurrentSystem]=UAdsorbateTranslationalKinetic[CurrentSystem]+
UAdsorbateRotationalKinetic[CurrentSystem];
UCationKinetic[CurrentSystem]=UCationTranslationalKinetic[CurrentSystem]+
UCationRotationalKinetic[CurrentSystem];
UKinetic[CurrentSystem]=UHostKinetic[CurrentSystem]+
UAdsorbateKinetic[CurrentSystem]+UCationKinetic[CurrentSystem];
}
void InitializeForces(void)
{
int i;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
ComputeQuaternionAdsorbate(i);
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
ComputeQuaternionCation(i);
CalculateForce();
CreateCartesianVelocities();
ComputeKineticEnergySystem();
ComputeNoseHooverEnergySystem();
ConservedEnergy[CurrentSystem]=
UTotal[CurrentSystem]+
UKinetic[CurrentSystem]+
UNoseHoover[CurrentSystem];
}
void InitializeForcesAllSystems(void)
{
int i;
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
ComputeQuaternionAdsorbate(i);
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
ComputeQuaternionCation(i);
CreateCartesianVelocities();
CalculateForce();
ComputeKineticEnergySystem();
ComputeNoseHooverEnergySystem();
ConservedEnergy[CurrentSystem]=
UTotal[CurrentSystem]+
UKinetic[CurrentSystem]+
UNoseHoover[CurrentSystem];
}
CurrentSystem=0;
}
void CalculateTotalEnergyAllSystems(void)
{
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
CalculateEnergy();
CurrentSystem=0;
}
void CalculateEnergy(void)
{
// initialize energies
UAdsorbateBond[CurrentSystem]=0.0;
UAdsorbateUreyBradley[CurrentSystem]=0.0;
UAdsorbateBend[CurrentSystem]=0.0;
UAdsorbateInversionBend[CurrentSystem]=0.0;
UAdsorbateTorsion[CurrentSystem]=0.0;
UAdsorbateImproperTorsion[CurrentSystem]=0.0;
UAdsorbateBondBond[CurrentSystem]=0.0;
UAdsorbateBondBend[CurrentSystem]=0.0;
UAdsorbateBendBend[CurrentSystem]=0.0;
UAdsorbateBondTorsion[CurrentSystem]=0.0;
UAdsorbateBendTorsion[CurrentSystem]=0.0;
UAdsorbateIntraVDW[CurrentSystem]=0.0;
UAdsorbateIntraChargeCharge[CurrentSystem]=0.0;
UAdsorbateIntraChargeBondDipole[CurrentSystem]=0.0;
UAdsorbateIntraBondDipoleBondDipole[CurrentSystem]=0.0;
UCationBond[CurrentSystem]=0.0;
UCationUreyBradley[CurrentSystem]=0.0;
UCationBend[CurrentSystem]=0.0;
UCationInversionBend[CurrentSystem]=0.0;
UCationTorsion[CurrentSystem]=0.0;
UCationImproperTorsion[CurrentSystem]=0.0;
UCationBondBond[CurrentSystem]=0.0;
UCationBondBend[CurrentSystem]=0.0;
UCationBendBend[CurrentSystem]=0.0;
UCationBondTorsion[CurrentSystem]=0.0;
UCationBendTorsion[CurrentSystem]=0.0;
UCationIntraVDW[CurrentSystem]=0.0;
UCationIntraChargeCharge[CurrentSystem]=0.0;
UCationIntraChargeBondDipole[CurrentSystem]=0.0;
UCationIntraBondDipoleBondDipole[CurrentSystem]=0.0;
UHostBond[CurrentSystem]=0.0;
UHostUreyBradley[CurrentSystem]=0.0;
UHostBend[CurrentSystem]=0.0;
UHostInversionBend[CurrentSystem]=0.0;
UHostTorsion[CurrentSystem]=0.0;
UHostImproperTorsion[CurrentSystem]=0.0;
UHostBondBond[CurrentSystem]=0.0;
UHostBondBend[CurrentSystem]=0.0;
UHostBendBend[CurrentSystem]=0.0;
UHostBondTorsion[CurrentSystem]=0.0;
UHostBendTorsion[CurrentSystem]=0.0;
UHostHost[CurrentSystem]=0.0;
UAdsorbateAdsorbate[CurrentSystem]=0.0;
UCationCation[CurrentSystem]=0.0;
UHostAdsorbate[CurrentSystem]=0.0;
UHostCation[CurrentSystem]=0.0;
UAdsorbateCation[CurrentSystem]=0.0;
UHostHostVDW[CurrentSystem]=0.0;
UAdsorbateAdsorbateVDW[CurrentSystem]=0.0;
UCationCationVDW[CurrentSystem]=0.0;
UHostAdsorbateVDW[CurrentSystem]=0.0;
UHostCationVDW[CurrentSystem]=0.0;
UAdsorbateCationVDW[CurrentSystem]=0.0;
UHostHostCoulomb[CurrentSystem]=0.0;
UAdsorbateAdsorbateCoulomb[CurrentSystem]=0.0;
UCationCationCoulomb[CurrentSystem]=0.0;
UHostAdsorbateCoulomb[CurrentSystem]=0.0;
UHostCationCoulomb[CurrentSystem]=0.0;
UAdsorbateCationCoulomb[CurrentSystem]=0.0;
UHostHostChargeChargeReal[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeChargeReal[CurrentSystem]=0.0;
UCationCationChargeChargeReal[CurrentSystem]=0.0;
UHostAdsorbateChargeChargeReal[CurrentSystem]=0.0;
UHostCationChargeChargeReal[CurrentSystem]=0.0;
UAdsorbateCationChargeChargeReal[CurrentSystem]=0.0;
UHostHostChargeBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeBondDipoleReal[CurrentSystem]=0.0;
UCationCationChargeBondDipoleReal[CurrentSystem]=0.0;
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]=0.0;
UHostCationChargeBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateCationChargeBondDipoleReal[CurrentSystem]=0.0;
UHostHostBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateAdsorbateBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UCationCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UHostCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UHostHostChargeChargeFourier[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeChargeFourier[CurrentSystem]=0.0;
UCationCationChargeChargeFourier[CurrentSystem]=0.0;
UHostAdsorbateChargeChargeFourier[CurrentSystem]=0.0;
UHostCationChargeChargeFourier[CurrentSystem]=0.0;
UAdsorbateCationChargeChargeFourier[CurrentSystem]=0.0;
UHostHostChargeBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeBondDipoleFourier[CurrentSystem]=0.0;
UCationCationChargeBondDipoleFourier[CurrentSystem]=0.0;
UHostAdsorbateChargeBondDipoleFourier[CurrentSystem]=0.0;
UHostCationChargeBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateCationChargeBondDipoleFourier[CurrentSystem]=0.0;
UHostHostBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateAdsorbateBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UCationCationBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UHostAdsorbateBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UHostCationBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateCationBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UHostPolarization[CurrentSystem]=0.0;
UAdsorbatePolarization[CurrentSystem]=0.0;
UCationPolarization[CurrentSystem]=0.0;
UHostBackPolarization[CurrentSystem]=0.0;
UAdsorbateBackPolarization[CurrentSystem]=0.0;
UCationBackPolarization[CurrentSystem]=0.0;
UTailCorrection[CurrentSystem]=0.0;
UDistanceConstraints[CurrentSystem]=0.0;
UAngleConstraints[CurrentSystem]=0.0;
UDihedralConstraints[CurrentSystem]=0.0;
UInversionBendConstraints[CurrentSystem]=0.0;
UOutOfPlaneDistanceConstraints[CurrentSystem]=0.0;
UExclusionConstraints[CurrentSystem]=0.0;
UNoseHoover[CurrentSystem]=0.0;
UTotal[CurrentSystem]=0.0;
// compute the modified VDW sites for anisotropic models
CalculateAnisotropicSites();
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
UHostBond[CurrentSystem]=CalculateFrameworkBondEnergy(TRUE,0,0);
UHostUreyBradley[CurrentSystem]=CalculateFrameworkUreyBradleyEnergy(TRUE,0,0);
UHostBend[CurrentSystem]=CalculateFrameworkBendEnergy(TRUE,0,0);
UHostInversionBend[CurrentSystem]=CalculateFrameworkInversionBendEnergy(TRUE,0,0);
UHostTorsion[CurrentSystem]=CalculateFrameworkTorsionEnergy(TRUE,0,0);
UHostImproperTorsion[CurrentSystem]=CalculateFrameworkImproperTorsionEnergy(TRUE,0,0);
UHostBondBond[CurrentSystem]=CalculateFrameworkBondBondEnergy(TRUE,0,0);
UHostBondBend[CurrentSystem]=CalculateFrameworkBondBendEnergy(TRUE,0,0);
UHostBendBend[CurrentSystem]=CalculateFrameworkBendBendEnergy(TRUE,0,0);
UHostBondTorsion[CurrentSystem]=CalculateFrameworkBondTorsionEnergy(TRUE,0,0);
UHostBendTorsion[CurrentSystem]=CalculateFrameworkBendTorsionEnergy(TRUE,0,0);
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkIntraReplicaVDWEnergy();
CalculateFrameworkIntraReplicaChargeChargeEnergy();
}
else
{
CalculateFrameworkIntraVDWEnergy();
CalculateFrameworkIntraChargeChargeEnergy();
}
CalculateFrameworkIntraChargeBondDipoleEnergy();
CalculateFrameworkIntraBondDipoleBondDipoleEnergy();
}
CalculateBondEnergyAdsorbates();
CalculateUreyBradleyEnergyAdsorbates();
CalculateBendEnergyAdsorbates();
CalculateInversionBendEnergyAdsorbates();
CalculateTorsionEnergyAdsorbates();
CalculateImproperTorsionEnergyAdsorbates();
CalculateBondBondEnergyAdsorbates();
CalculateBondBendEnergyAdsorbates();
CalculateBendBendEnergyAdsorbates();
CalculateBendTorsionEnergyAdsorbates();
CalculateBondTorsionEnergyAdsorbates();
CalculateIntraVDWEnergyAdsorbates();
CalculateIntraChargeChargeEnergyAdsorbates();
CalculateIntraChargeBondDipoleEnergyAdsorbates();
CalculateIntraBondDipoleBondDipoleEnergyAdsorbates();
CalculateBondEnergyCations();
CalculateUreyBradleyEnergyCations();
CalculateBendEnergyCations();
CalculateInversionBendEnergyCations();
CalculateTorsionEnergyCations();
CalculateImproperTorsionEnergyCations();
CalculateBondBondEnergyCations();
CalculateBondBendEnergyCations();
CalculateBendBendEnergyCations();
CalculateBondTorsionEnergyCations();
CalculateBendTorsionEnergyCations();
CalculateIntraVDWEnergyCations();
CalculateIntraChargeChargeEnergyCations();
CalculateIntraChargeBondDipoleEnergyCations();
CalculateIntraBondDipoleBondDipoleEnergyCations();
// contribution of the intermolecular interactions (between adsorbates and/or cations)
CalculateTotalInterVDWEnergy();
CalculateTotalInterChargeChargeCoulombEnergy();
CalculateTotalInterChargeBondDipoleCoulombEnergy();
CalculateTotalInterBondDipoleBondDipoleCoulombEnergy();
// contribution of the interactions of the adsorbates with the framework
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkAdsorbateReplicaVDWEnergy();
CalculateFrameworkAdsorbateReplicaChargeChargeEnergy();
}
else
{
CalculateFrameworkAdsorbateVDWEnergy();
CalculateFrameworkAdsorbateChargeChargeEnergy();
}
CalculateFrameworkAdsorbateChargeBondDipoleEnergy();
CalculateFrameworkAdsorbateBondDipoleBondDipoleEnergy();
// contribution of the interactions of the cations with the framework
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkCationReplicaVDWEnergy();
CalculateFrameworkCationReplicaChargeChargeEnergy();
}
else
{
CalculateFrameworkCationVDWEnergy();
CalculateFrameworkCationChargeChargeEnergy();
}
CalculateFrameworkCationChargeBondDipoleEnergy();
CalculateFrameworkCationBondDipoleBondDipoleEnergy();
// the contribution of the charges present in the system (long-range interaction)
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
EwaldFourierEnergy();
CalculateTailCorrection();
CalculateHarmonicBondConstraintEnergy();
CalculateHarmonicAngleConstraintEnergy();
CalculateHarmonicDihedralConstraintEnergy();
CalculateConstraintsExclusionEnergy();
if(ComputePolarization)
CalculateElectricField();
UAdsorbateAdsorbateCoulomb[CurrentSystem]=
UAdsorbateAdsorbateChargeChargeReal[CurrentSystem]+UAdsorbateAdsorbateChargeChargeFourier[CurrentSystem]+
UAdsorbateAdsorbateChargeBondDipoleReal[CurrentSystem]+UAdsorbateAdsorbateChargeBondDipoleFourier[CurrentSystem]+
UAdsorbateAdsorbateBondDipoleBondDipoleReal[CurrentSystem]+UAdsorbateAdsorbateBondDipoleBondDipoleFourier[CurrentSystem];
UAdsorbateAdsorbate[CurrentSystem]=UAdsorbateAdsorbateVDW[CurrentSystem]+UAdsorbateAdsorbateCoulomb[CurrentSystem];
UCationCationCoulomb[CurrentSystem]=
UCationCationChargeChargeReal[CurrentSystem]+UCationCationChargeChargeFourier[CurrentSystem]+
UCationCationChargeBondDipoleReal[CurrentSystem]+UCationCationChargeBondDipoleFourier[CurrentSystem]+
UCationCationBondDipoleBondDipoleReal[CurrentSystem]+UCationCationBondDipoleBondDipoleFourier[CurrentSystem];
UCationCation[CurrentSystem]=UCationCationVDW[CurrentSystem]+UCationCationCoulomb[CurrentSystem];
UAdsorbateCationCoulomb[CurrentSystem]=
UAdsorbateCationChargeChargeReal[CurrentSystem]+UAdsorbateCationChargeChargeFourier[CurrentSystem]+
UAdsorbateCationChargeBondDipoleReal[CurrentSystem]+UAdsorbateCationChargeBondDipoleFourier[CurrentSystem]+
UAdsorbateCationBondDipoleBondDipoleReal[CurrentSystem]+UAdsorbateCationBondDipoleBondDipoleFourier[CurrentSystem];
UAdsorbateCation[CurrentSystem]=UAdsorbateCationVDW[CurrentSystem]+UAdsorbateCationCoulomb[CurrentSystem];
UHostAdsorbateCoulomb[CurrentSystem]=
UHostAdsorbateChargeChargeReal[CurrentSystem]+UHostAdsorbateChargeChargeFourier[CurrentSystem]+
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]+UHostAdsorbateChargeBondDipoleFourier[CurrentSystem]+
UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]+UHostAdsorbateBondDipoleBondDipoleFourier[CurrentSystem];
UHostAdsorbate[CurrentSystem]=UHostAdsorbateVDW[CurrentSystem]+UHostAdsorbateCoulomb[CurrentSystem];
UHostCationCoulomb[CurrentSystem]=
UHostCationChargeChargeReal[CurrentSystem]+UHostCationChargeChargeFourier[CurrentSystem]+
UHostCationChargeBondDipoleReal[CurrentSystem]+UHostCationChargeBondDipoleFourier[CurrentSystem]+
UHostCationBondDipoleBondDipoleReal[CurrentSystem]+UHostCationBondDipoleBondDipoleFourier[CurrentSystem];
UHostCation[CurrentSystem]=UHostCationVDW[CurrentSystem]+UHostCationCoulomb[CurrentSystem];
UHostHostCoulomb[CurrentSystem]=
UHostHostChargeChargeReal[CurrentSystem]+UHostHostChargeChargeFourier[CurrentSystem]+
UHostHostChargeBondDipoleReal[CurrentSystem]+UHostHostChargeBondDipoleFourier[CurrentSystem]+
UHostHostBondDipoleBondDipoleReal[CurrentSystem]+UHostHostBondDipoleBondDipoleFourier[CurrentSystem];
UHostHost[CurrentSystem]=UHostHostVDW[CurrentSystem]+UHostHostCoulomb[CurrentSystem];
UTotal[CurrentSystem]=
// inter
UHostHost[CurrentSystem]+UCationCation[CurrentSystem]+UAdsorbateAdsorbate[CurrentSystem]+
UHostCation[CurrentSystem]+UHostAdsorbate[CurrentSystem]+UAdsorbateCation[CurrentSystem]+
// intra framework
UHostBond[CurrentSystem]+UHostUreyBradley[CurrentSystem]+UHostBend[CurrentSystem]+
UHostInversionBend[CurrentSystem]+UHostTorsion[CurrentSystem]+UHostImproperTorsion[CurrentSystem]+
UHostBondBond[CurrentSystem]+UHostBondBend[CurrentSystem]+UHostBendBend[CurrentSystem]+
UHostBondTorsion[CurrentSystem]+UHostBendTorsion[CurrentSystem]+
// intra adsorbates
UAdsorbateBond[CurrentSystem]+UAdsorbateUreyBradley[CurrentSystem]+UAdsorbateBend[CurrentSystem]+
UAdsorbateInversionBend[CurrentSystem]+UAdsorbateTorsion[CurrentSystem]+UAdsorbateImproperTorsion[CurrentSystem]+
UAdsorbateBondBond[CurrentSystem]+UAdsorbateBondBend[CurrentSystem]+UAdsorbateBendBend[CurrentSystem]+
UAdsorbateBondTorsion[CurrentSystem]+UAdsorbateBendTorsion[CurrentSystem]+
UAdsorbateIntraVDW[CurrentSystem]+UAdsorbateIntraChargeCharge[CurrentSystem]+
UAdsorbateIntraChargeBondDipole[CurrentSystem]+UAdsorbateIntraBondDipoleBondDipole[CurrentSystem]+
// intra cations
UCationBond[CurrentSystem]+UCationUreyBradley[CurrentSystem]+UCationBend[CurrentSystem]+
UCationInversionBend[CurrentSystem]+UCationTorsion[CurrentSystem]+UCationImproperTorsion[CurrentSystem]+
UCationBondBond[CurrentSystem]+UCationBondBend[CurrentSystem]+UCationBendBend[CurrentSystem]+
UCationBondTorsion[CurrentSystem]+UCationBendTorsion[CurrentSystem]+
UCationIntraVDW[CurrentSystem]+UCationIntraChargeCharge[CurrentSystem]+
UCationIntraChargeBondDipole[CurrentSystem]+UCationIntraBondDipoleBondDipole[CurrentSystem]+
// polarization
UHostPolarization[CurrentSystem]+UAdsorbatePolarization[CurrentSystem]+UCationPolarization[CurrentSystem]+
UHostBackPolarization[CurrentSystem]+UAdsorbateBackPolarization[CurrentSystem]+UCationBackPolarization[CurrentSystem]+
// tailcorrection
UTailCorrection[CurrentSystem]+
// harmonic constraint energy
UDistanceConstraints[CurrentSystem]+UAngleConstraints[CurrentSystem]+UDihedralConstraints[CurrentSystem]+
UInversionBendConstraints[CurrentSystem]+UOutOfPlaneDistanceConstraints[CurrentSystem]+UExclusionConstraints[CurrentSystem];
}
void CalculateForce(void)
{
int i,j,f1;
VECTOR com,pos,force;
REAL temp;
int Type,A;
int k,l;
// initialize stress
StressTensor[CurrentSystem].ax=StressTensor[CurrentSystem].bx=StressTensor[CurrentSystem].cx=0.0;
StressTensor[CurrentSystem].ay=StressTensor[CurrentSystem].by=StressTensor[CurrentSystem].cy=0.0;
StressTensor[CurrentSystem].az=StressTensor[CurrentSystem].bz=StressTensor[CurrentSystem].cz=0.0;
StrainDerivativeTensor[CurrentSystem].ax=StrainDerivativeTensor[CurrentSystem].bx=StrainDerivativeTensor[CurrentSystem].cx=0.0;
StrainDerivativeTensor[CurrentSystem].ay=StrainDerivativeTensor[CurrentSystem].by=StrainDerivativeTensor[CurrentSystem].cy=0.0;
StrainDerivativeTensor[CurrentSystem].az=StrainDerivativeTensor[CurrentSystem].bz=StrainDerivativeTensor[CurrentSystem].cz=0.0;
StrainDerivativeRigidCorrection[CurrentSystem].ax=StrainDerivativeRigidCorrection[CurrentSystem].bx=StrainDerivativeRigidCorrection[CurrentSystem].cx=0.0;
StrainDerivativeRigidCorrection[CurrentSystem].ay=StrainDerivativeRigidCorrection[CurrentSystem].by=StrainDerivativeRigidCorrection[CurrentSystem].cy=0.0;
StrainDerivativeRigidCorrection[CurrentSystem].az=StrainDerivativeRigidCorrection[CurrentSystem].bz=StrainDerivativeRigidCorrection[CurrentSystem].cz=0.0;
// initialize energies
UAdsorbateBond[CurrentSystem]=0.0;
UAdsorbateUreyBradley[CurrentSystem]=0.0;
UAdsorbateBend[CurrentSystem]=0.0;
UAdsorbateInversionBend[CurrentSystem]=0.0;
UAdsorbateTorsion[CurrentSystem]=0.0;
UAdsorbateImproperTorsion[CurrentSystem]=0.0;
UAdsorbateBondBond[CurrentSystem]=0.0;
UAdsorbateBondBend[CurrentSystem]=0.0;
UAdsorbateBendBend[CurrentSystem]=0.0;
UAdsorbateBondTorsion[CurrentSystem]=0.0;
UAdsorbateBendTorsion[CurrentSystem]=0.0;
UAdsorbateIntraVDW[CurrentSystem]=0.0;
UAdsorbateIntraChargeCharge[CurrentSystem]=0.0;
UAdsorbateIntraChargeBondDipole[CurrentSystem]=0.0;
UAdsorbateIntraBondDipoleBondDipole[CurrentSystem]=0.0;
UCationBond[CurrentSystem]=0.0;
UCationUreyBradley[CurrentSystem]=0.0;
UCationBend[CurrentSystem]=0.0;
UCationInversionBend[CurrentSystem]=0.0;
UCationTorsion[CurrentSystem]=0.0;
UCationImproperTorsion[CurrentSystem]=0.0;
UCationBondBond[CurrentSystem]=0.0;
UCationBondBend[CurrentSystem]=0.0;
UCationBendBend[CurrentSystem]=0.0;
UCationBondTorsion[CurrentSystem]=0.0;
UCationBendTorsion[CurrentSystem]=0.0;
UCationIntraVDW[CurrentSystem]=0.0;
UCationIntraChargeCharge[CurrentSystem]=0.0;
UCationIntraChargeBondDipole[CurrentSystem]=0.0;
UCationIntraBondDipoleBondDipole[CurrentSystem]=0.0;
UHostBond[CurrentSystem]=0.0;
UHostUreyBradley[CurrentSystem]=0.0;
UHostBend[CurrentSystem]=0.0;
UHostInversionBend[CurrentSystem]=0.0;
UHostTorsion[CurrentSystem]=0.0;
UHostImproperTorsion[CurrentSystem]=0.0;
UHostBondBond[CurrentSystem]=0.0;
UHostBondBend[CurrentSystem]=0.0;
UHostBendBend[CurrentSystem]=0.0;
UHostBondTorsion[CurrentSystem]=0.0;
UHostBendTorsion[CurrentSystem]=0.0;
UHostHost[CurrentSystem]=0.0;
UAdsorbateAdsorbate[CurrentSystem]=0.0;
UCationCation[CurrentSystem]=0.0;
UHostAdsorbate[CurrentSystem]=0.0;
UHostCation[CurrentSystem]=0.0;
UAdsorbateCation[CurrentSystem]=0.0;
UHostHostVDW[CurrentSystem]=0.0;
UAdsorbateAdsorbateVDW[CurrentSystem]=0.0;
UCationCationVDW[CurrentSystem]=0.0;
UHostAdsorbateVDW[CurrentSystem]=0.0;
UHostCationVDW[CurrentSystem]=0.0;
UAdsorbateCationVDW[CurrentSystem]=0.0;
UHostHostCoulomb[CurrentSystem]=0.0;
UAdsorbateAdsorbateCoulomb[CurrentSystem]=0.0;
UCationCationCoulomb[CurrentSystem]=0.0;
UHostAdsorbateCoulomb[CurrentSystem]=0.0;
UHostCationCoulomb[CurrentSystem]=0.0;
UAdsorbateCationCoulomb[CurrentSystem]=0.0;
UHostHostChargeChargeReal[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeChargeReal[CurrentSystem]=0.0;
UCationCationChargeChargeReal[CurrentSystem]=0.0;
UHostAdsorbateChargeChargeReal[CurrentSystem]=0.0;
UHostCationChargeChargeReal[CurrentSystem]=0.0;
UAdsorbateCationChargeChargeReal[CurrentSystem]=0.0;
UHostHostChargeBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeBondDipoleReal[CurrentSystem]=0.0;
UCationCationChargeBondDipoleReal[CurrentSystem]=0.0;
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]=0.0;
UHostCationChargeBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateCationChargeBondDipoleReal[CurrentSystem]=0.0;
UHostHostBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateAdsorbateBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UCationCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UHostCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UAdsorbateCationBondDipoleBondDipoleReal[CurrentSystem]=0.0;
UHostHostChargeChargeFourier[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeChargeFourier[CurrentSystem]=0.0;
UCationCationChargeChargeFourier[CurrentSystem]=0.0;
UHostAdsorbateChargeChargeFourier[CurrentSystem]=0.0;
UHostCationChargeChargeFourier[CurrentSystem]=0.0;
UAdsorbateCationChargeChargeFourier[CurrentSystem]=0.0;
UHostHostChargeBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateAdsorbateChargeBondDipoleFourier[CurrentSystem]=0.0;
UCationCationChargeBondDipoleFourier[CurrentSystem]=0.0;
UHostAdsorbateChargeBondDipoleFourier[CurrentSystem]=0.0;
UHostCationChargeBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateCationChargeBondDipoleFourier[CurrentSystem]=0.0;
UHostHostBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateAdsorbateBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UCationCationBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UHostAdsorbateBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UHostCationBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UAdsorbateCationBondDipoleBondDipoleFourier[CurrentSystem]=0.0;
UHostPolarization[CurrentSystem]=0.0;
UAdsorbatePolarization[CurrentSystem]=0.0;
UCationPolarization[CurrentSystem]=0.0;
UHostBackPolarization[CurrentSystem]=0.0;
UAdsorbateBackPolarization[CurrentSystem]=0.0;
UCationBackPolarization[CurrentSystem]=0.0;
UTailCorrection[CurrentSystem]=0.0;
UDistanceConstraints[CurrentSystem]=0.0;
UAngleConstraints[CurrentSystem]=0.0;
UDihedralConstraints[CurrentSystem]=0.0;
UInversionBendConstraints[CurrentSystem]=0.0;
UOutOfPlaneDistanceConstraints[CurrentSystem]=0.0;
UExclusionConstraints[CurrentSystem]=0.0;
UNoseHoover[CurrentSystem]=0.0;
UTotal[CurrentSystem]=0.0;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Framework[CurrentSystem].Atoms[f1][i].Force.x=0.0;
Framework[CurrentSystem].Atoms[f1][i].Force.y=0.0;
Framework[CurrentSystem].Atoms[f1][i].Force.z=0.0;
}
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Adsorbates[CurrentSystem][i].Atoms[j].Force.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Cations[CurrentSystem][i].Atoms[j].Force.x=0.0;
Cations[CurrentSystem][i].Atoms[j].Force.y=0.0;
Cations[CurrentSystem][i].Atoms[j].Force.z=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
// create atomic positions from com-positions (needed to compute the atomicly defined forces)
CreateCartesianPositions();
CalculateAnisotropicSites();
// compute the current bond-dipole vectors from the positions of the individual bond atoms
ConstructBondDipolesFromBondsFramework();
if(ComputeBornTerm)
{
InitializeMatrix9x9(&BornTerm[CurrentSystem]);
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
CalculateFrameworkBondBornTerm();
CalculateFrameworkUreyBradleyBornTerm();
CalculateFrameworkBendBornTerm();
CalculateFrameworkTorsionBornTerm();
CalculateFrameworkImproperTorsionBornTerm();
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkIntraReplicaVDWBornTerm();
CalculateFrameworkIntraReplicaChargeChargeBornTerm();
}
else
{
CalculateFrameworkIntraVDWBornTerm();
CalculateFrameworkIntraChargeChargeBornTerm();
}
}
CalculateAdsorbateBondBornTerm();
CalculateAdsorbateUreyBradleyBornTerm();
CalculateAdsorbateBendBornTerm();
CalculateAdsorbateTorsionBornTerm();
CalculateAdsorbateImproperTorsionBornTerm();
CalculateAdsorbateIntraVDWBornTerm();
CalculateAdsorbateIntraCoulombBornTerm();
CalculateCationBondBornTerm();
CalculateCationUreyBradleyBornTerm();
CalculateCationBendBornTerm();
CalculateCationTorsionBornTerm();
CalculateCationImproperTorsionBornTerm();
CalculateCationIntraVDWBornTerm();
CalculateCationIntraCoulombBornTerm();
ComputeInterVDWBornTerm();
ComputeInterChargeChargeBornTerm();
if(UseReplicas[CurrentSystem])
{
FrameworkAdsorbateReplicaVDWBornTerm();
FrameworkAdsorbateReplicaChargeChargeBornTerm();
FrameworkCationReplicaVDWBornTerm();
FrameworkCationReplicaChargeChargeBornTerm();
}
else
{
FrameworkAdsorbateVDWBornTerm();
FrameworkAdsorbateChargeChargeBornTerm();
FrameworkCationVDWBornTerm();
FrameworkCationChargeChargeBornTerm();
}
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
EwaldFourierBornTerm();
FillInRemainingTermsInBornTerm();
}
else
{
// contribution of the intra molecular interactions of the framework
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
CalculateFrameworkBondForce();
CalculateFrameworkUreyBradleyForce();
CalculateFrameworkBendForce();
CalculateFrameworkInversionBendForce();
CalculateFrameworkTorsionForce();
CalculateFrameworkImproperTorsionForce();
CalculateFrameworkBondBondForce();
CalculateFrameworkBondBendForce();
CalculateFrameworkBendBendForce();
CalculateFrameworkBondTorsionForce();
CalculateFrameworkBendTorsionForce();
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkIntraReplicaVDWForce();
CalculateFrameworkIntraReplicaChargeChargeForce();
}
else
{
CalculateFrameworkIntraVDWForce();
CalculateFrameworkIntraChargeChargeForce();
}
CalculateFrameworkIntraChargeBondDipoleForce();
CalculateFrameworkIntraBondDipoleBondDipoleForce();
}
// contribution of the intra molecular interactions of the adsorbates
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
CalculateAdsorbateBondForce(i);
CalculateAdsorbateUreyBradleyForce(i);
CalculateAdsorbateBendForce(i);
CalculateAdsorbateInversionBendForce(i);
CalculateAdsorbateTorsionForce(i);
CalculateAdsorbateImproperTorsionForce(i);
CalculateAdsorbateBondBondForce(i);
CalculateAdsorbateBondBendForce(i);
CalculateAdsorbateBendBendForce(i);
CalculateAdsorbateBondTorsionForce(i);
CalculateAdsorbateBendTorsionForce(i);
CalculateAdsorbateIntraVDWForce(i);
CalculateAdsorbateIntraChargeChargeForce(i);
CalculateAdsorbateIntraChargeBondDipoleForce(i);
CalculateAdsorbateIntraBondDipoleBondDipoleForce(i);
}
// contribution of the intra molecular interactions of the cations
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
CalculateCationBondForce(i);
CalculateCationUreyBradleyForce(i);
CalculateCationBendForce(i);
CalculateCationInversionBendForce(i);
CalculateCationTorsionForce(i);
CalculateCationImproperTorsionForce(i);
CalculateCationBondBondForce(i);
CalculateCationBondBendForce(i);
CalculateCationBendBendForce(i);
CalculateCationBondTorsionForce(i);
CalculateCationBendTorsionForce(i);
CalculateCationIntraVDWForce(i);
CalculateCationIntraChargeChargeForce(i);
CalculateCationIntraChargeBondDipoleForce(i);
CalculateCationIntraBondDipoleBondDipoleForce(i);
}
// contribution of the intermolecular interactions (between adsorbates and/or cations)
if(UseReplicas[CurrentSystem])
{
CalculateTotalInterReplicaVDWForce();
CalculateTotalInterReplicaChargeChargeCoulombForce();
}
else
{
CalculateTotalInterVDWForce();
CalculateTotalInterChargeChargeCoulombForce();
}
CalculateTotalInterChargeBondDipoleCoulombForce();
CalculateTotalInterBondDipoleBondDipoleCoulombForce();
// contribution of the interactions of the adsorbates with the framework
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkAdsorbateReplicaVDWForce();
CalculateFrameworkAdsorbateReplicaChargeChargeForce();
}
else
{
CalculateFrameworkAdsorbateVDWForce();
CalculateFrameworkAdsorbateChargeChargeForce();
}
CalculateFrameworkAdsorbateChargeBondDipoleForce();
CalculateFrameworkAdsorbateBondDipoleBondDipoleForce();
// contribution of the interactions of the cations with the framework
if(UseReplicas[CurrentSystem])
{
CalculateFrameworkCationReplicaVDWForce();
CalculateFrameworkCationReplicaChargeChargeForce();
}
else
{
CalculateFrameworkCationVDWForce();
CalculateFrameworkCationChargeChargeForce();
}
CalculateFrameworkCationChargeBondDipoleForce();
CalculateFrameworkCationBondDipoleBondDipoleForce();
// the contribution of the charges present in the system (long-range interaction)
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
EwaldFourierForce();
}
if(ComputePolarization)
{
CalculateElectricField();
CalculateFrameworkAdsorbateChargeInducedDipoleForce();
CalculateFrameworkAdsorbateInducedDipoleInducedDipoleForce();
CalculateInterChargeInducedDipoleForce();
CalculateInterInducedDipoleInducedDipoleForce();
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
ComputeInducedDipolesForcesEwald();
}
CreateQuaternionAndComForces();
CalculateTailCorrection();
CalculateHarmonicBondConstraintForce();
CalculateHarmonicAngleConstraintForce();
CalculateHarmonicDihedralConstraintForce();
CalculateConstraintsExclusionForce();
UAdsorbateAdsorbateCoulomb[CurrentSystem]=
UAdsorbateAdsorbateChargeChargeReal[CurrentSystem]+UAdsorbateAdsorbateChargeChargeFourier[CurrentSystem]+
UAdsorbateAdsorbateChargeBondDipoleReal[CurrentSystem]+UAdsorbateAdsorbateChargeBondDipoleFourier[CurrentSystem]+
UAdsorbateAdsorbateBondDipoleBondDipoleReal[CurrentSystem]+UAdsorbateAdsorbateBondDipoleBondDipoleFourier[CurrentSystem];
UAdsorbateAdsorbate[CurrentSystem]=UAdsorbateAdsorbateVDW[CurrentSystem]+UAdsorbateAdsorbateCoulomb[CurrentSystem];
UCationCationCoulomb[CurrentSystem]=
UCationCationChargeChargeReal[CurrentSystem]+UCationCationChargeChargeFourier[CurrentSystem]+
UCationCationChargeBondDipoleReal[CurrentSystem]+UCationCationChargeBondDipoleFourier[CurrentSystem]+
UCationCationBondDipoleBondDipoleReal[CurrentSystem]+UCationCationBondDipoleBondDipoleFourier[CurrentSystem];
UCationCation[CurrentSystem]=UCationCationVDW[CurrentSystem]+UCationCationCoulomb[CurrentSystem];
UAdsorbateCationCoulomb[CurrentSystem]=
UAdsorbateCationChargeChargeReal[CurrentSystem]+UAdsorbateCationChargeChargeFourier[CurrentSystem]+
UAdsorbateCationChargeBondDipoleReal[CurrentSystem]+UAdsorbateCationChargeBondDipoleFourier[CurrentSystem]+
UAdsorbateCationBondDipoleBondDipoleReal[CurrentSystem]+UAdsorbateCationBondDipoleBondDipoleFourier[CurrentSystem];
UAdsorbateCation[CurrentSystem]=UAdsorbateCationVDW[CurrentSystem]+UAdsorbateCationCoulomb[CurrentSystem];
UHostAdsorbateCoulomb[CurrentSystem]=
UHostAdsorbateChargeChargeReal[CurrentSystem]+UHostAdsorbateChargeChargeFourier[CurrentSystem]+
UHostAdsorbateChargeBondDipoleReal[CurrentSystem]+UHostAdsorbateChargeBondDipoleFourier[CurrentSystem]+
UHostAdsorbateBondDipoleBondDipoleReal[CurrentSystem]+UHostAdsorbateBondDipoleBondDipoleFourier[CurrentSystem];
UHostAdsorbate[CurrentSystem]=UHostAdsorbateVDW[CurrentSystem]+UHostAdsorbateCoulomb[CurrentSystem];
UHostCationCoulomb[CurrentSystem]=
UHostCationChargeChargeReal[CurrentSystem]+UHostCationChargeChargeFourier[CurrentSystem]+
UHostCationChargeBondDipoleReal[CurrentSystem]+UHostCationChargeBondDipoleFourier[CurrentSystem]+
UHostCationBondDipoleBondDipoleReal[CurrentSystem]+UHostCationBondDipoleBondDipoleFourier[CurrentSystem];
UHostCation[CurrentSystem]=UHostCationVDW[CurrentSystem]+UHostCationCoulomb[CurrentSystem];
UHostHostCoulomb[CurrentSystem]=
UHostHostChargeChargeReal[CurrentSystem]+UHostHostChargeChargeFourier[CurrentSystem]+
UHostHostChargeBondDipoleReal[CurrentSystem]+UHostHostChargeBondDipoleFourier[CurrentSystem]+
UHostHostBondDipoleBondDipoleReal[CurrentSystem]+UHostHostBondDipoleBondDipoleFourier[CurrentSystem];
UHostHost[CurrentSystem]=UHostHostVDW[CurrentSystem]+UHostHostCoulomb[CurrentSystem];
// correct the strain derivative tensor for rigid units
// first the tensor was computed atomicly, here the rigid interactions are subtracted
// note that instantaneous molecular strain derivative tensor is NOT symmetric
// the total force is not directed along the line of the center of the molecules and the
// contribution subtracted here introduces a torque on the molecules
// the average pressure tensor however, is symmetric
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
com=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition;
for(k=0;k<Components[Type].Groups[l].NumberOfGroupAtoms;k++)
{
A=Components[Type].Groups[l].Atoms[k];
pos=Adsorbates[CurrentSystem][i].Atoms[A].Position;
force=Adsorbates[CurrentSystem][i].Atoms[A].Force;
StrainDerivativeRigidCorrection[CurrentSystem].ax+=(pos.x-com.x)*force.x;
StrainDerivativeRigidCorrection[CurrentSystem].ay+=(pos.x-com.x)*force.y;
StrainDerivativeRigidCorrection[CurrentSystem].az+=(pos.x-com.x)*force.z;
StrainDerivativeRigidCorrection[CurrentSystem].bx+=(pos.y-com.y)*force.x;
StrainDerivativeRigidCorrection[CurrentSystem].by+=(pos.y-com.y)*force.y;
StrainDerivativeRigidCorrection[CurrentSystem].bz+=(pos.y-com.y)*force.z;
StrainDerivativeRigidCorrection[CurrentSystem].cx+=(pos.z-com.z)*force.x;
StrainDerivativeRigidCorrection[CurrentSystem].cy+=(pos.z-com.z)*force.y;
StrainDerivativeRigidCorrection[CurrentSystem].cz+=(pos.z-com.z)*force.z;
}
}
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
Type=Cations[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
com=Cations[CurrentSystem][i].Groups[l].CenterOfMassPosition;
for(k=0;k<Components[Type].Groups[l].NumberOfGroupAtoms;k++)
{
A=Components[Type].Groups[l].Atoms[k];
pos=Cations[CurrentSystem][i].Atoms[A].Position;
force=Cations[CurrentSystem][i].Atoms[A].Force;
StrainDerivativeRigidCorrection[CurrentSystem].ax+=(pos.x-com.x)*force.x;
StrainDerivativeRigidCorrection[CurrentSystem].ay+=(pos.x-com.x)*force.y;
StrainDerivativeRigidCorrection[CurrentSystem].az+=(pos.x-com.x)*force.z;
StrainDerivativeRigidCorrection[CurrentSystem].bx+=(pos.y-com.y)*force.x;
StrainDerivativeRigidCorrection[CurrentSystem].by+=(pos.y-com.y)*force.y;
StrainDerivativeRigidCorrection[CurrentSystem].bz+=(pos.y-com.y)*force.z;
StrainDerivativeRigidCorrection[CurrentSystem].cx+=(pos.z-com.z)*force.x;
StrainDerivativeRigidCorrection[CurrentSystem].cy+=(pos.z-com.z)*force.y;
StrainDerivativeRigidCorrection[CurrentSystem].cz+=(pos.z-com.z)*force.z;
}
}
}
}
// correct the first strain-derivative for constraints (rigid units)
StrainDerivativeTensor[CurrentSystem].ax+=StrainDerivativeRigidCorrection[CurrentSystem].ax;
StrainDerivativeTensor[CurrentSystem].ay+=StrainDerivativeRigidCorrection[CurrentSystem].ay;
StrainDerivativeTensor[CurrentSystem].az+=StrainDerivativeRigidCorrection[CurrentSystem].az;
StrainDerivativeTensor[CurrentSystem].bx+=StrainDerivativeRigidCorrection[CurrentSystem].bx;
StrainDerivativeTensor[CurrentSystem].by+=StrainDerivativeRigidCorrection[CurrentSystem].by;
StrainDerivativeTensor[CurrentSystem].bz+=StrainDerivativeRigidCorrection[CurrentSystem].bz;
StrainDerivativeTensor[CurrentSystem].cx+=StrainDerivativeRigidCorrection[CurrentSystem].cx;
StrainDerivativeTensor[CurrentSystem].cy+=StrainDerivativeRigidCorrection[CurrentSystem].cy;
StrainDerivativeTensor[CurrentSystem].cz+=StrainDerivativeRigidCorrection[CurrentSystem].cz;
// correct the first strain-derivative for tail-corrections
StrainDerivativeTensor[CurrentSystem].ax+=StrainDerivativeTailCorrection[CurrentSystem];
StrainDerivativeTensor[CurrentSystem].by+=StrainDerivativeTailCorrection[CurrentSystem];
StrainDerivativeTensor[CurrentSystem].cz+=StrainDerivativeTailCorrection[CurrentSystem];
// symmetrize strain-derivative (asymmetry originates from torque induced by rigid units and bond-dipoles)
temp=0.5*(StrainDerivativeTensor[CurrentSystem].ay+StrainDerivativeTensor[CurrentSystem].bx);
StrainDerivativeTensor[CurrentSystem].ay=StrainDerivativeTensor[CurrentSystem].bx=temp;
temp=0.5*(StrainDerivativeTensor[CurrentSystem].az+StrainDerivativeTensor[CurrentSystem].cx);
StrainDerivativeTensor[CurrentSystem].az=StrainDerivativeTensor[CurrentSystem].cx=temp;
temp=0.5*(StrainDerivativeTensor[CurrentSystem].bz+StrainDerivativeTensor[CurrentSystem].cy);
StrainDerivativeTensor[CurrentSystem].bz=StrainDerivativeTensor[CurrentSystem].cy=temp;
// correct the second strain-derivative for tail-corrections
if(ComputeBornTerm)
{
BornTerm[CurrentSystem].xxxx-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].yyxx-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].zzxx-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].xxyy-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].yyyy-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].zzyy-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].xxzz-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].yyzz-=StrainDerivativeTailCorrection[CurrentSystem];
BornTerm[CurrentSystem].zzzz-=StrainDerivativeTailCorrection[CurrentSystem];
}
// compute the stress-tensor from the strain-derivative tensor
ConfigurationalStressTensor[CurrentSystem].ax=-StrainDerivativeTensor[CurrentSystem].ax/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].bx=-StrainDerivativeTensor[CurrentSystem].bx/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].cx=-StrainDerivativeTensor[CurrentSystem].cx/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].ay=-StrainDerivativeTensor[CurrentSystem].ay/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].by=-StrainDerivativeTensor[CurrentSystem].by/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].cy=-StrainDerivativeTensor[CurrentSystem].cy/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].az=-StrainDerivativeTensor[CurrentSystem].az/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].bz=-StrainDerivativeTensor[CurrentSystem].bz/Volume[CurrentSystem];
ConfigurationalStressTensor[CurrentSystem].cz=-StrainDerivativeTensor[CurrentSystem].cz/Volume[CurrentSystem];
// compute the pressure arising from interactions from the trace of the stress tensor
Pressure[CurrentSystem]=(StressTensor[CurrentSystem].ax+StressTensor[CurrentSystem].by+StressTensor[CurrentSystem].cz)/3.0;
KineticStressTensor[CurrentSystem]=GetKineticStressTensor();
KineticStressTensor[CurrentSystem].ax/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].ay/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].az/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].bx/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].by/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].bz/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].cx/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].cy/=Volume[CurrentSystem];
KineticStressTensor[CurrentSystem].cz/=Volume[CurrentSystem];
StressTensor[CurrentSystem].ax=ConfigurationalStressTensor[CurrentSystem].ax+KineticStressTensor[CurrentSystem].ax;
StressTensor[CurrentSystem].ay=ConfigurationalStressTensor[CurrentSystem].ay+KineticStressTensor[CurrentSystem].ay;
StressTensor[CurrentSystem].az=ConfigurationalStressTensor[CurrentSystem].az+KineticStressTensor[CurrentSystem].az;
StressTensor[CurrentSystem].bx=ConfigurationalStressTensor[CurrentSystem].bx+KineticStressTensor[CurrentSystem].bx;
StressTensor[CurrentSystem].by=ConfigurationalStressTensor[CurrentSystem].by+KineticStressTensor[CurrentSystem].by;
StressTensor[CurrentSystem].bz=ConfigurationalStressTensor[CurrentSystem].bz+KineticStressTensor[CurrentSystem].bz;
StressTensor[CurrentSystem].cx=ConfigurationalStressTensor[CurrentSystem].cx+KineticStressTensor[CurrentSystem].cx;
StressTensor[CurrentSystem].cy=ConfigurationalStressTensor[CurrentSystem].cy+KineticStressTensor[CurrentSystem].cy;
StressTensor[CurrentSystem].cz=ConfigurationalStressTensor[CurrentSystem].cz+KineticStressTensor[CurrentSystem].cz;
UTotal[CurrentSystem]=
// inter
UHostHost[CurrentSystem]+UCationCation[CurrentSystem]+UAdsorbateAdsorbate[CurrentSystem]+
UHostCation[CurrentSystem]+UHostAdsorbate[CurrentSystem]+UAdsorbateCation[CurrentSystem]+
// intra framework
UHostBond[CurrentSystem]+UHostUreyBradley[CurrentSystem]+UHostBend[CurrentSystem]+
UHostInversionBend[CurrentSystem]+UHostTorsion[CurrentSystem]+UHostImproperTorsion[CurrentSystem]+
UHostBondBond[CurrentSystem]+UHostBondBend[CurrentSystem]+UHostBendBend[CurrentSystem]+
UHostBondTorsion[CurrentSystem]+UHostBendTorsion[CurrentSystem]+
// intra adsorbates
UAdsorbateBond[CurrentSystem]+UAdsorbateUreyBradley[CurrentSystem]+UAdsorbateBend[CurrentSystem]+
UAdsorbateInversionBend[CurrentSystem]+UAdsorbateTorsion[CurrentSystem]+UAdsorbateImproperTorsion[CurrentSystem]+
UAdsorbateBondBond[CurrentSystem]+UAdsorbateBondBend[CurrentSystem]+UAdsorbateBendBend[CurrentSystem]+
UAdsorbateBondTorsion[CurrentSystem]+UAdsorbateBendTorsion[CurrentSystem]+
UAdsorbateIntraVDW[CurrentSystem]+UAdsorbateIntraChargeCharge[CurrentSystem]+
UAdsorbateIntraChargeBondDipole[CurrentSystem]+UAdsorbateIntraBondDipoleBondDipole[CurrentSystem]+
// intra cations
UCationBond[CurrentSystem]+UCationUreyBradley[CurrentSystem]+UCationBend[CurrentSystem]+
UCationInversionBend[CurrentSystem]+UCationTorsion[CurrentSystem]+UCationImproperTorsion[CurrentSystem]+
UCationBondBond[CurrentSystem]+UCationBondBend[CurrentSystem]+UCationBendBend[CurrentSystem]+
UCationBondTorsion[CurrentSystem]+UCationBendTorsion[CurrentSystem]+
UCationIntraVDW[CurrentSystem]+UCationIntraChargeCharge[CurrentSystem]+
UCationIntraChargeBondDipole[CurrentSystem]+UCationIntraBondDipoleBondDipole[CurrentSystem]+
// polarization
UHostPolarization[CurrentSystem]+UAdsorbatePolarization[CurrentSystem]+UCationPolarization[CurrentSystem]+
UHostBackPolarization[CurrentSystem]+UAdsorbateBackPolarization[CurrentSystem]+UCationBackPolarization[CurrentSystem]+
// tailcorrection
UTailCorrection[CurrentSystem]+
// harmonic constraint energy
UDistanceConstraints[CurrentSystem]+UAngleConstraints[CurrentSystem]+UDihedralConstraints[CurrentSystem]+
UInversionBendConstraints[CurrentSystem]+UOutOfPlaneDistanceConstraints[CurrentSystem]+UExclusionConstraints[CurrentSystem];
}
void CalculateMolecularExcessPressure(void)
{
int i,j,l;
VECTOR pos,force,com;
REAL temp;
int Type;
StrainDerivativeTensor[CurrentSystem].ax=StrainDerivativeTensor[CurrentSystem].bx=StrainDerivativeTensor[CurrentSystem].cx=0.0;
StrainDerivativeTensor[CurrentSystem].ay=StrainDerivativeTensor[CurrentSystem].by=StrainDerivativeTensor[CurrentSystem].cy=0.0;
StrainDerivativeTensor[CurrentSystem].az=StrainDerivativeTensor[CurrentSystem].bz=StrainDerivativeTensor[CurrentSystem].cz=0.0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Adsorbates[CurrentSystem][i].Atoms[j].Force.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].Force.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].Force.z=0.0;
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Cations[CurrentSystem][i].Atoms[j].Force.x=0.0;
Cations[CurrentSystem][i].Atoms[j].Force.y=0.0;
Cations[CurrentSystem][i].Atoms[j].Force.z=0.0;
}
}
CalculateTotalInterVDWForce();
CalculateTotalInterChargeChargeCoulombForce();
CalculateTotalInterChargeBondDipoleCoulombForce();
CalculateTotalInterBondDipoleBondDipoleCoulombForce();
// the contribution of the charges present in the system (long-range interaction)
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
EwaldFourierForce();
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
com=GetAdsorbateCenterOfMass(i);
for(l=0;l<Components[Type].NumberOfAtoms;l++)
{
pos=Adsorbates[CurrentSystem][i].Atoms[l].Position;
force=Adsorbates[CurrentSystem][i].Atoms[l].Force;
StrainDerivativeTensor[CurrentSystem].ax+=(pos.x-com.x)*force.x;
StrainDerivativeTensor[CurrentSystem].ay+=(pos.x-com.x)*force.y;
StrainDerivativeTensor[CurrentSystem].az+=(pos.x-com.x)*force.z;
StrainDerivativeTensor[CurrentSystem].bx+=(pos.y-com.y)*force.x;
StrainDerivativeTensor[CurrentSystem].by+=(pos.y-com.y)*force.y;
StrainDerivativeTensor[CurrentSystem].bz+=(pos.y-com.y)*force.z;
StrainDerivativeTensor[CurrentSystem].cx+=(pos.z-com.z)*force.x;
StrainDerivativeTensor[CurrentSystem].cy+=(pos.z-com.z)*force.y;
StrainDerivativeTensor[CurrentSystem].cz+=(pos.z-com.z)*force.z;
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
Type=Cations[CurrentSystem][i].Type;
com=GetCationCenterOfMass(i);
for(l=0;l<Components[Type].NumberOfAtoms;l++)
{
pos=Cations[CurrentSystem][i].Atoms[l].Position;
force=Cations[CurrentSystem][i].Atoms[l].Force;
StrainDerivativeTensor[CurrentSystem].ax+=(pos.x-com.x)*force.x;
StrainDerivativeTensor[CurrentSystem].ay+=(pos.x-com.x)*force.y;
StrainDerivativeTensor[CurrentSystem].az+=(pos.x-com.x)*force.z;
StrainDerivativeTensor[CurrentSystem].bx+=(pos.y-com.y)*force.x;
StrainDerivativeTensor[CurrentSystem].by+=(pos.y-com.y)*force.y;
StrainDerivativeTensor[CurrentSystem].bz+=(pos.y-com.y)*force.z;
StrainDerivativeTensor[CurrentSystem].cx+=(pos.z-com.z)*force.x;
StrainDerivativeTensor[CurrentSystem].cy+=(pos.z-com.z)*force.y;
StrainDerivativeTensor[CurrentSystem].cz+=(pos.z-com.z)*force.z;
}
}
temp=0.5*(StrainDerivativeTensor[CurrentSystem].ay+StrainDerivativeTensor[CurrentSystem].bx);
StrainDerivativeTensor[CurrentSystem].ay=StrainDerivativeTensor[CurrentSystem].bx=temp;
temp=0.5*(StrainDerivativeTensor[CurrentSystem].az+StrainDerivativeTensor[CurrentSystem].cx);
StrainDerivativeTensor[CurrentSystem].az=StrainDerivativeTensor[CurrentSystem].cx=temp;
temp=0.5*(StrainDerivativeTensor[CurrentSystem].bz+StrainDerivativeTensor[CurrentSystem].cy);
StrainDerivativeTensor[CurrentSystem].bz=StrainDerivativeTensor[CurrentSystem].cy=temp;
}
// the main routine for MD: the integrator
void Integration(void)
{
switch(Ensemble[CurrentSystem])
{
case NPTPR:
case MuPTPR:
NoseHooverNPTPR();
if(DegreesOfFreedomRotation[CurrentSystem]>0)
NoseHooverNVTRotation();
// evolve the positions a half timestep
UpdateVelocities();
UpdatePositionsVelocitiesNPTPR();
// evolve the part of rigid bodies involving free rotation
NoSquishFreeRotorOrderTwo();
// compute the forces on all the atoms
CalculateForce();
// evolve the positions a half timestep
UpdateVelocities();
if(DegreesOfFreedomRotation[CurrentSystem]>0)
NoseHooverNVTRotation();
NoseHooverNPTPR();
break;
case NPHPR:
NoseHooverNPHPR();
// evolve the positions a half timestep
UpdateVelocities();
UpdatePositionsVelocitiesNPTPR();
// evolve the part of rigid bodies involving free rotation
NoSquishFreeRotorOrderTwo();
// store the structure-factors for the Ewald-summations
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
{
SetupKVectors();
EwaldEnergyIon();
}
// compute the forces on all the atoms
CalculateForce();
// evolve the positions a half timestep
UpdateVelocities();
NoseHooverNPHPR();
break;
case NPH:
// update the velocity of the cell
UpdateCellVelocity();
// evolve the positions a half timestep
UpdateVelocities();
// evolve the positions a full timestep
UpdatePositions();
// evolve the part of rigid bodies involving free rotation
NoSquishFreeRotorOrderTwo();
// store the structure-factors for the Ewald-summations
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
{
SetupKVectors();
EwaldEnergyIon();
}
// compute the forces on all the atoms
CalculateForce();
// evolve the positions a half timestep
UpdateVelocities();
// update the velocity of the cell
UpdateCellVelocity();
break;
case NPT:
case MuPT:
// apply thermo/barostats for temperature, volume, and/or box-shape control
// integrate the fictive velocities another half a timestep
NoseHooverNPT();
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
NoseHooverNVTFramework();
if(DegreesOfFreedomTranslationalAdsorbates[CurrentSystem]>0)
NoseHooverNVTAdsorbates();
if(DegreesOfFreedomTranslationalCations[CurrentSystem]>0)
NoseHooverNVTCations();
if(DegreesOfFreedomRotation[CurrentSystem]>0)
NoseHooverNVTRotation();
// update the velocity of the cell
UpdateCellVelocity();
// evolve the positions a half timestep
UpdateVelocities();
// evolve the positions a full timestep
UpdatePositions();
// evolve the part of rigid bodies involving free rotation
NoSquishFreeRotorOrderTwo();
// compute the forces on all the atoms
CalculateForce();
// evolve the positions a half timestep
UpdateVelocities();
// update the velocity of the cell
UpdateCellVelocity();
// apply thermo/barostats for temperature, volume, and/or box-shape control
// integrate the fictive velocities another half a timestep
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
NoseHooverNVTFramework();
if(DegreesOfFreedomTranslationalAdsorbates[CurrentSystem]>0)
NoseHooverNVTAdsorbates();
if(DegreesOfFreedomTranslationalCations[CurrentSystem]>0)
NoseHooverNVTCations();
if(DegreesOfFreedomRotation[CurrentSystem]>0)
NoseHooverNVTRotation();
NoseHooverNPT();
break;
case NVT:
case MuVT:
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
NoseHooverNVTFramework();
if(DegreesOfFreedomTranslationalAdsorbates[CurrentSystem]>0)
NoseHooverNVTAdsorbates();
if(DegreesOfFreedomTranslationalCations[CurrentSystem]>0)
NoseHooverNVTCations();
if(DegreesOfFreedomRotation[CurrentSystem]>0)
NoseHooverNVTRotation();
// evolve the positions a half timestep
UpdateVelocities();
// evolve the positions a full timestep
UpdatePositions();
// first part of bond-constraints
RattleStageOne();
// evolve the part of rigid bodies involving free rotation
NoSquishFreeRotorOrderTwo();
// compute the forces on all the atoms
CalculateForce();
// evolve the positions a half timestep
UpdateVelocities();
// second part of bond-constraints
RattleStageTwo();
// apply thermo/barostats for temperature, volume, and/or box-shape control
// integrate the fictive velocities another half a timestep
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
NoseHooverNVTFramework();
if(DegreesOfFreedomTranslationalAdsorbates[CurrentSystem]>0)
NoseHooverNVTAdsorbates();
if(DegreesOfFreedomTranslationalCations[CurrentSystem]>0)
NoseHooverNVTCations();
if(DegreesOfFreedomRotation[CurrentSystem]>0)
NoseHooverNVTRotation();
break;
case NVE:
default:
// evolve the positions a half timestep
UpdateVelocities();
// evolve the positions a full timestep
UpdatePositions();
// first part of bond-constraints
RattleStageOne();
// evolve the part of rigid bodies involving free rotation
NoSquishFreeRotorOrderTwo();
// compute the forces on all the atoms
CalculateForce();
// evolve the positions a half timestep
UpdateVelocities();
// second part of bond-constraints
RattleStageTwo();
break;
}
// for rigid units: create atomic velocities from com-velocity and quaternion-velocity
CreateCartesianVelocities();
ComputeNoseHooverEnergySystem();
ComputeKineticEnergySystem();
ConservedEnergy[CurrentSystem]=UTotal[CurrentSystem]+UKinetic[CurrentSystem]+UNoseHoover[CurrentSystem];
}
int CalculateElectricField(void)
{
int i,j,k,f1;
REAL_MATRIX3x3 pol_factor;
VECTOR electric_field,electric_field1,electric_field2;
VECTOR induced_dipole;
int Type;
// set "static" polarization to zero
UHostPolarization[CurrentSystem]=0.0;
UAdsorbatePolarization[CurrentSystem]=0.0;
UCationPolarization[CurrentSystem]=0.0;
// set "back" polarization to zero
UHostBackPolarization[CurrentSystem]=0.0;
UAdsorbateBackPolarization[CurrentSystem]=0.0;
UCationBackPolarization[CurrentSystem]=0.0;
// set framework electric fields to zero
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModel==FLEXIBLE))
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField.x=0.0;
Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField.y=0.0;
Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField.z=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z=0.0;
}
}
}
// set adsorbate electric fields to zero
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField.z=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
// set cation electric fields to zero
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField.x=0.0;
Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField.y=0.0;
Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField.z=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
// calculate static electric field
CalculateTotalInterChargeChargeCoulombElectricFieldMC(FALSE,-1,-1);
CalculateFrameworkChargeChargeElectricFieldMC(FALSE,-1,-1);
ComputeStaticElectricFieldEwald(FALSE,-1,-1);
// set the framework induces dipoles when backpolarization is used or the framework is flexible
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModel==FLEXIBLE))
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Type=Framework[CurrentSystem].Atoms[f1][i].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field=Framework[CurrentSystem].Atoms[f1][i].ElectricField;
// Eq. 10 from T.M. Nymand and P. Linse, J. Chem. Phys., 112(14), 2000
Framework[CurrentSystem].Atoms[f1][i].InducedDipole.x=pol_factor.ax*electric_field.x+pol_factor.ay*electric_field.y+pol_factor.az*electric_field.z;
Framework[CurrentSystem].Atoms[f1][i].InducedDipole.y=pol_factor.bx*electric_field.x+pol_factor.by*electric_field.y+pol_factor.bz*electric_field.z;
Framework[CurrentSystem].Atoms[f1][i].InducedDipole.z=pol_factor.cx*electric_field.x+pol_factor.cy*electric_field.y+pol_factor.cz*electric_field.z;
Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField=electric_field;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z=0.0;
}
}
}
// set the adsorbate induces dipoles
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Adsorbates[CurrentSystem][i].Atoms[j].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field=Adsorbates[CurrentSystem][i].Atoms[j].ElectricField;
// Eq. 10 from T.M. Nymand and P. Linse, J. Chem. Phys., 112(14), 2000
Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole.x=pol_factor.ax*electric_field.x+pol_factor.ay*electric_field.y+pol_factor.az*electric_field.z;
Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole.y=pol_factor.bx*electric_field.x+pol_factor.by*electric_field.y+pol_factor.bz*electric_field.z;
Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole.z=pol_factor.cx*electric_field.x+pol_factor.cy*electric_field.y+pol_factor.cz*electric_field.z;
Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField=electric_field;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
// set the cation induces dipoles
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Cations[CurrentSystem][i].Atoms[j].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field=Cations[CurrentSystem][i].Atoms[j].ElectricField;
// Eq. 10 from T.M. Nymand and P. Linse, J. Chem. Phys., 112(14), 2000
Cations[CurrentSystem][i].Atoms[j].InducedDipole.x=pol_factor.ax*electric_field.x+pol_factor.ay*electric_field.y+pol_factor.az*electric_field.z;
Cations[CurrentSystem][i].Atoms[j].InducedDipole.y=pol_factor.bx*electric_field.x+pol_factor.by*electric_field.y+pol_factor.bz*electric_field.z;
Cations[CurrentSystem][i].Atoms[j].InducedDipole.z=pol_factor.cx*electric_field.x+pol_factor.cy*electric_field.y+pol_factor.cz*electric_field.z;
Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField=electric_field;
Cations[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
// initialize the polarization energies
UHostPolarization[CurrentSystem]=0.0;
UAdsorbatePolarization[CurrentSystem]=0.0;
UCationPolarization[CurrentSystem]=0.0;
// calculate the host-polarization from the induces dipoles and electric field, Eq. 13 from T.M. Nymand and P. Linse, J. Chem. Phys., 112(14), 2000
if((BackPolarization)||(Framework[CurrentSystem].FrameworkModel==FLEXIBLE))
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Type=Framework[CurrentSystem].Atoms[f1][i].Type;
electric_field=Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField;
induced_dipole=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
UHostPolarization[CurrentSystem]-=0.5*(induced_dipole.x*electric_field.x+induced_dipole.y*electric_field.y+induced_dipole.z*electric_field.z);
}
}
}
}
// calculate the adsorbate-polarization from the induces dipoles and electric field, Eq. 13 from T.M. Nymand and P. Linse, J. Chem. Phys., 112(14), 2000
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Adsorbates[CurrentSystem][i].Atoms[j].Type;
induced_dipole=Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole;
electric_field=Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField;
UAdsorbatePolarization[CurrentSystem]-=0.5*(induced_dipole.x*electric_field.x+induced_dipole.y*electric_field.y+induced_dipole.z*electric_field.z);
}
}
// calculate the cation-polarization from the induces dipoles and electric field, Eq. 13 from T.M. Nymand and P. Linse, J. Chem. Phys., 112(14), 2000
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Cations[CurrentSystem][i].Atoms[j].Type;
induced_dipole=Cations[CurrentSystem][i].Atoms[j].InducedDipole;
electric_field=Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField;
UCationPolarization[CurrentSystem]-=0.5*(induced_dipole.x*electric_field.x+induced_dipole.y*electric_field.y+induced_dipole.z*electric_field.z);
}
}
if(!BackPolarization) return 0;
// iterate to convergence
for(k=0;k<NumberOfBackPolarizationSteps;k++)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Framework[CurrentSystem].Atoms[f1][i].ElectricField.x=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.y=0.0;
Framework[CurrentSystem].Atoms[f1][i].ElectricField.z=0.0;
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Adsorbates[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Cations[CurrentSystem][i].Atoms[j].ElectricField.x=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.y=0.0;
Cations[CurrentSystem][i].Atoms[j].ElectricField.z=0.0;
}
}
// compute electric field generated by the induced dipoles
//CalculateInterElectricFieldFromInducedDipoles();
CalculateInterElectricFieldFromInducedDipoleMC(FALSE,-1,-1);
CalculateFrameworkMoleculeElectricFieldFromInducedDipoleMC(FALSE,-1,-1);
ComputeElectricFieldFromInducedDipolesEwaldMC(FALSE,-1,-1);
// computer new induced dipoles from electric field
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Type=Framework[CurrentSystem].Atoms[f1][i].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field1=Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField;
electric_field2=Framework[CurrentSystem].Atoms[f1][i].ElectricField;
electric_field.x=electric_field1.x+electric_field2.x;
electric_field.y=electric_field1.y+electric_field2.y;
electric_field.z=electric_field1.z+electric_field2.z;
// update the new induced dipoles from the statc electric field plus the induced field
Framework[CurrentSystem].Atoms[f1][i].InducedDipole.x=pol_factor.ax*electric_field.x+pol_factor.ay*electric_field.y+pol_factor.az*electric_field.z;
Framework[CurrentSystem].Atoms[f1][i].InducedDipole.y=pol_factor.bx*electric_field.x+pol_factor.by*electric_field.y+pol_factor.bz*electric_field.z;
Framework[CurrentSystem].Atoms[f1][i].InducedDipole.z=pol_factor.cx*electric_field.x+pol_factor.cy*electric_field.y+pol_factor.cz*electric_field.z;
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Adsorbates[CurrentSystem][i].Atoms[j].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field1=Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField;
electric_field2=Adsorbates[CurrentSystem][i].Atoms[j].ElectricField;
electric_field.x=electric_field1.x+electric_field2.x;
electric_field.y=electric_field1.y+electric_field2.y;
electric_field.z=electric_field1.z+electric_field2.z;
// update the new induced dipoles from the statc electric field plus the induced field
Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole.x=pol_factor.ax*electric_field.x+pol_factor.ay*electric_field.y+pol_factor.az*electric_field.z;
Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole.y=pol_factor.bx*electric_field.x+pol_factor.by*electric_field.y+pol_factor.bz*electric_field.z;
Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole.z=pol_factor.cx*electric_field.x+pol_factor.cy*electric_field.y+pol_factor.cz*electric_field.z;
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Cations[CurrentSystem][i].Atoms[j].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field1=Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField;
electric_field2=Cations[CurrentSystem][i].Atoms[j].ElectricField;
electric_field.x=electric_field1.x+electric_field2.x;
electric_field.y=electric_field1.y+electric_field2.y;
electric_field.z=electric_field1.z+electric_field2.z;
// update the new induced dipoles from the statc electric field plus the induced field
Cations[CurrentSystem][i].Atoms[j].InducedDipole.x=pol_factor.ax*electric_field.x+pol_factor.ay*electric_field.y+pol_factor.az*electric_field.z;
Cations[CurrentSystem][i].Atoms[j].InducedDipole.y=pol_factor.bx*electric_field.x+pol_factor.by*electric_field.y+pol_factor.bz*electric_field.z;
Cations[CurrentSystem][i].Atoms[j].InducedDipole.z=pol_factor.cx*electric_field.x+pol_factor.cy*electric_field.y+pol_factor.cz*electric_field.z;
}
}
}
// sum the energy
UHostBackPolarization[CurrentSystem]=0.0;
UAdsorbateBackPolarization[CurrentSystem]=0.0;
UCationBackPolarization[CurrentSystem]=0.0;
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Type=Framework[CurrentSystem].Atoms[f1][i].Type;
pol_factor=PseudoAtoms[Type].Polarization;
electric_field=Framework[CurrentSystem].Atoms[f1][i].ReferenceElectricField;
induced_dipole=Framework[CurrentSystem].Atoms[f1][i].InducedDipole;
UHostBackPolarization[CurrentSystem]-=0.5*(induced_dipole.x*electric_field.x+induced_dipole.y*electric_field.y+induced_dipole.z*electric_field.z);
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Adsorbates[CurrentSystem][i].Atoms[j].Type;
pol_factor=PseudoAtoms[Type].Polarization;
induced_dipole=Adsorbates[CurrentSystem][i].Atoms[j].InducedDipole;
electric_field=Adsorbates[CurrentSystem][i].Atoms[j].ReferenceElectricField;
UAdsorbateBackPolarization[CurrentSystem]-=0.5*(induced_dipole.x*electric_field.x+induced_dipole.y*electric_field.y+induced_dipole.z*electric_field.z);
}
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
for(j=0;j<Cations[CurrentSystem][i].NumberOfAtoms;j++)
{
Type=Cations[CurrentSystem][i].Atoms[j].Type;
pol_factor=PseudoAtoms[Type].Polarization;
induced_dipole=Cations[CurrentSystem][i].Atoms[j].InducedDipole;
electric_field=Cations[CurrentSystem][i].Atoms[j].ReferenceElectricField;
UCationBackPolarization[CurrentSystem]-=0.5*(induced_dipole.x*electric_field.x+induced_dipole.y*electric_field.y+induced_dipole.z*electric_field.z);
}
}
UHostBackPolarization[CurrentSystem]-=UHostPolarization[CurrentSystem];
UAdsorbateBackPolarization[CurrentSystem]-=UAdsorbatePolarization[CurrentSystem];
UCationBackPolarization[CurrentSystem]-=UCationPolarization[CurrentSystem];
return 0;
}
// integrate using a leap-frog algorithm
// never use (unless for comparison or testing)
void IntegrationLeapFrog(void)
{
int i,j,l;
int Type,A;
VECTOR Force,Velocity;
VECTOR Torque,dr,op,tr,inertia,inv,oq;
REAL Mass,tmp,eps,rnorm;
REAL_MATRIX3x3 M;
QUATERNION q,qn,qna,qnb;
CurrentSystem=0;
UAdsorbateKinetic[CurrentSystem]=0.0;
UAdsorbateRotationalKinetic[CurrentSystem]=0.0;
UAdsorbateTranslationalKinetic[CurrentSystem]=0.0;
// rotational motion
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
// compute the torque
Torque.x=0.0;
Torque.y=0.0;
Torque.z=0.0;
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Force=Adsorbates[CurrentSystem][i].Atoms[A].Force;
dr.x=Adsorbates[CurrentSystem][i].Atoms[A].Position.x-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.x;
dr.y=Adsorbates[CurrentSystem][i].Atoms[A].Position.y-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.y;
dr.z=Adsorbates[CurrentSystem][i].Atoms[A].Position.z-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.z;
Torque.x+=dr.y*Force.z-dr.z*Force.y;
Torque.y+=dr.z*Force.x-dr.x*Force.z;
Torque.z+=dr.x*Force.y-dr.y*Force.x;
}
BuildRotationMatrix(&M,Adsorbates[CurrentSystem][i].Groups[l].Quaternion);
// angular velocity at time step n (first guess)
op=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity;
inv=Components[Type].Groups[l].InverseInertiaVector;
inertia=Components[Type].Groups[l].InertiaVector;
for(j=0;j<5;j++)
{
tr.x=(Torque.x*M.ax+Torque.y*M.bx+Torque.z*M.cx)*inv.x
+(inertia.y-inertia.z)*op.y*op.z*inv.x;
tr.y=(Torque.x*M.ay+Torque.y*M.by+Torque.z*M.cy)*inv.y
+(inertia.z-inertia.x)*op.z*op.x*inv.y;
tr.z=(Torque.x*M.az+Torque.y*M.bz+Torque.z*M.cz)*inv.z
+(inertia.x-inertia.y)*op.x*op.y*inv.z;
// improved angular velocity at time step n
op.x=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.x+0.5*DeltaT*tr.x;
op.y=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.y+0.5*DeltaT*tr.y;
op.z=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.z+0.5*DeltaT*tr.z;
}
// angular velocity at time step n+1 (needed for quat algorithm)
oq.x=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.x+1.5*DeltaT*tr.x;
oq.y=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.y+1.5*DeltaT*tr.y;
oq.z=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.z+1.5*DeltaT*tr.z;
// angular velocity at time step n+1/2
Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.x+=DeltaT*tr.x;
Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.y+=DeltaT*tr.y;
Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.z+=DeltaT*tr.z;
// rotational kinetic energy
UAdsorbateRotationalKinetic[CurrentSystem]+=
0.5*(inertia.x*SQR(op.x)+inertia.y*SQR(op.y)+inertia.z*SQR(op.z));
q=Adsorbates[CurrentSystem][i].Groups[l].Quaternion;
qn.r=q.r+(-q.i*op.x-q.j*op.y-q.k*op.z)*0.5*DeltaT;
qn.i=q.i+(q.r*op.x-q.k*op.y+q.j*op.z)*0.5*DeltaT;
qn.j=q.j+(q.k*op.x+q.r*op.y-q.i*op.z)*0.5*DeltaT;
qn.k=q.k+(-q.j*op.x+q.i*op.y+q.r*op.z)*0.5*DeltaT;
qnb.r=qnb.i=qnb.j=qnb.k=0.0;
do
{
qna.r=0.5*(-q.i*op.x-q.j*op.y-q.k*op.z)
+0.5*(-qn.i*oq.x-qn.j*oq.y-qn.k*oq.z);
qna.i=0.5*(q.r*op.x-q.k*op.y+q.j*op.z)
+0.5*(qn.r*oq.x-qn.k*oq.y+qn.j*oq.z);
qna.j=0.5*(q.k*op.x+q.r*op.y-q.i*op.z)
+0.5*(qn.k*oq.x+qn.r*oq.y-qn.i*oq.z);
qna.k=0.5*(-q.j*op.x+q.i*op.y+q.r*op.z)
+0.5*(-qn.j*oq.x+qn.i*oq.y+qn.r*oq.z);
qn.r=q.r+0.5*qna.r*DeltaT;
qn.i=q.i+0.5*qna.i*DeltaT;
qn.j=q.j+0.5*qna.j*DeltaT;
qn.k=q.k+0.5*qna.k*DeltaT;
rnorm=1.0/sqrt(SQR(qn.r)+SQR(qn.i)+SQR(qn.j)+SQR(qn.k));
qn.r*=rnorm;
qn.i*=rnorm;
qn.j*=rnorm;
qn.k*=rnorm;
//convergence test
eps=(SQR(qna.r-qnb.r)+SQR(qna.i-qnb.i)+SQR(qna.j-qnb.j)+SQR(qna.k-qnb.k))*SQR(DeltaT);
qnb=qna;
}while(eps>1e-5);
// store new quaternions
Adsorbates[CurrentSystem][i].Groups[l].Quaternion=qn;
}
}
}
// translational motion
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Mass=Components[Adsorbates[CurrentSystem][i].Type].Mass;
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
Force.x=Force.y=Force.z=0.0;
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Force.x+=Adsorbates[CurrentSystem][i].Atoms[A].Force.x;
Force.y+=Adsorbates[CurrentSystem][i].Atoms[A].Force.y;
Force.z+=Adsorbates[CurrentSystem][i].Atoms[A].Force.z;
}
// centre of mass velocities at half-step to compute the kinetic energy
tmp=0.5*DeltaT/Mass;
Velocity.x=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.x+tmp*Force.x;
Velocity.y=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.y+tmp*Force.y;
Velocity.z=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.z+tmp*Force.z;
UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*(SQR(Velocity.x)+SQR(Velocity.y)+SQR(Velocity.z));
// advance velocity by leapfrog
tmp=DeltaT/Mass;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.x+=tmp*Force.x;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.y+=tmp*Force.y;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.z+=tmp*Force.z;
// advance position by leapfrog
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.x+=DeltaT*Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.x;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.y+=DeltaT*Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.y;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.z+=DeltaT*Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.z;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Mass=PseudoAtoms[Components[Type].Type[A]].Mass;
Force=Adsorbates[CurrentSystem][i].Atoms[A].Force;
// centre of mass velocities at half-step to compute the kinetic energy
tmp=0.5*DeltaT/Mass;
Velocity.x=Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x+tmp*Force.x;
Velocity.y=Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y+tmp*Force.y;
Velocity.z=Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z+tmp*Force.z;
UAdsorbateTranslationalKinetic[CurrentSystem]+=0.5*Mass*(SQR(Velocity.x)+SQR(Velocity.y)+SQR(Velocity.z));
// advance velocity by leapfrog
tmp=DeltaT/Mass;
Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x+=tmp*Force.x;
Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y+=tmp*Force.y;
Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z+=tmp*Force.z;
// advance position by leapfrog
Adsorbates[CurrentSystem][i].Atoms[A].Position.x+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x;
Adsorbates[CurrentSystem][i].Atoms[A].Position.y+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y;
Adsorbates[CurrentSystem][i].Atoms[A].Position.z+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z;
}
}
}
}
UKinetic[CurrentSystem]=UAdsorbateTranslationalKinetic[CurrentSystem]+UAdsorbateRotationalKinetic[CurrentSystem];
ConservedEnergy[CurrentSystem]=
UTotal[CurrentSystem]+
UKinetic[CurrentSystem]+
UNoseHoover[CurrentSystem]+
UNoseHooverAdsorbates[CurrentSystem]+
UNoseHooverCations[CurrentSystem]+
UNoseHooverFramework[CurrentSystem];
// new atomic positions for atoms in rigid bodies - relative to c.o.m
CreateCartesianPositions();
CalculateForce();
}
void IntegrationLeapFrogAtomicPositions(void)
{
int i,j;
CurrentSystem=0;
// advance position by leapfrog
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Adsorbates[CurrentSystem][i].Atoms[j].Position.x+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[j].Velocity.x;
Adsorbates[CurrentSystem][i].Atoms[j].Position.y+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[j].Velocity.y;
Adsorbates[CurrentSystem][i].Atoms[j].Position.z+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[j].Velocity.z;
}
}
}
void IntegrationLeapFrogAtomicVelocities(void)
{
int i,j;
int Type;
REAL Mass,tmp;
VECTOR Force,Velocity;
CurrentSystem=0;
UKinetic[CurrentSystem]=0.0;
// translational motion
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Mass=Components[Adsorbates[CurrentSystem][i].Type].Mass;
Type=Adsorbates[CurrentSystem][i].Type;
for(j=0;j<Adsorbates[CurrentSystem][i].NumberOfAtoms;j++)
{
Mass=PseudoAtoms[Adsorbates[CurrentSystem][i].Atoms[j].Type].Mass;
Force=Adsorbates[CurrentSystem][i].Atoms[j].Force;
// centre of mass velocities at half-step to compute the kinetic energy
tmp=0.5*DeltaT/Mass;
Velocity.x=Adsorbates[CurrentSystem][i].Atoms[j].Velocity.x+tmp*Force.x;
Velocity.y=Adsorbates[CurrentSystem][i].Atoms[j].Velocity.y+tmp*Force.y;
Velocity.z=Adsorbates[CurrentSystem][i].Atoms[j].Velocity.z+tmp*Force.z;
UKinetic[CurrentSystem]+=0.5*Mass*(SQR(Velocity.x)+SQR(Velocity.y)+SQR(Velocity.z));
// advance velocity by leapfrog
tmp=DeltaT/Mass;
Adsorbates[CurrentSystem][i].Atoms[j].Velocity.x+=tmp*Force.x;
Adsorbates[CurrentSystem][i].Atoms[j].Velocity.y+=tmp*Force.y;
Adsorbates[CurrentSystem][i].Atoms[j].Velocity.z+=tmp*Force.z;
}
}
ConservedEnergy[CurrentSystem]=
UTotal[CurrentSystem]+
UKinetic[CurrentSystem]+
UNoseHoover[CurrentSystem]+
UNoseHooverAdsorbates[CurrentSystem]+
UNoseHooverCations[CurrentSystem]+
UNoseHooverFramework[CurrentSystem];
}
void IntegrationLeapFrogAtomicPositionsAndQuaternions(void)
{
int i,j,l;
int Type,A;
VECTOR Force;
VECTOR Torque,dr,op,tr,inertia,inv,oq;
REAL Mass,eps,rnorm;
REAL_MATRIX3x3 M;
QUATERNION q,qn,qna,qnb;
CurrentSystem=0;
// rotational motion
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
// compute the torque
Torque.x=0.0;
Torque.y=0.0;
Torque.z=0.0;
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Force=Adsorbates[CurrentSystem][i].Atoms[A].Force;
dr.x=Adsorbates[CurrentSystem][i].Atoms[A].Position.x-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.x;
dr.y=Adsorbates[CurrentSystem][i].Atoms[A].Position.y-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.y;
dr.z=Adsorbates[CurrentSystem][i].Atoms[A].Position.z-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.z;
Torque.x+=dr.y*Force.z-dr.z*Force.y;
Torque.y+=dr.z*Force.x-dr.x*Force.z;
Torque.z+=dr.x*Force.y-dr.y*Force.x;
}
BuildRotationMatrix(&M,Adsorbates[CurrentSystem][i].Groups[l].Quaternion);
// angular velocity at time step n (first guess)
op=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity;
inv=Components[Type].Groups[l].InverseInertiaVector;
inertia=Components[Type].Groups[l].InertiaVector;
for(j=0;j<5;j++)
{
tr.x=(Torque.x*M.ax+Torque.y*M.bx+Torque.z*M.cx)*inv.x
+(inertia.y-inertia.z)*op.y*op.z*inv.x;
tr.y=(Torque.x*M.ay+Torque.y*M.by+Torque.z*M.cy)*inv.y
+(inertia.z-inertia.x)*op.z*op.x*inv.y;
tr.z=(Torque.x*M.az+Torque.y*M.bz+Torque.z*M.cz)*inv.z
+(inertia.x-inertia.y)*op.x*op.y*inv.z;
// improved angular velocity at time step n
op.x=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.x-0.5*DeltaT*tr.x;
op.y=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.y-0.5*DeltaT*tr.y;
op.z=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.z-0.5*DeltaT*tr.z;
}
// angular velocity at time step n+1 (needed for quat algorithm)
oq.x=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.x+0.5*DeltaT*tr.x;
oq.y=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.y+0.5*DeltaT*tr.y;
oq.z=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.z+0.5*DeltaT*tr.z;
// rotational kinetic energy
UAdsorbateRotationalKinetic[CurrentSystem]+=
0.5*(inertia.x*SQR(op.x)+inertia.y*SQR(op.y)+inertia.z*SQR(op.z));
q=Adsorbates[CurrentSystem][i].Groups[l].Quaternion;
qn.r=q.r+(-q.i*op.x-q.j*op.y-q.k*op.z)*0.5*DeltaT;
qn.i=q.i+(q.r*op.x-q.k*op.y+q.j*op.z)*0.5*DeltaT;
qn.j=q.j+(q.k*op.x+q.r*op.y-q.i*op.z)*0.5*DeltaT;
qn.k=q.k+(-q.j*op.x+q.i*op.y+q.r*op.z)*0.5*DeltaT;
qnb.r=qnb.i=qnb.j=qnb.k=0.0;
do
{
qna.r=0.5*(-q.i*op.x-q.j*op.y-q.k*op.z)
+0.5*(-qn.i*oq.x-qn.j*oq.y-qn.k*oq.z);
qna.i=0.5*(q.r*op.x-q.k*op.y+q.j*op.z)
+0.5*(qn.r*oq.x-qn.k*oq.y+qn.j*oq.z);
qna.j=0.5*(q.k*op.x+q.r*op.y-q.i*op.z)
+0.5*(qn.k*oq.x+qn.r*oq.y-qn.i*oq.z);
qna.k=0.5*(-q.j*op.x+q.i*op.y+q.r*op.z)
+0.5*(-qn.j*oq.x+qn.i*oq.y+qn.r*oq.z);
qn.r=q.r+0.5*qna.r*DeltaT;
qn.i=q.i+0.5*qna.i*DeltaT;
qn.j=q.j+0.5*qna.j*DeltaT;
qn.k=q.k+0.5*qna.k*DeltaT;
rnorm=1.0/sqrt(SQR(qn.r)+SQR(qn.i)+SQR(qn.j)+SQR(qn.k));
qn.r*=rnorm;
qn.i*=rnorm;
qn.j*=rnorm;
qn.k*=rnorm;
//convergence test
eps=(SQR(qna.r-qnb.r)+SQR(qna.i-qnb.i)+SQR(qna.j-qnb.j)+SQR(qna.k-qnb.k))*SQR(DeltaT);
qnb=qna;
}while(eps>1e-5);
// store new quaternions
Adsorbates[CurrentSystem][i].Groups[l].Quaternion=qn;
}
}
}
// translational motion
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].TotalNumberOfAtoms;i++)
{
Mass=PseudoAtoms[Framework[CurrentSystem].Atoms[0][i].Type].Mass;
// advance velocity by leapfrog
Framework[CurrentSystem].Atoms[0][i].Position.x+=DeltaT*Framework[CurrentSystem].Atoms[0][i].Velocity.x;
Framework[CurrentSystem].Atoms[0][i].Position.y+=DeltaT*Framework[CurrentSystem].Atoms[0][i].Velocity.y;
Framework[CurrentSystem].Atoms[0][i].Position.z+=DeltaT*Framework[CurrentSystem].Atoms[0][i].Velocity.z;
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Mass=Components[Adsorbates[CurrentSystem][i].Type].Mass;
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
// advance position by leapfrog
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.x+=DeltaT*Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.x;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.y+=DeltaT*Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.y;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.z+=DeltaT*Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.z;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
// advance position by leapfrog
Adsorbates[CurrentSystem][i].Atoms[A].Position.x+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x;
Adsorbates[CurrentSystem][i].Atoms[A].Position.y+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y;
Adsorbates[CurrentSystem][i].Atoms[A].Position.z+=DeltaT*Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z;
}
}
}
}
}
void IntegrationLeapFrogAtomicVelocitiesAndQuaternions(void)
{
int i,j,l;
int Type,A;
VECTOR Force,Velocity;
VECTOR Torque,dr,op,tr,inertia,inv;
REAL Mass,tmp;
REAL_MATRIX3x3 M;
CurrentSystem=0;
UKinetic[CurrentSystem]=0.0;
// rotational motion
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
// compute the torque
Torque.x=0.0;
Torque.y=0.0;
Torque.z=0.0;
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Force=Adsorbates[CurrentSystem][i].Atoms[A].Force;
dr.x=Adsorbates[CurrentSystem][i].Atoms[A].Position.x-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.x;
dr.y=Adsorbates[CurrentSystem][i].Atoms[A].Position.y-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.y;
dr.z=Adsorbates[CurrentSystem][i].Atoms[A].Position.z-Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassPosition.z;
Torque.x+=dr.y*Force.z-dr.z*Force.y;
Torque.y+=dr.z*Force.x-dr.x*Force.z;
Torque.z+=dr.x*Force.y-dr.y*Force.x;
}
BuildRotationMatrix(&M,Adsorbates[CurrentSystem][i].Groups[l].Quaternion);
// angular velocity at time step n (first guess)
op=Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity;
inv=Components[Type].Groups[l].InverseInertiaVector;
inertia=Components[Type].Groups[l].InertiaVector;
for(j=0;j<5;j++)
{
tr.x=(Torque.x*M.ax+Torque.y*M.bx+Torque.z*M.cx)*inv.x
+(inertia.y-inertia.z)*op.y*op.z*inv.x;
tr.y=(Torque.x*M.ay+Torque.y*M.by+Torque.z*M.cy)*inv.y
+(inertia.z-inertia.x)*op.z*op.x*inv.y;
tr.z=(Torque.x*M.az+Torque.y*M.bz+Torque.z*M.cz)*inv.z
+(inertia.x-inertia.y)*op.x*op.y*inv.z;
}
// angular velocity at time step n+1/2
Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.x+=DeltaT*tr.x;
Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.y+=DeltaT*tr.y;
Adsorbates[CurrentSystem][i].Groups[l].AngularVelocity.z+=DeltaT*tr.z;
// rotational kinetic energy
UAdsorbateRotationalKinetic[CurrentSystem]+=
0.5*(inertia.x*SQR(op.x)+inertia.y*SQR(op.y)+inertia.z*SQR(op.z));
}
}
}
// translational motion
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].TotalNumberOfAtoms;i++)
{
Mass=PseudoAtoms[Framework[CurrentSystem].Atoms[0][i].Type].Mass;
Force=Framework[CurrentSystem].Atoms[0][i].Force;
// centre of mass velocities at half-step to compute the kinetic energy
tmp=0.5*DeltaT/Mass;
Velocity.x=Framework[CurrentSystem].Atoms[0][i].Velocity.x+tmp*Force.x;
Velocity.y=Framework[CurrentSystem].Atoms[0][i].Velocity.y+tmp*Force.y;
Velocity.z=Framework[CurrentSystem].Atoms[0][i].Velocity.z+tmp*Force.z;
UKinetic[CurrentSystem]+=0.5*Mass*(SQR(Velocity.x)+SQR(Velocity.y)+SQR(Velocity.z));
// advance velocity by leapfrog
tmp=DeltaT/Mass;
Framework[CurrentSystem].Atoms[0][i].Velocity.x+=tmp*Force.x;
Framework[CurrentSystem].Atoms[0][i].Velocity.y+=tmp*Force.y;
Framework[CurrentSystem].Atoms[0][i].Velocity.z+=tmp*Force.z;
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Mass=Components[Adsorbates[CurrentSystem][i].Type].Mass;
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)
{
Force.x=Force.y=Force.z=0.0;
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Force.x+=Adsorbates[CurrentSystem][i].Atoms[A].Force.x;
Force.y+=Adsorbates[CurrentSystem][i].Atoms[A].Force.y;
Force.z+=Adsorbates[CurrentSystem][i].Atoms[A].Force.z;
}
// centre of mass velocities at half-step to compute the kinetic energy
tmp=0.5*DeltaT/Mass;
Velocity.x=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.x+tmp*Force.x;
Velocity.y=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.y+tmp*Force.y;
Velocity.z=Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.z+tmp*Force.z;
UKinetic[CurrentSystem]+=0.5*Mass*(SQR(Velocity.x)+SQR(Velocity.y)+SQR(Velocity.z));
// advance velocity by leapfrog
tmp=DeltaT/Mass;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.x+=tmp*Force.x;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.y+=tmp*Force.y;
Adsorbates[CurrentSystem][i].Groups[l].CenterOfMassVelocity.z+=tmp*Force.z;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
A=Components[Type].Groups[l].Atoms[j];
Mass=PseudoAtoms[Components[Type].Type[A]].Mass;
Force=Adsorbates[CurrentSystem][i].Atoms[A].Force;
// centre of mass velocities at half-step to compute the kinetic energy
tmp=0.5*DeltaT/Mass;
Velocity.x=Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x+tmp*Force.x;
Velocity.y=Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y+tmp*Force.y;
Velocity.z=Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z+tmp*Force.z;
UKinetic[CurrentSystem]+=0.5*Mass*(SQR(Velocity.x)+SQR(Velocity.y)+SQR(Velocity.z));
// advance velocity by leapfrog
tmp=DeltaT/Mass;
Adsorbates[CurrentSystem][i].Atoms[A].Velocity.x+=tmp*Force.x;
Adsorbates[CurrentSystem][i].Atoms[A].Velocity.y+=tmp*Force.y;
Adsorbates[CurrentSystem][i].Atoms[A].Velocity.z+=tmp*Force.z;
}
}
}
}
ConservedEnergy[CurrentSystem]=
UTotal[CurrentSystem]+
UKinetic[CurrentSystem]+
UNoseHoover[CurrentSystem]+
UNoseHooverAdsorbates[CurrentSystem]+
UNoseHooverCations[CurrentSystem]+
UNoseHooverFramework[CurrentSystem];
}
REAL NumericalElectrostaticPotential(VECTOR pos)
{
REAL U1,U2;
REAL charge1,charge2;
int type1,type2;
int nr;
nr=32;
CurrentSystem=0;
Adsorbates[CurrentSystem][nr].Atoms[0].Position=pos;
type1=ReturnPseudoAtomNumber("TEST1");
Adsorbates[CurrentSystem][nr].Atoms[0].Type=type1;
charge1=PseudoAtoms[type1].Charge1;
CalculateEnergy();
U1=UTotal[0];
type2=ReturnPseudoAtomNumber("TEST2");
Adsorbates[CurrentSystem][nr].Atoms[0].Type=type2;
charge2=PseudoAtoms[type2].Charge1;
CalculateEnergy();
U2=UTotal[0];
return (U2-U1)/(charge2-charge1);
}
void TestElectrostaticPotential(void)
{
int i;
REAL U;
VECTOR pos;
for(i=0;i<200;i++)
{
pos.x=RandomNumber()*Box[CurrentSystem].ax;
pos.y=RandomNumber()*Box[CurrentSystem].by;
pos.z=RandomNumber()*Box[CurrentSystem].cz;
U=0.0;
//U+=EwaldFourierElectrostaticPotential(pos);
U+=CalculateFrameworkElectrostaticPotential(pos);
U+=CalculateInterChargeElectrostaticPotential(pos);
fprintf(stderr, "(%g,%g,%g) Final U= %18.10f <-> %18.10f\n",pos.x,pos.y,pos.z,U*ENERGY_TO_KELVIN,NumericalElectrostaticPotential(pos)*ENERGY_TO_KELVIN);
}
}
/*************************************************************************************************************
The MIT License
Copyright (C) 2006-2019 David Dubbeldam, Sofia Calero, Thijs Vlugt, Donald E. Ellis, and Randall Q. Snurr.
D.Dubbeldam@uva.nl http://www.uva.nl/profiel/d/u/d.dubbeldam/d.dubbeldam.html
scaldia@upo.es http://www.upo.es/raspa/
t.j.h.vlugt@tudelft.nl http://homepage.tudelft.nl/v9k6y
don-ellis@northwestern.edu http://dvworld.northwestern.edu/
snurr@northwestern.edu http://zeolites.cqe.northwestern.edu/
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************************************************/
void ComputeKineticEnergySystem(void)
{
int i,j,l,f1;
int Type,A;
REAL Mass;
VECTOR I,Velocity;
QUATERNION p,q;
INT_VECTOR3 Fixed;
UHostKinetic[CurrentSystem]=0.0;
if(Framework[CurrentSystem].FrameworkModel==FLEXIBLE)
{
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
if(Framework[CurrentSystem].FrameworkModels[f1]==FLEXIBLE)
{
for(i=0;i<Framework[CurrentSystem].NumberOfAtoms[f1];i++)
{
Mass=PseudoAtoms[Framework[CurrentSystem].Atoms[f1][i].Type].Mass;
if(!Framework[CurrentSystem].Atoms[f1][i].Fixed.x)
UHostKinetic[CurrentSystem]+=0.5*Mass*SQR(Framework[CurrentSystem].Atoms[f1][i].Velocity.x);
if(!Framework[CurrentSystem].Atoms[f1][i].Fixed.y)
UHostKinetic[CurrentSystem]+=0.5*Mass*SQR(Framework[CurrentSystem].Atoms[f1][i].Velocity.y);
if(!Framework[CurrentSystem].Atoms[f1][i].Fixed.z)
UHostKinetic[CurrentSystem]+=0.5*Mass*SQR(Framework[CurrentSystem].Atoms[f1][i].Velocity.z);
}
}
}
}
UAdsorbateTranslationalKinetic[CurrentSystem]=0.0;
UAdsorbateRotationalKinetic[CurrentSystem]=0.0;
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
Type=Adsorbates[CurrentSystem][i].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid)