/*************************************************************************************************************
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 <stdbool.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <float.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>
#include "molecule.h"
#include "framework.h"
#include "simulation.h"
#include "ewald.h"
#include "potentials.h"
#include "utils.h"
#include "output.h"
#include "input.h"
#include "cbmc.h"
#include "mc_moves.h"
#include "ewald.h"
#include "grids.h"
#include "spacegroup.h"
#include "recrossing.h"
#include "movies.h"
#include "utils.h"
#include "sample.h"
#include "spectra.h"
#include "rigid.h"
#include "integration.h"
#include "statistics.h"
#include "thermo_baro_stats.h"
#include "equations_of_state.h"
#include "inter_energy.h"
#include "minimization.h"
#include "scattering_factors.h"
#include "framework_force.h"
#include "warnings.h"
#include "internal_force.h"
#include "status.h"
#include "charge_equilibration.h"
int EwaldAutomatic;
int RemoveFractionalMoleculesFromRestartFile;
static int *read_frameworks;
static int *InitializeBox;
int VolumeChangeDirection=7;
int IsActiveAtomType(int type)
{
int i;
for(i=0;i<NumberOfActiveAtomTypes;i++)
if(ReturnPseudoAtomNumber(ActiveAtomTypes[i])==type) return TRUE;
return FALSE;
}
int IsFixedAtomType(int type)
{
int i;
for(i=0;i<NumberOfFixedAtomTypes;i++)
if(ReturnPseudoAtomNumber(FixedAtomTypes[i])==type) return TRUE;
return FALSE;
}
void CheckConstraintInputFramework(FRAMEWORK_COMPONENT* framework,int framework_nr,int atom_nr)
{
if(framework[CurrentSystem].NumberOfFrameworks==0)
{
fprintf(stderr, "Error: framework constraint definition, framework does not exist.\n");
exit(0);
}
if(framework_nr>=Framework[CurrentSystem].NumberOfFrameworks)
{
fprintf(stderr, "Error: framework constraint definition, framework id %d does not exist.\n",framework_nr);
exit(0);
}
if(atom_nr>=Framework[CurrentSystem].NumberOfAtoms[framework_nr])
{
fprintf(stderr, "Error: framework constraint definition, framework-atom %d of framework %d does not exist.\n",atom_nr,framework_nr);
exit(0);
}
}
void CheckConstraintInputAdsorbate(ADSORBATE_MOLECULE** adsorbates,int molecule_nr,int atom_nr)
{
if(!adsorbates[CurrentSystem])
{
fprintf(stderr, "Error: adsorbate constraint definition, adsorbate-list does not exist.\n");
exit(0);
}
if(molecule_nr>=NumberOfAdsorbateMolecules[CurrentSystem])
{
fprintf(stderr, "Error: adsorbate constraint definition, adsorbate-molecule id %d does not exist.\n",molecule_nr);
exit(0);
}
if(atom_nr>=adsorbates[CurrentSystem][molecule_nr].NumberOfAtoms)
{
fprintf(stderr, "Error: adsorbate constraint definition, adsorbate-atom %d of molecule %d does not exist.\n",atom_nr,molecule_nr);
exit(0);
}
}
void CheckConstraintInputCation(CATION_MOLECULE** cations,int molecule_nr,int atom_nr)
{
if(!cations[CurrentSystem])
{
fprintf(stderr, "Error: cation constraint definition, cation-list does not exist.\n");
exit(0);
}
if(molecule_nr>=NumberOfCationMolecules[CurrentSystem])
{
fprintf(stderr, "Error: cation constraint definition, cation-molecule id %d does not exist.\n",molecule_nr);
exit(0);
}
if(atom_nr>=Cations[CurrentSystem][molecule_nr].NumberOfAtoms)
{
fprintf(stderr, "Error: cations constraint definition, cation-atom %d of molecule %d does not exist.\n",atom_nr,molecule_nr);
exit(0);
}
}
// Reads at most 'length-1' characters from a file into a buffer
// The character sequence is zero-terminated
// more characters then the line are discarded
char *ReadLine(char *buffer, size_t length, FILE *file)
{
char *p;
size_t last;
if((p=fgets(buffer,length,file)))
{
last=strlen(buffer)-1;
if(buffer[last]=='\n')
buffer[last]='\0'; // discard the trailing newline
else
{
fscanf(file,"%*[^\n]");
(void) fgetc(file); // discard the newline
}
}
return p;
}
// Loads the contents of a file specified by `path` into a string
char* LoadFile(char *path)
{
char *buffer=0;
long length;
FILE *FilePtr;
if(!(FilePtr=fopen(path, "r")))
{
printf("Error opening input-file '%s' (routine int LoadFile(char *path))\n", path);
return NULL;
}
fseek(FilePtr, 0, SEEK_END);
length = ftell(FilePtr);
fseek(FilePtr, 0, SEEK_SET);
buffer = malloc(length);
if (buffer)
fread(buffer, 1, length, FilePtr);
fclose(FilePtr);
return buffer;
}
// Load the contents of a file into an in-memory buffer and pass to the parser
// (Separating file reading from parsing exposes useful functionality)
int ReadInputFile(char *filename)
{
return ReadInput(LoadFile(filename));
}
// Reads the input and parses the options
// * all string are converted to lowercase
// * leading spaces are removed
// * line-input after a parsed command is ignored
int ReadInput(char *input)
{
int i,j,k,l,m,n,index,nr_sites;
int Restart,RestartStyle,Type;
int StartingBead,Swapable,A1,B1;
char string[1024],keyword[1024],firstargument[1024],arguments[16384];
char *line,*tokptr,*arg_pointer,*tmp;
REAL det,r;
REAL A,B,C,tempd;
int temp_int;
REAL temp_real;
double Wavelength;
int f1,f2;
VECTOR posf1,posf2,dr,s;
int intinput1,intinput2,intinput3,intinput4,intinput5,intinput6,intinput7,intinput8,intinput9,intinput10,intinput11,intinput12;
char charinput1,charinput2,charinput3,charinput4,charinput5,charinput6;
REAL realinput1,realinput2;
int LineNumber;
int CurrentPrism,CurrentCylinder,CurrentSphere;
int NumberOfCFBiasingFactors;
REAL OverlapDistance;
int CurrentReaction;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
int CurrentAlchReaction;
//-------------------------------------------------------------------
int typeA,typeB;
int atom1,atom2;
int CFMoleculePresent=FALSE;
CurrentReaction=0;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
CurrentAlchReaction=0;
//-------------------------------------------------------------------
RXMCLambdaHistogramSize=21;
MeasureLambdaBelow=10.0;
RemoveFractionalMoleculesFromRestartFile=FALSE;
NumberOfFixedAtomTypes=0;
NumberOfActiveAtomTypes=0;
FixedAtomTypes=NULL;
ActiveAtomTypes=NULL;
CurrentPrism=0;
CurrentCylinder=0;
CurrentSphere=0;
CreateTinkerInput=FALSE;
CreateDlpolyInput=FALSE;
// not set, means get the random seed from the system time
seed=0lu;
UseReducedUnits=FALSE;
therm_baro_stats.UseExternalStress=FALSE;
Dimension=3;
UseTabularGrid=FALSE;
Swapable=FALSE;
Type=0;
MaxNumberOfBeads=0;
MaxNumberOfBonds=0;
MaxNumberOfUreyBradleys=0;
MaxNumberOfTorsions=0;
MaxNumberOfImproperTorsions=0;
MaxNumberOfOutOfPlanes=0;
MaxNumberOfIntraVDW=0;
MaxNumberOfIntraChargeCharge=0;
MaxNumberOfIntraChargeBondDipole=0;
MaxNumberOfIntraBondDipoleBondDipole=0;
CurrentIsothermPressure=0;
NumberOfIsothermPressures=0;
ComputeHessian=HESSIAN_ANALYTICAL;
ComputeLambda=LAMBDA_METHOD_2;
MinimizationVariables=CARTESIAN;
UseSymmetryInMinimization=FALSE;
RemoveTranslationFromHessian=FALSE;
RemoveRotationFromHessian=FALSE;
MaximumStepLength=0.3;
MaximumStepLengthInput=0.3;
MinimizationConvergenceFactor=1.0;
NumberOfElementsDistanceHistogram=200;
MaxRangeDistanceHistogram=12.0;
WriteVTKGrids=FALSE;
DensityAveragingTypeVTK=VTK_FULL_BOX;
FreeEnergyAveragingTypeVTK=VTK_FULL_BOX;
AverageDensityOverUnitCellsVTK=TRUE;
VTKFractionalFrameworkAtomsMin.x=VTKFractionalFrameworkAtomsMin.y=VTKFractionalFrameworkAtomsMin.z=-0.001;
VTKFractionalFrameworkAtomsMax.x=VTKFractionalFrameworkAtomsMax.y=VTKFractionalFrameworkAtomsMax.z=1.001;
VTKFractionalFrameworkBondsMin.x=VTKFractionalFrameworkBondsMin.y=VTKFractionalFrameworkBondsMin.z=-0.151;
VTKFractionalFrameworkBondsMax.x=VTKFractionalFrameworkBondsMax.y=VTKFractionalFrameworkBondsMax.z=1.151;
VTKFractionalAdsorbateComMin.x=VTKFractionalAdsorbateComMin.y=VTKFractionalAdsorbateComMin.z=-0.101;
VTKFractionalAdsorbateComMax.x=VTKFractionalAdsorbateComMax.y=VTKFractionalAdsorbateComMax.z=1.101;
VTKFractionalCationComMin.x=VTKFractionalCationComMin.y=VTKFractionalCationComMin.z=-0.101;
VTKFractionalCationComMax.x=VTKFractionalCationComMax.y=VTKFractionalCationComMax.z=1.101;
MovieScale=1.0;
WritePseudoAtomsToOutput=TRUE;
WriteForcefieldToOutput=TRUE;
WriteMoleculeDefinitionToOutput=TRUE;
Restart=FALSE;
RestartStyle=RASPA_STYLE;
Wavelength=0.0;
PrintPropertiesEvery=10000;
PrintEvery=5000;
OptimizeAcceptenceEvery=5000;
OptimizeVolumeChange=TRUE;
OptimizeGibbsVolumeChange=TRUE;
OptimizeTranslation=TRUE;
OptimizeRotation=TRUE;
OptimizeFrameworkChange=TRUE;
OptimizeFrameworkShift=TRUE;
OptimizeCFLambdaChange=TRUE;
OptimizeCFGibbsLambdaChange=TRUE;
OptimizeCBCFLambdaChange=TRUE;
OptimizeCBCFGibbsLambdaChange=TRUE;
OptimizeRXMCLambdaChange=TRUE;
VolumeChangeDirection=7;
// default values for the restart-file
ContinueAfterCrash=FALSE;
WriteBinaryRestartFileEvery=0;
// default values for equations-of-state
MultiComponentMixingRules=VAN_DER_WAALS_MIXING_RULES;
EquationOfState=PENG_ROBINSON;
// default values for CBMC
BiasingMethod=LJ_BIASING;
MinimumInnerCycles=20;
NumberOfTrialPositions=10;
NumberOfTrialPositionsForTheFirstBead=10;
NumberOfTrialPositionsTorsion=100;
NumberOfTrialMovesPerOpenBead=150;
NumberOfTrialPositionsReinsertion=10;
NumberOfTrialPositionsPartialReinsertion=10;
NumberOfTrialPositionsIdentityChange=10;
NumberOfTrialPositionsGibbs=10;
NumberOfTrialPositionsSwap=10;
NumberOfTrialPositionsWidom=10;
NumberOfTrialPositionsForTheFirstBeadReinsertion=10;
NumberOfTrialPositionsForTheFirstBeadPartialReinsertion=10;
NumberOfTrialPositionsForTheFirstBeadIdentityChange=10;
NumberOfTrialPositionsForTheFirstBeadGibbs=10;
NumberOfTrialPositionsForTheFirstBeadSwap=10;
NumberOfTrialPositionsForTheFirstBeadWidom=10;
EnergyOverlapCriteria=1.0e7;
MinimumRosenbluthFactor=1.0e-150;
TargetAccRatioSmallMCScheme=0.4;
TargetAccRatioTranslation=0.5;
TargetAccRatioRotation=0.5;
TargetAccRatioLambdaChange=0.5;
TargetAccRatioVolumeChange=0.5;
TargetAccRatioBoxShapeChange=0.5;
TargetAccRatioGibbsVolumeChange=0.5;
TargetAccRatioReactionLambdaChange=0.5;
BlockGridPockets=TRUE;
BlockGridPores=FALSE;
BlockEnergyGridOverlapCriteria=EnergyOverlapCriteria/5.0;
// default value for the cut-off
OverlapDistance=1.0;
OverlapDistanceSquared=1.0;
CutOffVDW=12.0;
InverseCutOffVDW=1.0/CutOffVDW;
CutOffVDWSquared=SQR(CutOffVDW);
CutOffChargeBondDipole=12.0;
CutOffChargeBondDipoleSquared=SQR(CutOffChargeBondDipole);
CutOffBondDipoleBondDipole=12.0;
CutOffBondDipoleBondDipoleSquared=SQR(CutOffBondDipoleBondDipole);
CutOffIons=2.0;
CutOffVDWSwitch=0.0;
CutOffChargeBondDipoleSwitch=0.0;
CutOffBondDipoleBondDipoleSwitch=0.0;
// tail-corrections do not apply on shifted potentials
ShiftPotentials=TRUE;
TailCorrections=FALSE;
// default values for the Ewald-summation
ChargeMethod=EWALD;
SymmetrizeFrameworkCharges=TRUE;
ChargeEquilibrationPeriodic=TRUE;
ChargeEquilibrationEwald=TRUE;
ChargeFromChargeEquilibration=FALSE;
ChargeEquilibrationMethod=WILMER_SNURR;
EwaldPrecision=1e-6;
EwaldAutomatic=TRUE;
DielectricConstantOfTheMedium=1.0;
OmitAdsorbateAdsorbateVDWInteractions=FALSE;
OmitAdsorbateAdsorbateCoulombInteractions=FALSE;
OmitCationCationVDWInteractions=FALSE;
OmitCationCationCoulombInteractions=FALSE;
OmitEwaldFourier=FALSE;
ComputePolarization=FALSE;
PolarizationMatrix=ISOTROPIC;
BackPolarization=FALSE;
NumberOfBackPolarizationSteps=7;
OmitIntraFrameworkPolarization=TRUE;
OmitAdsorbateAdsorbatePolarization=TRUE;
OmitCationCationPolarization=TRUE;
SampleEveryInfraRed=1;
NumberOfBlockElementsMSDOrderN=25;
MaxNumberOfBlocksMSDOrderN=25;
ComputeIndividualMSDOrderN=FALSE;
ComputeSiteTypeMSDOrderN=FALSE;
ComputeMSDOrderNPerPseudoAtom=FALSE;
NumberOfBlockElementsVACFOrderN=10;
MaxNumberOfBlocksVACFOrderN=5000;
ComputeIndividualVACFOrderN=FALSE;
ComputeVACFOrderNPerPseudoAtom=FALSE;
NumberOfBlockElementsRVACFOrderN=10;
MaxNumberOfBlocksRVACFOrderN=5000;
ComputeIndividualRVACFOrderN=FALSE;
ComputeRVACFOrderNPerPseudoAtom=FALSE;
NumberOfBlockElementsMolecularOrientationOrderN=10;
MaxNumberOfBlocksMolecularOrientationOrderN=5000;
NumberOfBlockElementsBondOrientationOrderN=25;
MaxNumberOfBlocksBondOrientationOrderN=5000;
NumberOfBuffersMSD=20;
BufferLengthMSD=5000;
NumberOfBuffersVACF=20;
BufferLengthVACF=5000;
ParallelMolFractionComponentA=0;
ParallelMolFractionComponentB=1;
// default values for the spacing in Angstrom of grid points
SpacingVDWGrid=0.15;
SpacingCoulombGrid=0.15;
AsymmetricIons=FALSE;
CorrectNetChargeOnPseudoAtom=-1;
DensityProfile3DVTKGridPoints.x=150;
DensityProfile3DVTKGridPoints.y=150;
DensityProfile3DVTKGridPoints.z=150;
WidomParticleInsertionComponent=0;
ReinitializeVelocities=TRUE;
QuenchCoreShellVelocities=FALSE;
ComputePrincipleMomentsOfInertia=FALSE;
CFWangLandauEvery=5000;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
RelaxationStepsAlchemicalTransformationMove = 5;
ChemicalPotentialAlchemical = 0.0;
//-------------------------------------------------------------------
NumberOfHybridNVESteps=5;
NumberOfHybridNPHSteps=5;
NumberOfHybridNPHPRSteps=5;
therm_baro_stats.ThermostatChainLength=3;
therm_baro_stats.BarostatChainLength=3;
therm_baro_stats.NumberOfYoshidaSuzukiSteps=5;
therm_baro_stats.NumberOfRespaSteps=5;
therm_baro_stats.time_scale_parameter_thermostat=0.15;
therm_baro_stats.time_scale_parameter_barostat=0.15;
RemoveBondNeighboursFromLongRangeInteraction=TRUE;
RemoveBendNeighboursFromLongRangeInteraction=TRUE;
RemoveTorsionNeighboursFromLongRangeInteraction=FALSE;
Remove12NeighboursFromVDWInteraction=FALSE;
Remove13NeighboursFromVDWInteraction=FALSE;
Remove14NeighboursFromVDWInteraction=FALSE;
Remove12NeighboursFromChargeChargeInteraction=FALSE;
Remove13NeighboursFromChargeChargeInteraction=FALSE;
Remove14NeighboursFromChargeChargeInteraction=FALSE;
Remove11NeighboursFromChargeBondDipoleInteraction=FALSE;
Remove12NeighboursFromChargeBondDipoleInteraction=FALSE;
Remove13NeighboursFromChargeBondDipoleInteraction=FALSE;
Remove14NeighboursFromChargeBondDipoleInteraction=FALSE;
Remove12NeighboursFromBondDipoleBondDipoleInteraction=FALSE;
Remove13NeighboursFromBondDipoleBondDipoleInteraction=FALSE;
Remove14NeighboursFromBondDipoleBondDipoleInteraction=FALSE;
ImproperTorsionScanType=IMPROPER_TORSION_SCAN_GENERAL;
InternalFrameworkLennardJonesInteractions=TRUE;
ComputePowderDiffractionPattern=FALSE;
ComputeNormalModes=FALSE;
CorrectNormalModesForConstraints=TRUE;
MinimumMode=0;
MaximumMode=20;
ModeResolution=100;
MinimizationMethod=BAKER_MINIMIZATION;
MinimizationType=SEARCH_LOCAL_MINIMUM;
MinimizationPotentialMethod=ANALYTICALLY;
MaximumNumberOfMinimizationSteps=10000;
UseGradientInLineMinimization=TRUE;
RMSGradientTolerance=1e-6;
MaxGradientTolerance=1e-6;
ProbabilityFrameworkChangeMove=0.0;
ProbabilityVolumeChangeMove=0.0;
ProbabilityBoxShapeChangeMove=0.0;
ProbabilityParallelTemperingMove=0.0;
ProbabilityHyperParallelTemperingMove=0.0;
ProbabilityParallelMolFractionMove=0.0;
ProbabilityGibbsVolumeChangeMove=0.0;
ProbabilityHybridNVEMove=0.0;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
ProbabilityAlchemicalTransformationMove=0.0;
ProbabilityWidomOsmostatCalculationMove=0.0;
//-------------------------------------------------------------------
ProbabilityHybridNPHMove=0.0;
ProbabilityHybridNPHPRMove=0.0;
ProbabilityFrameworkChangeMove=0.0;
ProbabilityFrameworkShiftMove=0.0;
ProbabilityCFCRXMCLambdaChangeMove=0.0; // CFC-RXMC
// default time step is 0.5 fs
DeltaT=0.0005;
// powder diffraction defaults
Diffraction.Type=XRAY_DIFFRACTION;
Diffraction.RadiationType=COPPER_RADIATION;
Diffraction.lambda_type=DIFFRACTION_SINGLE;
Diffraction.u=0.01;
Diffraction.v=-0.001;
Diffraction.w=0.002;
Diffraction.asym=0.5;
Diffraction.two_theta_min=3.0;
Diffraction.two_theta_max=50.0;
Diffraction.two_theta_step=0.01;
Diffraction.PeakShape=DIFFRACTION_PSEUDO_VOIGT;
ComputeRattleSteps=FALSE;
DistanceConstraintType=DISTANCE_R_SQUARED;
BendConstraintType=THETA;
DihedralConstraintType=PHI;
ImproperDihedralConstraintType=PHI;
InversionBendConstraintType=CHI;
OutOfPlaneConstraintType=DISTANCE_R;
PrintFrameworkBondStatus=TRUE;
PrintFrameworkUreyBradleyStatus=TRUE;
PrintFrameworkBendStatus=TRUE;
PrintFrameworkInversionBendStatus=TRUE;
PrintFrameworkTorsionStatus=TRUE;
PrintFrameworkImproperTorsionStatus=TRUE;
PrintFrameworkBondBondStatus=TRUE;
PrintFrameworkBondBendStatus=TRUE;
PrintFrameworkBendBendStatus=TRUE;
PrintFrameworkBendTorsionStatus=TRUE;
PrintFrameworkIntraVDWStatus=TRUE;
PrintFrameworkIntraChargeChargeStatus=TRUE;
PrintFrameworkIntraChargeBondDipoleStatus=TRUE;
PrintFrameworkIntraBondDipoleBondDipoleStatus=TRUE;
PrintAdsorbateBondStatus=TRUE;
PrintAdsorbateUreyBradleyStatus=TRUE;
PrintAdsorbateBendStatus=TRUE;
PrintAdsorbateTorsionStatus=TRUE;
PrintAdsorbateImproperTorsionStatus=TRUE;
PrintAdsorbateBondBondStatus=TRUE;
PrintAdsorbateBondBendStatus=TRUE;
PrintAdsorbateBendBendStatus=TRUE;
PrintAdsorbateBondTorsionStatus=TRUE;
PrintAdsorbateBendTorsionStatus=TRUE;
PrintAdsorbateIntraVDWStatus=TRUE;
PrintAdsorbateIntraChargeChargeStatus=TRUE;
PrintAdsorbateIntraChargeBondDipoleStatus=TRUE;
PrintAdsorbateIntraBondDipoleBondDipoleStatus=TRUE;
PrintCationBondStatus=TRUE;
PrintCationUreyBradleyStatus=TRUE;
PrintCationBendStatus=TRUE;
PrintCationTorsionStatus=TRUE;
PrintCationImproperTorsionStatus=TRUE;
PrintCationBondBondStatus=TRUE;
PrintCationBondBendStatus=TRUE;
PrintCationBendBendStatus=TRUE;
PrintCationBondTorsionStatus=TRUE;
PrintCationBendTorsionStatus=TRUE;
PrintCationIntraVDWStatus=TRUE;
PrintCationIntraChargeChargeStatus=TRUE;
PrintCationIntraChargeBondDipoleStatus=TRUE;
PrintCationIntraBondDipoleBondDipoleStatus=TRUE;
PrintInterVDWStatus=TRUE;
PrintInterChargeChargeStatus=TRUE;
PrintInterChargeBondDipoleStatus=TRUE;
PrintInterBondDipoleBondDipoleStatus=TRUE;
PrintFrameworkAdsorbateVDWStatus=TRUE;
PrintFrameworkAdsorbateChargeChargeStatus=TRUE;
PrintFrameworkAdsorbateChargeBondDipoleStatus=TRUE;
PrintFrameworkAdsorbateBondDipoleBondDipoleStatus=TRUE;
PrintFrameworkCationVDWStatus=TRUE;
PrintFrameworkCationChargeChargeStatus=TRUE;
PrintFrameworkCationChargeBondDipoleStatus=TRUE;
PrintFrameworkCationBondDipoleBondDipoleStatus=TRUE;
// first pass to get NumberOfSystems and NumberOfComponents etc.
// also loof for a binary restart-file, in that case immediately return
NumberOfSystems=0;
NumberOfComponents=0;
NumberOfReactions=0;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
NumberAlchemicalReactions=0;
//-------------------------------------------------------------------
// This loops through the string line-by-line, using the reentrant form of
// `strtok` to be less ambiguous about the state of things
tmp = strdup(input);
for (line=strtok_r(tmp, "\n", &tokptr); line; line=strtok_r(NULL, "\n", &tokptr))
{
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s%[^\n]",keyword,arguments);
sscanf(arguments,"%s",firstargument);
if(strcasecmp("CreateTinkerInput",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) CreateTinkerInput=TRUE;
if(strcasecmp("no",firstargument)==0) CreateTinkerInput=FALSE;
}
if(strcasecmp("CreateDlpolyInput",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) CreateDlpolyInput=TRUE;
if(strcasecmp("no",firstargument)==0) CreateDlpolyInput=FALSE;
}
if(strcasecmp("ReducedUnits",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) UseReducedUnits=TRUE;
if(strcasecmp("no",firstargument)==0) UseReducedUnits=FALSE;
}
if(strcasecmp("Dimension",keyword)==0) sscanf(arguments,"%d",&Dimension);
// read statements for the number of systems
if(strcasecmp("Box",keyword)==0)
{
if(sscanf(arguments,"%d",&CurrentSystem))
{
if(CurrentSystem<0)
{
fprintf(stderr, "Input error in 'Box'-command: the number of the system is incorrect (%d given, 0 <= system-number\n",CurrentSystem);
exit(0);
}
NumberOfSystems++;
}
}
if(strcasecmp("BoxMatrix",keyword)==0)
{
if(sscanf(arguments,"%d",&CurrentSystem))
{
if(CurrentSystem<0)
{
fprintf(stderr, "Input error in 'BoxMatrix'-command: the number of the system is incorrect (%d given, 0 <= system-number\n",CurrentSystem);
exit(0);
}
NumberOfSystems++;
}
}
if(strcasecmp("Framework",keyword)==0)
{
if(sscanf(arguments,"%d",&CurrentSystem))
{
if(CurrentSystem<0)
{
fprintf(stderr, "Input error in 'Framework'-command: the number of the system is incorrect (%d given, 0 <= system-number\n",CurrentSystem);
exit(0);
}
NumberOfSystems++;
}
}
// read statement for the number of components
if(strcasecmp("Component",keyword)==0)
{
if(sscanf(arguments,"%d %*s %s",&CurrentComponent,string))
{
if(CurrentComponent<0)
{
fprintf(stderr, "Input error in 'Component'-command: the number of the component is incorrect (%d given, 0 <= component-number)\n",CurrentComponent);
exit(0);
}
NumberOfComponents++;
}
}
if(strcasecmp("CFCRXMCLambdaHistogramSize",keyword)==0) sscanf(arguments,"%d",&RXMCLambdaHistogramSize);
//-------------------------------------------------------------------------------------------------------------------------------------------------------
// CFC-RXMC : read statements for number of reactions
//-------------------------------------------------------------------------------------------------------------------------------------------------------
if(strcasecmp("Reaction",keyword)==0) NumberOfReactions++;
//-------------------------------------------------------------------------------------------------------------------------------------------------------
// if restarted from a binary restart file we can skip everything, and read
// the full system status from that binary restart-file
if(strcasecmp("ContinueAfterCrash",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
ContinueAfterCrash=TRUE;
// no need to reed the rest of the input file
// instead read the binary status file
ReadBinaryRestartFiles();
if(ContinueAfterCrash) return 0;
}
}
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
if(strcasecmp("AlchemicalTransformation",keyword)==0) NumberAlchemicalReactions++;
// store the index of salt ions.
if(NumberAlchemicalReactions>0)
{
SaltIndex =(int**)calloc(NumberAlchemicalReactions,sizeof(int*));
MultiplicitySalt =(int**)calloc(NumberAlchemicalReactions,sizeof(int*));
ChosenMoleculeAlchemicalTransformation =(int**)calloc(NumberAlchemicalReactions,sizeof(int*));
NumberTransientMoities =(int*)calloc(NumberAlchemicalReactions,sizeof(int));
for(i=0;i<NumberAlchemicalReactions;i++)
{
SaltIndex[i]=(int*)calloc(2,sizeof(int));
MultiplicitySalt[i]=(int*)calloc(2,sizeof(int));
}
}
//-------------------------------------------------------------------
}
// set units, either reduced or real units
SetSimulationUnits();
// 'NumberOfSystems' and 'NumberOfComponents' are known
// allocate memory for the components that depends on 'NumberOfSystems' and
// 'NumberOfComponents', and set some defaults if needed
// allocate memory
AllocateSimulationMemory();
AllocateWarningsMemory();
AllocateEquationOfStateMemory();
AllocateMovieMemory();
AllocateRecrossingMemory();
AllocateMinimizationMemory();
read_frameworks=(int*)calloc(NumberOfSystems,sizeof(REAL));
InitializeBox=(int*)calloc(NumberOfSystems,sizeof(REAL));
for(i=0;i<NumberOfSystems;i++)
{
AdsorbateFixedInitialization[i]=FREE;
CationFixedInitialization[i]=FREE;
}
for(i=0;i<NumberOfSystems;i++)
for(j=0;j<NumberOfComponents;j++)
ComputeFugacityCoefficient[i][j]=TRUE;
Framework=(FRAMEWORK_COMPONENT*)calloc(NumberOfSystems,sizeof(FRAMEWORK_COMPONENT));
crystallographic_stats=(CRYSTALLOGRAPHIC_STATISTICS*)calloc(NumberOfSystems,sizeof(CRYSTALLOGRAPHIC_STATISTICS));
for(i=0;i<NumberOfSystems;i++)
{
Framework[i].NumberOfFrameworks=0;
Framework[i].SurfaceAreaSamplingPointsPerShere=5;
strcpy(Framework[i].SurfaceAreaProbeAtom,"N_n2");
Framework[i].SurfaceAreaProbeDistance=pow(2.0,1.0/6.0);
Framework[i].RestrictFrameworkAtomsToBox=TRUE;
}
for(i=0;i<NumberOfSystems;i++)
{
CutOffChargeCharge[i]=12.0;
CutOffChargeChargeSquared[i]=SQR(CutOffChargeCharge[i]);
CutOffChargeChargeSwitch[i]=0.0;
}
UnitCellSize=(VECTOR*)calloc(NumberOfSystems,sizeof(VECTOR));
NumberOfUnitCells=(INT_VECTOR3*)calloc(NumberOfSystems,sizeof(INT_VECTOR3));
UnitCellBox=(REAL_MATRIX3x3*)calloc(NumberOfSystems,sizeof(REAL_MATRIX3x3));
InverseUnitCellBox=(REAL_MATRIX3x3*)calloc(NumberOfSystems,sizeof(REAL_MATRIX3x3));
Lowenstein=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfIsothermPressures=1;
for(i=0;i<NumberOfSystems;i++)
{
read_frameworks[i]=FALSE;
BarrierNormal[i].x=0.0;
BarrierNormal[i].y=0.0;
BarrierNormal[i].z=0.0;
MaxBarrierTime[i]=10.0;
NumberOfVelocities[i]=5;
BoundaryCondition[i]=UNINITIALIZED_BOUNDARY_CONDITION;
Ensemble[i]=NVT;
InitEnsemble[i]=NVE;
RunEnsemble[i]=NVE;
Box[i].ax=Box[i].by=Box[i].cz=25.0;
NumberOfUnitCells[i].x=1;
NumberOfUnitCells[i].y=1;
NumberOfUnitCells[i].z=1;
AlphaAngle[i]=90.0*M_PI/180.0;
BetaAngle[i]=90.0*M_PI/180.0;
GammaAngle[i]=90.0*M_PI/180.0;
Lowenstein[i]=TRUE;
}
if(NumberOfComponents>0)
Components=(COMPONENT*)calloc(NumberOfComponents,sizeof(COMPONENT));
MaxNumberOfAdsorbateMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfAdsorbateMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
MaxNumberOfCationMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfCationMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfAdsorbateMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfCationMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfFractionalMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfFractionalAdsorbateMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfFractionalCationMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfReactionMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfReactionAdsorbateMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfReactionCationMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfAtomsPerSystem=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfChargesPerSystem=(int*)calloc(NumberOfSystems,sizeof(int));
NumberOfBondDipolesPerSystem=(int*)calloc(NumberOfSystems,sizeof(int));
for(i=0;i<NumberOfComponents;i++)
{
Components[i].IdealGasRosenbluthWeight=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].IdealGasTotalEnergy=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].PartialPressure=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].FugacityCoefficient=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].BulkFluidDensity=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].Compressibility=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].MolFraction=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].AmountOfExcessMolecules=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].CreateNumberOfMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].NumberOfMolecules=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].FractionalMolecule=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].CFMoleculePresent=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].CFWangLandauScalingFactor=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].CFBiasingFactors=(REAL**)calloc(NumberOfSystems,sizeof(REAL*));
Components[i].RXMCMoleculesPresent=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].NumberOfRXMCMoleculesPresent=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].MOLEC_PER_UC_TO_MOL_PER_KG=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].MOLEC_PER_UC_TO_MILLIGRAM_PER_GRAM_OF_FRAMEWORK=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].MOLEC_PER_UC_TO_CC_STP_G=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].MOLEC_PER_UC_TO_CC_STP_CC=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].MOL_PER_KG_TO_CC_STP_G=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].MOL_PER_KG_TO_CC_STP_CC=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
Components[i].IdentityChanges=(int*)calloc(NumberOfComponents,sizeof(int));
Components[i].GibbsIdentityChanges=(int*)calloc(NumberOfComponents,sizeof(int));
Components[i].BlockPockets=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].ComputeFreeEnergyProfile=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].BlockPocketsFilename=(char(*)[256])calloc(NumberOfSystems,sizeof(char[256]));
Components[i].NumberOfBlockCenters=(int*)calloc(NumberOfSystems,sizeof(int));
Components[i].BlockDistance=(REAL**)calloc(NumberOfSystems,sizeof(REAL*));
Components[i].BlockCenters=(VECTOR**)calloc(NumberOfSystems,sizeof(VECTOR*));
Components[i].CFLambdaHistogramSize=21;
for(j=0;j<NumberOfSystems;j++)
{
Components[i].BlockPockets[j]=FALSE;
Components[i].ComputeFreeEnergyProfile[j]=FALSE;
Components[i].IdealGasRosenbluthWeight[j]=1.0;
Components[i].IdealGasTotalEnergy[j]=0.0;
Components[i].FugacityCoefficient[j]=-1.0;
Components[i].MolFraction[j]=1.0;
// start with no defined fractional molecule
Components[i].FractionalMolecule[j]=-1;
Components[i].CFMoleculePresent[j]=FALSE;
Components[i].CFWangLandauScalingFactor[j]=0.01;
}
strcpy(Components[i].MoleculeDefinition,"TraPPE");
strcpy(Components[i].Name,"");
Components[i].Swapable=FALSE;
Components[i].Widom=FALSE;
// initialize box restriction to false (the full box is selected)
Components[i].RestrictMoves=FALSE;
// initialize the first box to all, the other 3 boxes to empty
Components[i].RestrictMovesToBox=FALSE;
Components[i].BoxAxisABC_Min.x=Components[i].BoxAxisABC_Min.y=Components[i].BoxAxisABC_Min.z=0.0;
Components[i].BoxAxisABC_Max.x=Components[i].BoxAxisABC_Max.y=Components[i].BoxAxisABC_Max.z=1.0;
Components[i].BoxAxisABC_Min2.x=Components[i].BoxAxisABC_Min2.y=Components[i].BoxAxisABC_Min2.z=1.0;
Components[i].BoxAxisABC_Max2.x=Components[i].BoxAxisABC_Max2.y=Components[i].BoxAxisABC_Max2.z=0.0;
Components[i].BoxAxisABC_Min3.x=Components[i].BoxAxisABC_Min3.y=Components[i].BoxAxisABC_Min3.z=1.0;
Components[i].BoxAxisABC_Max3.x=Components[i].BoxAxisABC_Max3.y=Components[i].BoxAxisABC_Max3.z=0.0;
Components[i].BoxAxisABC_Min4.x=Components[i].BoxAxisABC_Min4.y=Components[i].BoxAxisABC_Min4.z=1.0;
Components[i].BoxAxisABC_Max4.x=Components[i].BoxAxisABC_Max4.y=Components[i].BoxAxisABC_Max4.z=0.0;
Components[i].RestrictMovesToPrisms=FALSE;
for(j=0;j<MAX_NUMBER_OF_PRISMS;j++)
{
Components[i].RestrictMovesToPrism[j]=FALSE;
Components[i].RestrictPrismABC_Min[j].x=0.0;
Components[i].RestrictPrismABC_Max[j].x=1.0;
}
Components[i].RestrictMovesToCylinders=FALSE;
for(j=0;j<MAX_NUMBER_OF_CYLINDERS;j++)
{
Components[i].RestrictMovesToCylinder[j]=FALSE;
Components[i].RestrictCylinderABC_Min[j].x=0.0;
Components[i].RestrictCylinderABC_Max[j].x=1.0;
Components[i].RestrictCylinderABC_Min[j].y=0.0;
Components[i].RestrictCylinderABC_Max[j].y=1.0;
Components[i].RestrictCylinderABC_Min[j].z=0.0;
Components[i].RestrictCylinderABC_Max[j].z=1.0;
Components[i].RestrictCylinderCenter[j].x=0.0;
Components[i].RestrictCylinderCenter[j].y=0.5;
Components[i].RestrictCylinderCenter[j].z=0.5;
Components[i].RestrictCylinderDirection[j]=X_DIR;
Components[i].RestrictCylinderRadius[j]=5.0;
}
Components[i].RestrictMovesToSpheres=FALSE;
for(j=0;j<MAX_NUMBER_OF_SPHERES;j++)
{
Components[i].RestrictMovesToSphere[j]=FALSE;
Components[i].RestrictSphereCenter[j].x=0.5;
Components[i].RestrictSphereCenter[j].y=0.5;
Components[i].RestrictSphereCenter[j].z=0.5;
Components[i].RestrictSphereRadius[j]=5.0;
}
Components[i].RuizMonteroFactor=1.0;
Components[i].UmbrellaFactor=1.0;
Components[i].InvertBlockPockets=FALSE;
Components[i].Intra14VDWScalingValue=1.0;
Components[i].Intra14ChargeChargeScalingValue=1.0;
Components[i].AnisotropicType=ANISOTROPIC_MID_POINT;
Components[i].BiasingDirection=A_MAPPING;
}
Alpha=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
kvec=(INT_VECTOR3*)calloc(NumberOfSystems,sizeof(INT_VECTOR3));
NumberOfKVectors=(int*)calloc(NumberOfSystems,sizeof(int));
ReciprocalCutOffSquared=(REAL*)calloc(NumberOfSystems,sizeof(REAL));
ReactantsStoichiometry=(int**)calloc(NumberOfReactions,sizeof(int*));
ProductsStoichiometry=(int**)calloc(NumberOfReactions,sizeof(int*));
for(i=0;i<NumberOfReactions;i++)
{
ReactantsStoichiometry[i]=(int*)calloc(NumberOfComponents,sizeof(int));
ProductsStoichiometry[i]=(int*)calloc(NumberOfComponents,sizeof(int));
}
for(i=0;i<NumberOfSystems;i++)
for(l=0;l<NumberOfReactions;l++)
CFRXMCWangLandauScalingFactor[i][l]=0.01;
// second pass to get the number of frameworks per system
CurrentSystem=0;
CurrentComponent=0;
tmp = strdup(input);
tokptr = 0;
for (line=strtok_r(tmp, "\n", &tokptr); line; line=strtok_r(NULL, "\n", &tokptr))
{
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s%[^\n]",keyword,arguments);
sscanf(arguments,"%s",firstargument);
if(strcasecmp("Framework",keyword)==0)
{
sscanf(arguments,"%d",&CurrentSystem);
if(CurrentSystem>=NumberOfSystems)
{
fprintf(stderr, "Input error in 'Framework'-command: the number of the system is incorrect (%d given, 0 <= system-number < %d)\n",CurrentSystem,NumberOfSystems);
exit(0);
}
}
if(strcasecmp("FrameworkName",keyword)==0)
Framework[CurrentSystem].NumberOfFrameworks++;
if(strcasecmp("ExternalPressure",keyword)==0)
{
arg_pointer=arguments;
NumberOfIsothermPressures=0;
while(sscanf(arg_pointer,"%lf%n",&tempd,&n)==1)
{
arg_pointer+=n;
NumberOfIsothermPressures++;
}
}
// read statement for the number of components
if(strcasecmp("Component",keyword)==0)
{
if(sscanf(arguments,"%d %*s %s",&CurrentComponent,string))
{
if(CurrentComponent<0)
{
fprintf(stderr, "Input error in 'Component'-command: the number of the component is incorrect (%d given, 0 <= component-number)\n",CurrentComponent);
exit(0);
}
}
}
if(strcasecmp("CFLambdaHistogramSize",keyword)==0) sscanf(arguments,"%d",&Components[CurrentComponent].CFLambdaHistogramSize);
if(strcasecmp("CFRXMCWangLandauScalingFactor",keyword)==0)
{
sscanf(arguments,"%d",&temp_int);
for(i=0;i<NumberOfSystems;i++)
for(l=0;l<NumberOfReactions;l++)
CFRXMCWangLandauScalingFactor[i][l]=temp_int;
}
}
AllocateThermoBaroStatMemory();
AllocateSampleMemory();
NumberOfIsothermPressures=1;
for(i=0;i<NumberOfSystems;i++)
{
for(j=0;j<NumberOfComponents;j++)
{
Components[j].CFBiasingFactors[i]=(REAL*)calloc(Components[j].CFLambdaHistogramSize,sizeof(REAL));
// starting bias-factor for CF are zero
for(k=0;k<Components[j].CFLambdaHistogramSize;k++)
Components[j].CFBiasingFactors[i][k]=0.0;
}
ReciprocalCutOffSquared[i]=-1.0;
therm_baro_stats.ExternalTemperature[i]=298.0;
therm_baro_stats.ExternalSurfaceTension[i].x=0.0;
therm_baro_stats.ExternalSurfaceTension[i].x=0.0;
therm_baro_stats.ExternalSurfaceTension[i].x=0.0;
Movies[i]=FALSE;
WriteMoviesEvery[i]=1000;
// sampling the radial distribution function (RDF)
ComputeRDF[i]=FALSE;
WriteRDFEvery[i]=5000;
RDFHistogramSize[i]=500;
RDFRange[i]=12.0;
// sampling the projected lengths
ComputeProjectedLengths[i]=FALSE;
WriteProjectedLengthsEvery[i]=5000;
ProjectedLengthsHistogramSize[i]=500;
ProjectedLengthsRange[i]=12.0;
// sampling the projected angles
ComputeProjectedAngles[i]=FALSE;
WriteProjectedAnglesEvery[i]=5000;
ProjectedAnglesHistogramSize[i]=500;
ProjectedAnglesRange[i]=180.0;
//----------------------------------------------------------------------------
// CFC-RXMC : sampling lambda histogram
//----------------------------------------------------------------------------
ComputeCFCRXMCLambdaHistogram[i]=FALSE;
WriteCFCRXMCLambdaHistogramEvery[i]=5000;
CFCRXMCLambdaHistogramBins[i]=10;
//----------------------------------------------------------------------------
// sampling the number-of-molecules histogram
ComputeNumberOfMoleculesHistogram[i]=FALSE;
WriteNumberOfMoleculesHistogramEvery[i]=5000;
NumberOfMoleculesRange[i]=500.0;
NumberOfMoleculesHistogramSize[i]=1000;
// sampling position histograms/free energies
ComputePositionHistogram[i]=FALSE;
WritePositionHistogramEvery[i]=5000;
PositionHistogramSize[i]=1000;
PositionHistogramMappingType[i]=ABC_MAPPING;
// samples the free energy profiles in a,b,c directions
ComputeFreeEnergyProfile[i]=FALSE;
WriteFreeEnergyProfileEvery[i]=5000;
FreeEnergyHistogramSize[i]=1800;
FreeEnergyMappingType[i]=ABC_MAPPING;
// sampling the pore-size distribution (PSD)
ComputePSDHistogram[i]=FALSE;
WritePSDHistogramEvery[i]=1000;
PSDHistogramSize[i]=200;
PSDRange[i]=10.0;
// sampling the end-to-end histograms
ComputeEndToEndDistanceHistogram[i]=FALSE;
WriteEndToEndDistanceHistogramEvery[i]=5000;
EndToEndHistogramSize[i]=1000;
EndToEndRange[i]=30.0;
// sampling the energy histogram
WriteEnergyHistogramEvery[i]=5000;
EnergyHistogramLowerLimit[i]=-1e4;
EnergyHistogramUpperLimit[i]=0;
EnergyHistogramSize[i]=1000;
// sampling the thermodynamic factor
ComputeThermoDynamicFactor[i]=FALSE;
WriteThermoDynamicFactorEvery[i]=5000;
// sampling the inter-framework spacing histogram
ComputeFrameworkSpacingHistogram[i]=FALSE;
WriteFrameworkSpacingHistogramEvery[i]=5000;
FrameworkSpacingHistogramSize[i]=1000;
FrameworkSpacingRange[i]=10.0;
// sampling histograms of the residence times
ComputeResidenceTimes[i]=FALSE;
WriteResidenceTimesEvery[i]=5000;
ResidenceTimesHistogramSize[i]=200;
RangeResidenceTimes[i]=500.0; // 0.5 nanosecond
// sampling histograms of the distance between 2 selected atoms
ComputeDistanceHistograms[i]=FALSE;
WriteDistanceHistogramsEvery[i]=5000;
// sampling histograms of the bend angle between 3 selected atoms
ComputeBendAngleHistograms[i]=FALSE;
WriteBendAngleHistogramsEvery[i]=5000;
// sampling histograms of the angle between two planes (each formed by 3 chosen atoms)
ComputeDihedralAngleHistograms[i]=FALSE;
WriteDihedralAngleHistogramsEvery[i]=5000;
// sampling histograms of the dihedral angle between 4 selected atoms
ComputeAngleBetweenPlanesHistograms[i]=FALSE;
WriteAngleBetweenPlanesHistogramsEvery[i]=5000;
// sampling molecular properties (bond distance, bend angle, dihedral angle)
ComputeMoleculeProperties[i]=FALSE;
WriteMoleculePropertiesEvery[i]=5000;
BondLengthHistogramSize[i]=1000;
BendAngleHistogramSize[i]=1000;
DihedralHistogramSize[i]=1000;
BondLengthRange[i]=4.0;
BendAngleRange[i]=180.0;
DihedralRange[i]=360.0;
// sampling the IR spectra (spacings: 2048, 4196, 8192, 16384, 32768 points)
ComputeInfraRedSpectra[i]=FALSE;
WriteInfraRedSpectraEvery[i]=5000;
// sampling the mean-squared displacement using a modified order-N algorithm
ComputeMSDOrderN[i]=FALSE;
WriteMSDOrderNEvery[i]=5000;
NumberOfSitesMSDOrderN[i]=2;
SampleMSDOrderNEvery[i]=1;
// sampling the velocity autocorrelation function using a modified order-N algorithm
ComputeVACFOrderN[i]=FALSE;
WriteVACFOrderNEvery[i]=5000;
SampleVACFOrderNEvery[i]=5;
// sampling of the rotational velocity autocorrelation function using a modified order-N algorithm
ComputeRVACFOrderN[i]=FALSE;
WriteRVACFOrderNEvery[i]=5000;
SampleRVACFOrderNEvery[i]=5;
// sampling of the molecular orientation autocorrelation function using a modified order-N algorithm
ComputeMolecularOrientationOrderN[i]=FALSE;
WriteMolecularOrientationOrderNEvery[i]=5000;
SampleMolecularOrientationOrderNEvery[i]=5;
MolecularOrientationVector.x=0.0;
MolecularOrientationVector.y=1.0;
MolecularOrientationVector.z=0.0;
MolecularOrientationGroup=0;
MolecularOrientationType=END_TO_END_VECTOR;
// sampling of the bond orientation autocorrelation function using a modified order-N algorithm
ComputeBondOrientationOrderN[i]=FALSE;
WriteBondOrientationOrderNEvery[i]=5000;
SampleBondOrientationOrderNEvery[i]=10;
BondOrientationAngleHistogramSize[i]=360;
// sampling the mean-square displacement function using a conventional algorithm
ComputeMSD[i]=FALSE;
WriteMSDEvery[i]=5000;
SampleMSDEvery[i]=5;
// sampling the velocity autocorrelation function using a conventional algorithm
ComputeVACF[i]=FALSE;
WriteVACFEvery[i]=5000;
SampleVACFEvery[i]=5;
// sampling the 3D histograms of position (i.e. 3D free energy)
ComputeDensityProfile3DVTKGrid[i]=FALSE;
WriteDensityProfile3DVTKGridEvery[i]=5000;
// samples the cation sites and adsorption sites
ComputeCationAndAdsorptionSites[i]=FALSE;
WriteCationAndAdsorptionSitesEvery[i]=5000;
// samples initial configurations for the tranmission coefficient (dcTST)
WritedcTSTSnapShotsToFile[i]=FALSE;
WritedcTSTSnapShotsEvery[i]=100;
// samples pressure and stress
ComputeMolecularPressure[i]=FALSE;
}
for(i=0;i<NumberOfSystems;i++)
{
if(Framework[i].NumberOfFrameworks>0)
{
Framework[i].NumberOfCoreShells=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].Atoms=(ATOM**)calloc(Framework[i].NumberOfFrameworks,sizeof(ATOM*));
Framework[i].NumberOfAtoms=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfFixedAtoms=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfFreeAtoms=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfCharges=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfUnitCellAtoms=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfAtoms=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].FrameworkProbability=(REAL*)calloc(Framework[i].NumberOfFrameworks,sizeof(REAL));
Framework[i].AtomsAsymmetric=(FRAMEWORK_ASYMMETRIC_ATOM**)calloc(Framework[i].NumberOfFrameworks,sizeof(FRAMEWORK_ASYMMETRIC_ATOM*));
Framework[i].NumberOfAsymmetricAtoms=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].Name=(char(*)[256])calloc(Framework[i].NumberOfFrameworks,sizeof(char[256]));
Framework[i].FrameworkModels=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].ShiftUnitCell=(VECTOR*)calloc(Framework[i].NumberOfFrameworks,sizeof(VECTOR));
Framework[i].Asymmetric=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].SpaceGroupIdentifier=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].CalculateSpaceGroup=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].RemoveAtomNumberCodeFromLabel=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].AddAtomNumberCodeToLabel=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].InputFileType=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].SurfaceAreas=(REAL*)calloc(Framework[i].NumberOfFrameworks,sizeof(REAL));
Framework[i].FrameworkDensityPerComponent=(REAL*)calloc(Framework[i].NumberOfFrameworks,sizeof(REAL));
Framework[i].FrameworkMassPerComponent=(REAL*)calloc(Framework[i].NumberOfFrameworks,sizeof(REAL));
Framework[i].NumberOfCitations=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].CitationInformation=(CITATION_INFORMATION**)calloc(Framework[i].NumberOfFrameworks,sizeof(CITATION_INFORMATION*));
Framework[i].Connectivity=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].Neighbours=(int***)calloc(Framework[i].NumberOfFrameworks,sizeof(int**));
// allocate first dimension of bonds
Framework[i].NumberOfBonds=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBonds=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].Bonds=(PAIR**)calloc(Framework[i].NumberOfFrameworks,sizeof(PAIR*));
Framework[i].BondType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BondArguments=(REAL(**)[MAX_BOND_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BOND_POTENTIAL_ARGUMENTS]));
// allocate first dimension of bond-dipoles
Framework[i].NumberOfBondDipoles=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBondDipoles=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].BondDipoles=(PAIR**)calloc(Framework[i].NumberOfFrameworks,sizeof(PAIR*));
Framework[i].BondDipoleMagnitude=(REAL**)calloc(Framework[i].NumberOfFrameworks,sizeof(REAL*));
// allocate first dimension of Urey-Bradleys
Framework[i].NumberOfUreyBradleys=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfUreyBradleys=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].UreyBradleys=(TRIPLE**)calloc(Framework[i].NumberOfFrameworks,sizeof(TRIPLE*));
Framework[i].UreyBradleyType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].UreyBradleyArguments=(REAL(**)[MAX_UREYBRADLEY_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_UREYBRADLEY_POTENTIAL_ARGUMENTS]));
// allocate first dimension of bends
Framework[i].NumberOfBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].Bends=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].BendType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BendArguments=(REAL(**)[MAX_BEND_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BEND_POTENTIAL_ARGUMENTS]));
// allocate first dimension of inversion-bends
Framework[i].NumberOfInversionBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfInversionBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].InversionBends=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].InversionBendType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].InversionBendArguments=(REAL(**)[MAX_INVERSION_BEND_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_INVERSION_BEND_POTENTIAL_ARGUMENTS]));
// allocate first dimension of torsions
Framework[i].NumberOfTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].Torsions=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].TorsionType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].TorsionArguments=(REAL(**)[MAX_TORSION_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_TORSION_POTENTIAL_ARGUMENTS]));
// allocate first dimension of improper torsions
Framework[i].NumberOfImproperTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfImproperTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].ImproperTorsions=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].ImproperTorsionType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].ImproperTorsionArguments=(REAL(**)[MAX_IMPROPER_TORSION_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_IMPROPER_TORSION_POTENTIAL_ARGUMENTS]));
// allocate first dimension of out-of-plane
Framework[i].NumberOfOutOfPlanes=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfOutOfPlanes=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].OutOfPlanes=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].OutOfPlaneType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].OutOfPlaneArguments=(REAL(**)[MAX_OUT_OF_PLANE_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_OUT_OF_PLANE_POTENTIAL_ARGUMENTS]));
// allocate first dimension of bond-bond
Framework[i].NumberOfBondBonds=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBondBonds=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].BondBonds=(TRIPLE**)calloc(Framework[i].NumberOfFrameworks,sizeof(TRIPLE*));
Framework[i].BondBondType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BondBondArguments=(REAL(**)[MAX_BOND_BOND_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BOND_BOND_POTENTIAL_ARGUMENTS]));
// allocate first dimension of bond-bend
Framework[i].NumberOfBondBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBondBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].BondBends=(TRIPLE**)calloc(Framework[i].NumberOfFrameworks,sizeof(TRIPLE*));
Framework[i].BondBendType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BondBendArguments=(REAL(**)[MAX_BOND_BEND_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BOND_BEND_POTENTIAL_ARGUMENTS]));
// allocate first dimension of bend-bend
Framework[i].NumberOfBendBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBendBends=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].BendBends=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].BendBendType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BendBendArguments=(REAL(**)[MAX_BEND_BEND_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BEND_BEND_POTENTIAL_ARGUMENTS]));
// allocate first dimension of stretch-torsion
Framework[i].NumberOfBondTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBondTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].BondTorsions=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].BondTorsionType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BondTorsionArguments=(REAL(**)[MAX_BOND_TORSION_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BOND_TORSION_POTENTIAL_ARGUMENTS]));
// allocate first dimension of bend-torsion
Framework[i].NumberOfBendTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfBendTorsions=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].BendTorsions=(QUAD**)calloc(Framework[i].NumberOfFrameworks,sizeof(QUAD*));
Framework[i].BendTorsionType=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
Framework[i].BendTorsionArguments=(REAL(**)[MAX_BEND_TORSION_POTENTIAL_ARGUMENTS])calloc(Framework[i].NumberOfFrameworks,
sizeof(REAL(*)[MAX_BEND_TORSION_POTENTIAL_ARGUMENTS]));
Framework[i].NumberOfIntraVDW=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfExcludedIntraVDW=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfIntraCharges=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfIntraChargeBondDipoles=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfIntraBondDipoles=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].NumberOfExcludedIntraChargeCharge=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfExcludedIntraChargeCharge=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].ExcludedIntraChargeCharge=(PAIR**)calloc(Framework[i].NumberOfFrameworks,sizeof(PAIR*));
Framework[i].NumberOfExcludedIntraChargeBondDipole=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfExcludedIntraChargeBondDipole=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].ExcludedIntraChargeBondDipole=(PAIR**)calloc(Framework[i].NumberOfFrameworks,sizeof(PAIR*));
Framework[i].NumberOfExcludedIntraBondDipoleBondDipole=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].MaxNumberOfExcludedIntraBondDipoleBondDipole=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].ExcludedIntraBondDipoleBondDipole=(PAIR**)calloc(Framework[i].NumberOfFrameworks,sizeof(PAIR*));
FrameworkFixedInitialization[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfFixedFrameworkAtoms[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfFixedFrameworkAtomsX[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfFixedFrameworkAtomsY[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfFixedFrameworkAtomsZ[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfActiveFrameworkAtoms[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfActiveFrameworkAtomsX[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfActiveFrameworkAtomsY[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
NumberOfActiveFrameworkAtomsZ[i]=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
FixedFrameworkAtoms[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
FixedFrameworkAtomsX[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
FixedFrameworkAtomsY[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
FixedFrameworkAtomsZ[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
ActiveFrameworkAtoms[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
ActiveFrameworkAtomsX[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
ActiveFrameworkAtomsY[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
ActiveFrameworkAtomsZ[i]=(int**)calloc(Framework[i].NumberOfFrameworks,sizeof(int*));
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
FrameworkFixedInitialization[i][j]=-1;
Framework[i].SpaceGroupIdentifier[j]=1;
Framework[i].FrameworkProbability[j]=1.0/Framework[i].NumberOfFrameworks;
Framework[i].RemoveAtomNumberCodeFromLabel[j]=FALSE;
Framework[i].AddAtomNumberCodeToLabel[j]=FALSE;
Framework[i].InputFileType[j]=CIF_FORMAT;
Framework[i].FrameworkProbability[j]=1.0;
}
Framework[i].PoreSizeDistributionProbeDistance=1.0;
Framework[i].AnisotropicType=ANISOTROPIC_MID_POINT;
Framework[i].ForceSpaceGroupDetection=FALSE;
Framework[i].ReadCIFAsCartesian=FALSE;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
// Print Interaction index for bond, bend and dihedral analysis.
Framework[i].PrintInteractionIndex=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
Framework[i].PrintInteractionIndex[j]=FALSE;
}
//-------------------------------------------------------------------
Framework[i].ReadCIFAsCartesian=FALSE;
Framework[i].Intra14VDWScalingValue=1.0;
Framework[i].Intra14ChargeChargeScalingValue=1.0;
}
else
{
Framework[i].Name=(char(*)[256])calloc(1,sizeof(char[256]));
Framework[i].NumberOfAtoms=(int*)calloc(1,sizeof(int));
Framework[i].NumberOfCharges=(int*)calloc(1,sizeof(int));
Framework[i].NumberOfAtoms[0]=0;
Framework[i].NumberOfCharges[0]=0;
Framework[i].NumberOfAsymmetricAtoms=(int*)calloc(1,sizeof(int));
Framework[i].RemoveAtomNumberCodeFromLabel=(int*)calloc(1,sizeof(int));
Framework[i].AddAtomNumberCodeToLabel=(int*)calloc(1,sizeof(int));
Framework[i].NumberOfAsymmetricAtoms[0]=0;
Framework[i].FrameworkModels=(int*)calloc(Framework[i].NumberOfFrameworks,sizeof(int));
Framework[i].PoreSizeDistributionProbeDistance=1.0;
Framework[i].AnisotropicType=ANISOTROPIC_MID_POINT;
Framework[i].FrameworkModel=NONE;
Framework[i].Intra14VDWScalingValue=1.0;
Framework[i].Intra14ChargeChargeScalingValue=1.0;
}
}
// allocate memory
AllocateStatisticsMemory();
// final pass, most memory is now already allocated
CurrentComponent=0;
CurrentReaction=0;
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
CurrentAlchReaction=0;
//-------------------------------------------------------------------
LineNumber=0;
tmp = strdup(input);
tokptr = 0;
for (line=strtok_r(tmp, "\n", &tokptr); line; line=strtok_r(NULL, "\n", &tokptr))
{
LineNumber++;
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s%[^\n]",keyword,arguments);
sscanf(arguments,"%s",firstargument);
// read the simulation type
if(strcasecmp("SimulationType",keyword)==0)
{
if(strcasecmp("MonteCarlo",firstargument)==0) SimulationType=MONTE_CARLO;
if(strcasecmp("MC",firstargument)==0) SimulationType=MONTE_CARLO;
if(strcasecmp("MolecularDynamics",firstargument)==0) SimulationType=MOLECULAR_DYNAMICS;
if(strcasecmp("MD",firstargument)==0) SimulationType=MOLECULAR_DYNAMICS;
if(strcasecmp("Spectra",firstargument)==0) SimulationType=SPECTRA;
if(strcasecmp("PhononDispersion",firstargument)==0) SimulationType=PHONON_DISPERSION;
if(strcasecmp("Minimization",firstargument)==0) SimulationType=MINIMIZATION;
if(strcasecmp("GlobalMinimization",firstargument)==0) SimulationType=GLOBAL_MINIMIZATION;
if(strcasecmp("Visualization",firstargument)==0) SimulationType=VISUALIZATION;
if((strcasecmp("PoreSizeDistribution",firstargument)==0)||
(strcasecmp("PSD",firstargument)==0)) SimulationType=PORE_SIZE_DISTRIBUTION;
if(strcasecmp("SurfaceArea",firstargument)==0) SimulationType=SURFACE_AREA;
if(strcasecmp("BarrierRecrossing",firstargument)==0) SimulationType=BARRIER_RECROSSING;
if(strcasecmp("RuizMontero",firstargument)==0) SimulationType=BARRIER_RUIZ_MONTERO;
if(strcasecmp("FreeEnergy",firstargument)==0) SimulationType=FREE_ENERGY;
if(strcasecmp("MakeGrid",firstargument)==0) SimulationType=MAKE_GRID;
if(strcasecmp("MakeASCIGrid",firstargument)==0) SimulationType=MAKE_ASCI_GRID;
if(strcasecmp("Numerical",firstargument)==0) SimulationType=NUMERICAL;
if(strcasecmp("PlotPotential",firstargument)==0) SimulationType=PLOT_POTENTIAL;
if(strcasecmp("Status",firstargument)==0) SimulationType=STATUS;
if(strcasecmp("GenerateFramework",firstargument)==0) SimulationType=GENERATE_FRAMEWORK;
}
if(strcasecmp("RandomSeed",keyword)==0) sscanf(arguments,"%lu",&seed);
// read simulation parameters
if(strcasecmp("TimeStep",keyword)==0) sscanf(arguments,"%lf",&DeltaT);
if(strcasecmp("OverlapDistance",keyword)==0)
{
sscanf(arguments,"%lf",&OverlapDistance);
OverlapDistanceSquared=OverlapDistance*OverlapDistance;
}
if(strcasecmp("CutOff",keyword)==0) sscanf(arguments,"%lf",&CutOffVDW);
if(strcasecmp("CutOffVDW",keyword)==0) sscanf(arguments,"%lf",&CutOffVDW);
if(strcasecmp("CutOffVDWSwitch",keyword)==0) sscanf(arguments,"%lf",&CutOffVDWSwitch);
if(strcasecmp("CutOffCoulomb",keyword)==0) sscanf(arguments,"%lf",&CutOffChargeCharge[CurrentSystem]);
if(strcasecmp("CutOffCoulombSwitch",keyword)==0) sscanf(arguments,"%lf",&CutOffChargeChargeSwitch[CurrentSystem]);
if(strcasecmp("CutOffChargeCharge",keyword)==0) sscanf(arguments,"%lf",&CutOffChargeCharge[CurrentSystem]);
if(strcasecmp("CutOffChargeChargeSwitch",keyword)==0) sscanf(arguments,"%lf",&CutOffChargeChargeSwitch[CurrentSystem]);
if(strcasecmp("CutOffChargeBondDipole",keyword)==0) sscanf(arguments,"%lf",&CutOffChargeBondDipole);
if(strcasecmp("CutOffChargeBondDipoleSwitch",keyword)==0) sscanf(arguments,"%lf",&CutOffChargeBondDipoleSwitch);
if(strcasecmp("CutOffBondDipoleBondDipole",keyword)==0) sscanf(arguments,"%lf",&CutOffBondDipoleBondDipole);
if(strcasecmp("CutOffBondDipoleBondDipoleSwitch",keyword)==0) sscanf(arguments,"%lf",&CutOffBondDipoleBondDipoleSwitch);
if(strcasecmp("CutOffIons",keyword)==0) sscanf(arguments,"%lf",&CutOffIons);
// read the amount of cycles
if(strcasecmp("NumberOfCycles",keyword)==0) sscanf(arguments,"%lld",&NumberOfCycles);
if(strcasecmp("NumberOfInitializationCycles",keyword)==0) sscanf(arguments,"%lld",&NumberOfInitializationCycles);
if(strcasecmp("NumberOfEquilibrationCycles",keyword)==0) sscanf(arguments,"%lld",&NumberOfEquilibrationCycles);
if(strcasecmp("NumberOfVelocityScalingCycles",keyword)==0) sscanf(arguments,"%lld",&NumberOfVelocityScalingCycles);
// read restart-options
if(strcasecmp("RestartFile",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Restart=TRUE;
if(strcasecmp("no",firstargument)==0) Restart=FALSE;
}
if(strcasecmp("RemoveFractionalMoleculesFromRestartFile",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) RemoveFractionalMoleculesFromRestartFile=TRUE;
if(strcasecmp("no",firstargument)==0) RemoveFractionalMoleculesFromRestartFile=FALSE;
}
if(strcasecmp("ContinueAfterCrash",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
ContinueAfterCrash=TRUE;
// no need to reed the rest of the input file
// instead read the binary status file
ReadBinaryRestartFiles();
if(ContinueAfterCrash) return 0;
}
if(strcasecmp("no",firstargument)==0) ContinueAfterCrash=FALSE;
}
if(strcasecmp("WriteBinaryRestartFileEvery",keyword)==0) sscanf(arguments,"%d",&WriteBinaryRestartFileEvery);
if(strcasecmp("RestartStyle",keyword)==0)
{
if(strcasecmp("BIGMAC",firstargument)==0) RestartStyle=BIGMAC_STYLE;
if(strcasecmp("RASPA",firstargument)==0) RestartStyle=RASPA_STYLE;
if(strcasecmp("RASPA_OLD",firstargument)==0) RestartStyle=RASPA_STYLE_OLD;
}
if(strcasecmp("ReinitializeVelocities",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ReinitializeVelocities=TRUE;
if(strcasecmp("no",firstargument)==0) ReinitializeVelocities=FALSE;
}
// read charge parameters
if(strcasecmp("ChargeMethod",keyword)==0)
{
if(strcasecmp("None",firstargument)==0) ChargeMethod=NONE;
if(strcasecmp("Ewald",firstargument)==0) ChargeMethod=EWALD;
if(strcasecmp("Coulomb",firstargument)==0) ChargeMethod=TRUNCATED_COULOMB;
if(strcasecmp("WolfsMethod",firstargument)==0) ChargeMethod=WOLFS_METHOD;
if(strcasecmp("WolfsMethodDamped",firstargument)==0) ChargeMethod=WOLFS_METHOD_DAMPED;
if(strcasecmp("WolfsMethodDampedFG",firstargument)==0) ChargeMethod=WOLFS_METHOD_DAMPED_FG;
if(strcasecmp("CoulombTruncated",firstargument)==0) ChargeMethod=TRUNCATED_COULOMB;
if(strcasecmp("CoulombShifted",firstargument)==0) ChargeMethod=SHIFTED_COULOMB;
if(strcasecmp("CoulombSmoothed",firstargument)==0) ChargeMethod=SMOOTHED_COULOMB;
}
if(strcasecmp("ChargeFromChargeEquilibration",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ChargeFromChargeEquilibration=TRUE;
if(strcasecmp("no",firstargument)==0) ChargeFromChargeEquilibration=FALSE;
}
if(strcasecmp("ChargeEquilibrationMethod",keyword)==0)
{
if(strcasecmp("RAPPE_GODDARD",firstargument)==0) ChargeEquilibrationMethod=RAPPE_GODDARD;
if(strcasecmp("WILMER_SNURR",firstargument)==0) ChargeEquilibrationMethod=WILMER_SNURR;
if(strcasecmp("DING_YAZAYDIN_DUBBELDAM",firstargument)==0) ChargeEquilibrationMethod=DING_YAZAYDIN_DUBBELDAM;
}
if(strcasecmp("SymmetrizeFrameworkCharges",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) SymmetrizeFrameworkCharges=TRUE;
if(strcasecmp("no",firstargument)==0) SymmetrizeFrameworkCharges=FALSE;
}
if(strcasecmp("UseChargesFromMOLFile",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) UseChargesFromMOLFile=TRUE;
if(strcasecmp("no",firstargument)==0) UseChargesFromMOLFile=FALSE;
}
if(strcasecmp("UseChargesFromCIFFile",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) UseChargesFromCIFFile=TRUE;
if(strcasecmp("no",firstargument)==0) UseChargesFromCIFFile=FALSE;
}
if(strcasecmp("EwaldPrecision",keyword)==0) sscanf(arguments,"%lf",&EwaldPrecision),EwaldAutomatic=TRUE;
if(strcasecmp("EwaldParameters",keyword)==0) sscanf(arguments,"%lf %d %d %d",&Alpha[CurrentSystem],
&kvec[CurrentSystem].x,&kvec[CurrentSystem].y,&kvec[CurrentSystem].z),EwaldAutomatic=FALSE;
if(strcasecmp("ReciprocalCutOff",keyword)==0)
{
sscanf(arguments,"%lf",&realinput1);
ReciprocalCutOffSquared[CurrentSystem]=SQR(realinput1);
}
if(strcasecmp("NoReciprocalCutOff",keyword)==0) ReciprocalCutOffSquared[CurrentSystem]=DBL_MAX;
if(strcasecmp("DielectricConstantOfTheMedium",keyword)==0) sscanf(arguments,"%lf",&DielectricConstantOfTheMedium);
// read some printing options
if(strcasecmp("PrintEvery",keyword)==0) sscanf(arguments,"%d",&PrintEvery);
if(strcasecmp("PrintPropertiesEvery",keyword)==0) sscanf(arguments,"%d",&PrintPropertiesEvery);
if(strcasecmp("Output",keyword)==0)
{
if(strcasecmp("screen",firstargument)==0) Output=OUTPUT_TO_SCREEN;
if(strcasecmp("file",firstargument)==0) Output=OUTPUT_TO_FILE;
}
if(strcasecmp("FileNameAppend",keyword)==0)
sscanf(arguments,"%s",FileNameAppend);
if(strcasecmp("PrintForcefieldToOutput",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) WriteForcefieldToOutput=TRUE;
if(strcasecmp("no",firstargument)==0) WriteForcefieldToOutput=FALSE;
}
if(strcasecmp("PrintPseudoAtomsToOutput",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) WritePseudoAtomsToOutput=TRUE;
if(strcasecmp("no",firstargument)==0) WritePseudoAtomsToOutput=FALSE;
}
if(strcasecmp("PrintMoleculeDefinitionToOutput",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) WriteMoleculeDefinitionToOutput=TRUE;
if(strcasecmp("no",firstargument)==0) WriteMoleculeDefinitionToOutput=FALSE;
}
// read the forcefield definition
if(strcasecmp("ForceField",keyword)==0) sscanf(firstargument,"%s",ForceField);
if(strcasecmp("ComputePolarization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputePolarization=TRUE;
if(strcasecmp("no",firstargument)==0) ComputePolarization=FALSE;
}
if(strcasecmp("PolarizationMatrix",keyword)==0)
{
if(strcasecmp("Isotropic",firstargument)==0) PolarizationMatrix=ISOTROPIC;
if(strcasecmp("AnIsotropic",firstargument)==0) PolarizationMatrix=ANISOTROPIC;
if(strcasecmp("Full",firstargument)==0) PolarizationMatrix=REGULAR_UPPER_TRIANGLE;
}
if(strcasecmp("BackPolarization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) BackPolarization=TRUE;
if(strcasecmp("no",firstargument)==0) BackPolarization=FALSE;
}
if(strcasecmp("NumberOfBackPolarizationSteps",keyword)==0) sscanf(arguments,"%d",&NumberOfBackPolarizationSteps);
if(strcasecmp("OmitInterMolecularInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
OmitInterMolecularInteractions=TRUE;
OmitAdsorbateAdsorbateVDWInteractions=OmitAdsorbateAdsorbateCoulombInteractions=TRUE;
OmitAdsorbateCationVDWInteractions=OmitAdsorbateCationCoulombInteractions=TRUE;
OmitCationCationVDWInteractions=OmitCationCationCoulombInteractions=TRUE;
}
if(strcasecmp("no",firstargument)==0)
{
OmitInterMolecularInteractions=FALSE;
OmitAdsorbateAdsorbateVDWInteractions=OmitAdsorbateAdsorbateCoulombInteractions=FALSE;
OmitAdsorbateCationVDWInteractions=OmitAdsorbateCationCoulombInteractions=FALSE;
OmitCationCationVDWInteractions=OmitCationCationCoulombInteractions=FALSE;
}
}
if(strcasecmp("OmitInterMolecularVDWInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
OmitInterMolecularVDWInteractions=TRUE;
OmitAdsorbateAdsorbateVDWInteractions=TRUE;
OmitAdsorbateCationVDWInteractions=TRUE;
OmitCationCationVDWInteractions=TRUE;
}
if(strcasecmp("no",firstargument)==0)
{
OmitInterMolecularVDWInteractions=FALSE;
OmitAdsorbateAdsorbateVDWInteractions=FALSE;
OmitAdsorbateCationVDWInteractions=FALSE;
OmitCationCationVDWInteractions=FALSE;
}
}
if(strcasecmp("OmitInterMolecularCoulombInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
OmitInterMolecularCoulombInteractions=TRUE;
OmitAdsorbateAdsorbateCoulombInteractions=TRUE;
OmitAdsorbateCationCoulombInteractions=TRUE;
OmitCationCationCoulombInteractions=TRUE;
}
if(strcasecmp("no",firstargument)==0)
{
OmitInterMolecularCoulombInteractions=FALSE;
OmitAdsorbateAdsorbateCoulombInteractions=FALSE;
OmitAdsorbateCationCoulombInteractions=FALSE;
OmitCationCationCoulombInteractions=FALSE;
}
}
if(strcasecmp("OmitAdsorbateAdsorbateVDWInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitAdsorbateAdsorbateVDWInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) OmitAdsorbateAdsorbateVDWInteractions=FALSE;
}
if(strcasecmp("OmitAdsorbateAdsorbateCoulombInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitAdsorbateAdsorbateCoulombInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) OmitAdsorbateAdsorbateCoulombInteractions=FALSE;
}
if(strcasecmp("OmitAdsorbateCationVDWInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitAdsorbateCationVDWInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) OmitAdsorbateCationVDWInteractions=FALSE;
}
if(strcasecmp("OmitAdsorbateCationCoulombInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitAdsorbateCationCoulombInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) OmitAdsorbateCationCoulombInteractions=FALSE;
}
if(strcasecmp("OmitCationCationVDWInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitCationCationVDWInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) OmitCationCationVDWInteractions=FALSE;
}
if(strcasecmp("OmitCationCationCoulombInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitCationCationCoulombInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) OmitCationCationCoulombInteractions=FALSE;
}
if(strcasecmp("OmitAdsorbateAdsorbatePolarization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitAdsorbateAdsorbatePolarization=TRUE;
if(strcasecmp("no",firstargument)==0) OmitAdsorbateAdsorbatePolarization=FALSE;
}
if(strcasecmp("OmitAdsorbateCationPolarization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitAdsorbateCationPolarization=TRUE;
if(strcasecmp("no",firstargument)==0) OmitAdsorbateCationPolarization=FALSE;
}
if(strcasecmp("OmitCationCationPolarization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitCationCationPolarization=TRUE;
if(strcasecmp("no",firstargument)==0) OmitCationCationPolarization=FALSE;
}
if(strcasecmp("OmitIntraFrameworkPolarization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitIntraFrameworkPolarization=TRUE;
if(strcasecmp("no",firstargument)==0) OmitIntraFrameworkPolarization=FALSE;
}
if(strcasecmp("OmitEwaldFourier",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OmitEwaldFourier=TRUE;
if(strcasecmp("no",firstargument)==0) OmitEwaldFourier=FALSE;
}
if(strcasecmp("InternalFrameworkLennardJonesInteractions",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) InternalFrameworkLennardJonesInteractions=TRUE;
if(strcasecmp("no",firstargument)==0) InternalFrameworkLennardJonesInteractions=FALSE;
}
if(strcasecmp("ImproperTorsionScanType",keyword)==0)
{
if(strcasecmp("general",firstargument)==0) ImproperTorsionScanType=IMPROPER_TORSION_SCAN_GENERAL;
if(strcasecmp("unique",firstargument)==0) ImproperTorsionScanType=IMPROPER_TORSION_SCAN_UNIQUE;
}
if((strcasecmp("Substitute",keyword)==0)||(strcasecmp("Modify",keyword)==0))
{
// allocate additional memory for this modification rule
SubstitutionSingleFrameworkAtom=(char(*)[3][256])realloc(SubstitutionSingleFrameworkAtom,(NumberOfSingleSubstitutionRules+1)*sizeof(char[3][256]));
if(!SubstitutionSingleFrameworkAtom)
{
printf("Memory reallocation error of 'SubstitutionSingleFrameworkAtom' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
SubstitutionSingleFrameworkAtomTypes=(int(*)[3])realloc(SubstitutionSingleFrameworkAtomTypes,(NumberOfSingleSubstitutionRules+1)*sizeof(int[3]));
if(!SubstitutionSingleFrameworkAtomTypes)
{
printf("Memory reallocation error of 'SubstitutionSingleFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
// scan the arguments from the input
sscanf(arguments,"%s %s %s",
SubstitutionSingleFrameworkAtom[NumberOfSingleSubstitutionRules][0],
SubstitutionSingleFrameworkAtom[NumberOfSingleSubstitutionRules][1],
SubstitutionSingleFrameworkAtom[NumberOfSingleSubstitutionRules][2]);
// increase the amount of modifcation rules by 1
NumberOfSingleSubstitutionRules++;
}
if((strcasecmp("RandomlySubstitute",keyword)==0)||(strcasecmp("RandomlyModify",keyword)==0))
{
// allocate additional memory for this modification rule
SubstitutionFrameworkAtoms=(char(*)[3][256])realloc(SubstitutionFrameworkAtoms,(NumberOfSubstitutionRules+1)*sizeof(char[3][256]));
if(!SubstitutionFrameworkAtoms)
{
printf("Memory reallocation error of 'SubstitutionFrameworkAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
SubstitutionFrameworkAtomTypes=(int(*)[3])realloc(SubstitutionFrameworkAtomTypes,(NumberOfSubstitutionRules+1)*sizeof(int[3]));
if(!SubstitutionFrameworkAtomTypes)
{
printf("Memory reallocation error of 'SubstitutionFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
// scan the arguments from the input
sscanf(arguments,"%s %s %s",
SubstitutionFrameworkAtoms[NumberOfSubstitutionRules][0],
SubstitutionFrameworkAtoms[NumberOfSubstitutionRules][1],
SubstitutionFrameworkAtoms[NumberOfSubstitutionRules][2]);
// increase the amount of modifcation rules by 1
NumberOfSubstitutionRules++;
}
if((strcasecmp("ModifyOxgensConnectedToAluminium",keyword)==0)||(strcasecmp("ModifyOxygensConnectedToAluminium",keyword)==0))
{
// allocate additional memory for this modification rule
ModificationRuleType=(int*)realloc(ModificationRuleType,(NumberOfModificationRules+1)*sizeof(int));
if(!ModificationRuleType)
{
printf("Memory reallocation error of 'ModificationRuleType' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtoms=(char(*)[10][256])realloc(ModifyFrameworkAtoms,(NumberOfModificationRules+1)*sizeof(char[10][256]));
if(!ModifyFrameworkAtoms)
{
printf("Memory reallocation error of 'ModifyFrameworkAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtomTypes=(int(*)[10])realloc(ModifyFrameworkAtomTypes,(NumberOfModificationRules+1)*sizeof(int[10]));
if(!ModifyFrameworkAtomTypes)
{
printf("Memory reallocation error of 'ModifyFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModificationRuleType[NumberOfModificationRules]=MODIFY_FRAMEWORKATOM_CONNECTED_TO;
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][3],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][4],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][5],"wild card");
// scan the arguments from the input
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][0],"O");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][1],"Oa");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][2],"Al");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][3],"wild card");
// increase the amount of modifcation rules by 1
NumberOfModificationRules++;
}
if(strcasecmp("ModifyFrameworkAtomConnectedTo",keyword)==0)
{
// allocate additional memory for this modification rule
ModificationRuleType=(int*)realloc(ModificationRuleType,(NumberOfModificationRules+1)*sizeof(int));
if(!ModificationRuleType)
{
printf("Memory reallocation error of 'ModificationRuleType' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtoms=(char(*)[10][256])realloc(ModifyFrameworkAtoms,(NumberOfModificationRules+1)*sizeof(char[10][256]));
if(!ModifyFrameworkAtoms)
{
printf("Memory reallocation error of 'ModifyFrameworkAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtomTypes=(int(*)[10])realloc(ModifyFrameworkAtomTypes,(NumberOfModificationRules+1)*sizeof(int[10]));
if(!ModifyFrameworkAtomTypes)
{
printf("Memory reallocation error of 'ModifyFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModificationRuleType[NumberOfModificationRules]=MODIFY_FRAMEWORKATOM_CONNECTED_TO;
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][2],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][3],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][4],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][5],"wild card");
// scan the arguments from the input
sscanf(arguments,"%s %s %s %s",
ModifyFrameworkAtoms[NumberOfModificationRules][0],
ModifyFrameworkAtoms[NumberOfModificationRules][1],
ModifyFrameworkAtoms[NumberOfModificationRules][2],
ModifyFrameworkAtoms[NumberOfModificationRules][3]);
// increase the amount of modifcation rules by 1
NumberOfModificationRules++;
}
if(strcasecmp("ModifyFrameworkDimer",keyword)==0)
{
// allocate additional memory for this modification rule
ModificationRuleType=(int*)realloc(ModificationRuleType,(NumberOfModificationRules+1)*sizeof(int));
if(!ModificationRuleType)
{
printf("Memory reallocation error of 'ModificationRuleType' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtoms=(char(*)[10][256])realloc(ModifyFrameworkAtoms,(NumberOfModificationRules+1)*sizeof(char[10][256]));
if(!ModifyFrameworkAtoms)
{
printf("Memory reallocation error of 'ModifyFrameworkAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtomTypes=(int(*)[10])realloc(ModifyFrameworkAtomTypes,(NumberOfModificationRules+1)*sizeof(int[10]));
if(!ModifyFrameworkAtomTypes)
{
printf("Memory reallocation error of 'ModifyFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModificationRuleType[NumberOfModificationRules]=MODIFY_FRAMEWORKATOM_DIMER;
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][0],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][1],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][2],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][3],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][4],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][5],"wild card");
// scan the arguments from the input
sscanf(arguments,"%s %s %s %s",
ModifyFrameworkAtoms[NumberOfModificationRules][0],
ModifyFrameworkAtoms[NumberOfModificationRules][1],
ModifyFrameworkAtoms[NumberOfModificationRules][2],
ModifyFrameworkAtoms[NumberOfModificationRules][3]);
// increase the amount of modifcation rules by 1
NumberOfModificationRules++;
}
if(strcasecmp("ModifyFrameworkTriple",keyword)==0)
{
// allocate additional memory for this modification rule
ModificationRuleType=(int*)realloc(ModificationRuleType,(NumberOfModificationRules+1)*sizeof(int));
if(!ModificationRuleType)
{
printf("Memory reallocation error of 'ModificationRuleType' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtoms=(char(*)[10][256])realloc(ModifyFrameworkAtoms,(NumberOfModificationRules+1)*sizeof(char[10][256]));
if(!ModifyFrameworkAtoms)
{
printf("Memory reallocation error of 'ModifyFrameworkAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtomTypes=(int(*)[10])realloc(ModifyFrameworkAtomTypes,(NumberOfModificationRules+1)*sizeof(int[10]));
if(!ModifyFrameworkAtomTypes)
{
printf("Memory reallocation error of 'ModifyFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModificationRuleType[NumberOfModificationRules]=MODIFY_FRAMEWORKATOM_TRIPLE;
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][0],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][1],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][2],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][3],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][4],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][5],"wild card");
// scan the arguments from the input
sscanf(arguments,"%s %s %s %s %s %s",
ModifyFrameworkAtoms[NumberOfModificationRules][0],
ModifyFrameworkAtoms[NumberOfModificationRules][1],
ModifyFrameworkAtoms[NumberOfModificationRules][2],
ModifyFrameworkAtoms[NumberOfModificationRules][3],
ModifyFrameworkAtoms[NumberOfModificationRules][4],
ModifyFrameworkAtoms[NumberOfModificationRules][5]);
// increase the amount of modifcation rules by 1
NumberOfModificationRules++;
}
if(strcasecmp("ModifyFrameworkPlanar",keyword)==0)
{
// allocate additional memory for this modification rule
ModificationRuleType=(int*)realloc(ModificationRuleType,(NumberOfModificationRules+1)*sizeof(int));
if(!ModificationRuleType)
{
printf("Memory reallocation error of 'ModificationRuleType' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtoms=(char(*)[10][256])realloc(ModifyFrameworkAtoms,(NumberOfModificationRules+1)*sizeof(char[10][256]));
if(!ModifyFrameworkAtoms)
{
printf("Memory reallocation error of 'ModifyFrameworkAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModifyFrameworkAtomTypes=(int(*)[10])realloc(ModifyFrameworkAtomTypes,(NumberOfModificationRules+1)*sizeof(int[10]));
if(!ModifyFrameworkAtomTypes)
{
printf("Memory reallocation error of 'ModifyFrameworkAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ModificationRuleType[NumberOfModificationRules]=MODIFY_FRAMEWORKATOM_PLANAR;
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][0],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][1],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][2],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][3],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][4],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][5],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][6],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][7],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][8],"wild card");
strcpy(ModifyFrameworkAtoms[NumberOfModificationRules][9],"wild card");
// scan the arguments from the input
sscanf(arguments,"%s %s %s %s %s %s %s %s %s %s",
ModifyFrameworkAtoms[NumberOfModificationRules][0],
ModifyFrameworkAtoms[NumberOfModificationRules][1],
ModifyFrameworkAtoms[NumberOfModificationRules][2],
ModifyFrameworkAtoms[NumberOfModificationRules][3],
ModifyFrameworkAtoms[NumberOfModificationRules][4],
ModifyFrameworkAtoms[NumberOfModificationRules][5],
ModifyFrameworkAtoms[NumberOfModificationRules][6],
ModifyFrameworkAtoms[NumberOfModificationRules][7],
ModifyFrameworkAtoms[NumberOfModificationRules][8],
ModifyFrameworkAtoms[NumberOfModificationRules][9]);
// increase the amount of modifcation rules by 1
NumberOfModificationRules++;
}
if(strcasecmp("ForbiddenFrameworkConnectivity",keyword)==0)
{
// allocate additional memory for this modification rule
ForbiddenConnectivityAtoms=(char(*)[3][256])realloc(ForbiddenConnectivityAtoms,(NumberOfForbiddenConnectivityRules+1)*sizeof(char[3][256]));
if(!ForbiddenConnectivityAtoms)
{
printf("Memory reallocation error of 'ForbiddenConnectivityAtoms' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ForbiddenConnectivityTypes=(int(*)[3])realloc(ForbiddenConnectivityTypes,(NumberOfForbiddenConnectivityRules+1)*sizeof(int[3]));
if(!ForbiddenConnectivityTypes)
{
printf("Memory reallocation error of 'ForbiddenConnectivityTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
// scan the arguments from the input
sscanf(arguments,"%s %s %s",
ForbiddenConnectivityAtoms[NumberOfForbiddenConnectivityRules][0],
ForbiddenConnectivityAtoms[NumberOfForbiddenConnectivityRules][1],
ForbiddenConnectivityAtoms[NumberOfForbiddenConnectivityRules][2]);
// increase the amount of modifcation rules by 1
NumberOfForbiddenConnectivityRules++;
}
if(strcasecmp("ConfirmPseudoAtomWithoutVDWInteraction",keyword)==0)
{
PseudoAtomsWithoutVDWInteraction=(char(*)[32])realloc(PseudoAtomsWithoutVDWInteraction,
(NumberOfPseudoAtomsWithoutVDWInteraction+1)*sizeof(char[32]));
if(!PseudoAtomsWithoutVDWInteraction)
{
printf("Memory reallocation error of 'PseudoAtomsWithoutVDWInteraction' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%s",PseudoAtomsWithoutVDWInteraction[NumberOfPseudoAtomsWithoutVDWInteraction]);
NumberOfPseudoAtomsWithoutVDWInteraction++;
}
if(strcasecmp("RemoveBondNeighboursFromLongRangeInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) RemoveBondNeighboursFromLongRangeInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) RemoveBondNeighboursFromLongRangeInteraction=FALSE;
}
if(strcasecmp("RemoveBendNeighboursFromLongRangeInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) RemoveBendNeighboursFromLongRangeInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) RemoveBendNeighboursFromLongRangeInteraction=FALSE;
}
if(strcasecmp("RemoveTorsionNeighboursFromLongRangeInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) RemoveTorsionNeighboursFromLongRangeInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) RemoveTorsionNeighboursFromLongRangeInteraction=FALSE;
}
if(strcasecmp("Remove12NeighboursFromVDWInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove12NeighboursFromVDWInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove12NeighboursFromVDWInteraction=FALSE;
}
if(strcasecmp("Remove13NeighboursFromVDWInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove13NeighboursFromVDWInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove13NeighboursFromVDWInteraction=FALSE;
}
if(strcasecmp("Remove14NeighboursFromVDWInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove14NeighboursFromVDWInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove14NeighboursFromVDWInteraction=FALSE;
}
if(strcasecmp("Remove12NeighboursFromChargeChargeInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove12NeighboursFromChargeChargeInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove12NeighboursFromChargeChargeInteraction=FALSE;
}
if(strcasecmp("Remove13NeighboursFromChargeChargeInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove13NeighboursFromChargeChargeInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove13NeighboursFromChargeChargeInteraction=FALSE;
}
if(strcasecmp("Remove14NeighboursFromChargeChargeInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove14NeighboursFromChargeChargeInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove14NeighboursFromChargeChargeInteraction=FALSE;
}
if(strcasecmp("Remove11NeighboursFromChargeBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove11NeighboursFromChargeBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove11NeighboursFromChargeBondDipoleInteraction=FALSE;
}
if(strcasecmp("Remove12NeighboursFromChargeBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove12NeighboursFromChargeBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove12NeighboursFromChargeBondDipoleInteraction=FALSE;
}
if(strcasecmp("Remove13NeighboursFromChargeBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove13NeighboursFromChargeBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove13NeighboursFromChargeBondDipoleInteraction=FALSE;
}
if(strcasecmp("Remove14NeighboursFromChargeBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove14NeighboursFromChargeBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove14NeighboursFromChargeBondDipoleInteraction=FALSE;
}
if(strcasecmp("Remove12NeighboursFromBondDipoleBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove12NeighboursFromBondDipoleBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove12NeighboursFromBondDipoleBondDipoleInteraction=FALSE;
}
if(strcasecmp("Remove13NeighboursFromBondDipoleBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove13NeighboursFromBondDipoleBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove13NeighboursFromBondDipoleBondDipoleInteraction=FALSE;
}
if(strcasecmp("Remove14NeighboursFromBondDipoleBondDipoleInteraction",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Remove14NeighboursFromBondDipoleBondDipoleInteraction=TRUE;
if(strcasecmp("no",firstargument)==0) Remove14NeighboursFromBondDipoleBondDipoleInteraction=FALSE;
}
// read thermo/barostat options
if(strcasecmp("ExternalTemperature",keyword)==0)
{
sscanf(arguments,"%lf",&therm_baro_stats.ExternalTemperature[CurrentSystem]);
if(therm_baro_stats.ExternalTemperature[CurrentSystem]<1e-10)
{
fprintf(stderr, "ERROR: temperature (%lg) should be positive\n",therm_baro_stats.ExternalTemperature[CurrentSystem]);
exit(0);
}
Beta[CurrentSystem]=1.0/(K_B*therm_baro_stats.ExternalTemperature[CurrentSystem]);
}
if(strcasecmp("ExternalPressure",keyword)==0)
{
arg_pointer=arguments;
NumberOfIsothermPressures=0;
while(sscanf(arg_pointer,"%lf%n",&therm_baro_stats.ExternalPressure[CurrentSystem][NumberOfIsothermPressures],&n)==1)
{
arg_pointer+=n;
NumberOfIsothermPressures++;
}
for(i=0;i<NumberOfIsothermPressures;i++)
therm_baro_stats.ExternalPressure[CurrentSystem][i]/=PRESSURE_CONVERSION_FACTOR; // convert from Pascal
}
if(strcasecmp("ThermostatChainLength",keyword)==0) sscanf(arguments,"%d",&therm_baro_stats.ThermostatChainLength);
if(strcasecmp("BarostatChainLength",keyword)==0) sscanf(arguments,"%d",&therm_baro_stats.BarostatChainLength);
if(strcasecmp("NumberOfYoshidaSuzukiSteps",keyword)==0) sscanf(arguments,"%d",&therm_baro_stats.NumberOfYoshidaSuzukiSteps);
if(strcasecmp("TimeScaleParameterThermostat",keyword)==0)
sscanf(arguments,"%lf",&therm_baro_stats.time_scale_parameter_thermostat);
if(strcasecmp("TimeScaleParameterBarostat",keyword)==0)
sscanf(arguments,"%lf",&therm_baro_stats.time_scale_parameter_barostat);
if(strcasecmp("ExternalStress",keyword)==0)
{
therm_baro_stats.UseExternalStress=TRUE;
switch(Dimension)
{
case 2:
sscanf(arguments,"%lf %lf %lf",&therm_baro_stats.ExternalStress[CurrentSystem].ax,
&therm_baro_stats.ExternalStress[CurrentSystem].bx,&therm_baro_stats.ExternalStress[CurrentSystem].by);
therm_baro_stats.ExternalStress[CurrentSystem].ax/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].bx/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].by/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].ay=therm_baro_stats.ExternalStress[CurrentSystem].bx;
break;
case 3:
sscanf(arguments,"%lf %lf %lf %lf %lf %lf",&therm_baro_stats.ExternalStress[CurrentSystem].ax,
&therm_baro_stats.ExternalStress[CurrentSystem].bx,&therm_baro_stats.ExternalStress[CurrentSystem].bz,
&therm_baro_stats.ExternalStress[CurrentSystem].by,&therm_baro_stats.ExternalStress[CurrentSystem].cy,
&therm_baro_stats.ExternalStress[CurrentSystem].cz);
therm_baro_stats.ExternalStress[CurrentSystem].ax/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].bx/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].cx/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].by/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].cy/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].cz/=PRESSURE_CONVERSION_FACTOR;
therm_baro_stats.ExternalStress[CurrentSystem].ay=therm_baro_stats.ExternalStress[CurrentSystem].bx;
therm_baro_stats.ExternalStress[CurrentSystem].az=therm_baro_stats.ExternalStress[CurrentSystem].cx;
therm_baro_stats.ExternalStress[CurrentSystem].bz=therm_baro_stats.ExternalStress[CurrentSystem].cy;
break;
}
}
//-----------------------------------------------------------------------------------------------------
// CFC-RXMC : read reactions
//-----------------------------------------------------------------------------------------------------
if(strcasecmp("Reaction",keyword)==0)
{
arg_pointer=arguments;
for(i=0;i<NumberOfComponents;i++)
{
sscanf(arg_pointer,"%d%n",&ReactantsStoichiometry[CurrentReaction][i],&n);
arg_pointer+=n;
}
for(i=0;i<NumberOfComponents;i++)
{
sscanf(arg_pointer,"%d%n",&ProductsStoichiometry[CurrentReaction][i],&n);
arg_pointer+=n;
}
CurrentReaction++;
}
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
// Alchemical transformation : read cation and anion indexes.
if(strcasecmp("AlchemicalTransformation",keyword)==0)
{
arg_pointer=arguments;
// Read the index of the solvent in which salt must be introduced.
sscanf(arg_pointer,"%d%n",&SolventIndex,&n);
arg_pointer+=n;
// Read the index of the salt, to be appeared in the component section.
for(i=0;i<2;i++)
{
sscanf(arg_pointer,"%d%n",&SaltIndex[CurrentAlchReaction][i],&n);
arg_pointer+=n;
}
CurrentAlchReaction++;
}
//-------------------------------------------------------------------
// read MD ensembles
if(strcasecmp("Ensemble",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("NVE",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NVE;
if(strcasecmp("NVT",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NVT;
if(strcasecmp("NPT",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPT;
if(strcasecmp("NPH",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPH;
if(strcasecmp("NPTPR",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPTPR;
if(strcasecmp("NPHPR",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPHPR;
if(strcasecmp("MuPT",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=MuPT;
if(strcasecmp("MuVT",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=MuVT;
if(strcasecmp("MuPTPR",keyword)==0)
Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=MuPTPR;
if(strcasecmp("NPTPR_ISO",keyword)==0) {Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPTPR; NPTPRCellType[index]=ISOTROPIC;}
if(strcasecmp("NPTPR_ANISO",keyword)==0) {Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPTPR; NPTPRCellType[index]=ANISOTROPIC;}
if(strcasecmp("NPTPR_MONO",keyword)==0) {Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPTPR; NPTPRCellType[index]=MONOCLINIC;}
if(strcasecmp("NPTPR_UPPER",keyword)==0) {Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPTPR; NPTPRCellType[index]=REGULAR_UPPER_TRIANGLE;}
if(strcasecmp("NPTPR_MONO_UPPER",keyword)==0) {Ensemble[index]=InitEnsemble[index]=RunEnsemble[index]=NPTPR; NPTPRCellType[index]=MONOCLINIC_UPPER_TRIANGLE;}
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("InitEnsemble",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("NVE",keyword)==0) InitEnsemble[index]=NVE;
if(strcasecmp("NVT",keyword)==0) InitEnsemble[index]=NVT;
if(strcasecmp("NPT",keyword)==0) InitEnsemble[index]=NPT;
if(strcasecmp("NPH",keyword)==0) InitEnsemble[index]=NPH;
if(strcasecmp("NPTPR",keyword)==0) InitEnsemble[index]=NPTPR;
if(strcasecmp("NPHPR",keyword)==0) InitEnsemble[index]=NPHPR;
if(strcasecmp("MuPT",keyword)==0) InitEnsemble[index]=MuPT;
if(strcasecmp("MuVT",keyword)==0) InitEnsemble[index]=MuVT;
if(strcasecmp("MuPTPR",keyword)==0) InitEnsemble[index]=MuPTPR;
if(strcasecmp("NPTPR_ISO",keyword)==0) {InitEnsemble[index]=NPTPR; NPTPRCellType[index]=ISOTROPIC;}
if(strcasecmp("NPTPR_ANISO",keyword)==0) {InitEnsemble[index]=NPTPR; NPTPRCellType[index]=ANISOTROPIC;}
if(strcasecmp("NPTPR_MONO",keyword)==0) {InitEnsemble[index]=NPTPR; NPTPRCellType[index]=MONOCLINIC;}
if(strcasecmp("NPTPR_UPPER",keyword)==0) {InitEnsemble[index]=NPTPR; NPTPRCellType[index]=REGULAR_UPPER_TRIANGLE;}
if(strcasecmp("NPTPR_MONO_UPPER",keyword)==0) {InitEnsemble[index]=NPTPR; NPTPRCellType[index]=MONOCLINIC_UPPER_TRIANGLE;}
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("RunEnsemble",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("NVE",keyword)==0) RunEnsemble[index]=NVE;
if(strcasecmp("NVT",keyword)==0) RunEnsemble[index]=NVT;
if(strcasecmp("NPT",keyword)==0) RunEnsemble[index]=NPT;
if(strcasecmp("NPH",keyword)==0) RunEnsemble[index]=NPH;
if(strcasecmp("NPTPR",keyword)==0) RunEnsemble[index]=NPTPR;
if(strcasecmp("NPHPR",keyword)==0) RunEnsemble[index]=NPHPR;
if(strcasecmp("MuPT",keyword)==0) RunEnsemble[index]=MuPT;
if(strcasecmp("MuVT",keyword)==0) RunEnsemble[index]=MuVT;
if(strcasecmp("MuPTPR",keyword)==0) RunEnsemble[index]=MuPTPR;
if(strcasecmp("NPTPR_ISO",keyword)==0) {RunEnsemble[index]=NPTPR; NPTPRCellType[index]=ISOTROPIC;}
if(strcasecmp("NPTPR_ANISO",keyword)==0) {RunEnsemble[index]=NPTPR; NPTPRCellType[index]=ANISOTROPIC;}
if(strcasecmp("NPTPR_MONO",keyword)==0) {RunEnsemble[index]=NPTPR; NPTPRCellType[index]=MONOCLINIC;}
if(strcasecmp("NPTPR_UPPER",keyword)==0) {RunEnsemble[index]=NPTPR; NPTPRCellType[index]=REGULAR_UPPER_TRIANGLE;}
if(strcasecmp("NPTPR_MONO_UPPER",keyword)==0) {RunEnsemble[index]=NPTPR; NPTPRCellType[index]=MONOCLINIC_UPPER_TRIANGLE;}
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("NPTPRCellType",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("Regular",keyword)==0) NPTPRCellType[index]=REGULAR;
if(strcasecmp("Monoclinic",keyword)==0) NPTPRCellType[index]=MONOCLINIC;
if(strcasecmp("RegularUpperTriangle",keyword)==0) NPTPRCellType[index]=REGULAR_UPPER_TRIANGLE;
if(strcasecmp("MonoclinicUpperTriangle",keyword)==0) NPTPRCellType[index]=MONOCLINIC_UPPER_TRIANGLE;
if(strcasecmp("Isotropic",keyword)==0) NPTPRCellType[index]=ISOTROPIC;
if(strcasecmp("Anisotropic",keyword)==0) NPTPRCellType[index]=ANISOTROPIC;
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("MonoclinicAngleType",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("Alpha",keyword)==0) MonoclinicAngleType[index]=MONOCLINIC_ALPHA_ANGLE;
if(strcasecmp("Beta",keyword)==0) MonoclinicAngleType[index]=MONOCLINIC_BETA_ANGLE;
if(strcasecmp("Gamma",keyword)==0) MonoclinicAngleType[index]=MONOCLINIC_GAMMA_ANGLE;
index++;
}
}while(index<NumberOfSystems);
}
// read box-sizes and angles
if(strcasecmp("Box",keyword)==0)
{
if(sscanf(arguments,"%d",&CurrentSystem))
{
if(CurrentSystem>=NumberOfSystems)
{
fprintf(stderr, "Input error in 'Box'-command: the number of the system is incorrect (%d given, 0 <= system-number < %d)\n",CurrentSystem,NumberOfSystems);
exit(0);
}
if(strlen(Framework[CurrentSystem].Name[0])>0)
{
fprintf(stderr, "Input error in 'Box'-command: the number of the system %d is already taken\n",CurrentSystem);
exit(0);
}
sprintf(Framework[CurrentSystem].Name[0],"Box");
InitializeBox[CurrentSystem]=TRUE;
}
}
if(strcasecmp("BoxMatrix",keyword)==0)
{
if(sscanf(arguments,"%d",&CurrentSystem))
{
strcpy(arguments, strtok_r(NULL, "\n", &tokptr));
sscanf(arguments,"%lf %lf %lf\n",&Box[CurrentSystem].ax,&Box[CurrentSystem].bx,&Box[CurrentSystem].cx);
strcpy(arguments, strtok_r(NULL, "\n", &tokptr));
sscanf(arguments,"%lf %lf %lf\n",&Box[CurrentSystem].ax,&Box[CurrentSystem].bx,&Box[CurrentSystem].cx);
sscanf(arguments,"%lf %lf %lf\n",&Box[CurrentSystem].ay,&Box[CurrentSystem].by,&Box[CurrentSystem].cy);
strcpy(arguments, strtok_r(NULL, "\n", &tokptr));
sscanf(arguments,"%lf %lf %lf\n",&Box[CurrentSystem].az,&Box[CurrentSystem].bz,&Box[CurrentSystem].cz);
NumberOfUnitCells[CurrentSystem].x=1;
NumberOfUnitCells[CurrentSystem].y=1;
NumberOfUnitCells[CurrentSystem].z=1;
UnitCellBox[CurrentSystem]=Box[CurrentSystem];
CellProperties(&Box[CurrentSystem],&BoxProperties[CurrentSystem],&Volume[CurrentSystem]);
InverseUnitCellBox[CurrentSystem]=InverseBox[CurrentSystem];
InverseBoxMatrix(&Box[CurrentSystem],&InverseBox[CurrentSystem]);
CellProperties(&InverseBox[CurrentSystem],&InverseBoxProperties[CurrentSystem],&det);
AlphaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].bx);
BetaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].by);
GammaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].bz);
InitializeBox[CurrentSystem]=FALSE;
sprintf(Framework[CurrentSystem].Name[CurrentFramework],"Box");
}
}
if((strcasecmp("BoxLengths",keyword)==0)||(strcasecmp("CellLengths",keyword)==0))
{
UnitCellSize[CurrentSystem].x=UnitCellSize[CurrentSystem].y=UnitCellSize[CurrentSystem].z=0.0;
switch(Dimension)
{
case 2:
sscanf(arguments,"%lf %lf",&UnitCellSize[CurrentSystem].x,&UnitCellSize[CurrentSystem].y);
break;
case 3:
sscanf(arguments,"%lf %lf %lf",&UnitCellSize[CurrentSystem].x,&UnitCellSize[CurrentSystem].y,&UnitCellSize[CurrentSystem].z);
break;
}
InitializeBox[CurrentSystem]=TRUE;
}
if((strcasecmp("BoxAngles",keyword)==0)||(strcasecmp("CellAngles",keyword)==0))
{
AlphaAngle[CurrentSystem]=BetaAngle[CurrentSystem]=GammaAngle[CurrentSystem]=0.0;
switch(Dimension)
{
case 2:
sscanf(arguments,"%lf",&GammaAngle[CurrentSystem]);
break;
case 3:
sscanf(arguments,"%lf %lf %lf",&AlphaAngle[CurrentSystem],&BetaAngle[CurrentSystem],&GammaAngle[CurrentSystem]);
break;
}
AlphaAngle[CurrentSystem]*=M_PI/180.0;
BetaAngle[CurrentSystem]*=M_PI/180.0;
GammaAngle[CurrentSystem]*=M_PI/180.0;
InitializeBox[CurrentSystem]=TRUE;
}
// read framework options
if(strcasecmp("Framework",keyword)==0)
{
if(sscanf(arguments,"%d",&CurrentSystem))
{
if(strlen(Framework[CurrentSystem].Name[0])>0)
{
fprintf(stderr, "Input error in 'Framework'-command: the number of the system %d is already taken\n",CurrentSystem);
exit(0);
}
sprintf(Framework[CurrentSystem].Name[0],"Box");
Framework[CurrentSystem].FrameworkModel=FULL;
read_frameworks[CurrentSystem]=TRUE;
CurrentFramework=-1;
}
}
if(strcasecmp("FrameworkName",keyword)==0)
{
CurrentFramework++;
sscanf(arguments,"%s",Framework[CurrentSystem].Name[CurrentFramework]);
}
if(strcasecmp("FrameworkDefinitions",keyword)==0) sscanf(arguments,"%s",Framework[CurrentSystem].FrameworkDefinitions);
if(strcasecmp("FlexibleModelInputType",keyword)==0)
{
if(strcasecmp("RASPA",firstargument)==0) Framework[CurrentSystem].FlexibleModelInputType=FLEXIBLE_FILE_TYPE_RASPA;
if(strcasecmp("DLPOLY",firstargument)==0) Framework[CurrentSystem].FlexibleModelInputType=FLEXIBLE_FILE_TYPE_DLPOLY;
}
if(strcasecmp("HeliumVoidFraction",keyword)==0) sscanf(arguments,"%lf",&HeliumVoidFraction[CurrentSystem]);
if(strcasecmp("ExcessVolume",keyword)==0) sscanf(arguments,"%lf",&ExcessVolume[CurrentSystem]);
if(strcasecmp("IonsName",keyword)==0) sscanf(arguments,"%s",Framework[CurrentSystem].NameIons);
if(strcasecmp("FrameworkIntra14VDWScalingValue",keyword)==0) sscanf(arguments,"%lf",&Framework[CurrentSystem].Intra14VDWScalingValue);
if(strcasecmp("FrameworkIntra14ChargeChargeScalingValue",keyword)==0) sscanf(arguments,"%lf",&Framework[CurrentSystem].Intra14ChargeChargeScalingValue);
if(strcasecmp("CalculateSpaceGroup",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].CalculateSpaceGroup[CurrentFramework]=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].CalculateSpaceGroup[CurrentFramework]=FALSE;
}
if(strcasecmp("RemoveAtomNumberCodeFromLabel",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].RemoveAtomNumberCodeFromLabel[CurrentFramework]=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].RemoveAtomNumberCodeFromLabel[CurrentFramework]=FALSE;
}
if(strcasecmp("AddAtomNumberCodeToLabel",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].AddAtomNumberCodeToLabel[CurrentFramework]=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].AddAtomNumberCodeToLabel[CurrentFramework]=FALSE;
}
if(strcasecmp("ForceSpaceGroupDetection",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].ForceSpaceGroupDetection=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].ForceSpaceGroupDetection=FALSE;
}
if(strcasecmp("ReadCIFAsCartesian",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].ReadCIFAsCartesian=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].ReadCIFAsCartesian=FALSE;
}
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
if(strcasecmp("PrintInteractionIndexAtoms",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].PrintInteractionIndex[CurrentFramework]=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].PrintInteractionIndex[CurrentFramework]=FALSE;
}
//-------------------------------------------------------------------
if(strcasecmp("RestrictFrameworkAtomsToBox",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].RestrictFrameworkAtomsToBox=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].RestrictFrameworkAtomsToBox=FALSE;
}
if(strcasecmp("InputFileType",keyword)==0)
{
if(strcasecmp("xyz",firstargument)==0) Framework[CurrentSystem].InputFileType[CurrentFramework]=XYZ_FORMAT;
if(strcasecmp("mol",firstargument)==0) Framework[CurrentSystem].InputFileType[CurrentFramework]=MOL_FORMAT;
if(strcasecmp("cssr",firstargument)==0) Framework[CurrentSystem].InputFileType[CurrentFramework]=CSSR_FORMAT;
if(strcasecmp("dlpoly",firstargument)==0) Framework[CurrentSystem].InputFileType[CurrentFramework]=DLPOLY_FORMAT;
if(strcasecmp("pdb",firstargument)==0) Framework[CurrentSystem].InputFileType[CurrentFramework]=PDB_FORMAT;
if(strcasecmp("cif",firstargument)==0) Framework[CurrentSystem].InputFileType[CurrentFramework]=CIF_FORMAT;
}
if(strcasecmp("UnitCells",keyword)==0) sscanf(arguments,"%d %d %d\n",&NumberOfUnitCells[CurrentSystem].x,
&NumberOfUnitCells[CurrentSystem].y,&NumberOfUnitCells[CurrentSystem].z);
if(strcasecmp("ReplicaUnitCells",keyword)==0) sscanf(arguments,"%d %d %d\n",&NumberOfReplicaCells[CurrentSystem].x,
&NumberOfReplicaCells[CurrentSystem].y,&NumberOfReplicaCells[CurrentSystem].z);
if(strcasecmp("ShiftUnitCells",keyword)==0) sscanf(arguments,"%lf %lf %lf",
&Framework[CurrentSystem].ShiftUnitCell[CurrentFramework].x,
&Framework[CurrentSystem].ShiftUnitCell[CurrentFramework].y,
&Framework[CurrentSystem].ShiftUnitCell[CurrentFramework].z);
if(strcasecmp("FlexibleFramework",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
Framework[CurrentSystem].FrameworkModels[CurrentFramework]=FLEXIBLE;
Framework[CurrentSystem].FrameworkModel=FLEXIBLE;
}
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].FrameworkModels[CurrentFramework]=RIGID;
}
// read component and component options (MC-moves, starting bead, molfraction, etc)
if(strcasecmp("Component",keyword)==0)
{
if(sscanf(arguments,"%d %*s %s",&CurrentComponent,string))
{
if(CurrentComponent>=NumberOfComponents)
{
fprintf(stderr, "Input error in 'Component'-command: the number of the component is incorrect (%d given, 0 <= component-number < %d)\n",CurrentComponent,NumberOfComponents);
exit(0);
}
if(strlen(Components[CurrentComponent].Name)>0)
{
fprintf(stderr, "Input error in 'Component'-command: the number of the component %d is already taken\n",CurrentComponent);
exit(0);
}
strcpy(Components[CurrentComponent].Name,string);
}
}
if(strcasecmp("MoleculeDefinition",keyword)==0) sscanf(arguments,"%s",Components[CurrentComponent].MoleculeDefinition);
if(strcasecmp("StartingBead",keyword)==0) sscanf(arguments,"%d",&Components[CurrentComponent].StartingBead);
if(strcasecmp("Intra14VDWScalingValue",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].Intra14VDWScalingValue);
if(strcasecmp("Intra14ChargeChargeScalingValue",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].Intra14ChargeChargeScalingValue);
if(strcasecmp("BlockPockets",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("yes",keyword)==0) Components[CurrentComponent].BlockPockets[index]=TRUE;
if(strcasecmp("no",keyword)==0) Components[CurrentComponent].BlockPockets[index]=FALSE;
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("InvertBlockPockets",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Components[CurrentComponent].InvertBlockPockets=TRUE;
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].InvertBlockPockets=FALSE;
}
if(strcasecmp("BlockPocketsFileName",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
strcpy(Components[CurrentComponent].BlockPocketsFilename[index],keyword);
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("ComputeFreeEnergyProfile",keyword)==0)
{
index=0;
do
{
if(sscanf(arguments,"%s %[^\n]",keyword,arguments)>0)
{
if(strcasecmp("yes",keyword)==0) Components[CurrentComponent].ComputeFreeEnergyProfile[index]=ComputeFreeEnergyProfile[index]=TRUE;
if(strcasecmp("no",keyword)==0) Components[CurrentComponent].ComputeFreeEnergyProfile[index]=FALSE;
index++;
}
}while(index<NumberOfSystems);
}
if(strcasecmp("MolFraction",keyword)==0)
{
index=0;
do
{
if(index==NumberOfSystems)
{
fprintf(stderr, "Reading mol fraction for more systems than the maximum allowed: %d\n",NumberOfSystems);
exit(0);
}
}while(sscanf(arguments,"%lf %[^\n]",&Components[CurrentComponent].MolFraction[index++],arguments)>1);
}
if(strcasecmp("FrameworkChangeMoveProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityFrameworkChangeMove);
if(strcasecmp("FrameworkShiftMoveProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityFrameworkShiftMove);
if(strcasecmp("VolumeChangeProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityVolumeChangeMove);
if(strcasecmp("VolumeChangeDirection", keyword)==0)
{
if(strcasecmp("a", firstargument)==0) VolumeChangeDirection=1;
if(strcasecmp("b", firstargument)==0) VolumeChangeDirection=2;
if(strcasecmp("c", firstargument)==0) VolumeChangeDirection=3;
if(strcasecmp("ab", firstargument)==0) VolumeChangeDirection=4;
if(strcasecmp("bc", firstargument)==0) VolumeChangeDirection=5;
if(strcasecmp("ac", firstargument)==0) VolumeChangeDirection=6;
if(strcasecmp("abc", firstargument)==0) VolumeChangeDirection=7;
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------
// CFC-RXMC : reading parameters
//--------------------------------------------------------------------------------------------------------------------------------------------------------
if(strcasecmp("ProbabilityCFCRXMCLambdaChangeMove",keyword)==0) sscanf(arguments,"%lf",&ProbabilityCFCRXMCLambdaChangeMove);
if(strcasecmp("TargetAccRatioReactionLambdaChange",keyword)==0) sscanf(arguments,"%lf",&TargetAccRatioReactionLambdaChange);
if(strcasecmp("LnPartitionFunction",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].PartitionFunction);
if(strcasecmp("PartitionFunction",keyword)==0)
{
double partition_function=0.0;
sscanf(arguments,"%lf",&partition_function);
Components[CurrentComponent].PartitionFunction=log(partition_function);
}
if(strcasecmp("MaximumReactionLambdaChange",keyword)==0)
{
sscanf(arguments,"%lf",&temp_real);
for(i=0;i<NumberOfReactions;i++)
MaximumReactionLambdaChange[CurrentSystem][i]=temp_real;
}
if(strcasecmp("MeasureLambdaBelow",keyword)==0) sscanf(arguments,"%lf",&MeasureLambdaBelow);
//--------------------------------------------------------------------------------------------------------------------------------------------------------
if(strcasecmp("ParallelTemperingProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityParallelTemperingMove);
if(strcasecmp("HyperParallelTemperingProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityHyperParallelTemperingMove);
if(strcasecmp("ParallelMolFractionProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityParallelMolFractionMove);
if(strcasecmp("ParallelMolFractionComponentA",keyword)==0)
{
sscanf(arguments,"%d",&ParallelMolFractionComponentA);
if((ParallelMolFractionComponentA<0)||(ParallelMolFractionComponentA>=NumberOfComponents))
{
fprintf(stderr, "Input error in 'ParallelMolFractionComponentA'-command: the number of the component %d is incorrect (should be < %d)\n",ParallelMolFractionComponentA,NumberOfComponents);
exit(0);
}
}
if(strcasecmp("ParallelMolFractionComponentB",keyword)==0)
{
sscanf(arguments,"%d",&ParallelMolFractionComponentB);
if((ParallelMolFractionComponentB<0)||(ParallelMolFractionComponentB>=NumberOfComponents))
{
fprintf(stderr, "Input error in 'ParallelMolFractionComponentB'-command: the number of the component %d is incorrect (should be < %d)\n",ParallelMolFractionComponentB,NumberOfComponents);
exit(0);
}
}
if(strcasecmp("ChiralInversionProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityChiralInversionMove);
if(strcasecmp("MaximumVolumeChange",keyword)==0)
sscanf(arguments,"system %d: %lf",&CurrentSystem,&MaximumVolumeChange[CurrentSystem]);
if(strcasecmp("BoxShapeChangeProbability",keyword)==0)
{
sscanf(arguments,"%lf",&ProbabilityBoxShapeChangeMove);
if(BoundaryCondition[CurrentSystem]==UNINITIALIZED_BOUNDARY_CONDITION)
BoundaryCondition[CurrentSystem]=TRICLINIC;
}
if(strcasecmp("BoundaryCondition",keyword)==0)
{
if(strcasecmp("None",firstargument)==0) BoundaryCondition[CurrentSystem]=FINITE;
if(strcasecmp("Rectangular",firstargument)==0) BoundaryCondition[CurrentSystem]=RECTANGULAR;
if(strcasecmp("Triclinic",firstargument)==0) BoundaryCondition[CurrentSystem]=TRICLINIC;
if(strcasecmp("Cubic",firstargument)==0) BoundaryCondition[CurrentSystem]=CUBIC;
}
if(strcasecmp("GibbsVolumeChangeProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityGibbsVolumeChangeMove);
if(strcasecmp("MaximumGibbsVolumeChange",keyword)==0)
sscanf(arguments,"system %d: %lf",&CurrentSystem,&MaximumGibbsVolumeChange[CurrentSystem]);
if(strcasecmp("GibbsSwapProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityGibbsChangeMove);
if(Components[CurrentComponent].ProbabilityGibbsChangeMove>0.0)
Swapable=TRUE;
}
if(strcasecmp("GibbsIdentityChangeProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityGibbsIdentityChangeMove);
if(Components[CurrentComponent].ProbabilityGibbsIdentityChangeMove>0.0)
Swapable=TRUE;
}
if(strcasecmp("CFGibbsProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCFGibbsChangeMove);
if(Components[CurrentComponent].ProbabilityCFGibbsChangeMove>0.0)
{
for(i=0;i<NumberOfSystems;i++)
Components[CurrentComponent].CFMoleculePresent[i]=TRUE;
Swapable=TRUE;
}
}
if(strcasecmp("CBCFGibbsProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCBCFGibbsChangeMove);
if(Components[CurrentComponent].ProbabilityCBCFGibbsChangeMove>0.0)
{
for(i=0;i<NumberOfSystems;i++)
Components[CurrentComponent].CFMoleculePresent[i]=TRUE;
Swapable=TRUE;
}
}
if(strcasecmp("TranslationProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityTranslationMove);
if(strcasecmp("TargetAccRatioTranslation",keyword)==0) sscanf(arguments,"%lf",&TargetAccRatioTranslation);
if(strcasecmp("TargetAccRatioRotation",keyword)==0) sscanf(arguments,"%lf",&TargetAccRatioRotation);
if(strcasecmp("TranslationDirection",keyword)==0)
{
if(strcasecmp("XYZ",firstargument)==0) Components[CurrentComponent].TranslationDirection=XYZ_DIR;
if(strcasecmp("XY",firstargument)==0) Components[CurrentComponent].TranslationDirection=XY_DIR;
if(strcasecmp("XZ",firstargument)==0) Components[CurrentComponent].TranslationDirection=XZ_DIR;
if(strcasecmp("YZ",firstargument)==0) Components[CurrentComponent].TranslationDirection=YZ_DIR;
if(strcasecmp("X",firstargument)==0) Components[CurrentComponent].TranslationDirection=X_DIR;
if(strcasecmp("Y",firstargument)==0) Components[CurrentComponent].TranslationDirection=Y_DIR;
if(strcasecmp("Z",firstargument)==0) Components[CurrentComponent].TranslationDirection=Z_DIR;
if(strcasecmp("ABC",firstargument)==0) Components[CurrentComponent].TranslationDirection=ABC_DIR;
if(strcasecmp("AB",firstargument)==0) Components[CurrentComponent].TranslationDirection=AB_DIR;
if(strcasecmp("AC",firstargument)==0) Components[CurrentComponent].TranslationDirection=AC_DIR;
if(strcasecmp("BC",firstargument)==0) Components[CurrentComponent].TranslationDirection=BC_DIR;
if(strcasecmp("A",firstargument)==0) Components[CurrentComponent].TranslationDirection=A_DIR;
if(strcasecmp("B",firstargument)==0) Components[CurrentComponent].TranslationDirection=B_DIR;
if(strcasecmp("C",firstargument)==0) Components[CurrentComponent].TranslationDirection=C_DIR;
if(strcasecmp("ORTHOGONAL_TO_AB_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_AB_DIR;
if(strcasecmp("ORTHOGONAL_TO_AC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_AC_DIR;
if(strcasecmp("ORTHOGONAL_TO_BC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_BC_DIR;
if(strcasecmp("ORTHOGONAL_TO_O_AB_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_O_AB_DIR;
if(strcasecmp("ORTHOGONAL_TO_O_AC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_O_AC_DIR;
if(strcasecmp("ORTHOGONAL_TO_O_BC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_O_BC_DIR;
if(strcasecmp("ORTHOGONAL_TO_A_BC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_A_BC_DIR;
if(strcasecmp("ORTHOGONAL_TO_B_AC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_B_AC_DIR;
if(strcasecmp("ORTHOGONAL_TO_C_AB_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_C_AB_DIR;
if(strcasecmp("ORTHOGONAL_TO_O_ABC_DIR",firstargument)==0) Components[CurrentComponent].TranslationDirection=ORTHOGONAL_TO_O_ABC_DIR;
}
if(strcasecmp("RandomTranslationProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityRandomTranslationMove);
if(strcasecmp("RotationProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityRotationMove);
if(strcasecmp("RandomRotationProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityRandomRotationMove);
if(strcasecmp("ExchangeFractionalParticleProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityExchangeFractionalParticleMove);
if(strcasecmp("CBMCProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityPartialReinsertionMove);
if(strcasecmp("PartialReinsertionProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityPartialReinsertionMove);
if(strcasecmp("ReinsertionProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityReinsertionMove);
if(strcasecmp("RegrowProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityReinsertionMove);
if(strcasecmp("ReinsertionInPlaceProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityReinsertionInPlaceMove);
if(strcasecmp("RegrowInPlaceProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityReinsertionInPlaceMove);
if(strcasecmp("ReinsertionInPlaceProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityReinsertionInPlaceMove);
if(strcasecmp("HybridMCMDMoveProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityHybridNVEMove);
if(strcasecmp("HybridNVEMoveProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityHybridNVEMove);
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
if(strcasecmp("ProbabilityAlchemicalTransformationMove",keyword)==0) sscanf(arguments,"%lf",&ProbabilityAlchemicalTransformationMove);
if(strcasecmp("LambdaStepsAlchemicalTransformationMove",keyword)==0) sscanf(arguments,"%d",&AlchReacLambda);
if(strcasecmp("ChemicalPotentialAlchemical",keyword)==0) sscanf(arguments,"%lf",&ChemicalPotentialAlchemical);
if(strcasecmp("RelaxationStepsAlchemicalTransformationMove",keyword)==0) sscanf(arguments,"%d",&RelaxationStepsAlchemicalTransformationMove);
if(strcasecmp("ProbabilityWidomOsmostatCalculationMove",keyword)==0) sscanf(arguments,"%lf",&ProbabilityWidomOsmostatCalculationMove);
//-------------------------------------------------------------------
if(strcasecmp("HybridNPHMoveProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityHybridNPHMove);
if(strcasecmp("HybridNPHPRMoveProbability",keyword)==0) sscanf(arguments,"%lf",&ProbabilityHybridNPHPRMove);
if(strcasecmp("NumberOfHybridNVESteps",keyword)==0) sscanf(arguments,"%d",&NumberOfHybridNVESteps);
if(strcasecmp("NumberOfHybridNPHSteps",keyword)==0) sscanf(arguments,"%d",&NumberOfHybridNPHSteps);
if(strcasecmp("NumberOfHybridNPHPRSteps",keyword)==0) sscanf(arguments,"%d",&NumberOfHybridNPHPRSteps);
if(strcasecmp("ReinsertionInPlaneProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityReinsertionInPlaneMove);
if(strcasecmp("IdentityChangeProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityIdentityChangeMove);
if(strcasecmp("NumberOfIdentityChanges",keyword)==0) sscanf(arguments,"%d",&Components[CurrentComponent].NumberOfIdentityChanges);
if(strcasecmp("IdentityChangesList",keyword)==0)
for(j=0;j<Components[CurrentComponent].NumberOfIdentityChanges;j++)
sscanf(arguments,"%d %[^\n]",&Components[CurrentComponent].IdentityChanges[j],arguments);
if(strcasecmp("NumberOfGibbsIdentityChanges",keyword)==0) sscanf(arguments,"%d",&Components[CurrentComponent].NumberOfGibbsIdentityChanges);
if(strcasecmp("GibbsIdentityChangesList",keyword)==0)
for(j=0;j<Components[CurrentComponent].NumberOfGibbsIdentityChanges;j++)
sscanf(arguments,"%d %[^\n]",&Components[CurrentComponent].GibbsIdentityChanges[j],arguments);
if(strcasecmp("SwapProbability",keyword)==0)
if(sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilitySwapMove))
if(Components[CurrentComponent].ProbabilitySwapMove>0.0)
{
Components[CurrentComponent].Swapable=TRUE;
Swapable=TRUE;
}
if(strcasecmp("CFSwapLambdaProbability",keyword)==0)
if(sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCFSwapLambdaMove))
{
if(Components[CurrentComponent].ProbabilityCFSwapLambdaMove>0.0)
{
Components[CurrentComponent].Swapable=TRUE;
for(i=0;i<NumberOfSystems;i++)
Components[CurrentComponent].CFMoleculePresent[i]=TRUE;
Swapable=TRUE;
}
}
if(strcasecmp("CBCFSwapLambdaProbability",keyword)==0)
if(sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCBCFSwapLambdaMove))
{
if(Components[CurrentComponent].ProbabilityCBCFSwapLambdaMove>0.0)
{
Components[CurrentComponent].Swapable=TRUE;
for(i=0;i<NumberOfSystems;i++)
Components[CurrentComponent].CFMoleculePresent[i]=TRUE;
Swapable=TRUE;
}
}
if(strcasecmp("CFWangLandauScalingFactor",keyword)==0)
sscanf(arguments,"%lf",&Components[CurrentComponent].CFWangLandauScalingFactor[CurrentSystem]);
if(strcasecmp("TargetAccRatioLambdaChange",keyword)==0) sscanf(arguments,"%lf",&TargetAccRatioLambdaChange);
if(strcasecmp("CFBiasingFactors",keyword)==0)
{
arg_pointer=arguments;
NumberOfCFBiasingFactors=0;
while(sscanf(arg_pointer,"%lf%n",&Components[CurrentComponent].CFBiasingFactors[CurrentSystem][NumberOfCFBiasingFactors],&n)==1)
{
arg_pointer+=n;
NumberOfCFBiasingFactors++;
}
}
if(strcasecmp("WidomProbability",keyword)==0)
{
if(sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityWidomMove))
{
if(Components[CurrentComponent].ProbabilityWidomMove>0.0)
Components[CurrentComponent].Widom=TRUE;
}
}
if(strcasecmp("CFWidomProbability",keyword)==0)
{
if(sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCFWidomLambdaMove))
{
if(Components[CurrentComponent].ProbabilityCFWidomLambdaMove>0.0)
{
Components[CurrentComponent].Widom=TRUE;
for(i=0;i<NumberOfSystems;i++)
Components[CurrentComponent].CFMoleculePresent[i]=TRUE;
}
}
}
if(strcasecmp("GibbsWidomProbability",keyword)==0)
{
if(sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityGibbsWidomMove))
{
if(Components[CurrentComponent].ProbabilityGibbsWidomMove>0.0)
Components[CurrentComponent].Widom=TRUE;
}
}
if(strcasecmp("WidomParticleInsertionComponent",keyword)==0) sscanf(arguments,"%d",&WidomParticleInsertionComponent);
if(strcasecmp("SurfaceAreaProbability",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilitySurfaceAreaMove);
if(strcasecmp("CFGibbsSwapFractionalMoleculeToOtherBoxMoveProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCFGibbsSwapFractionalMoleculeToOtherBoxMove);
if(Components[CurrentComponent].ProbabilityCFGibbsSwapFractionalMoleculeToOtherBoxMove>0.0)
{
Components[CurrentComponent].CFMoleculePresent[0]=TRUE;
SimulationSubType=GIBBS_CFCMC_SINGLE_FRACTIONAL_PARTICLE;
}
}
if(strcasecmp("CFGibbsLambdaChangeMoveProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCFGibbsLambdaChangeMove);
if(Components[CurrentComponent].ProbabilityCFGibbsLambdaChangeMove>0.0)
{
Components[CurrentComponent].CFMoleculePresent[0]=TRUE;
SimulationSubType=GIBBS_CFCMC_SINGLE_FRACTIONAL_PARTICLE;
}
}
if(strcasecmp("CFGibbsFractionalToIntegerMoveProbability",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].ProbabilityCFGibbsFractionalToIntegerMove);
if(Components[CurrentComponent].ProbabilityCFGibbsFractionalToIntegerMove>0.0)
{
Components[CurrentComponent].CFMoleculePresent[0]=TRUE;
SimulationSubType=GIBBS_CFCMC_SINGLE_FRACTIONAL_PARTICLE;
}
}
if(strcasecmp("RestrictEnantionface",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Components[CurrentComponent].RestrictEnantionface=TRUE;
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].RestrictEnantionface=FALSE;
}
if(strcasecmp("Enantioface",keyword)==0)
{
if(strcasecmp("Re",firstargument)==0) Components[CurrentComponent].Enantioface=ENANTIOFACE_RE;
if(strcasecmp("Si",firstargument)==0) Components[CurrentComponent].Enantioface=ENANTIOFACE_SI;
}
if(strcasecmp("EnantiofaceAtoms",keyword)==0)
{
sscanf(arguments," %c%d%d %c%d%d %c%d%d %c%d%d %c%d%d %[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,&charinput5,&intinput9,&intinput10,arguments);
if((charinput1=='F')||(charinput1=='f'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[0][0]=CATION;
Components[CurrentComponent].EnantiofaceAtomDefinitions[0][1]=intinput1;
Components[CurrentComponent].EnantiofaceAtomDefinitions[0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[1][0]=CATION;
Components[CurrentComponent].EnantiofaceAtomDefinitions[1][1]=intinput3;
Components[CurrentComponent].EnantiofaceAtomDefinitions[1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[2][0]=CATION;
Components[CurrentComponent].EnantiofaceAtomDefinitions[2][1]=intinput5;
Components[CurrentComponent].EnantiofaceAtomDefinitions[2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[3][0]=CATION;
Components[CurrentComponent].EnantiofaceAtomDefinitions[3][1]=intinput7;
Components[CurrentComponent].EnantiofaceAtomDefinitions[3][2]=intinput8;
if((charinput5=='F')||(charinput5=='f'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[4][0]=FRAMEWORK;
else if((charinput5=='A')||(charinput5=='a'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[4][0]=ADSORBATE;
else if((charinput5=='C')||(charinput5=='c'))
Components[CurrentComponent].EnantiofaceAtomDefinitions[4][0]=CATION;
Components[CurrentComponent].EnantiofaceAtomDefinitions[4][1]=intinput9;
Components[CurrentComponent].EnantiofaceAtomDefinitions[4][2]=intinput10;
}
if(strcasecmp("ExtraFrameworkMolecule",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Components[CurrentComponent].ExtraFrameworkMolecule=TRUE;
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].ExtraFrameworkMolecule=FALSE;
}
if(strcasecmp("CreateNumberOfMolecules",keyword)==0)
{
index=0;
do
{
if(index==NumberOfSystems)
{
fprintf(stderr, "Creating molecules for more systems than the maximum allowed: %d\n",NumberOfSystems);
exit(0);
}
}while(sscanf(arguments,"%d %[^\n]",&Components[CurrentComponent].CreateNumberOfMolecules[index++],arguments)>1);
}
if(strcasecmp("BinaryEOSInteractionParameter",keyword)==0)
{
index=0;
do
{
if(index==NumberOfComponents)
{
fprintf(stderr, "Reading BinaryEOSInteractionParamter for more components than the maximum allowed: %d\n",NumberOfComponents);
exit(0);
}
}while(sscanf(arguments,"%lf %[^\n]",&BinaryInteractionParameter[CurrentComponent][index++],arguments)>1);
}
if(strcasecmp("FugacityCoefficient",keyword)==0)
{
index=0;
do
{
if(index==NumberOfSystems)
{
fprintf(stderr, "Reading fugacity coefficients (%d) for more systems than the maximum allowed: %d\n",index,NumberOfSystems);
exit(0);
}
}while(sscanf(arguments,"%lf %[^\n]",&Components[CurrentComponent].FugacityCoefficient[index++],arguments)>1);
for(i=0;i<index;i++)
if(Components[CurrentComponent].FugacityCoefficient[i]>=0.0) ComputeFugacityCoefficient[i][CurrentComponent]=FALSE;
}
if(strcasecmp("IdealGasRosenbluthWeight",keyword)==0)
{
index=0;
do
{
if(index==NumberOfSystems)
{
fprintf(stderr, "Reading ideal Rosenbluth weights for more systems than the maximum allowed: %d\n",NumberOfSystems);
exit(0);
}
}while(sscanf(arguments,"%lf %[^\n]",&Components[CurrentComponent].IdealGasRosenbluthWeight[index++],arguments)>1);
}
if(strcasecmp("RestrictMovesToBox",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
Components[CurrentComponent].RestrictMovesToBox=TRUE;
Components[CurrentComponent].RestrictMoves=TRUE;
}
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].RestrictMovesToBox=FALSE;
}
if(strcasecmp("BoxAxisABC_Min",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Min.x,
&Components[CurrentComponent].BoxAxisABC_Min.y,&Components[CurrentComponent].BoxAxisABC_Min.z);
if(strcasecmp("BoxAxisABC_Max",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Max.x,
&Components[CurrentComponent].BoxAxisABC_Max.y,&Components[CurrentComponent].BoxAxisABC_Max.z);
if(strcasecmp("BoxAxisABC_Min2",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Min2.x,
&Components[CurrentComponent].BoxAxisABC_Min2.y,&Components[CurrentComponent].BoxAxisABC_Min2.z);
if(strcasecmp("BoxAxisABC_Max2",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Max2.x,
&Components[CurrentComponent].BoxAxisABC_Max2.y,&Components[CurrentComponent].BoxAxisABC_Max2.z);
if(strcasecmp("BoxAxisABC_Min3",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Min3.x,
&Components[CurrentComponent].BoxAxisABC_Min3.y,&Components[CurrentComponent].BoxAxisABC_Min3.z);
if(strcasecmp("BoxAxisABC_Max3",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Max3.x,
&Components[CurrentComponent].BoxAxisABC_Max3.y,&Components[CurrentComponent].BoxAxisABC_Max3.z);
if(strcasecmp("BoxAxisABC_Min4",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Min4.x,
&Components[CurrentComponent].BoxAxisABC_Min4.y,&Components[CurrentComponent].BoxAxisABC_Min4.z);
if(strcasecmp("BoxAxisABC_Max4",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].BoxAxisABC_Max4.x,
&Components[CurrentComponent].BoxAxisABC_Max4.y,&Components[CurrentComponent].BoxAxisABC_Max4.z);
if(strcasecmp("RestrictMovesToPrism",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
Components[CurrentComponent].RestrictMoves=TRUE;
Components[CurrentComponent].RestrictMovesToPrisms=TRUE;
}
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].RestrictMovesToPrisms=FALSE;
}
if(strcasecmp("Prism",keyword)==0)
{
sscanf(arguments,"%d",&CurrentPrism);
Components[CurrentComponent].RestrictMovesToPrism[CurrentPrism]=TRUE;
}
if(strcasecmp("PrismABC_Min",keyword)==0)
{
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].RestrictPrismABC_Min[CurrentPrism].x,
&Components[CurrentComponent].RestrictPrismABC_Min[CurrentPrism].y,&Components[CurrentComponent].RestrictPrismABC_Min[CurrentPrism].z);
}
if(strcasecmp("PrismABC_Max",keyword)==0)
{
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].RestrictPrismABC_Max[CurrentPrism].x,
&Components[CurrentComponent].RestrictPrismABC_Max[CurrentPrism].y,&Components[CurrentComponent].RestrictPrismABC_Max[CurrentPrism].z);
}
if(strcasecmp("RestrictMovesToCylinder",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
Components[CurrentComponent].RestrictMoves=TRUE;
Components[CurrentComponent].RestrictMovesToCylinders=TRUE;
}
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].RestrictMovesToCylinders=FALSE;
}
if(strcasecmp("Cylinder",keyword)==0)
{
sscanf(arguments,"%d",&CurrentCylinder);
Components[CurrentComponent].RestrictMovesToCylinder[CurrentCylinder]=TRUE;
}
if(strcasecmp("CylinderABC_Min",keyword)==0)
{
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].RestrictCylinderABC_Min[CurrentCylinder].x,
&Components[CurrentComponent].RestrictCylinderABC_Min[CurrentCylinder].y,&Components[CurrentComponent].RestrictCylinderABC_Min[CurrentCylinder].z);
}
if(strcasecmp("CylinderABC_Max",keyword)==0)
{
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].RestrictCylinderABC_Max[CurrentCylinder].x,
&Components[CurrentComponent].RestrictCylinderABC_Max[CurrentCylinder].y,&Components[CurrentComponent].RestrictCylinderABC_Max[CurrentCylinder].z);
}
if(strcasecmp("CylinderCenter",keyword)==0)
{
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].RestrictCylinderCenter[CurrentCylinder].x,
&Components[CurrentComponent].RestrictCylinderCenter[CurrentCylinder].y,&Components[CurrentComponent].RestrictCylinderCenter[CurrentCylinder].z);
}
if(strcasecmp("CylinderRadius",keyword)==0)
sscanf(arguments,"%lf",&Components[CurrentComponent].RestrictCylinderRadius[CurrentCylinder]);
if(strcasecmp("CylinderDiameter",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].RestrictCylinderRadius[CurrentCylinder]);
Components[CurrentComponent].RestrictCylinderRadius[CurrentCylinder]*=0.5;
}
if(strcasecmp("CylinderDirection",keyword)==0)
{
if(strcasecmp("X",firstargument)==0) Components[CurrentComponent].RestrictCylinderDirection[CurrentCylinder]=X_DIR;
if(strcasecmp("Y",firstargument)==0) Components[CurrentComponent].RestrictCylinderDirection[CurrentCylinder]=Y_DIR;
if(strcasecmp("Z",firstargument)==0) Components[CurrentComponent].RestrictCylinderDirection[CurrentCylinder]=Z_DIR;
}
if(strcasecmp("RestrictMovesToSphere",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0)
{
Components[CurrentComponent].RestrictMoves=TRUE;
Components[CurrentComponent].RestrictMovesToSpheres=TRUE;
}
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].RestrictMovesToSpheres=FALSE;
}
if(strcasecmp("Sphere",keyword)==0)
{
sscanf(arguments,"%d",&CurrentSphere);
Components[CurrentComponent].RestrictMovesToSphere[CurrentSphere]=TRUE;
}
if(strcasecmp("SphereCenter",keyword)==0)
{
sscanf(arguments,"%lf %lf %lf",&Components[CurrentComponent].RestrictSphereCenter[CurrentSphere].x,
&Components[CurrentComponent].RestrictSphereCenter[CurrentSphere].y,&Components[CurrentComponent].RestrictSphereCenter[CurrentSphere].z);
}
if(strcasecmp("SphereRadius",keyword)==0)
sscanf(arguments,"%lf",&Components[CurrentComponent].RestrictSphereRadius[CurrentSphere]);
if(strcasecmp("SphereDiameter",keyword)==0)
{
sscanf(arguments,"%lf",&Components[CurrentComponent].RestrictSphereRadius[CurrentSphere]);
Components[CurrentComponent].RestrictSphereRadius[CurrentSphere]*=0.5;
}
if(strcasecmp("TransmissionCoefficients",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Components[CurrentComponent].TransmissionCoefficient=TRUE;
if(strcasecmp("no",firstargument)==0) Components[CurrentComponent].TransmissionCoefficient=FALSE;
}
if(strcasecmp("BiasingMethod",keyword)==0)
{
if(strcasecmp("umbrella",firstargument)==0) Components[CurrentComponent].Biased=UMBRELLA;
if(strcasecmp("ruizmontero",firstargument)==0) Components[CurrentComponent].Biased=RUIZ_MONTERO;
}
if(strcasecmp("RuizMonterofactor",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].RuizMonteroFactor);
if(strcasecmp("UmbrellaFactor",keyword)==0) sscanf(arguments,"%lf",&Components[CurrentComponent].UmbrellaFactor);
if(strcasecmp("BiasingProfile",keyword)==0)
{
Components[CurrentComponent].ReadBiasingFunction=TRUE;
sscanf(arguments,"%s",Components[CurrentComponent].BiasingFunctionName);
}
if(strcasecmp("BiasingDirection",keyword)==0)
{
if(strcasecmp("A",firstargument)==0) Components[CurrentComponent].BiasingDirection=A_MAPPING;
if(strcasecmp("B",firstargument)==0) Components[CurrentComponent].BiasingDirection=B_MAPPING;
if(strcasecmp("C",firstargument)==0) Components[CurrentComponent].BiasingDirection=C_MAPPING;
if(strcasecmp("AB_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_AB_DIAGONAL;
if(strcasecmp("AC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_AC_DIAGONAL;
if(strcasecmp("BC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_BC_DIAGONAL;
if(strcasecmp("O_AB_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_O_AB_DIAGONAL;
if(strcasecmp("O_AC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_O_AC_DIAGONAL;
if(strcasecmp("O_BC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_O_BC_DIAGONAL;
if(strcasecmp("A_BC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_A_BC_DIAGONAL;
if(strcasecmp("B_AC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_B_AC_DIAGONAL;
if(strcasecmp("C_AB_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_C_AB_DIAGONAL;
if(strcasecmp("O_ABC_DIAGONAL",firstargument)==0) Components[CurrentComponent].BiasingDirection=MAP_O_ABC_DIAGONAL;
}
if(strcasecmp("Histogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputePositionHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputePositionHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("PositionHistogramMappingType",keyword)==0)
{
if(strcasecmp("A",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=A_MAPPING;
if(strcasecmp("B",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=B_MAPPING;
if(strcasecmp("C",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=C_MAPPING;
if(strcasecmp("ABC",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=ABC_MAPPING;
if(strcasecmp("AB_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_AB_DIAGONAL;
if(strcasecmp("AC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_AC_DIAGONAL;
if(strcasecmp("BC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_BC_DIAGONAL;
if(strcasecmp("O_AB_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_O_AB_DIAGONAL;
if(strcasecmp("O_AC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_O_AC_DIAGONAL;
if(strcasecmp("O_BC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_O_BC_DIAGONAL;
if(strcasecmp("A_BC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_A_BC_DIAGONAL;
if(strcasecmp("B_AC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_B_AC_DIAGONAL;
if(strcasecmp("C_AB_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_C_AB_DIAGONAL;
if(strcasecmp("O_ABC_DIAGONAL",firstargument)==0) PositionHistogramMappingType[CurrentSystem]=MAP_O_ABC_DIAGONAL;
}
// reading options to measure properties
// ==================================================================================================
if(strcasecmp("Movies",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Movies[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) Movies[CurrentSystem]=FALSE;
}
if(strcasecmp("MovieScale",keyword)==0) sscanf(arguments,"%lf",&MovieScale);
if(strcasecmp("WriteMoviesEvery",keyword)==0) sscanf(arguments,"%d",&WriteMoviesEvery[CurrentSystem]);
// sampling the radial distribution function (RDF)
if(strcasecmp("ComputeRDF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeRDF[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeRDF[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteRDFEvery",keyword)==0) sscanf(arguments,"%d",&WriteRDFEvery[CurrentSystem]);
if(strcasecmp("RDFHistogramSize",keyword)==0) sscanf(arguments,"%d",&RDFHistogramSize[CurrentSystem]);
if(strcasecmp("RDFRange",keyword)==0) sscanf(arguments,"%lf",&RDFRange[CurrentSystem]);
// sampling the projected-lengths distribution function
if(strcasecmp("ComputeProjectedLengths",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeProjectedLengths[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeProjectedLengths[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteProjectedLengthsEvery",keyword)==0) sscanf(arguments,"%d",&WriteProjectedLengthsEvery[CurrentSystem]);
if(strcasecmp("ProjectedLengthsHistogramSize",keyword)==0) sscanf(arguments,"%d",&ProjectedLengthsHistogramSize[CurrentSystem]);
if(strcasecmp("ProjectedLengthsRange",keyword)==0) sscanf(arguments,"%lf",&ProjectedLengthsRange[CurrentSystem]);
// sampling the projected-angles distribution function
if(strcasecmp("ComputeProjectedAngles",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeProjectedAngles[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeProjectedAngles[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteProjectedAnglesEvery",keyword)==0) sscanf(arguments,"%d",&WriteProjectedAnglesEvery[CurrentSystem]);
if(strcasecmp("ProjectedAnglesHistogramSize",keyword)==0) sscanf(arguments,"%d",&ProjectedAnglesHistogramSize[CurrentSystem]);
if(strcasecmp("ProjectedAnglesRange",keyword)==0) sscanf(arguments,"%lf",&ProjectedAnglesRange[CurrentSystem]);
//----------------------------------------------------------------------------------------------------------------------------------------------
// CFC-RXMC : sampling lambda histogram
//----------------------------------------------------------------------------------------------------------------------------------------------
if(strcasecmp("ComputeCFCRXMCLambdaHistogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeCFCRXMCLambdaHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeCFCRXMCLambdaHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteCFCRXMCLambdaHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteCFCRXMCLambdaHistogramEvery[CurrentSystem]);
if(strcasecmp("CFCRXMCLambdaHistogramBins",keyword)==0) sscanf(arguments,"%d",&CFCRXMCLambdaHistogramBins[CurrentSystem]);
//----------------------------------------------------------------------------------------------------------------------------------------------
// sampling the number-of-molecules histogram
if(strcasecmp("ComputeNumberOfMoleculesHistogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeNumberOfMoleculesHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeNumberOfMoleculesHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteNumberOfMoleculesHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteNumberOfMoleculesHistogramEvery[CurrentSystem]);
if(strcasecmp("NumberOfMoleculesHistogramSize",keyword)==0) sscanf(arguments,"%d",&NumberOfMoleculesHistogramSize[CurrentSystem]);
if(strcasecmp("NumberOfMoleculesRange",keyword)==0) sscanf(arguments,"%lf",&NumberOfMoleculesRange[CurrentSystem]);
// sampling position histograms/free energies
if(strcasecmp("ComputePositionHistogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputePositionHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputePositionHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WritePositionHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WritePositionHistogramEvery[CurrentSystem]);
if(strcasecmp("PositionHistogramSize",keyword)==0) sscanf(arguments,"%d",&PositionHistogramSize[CurrentSystem]);
// samples the free energy profiles in a,b,c directions
if(strcasecmp("WriteFreeEnergyProfileEvery",keyword)==0) sscanf(arguments,"%d",&WriteFreeEnergyProfileEvery[CurrentSystem]);
if(strcasecmp("FreeEnergyHistogramSize",keyword)==0) sscanf(arguments,"%d",&FreeEnergyHistogramSize[CurrentSystem]);
// sampling the pore-size distribution (PSD)
if((strcasecmp("ComputePSDHistogram",keyword)==0)||(strcasecmp("ComputePSD",keyword)==0))
{
if(strcasecmp("yes",firstargument)==0) ComputePSDHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputePSDHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WritePSDHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WritePSDHistogramEvery[CurrentSystem]);
if(strcasecmp("PSDHistogramSize",keyword)==0) sscanf(arguments,"%d",&PSDHistogramSize[CurrentSystem]);
if(strcasecmp("PSDRange",keyword)==0) sscanf(arguments,"%lf",&PSDRange[CurrentSystem]);
if(strcasecmp("PSDProbeDistance",keyword)==0)
{
if(strcasecmp("Minimum",firstargument)==0) Framework[CurrentSystem].PoreSizeDistributionProbeDistance=pow(2.0,1.0/6.0);
if(strcasecmp("Sigma",firstargument)==0) Framework[CurrentSystem].PoreSizeDistributionProbeDistance=1.0;
}
// sampling the end-to-end histograms
if(strcasecmp("ComputeEndToEndDistanceHistogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeEndToEndDistanceHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeEndToEndDistanceHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteEndToEndDistanceHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteEndToEndDistanceHistogramEvery[CurrentSystem]);
if(strcasecmp("EndToEndHistogramSize",keyword)==0) sscanf(arguments,"%d",&EndToEndHistogramSize[CurrentSystem]);
if(strcasecmp("EndToEndRange",keyword)==0) sscanf(arguments,"%lf",&EndToEndRange[CurrentSystem]);
// sampling the energy histogram
if(strcasecmp("ComputeEnergyHistogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeEnergyHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeEnergyHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteEnergyHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteEnergyHistogramEvery[CurrentSystem]);
if(strcasecmp("EnergyHistogramSize",keyword)==0) sscanf(arguments,"%d",&EnergyHistogramSize[CurrentSystem]);
if(strcasecmp("EnergyHistogramLowerLimit",keyword)==0) sscanf(arguments,"%lf",&EnergyHistogramLowerLimit[CurrentSystem]);
if(strcasecmp("EnergyHistogramUpperLimit",keyword)==0) sscanf(arguments,"%lf",&EnergyHistogramUpperLimit[CurrentSystem]);
// sampling the thermodynamic factor
if(strcasecmp("ComputeThermoDynamicFactor",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeThermoDynamicFactor[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeThermoDynamicFactor[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteThermoDynamicFactorEvery",keyword)==0) sscanf(arguments,"%d",&WriteThermoDynamicFactorEvery[CurrentSystem]);
// sampling the inter-framework spacing histogram
if(strcasecmp("ComputeFrameworkSpacingHistogram",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeFrameworkSpacingHistogram[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeFrameworkSpacingHistogram[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteFrameworkSpacingHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteFrameworkSpacingHistogramEvery[CurrentSystem]);
if(strcasecmp("FrameworkSpacingHistogramSize",keyword)==0) sscanf(arguments,"%d",&FrameworkSpacingHistogramSize[CurrentSystem]);
if(strcasecmp("FrameworkSpacingRange",keyword)==0) sscanf(arguments,"%lf",&FrameworkSpacingRange[CurrentSystem]);
// sampling histograms of the residence times
if(strcasecmp("ComputeResidenceTimes",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeResidenceTimes[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeResidenceTimes[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteResidenceTimesEvery",keyword)==0) sscanf(arguments,"%d",&WriteResidenceTimesEvery[CurrentSystem]);
if(strcasecmp("RangeResidenceTimes",keyword)==0) sscanf(arguments,"%lf",&RangeResidenceTimes[CurrentSystem]);
if(strcasecmp("ResidenceTimesHistogramSize",keyword)==0) sscanf(arguments,"%d",&ResidenceTimesHistogramSize[CurrentSystem]);
// sampling histograms of the distance between 2 selected atoms
if(strcasecmp("ComputeDistanceHistograms",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeDistanceHistograms[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeDistanceHistograms[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteDistanceHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteDistanceHistogramsEvery[CurrentSystem]);
if(strcasecmp("MaxRangeDistanceHistogram",keyword)==0) sscanf(arguments,"%lf",&MaxRangeDistanceHistogram);
if(strcasecmp("NumberOfElementsDistanceHistogram",keyword)==0) sscanf(arguments,"%d",&NumberOfElementsDistanceHistogram);
// sampling histograms of the bend angle between 3 selected atoms
if(strcasecmp("ComputeBendAngleHistograms",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeBendAngleHistograms[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeBendAngleHistograms[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteBendAngleHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteBendAngleHistogramsEvery[CurrentSystem]);
if(strcasecmp("MaxRangeBendAngleHistogram",keyword)==0) sscanf(arguments,"%lf",&MaxRangeBendAngleHistogram);
if(strcasecmp("NumberOfElementsBendAngleHistogram",keyword)==0) sscanf(arguments,"%d",&NumberOfElementsBendAngleHistogram);
// sampling histograms of the dihedral angle between 4 selected atoms
if(strcasecmp("ComputeDihedralAngleHistograms",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeDihedralAngleHistograms[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeDihedralAngleHistograms[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteDihedralAngleHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteDihedralAngleHistogramsEvery[CurrentSystem]);
if(strcasecmp("MaxRangeDihedralAngleHistogram",keyword)==0) sscanf(arguments,"%lf",&MaxRangeDihedralAngleHistogram);
if(strcasecmp("NumberOfElementsDihedralAngleHistogram",keyword)==0) sscanf(arguments,"%d",&NumberOfElementsDihedralAngleHistogram);
// sampling histograms of the angle between two planes (each formed by 3 chosen atoms)
if(strcasecmp("ComputeAngleBetweenPlanesHistograms",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeAngleBetweenPlanesHistograms[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeAngleBetweenPlanesHistograms[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteAngleBetweenPlanesHistogramEvery",keyword)==0) sscanf(arguments,"%d",&WriteAngleBetweenPlanesHistogramsEvery[CurrentSystem]);
if(strcasecmp("MaxRangeAngleBetweenPlanesHistogram",keyword)==0) sscanf(arguments,"%lf",&MaxRangeAngleBetweenPlanesHistogram);
if(strcasecmp("NumberOfElementsAngleBetweenPlanesHistogram",keyword)==0) sscanf(arguments,"%d",&NumberOfElementsAngleBetweenPlanesHistogram);
// sampling molecular properties (bond distance, bend angle, dihedral angle)
if(strcasecmp("ComputeMoleculeProperties",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeMoleculeProperties[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeMoleculeProperties[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteMoleculePropertiesEvery",keyword)==0) sscanf(arguments,"%d",&WriteMoleculePropertiesEvery[CurrentSystem]);
if(strcasecmp("BondLengthHistogramSize",keyword)==0) sscanf(arguments,"%d",&BondLengthHistogramSize[CurrentSystem]);
if(strcasecmp("BendAngleHistogramSize",keyword)==0) sscanf(arguments,"%d",&BendAngleHistogramSize[CurrentSystem]);
if(strcasecmp("DihedralHistogramSize",keyword)==0) sscanf(arguments,"%d",&DihedralHistogramSize[CurrentSystem]);
if(strcasecmp("BondLengthRange",keyword)==0) sscanf(arguments,"%lf",&BondLengthRange[CurrentSystem]);
if(strcasecmp("BendAngleRange",keyword)==0) sscanf(arguments,"%lf",&BendAngleRange[CurrentSystem]);
if(strcasecmp("DihedralRange",keyword)==0) sscanf(arguments,"%lf",&DihedralRange[CurrentSystem]);
// sampling the IR spectra (spacings: 2048, 4196, 8192, 16384, 32768 points)
if(strcasecmp("ComputeInfraRedSpectra",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeInfraRedSpectra[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeInfraRedSpectra[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteInfraRedSpectraEvery",keyword)==0) sscanf(arguments,"%d",&WriteInfraRedSpectraEvery[CurrentSystem]);
if(strcasecmp("SampleEveryInfraRed",keyword)==0) sscanf(arguments,"%d",&SampleEveryInfraRed);
// sampling the mean-squared displacement using a modified order-N algorithm
if(strcasecmp("ComputeMSD",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeMSDOrderN[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeMSDOrderN[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteMSDEvery",keyword)==0) sscanf(arguments,"%d",&WriteMSDOrderNEvery[CurrentSystem]);
if(strcasecmp("NumberOfSitesMSDOrderN",keyword)==0) sscanf(arguments,"%d",&NumberOfSitesMSDOrderN[CurrentSystem]);
if(strcasecmp("SampleMSDEvery",keyword)==0) sscanf(arguments,"%d",&SampleMSDOrderNEvery[CurrentSystem]);
if(strcasecmp("NumberOfBlockElementsMSD",keyword)==0) sscanf(arguments,"%d",&NumberOfBlockElementsMSDOrderN);
if(strcasecmp("NumberOfBlocksMSD",keyword)==0) sscanf(arguments,"%d",&MaxNumberOfBlocksMSDOrderN);
if(strcasecmp("ComputeIndividualMSD",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeIndividualMSDOrderN=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeIndividualMSDOrderN=FALSE;
}
if(strcasecmp("ComputeSiteTypeMSD",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeSiteTypeMSDOrderN=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeSiteTypeMSDOrderN=FALSE;
}
if(strcasecmp("ComputeMSDPerPseudoAtom",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeMSDOrderNPerPseudoAtom=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeMSDOrderNPerPseudoAtom=FALSE;
}
// sampling the velocity autocorrelation function using a modified order-N algorithm
if(strcasecmp("ComputeVACF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeVACFOrderN[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeVACFOrderN[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteVACFEvery",keyword)==0) sscanf(arguments,"%d",&WriteVACFOrderNEvery[CurrentSystem]);
if(strcasecmp("SampleVACFEvery",keyword)==0) sscanf(arguments,"%d",&SampleVACFOrderNEvery[CurrentSystem]);
if(strcasecmp("NumberOfBlockElementsVACF",keyword)==0) sscanf(arguments,"%d",&NumberOfBlockElementsVACFOrderN);
if(strcasecmp("NumberOfBlocksVACF",keyword)==0) sscanf(arguments,"%d",&MaxNumberOfBlocksVACFOrderN);
if(strcasecmp("ComputeIndividualVACF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeIndividualVACFOrderN=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeIndividualVACFOrderN=FALSE;
}
if(strcasecmp("ComputeVACFPerPseudoAtom",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeVACFOrderNPerPseudoAtom=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeVACFOrderNPerPseudoAtom=FALSE;
}
// sampling of the rotational velocity autocorrelation function using a modified order-N algorithm
if(strcasecmp("ComputeRVACF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeRVACFOrderN[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeRVACFOrderN[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteRVACFEvery",keyword)==0) sscanf(arguments,"%d",&WriteRVACFOrderNEvery[CurrentSystem]);
if(strcasecmp("SampleRVACFEvery",keyword)==0) sscanf(arguments,"%d",&SampleRVACFOrderNEvery[CurrentSystem]);
if(strcasecmp("NumberOfBlockElementsRVACF",keyword)==0) sscanf(arguments,"%d",&NumberOfBlockElementsRVACFOrderN);
if(strcasecmp("NumberOfBlocksRVACF",keyword)==0) sscanf(arguments,"%d",&MaxNumberOfBlocksRVACFOrderN);
if(strcasecmp("ComputeIndividualRVACF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeIndividualRVACFOrderN=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeIndividualRVACFOrderN=FALSE;
}
if(strcasecmp("ComputeRVACFPerPseudoAtom",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeRVACFOrderNPerPseudoAtom=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeRVACFOrderNPerPseudoAtom=FALSE;
}
// sampling of the molecular orientation autocorrelation function using a modified order-N algorithm
if(strcasecmp("ComputeMOACF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeMolecularOrientationOrderN[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeMolecularOrientationOrderN[CurrentSystem]=FALSE;
}
if(strcasecmp("MolecularOrientationVector",keyword)==0) sscanf(arguments,"%lf %lf %lf",&MolecularOrientationVector.x,
&MolecularOrientationVector.y,&MolecularOrientationVector.z);
if(strcasecmp("MolecularOrientationGroup",keyword)==0) sscanf(arguments,"%d",&MolecularOrientationGroup);
if(strcasecmp("MolecularOrientationType",keyword)==0)
{
if(strcasecmp("EndToEndvector",firstargument)==0) MolecularOrientationType=END_TO_END_VECTOR;
if(strcasecmp("MolecularVector",firstargument)==0) MolecularOrientationType=MOLECULAR_VECTOR;
}
if(strcasecmp("WriteMOAACFEvery",keyword)==0) sscanf(arguments,"%d",&WriteMolecularOrientationOrderNEvery[CurrentSystem]);
if(strcasecmp("SampleMOACFEvery",keyword)==0) sscanf(arguments,"%d",&SampleMolecularOrientationOrderNEvery[CurrentSystem]);
if(strcasecmp("NumberOfBlockElementsMOACF",keyword)==0) sscanf(arguments,"%d",&NumberOfBlockElementsMolecularOrientationOrderN);
if(strcasecmp("NumberOfBlocksMOACF",keyword)==0) sscanf(arguments,"%d",&MaxNumberOfBlocksMolecularOrientationOrderN);
// sampling of the bond orientation autocorrelation function using a modified order-N algorithm
if(strcasecmp("ComputeBOACF",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeBondOrientationOrderN[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeBondOrientationOrderN[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteBOACFEvery",keyword)==0) sscanf(arguments,"%d",&WriteBondOrientationOrderNEvery[CurrentSystem]);
if(strcasecmp("SampleBOACFEvery",keyword)==0) sscanf(arguments,"%d",&SampleBondOrientationOrderNEvery[CurrentSystem]);
if(strcasecmp("NumberOfBlockElementsBOACF",keyword)==0) sscanf(arguments,"%d",&NumberOfBlockElementsBondOrientationOrderN);
if(strcasecmp("NumberOfBlocksBOACF",keyword)==0) sscanf(arguments,"%d",&MaxNumberOfBlocksBondOrientationOrderN);
if(strcasecmp("BondOrientationAngleHistogramSize",keyword)==0) sscanf(arguments,"%d",&BondOrientationAngleHistogramSize[CurrentSystem]);
// sampling the mean-square displacement function using a conventional algorithm
if(strcasecmp("ComputeMSDConventional",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeMSD[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeMSD[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteMSDConventionalEvery",keyword)==0) sscanf(arguments,"%d",&WriteMSDEvery[CurrentSystem]);
if(strcasecmp("SampleMSDConventionalEvery",keyword)==0) sscanf(arguments,"%d",&SampleMSDEvery[CurrentSystem]);
if(strcasecmp("NumberOfBuffersMSDConventional",keyword)==0) sscanf(arguments,"%d",&NumberOfBuffersMSD);
if(strcasecmp("BufferLengthMSDConventional",keyword)==0) sscanf(arguments,"%d",&BufferLengthMSD);
// sampling the velocity autocorrelation function using a conventional algorithm
if(strcasecmp("ComputeVACFConventional",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeVACF[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeVACF[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteVACFConventionalEvery",keyword)==0) sscanf(arguments,"%d",&WriteVACFEvery[CurrentSystem]);
if(strcasecmp("SampleVACFConventionalEvery",keyword)==0) sscanf(arguments,"%d",&SampleVACFEvery[CurrentSystem]);
if(strcasecmp("NumberOfBuffersVACFConventional",keyword)==0) sscanf(arguments,"%d",&NumberOfBuffersVACF);
if(strcasecmp("BufferLengthVACFConventional",keyword)==0) sscanf(arguments,"%d",&BufferLengthVACF);
// sampling the 3D histograms of position (i.e. 3D free energy)
if(strcasecmp("ComputeDensityProfile3DVTKGrid",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeDensityProfile3DVTKGrid[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeDensityProfile3DVTKGrid[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteDensityProfile3DVTKGridEvery",keyword)==0) sscanf(arguments,"%d",&WriteDensityProfile3DVTKGridEvery[CurrentSystem]);
if(strcasecmp("DensityProfile3DVTKGridPoints",keyword)==0)
sscanf(arguments,"%d %d %d",&DensityProfile3DVTKGridPoints.x,&DensityProfile3DVTKGridPoints.y,&DensityProfile3DVTKGridPoints.z);
if(strcasecmp("DensityAveragingTypeVTK",keyword)==0)
{
if((strcasecmp("unit_cell",firstargument)==0)||(strcasecmp("UnitCell",firstargument)==0)) DensityAveragingTypeVTK=VTK_UNIT_CELL;
if((strcasecmp("full_box",firstargument)==0)||(strcasecmp("FullBox",firstargument)==0)) DensityAveragingTypeVTK=VTK_FULL_BOX;
}
if(strcasecmp("AverageDensityOverUnitCellsVTK",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) AverageDensityOverUnitCellsVTK=TRUE;
if(strcasecmp("no",firstargument)==0) AverageDensityOverUnitCellsVTK=FALSE;
}
// samples the cation sites and adsorption sites
if(strcasecmp("ComputeCationAndAdsorptionSites",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeCationAndAdsorptionSites[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeCationAndAdsorptionSites[CurrentSystem]=FALSE;
}
if(strcasecmp("WriteCationAndAdsorptionSitesEvery",keyword)==0) sscanf(arguments,"%d",&WriteCationAndAdsorptionSitesEvery[CurrentSystem]);
// samples initial configurations for the tranmission coefficient (dcTST)
if(strcasecmp("WritedcTSTSnapShotsEvery",keyword)==0) sscanf(arguments,"%d",&WritedcTSTSnapShotsEvery[CurrentSystem]);
if(strcasecmp("WritedcTSTSnapShotsToFile",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) WritedcTSTSnapShotsToFile[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) WritedcTSTSnapShotsToFile[CurrentSystem]=FALSE;
}
// samples the principle moment of inertia
if(strcasecmp("ComputePrincipleMomentsOfInertia",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputePrincipleMomentsOfInertia=TRUE;
if(strcasecmp("no",firstargument)==0) ComputePrincipleMomentsOfInertia=FALSE;
}
if((strcasecmp("ComputeMolecularPressure",keyword)==0)||(strcasecmp("ComputePressure",keyword)==0))
{
if(strcasecmp("yes",firstargument)==0) ComputeMolecularPressure[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeMolecularPressure[CurrentSystem]=FALSE;
}
if((strcasecmp("OrientationFrameworkBond",keyword)==0)||(strcasecmp("orientation_framework_bond",keyword)==0))
{
// allocate additional memory for this modification rule
OrientationFrameworkBonds[CurrentSystem][CurrentFramework]=(char(*)[2][256])realloc(
OrientationFrameworkBonds[CurrentSystem][CurrentFramework],
(NumberOfOrientationFrameworkBonds[CurrentSystem][CurrentFramework]+1)*sizeof(char[2][256]));
if(!OrientationFrameworkBonds[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'OrientationFrameworkBonds[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
index=NumberOfOrientationFrameworkBonds[CurrentSystem][CurrentFramework];
// scan the arguments from the input
sscanf(arguments,"%s %s",
OrientationFrameworkBonds[CurrentSystem][CurrentFramework][index][0],
OrientationFrameworkBonds[CurrentSystem][CurrentFramework][index][1]);
// increase the amount of modifcation rules by 1
NumberOfOrientationFrameworkBonds[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("SurfaceAreaProbeAtom",keyword)==0) sscanf(arguments,"%s",Framework[CurrentSystem].SurfaceAreaProbeAtom);
if(strcasecmp("SurfaceAreaSamplingPointsPerSphere",keyword)==0) sscanf(arguments,"%d",&Framework[CurrentSystem].SurfaceAreaSamplingPointsPerShere);
if(strcasecmp("SurfaceAreaProbeDistance",keyword)==0)
{
if(strcasecmp("Minimum",firstargument)==0) Framework[CurrentSystem].SurfaceAreaProbeDistance=pow(2.0,1.0/6.0);
if(strcasecmp("Sigma",firstargument)==0) Framework[CurrentSystem].SurfaceAreaProbeDistance=1.0;
}
if(strcasecmp("ComputeElasticConstants",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeElasticConstants=ComputeBornTerm=ComputeCrossTerm=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeElasticConstants=ComputeBornTerm=ComputeCrossTerm=FALSE;
}
if(strcasecmp("ComputeElasticConstantsThirdOrder",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeElasticConstantsThirdOrder=ComputeElasticConstants=ComputeBornTerm=ComputeCrossTerm=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeElasticConstantsThirdOrder=FALSE;
}
if(strcasecmp("ComputePowderDiffractionPattern",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputePowderDiffractionPattern=TRUE;
if(strcasecmp("no",firstargument)==0) ComputePowderDiffractionPattern=FALSE;
}
if(strcasecmp("DiffractionType",keyword)==0)
{
if(strcasecmp("xray",firstargument)==0) Diffraction.Type=XRAY_DIFFRACTION;
if(strcasecmp("neutron",firstargument)==0) Diffraction.Type=NEUTRON_DIFFRACTION;
if(strcasecmp("electron",firstargument)==0) Diffraction.Type=ELECTRON_DIFFRACTION;
}
if(strcasecmp("DiffractionRadiationType",keyword)==0)
{
if(strcasecmp("chromium",firstargument)==0) Diffraction.RadiationType=CHROMIUM_RADIATION;
if(strcasecmp("iron",firstargument)==0) Diffraction.RadiationType=IRON_RADIATION;
if(strcasecmp("copper",firstargument)==0) Diffraction.RadiationType=COPPER_RADIATION;
if(strcasecmp("molybdenum",firstargument)==0) Diffraction.RadiationType=MOLYBDENUM_RADIATION;
if(strcasecmp("silver",firstargument)==0) Diffraction.RadiationType=SILVER_RADIATION;
if(strcasecmp("synchrotron",firstargument)==0) Diffraction.RadiationType=SYNCHROTRON_RADIATION;
}
if(strcasecmp("WaveLengthType",keyword)==0)
{
if(strcasecmp("Single",firstargument)==0) Diffraction.lambda_type=DIFFRACTION_SINGLE;
if(strcasecmp("Double",firstargument)==0) Diffraction.lambda_type=DIFFRACTION_DOUBLET;
}
if(strcasecmp("PeakShape",keyword)==0)
{
if(strcasecmp("Gaussian",firstargument)==0) Diffraction.PeakShape=DIFFRACTION_GAUSSIAN;
if(strcasecmp("Lorentzian",firstargument)==0) Diffraction.PeakShape=DIFFRACTION_LORENTZIAN;
if(strcasecmp("PseudoVoigt",firstargument)==0) Diffraction.PeakShape=DIFFRACTION_PSEUDO_VOIGT;
}
if(strcasecmp("WaveLength",keyword)==0) sscanf(arguments,"%lf",&Wavelength);
if(strcasecmp("TwoThetaMin",keyword)==0) sscanf(arguments,"%lf",&Diffraction.two_theta_min);
if(strcasecmp("TwoThetaMax",keyword)==0) sscanf(arguments,"%lf",&Diffraction.two_theta_max);
if(strcasecmp("TwoThetaStep",keyword)==0) sscanf(arguments,"%lf",&Diffraction.two_theta_step);
if(strcasecmp("PeakWidthModifierU",keyword)==0) sscanf(arguments,"%lf",&Diffraction.u);
if(strcasecmp("PeakWidthModifierV",keyword)==0) sscanf(arguments,"%lf",&Diffraction.v);
if(strcasecmp("PeakWidthModifierW",keyword)==0) sscanf(arguments,"%lf",&Diffraction.w);
if(strcasecmp("ComputeNormalModes",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeNormalModes=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeNormalModes=FALSE;
}
if(strcasecmp("CorrectNormalModesForConstraints",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) CorrectNormalModesForConstraints=TRUE;
if(strcasecmp("no",firstargument)==0) CorrectNormalModesForConstraints=FALSE;
}
if(strcasecmp("MinimumMode",keyword)==0) sscanf(arguments,"%d",&MinimumMode);
if(strcasecmp("MaximumMode",keyword)==0) sscanf(arguments,"%d",&MaximumMode);
if(strcasecmp("ModeResolution",keyword)==0) sscanf(arguments,"%d",&ModeResolution);
if(strcasecmp("WriteVTKGrids",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) WriteVTKGrids=TRUE;
if(strcasecmp("no",firstargument)==0) WriteVTKGrids=FALSE;
}
if(strcasecmp("VTKFractionalFrameworkAtomsMin",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalFrameworkAtomsMin.x,&VTKFractionalFrameworkAtomsMin.y,&VTKFractionalFrameworkAtomsMin.z);
if(strcasecmp("VTKFractionalFrameworkAtomsMax",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalFrameworkAtomsMax.x,&VTKFractionalFrameworkAtomsMax.y,&VTKFractionalFrameworkAtomsMax.z);
if(strcasecmp("VTKFractionalFrameworkBondsMin",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalFrameworkBondsMin.x,&VTKFractionalFrameworkBondsMin.y,&VTKFractionalFrameworkBondsMin.z);
if(strcasecmp("VTKFractionalFrameworkBondsMax",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalFrameworkBondsMax.x,&VTKFractionalFrameworkBondsMax.y,&VTKFractionalFrameworkBondsMax.z);
if(strcasecmp("VTKFractionalAdsorbateMin",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalAdsorbateComMin.x,&VTKFractionalAdsorbateComMin.y,&VTKFractionalAdsorbateComMin.z);
if(strcasecmp("VTKFractionalAdsorbateMax",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalAdsorbateComMax.x,&VTKFractionalAdsorbateComMax.y,&VTKFractionalAdsorbateComMax.z);
if(strcasecmp("VTKFractionalCationMin",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalCationComMin.x,&VTKFractionalCationComMin.y,&VTKFractionalCationComMin.z);
if(strcasecmp("VTKFractionalCationMax",keyword)==0)
sscanf(arguments,"%lf %lf %lf",&VTKFractionalCationComMax.x,&VTKFractionalCationComMax.y,&VTKFractionalCationComMax.z);
if(strcasecmp("FreeEnergyAveragingTypeVTK",keyword)==0)
{
if((strcasecmp("unit_cell",firstargument)==0)||(strcasecmp("UnitCell",firstargument)==0)) FreeEnergyAveragingTypeVTK=VTK_UNIT_CELL;
if((strcasecmp("full_box",firstargument)==0)||(strcasecmp("FullBox",firstargument)==0)) FreeEnergyAveragingTypeVTK=VTK_FULL_BOX;
}
// read energy/force grid options
if(strcasecmp("UseTabularGrid",keyword)==0)
if((strcasecmp(firstargument,"yes")==0)&&(SimulationType!=MAKE_GRID)) UseTabularGrid=TRUE;
if(strcasecmp("SpacingVDWGrid",keyword)==0) sscanf(arguments,"%lf",&SpacingVDWGrid);
if(strcasecmp("SpacingCoulombGrid",keyword)==0) sscanf(arguments,"%lf",&SpacingCoulombGrid);
if(strcasecmp("NumberOfGrids",keyword)==0)
{
sscanf(arguments,"%d",&NumberOfGrids);
GridTypeListName=(char(*)[256])calloc(NumberOfGrids,sizeof(char[256]));
}
if(strcasecmp("GridTypes",keyword)==0)
{
for(j=0;j<NumberOfGrids;j++)
sscanf(arguments,"%s %[^\n]",GridTypeListName[j],arguments);
}
if(strcasecmp("BlockEnergyGrids",keyword)==0)
{
if(strcasecmp(firstargument,"yes")==0) BlockEnergyGrids=TRUE;
if(strcasecmp(firstargument,"no")==0) BlockEnergyGrids=FALSE;
}
if(strcasecmp("BlockGridPockets",keyword)==0)
{
if(strcasecmp(firstargument,"yes")==0) BlockGridPockets=TRUE;
if(strcasecmp(firstargument,"no")==0) BlockGridPockets=FALSE;
}
if(strcasecmp("BlockGridPores",keyword)==0)
{
if(strcasecmp(firstargument,"yes")==0) BlockGridPores=TRUE;
if(strcasecmp(firstargument,"no")==0) BlockGridPores=FALSE;
}
if(strcasecmp("BlockEnergyGridOverlapCriteria",keyword)==0) sscanf(arguments,"%lf",&BlockEnergyGridOverlapCriteria);
if(strcasecmp("GridSeed",keyword)==0)
{
GridSeeds=realloc(GridSeeds,(NumberOfGridSeeds+1)*sizeof(VECTOR));
if(!GridSeeds)
{
printf("Memory reallocation error of 'GridSeeds' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%lf %lf %lf",&GridSeeds[NumberOfGridSeeds].x,&GridSeeds[NumberOfGridSeeds].y,&GridSeeds[NumberOfGridSeeds].z);
NumberOfGridSeeds++;
}
// read method of minimization
if(strcasecmp("MinimizationMethod",keyword)==0)
{
if(strcasecmp("SteepestDescent",firstargument)==0) MinimizationMethod=STEEPEST_DESCENT_MINIMIZATION;
if(strcasecmp("ConjugateGradient",firstargument)==0) MinimizationMethod=CONJUGATE_GRADIENT_MINIMIZATION;
if(strcasecmp("bfgc",firstargument)==0) MinimizationMethod=BFGS_MINIMIZATION;
if(strcasecmp("Snyman",firstargument)==0) MinimizationMethod=SNYMAN_MINIMIZATION;
if((strcasecmp("Baker",firstargument)==0)||(strcasecmp("BakerMinimization",firstargument)==0)) MinimizationMethod=BAKER_MINIMIZATION;
if((strcasecmp("NewtonRaphson",firstargument)==0)||(strcasecmp("NewtonRaphsonMinimization",firstargument)==0)) MinimizationMethod=NEWTON_RAPHSON_MINIMIZATION;
if((strcasecmp("BakerSaddlePoint",firstargument)==0)||(strcasecmp("SaddlePoint",firstargument)==0)) MinimizationMethod=BAKER_SADDLE_POINT;
}
if(strcasecmp("MinimizationVariables",keyword)==0)
{
if(strcasecmp("Fractional",firstargument)==0) MinimizationVariables=FRACTIONAL;
if(strcasecmp("Cartesian",firstargument)==0) MinimizationVariables=CARTESIAN;
}
if(strcasecmp("UseSymmetryInMinimization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) UseSymmetryInMinimization=TRUE;
if(strcasecmp("no",firstargument)==0) UseSymmetryInMinimization=FALSE;
}
if(strcasecmp("MaximumNumberOfMinimizationSteps",keyword)==0) sscanf(arguments,"%d",&MaximumNumberOfMinimizationSteps);
if(strcasecmp("RMSGradientTolerance",keyword)==0) sscanf(arguments,"%lf",&RMSGradientTolerance);
if(strcasecmp("MaxGradientTolerance",keyword)==0) sscanf(arguments,"%lf",&MaxGradientTolerance);
if(strcasecmp("MaximumStepLength",keyword)==0)
{
sscanf(arguments,"%lf",&MaximumStepLengthInput);
MaximumStepLength=MaximumStepLengthInput;
}
if(strcasecmp("MinimizationConvergenceFactor",keyword)==0)
sscanf(arguments,"%lf",&MinimizationConvergenceFactor);
if(strcasecmp("UseGradientInLineMinimization",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) UseGradientInLineMinimization=TRUE;
if(strcasecmp("no",firstargument)==0) UseGradientInLineMinimization=FALSE;
}
if(strcasecmp("TransformUnitCell",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) TransformUnitCell=TRUE;
if(strcasecmp("no",firstargument)==0) TransformUnitCell=FALSE;
}
if(strcasecmp("UnitCellDeformation",keyword)==0) sscanf(arguments,"%lf",&UnitCellDeformation);
if(strcasecmp("ElasticConstantEnergyVolume",keyword)==0)
{
if(strcasecmp("CUBIC_C44",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_CUBIC_C44;
if(strcasecmp("CUBIC_CS",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_CUBIC_CS;
if(strcasecmp("CUBIC_C66",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_CUBIC_C66;
if(strcasecmp("HEXAGONAL_C44",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_HEXAGONAL_C44;
if(strcasecmp("BULK_MODULUS",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_BULK_MODULUS;
if(strcasecmp("ORTHO_C11",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_ORTHO_C11;
if(strcasecmp("ORTHO_C12",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_ORTHO_C12;
if(strcasecmp("ORTHO_C13",firstargument)==0) ElasticConstantEnergyVolume=ELASTIC_CONSTANT_ORTHO_C13;
}
if(strcasecmp("MinimizationPotentialMethod",keyword)==0)
{
if(strcasecmp("Analytically",firstargument)==0) MinimizationPotentialMethod=ANALYTICALLY;
if(strcasecmp("Numerically",firstargument)==0) MinimizationPotentialMethod=NUMERICALLY;
}
if(strcasecmp("ComputeLambda",keyword)==0)
{
if(strcasecmp("LambdaMethod1",firstargument)==0) ComputeLambda=LAMBDA_METHOD_1;
if(strcasecmp("LambdaMethod2",firstargument)==0) ComputeLambda=LAMBDA_METHOD_2;
}
if(strcasecmp("RemoveTranslationFromHessian",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) RemoveTranslationFromHessian=TRUE;
if(strcasecmp("no",firstargument)==0) RemoveTranslationFromHessian=FALSE;
}
if(strcasecmp("RemoveRotationFromHessian",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) RemoveRotationFromHessian=TRUE;
if(strcasecmp("no",firstargument)==0) RemoveRotationFromHessian=FALSE;
}
if(strcasecmp("FrameworkFixedInitialization",keyword)==0)
{
if(strcasecmp("free",firstargument)==0) FrameworkFixedInitialization[CurrentSystem][CurrentFramework]=FREE;
if(strcasecmp("fixed",firstargument)==0) FrameworkFixedInitialization[CurrentSystem][CurrentFramework]=FIXED;
}
if(strcasecmp("AdsorbateFixedInitialization",keyword)==0)
{
if(strcasecmp("free",firstargument)==0) AdsorbateFixedInitialization[CurrentSystem]=FREE;
if(strcasecmp("fixed",firstargument)==0) AdsorbateFixedInitialization[CurrentSystem]=FIXED;
}
if(strcasecmp("CationFixedInitialization",keyword)==0)
{
if(strcasecmp("free",firstargument)==0) CationFixedInitialization[CurrentSystem]=FREE;
if(strcasecmp("fixed",firstargument)==0) CationFixedInitialization[CurrentSystem]=FIXED;
}
if(strcasecmp("ActiveFrameworkAtom",keyword)==0)
{
ActiveFrameworkAtoms[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtoms[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtoms[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!ActiveFrameworkAtoms[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtoms[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&ActiveFrameworkAtoms[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtoms[CurrentSystem][CurrentFramework]]);
NumberOfActiveFrameworkAtoms[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("ActiveFrameworkAtomX",keyword)==0)
{
ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]]);
NumberOfActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("ActiveFrameworkAtomY",keyword)==0)
{
ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]]);
NumberOfActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("ActiveFrameworkAtomZ",keyword)==0)
{
ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]]);
NumberOfActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("ActiveFrameworkAtoms",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
ActiveFrameworkAtoms[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtoms[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtoms[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!ActiveFrameworkAtoms[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtoms[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&ActiveFrameworkAtoms[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtoms[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("ActiveFrameworkAtomsX",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&ActiveFrameworkAtomsX[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtomsX[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("ActiveFrameworkAtomsY",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&ActiveFrameworkAtomsY[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtomsY[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("ActiveFrameworkAtomsZ",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]=(int*)realloc(ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework],
(NumberOfActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&ActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework][NumberOfActiveFrameworkAtomsZ[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("FixedFrameworkAtom",keyword)==0)
{
FixedFrameworkAtoms[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtoms[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtoms[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!FixedFrameworkAtoms[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtoms[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&FixedFrameworkAtoms[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtoms[CurrentSystem][CurrentFramework]]);
NumberOfFixedFrameworkAtoms[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("FixedFrameworkAtomX",keyword)==0)
{
FixedFrameworkAtomsX[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtomsX[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtomsX[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!FixedFrameworkAtomsX[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtomsX[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&FixedFrameworkAtomsX[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtomsX[CurrentSystem][CurrentFramework]]);
NumberOfFixedFrameworkAtomsX[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("FixedFrameworkAtomY",keyword)==0)
{
FixedFrameworkAtomsY[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtomsY[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtomsY[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!FixedFrameworkAtomsY[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtomsY[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&FixedFrameworkAtomsY[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtomsY[CurrentSystem][CurrentFramework]]);
NumberOfFixedFrameworkAtomsY[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("FixedFrameworkAtomZ",keyword)==0)
{
FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]+1)*sizeof(int));
if(!FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]]);
NumberOfFixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]++;
}
if(strcasecmp("FixedFrameworkAtoms",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
FixedFrameworkAtoms[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtoms[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtoms[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!FixedFrameworkAtoms[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtoms[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&FixedFrameworkAtoms[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtoms[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("FixedFrameworkAtomsX",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
FixedFrameworkAtomsX[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtomsX[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtomsX[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!FixedFrameworkAtomsX[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtomsX[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&FixedFrameworkAtomsX[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtomsX[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("FixedFrameworkAtomsY",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
FixedFrameworkAtomsY[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtomsY[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtomsY[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!FixedFrameworkAtomsY[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtomsY[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&FixedFrameworkAtomsY[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtomsY[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("FixedFrameworkAtomsZ",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]=(int*)realloc(FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework],
(NumberOfFixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]+temp_int)*sizeof(int));
if(!FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework])
{
printf("Memory reallocation error of 'FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%d%[^\n]",&FixedFrameworkAtomsZ[CurrentSystem][CurrentFramework][NumberOfFixedFrameworkAtomsZ[CurrentSystem][CurrentFramework]++],arguments);
}
if(strcasecmp("ActiveAdsorbateMolecule",keyword)==0)
{
ActiveAdsorbateMolecules[CurrentSystem]=(int*)realloc(ActiveAdsorbateMolecules[CurrentSystem],(NumberOfActiveAdsorbateMolecules[CurrentSystem]+1)*sizeof(int));
if(!ActiveAdsorbateMolecules[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateMolecules[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&ActiveAdsorbateMolecules[CurrentSystem][NumberOfActiveAdsorbateMolecules[CurrentSystem]]);
NumberOfActiveAdsorbateMolecules[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateMolecule",keyword)==0)
{
FixedAdsorbateMolecules[CurrentSystem]=(int*)realloc(FixedAdsorbateMolecules[CurrentSystem],(NumberOfFixedAdsorbateMolecules[CurrentSystem]+1)*sizeof(int));
if(!FixedAdsorbateMolecules[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateMolecules[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&FixedAdsorbateMolecules[CurrentSystem][NumberOfFixedAdsorbateMolecules[CurrentSystem]]);
NumberOfFixedAdsorbateMolecules[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateAtom",keyword)==0)
{
ActiveAdsorbateAtoms[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateAtoms[CurrentSystem],(NumberOfActiveAdsorbateAtoms[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateAtoms[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateAtoms[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateAtoms[CurrentSystem][NumberOfActiveAdsorbateAtoms[CurrentSystem]].A,
&ActiveAdsorbateAtoms[CurrentSystem][NumberOfActiveAdsorbateAtoms[CurrentSystem]].B);
NumberOfActiveAdsorbateAtoms[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateAtomX",keyword)==0)
{
ActiveAdsorbateAtomsX[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateAtomsX[CurrentSystem],(NumberOfActiveAdsorbateAtomsX[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateAtomsX[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateAtomsX[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateAtomsX[CurrentSystem][NumberOfActiveAdsorbateAtomsX[CurrentSystem]].A,
&ActiveAdsorbateAtomsX[CurrentSystem][NumberOfActiveAdsorbateAtomsX[CurrentSystem]].B);
NumberOfActiveAdsorbateAtomsX[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateAtomY",keyword)==0)
{
ActiveAdsorbateAtomsY[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateAtomsY[CurrentSystem],(NumberOfActiveAdsorbateAtomsY[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateAtomsY[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateAtomsY[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateAtomsY[CurrentSystem][NumberOfActiveAdsorbateAtomsY[CurrentSystem]].A,
&ActiveAdsorbateAtomsY[CurrentSystem][NumberOfActiveAdsorbateAtomsY[CurrentSystem]].B);
NumberOfActiveAdsorbateAtomsY[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateAtomZ",keyword)==0)
{
ActiveAdsorbateAtomsZ[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateAtomsZ[CurrentSystem],(NumberOfActiveAdsorbateAtomsZ[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateAtomsZ[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateAtomsZ[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateAtomsZ[CurrentSystem][NumberOfActiveAdsorbateAtomsZ[CurrentSystem]].A,
&ActiveAdsorbateAtomsZ[CurrentSystem][NumberOfActiveAdsorbateAtomsZ[CurrentSystem]].B);
NumberOfActiveAdsorbateAtomsZ[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateAtom",keyword)==0)
{
FixedAdsorbateAtoms[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateAtoms[CurrentSystem],(NumberOfFixedAdsorbateAtoms[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateAtoms[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateAtoms[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateAtoms[CurrentSystem][NumberOfFixedAdsorbateAtoms[CurrentSystem]].A,
&FixedAdsorbateAtoms[CurrentSystem][NumberOfFixedAdsorbateAtoms[CurrentSystem]].B);
NumberOfFixedAdsorbateAtoms[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateAtomX",keyword)==0)
{
FixedAdsorbateAtomsX[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateAtomsX[CurrentSystem],(NumberOfFixedAdsorbateAtomsX[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateAtomsX[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateAtomsX[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateAtomsX[CurrentSystem][NumberOfFixedAdsorbateAtomsX[CurrentSystem]].A,
&FixedAdsorbateAtomsX[CurrentSystem][NumberOfFixedAdsorbateAtomsX[CurrentSystem]].B);
NumberOfFixedAdsorbateAtomsX[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateAtomY",keyword)==0)
{
FixedAdsorbateAtomsY[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateAtomsY[CurrentSystem],(NumberOfFixedAdsorbateAtomsY[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateAtomsY[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateAtomsY[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateAtomsY[CurrentSystem][NumberOfFixedAdsorbateAtomsY[CurrentSystem]].A,
&FixedAdsorbateAtomsY[CurrentSystem][NumberOfFixedAdsorbateAtomsY[CurrentSystem]].B);
NumberOfFixedAdsorbateAtomsY[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateAtomZ",keyword)==0)
{
FixedAdsorbateAtomsZ[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateAtomsZ[CurrentSystem],(NumberOfFixedAdsorbateAtomsZ[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateAtomsZ[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateAtomsZ[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateAtomsZ[CurrentSystem][NumberOfFixedAdsorbateAtomsZ[CurrentSystem]].A,
&FixedAdsorbateAtomsZ[CurrentSystem][NumberOfFixedAdsorbateAtomsZ[CurrentSystem]].B);
NumberOfFixedAdsorbateAtomsZ[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateGroup",keyword)==0)
{
ActiveAdsorbateGroups[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateGroups[CurrentSystem],(NumberOfActiveAdsorbateGroups[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateGroups[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateGroups[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateGroups[CurrentSystem][NumberOfActiveAdsorbateGroups[CurrentSystem]].A,
&ActiveAdsorbateGroups[CurrentSystem][NumberOfActiveAdsorbateGroups[CurrentSystem]].B);
NumberOfActiveAdsorbateGroups[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroup",keyword)==0)
{
FixedAdsorbateGroups[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroups[CurrentSystem],(NumberOfFixedAdsorbateGroups[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroups[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroups[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroups[CurrentSystem][NumberOfFixedAdsorbateGroups[CurrentSystem]].A,
&FixedAdsorbateGroups[CurrentSystem][NumberOfFixedAdsorbateGroups[CurrentSystem]].B);
NumberOfFixedAdsorbateGroups[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateGroupCenterOfMass",keyword)==0)
{
ActiveAdsorbateGroupsCenterOfMass[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateGroupsCenterOfMass[CurrentSystem],
(NumberOfActiveAdsorbateGroupsCenterOfMass[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateGroupsCenterOfMass[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateGroupsCenterOfMass[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateGroupsCenterOfMass[CurrentSystem][NumberOfActiveAdsorbateGroupsCenterOfMass[CurrentSystem]].A,
&ActiveAdsorbateGroupsCenterOfMass[CurrentSystem][NumberOfActiveAdsorbateGroupsCenterOfMass[CurrentSystem]].B);
NumberOfActiveAdsorbateGroupsCenterOfMass[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupCenterOfMass",keyword)==0)
{
FixedAdsorbateGroupsCenterOfMass[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsCenterOfMass[CurrentSystem],
(NumberOfFixedAdsorbateGroupsCenterOfMass[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsCenterOfMass[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsCenterOfMass[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsCenterOfMass[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMass[CurrentSystem]].A,
&FixedAdsorbateGroupsCenterOfMass[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMass[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsCenterOfMass[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupCenterOfMassX",keyword)==0)
{
FixedAdsorbateGroupsCenterOfMassX[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsCenterOfMassX[CurrentSystem],
(NumberOfFixedAdsorbateGroupsCenterOfMassX[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsCenterOfMassX[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsCenterOfMassX[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsCenterOfMassX[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMassX[CurrentSystem]].A,
&FixedAdsorbateGroupsCenterOfMassX[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMassX[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsCenterOfMassX[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupCenterOfMassY",keyword)==0)
{
FixedAdsorbateGroupsCenterOfMassY[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsCenterOfMassY[CurrentSystem],
(NumberOfFixedAdsorbateGroupsCenterOfMassY[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsCenterOfMassY[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsCenterOfMassY[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsCenterOfMassY[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMassY[CurrentSystem]].A,
&FixedAdsorbateGroupsCenterOfMassY[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMassY[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsCenterOfMassY[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupCenterOfMassZ",keyword)==0)
{
FixedAdsorbateGroupsCenterOfMassZ[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsCenterOfMassZ[CurrentSystem],
(NumberOfFixedAdsorbateGroupsCenterOfMassZ[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsCenterOfMassZ[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsCenterOfMassZ[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsCenterOfMassZ[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMassZ[CurrentSystem]].A,
&FixedAdsorbateGroupsCenterOfMassZ[CurrentSystem][NumberOfFixedAdsorbateGroupsCenterOfMassZ[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsCenterOfMassZ[CurrentSystem]++;
}
if(strcasecmp("ActiveAdsorbateGroupOrientation",keyword)==0)
{
ActiveAdsorbateGroupsOrientation[CurrentSystem]=(PAIR*)realloc(ActiveAdsorbateGroupsOrientation[CurrentSystem],
(NumberOfActiveAdsorbateGroupsOrientation[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveAdsorbateGroupsOrientation[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveAdsorbateGroupsOrientation[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveAdsorbateGroupsOrientation[CurrentSystem][NumberOfActiveAdsorbateGroupsOrientation[CurrentSystem]].A,
&ActiveAdsorbateGroupsOrientation[CurrentSystem][NumberOfActiveAdsorbateGroupsOrientation[CurrentSystem]].B);
NumberOfActiveAdsorbateGroupsOrientation[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupOrientation",keyword)==0)
{
FixedAdsorbateGroupsOrientation[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsOrientation[CurrentSystem],
(NumberOfFixedAdsorbateGroupsOrientation[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsOrientation[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsOrientation[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsOrientation[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientation[CurrentSystem]].A,
&FixedAdsorbateGroupsOrientation[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientation[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsOrientation[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupOrientationX",keyword)==0)
{
FixedAdsorbateGroupsOrientationX[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsOrientationX[CurrentSystem],
(NumberOfFixedAdsorbateGroupsOrientationX[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsOrientationX[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsOrientationX[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsOrientationX[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientationX[CurrentSystem]].A,
&FixedAdsorbateGroupsOrientationX[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientationX[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsOrientationX[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupOrientationY",keyword)==0)
{
FixedAdsorbateGroupsOrientationY[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsOrientationY[CurrentSystem],
(NumberOfFixedAdsorbateGroupsOrientationY[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsOrientationY[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsOrientationY[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsOrientationY[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientationY[CurrentSystem]].A,
&FixedAdsorbateGroupsOrientationY[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientationY[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsOrientationY[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateGroupOrientationZ",keyword)==0)
{
FixedAdsorbateGroupsOrientationZ[CurrentSystem]=(PAIR*)realloc(FixedAdsorbateGroupsOrientationZ[CurrentSystem],
(NumberOfFixedAdsorbateGroupsOrientationZ[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedAdsorbateGroupsOrientationZ[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateGroupsOrientationZ[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedAdsorbateGroupsOrientationZ[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientationZ[CurrentSystem]].A,
&FixedAdsorbateGroupsOrientationZ[CurrentSystem][NumberOfFixedAdsorbateGroupsOrientationZ[CurrentSystem]].B);
NumberOfFixedAdsorbateGroupsOrientationZ[CurrentSystem]++;
}
if(strcasecmp("ActiveCationMolecule",keyword)==0)
{
ActiveCationMolecules[CurrentSystem]=(int*)realloc(ActiveCationMolecules[CurrentSystem],(NumberOfActiveCationMolecules[CurrentSystem]+1)*sizeof(int));
if(!ActiveCationMolecules[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationMolecules[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&ActiveCationMolecules[CurrentSystem][NumberOfActiveCationMolecules[CurrentSystem]]);
NumberOfActiveCationMolecules[CurrentSystem]++;
}
if(strcasecmp("FixedAdsorbateMolecule",keyword)==0)
{
FixedAdsorbateMolecules[CurrentSystem]=(int*)realloc(FixedAdsorbateMolecules[CurrentSystem],(NumberOfFixedAdsorbateMolecules[CurrentSystem]+1)*sizeof(int));
if(!FixedAdsorbateMolecules[CurrentSystem])
{
printf("Memory reallocation error of 'FixedAdsorbateMolecules[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d",&FixedAdsorbateMolecules[CurrentSystem][NumberOfFixedAdsorbateMolecules[CurrentSystem]]);
NumberOfFixedAdsorbateMolecules[CurrentSystem]++;
}
if(strcasecmp("ActiveCationAtom",keyword)==0)
{
ActiveCationAtoms[CurrentSystem]=(PAIR*)realloc(ActiveCationAtoms[CurrentSystem],(NumberOfActiveCationAtoms[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationAtoms[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationAtoms[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationAtoms[CurrentSystem][NumberOfActiveCationAtoms[CurrentSystem]].A,
&ActiveCationAtoms[CurrentSystem][NumberOfActiveCationAtoms[CurrentSystem]].B);
NumberOfActiveCationAtoms[CurrentSystem]++;
}
if(strcasecmp("ActiveCationAtomX",keyword)==0)
{
ActiveCationAtomsX[CurrentSystem]=(PAIR*)realloc(ActiveCationAtomsX[CurrentSystem],(NumberOfActiveCationAtomsX[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationAtomsX[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationAtomsX[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationAtomsX[CurrentSystem][NumberOfActiveCationAtomsX[CurrentSystem]].A,
&ActiveCationAtomsX[CurrentSystem][NumberOfActiveCationAtomsX[CurrentSystem]].B);
NumberOfActiveCationAtomsX[CurrentSystem]++;
}
if(strcasecmp("ActiveCationAtomY",keyword)==0)
{
ActiveCationAtomsY[CurrentSystem]=(PAIR*)realloc(ActiveCationAtomsY[CurrentSystem],(NumberOfActiveCationAtomsY[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationAtomsY[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationAtomsY[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationAtomsY[CurrentSystem][NumberOfActiveCationAtomsY[CurrentSystem]].A,
&ActiveCationAtomsY[CurrentSystem][NumberOfActiveCationAtomsY[CurrentSystem]].B);
NumberOfActiveCationAtomsY[CurrentSystem]++;
}
if(strcasecmp("ActiveCationAtomZ",keyword)==0)
{
ActiveCationAtomsZ[CurrentSystem]=(PAIR*)realloc(ActiveCationAtomsZ[CurrentSystem],(NumberOfActiveCationAtomsZ[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationAtomsZ[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationAtomsZ[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationAtomsZ[CurrentSystem][NumberOfActiveCationAtomsZ[CurrentSystem]].A,
&ActiveCationAtomsZ[CurrentSystem][NumberOfActiveCationAtomsZ[CurrentSystem]].B);
NumberOfActiveCationAtomsZ[CurrentSystem]++;
}
if(strcasecmp("FixedCationAtom",keyword)==0)
{
FixedCationAtoms[CurrentSystem]=(PAIR*)realloc(FixedCationAtoms[CurrentSystem],(NumberOfFixedCationAtoms[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationAtoms[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationAtoms[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationAtoms[CurrentSystem][NumberOfFixedCationAtoms[CurrentSystem]].A,
&FixedCationAtoms[CurrentSystem][NumberOfFixedCationAtoms[CurrentSystem]].B);
NumberOfFixedCationAtoms[CurrentSystem]++;
}
if(strcasecmp("FixedCationAtomX",keyword)==0)
{
FixedCationAtomsX[CurrentSystem]=(PAIR*)realloc(FixedCationAtomsX[CurrentSystem],(NumberOfFixedCationAtomsX[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationAtomsX[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationAtomsX[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationAtomsX[CurrentSystem][NumberOfFixedCationAtomsX[CurrentSystem]].A,
&FixedCationAtomsX[CurrentSystem][NumberOfFixedCationAtomsX[CurrentSystem]].B);
NumberOfFixedCationAtomsX[CurrentSystem]++;
}
if(strcasecmp("FixedCationAtomY",keyword)==0)
{
FixedCationAtomsY[CurrentSystem]=(PAIR*)realloc(FixedCationAtomsY[CurrentSystem],(NumberOfFixedCationAtomsY[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationAtomsY[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationAtomsY[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationAtomsY[CurrentSystem][NumberOfFixedCationAtomsY[CurrentSystem]].A,
&FixedCationAtomsY[CurrentSystem][NumberOfFixedCationAtomsY[CurrentSystem]].B);
NumberOfFixedCationAtomsY[CurrentSystem]++;
}
if(strcasecmp("FixedCationAtomZ",keyword)==0)
{
FixedCationAtomsZ[CurrentSystem]=(PAIR*)realloc(FixedCationAtomsZ[CurrentSystem],(NumberOfFixedCationAtomsZ[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationAtomsZ[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationAtomsZ[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationAtomsZ[CurrentSystem][NumberOfFixedCationAtomsZ[CurrentSystem]].A,
&FixedCationAtomsZ[CurrentSystem][NumberOfFixedCationAtomsZ[CurrentSystem]].B);
NumberOfFixedCationAtomsZ[CurrentSystem]++;
}
if(strcasecmp("ActiveCationGroup",keyword)==0)
{
ActiveCationGroups[CurrentSystem]=(PAIR*)realloc(ActiveCationGroups[CurrentSystem],(NumberOfActiveCationGroups[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationGroups[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationGroups[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationGroups[CurrentSystem][NumberOfActiveCationGroups[CurrentSystem]].A,
&ActiveCationGroups[CurrentSystem][NumberOfActiveCationGroups[CurrentSystem]].B);
NumberOfActiveCationGroups[CurrentSystem]++;
}
if(strcasecmp("FixedCationGroup",keyword)==0)
{
FixedCationGroups[CurrentSystem]=(PAIR*)realloc(FixedCationGroups[CurrentSystem],(NumberOfFixedCationGroups[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationGroups[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationGroups[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationGroups[CurrentSystem][NumberOfFixedCationGroups[CurrentSystem]].A,
&FixedCationGroups[CurrentSystem][NumberOfFixedCationGroups[CurrentSystem]].B);
NumberOfFixedCationGroups[CurrentSystem]++;
}
if(strcasecmp("ActiveCationGroupCenterOfMass",keyword)==0)
{
ActiveCationGroupsCenterOfMass[CurrentSystem]=(PAIR*)realloc(ActiveCationGroupsCenterOfMass[CurrentSystem],
(NumberOfActiveCationGroupsCenterOfMass[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationGroupsCenterOfMass[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationGroupsCenterOfMass[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationGroupsCenterOfMass[CurrentSystem][NumberOfActiveCationGroupsCenterOfMass[CurrentSystem]].A,
&ActiveCationGroupsCenterOfMass[CurrentSystem][NumberOfActiveCationGroupsCenterOfMass[CurrentSystem]].B);
NumberOfActiveCationGroupsCenterOfMass[CurrentSystem]++;
}
if(strcasecmp("FixedCationGroupCenterOfMass",keyword)==0)
{
FixedCationGroupsCenterOfMass[CurrentSystem]=(PAIR*)realloc(FixedCationGroupsCenterOfMass[CurrentSystem],
(NumberOfFixedCationGroupsCenterOfMass[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationGroupsCenterOfMass[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationGroupsCenterOfMass[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationGroupsCenterOfMass[CurrentSystem][NumberOfFixedCationGroupsCenterOfMass[CurrentSystem]].A,
&FixedCationGroupsCenterOfMass[CurrentSystem][NumberOfFixedCationGroupsCenterOfMass[CurrentSystem]].B);
NumberOfFixedCationGroupsCenterOfMass[CurrentSystem]++;
}
if(strcasecmp("ActiveCationGroupOrientation",keyword)==0)
{
ActiveCationGroupsOrientation[CurrentSystem]=(PAIR*)realloc(ActiveCationGroupsOrientation[CurrentSystem],
(NumberOfActiveCationGroupsOrientation[CurrentSystem]+1)*sizeof(PAIR));
if(!ActiveCationGroupsOrientation[CurrentSystem])
{
printf("Memory reallocation error of 'ActiveCationGroupsOrientation[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&ActiveCationGroupsOrientation[CurrentSystem][NumberOfActiveCationGroupsOrientation[CurrentSystem]].A,
&ActiveCationGroupsOrientation[CurrentSystem][NumberOfActiveCationGroupsOrientation[CurrentSystem]].B);
NumberOfActiveCationGroupsOrientation[CurrentSystem]++;
}
if(strcasecmp("FixedCationGroupOrientation",keyword)==0)
{
FixedCationGroupsOrientation[CurrentSystem]=(PAIR*)realloc(FixedCationGroupsOrientation[CurrentSystem],
(NumberOfFixedCationGroupsOrientation[CurrentSystem]+1)*sizeof(PAIR));
if(!FixedCationGroupsOrientation[CurrentSystem])
{
printf("Memory reallocation error of 'FixedCationGroupsOrientation[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%d%d\n",&FixedCationGroupsOrientation[CurrentSystem][NumberOfFixedCationGroupsOrientation[CurrentSystem]].A,
&FixedCationGroupsOrientation[CurrentSystem][NumberOfFixedCationGroupsOrientation[CurrentSystem]].B);
NumberOfFixedCationGroupsOrientation[CurrentSystem]++;
}
if(strcasecmp("ActiveAtomType",keyword)==0)
{
ActiveAtomTypes=(char(*)[256])realloc(ActiveAtomTypes,(NumberOfActiveAtomTypes+1)*sizeof(char[256]));
if(!ActiveAtomTypes)
{
printf("Memory reallocation error of 'ActiveAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%s",ActiveAtomTypes[NumberOfActiveAtomTypes]);
NumberOfActiveAtomTypes++;
}
if(strcasecmp("ActiveAtomTypes",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
ActiveAtomTypes=(char(*)[256])realloc(ActiveAtomTypes,(NumberOfActiveAtomTypes+temp_int)*sizeof(char[256]));
if(!ActiveAtomTypes)
{
printf("Memory reallocation error of 'ActiveAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%s%[^\n]",ActiveAtomTypes[NumberOfActiveAtomTypes++],arguments);
}
if(strcasecmp("FixedAtomType",keyword)==0)
{
FixedAtomTypes=(char(*)[256])realloc(FixedAtomTypes,(NumberOfFixedAtomTypes+1)*sizeof(char[256]));
if(!FixedAtomTypes)
{
printf("Memory reallocation error of 'FixedAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
sscanf(arguments,"%s",FixedAtomTypes[NumberOfFixedAtomTypes]);
NumberOfFixedAtomTypes++;
}
if(strcasecmp("FixedAtomTypes",keyword)==0)
{
sscanf(arguments,"%d%[^\n]",&temp_int,arguments);
FixedAtomTypes=(char(*)[256])realloc(FixedAtomTypes,(NumberOfFixedAtomTypes+temp_int)*sizeof(char[256]));
if(!FixedAtomTypes)
{
printf("Memory reallocation error of 'FixedAtomTypes' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<temp_int;i++)
sscanf(arguments,"%s%[^\n]",FixedAtomTypes[NumberOfFixedAtomTypes++],arguments);
}
// read the input for the distance histograms between pairs of atoms
if(strcasecmp("DistanceHistogramDefinition",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,arguments);
DistanceHistogramDefinitions[CurrentSystem]=(int(*)[2][3])realloc(DistanceHistogramDefinitions[CurrentSystem],(NumberOfDistanceHistogramDefinitions[CurrentSystem]+1)*sizeof(int[2][3]));
if(!DistanceHistogramDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'DistanceHistogramDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][0][0]=CATION;
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][0][1]=intinput1;
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][1][0]=CATION;
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][1][1]=intinput3;
DistanceHistogramDefinitions[CurrentSystem][NumberOfDistanceHistogramDefinitions[CurrentSystem]][1][2]=intinput4;
NumberOfDistanceHistogramDefinitions[CurrentSystem]++;
}
// read the input for the bend-angle histograms between trimers of atoms
if(strcasecmp("BendAngleHistogramDefinition",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d%*[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,&charinput3,&intinput5,&intinput6);
BendAngleHistogramDefinitions[CurrentSystem]=(int(*)[3][3])realloc(BendAngleHistogramDefinitions[CurrentSystem],
(NumberOfBendAngleHistogramDefinitions[CurrentSystem]+1)*sizeof(int[3][3]));
if(!BendAngleHistogramDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'BendAngleHistogramDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][0][0]=CATION;
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][0][1]=intinput1;
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][1][0]=CATION;
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][1][1]=intinput3;
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][2][0]=CATION;
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][2][1]=intinput5;
BendAngleHistogramDefinitions[CurrentSystem][NumberOfBendAngleHistogramDefinitions[CurrentSystem]][2][2]=intinput6;
NumberOfBendAngleHistogramDefinitions[CurrentSystem]++;
}
// read the input for the dihedral-angle histograms between quads of atoms
if(strcasecmp("DihedralAngleHistogramDefinition",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d%*[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8);
DihedralAngleHistogramDefinitions[CurrentSystem]=(int(*)[4][3])realloc(DihedralAngleHistogramDefinitions[CurrentSystem],
(NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]+1)*sizeof(int[4][3]));
if(!DihedralAngleHistogramDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'DihedralAngleHistogramDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][0][0]=CATION;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][0][1]=intinput1;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][1][0]=CATION;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][1][1]=intinput3;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][2][0]=CATION;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][2][1]=intinput5;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][3][0]=CATION;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][3][1]=intinput7;
DihedralAngleHistogramDefinitions[CurrentSystem][NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]][3][2]=intinput8;
NumberOfDihedralAngleHistogramDefinitions[CurrentSystem]++;
}
// read the input for the angle-between-two-planes histograms
if(strcasecmp("AngleBetweenPlanesHistogramDefinition",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d %c %d %d %c %d %d%*[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,
&charinput5,&intinput9,&intinput10,&charinput6,&intinput11,&intinput12);
AngleBetweenPlanesHistogramDefinitions[CurrentSystem]=(int(*)[6][3])realloc(AngleBetweenPlanesHistogramDefinitions[CurrentSystem],
(NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]+1)*sizeof(int[6][3]));
if(!AngleBetweenPlanesHistogramDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'AngleBetweenPlanesHistogramDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][0][0]=CATION;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][0][1]=intinput1;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][1][0]=CATION;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][1][1]=intinput3;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][2][0]=CATION;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][2][1]=intinput5;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][3][0]=CATION;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][3][1]=intinput7;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][3][2]=intinput8;
if((charinput5=='F')||(charinput5=='f'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][4][0]=FRAMEWORK;
else if((charinput5=='A')||(charinput5=='a'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][4][0]=ADSORBATE;
else if((charinput5=='C')||(charinput5=='c'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][4][0]=CATION;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][4][1]=intinput9;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][4][2]=intinput10;
if((charinput6=='F')||(charinput6=='f'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][5][0]=FRAMEWORK;
else if((charinput6=='A')||(charinput6=='a'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][5][0]=ADSORBATE;
else if((charinput6=='C')||(charinput6=='c'))
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][5][0]=CATION;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][5][1]=intinput11;
AngleBetweenPlanesHistogramDefinitions[CurrentSystem][NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]][5][2]=intinput12;
NumberOfAngleBetweenPlanesHistogramDefinitions[CurrentSystem]++;
}
if(strcasecmp("DistanceConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,arguments);
sscanf(arguments,"%lf",&realinput1);
DistanceDefinitions[CurrentSystem]=(int(*)[2][3])realloc(DistanceDefinitions[CurrentSystem],(NumberOfDistanceConstraints[CurrentSystem]+1)*sizeof(int[2][3]));
if(!DistanceDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'DistanceDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][0][0]=CATION;
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][0][1]=intinput1;
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][1][0]=CATION;
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][1][1]=intinput3;
DistanceDefinitions[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]][1][2]=intinput4;
// optional reference distance
DistanceConstraintParameter[CurrentSystem]=(REAL*)realloc(DistanceConstraintParameter[CurrentSystem],
(NumberOfDistanceConstraints[CurrentSystem]+1)*sizeof(REAL));
if(!DistanceConstraintParameter[CurrentSystem])
{
printf("Memory reallocation error of 'DistanceConstraintParameter[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
DistanceConstraintParameter[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]]=UNDEFINED;
if(sscanf(arguments,"%lf",&realinput1)==1)
DistanceConstraintParameter[CurrentSystem][NumberOfDistanceConstraints[CurrentSystem]]=realinput1;
NumberOfDistanceConstraints[CurrentSystem]++;
}
if(strcasecmp("AngleConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,arguments);
sscanf(arguments,"%lf",&realinput1);
AngleDefinitions[CurrentSystem]=(int(*)[3][3])realloc(AngleDefinitions[CurrentSystem],
(NumberOfAngleConstraints[CurrentSystem]+1)*sizeof(int[3][3]));
if(!AngleDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'AngleDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][0][0]=CATION;
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][0][1]=intinput1;
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][1][0]=CATION;
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][1][1]=intinput3;
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][2][0]=CATION;
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][2][1]=intinput5;
AngleDefinitions[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]][2][2]=intinput6;
// optional reference angle
AngleConstraintParameter[CurrentSystem]=(REAL*)realloc(AngleConstraintParameter[CurrentSystem],
(NumberOfAngleConstraints[CurrentSystem]+1)*sizeof(REAL));
if(!AngleConstraintParameter[CurrentSystem])
{
printf("Memory reallocation error of 'AngleConstraintParameter[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
AngleConstraintParameter[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]]=UNDEFINED;
if(sscanf(arguments,"%lf",&realinput1)==1)
AngleConstraintParameter[CurrentSystem][NumberOfAngleConstraints[CurrentSystem]]=realinput1*DEG2RAD;
NumberOfAngleConstraints[CurrentSystem]++;
}
if(strcasecmp("DihedralConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,arguments);
sscanf(arguments,"%lf",&realinput1);
DihedralDefinitions[CurrentSystem]=(int(*)[4][3])realloc(DihedralDefinitions[CurrentSystem],
(NumberOfDihedralConstraints[CurrentSystem]+1)*sizeof(int[4][3]));
if(!DihedralDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'DihedralDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][0][0]=CATION;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][0][1]=intinput1;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][1][0]=CATION;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][1][1]=intinput3;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][2][0]=CATION;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][2][1]=intinput5;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][3][0]=CATION;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][3][1]=intinput7;
DihedralDefinitions[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]][3][2]=intinput8;
// optional reference dihedral angle
DihedralConstraintParameter[CurrentSystem]=(REAL*)realloc(DihedralConstraintParameter[CurrentSystem],
(NumberOfDihedralConstraints[CurrentSystem]+1)*sizeof(REAL));
if(!DihedralConstraintParameter[CurrentSystem])
{
printf("Memory reallocation error of 'DihedralConstraintParameter[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
DihedralConstraintParameter[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]]=UNDEFINED;
if(sscanf(arguments,"%lf",&realinput1)==1)
DihedralConstraintParameter[CurrentSystem][NumberOfDihedralConstraints[CurrentSystem]]=realinput1*DEG2RAD;
NumberOfDihedralConstraints[CurrentSystem]++;
}
if(strcasecmp("ImproperDihedralConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,arguments);
sscanf(arguments,"%lf",&realinput1);
ImproperDihedralDefinitions[CurrentSystem]=(int(*)[4][3])realloc(ImproperDihedralDefinitions[CurrentSystem],
(NumberOfImproperDihedralConstraints[CurrentSystem]+1)*sizeof(int[4][3]));
if(!ImproperDihedralDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'ImproperDihedralDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][0][0]=CATION;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][0][1]=intinput1;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][1][0]=CATION;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][1][1]=intinput3;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][2][0]=CATION;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][2][1]=intinput5;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][3][0]=CATION;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][3][1]=intinput7;
ImproperDihedralDefinitions[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]][3][2]=intinput8;
// optional reference dihedral angle
ImproperDihedralConstraintParameter[CurrentSystem]=(REAL*)realloc(ImproperDihedralConstraintParameter[CurrentSystem],
(NumberOfImproperDihedralConstraints[CurrentSystem]+1)*sizeof(REAL));
if(!ImproperDihedralConstraintParameter[CurrentSystem])
{
printf("Memory reallocation error of 'ImproperDihedralConstraintParameter[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
ImproperDihedralConstraintParameter[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]]=UNDEFINED;
if(sscanf(arguments,"%lf",&realinput1)==1)
ImproperDihedralConstraintParameter[CurrentSystem][NumberOfImproperDihedralConstraints[CurrentSystem]]=realinput1*DEG2RAD;
NumberOfImproperDihedralConstraints[CurrentSystem]++;
}
if(strcasecmp("InversionBendConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,arguments);
sscanf(arguments,"%lf",&realinput1);
InversionBendDefinitions[CurrentSystem]=(int(*)[4][3])realloc(InversionBendDefinitions[CurrentSystem],
(NumberOfInversionBendConstraints[CurrentSystem]+1)*sizeof(int[4][3]));
if(!InversionBendDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'InversionBendDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][0][0]=CATION;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][0][1]=intinput1;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][1][0]=CATION;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][1][1]=intinput3;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][2][0]=CATION;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][2][1]=intinput5;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][3][0]=CATION;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][3][1]=intinput7;
InversionBendDefinitions[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]][3][2]=intinput8;
// optional reference dihedral angle
InversionBendConstraintParameter[CurrentSystem]=(REAL*)realloc(InversionBendConstraintParameter[CurrentSystem],
(NumberOfInversionBendConstraints[CurrentSystem]+1)*sizeof(REAL));
if(!InversionBendConstraintParameter[CurrentSystem])
{
printf("Memory reallocation error of 'InversionBendConstraintParameter[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
InversionBendConstraintParameter[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]]=UNDEFINED;
if(sscanf(arguments,"%lf",&realinput1)==1)
InversionBendConstraintParameter[CurrentSystem][NumberOfInversionBendConstraints[CurrentSystem]]=realinput1*DEG2RAD;
NumberOfInversionBendConstraints[CurrentSystem]++;
}
if(strcasecmp("OutOfPlaneConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,arguments);
sscanf(arguments,"%lf",&realinput1);
OutOfPlaneDistanceDefinitions[CurrentSystem]=(int(*)[4][3])realloc(OutOfPlaneDistanceDefinitions[CurrentSystem],
(NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]+1)*sizeof(int[4][3]));
if(!OutOfPlaneDistanceDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'OutOfPlaneDistanceDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][0][0]=CATION;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][0][1]=intinput1;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][1][0]=CATION;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][1][1]=intinput3;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][2][0]=CATION;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][2][1]=intinput5;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][3][0]=CATION;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][3][1]=intinput7;
OutOfPlaneDistanceDefinitions[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]][3][2]=intinput8;
// optional reference dihedral angle
OutOfPlaneDistanceConstraintParameter[CurrentSystem]=(REAL*)realloc(OutOfPlaneDistanceConstraintParameter[CurrentSystem],
(NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]+1)*sizeof(REAL));
if(!OutOfPlaneDistanceConstraintParameter[CurrentSystem])
{
printf("Memory reallocation error of 'OutOfPlaneDistanceConstraintParameter[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
OutOfPlaneDistanceConstraintParameter[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]]=UNDEFINED;
if(sscanf(arguments,"%lf",&realinput1)==1)
OutOfPlaneDistanceConstraintParameter[CurrentSystem][NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]]=realinput1*DEG2RAD;
NumberOfOutOfPlaneDistanceConstraints[CurrentSystem]++;
}
if(strcasecmp("HarmonicDistanceConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,arguments);
HarmonicDistanceDefinitions[CurrentSystem]=(int(*)[2][3])realloc(HarmonicDistanceDefinitions[CurrentSystem],
(NumberOfHarmonicDistanceConstraints[CurrentSystem]+1)*sizeof(int[2][3]));
if(!HarmonicDistanceDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'HarmonicDistanceDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0][0]=CATION;
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0][1]=intinput1;
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1][0]=CATION;
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1][1]=intinput3;
HarmonicDistanceDefinitions[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1][2]=intinput4;
// optional bond-constant and reference distance
HarmonicDistanceConstraintParameters[CurrentSystem]=(REAL(*)[2])realloc(HarmonicDistanceConstraintParameters[CurrentSystem],
(NumberOfHarmonicDistanceConstraints[CurrentSystem]+1)*sizeof(REAL[2]));
if(!HarmonicDistanceConstraintParameters[CurrentSystem])
{
printf("Memory reallocation error of 'HarmonicDistanceConstraintParameters[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
HarmonicDistanceConstraintParameters[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0]=1e6/ENERGY_TO_KELVIN;
HarmonicDistanceConstraintParameters[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1]=UNDEFINED;
if(sscanf(arguments,"%lf%lf",&realinput1,&realinput2)==2)
{
HarmonicDistanceConstraintParameters[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0]=realinput1/ENERGY_TO_KELVIN;
HarmonicDistanceConstraintParameters[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][1]=realinput2;
}
else if(sscanf(arguments,"%lf",&realinput1)==1)
HarmonicDistanceConstraintParameters[CurrentSystem][NumberOfHarmonicDistanceConstraints[CurrentSystem]][0]=realinput1/ENERGY_TO_KELVIN;
NumberOfHarmonicDistanceConstraints[CurrentSystem]++;
}
if(strcasecmp("HarmonicAngleConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,arguments);
HarmonicAngleDefinitions[CurrentSystem]=(int(*)[3][3])realloc(HarmonicAngleDefinitions[CurrentSystem],
(NumberOfHarmonicAngleConstraints[CurrentSystem]+1)*sizeof(int[3][3]));
if(!HarmonicAngleDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'HarmonicAngleDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0][0]=CATION;
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0][1]=intinput1;
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1][0]=CATION;
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1][1]=intinput3;
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][2][0]=CATION;
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][2][1]=intinput5;
HarmonicAngleDefinitions[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][2][2]=intinput6;
// optional bend-constant and reference angle
HarmonicAngleConstraintParameters[CurrentSystem]=(REAL(*)[2])realloc(HarmonicAngleConstraintParameters[CurrentSystem],
(NumberOfHarmonicAngleConstraints[CurrentSystem]+1)*sizeof(REAL[2]));
if(!HarmonicAngleConstraintParameters[CurrentSystem])
{
printf("Memory reallocation error of 'HarmonicAngleConstraintParameters[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
HarmonicAngleConstraintParameters[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0]=1e5/ENERGY_TO_KELVIN;
HarmonicAngleConstraintParameters[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1]=UNDEFINED;
if(sscanf(arguments,"%lf%lf",&realinput1,&realinput2)==2)
{
HarmonicAngleConstraintParameters[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0]=realinput1/ENERGY_TO_KELVIN;
HarmonicAngleConstraintParameters[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][1]=realinput2*DEG2RAD;
}
else if(sscanf(arguments,"%lf",&realinput1)==1)
HarmonicAngleConstraintParameters[CurrentSystem][NumberOfHarmonicAngleConstraints[CurrentSystem]][0]=realinput1/ENERGY_TO_KELVIN;
NumberOfHarmonicAngleConstraints[CurrentSystem]++;
}
if(strcasecmp("HarmonicDihedralConstraint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,arguments);
HarmonicDihedralDefinitions[CurrentSystem]=(int(*)[4][3])realloc(HarmonicDihedralDefinitions[CurrentSystem],
(NumberOfHarmonicDihedralConstraints[CurrentSystem]+1)*sizeof(int[4][3]));
if(!HarmonicDihedralDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'HarmonicDihedralDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0][0]=CATION;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0][1]=intinput1;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1][0]=CATION;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1][1]=intinput3;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][2][0]=CATION;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][2][1]=intinput5;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][3][0]=CATION;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][3][1]=intinput7;
HarmonicDihedralDefinitions[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][3][2]=intinput8;
// optional bend-constant and reference angle
HarmonicDihedralConstraintParameters[CurrentSystem]=(REAL(*)[2])realloc(HarmonicDihedralConstraintParameters[CurrentSystem],
(NumberOfHarmonicDihedralConstraints[CurrentSystem]+1)*sizeof(REAL[2]));
if(!HarmonicDihedralConstraintParameters[CurrentSystem])
{
printf("Memory reallocation error of 'HarmonicDihedralConstraintParameters[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
HarmonicDihedralConstraintParameters[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0]=1e5/ENERGY_TO_KELVIN;
HarmonicDihedralConstraintParameters[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1]=UNDEFINED;
if(sscanf(arguments,"%lf%lf",&realinput1,&realinput2)==2)
{
HarmonicDihedralConstraintParameters[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0]=realinput1/ENERGY_TO_KELVIN;
HarmonicDihedralConstraintParameters[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][1]=realinput2*DEG2RAD;
}
else if(sscanf(arguments,"%lf",&realinput1)==1)
HarmonicDihedralConstraintParameters[CurrentSystem][NumberOfHarmonicDihedralConstraints[CurrentSystem]][0]=realinput1/ENERGY_TO_KELVIN;
NumberOfHarmonicDihedralConstraints[CurrentSystem]++;
}
if(strcasecmp("DistanceConstraintType",keyword)==0)
{
if(strcasecmp("Distance",firstargument)==0) DistanceConstraintType=DISTANCE_R;
if(strcasecmp("DistanceSquared",firstargument)==0) DistanceConstraintType=DISTANCE_R_SQUARED;
}
if(strcasecmp("BendConstraintType",keyword)==0)
{
if(strcasecmp("Theta",firstargument)==0) BendConstraintType=THETA;
if(strcasecmp("CosTheta",firstargument)==0) BendConstraintType=COS_THETA;
if(strcasecmp("CosThetaSquared",firstargument)==0) BendConstraintType=COS_THETA_SQUARED;
}
if(strcasecmp("DihedralConstraintType",keyword)==0)
{
if(strcasecmp("Phi",firstargument)==0) DihedralConstraintType=PHI;
if(strcasecmp("CosPhi",firstargument)==0) DihedralConstraintType=COS_PHI;
if(strcasecmp("CosPhiSquared",firstargument)==0) DihedralConstraintType=COS_PHI_SQUARED;
}
if(strcasecmp("ImproperDihedralConstraintType",keyword)==0)
{
if(strcasecmp("Phi",firstargument)==0) ImproperDihedralConstraintType=PHI;
if(strcasecmp("CosPhi",firstargument)==0) ImproperDihedralConstraintType=COS_PHI;
if(strcasecmp("CosPhiSquared",firstargument)==0) ImproperDihedralConstraintType=COS_PHI_SQUARED;
}
if(strcasecmp("InversionBendConstraintType",keyword)==0)
{
if(strcasecmp("Chi",firstargument)==0) InversionBendConstraintType=CHI;
if(strcasecmp("SinChi",firstargument)==0) InversionBendConstraintType=SIN_CHI;
if(strcasecmp("SinChiSquared",firstargument)==0) InversionBendConstraintType=SIN_CHI_SQUARED;
}
if(strcasecmp("OutOfPlaneConstraintType",keyword)==0)
{
if(strcasecmp("Distance",firstargument)==0) OutOfPlaneConstraintType=DISTANCE_R;
if(strcasecmp("DistanceSquared",firstargument)==0) OutOfPlaneConstraintType=DISTANCE_R_SQUARED;
}
if(strcasecmp("ComputeRattleSteps",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) ComputeRattleSteps=TRUE;
if(strcasecmp("no",firstargument)==0) ComputeRattleSteps=FALSE;
}
if(strcasecmp("MeasureDihedralWithMidpoint",keyword)==0)
{
sscanf(arguments," %c %d %d %c %d %d %c %d %d %c %d %d %c %d %d %c %d %d%[^\n]",&charinput1,&intinput1,&intinput2,&charinput2,&intinput3,&intinput4,
&charinput3,&intinput5,&intinput6,&charinput4,&intinput7,&intinput8,
&charinput5,&intinput9,&intinput10,&charinput6,&intinput11,&intinput12,arguments);
sscanf(arguments,"%lf",&realinput1);
TwoPointDihedralDefinitions[CurrentSystem]=(int(*)[6][3])realloc(TwoPointDihedralDefinitions[CurrentSystem],
(NumberOfTwoPointDihedralDefinitions[CurrentSystem]+1)*sizeof(int[6][3]));
if(!TwoPointDihedralDefinitions[CurrentSystem])
{
printf("Memory reallocation error of 'TwoPointDihedralDefinitions[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
if((charinput1=='F')||(charinput1=='f'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][0][0]=FRAMEWORK;
else if((charinput1=='A')||(charinput1=='a'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][0][0]=ADSORBATE;
else if((charinput1=='C')||(charinput1=='c'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][0][0]=CATION;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][0][1]=intinput1;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][0][2]=intinput2;
if((charinput2=='F')||(charinput2=='f'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][1][0]=FRAMEWORK;
else if((charinput2=='A')||(charinput2=='a'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][1][0]=ADSORBATE;
else if((charinput2=='C')||(charinput2=='c'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][1][0]=CATION;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][1][1]=intinput3;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][1][2]=intinput4;
if((charinput3=='F')||(charinput3=='f'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][2][0]=FRAMEWORK;
else if((charinput3=='A')||(charinput3=='a'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][2][0]=ADSORBATE;
else if((charinput3=='C')||(charinput3=='c'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][2][0]=CATION;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][2][1]=intinput5;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][2][2]=intinput6;
if((charinput4=='F')||(charinput4=='f'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][3][0]=FRAMEWORK;
else if((charinput4=='A')||(charinput4=='a'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][3][0]=ADSORBATE;
else if((charinput4=='C')||(charinput4=='c'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][3][0]=CATION;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][3][1]=intinput7;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][3][2]=intinput8;
if((charinput5=='F')||(charinput5=='f'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][4][0]=FRAMEWORK;
else if((charinput5=='A')||(charinput5=='a'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][4][0]=ADSORBATE;
else if((charinput5=='C')||(charinput5=='c'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][4][0]=CATION;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][4][1]=intinput9;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][4][2]=intinput10;
if((charinput6=='F')||(charinput6=='f'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][5][0]=FRAMEWORK;
else if((charinput6=='A')||(charinput6=='a'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][5][0]=ADSORBATE;
else if((charinput6=='C')||(charinput6=='c'))
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][5][0]=CATION;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][5][1]=intinput11;
TwoPointDihedralDefinitions[CurrentSystem][NumberOfTwoPointDihedralDefinitions[CurrentSystem]][5][2]=intinput12;
NumberOfTwoPointDihedralDefinitions[CurrentSystem]++;
}
// read Monte Carlo settings
if(strcasecmp("CBMCBiasingMethod",keyword)==0)
{
if(strcasecmp("LJ_Biasing",firstargument)==0) BiasingMethod=LJ_BIASING;
if(strcasecmp("LJ_And_Real_Biasing",firstargument)==0) BiasingMethod=LJ_AND_REAL_BIASING;
}
if(strcasecmp("OptimizeAcceptenceEvery",keyword)==0) sscanf(arguments,"%d",&OptimizeAcceptenceEvery);
if(strcasecmp("OptimizeVolumeChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeVolumeChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeVolumeChange=FALSE;
}
if(strcasecmp("OptimizeGibbsVolumeChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeGibbsVolumeChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeGibbsVolumeChange=FALSE;
}
if(strcasecmp("OptimizeTranslation",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeTranslation=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeTranslation=FALSE;
}
if(strcasecmp("OptimizeRotation",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeRotation=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeRotation=FALSE;
}
if(strcasecmp("OptimizeFrameworkChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeFrameworkChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeFrameworkChange=FALSE;
}
if(strcasecmp("OptimizeFrameworkShift",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeFrameworkShift=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeFrameworkShift=FALSE;
}
if(strcasecmp("OptimizeCFLambdaChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeCFLambdaChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeCFLambdaChange=FALSE;
}
if(strcasecmp("OptimizeCFGibbsLambdaChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeCFGibbsLambdaChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeCFGibbsLambdaChange=FALSE;
}
if(strcasecmp("OptimizeCBCFLambdaChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeCBCFLambdaChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeCBCFLambdaChange=FALSE;
}
if(strcasecmp("OptimizeCBCFGibbsLambdaChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeCBCFGibbsLambdaChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeCBCFGibbsLambdaChange=FALSE;
}
if(strcasecmp("OptimizeRXMCLambdaChange",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) OptimizeRXMCLambdaChange=TRUE;
if(strcasecmp("no",firstargument)==0) OptimizeRXMCLambdaChange=FALSE;
}
if(strcasecmp("MinimumInnerCycles",keyword)==0) sscanf(arguments,"%d",&MinimumInnerCycles);
if(strcasecmp("NumberOfTrialPositions",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositions);
if(strcasecmp("NumberOfTrialPositionsReinsertion",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsReinsertion);
if(strcasecmp("NumberOfTrialPositionsPartialReinsertion",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsPartialReinsertion);
if(strcasecmp("NumberOfTrialPositionsIdentityChange",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsIdentityChange);
if(strcasecmp("NumberOfTrialPositionsGibbs",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsGibbs);
if(strcasecmp("NumberOfTrialPositionsSwap",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsSwap);
if(strcasecmp("NumberOfTrialPositionsWidom",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsWidom);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBeadReinsertion",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBeadReinsertion);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBeadPartialReinsertion",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBeadPartialReinsertion);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBeadIdentityChange",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBeadIdentityChange);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBeadGibbs",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBeadGibbs);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBeadSwap",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBeadSwap);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBeadWidom",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBeadWidom);
if(strcasecmp("NumberOfTrialPositionsTorsion",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialPositionsTorsion);
if(strcasecmp("NumberOfTrialPositionsForTheFirstBead",keyword)==0)
sscanf(arguments,"%d",&NumberOfTrialPositionsForTheFirstBead);
if(strcasecmp("NumberOfTrialMovesPerOpenBead",keyword)==0) sscanf(arguments,"%d",&NumberOfTrialMovesPerOpenBead);
if(strcasecmp("TargetAccRatioSmallMCScheme",keyword)==0) sscanf(arguments,"%lf",&TargetAccRatioSmallMCScheme);
if(strcasecmp("EnergyOverlapCriteria",keyword)==0) sscanf(arguments,"%lf",&EnergyOverlapCriteria);
if(strcasecmp("MinimumRosenbluthFactor",keyword)==0) sscanf(arguments,"%lf",&MinimumRosenbluthFactor);
// transition state theory settings
if(strcasecmp("FreeEnergyMappingType",keyword)==0)
{
if(strcasecmp("A",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=A_MAPPING;
if(strcasecmp("B",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=B_MAPPING;
if(strcasecmp("C",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=C_MAPPING;
if(strcasecmp("ABC",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=ABC_MAPPING;
if(strcasecmp("AB_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_AB_DIAGONAL;
if(strcasecmp("AC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_AC_DIAGONAL;
if(strcasecmp("BC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_BC_DIAGONAL;
if(strcasecmp("O_AB_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_O_AB_DIAGONAL;
if(strcasecmp("O_AC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_O_AC_DIAGONAL;
if(strcasecmp("O_BC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_O_BC_DIAGONAL;
if(strcasecmp("A_BC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_A_BC_DIAGONAL;
if(strcasecmp("B_AC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_B_AC_DIAGONAL;
if(strcasecmp("C_AB_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_C_AB_DIAGONAL;
if(strcasecmp("O_ABC_DIAGONAL",firstargument)==0) FreeEnergyMappingType[CurrentSystem]=MAP_O_ABC_DIAGONAL;
}
if(strcasecmp("PutMoleculeOnBarrier",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PutMoleculeOnBarrier[CurrentSystem]=TRUE;
if(strcasecmp("no",firstargument)==0) PutMoleculeOnBarrier[CurrentSystem]=FALSE;
}
if(strcasecmp("BarrierPosition",keyword)==0) sscanf(arguments,"%lf %lf %lf",
&BarrierPosition[CurrentSystem].x,&BarrierPosition[CurrentSystem].y,&BarrierPosition[CurrentSystem].z);
if(strcasecmp("BarrierNormal",keyword)==0) sscanf(arguments,"%lf %lf %lf",
&BarrierNormal[CurrentSystem].x,&BarrierNormal[CurrentSystem].y,&BarrierNormal[CurrentSystem].z);
if(strcasecmp("BarrierAngle",keyword)==0)
if(sscanf(arguments,"%lf %lf %lf",&BarrierAngle[CurrentSystem].x,&BarrierAngle[CurrentSystem].y,&BarrierAngle[CurrentSystem].z))
{BarrierAngle[CurrentSystem].x*=DEG2RAD; BarrierAngle[CurrentSystem].y*=DEG2RAD; BarrierAngle[CurrentSystem].z*=DEG2RAD;};
if(strcasecmp("MaxBarrierDistance",keyword)==0) sscanf(arguments,"%lf",&MaxBarrierDistance[CurrentSystem]);
if(strcasecmp("MaxBarrierTime",keyword)==0) sscanf(arguments,"%lf",&MaxBarrierTime[CurrentSystem]);
if(strcasecmp("NumberOfVelocities",keyword)==0) sscanf(arguments,"%d",&NumberOfVelocities[CurrentSystem]);
if(strcasecmp("PrintFrameworkBondStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkBondStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkBondStatus=FALSE;
}
if(strcasecmp("PrintFrameworkUreyBradleyStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkUreyBradleyStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkUreyBradleyStatus=FALSE;
}
if(strcasecmp("PrintFrameworkBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkBendStatus=FALSE;
}
if(strcasecmp("PrintFrameworkInversionBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkInversionBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkInversionBendStatus=FALSE;
}
if(strcasecmp("PrintFrameworkTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkTorsionStatus=FALSE;
}
if(strcasecmp("PrintFrameworkImproperTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkImproperTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkImproperTorsionStatus=FALSE;
}
if(strcasecmp("PrintFrameworkBondBondStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkBondBondStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkBondBondStatus=FALSE;
}
if(strcasecmp("PrintFrameworkBondBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkBondBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkBondBendStatus=FALSE;
}
if(strcasecmp("PrintFrameworkBendBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkBendBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkBendBendStatus=FALSE;
}
if(strcasecmp("PrintFrameworkBendTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkBendTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkBendTorsionStatus=FALSE;
}
if(strcasecmp("PrintFrameworkIntraVDWStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkIntraVDWStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkIntraVDWStatus=FALSE;
}
if(strcasecmp("PrintFrameworkIntraChargeChargeStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkIntraChargeChargeStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkIntraChargeChargeStatus=FALSE;
}
if(strcasecmp("PrintFrameworkIntraChargeBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkIntraChargeBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkIntraChargeBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintFrameworkIntraBondDipoleBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkIntraBondDipoleBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkIntraBondDipoleBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBondStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBondStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBondStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateUreyBradleyStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateUreyBradleyStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateUreyBradleyStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBendStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateTorsionStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateImproperTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateImproperTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateImproperTorsionStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBondBondStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBondBondStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBondBondStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBondBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBondBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBondBendStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBendBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBendBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBendBendStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBondTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBondTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBondTorsionStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateBendTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateBendTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateBendTorsionStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateIntraVDWStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateIntraVDWStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateIntraVDWStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateIntraChargeChargeStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateIntraChargeChargeStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateIntraChargeChargeStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateIntraChargeBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateIntraChargeBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateIntraChargeBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintAdsorbateIntraBondDipoleBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintAdsorbateIntraBondDipoleBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintAdsorbateIntraBondDipoleBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintCationBondStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationBondStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationBondStatus=FALSE;
}
if(strcasecmp("PrintCationUreyBradleyStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationUreyBradleyStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationUreyBradleyStatus=FALSE;
}
if(strcasecmp("PrintCationBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationBendStatus=FALSE;
}
if(strcasecmp("PrintCationTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationTorsionStatus=FALSE;
}
if(strcasecmp("PrintCationImproperTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationImproperTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationImproperTorsionStatus=FALSE;
}
if(strcasecmp("PrintCationBondBondStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationBondBondStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationBondBondStatus=FALSE;
}
if(strcasecmp("PrintCationBondBendStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationBondBendStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationBondBendStatus=FALSE;
}
if(strcasecmp("PrintCationBondTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationBondTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationBondTorsionStatus=FALSE;
}
if(strcasecmp("PrintCationBendTorsionStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationBendTorsionStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationBendTorsionStatus=FALSE;
}
if(strcasecmp("PrintCationIntraVDWStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationIntraVDWStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationIntraVDWStatus=FALSE;
}
if(strcasecmp("PrintCationIntraChargeChargeStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationIntraChargeChargeStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationIntraChargeChargeStatus=FALSE;
}
if(strcasecmp("PrintCationIntraChargeBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationIntraChargeBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationIntraChargeBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintCationIntraBondDipoleBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintCationIntraBondDipoleBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintCationIntraBondDipoleBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintInterVDWStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintInterVDWStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintInterVDWStatus=FALSE;
}
if(strcasecmp("PrintInterChargeChargeStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintInterChargeChargeStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintInterChargeChargeStatus=FALSE;
}
if(strcasecmp("PrintInterChargeBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintInterChargeBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintInterChargeBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintInterBondDipoleBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintInterBondDipoleBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintInterBondDipoleBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintFrameworkAdsorbateVDWStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkAdsorbateVDWStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkAdsorbateVDWStatus=FALSE;
}
if(strcasecmp("PrintFrameworkAdsorbateChargeChargeStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkAdsorbateChargeChargeStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkAdsorbateChargeChargeStatus=FALSE;
}
if(strcasecmp("PrintFrameworkAdsorbateChargeBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkAdsorbateChargeBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkAdsorbateChargeBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintFrameworkAdsorbateBondDipoleBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkAdsorbateBondDipoleBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkAdsorbateBondDipoleBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintFrameworkCationVDWStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkCationVDWStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkCationVDWStatus=FALSE;
}
if(strcasecmp("PrintFrameworkCationChargeChargeStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkCationChargeChargeStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkCationChargeChargeStatus=FALSE;
}
if(strcasecmp("PrintFrameworkCationChargeBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkCationChargeBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkCationChargeBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintFrameworkCationBondDipoleBondDipoleStatus",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) PrintFrameworkCationBondDipoleBondDipoleStatus=TRUE;
if(strcasecmp("no",firstargument)==0) PrintFrameworkCationBondDipoleBondDipoleStatus=FALSE;
}
if(strcasecmp("PrintFrameworkBondStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkBondStatus=TRUE;
}
if(strcasecmp("PrintFrameworkUreyBradleyStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkUreyBradleyStatus=TRUE;
}
if(strcasecmp("PrintFrameworkBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkBendStatus=TRUE;
}
if(strcasecmp("PrintFrameworkInversionBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkInversionBendStatus=TRUE;
}
if(strcasecmp("PrintFrameworkTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkTorsionStatus=TRUE;
}
if(strcasecmp("PrintFrameworkImproperTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkImproperTorsionStatus=TRUE;
}
if(strcasecmp("PrintFrameworkBondBondStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkBondBondStatus=TRUE;
}
if(strcasecmp("PrintFrameworkBondBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkBondBendStatus=TRUE;
}
if(strcasecmp("PrintFrameworkBendBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkBendBendStatus=TRUE;
}
if(strcasecmp("PrintFrameworkBendTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkBendTorsionStatus=TRUE;
}
if(strcasecmp("PrintFrameworkIntraVDWStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkIntraVDWStatus=TRUE;
}
if(strcasecmp("PrintFrameworkIntraChargeChargeStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkIntraChargeChargeStatus=TRUE;
}
if(strcasecmp("PrintFrameworkIntraChargeBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkIntraChargeBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintFrameworkIntraBondDipoleBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkIntraBondDipoleBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBondStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBondStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateUreyBradleyStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateUreyBradleyStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBendStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateTorsionStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateImproperTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateImproperTorsionStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBondBondStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBondBondStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBondBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBondBendStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBendBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBendBendStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBondTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBondTorsionStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateBendTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateBendTorsionStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateIntraVDWStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateIntraVDWStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateIntraChargeChargeStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateIntraChargeChargeStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateIntraChargeBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateIntraChargeBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintAdsorbateIntraBondDipoleBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintAdsorbateIntraBondDipoleBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintCationBondStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationBondStatus=TRUE;
}
if(strcasecmp("PrintCationUreyBradleyStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationUreyBradleyStatus=TRUE;
}
if(strcasecmp("PrintCationBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationBendStatus=TRUE;
}
if(strcasecmp("PrintCationTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationTorsionStatus=TRUE;
}
if(strcasecmp("PrintCationImproperTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationImproperTorsionStatus=TRUE;
}
if(strcasecmp("PrintCationBondBondStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationBondBondStatus=TRUE;
}
if(strcasecmp("PrintCationBondBendStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationBondBendStatus=TRUE;
}
if(strcasecmp("PrintCationBondTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationBondTorsionStatus=TRUE;
}
if(strcasecmp("PrintCationBendTorsionStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationBendTorsionStatus=TRUE;
}
if(strcasecmp("PrintCationIntraVDWStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationIntraVDWStatus=TRUE;
}
if(strcasecmp("PrintCationIntraChargeChargeStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationIntraChargeChargeStatus=TRUE;
}
if(strcasecmp("PrintCationIntraChargeBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationIntraChargeBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintCationIntraBondDipoleBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintCationIntraBondDipoleBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintInterVDWStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintInterVDWStatus=TRUE;
}
if(strcasecmp("PrintInterChargeChargeStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintInterChargeChargeStatus=TRUE;
}
if(strcasecmp("PrintInterChargeBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintInterChargeBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintInterBondDipoleBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintInterBondDipoleBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintFrameworkAdsorbateVDWStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkAdsorbateVDWStatus=TRUE;
}
if(strcasecmp("PrintFrameworkAdsorbateChargeChargeStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkAdsorbateChargeChargeStatus=TRUE;
}
if(strcasecmp("PrintFrameworkAdsorbateChargeBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkAdsorbateChargeBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintFrameworkAdsorbateBondDipoleBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkAdsorbateBondDipoleBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintFrameworkCationVDWStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkCationVDWStatus=TRUE;
}
if(strcasecmp("PrintFrameworkCationChargeChargeStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkCationChargeChargeStatus=TRUE;
}
if(strcasecmp("PrintFrameworkCationChargeBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkCationChargeBondDipoleStatus=TRUE;
}
if(strcasecmp("PrintFrameworkCationBondDipoleBondDipoleStatusOnly",keyword)==0)
{
SetPrintStatusToFalse();
PrintFrameworkCationBondDipoleBondDipoleStatus=TRUE;
}
// create frameworks
if(strcasecmp("FrameworkProbability",keyword)==0) sscanf(arguments,"%lf",&Framework[CurrentSystem].FrameworkProbability[CurrentFramework]);
if(strcasecmp("FrameworkExclusion",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].FrameworkExclusion=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].FrameworkExclusion=FALSE;
}
if(strcasecmp("RemoveHydrogenDisorder",keyword)==0)
{
if(strcasecmp("yes",firstargument)==0) Framework[CurrentSystem].RemoveHydrogenDisorder=TRUE;
if(strcasecmp("no",firstargument)==0) Framework[CurrentSystem].RemoveHydrogenDisorder=FALSE;
}
}
// if the frameworks can be moved apart, the system is set to 'flexible'
// the individual frameworks can be either 'fleixble' or 'rigid'
if(ProbabilityFrameworkShiftMove>0.0)
{
for(i=0;i<NumberOfSystems;i++)
if(Framework[i].NumberOfFrameworks>1) Framework[i].FrameworkModel=FLEXIBLE;
}
// get the random number seed from the system-time if not specified
if(seed<=0lu) seed=time(0lu);
// Initialize random-number generator using the "random" seed
InitializeRandomNumberGenerator(seed);
if(BoundaryCondition[CurrentSystem]==FINITE)
{
CutOffVDW=DBL_MAX;
CutOffVDWSquared=DBL_MAX;
for(i=0;i<NumberOfSystems;i++)
{
CutOffChargeCharge[i]=DBL_MAX;
CutOffChargeChargeSquared[i]=DBL_MAX;
CutOffChargeChargeSwitch[i]=DBL_MAX;
CutOffChargeChargeSwitchSquared[i]=DBL_MAX;
}
CutOffChargeBondDipole=DBL_MAX;
CutOffChargeBondDipoleSquared=DBL_MAX;
CutOffBondDipoleBondDipole=DBL_MAX;
CutOffBondDipoleBondDipoleSquared=DBL_MAX;
CutOffVDWSwitch=DBL_MAX;
CutOffVDWSwitchSquared=DBL_MAX;
CutOffChargeBondDipoleSwitch=DBL_MAX;
CutOffChargeBondDipoleSwitchSquared=DBL_MAX;
CutOffBondDipoleBondDipoleSwitch=DBL_MAX;
CutOffBondDipoleBondDipoleSwitchSquared=DBL_MAX;
if((ChargeMethod==EWALD)&&(!OmitEwaldFourier))
{
fprintf(stderr, "ERROR: you can not use a finite system *and* the Ewald summation\n");
exit(0);
}
}
else
{
// Calculate cutoff-related values
CutOffVDWSquared=SQR(CutOffVDW);
for(i=0;i<NumberOfSystems;i++)
{
CutOffChargeChargeSquared[i]=SQR(CutOffChargeCharge[i]);
InverseCutOffChargeCharge[i]=1.0/CutOffChargeCharge[i];
if(CutOffChargeChargeSwitch[i]<=0.0)
CutOffChargeChargeSwitch[i]=0.65*CutOffChargeCharge[i];
CutOffChargeChargeSwitchSquared[i]=SQR(CutOffChargeChargeSwitch[i]);
}
CutOffChargeBondDipoleSquared=SQR(CutOffChargeBondDipole);
CutOffBondDipoleBondDipoleSquared=SQR(CutOffBondDipoleBondDipole);
InverseCutOffVDW=1.0/CutOffVDW;
if(CutOffVDWSwitch<=0)
CutOffVDWSwitch=0.9*CutOffVDW;
CutOffVDWSwitchSquared=SQR(CutOffVDWSwitch);
if(CutOffChargeBondDipoleSwitch<=0.0)
CutOffChargeBondDipoleSwitch=0.7*CutOffChargeBondDipole;
CutOffChargeBondDipoleSwitchSquared=SQR(CutOffChargeBondDipoleSwitch);
if(CutOffBondDipoleBondDipoleSwitch<=0.0)
CutOffBondDipoleBondDipoleSwitch=0.75*CutOffBondDipoleBondDipole;
CutOffBondDipoleBondDipoleSwitchSquared=SQR(CutOffBondDipoleBondDipoleSwitch);
}
ComputeSwitchingFactors();
if(UseTabularGrid)
{
for(i=0;i<NumberOfSystems;i++)
Framework[i].FrameworkModel=GRID,printf("Setting GRID\n");
}
// read pseudo-atoms definitions
// Note these can be extended by atoms read from cif-files
ReadPseudoAtomsDefinitions();
// PrintEvery should be larger then zero
if(PrintEvery<1) PrintEvery=5000;
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
if(Framework[CurrentSystem].FrameworkModel!=NONE)
{
if(read_frameworks[CurrentSystem])
{
for(CurrentFramework=0;CurrentFramework<Framework[CurrentSystem].NumberOfFrameworks;CurrentFramework++)
{
switch(Framework[CurrentSystem].InputFileType[CurrentFramework])
{
case CIF_FORMAT:
ReadFrameworkDefinitionCIF();
break;
case CSSR_FORMAT:
ReadFrameworkDefinitionCSSR();
break;
case DLPOLY_FORMAT:
ReadFrameworkDefinitionDLPOLY();
break;
case MOL_FORMAT:
ReadFrameworkDefinitionMOL();
break;
default:
fprintf(stderr, "Unknown structure-format\n");
break;
}
if(Framework[CurrentSystem].CalculateSpaceGroup[CurrentFramework]) DetermineSpaceGroup();
}
InitializeReplicaBox();
// check modification rules
for(i=0;i<NumberOfModificationRules;i++)
{
// convert strings to ids
for(k=0;k<10;k++)
{
Type=-1;
for(j=0;j<NumberOfPseudoAtoms;j++)
if(strcasecmp(PseudoAtoms[j].Name,ModifyFrameworkAtoms[i][k])==0) Type=j;
ModifyFrameworkAtomTypes[i][k]=Type;
}
// check atom strings
switch(ModificationRuleType[i])
{
case MODIFY_FRAMEWORKATOM_CONNECTED_TO:
for(k=0;k<2;k++)
{
if(ModifyFrameworkAtomTypes[i][k]<0)
{
fprintf(stderr, "Unknown framework atom '%s' in modification rule %d atom %d\n",ModifyFrameworkAtoms[i][k],i,k);
exit(0);
}
}
break;
case MODIFY_FRAMEWORKATOM_DIMER:
for(k=0;k<4;k++)
{
if(ModifyFrameworkAtomTypes[i][k]<0)
{
fprintf(stderr, "Unknown framework atom '%s' in modification rule %d atom %d\n",ModifyFrameworkAtoms[i][k],i,k);
exit(0);
}
}
break;
case MODIFY_FRAMEWORKATOM_TRIPLE:
for(k=0;k<6;k++)
{
if(ModifyFrameworkAtomTypes[i][k]<0)
{
fprintf(stderr, "Unknown framework atom '%s' in modification rule %d atom %d\n",ModifyFrameworkAtoms[i][k],i,k);
exit(0);
}
}
break;
case MODIFY_FRAMEWORKATOM_PLANAR:
for(k=0;k<10;k++)
{
if(ModifyFrameworkAtomTypes[i][k]<0)
{
fprintf(stderr, "Unknown framework atom '%s' in modification rule %d atom %d\n",ModifyFrameworkAtoms[i][k],i,k);
exit(0);
}
}
break;
}
}
// check forbidden connectivity rules
for(i=0;i<NumberOfForbiddenConnectivityRules;i++)
{
// convert strings to ids
for(k=0;k<3;k++)
{
Type=-1;
for(j=0;j<NumberOfPseudoAtoms;j++)
if(strcasecmp(PseudoAtoms[j].Name,ForbiddenConnectivityAtoms[i][k])==0) Type=j;
ForbiddenConnectivityTypes[i][k]=Type;
}
if(ForbiddenConnectivityTypes[i][0]<0)
{
fprintf(stderr, "Unknown framework atom %s in forbidden connectivity rule %d\n",ForbiddenConnectivityAtoms[i][0],0);
exit(0);
}
if(ForbiddenConnectivityTypes[i][1]<0)
{
fprintf(stderr, "Unknown framework atom %s in forbidden connectivity rule %d\n",ForbiddenConnectivityAtoms[i][1],1);
exit(0);
}
if(ForbiddenConnectivityTypes[i][2]<0)
{
fprintf(stderr, "Unknown framework atom %s in forbidden connectivity rule %d\n",ForbiddenConnectivityAtoms[i][2],2);
exit(0);
}
}
// make a connectivity list to look for neighbors
// the list is used to obtain bonds, bends, torsion etc
// read the flexible framework model definitions
ReadFrameworkDefinition();
ReadFrameworkSpecificDefinition();
MakeExclusionMatrix(CurrentSystem);
MakeExcludedInteractionLists(CurrentSystem);
// Added by Ambroise de Izarra
//-------------------------------------------------------------------
AllocateList14atomsVDWandEwald(CurrentSystem);
printInteractionIndexAtoms(CurrentSystem);
//-------------------------------------------------------------------
ReadBlockingPockets();
}
// measure the original shift between the frameworks
for(f1=0;f1<Framework[CurrentSystem].NumberOfFrameworks;f1++)
{
CurrentFramework=f1;
posf1=GetFrameworkCenterOfMassPosition();
for(f2=f1+1;f2<Framework[CurrentSystem].NumberOfFrameworks;f2++)
{
CurrentFramework=f2;
posf2=GetFrameworkCenterOfMassPosition();
dr.x=posf1.x-posf2.x;
dr.y=posf1.y-posf2.y;
dr.z=posf1.z-posf2.z;
dr=ApplyBoundaryCondition(dr);
r=sqrt(SQR(dr.x)+SQR(dr.y)+SQR(dr.z));
OriginalFrameworkShiftDirAvg[CurrentSystem][f1][f2]=r;
OriginalFrameworkShift[CurrentSystem][f1][f2].x=dr.x;
OriginalFrameworkShift[CurrentSystem][f1][f2].y=dr.y;
OriginalFrameworkShift[CurrentSystem][f1][f2].z=dr.z;
}
}
if(strlen(Framework[CurrentSystem].NameIons)>0)
ReadIonSitingDefinition();
}
}
for(i=0;i<NumberOfSystems;i++)
{
for(f1=0;f1<Framework[i].NumberOfFrameworks;f1++)
{
OrientationFrameworkBondTypes[i][f1]=(int *)calloc(NumberOfOrientationFrameworkBonds[i][f1],sizeof(int));
NumberOfOrientationFrameworkBondPairs[i][f1]=(int*)calloc(NumberOfOrientationFrameworkBonds[i][f1],sizeof(int));
OrientationFrameworkBondPairs[i][f1]=(PAIR**)calloc(NumberOfOrientationFrameworkBonds[i][f1],sizeof(PAIR*));
for(k=0;k<NumberOfOrientationFrameworkBonds[i][f1];k++)
{
for(l=0;l<Framework[i].NumberOfBondsDefinitions;l++)
{
typeA=Framework[i].BondDefinitions[l].A;
typeB=Framework[i].BondDefinitions[l].B;
if(((strcmp(PseudoAtoms[typeA].Name,OrientationFrameworkBonds[i][f1][k][0])==0)&&
(strcmp(PseudoAtoms[typeB].Name,OrientationFrameworkBonds[i][f1][k][1])==0))||
((strcmp(PseudoAtoms[typeB].Name,OrientationFrameworkBonds[i][f1][k][0])==0)&&
(strcmp(PseudoAtoms[typeA].Name,OrientationFrameworkBonds[i][f1][k][1])==0)))
{
OrientationFrameworkBondTypes[i][f1][k]=l;
break;
}
}
}
for(k=0;k<NumberOfOrientationFrameworkBonds[i][f1];k++)
{
l=OrientationFrameworkBondTypes[i][f1][k];
NumberOfOrientationFrameworkBondPairs[i][f1][k]=Framework[i].NumberOfBondsPerType[l];
OrientationFrameworkBondPairs[i][f1][k]=(PAIR*)calloc(NumberOfOrientationFrameworkBondPairs[i][f1][k],sizeof(PAIR));
index=0;
for(l=0;l<Framework[i].NumberOfBonds[f1];l++)
{
atom1=Framework[i].Bonds[f1][l].A;
atom2=Framework[i].Bonds[f1][l].B;
typeA=Framework[i].Atoms[f1][atom1].Type;
typeB=Framework[i].Atoms[f1][atom2].Type;
if(((strcmp(PseudoAtoms[typeA].Name,OrientationFrameworkBonds[i][f1][k][0])==0)&&
(strcmp(PseudoAtoms[typeB].Name,OrientationFrameworkBonds[i][f1][k][1])==0))||
((strcmp(PseudoAtoms[typeB].Name,OrientationFrameworkBonds[i][f1][k][0])==0)&&
(strcmp(PseudoAtoms[typeA].Name,OrientationFrameworkBonds[i][f1][k][1])==0)))
{
OrientationFrameworkBondPairs[i][f1][k][index].A=atom1;
OrientationFrameworkBondPairs[i][f1][k][index].B=atom2;
index++;
}
}
}
}
}
// read forcefields after the structure has been read
// (because CIF-files can add atom-types)
CurrentSystem=0;
ReadForceFieldDefinitionsMixingRules();
ReadForceFieldDefinitions();
ComputeDummyInteractions();
ComputePotentialShifts();
if(ChargeFromChargeEquilibration)
{
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
ChargeEquilibration();
}
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
CheckFrameworkCharges();
for(i=0;i<NumberOfPseudoAtomsWithoutVDWInteraction;i++)
PseudoAtoms[ReturnPseudoAtomNumber(PseudoAtomsWithoutVDWInteraction[i])].HasVDWInteraction=FALSE;
// Read the definitions of the components
MaxNumberOfCoulombicSites=0;
LargestNumberOfCoulombicSites=0;
MaxNumberOfBondDipoleSites=0;
LargestNumberOfBondDipoleSites=0;
for(i=0;i<NumberOfSystems;i++)
{
MaxNumberOfAdsorbateMolecules[i]=0;
MaxNumberOfCationMolecules[i]=0;
NumberOfAtomsPerSystem[i]=0;
NumberOfChargesPerSystem[i]=0;
NumberOfBondDipolesPerSystem[i]=0;
}
for(i=0;i<NumberOfComponents;i++)
{
ReadComponentDefinition(i);
if(Components[i].StartingBead>=Components[i].NumberOfAtoms)
{
fprintf(stderr, "Starting bead (%d) not within number of atoms: %d\n",
Components[i].StartingBead,Components[i].NumberOfAtoms);
exit(0);
}
for(j=0;j<NumberOfSystems;j++)
{
if(Components[i].ExtraFrameworkMolecule)
MaxNumberOfCationMolecules[j]+=Components[i].CreateNumberOfMolecules[j];
else
MaxNumberOfAdsorbateMolecules[j]+=Components[i].CreateNumberOfMolecules[j];
NumberOfAtomsPerSystem[j]+=Components[i].NumberOfAtoms*Components[i].CreateNumberOfMolecules[j];
NumberOfChargesPerSystem[j]+=Components[i].NumberOfCharges*Components[i].CreateNumberOfMolecules[j];
NumberOfBondDipolesPerSystem[j]+=Components[i].NumberOfBondDipoles*Components[i].CreateNumberOfMolecules[j];
}
}
// update the maximum amount of atoms (maximum over all systems)
LargestNumberOfCoulombicSites=0;
for(i=0;i<NumberOfSystems;i++)
{
nr_sites=NumberOfChargesPerSystem[i];
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
nr_sites+=Framework[i].NumberOfCharges[j]+Framework[i].NumberOfCoreShells[j];
}
if(nr_sites>LargestNumberOfCoulombicSites) LargestNumberOfCoulombicSites=nr_sites;
NumberOfAtomsPerSystem[i]=0;
NumberOfChargesPerSystem[i]=0;
}
LargestNumberOfBondDipoleSites=0;
for(i=0;i<NumberOfSystems;i++)
{
nr_sites=NumberOfBondDipolesPerSystem[i];
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
nr_sites+=Framework[i].NumberOfBondDipoles[j];
if(nr_sites>LargestNumberOfBondDipoleSites) LargestNumberOfBondDipoleSites=nr_sites;
NumberOfBondDipolesPerSystem[i]=0;
}
// the components are read, and all limits are known
// allocate the memory for use in the cbmc routines
AllocateCBMCMemory();
AllocateMCMovesMemory();
AllocateGridMemory();
for(i=0;i<NumberOfGrids;i++)
GridTypeList[i]=ReturnPseudoAtomNumber(GridTypeListName[i]);
for(i=0;i<NumberOfSystems;i++)
{
MaximumVolumeChange[i]=0.025;
MaximumBoxShapeChange[i].ax=0.1;
MaximumBoxShapeChange[i].ay=0.1;
MaximumBoxShapeChange[i].az=0.1;
MaximumBoxShapeChange[i].bx=0.1;
MaximumBoxShapeChange[i].by=0.1;
MaximumBoxShapeChange[i].bz=0.1;
MaximumBoxShapeChange[i].cx=0.1;
MaximumBoxShapeChange[i].cy=0.1;
MaximumBoxShapeChange[i].cz=0.1;
MaximumGibbsVolumeChange[i]=0.1;
for(j=0;j<NumberOfReactions;j++)
MaximumReactionLambdaChange[i][j]=0.3;
for(j=0;j<NumberOfComponents;j++)
{
MaximumCFLambdaChange[i][j]=0.5;
MaximumCBCFLambdaChange[i][j]=0.5;
switch(Components[j].TranslationDirection)
{
case XYZ_DIR:
case XY_DIR:
case XZ_DIR:
case YZ_DIR:
case X_DIR:
case Y_DIR:
case Z_DIR:
MaximumTranslation[i][j].x=1.3;
MaximumTranslation[i][j].y=1.3;
MaximumTranslation[i][j].z=1.3;
MaximumRotation[i][j].x=25.0*DEG2RAD;
MaximumRotation[i][j].y=25.0*DEG2RAD;
MaximumRotation[i][j].z=25.0*DEG2RAD;
break;
case ABC_DIR:
case AB_DIR:
case AC_DIR:
case BC_DIR:
case A_DIR:
case B_DIR:
case C_DIR:
default:
MaximumTranslation[i][j].x=0.03;
MaximumTranslation[i][j].y=0.03;
MaximumTranslation[i][j].z=0.03;
MaximumRotation[i][j].x=25.0*DEG2RAD;
MaximumRotation[i][j].y=25.0*DEG2RAD;
MaximumRotation[i][j].z=25.0*DEG2RAD;
break;
}
MaximumTranslationInPlane[i][j].x=0.3;
MaximumTranslationInPlane[i][j].y=0.3;
MaximumTranslationInPlane[i][j].z=0.3;
}
}
// components have been read and the maximum amount of molecules has been determined for NVT
if(!Swapable)
{
// the +1 molecule for the Widom particle insertion particle
MaxNumberOfCoulombicSites=LargestNumberOfCoulombicSites+2*MaxNumberOfBeads;
MaxNumberOfBondDipoleSites=LargestNumberOfBondDipoleSites+2*MaxNumberOfBeads;
Adsorbates=(ADSORBATE_MOLECULE**)calloc(NumberOfSystems,sizeof(ADSORBATE_MOLECULE*));
for(i=0;i<NumberOfSystems;i++)
{
if(MaxNumberOfAdsorbateMolecules[i]>0)
Adsorbates[i]=(ADSORBATE_MOLECULE*)calloc(MaxNumberOfAdsorbateMolecules[i],sizeof(ADSORBATE_MOLECULE));
}
Cations=(CATION_MOLECULE**)calloc(NumberOfSystems,sizeof(CATION_MOLECULE*));
for(i=0;i<NumberOfSystems;i++)
{
if(MaxNumberOfCationMolecules[i]>0)
Cations[i]=(CATION_MOLECULE*)calloc(MaxNumberOfCationMolecules[i],sizeof(CATION_MOLECULE));
}
}
else
{
// make sure these are off for a grand-canonical system
for(i=0;i<NumberOfSystems;i++)
{
ComputeInfraRedSpectra[i]=FALSE;
ComputeMSDOrderN[i]=FALSE;
ComputeVACFOrderN[i]=FALSE;
ComputeRVACFOrderN[i]=FALSE;
ComputeMSD[i]=FALSE;
ComputeVACF[i]=FALSE;
}
// default: start with 512 atoms in addition to a possible framework
MaxNumberOfCoulombicSites=LargestNumberOfCoulombicSites+MAX2(MaxNumberOfBeads,512);
MaxNumberOfBondDipoleSites=LargestNumberOfBondDipoleSites+MAX2(MaxNumberOfBeads,512);
// default: start with 256 adsorbates
Adsorbates=(ADSORBATE_MOLECULE**)calloc(NumberOfSystems,sizeof(ADSORBATE_MOLECULE*));
if(!Adsorbates)
{
printf("Memory allocation error of 'Adsorbates' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<NumberOfSystems;i++)
{
MaxNumberOfAdsorbateMolecules[i]=256;
Adsorbates[i]=(ADSORBATE_MOLECULE*)calloc(MaxNumberOfAdsorbateMolecules[i],sizeof(ADSORBATE_MOLECULE));
if(!Adsorbates[i])
{
printf("Memory allocation error of 'Adsorbates[i]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
}
// default: start with 1 cation (zero can not be reallocated later)
Cations=(CATION_MOLECULE**)calloc(NumberOfSystems,sizeof(CATION_MOLECULE*));
if(!Cations)
{
printf("Memory allocation error of 'Cations' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
for(i=0;i<NumberOfSystems;i++)
{
MaxNumberOfCationMolecules[i]=1;
Cations[i]=(CATION_MOLECULE*)calloc(MaxNumberOfCationMolecules[i],sizeof(CATION_MOLECULE));
if(!Cations[i])
{
printf("Memory allocation error of 'Cations[i]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
}
}
// should be improved
BondTypes[RIGID_BOND].nr_args=1;
// initialize the box for "Box" and "Angles", both are specified independently and in order to allow the
// statements to be specified in any order the construction is done after both are known
for(i=0;i<NumberOfSystems;i++)
{
if(InitializeBox[i])
{
switch(Dimension)
{
case 2:
// Construct transformation matrix Box to go from abc-coordinates to xyz-coordinates
A=UnitCellSize[i].x;
B=UnitCellSize[i].y;
C=0.0;
UnitCellBox[i].ax=A; UnitCellBox[i].bx=B*cos(GammaAngle[i]); UnitCellBox[i].cx=0.0;
UnitCellBox[i].ay=0.0; UnitCellBox[i].by=B*sin(GammaAngle[i]); UnitCellBox[i].cy=0.0;
UnitCellBox[i].az=0.0; UnitCellBox[i].bz=0.0; UnitCellBox[i].cz=0.0;
tempd=1.0/(UnitCellBox[i].ax*UnitCellBox[i].by-B*cos(GammaAngle[i]));
InverseUnitCellBox[i].ax=tempd*UnitCellBox[i].by; InverseUnitCellBox[i].bx=-tempd*UnitCellBox[i].bx; InverseUnitCellBox[i].cx=0.0;
InverseUnitCellBox[i].ay=-tempd*UnitCellBox[i].ay; InverseUnitCellBox[i].by=tempd*UnitCellBox[i].ax; InverseUnitCellBox[i].cy=0.0;
InverseUnitCellBox[i].az=0.0; InverseUnitCellBox[i].cy=0.0; InverseUnitCellBox[i].cz=0.0;
A=(REAL)NumberOfUnitCells[i].x*UnitCellSize[i].x;
B=(REAL)NumberOfUnitCells[i].y*UnitCellSize[i].y;
C=0.0;
Box[i].ax=A; Box[i].bx=B*cos(GammaAngle[i]); Box[i].cx=0.0;
Box[i].ay=0.0; Box[i].by=B*sin(GammaAngle[i]); Box[i].cy=0.0;
Box[i].az=0.0; Box[i].bz=0.0; Box[i].cz=0.0;
tempd=1.0/(Box[i].ax*Box[i].by-B*cos(GammaAngle[i]));
InverseBox[i].ax=tempd*Box[i].by; InverseBox[i].bx=-tempd*Box[i].bx; InverseBox[i].cx=0.0;
InverseBox[i].ay=-tempd*Box[i].ay; InverseBox[i].by=tempd*Box[i].ax; InverseBox[i].cy=0.0;
InverseBox[i].az=0.0; InverseBox[i].cy=0.0; InverseBox[i].cz=0.0;
// Calculate box-properties
CellProperties(&Box[i],&BoxProperties[i],&Volume[i]);
// Compute the invers box and properties of the inverse box
CellProperties(&InverseBox[i],&InverseBoxProperties[i],&det);
break;
case 3:
// Construct transformation matrix Box to go from abc-coordinates to xyz-coordinates
A=UnitCellSize[i].x;
B=UnitCellSize[i].y;
C=UnitCellSize[i].z;
tempd=(cos(AlphaAngle[i])-cos(GammaAngle[i])*cos(BetaAngle[i]))/sin(GammaAngle[i]);
UnitCellBox[i].ax=A; UnitCellBox[i].bx=B*cos(GammaAngle[i]); UnitCellBox[i].cx=C*cos(BetaAngle[i]);
UnitCellBox[i].ay=0.0; UnitCellBox[i].by=B*sin(GammaAngle[i]); UnitCellBox[i].cy=C*tempd;
UnitCellBox[i].az=0.0; UnitCellBox[i].bz=0.0;
UnitCellBox[i].cz=C*sqrt(1.0-SQR(cos(BetaAngle[i]))-SQR(tempd));
Invert3x3Matrix(&UnitCellBox[i],&InverseUnitCellBox[i],&det);
A=(REAL)NumberOfUnitCells[i].x*UnitCellSize[i].x;
B=(REAL)NumberOfUnitCells[i].y*UnitCellSize[i].y;
C=(REAL)NumberOfUnitCells[i].z*UnitCellSize[i].z;
tempd=(cos(AlphaAngle[i])-cos(GammaAngle[i])*cos(BetaAngle[i]))/sin(GammaAngle[i]);
Box[i].ax=A; Box[i].bx=B*cos(GammaAngle[i]); Box[i].cx=C*cos(BetaAngle[i]);
Box[i].ay=0.0; Box[i].by=B*sin(GammaAngle[i]); Box[i].cy=C*tempd;
Box[i].az=0.0; Box[i].bz=0.0; Box[i].cz=C*sqrt(1.0-SQR(cos(BetaAngle[i]))-SQR(tempd));
// Calculate box-properties
CellProperties(&Box[i],&BoxProperties[i],&Volume[i]);
// Compute the invers box and properties of the inverse box
Invert3x3Matrix(&Box[i],&InverseBox[i],&det);
CellProperties(&InverseBox[i],&InverseBoxProperties[i],&det);
break;
}
}
// determine boundary conditions from angles
if(BoundaryCondition[i]==UNINITIALIZED_BOUNDARY_CONDITION)
{
SetBoundaryConditionFromSystem(i, 0.001, 0.00001);
}
}
// the probabilities are just relative with respect to each other
// so rescale and clean up all the specified probabilities after they are known
RescaleComponentProbabilities();
RescaleMolarFractions();
// calculate box-properties
for(i=0;i<NumberOfSystems;i++)
{
CellProperties(&Box[i],&BoxProperties[i],&Volume[i]);
InverseBoxMatrix(&Box[i],&InverseBox[i]);
CellProperties(&InverseBox[i],&InverseBoxProperties[i],&det);
CurrentSystem=i;
InitializeReplicaBox();
}
// count how many fractional molecules there should be for the reactions
if(NumberOfReactions>0)
{
for(i=0;i<NumberOfSystems;i++)
{
for(k=0;k<NumberOfComponents;k++)
{
Components[k].RXMCMoleculesPresent[i]=FALSE;
Components[k].NumberOfRXMCMoleculesPresent[i]=0;
for(j=0;j<NumberOfReactions;j++)
{
Components[k].RXMCMoleculesPresent[i]=TRUE;
Components[k].NumberOfRXMCMoleculesPresent[i]+=ReactantsStoichiometry[j][k]+ProductsStoichiometry[j][k];
}
}
}
}
CurrentComponent=0;
// set the wavelength
SetDiffractionWaveLength(Wavelength);
// get the indices to the scattering factors for all (pseudo-)atoms
for(i=0;i<NumberOfPseudoAtoms;i++)
{
PseudoAtoms[i].ScatteringType=GetScatteringNumber(PseudoAtoms[i].ChemicalElement);
PseudoAtoms[i].AnomalousScatteringType=GetAnomalousScatteringNumber(PseudoAtoms[i].PrintToPDBName);
}
if(Framework[0].FrameworkModel==GRID)
{
CurrentSystem=0;
ReadVDWGrid();
if(ChargeMethod!=NONE)
ReadCoulombGrid();
if(BlockEnergyGrids)
BlockingVDWGrid();
}
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
if(Ensemble[CurrentSystem]==NPTPR) BoundaryCondition[CurrentSystem]=TRICLINIC;
if(ProbabilityBoxShapeChangeMove>0.0) BoundaryCondition[CurrentSystem]=TRICLINIC;
}
// if the boundary-condition is still not set, let it default to 'triclinic'
for(i=0;i<NumberOfSystems;i++)
{
if(BoundaryCondition[i]==UNINITIALIZED_BOUNDARY_CONDITION)
BoundaryCondition[i]=TRICLINIC;
}
for(i=0;i<NumberOfSystems;i++)
{
if(Framework[i].FrameworkModel==FLEXIBLE)
{
// fill in the atom that are kept fixed in e.g. minimization
// set overall fixed/free setting for framework
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
if(Framework[i].FrameworkModels[j]==FLEXIBLE)
{
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=FALSE;
Framework[i].Atoms[j][k].Fixed.y=FALSE;
Framework[i].Atoms[j][k].Fixed.z=FALSE;
}
switch(FrameworkFixedInitialization[i][j])
{
case FIXED:
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=TRUE;
Framework[i].Atoms[j][k].Fixed.y=TRUE;
Framework[i].Atoms[j][k].Fixed.z=TRUE;
}
break;
case FREE:
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=FALSE;
Framework[i].Atoms[j][k].Fixed.y=FALSE;
Framework[i].Atoms[j][k].Fixed.z=FALSE;
}
break;
default:
break;
}
}
else
{
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=TRUE;
Framework[i].Atoms[j][k].Fixed.y=TRUE;
Framework[i].Atoms[j][k].Fixed.z=TRUE;
}
switch(FrameworkFixedInitialization[i][j])
{
case FIXED:
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=TRUE;
Framework[i].Atoms[j][k].Fixed.y=TRUE;
Framework[i].Atoms[j][k].Fixed.z=TRUE;
}
break;
case FREE:
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=FALSE;
Framework[i].Atoms[j][k].Fixed.y=FALSE;
Framework[i].Atoms[j][k].Fixed.z=FALSE;
}
break;
default:
break;
}
}
}
}
else
{
// set overall fixed/free setting for framework
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
Framework[i].Atoms[j][k].Fixed.x=TRUE;
Framework[i].Atoms[j][k].Fixed.y=TRUE;
Framework[i].Atoms[j][k].Fixed.z=TRUE;
}
}
}
}
for(i=0;i<NumberOfSystems;i++)
{
// set overall fixed/free setting for adsorbates
for(m=0;m<NumberOfAdsorbateMolecules[i];m++)
{
Type=Adsorbates[i][m].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid) // rigid unit
{
if(AdsorbateFixedInitialization[i]==FIXED)
{
Adsorbates[i][m].Groups[l].FixedCenterOfMass.x=TRUE;
Adsorbates[i][m].Groups[l].FixedCenterOfMass.y=TRUE;
Adsorbates[i][m].Groups[l].FixedCenterOfMass.z=TRUE;
Adsorbates[i][m].Groups[l].FixedOrientation.x=TRUE;
Adsorbates[i][m].Groups[l].FixedOrientation.y=TRUE;
Adsorbates[i][m].Groups[l].FixedOrientation.z=TRUE;
}
else
{
Adsorbates[i][m].Groups[l].FixedCenterOfMass.x=FALSE;
Adsorbates[i][m].Groups[l].FixedCenterOfMass.y=FALSE;
Adsorbates[i][m].Groups[l].FixedCenterOfMass.z=FALSE;
Adsorbates[i][m].Groups[l].FixedOrientation.x=FALSE;
Adsorbates[i][m].Groups[l].FixedOrientation.y=FALSE;
Adsorbates[i][m].Groups[l].FixedOrientation.z=FALSE;
}
}
else
{
for(k=0;k<Components[Type].Groups[l].NumberOfGroupAtoms;k++)
{
A=Components[Type].Groups[l].Atoms[k];
if(AdsorbateFixedInitialization[i]==FIXED)
{
Adsorbates[i][m].Atoms[k].Fixed.x=TRUE;
Adsorbates[i][m].Atoms[k].Fixed.y=TRUE;
Adsorbates[i][m].Atoms[k].Fixed.z=TRUE;
}
else
{
Adsorbates[i][m].Atoms[k].Fixed.x=FALSE;
Adsorbates[i][m].Atoms[k].Fixed.y=FALSE;
Adsorbates[i][m].Atoms[k].Fixed.z=FALSE;
}
}
}
}
}
// set overall fixed/free setting for cations
for(m=0;m<NumberOfCationMolecules[i];m++)
{
Type=Cations[i][m].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid) // rigid unit
{
if(CationFixedInitialization[i]==FIXED)
{
Cations[i][m].Groups[l].FixedCenterOfMass.x=TRUE;
Cations[i][m].Groups[l].FixedCenterOfMass.y=TRUE;
Cations[i][m].Groups[l].FixedCenterOfMass.z=TRUE;
Cations[i][m].Groups[l].FixedOrientation.x=TRUE;
Cations[i][m].Groups[l].FixedOrientation.y=TRUE;
Cations[i][m].Groups[l].FixedOrientation.z=TRUE;
}
else
{
Cations[i][m].Groups[l].FixedCenterOfMass.x=FALSE;
Cations[i][m].Groups[l].FixedCenterOfMass.y=FALSE;
Cations[i][m].Groups[l].FixedCenterOfMass.z=FALSE;
Cations[i][m].Groups[l].FixedOrientation.x=FALSE;
Cations[i][m].Groups[l].FixedOrientation.y=FALSE;
Cations[i][m].Groups[l].FixedOrientation.z=FALSE;
}
}
else
{
for(k=0;k<Components[Type].Groups[l].NumberOfGroupAtoms;k++)
{
A=Components[Type].Groups[l].Atoms[k];
if(CationFixedInitialization[i]==FIXED)
{
Cations[i][m].Atoms[k].Fixed.x=TRUE;
Cations[i][m].Atoms[k].Fixed.y=TRUE;
Cations[i][m].Atoms[k].Fixed.z=TRUE;
}
else
{
Cations[i][m].Atoms[k].Fixed.x=FALSE;
Cations[i][m].Atoms[k].Fixed.y=FALSE;
Cations[i][m].Atoms[k].Fixed.z=FALSE;
}
}
}
}
}
// overwrite based on atom type
for(f1=0;f1<Framework[i].NumberOfFrameworks;f1++)
{
for(j=0;j<Framework[i].NumberOfAtoms[f1];j++)
{
if(IsActiveAtomType(Framework[i].Atoms[f1][j].Type))
{
Framework[CurrentSystem].Atoms[f1][j].Fixed.x=FALSE;
Framework[CurrentSystem].Atoms[f1][j].Fixed.y=FALSE;
Framework[CurrentSystem].Atoms[f1][j].Fixed.z=FALSE;
}
if(IsFixedAtomType(Framework[i].Atoms[f1][j].Type))
{
Framework[CurrentSystem].Atoms[f1][j].Fixed.x=TRUE;
Framework[CurrentSystem].Atoms[f1][j].Fixed.y=TRUE;
Framework[CurrentSystem].Atoms[f1][j].Fixed.z=TRUE;
}
}
}
for(m=0;m<NumberOfAdsorbateMolecules[i];m++)
{
Type=Adsorbates[i][m].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
for(k=0;k<Components[Type].Groups[l].NumberOfGroupAtoms;k++)
{
A1=Components[Type].Groups[l].Atoms[k];
// handle fixed atoms
if(IsActiveAtomType(Adsorbates[i][m].Atoms[A1].Type))
{
if(Components[Type].Groups[l].Rigid) // rigid unit, set all atoms as 'active'
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
B1=Components[Type].Groups[l].Atoms[j];
Adsorbates[i][m].Atoms[B1].Fixed.x=FALSE;
Adsorbates[i][m].Atoms[B1].Fixed.y=FALSE;
Adsorbates[i][m].Atoms[B1].Fixed.z=FALSE;
}
}
else
{
Adsorbates[i][m].Atoms[A1].Fixed.x=FALSE;
Adsorbates[i][m].Atoms[A1].Fixed.y=FALSE;
Adsorbates[i][m].Atoms[A1].Fixed.z=FALSE;
}
}
// handle fixed atoms
if(IsFixedAtomType(Adsorbates[i][m].Atoms[A1].Type))
{
if(Components[Type].Groups[l].Rigid) // rigid unit, set all atoms as 'fixed'
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
B1=Components[Type].Groups[l].Atoms[j];
Adsorbates[i][m].Atoms[B1].Fixed.x=TRUE;
Adsorbates[i][m].Atoms[B1].Fixed.y=TRUE;
Adsorbates[i][m].Atoms[B1].Fixed.z=TRUE;
}
}
else
{
Adsorbates[i][m].Atoms[A1].Fixed.x=TRUE;
Adsorbates[i][m].Atoms[A1].Fixed.y=TRUE;
Adsorbates[i][m].Atoms[A1].Fixed.z=TRUE;
}
}
}
}
}
for(m=0;m<NumberOfCationMolecules[i];m++)
{
Type=Cations[i][m].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
for(k=0;k<Components[Type].Groups[l].NumberOfGroupAtoms;k++)
{
A1=Components[Type].Groups[l].Atoms[k];
// handle fixed atoms
if(IsActiveAtomType(Cations[i][m].Atoms[A1].Type))
{
if(Components[Type].Groups[l].Rigid) // rigid unit, set all atoms as 'active'
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
B1=Components[Type].Groups[l].Atoms[j];
Cations[i][m].Atoms[B1].Fixed.x=FALSE;
Cations[i][m].Atoms[B1].Fixed.y=FALSE;
Cations[i][m].Atoms[B1].Fixed.z=FALSE;
}
}
else
{
Cations[i][m].Atoms[A1].Fixed.x=FALSE;
Cations[i][m].Atoms[A1].Fixed.y=FALSE;
Cations[i][m].Atoms[A1].Fixed.z=FALSE;
}
}
// handle fixed atoms
if(IsFixedAtomType(Cations[i][m].Atoms[A1].Type))
{
if(Components[Type].Groups[l].Rigid) // rigid unit, set all atoms as 'fixed'
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
B1=Components[Type].Groups[l].Atoms[j];
Cations[i][m].Atoms[B1].Fixed.x=TRUE;
Cations[i][m].Atoms[B1].Fixed.y=TRUE;
Cations[i][m].Atoms[B1].Fixed.z=TRUE;
}
}
else
{
Cations[i][m].Atoms[A1].Fixed.x=TRUE;
Cations[i][m].Atoms[A1].Fixed.y=TRUE;
Cations[i][m].Atoms[A1].Fixed.z=TRUE;
}
}
}
}
}
// overwrite individual settings for the framework
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
for(k=0;k<NumberOfActiveFrameworkAtoms[i][j];k++)
{
Framework[i].Atoms[j][ActiveFrameworkAtoms[i][j][k]].Fixed.x=FALSE;
Framework[i].Atoms[j][ActiveFrameworkAtoms[i][j][k]].Fixed.y=FALSE;
Framework[i].Atoms[j][ActiveFrameworkAtoms[i][j][k]].Fixed.z=FALSE;
}
for(k=0;k<NumberOfFixedFrameworkAtoms[i][j];k++)
{
Framework[i].Atoms[j][FixedFrameworkAtoms[i][j][k]].Fixed.x=TRUE;
Framework[i].Atoms[j][FixedFrameworkAtoms[i][j][k]].Fixed.y=TRUE;
Framework[i].Atoms[j][FixedFrameworkAtoms[i][j][k]].Fixed.z=TRUE;
}
}
// overwrite individual settings for the adsorbates
for(k=0;k<NumberOfActiveAdsorbateMolecules[i];k++)
{
A1=ActiveAdsorbateMolecules[i][k];
Type=Adsorbates[i][A1].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid) // rigid unit
{
Adsorbates[i][A1].Groups[l].FixedCenterOfMass.x=FALSE;
Adsorbates[i][A1].Groups[l].FixedCenterOfMass.y=FALSE;
Adsorbates[i][A1].Groups[l].FixedCenterOfMass.z=FALSE;
Adsorbates[i][A1].Groups[l].FixedOrientation.x=FALSE;
Adsorbates[i][A1].Groups[l].FixedOrientation.y=FALSE;
Adsorbates[i][A1].Groups[l].FixedOrientation.z=FALSE;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
Adsorbates[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.x=FALSE;
Adsorbates[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.y=FALSE;
Adsorbates[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.z=FALSE;
}
}
}
}
for(k=0;k<NumberOfFixedAdsorbateMolecules[i];k++)
{
A1=FixedAdsorbateMolecules[i][k];
Type=Adsorbates[i][A1].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid) // rigid unit
{
Adsorbates[i][A1].Groups[l].FixedCenterOfMass.x=TRUE;
Adsorbates[i][A1].Groups[l].FixedCenterOfMass.y=TRUE;
Adsorbates[i][A1].Groups[l].FixedCenterOfMass.z=TRUE;
Adsorbates[i][A1].Groups[l].FixedOrientation.x=TRUE;
Adsorbates[i][A1].Groups[l].FixedOrientation.y=TRUE;
Adsorbates[i][A1].Groups[l].FixedOrientation.z=TRUE;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
Adsorbates[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.x=TRUE;
Adsorbates[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.y=TRUE;
Adsorbates[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.z=TRUE;
}
}
}
}
for(k=0;k<NumberOfActiveAdsorbateAtoms[i];k++)
{
A1=ActiveAdsorbateAtoms[i][k].A;
B1=ActiveAdsorbateAtoms[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.x=FALSE;
Adsorbates[i][A1].Atoms[B1].Fixed.y=FALSE;
Adsorbates[i][A1].Atoms[B1].Fixed.z=FALSE;
}
for(k=0;k<NumberOfActiveAdsorbateAtomsX[i];k++)
{
A1=ActiveAdsorbateAtomsX[i][k].A;
B1=ActiveAdsorbateAtomsX[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.x=FALSE;
}
for(k=0;k<NumberOfActiveAdsorbateAtomsY[i];k++)
{
A1=ActiveAdsorbateAtomsY[i][k].A;
B1=ActiveAdsorbateAtomsY[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.y=FALSE;
}
for(k=0;k<NumberOfActiveAdsorbateAtomsZ[i];k++)
{
A1=ActiveAdsorbateAtomsZ[i][k].A;
B1=ActiveAdsorbateAtomsZ[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.z=FALSE;
}
for(k=0;k<NumberOfFixedAdsorbateAtoms[i];k++)
{
A1=FixedAdsorbateAtoms[i][k].A;
B1=FixedAdsorbateAtoms[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.x=TRUE;
Adsorbates[i][A1].Atoms[B1].Fixed.y=TRUE;
Adsorbates[i][A1].Atoms[B1].Fixed.z=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateAtomsX[i];k++)
{
A1=FixedAdsorbateAtomsX[i][k].A;
B1=FixedAdsorbateAtomsX[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.x=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateAtomsY[i];k++)
{
A1=FixedAdsorbateAtomsY[i][k].A;
B1=FixedAdsorbateAtomsY[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.y=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateAtomsZ[i];k++)
{
A1=FixedAdsorbateAtomsZ[i][k].A;
B1=FixedAdsorbateAtomsZ[i][k].B;
Adsorbates[i][A1].Atoms[B1].Fixed.z=TRUE;
}
for(k=0;k<NumberOfActiveAdsorbateGroups[i];k++)
{
A1=ActiveAdsorbateGroups[i][k].A;
B1=ActiveAdsorbateGroups[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.x=FALSE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.y=FALSE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.z=FALSE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.x=FALSE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.y=FALSE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.z=FALSE;
}
for(k=0;k<NumberOfFixedAdsorbateGroups[i];k++)
{
A1=FixedAdsorbateGroups[i][k].A;
B1=FixedAdsorbateGroups[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.x=TRUE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.y=TRUE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.z=TRUE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.x=TRUE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.y=TRUE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.z=TRUE;
}
for(k=0;k<NumberOfActiveAdsorbateGroupsCenterOfMass[i];k++)
{
A1=ActiveAdsorbateGroupsCenterOfMass[i][k].A;
B1=ActiveAdsorbateGroupsCenterOfMass[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.x=FALSE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.y=FALSE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.z=FALSE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsCenterOfMass[i];k++)
{
A1=FixedAdsorbateGroupsCenterOfMass[i][k].A;
B1=FixedAdsorbateGroupsCenterOfMass[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.x=TRUE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.y=TRUE;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.z=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsCenterOfMassX[i];k++)
{
A1=FixedAdsorbateGroupsCenterOfMassX[i][k].A;
B1=FixedAdsorbateGroupsCenterOfMassX[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.x=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsCenterOfMassY[i];k++)
{
A1=FixedAdsorbateGroupsCenterOfMassY[i][k].A;
B1=FixedAdsorbateGroupsCenterOfMassY[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.y=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsCenterOfMassZ[i];k++)
{
A1=FixedAdsorbateGroupsCenterOfMassZ[i][k].A;
B1=FixedAdsorbateGroupsCenterOfMassZ[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedCenterOfMass.z=TRUE;
}
for(k=0;k<NumberOfActiveAdsorbateGroupsOrientation[i];k++)
{
A1=ActiveAdsorbateGroupsOrientation[i][k].A;
B1=ActiveAdsorbateGroupsOrientation[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedOrientation.x=FALSE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.y=FALSE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.z=FALSE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsOrientation[i];k++)
{
A1=FixedAdsorbateGroupsOrientation[i][k].A;
B1=FixedAdsorbateGroupsOrientation[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedOrientation.x=TRUE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.y=TRUE;
Adsorbates[i][A1].Groups[B1].FixedOrientation.z=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsOrientationX[i];k++)
{
A1=FixedAdsorbateGroupsOrientationX[i][k].A;
B1=FixedAdsorbateGroupsOrientationX[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedOrientation.x=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsOrientationY[i];k++)
{
A1=FixedAdsorbateGroupsOrientationY[i][k].A;
B1=FixedAdsorbateGroupsOrientationY[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedOrientation.y=TRUE;
}
for(k=0;k<NumberOfFixedAdsorbateGroupsOrientationZ[i];k++)
{
A1=FixedAdsorbateGroupsOrientationZ[i][k].A;
B1=FixedAdsorbateGroupsOrientationZ[i][k].B;
Adsorbates[i][A1].Groups[B1].FixedOrientation.z=TRUE;
}
// overwrite individual settings for the cations
for(k=0;k<NumberOfActiveCationMolecules[i];k++)
{
A1=ActiveCationMolecules[i][k];
Type=Cations[i][A1].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid) // rigid unit
{
Cations[i][A1].Groups[l].FixedCenterOfMass.x=FALSE;
Cations[i][A1].Groups[l].FixedCenterOfMass.y=FALSE;
Cations[i][A1].Groups[l].FixedCenterOfMass.x=FALSE;
Cations[i][A1].Groups[l].FixedOrientation.x=FALSE;
Cations[i][A1].Groups[l].FixedOrientation.y=FALSE;
Cations[i][A1].Groups[l].FixedOrientation.z=FALSE;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
Cations[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.x=FALSE;
Cations[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.y=FALSE;
Cations[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.z=FALSE;
}
}
}
}
for(k=0;k<NumberOfFixedCationMolecules[i];k++)
{
A1=FixedCationMolecules[i][k];
Type=Cations[i][A1].Type;
for(l=0;l<Components[Type].NumberOfGroups;l++)
{
if(Components[Type].Groups[l].Rigid) // rigid unit
{
Cations[i][A1].Groups[l].FixedCenterOfMass.x=TRUE;
Cations[i][A1].Groups[l].FixedCenterOfMass.y=TRUE;
Cations[i][A1].Groups[l].FixedCenterOfMass.z=TRUE;
Cations[i][A1].Groups[l].FixedOrientation.x=TRUE;
Cations[i][A1].Groups[l].FixedOrientation.y=TRUE;
Cations[i][A1].Groups[l].FixedOrientation.z=TRUE;
}
else
{
for(j=0;j<Components[Type].Groups[l].NumberOfGroupAtoms;j++)
{
Cations[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.x=TRUE;
Cations[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.y=TRUE;
Cations[i][A1].Atoms[Components[Type].Groups[l].Atoms[j]].Fixed.z=TRUE;
}
}
}
}
for(k=0;k<NumberOfActiveCationAtoms[i];k++)
{
A1=ActiveCationAtoms[i][k].A;
B1=ActiveCationAtoms[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.x=FALSE;
Cations[i][A1].Atoms[B1].Fixed.y=FALSE;
Cations[i][A1].Atoms[B1].Fixed.z=FALSE;
}
for(k=0;k<NumberOfActiveCationAtomsX[i];k++)
{
A1=ActiveCationAtomsX[i][k].A;
B1=ActiveCationAtomsX[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.x=FALSE;
}
for(k=0;k<NumberOfActiveCationAtomsY[i];k++)
{
A1=ActiveCationAtomsY[i][k].A;
B1=ActiveCationAtomsY[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.y=FALSE;
}
for(k=0;k<NumberOfActiveCationAtomsZ[i];k++)
{
A1=ActiveCationAtomsZ[i][k].A;
B1=ActiveCationAtomsZ[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.z=FALSE;
}
for(k=0;k<NumberOfFixedCationAtoms[i];k++)
{
A1=FixedCationAtoms[i][k].A;
B1=FixedCationAtoms[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.x=TRUE;
Cations[i][A1].Atoms[B1].Fixed.y=TRUE;
Cations[i][A1].Atoms[B1].Fixed.z=TRUE;
}
for(k=0;k<NumberOfFixedCationAtomsX[i];k++)
{
A1=FixedCationAtomsX[i][k].A;
B1=FixedCationAtomsX[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.x=TRUE;
}
for(k=0;k<NumberOfFixedCationAtomsY[i];k++)
{
A1=FixedCationAtomsY[i][k].A;
B1=FixedCationAtomsY[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.y=TRUE;
}
for(k=0;k<NumberOfFixedCationAtomsZ[i];k++)
{
A1=FixedCationAtomsZ[i][k].A;
B1=FixedCationAtomsZ[i][k].B;
Cations[i][A1].Atoms[B1].Fixed.z=TRUE;
}
for(k=0;k<NumberOfActiveCationGroups[i];k++)
{
A1=ActiveCationGroups[i][k].A;
B1=ActiveCationGroups[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.x=FALSE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.y=FALSE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.z=FALSE;
Cations[i][A1].Groups[B1].FixedOrientation.x=FALSE;
Cations[i][A1].Groups[B1].FixedOrientation.y=FALSE;
Cations[i][A1].Groups[B1].FixedOrientation.z=FALSE;
}
for(k=0;k<NumberOfFixedCationGroups[i];k++)
{
A1=FixedCationGroups[i][k].A;
B1=FixedCationGroups[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.x=TRUE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.y=TRUE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.z=TRUE;
Cations[i][A1].Groups[B1].FixedOrientation.x=TRUE;
Cations[i][A1].Groups[B1].FixedOrientation.y=TRUE;
Cations[i][A1].Groups[B1].FixedOrientation.z=TRUE;
}
for(k=0;k<NumberOfActiveCationGroupsCenterOfMass[i];k++)
{
A1=ActiveCationGroupsCenterOfMass[i][k].A;
B1=ActiveCationGroupsCenterOfMass[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.x=FALSE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.y=FALSE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.z=FALSE;
}
for(k=0;k<NumberOfActiveCationGroupsCenterOfMassX[i];k++)
{
A1=ActiveCationGroupsCenterOfMassX[i][k].A;
B1=ActiveCationGroupsCenterOfMassX[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.x=FALSE;
}
for(k=0;k<NumberOfActiveCationGroupsCenterOfMassY[i];k++)
{
A1=ActiveCationGroupsCenterOfMassY[i][k].A;
B1=ActiveCationGroupsCenterOfMassY[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.y=FALSE;
}
for(k=0;k<NumberOfActiveCationGroupsCenterOfMassZ[i];k++)
{
A1=ActiveCationGroupsCenterOfMassZ[i][k].A;
B1=ActiveCationGroupsCenterOfMassZ[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.z=FALSE;
}
for(k=0;k<NumberOfFixedCationGroupsCenterOfMass[i];k++)
{
A1=FixedCationGroupsCenterOfMass[i][k].A;
B1=FixedCationGroupsCenterOfMass[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.x=TRUE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.y=TRUE;
Cations[i][A1].Groups[B1].FixedCenterOfMass.z=TRUE;
}
for(k=0;k<NumberOfFixedCationGroupsCenterOfMassX[i];k++)
{
A1=FixedCationGroupsCenterOfMassX[i][k].A;
B1=FixedCationGroupsCenterOfMassX[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.x=TRUE;
}
for(k=0;k<NumberOfFixedCationGroupsCenterOfMassY[i];k++)
{
A1=FixedCationGroupsCenterOfMassY[i][k].A;
B1=FixedCationGroupsCenterOfMassY[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.y=TRUE;
}
for(k=0;k<NumberOfFixedCationGroupsCenterOfMassZ[i];k++)
{
A1=FixedCationGroupsCenterOfMassZ[i][k].A;
B1=FixedCationGroupsCenterOfMassZ[i][k].B;
Cations[i][A1].Groups[B1].FixedCenterOfMass.z=TRUE;
}
for(k=0;k<NumberOfActiveCationGroupsOrientation[i];k++)
{
A1=ActiveCationGroupsOrientation[i][k].A;
B1=ActiveCationGroupsOrientation[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.x=FALSE;
Cations[i][A1].Groups[B1].FixedOrientation.y=FALSE;
Cations[i][A1].Groups[B1].FixedOrientation.z=FALSE;
}
for(k=0;k<NumberOfActiveCationGroupsOrientationX[i];k++)
{
A1=ActiveCationGroupsOrientationX[i][k].A;
B1=ActiveCationGroupsOrientationX[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.x=FALSE;
}
for(k=0;k<NumberOfActiveCationGroupsOrientationY[i];k++)
{
A1=ActiveCationGroupsOrientationY[i][k].A;
B1=ActiveCationGroupsOrientationY[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.y=FALSE;
}
for(k=0;k<NumberOfActiveCationGroupsOrientationZ[i];k++)
{
A1=ActiveCationGroupsOrientationZ[i][k].A;
B1=ActiveCationGroupsOrientationZ[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.z=FALSE;
}
for(k=0;k<NumberOfFixedCationGroupsOrientation[i];k++)
{
A1=FixedCationGroupsOrientation[i][k].A;
B1=FixedCationGroupsOrientation[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.x=TRUE;
Cations[i][A1].Groups[B1].FixedOrientation.y=TRUE;
Cations[i][A1].Groups[B1].FixedOrientation.z=TRUE;
}
for(k=0;k<NumberOfFixedCationGroupsOrientationX[i];k++)
{
A1=FixedCationGroupsOrientationX[i][k].A;
B1=FixedCationGroupsOrientationX[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.x=TRUE;
}
for(k=0;k<NumberOfFixedCationGroupsOrientationY[i];k++)
{
A1=FixedCationGroupsOrientationY[i][k].A;
B1=FixedCationGroupsOrientationY[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.y=TRUE;
}
for(k=0;k<NumberOfFixedCationGroupsOrientationZ[i];k++)
{
A1=FixedCationGroupsOrientationZ[i][k].A;
B1=FixedCationGroupsOrientationZ[i][k].B;
Cations[i][A1].Groups[B1].FixedOrientation.z=TRUE;
}
}
if(Restart)
{
if(RestartStyle==RASPA_STYLE)
ReadRestartFile();
else if(RestartStyle==RASPA_STYLE_OLD)
ReadRestartFileOld();
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
InitializeReplicaBox();
}
InitializeEwald(EwaldPrecision,EwaldAutomatic);
AllocateEwaldMemory();
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
if(PutMoleculeOnBarrier[CurrentSystem])
{
s=BarrierPosition[CurrentSystem];
do
{
NumberOfBeadsAlreadyPlaced=0;
CurrentAdsorbateMolecule=0;
CurrentCationMolecule=0;
CurrentComponent=0;
StartingBead=Components[CurrentComponent].StartingBead;
NewPosition[CurrentSystem][StartingBead].x=UnitCellBox[CurrentSystem].ax*s.x+UnitCellBox[CurrentSystem].bx*s.y+UnitCellBox[CurrentSystem].cx*s.z;
NewPosition[CurrentSystem][StartingBead].y=UnitCellBox[CurrentSystem].ay*s.x+UnitCellBox[CurrentSystem].by*s.y+UnitCellBox[CurrentSystem].cy*s.z;
NewPosition[CurrentSystem][StartingBead].z=UnitCellBox[CurrentSystem].az*s.x+UnitCellBox[CurrentSystem].bz*s.y+UnitCellBox[CurrentSystem].cz*s.z;
GrowMolecule(CBMC_PARTIAL_INSERTION);
}
while(OVERLAP==TRUE);
if(Components[CurrentComponent].ExtraFrameworkMolecule)
InsertCationMolecule();
else
InsertAdsorbateMolecule();
Components[CurrentComponent].CreateNumberOfMolecules[CurrentSystem]--;
}
SetBarierNormal();
}
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
NumberOfReactionMolecules[CurrentSystem]=0;
NumberOfReactionAdsorbateMolecules[CurrentSystem]=0;
NumberOfReactionCationMolecules[CurrentSystem]=0;
for(j=0;j<NumberOfComponents;j++)
{
// the are no molecules present from a restart-file -> create reaction fractional molecules
if(Components[j].NumberOfMolecules[CurrentSystem]==0)
{
for(k=0;k<NumberOfReactions;k++)
{
CFCRXMCLambda[CurrentSystem][k]=0.5;
for(l=0;l<ReactantsStoichiometry[k][j];l++)
{
if(Components[j].ExtraFrameworkMolecule)
{
MakeInitialCations(1,j);
Components[j].ReactantFractionalMolecules[CurrentSystem][k][l]=NumberOfCationMolecules[CurrentSystem]-1;
NumberOfReactionMolecules[CurrentSystem]++;
NumberOfReactionCationMolecules[CurrentSystem]++;
for(m=0;m<Components[j].NumberOfAtoms;m++)
{
Cations[CurrentSystem][NumberOfCationMolecules[CurrentSystem]-1].Atoms[m].CFVDWScalingParameter=0.999999;
Cations[CurrentSystem][NumberOfCationMolecules[CurrentSystem]-1].Atoms[m].CFChargeScalingParameter=pow(0.999999,5);
}
}
else
{
MakeInitialAdsorbates(1,j);
Components[j].ReactantFractionalMolecules[CurrentSystem][k][l]=NumberOfAdsorbateMolecules[CurrentSystem]-1;
NumberOfReactionMolecules[CurrentSystem]++;
NumberOfReactionAdsorbateMolecules[CurrentSystem]++;
for(m=0;m<Components[j].NumberOfAtoms;m++)
{
Adsorbates[CurrentSystem][NumberOfAdsorbateMolecules[CurrentSystem]-1].Atoms[m].CFVDWScalingParameter=0.999999;
Adsorbates[CurrentSystem][NumberOfAdsorbateMolecules[CurrentSystem]-1].Atoms[m].CFChargeScalingParameter=pow(0.999999,5);
}
}
}
for(l=0;l<ProductsStoichiometry[k][j];l++)
{
if(Components[j].ExtraFrameworkMolecule)
{
MakeInitialCations(1,j);
Components[j].ProductFractionalMolecules[CurrentSystem][k][l]=NumberOfCationMolecules[CurrentSystem]-1;
NumberOfReactionMolecules[CurrentSystem]++;
NumberOfReactionCationMolecules[CurrentSystem]++;
for(m=0;m<Components[j].NumberOfAtoms;m++)
{
Cations[CurrentSystem][NumberOfCationMolecules[CurrentSystem]-1].Atoms[m].CFVDWScalingParameter=0.999999;
Cations[CurrentSystem][NumberOfCationMolecules[CurrentSystem]-1].Atoms[m].CFChargeScalingParameter=pow(0.999999,5);
}
}
else
{
MakeInitialAdsorbates(1,j);
Components[j].ProductFractionalMolecules[CurrentSystem][k][l]=NumberOfAdsorbateMolecules[CurrentSystem]-1;
NumberOfReactionMolecules[CurrentSystem]++;
NumberOfReactionAdsorbateMolecules[CurrentSystem]++;
for(m=0;m<Components[j].NumberOfAtoms;m++)
{
Adsorbates[CurrentSystem][NumberOfAdsorbateMolecules[CurrentSystem]-1].Atoms[m].CFVDWScalingParameter=0.999999;
Adsorbates[CurrentSystem][NumberOfAdsorbateMolecules[CurrentSystem]-1].Atoms[m].CFChargeScalingParameter=pow(0.999999,5);
}
}
}
}
}
}
}
for(i=0;i<NumberOfSystems;i++)
{
for(j=0;j<NumberOfComponents;j++)
{
// create the initial integer number of molecules
if(Components[j].CreateNumberOfMolecules[i]>0)
{
CurrentSystem=i;
CalculateAnisotropicSites();
if(Components[j].ExtraFrameworkMolecule)
MakeInitialCations(Components[j].CreateNumberOfMolecules[i],j);
else
MakeInitialAdsorbates(Components[j].CreateNumberOfMolecules[i],j);
}
}
}
switch(SimulationSubType)
{
case GIBBS_CFCMC_SINGLE_FRACTIONAL_PARTICLE:
for(j=0;j<NumberOfComponents;j++)
{
int shouldAddFractionalMolecule=TRUE;
// test whether there is already a fractional molecule for this component in any system
for(i=0;i<NumberOfSystems;i++)
{
shouldAddFractionalMolecule=shouldAddFractionalMolecule && (Components[j].FractionalMolecule[i]<0);
}
if(shouldAddFractionalMolecule)
{
// add the fractional molecule always to system 0 (there needs to be only one for all systems)
NumberOfFractionalMolecules[0]++;
if(Components[j].ExtraFrameworkMolecule)
NumberOfFractionalCationMolecules[0]++;
else
NumberOfFractionalAdsorbateMolecules[0]++;
// CF: if number of molecules is zero, create an initial fractional molecule
CurrentSystem=0;
CalculateAnisotropicSites();
if(Components[j].NumberOfMolecules[0]==0)
{
fprintf(stderr, "Creating Lambda particle\n");
if(Components[j].ExtraFrameworkMolecule)
MakeInitialCations(1,j);
else
MakeInitialAdsorbates(1,j);
}
if(Components[j].FractionalMolecule[0]<0)
{
CurrentSystem=0;
Components[j].FractionalMolecule[0]=SelectRandomMoleculeOfType(j);
// start with Lambda=0.5
for(k=0;k<Components[j].NumberOfAtoms;k++)
{
if(Components[j].ExtraFrameworkMolecule)
{
Cations[0][Components[j].FractionalMolecule[0]].Atoms[k].CFVDWScalingParameter=0.5;
Cations[0][Components[j].FractionalMolecule[0]].Atoms[k].CFChargeScalingParameter=pow(0.5,5);
}
else
{
Adsorbates[0][Components[j].FractionalMolecule[0]].Atoms[k].CFVDWScalingParameter=0.5;
Adsorbates[0][Components[j].FractionalMolecule[0]].Atoms[k].CFChargeScalingParameter=pow(0.5,5);
}
// count the fractional-molecule pseudo-atom types (needed to correct the tail-correction energy)
NumberOfFractionalPseudoAtomsType[0][Components[j].Type[k]]++;
}
}
}
}
break;
default:
for(i=0;i<NumberOfSystems;i++)
{
for(j=0;j<NumberOfComponents;j++)
{
if(Components[j].CFMoleculePresent[i] && (Components[j].FractionalMolecule[i]<0))
{
NumberOfFractionalMolecules[i]++;
if(Components[j].ExtraFrameworkMolecule)
NumberOfFractionalCationMolecules[i]++;
else
NumberOfFractionalAdsorbateMolecules[i]++;
// CF: if number of molecules is zero, create an initial fractional molecule
CurrentSystem=i;
CalculateAnisotropicSites();
if(Components[j].NumberOfMolecules[i]==0)
{
fprintf(stderr, "Creating Lambda particle\n");
if(Components[j].ExtraFrameworkMolecule)
MakeInitialCations(1,j);
else
MakeInitialAdsorbates(1,j);
}
if(Components[j].FractionalMolecule[i]<0)
{
CurrentSystem=i;
Components[j].FractionalMolecule[i]=SelectRandomMoleculeOfType(j);
// start with Lambda=0.5
for(k=0;k<Components[j].NumberOfAtoms;k++)
{
if(Components[j].ExtraFrameworkMolecule)
{
Cations[i][Components[j].FractionalMolecule[i]].Atoms[k].CFVDWScalingParameter=0.5;
Cations[i][Components[j].FractionalMolecule[i]].Atoms[k].CFChargeScalingParameter=pow(0.5,5);
}
else
{
Adsorbates[i][Components[j].FractionalMolecule[i]].Atoms[k].CFVDWScalingParameter=0.5;
Adsorbates[i][Components[j].FractionalMolecule[i]].Atoms[k].CFChargeScalingParameter=pow(0.5,5);
}
// count the fractional-molecule pseudo-atom types (needed to correct the tail-correction energy)
NumberOfFractionalPseudoAtomsType[i][Components[j].Type[k]]++;
}
}
}
}
}
break;
}
// for some CF only 1 system has CFMoleculePresent true (1 fractional particle for all systems, i.e. Gibbs)
// At this point: set CFMoleculePresent the same for all systems
if (SimulationSubType==GIBBS_CFCMC_SINGLE_FRACTIONAL_PARTICLE)
{
CFMoleculePresent=FALSE;
for(i=0;i<NumberOfSystems;i++)
{
for(j=0;j<NumberOfComponents;j++)
{
CFMoleculePresent=CFMoleculePresent || Components[j].CFMoleculePresent[i];
}
}
for(i=0;i<NumberOfSystems;i++)
{
for(j=0;j<NumberOfComponents;j++)
{
Components[j].CFMoleculePresent[i]=CFMoleculePresent;
}
}
}
// compute the Inertia-tensors and quaternions for all rigid molecules
ComputeQuaternions();
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
// compute the intial center-of-mass position
Framework[CurrentSystem].IntialCenterOfMassPosition=GetFrameworkCenterOfMass();
IntialCenterOfMassPosition[CurrentSystem]=GetCenterOfMassCurrentSystem();
}
CheckConfigMoves();
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
PrintRestartFile();
for(i=0;i<NumberOfSystems;i++)
WriteVTK(i);
// distance pairs for histograms
for(i=0;i<NumberOfSystems;i++)
{
if(NumberOfDistanceHistogramDefinitions[i]>0)
{
DistanceHistogramPairs[i]=(ATOM*(*)[2])calloc(NumberOfDistanceHistogramDefinitions[i],sizeof(ATOM*[2]));
for(j=0;j<NumberOfDistanceHistogramDefinitions[i];j++)
{
intinput1=DistanceHistogramDefinitions[i][j][0][1];
intinput2=DistanceHistogramDefinitions[i][j][0][2];
switch(DistanceHistogramDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DistanceHistogramPairs[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DistanceHistogramPairs[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DistanceHistogramPairs[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=DistanceHistogramDefinitions[i][j][1][1];
intinput4=DistanceHistogramDefinitions[i][j][1][2];
switch(DistanceHistogramDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
DistanceHistogramPairs[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
DistanceHistogramPairs[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
DistanceHistogramPairs[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
}
}
}
// bend-angle trimers for histograms
for(i=0;i<NumberOfSystems;i++)
{
if(NumberOfBendAngleHistogramDefinitions[i]>0)
{
BendAngleHistogramPairs[i]=(ATOM*(*)[3])calloc(NumberOfBendAngleHistogramDefinitions[i],sizeof(ATOM*[3]));
for(j=0;j<NumberOfBendAngleHistogramDefinitions[i];j++)
{
intinput1=BendAngleHistogramDefinitions[i][j][0][1];
intinput2=BendAngleHistogramDefinitions[i][j][0][2];
switch(BendAngleHistogramDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
BendAngleHistogramPairs[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
BendAngleHistogramPairs[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
BendAngleHistogramPairs[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=BendAngleHistogramDefinitions[i][j][1][1];
intinput2=BendAngleHistogramDefinitions[i][j][1][2];
switch(BendAngleHistogramDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
BendAngleHistogramPairs[i][j][1]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
BendAngleHistogramPairs[i][j][1]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
BendAngleHistogramPairs[i][j][1]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=BendAngleHistogramDefinitions[i][j][2][1];
intinput2=BendAngleHistogramDefinitions[i][j][2][2];
switch(BendAngleHistogramDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
BendAngleHistogramPairs[i][j][2]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
BendAngleHistogramPairs[i][j][2]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
BendAngleHistogramPairs[i][j][2]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
}
}
}
// Dihedral-angle quads for histograms
for(i=0;i<NumberOfSystems;i++)
{
if(NumberOfDihedralAngleHistogramDefinitions[i]>0)
{
DihedralAngleHistogramPairs[i]=(ATOM*(*)[4])calloc(NumberOfDihedralAngleHistogramDefinitions[i],sizeof(ATOM*[4]));
for(j=0;j<NumberOfDihedralAngleHistogramDefinitions[i];j++)
{
intinput1=DihedralAngleHistogramDefinitions[i][j][0][1];
intinput2=DihedralAngleHistogramDefinitions[i][j][0][2];
switch(DihedralAngleHistogramDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=DihedralAngleHistogramDefinitions[i][j][1][1];
intinput2=DihedralAngleHistogramDefinitions[i][j][1][2];
switch(DihedralAngleHistogramDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][1]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][1]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][1]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=DihedralAngleHistogramDefinitions[i][j][2][1];
intinput2=DihedralAngleHistogramDefinitions[i][j][2][2];
switch(DihedralAngleHistogramDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][2]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][2]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][2]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=DihedralAngleHistogramDefinitions[i][j][3][1];
intinput2=DihedralAngleHistogramDefinitions[i][j][3][2];
switch(DihedralAngleHistogramDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][3]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][3]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DihedralAngleHistogramPairs[i][j][3]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
}
}
}
// Dihedral-angle quads for histograms
for(i=0;i<NumberOfSystems;i++)
{
if(NumberOfAngleBetweenPlanesHistogramDefinitions[i]>0)
{
AngleBetweenPlanesHistogramPairs[i]=(ATOM*(*)[6])calloc(NumberOfAngleBetweenPlanesHistogramDefinitions[i],sizeof(ATOM*[6]));
for(j=0;j<NumberOfAngleBetweenPlanesHistogramDefinitions[i];j++)
{
intinput1=AngleBetweenPlanesHistogramDefinitions[i][j][0][1];
intinput2=AngleBetweenPlanesHistogramDefinitions[i][j][0][2];
switch(AngleBetweenPlanesHistogramDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=AngleBetweenPlanesHistogramDefinitions[i][j][1][1];
intinput2=AngleBetweenPlanesHistogramDefinitions[i][j][1][2];
switch(AngleBetweenPlanesHistogramDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][1]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][1]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][1]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=AngleBetweenPlanesHistogramDefinitions[i][j][2][1];
intinput2=AngleBetweenPlanesHistogramDefinitions[i][j][2][2];
switch(AngleBetweenPlanesHistogramDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][2]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][2]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][2]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=AngleBetweenPlanesHistogramDefinitions[i][j][3][1];
intinput2=AngleBetweenPlanesHistogramDefinitions[i][j][3][2];
switch(AngleBetweenPlanesHistogramDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][3]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][3]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][3]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=AngleBetweenPlanesHistogramDefinitions[i][j][4][1];
intinput2=AngleBetweenPlanesHistogramDefinitions[i][j][4][2];
switch(AngleBetweenPlanesHistogramDefinitions[i][j][4][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][4]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][4]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][4]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=AngleBetweenPlanesHistogramDefinitions[i][j][5][1];
intinput2=AngleBetweenPlanesHistogramDefinitions[i][j][5][2];
switch(AngleBetweenPlanesHistogramDefinitions[i][j][5][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][5]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][5]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleBetweenPlanesHistogramPairs[i][j][5]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
}
}
}
for(i=0;i<NumberOfSystems;i++)
{
if(NumberOfDistanceConstraints[i]>0)
{
DistanceConstraints[i]=(ATOM*(*)[2])calloc(NumberOfDistanceConstraints[i],sizeof(ATOM*[2]));
DistanceConstraintsDerivatives[i]=(VECTOR(*)[2])calloc(NumberOfDistanceConstraints[i],sizeof(VECTOR[2]));
for(j=0;j<NumberOfDistanceConstraints[i];j++)
{
intinput1=DistanceDefinitions[i][j][0][1];
intinput2=DistanceDefinitions[i][j][0][2];
switch(DistanceDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DistanceConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DistanceConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DistanceConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=DistanceDefinitions[i][j][1][1];
intinput4=DistanceDefinitions[i][j][1][2];
switch(DistanceDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
DistanceConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
DistanceConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
DistanceConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
}
}
if(NumberOfAngleConstraints[i]>0)
{
AngleConstraints[i]=(ATOM*(*)[3])calloc(NumberOfAngleConstraints[i],sizeof(ATOM*[3]));
AngleConstraintsDerivatives[i]=(VECTOR(*)[3])calloc(NumberOfAngleConstraints[i],sizeof(VECTOR[3]));
for(j=0;j<NumberOfAngleConstraints[i];j++)
{
intinput1=AngleDefinitions[i][j][0][1];
intinput2=AngleDefinitions[i][j][0][2];
switch(AngleDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
AngleConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
AngleConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
AngleConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=AngleDefinitions[i][j][1][1];
intinput4=AngleDefinitions[i][j][1][2];
switch(AngleDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
AngleConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
AngleConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
AngleConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=AngleDefinitions[i][j][2][1];
intinput6=AngleDefinitions[i][j][2][2];
switch(AngleDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
AngleConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
AngleConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
AngleConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
}
}
if(NumberOfDihedralConstraints[i]>0)
{
DihedralConstraints[i]=(ATOM*(*)[4])calloc(NumberOfDihedralConstraints[i],sizeof(ATOM*[4]));
DihedralConstraintsDerivatives[i]=(VECTOR(*)[4])calloc(NumberOfDihedralConstraints[i],sizeof(VECTOR[4]));
for(j=0;j<NumberOfDihedralConstraints[i];j++)
{
intinput1=DihedralDefinitions[i][j][0][1];
intinput2=DihedralDefinitions[i][j][0][2];
switch(DihedralDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
DihedralConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
DihedralConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
DihedralConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=DihedralDefinitions[i][j][1][1];
intinput4=DihedralDefinitions[i][j][1][2];
switch(DihedralDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
DihedralConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
DihedralConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
DihedralConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=DihedralDefinitions[i][j][2][1];
intinput6=DihedralDefinitions[i][j][2][2];
switch(DihedralDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
DihedralConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
DihedralConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
DihedralConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
intinput7=DihedralDefinitions[i][j][3][1];
intinput8=DihedralDefinitions[i][j][3][2];
switch(DihedralDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput7,intinput8);
DihedralConstraints[i][j][3]=&Framework[i].Atoms[intinput7][intinput8];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput7,intinput8);
DihedralConstraints[i][j][3]=&Adsorbates[i][intinput7].Atoms[intinput8];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput7,intinput8);
DihedralConstraints[i][j][3]=&Cations[i][intinput7].Atoms[intinput8];
break;
}
}
}
if(NumberOfImproperDihedralConstraints[i]>0)
{
ImproperDihedralConstraints[i]=(ATOM*(*)[4])calloc(NumberOfImproperDihedralConstraints[i],sizeof(ATOM*[4]));
ImproperDihedralConstraintsDerivatives[i]=(VECTOR(*)[4])calloc(NumberOfImproperDihedralConstraints[i],sizeof(VECTOR[4]));
for(j=0;j<NumberOfImproperDihedralConstraints[i];j++)
{
intinput1=ImproperDihedralDefinitions[i][j][0][1];
intinput2=ImproperDihedralDefinitions[i][j][0][2];
switch(ImproperDihedralDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
ImproperDihedralConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
ImproperDihedralConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
ImproperDihedralConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=ImproperDihedralDefinitions[i][j][1][1];
intinput4=ImproperDihedralDefinitions[i][j][1][2];
switch(ImproperDihedralDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
ImproperDihedralConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
ImproperDihedralConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
ImproperDihedralConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=ImproperDihedralDefinitions[i][j][2][1];
intinput6=ImproperDihedralDefinitions[i][j][2][2];
switch(ImproperDihedralDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
ImproperDihedralConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
ImproperDihedralConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
ImproperDihedralConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
intinput7=ImproperDihedralDefinitions[i][j][3][1];
intinput8=ImproperDihedralDefinitions[i][j][3][2];
switch(ImproperDihedralDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput7,intinput8);
ImproperDihedralConstraints[i][j][3]=&Framework[i].Atoms[intinput7][intinput8];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput7,intinput8);
ImproperDihedralConstraints[i][j][3]=&Adsorbates[i][intinput7].Atoms[intinput8];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput7,intinput8);
ImproperDihedralConstraints[i][j][3]=&Cations[i][intinput7].Atoms[intinput8];
break;
}
}
}
if(NumberOfInversionBendConstraints[i]>0)
{
InversionBendConstraints[i]=(ATOM*(*)[4])calloc(NumberOfInversionBendConstraints[i],sizeof(ATOM*[4]));
InversionBendConstraintsDerivatives[i]=(VECTOR(*)[4])calloc(NumberOfInversionBendConstraints[i],sizeof(VECTOR[4]));
for(j=0;j<NumberOfInversionBendConstraints[i];j++)
{
intinput1=InversionBendDefinitions[i][j][0][1];
intinput2=InversionBendDefinitions[i][j][0][2];
switch(InversionBendDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
InversionBendConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
InversionBendConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
InversionBendConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=InversionBendDefinitions[i][j][1][1];
intinput4=InversionBendDefinitions[i][j][1][2];
switch(InversionBendDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
InversionBendConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
InversionBendConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
InversionBendConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=InversionBendDefinitions[i][j][2][1];
intinput6=InversionBendDefinitions[i][j][2][2];
switch(InversionBendDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
InversionBendConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
InversionBendConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
InversionBendConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
intinput7=InversionBendDefinitions[i][j][3][1];
intinput8=InversionBendDefinitions[i][j][3][2];
switch(InversionBendDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput7,intinput8);
InversionBendConstraints[i][j][3]=&Framework[i].Atoms[intinput7][intinput8];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput7,intinput8);
InversionBendConstraints[i][j][3]=&Adsorbates[i][intinput7].Atoms[intinput8];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput7,intinput8);
InversionBendConstraints[i][j][3]=&Cations[i][intinput7].Atoms[intinput8];
break;
}
}
}
if(NumberOfOutOfPlaneDistanceConstraints[i]>0)
{
OutOfPlaneDistanceConstraints[i]=(ATOM*(*)[4])calloc(NumberOfOutOfPlaneDistanceConstraints[i],sizeof(ATOM*[4]));
OutOfPlaneDistanceConstraintsDerivatives[i]=(VECTOR(*)[4])calloc(NumberOfOutOfPlaneDistanceConstraints[i],sizeof(VECTOR[4]));
for(j=0;j<NumberOfOutOfPlaneDistanceConstraints[i];j++)
{
intinput1=OutOfPlaneDistanceDefinitions[i][j][0][1];
intinput2=OutOfPlaneDistanceDefinitions[i][j][0][2];
switch(OutOfPlaneDistanceDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
OutOfPlaneDistanceConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
OutOfPlaneDistanceConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
OutOfPlaneDistanceConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=OutOfPlaneDistanceDefinitions[i][j][1][1];
intinput4=OutOfPlaneDistanceDefinitions[i][j][1][2];
switch(OutOfPlaneDistanceDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
OutOfPlaneDistanceConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
OutOfPlaneDistanceConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
OutOfPlaneDistanceConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=OutOfPlaneDistanceDefinitions[i][j][2][1];
intinput6=OutOfPlaneDistanceDefinitions[i][j][2][2];
switch(OutOfPlaneDistanceDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
OutOfPlaneDistanceConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
OutOfPlaneDistanceConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
OutOfPlaneDistanceConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
intinput7=OutOfPlaneDistanceDefinitions[i][j][3][1];
intinput8=OutOfPlaneDistanceDefinitions[i][j][3][2];
switch(OutOfPlaneDistanceDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput7,intinput8);
OutOfPlaneDistanceConstraints[i][j][3]=&Framework[i].Atoms[intinput7][intinput8];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput7,intinput8);
OutOfPlaneDistanceConstraints[i][j][3]=&Adsorbates[i][intinput7].Atoms[intinput8];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput7,intinput8);
OutOfPlaneDistanceConstraints[i][j][3]=&Cations[i][intinput7].Atoms[intinput8];
break;
}
}
}
if(NumberOfHarmonicDistanceConstraints[i]>0)
{
HarmonicDistanceConstraints[i]=(ATOM*(*)[2])calloc(NumberOfHarmonicDistanceConstraints[i],sizeof(ATOM*[2]));
for(j=0;j<NumberOfHarmonicDistanceConstraints[i];j++)
{
intinput1=HarmonicDistanceDefinitions[i][j][0][1];
intinput2=HarmonicDistanceDefinitions[i][j][0][2];
switch(HarmonicDistanceDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
HarmonicDistanceConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
HarmonicDistanceConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
HarmonicDistanceConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=HarmonicDistanceDefinitions[i][j][1][1];
intinput4=HarmonicDistanceDefinitions[i][j][1][2];
switch(HarmonicDistanceDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
HarmonicDistanceConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
HarmonicDistanceConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
HarmonicDistanceConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
}
}
if(NumberOfHarmonicAngleConstraints[i]>0)
{
HarmonicAngleConstraints[i]=(ATOM*(*)[3])calloc(NumberOfHarmonicAngleConstraints[i],sizeof(ATOM*[3]));
for(j=0;j<NumberOfHarmonicAngleConstraints[i];j++)
{
intinput1=HarmonicAngleDefinitions[i][j][0][1];
intinput2=HarmonicAngleDefinitions[i][j][0][2];
switch(HarmonicAngleDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
HarmonicAngleConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
HarmonicAngleConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
HarmonicAngleConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=HarmonicAngleDefinitions[i][j][1][1];
intinput4=HarmonicAngleDefinitions[i][j][1][2];
switch(HarmonicAngleDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
HarmonicAngleConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
HarmonicAngleConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
HarmonicAngleConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=HarmonicAngleDefinitions[i][j][2][1];
intinput6=HarmonicAngleDefinitions[i][j][2][2];
switch(HarmonicAngleDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
HarmonicAngleConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
HarmonicAngleConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
HarmonicAngleConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
}
}
if(NumberOfHarmonicDihedralConstraints[i]>0)
{
HarmonicDihedralConstraints[i]=(ATOM*(*)[4])calloc(NumberOfHarmonicDihedralConstraints[i],sizeof(ATOM*[4]));
for(j=0;j<NumberOfHarmonicDihedralConstraints[i];j++)
{
intinput1=HarmonicDihedralDefinitions[i][j][0][1];
intinput2=HarmonicDihedralDefinitions[i][j][0][2];
switch(HarmonicDihedralDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
HarmonicDihedralConstraints[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
HarmonicDihedralConstraints[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
HarmonicDihedralConstraints[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=HarmonicDihedralDefinitions[i][j][1][1];
intinput4=HarmonicDihedralDefinitions[i][j][1][2];
switch(HarmonicDihedralDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
HarmonicDihedralConstraints[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
HarmonicDihedralConstraints[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
HarmonicDihedralConstraints[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=HarmonicDihedralDefinitions[i][j][2][1];
intinput6=HarmonicDihedralDefinitions[i][j][2][2];
switch(HarmonicDihedralDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
HarmonicDihedralConstraints[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
HarmonicDihedralConstraints[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
HarmonicDihedralConstraints[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
intinput7=HarmonicDihedralDefinitions[i][j][3][1];
intinput8=HarmonicDihedralDefinitions[i][j][3][2];
switch(HarmonicDihedralDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput7,intinput8);
HarmonicDihedralConstraints[i][j][3]=&Framework[i].Atoms[intinput7][intinput8];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput7,intinput8);
HarmonicDihedralConstraints[i][j][3]=&Adsorbates[i][intinput7].Atoms[intinput8];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput7,intinput8);
HarmonicDihedralConstraints[i][j][3]=&Cations[i][intinput7].Atoms[intinput8];
break;
}
}
}
if(NumberOfTwoPointDihedralDefinitions[i]>0)
{
TwoPointDihedrals[i]=(ATOM*(*)[6])calloc(NumberOfTwoPointDihedralDefinitions[i],sizeof(ATOM*[6]));
for(j=0;j<NumberOfTwoPointDihedralDefinitions[i];j++)
{
intinput1=TwoPointDihedralDefinitions[i][j][0][1];
intinput2=TwoPointDihedralDefinitions[i][j][0][2];
switch(TwoPointDihedralDefinitions[i][j][0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
TwoPointDihedrals[i][j][0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
TwoPointDihedrals[i][j][0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
TwoPointDihedrals[i][j][0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput3=TwoPointDihedralDefinitions[i][j][1][1];
intinput4=TwoPointDihedralDefinitions[i][j][1][2];
switch(TwoPointDihedralDefinitions[i][j][1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput3,intinput4);
TwoPointDihedrals[i][j][1]=&Framework[i].Atoms[intinput3][intinput4];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput3,intinput4);
TwoPointDihedrals[i][j][1]=&Adsorbates[i][intinput3].Atoms[intinput4];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput3,intinput4);
TwoPointDihedrals[i][j][1]=&Cations[i][intinput3].Atoms[intinput4];
break;
}
intinput5=TwoPointDihedralDefinitions[i][j][2][1];
intinput6=TwoPointDihedralDefinitions[i][j][2][2];
switch(TwoPointDihedralDefinitions[i][j][2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput5,intinput6);
TwoPointDihedrals[i][j][2]=&Framework[i].Atoms[intinput5][intinput6];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput5,intinput6);
TwoPointDihedrals[i][j][2]=&Adsorbates[i][intinput5].Atoms[intinput6];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput5,intinput6);
TwoPointDihedrals[i][j][2]=&Cations[i][intinput5].Atoms[intinput6];
break;
}
intinput7=TwoPointDihedralDefinitions[i][j][3][1];
intinput8=TwoPointDihedralDefinitions[i][j][3][2];
switch(TwoPointDihedralDefinitions[i][j][3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput7,intinput8);
TwoPointDihedrals[i][j][3]=&Framework[i].Atoms[intinput7][intinput8];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput7,intinput8);
TwoPointDihedrals[i][j][3]=&Adsorbates[i][intinput7].Atoms[intinput8];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput7,intinput8);
TwoPointDihedrals[i][j][3]=&Cations[i][intinput7].Atoms[intinput8];
break;
}
intinput9=TwoPointDihedralDefinitions[i][j][4][1];
intinput10=TwoPointDihedralDefinitions[i][j][4][2];
switch(TwoPointDihedralDefinitions[i][j][4][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput9,intinput10);
TwoPointDihedrals[i][j][4]=&Framework[i].Atoms[intinput9][intinput10];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput9,intinput10);
TwoPointDihedrals[i][j][4]=&Adsorbates[i][intinput9].Atoms[intinput10];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput9,intinput10);
TwoPointDihedrals[i][j][4]=&Cations[i][intinput9].Atoms[intinput10];
break;
}
intinput11=TwoPointDihedralDefinitions[i][j][5][1];
intinput12=TwoPointDihedralDefinitions[i][j][5][2];
switch(TwoPointDihedralDefinitions[i][j][5][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput11,intinput12);
TwoPointDihedrals[i][j][5]=&Framework[i].Atoms[intinput11][intinput12];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput11,intinput12);
TwoPointDihedrals[i][j][5]=&Adsorbates[i][intinput11].Atoms[intinput12];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput11,intinput12);
TwoPointDihedrals[i][j][5]=&Cations[i][intinput11].Atoms[intinput12];
break;
}
}
}
for(j=0;j<NumberOfDistanceConstraints[i];j++)
if(DistanceConstraintParameter[i][j]<0.0)
DistanceConstraintParameter[i][j]=ReturnBondDistance(DistanceConstraints[i][j][0]->Position,
DistanceConstraints[i][j][1]->Position);
for(j=0;j<NumberOfAngleConstraints[i];j++)
if(AngleConstraintParameter[i][j]<-180.0)
AngleConstraintParameter[i][j]=ReturnBendAngle(AngleConstraints[i][j][0]->Position,
AngleConstraints[i][j][1]->Position,AngleConstraints[i][j][2]->Position);
for(j=0;j<NumberOfDihedralConstraints[i];j++)
if(DihedralConstraintParameter[i][j]<-180.0)
DihedralConstraintParameter[i][j]=ReturnDihedralAngle(DihedralConstraints[i][j][0]->Position,
DihedralConstraints[i][j][1]->Position,DihedralConstraints[i][j][2]->Position,
DihedralConstraints[i][j][3]->Position);
for(j=0;j<NumberOfImproperDihedralConstraints[i];j++)
if(ImproperDihedralConstraintParameter[i][j]<-180.0)
ImproperDihedralConstraintParameter[i][j]=ReturnDihedralAngle(ImproperDihedralConstraints[i][j][0]->Position,
ImproperDihedralConstraints[i][j][1]->Position,ImproperDihedralConstraints[i][j][2]->Position,
ImproperDihedralConstraints[i][j][3]->Position);
for(j=0;j<NumberOfInversionBendConstraints[i];j++)
if(InversionBendConstraintParameter[i][j]<-180.0)
InversionBendConstraintParameter[i][j]=ReturnInversionBendAngle(InversionBendConstraints[i][j][0]->Position,
InversionBendConstraints[i][j][1]->Position,InversionBendConstraints[i][j][2]->Position,
InversionBendConstraints[i][j][3]->Position);
for(j=0;j<NumberOfHarmonicDistanceConstraints[i];j++)
if(HarmonicDistanceConstraintParameters[i][j][1]<0.0)
HarmonicDistanceConstraintParameters[i][j][1]=ReturnBondDistance(
HarmonicDistanceConstraints[i][j][0]->Position,
HarmonicDistanceConstraints[i][j][1]->Position);
for(j=0;j<NumberOfHarmonicAngleConstraints[i];j++)
if(HarmonicAngleConstraintParameters[i][j][1]<-180.0)
HarmonicAngleConstraintParameters[i][j][1]=
ReturnBendAngle(HarmonicAngleConstraints[i][j][0]->Position,
HarmonicAngleConstraints[i][j][1]->Position,HarmonicAngleConstraints[i][j][2]->Position);
for(j=0;j<NumberOfHarmonicDihedralConstraints[i];j++)
if(HarmonicDihedralConstraintParameters[i][j][1]<-180.0)
HarmonicDihedralConstraintParameters[i][j][1]=
ReturnDihedralAngle(HarmonicDihedralConstraints[i][j][0]->Position,
HarmonicDihedralConstraints[i][j][1]->Position,
HarmonicDihedralConstraints[i][j][2]->Position,
HarmonicDihedralConstraints[i][j][3]->Position);
}
for(i=0;i<NumberOfComponents;i++)
{
if(Components[i].RestrictEnantionface)
{
intinput1=Components[i].EnantiofaceAtomDefinitions[0][1];
intinput2=Components[i].EnantiofaceAtomDefinitions[0][2];
switch(Components[i].EnantiofaceAtomDefinitions[0][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
Components[i].EnantiofaceAtoms[0]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
Components[i].EnantiofaceAtoms[0]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
Components[i].EnantiofaceAtoms[0]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=Components[i].EnantiofaceAtomDefinitions[1][1];
intinput2=Components[i].EnantiofaceAtomDefinitions[1][2];
switch(Components[i].EnantiofaceAtomDefinitions[1][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
Components[i].EnantiofaceAtoms[1]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
Components[i].EnantiofaceAtoms[1]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
Components[i].EnantiofaceAtoms[1]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=Components[i].EnantiofaceAtomDefinitions[2][1];
intinput2=Components[i].EnantiofaceAtomDefinitions[2][2];
switch(Components[i].EnantiofaceAtomDefinitions[2][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
Components[i].EnantiofaceAtoms[2]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
Components[i].EnantiofaceAtoms[2]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
Components[i].EnantiofaceAtoms[2]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=Components[i].EnantiofaceAtomDefinitions[3][1];
intinput2=Components[i].EnantiofaceAtomDefinitions[3][2];
switch(Components[i].EnantiofaceAtomDefinitions[3][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
Components[i].EnantiofaceAtoms[3]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
Components[i].EnantiofaceAtoms[3]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
Components[i].EnantiofaceAtoms[3]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
intinput1=Components[i].EnantiofaceAtomDefinitions[4][1];
intinput2=Components[i].EnantiofaceAtomDefinitions[4][2];
switch(Components[i].EnantiofaceAtomDefinitions[4][0])
{
case FRAMEWORK:
CheckConstraintInputFramework(Framework,intinput1,intinput2);
Components[i].EnantiofaceAtoms[4]=&Framework[i].Atoms[intinput1][intinput2];
break;
case ADSORBATE:
CheckConstraintInputAdsorbate(Adsorbates,intinput1,intinput2);
Components[i].EnantiofaceAtoms[4]=&Adsorbates[i][intinput1].Atoms[intinput2];
break;
case CATION:
CheckConstraintInputCation(Cations,intinput1,intinput2);
Components[i].EnantiofaceAtoms[4]=&Cations[i][intinput1].Atoms[intinput2];
break;
}
}
}
for(i=0;i<NumberOfSystems;i++)
{
for(j=0;j<Framework[i].NumberOfFrameworks;j++)
{
Framework[i].NumberOfFreeAtoms[j]=0;
Framework[i].NumberOfFixedAtoms[j]=0;
for(k=0;k<Framework[i].NumberOfAtoms[j];k++)
{
if(Framework[i].Atoms[j][k].Fixed.x) // FIX
Framework[i].NumberOfFixedAtoms[j]++;
else
Framework[i].NumberOfFreeAtoms[j]++;
}
}
}
// mark also atoms as swapable if the molecule is swapable
for(i=0;i<NumberOfComponents;i++)
{
if(Components[i].Swapable)
{
for(j=0;j<Components[i].NumberOfAtoms;j++)
PseudoAtoms[Components[i].Type[j]].Swapable=TRUE;
}
for(k=0;k<NumberOfSystems;k++)
{
if(Components[i].CFMoleculePresent[k]||Components[i].RXMCMoleculesPresent[k])
{
for(j=0;j<Components[i].NumberOfAtoms;j++)
PseudoAtoms[Components[i].Type[j]].CF=TRUE;
}
}
}
// if needed change the VDW potential to their CF-counterparts
ChangeVDWtoCFVDW();
// compute the degrees of freedom
ComputeDegreesOfFreedom();
// generate warnings
CreateWarnings();
CheckForErrors();
// precompute contributions to the Ewald sums from fixed atoms
// setup k-vectors in advance
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
SetupKVectors();
EwaldEnergyIon();
PrecomputeFixedEwaldContributions();
PrecomputeTotalEwaldContributions();
}
if(CreateDlpolyInput)
{
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
WriteFrameworkDefinitionDLPOLY();
}
CurrentSystem=0;
CurrentComponent=0;
CurrentFramework=0;
return 0;
}
void ReadRestartFile(void)
{
int i,j,k;
int NumberOfComponentsRead;
int extra_framework_boolean;
FILE *FilePtrIn;
char buffer[256];
char line[4096],keyword[4096],arguments[4096];
int CurrentComponentRead;
char ExtraFrameworkMoleculeRead[256];
int NumberOfMoleculesRead;
char ComponentNameRead[256];
REAL temp1,temp2,temp3;
int int_temp1,int_temp2,int_temp3,int_temp4,int_temp5;
int *typeArrayAdsorbates,*typeArrayCations;
int totalNumberOfAdsorbateMolecules;
int totalNumberOfCationMolecules;
int *FractionalMolecules;
char *arg_pointer;
int n;
extra_framework_boolean=FALSE;
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
sprintf(buffer,"RestartInitial/System_%d",CurrentSystem);
mkdir(buffer,S_IRWXU);
}
FractionalMolecules=(int*)calloc(NumberOfComponents,sizeof(int));
for(i=0;i<NumberOfComponents;i++)
FractionalMolecules[i]=-1;
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
sprintf(buffer,"RestartInitial/System_%d/restart_%s_%d.%d.%d_%lf_%lg",
CurrentSystem,
Framework[CurrentSystem].Name[0],
NumberOfUnitCells[CurrentSystem].x,
NumberOfUnitCells[CurrentSystem].y,
NumberOfUnitCells[CurrentSystem].z,
(double)therm_baro_stats.ExternalTemperature[CurrentSystem],
(double)therm_baro_stats.ExternalPressure[CurrentSystem][CurrentIsothermPressure]*PRESSURE_CONVERSION_FACTOR);
// read first time to get the total number of molecules
if(!(FilePtrIn=fopen(buffer,"r")))
{
fprintf(stderr, "Could NOT open file: %s\n",buffer);
exit(0);
}
totalNumberOfAdsorbateMolecules=0;
totalNumberOfCationMolecules=0;
while(fgets(line,4096,FilePtrIn))
{
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s %[^\n]",keyword,arguments);
if(strcasecmp(keyword,"Components:")==0)
{
sscanf(arguments,"%d (Adsorbates %d, Cations %d) %*[^\n]",&NumberOfComponentsRead,
&totalNumberOfAdsorbateMolecules,&totalNumberOfCationMolecules);
if(NumberOfComponentsRead!=NumberOfComponents)
fprintf(stderr, "Warning: NumberOfComponents does not match restart-file !\n");
}
}
fclose(FilePtrIn);
// allocate the memory for the type of the molecules
typeArrayAdsorbates=(int*)calloc(totalNumberOfAdsorbateMolecules,sizeof(int*));
typeArrayCations=(int*)calloc(totalNumberOfCationMolecules,sizeof(int*));
// read second time to get the types of all the molecules
if(!(FilePtrIn=fopen(buffer,"r")))
{
fprintf(stderr, "Could NOT open file: %s\n",buffer);
exit(0);
}
CurrentComponent=0;
while(fgets(line,4096,FilePtrIn))
{
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s %[^\n]",keyword,arguments);
// parse "Component: 0 Cation 96 molecules of sodium"
if(strcasecmp(keyword,"Component:")==0)
{
sscanf(arguments,"%d %s %d molecules of %s%*[^\n]",
&CurrentComponentRead,
ExtraFrameworkMoleculeRead,
&NumberOfMoleculesRead,
ComponentNameRead);
CurrentComponent=CurrentComponentRead;
}
// read adsorbate atom information
if(strcasecmp(keyword,"Adsorbate-atom-position:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
typeArrayAdsorbates[int_temp1]=CurrentComponent;
}
// read cation atom information
if(strcasecmp(keyword,"Cation-atom-position:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
typeArrayCations[int_temp1]=CurrentComponent;
}
}
fclose(FilePtrIn);
// allocate the molecules with the correct type
for(j=0;j<totalNumberOfAdsorbateMolecules;j++)
{
CurrentComponent=typeArrayAdsorbates[j];
for(i=0;i<Components[CurrentComponent].NumberOfAtoms;i++)
{
CFVDWScaling[i]=1.0;
CFChargeScaling[i]=1.0;
NewPosition[CurrentSystem][i].x=0.0;
NewPosition[CurrentSystem][i].y=0.0;
NewPosition[CurrentSystem][i].z=0.0;
NewVelocity[CurrentSystem][i].x=0.0;
NewVelocity[CurrentSystem][i].y=0.0;
NewVelocity[CurrentSystem][i].z=0.0;
NewForce[CurrentSystem][i].x=0.0;
NewForce[CurrentSystem][i].y=0.0;
NewForce[CurrentSystem][i].z=0.0;
}
InsertAdsorbateMolecule();
}
for(j=0;j<totalNumberOfCationMolecules;j++)
{
CurrentComponent=typeArrayCations[j];
for(i=0;i<Components[CurrentComponent].NumberOfAtoms;i++)
{
CFVDWScaling[i]=1.0;
CFChargeScaling[i]=1.0;
NewPosition[CurrentSystem][i].x=0.0;
NewPosition[CurrentSystem][i].y=0.0;
NewPosition[CurrentSystem][i].z=0.0;
NewVelocity[CurrentSystem][i].x=0.0;
NewVelocity[CurrentSystem][i].y=0.0;
NewVelocity[CurrentSystem][i].z=0.0;
NewForce[CurrentSystem][i].x=0.0;
NewForce[CurrentSystem][i].y=0.0;
NewForce[CurrentSystem][i].z=0.0;
}
InsertCationMolecule();
}
free(typeArrayAdsorbates);
free(typeArrayCations);
// read second time to fill in all values
FilePtrIn=fopen(buffer,"r");
while(fgets(line,4096,FilePtrIn))
{
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s %[^\n]",keyword,arguments);
// parse "Component: 0 Cation 96 molecules of sodium"
if(strcasecmp(keyword,"Component:")==0)
{
sscanf(arguments,"%d %s %d molecules of %s%*[^\n]",
&CurrentComponentRead,
ExtraFrameworkMoleculeRead,
&NumberOfMoleculesRead,
ComponentNameRead);
CurrentComponent=CurrentComponentRead;
}
if(strcasecmp(keyword,"cell-lengths:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
UnitCellSize[CurrentSystem].x=temp1;
UnitCellSize[CurrentSystem].y=temp2;
UnitCellSize[CurrentSystem].z=temp3;
}
if(strcasecmp(keyword,"cell-angles:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
AlphaAngle[CurrentSystem]=temp1*DEG2RAD;
BetaAngle[CurrentSystem]=temp2*DEG2RAD;
GammaAngle[CurrentSystem]=temp3*DEG2RAD;
}
if(strcasecmp(keyword,"unit-cell-vector-a:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
UnitCellBox[CurrentSystem].ax=temp1;
UnitCellBox[CurrentSystem].ay=temp2;
UnitCellBox[CurrentSystem].az=temp3;
}
if(strcasecmp(keyword,"unit-cell-vector-b:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
UnitCellBox[CurrentSystem].bx=temp1;
UnitCellBox[CurrentSystem].by=temp2;
UnitCellBox[CurrentSystem].bz=temp3;
}
if(strcasecmp(keyword,"unit-cell-vector-c:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
UnitCellBox[CurrentSystem].cx=temp1;
UnitCellBox[CurrentSystem].cy=temp2;
UnitCellBox[CurrentSystem].cz=temp3;
}
if(strcasecmp(keyword,"cell-vector-a:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
Box[CurrentSystem].ax=temp1;
Box[CurrentSystem].ay=temp2;
Box[CurrentSystem].az=temp3;
}
if(strcasecmp(keyword,"cell-vector-b:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
Box[CurrentSystem].bx=temp1;
Box[CurrentSystem].by=temp2;
Box[CurrentSystem].bz=temp3;
}
if(strcasecmp(keyword,"cell-vector-c:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
Box[CurrentSystem].cx=temp1;
Box[CurrentSystem].cy=temp2;
Box[CurrentSystem].cz=temp3;
}
// Read CB/CFCMC settings
//------------------------------------------------------------------------------
if(strcasecmp(keyword,"Fractional-molecule-id")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"component %d: %d",&int_temp1,&int_temp2)==2)
{
FractionalMolecules[int_temp1]=int_temp2;
Components[int_temp1].FractionalMolecule[CurrentSystem]=int_temp2;
}
}
if(strcasecmp(keyword,"Number-of-biasing-factors")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"component %d: %d",&int_temp1,&int_temp2)==2)
{
if(temp2!=Components[int_temp1].CFLambdaHistogramSize)
{
Components[int_temp1].CFLambdaHistogramSize=int_temp2;
// realloc memory
Components[int_temp1].CFBiasingFactors[CurrentSystem]=(REAL*)realloc(Components[int_temp1].CFBiasingFactors[CurrentSystem],
Components[int_temp1].CFLambdaHistogramSize*sizeof(REAL));
if(!Components[int_temp1].CFBiasingFactors[CurrentSystem])
{
printf("Memory reallocation error of 'Components[int_temp1].CFBiasingFactors[CurrentSystem]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
}
}
}
if(strcasecmp(keyword,"Biasing-factors")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"component %d: %n",&int_temp1,&n)==1)
{
arg_pointer=arguments;
for(i=0;i<Components[int_temp1].CFLambdaHistogramSize;i++)
{
arg_pointer+=n;
sscanf(arg_pointer,"%lf%n",&Components[int_temp1].CFBiasingFactors[CurrentSystem][i],&n);
}
}
}
if(strcasecmp(keyword,"Maximum-translation-change")==0)
{
int_temp1=int_temp2=0;
temp1=temp2=temp3=0.0;
if(sscanf(arguments,"component %d: %lf %lf %lf",&int_temp1,&temp1,&temp2,&temp3)==4)
{
MaximumTranslation[CurrentSystem][int_temp1].x=temp1;
MaximumTranslation[CurrentSystem][int_temp1].y=temp2;
MaximumTranslation[CurrentSystem][int_temp1].z=temp3;
}
}
if(strcasecmp(keyword,"Maximum-CF-Lambda-change")==0)
{
int_temp1=int_temp2=0;
temp1=temp2=temp3=0.0;
if(sscanf(arguments,"component %d: %lf",&int_temp1,&temp1)==2)
{
MaximumCFLambdaChange[CurrentSystem][int_temp1]=temp1;
}
}
if(strcasecmp(keyword,"Maximum-CBCF-Lambda-change")==0)
{
int_temp1=int_temp2=0;
temp1=temp2=temp3=0.0;
if(sscanf(arguments,"component %d: %lf",&int_temp1,&temp1)==2)
{
MaximumCBCFLambdaChange[CurrentSystem][int_temp1]=temp1;
}
}
if(strcasecmp(keyword,"Maximum-translation-in-plane-change")==0)
{
int_temp1=int_temp2=0;
temp1=temp2=temp3=0.0;
if(sscanf(arguments,"component %d: %lf %lf %lf",&int_temp1,&temp1,&temp2,&temp3)==4)
{
MaximumTranslationInPlane[CurrentSystem][int_temp1].x=temp1;
MaximumTranslationInPlane[CurrentSystem][int_temp1].y=temp2;
MaximumTranslationInPlane[CurrentSystem][int_temp1].z=temp3;
}
}
// Read CFRXMC settings
//------------------------------------------------------------------------------
if(strcasecmp(keyword,"Number-of-biasing-factors-reaction")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"%d",&int_temp1))
{
if(int_temp1>RXMCLambdaHistogramSize)
{
RXMCLambdaHistogramSize=int_temp1;
// realloc memory
for(i=0;i<NumberOfReactions;i++)
{
RXMCBiasingFactors[CurrentSystem][i]=(REAL*)realloc(RXMCBiasingFactors[CurrentSystem][i],RXMCLambdaHistogramSize*sizeof(REAL));
if(!RXMCBiasingFactors[CurrentSystem][i])
{
printf("Memory reallocation error of 'RXMCBiasingFactors[CurrentSystem][i]' in file %s line %d\n", __FILE__, __LINE__);
exit(-1);
}
}
}
}
}
if(strcasecmp(keyword,"Lambda-factor")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"reaction %d: %lf",&int_temp1,&temp1)==2)
{
CFCRXMCLambda[CurrentSystem][int_temp1]=temp1;
}
}
if(strcasecmp(keyword,"Maximum-Lambda-reaction-change")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"reaction %d: %lf",&int_temp1,&temp1)==2)
{
MaximumReactionLambdaChange[CurrentSystem][int_temp1]=temp1;
}
}
if(strcasecmp(keyword,"Fractional-product-molecules")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"reaction %d: %n",&int_temp1,&n)==1)
{
arg_pointer=arguments;
for(j=0;j<NumberOfComponents;j++)
{
if(ProductsStoichiometry[int_temp1][j]>0)
{
for(k=0;k<ProductsStoichiometry[int_temp1][j];k++)
{
arg_pointer+=n;
sscanf(arg_pointer,"%d%n",&Components[j].ProductFractionalMolecules[CurrentSystem][int_temp1][k],&n);
}
}
}
}
}
if(strcasecmp(keyword,"Fractional-reactant-molecules")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"reaction %d: %n",&int_temp1,&n)==1)
{
arg_pointer=arguments;
for(j=0;j<NumberOfComponents;j++)
{
if(ReactantsStoichiometry[int_temp1][j]>0)
{
for(k=0;k<ReactantsStoichiometry[int_temp1][j];k++)
{
arg_pointer+=n;
sscanf(arg_pointer,"%d%n",&Components[j].ReactantFractionalMolecules[CurrentSystem][int_temp1][k],&n);
}
}
}
}
}
if(strcasecmp(keyword,"Reaction-biasing-factors")==0)
{
int_temp1=int_temp2=0;
if(sscanf(arguments,"reaction %d: %n",&int_temp1,&n)==1)
{
arg_pointer=arguments;
for(k=0;k<RXMCLambdaHistogramSize;k++)
{
arg_pointer+=n;
sscanf(arg_pointer,"%lf%n",&RXMCBiasingFactors[CurrentSystem][int_temp1][k],&n);
}
}
}
// read framework atom information
if(strcasecmp(keyword,"Framework-atom-position:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Position.x=temp1;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Position.y=temp2;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Position.z=temp3;
}
if(strcasecmp(keyword,"Framework-atom-velocity:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Velocity.x=temp1;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Velocity.y=temp2;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Velocity.z=temp3;
}
if(strcasecmp(keyword,"Framework-atom-force:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Force.x=temp1;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Force.y=temp2;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Force.z=temp3;
}
if(strcasecmp(keyword,"Framework-atom-charge:")==0)
{
temp1=0.0;
sscanf(arguments,"%d %d %lf\n",&int_temp1,&int_temp2,&temp1);
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Charge=temp1;
}
if(strcasecmp(keyword,"Framework-atom-fixed:")==0)
{
int_temp3=int_temp4=int_temp5=FALSE;
sscanf(arguments,"%d %d %d %d %d\n",&int_temp1,&int_temp2,&int_temp3,&int_temp4,&int_temp5);
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Fixed.x=int_temp3;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Fixed.y=int_temp4;
Framework[CurrentSystem].Atoms[int_temp1][int_temp2].Fixed.z=int_temp5;
}
// read adsorbate atom information
if(strcasecmp(keyword,"Adsorbate-atom-position:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Position.x=temp1;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Position.y=temp2;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Position.z=temp3;
}
if(strcasecmp(keyword,"Adsorbate-atom-velocity:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Velocity.x=temp1;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Velocity.y=temp2;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Velocity.z=temp3;
}
if(strcasecmp(keyword,"Adsorbate-atom-force:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Force.x=temp1;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Force.y=temp2;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Force.z=temp3;
}
if(strcasecmp(keyword,"Adsorbate-atom-charge:")==0)
{
temp1=0.0;
sscanf(arguments,"%d %d %lf\n",&int_temp1,&int_temp2,&temp1);
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Charge=temp1;
}
if(strcasecmp(keyword,"Adsorbate-atom-scaling:")==0)
{
temp1=0.0;
sscanf(arguments,"%d %d %lf\n",&int_temp1,&int_temp2,&temp1);
if(Components[CurrentComponent].CFMoleculePresent[CurrentSystem])
{
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].CFVDWScalingParameter=temp1;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].CFChargeScalingParameter=pow(temp1,5);
}
}
if(strcasecmp(keyword,"Adsorbate-atom-fixed:")==0)
{
int_temp3=int_temp4=int_temp5=FALSE;
sscanf(arguments,"%d %d %d %d %d\n",&int_temp1,&int_temp2,&int_temp3,&int_temp4,&int_temp5);
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Fixed.x=int_temp3;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Fixed.y=int_temp4;
Adsorbates[CurrentSystem][int_temp1].Atoms[int_temp2].Fixed.z=int_temp5;
}
// read cation atom information
if(strcasecmp(keyword,"Cation-atom-position:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Position.x=temp1;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Position.y=temp2;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Position.z=temp3;
}
if(strcasecmp(keyword,"Cation-atom-velocity:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Velocity.x=temp1;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Velocity.y=temp2;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Velocity.z=temp3;
}
if(strcasecmp(keyword,"Cation-atom-force:")==0)
{
temp1=temp2=temp3=0.0;
sscanf(arguments,"%d %d %lf %lf %lf\n",&int_temp1,&int_temp2,&temp1,&temp2,&temp3);
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Force.x=temp1;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Force.y=temp2;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Force.z=temp3;
}
if(strcasecmp(keyword,"Cation-atom-charge:")==0)
{
temp1=0.0;
sscanf(arguments,"%d %d %lf\n",&int_temp1,&int_temp2,&temp1);
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Charge=temp1;
}
if(strcasecmp(keyword,"Cation-atom-scaling:")==0)
{
temp1=0.0;
sscanf(arguments,"%d %d %lf\n",&int_temp1,&int_temp2,&temp1);
if(Components[CurrentComponent].CFMoleculePresent[CurrentSystem])
{
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].CFVDWScalingParameter=temp1;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].CFChargeScalingParameter=pow(temp1,5);
}
}
if(strcasecmp(keyword,"Cation-atom-fixed:")==0)
{
int_temp3=int_temp4=int_temp5=FALSE;
sscanf(arguments,"%d %d %d %d %d\n",&int_temp1,&int_temp2,&int_temp3,&int_temp4,&int_temp5);
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Fixed.x=int_temp3;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Fixed.y=int_temp4;
Cations[CurrentSystem][int_temp1].Atoms[int_temp2].Fixed.z=int_temp5;
}
}
InverseBoxMatrix(&Box[CurrentSystem],&InverseBox[CurrentSystem]);
CellProperties(&Box[CurrentSystem],&BoxProperties[CurrentSystem],&Volume[CurrentSystem]);
AlphaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].bx);
BetaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].by);
GammaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].bz);
// determine boundary conditions from angles
if((BoundaryCondition[CurrentSystem]!=UNINITIALIZED_BOUNDARY_CONDITION)&&(BoundaryCondition[CurrentSystem]!=FINITE))
{
SetBoundaryConditionFromSystem(CurrentSystem, 0.001, 0.00001);
}
if(Framework[CurrentSystem].FrameworkModel==NONE)
sprintf(Framework[CurrentSystem].Name[0],"Box");
CalculateAnisotropicSites();
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
{
UpdateGroupCenterOfMassAdsorbate(i);
ComputeQuaternionAdsorbate(i);
}
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
{
UpdateGroupCenterOfMassCation(i);
ComputeQuaternionCation(i);
}
if(RemoveFractionalMoleculesFromRestartFile)
{
// sort the fractional molecules
BubbleSort(FractionalMolecules,NumberOfComponents);
// if restarting with CBMC from CFMC then remove fractional molecules
// start with the highest one, because removing is done by swapping with the last-molecule
for(CurrentComponent=NumberOfComponents-1;CurrentComponent>=0;CurrentComponent--)
{
if(!Components[CurrentComponent].CFMoleculePresent[CurrentSystem])
{
if(FractionalMolecules[CurrentComponent]>=0)
{
if(Components[CurrentComponent].ExtraFrameworkMolecule)
{
CurrentCationMolecule=FractionalMolecules[CurrentComponent];
RemoveCationMolecule();
}
else
{
CurrentAdsorbateMolecule=FractionalMolecules[CurrentComponent];
RemoveAdsorbateMolecule();
}
}
}
}
// set bias-factors to zero, because in CBMC the weight should be 1.0
NumberOfFractionalMolecules[CurrentSystem]=0;
NumberOfFractionalAdsorbateMolecules[CurrentSystem]=0;
NumberOfFractionalCationMolecules[CurrentSystem]=0;
for(i=0;i<NumberOfComponents;i++)
{
Components[i].FractionalMolecule[CurrentSystem]=-1;
for(j=0;j<Components[i].CFLambdaHistogramSize;j++)
Components[i].CFBiasingFactors[CurrentSystem][j]=0.0;
}
}
CurrentComponent=0;
fclose(FilePtrIn);
}
free(FractionalMolecules);
}
void ReadRestartFileOld(void)
{
printf("READ_restart_old");
int i;
int NumberOfComponentsRead;
int extra_framework_boolean;
FILE *FilePtrIn;
char buffer[256];
char line[1024],keyword[1024],arguments[1024];
int CurrentComponentRead;
char ExtraFrameworkMoleculeRead[256];
int NumberOfMoleculesRead,AtomNumberRead,MoleculeNumberRead,FrameworkAtomNumberRead;
char ComponentNameRead[256];
VECTOR tmp;
double temp1,temp2,temp3;
extra_framework_boolean=FALSE;
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
sprintf(buffer,"RestartInitial/System_%d",CurrentSystem);
mkdir(buffer,S_IRWXU);
}
for(CurrentSystem=0;CurrentSystem<NumberOfSystems;CurrentSystem++)
{
sprintf(buffer,"RestartInitial/System_%d/restart_%s_%d.%d.%d_%lf_%lf",
CurrentSystem,
Framework[CurrentSystem].Name[0],
NumberOfUnitCells[CurrentSystem].x,
NumberOfUnitCells[CurrentSystem].y,
NumberOfUnitCells[CurrentSystem].z,
(double)therm_baro_stats.ExternalTemperature[CurrentSystem],
(double)therm_baro_stats.ExternalPressure[CurrentSystem][CurrentIsothermPressure]*PRESSURE_CONVERSION_FACTOR);
if(!(FilePtrIn=fopen(buffer,"r")))
{
fprintf(stderr, "Could NOT open file: %s\n",buffer);
exit(0);
}
while(fgets(line,1024,FilePtrIn))
{
// extract first word
strcpy(keyword,"keyword");
sscanf(line,"%s %[^\n]",keyword,arguments);
if(strcasecmp(keyword,"Box:")==0)
{
fgets(line,1024,FilePtrIn);
fgets(line,1024,FilePtrIn);
sscanf(line,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
Box[CurrentSystem].ax=(REAL)temp1;
Box[CurrentSystem].bx=(REAL)temp2;
Box[CurrentSystem].cx=(REAL)temp3;
fgets(line,1024,FilePtrIn);
sscanf(line,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
Box[CurrentSystem].ay=(REAL)temp1;
Box[CurrentSystem].by=(REAL)temp2;
Box[CurrentSystem].cy=(REAL)temp3;
fgets(line,1024,FilePtrIn);
sscanf(line,"%lf %lf %lf\n",&temp1,&temp2,&temp3);
Box[CurrentSystem].az=(REAL)temp1;
Box[CurrentSystem].bz=(REAL)temp2;
Box[CurrentSystem].cz=(REAL)temp3;
InverseBoxMatrix(&Box[CurrentSystem],&InverseBox[CurrentSystem]);
//UnitCellBox[CurrentSystem]=Box[CurrentSystem];
//InverseUnitCellBox[CurrentSystem]=InverseBox[CurrentSystem];
CellProperties(&Box[CurrentSystem],&BoxProperties[CurrentSystem],&Volume[CurrentSystem]);
AlphaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].bx);
BetaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].by);
GammaAngle[CurrentSystem]=acos(BoxProperties[CurrentSystem].bz);
// determine boundary conditions from angles
if((BoundaryCondition[CurrentSystem]!=UNINITIALIZED_BOUNDARY_CONDITION)&&(BoundaryCondition[CurrentSystem]!=FINITE))
{
SetBoundaryConditionFromSystem(CurrentSystem, 0.001, 0.00001);
}
if(Framework[CurrentSystem].FrameworkModel==NONE)
sprintf(Framework[CurrentSystem].Name[0],"Box");
}
if(strcasecmp(keyword,"Components:")==0)
{
sscanf(arguments,"%d%*[^\n]",&NumberOfComponentsRead);
if(NumberOfComponentsRead!=NumberOfComponents)
fprintf(stderr, "Warning: NumberOfComponents does not match restart-file !\n");
}
if(strcasecmp(keyword,"Volume")==0)
{
sscanf(arguments,"change, maximum: %lf\n",&temp1);
MaximumVolumeChange[CurrentSystem]=(REAL)temp1;
}
if(strcasecmp(keyword,"Translation")==0)
{
sscanf(arguments,"change component %d [ %s ], maximum: %lf,%lf,%lf\n",
&CurrentComponent,
buffer,&temp1,&temp2,&temp3);
tmp.x=(REAL)temp1;
tmp.y=(REAL)temp2;
tmp.z=(REAL)temp3;
MaximumTranslation[CurrentSystem][CurrentComponent]=tmp;
}
// parse "Component: 0 Cation 96 molecules of sodium"
if(strcasecmp(keyword,"Component:")==0)
{
sscanf(arguments,"%d %s %d molecules of %s%*[^\n]",
&CurrentComponentRead,
ExtraFrameworkMoleculeRead,
&NumberOfMoleculesRead,
ComponentNameRead);
CurrentComponent=CurrentComponentRead;
if(!strncasecmp(ExtraFrameworkMoleculeRead,"Cation",MAX2(strlen(ExtraFrameworkMoleculeRead),strlen("Cation"))))
extra_framework_boolean=TRUE;
else
extra_framework_boolean=FALSE;
}
if(strcasecmp(keyword,"Framework")==0)
{
FrameworkAtomNumberRead=-1;
sscanf(arguments,"Atom: %d %d %[^\n]",
&FrameworkAtomNumberRead,
&CurrentFramework,
arguments);
sscanf(arguments,"Position: %lf %lf %lf %[^\n]",&temp1,&temp2,&temp3,arguments);
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Position.x=(REAL)temp1;
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Position.y=(REAL)temp2;
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Position.z=(REAL)temp3;
sscanf(arguments,"Velocity: %lf %lf %lf %[^\n]",&temp1,&temp2,&temp3,arguments);
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Velocity.x=(REAL)temp1;
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Velocity.y=(REAL)temp2;
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Velocity.z=(REAL)temp3;
sscanf(arguments,"Force: %lf %lf %lf %[^\n]",&temp1,&temp2,&temp3,arguments);
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Force.x=(REAL)temp1;
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Force.y=(REAL)temp2;
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Force.z=(REAL)temp3;
if(sscanf(arguments,"Charge: %lf%*[^\n]",&temp1))
Framework[CurrentSystem].Atoms[CurrentFramework][FrameworkAtomNumberRead].Charge=(REAL)temp1;
}
if(strcasecmp(keyword,"Molecule:")==0)
{
if(NumberOfComponents==0)
{
fprintf(stderr, "\nReadRestartFile: component present, but not defined in inputfile\n");
exit(0);
}
MoleculeNumberRead=-1;
sscanf(arguments,"%d %[^\n]",
&MoleculeNumberRead,
arguments);
AtomNumberRead=-1;
sscanf(arguments,"Atom: %d %[^\n]",
&AtomNumberRead,
arguments);
sscanf(arguments,"Position: %lf %lf %lf %[^\n]",&temp1,&temp2,&temp3,arguments);
NewPosition[CurrentSystem][AtomNumberRead].x=(REAL)temp1;
NewPosition[CurrentSystem][AtomNumberRead].y=(REAL)temp2;
NewPosition[CurrentSystem][AtomNumberRead].z=(REAL)temp3;
sscanf(arguments,"Velocity: %lf %lf %lf %[^\n]",&temp1,&temp2,&temp3,arguments);
NewVelocity[CurrentSystem][AtomNumberRead].x=(REAL)temp1;
NewVelocity[CurrentSystem][AtomNumberRead].y=(REAL)temp2;
NewVelocity[CurrentSystem][AtomNumberRead].z=(REAL)temp3;
sscanf(arguments,"Force: %lf %lf %lf %*[^\n]",&temp1,&temp2,&temp3);
NewForce[CurrentSystem][AtomNumberRead].x=(REAL)temp1;
NewForce[CurrentSystem][AtomNumberRead].y=(REAL)temp2;
NewForce[CurrentSystem][AtomNumberRead].z=(REAL)temp3;
if(AtomNumberRead==Components[CurrentComponent].NumberOfAtoms-1)
{
if(extra_framework_boolean)
InsertCationMolecule();
else
InsertAdsorbateMolecule();
AtomNumberRead=0;
}
}
}
for(i=0;i<NumberOfAdsorbateMolecules[CurrentSystem];i++)
UpdateGroupCenterOfMassAdsorbate(i);
for(i=0;i<NumberOfCationMolecules[CurrentSystem];i++)
UpdateGroupCenterOfMassCation(i);
}
}
void ReadBinaryRestartFiles(void)
{
FILE *FilePtr;
char buffer[1024];
fprintf(stderr, "read binary file\n");
sprintf(buffer,"CrashRestart/binary_restart.dat");
if((FilePtr=fopen(buffer,"r")))
{
if(ContinueAfterCrash) ReadRestartConstants(FilePtr);
if(ContinueAfterCrash) ReadRestartSimulation(FilePtr);
if(ContinueAfterCrash) ReadRestartWarnings(FilePtr);
if(ContinueAfterCrash) ReadRestartPseudoAtoms(FilePtr);
if(ContinueAfterCrash) ReadRestartComponent(FilePtr);
if(ContinueAfterCrash) ReadRestartMolecules(FilePtr);
if(ContinueAfterCrash) ReadRestartFramework(FilePtr);
if(ContinueAfterCrash) ReadRestartCBMC(FilePtr);
if(ContinueAfterCrash) ReadRestartEwald(FilePtr);
if(ContinueAfterCrash) ReadRestartStatistics(FilePtr);
if(ContinueAfterCrash) ReadRestartMcMoves(FilePtr);
if(ContinueAfterCrash) ReadRestartSample(FilePtr);
if(ContinueAfterCrash) ReadRestartThermoBarostats(FilePtr);
if(ContinueAfterCrash) ReadRestartEquationOfState(FilePtr);
if(ContinueAfterCrash) ReadRestartGrids(FilePtr);
if(ContinueAfterCrash) ReadRestartMinimization(FilePtr);
if(ContinueAfterCrash) ReadRestartUtils(FilePtr);
if(ContinueAfterCrash) ReadRestartMovies(FilePtr);
if(ContinueAfterCrash) ReadRestartOutput(FilePtr);
fclose(FilePtr);
}
else
{
ContinueAfterCrash=FALSE;
fprintf(stderr, "Crash set to false\n");
}
}
/*************************************************************************************************************
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.
**************************************************************************************************************/
int EwaldAutomatic;
int RemoveFractionalMoleculesFromRestartFile;
static int *read_frameworks;
static int *InitializeBox;
int VolumeChangeDirection=7;
int IsActiveAtomType(int type)
{
int i;
for(i=0;i<NumberOfActiveAtomTypes;i++)
if(ReturnPseudoAtomNumber(ActiveAtomTypes[i])==type) return TRUE;
return FALSE;
}
int IsFixedAtomType(int type)
{
int i;
for(i=0;i<NumberOfFixedAtomTypes;i++)
if(ReturnPseudoAtomNumber(FixedAtomTypes[i])==type) return TRUE;
return FALSE;
}