hdiff output

r31963/commons.f90 2017-02-23 15:30:38.420833057 +0000 r31962/commons.f90 2017-02-23 15:30:39.580848437 +0000
 19:       MODULE COMMONS 19:       MODULE COMMONS
 20:       IMPLICIT NONE 20:       IMPLICIT NONE
 21:       SAVE 21:       SAVE
 22:       INTEGER :: NATOMS, NATOMSALLOC, NACCEPT, MAXIT, NTARGETS, NN, MM, NPAR, NPAR_GBH, NPATCH, TIPID, PAHID, NSYMREM=0, NFREEZE, NSAVEINTE, & 22:       INTEGER :: NATOMS, NATOMSALLOC, NACCEPT, MAXIT, NTARGETS, NN, MM, NPAR, NPAR_GBH, NPATCH, TIPID, PAHID, NSYMREM=0, NFREEZE, NSAVEINTE, &
 23:      &        NINTV, NSEED, NVEC, NS, NSSTOP, MAXIT2, NSAVE, SHELLMOVEMAX, HPTGRP, NFIX, CURRENTIMP,& 23:      &        NINTV, NSEED, NVEC, NS, NSSTOP, MAXIT2, NSAVE, SHELLMOVEMAX, HPTGRP, NFIX, CURRENTIMP,&
 24:      &        MCSTEPS(3), NRUNS, NVAR, MYPOWER, XMUL,  NTAB, NCARBON, NCOOP, NSYMINTERVAL, QDLIMIT, COULN, & 24:      &        MCSTEPS(3), NRUNS, NVAR, MYPOWER, XMUL,  NTAB, NCARBON, NCOOP, NSYMINTERVAL, QDLIMIT, COULN, &
 25:      &        NSUPER, NSACCEPT, NSUPERSTEP, GMODES, QUENCHFRQ, CHNRES, CHECKDID, & 25:      &        NSUPER, NSACCEPT, NSUPERSTEP, GMODES, QUENCHFRQ, CHNRES, CHECKDID, &
 26:      &        NEVL, NEVS, NVECTORS, MUPDATE, LSYS, NHSMOVE, NRENORM, NRELAX, NHSRESTART, NRENSTUCK, GBH_NREJMAX, GBH_NAVOID, & 26:      &        NEVL, NEVS, NVECTORS, MUPDATE, LSYS, NHSMOVE, NRENORM, NRELAX, NHSRESTART, NRENSTUCK, GBH_NREJMAX, GBH_NAVOID, &
 27:      &        HBINS, NRBSITES, NRBSITES1, NPS, GATOM, NMSBSAVE, MAXSAVE, NSYMQMAX, EQUIL, TPAHA, ISTEP, & 27:      &        HBINS, NRBSITES, NRBSITES1, NPS, GATOM, NMSBSAVE, MAXSAVE, NSYMQMAX, EQUIL, TPAHA, ISTEP, &
 28:      &        NINTS, NumberOfTrajectories, & 28:      &        NINTS, NumberOfTrajectories, &
 29:      &        MCCycles, MCCyclesEquilibration, TargetWL, NTempPoints, SaveNth, DumpEveryNthQuench, NSpline, Hwindows, & 29:      &        MCCycles, MCCyclesEquilibration, TargetWL, NTempPoints, SaveNth, DumpEveryNthQuench, NSpline, Hwindows, & 
 30:      &        lhbins, sampledbins, MYNODE, MYNQ, NENRPER, DUMPINT, MYUNIT, PRTFRQ, BSPTDUMPFRQ, NPERMGROUP, NMOVABLEATOMS, & 30:      &        lhbins, sampledbins, MYNODE, MYNQ, NENRPER, DUMPINT, MYUNIT, PRTFRQ, BSPTDUMPFRQ, NPERMGROUP, NMOVABLEATOMS, &
 31:      &        CPS, CPF, ACKLANDID, PATOM1, PATOM2, CSMGPINDEX, CSMGUIDEGPINDEX, CSMSTEPS, CSMQUENCHES, CSMMAXIT, & 31:      &        CPS, CPF, ACKLANDID, PATOM1, PATOM2, CSMGPINDEX, CSMGUIDEGPINDEX, CSMSTEPS, CSMQUENCHES, CSMMAXIT, &
 32:      &        MYEUNIT, MYMUNIT, MYBUNIT, MYRUNIT, MYPUNIT, NFREEZETYPEA, & 32:      &        MYEUNIT, MYMUNIT, MYBUNIT, MYRUNIT, MYPUNIT, NFREEZETYPEA, &
 33:      &        TBPSTEPS, TBPCI, TBPBASIN, NTSITES, NRBGROUP, NZERO, PTMCDS_FRQ, PTMCDUMPENERFRQ, MONITORINT, NBLOCKS, & 33:      &        TBPSTEPS, TBPCI, TBPBASIN, NTSITES, NRBGROUP, NZERO, PTMCDS_FRQ, PTMCDUMPENERFRQ, MONITORINT, NBLOCKS, &
 34:      &        BINARY_EXAB_FRQ, NRESMIN, USERES, EXEQ, NONEDAPBC, STRUC, CHEMSHIFTITER, GRIDSIZE, MFETRUNS, BESTINVERT, GCNATOMS, & 34:      &        BINARY_EXAB_FRQ, NRESMIN, USERES, EXEQ, NONEDAPBC, STRUC, CHEMSHIFTITER, GRIDSIZE, MFETRUNS, BESTINVERT, GCNATOMS, &
 35:      &        GCINT, GCRELAX, MTARGETS, & 35:      &        GCINT, GCRELAX, MTARGETS, &
 36:      &        INTCONSEP, INTREPSEP, NCONSTRAINTON, CPREPSEP, CPCONSEP, NCONGEOM, & 36:      &        INTCONSEP, INTREPSEP, NCONSTRAINTON, CPREPSEP, CPCONSEP, NCONGEOM, &
 37:      &        NCPREPULSIVE, NCPCONSTRAINT, MAXCONUSE, INTCONSTEPS, INTRELSTEPS, INTSTEPS1, INTLJSTEPS, & 37:      &        NCPREPULSIVE, NCPCONSTRAINT, MAXCONUSE, INTCONSTEPS, INTRELSTEPS, INTSTEPS1, INTLJSTEPS, &
 38:      &        NTRAPPOW, MAXINTIMAGE, CHECKREPINTERVAL, INTFREEZEMIN, INTNTRIESMAX, INTIMAGEINCR, & 38:      &        NTRAPPOW, MAXINTIMAGE, CHECKREPINTERVAL, INTFREEZEMIN, INTNTRIESMAX, INTIMAGEINCR, &
 39:      &        NCONSTRAINTFIX, INTIMAGECHECK, NREPULSIVEFIX, INTIMAGE, NREPULSIVE, & 39:      &        NCONSTRAINTFIX, INTIMAGECHECK, NREPULSIVEFIX, INTIMAGE, NREPULSIVE, &
 40:      &        NNREPULSIVE, NCONSTRAINT, INTMUPDATE, DUMPINTEOSFREQ, DUMPINTXYZFREQ, & 40:      &        NNREPULSIVE, NCONSTRAINT, INTMUPDATE, DUMPINTEOSFREQ, DUMPINTXYZFREQ, &
 41:      &        LOCALPERMNEIGH, LOCALPERMMAXSEP, MAXNACTIVE, QCIPERMCHECKINT, & 41:      &        LOCALPERMNEIGH, LOCALPERMMAXSEP, MAXNACTIVE, QCIPERMCHECKINT, &
 42:      &        MLPIN, MLPSTART, MLPOUT, MLPHIDDEN, MLPDATA, NMLP, DJWRBID, NHEXAMERS, QCIADDREP, QCIBONDS, QCISECOND, MQUNIT, & 42:      &        MLPIN, MLPSTART, MLPOUT, MLPHIDDEN, MLPDATA, NMLP, DJWRBID, NHEXAMERS, QCIADDREP, QCIBONDS, QCISECOND, MQUNIT, &
 43:      &        MLQIN, MLQSTART, MLQOUT, MLQDATA, NMLQ, NADDTARGET 43:      &        MLQIN, MLQSTART, MLQOUT, MLQDATA, NMLQ, NADDTARGET
 44:  44:  
 45:       DOUBLE PRECISION RHO, GAMMA, SIG, SCEPS, SCC, TOLB, T12FAC, XMOVERENORM, RESIZE, QTSALLIS, & 45:       DOUBLE PRECISION RHO, GAMMA, SIG, SCEPS, SCC, TOLB, T12FAC, XMOVERENORM, RESIZE, QTSALLIS, &
 46:      &                 CQMAX, RADIUS, BQMAX,  MAXBFGS, DECAYPARAM, SYMTOL1, SYMTOL2, SYMTOL3, SYMTOL4, SYMTOL5, PGSYMTOLS(3),& 46:      &                 CQMAX, RADIUS, BQMAX,  MAXBFGS, DECAYPARAM, SYMTOL1, SYMTOL2, SYMTOL3, SYMTOL4, SYMTOL5, PGSYMTOLS(3),&
 47:      &                 ECONV, TOLD, TOLE, SYMREM(120,3,3), GMAX, CUTOFF, PCUT, EXPFAC, EXPD, CENTX, CENTY, CENTZ, & 47:      &                 ECONV, TOLD, TOLE, SYMREM(120,3,3), GMAX, CUTOFF, PCUT, EXPFAC, EXPD, CENTX, CENTY, CENTZ, &
 48:      &                 BOXLX, BOXLY, BOXLZ, BOX3D(3), PCUTOFF, SUPSTEP, SQUEEZER, SQUEEZED, COOPCUT, STOCKMU, STOCKLAMBDA, & 48:      &                 BOXLX, BOXLY, BOXLZ, BOX3D(3), PCUTOFF, SUPSTEP, SQUEEZER, SQUEEZED, COOPCUT, STOCKMU, STOCKLAMBDA, &
 49:      &                 TFAC(3), RMS, TEMPS, SACCRAT, CEIG, PNEWJUMP, EAMP, DISTFAC, ODDCHARGE, COULQ, COULSWAP, & 49:      &                 TFAC(3), RMS, TEMPS, SACCRAT, CEIG, PNEWJUMP, EAMP, DISTFAC, ODDCHARGE, COULQ, COULSWAP, &
 50:      &                 COULTEMP, APP, AMM, APM, XQP, XQM, ALPHAP, ALPHAM, ZSTAR, K_COMP, DGUESS, GUIDECUT, EFAC,& 50:      &                 COULTEMP, APP, AMM, APM, XQP, XQM, ALPHAP, ALPHAM, ZSTAR, K_COMP, DGUESS, GUIDECUT, EFAC,& 
 51:      &                 TRENORM, HISTMIN, HISTMAX, HISTFAC, EPSSPHERE, FINALCUTOFF, SHELLPROB, RINGROTSCALE, & 51:      &                 TRENORM, HISTMIN, HISTMAX, HISTFAC, EPSSPHERE, FINALCUTOFF, SHELLPROB, RINGROTSCALE, &
 52:      &                 HISTFACMUL, HPERCENT, AVOIDDIST, MAXERISE, MAXEFALL, TSTART, MATDIFF, STICKYSIG, SDTOL, & 52:      &                 HISTFACMUL, HPERCENT, AVOIDDIST, MAXERISE, MAXEFALL, TSTART, MATDIFF, STICKYSIG, SDTOL, &
 53:      &                 MinimalTemperature, MaximalTemperature, SwapProb, hdistconstraint, COREFRAC, TSTAR, & 53:      &                 MinimalTemperature, MaximalTemperature, SwapProb, hdistconstraint, COREFRAC, TSTAR, &
 54:      &                 RK_R, RK_THETA,ARMA,ARMB, ExtrapolationPercent, lnHarmFreq, PTEMIN, PTEMAX, PTTMIN, PTTMAX, EXCHPROB, & 54:      &                 RK_R, RK_THETA,ARMA,ARMB, ExtrapolationPercent, lnHarmFreq, PTEMIN, PTEMAX, PTTMIN, PTTMAX, EXCHPROB, &
 55:      &                 PTSTEPS, NEQUIL, NQUENCH, COLDFUSIONLIMIT, NEWRES_TEMP, MINOMEGA, LJSIGMA, LJEPSILON, TAUMAX, & 55:      &                 PTSTEPS, NEQUIL, NQUENCH, COLDFUSIONLIMIT, NEWRES_TEMP, MINOMEGA, LJSIGMA, LJEPSILON, TAUMAX, &
 56:      &                 TAUMAXFULL, CPFACTORSG, CPFACTORFG, VGWTOL, ABTHRESH, ACTHRESH, CSMPMAT(3,3), & 56:      &                 TAUMAXFULL, CPFACTORSG, CPFACTORFG, VGWTOL, ABTHRESH, ACTHRESH, CSMPMAT(3,3), &
 57:      &                 RADIUS_CONTAINER, HYDROPHOBIC, RESTRICTREGIONX0, RESTRICTREGIONY0, RESTRICTREGIONZ0, & 57:      &                 RADIUS_CONTAINER, HYDROPHOBIC, RESTRICTREGIONX0, RESTRICTREGIONY0, RESTRICTREGIONZ0, &
 58:      &                 RESTRICTREGIONRADIUS, HARMONICSTR, DUMPUNIQUEEPREV, DUMPUNIQUEEMARKOV, FREEZESAVEE, & 58:      &                 RESTRICTREGIONRADIUS, HARMONICSTR, DUMPUNIQUEEPREV, DUMPUNIQUEEMARKOV, FREEZESAVEE, &
 59:      &                 TBPMIN, TBPSTEP, TBPHF, TBPCF, TBPINCR, SHIFTV, GEOMDIFFTOL, LJATTOC, GCMU, HESS_EIGEN_TOL, & 59:      &                 TBPMIN, TBPSTEP, TBPHF, TBPCF, TBPINCR, SHIFTV, GEOMDIFFTOL, LJATTOC, GCMU, HESS_EIGEN_TOL, &
 60:      &                 SRATIO, TRATIO, EXCHINT, DDMCUT, SUMTEMP, SUMSTEP, SUMOSTEP, EXPANDFACTOR, ROTATEFACTOR, EPSRIGID, & 60:      &                 SRATIO, TRATIO, EXCHINT, DDMCUT, SUMTEMP, SUMSTEP, SUMOSTEP, EXPANDFACTOR, ROTATEFACTOR, EPSRIGID, &
 61:      &                 CONTOURBOUNDS(3,2), KCOMP_RIGID, RIGIDCOMDIST, PALPHA, PBETA, PGAMMA, LAT(3,3), MFETPCTL, MFETTRGT, QUIPEQDIST, & 61:      &                 CONTOURBOUNDS(3,2), KCOMP_RIGID, RIGIDCOMDIST, PALPHA, PBETA, PGAMMA, LAT(3,3), MFETPCTL, MFETTRGT, QUIPEQDIST, &
 62:  62: 
 63: !   parameters for anisotropic potentials 63: !   parameters for anisotropic potentials
 64: ! 64: !
 65: !    DC430 > 65: !    DC430 >
 66:      &                 CAPEPS2, CAPRAD, CAPRHO, CAPHEIGHT1, CAPHEIGHT2, & 66:      &                 CAPEPS2, CAPRAD, CAPRHO, CAPHEIGHT1, CAPHEIGHT2, &
 67:      &                 EPSR, GBKAPPA, GBKAPPRM, GBMU,GBNU, GBSIGNOT, GBEPSNOT, GBCHI, GBCHIPRM, & 67:      &                 EPSR, GBKAPPA, GBKAPPRM, GBMU,GBNU, GBSIGNOT, GBEPSNOT, GBCHI, GBCHIPRM, &
 68:      &                 SIGNOT, EPSNOT, SIGMAF, INVKAP, ESA(3), LPRSQ, LSQDFR, GBDPMU, GBDPEPS, GBDPFCT, & 68:      &                 SIGNOT, EPSNOT, SIGMAF, INVKAP, ESA(3), LPRSQ, LSQDFR, GBDPMU, GBDPEPS, GBDPFCT, &
 69:      &                 PYSIGNOT, PYEPSNOT, PYA1(3), PYA2(3), PYDPMU, PYDPEPS, PYDPFCT, PYGRAVITYC1, PYGRAVITYC2, & 69:      &                 PYSIGNOT, PYEPSNOT, PYA1(3), PYA2(3), PYDPMU, PYDPEPS, PYDPFCT, PYGRAVITYC1, PYGRAVITYC2, &
 70:      &                 LWRCUT, LWCNSTA, LWCNSTB, LWRCUTSQ, LWRCUT2SQ, DELRC, PAPALP, PAPS, PAPCD, PAPEPS, PAPANG1, PAPANG2, & 70:      &                 LWRCUT, LWCNSTA, LWCNSTB, LWRCUTSQ, LWRCUT2SQ, DELRC, PAPALP, PAPS, PAPCD, PAPEPS, PAPANG1, PAPANG2, &    
 71:      &                 DBEPSBB, DBEPSAB, DBSIGBB, DBSIGAB, DBPMU, EFIELD, YKAPPA, YEPS, GEMRC, MREQ, HSEFF, BEPS, & 71:      &                 DBEPSBB, DBEPSAB, DBSIGBB, DBSIGAB, DBPMU, EFIELD, YKAPPA, YEPS, GEMRC, MREQ, HSEFF, BEPS, &
 72:      &                 EPS11, EPS22, EPS12, MRHO11, MRHO22, MRHO12, REQ11, REQ22, REQ12, & 72:      &                 EPS11, EPS22, EPS12, MRHO11, MRHO22, MRHO12, REQ11, REQ22, REQ12, &
 73:      &                 RHOCC0, RHOCC10, RHOCC20,  RHOHH0, RHOHH10, RHOHH20, RHOCH0, RHOC10H, & 73:      &                 RHOCC0, RHOCC10, RHOCC20,  RHOHH0, RHOHH10, RHOHH20, RHOCH0, RHOC10H, &
 74:      &                 RHOCH10, RHOC20H, RHOCH20, ALPHACC, ALPHAHH, ALPHACH, DC6CC, DC6HH, DC6CH, KKJ, CCKJ, SYMFCTR, & 74:      &                 RHOCH10, RHOC20H, RHOCH20, ALPHACC, ALPHAHH, ALPHACH, DC6CC, DC6HH, DC6CH, KKJ, CCKJ, SYMFCTR, &
 75:      &                 GBANISOTROPYR,GBWELLDEPTHR,PARAMa1,PARAMb1,PARAMc1,PARAMa2,PARAMB2,PARAMc2,PSIGMA0(2),PEPSILON0,& 75:      &                 GBANISOTROPYR,GBWELLDEPTHR,PARAMa1,PARAMb1,PARAMc1,PARAMa2,PARAMB2,PARAMc2,PSIGMA0(2),PEPSILON0,&
 76:      &                 PEPSILON1(3),PSCALEFAC1(2),PSCALEFAC2(2),PYA11(3),PYA21(3),PYA12(3),PYA22(3), & 76:      &                 PEPSILON1(3),PSCALEFAC1(2),PSCALEFAC2(2),PYA11(3),PYA21(3),PYA12(3),PYA22(3), &
 77:      &                 PEPSILONATTR(2),PSIGMAATTR(2), PYOVERLAPTHRESH, PYCFTHRESH, LJSITECOORDS(3), & 77:      &                 PEPSILONATTR(2),PSIGMAATTR(2), PYOVERLAPTHRESH, PYCFTHRESH, LJSITECOORDS(3), &
 78:      &                 MSTART,MFINISH,MBSTART1,MBFINISH1,MBSTART2,MBFINISH2,MBHEIGHT1,MBHEIGHT2,ME1,ME2,ME3, & 78:      &                 MSTART,MFINISH,MBSTART1,MBFINISH1,MBSTART2,MBFINISH2,MBHEIGHT1,MBHEIGHT2,ME1,ME2,ME3, &
 79:      &                 BSPTQMAX, BSPTQMIN, PFORCE, CSMNORM, CSMGUIDENORM, CSMEPS, PERCCUT, & 79:      &                 BSPTQMAX, BSPTQMIN, PFORCE, CSMNORM, CSMGUIDENORM, CSMEPS, PERCCUT, &
 80:      &                 LOWESTE, PERTSTEP, GCPLUS, & 80:      &                 LOWESTE, PERTSTEP, GCPLUS, &
 81:      &                 KINT, INTFREEZETOL, IMSEPMIN, IMSEPMAX, CONCUTABS, CONCUTFRAC, & 81:      &                 KINT, INTFREEZETOL, IMSEPMIN, IMSEPMAX, CONCUTABS, CONCUTFRAC, &
 82:      &                 LPDGEOMDIFFTOL, INTCONFRAC, MAXCONE, INTRMSTOL, BFGSTSTOL, ORBITTOL, & 82:      &                 LPDGEOMDIFFTOL, INTCONFRAC, MAXCONE, INTRMSTOL, BFGSTSTOL, ORBITTOL, &
 83:      &                 INTCONSTRAINTTOL, INTCONSTRAINTDEL, RBCUTOFF, INTCONSTRAINTREP, INTCONSTRAINREPCUT, & 83:      &                 INTCONSTRAINTTOL, INTCONSTRAINTDEL, RBCUTOFF, INTCONSTRAINTREP, INTCONSTRAINREPCUT, &
 84:      &                 INTLJTOL, INTLJDEL, INTLJEPS, REPCON, INTDGUESS, CHECKREPCUTOFF, INTMINFAC, FREEZETOL, & 84:      &                 INTLJTOL, INTLJDEL, INTLJEPS, REPCON, INTDGUESS, CHECKREPCUTOFF, INTMINFAC, FREEZETOL, &
 85:      &                 LOCALPERMCUT, LOCALPERMCUT2, INTCONCUT, QCIRADSHIFT, MLPLAMBDA, & 85:      &                 LOCALPERMCUT, LOCALPERMCUT2, INTCONCUT, QCIRADSHIFT, MLPLAMBDA, &
 86:      &                 CAPSIDRHO,CAPSIDEPS,SIGMAPENT,RADPENT,SIGMAHEX,RADHEX,SIGMAPH, KLIM, SCA, & 86:      &                 CAPSIDRHO,CAPSIDEPS,SIGMAPENT,RADPENT,SIGMAHEX,RADHEX,SIGMAPH, KLIM, SCA, &
 87:      &                 QCIADDREPCUT, QCIADDREPEPS, MLQLAMBDA 87:      &                 QCIADDREPCUT, QCIADDREPEPS, MLQLAMBDA
 88:  88: 
 89:       LOGICAL DEBUG, TARGET, MORSET, CUTT, SEEDT, CENT, TSALLIST, FREEZECORE, NEWJUMP, RENORM, CAPSID, FREEZE, & 89:       LOGICAL DEBUG, TARGET, MORSET, CUTT, SEEDT, CENT, TSALLIST, FREEZECORE, NEWJUMP, RENORM, CAPSID, FREEZE, &
 90:      &        OTPT, LJMFT, STRANDT, PAHT, SWT, MSTRANST, STOCKT, STICKYT, BLNT, MYSDT, FREEZERES, CENTXY, & 90:      &        OTPT, LJMFT, STRANDT, PAHT, SWT, MSTRANST, STOCKT, STICKYT, BLNT, MYSDT, FREEZERES, CENTXY, &
 91:      &        MSORIGT, SQUEEZET, PERIODIC, SCT, MSCT, MGUPTAT, RESIZET, TIP, RIGID, CALCQT, MPIT, GBHT, JMT, LJCOULT, LJ_GAUSST, SETCENT, & 91:      &        MSORIGT, SQUEEZET, PERIODIC, SCT, MSCT, MGUPTAT, RESIZET, TIP, RIGID, CALCQT, MPIT, GBHT, JMT, LJCOULT, SETCENT, &
 92:      &        SORTT, HIT, SAVEQ, PARALLELT, FIXD, RKMIN, BSMIN, PERMDIST, PERMOPT, BSWL, BSPT, BSPTRESTART, & 92:      &        SORTT, HIT, SAVEQ, PARALLELT, FIXD, RKMIN, BSMIN, PERMDIST, PERMOPT, BSWL, BSPT, BSPTRESTART, &
 93:      &        SYMMETRIZE, SYMMETRIZECSM, PRINT_PTGRP, PRINT_MINDATA, DUMPT, NEON, ARGON, P46, NORESET, TABOOT, EVSTEPT, PACHECO, DL_POLY, QUCENTRE, & 93:      &        SYMMETRIZE, SYMMETRIZECSM, PRINT_PTGRP, PRINT_MINDATA, DUMPT, NEON, ARGON, P46, NORESET, TABOOT, EVSTEPT, PACHECO, DL_POLY, QUCENTRE, &
 94:      &        STAR, PLUS, TWOPLUS, GROUND, DIPOLE, DFTBT, DFTBCT, SW, SUPERSTEP, EAMLJT, PBGLUET, TRACKDATAT, & 94:      &        STAR, PLUS, TWOPLUS, GROUND, DIPOLE, DFTBT, DFTBCT, SW, SUPERSTEP, EAMLJT, PBGLUET, TRACKDATAT, &
 95:      &        EAMALT, ALGLUET, MGGLUET, GUPTAT, LJATT, FST, DECAY, COOP, FIXBIN, GAUSST, QUENCHDOS, FIXDIHEFLAG, & 95:      &        EAMALT, ALGLUET, MGGLUET, GUPTAT, LJATT, FST, DECAY, COOP, FIXBIN, GAUSST, QUENCHDOS, FIXDIHEFLAG, &
 96:      &        FRAUSIT, ANGST, SELFT, STEPOUT, WENZEL, THRESHOLDT, THOMSONT, MULLERBROWNT, CHARMMENERGIES, & 96:      &        FRAUSIT, ANGST, SELFT, STEPOUT, WENZEL, THRESHOLDT, THOMSONT, MULLERBROWNT, CHARMMENERGIES, &
 97:      &        PROJ, RGCL2, TOSI, WELCH, AXTELL, AMBER, FIXIMAGE, BINARY, SHIFTCUT, ARNO, TUNNELT, TWOD, & 97:      &        PROJ, RGCL2, TOSI, WELCH, AXTELL, AMBER, FIXIMAGE, BINARY, SHIFTCUT, ARNO, TUNNELT, TWOD, & 
 98:      &        BLJCLUSTER, BLJCLUSTER_NOCUT, COMPRESST, FIX, FIXT, BFGS, LBFGST, DBRENTT, DZTEST, FNI, FAL, CPMD, TNT, ZETT1, & 98:      &        BLJCLUSTER, BLJCLUSTER_NOCUT, COMPRESST, FIX, FIXT, BFGS, LBFGST, DBRENTT, DZTEST, FNI, FAL, CPMD, TNT, ZETT1, &
 99:      &        ZETT2, GBH_RESTART, RESTART, CONJG, NEWRESTART, AVOID, NATBT, DIFFRACTT, CHRMMT, INTMINT, LB2T, & 99:      &        ZETT2, GBH_RESTART, RESTART, CONJG, NEWRESTART, AVOID, NATBT, DIFFRACTT, CHRMMT, INTMINT, LB2T, & 
100:      &        PTMC, BINSTRUCTURES, PROGRESS, MODEL1T, NEWRESTART_MD, CHANGE_TEMP, NOCISTRANS, CHECKCHIRALITY, &100:      &        PTMC, BINSTRUCTURES, PROGRESS, MODEL1T, NEWRESTART_MD, CHANGE_TEMP, NOCISTRANS, CHECKCHIRALITY, &
101:      &        GBT, GBDT, GBDPT, GEMT, LINRODT, RADIFT, CAPBINT, DBPT, DBPTDT, DMBLMT, DMBLPYT, EFIELDT, PAHAT, STOCKAAT, MORSEDPT, &101:      &        GBT, GBDT, GBDPT, GEMT, LINRODT, RADIFT, CAPBINT, DBPT, DBPTDT, DMBLMT, DMBLPYT, EFIELDT, PAHAT, STOCKAAT, MORSEDPT, &
102:      &        MSGBT, MSTBINT, MMRSDPT, MSSTOCKT, LWOTPT, NCAPT, NPAHT, NTIPT, PAHW99T, ELLIPSOIDT, GAYBERNET,&102:      &        MSGBT, MSTBINT, MMRSDPT, MSSTOCKT, LWOTPT, NCAPT, NPAHT, NTIPT, PAHW99T, ELLIPSOIDT, GAYBERNET,& 
103:      &        MULTPAHAT, PAPT, PAPBINT, PAPJANT, PTSTSTT, SHIFTED, SILANET, TDHDT, DDMT, WATERDCT, WATERKZT, CHECKDT, CHECKMARKOVT,&103:      &        MULTPAHAT, PAPT, PAPBINT, PAPJANT, PTSTSTT, SHIFTED, SILANET, TDHDT, DDMT, WATERDCT, WATERKZT, CHECKDT, CHECKMARKOVT,& 
104:      &        TETHER, HISTSMOOTH, VISITPROP, ARMT, FixedEndMoveT, FIXCOM, RESTORET, QUADT, AMHT, MOVESHELLT, QDT, QD2T, &104:      &        TETHER, HISTSMOOTH, VISITPROP, ARMT, FixedEndMoveT, FIXCOM, RESTORET, QUADT, AMHT, MOVESHELLT, QDT, QD2T, &
105:      &        PARAMONOVPBCX, PARAMONOVPBCY, PARAMONOVPBCZ, PARAMONOVCUTOFF, GAYBERNEDCT, UNFREEZERES, FREEZEALL, &105:      &        PARAMONOVPBCX, PARAMONOVPBCY, PARAMONOVPBCZ, PARAMONOVCUTOFF, GAYBERNEDCT, UNFREEZERES, FREEZEALL, &
106:      &        PROJIT, PROJIHT, LEAPDIHE, DUMPQUT, DUMPBESTT, LJSITE, BLJSITE, LJSITEATTR, DUMPSTEPST, &106:      &        PROJIT, PROJIHT, LEAPDIHE, DUMPQUT, DUMPBESTT, LJSITE, BLJSITE, LJSITEATTR, DUMPSTEPST, &
107:      &        AMBERT, RANDOMSEEDT, PYGPERIODICT, LJCAPSIDT, PYBINARYT, SWAPMOVEST, MOVABLEATOMST, LIGMOVET,DUMPSTRUCTURES, &107:      &        AMBERT, RANDOMSEEDT, PYGPERIODICT, LJCAPSIDT, PYBINARYT, SWAPMOVEST, MOVABLEATOMST, LIGMOVET,DUMPSTRUCTURES, &
108:      &        LJSITECOORDST, VGW, ACKLANDT, G46, DF1T, PULLT, LOCALSAMPLET, CSMT, A9INTET, INTERESTORE, COLDFUSION, &108:      &        LJSITECOORDST, VGW, ACKLANDT, G46, DF1T, PULLT, LOCALSAMPLET, CSMT, A9INTET, INTERESTORE, COLDFUSION, &
109:      &        CSMGUIDET, MULTISITEPYT, CHAPERONINT, AVOIDRESEEDT, OHCELLT, UNFREEZEFINALQ, PERCOLATET, PERCT, PERCACCEPTED, PERCCOMPMARKOV, &109:      &        CSMGUIDET, MULTISITEPYT, CHAPERONINT, AVOIDRESEEDT, OHCELLT, UNFREEZEFINALQ, PERCOLATET, PERCT, PERCACCEPTED, PERCCOMPMARKOV, &
110:      &        GENALT, MINDENSITYT, RESTRICTREGION, RESTRICTREGIONTEST, RESTRICTCYL, ACK1, ACK2, HARMONICF,&110:      &        GENALT, MINDENSITYT, RESTRICTREGION, RESTRICTREGIONTEST, RESTRICTCYL, ACK1, ACK2, HARMONICF,&
111:      &        HARMONICDONTMOVE, DUMPUNIQUE, FREEZESAVE, TBP, RBSYMT, PTMCDUMPSTRUCT, PTMCDUMPENERT, PYCOLDFUSION, MONITORT,&111:      &        HARMONICDONTMOVE, DUMPUNIQUE, FREEZESAVE, TBP, RBSYMT, PTMCDUMPSTRUCT, PTMCDUMPENERT, PYCOLDFUSION, MONITORT,&
112:      &        CHARMMDFTBT, PERMINVOPT, BLOCKMOVET, MAXERISE_SET, PYT, BINARY_EXAB, CHIROT, POLYT, SANDBOXT, &112:      &        CHARMMDFTBT, PERMINVOPT, BLOCKMOVET, MAXERISE_SET, PYT, BINARY_EXAB, CHIROT, POLYT, SANDBOXT, &
113:      &        RESERVOIRT, DISTOPT, ONEDAPBCT, ONEDPBCT, TWODAPBCT, TWODPBCT, THREEDAPBCT, THREEDPBCT, RATIOT, &113:      &        RESERVOIRT, DISTOPT, ONEDAPBCT, ONEDPBCT, TWODAPBCT, TWODPBCT, THREEDAPBCT, THREEDPBCT, RATIOT, &
114:      &        PTRANDOM, PTINTERVAL, PTSINGLE, PTSETS, CHEMSHIFT, CHEMSHIFT2, CSH, DEBUGss2029, UNIFORMMOVE, RANSEEDT, &114:      &        PTRANDOM, PTINTERVAL, PTSINGLE, PTSETS, CHEMSHIFT, CHEMSHIFT2, CSH, DEBUGss2029, UNIFORMMOVE, RANSEEDT, &
115:      &        TTM3T, NOINVERSION, RIGIDCONTOURT, UPDATERIGIDREFT, HYBRIDMINT, COMPRESSRIGIDT, MWFILMT, &115:      &        TTM3T, NOINVERSION, RIGIDCONTOURT, UPDATERIGIDREFT, HYBRIDMINT, COMPRESSRIGIDT, MWFILMT, &
116:      &        SUPPRESST, MFETT, POLIRT, QUIPT, SWPOTT, MWPOTT, REPMATCHT, GLJT, MLJT, READMASST, SPECMASST, NEWTSALLIST, &116:      &        SUPPRESST, MFETT, POLIRT, QUIPT, SWPOTT, MWPOTT, REPMATCHT, GLJT, MLJT, READMASST, SPECMASST, NEWTSALLIST, &
117:      &        PHI4MODELT, CUDAT, CUDATIMET, AMBER12T, ENERGY_DECOMPT, NEWMOVEST, DUMPMINT, MBPOLT, MOLECULART, GCBHT, SEMIGRAND_MUT, USEROT, &117:      &        PHI4MODELT, CUDAT, CUDATIMET, AMBER12T, ENERGY_DECOMPT, NEWMOVEST, DUMPMINT, MBPOLT, MOLECULART, GCBHT, SEMIGRAND_MUT, USEROT, & 
118:      &        SAVEMULTIMINONLY, GRADPROBLEMT, INTLJT, CONDATT, QCIPERMCHECK, &118:      &        SAVEMULTIMINONLY, GRADPROBLEMT, INTLJT, CONDATT, QCIPERMCHECK, &
119:      &        INTCONSTRAINTT, INTFREEZET, CHECKCONINT, CONCUTABST, CONCUTFRACT, INTERPCOSTFUNCTION, &119:      &        INTCONSTRAINTT, INTFREEZET, CHECKCONINT, CONCUTABST, CONCUTFRACT, INTERPCOSTFUNCTION, &
120:      &        RBAAT, FREEZENODEST, DUMPINTEOS, DUMPINTXYZ, QCIPOTT, QCIPOT2T, INTSPRINGACTIVET, LPERMDIST, LOCALPERMDIST, QCIRADSHIFTT, &120:      &        RBAAT, FREEZENODEST, DUMPINTEOS, DUMPINTXYZ, QCIPOTT, QCIPOT2T, INTSPRINGACTIVET, LPERMDIST, LOCALPERMDIST, QCIRADSHIFTT, &
121:      &        MLP3T, MKTRAPT, MLPB3T, MLPB3NEWT, MULTIPOTT, QCIAMBERT, MLPNEWREG, DJWRBT, STEALTHYT, LJADDT, QCINOREPINT, RIGIDMDT, &121:      &        MLP3T, MKTRAPT, MLPB3T, MLPB3NEWT, MULTIPOTT, QCIAMBERT, MLPNEWREG, DJWRBT, STEALTHYT, LJADDT, QCINOREPINT, RIGIDMDT, &
122:      &        DUMPMQT, MLQT, MLQPROB, LJADD2T, MLPVB3T, NOREGBIAS, PYADDT, PYADD2T, LJADD3T, REORDERADDT122:      &        DUMPMQT, MLQT, MLQPROB, LJADD2T, MLPVB3T, NOREGBIAS, PYADDT, PYADD2T, LJADD3T, REORDERADDT
123: !123: !
124:       DOUBLE PRECISION, ALLOCATABLE :: SEMIGRAND_MU(:)124:       DOUBLE PRECISION, ALLOCATABLE :: SEMIGRAND_MU(:) 
125:       DOUBLE PRECISION, ALLOCATABLE :: ATMASS(:)125:       DOUBLE PRECISION, ALLOCATABLE :: ATMASS(:)
126:       DOUBLE PRECISION, ALLOCATABLE :: SPECMASS(:)126:       DOUBLE PRECISION, ALLOCATABLE :: SPECMASS(:) 
127: 127: 
128: ! csw34> FREEZEGROUP variables128: ! csw34> FREEZEGROUP variables
129: !129: !
130:       INTEGER :: GROUPCENTRE130:       INTEGER :: GROUPCENTRE
131:       DOUBLE PRECISION :: GROUPRADIUS131:       DOUBLE PRECISION :: GROUPRADIUS
132:       CHARACTER (LEN=2) :: FREEZEGROUPTYPE132:       CHARACTER (LEN=2) :: FREEZEGROUPTYPE
133:       LOGICAL :: FREEZEGROUPT133:       LOGICAL :: FREEZEGROUPT
134: ! END134: ! END
135: 135: 
136: !136: !
161: 161: 
162: ! GROUP ROTATION MOVE PARAMETERS162: ! GROUP ROTATION MOVE PARAMETERS
163:       INTEGER :: GROUPROTFREQ, NGROUPS163:       INTEGER :: GROUPROTFREQ, NGROUPS
164:       LOGICAL :: GROUPROTT, DOGROUPROT=.FALSE., GR_SCALEROT, GR_SCALEPROB164:       LOGICAL :: GROUPROTT, DOGROUPROT=.FALSE., GR_SCALEROT, GR_SCALEPROB
165:       LOGICAL :: GROUPROT_SUPPRESS165:       LOGICAL :: GROUPROT_SUPPRESS
166:       CHARACTER(LEN=10), ALLOCATABLE :: ATOMGROUPNAMES(:)166:       CHARACTER(LEN=10), ALLOCATABLE :: ATOMGROUPNAMES(:)
167:       CHARACTER(LEN=30) :: GR_SCALEMODE167:       CHARACTER(LEN=30) :: GR_SCALEMODE
168:       INTEGER, ALLOCATABLE :: ATOMGROUPAXIS(:,:)168:       INTEGER, ALLOCATABLE :: ATOMGROUPAXIS(:,:)
169:       DOUBLE PRECISION, ALLOCATABLE :: ATOMGROUPSCALING(:),ATOMGROUPPSELECT(:)169:       DOUBLE PRECISION, ALLOCATABLE :: ATOMGROUPSCALING(:),ATOMGROUPPSELECT(:)
170:       LOGICAL, ALLOCATABLE :: ATOMGROUPS(:,:)170:       LOGICAL, ALLOCATABLE :: ATOMGROUPS(:,:)
171: 171:       
172: ! DIHEDRAL GROUP ROTATION MOVE PARAMETERS172: ! DIHEDRAL GROUP ROTATION MOVE PARAMETERS
173:       INTEGER :: DIHEDRALROTFREQ, NDIHEDRALGROUPS173:       INTEGER :: DIHEDRALROTFREQ, NDIHEDRALGROUPS 
174:       LOGICAL :: DIHEDRALROTT, DODIHEDRALROT=.FALSE.174:       LOGICAL :: DIHEDRALROTT, DODIHEDRALROT=.FALSE.
175:       CHARACTER(LEN=10), ALLOCATABLE :: DIHEDRALGROUPNAMES(:), ANGLETYPE(:)175:       CHARACTER(LEN=10), ALLOCATABLE :: DIHEDRALGROUPNAMES(:), ANGLETYPE(:)
176:       INTEGER, ALLOCATABLE :: DIHEDRALGROUPAXIS(:,:)176:       INTEGER, ALLOCATABLE :: DIHEDRALGROUPAXIS(:,:)
177:       DOUBLE PRECISION, ALLOCATABLE :: DIHEDRALGROUPSCALING(:),DIHEDRALGROUPPSELECT(:)177:       DOUBLE PRECISION, ALLOCATABLE :: DIHEDRALGROUPSCALING(:),DIHEDRALGROUPPSELECT(:)
178:       LOGICAL, ALLOCATABLE :: DIHEDRALGROUPS(:,:)178:       LOGICAL, ALLOCATABLE :: DIHEDRALGROUPS(:,:)
179: 179:       
180:       ! parameters for helical sampling moves180:       ! parameters for helical sampling moves
181:       LOGICAL :: BGSMOVE181:       LOGICAL :: BGSMOVE
182:       DOUBLE PRECISION :: PHI0,PSI0,PHIk,PSIk182:       DOUBLE PRECISION :: PHI0,PSI0,PHIk,PSIk
183:       DOUBLE PRECISION :: bgsb1, bgsb2, pselectBGS ! parameters for biased gaussian sampling:183:       DOUBLE PRECISION :: bgsb1, bgsb2, pselectBGS ! parameters for biased gaussian sampling: 
184:       INTEGER :: NDIHEDRAL_BB_GROUPS184:       INTEGER :: NDIHEDRAL_BB_GROUPS
185:       ! bgsb1 is spring constant associated with independent torsion sampling185:       ! bgsb1 is spring constant associated with independent torsion sampling
186:       ! bgsb2 controls bias towards local deformations186:       ! bgsb2 controls bias towards local deformations
187:       ! pselectBGS: probability of attempting BGS move187:       ! pselectBGS: probability of attempting BGS move
188: 188: 
189: 189: 
190: ! EXPANDRIGID variables190: ! EXPANDRIGID variables
191:       INTEGER :: EXPANDRIGIDFREQ191:       INTEGER :: EXPANDRIGIDFREQ
192:       LOGICAL :: EXPANDRIGIDT, NORMALISEEXPANDT, DOEXPANDRIGID=.FALSE.192:       LOGICAL :: EXPANDRIGIDT, NORMALISEEXPANDT, DOEXPANDRIGID=.FALSE.
193: 193: 
217:       DOUBLE PRECISION, ALLOCATABLE :: HBONDBESTCOORDS(:,:)217:       DOUBLE PRECISION, ALLOCATABLE :: HBONDBESTCOORDS(:,:)
218:       DOUBLE PRECISION, ALLOCATABLE :: HBONDMARKOV(:), HBONDBEST(:),HBONDQUE(:)218:       DOUBLE PRECISION, ALLOCATABLE :: HBONDMARKOV(:), HBONDBEST(:),HBONDQUE(:)
219:       DOUBLE PRECISION, ALLOCATABLE :: HBONDMAXE(:)219:       DOUBLE PRECISION, ALLOCATABLE :: HBONDMAXE(:)
220:       INTEGER :: HBONDNRES, HBONDMATCHN, MAXHBONDGROUPS220:       INTEGER :: HBONDNRES, HBONDMATCHN, MAXHBONDGROUPS
221: ! END OF HBONDMATRIX VARIABLES221: ! END OF HBONDMATRIX VARIABLES
222: 222: 
223: ! sf344> Modular global optimization variables223: ! sf344> Modular global optimization variables
224:       INTEGER :: MODULARNMIN, MODULARNMAX, MODULARNINCR, MODULARLOWEST,MODULARCURRENTN224:       INTEGER :: MODULARNMIN, MODULARNMAX, MODULARNINCR, MODULARLOWEST,MODULARCURRENTN
225:       LOGICAL :: MODULART,MODULARRESTARTT225:       LOGICAL :: MODULART,MODULARRESTARTT
226:       LOGICAL, ALLOCATABLE :: EXCLUDED(:)226:       LOGICAL, ALLOCATABLE :: EXCLUDED(:)
227:       CHARACTER(LEN=80) :: MODULARRESTARTFILE227:       CHARACTER(LEN=80) :: MODULARRESTARTFILE 
228: ! sf344> end of modular global optimization variables228: ! sf344> end of modular global optimization variables
229: 229: 
230:       INTEGER  NGBSITE, NPYSITE, PYBINARYTYPE1, PYSWAP(3), MAXINTERACTIONS230:       INTEGER  NGBSITE, NPYSITE, PYBINARYTYPE1, PYSWAP(3), MAXINTERACTIONS
231: 231:    
232:       DOUBLE PRECISION :: DZP1, DZP2, DZP3, DZP4, DZP5, DZP6, DZP7232:       DOUBLE PRECISION :: DZP1, DZP2, DZP3, DZP4, DZP5, DZP6, DZP7
233:       LOGICAL :: FIELDT, OHT, IHT, TDT, D5HT233:       LOGICAL :: FIELDT, OHT, IHT, TDT, D5HT
234:       DOUBLE PRECISION :: FOH, FIH, FTD, FD5H234:       DOUBLE PRECISION :: FOH, FIH, FTD, FD5H
235: 235: 
236:       !ds656> Box centroid to facilitate global236:       !ds656> Box centroid to facilitate global
237:       !       optimisation of supported clusters.237:       !       optimisation of supported clusters.
238:       LOGICAL :: BOXCENTROIDT, BOXCENTROID_DISCRETE(3)238:       LOGICAL :: BOXCENTROIDT, BOXCENTROID_DISCRETE(3)
239:       DOUBLE PRECISION :: BOXCENTROID_X(3), BOXCENTROID_DX(3)239:       DOUBLE PRECISION :: BOXCENTROID_X(3), BOXCENTROID_DX(3)
240: 240: 
241:       !ds656> Mie field(s) for modelling substrate effects.241:       !ds656> Mie field(s) for modelling substrate effects.
242:       LOGICAL :: MIEFT, MIEF_CUTT, MIEF_PBCT242:       LOGICAL :: MIEFT, MIEF_CUTT, MIEF_PBCT
243:       CHARACTER(LEN=130) :: MIEF_FILENAME243:       CHARACTER(LEN=130) :: MIEF_FILENAME
244:       INTEGER :: MIEF_NSITES,MIEF_N,MIEF_M244:       INTEGER :: MIEF_NSITES,MIEF_N,MIEF_M
245:       DOUBLE PRECISION :: MIEF_BOX(3), MIEF_RCUT245:       DOUBLE PRECISION :: MIEF_BOX(3), MIEF_RCUT           
246:       DOUBLE PRECISION, ALLOCATABLE :: MIEF_EPS(:), MIEF_SIG(:), &246:       DOUBLE PRECISION, ALLOCATABLE :: MIEF_EPS(:), MIEF_SIG(:), &
247:            MIEF_SITES(:,:), MIEF_U_RCUT(:), MIEF_DUDR_RCUT(:)247:            MIEF_SITES(:,:), MIEF_U_RCUT(:), MIEF_DUDR_RCUT(:)
248: 248: 
249:       CHARACTER(LEN=80) :: SYS249:       CHARACTER(LEN=80) :: SYS
250:       CHARACTER(LEN=80) :: INFILE=''250:       CHARACTER(LEN=80) :: INFILE=''
251:       CHARACTER(LEN=1), ALLOCATABLE :: BEADLETTER(:), BLNSSTRUCT(:)251:       CHARACTER(LEN=1), ALLOCATABLE :: BEADLETTER(:), BLNSSTRUCT(:)
252:       CHARACTER(LEN=130) DUMPFILE, MYFILENAME, INTEDUMPFILE252:       CHARACTER(LEN=130) DUMPFILE, MYFILENAME, INTEDUMPFILE
253: 253: 
254:       INTEGER NUMPRO_AMH, NINT_AMH, SEED_AMH,HARM_AMH, I1_AMH254:       INTEGER NUMPRO_AMH, NINT_AMH, SEED_AMH,HARM_AMH, I1_AMH
255:       CHARACTER AMINOA(21)*3255:       CHARACTER AMINOA(21)*3
256:       DATA (AMINOA(I1_AMH),I1_AMH=1,21)/'ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY', &256:       DATA (AMINOA(I1_AMH),I1_AMH=1,21)/'ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY', &
257:            'HIS','ILE','LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL','INI'/257:            'HIS','ILE','LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL','INI'/
258: 258: 
259: !      DOUBLE PRECISION :: HESS(1,1)259: !      DOUBLE PRECISION :: HESS(1,1)
260: !     DOUBLE PRECISION HESS(3*MXATMS,3*MXATMS)260: !     DOUBLE PRECISION HESS(3*MXATMS,3*MXATMS)
261:       CHARACTER(LEN=3) :: CSMGP, CSMGUIDEGP261:       CHARACTER(LEN=3) :: CSMGP, CSMGUIDEGP
262: 262: 
263: 263: 
264: !|gd351> extra variables for patchy and asakura-oosawa models264: !|gd351> extra variables for patchy and asakura-oosawa models
265:        LOGICAL :: PATCHY, ASAOOS265:        LOGICAL :: PATCHY, ASAOOS
266:        DOUBLE PRECISION :: SIGMASQ, RANGESQ, FACTOR, SIGMAP266:        DOUBLE PRECISION :: SIGMASQ, RANGESQ, FACTOR, SIGMAP 
267: !<gd351|267: !<gd351|
268: 268: 
269: !js850> variables for OVERLAP269: !js850> variables for OVERLAP
270:       LOGICAL OVERLAPK, OVERLAP_IMPORT270:       LOGICAL OVERLAPK, OVERLAP_IMPORT
271:       DOUBLE PRECISION OVERLAP_DR271:       DOUBLE PRECISION OVERLAP_DR
272:       INTEGER OVERLAP_FRQ272:       INTEGER OVERLAP_FRQ
273: !js850> variables for LJPSHIFT + FREEZE + RESTRICTREGION interactionlist273: !js850> variables for LJPSHIFT + FREEZE + RESTRICTREGION interactionlist
274:       INTEGER, ALLOCATABLE :: FREEZEIL(:,:) ! ALLOCATE(FREEZEIL(NATOMS*(NATOMS+1),2))274:       INTEGER, ALLOCATABLE :: FREEZEIL(:,:) ! ALLOCATE(FREEZEIL(NATOMS*(NATOMS+1),2))
275:       INTEGER FREEZEIL_NAA, FREEZEIL_NAB, FREEZEIL_NBB275:       INTEGER FREEZEIL_NAA, FREEZEIL_NAB, FREEZEIL_NBB
276:       LOGICAL FREEZEIL_USE276:       LOGICAL FREEZEIL_USE
277:       DOUBLE PRECISION FREEZEIL_E277:       DOUBLE PRECISION FREEZEIL_E
278:       INTEGER NTYPEA, NTYPEA_FIX278:       INTEGER NTYPEA, NTYPEA_FIX
279:       DOUBLE PRECISION EPSAB, EPSBB, SIGAB, SIGBB279:       DOUBLE PRECISION EPSAB, EPSBB, SIGAB, SIGBB
280: !js850> variables for potential SOFT_SPHERE280: !js850> variables for potential SOFT_SPHERE
281:       LOGICAL SOFT_SPHERE281:       LOGICAL SOFT_SPHERE
282:       DOUBLE PRECISION SOFT_SPHERE_RCUT282:       DOUBLE PRECISION SOFT_SPHERE_RCUT
283:       INTEGER SOFT_SPHERE_NTYPEA283:       INTEGER SOFT_SPHERE_NTYPEA
284: !js850> variables for ONE_ATOM_TAKESTEP284: !js850> variables for ONE_ATOM_TAKESTEP
285:       !DOUBLE PRECISION, ALLOCATABLE :: ONE_ATOM_ENERGIES(:)285:       !DOUBLE PRECISION, ALLOCATABLE :: ONE_ATOM_ENERGIES(:) 
286:       !DOUBLE PRECISION, ALLOCATABLE :: ONE_ATOM_ENERGY_MATRIX(:,:)286:       !DOUBLE PRECISION, ALLOCATABLE :: ONE_ATOM_ENERGY_MATRIX(:,:) 
287:       !INTEGER :: ONE_ATOMI287:       !INTEGER :: ONE_ATOMI
288:       !LOGICAL :: ONE_ATOM_TAKESTEP, ONE_ATOM_USE288:       !LOGICAL :: ONE_ATOM_TAKESTEP, ONE_ATOM_USE
289:       LOGICAL :: ONE_ATOM_TAKESTEP289:       LOGICAL :: ONE_ATOM_TAKESTEP
290:       LOGICAL, ALLOCATABLE :: ONE_ATOM_USE(:) !ONE FOR EACH PROCESSOR290:       LOGICAL, ALLOCATABLE :: ONE_ATOM_USE(:) !ONE FOR EACH PROCESSOR
291:       INTEGER, ALLOCATABLE :: ONE_ATOMI(:) !ONE FOR EACH PROCESSOR291:       INTEGER, ALLOCATABLE :: ONE_ATOMI(:) !ONE FOR EACH PROCESSOR
292: !js850> variables for setting parallel tempering temperatures292: !js850> variables for setting parallel tempering temperatures
293:       LOGICAL PTREADTEMPS293:       LOGICAL PTREADTEMPS
294: !js850> variables for PTEX_INDEP294: !js850> variables for PTEX_INDEP
295:       LOGICAL PTEX_INDEP295:       LOGICAL PTEX_INDEP
296:       INTEGER PTEX_INDEP_NSTEPS296:       INTEGER PTEX_INDEP_NSTEPS
297:       INTEGER PTEX_INDEP_UNIT297:       INTEGER PTEX_INDEP_UNIT
298: !js850>298: !js850> 
299:       INTEGER NPCALL ! the number of potential calls299:       INTEGER NPCALL ! the number of potential calls
300: !js850> for keyword max_npcall300: !js850> for keyword max_npcall
301:       LOGICAL MAX_NPCALLT301:       LOGICAL MAX_NPCALLT
302:       INTEGER MAX_NPCALL302:       INTEGER MAX_NPCALL
303: 303: 
304: !ds656> Binary Gupta keywords, parameters, variables...304: !ds656> Binary Gupta keywords, parameters, variables...
305:       LOGICAL :: BGUPTAT, BGUPTATAB, BGUPTATBB305:       LOGICAL :: BGUPTAT, BGUPTATAB, BGUPTATBB
306: !ds656> Sequence of label swaps (a.k.a. block of basin-hopping with306: !ds656> Sequence of label swaps (a.k.a. block of basin-hopping with
307: !       exchange moves only)307: !       exchange moves only)
308:       LOGICAL :: LSWAPST, FIXLABELS308:       LOGICAL :: LSWAPST, FIXLABELS
330:       CHARACTER(LEN=2), ALLOCATABLE :: SPECLABELS(:)330:       CHARACTER(LEN=2), ALLOCATABLE :: SPECLABELS(:)
331: !ds656> Enumerate permutations331: !ds656> Enumerate permutations
332:       LOGICAL :: ENPERMST, MULTIPERMT, SPANSWAPST332:       LOGICAL :: ENPERMST, MULTIPERMT, SPANSWAPST
333:       DOUBLE PRECISION, ALLOCATABLE :: LEHMER_COORDS(:,:) ! NAT, NPAR333:       DOUBLE PRECISION, ALLOCATABLE :: LEHMER_COORDS(:,:) ! NAT, NPAR
334:       CHARACTER(LEN=1), ALLOCATABLE :: LEHMER_LIST(:,:) ! NATOMS, NPAR334:       CHARACTER(LEN=1), ALLOCATABLE :: LEHMER_LIST(:,:) ! NATOMS, NPAR
335:       CHARACTER(LEN=1), ALLOCATABLE :: LEHMER_LAST(:) ! NPAR335:       CHARACTER(LEN=1), ALLOCATABLE :: LEHMER_LAST(:) ! NPAR
336:       INTEGER, ALLOCATABLE :: LEHMER_ILASTB(:) ! NPAR336:       INTEGER, ALLOCATABLE :: LEHMER_ILASTB(:) ! NPAR
337: !ds656> Generalized LJ + Yukawa potential337: !ds656> Generalized LJ + Yukawa potential
338:       LOGICAL :: GLJY338:       LOGICAL :: GLJY
339: 339: 
340: !ds656> Some integer arrays for book-keeping and cut-off definig340: !ds656> Some integer arrays for book-keeping and cut-off definig 
341: !       the neighbourhood of an atom.341: !       the neighbourhood of an atom.
342:       INTEGER, ALLOCATABLE :: ATOMLISTS(:,:,:), NBRLISTS(:,:,:)342:       INTEGER, ALLOCATABLE :: ATOMLISTS(:,:,:), NBRLISTS(:,:,:)
343:       INTEGER, ALLOCATABLE :: NNLISTS(:,:)343:       INTEGER, ALLOCATABLE :: NNLISTS(:,:)
344:       INTEGER, ALLOCATABLE :: INVATOMLISTS(:,:)344:       INTEGER, ALLOCATABLE :: INVATOMLISTS(:,:)
345:       LOGICAL :: KEEPLISTS345:       LOGICAL :: KEEPLISTS
346:       DOUBLE PRECISION :: NBRCUT1,NBRCUT2346:       DOUBLE PRECISION :: NBRCUT1,NBRCUT2
347:       INTEGER :: NVSITES_MAX, NNLIST_MAX347:       INTEGER :: NVSITES_MAX, NNLIST_MAX
348:       DOUBLE PRECISION, ALLOCATABLE :: VSITES(:,:)348:       DOUBLE PRECISION, ALLOCATABLE :: VSITES(:,:) 
349: 349: 
350: !ds656> Stress tensor350: !ds656> Stress tensor 
351:       LOGICAL :: STRESST351:       LOGICAL :: STRESST
352:       INTEGER :: STRESS_MODE352:       INTEGER :: STRESS_MODE
353:       DOUBLE PRECISION, ALLOCATABLE :: STRESS(:,:,:)353:       DOUBLE PRECISION, ALLOCATABLE :: STRESS(:,:,:)
354: 354: 
355: !ds656> A saw-tooth temperature protocol355: !ds656> A saw-tooth temperature protocol
356:       LOGICAL :: SAWTOOTH356:       LOGICAL :: SAWTOOTH
357:       INTEGER :: SAWTOOTH_NREJMAX357:       INTEGER :: SAWTOOTH_NREJMAX
358:       DOUBLE PRECISION :: SAWTOOTH_TMAX, SAWTOOTH_TFAC, &358:       DOUBLE PRECISION :: SAWTOOTH_TMAX, SAWTOOTH_TFAC, &
359:            SAWTOOTH_SFAC, SAWTOOTH_SFAC2359:            SAWTOOTH_SFAC, SAWTOOTH_SFAC2
360: 360: 
361: !ds656> Dump current Markov state at regular intervals361: !ds656> Dump current Markov state at regular intervals
362:       LOGICAL :: DUMP_MARKOV362:       LOGICAL :: DUMP_MARKOV
363:       INTEGER :: DUMP_MARKOV_NWAIT, DUMP_MARKOV_NFREQ363:       INTEGER :: DUMP_MARKOV_NWAIT, DUMP_MARKOV_NFREQ
364: 364:       
365: !   allocatables365: !   allocatables
366: 366: 
367:       INTEGER,ALLOCATABLE,DIMENSION(:) :: MOVABLEATOMLIST         ! a list containing the movable atom indices367:       INTEGER,ALLOCATABLE,DIMENSION(:) :: MOVABLEATOMLIST         ! a list containing the movable atom indices
368:       LOGICAL,ALLOCATABLE,DIMENSION(:) :: MOVABLEATOMLISTLOGICAL  ! is atom i movable?368:       LOGICAL,ALLOCATABLE,DIMENSION(:) :: MOVABLEATOMLISTLOGICAL  ! is atom i movable?
369:       INTEGER,ALLOCATABLE,DIMENSION(:) :: ATOMSINBLOCK            ! for BLOCKMOVE, to split movableatoms into separate blocks369:       INTEGER,ALLOCATABLE,DIMENSION(:) :: ATOMSINBLOCK            ! for BLOCKMOVE, to split movableatoms into separate blocks
370:       INTEGER,ALLOCATABLE,DIMENSION(:) :: NSPECIES(:), NSPECIES_INI(:)             ! for multicomponent systems370:       INTEGER,ALLOCATABLE,DIMENSION(:) :: NSPECIES(:), NSPECIES_INI(:)             ! for multicomponent systems
371: 371: 
372:       INTEGER, ALLOCATABLE, DIMENSION(:) :: NT, NQ, BLOCK, JUMPINT, JUMPTO, NCORE, NSURFMOVES  ! dimension will be NPAR372:       INTEGER, ALLOCATABLE, DIMENSION(:) :: NT, NQ, BLOCK, JUMPINT, JUMPTO, NCORE, NSURFMOVES  ! dimension will be NPAR
373:       INTEGER, ALLOCATABLE, DIMENSION(:) :: HISTVALS, LHISTVALS  ! dimension declared HBINS in keyword373:       INTEGER, ALLOCATABLE, DIMENSION(:) :: HISTVALS, LHISTVALS  ! dimension declared HBINS in keyword
374:       INTEGER, ALLOCATABLE, DIMENSION(:,:) :: WATERDEGREE374:       INTEGER, ALLOCATABLE, DIMENSION(:,:) :: WATERDEGREE
375:       INTEGER, ALLOCATABLE :: NPERMSIZE(:), PERMGROUP(:)375:       INTEGER, ALLOCATABLE :: NPERMSIZE(:), PERMGROUP(:)
376:       INTEGER, ALLOCATABLE :: NSETS(:)376:       INTEGER, ALLOCATABLE :: NSETS(:)
377:       INTEGER, ALLOCATABLE :: SETS(:,:)377:       INTEGER, ALLOCATABLE :: SETS(:,:)
378:       INTEGER, ALLOCATABLE :: PERMUTE(:,:)378:       INTEGER, ALLOCATABLE :: PERMUTE(:,:)
379:       INTEGER, ALLOCATABLE :: NCRBN(:), NCMP(:)379:       INTEGER, ALLOCATABLE :: NCRBN(:), NCMP(:)
380:       INTEGER, ALLOCATABLE :: BESTPERM(:) !jdf43>380:       INTEGER, ALLOCATABLE :: BESTPERM(:) !jdf43>
381:       INTEGER, ALLOCATABLE :: TBPBASINS(:),TBPBASINSO(:) !jdf43>381:       INTEGER, ALLOCATABLE :: TBPBASINS(:),TBPBASINSO(:) !jdf43>
382: 382: 
383:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:) :: TEMP, STEP, OSTEP, ASTEP, ACCRAT, EPREV ! dimension will be NPAR383:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:) :: TEMP, STEP, OSTEP, ASTEP, ACCRAT, EPREV ! dimension will be NPAR 
384:       DOUBLE PRECISION, ALLOCATABLE :: TARGETS(:) ! allocated NTARGETS in keyword.f384:       DOUBLE PRECISION, ALLOCATABLE :: TARGETS(:) ! allocated NTARGETS in keyword.f
385:       DOUBLE PRECISION, ALLOCATABLE :: ESAVE(:,:) ! dimension will be NTAB,NPAR385:       DOUBLE PRECISION, ALLOCATABLE :: ESAVE(:,:) ! dimension will be NTAB,NPAR
386:       DOUBLE PRECISION, ALLOCATABLE :: XINSAVE(:,:) ! dimension will be NTAB,NPAR386:       DOUBLE PRECISION, ALLOCATABLE :: XINSAVE(:,:) ! dimension will be NTAB,NPAR
387:       DOUBLE PRECISION, ALLOCATABLE :: HDIST(:), HWEIGHT(:) ! dimension declared HISTBINMAX in keyword387:       DOUBLE PRECISION, ALLOCATABLE :: HDIST(:), HWEIGHT(:) ! dimension declared HISTBINMAX in keyword
388:       DOUBLE PRECISION, ALLOCATABLE :: VEC(:) ! dimension would be NVEC - not used388:       DOUBLE PRECISION, ALLOCATABLE :: VEC(:) ! dimension would be NVEC - not used
389:       DOUBLE PRECISION, ALLOCATABLE :: RBOPS(:,:) !jdf43>389:       DOUBLE PRECISION, ALLOCATABLE :: RBOPS(:,:) !jdf43>
390:       DOUBLE PRECISION, ALLOCATABLE :: REPLOW(:)390:       DOUBLE PRECISION, ALLOCATABLE :: REPLOW(:)
391:       DOUBLE PRECISION, ALLOCATABLE :: GLJEPS(:,:), GLJSIG(:,:) ! GLJ parameters391:       DOUBLE PRECISION, ALLOCATABLE :: GLJEPS(:,:), GLJSIG(:,:) ! GLJ parameters
392: 392: 
393:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: FIXBOTH, FIXTEMP, FIXSTEP, JUMPMOVE, JDUMP, TMOVE, OMOVE ! dimension will be NPAR393:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: FIXBOTH, FIXTEMP, FIXSTEP, JUMPMOVE, JDUMP, TMOVE, OMOVE ! dimension will be NPAR
394:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: SHELLMOVES ! dimension will be NPAR394:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: SHELLMOVES ! dimension will be NPAR
395:       LOGICAL, ALLOCATABLE ::  IGNOREBIN(:) ! will be HBINS395:       LOGICAL, ALLOCATABLE ::  IGNOREBIN(:) ! will be HBINS
396:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: FROZENRES  ! NATOMS for safety396:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: FROZENRES  ! NATOMS for safety 
397:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: FROZEN  !  NATOMS397:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: FROZEN  !  NATOMS
398:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: HARMONICFLIST  !  NATOMS398:       LOGICAL, ALLOCATABLE, DIMENSION(:) :: HARMONICFLIST  !  NATOMS
399:       INTEGER, ALLOCATABLE, DIMENSION(:) :: FROZENLIST  !  NATOMS399:       INTEGER, ALLOCATABLE, DIMENSION(:) :: FROZENLIST  !  NATOMS
400: 400: 
401:       INTEGER, ALLOCATABLE, DIMENSION(:) ::  IATNUM401:       INTEGER, ALLOCATABLE, DIMENSION(:) ::  IATNUM     
402:       INTEGER,ALLOCATABLE :: ANV(:,:,:)402:       INTEGER,ALLOCATABLE :: ANV(:,:,:)
403:       DOUBLE PRECISION, ALLOCATABLE :: LJREP_BLN(:,:), LJATT_BLN(:,:), A_BLN(:), B_BLN(:), C_BLN(:), D_BLN(:), HYDRO_BLN(:)403:       DOUBLE PRECISION, ALLOCATABLE :: LJREP_BLN(:,:), LJATT_BLN(:,:), A_BLN(:), B_BLN(:), C_BLN(:), D_BLN(:), HYDRO_BLN(:)
404:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) :: TCOORDS404:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) :: TCOORDS
405:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:) :: VT405:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:) :: VT
406:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) :: VTVT406:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) :: VTVT
407:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) :: COORDS,COORDSO407:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) :: COORDS,COORDSO
408:       INTEGER, ALLOCATABLE, DIMENSION(:,:) :: LABELS, LABELSO ! <ds656408:       INTEGER, ALLOCATABLE, DIMENSION(:,:) :: LABELS, LABELSO ! <ds656
409:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:) :: FINISH409:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:) :: FINISH
410:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) ::  VAT,  VATO410:       DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:) ::  VAT,  VATO    
411:       DOUBLE PRECISION, ALLOCATABLE :: SITE(:,:), RBUV(:,:), RBSTLA(:,:), STCHRG(:), DPMU(:)411:       DOUBLE PRECISION, ALLOCATABLE :: SITE(:,:), RBUV(:,:), RBSTLA(:,:), STCHRG(:), DPMU(:)
412:       DOUBLE PRECISION, ALLOCATABLE :: MSBCOORDS(:,:)412:       DOUBLE PRECISION, ALLOCATABLE :: MSBCOORDS(:,:)
413:       DOUBLE PRECISION, ALLOCATABLE :: MSBE(:)413:       DOUBLE PRECISION, ALLOCATABLE :: MSBE(:)
414:       DOUBLE PRECISION, ALLOCATABLE :: GAUSSKK(:,:)414:       DOUBLE PRECISION, ALLOCATABLE :: GAUSSKK(:,:)
415:       DOUBLE PRECISION, ALLOCATABLE :: GAUSSEE(:), GKSMALL(:)415:       DOUBLE PRECISION, ALLOCATABLE :: GAUSSEE(:), GKSMALL(:)
416:       DOUBLE PRECISION, ALLOCATABLE :: CSMIMAGES(:)416:       DOUBLE PRECISION, ALLOCATABLE :: CSMIMAGES(:)
417:       DOUBLE PRECISION, ALLOCATABLE :: QMINPCSMAV(:,:), CSMAV(:), QMINAV(:), PTGP(:,:,:), PTGPGUIDE(:,:,:)417:       DOUBLE PRECISION, ALLOCATABLE :: QMINPCSMAV(:,:), CSMAV(:), QMINAV(:), PTGP(:,:,:), PTGPGUIDE(:,:,:)
418:       DOUBLE PRECISION, ALLOCATABLE :: LOWESTC(:)418:       DOUBLE PRECISION, ALLOCATABLE :: LOWESTC(:)
419:       CHARACTER(LEN=2), ALLOCATABLE, DIMENSION(:) :: ZSYM419:       CHARACTER(LEN=2), ALLOCATABLE, DIMENSION(:) :: ZSYM   
420:       CHARACTER(LEN=4), ALLOCATABLE, DIMENSION(:) :: PTGROUP ! dimension will be NPAR420:       CHARACTER(LEN=4), ALLOCATABLE, DIMENSION(:) :: PTGROUP ! dimension will be NPAR
421:       REAL, ALLOCATABLE :: xvEX(:)  !  single precision!!!!421:       REAL, ALLOCATABLE :: xvEX(:)  !  single precision!!!!
422:       DOUBLE PRECISION, ALLOCATABLE :: HARMONICR0(:)422:       DOUBLE PRECISION, ALLOCATABLE :: HARMONICR0(:)
423: 423: 
424:       DOUBLE PRECISION, ALLOCATABLE     :: PYA1bin(:,:), PYA2bin(:,:)424:       DOUBLE PRECISION, ALLOCATABLE     :: PYA1bin(:,:), PYA2bin(:,:)
425:       DOUBLE PRECISION, ALLOCATABLE :: TARGETCOORDS(:)425:       DOUBLE PRECISION, ALLOCATABLE :: TARGETCOORDS(:)
426: 426: 
427: !beh35> new type creation for mlowest427: !beh35> new type creation for mlowest
428: 428: 
429:       LOGICAL :: MLOWEST429:       LOGICAL :: MLOWEST
517:       TYPE(ONERESPAR) :: HYDROGENOTH(12),HYDROGENGLY(12),HYDROGENPRO(12)517:       TYPE(ONERESPAR) :: HYDROGENOTH(12),HYDROGENGLY(12),HYDROGENPRO(12)
518:       TYPE(TWORES) :: DISULFID,EXTDISOTH(26),EXTDISGLY(26)518:       TYPE(TWORES) :: DISULFID,EXTDISOTH(26),EXTDISGLY(26)
519:       TYPE(TWORES) :: EXTDISPRO(26)519:       TYPE(TWORES) :: EXTDISPRO(26)
520: !fh301>}}}520: !fh301>}}}
521: 521: 
522: 522: 
523:       DOUBLE PRECISION, ALLOCATABLE     :: XYPHI(:)523:       DOUBLE PRECISION, ALLOCATABLE     :: XYPHI(:)
524: 524: 
525:       ! Variables for LJGSITE keyword:525:       ! Variables for LJGSITE keyword:
526:       ! LJGSITET indicates if LJGSITE keyword is in data file526:       ! LJGSITET indicates if LJGSITE keyword is in data file
527:       LOGICAL :: LJGSITET527:       LOGICAL :: LJGSITET  
528:       ! Parameters for LJ potential read from data file528:       ! Parameters for LJ potential read from data file
529:       DOUBLE PRECISION :: LJGSITESIGMA, LJGSITEEPS529:       DOUBLE PRECISION :: LJGSITESIGMA, LJGSITEEPS
530:       !BLN/Go parameters530:       !BLN/Go parameters
531:       LOGICAL :: GOTYPE=.FALSE.531:       LOGICAL :: GOTYPE=.FALSE.
532:       DOUBLE PRECISION :: GOFACTOR=0D0532:       DOUBLE PRECISION :: GOFACTOR=0D0
533: !533: !
534: ! DJW variables associated with the RESERVOIR keyword - as in PATHSAMPLE534: ! DJW variables associated with the RESERVOIR keyword - as in PATHSAMPLE
535: !535: !
536:       DOUBLE PRECISION, ALLOCATABLE :: EMIN(:), FVIBMIN(:), PFMIN(:), IXMIN(:),  IYMIN(:), IZMIN(:), RESPOINTS(:,:)536:       DOUBLE PRECISION, ALLOCATABLE :: EMIN(:), FVIBMIN(:), PFMIN(:), IXMIN(:),  IYMIN(:), IZMIN(:), RESPOINTS(:,:)
537:       INTEGER, ALLOCATABLE :: HORDERMIN(:)537:       INTEGER, ALLOCATABLE :: HORDERMIN(:)
538: 538: 
539:  !539:  !
540:  ! ab2111> RESERVOIR variables with Gaussing sampling540:  ! ab2111> RESERVOIR variables with Gaussing sampling 
541:  !541:  !
542:       DOUBLE PRECISION, ALLOCATABLE :: HESSEIGVC(:,:,:), HESSEIGVA(:,:), PW(:)542:       DOUBLE PRECISION, ALLOCATABLE :: HESSEIGVC(:,:,:), HESSEIGVA(:,:), PW(:)
543:       DOUBLE PRECISION :: RES_PSWAP, BETA_RES543:       DOUBLE PRECISION :: RES_PSWAP, BETA_RES
544: 544:  
545: 545: 
546: !----------------------------------------------!546: !----------------------------------------------!
547: ! hk286 > Generalised rigid body new variables !547: ! hk286 > Generalised rigid body new variables !
548: ! RELAXFQ = during final quench use atom coords instead of rigid coords !548: ! RELAXFQ = during final quench use atom coords instead of rigid coords !
549: !----------------------------------------------!549: !----------------------------------------------!
550:       LOGICAL :: RELAXFQ550:       LOGICAL :: RELAXFQ
551: 551: 
552: !----------------------------------------------!552: !----------------------------------------------!
553: ! vr274 > DMACRYS variables                    !553: ! vr274 > DMACRYS variables                    !
554: !----------------------------------------------!554: !----------------------------------------------!
571:       INTEGER :: DMOVEFREQ, NDGROUPS571:       INTEGER :: DMOVEFREQ, NDGROUPS
572:       LOGICAL :: DAMPEDGMOVET, DODGROUPMOVET=.FALSE.572:       LOGICAL :: DAMPEDGMOVET, DODGROUPMOVET=.FALSE.
573:       CHARACTER(LEN=10), ALLOCATABLE :: DATOMGROUPNAMES(:)573:       CHARACTER(LEN=10), ALLOCATABLE :: DATOMGROUPNAMES(:)
574:       INTEGER, ALLOCATABLE :: DATOMGROUPAXIS(:,:)574:       INTEGER, ALLOCATABLE :: DATOMGROUPAXIS(:,:)
575:       DOUBLE PRECISION, ALLOCATABLE :: DATOMGROUPSCALINGA(:),DATOMGROUPSCALINGB(:),DATOMGROUPSCALINGC(:),DATOMGROUPSCALINGD(:)575:       DOUBLE PRECISION, ALLOCATABLE :: DATOMGROUPSCALINGA(:),DATOMGROUPSCALINGB(:),DATOMGROUPSCALINGC(:),DATOMGROUPSCALINGD(:)
576:       DOUBLE PRECISION, ALLOCATABLE :: DATOMGROUPPROBA(:),DATOMGROUPPROBB(:),DATOMGROUPPROBC(:),DATOMGROUPPROBD(:)576:       DOUBLE PRECISION, ALLOCATABLE :: DATOMGROUPPROBA(:),DATOMGROUPPROBB(:),DATOMGROUPPROBC(:),DATOMGROUPPROBD(:)
577:       DOUBLE PRECISION, ALLOCATABLE :: DATOMGROUPATT(:,:)577:       DOUBLE PRECISION, ALLOCATABLE :: DATOMGROUPATT(:,:)
578:       LOGICAL, ALLOCATABLE :: DATOMGROUPS(:,:)578:       LOGICAL, ALLOCATABLE :: DATOMGROUPS(:,:)
579: ! hk286 - Yukawa Dumbbells579: ! hk286 - Yukawa Dumbbells
580:       LOGICAL :: DBYUKAWAT580:       LOGICAL :: DBYUKAWAT
581:       DOUBLE PRECISION :: LAMBDAYAA, LAMBDAYBB, LAMBDAYAB, YEPSFAC581:       DOUBLE PRECISION :: LAMBDAYAA, LAMBDAYBB, LAMBDAYAB, YEPSFAC 
582: ! hk286 - RESTRAIN LENGTH582: ! hk286 - RESTRAIN LENGTH
583:       LOGICAL :: RESTRAINLT583:       LOGICAL :: RESTRAINLT
584:       DOUBLE PRECISION :: RESTRAINLK584:       DOUBLE PRECISION :: RESTRAINLK
585:       DOUBLE PRECISION, ALLOCATABLE :: RESTRAINLDIST(:)585:       DOUBLE PRECISION, ALLOCATABLE :: RESTRAINLDIST(:)
586:       INTEGER :: RESTRAINLNOPAIR586:       INTEGER :: RESTRAINLNOPAIR
587:       INTEGER, ALLOCATABLE :: RESTRAINLPAIRS(:,:)587:       INTEGER, ALLOCATABLE :: RESTRAINLPAIRS(:,:)
588: ! hk286588: ! hk286
589:       LOGICAL :: GTHOMSONT589:       LOGICAL :: GTHOMSONT
590:       DOUBLE PRECISION :: GThomsonZ, GThomsonC, GThomsonC2, VUNDULOID, GTHOMSONBIND590:       DOUBLE PRECISION :: GThomsonZ, GThomsonC, GThomsonC2, VUNDULOID, GTHOMSONBIND
591:       DOUBLE PRECISION :: GTrefU, GTrefZ, GTmu, GTk, GTm, GTn, GTa, GTc591:       DOUBLE PRECISION :: GTrefU, GTrefZ, GTmu, GTk, GTm, GTn, GTa, GTc
592:       INTEGER :: GTHOMMET, GTHOMPOT, GTHOMSONBINN592:       INTEGER :: GTHOMMET, GTHOMPOT, GTHOMSONBINN
593:       DOUBLE PRECISION :: GThomsonSigma, GThomsonRho593:       DOUBLE PRECISION :: GThomsonSigma, GThomsonRho
594: 594: 
595: ! dc550595: ! dc550
596:       LOGICAL :: SELECTMOVET596:       LOGICAL :: SELECTMOVET
597:       DOUBLE PRECISION, ALLOCATABLE :: SELTRANSSTEP(:), SELROTSCALE(:), SELMOVPROB(:)597:       DOUBLE PRECISION, ALLOCATABLE :: SELTRANSSTEP(:), SELROTSCALE(:), SELMOVPROB(:)
598:       INTEGER, ALLOCATABLE :: SELMOVFREQ(:), SELBEGIN(:), SELEND(:), SELSIZE(:)598:       INTEGER, ALLOCATABLE :: SELMOVFREQ(:), SELBEGIN(:), SELEND(:), SELSIZE(:)
599:       INTEGER :: SELMOVNO599:       INTEGER :: SELMOVNO
600: 600:       
601: !QUIP variables601: !QUIP variables
602:       CHARACTER(LEN=3) :: QUIPATOMTYPE602:       CHARACTER(LEN=3) :: QUIPATOMTYPE
603:       CHARACTER(LEN=10240) :: QUIPARGSTR603:       CHARACTER(LEN=10240) :: QUIPARGSTR
604: 604: 
605: ! FEBH variables605: ! FEBH variables
606:       LOGICAL           :: FEBHT, SPARSET606:       LOGICAL           :: FEBHT, SPARSET
607:       DOUBLE PRECISION  :: FEBH_POT_ENE, FETEMP, ZERO_THRESH607:       DOUBLE PRECISION  :: FEBH_POT_ENE, FETEMP, ZERO_THRESH
608:       DOUBLE PRECISION, PARAMETER :: SMALL_DOUBLE = 1.0D-100608:       DOUBLE PRECISION, PARAMETER :: SMALL_DOUBLE = 1.0D-100
609:       DOUBLE PRECISION, ALLOCATABLE :: QENERGIES(:), QCOORDINATES(:,:), QPE(:)609:       DOUBLE PRECISION, ALLOCATABLE :: QENERGIES(:), QCOORDINATES(:,:), QPE(:)
610:       INTEGER           :: FE_FILE_UNIT610:       INTEGER           :: FE_FILE_UNIT


r31963/keywords.f 2017-02-23 15:30:38.716836982 +0000 r31962/keywords.f 2017-02-23 15:30:39.880852415 +0000
 33:      &                      ligtransstep, ligmovefreq, amchnmax, amchnmin, amchpmax, amchpmin, rotamert, rotmaxchange, 33:      &                      ligtransstep, ligmovefreq, amchnmax, amchnmin, amchpmax, amchpmin, rotamert, rotmaxchange,
 34:      &                      rotcentre, rotpselect, rotoccuw, rotcutoff, setchiralgeneric, PRMTOP, IGB, RGBMAX, CUT, 34:      &                      rotcentre, rotpselect, rotoccuw, rotcutoff, setchiralgeneric, PRMTOP, IGB, RGBMAX, CUT,
 35:      &                      SALTCON, macroiont, nmacroions, macroiondist 35:      &                      SALTCON, macroiont, nmacroions, macroiondist
 36:       USE modamber 36:       USE modamber
 37:       USE PORFUNCS 37:       USE PORFUNCS
 38:       USE MYGA_PARAMS 38:       USE MYGA_PARAMS
 39:       USE BGUPMOD 39:       USE BGUPMOD
 40:       USE GLJYMOD 40:       USE GLJYMOD
 41:       USE CHIRO_MODULE, ONLY: CHIRO_SIGMA, CHIRO_MU, CHIRO_GAMMA, CHIRO_L 41:       USE CHIRO_MODULE, ONLY: CHIRO_SIGMA, CHIRO_MU, CHIRO_GAMMA, CHIRO_L
 42:       USE CONVEX_POLYHEDRA_MODULE, ONLY: INITIALISE_POLYHEDRA, K_COMPRESS, K_OVERLAP 42:       USE CONVEX_POLYHEDRA_MODULE, ONLY: INITIALISE_POLYHEDRA, K_COMPRESS, K_OVERLAP
 43:       USE LJ_GAUSS_MOD, ONLY: LJ_GAUSS_RCUT, LJ_GAUSS_EPS, LJ_GAUSS_R0, 
 44:      &                        LJ_GAUSS_INITIALISE 
 45:       USE MBPOLMOD, ONLY: MBPOLINIT 43:       USE MBPOLMOD, ONLY: MBPOLINIT
 46:       USE SWMOD, ONLY: SWINIT, MWINIT 44:       USE SWMOD, ONLY: SWINIT, MWINIT
 47:       USE AMBER12_INTERFACE_MOD, ONLY : AMBER12_SETUP, AMBER12_GET_COORDS, AMBER12_ATOMS, 45:       USE AMBER12_INTERFACE_MOD, ONLY : AMBER12_SETUP, AMBER12_GET_COORDS, AMBER12_ATOMS,
 48:      &                                  AMBER12_RESIDUES, POPULATE_ATOM_DATA 46:      &                                  AMBER12_RESIDUES, POPULATE_ATOM_DATA
 49:       USE CHIRALITY, ONLY : CIS_TRANS_TOL 47:       USE CHIRALITY, ONLY : CIS_TRANS_TOL
 50:       USE ISO_C_BINDING, ONLY: C_NULL_CHAR 48:       USE ISO_C_BINDING, ONLY: C_NULL_CHAR
 51:       USE PARSE_POT_PARAMS, ONLY : PARSE_MGUPTA_PARAMS, PARSE_MSC_PARAMS, 49:       USE PARSE_POT_PARAMS, ONLY : PARSE_MGUPTA_PARAMS, PARSE_MSC_PARAMS, 
 52:      &     PARSE_MLJ_PARAMS 50:      &     PARSE_MLJ_PARAMS
 53:       USE ROTAMER, ONLY: ROTAMER_MOVET, ROTAMER_SCRIPT, ROTAMER_INIT 51:       USE ROTAMER, ONLY: ROTAMER_MOVET, ROTAMER_SCRIPT, ROTAMER_INIT
 54:       USE HINGE_MOVES, ONLY: HINGE_INITIALISE 52:       USE HINGE_MOVES, ONLY: HINGE_INITIALISE
 55:       USE MOLECULAR_DYNAMICS, ONLY : MDT, MD_TSTEP, MD_GAMMA, MD_NWAIT, MD_NFREQ, MD_NSTEPS 53:       USE MOLECULAR_DYNAMICS, ONLY : MDT, MD_TSTEP, MD_GAMMA, MD_NWAIT, MD_NFREQ, MD_NSTEPS
 56:       USE OPEP_INTERFACE_MOD, ONLY : OPEP_INIT 54:       USE OPEP_INTERFACE_MOD, ONLY : OPEP_INIT
 57:  55:       
 58:       IMPLICIT NONE 56:       IMPLICIT NONE
 59:  57: 
 60:       DOUBLE PRECISION, ALLOCATABLE :: MLPMEAN(:), MLQMEAN(:) 58:       DOUBLE PRECISION, ALLOCATABLE :: MLPMEAN(:), MLQMEAN(:)
 61:       INTEGER ITEM, NITEMS, LOC, LINE, NCR, NERROR, LAST, IX, J1, JP, NPCOUNT, NDUMMY, INDEX, J2, J3, J4 59:       INTEGER ITEM, NITEMS, LOC, LINE, NCR, NERROR, LAST, IX, J1, JP, NPCOUNT, NDUMMY, INDEX, J2, J3, J4
 62:       INTEGER DATA_UNIT, FUNIT 60:       INTEGER DATA_UNIT, FUNIT
 63:       INTEGER MOVABLEATOMINDEX 61:       INTEGER MOVABLEATOMINDEX
 64:       LOGICAL CAT, YESNO, PERMFILE, CONFILE 62:       LOGICAL CAT, YESNO, PERMFILE, CONFILE
 65:       COMMON /BUFINF/ ITEM, NITEMS, LOC(80), LINE, SKIPBL, CLEAR, NCR, 63:       COMMON /BUFINF/ ITEM, NITEMS, LOC(80), LINE, SKIPBL, CLEAR, NCR,
 66:      &                NERROR, ECHO, LAST, CAT 64:      &                NERROR, ECHO, LAST, CAT
 67:        DOUBLE PRECISION XX, ROH, ROM, WTHETA 65:        DOUBLE PRECISION XX, ROH, ROM, WTHETA 
 68:       LOGICAL END, SKIPBL, CLEAR, ECHO 66:       LOGICAL END, SKIPBL, CLEAR, ECHO
 69:       CHARACTER WORD*16,PBC*3,WORD2*10 67:       CHARACTER WORD*16,PBC*3,WORD2*10
 70:       DOUBLE PRECISION EAMLJA0, EAMLJBETA, EAMLJZ0, DUMMY 68:       DOUBLE PRECISION EAMLJA0, EAMLJBETA, EAMLJZ0, DUMMY
 71:       COMMON /EAMLJCOMM/ EAMLJA0, EAMLJBETA, EAMLJZ0 69:       COMMON /EAMLJCOMM/ EAMLJA0, EAMLJBETA, EAMLJZ0
 72:       DOUBLE PRECISION SLENGTH, EPS 70:       DOUBLE PRECISION SLENGTH, EPS
 73:       INTEGER NOK, NBAD 71:       INTEGER NOK, NBAD
 74:       COMMON /BSNEW/ SLENGTH, NOK, NBAD, EPS 72:       COMMON /BSNEW/ SLENGTH, NOK, NBAD, EPS
 75:       DOUBLE PRECISION EPS2, RAD, HEIGHT 73:       DOUBLE PRECISION EPS2, RAD, HEIGHT
 76:       COMMON /CAPS/ EPS2, RAD, HEIGHT 74:       COMMON /CAPS/ EPS2, RAD, HEIGHT
 77:  75: 
449:       TOSI=.FALSE.447:       TOSI=.FALSE.
450:       WELCH=.FALSE.448:       WELCH=.FALSE.
451:       SOFT_SPHERE = .FALSE.449:       SOFT_SPHERE = .FALSE.
452:       SOFT_SPHERE_NTYPEA = 0450:       SOFT_SPHERE_NTYPEA = 0
453:       BINARY=.FALSE.451:       BINARY=.FALSE.
454:       BINARY_EXAB=.FALSE.452:       BINARY_EXAB=.FALSE.
455:       SHIFTCUT=.FALSE.453:       SHIFTCUT=.FALSE.
456:       FAL=.FALSE.454:       FAL=.FALSE.
457:       FNI=.FALSE.455:       FNI=.FALSE.
458:       PHI4MODELT=.FALSE.456:       PHI4MODELT=.FALSE.
459: 457:       
460:       READMASST=.FALSE.458:       READMASST=.FALSE.
461:       SPECMASST=.FALSE.459:       SPECMASST=.FALSE.
462: 460: 
463: !     AMBER=.FALSE.461: !     AMBER=.FALSE.
464:       AMHT=.FALSE.462:       AMHT=.FALSE.
465:       NINT_AMH=1463:       NINT_AMH=1
466:       DPARAM=1.0D0464:       DPARAM=1.0D0
467:       FAKEWATER=.FALSE.465:       FAKEWATER=.FALSE.
468:       AMCUT= .FALSE.466:       AMCUT= .FALSE.
469:       MGBWATER=.FALSE.467:       MGBWATER=.FALSE.
534:       SAWTOOTH_TMAX=0.3D0532:       SAWTOOTH_TMAX=0.3D0
535:       SAWTOOTH_TFAC=1.0D0533:       SAWTOOTH_TFAC=1.0D0
536:       SAWTOOTH_SFAC=1.0D0534:       SAWTOOTH_SFAC=1.0D0
537:       SAWTOOTH_SFAC2=1.0D0535:       SAWTOOTH_SFAC2=1.0D0
538: 536: 
539: !     ds656> Generalised LJ with Yukawa537: !     ds656> Generalised LJ with Yukawa
540:       GLJY = .FALSE.538:       GLJY = .FALSE.
541:       GLJ_EXP = 6539:       GLJ_EXP = 6
542:       YUK_A = 0.0D0540:       YUK_A = 0.0D0
543:       YUK_XI = 1.0D0541:       YUK_XI = 1.0D0
544: 542:       
545: !     ds656> Molecular Dynamics543: !     ds656> Molecular Dynamics
546:       MDT = .FALSE.544:       MDT = .FALSE.
547:       MD_NSTEPS = 0545:       MD_NSTEPS = 0
548:       MD_NWAIT = 1546:       MD_NWAIT = 1
549:       MD_NFREQ = 100547:       MD_NFREQ = 100
550:       MD_GAMMA = 0.1548:       MD_GAMMA = 0.1
551:       MD_TSTEP = 0.01549:       MD_TSTEP = 0.01
552: 550: 
553:       CHRMMT=.FALSE.551:       CHRMMT=.FALSE.
554:       CHARMMTYPE=1552:       CHARMMTYPE=1
594: ! allocate ATOMSINBLOCK to avoid reading unallocated memory592: ! allocate ATOMSINBLOCK to avoid reading unallocated memory
595:       ALLOCATE(ATOMSINBLOCK(1))593:       ALLOCATE(ATOMSINBLOCK(1))
596: ! csw34> RANDOMSEED now works for CHARMM also!594: ! csw34> RANDOMSEED now works for CHARMM also!
597:       RANDOMSEEDT=.FALSE.595:       RANDOMSEEDT=.FALSE.
598: ! csw34> Dumping structures after every quench596: ! csw34> Dumping structures after every quench
599:       DUMPQUT=.FALSE.597:       DUMPQUT=.FALSE.
600: ! csw34> Dumping structures after every step (before quenching)598: ! csw34> Dumping structures after every step (before quenching)
601:       DUMPSTEPST=.FALSE.599:       DUMPSTEPST=.FALSE.
602: ! khs26> Dump best structures after every step600: ! khs26> Dump best structures after every step
603:       DUMPBESTT=.FALSE.601:       DUMPBESTT=.FALSE.
604: ! csw34> Local sampling within distance constraints602: ! csw34> Local sampling within distance constraints 
605:       LOCALSAMPLET=.FALSE.603:       LOCALSAMPLET=.FALSE. 
606:       ABTHRESH=999.99604:       ABTHRESH=999.99
607:       ACTHRESH=999.99605:       ACTHRESH=999.99
608: ! csw34> AMBER interaction energy logical606: ! csw34> AMBER interaction energy logical
609:       A9INTET=.FALSE.607:       A9INTET=.FALSE.
610:       INTERESTORE=.FALSE.608:       INTERESTORE=.FALSE.
611: ! csw34> set COLDFUSION flag to .FALSE.609: ! csw34> set COLDFUSION flag to .FALSE.
612:       COlDFUSION=.FALSE.610:       COlDFUSION=.FALSE.
613: 611: 
614:       GRADPROBLEMT=.FALSE.612:       GRADPROBLEMT=.FALSE.
615: 613: 
619:       MOVABLEATOMST=.FALSE.617:       MOVABLEATOMST=.FALSE.
620:       LIGMOVET=.FALSE.618:       LIGMOVET=.FALSE.
621:       LIGROTSCALE=0.0D0619:       LIGROTSCALE=0.0D0
622:       LIGCARTSTEP=0.0D0620:       LIGCARTSTEP=0.0D0
623:       LIGTRANSSTEP=0.0D0621:       LIGTRANSSTEP=0.0D0
624:       LIGMOVEFREQ=1622:       LIGMOVEFREQ=1
625: !  sf344> this will allow an arbitrary number of ligands to be moved separately623: !  sf344> this will allow an arbitrary number of ligands to be moved separately
626: !         as rigid units during steptaking moves.624: !         as rigid units during steptaking moves.
627: !         Keyword BLOCKMOVE to be used in conjunction with LIGMOVE and MOVABLEATOMS.625: !         Keyword BLOCKMOVE to be used in conjunction with LIGMOVE and MOVABLEATOMS.
628: !         should be useful for global optimisation of clusters of organic molecules with AMBER.626: !         should be useful for global optimisation of clusters of organic molecules with AMBER.
629:       BLOCKMOVET=.FALSE.627:       BLOCKMOVET=.FALSE. 
630:       NBLOCKS=1628:       NBLOCKS=1
631: !629: !
632: !  csw34> rotamer move stuff630: !  csw34> rotamer move stuff
633: !631: !
634:       ROTAMERT=.FALSE.632:       ROTAMERT=.FALSE.
635: !633: !
636: !  csw34> some defaults (just in case)634: !  csw34> some defaults (just in case)
637: !635: !
638:       ROTMAXCHANGE=1636:       ROTMAXCHANGE=1
639:       ROTPSELECT=0.2637:       ROTPSELECT=0.2
644: !  csw34> atom group rotation moves642: !  csw34> atom group rotation moves
645: !643: !
646:       GROUPROTT=.FALSE.644:       GROUPROTT=.FALSE.
647:       NGROUPS=0645:       NGROUPS=0
648:       GROUPROTFREQ=1646:       GROUPROTFREQ=1
649:       GROUPOFFSET=0647:       GROUPOFFSET=0
650:       GROUPROT_SUPPRESS = .FALSE.648:       GROUPROT_SUPPRESS = .FALSE.
651: ! logicals controlling move scaling649: ! logicals controlling move scaling
652:       GR_SCALEROT=.FALSE.650:       GR_SCALEROT=.FALSE.
653:       GR_SCALEPROB=.FALSE.651:       GR_SCALEPROB=.FALSE.
654: 652:         
655: !653: !
656: !  ab2111> dihedral group rotation moves654: !  ab2111> dihedral group rotation moves
657: !655: !
658:       DIHEDRALROTT=.FALSE.656:       DIHEDRALROTT=.FALSE.
659:       BGSMOVE=.FALSE.657:       BGSMOVE=.FALSE.
660:       NDIHEDRALGROUPS=0658:       NDIHEDRALGROUPS=0
661:       DIHEDRALROTFREQ=1659:       DIHEDRALROTFREQ=1
662:       DIHEDRALOFFSET=0660:       DIHEDRALOFFSET=0
663:       PHI0=-0.33 ! * pi radians (rough alpha helix values)661:       PHI0=-0.33 ! * pi radians (rough alpha helix values)
664:       PSI0=-0.25 ! * pi radians662:       PSI0=-0.25 ! * pi radians 
665:       PHIk= 0.1 !  * pi radians  (standard deviation of phi sampling)663:       PHIk= 0.1 !  * pi radians  (standard deviation of phi sampling)
666:       PSIk= 0.1 !  * pi radians664:       PSIk= 0.1 !  * pi radians
667: !665: !
668: !  csw34> HBONDMATRIX666: !  csw34> HBONDMATRIX
669: !667: !
670:       HBONDMATRIX=.FALSE.668:       HBONDMATRIX=.FALSE.
671:       NHBONDGROUPS=0669:       NHBONDGROUPS=0
672:       MAXHBONDGROUPS=1000670:       MAXHBONDGROUPS=1000
673:       HBONDTYPE='ACCEPT'671:       HBONDTYPE='ACCEPT'
674:       HBONDACCEPT=.TRUE.672:       HBONDACCEPT=.TRUE.
694: ! csw34> ROTATERIGID692: ! csw34> ROTATERIGID
695: !693: !
696:       ROTATERIGIDT=.FALSE.694:       ROTATERIGIDT=.FALSE.
697:       ROTATEFACTOR=1.0D0695:       ROTATEFACTOR=1.0D0
698:       ROTATERIGIDFREQ=1696:       ROTATERIGIDFREQ=1
699:       UPDATERIGIDREFT=.FALSE.697:       UPDATERIGIDREFT=.FALSE.
700:       HYBRIDMINT=.FALSE.698:       HYBRIDMINT=.FALSE.
701:       EPSRIGID=1.0D-3699:       EPSRIGID=1.0D-3
702:       COMPRESSRIGIDT=.FALSE.700:       COMPRESSRIGIDT=.FALSE.
703:       KCOMP_RIGID=0.0D0701:       KCOMP_RIGID=0.0D0
704:       RIGIDCOMDIST = HUGE(1.0D0)702:       RIGIDCOMDIST = HUGE(1.0D0) 
705:       CHMOVET=.FALSE.703:       CHMOVET=.FALSE.
706:       OMEGAT=.FALSE.704:       OMEGAT=.FALSE.
707:       CHSTANDARDT=.FALSE.705:       CHSTANDARDT=.FALSE.
708:       CHLOOPMODT=.FALSE.706:       CHLOOPMODT=.FALSE.
709:       CHCARTMOVET=.FALSE.707:       CHCARTMOVET=.FALSE.
710:       CHCLUSTERT=.FALSE.708:       CHCLUSTERT=.FALSE.
711:       CHNEIGHBOURT=.FALSE.709:       CHNEIGHBOURT=.FALSE.
712:       CHBBT=.FALSE.710:       CHBBT=.FALSE.
713:       CHSCT=.FALSE.711:       CHSCT=.FALSE.
714:       SECPREDT=.FALSE.712:       SECPREDT=.FALSE.
737:       LOCALPERMMAXSEP=3735:       LOCALPERMMAXSEP=3
738:       LOCALPERMCUT2=10.0D0736:       LOCALPERMCUT2=10.0D0
739:       LPERMDIST=.FALSE.737:       LPERMDIST=.FALSE.
740:       LPDGEOMDIFFTOL=0.3D0738:       LPDGEOMDIFFTOL=0.3D0
741:       PERMOPT=.FALSE.739:       PERMOPT=.FALSE.
742:       DISTOPT=.FALSE.740:       DISTOPT=.FALSE.
743:       PERMINVOPT=.FALSE.741:       PERMINVOPT=.FALSE.
744: 742: 
745:       GAMMA=1.0D0743:       GAMMA=1.0D0
746:       TUNNELT=.FALSE.744:       TUNNELT=.FALSE.
747: 745:       
748:       TWOD=.FALSE.746:       TWOD=.FALSE.
749:       COMPRESST=.FALSE.747:       COMPRESST=.FALSE.
750: 748: 
751:       MUPDATE=4749:       MUPDATE=4
752:       DGUESS=0.1D0750:       DGUESS=0.1D0
753:       INTDGUESS=0.001D0751:       INTDGUESS=0.001D0
754:       BFGS=.FALSE.752:       BFGS=.FALSE.
755:       LBFGST=.TRUE.753:       LBFGST=.TRUE.
756:       CONJG=.FALSE.754:       CONJG=.FALSE.
757:       TNT=.FALSE.755:       TNT=.FALSE.
795:       MAXBFGS=0.4D0793:       MAXBFGS=0.4D0
796: 794: 
797:       CAPSID=.FALSE.795:       CAPSID=.FALSE.
798:       STRANDT=.FALSE.796:       STRANDT=.FALSE.
799:       PAHT=.FALSE.797:       PAHT=.FALSE.
800:       TIP=.FALSE.798:       TIP=.FALSE.
801:       TTM3T=.FALSE.799:       TTM3T=.FALSE.
802:       QUADT=.FALSE.800:       QUADT=.FALSE.
803:       STOCKT=.FALSE.801:       STOCKT=.FALSE.
804:       LJCOULT=.FALSE.802:       LJCOULT=.FALSE.
805:       LJ_GAUSST=.FALSE. 
806:       COULN=0803:       COULN=0
807:       COULQ=0.0D0804:       COULQ=0.0D0
808:       COULSWAP = 0.0D0805:       COULSWAP = 0.0D0
809:       COULTEMP = 0.0D0806:       COULTEMP = 0.0D0
810:       GAYBERNET=.FALSE.807:       GAYBERNET=.FALSE.
811:       ELLIPSOIDT=.FALSE.808:       ELLIPSOIDT=.FALSE.
812:       PYGPERIODICT=.FALSE.809:       PYGPERIODICT=.FALSE.
813:       LJCAPSIDT=.FALSE.810:       LJCAPSIDT=.FALSE.
814:       PYBINARYT=.FALSE.811:       PYBINARYT=.FALSE.
815:       pyt = .false.812:       pyt = .false.
842:       DMBLMT      = .FALSE.839:       DMBLMT      = .FALSE.
843:       EFIELDT     = .FALSE.840:       EFIELDT     = .FALSE.
844:       GAYBERNEDCT = .FALSE.841:       GAYBERNEDCT = .FALSE.
845:       GBDT        = .FALSE.842:       GBDT        = .FALSE.
846:       GBDPT       = .FALSE.843:       GBDPT       = .FALSE.
847:       GEMT        = .FALSE.844:       GEMT        = .FALSE.
848:       LINRODT     = .FALSE.845:       LINRODT     = .FALSE.
849:       LWOTPT      = .FALSE.846:       LWOTPT      = .FALSE.
850:       MMRSDPT     = .FALSE.847:       MMRSDPT     = .FALSE.
851:       MORSEDPT    = .FALSE.848:       MORSEDPT    = .FALSE.
852:       MSGBT       = .FALSE.849:       MSGBT       = .FALSE. 
853:       MSTBINT     = .FALSE.850:       MSTBINT     = .FALSE.
854:       MSSTOCKT    = .FALSE.851:       MSSTOCKT    = .FALSE.
855:       MULTPAHAT   = .FALSE.852:       MULTPAHAT   = .FALSE.
856:       NCAPT       = .FALSE.853:       NCAPT       = .FALSE.
857:       NPAHT       = .FALSE.854:       NPAHT       = .FALSE.
858:       NTIPT       = .FALSE.855:       NTIPT       = .FALSE.
859:       NZERO=0                   ! jdf43>856:       NZERO=0                   ! jdf43>
860:       PAHAT       = .FALSE.857:       PAHAT       = .FALSE.
861:       PAPT        = .FALSE.858:       PAPT        = .FALSE.
862:       POLYT       = .FALSE.859:       POLYT       = .FALSE.
868:       STOCKAAT    = .FALSE.865:       STOCKAAT    = .FALSE.
869:       TDHDT       = .FALSE.866:       TDHDT       = .FALSE.
870:       WATERDCT    = .FALSE.867:       WATERDCT    = .FALSE.
871:       WATERKZT    = .FALSE.868:       WATERKZT    = .FALSE.
872: !|gd351>869: !|gd351>
873:       PATCHY = .FALSE.870:       PATCHY = .FALSE.
874:       ASAOOS = .FALSE.871:       ASAOOS = .FALSE.
875: !<gd351|872: !<gd351|
876: 873: 
877: 874: 
878: 875:        
879:       THRESHOLDT=.FALSE.876:       THRESHOLDT=.FALSE.
880:       BSWL=.FALSE.877:       BSWL=.FALSE.
881:       BSPT=.FALSE.878:       BSPT=.FALSE.
882:       MINDENSITYT=.FALSE.879:       MINDENSITYT=.FALSE.
883:       BSPTQMAX=1.0D100880:       BSPTQMAX=1.0D100
884:       BSPTQMIN=-1.0D100881:       BSPTQMIN=-1.0D100
885:       BSPTRESTART=.FALSE.882:       BSPTRESTART=.FALSE.
886:       HISTSMOOTH=.FALSE.883:       HISTSMOOTH=.FALSE.
887:       NSpline=1884:       NSpline=1
888:       EPSSPHERE=0.0D0885:       EPSSPHERE=0.0D0
1019:       GENRIGIDT = .FALSE.1016:       GENRIGIDT = .FALSE.
1020:       ATOMRIGIDCOORDT = .TRUE.1017:       ATOMRIGIDCOORDT = .TRUE.
1021:       RIGIDINIT = .FALSE.1018:       RIGIDINIT = .FALSE.
1022:       RELAXFQ = .FALSE.1019:       RELAXFQ = .FALSE.
1023:       RELAXRIGIDT = .FALSE.1020:       RELAXRIGIDT = .FALSE.
1024:       NRELAXRIGIDR = 10000000001021:       NRELAXRIGIDR = 1000000000
1025:       NRELAXRIGIDA = 10000000001022:       NRELAXRIGIDA = 1000000000
1026: 1023: 
1027:       RIGIDOPTIMROTAT = .FALSE.1024:       RIGIDOPTIMROTAT = .FALSE.
1028:       OPTIMROTAVALUES(:) = 0.0D01025:       OPTIMROTAVALUES(:) = 0.0D0
1029:       FREEZERIGIDBODYT = .FALSE.1026:       FREEZERIGIDBODYT = .FALSE.      
1030: 1027: 
1031:       AACONVERGENCET = .FALSE.1028:       AACONVERGENCET = .FALSE.
1032: 1029: 
1033: ! sn402 > Multiple potential scheme1030: ! sn402 > Multiple potential scheme
1034:       MULTIPOTT = .FALSE.1031:       MULTIPOTT = .FALSE.
1035: 1032: 
1036: !--------------------------------!1033: !--------------------------------!
1037: ! hk286 > Generalised Thomson    !1034: ! hk286 > Generalised Thomson    !
1038: !--------------------------------!1035: !--------------------------------!
1039:       GTHOMSONT = .FALSE.1036:       GTHOMSONT = .FALSE.
1088:       SUPPRESST=.FALSE.1085:       SUPPRESST=.FALSE.
1089: ! jdf43> MFET1086: ! jdf43> MFET
1090:       MFETT=.FALSE.1087:       MFETT=.FALSE.
1091: ! jdf43> POLIR1088: ! jdf43> POLIR
1092:       POLIRT=.FALSE.1089:       POLIRT=.FALSE.
1093: ! jdf43> MBPOL1090: ! jdf43> MBPOL
1094:       MBPOLT=.FALSE.1091:       MBPOLT=.FALSE.
1095:       MOLECULART=.FALSE.1092:       MOLECULART=.FALSE.
1096: ! jdf43>1093: ! jdf43>
1097:       REPMATCHT=.FALSE.1094:       REPMATCHT=.FALSE.
1098: 1095:       
1099:       UNIFORMMOVE=.FALSE.1096:       UNIFORMMOVE=.FALSE.
1100:       ORBITTOL=1.0D-31097:       ORBITTOL=1.0D-3
1101:       NOINVERSION=.FALSE.1098:       NOINVERSION=.FALSE.
1102: !1099: !
1103: ! ds656> Parallelised generalised basin-hopping1100: ! ds656> Parallelised generalised basin-hopping 
1104:       GBHT=.FALSE.1101:       GBHT=.FALSE.
1105: 1102: 
1106: ! General mixed LJ systems1103: ! General mixed LJ systems
1107:       GLJT=.FALSE.1104:       GLJT=.FALSE.
1108: ! ds656> Multicomponent LJ system (different implementation to GLJ!)1105: ! ds656> Multicomponent LJ system (different implementation to GLJ!)
1109:       MLJT=.FALSE.1106:       MLJT=.FALSE.
1110: 1107: 
1111: ! khs26> Free energy basin-hopping stuff1108: ! khs26> Free energy basin-hopping stuff
1112:       FEBHT = .FALSE.1109:       FEBHT = .FALSE.
1113:       FETEMP = 0.0D01110:       FETEMP = 0.0D0
1114: ! khs26> This requires a minimum separation between the zero and non-zero1111: ! khs26> This requires a minimum separation between the zero and non-zero
1115: ! eigenvalues for runs using free energy basin-hopping. This is based on1112: ! eigenvalues for runs using free energy basin-hopping. This is based on 
1116: ! the minimum found in quench zero.1113: ! the minimum found in quench zero.
1117:       MIN_ZERO_SEP = 0.0D01114:       MIN_ZERO_SEP = 0.0D0
1118:       MAX_ATTEMPTS = 51115:       MAX_ATTEMPTS = 5
1119: ! Use sparse hessian methods1116: ! Use sparse hessian methods
1120:       SPARSET = .FALSE.1117:       SPARSET = .FALSE.
1121:       ZERO_THRESH = 0.0D01118:       ZERO_THRESH = 0.0D0
1122: ! khs26> Rotamer move stuff1119: ! khs26> Rotamer move stuff
1123:       ROTAMER_MOVET = .FALSE.1120:       ROTAMER_MOVET = .FALSE.
1124: 1121: 
1125: 1122:         
1126:       CUDAT=.FALSE.1123:       CUDAT=.FALSE.
1127:       CUDAPOT=' '1124:       CUDAPOT=' '
1128:       CUDATIMET=.FALSE.1125:       CUDATIMET=.FALSE.
1129:       GCBHT=.FALSE.1126:       GCBHT=.FALSE.
1130:       SEMIGRAND_MUT=.FALSE.1127:       SEMIGRAND_MUT=.FALSE.
1131:       USEROT=.FALSE.1128:       USEROT=.FALSE.
1132:       GCMU=0.0D01129:       GCMU=0.0D0
1133:       GCNATOMS=11130:       GCNATOMS=1
1134:       GCINT=1001131:       GCINT=100
1135:       GCRELAX=10*GCINT1132:       GCRELAX=10*GCINT
1180:       REORDERADDT=.FALSE.1177:       REORDERADDT=.FALSE.
1181:       PYADDT=.FALSE.1178:       PYADDT=.FALSE.
1182:       PYADD2T=.FALSE.1179:       PYADD2T=.FALSE.
1183: 1180: 
1184:       DUMPMQT=.FALSE.1181:       DUMPMQT=.FALSE.
1185: 1182: 
1186: 1183: 
1187: ! OPEP stuff1184: ! OPEP stuff
1188:       OPEPT = .FALSE.1185:       OPEPT = .FALSE.
1189:       OPEP_RNAT = .FALSE.1186:       OPEP_RNAT = .FALSE.
1190: 1187:              
1191:       CALL FILE_OPEN('data', DATA_UNIT, .FALSE.)1188:       CALL FILE_OPEN('data', DATA_UNIT, .FALSE.)
1192: 1189:       
1193: !      OPEN (5,FILE='data',STATUS='OLD')1190: !      OPEN (5,FILE='data',STATUS='OLD')
1194: 1191: 
1195: !190   CALL INPUT(END,5)1192: !190   CALL INPUT(END,5)
1196: 190   CALL INPUT(END, DATA_UNIT)1193: 190   CALL INPUT(END, DATA_UNIT)
1197:       IF (.NOT. END) THEN1194:       IF (.NOT. END) THEN
1198:         CALL READU(WORD)1195:         CALL READU(WORD)
1199:       ENDIF1196:       ENDIF
1200:       IF (END .OR. WORD .EQ. 'STOP') THEN1197:       IF (END .OR. WORD .EQ. 'STOP') THEN
1201: 1198: 
1202:          IF (NPCOUNT.LT.NPAR) THEN1199:          IF (NPCOUNT.LT.NPAR) THEN
1203:             DO J1=NPCOUNT+1,NPAR1200:             DO J1=NPCOUNT+1,NPAR
1204:                STEP(J1)=STEP(1)1201:                STEP(J1)=STEP(1)
1205:                ASTEP(J1)=ASTEP(1)1202:                ASTEP(J1)=ASTEP(1)
1206:                OSTEP(J1)=OSTEP(1)1203:                OSTEP(J1)=OSTEP(1)
1207:                BLOCK(J1)=BLOCK(1)1204:                BLOCK(J1)=BLOCK(1)
1208:             ENDDO1205:             ENDDO
1209:          ENDIF1206:          ENDIF
1210: ! th368: 20-10-2009 Read parameter file containing CHARMM DYNAmics1207: ! th368: 20-10-2009 Read parameter file containing CHARMM DYNAmics 
1211: ! parameters if either CHARMM/MD or CHARMM/NEWRESTART_MD was1208: ! parameters if either CHARMM/MD or CHARMM/NEWRESTART_MD was
1212: ! requested terminate if file is not found1209: ! requested terminate if file is not found
1213: 1210: 
1214:          IF(CHMDT .OR. ( CHRMMT .AND. NEWRESTART_MD)) THEN1211:          IF(CHMDT .OR. ( CHRMMT .AND. NEWRESTART_MD)) THEN
1215: 1212: 
1216:            INQUIRE(FILE='chmd.par',EXIST=YESNO)1213:            INQUIRE(FILE='chmd.par',EXIST=YESNO)
1217: 1214: 
1218:            IF (YESNO) THEN1215:            IF (YESNO) THEN
1219:               OPEN(99,file='chmd.par')1216:               OPEN(99,file='chmd.par')
1220:               READ(99,'(A)') CHMDPAR1217:               READ(99,'(A)') CHMDPAR
1224:               STOP1221:               STOP
1225:            ENDIF1222:            ENDIF
1226:          ENDIF1223:          ENDIF
1227: ! end th368: 20-10-20091224: ! end th368: 20-10-2009
1228: 1225: 
1229:         RETURN1226:         RETURN
1230:       ENDIF1227:       ENDIF
1231: 1228: 
1232:       IF (WORD.EQ.'    '.OR.WORD.EQ.'NOTE'.OR.WORD.EQ.'COMMENT'1229:       IF (WORD.EQ.'    '.OR.WORD.EQ.'NOTE'.OR.WORD.EQ.'COMMENT'
1233:      &                  .OR.WORD.EQ.'\\'.OR.WORD.EQ."!"1230:      &                  .OR.WORD.EQ.'\\'.OR.WORD.EQ."!"
1234:      &                  .OR.WORD.EQ."#") THEN1231:      &                  .OR.WORD.EQ."#") THEN 
1235:          GOTO 1901232:          GOTO 190
1236: 1233: 
1237: !1234: !
1238: !  Remaining documented keywords should be in alphabetical order.1235: !  Remaining documented keywords should be in alphabetical order.
1239: !1236: !
1240:       ELSE IF (WORD.EQ.'2D') THEN1237:       ELSE IF (WORD.EQ.'2D') THEN
1241:          TWOD=.TRUE.1238:          TWOD=.TRUE.
1242: 1239: 
1243:       ELSE IF (WORD.EQ.'ACCEPTRATIO') THEN1240:       ELSE IF (WORD.EQ.'ACCEPTRATIO') THEN
1244:          IF (NITEMS-1.GT.NPAR) THEN1241:          IF (NITEMS-1.GT.NPAR) THEN
1317:          WRITE(MYUNIT,'(A,F14.10)') 'AMCHNMAX=  ',AMCHNMAX1314:          WRITE(MYUNIT,'(A,F14.10)') 'AMCHNMAX=  ',AMCHNMAX
1318: 1315: 
1319:       ELSE IF (WORD.EQ.'AMCHNMIN') THEN1316:       ELSE IF (WORD.EQ.'AMCHNMIN') THEN
1320:          CALL READF(AMCHNMIN)1317:          CALL READF(AMCHNMIN)
1321:          WRITE(MYUNIT,'(A,F14.10)') 'AMCHNMIN=  ',AMCHNMIN1318:          WRITE(MYUNIT,'(A,F14.10)') 'AMCHNMIN=  ',AMCHNMIN
1322: 1319: 
1323:       ELSE IF (WORD.EQ.'AMH') THEN1320:       ELSE IF (WORD.EQ.'AMH') THEN
1324:          AMHT=.TRUE.1321:          AMHT=.TRUE.
1325:          WRITE(MYUNIT,'(A)')'USING AMH ENERGIES FORCES'1322:          WRITE(MYUNIT,'(A)')'USING AMH ENERGIES FORCES'
1326:          WRITE(MYUNIT,'(A)')'CALCULATE ENERGY AND FORCE TABLES  '1323:          WRITE(MYUNIT,'(A)')'CALCULATE ENERGY AND FORCE TABLES  '
1327:          CALL WALESAMH_INITIAL1324:          CALL WALESAMH_INITIAL 
1328:       ELSE IF (WORD.EQ.'NINT_AMH') THEN1325:       ELSE IF (WORD.EQ.'NINT_AMH') THEN
1329:          CALL READI(NINT_AMH)1326:          CALL READI(NINT_AMH)
1330:          WRITE(MYUNIT,*)'NINT_AMH' , NINT_AMH1327:          WRITE(MYUNIT,*)'NINT_AMH' , NINT_AMH
1331:       ELSE IF (WORD.EQ.'HARM_AMH') THEN1328:       ELSE IF (WORD.EQ.'HARM_AMH') THEN
1332:          CALL READI(HARM_AMH)1329:          CALL READI(HARM_AMH)
1333:          WRITE(MYUNIT,*)'HARM_AMH' , HARM_AMH1330:          WRITE(MYUNIT,*)'HARM_AMH' , HARM_AMH
1334:       ELSE IF (WORD.EQ.'ANGSTROM') THEN1331:       ELSE IF (WORD.EQ.'ANGSTROM') THEN
1335:          ANGST=.TRUE.1332:          ANGST=.TRUE.
1336:       ELSE IF (WORD.EQ.'ARGON') THEN1333:       ELSE IF (WORD.EQ.'ARGON') THEN
1337:          ARGON=.TRUE.1334:          ARGON=.TRUE.
1338: 1335:   
1339:       ELSE IF (WORD.EQ.'ARM') THEN1336:       ELSE IF (WORD.EQ.'ARM') THEN
1340:          ARMT=.TRUE.1337:          ARMT=.TRUE.
1341:          IF (NITEMS.GT.1) CALL READF(ARMA)1338:          IF (NITEMS.GT.1) CALL READF(ARMA)
1342:          IF (NITEMS.GT.2) CALL READF(ARMB)1339:          IF (NITEMS.GT.2) CALL READF(ARMB)
1343: 1340: 
1344:       ELSE IF (WORD.EQ.'ARNO') THEN1341:       ELSE IF (WORD.EQ.'ARNO') THEN
1345:          ARNO=.TRUE.1342:          ARNO=.TRUE.
1346: !1343: !
1347: !  Specify resetting if the latest structure gets too close to minima saved1344: !  Specify resetting if the latest structure gets too close to minima saved
1348: !  in MSBCOORDS. Use bipartite matching and closest approach distance AVOIDDIST.1345: !  in MSBCOORDS. Use bipartite matching and closest approach distance AVOIDDIST.
1349: !  Maximum number of saved structures is specified by MAXSAVE.1346: !  Maximum number of saved structures is specified by MAXSAVE.
1350: !1347: ! 
1351:       ELSE IF (WORD.EQ.'AVOID') THEN1348:       ELSE IF (WORD.EQ.'AVOID') THEN
1352:          AVOID=.TRUE.1349:          AVOID=.TRUE.
1353:          IF (NITEMS.GT.1) CALL READF(AVOIDDIST)1350:          IF (NITEMS.GT.1) CALL READF(AVOIDDIST)
1354:          IF (NITEMS.GT.2) CALL READI(MAXSAVE)1351:          IF (NITEMS.GT.2) CALL READI(MAXSAVE)
1355:          IF (NITEMS.GT.3) CALL READA(WORD2)1352:          IF (NITEMS.GT.3) CALL READA(WORD2)
1356:          WORD2=TRIM(ADJUSTL(WORD2))1353:          WORD2=TRIM(ADJUSTL(WORD2))
1357:          IF (WORD2(1:1).EQ.'F') AVOIDRESEEDT=.FALSE.1354:          IF (WORD2(1:1).EQ.'F') AVOIDRESEEDT=.FALSE.
1358:          IF (MAXSAVE.EQ.0) AVOID=.FALSE.1355:          IF (MAXSAVE.EQ.0) AVOID=.FALSE.
1359:          IF (MAXSAVE.EQ.0) AVOIDRESEEDT=.TRUE.1356:          IF (MAXSAVE.EQ.0) AVOIDRESEEDT=.TRUE.
1360:          IF (MAXSAVE.EQ.0) MAXSAVE=10 ! to avoid division by zero later1357:          IF (MAXSAVE.EQ.0) MAXSAVE=10 ! to avoid division by zero later
1424: !            EXCHPROB = 1.D0/EXCHINT1421: !            EXCHPROB = 1.D0/EXCHINT
1425: !         ENDIF1422: !         ENDIF
1426: 1423: 
1427:       ELSE IF (WORD.EQ.'BINARY') THEN1424:       ELSE IF (WORD.EQ.'BINARY') THEN
1428:          BINARY=.TRUE.1425:          BINARY=.TRUE.
1429:          CALL READI(NTYPEA)1426:          CALL READI(NTYPEA)
1430:          CALL READF(EPSAB)1427:          CALL READF(EPSAB)
1431:          CALL READF(EPSBB)1428:          CALL READF(EPSBB)
1432:          CALL READF(SIGAB)1429:          CALL READF(SIGAB)
1433:          CALL READF(SIGBB)1430:          CALL READF(SIGBB)
1434: 1431:          
1435: !js850> every BINARY_EXAB_FRQ steps, try to exchange an A atom with a B atom1432: !js850> every BINARY_EXAB_FRQ steps, try to exchange an A atom with a B atom
1436:       ELSE IF (WORD.EQ.'BINARY_EXAB') THEN1433:       ELSE IF (WORD.EQ.'BINARY_EXAB') THEN
1437:          BINARY_EXAB=.TRUE.1434:          BINARY_EXAB=.TRUE.
1438:          CALL READI(BINARY_EXAB_FRQ)1435:          CALL READI(BINARY_EXAB_FRQ)
1439: !1436: !
1440: ! Saves every n'th structure to the file with corresponding bin label1437: ! Saves every n'th structure to the file with corresponding bin label
1441: !1438: !
1442:       ELSE IF (WORD.EQ.'BINSTRUCTURES') THEN1439:       ELSE IF (WORD.EQ.'BINSTRUCTURES') THEN
1443:          BINSTRUCTURES=.TRUE.1440:          BINSTRUCTURES=.TRUE.
1444:          CALL READI(SAVENTH)1441:          CALL READI(SAVENTH)
1445:          IF (SAVENTH.LT.1) BINSTRUCTURES=.FALSE.1442:          IF (SAVENTH.LT.1) BINSTRUCTURES=.FALSE.
1446: ! BLJCLUSTER1443: ! BLJCLUSTER 
1447:       ELSE IF (WORD.EQ.'BLJCLUSTER') THEN1444:       ELSE IF (WORD.EQ.'BLJCLUSTER') THEN
1448:          BLJCLUSTER=.TRUE.1445:          BLJCLUSTER=.TRUE.
1449:          CALL READI(NTYPEA)1446:          CALL READI(NTYPEA)
1450:          CALL READF(EPSAB)1447:          CALL READF(EPSAB)
1451:          CALL READF(EPSBB)1448:          CALL READF(EPSBB)
1452:          CALL READF(SIGAB)1449:          CALL READF(SIGAB)
1453:          CALL READF(SIGBB)1450:          CALL READF(SIGBB)
1454:          CALL READF(CUTOFF)1451:          CALL READF(CUTOFF)
1455: ! ds656> BLJCLUSTER_NOCUT1452: ! ds656> BLJCLUSTER_NOCUT 
1456:       ELSE IF (WORD.EQ.'BLJCLUSTER_NOCUT') THEN1453:       ELSE IF (WORD.EQ.'BLJCLUSTER_NOCUT') THEN
1457:          BLJCLUSTER_NOCUT=.TRUE.1454:          BLJCLUSTER_NOCUT=.TRUE.
1458:          IF (NSPECIES(0) /= 2) THEN1455:          IF (NSPECIES(0) /= 2) THEN
1459:             WRITE(MYUNIT,'(A)') 'keywords> Inconsistent species count for BLJCLUSTER_NOCUT!'1456:             WRITE(MYUNIT,'(A)') 'keywords> Inconsistent species count for BLJCLUSTER_NOCUT!'
1460:             STOP1457:             STOP
1461:          ENDIF1458:          ENDIF
1462:          CALL READI(NTYPEA)1459:          CALL READI(NTYPEA)
1463:          CALL READF(EPSAB)1460:          CALL READF(EPSAB)
1464:          CALL READF(EPSBB)1461:          CALL READF(EPSBB)
1465:          CALL READF(SIGAB)1462:          CALL READF(SIGAB)
1511:          ALLOCATE(SPECLABELS(NITEMS-1))1508:          ALLOCATE(SPECLABELS(NITEMS-1))
1512:          DO J1=1,NITEMS-11509:          DO J1=1,NITEMS-1
1513:             CALL READA(SPECLABELS(J1))1510:             CALL READA(SPECLABELS(J1))
1514:          ENDDO1511:          ENDDO
1515:       ELSE IF(WORD .EQ. 'PGSYMTOLS') THEN1512:       ELSE IF(WORD .EQ. 'PGSYMTOLS') THEN
1516:          IF(NITEMS .EQ. 4) THEN1513:          IF(NITEMS .EQ. 4) THEN
1517:             CALL READF(PGSYMTOLS(1))1514:             CALL READF(PGSYMTOLS(1))
1518:             CALL READF(PGSYMTOLS(2))1515:             CALL READF(PGSYMTOLS(2))
1519:             CALL READF(PGSYMTOLS(3))1516:             CALL READF(PGSYMTOLS(3))
1520:          ELSE1517:          ELSE
1521:             WRITE(MYUNIT,'(A)')1518:             WRITE(MYUNIT,'(A)') 
1522:      2           'keywords> PGSYMTOLS expects 4 arguments.'1519:      2           'keywords> PGSYMTOLS expects 4 arguments.'
1523:             STOP1520:             STOP
1524:          ENDIF1521:          ENDIF
1525:       ELSE IF (WORD .EQ. 'KEEPLISTS') THEN1522:       ELSE IF (WORD .EQ. 'KEEPLISTS') THEN
1526:          KEEPLISTS = .TRUE.1523:          KEEPLISTS = .TRUE.
1527:          IF(NITEMS .EQ. 3) THEN1524:          IF(NITEMS .EQ. 3) THEN
1528:             CALL READF(NBRCUT1)1525:             CALL READF(NBRCUT1)
1529:             CALL READF(NBRCUT2)1526:             CALL READF(NBRCUT2)
1530:          ELSE1527:          ELSE
1531:             WRITE(MYUNIT,'(A)') "keywords> KEEPLISTS requires 2 arguments!"1528:             WRITE(MYUNIT,'(A)') "keywords> KEEPLISTS requires 2 arguments!"
1532:             STOP1529:             STOP
1533:          ENDIF1530:          ENDIF
1534: !1531: !  
1535:       ELSE IF (WORD.EQ.'BGUPTANAME') THEN1532:       ELSE IF (WORD.EQ.'BGUPTANAME') THEN
1536:          IF (NITEMS.GT.1) THEN1533:          IF (NITEMS.GT.1) THEN
1537:              CALL READA(BGUPTANAME1)1534:              CALL READA(BGUPTANAME1)
1538:           ENDIF1535:           ENDIF
1539:           IF (NITEMS.GT.2) THEN1536:           IF (NITEMS.GT.2) THEN
1540:              CALL READA(BGUPTANAME2)1537:              CALL READA(BGUPTANAME2)
1541:           ENDIF1538:           ENDIF
1542:        ELSE IF (WORD.EQ.'BGUPTAT') THEN1539:        ELSE IF (WORD.EQ.'BGUPTAT') THEN
1543:          BGUPTAT=.TRUE.1540:          BGUPTAT=.TRUE.
1544:          IF (NSPECIES(0) /= 2) THEN1541:          IF (NSPECIES(0) /= 2) THEN
1613:          IF(NITEMS.GT.2) CALL READF(SAWTOOTH_TFAC)1610:          IF(NITEMS.GT.2) CALL READF(SAWTOOTH_TFAC)
1614:          IF(NITEMS.GT.3) CALL READI(SAWTOOTH_NREJMAX)1611:          IF(NITEMS.GT.3) CALL READI(SAWTOOTH_NREJMAX)
1615:          IF(NITEMS.GT.4) THEN1612:          IF(NITEMS.GT.4) THEN
1616:             CALL READF(SAWTOOTH_SFAC)1613:             CALL READF(SAWTOOTH_SFAC)
1617:             SAWTOOTH_SFAC2=EXP(-LOG(SAWTOOTH_SFAC)/DBLE(SAWTOOTH_NREJMAX))1614:             SAWTOOTH_SFAC2=EXP(-LOG(SAWTOOTH_SFAC)/DBLE(SAWTOOTH_NREJMAX))
1618:          ENDIF1615:          ENDIF
1619: ! ds656> Stress tensor calculation1616: ! ds656> Stress tensor calculation
1620:       ELSE IF (WORD .EQ. 'STRESS') THEN1617:       ELSE IF (WORD .EQ. 'STRESS') THEN
1621:          STRESST=.TRUE.1618:          STRESST=.TRUE.
1622:          IF(NITEMS.GT.1) CALL READI(STRESS_MODE)1619:          IF(NITEMS.GT.1) CALL READI(STRESS_MODE)
1623: ! BLN1620: ! BLN 
1624:       ELSE IF (WORD.EQ.'BLN') THEN1621:       ELSE IF (WORD.EQ.'BLN') THEN
1625:          BLNT=.TRUE.1622:          BLNT=.TRUE.
1626:          CALL READF(RK_R)1623:          CALL READF(RK_R)
1627:          CALL READF(RK_THETA)1624:          CALL READF(RK_THETA)
1628:          ALLOCATE(BEADLETTER(NATOMS),BLNSSTRUCT(NATOMS),1625:          ALLOCATE(BEADLETTER(NATOMS),BLNSSTRUCT(NATOMS),
1629:      &            LJREP_BLN(NATOMS,NATOMS),LJATT_BLN(NATOMS,NATOMS),A_BLN(NATOMS),B_BLN(NATOMS),C_BLN(NATOMS),D_BLN(NATOMS))1626:      &            LJREP_BLN(NATOMS,NATOMS),LJATT_BLN(NATOMS,NATOMS),A_BLN(NATOMS),B_BLN(NATOMS),C_BLN(NATOMS),D_BLN(NATOMS))
1630:          OPEN(UNIT=1,FILE='BLNsequence',STATUS='OLD')1627:          OPEN(UNIT=1,FILE='BLNsequence',STATUS='OLD')
1631:          READ(1,*) DUMMYCH1628:          READ(1,*) DUMMYCH
1632:          READ(1,*) LJREPBB, LJATTBB1629:          READ(1,*) LJREPBB, LJATTBB
1633:          READ(1,*) LJREPLL, LJATTLL1630:          READ(1,*) LJREPLL, LJATTLL
1651:          WRITE(MYUNIT,'(A,I8,A)') 'BLN dihedral types:'1648:          WRITE(MYUNIT,'(A,I8,A)') 'BLN dihedral types:'
1652:          WRITE(MYUNIT,'(A1)',ADVANCE='NO') BLNSSTRUCT(1:NATOMS-3)1649:          WRITE(MYUNIT,'(A1)',ADVANCE='NO') BLNSSTRUCT(1:NATOMS-3)
1653:          WRITE(MYUNIT,'(A)') ' '1650:          WRITE(MYUNIT,'(A)') ' '
1654:          WRITE(MYUNIT,'(A,2F15.5)') 'B-B LJ coefficients: ',LJREPBB, LJATTBB1651:          WRITE(MYUNIT,'(A,2F15.5)') 'B-B LJ coefficients: ',LJREPBB, LJATTBB
1655:          WRITE(MYUNIT,'(A,2F15.5)') 'L-L LJ coefficients: ',LJREPLL, LJATTLL1652:          WRITE(MYUNIT,'(A,2F15.5)') 'L-L LJ coefficients: ',LJREPLL, LJATTLL
1656:          WRITE(MYUNIT,'(A,2F15.5)') 'N-N LJ coefficients: ',LJREPNN, LJATTNN1653:          WRITE(MYUNIT,'(A,2F15.5)') 'N-N LJ coefficients: ',LJREPNN, LJATTNN
1657:          WRITE(MYUNIT,'(A,4F15.5)') 'Helix    dihedral coefficients: ',HABLN,HBBLN,HCBLN,HDBLN1654:          WRITE(MYUNIT,'(A,4F15.5)') 'Helix    dihedral coefficients: ',HABLN,HBBLN,HCBLN,HDBLN
1658:          WRITE(MYUNIT,'(A,4F15.5)') 'Extended dihedral coefficients: ',EABLN,EBBLN,ECBLN,EDBLN1655:          WRITE(MYUNIT,'(A,4F15.5)') 'Extended dihedral coefficients: ',EABLN,EBBLN,ECBLN,EDBLN
1659:          WRITE(MYUNIT,'(A,4F15.5)') 'Turn     dihedral coefficients: ',TABLN,TBBLN,TCBLN,TDBLN1656:          WRITE(MYUNIT,'(A,4F15.5)') 'Turn     dihedral coefficients: ',TABLN,TBBLN,TCBLN,TDBLN
1660:          call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,1657:          call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,
1661:      &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN,1658:      &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, 
1662:      &                       HABLN, HBBLN, HCBLN, HDBLN, EABLN, EBBLN, ECBLN, EDBLN, TABLN, TBBLN, TCBLN, TDBLN, NATOMS)1659:      &                       HABLN, HBBLN, HCBLN, HDBLN, EABLN, EBBLN, ECBLN, EDBLN, TABLN, TBBLN, TCBLN, TDBLN, NATOMS)
1663: !        call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,1660: !        call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,
1664: !    &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, NATOMS)1661: !    &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, NATOMS) 
1665: ! End BLN1662: ! End BLN 
1666: ! BLN-Go Model1663: ! BLN-Go Model 
1667:       ELSE IF (WORD.EQ.'BLNGO') THEN1664:       ELSE IF (WORD.EQ.'BLNGO') THEN
1668:          GOTYPE=.TRUE.1665:          GOTYPE=.TRUE.
1669:          BLNT=.TRUE.1666:          BLNT=.TRUE.
1670:          CALL READF(RK_R)1667:          CALL READF(RK_R)
1671:          CALL READF(RK_THETA)1668:          CALL READF(RK_THETA)
1672:          IF (NITEMS.GT.3) THEN1669:          IF (NITEMS.GT.3) THEN
1673:             CALL READF(GOFACTOR)1670:             CALL READF(GOFACTOR)
1674:          ENDIF1671:          ENDIF
1675:          ALLOCATE(BEADLETTER(NATOMS),BLNSSTRUCT(NATOMS),1672:          ALLOCATE(BEADLETTER(NATOMS),BLNSSTRUCT(NATOMS),
1676:      &            LJREP_BLN(NATOMS,NATOMS),LJATT_BLN(NATOMS,NATOMS),A_BLN(NATOMS),B_BLN(NATOMS),C_BLN(NATOMS),D_BLN(NATOMS))1673:      &            LJREP_BLN(NATOMS,NATOMS),LJATT_BLN(NATOMS,NATOMS),A_BLN(NATOMS),B_BLN(NATOMS),C_BLN(NATOMS),D_BLN(NATOMS))
1704:          WRITE(MYUNIT,'(A,2F15.5)') 'L-L LJ coefficients: ',LJREPLL, LJATTLL1701:          WRITE(MYUNIT,'(A,2F15.5)') 'L-L LJ coefficients: ',LJREPLL, LJATTLL
1705:          WRITE(MYUNIT,'(A,2F15.5)') 'N-N LJ coefficients: ',LJREPNN, LJATTNN1702:          WRITE(MYUNIT,'(A,2F15.5)') 'N-N LJ coefficients: ',LJREPNN, LJATTNN
1706:          WRITE(MYUNIT,'(A,4F15.5)') 'Helix    dihedral coefficients: ',HABLN,HBBLN,HCBLN,HDBLN1703:          WRITE(MYUNIT,'(A,4F15.5)') 'Helix    dihedral coefficients: ',HABLN,HBBLN,HCBLN,HDBLN
1707:          WRITE(MYUNIT,'(A,4F15.5)') 'Extended dihedral coefficients: ',EABLN,EBBLN,ECBLN,EDBLN1704:          WRITE(MYUNIT,'(A,4F15.5)') 'Extended dihedral coefficients: ',EABLN,EBBLN,ECBLN,EDBLN
1708:          WRITE(MYUNIT,'(A,4F15.5)') 'Turn     dihedral coefficients: ',TABLN,TBBLN,TCBLN,TDBLN1705:          WRITE(MYUNIT,'(A,4F15.5)') 'Turn     dihedral coefficients: ',TABLN,TBBLN,TCBLN,TDBLN
1709:          call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,1706:          call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,
1710:      &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN,1707:      &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN,
1711:      &                       HABLN, HBBLN, HCBLN, HDBLN, EABLN, EBBLN, ECBLN, EDBLN, TABLN, TBBLN, TCBLN, TDBLN, NATOMS)1708:      &                       HABLN, HBBLN, HCBLN, HDBLN, EABLN, EBBLN, ECBLN, EDBLN, TABLN, TBBLN, TCBLN, TDBLN, NATOMS)
1712: !        call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,1709: !        call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,
1713: !    &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, NATOMS)1710: !    &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, NATOMS)
1714: ! End BLN1711: ! End BLN 
1715: !1712: !
1716:       ELSE IF (WORD.EQ.'CHAPERONIN') THEN1713:       ELSE IF (WORD.EQ.'CHAPERONIN') THEN
1717:          CHAPERONINT=.TRUE.1714:          CHAPERONINT=.TRUE.
1718:          CALL READF(RK_R)1715:          CALL READF(RK_R)
1719:          CALL READF(RK_THETA)1716:          CALL READF(RK_THETA)
1720:          CALL READF(RADIUS_CONTAINER)1717:          CALL READF(RADIUS_CONTAINER)
1721:          CALL READF(HYDROPHOBIC)1718:          CALL READF(HYDROPHOBIC)
1722:          ALLOCATE(BEADLETTER(NATOMS),BLNSSTRUCT(NATOMS),1719:          ALLOCATE(BEADLETTER(NATOMS),BLNSSTRUCT(NATOMS),
1723:      $        LJREP_BLN(NATOMS,NATOMS),LJATT_BLN(NATOMS,NATOMS)1720:      $        LJREP_BLN(NATOMS,NATOMS),LJATT_BLN(NATOMS,NATOMS)
1724:      $        ,A_BLN(NATOMS),B_BLN(NATOMS),C_BLN(NATOMS),D_BLN(NATOMS)1721:      $        ,A_BLN(NATOMS),B_BLN(NATOMS),C_BLN(NATOMS),D_BLN(NATOMS)
1761:          WRITE(MYUNIT,'(A,4F15.5)') 'Helix    dihedral coefficients: ',HABLN,HBBLN,HCBLN,HDBLN1758:          WRITE(MYUNIT,'(A,4F15.5)') 'Helix    dihedral coefficients: ',HABLN,HBBLN,HCBLN,HDBLN
1762:          WRITE(MYUNIT,'(A,4F15.5)') 'Extended dihedral coefficients: ',EABLN,EBBLN,ECBLN,EDBLN1759:          WRITE(MYUNIT,'(A,4F15.5)') 'Extended dihedral coefficients: ',EABLN,EBBLN,ECBLN,EDBLN
1763:          WRITE(MYUNIT,'(A,4F15.5)') 'Turn     dihedral coefficients: ',TABLN,TBBLN,TCBLN,TDBLN1760:          WRITE(MYUNIT,'(A,4F15.5)') 'Turn     dihedral coefficients: ',TABLN,TBBLN,TCBLN,TDBLN
1764:          call param_arrayCHAPERONIN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN1761:          call param_arrayCHAPERONIN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN
1765:      $        ,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,LJREPBB, LJATTBB,1762:      $        ,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,LJREPBB, LJATTBB,
1766:      $        LJREPLL, LJATTLL, LJREPNN, LJATTNN,LJREPBL, LJATTBL,1763:      $        LJREPLL, LJATTLL, LJREPNN, LJATTNN,LJREPBL, LJATTBL,
1767:      $        LJREPBN, LJATTBN, LJREPLN, LJATTLN,HABLN, HBBLN, HCBLN,1764:      $        LJREPBN, LJATTBN, LJREPLN, LJATTLN,HABLN, HBBLN, HCBLN,
1768:      $        HDBLN, EABLN, EBBLN, ECBLN, EDBLN, TABLN, TBBLN, TCBLN,1765:      $        HDBLN, EABLN, EBBLN, ECBLN, EDBLN, TABLN, TBBLN, TCBLN,
1769:      $        TDBLN, HYDROPHOBIC, HYDRO_BLN, NATOMS)1766:      $        TDBLN, HYDROPHOBIC, HYDRO_BLN, NATOMS)
1770: !        call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,1767: !        call param_arrayBLN(LJREP_BLN,LJATT_BLN,A_BLN,B_BLN,C_BLN,D_BLN,BEADLETTER,BLNSSTRUCT,
1771: !    &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, NATOMS)1768: !    &                       LJREPBB, LJATTBB, LJREPLL, LJATTLL, LJREPNN, LJATTNN, NATOMS) 
1772: ! End CHAPERONIN1769: ! End CHAPERONIN 
1773:       ELSE IF (WORD.EQ.'BSMIN') THEN1770:       ELSE IF (WORD.EQ.'BSMIN') THEN
1774:          BSMIN=.TRUE.1771:          BSMIN=.TRUE.
1775:          IF (NITEMS.GT.1) CALL READF(GMAX)1772:          IF (NITEMS.GT.1) CALL READF(GMAX)
1776:          IF (NITEMS.GT.2) CALL READF(EPS)1773:          IF (NITEMS.GT.2) CALL READF(EPS)
1777:          WRITE(MYUNIT,'(A,2L5)') 'BSMIN branch RKMIN,BSMIN=',RKMIN,BSMIN1774:          WRITE(MYUNIT,'(A,2L5)') 'BSMIN branch RKMIN,BSMIN=',RKMIN,BSMIN
1778: !1775: !
1779: ! Basin-sampling.1776: ! Basin-sampling. 
1780: !1777: !
1781:       ELSE IF (WORD.EQ.'BSPT') THEN1778:       ELSE IF (WORD.EQ.'BSPT') THEN
1782:          BSPT=.TRUE.1779:          BSPT=.TRUE.
1783:          CALL READF(HISTMIN)1780:          CALL READF(HISTMIN)
1784:          CALL READF(HISTMAX)1781:          CALL READF(HISTMAX)
1785:          CALL READF(PTEMIN)1782:          CALL READF(PTEMIN)
1786:          CALL READF(PTEMAX)1783:          CALL READF(PTEMAX)
1787:          CALL READF(PTTMIN)1784:          CALL READF(PTTMIN)
1788:          CALL READF(PTTMAX)1785:          CALL READF(PTTMAX)
1789:          CALL READF(EXCHPROB)1786:          CALL READF(EXCHPROB)
1817:          ENDIF1814:          ENDIF
1818:          EXCHINT=INT(1.D0/EXCHPROB)1815:          EXCHINT=INT(1.D0/EXCHPROB)
1819: ! jdf43> the following would enforce the same average number of pair1816: ! jdf43> the following would enforce the same average number of pair
1820: ! exchanges for the single & sets exchange schemes - ss2029 prefers this1817: ! exchanges for the single & sets exchange schemes - ss2029 prefers this
1821: ! not to be the case.1818: ! not to be the case.
1822: !1819: !
1823: !         IF (PTSETS) THEN1820: !         IF (PTSETS) THEN
1824: !            EXCHINT = INT(EXCHINT*(NPAR-1)/2)1821: !            EXCHINT = INT(EXCHINT*(NPAR-1)/2)
1825: !            EXCHPROB= EXCHPROB*2.D0/(1.D0*(NPAR-1))1822: !            EXCHPROB= EXCHPROB*2.D0/(1.D0*(NPAR-1))
1826: !         ENDIF1823: !         ENDIF
1827: !1824: ! 
1828: !1825: !
1829: ! Frequency of dumping the Visits.his.n files1826: ! Frequency of dumping the Visits.his.n files
1830: !1827: ! 
1831:       ELSE IF (WORD.EQ.'BSPTDUMPFRQ') THEN1828:       ELSE IF (WORD.EQ.'BSPTDUMPFRQ') THEN
1832:          CALL READI(BSPTDUMPFRQ)1829:          CALL READI(BSPTDUMPFRQ)
1833: !1830: !
1834: ! BSPT restriction on quench energy.1831: ! BSPT restriction on quench energy.
1835: !1832: !
1836:       ELSE IF (WORD.EQ.'BSPTQRANGE') THEN1833:       ELSE IF (WORD.EQ.'BSPTQRANGE') THEN
1837:          CALL READF(BSPTQMIN)1834:          CALL READF(BSPTQMIN)
1838:          CALL READF(BSPTQMAX)1835:          CALL READF(BSPTQMAX)
1839: !1836: !
1840: ! Restart from Visits and bsptrestart files.1837: ! Restart from Visits and bsptrestart files.
1841: !1838: !
1842:       ELSE IF (WORD.EQ.'BSPTRESTART') THEN1839:       ELSE IF (WORD.EQ.'BSPTRESTART') THEN
1843:          BSPTRESTART=.TRUE.1840:          BSPTRESTART=.TRUE.
1844: !1841: !
1845: ! WL Basin-sampling.1842: ! WL Basin-sampling. 
1846: !1843: !
1847:       ELSE IF (WORD.EQ.'BSWL') THEN1844:       ELSE IF (WORD.EQ.'BSWL') THEN
1848:          BSWL=.TRUE.1845:          BSWL=.TRUE.
1849:          CALL READF(HISTMIN)1846:          CALL READF(HISTMIN)
1850:          CALL READF(HISTMAX)1847:          CALL READF(HISTMAX)
1851:          CALL READF(HISTFAC)1848:          CALL READF(HISTFAC)
1852:          CALL READI(HBINS)1849:          CALL READI(HBINS)
1853:          CALL READF(HISTFACMUL)1850:          CALL READF(HISTFACMUL)
1854:          CALL READI(TargetWL)1851:          CALL READI(TargetWL)
1855:          CALL READF(HPERCENT)1852:          CALL READF(HPERCENT)
1900:           CALL READA(SHIFTFILE)1897:           CALL READA(SHIFTFILE)
1901:           SHIFTFILE=TRIM(ADJUSTL(SHIFTFILE))1898:           SHIFTFILE=TRIM(ADJUSTL(SHIFTFILE))
1902:           IF (NITEMS .GT. 4) THEN1899:           IF (NITEMS .GT. 4) THEN
1903:             CALL READF(CSN)1900:             CALL READF(CSN)
1904:           ENDIF1901:           ENDIF
1905:           IF (NITEMS .GT. 5) THEN1902:           IF (NITEMS .GT. 5) THEN
1906:             CALL READF(CSALPHA)1903:             CALL READF(CSALPHA)
1907:           ENDIF1904:           ENDIF
1908:         ENDIF1905:         ENDIF
1909: !fh301>}}}1906: !fh301>}}}
1910: 1907:  
1911:       ELSE IF (WORD.EQ.'CAPSID') THEN1908:       ELSE IF (WORD.EQ.'CAPSID') THEN
1912:          CAPSID=.TRUE.1909:          CAPSID=.TRUE.
1913:          RIGID=.TRUE.1910:          RIGID=.TRUE.
1914:          CALL READF(RHO)1911:          CALL READF(RHO)
1915:          CALL READF(EPS2)1912:          CALL READF(EPS2)
1916:          CALL READF(RAD)1913:          CALL READF(RAD)
1917:          IF (NITEMS.GT.4) CALL READF(HEIGHT)1914:          IF (NITEMS.GT.4) CALL READF(HEIGHT)
1918: !1915: !
1919: !  The six reference site positions per capped pentagon. These need to1916: !  The six reference site positions per capped pentagon. These need to
1920: !  be multiplied by RAD, including the repulsive site!1917: !  be multiplied by RAD, including the repulsive site!
1934:          SITE(4,2)=-(Sqrt((5.0D0 - Sqrt(5.0D0))/2.))/2.0D01931:          SITE(4,2)=-(Sqrt((5.0D0 - Sqrt(5.0D0))/2.))/2.0D0
1935:          SITE(4,3)=0.0D01932:          SITE(4,3)=0.0D0
1936:          SITE(5,1)=((-1 + Sqrt(5.0D0)))/4.0D01933:          SITE(5,1)=((-1 + Sqrt(5.0D0)))/4.0D0
1937:          SITE(5,2)=-(Sqrt((5.0D0 + Sqrt(5.0D0))/2.))/2.0D01934:          SITE(5,2)=-(Sqrt((5.0D0 + Sqrt(5.0D0))/2.))/2.0D0
1938:          SITE(5,3)=0.0D01935:          SITE(5,3)=0.0D0
1939:          SITE(6,1)=0.0D01936:          SITE(6,1)=0.0D0
1940:          SITE(6,2)=0.0D01937:          SITE(6,2)=0.0D0
1941:          SITE(6,3)=HEIGHT1938:          SITE(6,3)=HEIGHT
1942:       ELSE IF (WORD.EQ.'CENTRE') THEN1939:       ELSE IF (WORD.EQ.'CENTRE') THEN
1943:          CENT=.TRUE.1940:          CENT=.TRUE.
1944: 1941:        
1945: ! csw34> When using the implicit membrane potential IMM1, we want to let1942: ! csw34> When using the implicit membrane potential IMM1, we want to let
1946: ! the molecule move in and out of the membrane (z direction), but fix it1943: ! the molecule move in and out of the membrane (z direction), but fix it
1947: ! in x and y.1944: ! in x and y.
1948: 1945:        
1949:       ELSE IF (WORD.EQ.'CENTREXY') THEN1946:       ELSE IF (WORD.EQ.'CENTREXY') THEN
1950:          CENT=.TRUE.1947:          CENT=.TRUE.
1951:          CENTXY=.TRUE.1948:          CENTXY=.TRUE.
1952: 1949: 
1953: ! csw34> SETCENTRE moves the centre of coordinates to the specified1950: ! csw34> SETCENTRE moves the centre of coordinates to the specified
1954: ! location before the initial quench is done.1951: ! location before the initial quench is done.
1955: 1952: 
1956:       ELSE IF (WORD.EQ.'SETCENTRE') THEN1953:       ELSE IF (WORD.EQ.'SETCENTRE') THEN
1957:          SETCENT=.TRUE.1954:          SETCENT=.TRUE.
1958:          IF (NITEMS.EQ.2) THEN1955:          IF (NITEMS.EQ.2) THEN
1959:             CALL READF(CENTX)1956:             CALL READF(CENTX) 
1960:          ELSE IF (NITEMS.EQ.3) THEN1957:          ELSE IF (NITEMS.EQ.3) THEN
1961:             CALL READF(CENTX)1958:             CALL READF(CENTX)
1962:             CALL READF(CENTY)1959:             CALL READF(CENTY)
1963:          ELSE IF (NITEMS.EQ.4) THEN1960:          ELSE IF (NITEMS.EQ.4) THEN
1964:             CALL READF(CENTX)1961:             CALL READF(CENTX)
1965:             CALL READF(CENTY)1962:             CALL READF(CENTY)
1966:             CALL READF(CENTZ)1963:             CALL READF(CENTZ)
1967:          ENDIF1964:          ENDIF
1968:       ELSE IF (WORD.EQ.'QCIADDREP') THEN1965:       ELSE IF (WORD.EQ.'QCIADDREP') THEN
1969:          CALL READI(QCIADDREP)1966:          CALL READI(QCIADDREP)
1972:          WRITE(MYUNIT,'(A,I6,A)') 'keywords> Adding ',QCIADDREP,' repulsive sites along constraints'1969:          WRITE(MYUNIT,'(A,I6,A)') 'keywords> Adding ',QCIADDREP,' repulsive sites along constraints'
1973:       ELSE IF (WORD.EQ.'QCINOREPINT') THEN1970:       ELSE IF (WORD.EQ.'QCINOREPINT') THEN
1974:          QCINOREPINT=.TRUE.1971:          QCINOREPINT=.TRUE.
1975:       ELSE IF (WORD.EQ.'QCIPOT') THEN1972:       ELSE IF (WORD.EQ.'QCIPOT') THEN
1976:          QCIPOTT=.TRUE.1973:          QCIPOTT=.TRUE.
1977:       ELSE IF (WORD.EQ.'QCIPOT2') THEN1974:       ELSE IF (WORD.EQ.'QCIPOT2') THEN
1978:          QCIPOTT=.TRUE.1975:          QCIPOTT=.TRUE.
1979:          QCIPOT2T=.TRUE.1976:          QCIPOT2T=.TRUE.
1980: 1977: 
1981: !       csw34> QUCENTRE moves the centre of coordinates to (0,0,0)1978: !       csw34> QUCENTRE moves the centre of coordinates to (0,0,0)
1982: !       before each step is taken.1979: !       before each step is taken. 
1983:       ELSE IF (WORD.EQ.'QUCENTRE') THEN1980:       ELSE IF (WORD.EQ.'QUCENTRE') THEN
1984:          QUCENTRE=.TRUE.1981:          QUCENTRE=.TRUE.
1985: !1982: !
1986: !  Conjugate gradient optimisation instead of default LBFGS1983: !  Conjugate gradient optimisation instead of default LBFGS
1987: !1984: !
1988:       ELSE IF (WORD.EQ.'CG') THEN1985:       ELSE IF (WORD.EQ.'CG') THEN
1989:          LBFGST=.FALSE.1986:          LBFGST=.FALSE.
1990:          CONJG=.TRUE.1987:          CONJG=.TRUE.
1991: !1988: ! 
1992: ! sf344> Start of AMBER-related keywords1989: ! sf344> Start of AMBER-related keywords 
1993: !1990: !
1994:       ELSE IF (WORD.EQ.'AMBERMDSTEPS') THEN1991:       ELSE IF (WORD.EQ.'AMBERMDSTEPS') THEN
1995:         MDSTEPT = .TRUE.1992:         MDSTEPT = .TRUE.
1996:       ELSE IF (WORD .EQ. 'AMBER12') THEN1993:       ELSE IF (WORD .EQ. 'AMBER12') THEN
1997:         AMBER12T = .TRUE.1994:         AMBER12T = .TRUE.
1998:         IF(.NOT.ALLOCATED(COORDS1)) ALLOCATE(COORDS1(3*NATOMS))1995:         IF(.NOT.ALLOCATED(COORDS1)) ALLOCATE(COORDS1(3*NATOMS))
1999:         IF(ALLOCATED(COORDS)) DEALLOCATE(COORDS)1996:         IF(ALLOCATED(COORDS)) DEALLOCATE(COORDS)
2000:         ! Read the coords from AMBER12 into COORDS1(:)1997:         ! Read the coords from AMBER12 into COORDS1(:)
2001:         CALL AMBER12_GET_COORDS(NATOMS, COORDS1(:))1998:         CALL AMBER12_GET_COORDS(NATOMS, COORDS1(:))
2002:         ALLOCATE(COORDS(3*NATOMS,NPAR))1999:         ALLOCATE(COORDS(3*NATOMS,NPAR))
2003:         DO J1=1,NPAR2000:         DO J1=1,NPAR
2004:            COORDS(:,J1) = COORDS1(:)2001:            COORDS(:,J1) = COORDS1(:)
2005:         END DO2002:         END DO
2006: 2003: 
2007:       ELSE IF (WORD.EQ.'AMBER9') THEN2004:       ELSE IF (WORD.EQ.'AMBER9') THEN
2008:         AMBERT=.TRUE.2005:         AMBERT=.TRUE.
2009:         WRITE(MYUNIT,'(A)') 'keyword> RADIUS set to 999 for AMBER9 run'2006:         WRITE(MYUNIT,'(A)') 'keyword> RADIUS set to 999 for AMBER9 run'
2010:         RADIUS=9992007:         RADIUS=999
2011: 2008:         
2012: !2009: !
2013: ! csw34> if residues are frozen with FREEZERES, call the amber routine2010: ! csw34> if residues are frozen with FREEZERES, call the amber routine
2014: ! to fill the FROZEN array correctly (in amberinterface.f)2011: ! to fill the FROZEN array correctly (in amberinterface.f) 
2015: !2012: !
2016:         IF (PERMDIST.OR.LOCALPERMDIST.OR.LPERMDIST) THEN2013:         IF (PERMDIST.OR.LOCALPERMDIST.OR.LPERMDIST) THEN
2017:           IF(NPERMSIZE(1).EQ.NATOMS) THEN2014:           IF(NPERMSIZE(1).EQ.NATOMS) THEN
2018:            PRINT '(A)','keyword> ERROR - PERMDIST is specified for AMBER, but there is no perm.allow file present'2015:            PRINT '(A)','keyword> ERROR - PERMDIST is specified for AMBER, but there is no perm.allow file present'
2019:            STOP2016:            STOP
2020:           ENDIF2017:           ENDIF
2021:         ENDIF2018:         ENDIF
2022: 2019: 
2023: ! sf344> file open unit used to conflict with AMBER's IO units (mdin opened with unit = 5),2020: ! sf344> file open unit used to conflict with AMBER's IO units (mdin opened with unit = 5),
2024: 2021: 
2058:                IF(ALLOCATED(COORDS)) DEALLOCATE(COORDS)2055:                IF(ALLOCATED(COORDS)) DEALLOCATE(COORDS)
2059:                ALLOCATE(COORDS(3*NATOM,NPAR))2056:                ALLOCATE(COORDS(3*NATOM,NPAR))
2060:                NATOMS = NATOM2057:                NATOMS = NATOM
2061:              DO J1=1,NPAR2058:              DO J1=1,NPAR
2062:                COORDS(:,J1) = COORDS1(:)2059:                COORDS(:,J1) = COORDS1(:)
2063:              END DO2060:              END DO
2064: !                natoms = natom2061: !                natoms = natom
2065: 2062: 
2066: !                WRITE(MYUNIT,*) 'sf344> keywords.f, natoms = ', natoms2063: !                WRITE(MYUNIT,*) 'sf344> keywords.f, natoms = ', natoms
2067: !        call amopen(9,AMBERPRMTOP,'O','F','R')2064: !        call amopen(9,AMBERPRMTOP,'O','F','R')
2068:         IF (FREEZERES) THEN2065:         IF (FREEZERES) THEN 
2069:            IF (UNFREEZERES) THEN2066:            IF (UNFREEZERES) THEN
2070:               CALL A9RESTOATOM(FROZENRES,FROZEN,NFREEZE,.TRUE.)2067:               CALL A9RESTOATOM(FROZENRES,FROZEN,NFREEZE,.TRUE.)
2071:            ELSE2068:            ELSE
2072:               CALL A9RESTOATOM(FROZENRES,FROZEN,NFREEZE,.FALSE.)2069:               CALL A9RESTOATOM(FROZENRES,FROZEN,NFREEZE,.FALSE.)
2073:            ENDIF2070:            ENDIF
2074:         ENDIF2071:         ENDIF
2075: 2072: 
2076:         IF(DONTMOVEREST) THEN2073:         IF(DONTMOVEREST) THEN
2077:            IF (DOMOVEREST) THEN2074:            IF (DOMOVEREST) THEN
2078:               CALL A9RESTOATOM(DONTMOVERES,DONTMOVE,NDONTMOVE,.TRUE.)2075:               CALL A9RESTOATOM(DONTMOVERES,DONTMOVE,NDONTMOVE,.TRUE.)
2100:       ELSE IF (WORD.EQ.'MD') THEN2097:       ELSE IF (WORD.EQ.'MD') THEN
2101:          MDT=.TRUE.2098:          MDT=.TRUE.
2102:          CALL READI(MD_NSTEPS)2099:          CALL READI(MD_NSTEPS)
2103:          IF(NITEMS .GT. 2) THEN2100:          IF(NITEMS .GT. 2) THEN
2104:             CALL READI(MD_NWAIT)2101:             CALL READI(MD_NWAIT)
2105:             CALL READI(MD_NFREQ)2102:             CALL READI(MD_NFREQ)
2106:          ELSE2103:          ELSE
2107:             MD_NWAIT=MD_NSTEPS2104:             MD_NWAIT=MD_NSTEPS
2108:             MD_NFREQ=12105:             MD_NFREQ=1
2109:          ENDIF2106:          ENDIF
2110: 2107:          
2111:       ELSE IF (WORD.EQ.'MDPARAMS') THEN2108:       ELSE IF (WORD.EQ.'MDPARAMS') THEN
2112:          CALL READF(MD_TSTEP)2109:          CALL READF(MD_TSTEP)
2113:          CALL READF(MD_GAMMA)2110:          CALL READF(MD_GAMMA)
2114: !2111: !
2115: ! MK ion trap2112: ! MK ion trap
2116: !2113: !
2117:       ELSE IF (WORD.EQ.'MKTRAP') THEN2114:       ELSE IF (WORD.EQ.'MKTRAP') THEN
2118:          MKTRAPT=.TRUE.2115:          MKTRAPT=.TRUE.
2119: !2116: !
2120: ! Three layer neural network (multilayer perceptron) with2117: ! Three layer neural network (multilayer perceptron) with
2127:       ELSE IF ((WORD.EQ.'MLP3').OR.(WORD.EQ.'MLPB3')) THEN2124:       ELSE IF ((WORD.EQ.'MLP3').OR.(WORD.EQ.'MLPB3')) THEN
2128:          MLP3T=.TRUE.2125:          MLP3T=.TRUE.
2129:          IF (WORD.EQ.'MLPB3') MLPB3T=.TRUE.2126:          IF (WORD.EQ.'MLPB3') MLPB3T=.TRUE.
2130:          CALL READI(MLPIN)2127:          CALL READI(MLPIN)
2131:          CALL READI(MLPHIDDEN)2128:          CALL READI(MLPHIDDEN)
2132:          CALL READI(MLPOUT)2129:          CALL READI(MLPOUT)
2133:          CALL READI(MLPDATA)2130:          CALL READI(MLPDATA)
2134:          IF (NITEMS.GT.5) CALL READF(MLPLAMBDA)2131:          IF (NITEMS.GT.5) CALL READF(MLPLAMBDA)
2135:          IF (MLPB3T) THEN2132:          IF (MLPB3T) THEN
2136:             WRITE(MYUNIT,'(A,4I8,G20.10)') 'MLP3 potential bias nodes and Nin, Nhidden, Nout, Ndata, lambda=',2133:             WRITE(MYUNIT,'(A,4I8,G20.10)') 'MLP3 potential bias nodes and Nin, Nhidden, Nout, Ndata, lambda=',
2137:      &                                   MLPIN,MLPHIDDEN,MLPOUT,MLPDATA,MLPLAMBDA2134:      &                                   MLPIN,MLPHIDDEN,MLPOUT,MLPDATA,MLPLAMBDA  
2138:             NMLP=MLPHIDDEN*(MLPIN+MLPOUT)+12135:             NMLP=MLPHIDDEN*(MLPIN+MLPOUT)+1
2139:          ELSE2136:          ELSE
2140:             WRITE(MYUNIT,'(A,4I8,G20.10)') 'MLP3 potential with Nin, Nhidden, Nout, Ndata, lambda=',2137:             WRITE(MYUNIT,'(A,4I8,G20.10)') 'MLP3 potential with Nin, Nhidden, Nout, Ndata, lambda=',
2141:      &                                   MLPIN,MLPHIDDEN,MLPOUT,MLPDATA,MLPLAMBDA2138:      &                                   MLPIN,MLPHIDDEN,MLPOUT,MLPDATA,MLPLAMBDA  
2142:             NMLP=MLPHIDDEN*(MLPIN+MLPOUT)2139:             NMLP=MLPHIDDEN*(MLPIN+MLPOUT)
2143:          ENDIF2140:          ENDIF
2144:          IF (NMLP.NE.NATOMS) THEN2141:          IF (NMLP.NE.NATOMS) THEN
2145:             PRINT '(A,2I8)', 'keywords> ERROR *** NATOMS,NMLP=',NATOMS,NMLP2142:             PRINT '(A,2I8)', 'keywords> ERROR *** NATOMS,NMLP=',NATOMS,NMLP
2146:             STOP2143:             STOP
2147:          ENDIF2144:          ENDIF
2148: 2145:    
2149:          LUNIT=GETUNIT()2146:          LUNIT=GETUNIT()
2150:          OPEN(LUNIT,FILE='MLPdata',STATUS='OLD')2147:          OPEN(LUNIT,FILE='MLPdata',STATUS='OLD')
2151:          ALLOCATE(MLPDAT(MLPDATA,MLPIN),MLPOUTCOME(MLPDATA),MLPMEAN(MLPIN))2148:          ALLOCATE(MLPDAT(MLPDATA,MLPIN),MLPOUTCOME(MLPDATA),MLPMEAN(MLPIN))
2152:          MLPMEAN(1:MLPIN)=0.0D02149:          MLPMEAN(1:MLPIN)=0.0D0
2153:          DO J1=1,MLPDATA2150:          DO J1=1,MLPDATA
2154:             READ(LUNIT,*) MLPDAT(J1,1:MLPIN),MLPOUTCOME(J1)2151:             READ(LUNIT,*) MLPDAT(J1,1:MLPIN),MLPOUTCOME(J1)
2155:             MLPOUTCOME(J1)=MLPOUTCOME(J1)+1 ! to shift the range to 1 to 42152:             MLPOUTCOME(J1)=MLPOUTCOME(J1)+1 ! to shift the range to 1 to 4
2156: !           WRITE(*,'(9G20.10,I8)') MLPDAT(J1,1:MLPIN),MLPOUTCOME(J1)2153: !           WRITE(*,'(9G20.10,I8)') MLPDAT(J1,1:MLPIN),MLPOUTCOME(J1)
2157:             DO J2=1,MLPIN2154:             DO J2=1,MLPIN
2158:                MLPMEAN(J2)=MLPMEAN(J2)+ABS(MLPDAT(J1,J2))2155:                MLPMEAN(J2)=MLPMEAN(J2)+ABS(MLPDAT(J1,J2))
2159:             ENDDO2156:             ENDDO
2160:          ENDDO2157:          ENDDO
2161:          CLOSE(LUNIT)2158:          CLOSE(LUNIT)
2162:          IF (MLPNORM) THEN2159:          IF (MLPNORM) THEN
2163:             MLPMEAN(1:MLPIN)=MLPMEAN(1:MLPIN)/MLPDATA2160:             MLPMEAN(1:MLPIN)=MLPMEAN(1:MLPIN)/MLPDATA 
2164:             WRITE(MYUNIT,'(A)') 'keyword> Rescaling inputs by mean absolute values:'2161:             WRITE(MYUNIT,'(A)') 'keyword> Rescaling inputs by mean absolute values:'
2165:             WRITE(MYUNIT,'(6G20.10)') MLPMEAN(1:MLPIN)2162:             WRITE(MYUNIT,'(6G20.10)') MLPMEAN(1:MLPIN)
2166:             DO J1=1,MLPIN2163:             DO J1=1,MLPIN
2167:                MLPDAT(1:MLPDATA,J1)=MLPDAT(1:MLPDATA,J1)/MLPMEAN(J1)2164:                MLPDAT(1:MLPDATA,J1)=MLPDAT(1:MLPDATA,J1)/MLPMEAN(J1)
2168:             ENDDO2165:             ENDDO
2169:          ENDIF2166:          ENDIF
2170:          DEALLOCATE(MLPMEAN)2167:          DEALLOCATE(MLPMEAN)
2171:          MLPDONE=.TRUE.2168:          MLPDONE=.TRUE.
2172:       ELSE IF (WORD.EQ.'MLPB3NEW') THEN2169:       ELSE IF (WORD.EQ.'MLPB3NEW') THEN
2173:          MLP3T=.TRUE.2170:          MLP3T=.TRUE.
2174:          MLPB3T=.TRUE.2171:          MLPB3T=.TRUE.
2175:          MLPB3NEWT=.TRUE.2172:          MLPB3NEWT=.TRUE.
2176:          CALL READI(MLPIN)      ! number of inputs (data items after outcome)2173:          CALL READI(MLPIN)      ! number of inputs (data items after outcome)
2177:          CALL READI(MLPSTART) ! starting position in data list, not counting outcome2174:          CALL READI(MLPSTART) ! starting position in data list, not counting outcome
2178:          CALL READI(MLPHIDDEN)2175:          CALL READI(MLPHIDDEN)
2179:          CALL READI(MLPOUT)2176:          CALL READI(MLPOUT)
2180:          CALL READI(MLPDATA)2177:          CALL READI(MLPDATA)
2181:          IF (NITEMS.GT.5) CALL READF(MLPLAMBDA)2178:          IF (NITEMS.GT.5) CALL READF(MLPLAMBDA)
2182:          WRITE(MYUNIT,'(A,5I8,G20.10)') 'MLP3 new potential bias nodes and Nin, Ninstart, Nhidden, Nout, Ndata, lambda=',2179:          WRITE(MYUNIT,'(A,5I8,G20.10)') 'MLP3 new potential bias nodes and Nin, Ninstart, Nhidden, Nout, Ndata, lambda=',
2183:      &                                MLPIN,MLPSTART,MLPHIDDEN,MLPOUT,MLPDATA,MLPLAMBDA2180:      &                                MLPIN,MLPSTART,MLPHIDDEN,MLPOUT,MLPDATA,MLPLAMBDA  
2184:          NMLP=MLPHIDDEN*(MLPIN+MLPOUT)+12181:          NMLP=MLPHIDDEN*(MLPIN+MLPOUT)+1
2185:          IF (NMLP.NE.NATOMS) THEN2182:          IF (NMLP.NE.NATOMS) THEN
2186:             PRINT '(A,2I8)', 'keywords> ERROR *** NATOMS,NMLP=',NATOMS,NMLP2183:             PRINT '(A,2I8)', 'keywords> ERROR *** NATOMS,NMLP=',NATOMS,NMLP
2187:             STOP2184:             STOP
2188:          ENDIF2185:          ENDIF
2189: 2186:    
2190:          LUNIT=GETUNIT()2187:          LUNIT=GETUNIT()
2191:          OPEN(LUNIT,FILE='MLPdata',STATUS='OLD')2188:          OPEN(LUNIT,FILE='MLPdata',STATUS='OLD')
2192:          ALLOCATE(MLPDAT(MLPDATA,MLPIN),MLPOUTCOME(MLPDATA),MLPMEAN(MLPIN))2189:          ALLOCATE(MLPDAT(MLPDATA,MLPIN),MLPOUTCOME(MLPDATA),MLPMEAN(MLPIN))
2193:          MLPMEAN(1:MLPIN)=0.0D02190:          MLPMEAN(1:MLPIN)=0.0D0
2194:          DO J1=1,MLPDATA2191:          DO J1=1,MLPDATA
2195:             READ(LUNIT,*) MLPOUTCOME(J1),(DUMMY,J2=1,MLPSTART-1),MLPDAT(J1,1:MLPIN)2192:             READ(LUNIT,*) MLPOUTCOME(J1),(DUMMY,J2=1,MLPSTART-1),MLPDAT(J1,1:MLPIN)
2196:             MLPOUTCOME(J1)=MLPOUTCOME(J1)+1 ! to shift the range to 1 to 42193:             MLPOUTCOME(J1)=MLPOUTCOME(J1)+1 ! to shift the range to 1 to 4
2197:             DO J2=1,MLPIN2194:             DO J2=1,MLPIN
2198:                MLPMEAN(J2)=MLPMEAN(J2)+ABS(MLPDAT(J1,J2))2195:                MLPMEAN(J2)=MLPMEAN(J2)+ABS(MLPDAT(J1,J2))
2199:             ENDDO2196:             ENDDO
2200:          ENDDO2197:          ENDDO
2201:          CLOSE(LUNIT)2198:          CLOSE(LUNIT)
2202:          IF (MLPNORM) THEN2199:          IF (MLPNORM) THEN
2203:             MLPMEAN(1:MLPIN)=MLPMEAN(1:MLPIN)/MLPDATA2200:             MLPMEAN(1:MLPIN)=MLPMEAN(1:MLPIN)/MLPDATA 
2204:             WRITE(MYUNIT,'(A)') 'keyword> Rescaling inputs by mean absolute values:'2201:             WRITE(MYUNIT,'(A)') 'keyword> Rescaling inputs by mean absolute values:'
2205:             WRITE(MYUNIT,'(6G20.10)') MLPMEAN(1:MLPIN)2202:             WRITE(MYUNIT,'(6G20.10)') MLPMEAN(1:MLPIN)
2206:             DO J1=1,MLPIN2203:             DO J1=1,MLPIN
2207:                MLPDAT(1:MLPDATA,J1)=MLPDAT(1:MLPDATA,J1)/MLPMEAN(J1)2204:                MLPDAT(1:MLPDATA,J1)=MLPDAT(1:MLPDATA,J1)/MLPMEAN(J1)
2208:             ENDDO2205:             ENDDO
2209:          ENDIF2206:          ENDIF
2210:          DEALLOCATE(MLPMEAN)2207:          DEALLOCATE(MLPMEAN)
2211:          MLPDONE=.TRUE.2208:          MLPDONE=.TRUE.
2212:       ELSE IF (WORD.EQ.'NOREGBIAS') THEN2209:       ELSE IF (WORD.EQ.'NOREGBIAS') THEN
2213:         NOREGBIAS=.TRUE.2210:         NOREGBIAS=.TRUE.
2370:          IF (NITEMS.GT.1) CALL READI(MONITORINT)2367:          IF (NITEMS.GT.1) CALL READI(MONITORINT)
2371: 2368: 
2372: ! sf344> keyword for taking constrained random steps of just one part of the molecule between quenches2369: ! sf344> keyword for taking constrained random steps of just one part of the molecule between quenches
2373: !        should be useful for systems with ligands docked in a protein, this would be correspond to some2370: !        should be useful for systems with ligands docked in a protein, this would be correspond to some
2374: !        partially flexible docking scheme2371: !        partially flexible docking scheme
2375:       ELSE IF(WORD.EQ.'MOVABLEATOMS') THEN2372:       ELSE IF(WORD.EQ.'MOVABLEATOMS') THEN
2376:          MOVABLEATOMST=.TRUE.2373:          MOVABLEATOMST=.TRUE.
2377:          nmovableatoms=02374:          nmovableatoms=0
2378: ! csw34> for steered minimisation, need to read in the atoms used to define the points force acts on/from2375: ! csw34> for steered minimisation, need to read in the atoms used to define the points force acts on/from
2379: !        group A is the ligand, group B is the protein. They start at -1 as groups delimited by A and B2376: !        group A is the ligand, group B is the protein. They start at -1 as groups delimited by A and B
2380: ! csw34> also, for LOCALSAMPLEing, need to define a group of atoms in the ligand (A) and two groups of atoms (B and C)2377: ! csw34> also, for LOCALSAMPLEing, need to define a group of atoms in the ligand (A) and two groups of atoms (B and C) 
2381: !        that are used to calculate distances to the ligand2378: !        that are used to calculate distances to the ligand
2382:          natomsina=-12379:          natomsina=-1
2383:          natomsinb=-12380:          natomsinb=-1
2384:          natomsinc=-12381:          natomsinc=-1
2385: !        readswitch controls which part of movableatoms we're reading in i.e.2382: !        readswitch controls which part of movableatoms we're reading in i.e. 
2386: !        M=whole ligand, A=group A, B=group B, C=group C2383: !        M=whole ligand, A=group A, B=group B, C=group C
2387:          readswitch='M'2384:          readswitch='M'
2388:            WRITE(MYUNIT,'(A)') ' keyword> list of movable atoms will be read from file <movableatoms>'2385:            WRITE(MYUNIT,'(A)') ' keyword> list of movable atoms will be read from file <movableatoms>'
2389:            OPEN(unit=222,file='movableatoms',status='old')2386:            OPEN(unit=222,file='movableatoms',status='old')
2390:                  do2387:                  do
2391:                    read (unit=222,iostat=iostatus,fmt='(A6)') check12388:                    read (unit=222,iostat=iostatus,fmt='(A6)') check1
2392:                      if (iostatus<0) then2389:                      if (iostatus<0) then
2393:                         close(222)2390:                         close(222)
2394:                         exit2391:                         exit
2395:                      else if (TRIM(ADJUSTL(check1)).EQ.'A') then2392:                      else if (TRIM(ADJUSTL(check1)).EQ.'A') then
2396:                         readswitch='A'2393:                         readswitch='A'
2397:                      else if (TRIM(ADJUSTL(check1)).EQ.'B') then2394:                      else if (TRIM(ADJUSTL(check1)).EQ.'B') then
2398:                         readswitch='B'2395:                         readswitch='B'
2399:                      else if (TRIM(ADJUSTL(check1)).EQ.'C') then2396:                      else if (TRIM(ADJUSTL(check1)).EQ.'C') then
2400:                         readswitch='C'2397:                         readswitch='C'
2401:                      end if2398:                      end if
2402:                      if (readswitch.EQ.'M') then2399:                      if (readswitch.EQ.'M') then 
2403:                         nmovableatoms = nmovableatoms + 12400:                         nmovableatoms = nmovableatoms + 1
2404:                      else if (readswitch.EQ.'A') then2401:                      else if (readswitch.EQ.'A') then
2405:                         natomsina = natomsina + 12402:                         natomsina = natomsina + 1
2406:                      else if (readswitch.EQ.'B') then2403:                      else if (readswitch.EQ.'B') then
2407:                         natomsinb = natomsinb + 12404:                         natomsinb = natomsinb + 1
2408:                      else if (readswitch.EQ.'C') then2405:                      else if (readswitch.EQ.'C') then
2409:                         natomsinc = natomsinc + 12406:                         natomsinc = natomsinc + 1
2410:                      endif2407:                      endif
2411:                  end do2408:                  end do
2412: ! setup arrays for movableatoms2409: ! setup arrays for movableatoms
2413:            if(.not.allocated(movableatomlist)) ALLOCATE(movableatomlist(nmovableatoms))2410:            if(.not.allocated(movableatomlist)) ALLOCATE(movableatomlist(nmovableatoms))
2414:            if(.not.allocated(movableatomlistlogical)) ALLOCATE(movableatomlistlogical(natoms))2411:            if(.not.allocated(movableatomlistlogical)) ALLOCATE(movableatomlistlogical(natoms))
2415:            movableatomlistlogical(:)=.false.2412:            movableatomlistlogical(:)=.false.
2416: ! setup arrays for steered minimisation groups2413: ! setup arrays for steered minimisation groups
2417:            if (natomsina.gt.0) then2414:            if (natomsina.gt.0) then 
2418:               if(.not.allocated(atomsinalist)) ALLOCATE(atomsinalist(natomsina))2415:               if(.not.allocated(atomsinalist)) ALLOCATE(atomsinalist(natomsina))
2419:               if(.not.allocated(atomsinalistlogical)) ALLOCATE(atomsinalistlogical(natoms))2416:               if(.not.allocated(atomsinalistlogical)) ALLOCATE(atomsinalistlogical(natoms))
2420:               atomsinalistlogical(:)=.false.2417:               atomsinalistlogical(:)=.false.
2421:            endif2418:            endif
2422:            if (natomsinb.gt.0) then2419:            if (natomsinb.gt.0) then 
2423:               if(.not.allocated(atomsinblist)) ALLOCATE(atomsinblist(natomsinb))2420:               if(.not.allocated(atomsinblist)) ALLOCATE(atomsinblist(natomsinb))
2424:               if(.not.allocated(atomsinblistlogical)) ALLOCATE(atomsinblistlogical(natoms))2421:               if(.not.allocated(atomsinblistlogical)) ALLOCATE(atomsinblistlogical(natoms))
2425:               atomsinblistlogical(:)=.false.2422:               atomsinblistlogical(:)=.false.
2426:            endif2423:            endif
2427:            if (natomsinc.gt.0) then2424:            if (natomsinc.gt.0) then 
2428:               if(.not.allocated(atomsinclist)) ALLOCATE(atomsinclist(natomsinc))2425:               if(.not.allocated(atomsinclist)) ALLOCATE(atomsinclist(natomsinc))
2429:               if(.not.allocated(atomsinclistlogical)) ALLOCATE(atomsinclistlogical(natoms))2426:               if(.not.allocated(atomsinclistlogical)) ALLOCATE(atomsinclistlogical(natoms))
2430:               atomsinclistlogical(:)=.false.2427:               atomsinclistlogical(:)=.false.
2431:            endif2428:            endif
2432: ! now open movableatoms for the second time to actually read in the atom indices2429: ! now open movableatoms for the second time to actually read in the atom indices
2433: ! khs26> Also check that the movable atom indices are between 1 and NATOMS, otherwise we end up2430: ! khs26> Also check that the movable atom indices are between 1 and NATOMS, otherwise we end up
2434: ! writing past array bounds in amberinterface.f2431: ! writing past array bounds in amberinterface.f
2435:            OPEN(unit=222,file='movableatoms',status='old')2432:            OPEN(unit=222,file='movableatoms',status='old')
2436:               do i=1,nmovableatoms2433:               do i=1,nmovableatoms
2437:                  read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX2434:                  read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX
2438:                  IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN2435:                  IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN
2439:                     WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'2436:                     WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'
2440:                     STOP 'Error: movableatoms contains atom indices which are out of bounds.'2437:                     STOP 'Error: movableatoms contains atom indices which are out of bounds.'
2441:                  END IF2438:                  END IF
2442:                  movableatomlist(i) = MOVABLEATOMINDEX2439:                  movableatomlist(i) = MOVABLEATOMINDEX
2443:               end do2440:               end do
2444: ! if groups for steered minimisation are specified, read them in2441: ! if groups for steered minimisation are specified, read them in
2445:            if (natomsina.gt.0) then2442:            if (natomsina.gt.0) then 
2446:               read (unit=222,iostat=iostatus,fmt='(A6)') check12443:               read (unit=222,iostat=iostatus,fmt='(A6)') check1
2447:                  do i=1,natomsina2444:                  do i=1,natomsina
2448:                     read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX2445:                     read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX
2449:                     IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN2446:                     IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN
2450:                        WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'2447:                        WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'
2451:                        STOP 'Error: movableatoms contains atom indices which are out of bounds.'2448:                        STOP 'Error: movableatoms contains atom indices which are out of bounds.'
2452:                     END IF2449:                     END IF
2453:                     atomsinalist(i) = MOVABLEATOMINDEX2450:                     atomsinalist(i) = MOVABLEATOMINDEX
2454:                  end do2451:                  end do
2455:            endif2452:            endif
2456:            if (natomsinb.gt.0) then2453:            if (natomsinb.gt.0) then 
2457:               read (unit=222,iostat=iostatus,fmt='(A6)') check12454:               read (unit=222,iostat=iostatus,fmt='(A6)') check1
2458:                  do i=1,natomsinb2455:                  do i=1,natomsinb
2459:                     read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX2456:                     read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX
2460:                     IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN2457:                     IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN
2461:                        WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'2458:                        WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'
2462:                        STOP 'Error: movableatoms contains atom indices which are out of bounds.'2459:                        STOP 'Error: movableatoms contains atom indices which are out of bounds.'
2463:                     END IF2460:                     END IF
2464:                     atomsinblist(i) = MOVABLEATOMINDEX2461:                     atomsinblist(i) = MOVABLEATOMINDEX
2465:                  end do2462:                  end do
2466:            endif2463:            endif
2467:            if (natomsinc.gt.0) then2464:            if (natomsinc.gt.0) then 
2468:               read (unit=222,iostat=iostatus,fmt='(A6)') check12465:               read (unit=222,iostat=iostatus,fmt='(A6)') check1
2469:                  do i=1,natomsinc2466:                  do i=1,natomsinc
2470:                     read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX2467:                     read (unit=222,iostat=iostatus,fmt='(I6)') MOVABLEATOMINDEX
2471:                     IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN2468:                     IF ((MOVABLEATOMINDEX .LE. 0) .OR. (MOVABLEATOMINDEX .GT. NATOMS)) THEN
2472:                        WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'2469:                        WRITE(MYUNIT, '(A,I6,A,I6,A)') 'The index ', MOVABLEATOMINDEX, ' is out of bounds (NATOMS = ', NATOMS, ').'
2473:                        STOP 'Error: movableatoms contains atom indices which are out of bounds.'2470:                        STOP 'Error: movableatoms contains atom indices which are out of bounds.'
2474:                     END IF2471:                     END IF
2475:                     atomsinclist(i) = MOVABLEATOMINDEX2472:                     atomsinclist(i) = MOVABLEATOMINDEX
2476:                  end do2473:                  end do
2477:            endif2474:            endif
2492:               do i=1,natomsinc2489:               do i=1,natomsinc
2493:                  atomsinclistlogical(atomsinclist(i))=.true.2490:                  atomsinclistlogical(atomsinclist(i))=.true.
2494:               end do2491:               end do
2495:            endif2492:            endif
2496: ! write some output for the user2493: ! write some output for the user
2497:            WRITE(MYUNIT,'(A15,I6,A46)') ' keyword> ligand defined with ',nmovableatoms,' atoms'2494:            WRITE(MYUNIT,'(A15,I6,A46)') ' keyword> ligand defined with ',nmovableatoms,' atoms'
2498:            IF(natomsina.GT.0) WRITE(MYUNIT,'(A10,I6,A64)') ' keyword> ',natomsina,' atoms in group A'2495:            IF(natomsina.GT.0) WRITE(MYUNIT,'(A10,I6,A64)') ' keyword> ',natomsina,' atoms in group A'
2499:            IF(natomsinb.GT.0) WRITE(MYUNIT,'(A10,I6,A63)') ' keyword> ',natomsinb,' atoms in group B'2496:            IF(natomsinb.GT.0) WRITE(MYUNIT,'(A10,I6,A63)') ' keyword> ',natomsinb,' atoms in group B'
2500:            IF(natomsinc.GT.0) WRITE(MYUNIT,'(A10,I6,A63)') ' keyword> ',natomsinc,' atoms in group C'2497:            IF(natomsinc.GT.0) WRITE(MYUNIT,'(A10,I6,A63)') ' keyword> ',natomsinc,' atoms in group C'
2501: 2498: 
2502: ! sf344> model for macroions. Syntax: MACROION nmacroions macroiondist2499: ! sf344> model for macroions. Syntax: MACROION nmacroions macroiondist 
2503: !        Should be used in conjunction with LIGMOVE2500: !        Should be used in conjunction with LIGMOVE                     
2504:       ELSE IF(WORD.EQ.'MACROION') THEN2501:       ELSE IF(WORD.EQ.'MACROION') THEN
2505:         MACROIONT=.TRUE.2502:         MACROIONT=.TRUE.
2506:         BLOCKMOVET=.TRUE.2503:         BLOCKMOVET=.TRUE.
2507:         CALL READI(nmacroions)   ! number of macroions in the system (the topology file should contain these first!)2504:         CALL READI(nmacroions)   ! number of macroions in the system (the topology file should contain these first!)
2508:         CALL READF(macroiondist) ! distance threshold for determining bound pairs of macroions-counterions in TAKESTEPAMBER2505:         CALL READF(macroiondist) ! distance threshold for determining bound pairs of macroions-counterions in TAKESTEPAMBER
2509:         WRITE(MYUNIT,'(A15,I6,A46)') ' keyword> ligand defined with ',nmovableatoms,' atoms'2506:         WRITE(MYUNIT,'(A15,I6,A46)') ' keyword> ligand defined with ',nmovableatoms,' atoms'
2510: ! sf344> keyword for taking moves between quenches in which one part of the molecule is moved2507: ! sf344> keyword for taking moves between quenches in which one part of the molecule is moved
2511: ! csw34> updated on 29th September 2009 to allow local cartesian moves2508: ! csw34> updated on 29th September 2009 to allow local cartesian moves 
2512:       ELSE IF(WORD.EQ.'LIGMOVE') THEN2509:       ELSE IF(WORD.EQ.'LIGMOVE') THEN
2513:         LIGMOVET=.TRUE.2510:         LIGMOVET=.TRUE.
2514:         IF (NITEMS.GT.1) THEN2511:         IF (NITEMS.GT.1) THEN
2515:            CALL READF(ligrotscale)2512:            CALL READF(ligrotscale)
2516:         ENDIF2513:         ENDIF
2517:         IF (NITEMS.GT.2) THEN2514:         IF (NITEMS.GT.2) THEN
2518:            CALL READF(ligcartstep)2515:            CALL READF(ligcartstep)
2519:         ENDIF2516:         ENDIF
2520:         IF (NITEMS.GT.3) THEN2517:         IF (NITEMS.GT.3) THEN
2521:            CALL READF(ligtransstep)2518:            CALL READF(ligtransstep)
2522:         ENDIF2519:         ENDIF
2523:         IF (NITEMS.GT.4) THEN2520:         IF (NITEMS.GT.4) THEN
2524:            CALL READI(ligmovefreq)2521:            CALL READI(ligmovefreq)
2525: ! csw34> to prevent an arithmetic exception (divide by 0), we need to2522: ! csw34> to prevent an arithmetic exception (divide by 0), we need to
2526: ! check that the frequency of ligand moves is > 0. Otherwise, disable2523: ! check that the frequency of ligand moves is > 0. Otherwise, disable
2527: ! the moves.2524: ! the moves.
2528:            IF(ligmovefreq.EQ.0) THEN2525:            IF(ligmovefreq.EQ.0) THEN 
2529:               LIGMOVET=.FALSE.2526:               LIGMOVET=.FALSE.
2530:               WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of LIGMOVE moves set to 0 - moves DISABLED!'2527:               WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of LIGMOVE moves set to 0 - moves DISABLED!'
2531:            ENDIF2528:            ENDIF
2532:         ENDIF2529:         ENDIF
2533: 2530: 
2534: ! csw34> some user info about ligand moves2531: ! csw34> some user info about ligand moves 
2535:         IF (ligrotscale.gt.0) THEN2532:         IF (ligrotscale.gt.0) THEN
2536:            WRITE(MYUNIT,'(A)') ' keyword> one part of the molecule (ligand) will be randomly rotated during MC steptaking moves'2533:            WRITE(MYUNIT,'(A)') ' keyword> one part of the molecule (ligand) will be randomly rotated during MC steptaking moves'
2537:            WRITE(MYUNIT,'(A,G10.3)') ' keyword> ligand rotations scaled will be scaled by ',ligrotscale2534:            WRITE(MYUNIT,'(A,G10.3)') ' keyword> ligand rotations scaled will be scaled by ',ligrotscale 
2538:         ENDIF 
2539:         IF (ligcartstep.gt.0) THEN 
2540:            WRITE(MYUNIT,'(A,G10.3,A)') ' keyword> cartesian perturbations of up to ',ligcartstep,' will be applied to the ligand' 
2541:         ENDIF2535:         ENDIF
2542: ! sf344> block moves. To be used for rigid body moves of multiple ligands or small clusters of molecules. Rigid body move2536:         IF (ligcartstep.gt.0) THEN 
 2537:            WRITE(MYUNIT,'(A,G10.3,A)') ' keyword> cartesian perturbations of up to ',ligcartstep,' will be applied to the ligand' 
 2538:         ENDIF 
 2539: ! sf344> block moves. To be used for rigid body moves of multiple ligands or small clusters of molecules. Rigid body move 
2543: !        parameters will be set using LIGMOVE. Syntax: BLOCKMOVE nblocks block1 block2 ... blockN. The file movableatomslist2540: !        parameters will be set using LIGMOVE. Syntax: BLOCKMOVE nblocks block1 block2 ... blockN. The file movableatomslist
2544: !        has to contain all atom indices, and these will be separated into nblocks parts, each block containing block_i number2541: !        has to contain all atom indices, and these will be separated into nblocks parts, each block containing block_i number
2545: !        of atoms.2542: !        of atoms.
2546:       ELSE IF(WORD.EQ.'BLOCKMOVE') THEN2543:       ELSE IF(WORD.EQ.'BLOCKMOVE') THEN
2547:         BLOCKMOVET=.TRUE.2544:         BLOCKMOVET=.TRUE.
2548:         CALL READI(NBLOCKS)2545:         CALL READI(NBLOCKS)
2549:         DEALLOCATE(ATOMSINBLOCK)2546:         DEALLOCATE(ATOMSINBLOCK)
2550:         ALLOCATE(ATOMSINBLOCK(NBLOCKS))2547:         ALLOCATE(ATOMSINBLOCK(NBLOCKS))
2551:         DO J1=1,NBLOCKS2548:         DO J1=1,NBLOCKS
2552:            CALL READI(ATOMSINBLOCK(J1))2549:            CALL READI(ATOMSINBLOCK(J1))
2567:          IF (NITEMS>1) CALL READI(DUMPINTEOSFREQ)2564:          IF (NITEMS>1) CALL READI(DUMPINTEOSFREQ)
2568:       ELSE IF (WORD.eq.'DUMPSTRUCTURES') THEN2565:       ELSE IF (WORD.eq.'DUMPSTRUCTURES') THEN
2569:         DUMPSTRUCTURES=.TRUE.2566:         DUMPSTRUCTURES=.TRUE.
2570:         WRITE(MYUNIT,'(A)') ' keywords> Final structures will be dumped in different formats (.rst, .xyz, .pdb)'2567:         WRITE(MYUNIT,'(A)') ' keywords> Final structures will be dumped in different formats (.rst, .xyz, .pdb)'
2571:       ELSE IF (WORD.eq.'DUMPMIN') THEN2568:       ELSE IF (WORD.eq.'DUMPMIN') THEN
2572:         DUMPMINT=.TRUE.2569:         DUMPMINT=.TRUE.
2573:         WRITE(MYUNIT,'(A)') ' keywords> The SAVE lowest minima will be dumped every DUMPINT steps as dumpmin.x files'2570:         WRITE(MYUNIT,'(A)') ' keywords> The SAVE lowest minima will be dumped every DUMPINT steps as dumpmin.x files'
2574:       ELSE IF (WORD.eq.'RANDOMSEED') THEN2571:       ELSE IF (WORD.eq.'RANDOMSEED') THEN
2575:         WRITE(MYUNIT,'(A)') ' keywords> The random number generator for the random steptaking moves will be seeded with system time'2572:         WRITE(MYUNIT,'(A)') ' keywords> The random number generator for the random steptaking moves will be seeded with system time'
2576:         RANDOMSEEDT=.TRUE.2573:         RANDOMSEEDT=.TRUE.
2577: ! khs26> This writes the energy decomposition for AMBER2574: ! khs26> This writes the energy decomposition for AMBER 
2578:       ELSE IF (WORD.eq.'ENERGY_DECOMP') THEN2575:       ELSE IF (WORD.eq.'ENERGY_DECOMP') THEN
2579:         WRITE(MYUNIT,'(A)') ' keywords> After each quench, the energy decomposition will also be printed.'2576:         WRITE(MYUNIT,'(A)') ' keywords> After each quench, the energy decomposition will also be printed.'
2580:         ENERGY_DECOMPT=.TRUE.2577:         ENERGY_DECOMPT=.TRUE.
2581:       ELSE IF (WORD.EQ.'CHANGEACCEPT') THEN2578:       ELSE IF (WORD.EQ.'CHANGEACCEPT') THEN
2582:          CALL READI(IX)2579:          CALL READI(IX)
2583:          NACCEPT=IX2580:          NACCEPT=IX
2584: 2581: 
2585: ! js850> if DUMPUNIQUE then dump all unique structures to file dumpunique as2582: ! js850> if DUMPUNIQUE then dump all unique structures to file dumpunique as
2586: ! soon as they are found.  The test for uniqueness is by difference in energy2583: ! soon as they are found.  The test for uniqueness is by difference in energy
2587: ! using the criterion ECONV.  Only the last structure is tested against, so the2584: ! using the criterion ECONV.  Only the last structure is tested against, so the
2603:          YESNO=.FALSE.2600:          YESNO=.FALSE.
2604:          INQUIRE(FILE='AMBGMINintE.sh',EXIST=YESNO)2601:          INQUIRE(FILE='AMBGMINintE.sh',EXIST=YESNO)
2605:          IF (YESNO) THEN2602:          IF (YESNO) THEN
2606:             A9INTET=.TRUE.2603:             A9INTET=.TRUE.
2607:             WRITE(MYUNIT,'(A)') ' keyword> The interaction enthalpy to the specified residue will be calculated after each quench'2604:             WRITE(MYUNIT,'(A)') ' keyword> The interaction enthalpy to the specified residue will be calculated after each quench'
2608:          ELSE2605:          ELSE
2609:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: NEED AMBGMINintE.sh SCRIPT TO USE A9INTE - see www-wales.ch.cam.ac.uk/software'2606:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: NEED AMBGMINintE.sh SCRIPT TO USE A9INTE - see www-wales.ch.cam.ac.uk/software'
2610:             STOP2607:             STOP
2611:          ENDIF2608:          ENDIF
2612: 2609: 
2613: ! csw34> FREEZEGROUP2610: ! csw34> FREEZEGROUP 
2614: ! FREEZEGROUP lets you freeze all atoms within or beyond a radius2611: ! FREEZEGROUP lets you freeze all atoms within or beyond a radius
2615:       ELSE IF (WORD.EQ.'FREEZEGROUP') THEN2612:       ELSE IF (WORD.EQ.'FREEZEGROUP') THEN
2616:          FREEZE=.TRUE.2613:          FREEZE=.TRUE.
2617:          FREEZEGROUPT=.TRUE.2614:          FREEZEGROUPT=.TRUE.
2618:          CALL READI(GROUPCENTRE)2615:          CALL READI(GROUPCENTRE)
2619:          CALL READF(GROUPRADIUS)2616:          CALL READF(GROUPRADIUS)
2620:          IF(NITEMS.GT.3) CALL READA(FREEZEGROUPTYPE)2617:          IF(NITEMS.GT.3) CALL READA(FREEZEGROUPTYPE)
2621: 2618: 
2622: ! csw34> Rotamer moves2619: ! csw34> Rotamer moves 
2623:       ELSE IF (WORD.EQ.'ROTAMER') THEN2620:       ELSE IF (WORD.EQ.'ROTAMER') THEN
2624:          YESNO=.FALSE.2621:          YESNO=.FALSE.
2625:          INQUIRE(FILE='PdbRotamerSearch',EXIST=YESNO)2622:          INQUIRE(FILE='PdbRotamerSearch',EXIST=YESNO)
2626:          IF (YESNO) THEN2623:          IF (YESNO) THEN
2627:             ROTAMERT=.TRUE.2624:             ROTAMERT=.TRUE.
2628:             WRITE(MYUNIT,'(A)') ' keyword> AMBER rotamer moves enabled'2625:             WRITE(MYUNIT,'(A)') ' keyword> AMBER rotamer moves enabled'
2629:          ELSE2626:          ELSE
2630:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: NEED PdbRotamerSearch TO USE ROTAMER - see www-wales.ch.cam.ac.uk/software'2627:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: NEED PdbRotamerSearch TO USE ROTAMER - see www-wales.ch.cam.ac.uk/software'
2631:             STOP2628:             STOP
2632:          ENDIF2629:          ENDIF
2657: 2654: 
2658:          CHX(1)=13.13d13 ! this way we will tell CHARMM to save it's coords into CH. arrays; otherwise it will2655:          CHX(1)=13.13d13 ! this way we will tell CHARMM to save it's coords into CH. arrays; otherwise it will
2659:                          ! use input.crd only which is the default now2656:                          ! use input.crd only which is the default now
2660:          CALL FLUSH(MYUNIT)2657:          CALL FLUSH(MYUNIT)
2661:          CALL CHSETUP(CHX,CHY,CHZ,CHMASS,NATOM,TOPFILE,PARFILE,DATA_UNIT)2658:          CALL CHSETUP(CHX,CHY,CHZ,CHMASS,NATOM,TOPFILE,PARFILE,DATA_UNIT)
2662:          CALL FLUSH(MYUNIT)2659:          CALL FLUSH(MYUNIT)
2663:          CALL CHSETZSYMATMASS2660:          CALL CHSETZSYMATMASS
2664:          CALL CHALLOCATE(NATOMS)2661:          CALL CHALLOCATE(NATOMS)
2665: ! jmc49>         CALL CHSETDIHE2662: ! jmc49>         CALL CHSETDIHE
2666: ! Moved the above call to CHSETDIHE to below the "IF (FREEZERES) CALL CHRESTOATOM(FROZENRES,FROZEN)" below.2663: ! Moved the above call to CHSETDIHE to below the "IF (FREEZERES) CALL CHRESTOATOM(FROZENRES,FROZEN)" below.
2667: ! Necessary for the case of freezing residues when the MC moves are made in internal coordinates, and2664: ! Necessary for the case of freezing residues when the MC moves are made in internal coordinates, and 
2668: ! inconsequential otherwise.2665: ! inconsequential otherwise.
2669: 2666: 
2670: ! csw34> If we're freezing RESIDUES, fill the FROZEN array with atoms that are2667: ! csw34> If we're freezing RESIDUES, fill the FROZEN array with atoms that are
2671: ! within the frozen residues. This requires info from a CHARMM routine2668: ! within the frozen residues. This requires info from a CHARMM routine
2672: ! and so will be done in charmmgmin.src2669: ! and so will be done in charmmgmin.src
2673: 2670: 
2674:          IF (FREEZERES) THEN2671:          IF (FREEZERES) THEN 
2675:             IF (UNFREEZERES) THEN2672:             IF (UNFREEZERES) THEN
2676:                CALL CHRESTOATOM(FROZENRES,FROZEN,NFREEZE,.TRUE.)2673:                CALL CHRESTOATOM(FROZENRES,FROZEN,NFREEZE,.TRUE.)
2677:             ELSE2674:             ELSE
2678:                CALL CHRESTOATOM(FROZENRES,FROZEN,NFREEZE,.FALSE.)2675:                CALL CHRESTOATOM(FROZENRES,FROZEN,NFREEZE,.FALSE.)
2679:             ENDIF2676:             ENDIF
2680:          ENDIF2677:          ENDIF
2681: 2678: 
2682:          IF(DONTMOVEREST) THEN2679:          IF(DONTMOVEREST) THEN
2683:             IF (DOMOVEREST) THEN2680:             IF (DOMOVEREST) THEN
2684:                CALL CHRESTOATOM(DONTMOVERES,DONTMOVE,NDONTMOVE,.TRUE.)2681:                CALL CHRESTOATOM(DONTMOVERES,DONTMOVE,NDONTMOVE,.TRUE.)
2685:             ELSE2682:             ELSE
2686:                CALL CHRESTOATOM(DONTMOVERES,DONTMOVE,NDONTMOVE,.FALSE.)2683:                CALL CHRESTOATOM(DONTMOVERES,DONTMOVE,NDONTMOVE,.FALSE.)
2687:             ENDIF2684:             ENDIF
2688:          ENDIF2685:          ENDIF
2689:          CALL CHSETDIHE2686:          CALL CHSETDIHE
2690: 2687:          
2691:          IF (NATOM /= NATOMS) THEN2688:          IF (NATOM /= NATOMS) THEN
2692:             WRITE(MYUNIT,'(A)') 'No. of atoms in "input.crd" and file specified in CHARMM part of data conflict'2689:             WRITE(MYUNIT,'(A)') 'No. of atoms in "input.crd" and file specified in CHARMM part of data conflict'
2693:             WRITE(MYUNIT,'(A,2I8)') 'NATOM,NATOMS=',NATOM, NATOMS2690:             WRITE(MYUNIT,'(A,2I8)') 'NATOM,NATOMS=',NATOM, NATOMS
2694:             CALL EXIT(10)2691:             CALL EXIT(10)
2695:          ENDIF2692:          ENDIF
2696:          IF (MPIT) THEN2693:          IF (MPIT) THEN
2697:             DO J1=1,NATOMS2694:             DO J1=1,NATOMS
2698:                COORDS(3*(J1-1)+1,MYNODE+1)=CHX(J1)2695:                COORDS(3*(J1-1)+1,MYNODE+1)=CHX(J1)
2699:                COORDS(3*(J1-1)+2,MYNODE+1)=CHY(J1)2696:                COORDS(3*(J1-1)+2,MYNODE+1)=CHY(J1)
2700:                COORDS(3*(J1-1)+3,MYNODE+1)=CHZ(J1)2697:                COORDS(3*(J1-1)+3,MYNODE+1)=CHZ(J1)
2759: ! MD for CHARMM for the generation of new structures.2756: ! MD for CHARMM for the generation of new structures.
2760: !2757: !
2761:       ELSE IF (WORD.EQ.'CHMD') THEN2758:       ELSE IF (WORD.EQ.'CHMD') THEN
2762:          CHMDT=.TRUE.2759:          CHMDT=.TRUE.
2763:          INQUIRE(FILE='chmd.par',EXIST=YESNO)2760:          INQUIRE(FILE='chmd.par',EXIST=YESNO)
2764:          IF (YESNO) THEN2761:          IF (YESNO) THEN
2765:             OPEN(99,file='chmd.par')2762:             OPEN(99,file='chmd.par')
2766:             READ(99,'(A)') CHMDPAR2763:             READ(99,'(A)') CHMDPAR
2767:             CLOSE(99)2764:             CLOSE(99)
2768:          ENDIF2765:          ENDIF
2769:          CALL READI(CHMDFREQ)2766:          CALL READI(CHMDFREQ) 
2770: !2767: !
2771:       ELSE IF (WORD.EQ.'CHMOVE') THEN2768:       ELSE IF (WORD.EQ.'CHMOVE') THEN
2772:          CHMOVET=.TRUE.2769:          CHMOVET=.TRUE.
2773:          CALL READA(UNSTRING)2770:          CALL READA(UNSTRING)
2774:          IF (TRIM(ADJUSTL(UNSTRING)).EQ.'STANDARD') THEN2771:          IF (TRIM(ADJUSTL(UNSTRING)).EQ.'STANDARD') THEN
2775:             CHSTANDARDT=.TRUE.2772:             CHSTANDARDT=.TRUE.
2776:          ELSEIF (TRIM(ADJUSTL(UNSTRING)).EQ.'LOOPMODEL') THEN2773:          ELSEIF (TRIM(ADJUSTL(UNSTRING)).EQ.'LOOPMODEL') THEN
2777:             CHLOOPMODT=.TRUE.2774:             CHLOOPMODT=.TRUE.
2778:          ELSEIF (TRIM(ADJUSTL(UNSTRING)).EQ.'CART') THEN2775:          ELSEIF (TRIM(ADJUSTL(UNSTRING)).EQ.'CART') THEN
2779:             CHCARTMOVET=.TRUE.2776:             CHCARTMOVET=.TRUE.
2855:          ELSE IF (WORD.EQ.'QCIRADSHIFT') THEN2852:          ELSE IF (WORD.EQ.'QCIRADSHIFT') THEN
2856:             QCIRADSHIFTT=.TRUE.2853:             QCIRADSHIFTT=.TRUE.
2857:             IF (NITEMS.GT.1) CALL READF(QCIRADSHIFT)2854:             IF (NITEMS.GT.1) CALL READF(QCIRADSHIFT)
2858:             WRITE(MYUNIT,'(A,G20.10)') ' keyword> Shifting unconstrained atoms away from added atoms by ',QCIRADSHIFT2855:             WRITE(MYUNIT,'(A,G20.10)') ' keyword> Shifting unconstrained atoms away from added atoms by ',QCIRADSHIFT
2859: !2856: !
2860: ! Check for internal minimum in constraint terms for INTCONSTRAINT2857: ! Check for internal minimum in constraint terms for INTCONSTRAINT
2861: !2858: !
2862:          ELSE IF ((WORD.EQ.'CONINT').OR.(WORD.EQ.'QCIINT')) THEN2859:          ELSE IF ((WORD.EQ.'CONINT').OR.(WORD.EQ.'QCIINT')) THEN
2863:             CHECKCONINT=.TRUE.2860:             CHECKCONINT=.TRUE.
2864:             IF (NITEMS.GT.1) CALL READF(INTMINFAC)2861:             IF (NITEMS.GT.1) CALL READF(INTMINFAC)
2865:             WRITE(MYUNIT,'(A,G20.10)') ' keyword> Internal minima terms will be scaled by a factor of ',INTMINFAC2862:             WRITE(MYUNIT,'(A,G20.10)') ' keyword> Internal minima terms will be scaled by a factor of ',INTMINFAC 
2866: !2863: !
2867: ! Absolute distance to allow before turning on constraint potential.2864: ! Absolute distance to allow before turning on constraint potential.
2868: !2865: !
2869:          ELSE IF (WORD.EQ.'CONCUTABS') THEN2866:          ELSE IF (WORD.EQ.'CONCUTABS') THEN
2870:             CONCUTABST=.TRUE.2867:             CONCUTABST=.TRUE.
2871:             CONCUTFRACT=.FALSE.2868:             CONCUTFRACT=.FALSE.
2872:             IF (NITEMS.GT.1) CALL READF(CONCUTABS)2869:             IF (NITEMS.GT.1) CALL READF(CONCUTABS)
2873: !2870: !
2874: ! Fraction of constraint distance to allow before turning on constraint potential.2871: ! Fraction of constraint distance to allow before turning on constraint potential.
2875: !2872: !
2887:       ELSE IF (WORD.EQ.'OSASA') THEN2884:       ELSE IF (WORD.EQ.'OSASA') THEN
2888:          OSASAT=.TRUE.2885:          OSASAT=.TRUE.
2889:          CALL READF(RPRO)2886:          CALL READF(RPRO)
2890:          WRITE(MYUNIT,'(A)') 'OSASA set: solvent accessible surface area order parameter will be calculated'2887:          WRITE(MYUNIT,'(A)') 'OSASA set: solvent accessible surface area order parameter will be calculated'
2891:          WRITE(MYUNIT,'(A,F4.1)') 'using probe radius ',RPRO2888:          WRITE(MYUNIT,'(A,F4.1)') 'using probe radius ',RPRO
2892: 2889: 
2893:       ELSE IF (WORD.EQ.'ODIHE') THEN2890:       ELSE IF (WORD.EQ.'ODIHE') THEN
2894:          ODIHET=.TRUE.2891:          ODIHET=.TRUE.
2895:          WRITE(MYUNIT,'(A)') 'ODIHE set: dihedral-angle order parameter will be calculated'2892:          WRITE(MYUNIT,'(A)') 'ODIHE set: dihedral-angle order parameter will be calculated'
2896:          WRITE(MYUNIT,'(A)') 'using the reference structure supplied in ref.crd'2893:          WRITE(MYUNIT,'(A)') 'using the reference structure supplied in ref.crd'
2897: 2894:  
2898:       ELSE IF (WORD.EQ.'OEINT') THEN2895:       ELSE IF (WORD.EQ.'OEINT') THEN
2899:          OEINTT=.TRUE.2896:          OEINTT=.TRUE.
2900:          CALL READI(MON1(1))2897:          CALL READI(MON1(1))
2901:          CALL READI(MON1(2))2898:          CALL READI(MON1(2))
2902:          CALL READI(MON2(1))2899:          CALL READI(MON2(1))
2903:          CALL READI(MON2(2))2900:          CALL READI(MON2(2))
2904:          WRITE(MYUNIT,'(A)') 'OEINTT set: interaction energy between 2 peptides will be used as an order parameter'2901:          WRITE(MYUNIT,'(A)') 'OEINTT set: interaction energy between 2 peptides will be used as an order parameter'
2905: 2902: 
2906:       ELSE IF (WORD.EQ.'ORGYR') THEN2903:       ELSE IF (WORD.EQ.'ORGYR') THEN
2907:          ORGYT=.TRUE.2904:          ORGYT=.TRUE.
2935:       ELSE IF (WORD.EQ.'COLDFUSION') THEN2932:       ELSE IF (WORD.EQ.'COLDFUSION') THEN
2936:          CALL READF(COLDFUSIONLIMIT)2933:          CALL READF(COLDFUSIONLIMIT)
2937: 2934: 
2938:       ELSE IF (WORD.EQ.'COMPRESS') THEN2935:       ELSE IF (WORD.EQ.'COMPRESS') THEN
2939:          COMPRESST=.TRUE.2936:          COMPRESST=.TRUE.
2940:          CALL READF(K_COMP)2937:          CALL READF(K_COMP)
2941: 2938: 
2942: ! csw34> Apply compression to a rigid body system if the COM-COM distances exceed a threshold2939: ! csw34> Apply compression to a rigid body system if the COM-COM distances exceed a threshold
2943:       ELSE IF (WORD.EQ.'COMPRESSRIGID') THEN2940:       ELSE IF (WORD.EQ.'COMPRESSRIGID') THEN
2944:          COMPRESSRIGIDT=.TRUE.2941:          COMPRESSRIGIDT=.TRUE.
2945: ! Read in KCOMP_RIGID2942: ! Read in KCOMP_RIGID 
2946:          IF (NITEMS.GT.1) CALL READF(KCOMP_RIGID)2943:          IF (NITEMS.GT.1) CALL READF(KCOMP_RIGID)
2947:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body system compression enabled'2944:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body system compression enabled'
2948:          WRITE(MYUNIT,'(A,F20.10)') ' COMPRESSRIGID> Compression force constant =',KCOMP_RIGID2945:          WRITE(MYUNIT,'(A,F20.10)') ' COMPRESSRIGID> Compression force constant =',KCOMP_RIGID
2949: ! Read in COM-COM distance cutoff2946: ! Read in COM-COM distance cutoff
2950:          IF (NITEMS.GT.2) CALL READF(RIGIDCOMDIST)2947:          IF (NITEMS.GT.2) CALL READF(RIGIDCOMDIST)
2951:          WRITE(MYUNIT,'(A,F20.10)') ' COMPRESSRIGID> Compression will be applied if COM-COM distance exceeds =',RIGIDCOMDIST2948:          WRITE(MYUNIT,'(A,F20.10)') ' COMPRESSRIGID> Compression will be applied if COM-COM distance exceeds =',RIGIDCOMDIST
2952: !2949: !
2953: !  sf344> keyword to explore the potential field around a RIGID building block2950: !  sf344> keyword to explore the potential field around a RIGID building block
2954: !         (currently by changing only the Cartesian coordinates of the second particle on a grid, and evaluating the energy)2951: !         (currently by changing only the Cartesian coordinates of the second particle on a grid, and evaluating the energy)
2955: !       IMPORTANT: coords file should contain only 4 lines, with the position lines (first two) containing only zeros)2952: !       IMPORTANT: coords file should contain only 4 lines, with the position lines (first two) containing only zeros)
3029:                   STOP3026:                   STOP
3030:                ENDIF3027:                ENDIF
3031: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),3028: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),
3032: !    &                                                            J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)3029: !    &                                                            J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)
3033:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),3030:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),
3034:      &                                                              J2=1,NSETS(J1))3031:      &                                                              J2=1,NSETS(J1))
3035:                NDUMMY=NDUMMY+NPERMSIZE(J1)3032:                NDUMMY=NDUMMY+NPERMSIZE(J1)
3036:             ENDDO3033:             ENDDO
3037: !3034: !
3038: !  And another sanity check! This condition is now allowed.3035: !  And another sanity check! This condition is now allowed.
3039: !3036: !  
3040: !           DO J1=1,NDUMMY3037: !           DO J1=1,NDUMMY
3041: !              DO J2=J1+1,NDUMMY3038: !              DO J2=J1+1,NDUMMY
3042: !                 IF (PERMGROUP(J2).EQ.PERMGROUP(J1)) THEN3039: !                 IF (PERMGROUP(J2).EQ.PERMGROUP(J1)) THEN
3043: !                    PRINT '(2(A,I8))','keyword> ERROR - atom ',PERMGROUP(J1),' appears more than once'3040: !                    PRINT '(2(A,I8))','keyword> ERROR - atom ',PERMGROUP(J1),' appears more than once'
3044: !                    STOP3041: !                    STOP
3045: !                 ENDIF3042: !                 ENDIF
3046: !              ENDDO3043: !              ENDDO
3047: !           ENDDO3044: !           ENDDO
3048:             CLOSE(1)3045:             CLOSE(1)
3049: !3046: !
3050: !  And yet another!3047: !  And yet another!
3051: !3048: !  
3052:             IF (NFREEZE.GT.0) THEN3049:             IF (NFREEZE.GT.0) THEN
3053:                NDUMMY=03050:                NDUMMY=0
3054:                DO J1=1,NPERMGROUP3051:                DO J1=1,NPERMGROUP
3055:                   DO J2=1,NPERMSIZE(J1)3052:                   DO J2=1,NPERMSIZE(J1)
3056:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN3053:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN
3057:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'3054:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'
3058:                         STOP3055:                         STOP
3059:                      ENDIF3056:                      ENDIF
3060:                   ENDDO3057:                   ENDDO
3061:                   NDUMMY=NDUMMY+NPERMSIZE(J1)3058:                   NDUMMY=NDUMMY+NPERMSIZE(J1)
3103:          ENDIF3100:          ENDIF
3104: 3101: 
3105:       ELSE IF (WORD .EQ. 'CUDATIME') THEN3102:       ELSE IF (WORD .EQ. 'CUDATIME') THEN
3106:          CUDATIMET=.TRUE.3103:          CUDATIMET=.TRUE.
3107: 3104: 
3108:       ELSE IF (WORD.EQ.'CUTOFF') THEN3105:       ELSE IF (WORD.EQ.'CUTOFF') THEN
3109:          CUTT=.TRUE.3106:          CUTT=.TRUE.
3110:          IF (NITEMS.GT.1) CALL READF(CUTOFF)3107:          IF (NITEMS.GT.1) CALL READF(CUTOFF)
3111:          FINALCUTOFF=CUTOFF3108:          FINALCUTOFF=CUTOFF
3112:          IF (NITEMS.GT.2) CALL READF(FINALCUTOFF)3109:          IF (NITEMS.GT.2) CALL READF(FINALCUTOFF)
3113: 3110:          
3114:       ELSE IF (WORD.EQ.'BOXCENTROID') THEN3111:       ELSE IF (WORD.EQ.'BOXCENTROID') THEN
3115:          BOXCENTROIDT=.TRUE.3112:          BOXCENTROIDT=.TRUE.
3116:          CALL READF(BOXCENTROID_X(1))3113:          CALL READF(BOXCENTROID_X(1))
3117:          CALL READF(BOXCENTROID_X(2))3114:          CALL READF(BOXCENTROID_X(2))
3118:          CALL READF(BOXCENTROID_X(3))3115:          CALL READF(BOXCENTROID_X(3))
3119:          CALL READF(BOXCENTROID_DX(1))3116:          CALL READF(BOXCENTROID_DX(1))
3120:          CALL READF(BOXCENTROID_DX(2))3117:          CALL READF(BOXCENTROID_DX(2))
3121:          CALL READF(BOXCENTROID_DX(3))3118:          CALL READF(BOXCENTROID_DX(3))
3122:          IF(NITEMS.GT.7) THEN3119:          IF(NITEMS.GT.7) THEN
3123:             DO J1=1,33120:             DO J1=1,3
3124:                CALL READI(J2)3121:                CALL READI(J2)
3125:                IF(J2==1) BOXCENTROID_DISCRETE(J1) = .TRUE.3122:                IF(J2==1) BOXCENTROID_DISCRETE(J1) = .TRUE.
3126:             ENDDO3123:             ENDDO
3127:          ENDIF3124:          ENDIF
3128: 3125:          
3129:       ELSE IF (WORD.EQ.'MIE_FIELD') THEN3126:       ELSE IF (WORD.EQ.'MIE_FIELD') THEN
3130:          MIEFT=.TRUE.3127:          MIEFT=.TRUE.
3131:          CALL READA(MIEF_FILENAME)3128:          CALL READA(MIEF_FILENAME)
3132:          IF(NITEMS.GT.2) THEN3129:          IF(NITEMS.GT.2) THEN
3133:             MIEF_CUTT=.TRUE.3130:             MIEF_CUTT=.TRUE.
3134:             CALL READF(MIEF_RCUT)3131:             CALL READF(MIEF_RCUT)
3135:          ENDIF3132:          ENDIF
3136:          IF(NITEMS.GT.3) THEN3133:          IF(NITEMS.GT.3) THEN
3137:             MIEF_PBCT=.TRUE.3134:             MIEF_PBCT=.TRUE.
3138:             CALL READF(MIEF_BOX(1))3135:             CALL READF(MIEF_BOX(1))
3165:          IF (YESNO) THEN3162:          IF (YESNO) THEN
3166:             DAMPEDGMOVET=.TRUE.3163:             DAMPEDGMOVET=.TRUE.
3167:             WRITE(MYUNIT,'(A)') ' keyword> DAMPED group moves enabled'3164:             WRITE(MYUNIT,'(A)') ' keyword> DAMPED group moves enabled'
3168:          ELSE3165:          ELSE
3169:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: damped atom groups must be defined in Dampedatomgroups file'3166:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: damped atom groups must be defined in Dampedatomgroups file'
3170:             STOP3167:             STOP
3171:          ENDIF3168:          ENDIF
3172: 3169: 
3173:          IF (NITEMS.GT.1) CALL READI(DMOVEFREQ)3170:          IF (NITEMS.GT.1) CALL READI(DMOVEFREQ)
3174: ! if the frequency is 0, we need to disable the move3171: ! if the frequency is 0, we need to disable the move
3175:          IF(DMOVEFREQ.EQ.0) THEN3172:          IF(DMOVEFREQ.EQ.0) THEN 
3176:             DAMPEDGMOVET=.FALSE.3173:             DAMPEDGMOVET=.FALSE.
3177:             WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of DAMPED moves set to 0 - moves DISABLED!'3174:             WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of DAMPED moves set to 0 - moves DISABLED!'
3178:          ENDIF3175:          ENDIF
3179:          NDGROUPS=03176:          NDGROUPS=0
3180:          OPEN(UNIT=222,FILE='Dampedatomgroups',status='old')3177:          OPEN(UNIT=222,FILE='Dampedatomgroups',status='old')
3181:          DO3178:          DO
3182:             READ(222,*,IOSTAT=iostatus) CHECK13179:             READ(222,*,IOSTAT=iostatus) CHECK1
3183:             IF (iostatus<0) THEN3180:             IF (iostatus<0) THEN
3184:             CLOSE(222)3181:             CLOSE(222)
3185:             EXIT3182:             EXIT
3186:             ELSE IF (TRIM(ADJUSTL(check1)).EQ.'DGROUP') then3183:             ELSE IF (TRIM(ADJUSTL(check1)).EQ.'DGROUP') then
3187:                NDGROUPS=NDGROUPS+13184:                NDGROUPS=NDGROUPS+1
3188:             ENDIF3185:             ENDIF
3189:          END DO3186:          END DO        
3190:          CLOSE(222)3187:          CLOSE(222)
3191: ! Allocate atom group info arrays appropriately3188: ! Allocate atom group info arrays appropriately
3192:          ALLOCATE(DATOMGROUPNAMES(NDGROUPS))3189:          ALLOCATE(DATOMGROUPNAMES(NDGROUPS))
3193:          ALLOCATE(DATOMGROUPAXIS(NDGROUPS,2))3190:          ALLOCATE(DATOMGROUPAXIS(NDGROUPS,2))
3194:          ALLOCATE(DATOMGROUPPROBA(NDGROUPS))3191:          ALLOCATE(DATOMGROUPPROBA(NDGROUPS))
3195:          ALLOCATE(DATOMGROUPSCALINGA(NDGROUPS))3192:          ALLOCATE(DATOMGROUPSCALINGA(NDGROUPS))
3196:          ALLOCATE(DATOMGROUPPROBB(NDGROUPS))3193:          ALLOCATE(DATOMGROUPPROBB(NDGROUPS))
3197:          ALLOCATE(DATOMGROUPSCALINGB(NDGROUPS))3194:          ALLOCATE(DATOMGROUPSCALINGB(NDGROUPS))
3198:          ALLOCATE(DATOMGROUPPROBC(NDGROUPS))3195:          ALLOCATE(DATOMGROUPPROBC(NDGROUPS))
3199:          ALLOCATE(DATOMGROUPSCALINGC(NDGROUPS))3196:          ALLOCATE(DATOMGROUPSCALINGC(NDGROUPS))
3229:          OPEN(UNIT=222,FILE='Dampedatomgroups',status='unknown')3226:          OPEN(UNIT=222,FILE='Dampedatomgroups',status='unknown')
3230:          WRITE(MYUNIT,*) 'keyword> Reading in atom groups for DAMPEDGROUPMOVES'3227:          WRITE(MYUNIT,*) 'keyword> Reading in atom groups for DAMPEDGROUPMOVES'
3231:          DO J1=1,NDGROUPS3228:          DO J1=1,NDGROUPS
3232:             READ(222,*) CHECK1,DATOMGROUPNAMES(J1),DATOMGROUPAXIS(J1,1),DATOMGROUPAXIS(J1,2),GROUPSIZE,DATOMGROUPPROBA(J1),3229:             READ(222,*) CHECK1,DATOMGROUPNAMES(J1),DATOMGROUPAXIS(J1,1),DATOMGROUPAXIS(J1,2),GROUPSIZE,DATOMGROUPPROBA(J1),
3233:      &           DATOMGROUPSCALINGA(J1),DATOMGROUPPROBB(J1),DATOMGROUPSCALINGB(J1),3230:      &           DATOMGROUPSCALINGA(J1),DATOMGROUPPROBB(J1),DATOMGROUPSCALINGB(J1),
3234:      &           DATOMGROUPPROBC(J1),DATOMGROUPSCALINGC(J1),DATOMGROUPPROBD(J1),DATOMGROUPSCALINGD(J1)3231:      &           DATOMGROUPPROBC(J1),DATOMGROUPSCALINGC(J1),DATOMGROUPPROBD(J1),DATOMGROUPSCALINGD(J1)
3235:             CALL FLUSH(MYUNIT)3232:             CALL FLUSH(MYUNIT)
3236:             IF (TRIM(ADJUSTL(CHECK1)).EQ.'DGROUP') THEN3233:             IF (TRIM(ADJUSTL(CHECK1)).EQ.'DGROUP') THEN
3237:                DO J2=1,GROUPSIZE3234:                DO J2=1,GROUPSIZE
3238:                   READ(222,*) GROUPATOM, GROUPATT3235:                   READ(222,*) GROUPATOM, GROUPATT
3239:                   DATOMGROUPS(J1,GROUPATOM)=.TRUE.3236:                   DATOMGROUPS(J1,GROUPATOM)=.TRUE. 
3240:                   DATOMGROUPATT(J1,GROUPATOM) = GROUPATT3237:                   DATOMGROUPATT(J1,GROUPATOM) = GROUPATT
3241:                END DO3238:                END DO 
3242:             ELSE3239:             ELSE
3243:                WRITE(MYUNIT,'(A)') ' keyword: ERROR! DAMPED group file not formatted correctly!'3240:                WRITE(MYUNIT,'(A)') ' keyword: ERROR! DAMPED group file not formatted correctly!'
3244:                STOP3241:                STOP
3245:             ENDIF3242:             ENDIF
3246:             WRITE(MYUNIT,'(3A)') '<DGROUP ',TRIM(ADJUSTL(DATOMGROUPNAMES(J1))),'>'3243:             WRITE(MYUNIT,'(3A)') '<DGROUP ',TRIM(ADJUSTL(DATOMGROUPNAMES(J1))),'>'
3247:             WRITE(MYUNIT,'(A,I3)') 'Index: ',J13244:             WRITE(MYUNIT,'(A,I3)') 'Index: ',J1
3248:             WRITE(MYUNIT,'(A,I4)') 'Size: ',GROUPSIZE3245:             WRITE(MYUNIT,'(A,I4)') 'Size: ',GROUPSIZE
3249:             WRITE(MYUNIT,'(A,2I5)') 'Atoms defining axis: ',DATOMGROUPAXIS(J1,1),DATOMGROUPAXIS(J1,2)3246:             WRITE(MYUNIT,'(A,2I5)') 'Atoms defining axis: ',DATOMGROUPAXIS(J1,1),DATOMGROUPAXIS(J1,2)
3250:             WRITE(MYUNIT,'(A,4F5.2)') 'A - Selection probablity and scaling: ',DATOMGROUPPROBA(J1),DATOMGROUPSCALINGA(J1)3247:             WRITE(MYUNIT,'(A,4F5.2)') 'A - Selection probablity and scaling: ',DATOMGROUPPROBA(J1),DATOMGROUPSCALINGA(J1)
3251:             WRITE(MYUNIT,'(A,4F5.2)') 'B - Selection probablity and scaling: ',DATOMGROUPPROBB(J1),DATOMGROUPSCALINGB(J1)3248:             WRITE(MYUNIT,'(A,4F5.2)') 'B - Selection probablity and scaling: ',DATOMGROUPPROBB(J1),DATOMGROUPSCALINGB(J1)
3356: ! after the STEP, but their gradients are NOT set to 0, hence they may3353: ! after the STEP, but their gradients are NOT set to 0, hence they may
3357: ! move during minimisation.3354: ! move during minimisation.
3358: !3355: !
3359:       ELSE IF (WORD.EQ.'DONTMOVE') THEN3356:       ELSE IF (WORD.EQ.'DONTMOVE') THEN
3360:          DONTMOVET=.TRUE.3357:          DONTMOVET=.TRUE.
3361:          DO J1=1,NITEMS-13358:          DO J1=1,NITEMS-1
3362:             NDONTMOVE=NDONTMOVE+13359:             NDONTMOVE=NDONTMOVE+1
3363:             CALL READI(NDUMMY)3360:             CALL READI(NDUMMY)
3364:             DONTMOVE(NDUMMY)=.TRUE.3361:             DONTMOVE(NDUMMY)=.TRUE.
3365:          ENDDO3362:          ENDDO
3366: 3363:          
3367: ! csw34> DONTMOVEGROUP is analagous to FREEZEGROUP3364: ! csw34> DONTMOVEGROUP is analagous to FREEZEGROUP 
3368:       ELSE IF (WORD.EQ.'DONTMOVEGROUP') THEN3365:       ELSE IF (WORD.EQ.'DONTMOVEGROUP') THEN
3369:          DONTMOVET=.TRUE.3366:          DONTMOVET=.TRUE.
3370:          DONTMOVEGROUPT=.TRUE.3367:          DONTMOVEGROUPT=.TRUE.
3371:          CALL READI(DONTMOVECENTRE)3368:          CALL READI(DONTMOVECENTRE)
3372:          CALL READF(DONTMOVERADIUS)3369:          CALL READF(DONTMOVERADIUS)
3373:          IF(NITEMS.GT.3) CALL READA(DONTMOVEGROUPTYPE)3370:          IF(NITEMS.GT.3) CALL READA(DONTMOVEGROUPTYPE)
3374: 3371:          
3375:       ELSE IF (WORD.EQ.'DONTMOVEALL') THEN3372:       ELSE IF (WORD.EQ.'DONTMOVEALL') THEN
3376:          DONTMOVET=.TRUE.3373:          DONTMOVET=.TRUE.
3377:          DONTMOVEALL=.TRUE.3374:          DONTMOVEALL=.TRUE.
3378:          NDONTMOVE=NATOMSALLOC3375:          NDONTMOVE=NATOMSALLOC
3379:          DO J1=1,NATOMSALLOC3376:          DO J1=1,NATOMSALLOC
3380:             DONTMOVE(J1)=.TRUE.3377:             DONTMOVE(J1)=.TRUE.
3381:             DONTMOVERES(J1)=.TRUE.3378:             DONTMOVERES(J1)=.TRUE.
3382:          ENDDO3379:          ENDDO
3383: ! csw343380: ! csw34
3384: ! Things are then moved using the DOMOVE and DOMOVERES keywords3381: ! Things are then moved using the DOMOVE and DOMOVERES keywords
3392: 3389: 
3393:       ELSE IF (WORD.EQ.'DONTMOVERES') THEN3390:       ELSE IF (WORD.EQ.'DONTMOVERES') THEN
3394:          DONTMOVET=.TRUE.3391:          DONTMOVET=.TRUE.
3395:          DONTMOVEREST=.TRUE.3392:          DONTMOVEREST=.TRUE.
3396: ! The FROZENRES array is then filled with the residue number from the3393: ! The FROZENRES array is then filled with the residue number from the
3397: ! data file3394: ! data file
3398:          DO J1=1,NITEMS-13395:          DO J1=1,NITEMS-1
3399:             CALL READI(NDUMMY)3396:             CALL READI(NDUMMY)
3400:             DONTMOVERES(NDUMMY)=.TRUE.3397:             DONTMOVERES(NDUMMY)=.TRUE.
3401:          ENDDO3398:          ENDDO
3402: 3399:          
3403:          ELSEIF ((WORD.EQ.'DOMOVERES').AND.DONTMOVEALL) THEN3400:          ELSEIF ((WORD.EQ.'DOMOVERES').AND.DONTMOVEALL) THEN
3404:          DOMOVEREST=.TRUE.3401:          DOMOVEREST=.TRUE.
3405: ! Set the right parts of the DONTMOVERES array to FALSE3402: ! Set the right parts of the DONTMOVERES array to FALSE
3406:          DO J1=1,NITEMS-13403:          DO J1=1,NITEMS-1 
3407:             CALL READI(NDUMMY)3404:             CALL READI(NDUMMY)
3408:             DONTMOVERES(NDUMMY)=.FALSE.3405:             DONTMOVERES(NDUMMY)=.FALSE.
3409:          ENDDO3406:          ENDDO
3410:          DONTMOVEREST=.TRUE.3407:          DONTMOVEREST=.TRUE.
3411: 3408:          
3412:       ELSE IF (WORD.EQ.'DUMP') THEN3409:       ELSE IF (WORD.EQ.'DUMP') THEN
3413:          DUMPT=.TRUE.3410:          DUMPT=.TRUE.
3414: 3411: 
3415:       ELSE IF (WORD.EQ.'DUMPINT') THEN3412:       ELSE IF (WORD.EQ.'DUMPINT') THEN
3416:          CALL READI(DUMPINT)3413:          CALL READI(DUMPINT)
3417: 3414: 
3418:       ELSE IF (WORD.EQ.'DUMP_MARKOV') THEN3415:       ELSE IF (WORD.EQ.'DUMP_MARKOV') THEN
3419:          DUMP_MARKOV=.TRUE.3416:          DUMP_MARKOV=.TRUE.
3420:          CALL READI(DUMP_MARKOV_NWAIT)3417:          CALL READI(DUMP_MARKOV_NWAIT)
3421:          CALL READI(DUMP_MARKOV_NFREQ)3418:          CALL READI(DUMP_MARKOV_NFREQ)
3441:       ELSE IF (WORD.EQ.'EAMLJ') THEN3438:       ELSE IF (WORD.EQ.'EAMLJ') THEN
3442:          EAMLJT=.TRUE.3439:          EAMLJT=.TRUE.
3443:          CALL READF(EAMLJA0)3440:          CALL READF(EAMLJA0)
3444:          CALL READF(EAMLJBETA)3441:          CALL READF(EAMLJBETA)
3445:          CALL READF(EAMLJZ0)3442:          CALL READF(EAMLJZ0)
3446: 3443: 
3447:       ELSE IF (WORD.EQ.'EDIFF') THEN3444:       ELSE IF (WORD.EQ.'EDIFF') THEN
3448:          CALL READF(ECONV)3445:          CALL READF(ECONV)
3449: 3446: 
3450: !3447: !
3451: ! Accumulation of thermodynamic statistics starting after Equil steps,3448: ! Accumulation of thermodynamic statistics starting after Equil steps, 
3452: ! calculated thermodynamic properties is dumped every DumpEveryNthQuench quench.3449: ! calculated thermodynamic properties is dumped every DumpEveryNthQuench quench.
3453: 3450: 
3454: !3451: !
3455:       ELSE IF (WORD.EQ.'EQUILIBRATION') THEN3452:       ELSE IF (WORD.EQ.'EQUILIBRATION') THEN
3456:          CALL READI(EQUIL)3453:          CALL READI(EQUIL)
3457:          CALL READI(DumpEveryNthQuench)3454:          CALL READI(DumpEveryNthQuench)
3458: !3455: !
3459: !  Steps using transition state search-type moves. Obsolete.3456: !  Steps using transition state search-type moves. Obsolete.
3460: !  NOT DOCUMENTED3457: !  NOT DOCUMENTED
3461: !3458: !
3469: ! Number of steps of equilibration for the replica above a reservoir3466: ! Number of steps of equilibration for the replica above a reservoir
3470: ! after a successful exchange.3467: ! after a successful exchange.
3471: !3468: !
3472:       ELSE IF (WORD.EQ.'EXEQ') THEN3469:       ELSE IF (WORD.EQ.'EXEQ') THEN
3473:          CALL READI(EXEQ)3470:          CALL READI(EXEQ)
3474: !3471: !
3475: !  NOT DOCUMENTED - INTENTIONAL3472: !  NOT DOCUMENTED - INTENTIONAL
3476: !3473: !
3477: !3474: !
3478: ! csw34> Rigid body expansion moves. Scales the distance of the COM of each rigid body3475: ! csw34> Rigid body expansion moves. Scales the distance of the COM of each rigid body
3479: !        from the system COM by EXPANDFACTOR every EXPANDRIGIDFREQ steps. The idea here3476: !        from the system COM by EXPANDFACTOR every EXPANDRIGIDFREQ steps. The idea here 
3480: !        is to provide more space for subsequent large moves in dense systems. If the third3477: !        is to provide more space for subsequent large moves in dense systems. If the third 
3481: !        arguement 'NORMALISE' is given, the expansion vector for each rigid body is normalised3478: !        arguement 'NORMALISE' is given, the expansion vector for each rigid body is normalised 
3482: !        before it is scaled, essentially translating all bodies by EXPANDFACTOR from the system COM.3479: !        before it is scaled, essentially translating all bodies by EXPANDFACTOR from the system COM. 
3483: !3480: !
3484:       ELSE IF (WORD.EQ.'EXPANDRIGID') THEN3481:       ELSE IF (WORD.EQ.'EXPANDRIGID') THEN
3485:          EXPANDRIGIDT=.TRUE.3482:          EXPANDRIGIDT=.TRUE.
3486: ! Read EXPANDRIGIDFREQ3483: ! Read EXPANDRIGIDFREQ 
3487:          IF (NITEMS.GT.1) CALL READI(EXPANDRIGIDFREQ)3484:          IF (NITEMS.GT.1) CALL READI(EXPANDRIGIDFREQ)
3488: ! Read EXPANDFACTOR3485: ! Read EXPANDFACTOR
3489:          IF (NITEMS.GT.2) CALL READF(EXPANDFACTOR)3486:          IF (NITEMS.GT.2) CALL READF(EXPANDFACTOR)
3490:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body expansion moves enabled'3487:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body expansion moves enabled'
3491:          WRITE(MYUNIT,'(A,I2,A)') ' keyword> Rigid bodies will be expanded every ',EXPANDRIGIDFREQ,' steps'3488:          WRITE(MYUNIT,'(A,I2,A)') ' keyword> Rigid bodies will be expanded every ',EXPANDRIGIDFREQ,' steps' 
3492:          WRITE(MYUNIT,'(A,F20.10)') ' EXPANDRIGID> System expansion factor =',EXPANDFACTOR3489:          WRITE(MYUNIT,'(A,F20.10)') ' EXPANDRIGID> System expansion factor =',EXPANDFACTOR
3493:          IF (NITEMS.GT.3) THEN3490:          IF (NITEMS.GT.3) THEN
3494: ! Read second arguement3491: ! Read second arguement 
3495:             CALL READA(WORD2)3492:             CALL READA(WORD2)
3496:             WORD2=TRIM(ADJUSTL(WORD2))3493:             WORD2=TRIM(ADJUSTL(WORD2))
3497:             IF (WORD2.EQ.'NORMALISE') THEN3494:             IF (WORD2.EQ.'NORMALISE') THEN
3498:                WRITE(MYUNIT,'(A)') ' EXPANDRIGID> Expandsion vextor will be normalised before scaling'3495:                WRITE(MYUNIT,'(A)') ' EXPANDRIGID> Expandsion vextor will be normalised before scaling'
3499:                NORMALISEEXPANDT=.TRUE.3496:                NORMALISEEXPANDT=.TRUE.
3500:             ENDIF3497:             ENDIF
3501:          ENDIF3498:          ENDIF
3502: 3499: 
3503:       ELSE IF (WORD.EQ.'EXPFAC') THEN3500:       ELSE IF (WORD.EQ.'EXPFAC') THEN
3504:          CALL READF(EFAC)3501:          CALL READF(EFAC)
3506: 3503: 
3507: ! Commenting out this AMBER keyword that should be used only with PNM's hand-coded AMBER3504: ! Commenting out this AMBER keyword that should be used only with PNM's hand-coded AMBER
3508: !      ELSE IF (WORD.EQ.'FAKEWATER') THEN3505: !      ELSE IF (WORD.EQ.'FAKEWATER') THEN
3509: !         FAKEWATER=.TRUE.3506: !         FAKEWATER=.TRUE.
3510: !         WRITE (MYUNIT,'(A)') '**********************************************************'3507: !         WRITE (MYUNIT,'(A)') '**********************************************************'
3511: !         WRITE (MYUNIT,'(A)') '* DISTANCE DEPENDENT DIELECTRIC BEING USED - FAKE WATER! *'3508: !         WRITE (MYUNIT,'(A)') '* DISTANCE DEPENDENT DIELECTRIC BEING USED - FAKE WATER! *'
3512: !         WRITE (MYUNIT,'(A)') '**********************************************************'3509: !         WRITE (MYUNIT,'(A)') '**********************************************************'
3513: 3510: 
3514:       ELSE IF (WORD.EQ.'FAL') THEN3511:       ELSE IF (WORD.EQ.'FAL') THEN
3515:          FAL=.TRUE.3512:          FAL=.TRUE.
3516: 3513:      
3517:       ELSE IF (WORD == 'FEBH') THEN3514:       ELSE IF (WORD == 'FEBH') THEN
3518:          CALL READF(FETEMP)3515:          CALL READF(FETEMP)
3519:          FEBHT = .TRUE.3516:          FEBHT = .TRUE.
3520:          FE_FILE_UNIT = GETUNIT()3517:          FE_FILE_UNIT = GETUNIT()
3521:          OPEN(UNIT = FE_FILE_UNIT, FILE = 'free_energy', STATUS = 'REPLACE')3518:          OPEN(UNIT = FE_FILE_UNIT, FILE = 'free_energy', STATUS = 'REPLACE')
3522:          WRITE(FE_FILE_UNIT, '(6A20)') '       Quench       ', '  Potential energy  ',3519:          WRITE(FE_FILE_UNIT, '(6A20)') '       Quench       ', '  Potential energy  ',
3523:      &   '   Harmonic term    ', '    Free energy     ', '   Markov energy    ', '        Time        '3520:      &   '   Harmonic term    ', '    Free energy     ', '   Markov energy    ', '        Time        '
3524:          WRITE(FE_FILE_UNIT, '(6A20)') ' ------------------ ', ' ------------------ ',3521:          WRITE(FE_FILE_UNIT, '(6A20)') ' ------------------ ', ' ------------------ ',
3525:      &   ' ------------------ ', ' ------------------ ', ' ------------------ ', ' ------------------ '3522:      &   ' ------------------ ', ' ------------------ ', ' ------------------ ', ' ------------------ '
3526:          IF (NITEMS .GT. 2) THEN3523:          IF (NITEMS .GT. 2) THEN
3527:              CALL READA(WORD2)3524:              CALL READA(WORD2)
3528:              WORD2 = TRIM(ADJUSTL(WORD2))3525:              WORD2 = TRIM(ADJUSTL(WORD2))
3529:              IF (WORD2 .EQ. 'SPARSE') SPARSET = .TRUE.3526:              IF (WORD2 .EQ. 'SPARSE') SPARSET = .TRUE.
3530:          END IF3527:          END IF
3531:          IF (NITEMS .GT. 3) THEN3528:          IF (NITEMS .GT. 3) THEN
3532:              CALL READF(ZERO_THRESH)3529:              CALL READF(ZERO_THRESH)
3533:          END IF3530:          END IF
3534: 3531:  
3535:       ELSE IF (WORD.EQ.'FIXBOTH') THEN3532:       ELSE IF (WORD.EQ.'FIXBOTH') THEN
3536:          IF (NITEMS.EQ.1) THEN3533:          IF (NITEMS.EQ.1) THEN
3537:             FIXBOTH(1)=.TRUE.3534:             FIXBOTH(1)=.TRUE.
3538:             IF (NPAR.GT.1) THEN3535:             IF (NPAR.GT.1) THEN
3539:                DO J1=2,NPAR3536:                DO J1=2,NPAR
3540:                   FIXBOTH(J1)=.TRUE.3537:                   FIXBOTH(J1)=.TRUE.
3541:                ENDDO3538:                ENDDO
3542:             ENDIF3539:             ENDIF
3543:          ELSE3540:          ELSE
3544:             DO J1=1,NITEMS-13541:             DO J1=1,NITEMS-1
3545:                CALL READI(IX)3542:                CALL READI(IX) 
3546:                FIXBOTH(IX)=.TRUE.3543:                FIXBOTH(IX)=.TRUE.
3547:             ENDDO3544:             ENDDO
3548:          ENDIF3545:          ENDIF
3549: 3546: 
3550:       ELSE IF (WORD.EQ.'FIXCOM') THEN3547:       ELSE IF (WORD.EQ.'FIXCOM') THEN
3551:          FIXCOM=.TRUE.3548:          FIXCOM=.TRUE.
3552: !ds656> no need to allocate masses here, since it is done in main.F3549: !ds656> no need to allocate masses here, since it is done in main.F
3553: !         IF (ALLOCATED(ATMASS)) DEALLOCATE(ATMASS)3550: !         IF (ALLOCATED(ATMASS)) DEALLOCATE(ATMASS)
3554: !         ALLOCATE(ATMASS(NATOMSALLOC))3551: !         ALLOCATE(ATMASS(NATOMSALLOC)) 
3555: !3552: !     
3556: !  Take hard sphere type moves.3553: !  Take hard sphere type moves.
3557: !  T12FAC is the fraction of the first collision time to be used in HSMOVE3554: !  T12FAC is the fraction of the first collision time to be used in HSMOVE
3558: !3555: !
3559:       ELSE IF (WORD.EQ.'FIXD') THEN3556:       ELSE IF (WORD.EQ.'FIXD') THEN
3560:          FIXD=.TRUE.3557:          FIXD=.TRUE.
3561:          IF (NITEMS.GT.1) THEN3558:          IF (NITEMS.GT.1) THEN
3562:             CALL READI(NHSMOVE)3559:             CALL READI(NHSMOVE)
3563:          ENDIF3560:          ENDIF
3564:          IF (NITEMS.GT.2) THEN3561:          IF (NITEMS.GT.2) THEN
3565:             CALL READF(T12FAC)3562:             CALL READF(T12FAC)
3566:          ENDIF3563:          ENDIF
3567: 3564: 
3568:       ELSE IF (WORD.EQ.'FIXSTEP') THEN3565:       ELSE IF (WORD.EQ.'FIXSTEP') THEN
3569:          IF (NITEMS.EQ.1) THEN3566:          IF (NITEMS.EQ.1) THEN
3570:             FIXSTEP(1)=.TRUE.3567:             FIXSTEP(1)=.TRUE.
3571:          ELSE3568:          ELSE
3572:             DO J1=1,NITEMS-13569:             DO J1=1,NITEMS-1
3573:                CALL READI(IX)3570:                CALL READI(IX) 
3574:                FIXSTEP(IX)=.TRUE.3571:                FIXSTEP(IX)=.TRUE.
3575:             ENDDO3572:             ENDDO
3576:          ENDIF3573:          ENDIF
3577: 3574: 
3578:       ELSE IF (WORD.EQ.'FIXTEMP') THEN3575:       ELSE IF (WORD.EQ.'FIXTEMP') THEN
3579:          IF (NITEMS.EQ.1) THEN3576:          IF (NITEMS.EQ.1) THEN
3580:             FIXTEMP(1)=.TRUE.3577:             FIXTEMP(1)=.TRUE.
3581:          ELSE3578:          ELSE
3582:             DO J1=1,NITEMS-13579:             DO J1=1,NITEMS-1
3583:                CALL READI(IX)3580:                CALL READI(IX) 
3584:                FIXTEMP(IX)=.TRUE.3581:                FIXTEMP(IX)=.TRUE.
3585:             ENDDO3582:             ENDDO
3586:          ENDIF3583:          ENDIF
3587: 3584: 
3588:       ELSE IF (WORD.EQ.'FNI') THEN3585:       ELSE IF (WORD.EQ.'FNI') THEN
3589:          FNI=.TRUE.3586:          FNI=.TRUE.
3590: 3587: 
3591:       ELSE IF (WORD.EQ.'FORCERIGID') THEN3588:       ELSE IF (WORD.EQ.'FORCERIGID') THEN
3592:          RIGID=.TRUE.3589:          RIGID=.TRUE.
3593: 3590: 
3675:       ELSEIF ((WORD.EQ.'UNFREEZE').AND.FREEZEALL) THEN3672:       ELSEIF ((WORD.EQ.'UNFREEZE').AND.FREEZEALL) THEN
3676:          DO J1=1,NITEMS-13673:          DO J1=1,NITEMS-1
3677:             CALL READI(NDUMMY)3674:             CALL READI(NDUMMY)
3678:             FROZEN(NDUMMY)=.FALSE.3675:             FROZEN(NDUMMY)=.FALSE.
3679:             NFREEZE=NFREEZE-13676:             NFREEZE=NFREEZE-1
3680:          ENDDO3677:          ENDDO
3681: 3678: 
3682:       ELSEIF ((WORD.EQ.'UNFREEZERES').AND.FREEZEALL) THEN3679:       ELSEIF ((WORD.EQ.'UNFREEZERES').AND.FREEZEALL) THEN
3683:          UNFREEZERES=.TRUE.3680:          UNFREEZERES=.TRUE.
3684: ! Set the right parts of the FROZENRES array to FALSE3681: ! Set the right parts of the FROZENRES array to FALSE
3685:          DO J1=1,NITEMS-13682:          DO J1=1,NITEMS-1 
3686:             CALL READI(NDUMMY)3683:             CALL READI(NDUMMY)
3687:             FROZENRES(NDUMMY)=.FALSE.3684:             FROZENRES(NDUMMY)=.FALSE.
3688:          ENDDO3685:          ENDDO
3689:          FREEZERES=.TRUE.3686:          FREEZERES=.TRUE.
3690: ! The FREEZERES routines for AMBER and CHARMM do the rest :)3687: ! The FREEZERES routines for AMBER and CHARMM do the rest :)
3691: !3688: !      
3692: ! Finnis-Sinclair potential coded by James Elliott3689: ! Finnis-Sinclair potential coded by James Elliott
3693: !3690: !
3694:       ELSE IF (WORD.EQ.'FS') THEN3691:       ELSE IF (WORD.EQ.'FS') THEN
3695:          FST=.TRUE.3692:          FST=.TRUE.
3696:          CALL READI(GATOM)3693:          CALL READI(GATOM)
3697: 3694: 
3698:       ELSE IF (WORD.EQ.'G46') THEN3695:       ELSE IF (WORD.EQ.'G46') THEN
3699:          G46=.TRUE.3696:          G46=.TRUE.
3700:          BLNT=.TRUE.3697:          BLNT=.TRUE.
3701: ! mo361> Genetic algorithm keywords3698: ! mo361> Genetic algorithm keywords
3799:       ELSE IF (WORD.EQ.'GAUSS') THEN3796:       ELSE IF (WORD.EQ.'GAUSS') THEN
3800:          GAUSST=.TRUE.3797:          GAUSST=.TRUE.
3801:          CALL READI(GMODES) ! number of nodes3798:          CALL READI(GMODES) ! number of nodes
3802: !3799: !
3803: ! Grand canonical basin-hopping.3800: ! Grand canonical basin-hopping.
3804: !3801: !
3805:       ELSE IF (WORD.EQ.'GCBH') THEN3802:       ELSE IF (WORD.EQ.'GCBH') THEN
3806:          GCBHT=.TRUE.3803:          GCBHT=.TRUE.
3807:          CALL READF(GCMU) ! chemical potential3804:          CALL READF(GCMU) ! chemical potential
3808:          CALL READI(GCNATOMS) ! maximum number of atoms3805:          CALL READI(GCNATOMS) ! maximum number of atoms
3809:          IF (NITEMS.GT.3) CALL READI(GCINT)3806:          IF (NITEMS.GT.3) CALL READI(GCINT) 
3810:          IF (NITEMS.GT.4) CALL READI(GCRELAX)3807:          IF (NITEMS.GT.4) CALL READI(GCRELAX) 
3811:          IF (NITEMS.GT.5) CALL READF(GCPLUS)3808:          IF (NITEMS.GT.5) CALL READF(GCPLUS) 
3812:          WRITE(MYUNIT,'(A,I6)') 'keyyword> Interval for GC size change=',GCINT3809:          WRITE(MYUNIT,'(A,I6)') 'keyyword> Interval for GC size change=',GCINT
3813:          WRITE(MYUNIT,'(A,I6)') 'keyyword> Interval for GC relaxation=',GCRELAX3810:          WRITE(MYUNIT,'(A,I6)') 'keyyword> Interval for GC relaxation=',GCRELAX
3814:          IF (GCRELAX.GT.GCINT) THEN3811:          IF (GCRELAX.GT.GCINT) THEN
3815:             WRITE(MYUNIT,'(A,I6)') 'keyyword> *** ERROR - relaxation interval should be < size change interval'3812:             WRITE(MYUNIT,'(A,I6)') 'keyyword> *** ERROR - relaxation interval should be < size change interval'
3816:             STOP3813:             STOP
3817:          ENDIF3814:          ENDIF
3818:          WRITE(MYUNIT,'(A,2G20.10)') 'keyyword> GC atom addition/subtraction probabilities=',GCPLUS,1.0D0-GCPLUS3815:          WRITE(MYUNIT,'(A,2G20.10)') 'keyyword> GC atom addition/subtraction probabilities=',GCPLUS,1.0D0-GCPLUS
3819: 3816:          
3820: !ds656> Relative chemical potential(s) for semi-grand canonical BH.3817: !ds656> Relative chemical potential(s) for semi-grand canonical BH.
3821:       ELSE IF (WORD.EQ.'SEMIGRAND_MU') THEN3818:       ELSE IF (WORD.EQ.'SEMIGRAND_MU') THEN
3822:          SEMIGRAND_MUT = .TRUE.3819:          SEMIGRAND_MUT = .TRUE.
3823:          WRITE(MYUNIT,'(A)',ADVANCE='NO')3820:          WRITE(MYUNIT,'(A)',ADVANCE='NO') 
3824:      1        'keyword> Semi-grand chem. pots.:'3821:      1        'keyword> Semi-grand chem. pots.:'
3825:          ALLOCATE(SEMIGRAND_MU(NSPECIES(0)))3822:          ALLOCATE(SEMIGRAND_MU(NSPECIES(0)))
3826:          SEMIGRAND_MU(1) = 0.0D03823:          SEMIGRAND_MU(1) = 0.0D0
3827:          WRITE(MYUNIT,'(1X,F8.5)',ADVANCE='NO') SEMIGRAND_MU(1)3824:          WRITE(MYUNIT,'(1X,F8.5)',ADVANCE='NO') SEMIGRAND_MU(1)
3828:          DO J1=2,NSPECIES(0)3825:          DO J1=2,NSPECIES(0)
3829:             CALL READF(SEMIGRAND_MU(J1))3826:             CALL READF(SEMIGRAND_MU(J1))
3830:             WRITE(MYUNIT,'(1X,F8.5)',ADVANCE='NO') SEMIGRAND_MU(J1)3827:             WRITE(MYUNIT,'(1X,F8.5)',ADVANCE='NO') SEMIGRAND_MU(J1)
3831:          ENDDO3828:          ENDDO
3832:          WRITE(MYUNIT,*)3829:          WRITE(MYUNIT,*)
3833: !------------------------------------------------------------3830: !------------------------------------------------------------
3837:          MSCT = .TRUE.3834:          MSCT = .TRUE.
3838:          CALL PARSE_MSC_PARAMS(DATA_UNIT)3835:          CALL PARSE_MSC_PARAMS(DATA_UNIT)
3839: !------------------------------------3836: !------------------------------------
3840: ! ds656> Multicomponent Gupta systems3837: ! ds656> Multicomponent Gupta systems
3841: !------------------------------------3838: !------------------------------------
3842:       ELSE IF (WORD.EQ.'MGUPTA') THEN3839:       ELSE IF (WORD.EQ.'MGUPTA') THEN
3843:          MGUPTAT=.TRUE.3840:          MGUPTAT=.TRUE.
3844:          CALL PARSE_MGUPTA_PARAMS(DATA_UNIT)3841:          CALL PARSE_MGUPTA_PARAMS(DATA_UNIT)
3845: !-------------------------------------------3842: !-------------------------------------------
3846: ! ds656> Multicomponent Lennard-Jones system3843: ! ds656> Multicomponent Lennard-Jones system
3847: !-------------------------------------------3844: !-------------------------------------------  
3848:       ELSE IF (WORD.EQ.'MLJ') THEN3845:       ELSE IF (WORD.EQ.'MLJ') THEN
3849:          MLJT=.TRUE.3846:          MLJT=.TRUE.
3850:          CALL PARSE_MLJ_PARAMS(DATA_UNIT)3847:          CALL PARSE_MLJ_PARAMS(DATA_UNIT)
3851: !3848: !     
3852: ! General LJ for mixed systems3849: ! General LJ for mixed systems
3853: !3850: !
3854:       ELSE IF (WORD.EQ.'GLJ') THEN3851:       ELSE IF (WORD.EQ.'GLJ') THEN
3855:          GLJT=.TRUE.3852:          GLJT=.TRUE.
3856:          IF (NSPECIES(0) /= NITEMS-1) THEN3853:          IF (NSPECIES(0) /= NITEMS-1) THEN
3857:             WRITE(MYUNIT,'(A)') 'keywords> Inconsistent species count for GLJ!'3854:             WRITE(MYUNIT,'(A)') 'keywords> Inconsistent species count for GLJ!'
3858:             STOP3855:             STOP
3859:          ENDIF3856:          ENDIF
3860:          !  the number of different species is given by NITEMS-1,3857:          !  the number of different species is given by NITEMS-1, 
3861:          !  since we specify respective atom counts on this line3858:          !  since we specify respective atom counts on this line
3862:          DO J1=1,NSPECIES(0) ! loop over species3859:          DO J1=1,NSPECIES(0) ! loop over species
3863:             CALL READI(NSPECIES(J1)) ! number of atoms for each species3860:             CALL READI(NSPECIES(J1)) ! number of atoms for each species
3864:          ENDDO3861:          ENDDO
3865:          NTYPEA = NSPECIES(1)3862:          NTYPEA = NSPECIES(1)
3866:          IF (ALLOCATED(GLJEPS)) DEALLOCATE(GLJEPS)3863:          IF (ALLOCATED(GLJEPS)) DEALLOCATE(GLJEPS)
3867:          IF (ALLOCATED(GLJSIG)) DEALLOCATE(GLJSIG)3864:          IF (ALLOCATED(GLJSIG)) DEALLOCATE(GLJSIG)
3868:          ALLOCATE(GLJEPS(NSPECIES(0),NSPECIES(0)))3865:          ALLOCATE(GLJEPS(NSPECIES(0),NSPECIES(0)))
3869:          ALLOCATE(GLJSIG(NSPECIES(0),NSPECIES(0)))3866:          ALLOCATE(GLJSIG(NSPECIES(0),NSPECIES(0)))
3870:          WRITE(MYUNIT,'(A,I8,A)') 'keyword> Mixed LJ potential with ',NSPECIES(0),' particle types. Numbers of each particle:'3867:          WRITE(MYUNIT,'(A,I8,A)') 'keyword> Mixed LJ potential with ',NSPECIES(0),' particle types. Numbers of each particle:'
3919:             CALL READF(GTHOMSONC)3916:             CALL READF(GTHOMSONC)
3920:          ENDIF3917:          ENDIF
3921:          IF (NITEMS.GT.4) THEN3918:          IF (NITEMS.GT.4) THEN
3922:             CALL READF(GTHOMSONC2)3919:             CALL READF(GTHOMSONC2)
3923:             IF ( (GTHOMMET .EQ. 2) .AND. (GTHOMSONC2 > 0.0D0) ) THEN3920:             IF ( (GTHOMMET .EQ. 2) .AND. (GTHOMSONC2 > 0.0D0) ) THEN
3924:                GTHOMSONZ = LOG((GTHOMSONC2/GTHOMSONC)+ SQRT((GTHOMSONC2/GTHOMSONC)**2-1.0D0))*GTHOMSONC3921:                GTHOMSONZ = LOG((GTHOMSONC2/GTHOMSONC)+ SQRT((GTHOMSONC2/GTHOMSONC)**2-1.0D0))*GTHOMSONC
3925: !               PRINT *, GTHOMSONZ3922: !               PRINT *, GTHOMSONZ
3926:             ENDIF3923:             ENDIF
3927:          ENDIF3924:          ENDIF
3928:          IF (NITEMS.GT.5) CALL READF(VUNDULOID)3925:          IF (NITEMS.GT.5) CALL READF(VUNDULOID)
3929: 3926:      
3930:          IF ((GTHOMMET .EQ. 3) .OR. (GTHOMMET .EQ. 4)) THEN3927:          IF ((GTHOMMET .EQ. 3) .OR. (GTHOMMET .EQ. 4)) THEN
3931:             CALL CONVERTUNDULOIDPARAMETERS(VUNDULOID/2.0D0)3928:             CALL CONVERTUNDULOIDPARAMETERS(VUNDULOID/2.0D0)
3932:          ENDIF3929:          ENDIF
3933: 3930: 
3934: !         ODDCHARGE=1.0D03931: !         ODDCHARGE=1.0D0
3935: !         IF (NITEMS.GT.6) CALL READF(ODDCHARGE)3932: !         IF (NITEMS.GT.6) CALL READF(ODDCHARGE)
3936: 3933:          
3937:          IF ((GTHOMMET .EQ. 3) .OR. (GTHOMMET .EQ. 4)) THEN3934:          IF ((GTHOMMET .EQ. 3) .OR. (GTHOMMET .EQ. 4)) THEN
3938:             CALL FINDNGZ()3935:             CALL FINDNGZ()
3939:          ENDIF3936:          ENDIF
3940: 3937: 
3941:          CALL INIGTHOMSON()3938:          CALL INIGTHOMSON()
3942: 3939: 
3943:       ELSE IF (WORD .EQ. 'GTHOMSONPOT') THEN3940:       ELSE IF (WORD .EQ. 'GTHOMSONPOT') THEN
3944:          CALL READI(GTHOMPOT)3941:          CALL READI(GTHOMPOT)
3945:          IF (NITEMS.GT.2) THEN3942:          IF (NITEMS.GT.2) THEN
3946:             CALL READF(GThomsonSigma)3943:             CALL READF(GThomsonSigma)
3947:          ENDIF3944:          ENDIF
3948:          IF (NITEMS.GT.2) THEN3945:          IF (NITEMS.GT.2) THEN
3949:             CALL READF(GThomsonRho)3946:             CALL READF(GThomsonRho)
3950:          ENDIF3947:          ENDIF
3951: 3948: 
3952:       ELSE IF (WORD.EQ.'GEOMDIFFTOL') THEN3949:       ELSE IF (WORD.EQ.'GEOMDIFFTOL') THEN
3953:          CALL READF(GEOMDIFFTOL)3950:          CALL READF(GEOMDIFFTOL)
3954: 3951: 
3955: ! csw34> Group rotation moves (now for both AMBER and CHARMM!3952: ! csw34> Group rotation moves (now for both AMBER and CHARMM! 
3956:       ELSE IF (WORD.EQ.'GROUPROTATION') THEN3953:       ELSE IF (WORD.EQ.'GROUPROTATION') THEN
3957: 3954: 
3958: ! csw34> Check the group file is present3955: ! csw34> Check the group file is present
3959:          YESNO=.FALSE.3956:          YESNO=.FALSE.
3960:          INQUIRE(FILE='atomgroups',EXIST=YESNO)3957:          INQUIRE(FILE='atomgroups',EXIST=YESNO)
3961:          IF (YESNO) THEN3958:          IF (YESNO) THEN
3962:             GROUPROTT=.TRUE.3959:             GROUPROTT=.TRUE.
3963:             WRITE(MYUNIT,'(A)') ' keyword> AMBER group rotation moves enabled'3960:             WRITE(MYUNIT,'(A)') ' keyword> AMBER group rotation moves enabled'
3964:          ELSE3961:          ELSE
3965:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: atom groups must be defined in atomgroups file'3962:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: atom groups must be defined in atomgroups file'
3966:             STOP3963:             STOP
3967:          ENDIF3964:          ENDIF
3968:          IF (NITEMS.GT.1) CALL READI(GROUPROTFREQ)3965:          IF (NITEMS.GT.1) CALL READI(GROUPROTFREQ)
3969: ! csw34> if the frequency is 0, we need to disable the moves to present3966: ! csw34> if the frequency is 0, we need to disable the moves to present
3970: ! a divide by 0!3967: ! a divide by 0!
3971:          IF(GROUPROTFREQ.EQ.0) THEN3968:          IF(GROUPROTFREQ.EQ.0) THEN 
3972:             GROUPROTT=.FALSE.3969:             GROUPROTT=.FALSE.
3973:             WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of GROUPROTATION moves set to 0 - moves DISABLED!'3970:             WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of GROUPROTATION moves set to 0 - moves DISABLED!'
3974:          ENDIF3971:          ENDIF
3975: ! Specify GROUPROTATION move scaling mode amd inform the user3972: ! Specify GROUPROTATION move scaling mode amd inform the user
3976:          IF (NITEMS.GT.2) THEN3973:          IF (NITEMS.GT.2) THEN 
3977:             CALL READA(GR_SCALEMODE)3974:             CALL READA(GR_SCALEMODE)
3978:             IF(TRIM(ADJUSTL(GR_SCALEMODE)).EQ.'SCALEROT') THEN3975:             IF(TRIM(ADJUSTL(GR_SCALEMODE)).EQ.'SCALEROT') THEN
3979:                GR_SCALEROT=.TRUE.3976:                GR_SCALEROT=.TRUE.
3980:                WRITE(MYUNIT,'(A)') ' keyword> GROUPROTATION amplitudes will be scaled'3977:                WRITE(MYUNIT,'(A)') ' keyword> GROUPROTATION amplitudes will be scaled'
3981:             ELSEIF(TRIM(ADJUSTL(GR_SCALEMODE)).EQ.'SCALEPROB') THEN3978:             ELSEIF(TRIM(ADJUSTL(GR_SCALEMODE)).EQ.'SCALEPROB') THEN  
3982:                GR_SCALEPROB=.TRUE.3979:                GR_SCALEPROB=.TRUE.
3983:                WRITE(MYUNIT,'(A)') ' keyword> GROUPROTATION selection probabilities will be scaled'3980:                WRITE(MYUNIT,'(A)') ' keyword> GROUPROTATION selection probabilities will be scaled'
3984:             ELSEIF(TRIM(ADJUSTL(GR_SCALEMODE)).EQ.'SCALEBOTH') THEN3981:             ELSEIF(TRIM(ADJUSTL(GR_SCALEMODE)).EQ.'SCALEBOTH') THEN
3985:                GR_SCALEROT=.TRUE.3982:                GR_SCALEROT=.TRUE.
3986:                GR_SCALEPROB=.TRUE.3983:                GR_SCALEPROB=.TRUE.
3987:                WRITE(MYUNIT,'(A)') ' keyword> GROUPROTATION amplitudes and selection probabilities will be scaled'3984:                WRITE(MYUNIT,'(A)') ' keyword> GROUPROTATION amplitudes and selection probabilities will be scaled'
3988:             ENDIF3985:             ENDIF
3989:          ENDIF3986:          ENDIF
3990: ! Read atom offset for group definitions in atomgroups3987: ! Read atom offset for group definitions in atomgroups 
3991:          IF (NITEMS.GT.3) CALL READI(GROUPOFFSET)3988:          IF (NITEMS.GT.3) CALL READI(GROUPOFFSET)
3992: ! csw34> Figure out how many atom groups have been defined3989: ! csw34> Figure out how many atom groups have been defined
3993:          NGROUPS=03990:          NGROUPS=0
3994:          OPEN(UNIT=222,FILE='atomgroups',status='old')3991:          OPEN(UNIT=222,FILE='atomgroups',status='old')
3995:          DO3992:          DO
3996:             READ(222,*,IOSTAT=iostatus) CHECK13993:             READ(222,*,IOSTAT=iostatus) CHECK1
3997:             IF (iostatus<0) THEN3994:             IF (iostatus<0) THEN
3998:             CLOSE(222)3995:             CLOSE(222)
3999:             EXIT3996:             EXIT
4000:             ELSE IF (TRIM(ADJUSTL(check1)).EQ.'GROUP') then3997:             ELSE IF (TRIM(ADJUSTL(check1)).EQ.'GROUP') then
4001:                NGROUPS=NGROUPS+13998:                NGROUPS=NGROUPS+1
4002:             ENDIF3999:             ENDIF
4003:          END DO4000:          END DO        
4004:          CLOSE(222)4001:          CLOSE(222)
4005: ! csw34> Allocate atom group info arrays appropriately4002: ! csw34> Allocate atom group info arrays appropriately
4006:          ALLOCATE(ATOMGROUPNAMES(NGROUPS))4003:          ALLOCATE(ATOMGROUPNAMES(NGROUPS))
4007:          ALLOCATE(ATOMGROUPAXIS(NGROUPS,2))4004:          ALLOCATE(ATOMGROUPAXIS(NGROUPS,2))
4008:          ALLOCATE(ATOMGROUPPSELECT(NGROUPS))4005:          ALLOCATE(ATOMGROUPPSELECT(NGROUPS))
4009:          ALLOCATE(ATOMGROUPSCALING(NGROUPS))4006:          ALLOCATE(ATOMGROUPSCALING(NGROUPS))
4010:          ALLOCATE(ATOMGROUPS(NGROUPS,NATOMSALLOC))4007:          ALLOCATE(ATOMGROUPS(NGROUPS,NATOMSALLOC))
4011: ! csw34> Set safe defaults4008: ! csw34> Set safe defaults
4012:          ATOMGROUPS(:,:)=.FALSE.4009:          ATOMGROUPS(:,:)=.FALSE.
4013:          ATOMGROUPNAMES(:)='EMPTY'4010:          ATOMGROUPNAMES(:)='EMPTY'
4015:          ATOMGROUPSCALING(:)=1.0D04012:          ATOMGROUPSCALING(:)=1.0D0
4016:          ATOMGROUPPSELECT(:)=1.0D04013:          ATOMGROUPPSELECT(:)=1.0D0
4017: ! csw34> Read in group info4014: ! csw34> Read in group info
4018: ! Here is an example entry:4015: ! Here is an example entry:
4019: ! GROUP OME 6 5 4 1.04016: ! GROUP OME 6 5 4 1.0
4020: ! 14017: ! 1
4021: ! 24018: ! 2
4022: ! 34019: ! 3
4023: ! 44020: ! 4
4024: ! This says that group OME is to be rotated about the bond from atom 6->5.4021: ! This says that group OME is to be rotated about the bond from atom 6->5.
4025: ! There are 4 atoms in the OME group. Rotations of -pi->+pi are to be scaled by 1.0.4022: ! There are 4 atoms in the OME group. Rotations of -pi->+pi are to be scaled by 1.0. 
4026: ! Finally, the group members are specified one per line4023: ! Finally, the group members are specified one per line
4027:          OPEN(UNIT=222,FILE='atomgroups',status='unknown')4024:          OPEN(UNIT=222,FILE='atomgroups',status='unknown')
4028:          WRITE(MYUNIT,*) 'keyword> Reading in atom groups for GROUPROTATION'4025:          WRITE(MYUNIT,*) 'keyword> Reading in atom groups for GROUPROTATION'
4029:          IF(GROUPOFFSET.NE.0) WRITE(MYUNIT,*) 'keyword> Group atom numbering offset by ',GROUPOFFSET4026:          IF(GROUPOFFSET.NE.0) WRITE(MYUNIT,*) 'keyword> Group atom numbering offset by ',GROUPOFFSET
4030:          DO J1=1,NGROUPS4027:          DO J1=1,NGROUPS
4031:             READ(222,*) CHECK1,ATOMGROUPNAMES(J1),AXIS1,AXIS2,GROUPSIZE,ATOMGROUPSCALING(J1),4028:             READ(222,*) CHECK1,ATOMGROUPNAMES(J1),AXIS1,AXIS2,GROUPSIZE,ATOMGROUPSCALING(J1),
4032:      &                       ATOMGROUPPSELECT(J1)4029:      &                       ATOMGROUPPSELECT(J1) 
4033:             ATOMGROUPAXIS(J1,1)=AXIS1+GROUPOFFSET4030:             ATOMGROUPAXIS(J1,1)=AXIS1+GROUPOFFSET
4034:             ATOMGROUPAXIS(J1,2)=AXIS2+GROUPOFFSET4031:             ATOMGROUPAXIS(J1,2)=AXIS2+GROUPOFFSET
4035:             CALL FLUSH(MYUNIT)4032:             CALL FLUSH(MYUNIT)
4036:             IF (TRIM(ADJUSTL(CHECK1)).EQ.'GROUP') THEN4033:             IF (TRIM(ADJUSTL(CHECK1)).EQ.'GROUP') THEN
4037:                DO J2=1,GROUPSIZE4034:                DO J2=1,GROUPSIZE
4038:                   READ(222,*) GROUPATOM4035:                   READ(222,*) GROUPATOM
4039:                   IF(GROUPOFFSET.GT.0) GROUPATOM=GROUPATOM+GROUPOFFSET4036:                   IF(GROUPOFFSET.GT.0) GROUPATOM=GROUPATOM+GROUPOFFSET
4040: ! hk286 - add bound checks4037: ! hk286 - add bound checks
4041:                   IF (GROUPATOM > NATOMSALLOC) THEN4038:                   IF (GROUPATOM > NATOMSALLOC) THEN
4042:                      WRITE(MYUNIT,'(A)') ' keyword: ERROR! GROUPATOM > NATOMSALLOC'4039:                      WRITE(MYUNIT,'(A)') ' keyword: ERROR! GROUPATOM > NATOMSALLOC'
4043:                   ENDIF4040:                   ENDIF
4044: ! hk2864041: ! hk286
4045:                   ATOMGROUPS(J1,GROUPATOM)=.TRUE.4042:                   ATOMGROUPS(J1,GROUPATOM)=.TRUE. 
4046:                END DO4043:                END DO 
4047:             ELSE4044:             ELSE
4048:                WRITE(MYUNIT,'(A)') ' keyword: ERROR! Group file not formatted correctly!'4045:                WRITE(MYUNIT,'(A)') ' keyword: ERROR! Group file not formatted correctly!'
4049:                STOP4046:                STOP
4050:             ENDIF4047:             ENDIF
4051:             WRITE(MYUNIT,'(3A)') '<GROUP ',TRIM(ADJUSTL(ATOMGROUPNAMES(J1))),'>'4048:             WRITE(MYUNIT,'(3A)') '<GROUP ',TRIM(ADJUSTL(ATOMGROUPNAMES(J1))),'>'
4052:             WRITE(MYUNIT,'(A,I3)') 'Index: ',J14049:             WRITE(MYUNIT,'(A,I3)') 'Index: ',J1
4053:             WRITE(MYUNIT,'(A,I4)') 'Size: ',GROUPSIZE4050:             WRITE(MYUNIT,'(A,I4)') 'Size: ',GROUPSIZE
4054:             WRITE(MYUNIT,'(A,2I6)') 'Atoms defining axis: ',ATOMGROUPAXIS(J1,1),ATOMGROUPAXIS(J1,2)4051:             WRITE(MYUNIT,'(A,2I6)') 'Atoms defining axis: ',ATOMGROUPAXIS(J1,1),ATOMGROUPAXIS(J1,2)
4055:             WRITE(MYUNIT,'(A,F5.2)') 'Rotation scaling: ',ATOMGROUPSCALING(J1)4052:             WRITE(MYUNIT,'(A,F5.2)') 'Rotation scaling: ',ATOMGROUPSCALING(J1)
4056:             WRITE(MYUNIT,'(A,F5.4)') 'Selection probablity: ',ATOMGROUPPSELECT(J1)4053:             WRITE(MYUNIT,'(A,F5.4)') 'Selection probablity: ',ATOMGROUPPSELECT(J1)
4059:                IF(ATOMGROUPS(J1,J2)) WRITE(MYUNIT,*) J24056:                IF(ATOMGROUPS(J1,J2)) WRITE(MYUNIT,*) J2
4060:             ENDDO4057:             ENDDO
4061:          ENDDO4058:          ENDDO
4062:          CLOSE(222)4059:          CLOSE(222)
4063: 4060: 
4064: ! Keyword to suppress output of group rotation moves4061: ! Keyword to suppress output of group rotation moves
4065:       ELSE IF (WORD .EQ. 'QUIETGROUPROT') THEN4062:       ELSE IF (WORD .EQ. 'QUIETGROUPROT') THEN
4066:          GROUPROT_SUPPRESS = .TRUE.4063:          GROUPROT_SUPPRESS = .TRUE.
4067: 4064: 
4068: 4065: 
4069: ! ab2111> Group rotation moves for dihedral angles4066: ! ab2111> Group rotation moves for dihedral angles 
4070:       ELSE IF (WORD.EQ.'DIHEDRALROTATION') THEN4067:       ELSE IF (WORD.EQ.'DIHEDRALROTATION') THEN
4071: ! Check the group file is present4068: ! Check the group file is present
4072:          YESNO=.FALSE.4069:          YESNO=.FALSE.
4073:          INQUIRE(FILE='dihedralgroups',EXIST=YESNO)4070:          INQUIRE(FILE='dihedralgroups',EXIST=YESNO)
4074:          IF (YESNO) THEN4071:          IF (YESNO) THEN
4075:             DIHEDRALROTT=.TRUE.4072:             DIHEDRALROTT=.TRUE.
4076:             WRITE(MYUNIT,'(A)') ' keyword> AMBER dihedral group rotation moves enabled'4073:             WRITE(MYUNIT,'(A)') ' keyword> AMBER dihedral group rotation moves enabled'
4077:          ELSE4074:          ELSE
4078:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: atom groups must be defined in dihedralgroups file'4075:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: atom groups must be defined in dihedralgroups file'
4079:             STOP4076:             STOP
4080:          ENDIF4077:          ENDIF
4081:          IF (NITEMS.GT.1) CALL READI(DIHEDRALROTFREQ)4078:          IF (NITEMS.GT.1) CALL READI(DIHEDRALROTFREQ)
4082: ! if the frequency is 0, we need to disable the moves to present4079: ! if the frequency is 0, we need to disable the moves to present
4083: ! a divide by 0!4080: ! a divide by 0!
4084:          IF(DIHEDRALROTFREQ.EQ.0) THEN4081:          IF(DIHEDRALROTFREQ.EQ.0) THEN 
4085:             DIHEDRALROTT=.FALSE.4082:             DIHEDRALROTT=.FALSE.
4086:             WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of DIHEDRALROTATION moves set to 0 - moves DISABLED!'4083:             WRITE(MYUNIT,'(A)') ' keyword> WARNING: frequency of DIHEDRALROTATION moves set to 0 - moves DISABLED!'
4087:          ENDIF4084:          ENDIF
4088:          IF (NITEMS.GT.2) CALL READI(DIHEDRALOFFSET)4085:          IF (NITEMS.GT.2) CALL READI(DIHEDRALOFFSET)
4089: 4086: 
4090: ! Figure out how many atom groups have been defined4087: ! Figure out how many atom groups have been defined
4091:          NDIHEDRALGROUPS=04088:          NDIHEDRALGROUPS=0
4092:          OPEN(UNIT=223,FILE='dihedralgroups',status='old')4089:          OPEN(UNIT=223,FILE='dihedralgroups',status='old')
4093:          DO4090:          DO
4094:             READ(223,*,IOSTAT=iostatus) CHECK14091:             READ(223,*,IOSTAT=iostatus) CHECK1
4095:             IF (iostatus<0) THEN4092:             IF (iostatus<0) THEN
4096:             CLOSE(223)4093:             CLOSE(223)
4097:             EXIT4094:             EXIT
4098:             ELSE IF (TRIM(ADJUSTL(check1)).EQ.'GROUP') then4095:             ELSE IF (TRIM(ADJUSTL(check1)).EQ.'GROUP') then
4099:                NDIHEDRALGROUPS=NDIHEDRALGROUPS+14096:                NDIHEDRALGROUPS=NDIHEDRALGROUPS+1
4100:             ENDIF4097:             ENDIF
4101:          END DO4098:          END DO        
4102:          CLOSE(223)4099:          CLOSE(223)
4103: ! Allocate atom group info arrays appropriately4100: ! Allocate atom group info arrays appropriately
4104:          ALLOCATE(DIHEDRALGROUPNAMES(NDIHEDRALGROUPS))4101:          ALLOCATE(DIHEDRALGROUPNAMES(NDIHEDRALGROUPS))
4105:          ALLOCATE(ANGLETYPE(NDIHEDRALGROUPS))4102:          ALLOCATE(ANGLETYPE(NDIHEDRALGROUPS))
4106:          ALLOCATE(DIHEDRALGROUPAXIS(NDIHEDRALGROUPS,4))4103:          ALLOCATE(DIHEDRALGROUPAXIS(NDIHEDRALGROUPS,4))
4107:          ALLOCATE(DIHEDRALGROUPPSELECT(NDIHEDRALGROUPS))4104:          ALLOCATE(DIHEDRALGROUPPSELECT(NDIHEDRALGROUPS))
4108:          ALLOCATE(DIHEDRALGROUPSCALING(NDIHEDRALGROUPS))4105:          ALLOCATE(DIHEDRALGROUPSCALING(NDIHEDRALGROUPS))
4109:          ALLOCATE(DIHEDRALGROUPS(NDIHEDRALGROUPS,NATOMSALLOC))4106:          ALLOCATE(DIHEDRALGROUPS(NDIHEDRALGROUPS,NATOMSALLOC))
4110: !  Set safe defaults4107: !  Set safe defaults
4111:          DIHEDRALGROUPS(:,:)=.FALSE.4108:          DIHEDRALGROUPS(:,:)=.FALSE.
4114:          DIHEDRALGROUPAXIS(:,:)=04111:          DIHEDRALGROUPAXIS(:,:)=0
4115:          DIHEDRALGROUPSCALING(:)=1.0D04112:          DIHEDRALGROUPSCALING(:)=1.0D0
4116:          DIHEDRALGROUPPSELECT(:)=1.0D04113:          DIHEDRALGROUPPSELECT(:)=1.0D0
4117: !  Read in group info4114: !  Read in group info
4118: ! Here is an example entry:4115: ! Here is an example entry:
4119: ! GROUP OME <phi> 8 7 6 5 Natoms Scaling RotProbability4116: ! GROUP OME <phi> 8 7 6 5 Natoms Scaling RotProbability
4120: ! 14117: ! 1
4121: ! 24118: ! 2
4122: ! 34119: ! 3
4123: ! 44120: ! 4
4124: ! This says that group OME, angle type <phi> (used for printing purposes only)4121: ! This says that group OME, angle type <phi> (used for printing purposes only) 
4125: ! is to be rotated about the dihedral angle defined by atoms 8 7 6 5.4122: ! is to be rotated about the dihedral angle defined by atoms 8 7 6 5.
4126: ! Natoms = number of atoms to be rotated ( number of subsequent lines before next GROUP declaration4123: ! Natoms = number of atoms to be rotated ( number of subsequent lines before next GROUP declaration
4127: ! Scaling : uniform perturbation steps within range phi-pi*Scaling and phi+pi*Scaling4124: ! Scaling : uniform perturbation steps within range phi-pi*Scaling and phi+pi*Scaling
4128: ! RotProbability : probability of performing this trial move per MC step4125: ! RotProbability : probability of performing this trial move per MC step
4129: 4126: 
4130: ! Finally, the group members are specified one per line4127: ! Finally, the group members are specified one per line
4131:          OPEN(UNIT=223,FILE='dihedralgroups',status='unknown')4128:          OPEN(UNIT=223,FILE='dihedralgroups',status='unknown')
4132:          WRITE(MYUNIT,*) 'keyword> Reading in atom groups for DIHEDRALROTATION'4129:          WRITE(MYUNIT,*) 'keyword> Reading in atom groups for DIHEDRALROTATION'
4133:          IF(DIHEDRALOFFSET.NE.0) WRITE(MYUNIT,*) 'keyword> Group atom numbering offset by ',DIHEDRALOFFSET4130:          IF(DIHEDRALOFFSET.NE.0) WRITE(MYUNIT,*) 'keyword> Group atom numbering offset by ',DIHEDRALOFFSET
4134:          DO J1=1,NDIHEDRALGROUPS4131:          DO J1=1,NDIHEDRALGROUPS
4135:             READ(223,*) CHECK1,DIHEDRALGROUPNAMES(J1),ANGLETYPE(J1),A1,A2,A3,A4,4132:             READ(223,*) CHECK1,DIHEDRALGROUPNAMES(J1),ANGLETYPE(J1),A1,A2,A3,A4,
4136:      &       dihedralgroupsize,DIHEDRALGROUPSCALING(J1),DIHEDRALGROUPPSELECT(J1)4133:      &       dihedralgroupsize,DIHEDRALGROUPSCALING(J1),DIHEDRALGROUPPSELECT(J1) 
4137: !            READ(223,*) CHECK1,DIHEDRALGROUPNAMES(J1),A1,A2,A3,A4,GROUPSIZE,ATOMGROUPSCALING(J1),4134: !            READ(223,*) CHECK1,DIHEDRALGROUPNAMES(J1),A1,A2,A3,A4,GROUPSIZE,ATOMGROUPSCALING(J1),
4138: !     &                       ATOMGROUPPSELECT(J1)4135: !     &                       ATOMGROUPPSELECT(J1) 
4139:             DIHEDRALGROUPAXIS(J1,1)=A1+DIHEDRALOFFSET4136:             DIHEDRALGROUPAXIS(J1,1)=A1+DIHEDRALOFFSET
4140:             DIHEDRALGROUPAXIS(J1,2)=A2+DIHEDRALOFFSET4137:             DIHEDRALGROUPAXIS(J1,2)=A2+DIHEDRALOFFSET
4141:             DIHEDRALGROUPAXIS(J1,3)=A3+DIHEDRALOFFSET4138:             DIHEDRALGROUPAXIS(J1,3)=A3+DIHEDRALOFFSET
4142:             DIHEDRALGROUPAXIS(J1,4)=A4+DIHEDRALOFFSET4139:             DIHEDRALGROUPAXIS(J1,4)=A4+DIHEDRALOFFSET
4143:             CALL FLUSH(MYUNIT)4140:             CALL FLUSH(MYUNIT)
4144:             IF (TRIM(ADJUSTL(CHECK1)).EQ.'GROUP') THEN4141:             IF (TRIM(ADJUSTL(CHECK1)).EQ.'GROUP') THEN
4145:                DO J2=1,dihedralgroupsize4142:                DO J2=1,dihedralgroupsize
4146:                   READ(223,*) GROUPATOM4143:                   READ(223,*) GROUPATOM
4147:                   IF(dihedraloffset.GT.0) GROUPATOM=GROUPATOM+dihedraloffset4144:                   IF(dihedraloffset.GT.0) GROUPATOM=GROUPATOM+dihedraloffset
4148: ! - add bound checks4145: ! - add bound checks
4149:                   IF (GROUPATOM > NATOMSALLOC) THEN4146:                   IF (GROUPATOM > NATOMSALLOC) THEN
4150:                      WRITE(MYUNIT,'(A)') ' keyword: ERROR! GROUPATOM > NATOMSALLOC'4147:                      WRITE(MYUNIT,'(A)') ' keyword: ERROR! GROUPATOM > NATOMSALLOC'
4151:                   ENDIF4148:                   ENDIF
4152:                   DIHEDRALGROUPS(J1,GROUPATOM)=.TRUE.4149:                   DIHEDRALGROUPS(J1,GROUPATOM)=.TRUE. 
4153:                END DO4150:                END DO 
4154:             ELSE4151:             ELSE
4155:                WRITE(MYUNIT,'(A)') ' keyword: ERROR! Group file not formatted correctly!'4152:                WRITE(MYUNIT,'(A)') ' keyword: ERROR! Group file not formatted correctly!'
4156:                STOP4153:                STOP
4157:             ENDIF4154:             ENDIF
4158:             WRITE(MYUNIT,'(3A)') '<GROUP ',TRIM(ADJUSTL(DIHEDRALGROUPNAMES(J1))),'>'4155:             WRITE(MYUNIT,'(3A)') '<GROUP ',TRIM(ADJUSTL(DIHEDRALGROUPNAMES(J1))),'>'
4159:             WRITE(MYUNIT,'(A,I3)') 'Index: ',J14156:             WRITE(MYUNIT,'(A,I3)') 'Index: ',J1
4160:             WRITE(MYUNIT,'(A,I4)') 'Size: ',dihedralgroupsize4157:             WRITE(MYUNIT,'(A,I4)') 'Size: ',dihedralgroupsize
4161:             WRITE(MYUNIT,'(A,4I5)') 'Atoms defining dihedral: ',DIHEDRALGROUPAXIS(J1,1),DIHEDRALGROUPAXIS(J1,2),4158:             WRITE(MYUNIT,'(A,4I5)') 'Atoms defining dihedral: ',DIHEDRALGROUPAXIS(J1,1),DIHEDRALGROUPAXIS(J1,2),
4162:      &       DIHEDRALGROUPAXIS(J1,2),DIHEDRALGROUPAXIS(J1,2)4159:      &       DIHEDRALGROUPAXIS(J1,2),DIHEDRALGROUPAXIS(J1,2)
4163:             WRITE(MYUNIT,'(A,F5.2)') 'Rotation scaling: ',DIHEDRALGROUPSCALING(J1)4160:             WRITE(MYUNIT,'(A,F5.2)') 'Rotation scaling: ',DIHEDRALGROUPSCALING(J1)
4164:             WRITE(MYUNIT,'(A,F5.2)') 'Selection probablity: ',DIHEDRALGROUPPSELECT(J1)4161:             WRITE(MYUNIT,'(A,F5.2)') 'Selection probablity: ',DIHEDRALGROUPPSELECT(J1)
4165:             WRITE(MYUNIT,'(A)') 'Members:'4162:             WRITE(MYUNIT,'(A)') 'Members:'
4166:             DO J2=1,NATOMSALLOC4163:             DO J2=1,NATOMSALLOC
4167:                IF(DIHEDRALGROUPS(J1,J2)) WRITE(MYUNIT,*) J24164:                IF(DIHEDRALGROUPS(J1,J2)) WRITE(MYUNIT,*) J2
4168:             ENDDO4165:             ENDDO
4169:          ENDDO4166:          ENDDO
4170:          CLOSE(223)4167:          CLOSE(223)
4171: 4168:       
4172:       ELSE IF (WORD.EQ.'BGSMOVE') THEN4169:       ELSE IF (WORD.EQ.'BGSMOVE') THEN
4173:             BGSMOVE=.TRUE.4170:             BGSMOVE=.TRUE. 
4174:             ! check that DIHEDRALROTATION is turned on4171:             ! check that DIHEDRALROTATION is turned on
4175:             IF (DIHEDRALROTT.EQV..FALSE.) THEN4172:             IF (DIHEDRALROTT.EQV..FALSE.) THEN
4176:                WRITE(MYUNIT,*) "DIHEDRALROTATION must be turned on for BGSMOVE"4173:                WRITE(MYUNIT,*) "DIHEDRALROTATION must be turned on for BGSMOVE"
4177:                STOP4174:                STOP
4178:             ENDIF4175:             ENDIF
4179:          IF (NITEMS.GT.1) THEN4176:          IF (NITEMS.GT.1) THEN
4180:                CALL READF(bgsb1)4177:                CALL READF(bgsb1)
4181:                CALL READF(bgsb2)4178:                CALL READF(bgsb2)
4182:                CALL READF(pselectBGS)4179:                CALL READF(pselectBGS)
4183:          ENDIF4180:          ENDIF
4227:          YESNO=.FALSE.4224:          YESNO=.FALSE.
4228:          INQUIRE(FILE='hbond_matrix.sh',EXIST=YESNO)4225:          INQUIRE(FILE='hbond_matrix.sh',EXIST=YESNO)
4229:          IF (YESNO) THEN4226:          IF (YESNO) THEN
4230:             HBONDMATRIX=.TRUE.4227:             HBONDMATRIX=.TRUE.
4231:          ELSE4228:          ELSE
4232:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: NEED hbond_matrix.sh SCRIPT TO USE HBONDMATRIX'4229:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: NEED hbond_matrix.sh SCRIPT TO USE HBONDMATRIX'
4233:             STOP4230:             STOP
4234:          ENDIF4231:          ENDIF
4235:          CALL READA(HBONDDONORSACCEPTORS)4232:          CALL READA(HBONDDONORSACCEPTORS)
4236:          CALL READA(HBONDRESIDUES)4233:          CALL READA(HBONDRESIDUES)
4237: 4234:          
4238: ! Count how many residues are of interest4235: ! Count how many residues are of interest
4239:          OPEN(UNIT=20,FILE=TRIM(ADJUSTL(HBONDRESIDUES)),STATUS='OLD')4236:          OPEN(UNIT=20,FILE=TRIM(ADJUSTL(HBONDRESIDUES)),STATUS='OLD')
4240:          HBONDNRES=04237:          HBONDNRES=0
4241:          DO4238:          DO
4242:             READ(20,*,IOSTAT=EOF)4239:             READ(20,*,IOSTAT=EOF)
4243:             IF (EOF==0) THEN4240:             IF (EOF==0) THEN
4244:                HBONDNRES = HBONDNRES + 14241:                HBONDNRES = HBONDNRES + 1
4245:             ELSE4242:             ELSE
4246:                EXIT4243:                EXIT
4247:             ENDIF4244:             ENDIF
4248:          ENDDO4245:          ENDDO
4249:          CLOSE(20)4246:          CLOSE(20)
4250: ! Print some info4247: ! Print some info
4251:          WRITE(MYUNIT,'(A,I5,A)') ' keyword> Hydrogen-bond matrix includes ',HBONDNRES,' residues'4248:          WRITE(MYUNIT,'(A,I5,A)') ' keyword> Hydrogen-bond matrix includes ',HBONDNRES,' residues' 
4252: ! Optional mode switch for hydrogen-bond matrix analysis4249: ! Optional mode switch for hydrogen-bond matrix analysis
4253:          IF (NITEMS.GT.3) THEN4250:          IF (NITEMS.GT.3) THEN
4254:             CALL READA(HBONDTYPE)4251:             CALL READA(HBONDTYPE)
4255: ! If the third arguement is set to REJECT - all steps which move to a new group are rejected4252: ! If the third arguement is set to REJECT - all steps which move to a new group are rejected
4256:             IF (HBONDTYPE.EQ.'REJECT') HBONDACCEPT=.FALSE.4253:             IF (HBONDTYPE.EQ.'REJECT') HBONDACCEPT=.FALSE.
4257:          ENDIF4254:          ENDIF
4258: 4255: 
4259: ! csw34> Consider only the ligand when accepting/rejecting based on hydrogen-bonding4256: ! csw34> Consider only the ligand when accepting/rejecting based on hydrogen-bonding
4260:       ELSE IF (WORD.EQ.'HBONDLIGAND') THEN4257:       ELSE IF (WORD.EQ.'HBONDLIGAND') THEN
4261:             IF (.NOT.HBONDMATRIX) THEN4258:             IF (.NOT.HBONDMATRIX) THEN
4262:                WRITE(MYUNIT,'(A)') ' keyword> ERROR: HBONDLIGAND must appear after HBONDMATRIX in data!'4259:                WRITE(MYUNIT,'(A)') ' keyword> ERROR: HBONDLIGAND must appear after HBONDMATRIX in data!'
4263:                STOP4260:                STOP
4264:             ENDIF4261:             ENDIF
4265:             HBONDLIGAND=.TRUE.4262:             HBONDLIGAND=.TRUE.
4266:             IF (NITEMS.GT.1) THEN4263:             IF (NITEMS.GT.1) THEN
4267:                CALL READI(HBONDLIGANDN)4264:                CALL READI(HBONDLIGANDN)
4268:             ELSE4265:             ELSE
4269:                HBONDLIGANDN=HBONDNRES4266:                HBONDLIGANDN=HBONDNRES
4270:             ENDIF4267:             ENDIF 
4271:             WRITE(MYUNIT,'(A)') ' keyword> HBONDLIGAND: Only bonds to the ligand will be considered in HBONDMATRIX grouping'4268:             WRITE(MYUNIT,'(A)') ' keyword> HBONDLIGAND: Only bonds to the ligand will be considered in HBONDMATRIX grouping'
4272: 4269: 
4273: 4270: 
4274: ! csw34> Set the window size for the soft cutoffs to custom values4271: ! csw34> Set the window size for the soft cutoffs to custom values
4275:       ELSE IF (WORD.EQ.'HBONDSOFTCUT') THEN4272:       ELSE IF (WORD.EQ.'HBONDSOFTCUT') THEN
4276:          IF (HBONDMATRIX) THEN4273:          IF (HBONDMATRIX) THEN  
4277:             CALL READA(HBONDDCUTLOOSE)4274:             CALL READA(HBONDDCUTLOOSE)
4278:             CALL READA(HBONDDCUTTIGHT)4275:             CALL READA(HBONDDCUTTIGHT)
4279:             WRITE(MYUNIT,'(4A)') ' keyword> HBONDSOFTCUT: Soft distance cutoff set to ',TRIM(ADJUSTL(HBONDDCUTLOOSE)),4276:             WRITE(MYUNIT,'(4A)') ' keyword> HBONDSOFTCUT: Soft distance cutoff set to ',TRIM(ADJUSTL(HBONDDCUTLOOSE)),
4280:      &                          ' - ',TRIM(ADJUSTL(HBONDDCUTTIGHT))4277:      &                          ' - ',TRIM(ADJUSTL(HBONDDCUTTIGHT))
4281:             CALL READA(HBONDACUTLOOSE)4278:             CALL READA(HBONDACUTLOOSE)
4282:             CALL READA(HBONDACUTTIGHT)4279:             CALL READA(HBONDACUTTIGHT)
4283:             WRITE(MYUNIT,'(4A)') ' keyword> HBONDSOFTCUT: Soft angle cutoff set to ',TRIM(ADJUSTL(HBONDACUTLOOSE)),4280:             WRITE(MYUNIT,'(4A)') ' keyword> HBONDSOFTCUT: Soft angle cutoff set to ',TRIM(ADJUSTL(HBONDACUTLOOSE)),
4284:      &                          ' - ',TRIM(ADJUSTL(HBONDACUTTIGHT))4281:      &                          ' - ',TRIM(ADJUSTL(HBONDACUTTIGHT))
4285:          ELSE4282:          ELSE
4286:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: HBONDSOFTCUT can only be used with HBONDMATRIX'4283:             WRITE(MYUNIT,'(A)') ' keyword> ERROR: HBONDSOFTCUT can only be used with HBONDMATRIX'
4327:          CALL READF(XX)4324:          CALL READF(XX)
4328:          FIH=XX4325:          FIH=XX
4329:          IF (NITEMS.GT.2) THEN4326:          IF (NITEMS.GT.2) THEN
4330:             CALL READF(XX)4327:             CALL READF(XX)
4331:             EXPFAC=XX4328:             EXPFAC=XX
4332:          ENDIF4329:          ENDIF
4333:          IF (NITEMS.GT.3) THEN4330:          IF (NITEMS.GT.3) THEN
4334:             CALL READF(XX)4331:             CALL READF(XX)
4335:             EXPD=XX4332:             EXPD=XX
4336:          ENDIF4333:          ENDIF
4337: !4334: ! 
4338: ! Maximum active atoms in QCI procedure.4335: ! Maximum active atoms in QCI procedure.
4339: !4336: !        
4340:       ELSE IF (WORD.EQ.'QCIMAXACTIVE') THEN4337:       ELSE IF (WORD.EQ.'QCIMAXACTIVE') THEN
4341:          CALL READI(MAXNACTIVE)4338:          CALL READI(MAXNACTIVE)
4342: 4339: 
4343:       ELSE IF (WORD.EQ.'INTMIN') THEN4340:       ELSE IF (WORD.EQ.'INTMIN') THEN
4344:          INTMINT=.TRUE.4341:          INTMINT=.TRUE.
4345:       ELSE IF (WORD.EQ.'QCIPERMCHECK') THEN4342:       ELSE IF (WORD.EQ.'QCIPERMCHECK') THEN
4346:          QCIPERMCHECK=.TRUE.4343:          QCIPERMCHECK=.TRUE.
4347:          CALL READI(QCIPERMCHECKINT)4344:          CALL READI(QCIPERMCHECKINT)
4348: !4345: !
4349: ! Images for INTCONSTRAINT4346: ! Images for INTCONSTRAINT
4502: ! Only include spring gradients for active atoms.4499: ! Only include spring gradients for active atoms.
4503: !4500: !
4504:       ELSE IF (WORD.EQ.'INTSPRINGACTIVE') THEN4501:       ELSE IF (WORD.EQ.'INTSPRINGACTIVE') THEN
4505:          INTSPRINGACTIVET=.TRUE.4502:          INTSPRINGACTIVET=.TRUE.
4506: !4503: !
4507: ! KINT: force constant for springs in INTCONSTRAINT calculations.4504: ! KINT: force constant for springs in INTCONSTRAINT calculations.
4508: ! Default zero.4505: ! Default zero.
4509: !4506: !
4510:          ELSE IF (WORD.EQ.'KINT') THEN4507:          ELSE IF (WORD.EQ.'KINT') THEN
4511:             CALL READF(KINT)4508:             CALL READF(KINT)
4512: 4509:  
4513:       ELSE IF (WORD.EQ.'JM') THEN4510:       ELSE IF (WORD.EQ.'JM') THEN
4514:          JMT=.TRUE.4511:          JMT=.TRUE.
4515: 4512: 
4516:       ELSE IF (WORD.EQ.'JUMPMOVE') THEN4513:       ELSE IF (WORD.EQ.'JUMPMOVE') THEN
4517:          CALL READI(IX)4514:          CALL READI(IX)
4518:          JUMPMOVE(IX)=.TRUE.4515:          JUMPMOVE(IX)=.TRUE.
4519:          CALL READI(JUMPTO(IX))4516:          CALL READI(JUMPTO(IX))
4520:          JDUMP(JUMPTO(IX))=.TRUE.4517:          JDUMP(JUMPTO(IX))=.TRUE.
4521:          IF (NITEMS.GT.3) CALL READI(JUMPINT(IX))4518:          IF (NITEMS.GT.3) CALL READI(JUMPINT(IX))
4522: 4519: 
4790: 4787: 
4791:          DEALLOCATE(TARGETS)4788:          DEALLOCATE(TARGETS)
4792: 4789: 
4793: !4790: !
4794: !  MPI keyword4791: !  MPI keyword
4795: !4792: !
4796:       ELSE IF (WORD.EQ.'MPI') THEN4793:       ELSE IF (WORD.EQ.'MPI') THEN
4797:          MPIT=.TRUE.4794:          MPIT=.TRUE.
4798:          DEALLOCATE(FIXSTEP,FIXTEMP,FIXBOTH,TEMP,ACCRAT,STEP,ASTEP,OSTEP,BLOCK,NT,JUMPMOVE,JUMPINT,JDUMP,COORDS,LABELS,NQ,4795:          DEALLOCATE(FIXSTEP,FIXTEMP,FIXBOTH,TEMP,ACCRAT,STEP,ASTEP,OSTEP,BLOCK,NT,JUMPMOVE,JUMPINT,JDUMP,COORDS,LABELS,NQ,
4799:      &        JUMPTO,EPREV,COORDSO,LABELSO,VAT,VATO,SHELLMOVES,PTGROUP,NSURFMOVES,NCORE)4796:      &        JUMPTO,EPREV,COORDSO,LABELSO,VAT,VATO,SHELLMOVES,PTGROUP,NSURFMOVES,NCORE)
4800: 4797:          
4801:          ALLOCATE( FIXSTEP(NPAR),FIXTEMP(NPAR),FIXBOTH(NPAR),TEMP(NPAR),ACCRAT(NPAR),STEP(NPAR),ASTEP(NPAR),OSTEP(NPAR),4798:          ALLOCATE( FIXSTEP(NPAR),FIXTEMP(NPAR),FIXBOTH(NPAR),TEMP(NPAR),ACCRAT(NPAR),STEP(NPAR),ASTEP(NPAR),OSTEP(NPAR),
4802:      &        BLOCK(NPAR),NT(NPAR),JUMPMOVE(NPAR),JUMPINT(NPAR),JDUMP(NPAR),COORDS(3*NATOMSALLOC,NPAR),NQ(NPAR),4799:      &        BLOCK(NPAR),NT(NPAR),JUMPMOVE(NPAR),JUMPINT(NPAR),JDUMP(NPAR),COORDS(3*NATOMSALLOC,NPAR),NQ(NPAR),
4803:      &        JUMPTO(NPAR),EPREV(NPAR),COORDSO(3*NATOMSALLOC,NPAR),VAT(NATOMSALLOC,NPAR),VATO(NATOMSALLOC,NPAR),4800:      &        JUMPTO(NPAR),EPREV(NPAR),COORDSO(3*NATOMSALLOC,NPAR),VAT(NATOMSALLOC,NPAR),VATO(NATOMSALLOC,NPAR),
4804:      &        LABELS(NATOMSALLOC,NPAR),LABELSO(NATOMSALLOC,NPAR) )4801:      &        LABELS(NATOMSALLOC,NPAR),LABELSO(NATOMSALLOC,NPAR) )
4805:          ALLOCATE(SHELLMOVES(NPAR))4802:          ALLOCATE(SHELLMOVES(NPAR))
4806:          ALLOCATE(PTGROUP(NPAR))4803:          ALLOCATE(PTGROUP(NPAR))
4807:          ALLOCATE(NSURFMOVES(NPAR))4804:          ALLOCATE(NSURFMOVES(NPAR))
4808:          ALLOCATE(NCORE(NPAR))4805:          ALLOCATE(NCORE(NPAR))
4809:          DO JP=1,NPAR4806:          DO JP=1,NPAR
4810:             EPREV(JP)=1.0D1004807:             EPREV(JP)=1.0D100
4834:          MSTRANST=.TRUE.4831:          MSTRANST=.TRUE.
4835: 4832: 
4836:       ELSE IF (WORD.EQ.'MULLERBROWN') THEN4833:       ELSE IF (WORD.EQ.'MULLERBROWN') THEN
4837:          MULLERBROWNT=.TRUE.4834:          MULLERBROWNT=.TRUE.
4838: 4835: 
4839:       ELSE IF (WORD.EQ.'MULTIPLICITY') THEN4836:       ELSE IF (WORD.EQ.'MULTIPLICITY') THEN
4840:          CALL READI(XMUL)4837:          CALL READI(XMUL)
4841: 4838: 
4842:       ELSE IF (WORD .EQ. 'MULTIPOT') THEN4839:       ELSE IF (WORD .EQ. 'MULTIPOT') THEN
4843:          MULTIPOTT = .TRUE.4840:          MULTIPOTT = .TRUE.
4844: 4841:          
4845: !4842: !
4846: ! NOT DOCUMENTED4843: ! NOT DOCUMENTED
4847: !4844: !
4848:       ELSE IF (WORD.EQ.'MYSD') THEN4845:       ELSE IF (WORD.EQ.'MYSD') THEN
4849:          MYSDT=.TRUE.4846:          MYSDT=.TRUE.
4850:          CALL READF(SDTOL)4847:          CALL READF(SDTOL)
4851: 4848: 
4852:       ELSE IF (WORD.EQ.'NATB') THEN4849:       ELSE IF (WORD.EQ.'NATB') THEN
4853:          NATBT=.TRUE.4850:          NATBT=.TRUE.
4854: 4851: 
4869: !  Reseed runs if the energy does not decrease within NRELAX mc steps.4866: !  Reseed runs if the energy does not decrease within NRELAX mc steps.
4870: !  NHSRESTART defines the number of hard sphere moves used to produce the new starting4867: !  NHSRESTART defines the number of hard sphere moves used to produce the new starting
4871: !  configuration. If NHSRESTART=0 then the geometry is changed using RESEED.4868: !  configuration. If NHSRESTART=0 then the geometry is changed using RESEED.
4872: !4869: !
4873:       ELSE IF (WORD.EQ.'NEWMOVES') THEN4870:       ELSE IF (WORD.EQ.'NEWMOVES') THEN
4874:          NEWMOVEST=.TRUE.4871:          NEWMOVEST=.TRUE.
4875:       ELSE IF (WORD.EQ.'GBHRESTART') THEN !<ds6564872:       ELSE IF (WORD.EQ.'GBHRESTART') THEN !<ds656
4876:          GBH_RESTART=.TRUE.4873:          GBH_RESTART=.TRUE.
4877:          CALL READI(GBH_NREJMAX)4874:          CALL READI(GBH_NREJMAX)
4878:          IF(NITEMS.GT.2) CALL READI(GBH_NAVOID)4875:          IF(NITEMS.GT.2) CALL READI(GBH_NAVOID)
4879: 4876:          
4880:       ELSE IF (WORD.EQ.'NEWRESTART') THEN4877:       ELSE IF (WORD.EQ.'NEWRESTART') THEN
4881:          NEWRESTART=.TRUE.4878:          NEWRESTART=.TRUE.
4882:          NEWRESTART_MD = .FALSE.                   ! lb4154879:          NEWRESTART_MD = .FALSE.                   ! lb415
4883:          NEWRES_TEMP = 0.0D04880:          NEWRES_TEMP = 0.0D0
4884:          IF (NITEMS.GT.1) CALL READI(NRELAX)4881:          IF (NITEMS.GT.1) CALL READI(NRELAX)
4885:          IF (NITEMS.GT.2) CALL READI(NHSRESTART)4882:          IF (NITEMS.GT.2) CALL READI(NHSRESTART)
4886:          IF (NITEMS.GT.3) CALL READA(WORD2)        ! lb4154883:          IF (NITEMS.GT.3) CALL READA(WORD2)        ! lb415
4887:          IF (WORD2.EQ.'MD') NEWRESTART_MD = .TRUE. ! lb4154884:          IF (WORD2.EQ.'MD') NEWRESTART_MD = .TRUE. ! lb415
4888:          IF (NITEMS.GT.4) THEN                     ! lb4154885:          IF (NITEMS.GT.4) THEN                     ! lb415
4889:             CALL READF(NEWRES_TEMP)4886:             CALL READF(NEWRES_TEMP)
4894:          IF (.NOT.ALLOCATED(MSBE)) ALLOCATE(MSBE(MAXSAVE))4891:          IF (.NOT.ALLOCATED(MSBE)) ALLOCATE(MSBE(MAXSAVE))
4895:          IF (.NOT.ALLOCATED(MSBCOORDS)) ALLOCATE(MSBCOORDS(3*NATOMSALLOC,MAXSAVE))4892:          IF (.NOT.ALLOCATED(MSBCOORDS)) ALLOCATE(MSBCOORDS(3*NATOMSALLOC,MAXSAVE))
4896: 4893: 
4897: !      ELSE IF (WORD.EQ.'NMAX') THEN4894: !      ELSE IF (WORD.EQ.'NMAX') THEN
4898: !         CALL READF(NMAX)4895: !         CALL READF(NMAX)
4899: !         WRITE(MYUNIT,'(A,F14.10)') 'NMAX=  ',NMAX4896: !         WRITE(MYUNIT,'(A,F14.10)') 'NMAX=  ',NMAX
4900: !4897: !
4901: !      ELSE IF (WORD.EQ.'NMIN') THEN4898: !      ELSE IF (WORD.EQ.'NMIN') THEN
4902: !         CALL READF(NMIN)4899: !         CALL READF(NMIN)
4903: !         WRITE(MYUNIT,'(A,F14.10)') 'NMIN=  ',NMIN4900: !         WRITE(MYUNIT,'(A,F14.10)') 'NMIN=  ',NMIN
4904: 4901:  
4905:       ELSE IF (WORD.EQ.'NOCHIRALCHECKS') THEN4902:       ELSE IF (WORD.EQ.'NOCHIRALCHECKS') THEN
4906:          CHECKCHIRALITY=.FALSE.4903:          CHECKCHIRALITY=.FALSE.
4907: 4904: 
4908:       ELSE IF (WORD.EQ.'UACHIRAL') THEN4905:       ELSE IF (WORD.EQ.'UACHIRAL') THEN
4909:          UACHIRAL=.TRUE.4906:          UACHIRAL=.TRUE.
4910: 4907: 
4911:       ELSE IF (WORD.EQ.'NOCISTRANS') THEN4908:       ELSE IF (WORD.EQ.'NOCISTRANS') THEN
4912:          IF (NITEMS.GT.1) THEN4909:          IF (NITEMS.GT.1) THEN
4913:             CALL READF(MINOMEGA)4910:             CALL READF(MINOMEGA)
4914:             CIS_TRANS_TOL = 180.0D0 - MINOMEGA4911:             CIS_TRANS_TOL = 180.0D0 - MINOMEGA
4920:             CALL READF(MINOMEGA)4917:             CALL READF(MINOMEGA)
4921:             CIS_TRANS_TOL = 180.0D0 - MINOMEGA4918:             CIS_TRANS_TOL = 180.0D0 - MINOMEGA
4922:          END IF4919:          END IF
4923: 4920: 
4924:       ELSE IF (WORD.EQ.'NOCISTRANSRNA') THEN4921:       ELSE IF (WORD.EQ.'NOCISTRANSRNA') THEN
4925:          NOCISTRANSRNA=.TRUE.4922:          NOCISTRANSRNA=.TRUE.
4926:          IF (NITEMS.GT.1) THEN4923:          IF (NITEMS.GT.1) THEN
4927:             CALL READF(MINOMEGA)4924:             CALL READF(MINOMEGA)
4928:             CIS_TRANS_TOL = 180.0D0 - MINOMEGA4925:             CIS_TRANS_TOL = 180.0D0 - MINOMEGA
4929:          END IF4926:          END IF
4930: 4927:       
4931:       ELSE IF (WORD.EQ.'NOFREEZE') THEN4928:       ELSE IF (WORD.EQ.'NOFREEZE') THEN
4932:          FREEZECORE=.FALSE.4929:          FREEZECORE=.FALSE.
4933: !4930: !
4934: !  Turn off inversion in distance optimisation for minpermdist.4931: !  Turn off inversion in distance optimisation for minpermdist.
4935: !4932: !
4936:       ELSE IF (WORD.EQ.'NOINVERSION') THEN4933:       ELSE IF (WORD.EQ.'NOINVERSION') THEN
4937:          NOINVERSION=.TRUE.4934:          NOINVERSION=.TRUE.
4938: 4935: 
4939:       ELSE IF (WORD.EQ.'NORESET') THEN4936:       ELSE IF (WORD.EQ.'NORESET') THEN
4940:          NORESET=.TRUE.4937:          NORESET=.TRUE.
5055:          RIGID=.TRUE.5052:          RIGID=.TRUE.
5056:          NRBSITES=365053:          NRBSITES=36
5057:          ALLOCATE(SITE(NRBSITES,3))5054:          ALLOCATE(SITE(NRBSITES,3))
5058: 5055: 
5059:       ELSE IF (WORD.EQ.'PAIRDIST') THEN5056:       ELSE IF (WORD.EQ.'PAIRDIST') THEN
5060: ! csw34> PAIRDIST allows the monitoring of the distance between pairs of5057: ! csw34> PAIRDIST allows the monitoring of the distance between pairs of
5061: ! atoms during a BH run. The atom pairs are read from either as5058: ! atoms during a BH run. The atom pairs are read from either as
5062: ! arguements to the PAIRDIST keyword, or from the pairdist file5059: ! arguements to the PAIRDIST keyword, or from the pairdist file
5063:          NPAIRS=05060:          NPAIRS=0
5064:          IF (NITEMS.GT.1) THEN5061:          IF (NITEMS.GT.1) THEN
5065: ! If arguements are specified, assume NITEMS/2 pairs on the line5062: ! If arguements are specified, assume NITEMS/2 pairs on the line 
5066:             PAIRDISTT=.TRUE.5063:             PAIRDISTT=.TRUE.
5067:             WRITE(MYUNIT,'(A)') ' keyword> Pairwise atom distances will be output to pairdists*'5064:             WRITE(MYUNIT,'(A)') ' keyword> Pairwise atom distances will be output to pairdists*'
5068:             NPAIRS=(NITEMS-1)/25065:             NPAIRS=(NITEMS-1)/2
5069:             ALLOCATE(PAIRDIST(NPAIRS,2))5066:             ALLOCATE(PAIRDIST(NPAIRS,2))
5070:             DO J1=1,NPAIRS5067:             DO J1=1,NPAIRS
5071:                CALL READI(PAIRDIST(J1,1))5068:                CALL READI(PAIRDIST(J1,1))
5072:                CALL READI(PAIRDIST(J1,2))5069:                CALL READI(PAIRDIST(J1,2))
5073:                IF (PAIRDIST(J1,1).GT.NATOMSALLOC) THEN5070:                IF (PAIRDIST(J1,1).GT.NATOMSALLOC) THEN
5074:                   WRITE(MYUNIT,'(A)') ' keyword> ERROR: PAIRDIST atom index larger than system specified!'5071:                   WRITE(MYUNIT,'(A)') ' keyword> ERROR: PAIRDIST atom index larger than system specified!'
5075:                   STOP5072:                   STOP
5084:             YESNO=.FALSE.5081:             YESNO=.FALSE.
5085:             INQUIRE(FILE='pairdist',EXIST=YESNO)5082:             INQUIRE(FILE='pairdist',EXIST=YESNO)
5086:             IF (YESNO) THEN5083:             IF (YESNO) THEN
5087:                PAIRDISTT=.TRUE.5084:                PAIRDISTT=.TRUE.
5088:                WRITE(MYUNIT,'(A)') ' keyword> Pairwise atom distances will be output to pairdists*'5085:                WRITE(MYUNIT,'(A)') ' keyword> Pairwise atom distances will be output to pairdists*'
5089:             ELSE5086:             ELSE
5090:                WRITE(MYUNIT,'(A)') ' keyword> ERROR: pairdist input file missing for PAIRDIST'5087:                WRITE(MYUNIT,'(A)') ' keyword> ERROR: pairdist input file missing for PAIRDIST'
5091:                CALL FLUSH(MYUNIT)5088:                CALL FLUSH(MYUNIT)
5092:                STOP5089:                STOP
5093:             ENDIF5090:             ENDIF
5094: ! Determine NPAIRS to allow allocation of the PAIRDIST array5091: ! Determine NPAIRS to allow allocation of the PAIRDIST array 
5095:             OPEN(UNIT=222,FILE='pairdist',status='old')5092:             OPEN(UNIT=222,FILE='pairdist',status='old')
5096:             DO5093:             DO
5097:                READ(222,*,IOSTAT=iostatus) CHECK15094:                READ(222,*,IOSTAT=iostatus) CHECK1
5098:                IF (iostatus<0) THEN5095:                IF (iostatus<0) THEN
5099:                   CLOSE(222)5096:                   CLOSE(222)
5100:                   EXIT5097:                   EXIT
5101:                ELSE5098:                ELSE 
5102:                   NPAIRS=NPAIRS+15099:                   NPAIRS=NPAIRS+1
5103:                ENDIF5100:                ENDIF
5104:             END DO5101:             END DO        
5105:             CLOSE(222)5102:             CLOSE(222)
5106: ! Allocate the PAIRDIST array and read the pairs in5103: ! Allocate the PAIRDIST array and read the pairs in
5107:             ALLOCATE(PAIRDIST(NPAIRS,2))5104:             ALLOCATE(PAIRDIST(NPAIRS,2))
5108:             OPEN(UNIT=222,FILE='pairdist',status='old')5105:             OPEN(UNIT=222,FILE='pairdist',status='old')
5109:             DO J1=1,NPAIRS5106:             DO J1=1,NPAIRS
5110:                READ(222,*) PAIRDIST(J1,1),PAIRDIST(J1,2)5107:                READ(222,*) PAIRDIST(J1,1),PAIRDIST(J1,2)
5111:             ENDDO5108:             ENDDO
5112:             CLOSE(222)5109:             CLOSE(222)
5113:          ENDIF5110:          ENDIF
5114: ! Print list of pairs to GMIN output for checking5111: ! Print list of pairs to GMIN output for checking
5118:          ENDDO5115:          ENDDO
5119: 5116: 
5120: !5117: !
5121: !  PARALLEL must come before STEP and ACCRAT5118: !  PARALLEL must come before STEP and ACCRAT
5122: !  This keyword is for the serial parallel implementation - now obsolete.5119: !  This keyword is for the serial parallel implementation - now obsolete.
5123: !5120: !
5124:       ELSE IF (WORD.EQ.'PARALLEL') THEN5121:       ELSE IF (WORD.EQ.'PARALLEL') THEN
5125:          PARALLELT=.TRUE.5122:          PARALLELT=.TRUE.
5126:          CALL READI(NPAR)5123:          CALL READI(NPAR)
5127:          DEALLOCATE(FIXSTEP,FIXTEMP,FIXBOTH,TEMP,ACCRAT,STEP,ASTEP,OSTEP,BLOCK,NT,JUMPMOVE,JUMPINT,JDUMP,COORDS,LABELS,NQ,5124:          DEALLOCATE(FIXSTEP,FIXTEMP,FIXBOTH,TEMP,ACCRAT,STEP,ASTEP,OSTEP,BLOCK,NT,JUMPMOVE,JUMPINT,JDUMP,COORDS,LABELS,NQ,
5128:      &        JUMPTO,EPREV,COORDSO,LABELSO,VAT,VATO,SHELLMOVES,PTGROUP,NSURFMOVES,NCORE )5125:      &        JUMPTO,EPREV,COORDSO,LABELSO,VAT,VATO,SHELLMOVES,PTGROUP,NSURFMOVES,NCORE ) 
5129:          ALLOCATE( FIXSTEP(NPAR),FIXTEMP(NPAR),FIXBOTH(NPAR),TEMP(NPAR),ACCRAT(NPAR),STEP(NPAR),ASTEP(NPAR),OSTEP(NPAR),5126:          ALLOCATE( FIXSTEP(NPAR),FIXTEMP(NPAR),FIXBOTH(NPAR),TEMP(NPAR),ACCRAT(NPAR),STEP(NPAR),ASTEP(NPAR),OSTEP(NPAR), 
5130:      &        BLOCK(NPAR),NT(NPAR),JUMPMOVE(NPAR),JUMPINT(NPAR),JDUMP(NPAR),NQ(NPAR),JUMPTO(NPAR),5127:      &        BLOCK(NPAR),NT(NPAR),JUMPMOVE(NPAR),JUMPINT(NPAR),JDUMP(NPAR),NQ(NPAR),JUMPTO(NPAR),
5131:      &        COORDS(3*NATOMSALLOC,NPAR),LABELS(NATOMSALLOC,NPAR),5128:      &        COORDS(3*NATOMSALLOC,NPAR),LABELS(NATOMSALLOC,NPAR),
5132:      &        COORDSO(3*NATOMSALLOC,NPAR),LABELSO(NATOMSALLOC,NPAR),VAT(NATOMSALLOC,NPAR),VATO(NATOMSALLOC,NPAR),EPREV(NPAR),5129:      &        COORDSO(3*NATOMSALLOC,NPAR),LABELSO(NATOMSALLOC,NPAR),VAT(NATOMSALLOC,NPAR),VATO(NATOMSALLOC,NPAR),EPREV(NPAR),
5133:      &        NSURFMOVES(NPAR),NCORE(NPAR),REPLOW(NPAR),SHELLMOVES(NPAR),PTGROUP(NPAR) )5130:      &        NSURFMOVES(NPAR),NCORE(NPAR),REPLOW(NPAR),SHELLMOVES(NPAR),PTGROUP(NPAR) )
5134:          NATOMS=NATOMS/NPAR5131:          NATOMS=NATOMS/NPAR
5135:          DO JP=1,NPAR5132:          DO JP=1,NPAR
5136:             FIXSTEP(JP)=.FALSE.5133:             FIXSTEP(JP)=.FALSE.
5137:             FIXTEMP(JP)=.FALSE.5134:             FIXTEMP(JP)=.FALSE.
5138:             FIXBOTH(JP)=.FALSE.5135:             FIXBOTH(JP)=.FALSE.
5139:             TEMP(JP)=0.3D05136:             TEMP(JP)=0.3D0
5289:                   STOP5286:                   STOP
5290:                ENDIF5287:                ENDIF
5291: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),5288: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),
5292: !    &                                                            J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)5289: !    &                                                            J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)
5293:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),5290:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),
5294:      &                                                              J2=1,NSETS(J1))5291:      &                                                              J2=1,NSETS(J1))
5295:                NDUMMY=NDUMMY+NPERMSIZE(J1)5292:                NDUMMY=NDUMMY+NPERMSIZE(J1)
5296:             ENDDO5293:             ENDDO
5297: !5294: !
5298: !  And another sanity check!5295: !  And another sanity check!
5299: !5296: !  
5300: !           DO J1=1,NDUMMY5297: !           DO J1=1,NDUMMY
5301: !              DO J2=J1+1,NDUMMY5298: !              DO J2=J1+1,NDUMMY
5302: !                 IF (PERMGROUP(J2).EQ.PERMGROUP(J1)) THEN5299: !                 IF (PERMGROUP(J2).EQ.PERMGROUP(J1)) THEN
5303: !                    PRINT '(2(A,I8))','keyword> ERROR - atom ',PERMGROUP(J1),' appears more than once'5300: !                    PRINT '(2(A,I8))','keyword> ERROR - atom ',PERMGROUP(J1),' appears more than once'
5304: !                    STOP5301: !                    STOP
5305: !                 ENDIF5302: !                 ENDIF
5306: !              ENDDO5303: !              ENDDO
5307: !           ENDDO5304: !           ENDDO
5308:             CLOSE(1)5305:             CLOSE(1)
5309: !5306: !
5310: !  And yet another!5307: !  And yet another!
5311: !5308: !  
5312:             IF (NFREEZE.GT.0) THEN5309:             IF (NFREEZE.GT.0) THEN
5313:                NDUMMY=05310:                NDUMMY=0
5314:                DO J1=1,NPERMGROUP5311:                DO J1=1,NPERMGROUP
5315:                   DO J2=1,NPERMSIZE(J1)5312:                   DO J2=1,NPERMSIZE(J1)
5316:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN5313:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN
5317:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'5314:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'
5318:                         STOP5315:                         STOP
5319:                      ENDIF5316:                      ENDIF
5320:                   ENDDO5317:                   ENDDO
5321:                   NDUMMY=NDUMMY+NPERMSIZE(J1)5318:                   NDUMMY=NDUMMY+NPERMSIZE(J1)
5387:                ENDIF5384:                ENDIF
5388: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),5385: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),
5389: !    &                                 ((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)5386: !    &                                 ((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)
5390:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),5387:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),
5391:      &                                                              J2=1,NSETS(J1))5388:      &                                                              J2=1,NSETS(J1))
5392: 5389: 
5393:                NDUMMY=NDUMMY+NPERMSIZE(J1)5390:                NDUMMY=NDUMMY+NPERMSIZE(J1)
5394:             ENDDO5391:             ENDDO
5395: !5392: !
5396: !  And another sanity check!5393: !  And another sanity check!
5397: !5394: !  
5398: !           DO J1=1,NDUMMY5395: !           DO J1=1,NDUMMY
5399: !              DO J2=J1+1,NDUMMY5396: !              DO J2=J1+1,NDUMMY
5400: !                 IF (PERMGROUP(J2).EQ.PERMGROUP(J1)) THEN5397: !                 IF (PERMGROUP(J2).EQ.PERMGROUP(J1)) THEN
5401: !                    PRINT '(2(A,I8))','keyword> ERROR - atom ',PERMGROUP(J1),' appears more than once'5398: !                    PRINT '(2(A,I8))','keyword> ERROR - atom ',PERMGROUP(J1),' appears more than once'
5402: !                    STOP5399: !                    STOP
5403: !                 ENDIF5400: !                 ENDIF
5404: !              ENDDO5401: !              ENDDO
5405: !           ENDDO5402: !           ENDDO
5406:             CLOSE(1)5403:             CLOSE(1)
5407: !5404: !
5408: !  And yet another!5405: !  And yet another!
5409: !5406: !  
5410:             IF (NFREEZE.GT.0) THEN5407:             IF (NFREEZE.GT.0) THEN
5411:                NDUMMY=05408:                NDUMMY=0
5412:                DO J1=1,NPERMGROUP5409:                DO J1=1,NPERMGROUP
5413:                   DO J2=1,NPERMSIZE(J1)5410:                   DO J2=1,NPERMSIZE(J1)
5414:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN5411:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN
5415:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'5412:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'
5416:                         STOP5413:                         STOP
5417:                      ENDIF5414:                      ENDIF
5418:                   ENDDO5415:                   ENDDO
5419:                   NDUMMY=NDUMMY+NPERMSIZE(J1)5416:                   NDUMMY=NDUMMY+NPERMSIZE(J1)
5572: !5569: !
5573: !  Keyword for applied static force.5570: !  Keyword for applied static force.
5574: !5571: !
5575:       ELSE IF (WORD.EQ.'PULL') THEN5572:       ELSE IF (WORD.EQ.'PULL') THEN
5576:          PULLT=.TRUE.5573:          PULLT=.TRUE.
5577:          CALL READI(PATOM1)5574:          CALL READI(PATOM1)
5578:          CALL READI(PATOM2)5575:          CALL READI(PATOM2)
5579:          CALL READF(PFORCE)5576:          CALL READF(PFORCE)
5580:          WRITE(MYUNIT,'(A,I6,A,I6,A,G20.10)') ' keyword> Pulling atoms ',PATOM1,' and ',PATOM2,' force=',PFORCE5577:          WRITE(MYUNIT,'(A,I6,A,I6,A,G20.10)') ' keyword> Pulling atoms ',PATOM1,' and ',PATOM2,' force=',PFORCE
5581: !5578: !
5582: ! Request calculation of structural order parameters Q on the fly5579: ! Request calculation of structural order parameters Q on the fly 
5583: ! NOT DOCUMENTED.5580: ! NOT DOCUMENTED.
5584: !5581: !
5585:       ELSE IF (WORD.EQ.'CALCQ') THEN5582:       ELSE IF (WORD.EQ.'CALCQ') THEN
5586:          CALCQT=.TRUE.5583:          CALCQT=.TRUE.
5587: 5584: 
5588: !5585: !
5589: !Use topology information for QCI constraints for AMBER5586: !Use topology information for QCI constraints for AMBER
5590: !5587: !
5591:       ELSE IF (WORD.EQ.'QCIAMBER') THEN5588:       ELSE IF (WORD.EQ.'QCIAMBER') THEN
5592:          QCIAMBERT=.TRUE.5589:          QCIAMBERT=.TRUE.
5631:          CALL READF(XX)5628:          CALL READF(XX)
5632:          RADIUS=XX5629:          RADIUS=XX
5633: !5630: !
5634: !  integer seed for random number generator.5631: !  integer seed for random number generator.
5635: !5632: !
5636:       ELSE IF (WORD.EQ.'RANSEED') THEN5633:       ELSE IF (WORD.EQ.'RANSEED') THEN
5637:          RANSEEDT=.TRUE.5634:          RANSEEDT=.TRUE.
5638:          CALL READI(NDUMMY)5635:          CALL READI(NDUMMY)
5639:          CALL SDPRND(NDUMMY+MYNODE)5636:          CALL SDPRND(NDUMMY+MYNODE)
5640:          CALL SDPRND_UNIVERSAL(NDUMMY+NPAR)5637:          CALL SDPRND_UNIVERSAL(NDUMMY+NPAR)
5641:          WRITE(MYUNIT,'(A,I8)') 'keywords> Random seed = ',NDUMMY+MYNODE5638:          WRITE(MYUNIT,'(A,I8)') 'keywords> Random seed = ',NDUMMY+MYNODE 
5642: 5639: 
5643: !5640: !
5644: !  RBSYM defines the internal symmetry operations for each sort of rigid body5641: !  RBSYM defines the internal symmetry operations for each sort of rigid body
5645: !  coded via RBAAT.5642: !  coded via RBAAT.
5646: !5643: !
5647:       ELSE IF (WORD.EQ.'RBSYM') THEN5644:       ELSE IF (WORD.EQ.'RBSYM') THEN
5648:          RBSYMT=.TRUE.5645:          RBSYMT=.TRUE.
5649:          INQUIRE(FILE='rbsymops',EXIST=RBSYMTEST)5646:          INQUIRE(FILE='rbsymops',EXIST=RBSYMTEST)
5650:          IF (RBSYMTEST) THEN5647:          IF (RBSYMTEST) THEN
5651:             OPEN(UNIT=111,FILE='rbsymops',STATUS='OLD')5648:             OPEN(UNIT=111,FILE='rbsymops',STATUS='OLD')
5730:          OPEN(LUNIT,FILE='points.min',STATUS='OLD')5727:          OPEN(LUNIT,FILE='points.min',STATUS='OLD')
5731:          DO J1=1,NRESMIN5728:          DO J1=1,NRESMIN
5732:             DO J2=1,3*NATOMS,35729:             DO J2=1,3*NATOMS,3
5733:                READ(LUNIT,'(3G25.15)') RESPOINTS(J2,J1),RESPOINTS(J2+1,J1),RESPOINTS(J2+2,J1)5730:                READ(LUNIT,'(3G25.15)') RESPOINTS(J2,J1),RESPOINTS(J2+1,J1),RESPOINTS(J2+2,J1)
5734:                !READ(LUNIT,'(3G25.15)') RESPOINTS(3*J2-2,J1),RESPOINTS(3*J2-1,J1),RESPOINTS(3*J2,J1)5731:                !READ(LUNIT,'(3G25.15)') RESPOINTS(3*J2-2,J1),RESPOINTS(3*J2-1,J1),RESPOINTS(3*J2,J1)
5735:                !WRITE(*,'(A,2I3,G10.10)') "read points.min file", J1, J2, RESPOINTS(J2,J1)5732:                !WRITE(*,'(A,2I3,G10.10)') "read points.min file", J1, J2, RESPOINTS(J2,J1)
5736:             ENDDO5733:             ENDDO
5737:          ENDDO5734:          ENDDO
5738: !         DO J2=1,NRESMIN5735: !         DO J2=1,NRESMIN
5739: !            DO J1=1,NATOMS5736: !            DO J1=1,NATOMS
5740: !               WRITE(MYUNIT,'(A,3F20.6,2I)') 'setup> RESPOINTS ', RESPOINTS(3*(J1-1)+1,J2),5737: !               WRITE(MYUNIT,'(A,3F20.6,2I)') 'setup> RESPOINTS ', RESPOINTS(3*(J1-1)+1,J2), 
5741: !     &          RESPOINTS(3*(J1-1)+2,J2),RESPOINTS(3*(J1-1)+3,J2),3*(J1-1)+3,J25738: !     &          RESPOINTS(3*(J1-1)+2,J2),RESPOINTS(3*(J1-1)+3,J2),3*(J1-1)+3,J2
5742: !            ENDDO5739: !            ENDDO
5743: !         ENDDO5740: !         ENDDO
5744:          CLOSE(LUNIT)5741:          CLOSE(LUNIT)
5745:          IF (DEBUG) WRITE(MYUNIT,'(A,I6,A)') 'setup> points for ',NRESMIN,' minima read from file points.min'5742:          IF (DEBUG) WRITE(MYUNIT,'(A,I6,A)') 'setup> points for ',NRESMIN,' minima read from file points.min'
5746: 5743: 
5747:          ! AB > read eigenvalues / eigenvectors for each minimum from file5744:          ! AB > read eigenvalues / eigenvectors for each minimum from file
5748:          ! vector.dump5745:          ! vector.dump
5749:          ALLOCATE(HESSEIGVC(3*NATOMSALLOC,3*NATOMSALLOC,NRESMIN))5746:          ALLOCATE(HESSEIGVC(3*NATOMSALLOC,3*NATOMSALLOC,NRESMIN))
5750:          ALLOCATE(HESSEIGVA(3*NATOMSALLOC,NRESMIN))5747:          ALLOCATE(HESSEIGVA(3*NATOMSALLOC,NRESMIN))
5822:             STOP5819:             STOP
5823:          ELSE5820:          ELSE
5824:             IF (.NOT.ALLOCATED(MSBCOORDS)) ALLOCATE(MSBCOORDS(3*NATOMSALLOC,MAXSAVE))5821:             IF (.NOT.ALLOCATED(MSBCOORDS)) ALLOCATE(MSBCOORDS(3*NATOMSALLOC,MAXSAVE))
5825:             IF (.NOT.ALLOCATED(MSBE)) ALLOCATE(MSBE(MAXSAVE))5822:             IF (.NOT.ALLOCATED(MSBE)) ALLOCATE(MSBE(MAXSAVE))
5826:             OPEN(UNIT=34,FILE='MSBdata',STATUS='OLD')5823:             OPEN(UNIT=34,FILE='MSBdata',STATUS='OLD')
5827: 57          READ(34,*,END=56) DUMMY5824: 57          READ(34,*,END=56) DUMMY
5828:             NMSBSAVE=NMSBSAVE+15825:             NMSBSAVE=NMSBSAVE+1
5829:             MSBE(NMSBSAVE)=DUMMY5826:             MSBE(NMSBSAVE)=DUMMY
5830:             READ(34,*) (MSBCOORDS(J1,NMSBSAVE),J1=1,3*NATOMSALLOC)5827:             READ(34,*) (MSBCOORDS(J1,NMSBSAVE),J1=1,3*NATOMSALLOC)
5831:             IF (NMSBSAVE.LT.MAXSAVE) GOTO 575828:             IF (NMSBSAVE.LT.MAXSAVE) GOTO 57
5832: 56          WRITE(MYUNIT,'(A,I6,A)')5829: 56          WRITE(MYUNIT,'(A,I6,A)') 
5833:      1         'Energies and coordinates read for ',NMSBSAVE,' previous structures from MSBdata'5830:      1         'Energies and coordinates read for ',NMSBSAVE,' previous structures from MSBdata'
5834:             CLOSE(34)5831:             CLOSE(34)
5835:          ENDIF5832:          ENDIF
5836: 5833: 
5837: ! hk286 > use atom coords during final quench   !5834: ! hk286 > use atom coords during final quench   !
5838:       ELSE IF (WORD.EQ.'RELAXFINALQUENCH') THEN5835:       ELSE IF (WORD.EQ.'RELAXFINALQUENCH') THEN
5839:          RELAXFQ = .TRUE.5836:          RELAXFQ = .TRUE.
5840: 5837: 
5841: !5838: !
5842: !  Renormalisation attempt5839: !  Renormalisation attempt
5855:          IF (NITEMS.GT.4) CALL READI(NRENSTUCK)5852:          IF (NITEMS.GT.4) CALL READI(NRENSTUCK)
5856: 5853: 
5857:       ELSE IF (WORD.EQ.'RESIZE') THEN5854:       ELSE IF (WORD.EQ.'RESIZE') THEN
5858:          RESIZET=.TRUE.5855:          RESIZET=.TRUE.
5859:          CALL READF(XX)5856:          CALL READF(XX)
5860:          RESIZE=XX5857:          RESIZE=XX
5861: !5858: !
5862: !  Reseed runs if a step is not accepted in twice the relaxation time,5859: !  Reseed runs if a step is not accepted in twice the relaxation time,
5863: !  defined in terms of a number of mc steps NRELAX. NHSRESTART defines5860: !  defined in terms of a number of mc steps NRELAX. NHSRESTART defines
5864: !  the number of hard sphere moves used to produce the new starting5861: !  the number of hard sphere moves used to produce the new starting
5865: !  configuration.5862: !  configuration. 
5866: !5863: !
5867:       ELSE IF (WORD.EQ.'RESTART') THEN5864:       ELSE IF (WORD.EQ.'RESTART') THEN
5868:          RESTART=.TRUE.5865:          RESTART=.TRUE.
5869:          IF (NITEMS.GT.1) CALL READI(NRELAX)5866:          IF (NITEMS.GT.1) CALL READI(NRELAX)
5870:          IF (NITEMS.GT.2) CALL READI(NHSRESTART)5867:          IF (NITEMS.GT.2) CALL READI(NHSRESTART)
5871: !5868: !
5872: !  Restore the state of a previous GMIN run from dumpfile.5869: !  Restore the state of a previous GMIN run from dumpfile.
5873: !5870: !
5874:       ELSE IF (WORD.EQ.'RESTORE') THEN5871:       ELSE IF (WORD.EQ.'RESTORE') THEN
5875:          RESTORET=.TRUE.5872:          RESTORET=.TRUE.
5880:          ENDIF5877:          ENDIF
5881: 5878: 
5882: ! hk2865879: ! hk286
5883:       ELSE IF (WORD.EQ.'RESTRAINL') THEN5880:       ELSE IF (WORD.EQ.'RESTRAINL') THEN
5884: 5881: 
5885:          RESTRAINLT   = .TRUE.5882:          RESTRAINLT   = .TRUE.
5886:          CALL READF(RESTRAINLK)5883:          CALL READF(RESTRAINLK)
5887:          CALL READRESTRAINL()5884:          CALL READRESTRAINL()
5888: 5885: 
5889: !5886: !
5890: ! js850> reject moves if mobile particles are more than5887: ! js850> reject moves if mobile particles are more than 
5891: ! RESTRICTREGIONRADIUS from point (RESTRICTREGIONX0, RESTRICTREGIONY0, RESTRICTREGIONZ0).5888: ! RESTRICTREGIONRADIUS from point (RESTRICTREGIONX0, RESTRICTREGIONY0, RESTRICTREGIONZ0).
5892: ! Check mobility by looking at FROZEN, HARMONICFLIST, and DONTMOVE5889: ! Check mobility by looking at FROZEN, HARMONICFLIST, and DONTMOVE
5893: !5890: !
5894:       ELSE IF (WORD.EQ.'RESTRICTREGION') THEN5891:       ELSE IF (WORD.EQ.'RESTRICTREGION') THEN
5895:             RESTRICTREGION=.TRUE.5892:             RESTRICTREGION=.TRUE.
5896:             CALL READF( RESTRICTREGIONRADIUS)5893:             CALL READF( RESTRICTREGIONRADIUS)
5897:             CALL READF( RESTRICTREGIONX0)5894:             CALL READF( RESTRICTREGIONX0)
5898:             CALL READF( RESTRICTREGIONY0)5895:             CALL READF( RESTRICTREGIONY0)
5899:             CALL READF( RESTRICTREGIONZ0)5896:             CALL READF( RESTRICTREGIONZ0)
5900: 5897: 
5933:          CALL READI(J1)5930:          CALL READI(J1)
5934:          CALL READI(J2)5931:          CALL READI(J2)
5935:          IF(J1.EQ.1) THEN5932:          IF(J1.EQ.1) THEN
5936:            SELECTT=.TRUE.5933:            SELECTT=.TRUE.
5937:          ELSE5934:          ELSE
5938:            SELECTT=.FALSE.5935:            SELECTT=.FALSE.
5939:          ENDIF5936:          ENDIF
5940:          IF (J2.EQ.1) PROGRESS=.TRUE.5937:          IF (J2.EQ.1) PROGRESS=.TRUE.
5941:          WRITE(MYUNIT,'(A)') 'RMST set'5938:          WRITE(MYUNIT,'(A)') 'RMST set'
5942: 5939: 
5943: 5940:       
5944:        ELSE IF (WORD.EQ.'ROTATEHINGE') THEN5941:        ELSE IF (WORD.EQ.'ROTATEHINGE') THEN
5945:           ROTATEHINGET=.TRUE.5942:           ROTATEHINGET=.TRUE.
5946: !         Read ROTATEHINGEFREQ5943: !         Read ROTATEHINGEFREQ 
5947:           IF (NITEMS.GT.1) CALL READI(ROTATEHINGEFREQ)5944:           IF (NITEMS.GT.1) CALL READI(ROTATEHINGEFREQ)
5948: !         Read in ROTATEFACTOR5945: !         Read in ROTATEFACTOR
5949:           IF (NITEMS.GT.2) CALL READF(HINGEROTATEFACTOR)5946:           IF (NITEMS.GT.2) CALL READF(HINGEROTATEFACTOR)
5950:           WRITE(MYUNIT,'(A)') ' keywords> Enabled hinge rotation moves for the plate potential'5947:           WRITE(MYUNIT,'(A)') ' keywords> Enabled hinge rotation moves for the plate potential'
5951:           WRITE(MYUNIT,'(A,I2,A)') ' keywords> Hinges will be rotated every ',ROTATEHINGEFREQ,' steps'5948:           WRITE(MYUNIT,'(A,I2,A)') ' keywords> Hinges will be rotated every ',ROTATEHINGEFREQ,' steps'
5952:           WRITE(MYUNIT,'(A,F20.10)') ' keywords> Hinge angle rotatefactor =',HINGEROTATEFACTOR5949:           WRITE(MYUNIT,'(A,F20.10)') ' keywords> Hinge angle rotatefactor =',HINGEROTATEFACTOR
5953:           CALL HINGE_INITIALISE5950:           CALL HINGE_INITIALISE
5954: 5951:          
5955: !5952: !
5956: ! csw34> Rigid body rotation moves. Each rigid body is randomly rotated about its COM every ROTATERIGIDFREQ steps.5953: ! csw34> Rigid body rotation moves. Each rigid body is randomly rotated about its COM every ROTATERIGIDFREQ steps.
5957: !        ROTATEFACTOR scales the maximum rotation with 1.0 being complete freedom to rotate.5954: !        ROTATEFACTOR scales the maximum rotation with 1.0 being complete freedom to rotate.
5958: !5955: !
5959:       ELSE IF (WORD.EQ.'ROTATERIGID') THEN5956:       ELSE IF (WORD.EQ.'ROTATERIGID') THEN
5960:          ROTATERIGIDT=.TRUE.5957:          ROTATERIGIDT=.TRUE.
5961: ! Read ROTATERIGIDFREQ5958: ! Read ROTATERIGIDFREQ 
5962:          IF (NITEMS.GT.1) CALL READI(ROTATERIGIDFREQ)5959:          IF (NITEMS.GT.1) CALL READI(ROTATERIGIDFREQ)
5963: ! Read in ROTATEFACTOR5960: ! Read in ROTATEFACTOR
5964:          IF (NITEMS.GT.2) CALL READF(ROTATEFACTOR)5961:          IF (NITEMS.GT.2) CALL READF(ROTATEFACTOR)
5965:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body rotation moves enabled'5962:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body rotation moves enabled'
5966:          WRITE(MYUNIT,'(A,I2,A)') ' keyword> Rigid bodies will be rotated every ',ROTATERIGIDFREQ,' steps'5963:          WRITE(MYUNIT,'(A,I2,A)') ' keyword> Rigid bodies will be rotated every ',ROTATERIGIDFREQ,' steps'
5967:          WRITE(MYUNIT,'(A,F20.10)') ' ROTATERIGID> Rigid body ROTATEFACTOR =',ROTATEFACTOR5964:          WRITE(MYUNIT,'(A,F20.10)') ' ROTATERIGID> Rigid body ROTATEFACTOR =',ROTATEFACTOR
5968: 5965:    
5969: !5966: !
5970: ! mo361> Rigid body translation moves5967: ! mo361> Rigid body translation moves
5971: !        TRANSLATEFACTOR sets the maximum translation distance5968: !        TRANSLATEFACTOR sets the maximum translation distance
5972: !5969: !
5973:       ELSE IF (WORD.EQ.'TRANSLATERIGID') THEN5970:       ELSE IF (WORD.EQ.'TRANSLATERIGID') THEN
5974:          TRANSLATERIGIDT=.TRUE.5971:          TRANSLATERIGIDT=.TRUE.
5975: ! Read TRANSLATERIGIDFREQ5972: ! Read TRANSLATERIGIDFREQ 
5976:          IF (NITEMS.GT.1) CALL READI(TRANSLATERIGIDFREQ)5973:          IF (NITEMS.GT.1) CALL READI(TRANSLATERIGIDFREQ)
5977: ! Read in TRANSLATEFACTOR5974: ! Read in TRANSLATEFACTOR
5978:          IF (NITEMS.GT.2) CALL READF(TRANSLATEFACTOR)5975:          IF (NITEMS.GT.2) CALL READF(TRANSLATEFACTOR)
5979:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body translation moves enabled'5976:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body translation moves enabled'
5980:          WRITE(MYUNIT,'(A,I2,A)') ' keyword> Rigid bodies will be translated every ',TRANSLATERIGIDFREQ,' steps'5977:          WRITE(MYUNIT,'(A,I2,A)') ' keyword> Rigid bodies will be translated every ',TRANSLATERIGIDFREQ,' steps'
5981:          WRITE(MYUNIT,'(A,F20.10)') ' TRANSLATERIGID> Rigid body TRANSLATEFACTOR =',TRANSLATEFACTOR5978:          WRITE(MYUNIT,'(A,F20.10)') ' TRANSLATERIGID> Rigid body TRANSLATEFACTOR =',TRANSLATEFACTOR
5982: 5979:    
5983:       ELSE IF (WORD.EQ.'SAVE') THEN5980:       ELSE IF (WORD.EQ.'SAVE') THEN
5984:          CALL READI(NSAVE)5981:          CALL READI(NSAVE)
5985:          IF (A9INTET.AND.(NSAVEINTE.EQ.0)) NSAVEINTE=NSAVE5982:          IF (A9INTET.AND.(NSAVEINTE.EQ.0)) NSAVEINTE=NSAVE
5986: 5983: 
5987:       ELSE IF (WORD.EQ.'SAVEMULTIMINONLY') THEN5984:       ELSE IF (WORD.EQ.'SAVEMULTIMINONLY') THEN
5988:          SAVEMULTIMINONLY = .TRUE.5985:          SAVEMULTIMINONLY = .TRUE.
5989: 5986: 
5990:       ELSE IF (WORD.EQ.'SAVEINTE') THEN5987:       ELSE IF (WORD.EQ.'SAVEINTE') THEN
5991:          CALL READI(NSAVEINTE)5988:          CALL READI(NSAVEINTE)
5992: 5989: 
6105:       ELSE IF (WORD.EQ.'STEEREDMIN') THEN6102:       ELSE IF (WORD.EQ.'STEEREDMIN') THEN
6106:          STEEREDMINT=.TRUE.6103:          STEEREDMINT=.TRUE.
6107:          CALL READF(SMINK)          ! final value of force constant6104:          CALL READF(SMINK)          ! final value of force constant
6108:          CALL READF(SMINKINC)        ! increment of force constant per LBFGS step6105:          CALL READF(SMINKINC)        ! increment of force constant per LBFGS step
6109:          CALL READF(SMINDISTSTART)  ! initial distance for atoms SMINATOMA and SMINATOMB6106:          CALL READF(SMINDISTSTART)  ! initial distance for atoms SMINATOMA and SMINATOMB
6110:          CALL READF(SMINDISTFINISH) ! final distance for atoms SMINATOMA and SMINATOMB (force turned off)6107:          CALL READF(SMINDISTFINISH) ! final distance for atoms SMINATOMA and SMINATOMB (force turned off)
6111:          CALL READI(SMINATOMA)      ! Atom A in the body to be rotated6108:          CALL READI(SMINATOMA)      ! Atom A in the body to be rotated
6112:          CALL READI(SMINATOMB)      ! Atom B in the other body (fixed for step)6109:          CALL READI(SMINATOMB)      ! Atom B in the other body (fixed for step)
6113: 6110: 
6114:       ELSE IF (WORD.EQ.'TRACKDATA') THEN6111:       ELSE IF (WORD.EQ.'TRACKDATA') THEN
6115:          TRACKDATAT=.TRUE.6112:          TRACKDATAT=.TRUE.     
6116: !6113: !
6117: ! NOT DOCUMENTED6114: ! NOT DOCUMENTED
6118: !6115: !
6119:       ELSE IF (WORD.EQ.'STEPOUT') THEN6116:       ELSE IF (WORD.EQ.'STEPOUT') THEN
6120:          STEPOUT=.TRUE.6117:          STEPOUT=.TRUE.
6121: 6118: 
6122:       ELSE IF (WORD.EQ.'STEPS') THEN6119:       ELSE IF (WORD.EQ.'STEPS') THEN
6123:          NRUNS=16120:          NRUNS=1
6124:          CALL READI(IX)6121:          CALL READI(IX)
6125:          MCSTEPS(1)=IX6122:          MCSTEPS(1)=IX
6140:             MCSTEPS(3)=IX6137:             MCSTEPS(3)=IX
6141:             CALL READF(XX)6138:             CALL READF(XX)
6142:             TFAC(3)=XX6139:             TFAC(3)=XX
6143:          ENDIF6140:          ENDIF
6144: 6141: 
6145:       ELSE IF (WORD.EQ.'STICKY') THEN6142:       ELSE IF (WORD.EQ.'STICKY') THEN
6146:          STICKYT=.TRUE.6143:          STICKYT=.TRUE.
6147:          RIGID=.TRUE.6144:          RIGID=.TRUE.
6148:          CALL READI(NRBSITES)6145:          CALL READI(NRBSITES)
6149:          CALL READF(STICKYSIG)6146:          CALL READF(STICKYSIG)
6150: !        WRITE(MYUNIT,*) 'NRBSITES=',NRBSITES6147: !        WRITE(MYUNIT,*) 'NRBSITES=',NRBSITES 
6151: !        WRITE(MYUNIT,*) 'STICKYSIG=',STICKYSIG6148: !        WRITE(MYUNIT,*) 'STICKYSIG=',STICKYSIG 
6152:          ALLOCATE(SITE(NRBSITES,3))6149:          ALLOCATE(SITE(NRBSITES,3))
6153:          DO J1=1,NRBSITES6150:          DO J1=1,NRBSITES
6154:             READ(DATA_UNIT,*) SITE(J1,1:3)6151:             READ(DATA_UNIT,*) SITE(J1,1:3)
6155: !           CALL READF(SITE(J1,1))6152: !           CALL READF(SITE(J1,1))
6156: !           CALL READF(SITE(J1,2))6153: !           CALL READF(SITE(J1,2))
6157: !           CALL READF(SITE(J1,3))6154: !           CALL READF(SITE(J1,3))
6158: !           WRITE(MYUNIT,'(A,I5,3G20.10)') 'J1,site: ',J1,SITE(J1,1:3)6155: !           WRITE(MYUNIT,'(A,I5,3G20.10)') 'J1,site: ',J1,SITE(J1,1:3)
6159:          ENDDO6156:          ENDDO
6160: 6157: 
6161:       ELSE IF (WORD.EQ.'LJCOUL') THEN6158:       ELSE IF (WORD.EQ.'LJCOUL') THEN
6162:          LJCOULT=.TRUE.6159:          LJCOULT=.TRUE.
6163:          CALL READI(COULN)6160:          CALL READI(COULN)
6164:          CALL READF(COULQ)6161:          CALL READF(COULQ)
6165:          CALL READF(COULSWAP)6162:          CALL READF(COULSWAP)
6166:          CALL READF(COULTEMP)6163:          CALL READF(COULTEMP)
6167:          NRBSITES=16164:          NRBSITES=1
6168:          ALLOCATE(SITE(NRBSITES,3))6165:          ALLOCATE(SITE(NRBSITES,3))
6169: !        Maybe the above two lines are not necessary!6166: !        Maybe the above two lines are not necessary!
6170: 6167: 
6171: ! jwrm2> 
6172:       ELSE IF (WORD.EQ.'LJ_GAUSS') THEN 
6173:           LJ_GAUSST = .TRUE. 
6174:           CALL READF(LJ_GAUSS_RCUT) 
6175:           CALL READF(LJ_GAUSS_EPS) 
6176:           CALL READF(LJ_GAUSS_R0) 
6177:           CALL LJ_GAUSS_INITIALISE() 
6178: ! jwrm2> end 
6179:  
6180:       ELSE IF (WORD.EQ.'STOCK') THEN6168:       ELSE IF (WORD.EQ.'STOCK') THEN
6181:          STOCKT=.TRUE.6169:          STOCKT=.TRUE.
6182:          RIGID=.TRUE.6170:          RIGID=.TRUE.
6183:          NRBSITES=16171:          NRBSITES=1
6184:          CALL READF(STOCKMU)6172:          CALL READF(STOCKMU)
6185:          CALL READF(STOCKLAMBDA)6173:          CALL READF(STOCKLAMBDA)
6186:          ALLOCATE(SITE(NRBSITES,3))6174:          ALLOCATE(SITE(NRBSITES,3))
6187: 6175: 
6188: !       Anisotropic potentials:6176: !       Anisotropic potentials:
6189: 6177: 
6192:       ELSE IF (WORD.EQ.'CHECKD') THEN6180:       ELSE IF (WORD.EQ.'CHECKD') THEN
6193:          CHECKDT = .TRUE.6181:          CHECKDT = .TRUE.
6194:          IF (NITEMS .GT. 1) CALL READI(CHECKDID)6182:          IF (NITEMS .GT. 1) CALL READI(CHECKDID)
6195: 6183: 
6196:       ELSE IF (WORD.EQ.'CAPBIN') THEN6184:       ELSE IF (WORD.EQ.'CAPBIN') THEN
6197: 6185: 
6198:          CAPBINT = .TRUE.6186:          CAPBINT = .TRUE.
6199:          RIGID   = .TRUE.6187:          RIGID   = .TRUE.
6200:          CALL READI(NPS)     ! Number of pentamers6188:          CALL READI(NPS)     ! Number of pentamers
6201:          CALL READF(CAPEPS2)6189:          CALL READF(CAPEPS2)
6202:          CALL READF(CAPRHO)6190:          CALL READF(CAPRHO)    
6203:          CALL READF(CAPRAD)6191:          CALL READF(CAPRAD)
6204:          CALL READF(CAPHEIGHT1)6192:          CALL READF(CAPHEIGHT1)
6205:          CALL READF(CAPHEIGHT2)        ! comment out this line for the previous model6193:          CALL READF(CAPHEIGHT2)        ! comment out this line for the previous model
6206:          NRBSITES1 = 7        ! Number of sites defining a pentamer; change it to 6 for the previous model6194:          NRBSITES1 = 7        ! Number of sites defining a pentamer; change it to 6 for the previous model
6207:          IF (NPS == NATOMSALLOC/2) THEN6195:          IF (NPS == NATOMSALLOC/2) THEN
6208:             NRBSITES = 7      ! change it to 6 for the previous model6196:             NRBSITES = 7      ! change it to 6 for the previous model    
6209:          ELSE6197:          ELSE
6210:             NRBSITES = 15     ! Sum of the numbers of sites defining a pentamer and a hexamer; change it to 13 for the previous model6198:             NRBSITES = 15     ! Sum of the numbers of sites defining a pentamer and a hexamer; change it to 13 for the previous model
6211:          ENDIF6199:          ENDIF
6212:          ALLOCATE(SITE(NRBSITES,3))6200:          ALLOCATE(SITE(NRBSITES,3))
6213:          NTSITES = NRBSITES1*NPS + (NRBSITES-NRBSITES1)*(NATOMSALLOC/2-NPS)6201:          NTSITES = NRBSITES1*NPS + (NRBSITES-NRBSITES1)*(NATOMSALLOC/2-NPS)
6214:          CALL DEFCAPBIN()6202:          CALL DEFCAPBIN()
6215: 6203: 
6216:       ELSE IF (WORD .EQ. 'CHIRO') THEN6204:       ELSE IF (WORD .EQ. 'CHIRO') THEN
6217: 6205: 
6218:          CHIROT = .TRUE.6206:          CHIROT = .TRUE.
6230:       ELSE IF (WORD.EQ.'DBP') THEN6218:       ELSE IF (WORD.EQ.'DBP') THEN
6231: 6219: 
6232:          DBPT   = .TRUE.6220:          DBPT   = .TRUE.
6233:          RIGID  = .TRUE.6221:          RIGID  = .TRUE.
6234:          CALL READF(DBEPSBB)6222:          CALL READF(DBEPSBB)
6235:          CALL READF(DBSIGBB)6223:          CALL READF(DBSIGBB)
6236:          CALL READF(DBPMU)6224:          CALL READF(DBPMU)
6237:          IF (NITEMS > 4) THEN6225:          IF (NITEMS > 4) THEN
6238:             CALL READF(EFIELD)6226:             CALL READF(EFIELD)
6239:             EFIELDT = .TRUE.6227:             EFIELDT = .TRUE.
6240:          ENDIF6228:          ENDIF 
6241:          NRBSITES = 36229:          NRBSITES = 3
6242:          ALLOCATE(SITE(NRBSITES,3))6230:          ALLOCATE(SITE(NRBSITES,3))
6243:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>6231:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>
6244: 6232: 
6245:       ELSE IF (WORD.EQ.'DMBLPY') THEN6233:       ELSE IF (WORD.EQ.'DMBLPY') THEN
6246: 6234: 
6247:          DMBLPYT = .TRUE.6235:          DMBLPYT = .TRUE.
6248:          RIGID   = .TRUE.6236:          RIGID   = .TRUE.
6249:          CALL READF(YEPS)6237:          CALL READF(YEPS) 
6250:          CALL READF(YKAPPA)6238:          CALL READF(YKAPPA)
6251:          CALL READF(DBSIGBB)6239:          CALL READF(DBSIGBB)
6252:          CALL READF(DBPMU)6240:          CALL READF(DBPMU)
6253:          IF (NITEMS > 5) THEN6241:          IF (NITEMS > 5) THEN
6254:             CALL READF(EFIELD)6242:             CALL READF(EFIELD)
6255:             EFIELDT = .TRUE.6243:             EFIELDT = .TRUE.
6256:          ENDIF6244:          ENDIF
6257:          NRBSITES = 36245:          NRBSITES = 3
6258:          ALLOCATE(SITE(NRBSITES,3))6246:          ALLOCATE(SITE(NRBSITES,3))
6259:          NTSITES = NATOMSALLOC*NRBSITES/26247:          NTSITES = NATOMSALLOC*NRBSITES/2  
6260: 6248: 
6261: ! hk2866249: ! hk286
6262:       ELSE IF (WORD.EQ.'DBYUKAWA') THEN6250:       ELSE IF (WORD.EQ.'DBYUKAWA') THEN
6263:          DBYUKAWAT   = .TRUE.6251:          DBYUKAWAT   = .TRUE.
6264:          CALL READF(LAMBDAYAA)6252:          CALL READF(LAMBDAYAA)
6265:          CALL READF(LAMBDAYAB)6253:          CALL READF(LAMBDAYAB)
6266:          CALL READF(LAMBDAYBB)6254:          CALL READF(LAMBDAYBB)
6267:          CALL READF(YEPSFAC)6255:          CALL READF(YEPSFAC)
6268: 6256: 
6269:       ELSE IF (WORD.EQ.'DBPTD') THEN6257:       ELSE IF (WORD.EQ.'DBPTD') THEN
6270: 6258: 
6271:          DBPTDT = .TRUE.6259:          DBPTDT = .TRUE.
6272:          RIGID  = .TRUE.6260:          RIGID  = .TRUE.
6273:          CALL READF(DBEPSBB)6261:          CALL READF(DBEPSBB)
6274:          CALL READF(DBSIGBB)6262:          CALL READF(DBSIGBB)
6275:          CALL READF(DBPMU)6263:          CALL READF(DBPMU)
6276:          IF (NITEMS > 4) THEN6264:          IF (NITEMS > 4) THEN
6277:             CALL READF(EFIELD)6265:             CALL READF(EFIELD)
6278:             EFIELDT = .TRUE.6266:             EFIELDT = .TRUE.
6279:          ENDIF6267:          ENDIF
6280:          NRBSITES = 36268:          NRBSITES = 3 
6281:          ALLOCATE(SITE(NRBSITES,3))6269:          ALLOCATE(SITE(NRBSITES,3))
6282:          NTSITES = (NATOMSALLOC/2-1)*NRBSITES + 4    !jdf43>6270:          NTSITES = (NATOMSALLOC/2-1)*NRBSITES + 4    !jdf43>
6283: 6271: 
6284:       ELSE IF (WORD.EQ.'DMBLM') THEN6272:       ELSE IF (WORD.EQ.'DMBLM') THEN
6285: 6273: 
6286:          DMBLMT   = .TRUE.6274:          DMBLMT   = .TRUE.
6287:          RIGID    = .TRUE.6275:          RIGID    = .TRUE.
6288:          CALL READF(EPS11)6276:          CALL READF(EPS11)
6289:          CALL READF(EPS22)6277:          CALL READF(EPS22)
6290:          CALL READF(MRHO11)6278:          CALL READF(MRHO11)
6312:          ALLOCATE(SITE(NRBSITES,3))6300:          ALLOCATE(SITE(NRBSITES,3))
6313: 6301: 
6314:          CALL DEFLINROD()6302:          CALL DEFLINROD()
6315: 6303: 
6316:       ELSE IF (WORD.EQ.'LWOTP') THEN6304:       ELSE IF (WORD.EQ.'LWOTP') THEN
6317: 6305: 
6318:          LWOTPT = .TRUE.6306:          LWOTPT = .TRUE.
6319:          RIGID  = .TRUE.6307:          RIGID  = .TRUE.
6320:          IF (NITEMS > 1) CALL READF(LWRCUT)6308:          IF (NITEMS > 1) CALL READF(LWRCUT)
6321:          NRBSITES = 36309:          NRBSITES = 3
6322:          ALLOCATE(SITE(NRBSITES,3))6310:          ALLOCATE(SITE(NRBSITES,3)) 
6323:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>6311:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>
6324: 6312:  
6325:          CALL DEFLWOTP()6313:          CALL DEFLWOTP()
6326: 6314: 
6327:       ELSE IF (WORD.EQ.'NCAP') THEN6315:       ELSE IF (WORD.EQ.'NCAP') THEN
6328: 6316: 
6329:          NCAPT  = .TRUE.6317:          NCAPT  = .TRUE.
6330:          RIGID  = .TRUE.6318:          RIGID  = .TRUE.
6331:          CALL READF(EPS2)6319:          CALL READF(EPS2)
6332:          CALL READF(RHO)6320:          CALL READF(RHO)
6333:          CALL READF(RAD)6321:          CALL READF(RAD)
6334:          CALL READF(HEIGHT)6322:          CALL READF(HEIGHT)
6335:          NRBSITES = 86323:          NRBSITES = 8
6336:          ALLOCATE(SITE(NRBSITES,3))6324:          ALLOCATE(SITE(NRBSITES,3))
6337:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>6325:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>
6338: 6326: 
6339:          CALL DEFCAPSID(RAD,HEIGHT)6327:          CALL DEFCAPSID(RAD,HEIGHT)
6340: 6328: 
6341:       ELSE IF (WORD .EQ. 'NPAH') THEN6329:       ELSE IF (WORD .EQ. 'NPAH') THEN
6342: 6330: 
6343:          CALL READI(PAHID)6331:          CALL READI(PAHID)         
6344:          NPAHT    = .TRUE.6332:          NPAHT    = .TRUE.
6345:          RIGID    = .TRUE.6333:          RIGID    = .TRUE.
6346:          IF (PAHID == 1) THEN6334:          IF (PAHID == 1) THEN
6347:             NRBSITES = 366335:             NRBSITES = 36
6348:          ELSEIF (PAHID == 2) THEN6336:          ELSEIF (PAHID == 2) THEN
6349:             NRBSITES = 266337:             NRBSITES = 26
6350:          ELSEIF (PAHID == 3) THEN6338:          ELSEIF (PAHID == 3) THEN
6351:             NRBSITES = 126339:             NRBSITES = 12
6352:          ENDIF6340:          ENDIF
6353:          ALLOCATE(SITE(NRBSITES,3))6341:          ALLOCATE(SITE(NRBSITES,3))
6354: 6342: 
6355:       ELSE IF (WORD .EQ. 'NTIP') THEN6343:       ELSE IF (WORD .EQ. 'NTIP') THEN
6356: 6344:  
6357:          NTIPT =.TRUE.6345:          NTIPT =.TRUE.
6358:          RIGID =.TRUE.6346:          RIGID =.TRUE.
6359:          IF (NITEMS > 1) THEN6347:          IF (NITEMS > 1) THEN 
6360:             CALL READI(TIPID)6348:             CALL READI(TIPID)
6361:          ELSE6349:          ELSE
6362:             PRINT *, 'ERROR, TIPID is missing'6350:             PRINT *, 'ERROR, TIPID is missing'
6363:             STOP6351:             STOP
6364:          ENDIF6352:          ENDIF 
6365:          IF (TIPID == 1) NRBSITES = 36353:          IF (TIPID == 1) NRBSITES = 3
6366:          IF (TIPID == 2) NRBSITES = 46354:          IF (TIPID == 2) NRBSITES = 4
6367:          IF (TIPID == 3) NRBSITES = 36355:          IF (TIPID == 3) NRBSITES = 3
6368:          IF (TIPID == 4) NRBSITES = 46356:          IF (TIPID == 4) NRBSITES = 4
6369:          IF (TIPID == 5) NRBSITES = 56357:          IF (TIPID == 5) NRBSITES = 5
6370: 6358: 
6371:          ALLOCATE(SITE(NRBSITES,3))6359:          ALLOCATE(SITE(NRBSITES,3))
6372:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>6360:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>
6373:          IF (TIPID == 4) THEN6361:          IF (TIPID == 4) THEN
6374:              PI = 4.D0*DATAN(1.D0)6362:              PI = 4.D0*DATAN(1.D0)
6397: 6385: 
6398:          ENDIF6386:          ENDIF
6399:          IF (PERMDIST.OR. LOCALPERMDIST .OR. LPERMDIST) THEN ! correct all permutations allowed if perm.allow is not given explicitly6387:          IF (PERMDIST.OR. LOCALPERMDIST .OR. LPERMDIST) THEN ! correct all permutations allowed if perm.allow is not given explicitly
6400:             IF (NPERMSIZE(1).EQ.NATOMSALLOC) NPERMSIZE(1)=NATOMSALLOC/26388:             IF (NPERMSIZE(1).EQ.NATOMSALLOC) NPERMSIZE(1)=NATOMSALLOC/2
6401:          ENDIF6389:          ENDIF
6402: 6390: 
6403: 6391: 
6404: !|gd351>6392: !|gd351>
6405: 6393: 
6406:       ELSE IF (WORD .EQ. 'PATCHY') THEN6394:       ELSE IF (WORD .EQ. 'PATCHY') THEN
6407: 6395:  
6408:          PATCHY =.TRUE.6396:          PATCHY =.TRUE.
6409:          RIGID =.TRUE.6397:          RIGID =.TRUE.
6410:          IF (NITEMS > 1) THEN6398:          IF (NITEMS > 1) THEN 
6411:             CALL READI(NRBSITES)6399:             CALL READI(NRBSITES)
6412:          ELSE6400:          ELSE
6413:             PRINT *, 'ERROR, NRBSITES is missing'6401:             PRINT *, 'ERROR, NRBSITES is missing'
6414:             STOP6402:             STOP
6415:          ENDIF6403:          ENDIF 
6416: 6404: 
6417:          ALLOCATE(SITE(NRBSITES,3))6405:          ALLOCATE(SITE(NRBSITES,3))
6418: 6406: 
6419:          SIGMASQ = (1.D0)**26407:          SIGMASQ = (1.D0)**2
6420:          RANGESQ = (1.9D0)**26408:          RANGESQ = (1.9D0)**2
6421:          FACTOR =  (2*3.14159265358979D0*0.05)**26409:          FACTOR =  (2*3.14159265358979D0*0.05)**2
6422: 6410: 
6423:          CALL DEFINE_PATCHES(7.298D0)6411:          CALL DEFINE_PATCHES(7.298D0)
6424: 6412: 
6425:       ELSE IF (WORD .EQ. 'ASAOOS') THEN6413:       ELSE IF (WORD .EQ. 'ASAOOS') THEN
6426: 6414:  
6427:          ASAOOS =.TRUE.6415:          ASAOOS =.TRUE.
6428: 6416: 
6429:           IF (NITEMS > 1) THEN6417:           IF (NITEMS > 1) THEN 
6430:             CALL READF(SIGMAP)6418:             CALL READF(SIGMAP)
6431:          ELSE6419:          ELSE
6432:             SIGMAP=0.1D06420:             SIGMAP=0.1D0
6433:          ENDIF6421:          ENDIF 
6434: 6422: 
6435:          CALL ASAOOSPRINT()6423:          CALL ASAOOSPRINT()
6436: 6424: 
6437:       ELSE IF (WORD .EQ. 'SANDBOX') THEN6425:       ELSE IF (WORD .EQ. 'SANDBOX') THEN
6438: 6426: 
6439:          SANDBOXT = .TRUE.6427:          SANDBOXT = .TRUE.
6440: 6428: 
6441:       ELSE IF (WORD .EQ. 'SILANE') THEN6429:       ELSE IF (WORD .EQ. 'SILANE') THEN
6442: 6430: 
6443:          SILANET = .TRUE.6431:          SILANET = .TRUE.
6480: 6468: 
6481:          CALL READI(NRBSITES)6469:          CALL READI(NRBSITES)
6482:          MSSTOCKT = .TRUE.6470:          MSSTOCKT = .TRUE.
6483:          RIGID    = .TRUE.6471:          RIGID    = .TRUE.
6484:          ALLOCATE(SITE(NRBSITES,3))6472:          ALLOCATE(SITE(NRBSITES,3))
6485:          ALLOCATE(RBUV(NRBSITES,3))6473:          ALLOCATE(RBUV(NRBSITES,3))
6486:          ALLOCATE(DPMU(NRBSITES))6474:          ALLOCATE(DPMU(NRBSITES))
6487:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>6475:          NTSITES = NATOMSALLOC*NRBSITES/2    !jdf43>
6488:          DO J1 = 1, NRBSITES6476:          DO J1 = 1, NRBSITES
6489:             CALL READF(DPMU(J1))6477:             CALL READF(DPMU(J1))
6490:          ENDDO6478:          ENDDO    
6491:          IF (NRBSITES == 2) THEN6479:          IF (NRBSITES == 2) THEN
6492:             CALL DEFMULT2STOCK()6480:             CALL DEFMULT2STOCK()
6493:          ELSE IF (NRBSITES == 3) THEN6481:          ELSE IF (NRBSITES == 3) THEN
6494:             CALL DEFMULT3STOCK()6482:             CALL DEFMULT3STOCK()
6495:          ELSE IF (NRBSITES == 4) THEN6483:          ELSE IF (NRBSITES == 4) THEN
6496:             CALL DEFMULT4STOCK()6484:             CALL DEFMULT4STOCK()
6497:          ELSE IF (NRBSITES == 5) THEN6485:          ELSE IF (NRBSITES == 5) THEN
6498:             CALL DEFMULT5STOCK()6486:             CALL DEFMULT5STOCK()
6499:          ELSE6487:          ELSE
6500:             WRITE(MYUNIT,*) 'NOT ALLOWED NRBSITES=',NRBSITES6488:             WRITE(MYUNIT,*) 'NOT ALLOWED NRBSITES=',NRBSITES
6501:             STOP6489:             STOP 
6502:          ENDIF6490:          ENDIF
6503:          IF (NITEMS > (2 + NRBSITES)) THEN6491:          IF (NITEMS > (2 + NRBSITES)) THEN
6504:             CALL READF(EFIELD)6492:             CALL READF(EFIELD)
6505:             EFIELDT = .TRUE.6493:             EFIELDT = .TRUE.
6506:          ENDIF6494:          ENDIF
6507:          IF (.NOT. EFIELDT) EFIELD = 0.D06495:          IF (.NOT. EFIELDT) EFIELD = 0.D0
6508: 6496: 
6509:       ELSE IF (WORD .EQ. 'MSBIN') THEN6497:       ELSE IF (WORD .EQ. 'MSBIN') THEN
6510: 6498: 
6511: !         CALL READI(NRBSITES)6499: !         CALL READI(NRBSITES)
6512: !         CALL READI(NRBSITES1)6500: !         CALL READI(NRBSITES1)
6513:          CALL READI(NPS)6501:          CALL READI(NPS)
6514:          NRBSITES  = 116502:          NRBSITES  = 11
6515:          NRBSITES1 = 56503:          NRBSITES1 = 5        
6516:          MSTBINT = .TRUE.6504:          MSTBINT = .TRUE.
6517:          RIGID    = .TRUE.6505:          RIGID    = .TRUE.
6518:          CALL READF(STOCKMU)6506:          CALL READF(STOCKMU)
6519:          IF (NITEMS > 3) THEN6507:          IF (NITEMS > 3) THEN
6520:             CALL READF(EFIELD)6508:             CALL READF(EFIELD)
6521:             EFIELDT = .TRUE.6509:             EFIELDT = .TRUE.
6522:          ENDIF6510:          ENDIF
6523:          ALLOCATE(SITE(NRBSITES,3))6511:          ALLOCATE(SITE(NRBSITES,3))
6524:          ALLOCATE(RBUV(NRBSITES,3))6512:          ALLOCATE(RBUV(NRBSITES,3))
6525:          CALL DEFMSTBIN()6513:          CALL DEFMSTBIN()
6650:             NRBSITES = 246638:             NRBSITES = 24
6651:          ELSEIF (PAHID == 4) THEN6639:          ELSEIF (PAHID == 4) THEN
6652:             NRBSITES = 266640:             NRBSITES = 26
6653:          ENDIF6641:          ENDIF
6654: 6642: 
6655:          PAHAT    = .TRUE.6643:          PAHAT    = .TRUE.
6656:          RIGID    = .TRUE.6644:          RIGID    = .TRUE.
6657:          ALLOCATE(SITE(NRBSITES,3))6645:          ALLOCATE(SITE(NRBSITES,3))
6658:          ALLOCATE(RBSTLA(NRBSITES,3))6646:          ALLOCATE(RBSTLA(NRBSITES,3))
6659:          ALLOCATE(STCHRG(NRBSITES))6647:          ALLOCATE(STCHRG(NRBSITES))
6660: 6648:          
6661:          NTSITES = (NATOMSALLOC/2)*NRBSITES  !jdf43>6649:          NTSITES = (NATOMSALLOC/2)*NRBSITES  !jdf43>
6662: 6650: 
6663:          CALL DEFPAHA()6651:          CALL DEFPAHA()
6664: 6652: 
6665:          IF (PAHID == 1) THEN6653:          IF (PAHID == 1) THEN
6666:             NCARBON  = 66654:             NCARBON  = 6
6667:             CALL DEFBENZENE()6655:             CALL DEFBENZENE()
6668:          ELSEIF (PAHID == 2) THEN6656:          ELSEIF (PAHID == 2) THEN
6669:             NCARBON  = 106657:             NCARBON  = 10
6670:             CALL DEFNAPHTHALENE()6658:             CALL DEFNAPHTHALENE()
6690:          RIGID    = .TRUE.6678:          RIGID    = .TRUE.
6691:          ALLOCATE(SITE(NRBSITES,3))6679:          ALLOCATE(SITE(NRBSITES,3))
6692: 6680: 
6693:       ELSE IF (WORD .EQ. 'PAP') THEN6681:       ELSE IF (WORD .EQ. 'PAP') THEN
6694: 6682: 
6695:          CALL READI(NPATCH)6683:          CALL READI(NPATCH)
6696:          CALL READF(PAPALP)6684:          CALL READF(PAPALP)
6697:          CALL READF(PAPS)6685:          CALL READF(PAPS)
6698:          CALL READF(PAPCD)6686:          CALL READF(PAPCD)
6699:          CALL READF(PAPEPS)6687:          CALL READF(PAPEPS)
6700: 6688:          
6701:          NRBSITES = 2*NPATCH6689:          NRBSITES = 2*NPATCH
6702: 6690: 
6703:          PAPT   = .TRUE.6691:          PAPT   = .TRUE.
6704:          RIGID  = .TRUE.6692:          RIGID  = .TRUE.
6705: 6693: 
6706:       ELSE IF (WORD .EQ. 'PAPBIN') THEN6694:       ELSE IF (WORD .EQ. 'PAPBIN') THEN
6707: 6695: 
6708:          CALL READF(PAPEPS)6696:          CALL READF(PAPEPS)
6709:          CALL READF(PAPS)6697:          CALL READF(PAPS)
6710:          CALL READF(PAPANG1)6698:          CALL READF(PAPANG1)
6727:          CALL READF(YKAPPA)6715:          CALL READF(YKAPPA)
6728: 6716: 
6729:          NRBSITES = 26717:          NRBSITES = 2
6730:          ALLOCATE(RBSTLA(NRBSITES,3))6718:          ALLOCATE(RBSTLA(NRBSITES,3))
6731: 6719: 
6732:          CALL DEFPAPJANUS()6720:          CALL DEFPAPJANUS()
6733: 6721: 
6734:          PAPJANT = .TRUE.6722:          PAPJANT = .TRUE.
6735:          RIGID   = .TRUE.6723:          RIGID   = .TRUE.
6736: 6724: 
6737: ! jwrm2> 
6738:       ELSE IF (WORD .EQ. 'POLYHEDRA') THEN6725:       ELSE IF (WORD .EQ. 'POLYHEDRA') THEN
6739: 6726: 
6740:         POLYT = .TRUE.6727:         POLYT = .TRUE.
6741:         RIGID = .TRUE.6728:         RIGID = .TRUE.
6742:         CALL READF(K_OVERLAP)6729:         CALL READF(K_OVERLAP)
6743:         CALL READF(K_COMPRESS)6730:         CALL READF(K_COMPRESS)
6744:         CALL INITIALISE_POLYHEDRA()6731:         CALL INITIALISE_POLYHEDRA()
6745: ! jwrm2> end 
6746: 6732: 
6747:       ELSE IF (WORD .EQ. 'PTSTST') THEN6733:       ELSE IF (WORD .EQ. 'PTSTST') THEN
6748: 6734: 
6749:          CALL READI(NPATCH)6735:          CALL READI(NPATCH)
6750:          CALL READF(PAPEPS)6736:          CALL READF(PAPEPS)
6751:          CALL READF(PAPCD)6737:          CALL READF(PAPCD)
6752:          CALL READF(YKAPPA)6738:          CALL READF(YKAPPA)
6753: 6739: 
6754:          NRBSITES = NPATCH6740:          NRBSITES = NPATCH
6755:          ALLOCATE(SITE(NRBSITES,3))6741:          ALLOCATE(SITE(NRBSITES,3))
6756: 6742: 
6757:          CALL DEFPTSTST()6743:          CALL DEFPTSTST()
6758: 6744: 
6759:          PTSTSTT = .TRUE.6745:          PTSTSTT = .TRUE.
6760:          RIGID   = .TRUE.6746:          RIGID   = .TRUE.
6761: 6747: 
6762: ! js850> stop the monte carlo loop when MAX_NPCALL is reached.6748: ! js850> stop the monte carlo loop when MAX_NPCALL is reached.
6763: ! This can be useful for benchmarking where you want to see6749: ! This can be useful for benchmarking where you want to see 
6764: ! the lowest energy reached after a certain number of energy evaluations6750: ! the lowest energy reached after a certain number of energy evaluations
6765:        ELSE IF (WORD .EQ.'MAX_NPCALL') THEN6751:        ELSE IF (WORD .EQ.'MAX_NPCALL') THEN
6766:           MAX_NPCALLT = .TRUE.6752:           MAX_NPCALLT = .TRUE.
6767:           CALL READI(MAX_NPCALL)6753:           CALL READI(MAX_NPCALL)
6768: 6754: 
6769:        ELSE IF (WORD .EQ.'MSGB') THEN6755:        ELSE IF (WORD .EQ.'MSGB') THEN
6770: 6756: 
6771:          MSGBT = .TRUE.6757:          MSGBT = .TRUE.
6772: !         RIGID = .TRUE.6758: !         RIGID = .TRUE.
6773:          CALL READI(NGBSITE)6759:          CALL READI(NGBSITE)
6778:          CALL READF(SIGNOT)6764:          CALL READF(SIGNOT)
6779:          CALL READF(EPSNOT)6765:          CALL READF(EPSNOT)
6780: !         ALLOCATE(SITE(NRBSITES,3))6766: !         ALLOCATE(SITE(NRBSITES,3))
6781: 6767: 
6782:          LPL    = 0.5D0 * SIGNOT * GBKAPPA6768:          LPL    = 0.5D0 * SIGNOT * GBKAPPA
6783:          LPR    = 0.5D0 * SIGNOT6769:          LPR    = 0.5D0 * SIGNOT
6784:          LPRSQ  = LPR * LPR6770:          LPRSQ  = LPR * LPR
6785:          LSQDFR = LPL * LPL - LPRSQ6771:          LSQDFR = LPL * LPL - LPRSQ
6786: 6772: 
6787:       ELSE IF (WORD .EQ. 'RIGIDMD') THEN6773:       ELSE IF (WORD .EQ. 'RIGIDMD') THEN
6788:          ! Syntax:6774:          ! Syntax: 
6789: 6775: 
6790:          RIGIDMDT = .TRUE.6776:          RIGIDMDT = .TRUE.
6791: 6777:  
6792:       ELSE IF (WORD .EQ. 'PY') THEN6778:       ELSE IF (WORD .EQ. 'PY') THEN
6793:          ! Syntax: PY sig_0 eps_0 [cut] [XYZ boxx boxy boxz]6779:          ! Syntax: PY sig_0 eps_0 [cut] [XYZ boxx boxy boxz]
6794: 6780: 
6795:          PYT = .TRUE.6781:          PYT = .TRUE.
6796:          CALL READF(PYSIGNOT)6782:          CALL READF(PYSIGNOT)
6797:          CALL READF(PYEPSNOT)6783:          CALL READF(PYEPSNOT)
6798: 6784: 
6799:          RIGID = .TRUE.6785:          RIGID = .TRUE.
6800:          ! Rigid body SITE, NRBSITES, NTSITES information specified in py_input routine6786:          ! Rigid body SITE, NRBSITES, NTSITES information specified in py_input routine
6801: 6787: 
6802:          ! Specify cutoff for potential in absolute units6788:          ! Specify cutoff for potential in absolute units
6803:          IF (NITEMS.GT.3) THEN6789:          IF (NITEMS.GT.3) THEN
6804:             CALL READF(PCUTOFF)6790:             CALL READF(PCUTOFF)
6805:             PARAMONOVCUTOFF=.TRUE.6791:             PARAMONOVCUTOFF=.TRUE.
6806:             WRITE(MYUNIT,*) "multisitepy cutoff: ", PCUTOFF6792:             WRITE(MYUNIT,*) "multisitepy cutoff: ", PCUTOFF
6807:          ENDIF6793:          ENDIF
6808:          ! Specify periodic boundary conditions (PBCs)6794:          ! Specify periodic boundary conditions (PBCs)
6809:          IF (NITEMS.GT.4) THEN6795:          IF (NITEMS.GT.4) THEN
6810:             ! control which dimensions have periodic boundaries with a string 'XYZ', always put x before y before z.6796:             ! control which dimensions have periodic boundaries with a string 'XYZ', always put x before y before z.            
6811:             ! eg ...  Xz 20 30  specifies PBC on X and Z directions.  The X box size will be 20, the Z box size 306797:             ! eg ...  Xz 20 30  specifies PBC on X and Z directions.  The X box size will be 20, the Z box size 30
6812:             CALL READA(PBC)6798:             CALL READA(PBC)
6813:             BOXLX=06799:             BOXLX=0
6814:             BOXLY=06800:             BOXLY=0
6815:             BOXLZ=06801:             BOXLZ=0
6816:             IF (SCAN(PBC,'Xx').NE.0) THEN6802:             IF (SCAN(PBC,'Xx').NE.0) THEN
6817:                 PARAMONOVPBCX=.TRUE.6803:                 PARAMONOVPBCX=.TRUE.
6818:                 CALL READF(BOXLX)6804:                 CALL READF(BOXLX)
6819:                 BOXLX = BOXLX*PCUTOFF6805:                 BOXLX = BOXLX*PCUTOFF
6820:                 WRITE(MYUNIT,*) "PBC X:",BOXLX6806:                 WRITE(MYUNIT,*) "PBC X:",BOXLX
6834:          ENDIF6820:          ENDIF
6835:       ELSE IF (WORD .EQ. 'PYGRAVITY') THEN6821:       ELSE IF (WORD .EQ. 'PYGRAVITY') THEN
6836:          CALL READF(PYGRAVITYC1)6822:          CALL READF(PYGRAVITYC1)
6837:          CALL READF(PYGRAVITYC2)6823:          CALL READF(PYGRAVITYC2)
6838:          EFIELDT=.TRUE.6824:          EFIELDT=.TRUE.
6839:       ELSE IF (WORD.EQ.'PYOVERLAPTHRESH') THEN6825:       ELSE IF (WORD.EQ.'PYOVERLAPTHRESH') THEN
6840:          CALL READF(PYOVERLAPTHRESH)6826:          CALL READF(PYOVERLAPTHRESH)
6841:          WRITE(MYUNIT,'(A,F8.3)') 'keyword> ellipsoids considered to overlap for an ECF value below ', PYOVERLAPTHRESH6827:          WRITE(MYUNIT,'(A,F8.3)') 'keyword> ellipsoids considered to overlap for an ECF value below ', PYOVERLAPTHRESH
6842:          IF(NITEMS.GT.2) CALL READF(PYCFTHRESH)6828:          IF(NITEMS.GT.2) CALL READF(PYCFTHRESH)
6843:          WRITE(MYUNIT,'(A,F8.3)') 'keyword> cold fusion will be diagnosed for an ECF value below ', PYCFTHRESH6829:          WRITE(MYUNIT,'(A,F8.3)') 'keyword> cold fusion will be diagnosed for an ECF value below ', PYCFTHRESH
6844: 6830:  
6845:       ELSE IF (WORD.EQ.'GAYBERNE') THEN6831:       ELSE IF (WORD.EQ.'GAYBERNE') THEN
6846: 6832: 
6847:          GAYBERNET=.TRUE.6833:          GAYBERNET=.TRUE.
6848:          ELLIPSOIDT=.TRUE.6834:          ELLIPSOIDT=.TRUE.
6849:          RIGID=.TRUE.6835:          RIGID=.TRUE.
6850:          NRBSITES=16836:          NRBSITES=1
6851:          CALL READF(GBANISOTROPYR)6837:          CALL READF(GBANISOTROPYR)
6852:          CALL READF(GBWELLDEPTHR)6838:          CALL READF(GBWELLDEPTHR)
6853:          CALL READF(PSIGMA0(1))6839:          CALL READF(PSIGMA0(1))
6854:          CALL READF(PEPSILON0)6840:          CALL READF(PEPSILON0)
6856:          CALL READF(GBNU)6842:          CALL READF(GBNU)
6857:          ALLOCATE(SITE(NRBSITES,3))6843:          ALLOCATE(SITE(NRBSITES,3))
6858: !6844: !
6859: ! Addressable PY6845: ! Addressable PY
6860: !6846: !
6861:       ELSE IF (WORD.EQ.'PYADD') THEN6847:       ELSE IF (WORD.EQ.'PYADD') THEN
6862:          PYADDT=.TRUE.6848:          PYADDT=.TRUE.
6863:          CALL READI(NADDTARGET)6849:          CALL READI(NADDTARGET)
6864:          WRITE(MYUNIT,'(A,I6)') 'keyword> Target cluster size is ',NADDTARGET6850:          WRITE(MYUNIT,'(A,I6)') 'keyword> Target cluster size is ',NADDTARGET
6865:          IF (MOD(NATOMSALLOC/2,NADDTARGET).NE.0) THEN6851:          IF (MOD(NATOMSALLOC/2,NADDTARGET).NE.0) THEN
6866:             WRITE(MYUNIT,'(A,I6)') 'keyword> ERROR, target cluster size is not a factor of the number of PY particles ',6852:             WRITE(MYUNIT,'(A,I6)') 'keyword> ERROR, target cluster size is not a factor of the number of PY particles ', 
6867:      &          NATOMSALLOC/26853:      &          NATOMSALLOC/2  
6868:             STOP6854:             STOP
6869:          ENDIF6855:          ENDIF
6870:          LUNIT=GETUNIT()6856:          LUNIT=GETUNIT()
6871:          OPEN(LUNIT,FILE='epsilon',STATUS='OLD')6857:          OPEN(LUNIT,FILE='epsilon',STATUS='OLD')
6872:          IF (.NOT.ALLOCATED(PYADDEPS)) ALLOCATE(PYADDEPS(NADDTARGET,NADDTARGET))6858:          IF (.NOT.ALLOCATED(PYADDEPS)) ALLOCATE(PYADDEPS(NADDTARGET,NADDTARGET))
6873:          DO J1=1,NADDTARGET6859:          DO J1=1,NADDTARGET
6874:             DO J2=1,NADDTARGET6860:             DO J2=1,NADDTARGET
6875:                READ(LUNIT,*) PYADDEPS(J2,J1)6861:                READ(LUNIT,*) PYADDEPS(J2,J1)
6876:                WRITE(MYUNIT,'(2I6,G20.10)') J1,J2,PYADDEPS(J2,J1)6862:                WRITE(MYUNIT,'(2I6,G20.10)') J1,J2,PYADDEPS(J2,J1)
6877:             ENDDO6863:             ENDDO
6878:          ENDDO6864:          ENDDO
6879:          CLOSE(LUNIT)6865:          CLOSE(LUNIT)
6880:       ELSE IF (WORD.EQ.'PYADD2') THEN6866:       ELSE IF (WORD.EQ.'PYADD2') THEN
6881:          PYADD2T=.TRUE.6867:          PYADD2T=.TRUE.
6882:          CALL READI(NADDTARGET)6868:          CALL READI(NADDTARGET)
6883:          WRITE(MYUNIT,'(A,I6)') 'keyword> Target cluster size is ',NADDTARGET6869:          WRITE(MYUNIT,'(A,I6)') 'keyword> Target cluster size is ',NADDTARGET
6884:          IF (MOD(NATOMSALLOC/2,NADDTARGET).NE.0) THEN6870:          IF (MOD(NATOMSALLOC/2,NADDTARGET).NE.0) THEN
6885:             WRITE(MYUNIT,'(A,I6)') 'keyword> ERROR, target cluster size is not a factor of the number of PY particles ',6871:             WRITE(MYUNIT,'(A,I6)') 'keyword> ERROR, target cluster size is not a factor of the number of PY particles ', 
6886:      &          NATOMSALLOC/26872:      &          NATOMSALLOC/2  
6887:             STOP6873:             STOP
6888:          ENDIF6874:          ENDIF
6889:          LUNIT=GETUNIT()6875:          LUNIT=GETUNIT()
6890:          OPEN(LUNIT,FILE='epsilon',STATUS='OLD')6876:          OPEN(LUNIT,FILE='epsilon',STATUS='OLD')
6891:          IF (.NOT.ALLOCATED(PYADDREP)) ALLOCATE(PYADDREP(NADDTARGET,NADDTARGET))6877:          IF (.NOT.ALLOCATED(PYADDREP)) ALLOCATE(PYADDREP(NADDTARGET,NADDTARGET))
6892:          IF (.NOT.ALLOCATED(PYADDATT)) ALLOCATE(PYADDATT(NADDTARGET,NADDTARGET))6878:          IF (.NOT.ALLOCATED(PYADDATT)) ALLOCATE(PYADDATT(NADDTARGET,NADDTARGET))
6893:          DO J1=1,NADDTARGET6879:          DO J1=1,NADDTARGET
6894:             DO J2=1,NADDTARGET6880:             DO J2=1,NADDTARGET
6895:                READ(LUNIT,*) PYADDREP(J2,J1), PYADDATT(J2,J1)6881:                READ(LUNIT,*) PYADDREP(J2,J1), PYADDATT(J2,J1)
6896:                WRITE(MYUNIT,'(2I6,2G20.10)') J1,J2,PYADDREP(J2,J1),PYADDATT(J2,J1)6882:                WRITE(MYUNIT,'(2I6,2G20.10)') J1,J2,PYADDREP(J2,J1),PYADDATT(J2,J1)
6955:             ENDIF6941:             ENDIF
6956:             IF (SCAN(PBC,'Zz').NE.0) THEN6942:             IF (SCAN(PBC,'Zz').NE.0) THEN
6957:                 PARAMONOVPBCZ=.TRUE.6943:                 PARAMONOVPBCZ=.TRUE.
6958:                 CALL READF(BOXLZ)6944:                 CALL READF(BOXLZ)
6959:                 BOXLZ=BOXLZ*PCUTOFF6945:                 BOXLZ=BOXLZ*PCUTOFF
6960:                 write(*,*) "Paramonov Periodic Boundary Condition Z active. BOXLZ",BOXLZ6946:                 write(*,*) "Paramonov Periodic Boundary Condition Z active. BOXLZ",BOXLZ
6961:             ENDIF6947:             ENDIF
6962:          ENDIF6948:          ENDIF
6963:          ALLOCATE(SITE(NRBSITES,3))6949:          ALLOCATE(SITE(NRBSITES,3))
6964:       ELSE IF (WORD .EQ.'LJCAPSID') THEN6950:       ELSE IF (WORD .EQ.'LJCAPSID') THEN
6965: !         Three-site Lennard-Jones based capsid model. Sites at the origin are standard LJ sites, the two apex sites6951: !         Three-site Lennard-Jones based capsid model. Sites at the origin are standard LJ sites, the two apex sites 
6966: !         are repulsive LJ sites, polarised. The site in the middle only interacts with sites in the middle of other6952: !         are repulsive LJ sites, polarised. The site in the middle only interacts with sites in the middle of other 
6967: !         molecules.6953: !         molecules.
6968:          LJCAPSIDT = .TRUE.6954:          LJCAPSIDT = .TRUE.
6969:          CALL READF(PYSIGNOT)6955:          CALL READF(PYSIGNOT)
6970:          CALL READF(PYEPSNOT)6956:          CALL READF(PYEPSNOT)
6971:          CALL READF(PEPSILON1(1))6957:          CALL READF(PEPSILON1(1))
6972:          CALL READF(PSCALEFAC1(1))6958:          CALL READF(PSCALEFAC1(1))
6973:          CALL READF(PSCALEFAC2(1))6959:          CALL READF(PSCALEFAC2(1))
6974:          MAXINTERACTIONS=46960:          MAXINTERACTIONS=4
6975: 6961:         
6976:          ALLOCATE(SITE(NRBSITES,3))6962:          ALLOCATE(SITE(NRBSITES,3))
6977: 6963: 
6978:       ELSE IF (WORD.EQ.'EXTRALJSITE') THEN6964:       ELSE IF (WORD.EQ.'EXTRALJSITE') THEN
6979:          LJSITE=.TRUE.6965:          LJSITE=.TRUE.
6980:          CALL READF(PEPSILON1(1))6966:          CALL READF(PEPSILON1(1))
6981:          CALL READF(PSCALEFAC1(1))6967:          CALL READF(PSCALEFAC1(1))
6982:           MAXINTERACTIONS=16968:           MAXINTERACTIONS=1
6983:          IF(NITEMS.GT.3) THEN6969:          IF(NITEMS.GT.3) THEN
6984:           CALL READF(PSCALEFAC2(1))6970:           CALL READF(PSCALEFAC2(1))
6985:           WRITE(MYUNIT,'(A,3F8.3)') 'keyword> primary and secondary apex sites will be used, epsilon and heights: ',6971:           WRITE(MYUNIT,'(A,3F8.3)') 'keyword> primary and secondary apex sites will be used, epsilon and heights: ', 
6986:      &                              PEPSILON1(1), PSCALEFAC1(1), PSCALEFAC2(1)6972:      &                              PEPSILON1(1), PSCALEFAC1(1), PSCALEFAC2(1)
6987:           IF(.NOT.LJSITEATTR) THEN6973:           IF(.NOT.LJSITEATTR) THEN
6988:                 MAXINTERACTIONS=36974:                 MAXINTERACTIONS=3
6989:           ELSE6975:           ELSE
6990:                 MAXINTERACTIONS=46976:                 MAXINTERACTIONS=4
6991:           END IF6977:           END IF
6992:          ELSE6978:          ELSE
6993:           WRITE(MYUNIT,'(A,2F8.3)') 'keyword> primary apex sites will be used, epsilon and height: ', PEPSILON1(1), PSCALEFAC1(1)6979:           WRITE(MYUNIT,'(A,2F8.3)') 'keyword> primary apex sites will be used, epsilon and height: ', PEPSILON1(1), PSCALEFAC1(1)
6994:          END IF6980:          END IF
6995:          IF(NITEMS.GT.4) THEN           ! binary ellipsoidal clusters will be set up only for two apex sites, not one6981:          IF(NITEMS.GT.4) THEN           ! binary ellipsoidal clusters will be set up only for two apex sites, not one
6996:            BLJSITE=.TRUE.               ! we also won't use the sigma parameter from now on, epsilon is enough for repulsive sites6982:            BLJSITE=.TRUE.               ! we also won't use the sigma parameter from now on, epsilon is enough for repulsive sites
6997:            WRITE(MYUNIT,'(A,3F8.3)') 'keyword> binary system with primary and secondary apex sites, ' //6983:            WRITE(MYUNIT,'(A,3F8.3)') 'keyword> binary system with primary and secondary apex sites, ' //  
6998:      &  'epsilon and heights for 2nd type particle: ', PEPSILON1(1), PSCALEFAC1(1), PSCALEFAC2(1)6984:      &  'epsilon and heights for 2nd type particle: ', PEPSILON1(1), PSCALEFAC1(1), PSCALEFAC2(1)
6999: 6985: 
7000:            CALL READF(PEPSILON1(2))6986:            CALL READF(PEPSILON1(2))
7001:            CALL READF(PSCALEFAC1(2))6987:            CALL READF(PSCALEFAC1(2))
7002:            CALL READF(PSCALEFAC2(2))6988:            CALL READF(PSCALEFAC2(2))
7003:            CALL READF(PEPSILON1(3))     ! this is epsilon for the interaction between A and B type ellipsoids6989:            CALL READF(PEPSILON1(3))     ! this is epsilon for the interaction between A and B type ellipsoids
7004:            MAXINTERACTIONS=3 ! attractive secondary apex sites not incorporated for binary systems6990:            MAXINTERACTIONS=3 ! attractive secondary apex sites not incorporated for binary systems
7005:          END IF6991:          END IF
7006:       ELSE IF (WORD.EQ.'EXTRALJSITEATTR') THEN6992:       ELSE IF (WORD.EQ.'EXTRALJSITEATTR') THEN
7007:          LJSITE=.TRUE.6993:          LJSITE=.TRUE.
7008:          LJSITEATTR=.TRUE.6994:          LJSITEATTR=.TRUE.
7009:          CALL READF(PSIGMAATTR(1))6995:          CALL READF(PSIGMAATTR(1))
7010:          CALL READF(PEPSILONATTR(1))6996:          CALL READF(PEPSILONATTR(1))
7011:          CALL READF(PSIGMAATTR(2))6997:          CALL READF(PSIGMAATTR(2))
7012:          CALL READF(PEPSILONATTR(2))6998:          CALL READF(PEPSILONATTR(2))
7013: 6999: 
7014:          WRITE(MYUNIT,'(A,4F13.4)') 'keyword> primary and secondary apex sites '//7000:          WRITE(MYUNIT,'(A,4F13.4)') 'keyword> primary and secondary apex sites '//
7015:      &                             'with normal LJ attraction, sigmas and epsilons: ',7001:      &                             'with normal LJ attraction, sigmas and epsilons: ', 
7016:      &                             PSIGMAATTR(1), PEPSILONATTR(1), PSIGMAATTR(2), PEPSILONATTR(2)7002:      &                             PSIGMAATTR(1), PEPSILONATTR(1), PSIGMAATTR(2), PEPSILONATTR(2)
7017:          MAXINTERACTIONS=47003:          MAXINTERACTIONS=4
7018:       ELSE IF (WORD.EQ.'LJSITECOORDS') THEN7004:       ELSE IF (WORD.EQ.'LJSITECOORDS') THEN
7019:            LJSITECOORDST=.TRUE.7005:            LJSITECOORDST=.TRUE.
7020:            CALL READF(LJSITECOORDS(1))7006:            CALL READF(LJSITECOORDS(1))
7021:            CALL READF(LJSITECOORDS(2))7007:            CALL READF(LJSITECOORDS(2))
7022:            CALL READF(LJSITECOORDS(3))7008:            CALL READF(LJSITECOORDS(3))
7023:       ELSE IF (WORD.EQ.'SWAPMOVES') THEN7009:       ELSE IF (WORD.EQ.'SWAPMOVES') THEN
7024:          SWAPMOVEST=.TRUE.7010:          SWAPMOVEST=.TRUE.
7025:          IF(PYBINARYT) THEN7011:          IF(PYBINARYT) THEN
7093: 7079: 
7094:       ELSE IF (WORD.EQ.'STRAND') THEN7080:       ELSE IF (WORD.EQ.'STRAND') THEN
7095:          STRANDT=.TRUE.7081:          STRANDT=.TRUE.
7096:          RIGID=.TRUE.7082:          RIGID=.TRUE.
7097: !7083: !
7098: !  The nine reference site positions per strand.7084: !  The nine reference site positions per strand.
7099: !7085: !
7100:          NRBSITES=97086:          NRBSITES=9
7101:          ALLOCATE(SITE(NRBSITES,3))7087:          ALLOCATE(SITE(NRBSITES,3))
7102:          SITE(1,1)=-2.72988620827088:          SITE(1,1)=-2.7298862082
7103:          SITE(1,2)=2.36228656257089:          SITE(1,2)=2.3622865625 
7104:          SITE(1,3)=0.64751516297090:          SITE(1,3)=0.6475151629
7105:          SITE(2,1)=-1.74921221147091:          SITE(2,1)=-1.7492122114
7106:          SITE(2,2)=2.33311946647092:          SITE(2,2)=2.3331194664 
7107:          SITE(2,3)=0.58870151337093:          SITE(2,3)=0.5887015133
7108:          SITE(3,1)=-1.59636385867094:          SITE(3,1)=-1.5963638586
7109:          SITE(3,2)=1.43043205857095:          SITE(3,2)=1.4304320585 
7110:          SITE(3,3)=0.24427924797096:          SITE(3,3)=0.2442792479
7111:          SITE(4,1)=-0.61664613137097:          SITE(4,1)=-0.6166461313
7112:          SITE(4,2)=1.43018053897098:          SITE(4,2)=1.4301805389 
7113:          SITE(4,3)=0.13275465717099:          SITE(4,3)=0.1327546571
7114:          SITE(5,1)=-0.44602678367100:          SITE(5,1)=-0.4460267836
7115:          SITE(5,2)=0.52548096457101:          SITE(5,2)=0.5254809645  
7116:          SITE(5,3)=-0.21968379627102:          SITE(5,3)=-0.2196837962
7117:          SITE(6,1)=0.53139837497103:          SITE(6,1)=0.5313983749 
7118:          SITE(6,2)=0.52107077397104:          SITE(6,2)=0.5210707739  
7119:          SITE(6,3)=-0.34096451977105:          SITE(6,3)=-0.3409645197
7120:          SITE(7,1)=0.70653416137106:          SITE(7,1)=0.7065341613  
7121:          SITE(7,2)=-0.39142779627107:          SITE(7,2)=-0.3914277962 
7122:          SITE(7,3)=-0.67195798357108:          SITE(7,3)=-0.6719579835 
7123:          SITE(8,1)=1.67763979407109:          SITE(8,1)=1.6776397940  
7124:          SITE(8,2)=-0.38300535007110:          SITE(8,2)=-0.3830053500 
7125:          SITE(8,3)=-0.83552666047111:          SITE(8,3)=-0.8355266604
7126:          SITE(9,1)=1.81626894037112:          SITE(9,1)=1.8162689403  
7127:          SITE(9,2)=-1.30933819477113:          SITE(9,2)=-1.3093381947 
7128:          SITE(9,3)=-1.14278740157114:          SITE(9,3)=-1.1427874015
7129: !7115: !
7130: ! NOT DOCUMENTED7116: ! NOT DOCUMENTED
7131: !7117: !
7132:       ELSE IF (WORD.EQ.'SUPERSTEP') THEN7118:       ELSE IF (WORD.EQ.'SUPERSTEP') THEN
7133:          SUPERSTEP=.TRUE.7119:          SUPERSTEP=.TRUE.
7134:          IF (NITEMS.GT.1) CALL READI(NSUPER)7120:          IF (NITEMS.GT.1) CALL READI(NSUPER)
7135:          IF (NITEMS.GT.2) CALL READF(SUPSTEP)7121:          IF (NITEMS.GT.2) CALL READF(SUPSTEP)
7136:          IF (NITEMS.GT.3) CALL READF(TEMPS)7122:          IF (NITEMS.GT.3) CALL READF(TEMPS)
7137:          IF (NITEMS.GT.4) CALL READF(SACCRAT)7123:          IF (NITEMS.GT.4) CALL READF(SACCRAT)
7223: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),7209: !              READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SWAP1(PERMGROUP(J3),J2),J2=1,NSWAP(J1)),
7224: !    &                                                            J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)7210: !    &                                                            J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1)
7225:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),7211:                READ(1,*) PERMGROUP(NDUMMY:NDUMMY+NPERMSIZE(J1)-1),((SETS(PERMGROUP(J3),J2),J3=NDUMMY,NDUMMY+NPERMSIZE(J1)-1),
7226:      &                                                              J2=1,NSETS(J1))7212:      &                                                              J2=1,NSETS(J1))
7227: 7213: 
7228:                NDUMMY=NDUMMY+NPERMSIZE(J1)7214:                NDUMMY=NDUMMY+NPERMSIZE(J1)
7229:             ENDDO7215:             ENDDO
7230:             CLOSE(1)7216:             CLOSE(1)
7231: !7217: !
7232: !  And yet another!7218: !  And yet another!
7233: !7219: !  
7234:             IF (NFREEZE.GT.0) THEN7220:             IF (NFREEZE.GT.0) THEN
7235:                NDUMMY=07221:                NDUMMY=0
7236:                DO J1=1,NPERMGROUP7222:                DO J1=1,NPERMGROUP
7237:                   DO J2=1,NPERMSIZE(J1)7223:                   DO J2=1,NPERMSIZE(J1)
7238:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN7224:                      IF (FROZEN(PERMGROUP(NDUMMY+J2))) THEN
7239:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'7225:                         PRINT '(A,I8,A)',' keyword> ERROR atom ',PERMGROUP(NDUMMY+J2),' cannot be frozen and permuted'
7240:                         STOP7226:                         STOP
7241:                      ENDIF7227:                      ENDIF
7242:                   ENDDO7228:                   ENDDO
7243:                   NDUMMY=NDUMMY+NPERMSIZE(J1)7229:                   NDUMMY=NDUMMY+NPERMSIZE(J1)
7323:          IF (NITEMS-1.LT.NPAR) THEN7309:          IF (NITEMS-1.LT.NPAR) THEN
7324:             DO J1=NITEMS,NPAR7310:             DO J1=NITEMS,NPAR
7325:                TEMP(J1)=TEMP(1)7311:                TEMP(J1)=TEMP(1)
7326:             ENDDO7312:             ENDDO
7327:          ENDIF7313:          ENDIF
7328: !7314: !
7329: ! Tethered WL walk to determine anharmonic vibrational density of states7315: ! Tethered WL walk to determine anharmonic vibrational density of states
7330: !7316: !
7331:       ELSE IF (WORD.EQ.'TETHER') THEN7317:       ELSE IF (WORD.EQ.'TETHER') THEN
7332:          TETHER=.TRUE.7318:          TETHER=.TRUE.
7333:          CALL READF(hdistconstraint)7319:          CALL READF(hdistconstraint) 
7334:         CALL READI(hwindows)7320:         CALL READI(hwindows)
7335:          lhbins=int(hbins/hwindows)7321:          lhbins=int(hbins/hwindows)
7336:          CALL READF(ExtrapolationPercent)7322:          CALL READF(ExtrapolationPercent)
7337:          lhbins=int(hbins/hwindows)7323:          lhbins=int(hbins/hwindows)
7338:          sampledbins=int((1.0d0-ExtrapolationPercent)*hbins/hwindows)7324:          sampledbins=int((1.0d0-ExtrapolationPercent)*hbins/hwindows)
7339:          CALL READF(lnHarmFreq)7325:          CALL READF(lnHarmFreq)
7340:       ELSE IF (WORD.EQ.'THOMSON') THEN7326:       ELSE IF (WORD.EQ.'THOMSON') THEN
7341:          THOMSONT=.TRUE.7327:          THOMSONT=.TRUE.
7342:          ODDCHARGE=1.0D07328:          ODDCHARGE=1.0D0
7343:          IF (NITEMS.GT.1) CALL READF(ODDCHARGE)7329:          IF (NITEMS.GT.1) CALL READF(ODDCHARGE)
7393:       ELSE IF (WORD.EQ.'TSALLIS') THEN7379:       ELSE IF (WORD.EQ.'TSALLIS') THEN
7394:          TSALLIST=.TRUE.7380:          TSALLIST=.TRUE.
7395:          IF (NITEMS.GT.1) THEN7381:          IF (NITEMS.GT.1) THEN
7396:             CALL READF(QTSALLIS)7382:             CALL READF(QTSALLIS)
7397:          ENDIF7383:          ENDIF
7398:       ELSE IF (WORD.EQ.'NEWTSALLIS') THEN7384:       ELSE IF (WORD.EQ.'NEWTSALLIS') THEN
7399:          NEWTSALLIST=.TRUE.7385:          NEWTSALLIST=.TRUE.
7400:          IF (NITEMS.GT.1) THEN7386:          IF (NITEMS.GT.1) THEN
7401:             CALL READF(QTSALLIS)7387:             CALL READF(QTSALLIS)
7402:          ENDIF7388:          ENDIF
7403: 7389:          
7404: !7390: !
7405: !  Xantheas' TTM3-F water potential7391: !  Xantheas' TTM3-F water potential
7406: !7392: !
7407:       ELSE IF (WORD.EQ.'TTM3') THEN7393:       ELSE IF (WORD.EQ.'TTM3') THEN
7408:         TTM3T=.TRUE.7394:         TTM3T=.TRUE.
7409: 7395: 
7410: !! ns644> Adding dihedral angle potential via TWIST keyword:7396: !! ns644> Adding dihedral angle potential via TWIST keyword: 
7411:       ELSE IF (WORD.EQ.'TWIST') THEN7397:       ELSE IF (WORD.EQ.'TWIST') THEN
7412:          TWISTT=.TRUE.7398:          TWISTT=.TRUE. 
7413:          INQUIRE(FILE='twistgroups',EXIST=YESNO)7399:          INQUIRE(FILE='twistgroups',EXIST=YESNO)
7414:          IF (NITEMS.EQ.7) THEN7400:          IF (NITEMS.EQ.7) THEN
7415:             NTWISTGROUPS = 17401:             NTWISTGROUPS = 1
7416:             ALLOCATE(TWIST_K(1))7402:             ALLOCATE(TWIST_K(1))
7417:             ALLOCATE(TWIST_THETA0(1))7403:             ALLOCATE(TWIST_THETA0(1))
7418:             ALLOCATE(TWIST_ATOMS(1,1))7404:             ALLOCATE(TWIST_ATOMS(1,1))
7419:             CALL READI(TWIST_ATOMS(1,1))7405:             CALL READI(TWIST_ATOMS(1,1))
7420:             CALL READI(TWIST_ATOMS(2,1))7406:             CALL READI(TWIST_ATOMS(2,1))
7421:             CALL READI(TWIST_ATOMS(3,1))7407:             CALL READI(TWIST_ATOMS(3,1))
7422:             CALL READI(TWIST_ATOMS(4,1))7408:             CALL READI(TWIST_ATOMS(4,1))
7423:             CALL READF(TWIST_K(1))7409:             CALL READF(TWIST_K(1))
7424:             CALL READF(TWIST_THETA0(1))7410:             CALL READF(TWIST_THETA0(1))
7425:          ELSE IF (NITEMS.EQ.1 .AND. YESNO) THEN7411:          ELSE IF (NITEMS.EQ.1 .AND. YESNO) THEN
7426:             OPEN(UNIT=444,FILE='twistgroups',status='unknown')7412:             OPEN(UNIT=444,FILE='twistgroups',status='unknown')
7427:             WRITE(MYUNIT,*) 'keyword> Reading in twistgroups..'7413:             WRITE(MYUNIT,*) 'keyword> Reading in twistgroups..'
7428:             READ(444,*) NTWISTGROUPS7414:             READ(444,*) NTWISTGROUPS
7429:             ALLOCATE(TWIST_K(NTWISTGROUPS))7415:             ALLOCATE(TWIST_K(NTWISTGROUPS))
7430:             ALLOCATE(TWIST_THETA0(NTWISTGROUPS))7416:             ALLOCATE(TWIST_THETA0(NTWISTGROUPS))
7431:             ALLOCATE(TWIST_ATOMS(4,NTWISTGROUPS))7417:             ALLOCATE(TWIST_ATOMS(4,NTWISTGROUPS))
7432:             DO J1=1, NTWISTGROUPS7418:             DO J1=1, NTWISTGROUPS
7433:                READ(444,*) TWIST_ATOMS(1,J1),TWIST_ATOMS(2,J1),7419:                READ(444,*) TWIST_ATOMS(1,J1),TWIST_ATOMS(2,J1), 
7434:      &                     TWIST_ATOMS(3,J1),TWIST_ATOMS(4,J1),7420:      &                     TWIST_ATOMS(3,J1),TWIST_ATOMS(4,J1),
7435:      &                     TWIST_K(J1),TWIST_THETA0(J1)7421:      &                     TWIST_K(J1),TWIST_THETA0(J1)          
7436:             END DO7422:             END DO 
7437:          ELSE7423:          ELSE
7438:             WRITE(MYUNIT,*) 'Provide twistgroups file, or specify7424:             WRITE(MYUNIT,*) 'Provide twistgroups file, or specify
7439:      &                          details of single dihedral in data'7425:      &                          details of single dihedral in data'
7440:             STOP7426:             STOP
7441:          END IF7427:          END IF
7442: 7428: 
7443:       ELSE IF (WORD.EQ.'TWOPLUS') THEN7429:       ELSE IF (WORD.EQ.'TWOPLUS') THEN
7444:          TWOPLUS=.TRUE.7430:          TWOPLUS=.TRUE.
7445: !7431: !
7446: !     Specify 2D XY APBC potential7432: !     Specify 2D XY APBC potential
7447: !7433: !
7448:       ELSE IF (WORD.EQ.'TWODAPBC') THEN7434:       ELSE IF (WORD.EQ.'TWODAPBC') THEN                                        
7449:          TWODAPBCT=.TRUE.7435:          TWODAPBCT=.TRUE. 
7450:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)7436:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)  
7451:          IF (MOD(NONEDAPBC,3).NE.0) THEN7437:          IF (MOD(NONEDAPBC,3).NE.0) THEN        
7452:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'7438:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'    
7453:             STOP7439:             STOP
7454:          ENDIF7440:          ENDIF
7455: 7441: 
7456: !7442: !
7457: !     Specify 2D XY PBC potential7443: !     Specify 2D XY PBC potential 
7458: !7444: !      
7459:       ELSE IF (WORD.EQ.'TWODPBC') THEN7445:       ELSE IF (WORD.EQ.'TWODPBC') THEN   
7460:          TWODPBCT=.TRUE.7446:          TWODPBCT=.TRUE.
7461:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)7447:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)
7462:          IF (MOD(NONEDAPBC,3).NE.0) THEN7448:          IF (MOD(NONEDAPBC,3).NE.0) THEN 
7463:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'7449:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'  
7464:             STOP7450:             STOP 
7465:          ENDIF7451:          ENDIF 
7466: 7452: 
7467: !7453: !                                                                                                                                                                                                          
7468: !     Specify 3D XY APBC potential7454: !     Specify 3D XY APBC potential                                                                                                                                                                         
7469: !7455: !                                                                                                                                                                                                          
7470:       ELSE IF (WORD.EQ.'THREEDAPBC') THEN7456:       ELSE IF (WORD.EQ.'THREEDAPBC') THEN                                                                                                                                       
7471:          THREEDAPBCT=.TRUE.7457:          THREEDAPBCT=.TRUE.
7472:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)7458:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)
7473:          IF (MOD(NONEDAPBC,3).NE.0) THEN7459:          IF (MOD(NONEDAPBC,3).NE.0) THEN
7474:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'7460:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'                                                                                                         
7475:             STOP7461:             STOP                                                                                                                                                                                            
7476:          ENDIF7462:          ENDIF 
7477: 7463: 
7478: 7464: 
7479: !7465: !                                                                                                                                                                                                          
7480: !     Specify 3D XY PBC potential7466: !     Specify 3D XY PBC potential                                                                                                                                                                         
7481: !7467: !                                                                                                                                                                                                          
7482:       ELSE IF (WORD.EQ.'THREEDPBC') THEN7468:       ELSE IF (WORD.EQ.'THREEDPBC') THEN                                                                                                                                                                 
7483:          THREEDPBCT=.TRUE.7469:          THREEDPBCT=.TRUE.
7484:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)7470:          IF (NITEMS.GT.1) CALL READI(NONEDAPBC)
7485:          IF (MOD(NONEDAPBC,3).NE.0) THEN7471:          IF (MOD(NONEDAPBC,3).NE.0) THEN
7486:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'7472:             WRITE(MYUNIT,'(A)') 'keywords> ERROR *** lattice dimension must be a multiple of three'                                                                                                         
7487:             STOP7473:             STOP                                                                                                                                                                                            
7488:          ENDIF7474:          ENDIF 
7489: !7475: !
7490: !  Set proposed atomic steps in takestep to be uniformly distributed within7476: !  Set proposed atomic steps in takestep to be uniformly distributed within
7491: !  a sphere of given radius.7477: !  a sphere of given radius.
7492: !7478: !
7493:       ELSE IF (WORD.EQ.'UNIFORMMOVE') THEN7479:       ELSE IF (WORD.EQ.'UNIFORMMOVE') THEN
7494:          UNIFORMMOVE=.TRUE.7480:          UNIFORMMOVE=.TRUE.
7495: 7481: 
7496: !7482: !
7497: ! csw34> Update the reference coordinates for the generalised rigid bodies after a step has been taken.7483: ! csw34> Update the reference coordinates for the generalised rigid bodies after a step has been taken. 
7498: !        This allows steps to be taken WITHIN the rigid bodies, although HYBRIDMIN should also be used7484: !        This allows steps to be taken WITHIN the rigid bodies, although HYBRIDMIN should also be used
7499: !        as any bad conformation intrduced by these step will otherwise be frozen into the rigid bodies.7485: !        as any bad conformation intrduced by these step will otherwise be frozen into the rigid bodies.
7500: !7486: !
7501:       ELSE IF (WORD.EQ.'UPDATERIGIDREF') THEN7487:       ELSE IF (WORD.EQ.'UPDATERIGIDREF') THEN
7502:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body reference coordinates will be updated after each step'7488:          WRITE(MYUNIT,'(A)') ' keyword> Rigid body reference coordinates will be updated after each step'
7503:          WRITE(MYUNIT,'(A)') ' UPDATERIGIDREF> WARNING: make sure HYBRIDMIN is enabled!'7489:          WRITE(MYUNIT,'(A)') ' UPDATERIGIDREF> WARNING: make sure HYBRIDMIN is enabled!'
7504:          UPDATERIGIDREFT=.TRUE.7490:          UPDATERIGIDREFT=.TRUE.
7505: 7491: 
7506: !7492: !
7507: !  Number of BFGS updates before resetting, default=47493: !  Number of BFGS updates before resetting, default=4
7508: !7494: !
7509:       ELSE IF (WORD.EQ.'UPDATES') THEN7495:       ELSE IF (WORD.EQ.'UPDATES') THEN
7510:          CALL READI(MUPDATE)7496:          CALL READI(MUPDATE)
7511: !7497: !
7512: !  Whether to include rotational partition function for FEBH7498: !  Whether to include rotational partition function for FEBH
7513: !7499: !
7514:       ELSE IF (WORD.EQ.'USEROT') THEN7500:       ELSE IF (WORD.EQ.'USEROT') THEN
7515:          USEROT=.TRUE.7501:          USEROT=.TRUE.
7516: !7502: !      
7517: ! vr2747503: ! vr274
7518: ! This is supposed to be a potential which is linked in from a different file7504: ! This is supposed to be a potential which is linked in from a different file
7519: ! TODO: to some checking, e.g. give a string which defines the userpotential7505: ! TODO: to some checking, e.g. give a string which defines the userpotential
7520: ! and checks whether the correct binary is used, etc7506: ! and checks whether the correct binary is used, etc
7521: !7507: !
7522:       ELSE IF (WORD.EQ.'USERPOT') THEN7508:       ELSE IF (WORD.EQ.'USERPOT') THEN
7523:          USERPOTT=.true.7509:          USERPOTT=.true.
7524:          CALL USERPOT_INITIALIZE_GMIN(3*NATOMSALLOC, COORDS(:,1))7510:          CALL USERPOT_INITIALIZE_GMIN(3*NATOMSALLOC, COORDS(:,1))
7525: 7511: 
7526: !7512: !
7527: !  Use VGW (Variational Gaussian Wavepacket) Minimization (Quantum Quenching)7513: !  Use VGW (Variational Gaussian Wavepacket) Minimization (Quantum Quenching)
7528: !7514: !
7529:       ELSE IF (WORD.EQ.'VGW') THEN7515:       ELSE IF (WORD.EQ.'VGW') THEN
7530:          VGW=.TRUE.7516:          VGW=.TRUE.
7531:          LBFGST=.FALSE.7517:          LBFGST=.FALSE.
7532:          CALL READF(LJSIGMA)7518:          CALL READF(LJSIGMA)
7533:          CALL READF(LJEPSILON)7519:          CALL READF(LJEPSILON)
7534:          CALL READF(TAUMAX)7520:          CALL READF(TAUMAX)
7535:          CALL READF(TAUMAXFULL)7521:          CALL READF(TAUMAXFULL)
7536: 7522:                  
7537:       ELSE IF (WORD.EQ.'VGWCPS') THEN7523:       ELSE IF (WORD.EQ.'VGWCPS') THEN
7538:          CALL READI(CPS)7524:          CALL READI(CPS)
7539:          CALL READF(CPFACTORSG)7525:          CALL READF(CPFACTORSG)
7540: 7526: 
7541:       ELSE IF (WORD.EQ.'VGWCPF') THEN7527:       ELSE IF (WORD.EQ.'VGWCPF') THEN
7542:          CALL READI(CPF)7528:          CALL READI(CPF)
7543:          CALL READF(CPFACTORFG)7529:          CALL READF(CPFACTORFG)
7544: 7530: 
7545:       ELSE IF (WORD.EQ.'VGWTOL') THEN7531:       ELSE IF (WORD.EQ.'VGWTOL') THEN
7546:          CALL READF(VGWTOL)7532:          CALL READF(VGWTOL)
7547: 7533: 
7548: !7534: !
7549: ! Choice of convergence regime for Wang-Landau runs: histogram flatness (default),7535: ! Choice of convergence regime for Wang-Landau runs: histogram flatness (default), 
7550: ! VisitProp - minimal number of visits proportional to 1/sqrt(ln(f))7536: ! VisitProp - minimal number of visits proportional to 1/sqrt(ln(f))
7551: !7537: !
7552:       ELSE IF (WORD.EQ.'VISITPROP') THEN7538:       ELSE IF (WORD.EQ.'VISITPROP') THEN
7553:          VISITPROP=.TRUE.7539:          VISITPROP=.TRUE.
7554: !7540: !
7555: ! Maximum PE for an instantaneous configuration above a basin bottom in BSPT7541: ! Maximum PE for an instantaneous configuration above a basin bottom in BSPT
7556: !7542: !
7557:       ELSE IF (WORD.EQ.'TSTAR') THEN7543:       ELSE IF (WORD.EQ.'TSTAR') THEN
7558:          CALL READF(TSTAR)7544:          CALL READF(TSTAR)
7559:       ELSE IF (WORD.EQ.'WELCH') THEN7545:       ELSE IF (WORD.EQ.'WELCH') THEN
7580: 7566: 
7581: ! jdf43>7567: ! jdf43>
7582:       ELSE IF (WORD.EQ.'TBP') THEN7568:       ELSE IF (WORD.EQ.'TBP') THEN
7583:          TBP=.TRUE.7569:          TBP=.TRUE.
7584:          CALL READF(TBPMIN)7570:          CALL READF(TBPMIN)
7585:          CALL READF(TBPSTEP)7571:          CALL READF(TBPSTEP)
7586:          CALL READI(TBPSTEPS)7572:          CALL READI(TBPSTEPS)
7587:          CALL READF(TBPHF)7573:          CALL READF(TBPHF)
7588:          CALL READF(TBPCF)7574:          CALL READF(TBPCF)
7589:          CALL READI(TBPCI)7575:          CALL READI(TBPCI)
7590:          ALLOCATE(TBPBASINS(TBPSTEPS),TBPBASINSO(TBPSTEPS))7576:          ALLOCATE(TBPBASINS(TBPSTEPS),TBPBASINSO(TBPSTEPS)) 
7591: 7577: 
7592:       ELSE IF (WORD.EQ.'RATIO') THEN7578:       ELSE IF (WORD.EQ.'RATIO') THEN
7593:          RATIOT=.TRUE.7579:          RATIOT=.TRUE.
7594:          CALL READF(SRATIO)7580:          CALL READF(SRATIO)
7595:          CALL READF(TRATIO)7581:          CALL READF(TRATIO)
7596:          FIXBOTH=.TRUE.7582:          FIXBOTH=.TRUE.
7597: 7583: 
7598:       ELSE IF (WORD.EQ.'MWFILM') THEN7584:       ELSE IF (WORD.EQ.'MWFILM') THEN
7599:          MWFILMT=.TRUE.7585:          MWFILMT=.TRUE.
7600: 7586: 
7633:          MOLECULART=.TRUE.7619:          MOLECULART=.TRUE.
7634:          ALLOCATE(TYPECH(NATOMSALLOC))7620:          ALLOCATE(TYPECH(NATOMSALLOC))
7635:          TYPECH(1::3)(1:1)="O"7621:          TYPECH(1::3)(1:1)="O"
7636:          TYPECH(2::3)(1:1)="H"7622:          TYPECH(2::3)(1:1)="H"
7637:          TYPECH(3::3)(1:1)="H"7623:          TYPECH(3::3)(1:1)="H"
7638:       ELSE7624:       ELSE
7639:          CALL REPORT('Unrecognized command '//WORD,.TRUE.)7625:          CALL REPORT('Unrecognized command '//WORD,.TRUE.)
7640:          STOP7626:          STOP
7641:       ENDIF7627:       ENDIF
7642:       CALL FLUSH(MYUNIT)7628:       CALL FLUSH(MYUNIT)
7643: 7629:       
7644: !ds656> NTYPEA can fluctuate in homotop refinemet routine, so we need7630: !ds656> NTYPEA can fluctuate in homotop refinemet routine, so we need
7645: !     a fixed reference. It is set here instead of every single7631: !     a fixed reference. It is set here instead of every single
7646: !     IF block where NTYPEA can potentially change.7632: !     IF block where NTYPEA can potentially change. 
7647:       NTYPEA_FIX = NTYPEA7633:       NTYPEA_FIX = NTYPEA
7648: 7634:       
7649:       GOTO 1907635:       GOTO 190
7650: 7636:             
7651:       RETURN7637:       RETURN
7652:       END7638:       END


r31963/lj_gauss.f90 2017-02-23 15:30:39.000840747 +0000 r31962/lj_gauss.f90 2017-02-23 15:30:40.168856234 +0000
  1: !   GMIN: A program for finding global minima  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/GMIN/source/lj_gauss.f90' in revision 31962
  2: !   Copyright (C) 1999-2017 David J. Wales 
  3: !   This file is part of GMIN. 
  4: ! 
  5: !   GMIN is free software; you can redistribute it and/or modify 
  6: !   it under the terms of the GNU General Public License as published by 
  7: !   the Free Software Foundation; either version 2 of the License, or 
  8: !   (at your option) any later version. 
  9: ! 
 10: !   GMIN is distributed in the hope that it will be useful, 
 11: !   but WITHOUT ANY WARRANTY; without even the implied warranty of 
 12: !   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 13: !   GNU General Public License for more details. 
 14: ! 
 15: !   You should have received a copy of the GNU General Public License 
 16: !   along with this program; if not, write to the Free Software 
 17: !   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 18: ! 
 19: ! 
 20: ! This module provides a routine for calculating the energy and gradients with 
 21: ! a double well Lennard-Jones + Gaussian potential. 
 22: ! Questions to jwrm2. 
 23: ! 
 24: MODULE LJ_GAUSS_MOD 
 25:  
 26: PUBLIC :: LJ_GAUSS_EPS, LJ_GAUSS_R0, LJ_GAUSS_RCUT 
 27: PUBLIC :: LJ_GAUSS, LJ_GAUSS_INITIALISE 
 28: PRIVATE :: LJ_GAUSS_SIGMASQ, RCUTINV6, RCUTINV12, EXP_RCUT, PREF_RCUT 
 29: PRIVATE :: PERIODIC_RESET, LJ_GAUSS_PER, CALC_ENERGY, CALC_GRAD 
 30:  
 31: ! EPS: strength of the Gaussian potential. The LJ strength is 1. 
 32: ! R0: Equilibrium distance of the minimum in the Gaussian potential. The LJ 
 33: !     rmin is 1. 
 34: ! RCUTSQ: cutoff distance at which the energy, gradients and Hessian of 
 35: !         both parts of the potential go smoothly to zero. 
 36: DOUBLE PRECISION :: LJ_GAUSS_EPS, LJ_GAUSS_R0, LJ_GAUSS_RCUT 
 37:  
 38: ! LJ_GAUSS_SIGMA: variation (width) of the Gaussian potential 
 39: DOUBLE PRECISION, PARAMETER :: LJ_GAUSS_SIGMASQ = 0.02D0 
 40:  
 41: ! RCUTINV6, RCUTINV12: factors for LJ which don't pened on particle distance 
 42: DOUBLE PRECISION :: RCUTINV6, RCUTINV12 
 43:  
 44: ! EXP_RCUT, PREF_RCUT: factors for Gauss which don't depend on the particle 
 45: !                      distance 
 46: DOUBLE PRECISION :: EXP_RCUT, PREF_RCUT 
 47:  
 48: CONTAINS 
 49:  
 50: !------------------------------------------------------------------------------- 
 51: ! 
 52: ! Main routine for calculating the energy and gradients. 
 53: ! X: coordinates array 
 54: ! GRAD: gradients array 
 55: ! ENERGY: calculated energy 
 56: ! GTEST: whether gradients should be calculated 
 57: ! 
 58: !------------------------------------------------------------------------------- 
 59:     SUBROUTINE LJ_GAUSS(X, GRAD, ENERGY, GTEST) 
 60:  
 61:         ! NATOMS: number of particles 
 62:         ! PERIODIC: whether to use periodic boundary conditions 
 63:         USE COMMONS, ONLY: NATOMS, PERIODIC 
 64:  
 65:         IMPLICIT NONE 
 66:  
 67:         DOUBLE PRECISION, INTENT(INOUT) :: X(3*NATOMS) 
 68:         DOUBLE PRECISION, INTENT(OUT) :: GRAD(3*NATOMS), ENERGY 
 69:         LOGICAL, INTENT(IN) :: GTEST 
 70:  
 71:         ! I, J: indices for looping over particles 
 72:         INTEGER :: I, J 
 73:  
 74:         ! RIJ: Interparticle vector 
 75:         ! MODRIJ: distance between a pair of particles 
 76:         ! DVDR: derivative of pair potential wrt MODRIJ 
 77:         DOUBLE PRECISION :: RIJ(3), MODRIJ, DVDR 
 78:  
 79:         ! Initialise output variables 
 80:         ENERGY = 0.D0 
 81:         GRAD(:) = 0.D0 
 82:  
 83:         ! Reset all particles to within the box 
 84:         IF (PERIODIC) CALL PERIODIC_RESET(X(:)) 
 85:  
 86:         DO I = 1, NATOMS-1 ! Outer loop over particles 
 87:             DO J = I+1, NATOMS ! Inner loop over particles 
 88:  
 89:                 IF (.NOT. PERIODIC) THEN 
 90:                     ! Get the particle-particle distance 
 91:                     RIJ(:) = X(3*I-2:3*I) - X(3*J-2:3*J) 
 92:                     MODRIJ = SQRT(DOT_PRODUCT(RIJ(:), RIJ(:))) 
 93:  
 94:                     ! Add energy and gradients 
 95:                     IF (MODRIJ .LT. LJ_GAUSS_RCUT) THEN 
 96:                         ENERGY = ENERGY + CALC_ENERGY(MODRIJ) 
 97:  
 98:                         IF (GTEST) THEN 
 99:                             DVDR = CALC_GRAD(MODRIJ) 
100:                             GRAD(3*I-2:3*I) = GRAD(3*I-2:3*I) + & 
101:                                               DVDR*RIJ(:)/MODRIJ 
102:                             GRAD(3*J-2:3*J) = GRAD(3*J-2:3*J) - & 
103:                                               DVDR*RIJ(:)/MODRIJ 
104:                         END IF ! GTEST 
105:                     END IF ! If less than cutoff distance 
106:  
107:                 ELSE ! Periodic 
108:                     ! Add energy and gradients 
109:                     CALL LJ_GAUSS_PER(X(3*I-2:3*I), X(3*J-2:3*J), & 
110:                                       GRAD(3*I-2:3*I), GRAD(3*J-2:3*J), & 
111:                                       ENERGY, GTEST) 
112:                 END IF ! End if periodic 
113:  
114:             END DO ! Inner loop over particles 
115:         END DO ! Outer loop over particles 
116:  
117:     END SUBROUTINE LJ_GAUSS 
118:  
119: !------------------------------------------------------------------------------- 
120: ! 
121: ! Calculates the energy contribution for a pair of particles. 
122: ! MODRIJ: distance beteen the particle pair 
123: ! 
124: !------------------------------------------------------------------------------- 
125:     PURE DOUBLE PRECISION FUNCTION CALC_ENERGY(MODRIJ) 
126:  
127:         IMPLICIT NONE 
128:  
129:         DOUBLE PRECISION, INTENT(IN) :: MODRIJ 
130:  
131:         ! LJ6, LJ12: factors for the LJ potential 
132:         DOUBLE PRECISION :: LJ6, LJ12 
133:         ! EXPRIJ: factor for the Gauss potential 
134:         DOUBLE PRECISION :: EXP_RIJ 
135:         ! ENERGY: temporary energy store 
136:         DOUBLE PRECISION :: ENERGY 
137:  
138:         ! Initialise output variables 
139:         ENERGY = 0.D0 
140:  
141:         ! Evaluate LJ energy 
142:         LJ6 = (1.D0/MODRIJ)**6 
143:         LJ12 = LJ6**2 
144:         ENERGY = ENERGY + LJ12 - 2.D0*LJ6 
145:         ! Correction to LJ to make potential go to zero at RCUT 
146:         ENERGY = ENERGY - (RCUTINV12 - 2*RCUTINV6) 
147:         ! Correction to LJ to make derivative go to zero at RCUT 
148:         ENERGY = ENERGY + (12.D0/LJ_GAUSS_RCUT) * & 
149:                           (RCUTINV12 - RCUTINV6)* & 
150:                           (MODRIJ - LJ_GAUSS_RCUT) 
151:         ! Correction to LJ to make second derivatives go to zero at 
152:         ! RCUT 
153:         ENERGY = ENERGY + (1.D0/LJ_GAUSS_RCUT**2) * & 
154:                           (42.D0*RCUTINV6 - 78.D0*RCUTINV12) * & 
155:                           (MODRIJ - LJ_GAUSS_RCUT)**2 
156:         ! Evaluate Gaussian energy 
157:         EXP_RIJ = LJ_GAUSS_EPS * & 
158:                   EXP(- (MODRIJ - LJ_GAUSS_R0)**2 / & 
159:                         (2.D0*LJ_GAUSS_SIGMASQ)) 
160:         ENERGY = ENERGY - EXP_RIJ 
161:         ! Correction to Gauss to make potential go to zero at RCUT 
162:         ENERGY = ENERGY + EXP_RCUT 
163:         ! Correction to Gauss to make derivatives go to zero at RCUT 
164:         ENERGY = ENERGY - PREF_RCUT*EXP_RCUT*(MODRIJ-LJ_GAUSS_RCUT) 
165:         ! Correct to Gauss to make second derivatives go to zero at 
166:         ! RCUT 
167:         ENERGY = ENERGY - (EXP_RCUT / LJ_GAUSS_SIGMASQ - & 
168:                            (PREF_RCUT**2) * EXP_RCUT) * & 
169:                           0.5D0*((MODRIJ - LJ_GAUSS_RCUT)**2) 
170:  
171:         CALC_ENERGY = ENERGY 
172:  
173:     END FUNCTION CALC_ENERGY 
174:  
175: !------------------------------------------------------------------------------- 
176: ! 
177: ! Calculates the pair potential gradient for a pair of particles. 
178: ! MODRIJ: distance beteen the particle pair 
179: ! 
180: !------------------------------------------------------------------------------- 
181:     PURE DOUBLE PRECISION FUNCTION CALC_GRAD (MODRIJ) 
182:  
183:         IMPLICIT NONE 
184:  
185:         DOUBLE PRECISION, INTENT(IN) :: MODRIJ 
186:  
187:         ! LJ6, LJ12: factors for the LJ potential 
188:         DOUBLE PRECISION :: LJ6, LJ12 
189:         ! EXP_RIJ, PREF_RIJ: factor for the Gauss potential 
190:         DOUBLE PRECISION :: EXP_RIJ, PREF_RIJ 
191:         ! DVDR: temporary store for the result 
192:         DOUBLE PRECISION :: DVDR 
193:  
194:         ! Initialise output variables 
195:         DVDR = 0.D0 
196:  
197:         ! LJ factors 
198:         LJ6 = (1.D0/MODRIJ)**6 
199:         LJ12 = LJ6**2 
200:  
201:         ! Evaluate LJ derivatives 
202:         DVDR = DVDR + (12.D0/MODRIJ) * (LJ6 - LJ12) 
203:         ! Correction to LJ to make derivaitves go to zero at 
204:         ! RCUT 
205:         DVDR = DVDR + (12.D0/LJ_GAUSS_RCUT) * (RCUTINV12 - RCUTINV6) 
206:         ! Correction to LJ to make second derivatives go to zero 
207:         ! at RCUT 
208:         DVDR = DVDR + (12.D0/LJ_GAUSS_RCUT**2) * & 
209:                       (7.D0*RCUTINV6 - 13.D0*RCUTINV12) * & 
210:                       (MODRIJ - LJ_GAUSS_RCUT) 
211:  
212:         ! Gauss factors 
213:         PREF_RIJ = (MODRIJ - LJ_GAUSS_R0) / LJ_GAUSS_SIGMASQ 
214:         EXP_RIJ = LJ_GAUSS_EPS * EXP(- (MODRIJ - LJ_GAUSS_R0)**2 / & 
215:                                        (2.D0*LJ_GAUSS_SIGMASQ)) 
216:  
217:         ! Evaluate Gauss derivatives 
218:         DVDR = DVDR + PREF_RIJ * EXP_RIJ 
219:         ! Correction to Gauss to make derivatives go to zero at 
220:         ! RCUT 
221:         DVDR = DVDR - PREF_RCUT * EXP_RCUT 
222:         ! Correction to Gauss to make second derivatives go to 
223:         ! zero at RCUT 
224:         DVDR = DVDR - (EXP_RCUT / LJ_GAUSS_SIGMASQ - & 
225:                        (PREF_RCUT**2) * EXP_RCUT) * & 
226:                       (MODRIJ - LJ_GAUSS_RCUT) 
227:  
228:         CALC_GRAD = DVDR 
229:  
230:     END FUNCTION CALC_GRAD 
231:  
232: !------------------------------------------------------------------------------- 
233: ! 
234: ! Initialisation. Calculate some factors that won't be changing 
235: ! 
236: !------------------------------------------------------------------------------- 
237:     SUBROUTINE LJ_GAUSS_INITIALISE () 
238:  
239:         IMPLICIT NONE 
240:  
241:         ! Calculate some factors for LJ that don't depend on RIJ 
242:         RCUTINV6 = (1.D0/LJ_GAUSS_RCUT)**6 
243:         RCUTINV12 = RCUTINV6**2 
244:  
245:         ! Calculate some factors for Gauss that don't depend on RIJ 
246:         EXP_RCUT = LJ_GAUSS_EPS * EXP(- (LJ_GAUSS_RCUT - LJ_GAUSS_R0)**2 / & 
247:                                         (2.D0*LJ_GAUSS_SIGMASQ)) 
248:         PREF_RCUT = (LJ_GAUSS_RCUT - LJ_GAUSS_R0) / LJ_GAUSS_SIGMASQ 
249:  
250:     END SUBROUTINE LJ_GAUSS_INITIALISE 
251:  
252: !------------------------------------------------------------------------------- 
253: ! 
254: ! Resets all coordinates to within the unit cell 
255: ! COORDS: coordinates of the particles 
256: ! 
257: !------------------------------------------------------------------------------- 
258:     SUBROUTINE PERIODIC_RESET(COORDS) 
259:  
260:         ! BOXLX, BOXLY, BOXLZ: dimensions of box 
261:         ! MYUNIT: file unit for main GMIN output 
262:         ! NATOMS: number of particles 
263:         USE COMMONS, ONLY: BOXLX, BOXLY, BOXLZ, MYUNIT, NATOMS 
264:  
265:         IMPLICIT NONE 
266:  
267:         DOUBLE PRECISION, INTENT(INOUT) :: COORDS(3*NATOMS) 
268:  
269:         INTEGER :: I 
270:  
271:         ! Check RCUT against the box sizes 
272:         IF (LJ_GAUSS_RCUT .GT. BOXLX .OR. LJ_GAUSS_RCUT .GT. BOXLY & 
273:             .OR. LJ_GAUSS_RCUT .GT. BOXLZ) THEN 
274:             WRITE (MYUNIT, *) 'LJ_GAUSS> Box size less the potential cutoff.', & 
275:                               ' This can cause discontinuities.' 
276:         END IF 
277:  
278:         DO I = 1, NATOMS ! Loop over particles 
279:             ! The box stretches from -0.5*BOXLx to 0.5*BOXLx in each direction 
280:             COORDS(3*I-2) = COORDS(3*I - 2) - BOXLX*NINT(COORDS(3*I - 2)/BOXLX) 
281:             COORDS(3*I-1) = COORDS(3*I - 1) - BOXLY*NINT(COORDS(3*I - 1)/BOXLY) 
282:             COORDS(3*I  ) = COORDS(3*I    ) - BOXLZ*NINT(COORDS(3*I    )/BOXLZ) 
283:         END DO ! Loop over particles 
284:  
285:     END SUBROUTINE PERIODIC_RESET 
286:  
287: !------------------------------------------------------------------------------- 
288: ! 
289: ! Finds the energy and gradients for the periodic system 
290: ! COORDS_I: coordinates of particle I 
291: ! COORDS_J: coordinates of particle J 
292: ! GRAD_I: gradients for particle I 
293: ! GRAD_J: gradients for particle J 
294: ! ENERGY: energy contribution for this pair 
295: ! RIJ: mininum length vector between the particles 
296: ! GTEST: whether to calculate gradients 
297: ! 
298: !------------------------------------------------------------------------------- 
299:  
300:     SUBROUTINE LJ_GAUSS_PER(COORDS_I,COORDS_J,GRAD_I,GRAD_J,ENERGY,GTEST) 
301:  
302:         ! BOXLX, BOXLY, BOXLZ: dimensions of the box 
303:         USE COMMONS, ONLY: BOXLX, BOXLY, BOXLZ 
304:  
305:         DOUBLE PRECISION, INTENT(IN) :: COORDS_I(3), COORDS_J(3) 
306:         DOUBLE PRECISION, INTENT(INOUT) :: GRAD_I(3), GRAD_J(3), ENERGY 
307:         LOGICAL, INTENT(IN) :: GTEST 
308:  
309:         ! XJ: copy of j coordinates 
310:         ! RIJ(3): particle-particle vector 
311:         ! MODRIJ: particle-particle distance 
312:         ! DVDR: derivative of pair potential wrt MODRIJ 
313:         DOUBLE PRECISION :: XJ(3), RIJ(3), MODRIJ, DVDR 
314:  
315:         ! PER: integer for looping over cell possibilities 
316:         INTEGER :: PER 
317:  
318:         ! Loop over different coordinate possibilities. 
319:         DO PER = 0, 26 
320:  
321:             XJ(:) = COORDS_J(:) 
322:  
323:             XJ(1) = XJ(1) + (MOD(PER, 3) - 1) * BOXLX 
324:             XJ(2) = XJ(2) + (MOD(PER/3, 3) - 1) * BOXLY 
325:             XJ(3) = XJ(3) + (MOD(PER/9, 3) - 1) * BOXLZ 
326:  
327:             ! Find the distance. 
328:             RIJ(:) = COORDS_I(:) - XJ(:) 
329:             MODRIJ = SQRT(DOT_PRODUCT(RIJ(:),RIJ(:))) 
330:  
331:             IF (MODRIJ .LT. LJ_GAUSS_RCUT) THEN 
332:                 ! Add energy and gradients 
333:                 ENERGY = ENERGY + CALC_ENERGY(MODRIJ) 
334:  
335:                 IF (GTEST) THEN 
336:                     DVDR = CALC_GRAD(MODRIJ) 
337:                     GRAD_I(:) = GRAD_I(:) + DVDR*RIJ(:)/MODRIJ 
338:                     GRAD_J(:) = GRAD_J(:) - DVDR*RIJ(:)/MODRIJ 
339:                 END IF ! GTEST 
340:             END IF ! End if less than cutoff 
341:  
342:         END DO 
343:  
344:     END SUBROUTINE LJ_GAUSS_PER 
345:  
346: END MODULE LJ_GAUSS_MOD 


r31963/potential.f90 2017-02-23 15:30:39.288844566 +0000 r31962/potential.f90 2017-02-23 15:30:40.476860317 +0000
 13: !   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 13: !   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14: !   GNU General Public License for more details. 14: !   GNU General Public License for more details.
 15: ! 15: !
 16: !   You should have received a copy of the GNU General Public License 16: !   You should have received a copy of the GNU General Public License
 17: !   along with this program; if not, write to the Free Software 17: !   along with this program; if not, write to the Free Software
 18: !   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 18: !   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 19: ! 19: !
 20: SUBROUTINE POTENTIAL(X, GRAD, EREAL, GRADT, SECT) 20: SUBROUTINE POTENTIAL(X, GRAD, EREAL, GRADT, SECT)
 21: ! This subroutine acts as a wrapper for all of the potentials implemented in GMIN. 21: ! This subroutine acts as a wrapper for all of the potentials implemented in GMIN.
 22: ! The potential is chosen in the 'data' file (default is Lennard-Jones particles). 22: ! The potential is chosen in the 'data' file (default is Lennard-Jones particles).
 23: ! 23: ! 
 24: ! In addition, this routine also applies fields, if appropriate. 24: ! In addition, this routine also applies fields, if appropriate. 
 25:    USE COMMONS 25:    USE COMMONS
 26:    USE GENRIGID, ONLY: RIGIDINIT, NRIGIDBODY, DEGFREEDOMS, ATOMRIGIDCOORDT, & 26:    USE GENRIGID, ONLY: RIGIDINIT, NRIGIDBODY, DEGFREEDOMS, ATOMRIGIDCOORDT, &
 27:                        AACONVERGENCET, AACONVERGENCE, TRANSFORMRIGIDTOC, & 27:                        AACONVERGENCET, AACONVERGENCE, TRANSFORMRIGIDTOC, &
 28:                        TRANSFORMGRAD, TRANSFORMHESSIAN, TRANSFORMCTORIGID, & 28:                        TRANSFORMGRAD, TRANSFORMHESSIAN, TRANSFORMCTORIGID, &
 29:                        GENRIGID_DISTANCECHECK, GENRIGID_COMPRESS 29:                        GENRIGID_DISTANCECHECK, GENRIGID_COMPRESS
 30:    USE MULTIPOT, ONLY: MULTIPOT_CALL 30:    USE MULTIPOT, ONLY: MULTIPOT_CALL
 31:    USE QMODULE, ONLY: QMIN, QMINP 31:    USE QMODULE, ONLY: QMIN, QMINP 
 32:    USE PERMU, ONLY: FIN 32:    USE PERMU, ONLY: FIN
 33:    USE PORFUNCS 33:    USE PORFUNCS
 34:    USE AMBER12_INTERFACE_MOD, ONLY: AMBER12_ENERGY_AND_GRADIENT, POT_ENE_REC_C,& 34:    USE AMBER12_INTERFACE_MOD, ONLY: AMBER12_ENERGY_AND_GRADIENT, POT_ENE_REC_C,&
 35: &                                   AMBER12_NUM_HESS 35: &                                   AMBER12_NUM_HESS
 36:    USE MODHESS, ONLY: HESS, RBAANORMALMODET 36:    USE MODHESS, ONLY: HESS, RBAANORMALMODET 
 37:    USE MODAMBER9, ONLY: ATMASS1 37:    USE MODAMBER9, ONLY: ATMASS1
 38:    USE OPEP_INTERFACE_MOD, ONLY: OPEP_ENERGY_AND_GRADIENT, OPEP_NUM_HESS 38:    USE OPEP_INTERFACE_MOD, ONLY: OPEP_ENERGY_AND_GRADIENT, OPEP_NUM_HESS
 39:    USE POLIRMOD, ONLY: POLIR 39:    USE POLIRMOD, ONLY: POLIR
 40:    USE MBPOLMOD, ONLY: MBPOL 40:    USE MBPOLMOD, ONLY: MBPOL
 41:    USE SWMOD, ONLY: SWTYPE 41:    USE SWMOD, ONLY: SWTYPE
 42:    USE MODCUDALBFGS, ONLY: CUDA_ENEGRAD_WRAPPER, CUDA_NUMERICAL_HESS 42:    USE MODCUDALBFGS, ONLY: CUDA_ENEGRAD_WRAPPER, CUDA_NUMERICAL_HESS
 43:    USE GAUSS_MOD, ONLY: GFIELD 43:    USE GAUSS_MOD, ONLY: GFIELD
 44:    USE RAD_MOD, ONLY: RAD, RADR 44:    USE RAD_MOD, ONLY: RAD, RADR
 45:    USE PREC, ONLY: INT32, REAL64 45:    USE PREC, ONLY: INT32, REAL64
 46:    USE TWIST_MOD, ONLY: TWISTT, TWIST 46:    USE TWIST_MOD, ONLY: TWISTT, TWIST
 47:    USE CONVEX_POLYHEDRA_MODULE, ONLY: CONVEX_POLYHEDRA 47:    USE CONVEX_POLYHEDRA_MODULE, ONLY: CONVEX_POLYHEDRA
 48:    USE LJ_GAUSS_MOD, ONLY: LJ_GAUSS 
 49:    IMPLICIT NONE 48:    IMPLICIT NONE
 50: ! Arguments 49: ! Arguments
 51: ! TODO: Work out intents 50: ! TODO: Work out intents
 52: ! TODO: Fix array dimensions? 51: ! TODO: Fix array dimensions?
 53:    REAL(REAL64)               :: X(*) 52:    REAL(REAL64)               :: X(*)
 54:    REAL(REAL64)               :: GRAD(*) 53:    REAL(REAL64)               :: GRAD(*)
 55:    REAL(REAL64)               :: EREAL 54:    REAL(REAL64)               :: EREAL
 56:    LOGICAL, INTENT(IN)        :: GRADT 55:    LOGICAL, INTENT(IN)        :: GRADT
 57:    LOGICAL, INTENT(IN)        :: SECT 56:    LOGICAL, INTENT(IN)        :: SECT
 58: ! Variables 57: ! Variables      
 59: ! hk286 > generalised rigid body additions 58: ! hk286 > generalised rigid body additions
 60:    REAL(REAL64)               :: XCOORDS(3*NATOMS), GRADATOMS(3*NATOMS), & 59:    REAL(REAL64)               :: XCOORDS(3*NATOMS), GRADATOMS(3*NATOMS), &
 61:                                  XRIGIDCOORDS(DEGFREEDOMS), XRIGIDGRAD(DEGFREEDOMS) 60:                                  XRIGIDCOORDS(DEGFREEDOMS), XRIGIDGRAD(DEGFREEDOMS)
 62:    REAL(REAL64), ALLOCATABLE  :: TEMPHESS(:) 61:    REAL(REAL64), ALLOCATABLE  :: TEMPHESS(:)
 63:    REAL(REAL64)               :: GRAD1(3*NATOMS) 62:    REAL(REAL64)               :: GRAD1(3*NATOMS)
 64:    INTEGER(INT32)             :: I, J, K 63:    INTEGER(INT32)             :: I, J, K
 65:    REAL(REAL64)               :: XRIGIDHESS(DEGFREEDOMS, DEGFREEDOMS) 64:    REAL(REAL64)               :: XRIGIDHESS(DEGFREEDOMS, DEGFREEDOMS)
 66:    LOGICAL                    :: FTEST, EVAP, COMPON, YESNO, GUIDET, EVAPREJECT 65:    LOGICAL                    :: FTEST, EVAP, COMPON, YESNO, GUIDET, EVAPREJECT
 67:    INTEGER(INT32)             :: J1, J2, J3, CSMIT 66:    INTEGER(INT32)             :: J1, J2, J3, CSMIT
 68:    CHARACTER                  :: FNAME*80, DUMM*4 67:    CHARACTER                  :: FNAME*80, DUMM*4
 69:    REAL(REAL64)               :: DUMMY2, GEMAX, RMAT(3, 3), XTEMP(3*NATOMS), AVVAL, & 68:    REAL(REAL64)               :: DUMMY2, GEMAX, RMAT(3, 3), XTEMP(3*NATOMS), AVVAL, &
 70:                                  DUMMY(3*NATOMS), DIST2, QE, QX, AA(3), SAVECSMNORM, & 69:                                  DUMMY(3*NATOMS), DIST2, QE, QX, AA(3), SAVECSMNORM, &
 71:                                  CSMRMS, CSMGRAD(3), SAVECSMPMAT(3, 3), & 70:                                  CSMRMS, CSMGRAD(3), SAVECSMPMAT(3, 3), &
 72:                                  SAVECSMIMAGES(3*NATOMS*CSMGPINDEX) 71:                                  SAVECSMIMAGES(3*NATOMS*CSMGPINDEX)
 73:    CHARACTER(LEN=3)           :: CSMGPSAVE 72:    CHARACTER(LEN=3)           :: CSMGPSAVE
 74:    INTEGER(INT32)             :: CSMGPINDEXSAVE 73:    INTEGER(INT32)             :: CSMGPINDEXSAVE  
 75:    REAL(REAL64)               :: PTGPSAVE(3, 3, 2*CSMGPINDEX), CSMNORMSAVE, ENERGY, VNEW(3*NATOMS) 74:    REAL(REAL64)               :: PTGPSAVE(3, 3, 2*CSMGPINDEX), CSMNORMSAVE, ENERGY, VNEW(3*NATOMS)
 76:    INTEGER(INT32)             :: BRUN 75:    INTEGER(INT32)             :: BRUN
 77:    INTEGER(INT32)             :: NQTOT 76:    INTEGER(INT32)             :: NQTOT
 78:    LOGICAL                    :: SOCOUPLE, GUIDECHANGET, CSMDOGUIDET, COMTEST 77:    LOGICAL                    :: SOCOUPLE, GUIDECHANGET, CSMDOGUIDET, COMTEST
 79: ! khs26 > AMBER12 energy decomposition, type defined in AMBER12 interface 78: ! khs26 > AMBER12 energy decomposition, type defined in AMBER12 interface
 80:    TYPE(POT_ENE_REC_C)        :: AMBER12_ENERGY_DECOMP 79:    TYPE(POT_ENE_REC_C)        :: AMBER12_ENERGY_DECOMP
 81: ! Used only in commented sections 80: ! Used only in commented sections
 82: !   REAL(REAL64)               :: XG, YG, ZG, GRADLJ(3*NATOMS), EREALLJ, GRADMF(3*NATOMS), EREALMF, TERMLJ, TERMMF & 81: !   REAL(REAL64)               :: XG, YG, ZG, GRADLJ(3*NATOMS), EREALLJ, GRADMF(3*NATOMS), EREALMF, TERMLJ, TERMMF &
 83: !                                 GRADDUM(3*NATOMS), GRADDUM1(3*NATOMS), GRADDUM2(3*NATOMS), EPLUS, EMINUS, DIFF 82: !                                 GRADDUM(3*NATOMS), GRADDUM1(3*NATOMS), GRADDUM2(3*NATOMS), EPLUS, EMINUS, DIFF
 84: !                                 EDUM1, EDUM2 83: !                                 EDUM1, EDUM2
 85: !DS656> GRADIENT/HESSIAN TESTING 84: !DS656> GRADIENT/HESSIAN TESTING
 86:    DOUBLE PRECISION :: GPLUS(3*NATOMS), GMINUS(3*NATOMS), DIFF, & 85:    DOUBLE PRECISION :: GPLUS(3*NATOMS), GMINUS(3*NATOMS), DIFF, &
 87:         EPLUS, EMINUS 86:         EPLUS, EMINUS
 88:  87:    
 89: ! TODO: Delete common blocks 88: ! TODO: Delete common blocks
 90:    COMMON /CO/ COMPON 89:    COMMON /CO/ COMPON
 91:    COMMON /FAIL/ FTEST 90:    COMMON /FAIL/ FTEST
 92:    COMMON /EV/ EVAP, EVAPREJECT 91:    COMMON /EV/ EVAP, EVAPREJECT
 93:    COMMON /GD/ GUIDECHANGET, GUIDET, CSMDOGUIDET 92:    COMMON /GD/ GUIDECHANGET, GUIDET, CSMDOGUIDET
 94:    COMMON /CSMAVVAL/ AVVAL, CSMRMS, CSMIT 93:    COMMON /CSMAVVAL/ AVVAL, CSMRMS, CSMIT
 95:    COMMON /TOT/ NQTOT 94:    COMMON /TOT/ NQTOT
 96:  95: 
 97:    GUIDECHANGET=.FALSE. 96:    GUIDECHANGET=.FALSE.
 98: ! 97: !
116: !      WRITE(88,'(3G20.10)') ((QMINP(J2, J1), J1=1, 3*NATOMS), J2=1, NSAVE)115: !      WRITE(88,'(3G20.10)') ((QMINP(J2, J1), J1=1, 3*NATOMS), J2=1, NSAVE)
117: !      WRITE(88,'(G20.10)') (TEMP(J1), J1=1, NPAR)116: !      WRITE(88,'(G20.10)') (TEMP(J1), J1=1, NPAR)
118: !      WRITE(88,'(G20.10)') (ACCRAT(J1), J1=1, NPAR)117: !      WRITE(88,'(G20.10)') (ACCRAT(J1), J1=1, NPAR)
119: !      WRITE(88,'(G20.10)') (STEP(J1), J1=1, NPAR)118: !      WRITE(88,'(G20.10)') (STEP(J1), J1=1, NPAR)
120: !      WRITE(88,'(G20.10)') (ASTEP(J1), J1=1, NPAR)119: !      WRITE(88,'(G20.10)') (ASTEP(J1), J1=1, NPAR)
121: !      WRITE(88,'(G20.10)') (OSTEP(J1), J1=1, NPAR)120: !      WRITE(88,'(G20.10)') (OSTEP(J1), J1=1, NPAR)
122: !      CALL SYSTEM('rm ssave')121: !      CALL SYSTEM('rm ssave')
123: !      STOP122: !      STOP
124: !   END IF123: !   END IF
125: 124: 
126: ! ds656> For PTMC runs with MIEF and BOXCENTROID, safer to125: ! ds656> For PTMC runs with MIEF and BOXCENTROID, safer to 
127: !        call BOXCENTROID on every potential call...126: !        call BOXCENTROID on every potential call... 
128:    IF(BOXCENTROIDT .AND. PTMC) CALL BOXCENTROID(X)127:    IF(BOXCENTROIDT .AND. PTMC) CALL BOXCENTROID(X)
129: !128: !
130: ! Count the number of potential calls.129: ! Count the number of potential calls.
131:    NPCALL=NPCALL+1130:    NPCALL=NPCALL+1
132: 10 CONTINUE131: 10 CONTINUE
133: 132: 
134:    IF (MULTIPOTT) THEN133:    IF (MULTIPOTT) THEN
135:        IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN134:        IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN
136:            XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)135:            XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
137:            CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, X, XRIGIDCOORDS)136:            CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, X, XRIGIDCOORDS)               
138:        END IF137:        END IF
139: 138: 
140: !       CALL RAD(X, GRAD, EREAL, GRADT)139: !       CALL RAD(X, GRAD, EREAL, GRADT)
141:        CALL MULTIPOT_CALL(X, GRAD, EREAL, GRADT, SECT)140:        CALL MULTIPOT_CALL(X, GRAD, EREAL, GRADT, SECT)
142: 141: 
143:        IF ( RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN142:        IF ( RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN
144: 143: 
145:            X(DEGFREEDOMS+1:3*NATOMS)=0.0D0144:            X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
146:            X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)145:            X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)
147: 146: 
297: !      WRITE(*, *) 'EREALLJ, EREALMF=', EREALLJ, EREALMF296: !      WRITE(*, *) 'EREALLJ, EREALMF=', EREALLJ, EREALMF
298: !      EREAL=EREALLJ+EREALMF297: !      EREAL=EREALLJ+EREALMF
299: !      TERMLJ=EREALLJ298: !      TERMLJ=EREALLJ
300: !      TERMMF=EREALMF299: !      TERMMF=EREALMF
301: !      DO J1=1, 3*NATOMS300: !      DO J1=1, 3*NATOMS
302: !         WRITE(*, *) 'J1, GRADLJ, GRADMF=', J1, GRADLJ(J1), GRADMF(J1)301: !         WRITE(*, *) 'J1, GRADLJ, GRADMF=', J1, GRADLJ(J1), GRADMF(J1)
303: !         GRAD(J1)=GRADLJ(J1)+GRADMF(J1)302: !         GRAD(J1)=GRADLJ(J1)+GRADMF(J1)
304: !      END DO303: !      END DO
305: !      DIFF=1.0D-6304: !      DIFF=1.0D-6
306: !      WRITE(*, *) 'analytic and numerical gradients:'305: !      WRITE(*, *) 'analytic and numerical gradients:'
307: !306: ! 
308: !      DO J1=1, 3*NATOMS307: !      DO J1=1, 3*NATOMS
309: !         X(J1)=X(J1)+DIFF308: !         X(J1)=X(J1)+DIFF
310: !         CALL LJ(X, GRADDUM1, EDUM1,.FALSE.,.FALSE.)309: !         CALL LJ(X, GRADDUM1, EDUM1,.FALSE.,.FALSE.)
311: !         CALL MF(X, GRADDUM2, EDUM2,.FALSE.)310: !         CALL MF(X, GRADDUM2, EDUM2,.FALSE.)
312: !         EPLUS=EDUM1+EDUM2311: !         EPLUS=EDUM1+EDUM2
313: !312: ! 
314: !         X(J1)=X(J1)-2.0D0*DIFF313: !         X(J1)=X(J1)-2.0D0*DIFF
315: !314: ! 
316: !         CALL LJ(X, GRADDUM1, EDUM1,.FALSE.,.FALSE.)315: !         CALL LJ(X, GRADDUM1, EDUM1,.FALSE.,.FALSE.)
317: !         CALL MF(X, GRADDUM2, EDUM2,.FALSE.)316: !         CALL MF(X, GRADDUM2, EDUM2,.FALSE.)
318: !317: ! 
319: !         EMINUS=EDUM1+EDUM2318: !         EMINUS=EDUM1+EDUM2
320: !319: ! 
321: !         X(J1)=X(J1)+DIFF320: !         X(J1)=X(J1)+DIFF
322: !         GRAD(J1)=(EPLUS-EMINUS)/(2.0D0*DIFF)321: !         GRAD(J1)=(EPLUS-EMINUS)/(2.0D0*DIFF)
323: !         WRITE(*,'(I5, 4F20.10)') J1, GRAD(J1), EPLUS, EMINUS, ABS(EPLUS-EMINUS)322: !         WRITE(*,'(I5, 4F20.10)') J1, GRAD(J1), EPLUS, EMINUS, ABS(EPLUS-EMINUS)
324: !     END DO323: !     END DO
325: !324: !
326: 325: 
327:    ELSE IF (MORSET) THEN326:    ELSE IF (MORSET) THEN
328: !      CALL RAD(X, GRAD, EREAL, GRADT)327: !      CALL RAD(X, GRAD, EREAL, GRADT)
329: !      CALL MORSE(X, GRAD, EREAL, GRADT)328: !      CALL MORSE(X, GRAD, EREAL, GRADT)
330:       CALL MORSEGH(X, GRAD, EREAL, GRADT, SECT)329:       CALL MORSEGH(X, GRAD, EREAL, GRADT, SECT)
467:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)466:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
468:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)467:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)
469: ! Now call the AMBER 12 energy and gradient468: ! Now call the AMBER 12 energy and gradient
470:          IF (CUDAT) THEN469:          IF (CUDAT) THEN
471:             CALL CUDA_ENEGRAD_WRAPPER(NATOMS, XCOORDS, EREAL, GRADATOMS)470:             CALL CUDA_ENEGRAD_WRAPPER(NATOMS, XCOORDS, EREAL, GRADATOMS)
472:             GRAD(1:3*NATOMS)=GRADATOMS(:)471:             GRAD(1:3*NATOMS)=GRADATOMS(:)
473:          ELSE472:          ELSE
474:             CALL AMBER12_ENERGY_AND_GRADIENT(NATOMS, XCOORDS, EREAL, GRADATOMS, AMBER12_ENERGY_DECOMP)473:             CALL AMBER12_ENERGY_AND_GRADIENT(NATOMS, XCOORDS, EREAL, GRADATOMS, AMBER12_ENERGY_DECOMP)
475:             GRAD(1:3*NATOMS)=GRADATOMS(:)474:             GRAD(1:3*NATOMS)=GRADATOMS(:)
476:          END IF475:          END IF
477: ! Transform the gradient and coordinates back to the rigid body representation476: ! Transform the gradient and coordinates back to the rigid body representation 
478:          CALL TRANSFORMGRAD(GRADATOMS, XRIGIDCOORDS, XRIGIDGRAD)477:          CALL TRANSFORMGRAD(GRADATOMS, XRIGIDCOORDS, XRIGIDGRAD)
479:          X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)478:          X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)
480:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0479:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
481:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)480:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
482:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0481:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0
483:       END IF482:       END IF
484: !copied from OPTIM, rbody part not tested483: !copied from OPTIM, rbody part not tested
485:       IF (SECT) THEN484:       IF (SECT) THEN
486:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)485:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)
487:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))486:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))
489:          IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT) ) THEN488:          IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT) ) THEN
490:             CALL TRANSFORMHESSIAN(HESS, GRADATOMS, XRIGIDCOORDS,XRIGIDHESS, RBAANORMALMODET)489:             CALL TRANSFORMHESSIAN(HESS, GRADATOMS, XRIGIDCOORDS,XRIGIDHESS, RBAANORMALMODET)
491:             HESS(DEGFREEDOMS+1:3*NATOMS,:) = 0.0D0490:             HESS(DEGFREEDOMS+1:3*NATOMS,:) = 0.0D0
492:             HESS(:,DEGFREEDOMS+1:3*NATOMS) = 0.0D0491:             HESS(:,DEGFREEDOMS+1:3*NATOMS) = 0.0D0
493:             HESS(1:DEGFREEDOMS,1:DEGFREEDOMS) = XRIGIDHESS(1:DEGFREEDOMS,1:DEGFREEDOMS)492:             HESS(1:DEGFREEDOMS,1:DEGFREEDOMS) = XRIGIDHESS(1:DEGFREEDOMS,1:DEGFREEDOMS)
494:          END IF493:          END IF
495:       END IF494:       END IF
496: ! AMBER 9 Energy and gradient calls495: ! AMBER 9 Energy and gradient calls
497:    ELSE IF (AMBERT) THEN496:    ELSE IF (AMBERT) THEN
498: ! hk286 > Generalised rigid body497: ! hk286 > Generalised rigid body
499: ! hk286 > If rigid coords is used, then need to convert to atom coords first,498: ! hk286 > If rigid coords is used, then need to convert to atom coords first, 
500: ! hk286 > compute energies, then convert gradients & coords back to rigid499: ! hk286 > compute energies, then convert gradients & coords back to rigid
501:       IF (ATOMRIGIDCOORDT) THEN500:       IF (ATOMRIGIDCOORDT) THEN
502:          CALL AMBERENERGIES(X, GRAD, EREAL, .FALSE., .FALSE.)501:          CALL AMBERENERGIES(X, GRAD, EREAL, .FALSE., .FALSE.)
503:          IF (RESTRAINLT) THEN502:          IF (RESTRAINLT) THEN
504:             CALL RESTRAINLPOTENTIAL(X, GRAD, EREAL, GRADT, SECT) ! hk286503:             CALL RESTRAINLPOTENTIAL(X, GRAD, EREAL, GRADT, SECT) ! hk286
505:          END IF504:          END IF
506:       ELSE505:       ELSE
507:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)506:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
508:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)507:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)
509:          CALL AMBERENERGIES(XCOORDS, GRADATOMS, EREAL, .FALSE., .FALSE.)508:          CALL AMBERENERGIES(XCOORDS, GRADATOMS, EREAL, .FALSE., .FALSE.)
515:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0514:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
516:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)515:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
517:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0516:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0
518: ! csw34> apply compression if using COMPRESSRIGID and at least one COM-COM distance517: ! csw34> apply compression if using COMPRESSRIGID and at least one COM-COM distance
519: !        is greater than RIGIDCOMDIST518: !        is greater than RIGIDCOMDIST
520:          IF (COMPRESSRIGIDT) THEN519:          IF (COMPRESSRIGIDT) THEN
521:             COMTEST=.TRUE.520:             COMTEST=.TRUE.
522:             CALL GENRIGID_DISTANCECHECK(XRIGIDCOORDS, RIGIDCOMDIST, COMTEST)521:             CALL GENRIGID_DISTANCECHECK(XRIGIDCOORDS, RIGIDCOMDIST, COMTEST)
523: ! If the threshold distance is exceeded, apply the compression522: ! If the threshold distance is exceeded, apply the compression
524:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL before compression=', EREAL523:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL before compression=', EREAL
525:             IF (.NOT.COMTEST) CALL GENRIGID_COMPRESS(XRIGIDCOORDS, GRAD, EREAL, KCOMP_RIGID)524:             IF (.NOT.COMTEST) CALL GENRIGID_COMPRESS(XRIGIDCOORDS, GRAD, EREAL, KCOMP_RIGID) 
526:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL after compression=', EREAL525:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL after compression=', EREAL
527: ! Equate GRAD and XRIGIDGRAD to allow new RMS convergence condition to work526: ! Equate GRAD and XRIGIDGRAD to allow new RMS convergence condition to work
528:             XRIGIDGRAD(1:DEGFREEDOMS)=GRAD(1:DEGFREEDOMS)527:             XRIGIDGRAD(1:DEGFREEDOMS)=GRAD(1:DEGFREEDOMS) 
529:          END IF528:          END IF  
530:       END IF529:       END IF
531: 530: 
532:       IF (SECT) THEN531:       IF (SECT) THEN
533:          VNEW=0.0D0532:          VNEW=0.0D0
534: ! khs26> Copied analytical second derivatives from OPTIM533: ! khs26> Copied analytical second derivatives from OPTIM
535:          IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN534:          IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN
536:             XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)535:             XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
537:             CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, X, XRIGIDCOORDS)536:             CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, X, XRIGIDCOORDS)               
538:          END IF537:          END IF
539:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)538:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)
540:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))539:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))
541:          IF (CUDAT) THEN540:          IF (CUDAT) THEN
542:             CALL CUDA_NUMERICAL_HESS(NATOMS, X, HESS, DELTA=1.0D-6)541:             CALL CUDA_NUMERICAL_HESS(NATOMS, X, HESS, DELTA=1.0D-6)
543:          ELSE542:          ELSE 
544:             IF (.NOT. ALLOCATED(TEMPHESS)) ALLOCATE(TEMPHESS(9*NATOMS*NATOMS))543:             IF (.NOT. ALLOCATED(TEMPHESS)) ALLOCATE(TEMPHESS(9*NATOMS*NATOMS))
545:             TEMPHESS(:)=0.0D0544:             TEMPHESS(:)=0.0D0
546:             CALL MME2WRAPPER(X, ENERGY, VNEW, TEMPHESS, ATMASS1, GRAD1)545:             CALL MME2WRAPPER(X, ENERGY, VNEW, TEMPHESS, ATMASS1, GRAD1)
547:             IF (SQRT(ABS(ENERGY)) > 1.0D40) THEN546:             IF (SQRT(ABS(ENERGY)) > 1.0D40) THEN
548:                EREAL = ENERGY547:                EREAL = ENERGY
549:                WRITE(MYUNIT, *) "Linear dihedral detected in NAB routines (sff2.c)."548:                WRITE(MYUNIT, *) "Linear dihedral detected in NAB routines (sff2.c)."
550:             END IF549:             END IF
551:             K=1550:             K=1
552:             DO I=1, 3*NATOMS551:             DO I=1, 3*NATOMS
553:                DO J=1, 3*NATOMS552:                DO J=1, 3*NATOMS
562:             CALL TRANSFORMGRAD(VNEW, XRIGIDCOORDS, XRIGIDGRAD)561:             CALL TRANSFORMGRAD(VNEW, XRIGIDCOORDS, XRIGIDGRAD)
563:             X(DEGFREEDOMS+1:3*NATOMS)=0.0D0562:             X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
564:             X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)563:             X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)
565:             VNEW(DEGFREEDOMS+1:3*NATOMS)=0.0D0564:             VNEW(DEGFREEDOMS+1:3*NATOMS)=0.0D0
566:             VNEW(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)565:             VNEW(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
567:             HESS(DEGFREEDOMS+1:3*NATOMS,:)=0.0D0566:             HESS(DEGFREEDOMS+1:3*NATOMS,:)=0.0D0
568:             HESS(:, DEGFREEDOMS+1:3*NATOMS)=0.0D0567:             HESS(:, DEGFREEDOMS+1:3*NATOMS)=0.0D0
569:             HESS(1:DEGFREEDOMS, 1:DEGFREEDOMS)=XRIGIDHESS(1:DEGFREEDOMS, 1:DEGFREEDOMS)568:             HESS(1:DEGFREEDOMS, 1:DEGFREEDOMS)=XRIGIDHESS(1:DEGFREEDOMS, 1:DEGFREEDOMS)
570:          END IF569:          END IF
571:       END IF570:       END IF
572: ! End of second derivative calculation571: ! End of second derivative calculation 
573: 572: 
574: ! End of AMBERT section573: ! End of AMBERT section
575: 574: 
576: !kr366> OPEP potential575: !kr366> OPEP potential
577:    ELSE IF (OPEPT) THEN576:    ELSE IF (OPEPT) THEN
578:       ! If coordinates are atomistic (i.e. no rigid bodies) just call the energy577:       ! If coordinates are atomistic (i.e. no rigid bodies) just call the energy
579:       ! and gradient578:       ! and gradient
580:       IF (ATOMRIGIDCOORDT) THEN579:       IF (ATOMRIGIDCOORDT) THEN
581:          CALL OPEP_ENERGY_AND_GRADIENT(NATOMS, X, GRADATOMS, EREAL,GRADT)580:          CALL OPEP_ENERGY_AND_GRADIENT(NATOMS, X, GRADATOMS, EREAL,GRADT)
582:          GRAD(1:3*NATOMS)=GRADATOMS(:)581:          GRAD(1:3*NATOMS)=GRADATOMS(:)
583:       ! If the coordinates include rigid bodies, transform them back to being582:       ! If the coordinates include rigid bodies, transform them back to being
584:       ! atomistic first583:       ! atomistic first
585:       ELSE584:       ELSE
586:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)585:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
587:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)586:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)
588:          CALL OPEP_ENERGY_AND_GRADIENT(NATOMS, X, GRADATOMS, EREAL,GRADT)587:          CALL OPEP_ENERGY_AND_GRADIENT(NATOMS, X, GRADATOMS, EREAL,GRADT)
589:          GRAD(1:3*NATOMS)=GRADATOMS(:)588:          GRAD(1:3*NATOMS)=GRADATOMS(:)
590:          !Transform the gradient and coordinates back to the rigid body representation589:          !Transform the gradient and coordinates back to the rigid body representation 
591:          CALL TRANSFORMGRAD(GRADATOMS, XRIGIDCOORDS, XRIGIDGRAD)590:          CALL TRANSFORMGRAD(GRADATOMS, XRIGIDCOORDS, XRIGIDGRAD)
592:          X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)591:          X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)
593:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0592:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
594:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)593:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
595:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0594:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0
596:       END IF595:       END IF
597:       !copied from OPTIM, rbody part not tested596:       !copied from OPTIM, rbody part not tested
598:       IF (SECT) THEN597:       IF (SECT) THEN
599:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)598:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)
600:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))599:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))
603:             CALL TRANSFORMHESSIAN(HESS, GRADATOMS, XRIGIDCOORDS,XRIGIDHESS,RBAANORMALMODET)602:             CALL TRANSFORMHESSIAN(HESS, GRADATOMS, XRIGIDCOORDS,XRIGIDHESS,RBAANORMALMODET)
604:             HESS(DEGFREEDOMS+1:3*NATOMS,:) = 0.0D0603:             HESS(DEGFREEDOMS+1:3*NATOMS,:) = 0.0D0
605:             HESS(:,DEGFREEDOMS+1:3*NATOMS) = 0.0D0604:             HESS(:,DEGFREEDOMS+1:3*NATOMS) = 0.0D0
606:             HESS(1:DEGFREEDOMS,1:DEGFREEDOMS) =XRIGIDHESS(1:DEGFREEDOMS,1:DEGFREEDOMS)605:             HESS(1:DEGFREEDOMS,1:DEGFREEDOMS) =XRIGIDHESS(1:DEGFREEDOMS,1:DEGFREEDOMS)
607:          END IF606:          END IF
608:       END IF607:       END IF
609: 608: 
610: ! hk286609: ! hk286
611:    ELSE IF (CHRMMT) THEN610:    ELSE IF (CHRMMT) THEN
612: ! hk286 > Generalised rigid body611: ! hk286 > Generalised rigid body
613: ! hk286 > If rigid coords is used, then need to convert to atom coords first,612: ! hk286 > If rigid coords is used, then need to convert to atom coords first, 
614: ! hk286 > compute energies, then convert gradients & coords back to rigid613: ! hk286 > compute energies, then convert gradients & coords back to rigid
615:       IF (ATOMRIGIDCOORDT) THEN614:       IF (ATOMRIGIDCOORDT) THEN
616:          CALL OCHARMM(X, GRAD, EREAL, GRADT)615:          CALL OCHARMM(X, GRAD, EREAL, GRADT)
617:       ELSE616:       ELSE
618:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)617:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
619:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)618:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)
620:          CALL OCHARMM(XCOORDS, GRADATOMS, EREAL, GRADT)619:          CALL OCHARMM(XCOORDS, GRADATOMS, EREAL, GRADT)
621:          CALL TRANSFORMGRAD(GRADATOMS, XRIGIDCOORDS, XRIGIDGRAD)620:          CALL TRANSFORMGRAD(GRADATOMS, XRIGIDCOORDS, XRIGIDGRAD)
622:          X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)621:          X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)
623:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0622:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
624:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)623:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
625:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0624:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0
626: ! csw34> apply compression if using COMPRESSRIGID and at least one COM-COM distance625: ! csw34> apply compression if using COMPRESSRIGID and at least one COM-COM distance
627: !        is greater than RIGIDCOMDIST626: !        is greater than RIGIDCOMDIST
628:          IF (COMPRESSRIGIDT) THEN627:          IF (COMPRESSRIGIDT) THEN
629:             COMTEST=.TRUE.628:             COMTEST=.TRUE.
630:             CALL GENRIGID_DISTANCECHECK(XRIGIDCOORDS, RIGIDCOMDIST, COMTEST)629:             CALL GENRIGID_DISTANCECHECK(XRIGIDCOORDS, RIGIDCOMDIST, COMTEST)
631: ! If the threshold distance is exceeded, apply the compression630: ! If the threshold distance is exceeded, apply the compression
632:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL before compression=', EREAL631:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL before compression=', EREAL
633:             IF (.NOT.COMTEST) CALL GENRIGID_COMPRESS(XRIGIDCOORDS, GRAD, EREAL, KCOMP_RIGID)632:             IF (.NOT.COMTEST) CALL GENRIGID_COMPRESS(XRIGIDCOORDS, GRAD, EREAL, KCOMP_RIGID) 
634:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL after compression=', EREAL633:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL after compression=', EREAL
635: ! Equate GRAD and XRIGIDGRAD to allow new RMS convergence condition to work634: ! Equate GRAD and XRIGIDGRAD to allow new RMS convergence condition to work
636:             XRIGIDGRAD(1:DEGFREEDOMS)=GRAD(1:DEGFREEDOMS)635:             XRIGIDGRAD(1:DEGFREEDOMS)=GRAD(1:DEGFREEDOMS) 
637:          END IF636:          END IF  
638:       END IF637:       END IF
639: 638: 
640: ! hk286639: ! hk286
641:    ELSE IF (DMACRYST) THEN640:    ELSE IF (DMACRYST) THEN
642:       IF (.NOT. ATOMRIGIDCOORDT) THEN641:       IF (.NOT. ATOMRIGIDCOORDT) THEN
643:          CALL DMACRYS_POTENTIAL(X, GRAD, EREAL, GRADT)642:          CALL DMACRYS_POTENTIAL(X, GRAD, EREAL, GRADT)
644:       ELSE643:       ELSE
645:          CALL TRANSFORMCTORIGID(X, XRIGIDCOORDS)644:          CALL TRANSFORMCTORIGID(X, XRIGIDCOORDS)
646:          CALL DMACRYS_POTENTIAL(XRIGIDCOORDS, GRAD, EREAL, GRADT)645:          CALL DMACRYS_POTENTIAL(XRIGIDCOORDS, GRAD, EREAL, GRADT)
647:       END IF646:       END IF
648: 647: 
649:    ELSE IF (DZTEST) THEN648:    ELSE IF (DZTEST) THEN
650:       CALL RAD(X, GRAD, EREAL, GRADT)649:       CALL RAD(X, GRAD, EREAL, GRADT)
651:       CALL DZPOT(X, GRAD, EREAL, GRADT, SECT)650:       CALL DZPOT(X, GRAD, EREAL, GRADT, SECT)
652: ! vr274: userpot, linkage dependant potential651: ! vr274: userpot, linkage dependant potential
653: 652: 
654:    ELSE IF (USERPOTT) THEN653:    ELSE IF (USERPOTT) THEN
655: ! hk286 > Generalised rigid body654: ! hk286 > Generalised rigid body
656: ! hk286 > If rigid coords is used, then need to convert to atom coords first,655: ! hk286 > If rigid coords is used, then need to convert to atom coords first, 
657: ! hk286 > compute energies, then convert gradients & coords back to rigid656: ! hk286 > compute energies, then convert gradients & coords back to rigid
658:       IF (ATOMRIGIDCOORDT) THEN657:       IF (ATOMRIGIDCOORDT) THEN
659:          CALL USERPOT_POTENTIAL(3*NATOMS, X, GRAD, EREAL, GRADT)658:          CALL USERPOT_POTENTIAL(3*NATOMS, X, GRAD, EREAL, GRADT)
660:          IF (RESTRAINLT) THEN659:          IF (RESTRAINLT) THEN
661:             CALL RESTRAINLPOTENTIAL(X, GRAD, EREAL, GRADT, SECT) ! hk286660:             CALL RESTRAINLPOTENTIAL(X, GRAD, EREAL, GRADT, SECT) ! hk286
662:          END IF661:          END IF
663:       ELSE662:       ELSE
664:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)663:          XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
665:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)664:          CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, XCOORDS, XRIGIDCOORDS)
666:          CALL USERPOT_POTENTIAL(3*NATOMS, XCOORDS, GRADATOMS, EREAL, GRADT)665:          CALL USERPOT_POTENTIAL(3*NATOMS, XCOORDS, GRADATOMS, EREAL, GRADT)
672:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0671:          X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
673:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)672:          GRAD(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
674:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0673:          GRAD(DEGFREEDOMS+1:3*NATOMS)=0.0D0
675: ! csw34> apply compression if using COMPRESSRIGID and at least one COM-COM distance674: ! csw34> apply compression if using COMPRESSRIGID and at least one COM-COM distance
676: !        is greater than RIGIDCOMDIST675: !        is greater than RIGIDCOMDIST
677:          IF (COMPRESSRIGIDT) THEN676:          IF (COMPRESSRIGIDT) THEN
678:             COMTEST=.TRUE.677:             COMTEST=.TRUE.
679:             CALL GENRIGID_DISTANCECHECK(XRIGIDCOORDS, RIGIDCOMDIST, COMTEST)678:             CALL GENRIGID_DISTANCECHECK(XRIGIDCOORDS, RIGIDCOMDIST, COMTEST)
680: ! If the threshold distance is exceeded, apply the compression679: ! If the threshold distance is exceeded, apply the compression
681:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL before compression=', EREAL680:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL before compression=', EREAL
682:             IF (.NOT.COMTEST) CALL GENRIGID_COMPRESS(XRIGIDCOORDS, GRAD, EREAL, KCOMP_RIGID)681:             IF (.NOT.COMTEST) CALL GENRIGID_COMPRESS(XRIGIDCOORDS, GRAD, EREAL, KCOMP_RIGID) 
683:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL after compression=', EREAL682:             IF (DEBUG) WRITE(MYUNIT,'(A, F20.10)' ) 'EREAL after compression=', EREAL
684: ! Equate GRAD and XRIGIDGRAD to allow new RMS convergence condition to work683: ! Equate GRAD and XRIGIDGRAD to allow new RMS convergence condition to work
685:             XRIGIDGRAD(1:DEGFREEDOMS)=GRAD(1:DEGFREEDOMS)684:             XRIGIDGRAD(1:DEGFREEDOMS)=GRAD(1:DEGFREEDOMS) 
686:          END IF685:          END IF  
687:       END IF686:       END IF
688: 687: 
689:       IF (SECT) THEN688:       IF (SECT) THEN
690:          VNEW=0.0D0689:          VNEW=0.0D0
691: ! khs26> Copied analytical second derivatives from OPTIM690: ! khs26> Copied analytical second derivatives from OPTIM
692:          IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN691:          IF (RIGIDINIT .AND. (.NOT. ATOMRIGIDCOORDT)) THEN
693:             XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)692:             XRIGIDCOORDS(1:DEGFREEDOMS)=X(1:DEGFREEDOMS)
694:             CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, X, XRIGIDCOORDS)693:             CALL TRANSFORMRIGIDTOC(1, NRIGIDBODY, X, XRIGIDCOORDS)               
695:          END IF694:          END IF
696:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)695:          IF (ALLOCATED(HESS)) DEALLOCATE(HESS)
697:          IF (.NOT. ALLOCATED(TEMPHESS)) ALLOCATE(TEMPHESS(9*NATOMS*NATOMS))696:          IF (.NOT. ALLOCATED(TEMPHESS)) ALLOCATE(TEMPHESS(9*NATOMS*NATOMS))
698:          TEMPHESS(:)=0.0D0697:          TEMPHESS(:)=0.0D0
699:          CALL MME2WRAPPER(X, ENERGY, VNEW, TEMPHESS, ATMASS1, GRAD1)698:          CALL MME2WRAPPER(X, ENERGY, VNEW, TEMPHESS, ATMASS1, GRAD1)
700:          IF (SQRT(ABS(ENERGY)) > 1.0D40) THEN699:          IF (SQRT(ABS(ENERGY)) > 1.0D40) THEN
701:             EREAL = ENERGY700:             EREAL = ENERGY
702:             WRITE(MYUNIT, *) "Linear dihedral detected in NAB routines (sff2.c)."701:             WRITE(MYUNIT, *) "Linear dihedral detected in NAB routines (sff2.c)."
703:          END IF702:          END IF
704:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))703:          ALLOCATE(HESS(3*NATOMS, 3*NATOMS))
716:             X(DEGFREEDOMS+1:3*NATOMS)=0.0D0715:             X(DEGFREEDOMS+1:3*NATOMS)=0.0D0
717:             X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)716:             X(1:DEGFREEDOMS)=XRIGIDCOORDS(1:DEGFREEDOMS)
718:             VNEW(DEGFREEDOMS+1:3*NATOMS)=0.0D0717:             VNEW(DEGFREEDOMS+1:3*NATOMS)=0.0D0
719:             VNEW(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)718:             VNEW(1:DEGFREEDOMS)=XRIGIDGRAD(1:DEGFREEDOMS)
720:             HESS(DEGFREEDOMS+1:3*NATOMS,:)=0.0D0719: