hdiff output

r31908/commons.f90 2017-02-14 09:30:35.095068412 +0000 r31907/commons.f90 2017-02-14 09:30:37.651102273 +0000
 91:       LOGICAL YESNO, TEST1, TEST2, DEBUG, PRINTT, ADDPT, ADDPT2, ADDPT3, TWOD, BULKT, ANGLEAXIS, TAGT, & 91:       LOGICAL YESNO, TEST1, TEST2, DEBUG, PRINTT, ADDPT, ADDPT2, ADDPT3, TWOD, BULKT, ANGLEAXIS, TAGT, &
 92:      &        CHARMMT, AMBERT, OPEPT, STARTFROMPATH, RELATIVEET, EXTRACTTSFILET, & 92:      &        CHARMMT, AMBERT, OPEPT, STARTFROMPATH, RELATIVEET, EXTRACTTSFILET, &
 93:      &        KMCT, UNRST, KMCCOMMITT, REGROUPT, REGROUPRATET, REGROUPPET, NOPOINTS, ADDPATH, NGTT, GTT, GT2T, & 93:      &        KMCT, UNRST, KMCCOMMITT, REGROUPT, REGROUPRATET, REGROUPPET, NOPOINTS, ADDPATH, NGTT, GTT, GT2T, &
 94:      &        DIJKSTRAT, DIJPAIRT, DIJINITT, EXTRACTMINT, EXTRACTMINFILET, EXTRACTTST, DIJKSTRAWAITT, UNTRAPMETRICT, & 94:      &        DIJKSTRAT, DIJPAIRT, DIJINITT, EXTRACTMINT, EXTRACTMINFILET, EXTRACTTST, DIJKSTRAWAITT, UNTRAPMETRICT, &
 95:      &        EXPCOSTFUNCTION, COPYOPTIMT, CALCORDERT, CONNECTREGIONT, SHORTCUTT, MERGEDBT, UNTRAPT, AMHT,  AMHALLATOMMINT, & 95:      &        EXPCOSTFUNCTION, COPYOPTIMT, CALCORDERT, CONNECTREGIONT, SHORTCUTT, MERGEDBT, UNTRAPT, AMHT,  AMHALLATOMMINT, &
 96:      &        CHECKCONNECTIONST, AMHALLATOMTST, AMHQT,AMHQENGMINT, AMHQCONTT ,AMHRMSDT, AMHRELQT, AMH_RELCOT, DIAGT, ARNOLDIT, & 96:      &        CHECKCONNECTIONST, AMHALLATOMTST, AMHQT,AMHQENGMINT, AMHQCONTT ,AMHRMSDT, AMHRELQT, AMH_RELCOT, DIAGT, ARNOLDIT, &
 97:      &        GT2Sparse, GT2Switch, GT2AltPbb, GT2Rescale, GT2Normalise, GT2DisconnectSources, BARRIERSORT, & 97:      &        GT2Sparse, GT2Switch, GT2AltPbb, GT2Rescale, GT2Normalise, GT2DisconnectSources, BARRIERSORT, &
 98:      &        PERMDIST, PERMISOMER, RIGIDBODY, DIJINITSTARTT, DIJINITCONTT, RETAINSP, REMOVESP, NOFRQS, & 98:      &        PERMDIST, PERMISOMER, RIGIDBODY, DIJINITSTARTT, DIJINITCONTT, RETAINSP, REMOVESP, NOFRQS, &
 99:      &        BARRIERSHORT, FREEZE, RATESHORT, DUMMYRUNT, REWEIGHTT, REGROUPFREET, RFMULTIT, REGROUPFREEABT, READMINT, & 99:      &        BARRIERSHORT, FREEZE, RATESHORT, DUMMYRUNT, REWEIGHTT, REGROUPFREET, RFMULTIT, REGROUPFREEABT, READMINT, &
100:      &        DUMPGROUPST, FREEPAIRT, KSHORTESTPATHST, KSHORT_FULL_PRINTT, DIJINITFLYT, BHINTERPT, ICINTERPT, &100:      &        DUMPGROUPST, FREEPAIRT, KSHORTESTPATHST, KSHORT_FULL_PRINTT, DIJINITFLYT, BHINTERPT, ICINTERPT, &
101:      &        DUMMYTST, DOCKT, DSTAGE(6), USEPAIRST, LOWESTFRQT, BISECTT, NGTDISCONNECTALL, ANGLEAXIS2, MULTISITEPYT, TFOLDT, &101:      &        DUMMYTST, DOCKT, DSTAGE(6), USEPAIRST, LOWESTFRQT, BISECTT, NGTDISCONNECTALL, ANGLEAXIS2, TFOLDT, &
102:      &        SLURMT, INDEXCOSTFUNCTION, CVT, CVMINIMAT, DOST, IMFRQT, CLOSEFILEST, PULLT, FRICTIONT, ATOMMATCHFULL, &102:      &        SLURMT, INDEXCOSTFUNCTION, CVT, CVMINIMAT, DOST, IMFRQT, CLOSEFILEST, PULLT, FRICTIONT, ATOMMATCHFULL, &
103:      &        INTCONSTRAINTT, CHECKCONINT, INTLJT, INTERPCOSTFUNCTION, REMOVEUNCONNECTEDT, ATOMMATCHDIST, &103:      &        INTCONSTRAINTT, CHECKCONINT, INTLJT, INTERPCOSTFUNCTION, REMOVEUNCONNECTEDT, ATOMMATCHDIST, &
104:      &        DBPT, DBPTDT, DMBLPYT, EFIELDT, MSSTOCKT, NTIPT, PAHAT, PAPT, PATCHYDT, STOCKAAT, RBAAT, RBSYMT, TRAPT, SILANET, &104:      &        DBPT, DBPTDT, DMBLPYT, EFIELDT, MSSTOCKT, NTIPT, PAHAT, PAPT, PATCHYDT, STOCKAAT, RBAAT, RBSYMT, TRAPT, SILANET, &
105:      &        OHCELLT, INTFREEZET, LPERMDIST, PBST, RANDOMMETRICT, SSHT, ALLTST, USERPOTT, CHECKMINT, &105:      &        OHCELLT, INTFREEZET, LPERMDIST, PBST, RANDOMMETRICT, SSHT, ALLTST, USERPOTT, CHECKMINT, &
106:      &        CHECKTST, CHECKSPT, FROMLOWESTT, ADDMINXYZT, MACHINE, RATESCYCLET, NOINVERSION, NEWCONNECTIONST, NIMET, NIHEAM7T, &106:      &        CHECKTST, CHECKSPT, FROMLOWESTT, ADDMINXYZT, MACHINE, RATESCYCLET, NOINVERSION, NEWCONNECTIONST, NIMET, NIHEAM7T, &
107:      &        NIH2LEPST, DISTANCET, RATETARGETT, TARGETHIT, ALLOWABT, MICROTHERMT, RFKMCT, REGROUPKMCT, ONEREGROUPT, PHI4MODT, &107:      &        NIH2LEPST, DISTANCET, RATETARGETT, TARGETHIT, ALLOWABT, MICROTHERMT, RFKMCT, REGROUPKMCT, ONEREGROUPT, PHI4MODT, &
108:      &        PERSISTT, REGROUPPERSISTT, NOLABELST, SHANNONT, MAKEPAIRS, SKIPPAIRST, PERSISTAPPROXT, ALLCOMPONENTST, &108:      &        PERSISTT, REGROUPPERSISTT, NOLABELST, SHANNONT, MAKEPAIRS, SKIPPAIRST, PERSISTAPPROXT, ALLCOMPONENTST, &
109:      &        SHANNONRT, SHANNONZT, CUDAT, MLLJAT3, MLP3T, DIJPRUNET, PRINTSUMMARYT, MKTRAPT, MLPB3T, PRUNECYCLET, PAIRSIGNORET, &109:      &        SHANNONRT, SHANNONZT, CUDAT, MLLJAT3, MLP3T, DIJPRUNET, PRINTSUMMARYT, MKTRAPT, MLPB3T, PRUNECYCLET, PAIRSIGNORET, &
110:      &        NOTRANSROTT, NOPOINTGROUPT, MACROIONT110:      &        NOTRANSROTT, NOPOINTGROUPT, MACROIONT
111: 111: 


r31908/Dijkstra.f90 2017-02-14 09:30:34.827064864 +0000 r31907/Dijkstra.f90 2017-02-14 09:30:37.391098835 +0000
981:    IF (.NOT.(REGROUPRATET.OR.REGROUPPET.OR.REGROUPFREET.OR.DUMMYTST.OR.REGROUPPERSISTT.OR.NOPOINTS)) &981:    IF (.NOT.(REGROUPRATET.OR.REGROUPPET.OR.REGROUPFREET.OR.DUMMYTST.OR.REGROUPPERSISTT.OR.NOPOINTS)) &
982:   &                   OPEN(UNIT=1,FILE='redopoints',STATUS='UNKNOWN')982:   &                   OPEN(UNIT=1,FILE='redopoints',STATUS='UNKNOWN')
983:    IF (ALLOCATED(BESTPATH)) DEALLOCATE(BESTPATH)983:    IF (ALLOCATED(BESTPATH)) DEALLOCATE(BESTPATH)
984:    ALLOCATE(BESTPATH(2*NSTEPS+1))984:    ALLOCATE(BESTPATH(2*NSTEPS+1))
985:    J5=VERYBESTEND985:    J5=VERYBESTEND
986:    BESTPATHLENGTH=2*NSTEPS+1986:    BESTPATHLENGTH=2*NSTEPS+1
987:    DO J1=1,NSTEPS987:    DO J1=1,NSTEPS
988:       IF (.NOT.(REGROUPRATET.OR.REGROUPPET.OR.REGROUPFREET.OR.DUMMYTST.OR.REGROUPPERSISTT.OR.NOPOINTS)) THEN988:       IF (.NOT.(REGROUPRATET.OR.REGROUPPET.OR.REGROUPFREET.OR.DUMMYTST.OR.REGROUPPERSISTT.OR.NOPOINTS)) THEN
989:          READ(UMIN,REC=J5) (LOCALPOINTS(J2),J2=1,3*NATOMS)989:          READ(UMIN,REC=J5) (LOCALPOINTS(J2),J2=1,3*NATOMS)
990:          IF (J1.GT.1) THEN990:          IF (J1.GT.1) THEN
991:           IF(.NOT.RBAAT)  CALL MINPERMDIST(ALIGNPOINTS,LOCALPOINTS,NATOMS,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT,TWOD,DISTANCES,DIST2,RIGIDBODY, &991:             CALL MINPERMDIST(ALIGNPOINTS,LOCALPOINTS,NATOMS,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT,TWOD,DISTANCES,DIST2,RIGIDBODY, &
992:    &                         RMAT,.FALSE.)992:    &                         RMAT,.FALSE.)
993:          ENDIF993:          ENDIF
994: !994: !
995: ! We MUST use fixed format here in case the coordinates are read back into CHARMM. 995: ! We MUST use fixed format here in case the coordinates are read back into CHARMM. 
996: ! CHARMM cannot read exponential format, even if the free keyword is specified!!996: ! CHARMM cannot read exponential format, even if the free keyword is specified!!
997: !997: !
998:          WRITE(1,'(3F25.15)') (LOCALPOINTS(J2),J2=1,3*NATOMS)998:          WRITE(1,'(3F25.15)') (LOCALPOINTS(J2),J2=1,3*NATOMS)
999:          ALIGNPOINTS(1:3*NATOMS)=LOCALPOINTS(1:3*NATOMS)999:          ALIGNPOINTS(1:3*NATOMS)=LOCALPOINTS(1:3*NATOMS)
1000:          READ(UTS,REC=TSPATHID(J1)) (LOCALPOINTS(J2),J2=1,3*NATOMS)1000:          READ(UTS,REC=TSPATHID(J1)) (LOCALPOINTS(J2),J2=1,3*NATOMS)
1001:           IF(.NOT.RBAAT)  CALL MINPERMDIST(ALIGNPOINTS,LOCALPOINTS,NATOMS,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT,TWOD,DISTANCES,DIST2,RIGIDBODY, &1001:          CALL MINPERMDIST(ALIGNPOINTS,LOCALPOINTS,NATOMS,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT,TWOD,DISTANCES,DIST2,RIGIDBODY, &
1002:    &                      RMAT,.FALSE.)1002:    &                      RMAT,.FALSE.)
1003:          WRITE(1,'(3F25.15)') (LOCALPOINTS(J2),J2=1,3*NATOMS)1003:          WRITE(1,'(3F25.15)') (LOCALPOINTS(J2),J2=1,3*NATOMS)
1004:          ALIGNPOINTS(1:3*NATOMS)=LOCALPOINTS(1:3*NATOMS)1004:          ALIGNPOINTS(1:3*NATOMS)=LOCALPOINTS(1:3*NATOMS)
1005:          IF (J1.EQ.NSTEPS) THEN ! last minimum1005:          IF (J1.EQ.NSTEPS) THEN ! last minimum
1006:             READ(UMIN,REC=VERYBESTPARENT(J5)) (LOCALPOINTS(J2),J2=1,3*NATOMS)1006:             READ(UMIN,REC=VERYBESTPARENT(J5)) (LOCALPOINTS(J2),J2=1,3*NATOMS)
1007:           IF(.NOT.RBAAT)  CALL MINPERMDIST(ALIGNPOINTS,LOCALPOINTS,NATOMS,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT,TWOD,DISTANCES,DIST2,RIGIDBODY, &1007:             CALL MINPERMDIST(ALIGNPOINTS,LOCALPOINTS,NATOMS,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT,TWOD,DISTANCES,DIST2,RIGIDBODY, &
1008:    &                         RMAT,.FALSE.)1008:    &                         RMAT,.FALSE.)
1009:             WRITE(1,'(3F25.15)') (LOCALPOINTS(J2),J2=1,3*NATOMS)1009:             WRITE(1,'(3F25.15)') (LOCALPOINTS(J2),J2=1,3*NATOMS)
1010:          ENDIF1010:          ENDIF
1011:       ENDIF1011:       ENDIF
1012:       IF (J1.EQ.NSTEPS) BESTPATH(2*J1+1)=VERYBESTPARENT(J5) ! last min1012:       IF (J1.EQ.NSTEPS) BESTPATH(2*J1+1)=VERYBESTPARENT(J5) ! last min
1013:       BESTPATH(2*J1-1)=J5         ! min1013:       BESTPATH(2*J1-1)=J5         ! min
1014:       BESTPATH(2*J1)=TSPATHID(J1) ! ts1014:       BESTPATH(2*J1)=TSPATHID(J1) ! ts
1015:       J5=VERYBESTPARENT(J5)1015:       J5=VERYBESTPARENT(J5)
1016:    ENDDO1016:    ENDDO
1017:    IF (.NOT.(REGROUPRATET.OR.REGROUPPET.OR.REGROUPFREET.OR.DUMMYTST.OR.REGROUPPERSISTT.OR.NOPOINTS)) CLOSE(1)1017:    IF (.NOT.(REGROUPRATET.OR.REGROUPPET.OR.REGROUPFREET.OR.DUMMYTST.OR.REGROUPPERSISTT.OR.NOPOINTS)) CLOSE(1)


r31908/getallmin.f 2017-02-14 09:30:35.343071698 +0000 r31907/getallmin.f 2017-02-14 09:30:37.903105609 +0000
246: 130      CONTINUE246: 130      CONTINUE
247:       ENDDO247:       ENDDO
248: 110   CLOSE(LUNIT)248: 110   CLOSE(LUNIT)
249:       IF (DIJINITT) THEN249:       IF (DIJINITT) THEN
250:          IF (NMIN.GT.NMINSAVE) THEN ! write new pairdist and pairlist files250:          IF (NMIN.GT.NMINSAVE) THEN ! write new pairdist and pairlist files
251:             LUNIT=GETUNIT()251:             LUNIT=GETUNIT()
252:             OPEN(UNIT=LUNIT,FILE='pairdist',STATUS='UNKNOWN',POSITION='APPEND')252:             OPEN(UNIT=LUNIT,FILE='pairdist',STATUS='UNKNOWN',POSITION='APPEND')
253:             DO J3=NMINSAVE+1,NMIN253:             DO J3=NMINSAVE+1,NMIN
254:                WRITE(LUNIT,'(10G20.10)') (PAIRDIST(J3,J4),J4=1,PAIRDISTMAX)254:                WRITE(LUNIT,'(10G20.10)') (PAIRDIST(J3,J4),J4=1,PAIRDISTMAX)
255:             ENDDO255:             ENDDO
256:             CALL FLUSH(LUNIT,ISTAT) 
257:             CLOSE(LUNIT)256:             CLOSE(LUNIT)
258:             OPEN(UNIT=LUNIT,FILE='pairlist',STATUS='UNKNOWN',POSITION='APPEND')257:             OPEN(UNIT=LUNIT,FILE='pairlist',STATUS='UNKNOWN',POSITION='APPEND')
259:             DO J3=NMINSAVE+1,NMIN258:             DO J3=NMINSAVE+1,NMIN
260:                WRITE(LUNIT,'(10I10)') (PAIRLIST(J3,J4),J4=1,PAIRDISTMAX)259:                WRITE(LUNIT,'(10I10)') (PAIRLIST(J3,J4),J4=1,PAIRDISTMAX)
261:             ENDDO260:             ENDDO
262:             CALL FLUSH(LUNIT,ISTAT) 
263:             CLOSE(LUNIT)261:             CLOSE(LUNIT)
264:          ENDIF262:          ENDIF
265:       ENDIF263:       ENDIF
266: !264: !
267: !  If we found new minima between the original ones then adjust the barrier for MINS and MINF265: !  If we found new minima between the original ones then adjust the barrier for MINS and MINF
268: !  according to the sum of distances.266: !  according to the sum of distances.
269: !267: !
270:       IF ((NMIN-NMINSAVE.GT.0).AND.(BISECTT)) THEN268:       IF ((NMIN-NMINSAVE.GT.0).AND.(BISECTT)) THEN
271:          MATCHED=.FALSE.269:          MATCHED=.FALSE.
272:          DO J3=1,NTS270:          DO J3=1,NTS


r31908/getallpaths.f 2017-02-14 09:30:35.755077179 +0000 r31907/getallpaths.f 2017-02-14 09:30:38.187109370 +0000
800:                  ENDIF800:                  ENDIF
801: !801: !
802: ! Since entries have changed we'd better rewrite these files rather802: ! Since entries have changed we'd better rewrite these files rather
803: ! than just append to them. 803: ! than just append to them. 
804: !804: !
805:                   LUNIT=GETUNIT()805:                   LUNIT=GETUNIT()
806:                   OPEN(UNIT=LUNIT,FILE='pairdist',STATUS='UNKNOWN')806:                   OPEN(UNIT=LUNIT,FILE='pairdist',STATUS='UNKNOWN')
807:                   DO J3=1,NMIN807:                   DO J3=1,NMIN
808:                      WRITE(LUNIT,'(10G20.10)') (PAIRDIST(J3,J4),J4=1,PAIRDISTMAX)808:                      WRITE(LUNIT,'(10G20.10)') (PAIRDIST(J3,J4),J4=1,PAIRDISTMAX)
809:                   ENDDO809:                   ENDDO
810:                   CALL FLUSH(LUNIT,ISTAT) 
811:                   CLOSE(LUNIT)810:                   CLOSE(LUNIT)
812:                   OPEN(UNIT=LUNIT,FILE='pairlist',STATUS='UNKNOWN')811:                   OPEN(UNIT=LUNIT,FILE='pairlist',STATUS='UNKNOWN')
813:                   DO J3=1,NMIN812:                   DO J3=1,NMIN
814:                      WRITE(LUNIT,'(10I10)') (PAIRLIST(J3,J4),J4=1,PAIRDISTMAX)813:                      WRITE(LUNIT,'(10I10)') (PAIRLIST(J3,J4),J4=1,PAIRDISTMAX)
815:                   ENDDO814:                   ENDDO
816:                   CALL FLUSH(LUNIT,ISTAT) 
817:                   CLOSE(LUNIT)815:                   CLOSE(LUNIT)
818:                ENDIF816:                ENDIF
819:             ENDIF817:             ENDIF
820: C818: C
821: C  Update ts pointers.819: C  Update ts pointers.
822: C820: C
823:             POINTERP(NTS)=-1821:             POINTERP(NTS)=-1
824:             POINTERM(NTS)=-1822:             POINTERM(NTS)=-1
825:             IF (TOPPOINTER(PLUS(NTS)).GT.0) POINTERP(NTS)=TOPPOINTER(PLUS(NTS))823:             IF (TOPPOINTER(PLUS(NTS)).GT.0) POINTERP(NTS)=TOPPOINTER(PLUS(NTS))
826:             IF (TOPPOINTER(MINUS(NTS)).GT.0) POINTERM(NTS)=TOPPOINTER(MINUS(NTS))824:             IF (TOPPOINTER(MINUS(NTS)).GT.0) POINTERM(NTS)=TOPPOINTER(MINUS(NTS))


r31908/inertia.f 2017-02-14 09:30:36.055081132 +0000 r31907/inertia.f 2017-02-14 09:30:38.439112711 +0000
 69: C  Build inertia tensor and get principal values. 69: C  Build inertia tensor and get principal values.
 70: C 70: C
 71:       SUBROUTINE INERTIA(Q,ITX,ITY,ITZ) 71:       SUBROUTINE INERTIA(Q,ITX,ITY,ITZ)
 72:       USE COMMONS 72:       USE COMMONS
 73:       IMPLICIT NONE 73:       IMPLICIT NONE
 74:       INTEGER J1, J2, J3 74:       INTEGER J1, J2, J3
 75:       DOUBLE PRECISION IT(3,3), Q(NOPT), CMX, CMY, CMZ, VEC(3,3), ITX, ITY, ITZ, MASST 75:       DOUBLE PRECISION IT(3,3), Q(NOPT), CMX, CMY, CMZ, VEC(3,3), ITX, ITY, ITZ, MASST
 76:  76: 
 77:       if (size(MASS).ne.NOPT/3) then 77:       if (size(MASS).ne.NOPT/3) then
 78:          print *, 'inertia> Size of MASS not equal to number of points' 78:          print *, 'inertia> Size of MASS not equal to number of points'
 79: !         stop 79:          stop
 80:       endif 80:       endif
 81:  81: 
 82:       CMX=0.0D0 82:       CMX=0.0D0
 83:       CMY=0.0D0 83:       CMY=0.0D0
 84:       CMZ=0.0D0 84:       CMZ=0.0D0
 85:       MASST=0.0D0 85:       MASST=0.0D0
 86:       DO J1=1,NOPT/3 86:       DO J1=1,NOPT/3
 87:          CMX=CMX+Q(3*(J1-1)+1)*MASS(J1) 87:          CMX=CMX+Q(3*(J1-1)+1)*MASS(J1)
 88:          CMY=CMY+Q(3*(J1-1)+2)*MASS(J1) 88:          CMY=CMY+Q(3*(J1-1)+2)*MASS(J1)
 89:          CMZ=CMZ+Q(3*(J1-1)+3)*MASS(J1) 89:          CMZ=CMZ+Q(3*(J1-1)+3)*MASS(J1)


r31908/keywords.f 2017-02-14 09:30:36.311084520 +0000 r31907/keywords.f 2017-02-14 09:30:38.703116209 +0000
 19:       SUBROUTINE KEYWORDS 19:       SUBROUTINE KEYWORDS
 20:       USE PORFUNCS 20:       USE PORFUNCS
 21:       USE NODES, ONLY: JPN, GETNODES, NNODES 21:       USE NODES, ONLY: JPN, GETNODES, NNODES
 22:       USE COMMONS 22:       USE COMMONS
 23:       USE RIGIDBODYMOD, ONLY: CAPSOMER, NUMRBTYPES, CAPSOMERDEFS 23:       USE RIGIDBODYMOD, ONLY: CAPSOMER, NUMRBTYPES, CAPSOMERDEFS
 24:       IMPLICIT NONE 24:       IMPLICIT NONE
 25:  25: 
 26:       INTEGER ITEM, NITEMS, LOC, LINE, NCR, NERROR, IR, ISTAT, NDUMMY2, LAST 26:       INTEGER ITEM, NITEMS, LOC, LINE, NCR, NERROR, IR, ISTAT, NDUMMY2, LAST
 27:       LOGICAL CAT 27:       LOGICAL CAT
 28:       COMMON /BUFINF/ ITEM, NITEMS, LOC(80), LINE, SKIPBL, CLEAR, NCR, NERROR, IR, ECHO, LAST, CAT 28:       COMMON /BUFINF/ ITEM, NITEMS, LOC(80), LINE, SKIPBL, CLEAR, NCR, NERROR, IR, ECHO, LAST, CAT
 29:       INTEGER J1, NDUMMY, J2, J3, NELLIPSOIDS 29:       INTEGER J1, NDUMMY, J2, J3
 30:       DOUBLE PRECISION DUMMY, DBSIGBB, RBSITEPOS 30:       DOUBLE PRECISION DUMMY, DBSIGBB
 31:       DOUBLE PRECISION, ALLOCATABLE :: RBCENTRE(:,:) 
 32:       LOGICAL END, SKIPBL, CLEAR, ECHO, PERMFILE, RBSYMTEST 31:       LOGICAL END, SKIPBL, CLEAR, ECHO, PERMFILE, RBSYMTEST
 33:       CHARACTER(LEN=100) WW 32:       CHARACTER(LEN=100) WW
 34:       CHARACTER(LEN=80) RWENERGYFILE 33:       CHARACTER(LEN=80) RWENERGYFILE
 35:       CHARACTER(LEN=20) WORD 34:       CHARACTER(LEN=20) WORD
 36:       CHARACTER(LEN=1) LOYNO 35:       CHARACTER(LEN=1) LOYNO
 37:       CHARACTER(LEN=9) UNSTRING 36:       CHARACTER(LEN=9) UNSTRING
 38:       CHARACTER(LEN=4) LABEL 37:       CHARACTER(LEN=4) LABEL
 39:       CHARACTER(LEN=8) DUMMYSTRING  38:       CHARACTER(LEN=8) DUMMYSTRING 
 40:         39:        
 41:       TYPE (CAPSOMER), ALLOCATABLE :: TEMPCAPSOMERDEFS(:) 40:       TYPE (CAPSOMER), ALLOCATABLE :: TEMPCAPSOMERDEFS(:)
1995:          PULLT=.TRUE.1994:          PULLT=.TRUE.
1996:          CALL READI(PATOM1)1995:          CALL READI(PATOM1)
1997:          CALL READI(PATOM2)1996:          CALL READI(PATOM2)
1998:          CALL READF(PFORCE)1997:          CALL READF(PFORCE)
1999:          IF (PFORCE.EQ.0.0D0) THEN1998:          IF (PFORCE.EQ.0.0D0) THEN
2000:             WRITE(*,'(A,I6,A,I6,A,G20.10)') 'keyword> WARNING *** Pulling force is zero, turning off pulling directive'1999:             WRITE(*,'(A,I6,A,I6,A,G20.10)') 'keyword> WARNING *** Pulling force is zero, turning off pulling directive'
2001:             PULLT=.FALSE.2000:             PULLT=.FALSE.
2002:          ELSE2001:          ELSE
2003:             WRITE(*,'(A,I6,A,I6,A,G20.10)') 'keyword> Pulling atoms ',PATOM1,' and ',PATOM2,' force=',PFORCE2002:             WRITE(*,'(A,I6,A,I6,A,G20.10)') 'keyword> Pulling atoms ',PATOM1,' and ',PATOM2,' force=',PFORCE
2004:          ENDIF2003:          ENDIF
2005:          PRINT '(A)','keywords> Constant pulling force with 4 zero eigenvalues'2004:          PRINT '(A)','keywords> Constant fulling force with 4 zero eigenvalues'
2006:       ELSE IF (WORD.EQ.'MULTISITEPY') THEN2005:       ELSE IF (WORD.EQ.'MULTISITEPY') THEN
2007:               OPEN(UNIT=299,FILE="pysites.xyz",STATUS="old")2006:               OPEN(UNIT=299,FILE="pysites.xyz",STATUS="old")
2008:               READ(299,*) NELLIPSOIDS2007:               READ(299,*) NRBSITES
2009:               READ(299,*)2008:               READ(299,*)
2010:          MULTISITEPYT=.TRUE.2009:          ALLOCATE(RBSITE(NRBSITES,3))
2011:          IF(NITEMS.GT.1) THEN2010:          ALLOCATE(SITEMASS(NRBSITES))
2012:            NRBSITES=2*NELLIPSOIDS2011:          SITEMASS(:) = 1.D0
2013:            CALL READF(RBSITEPOS)2012:          DO J1=1,NRBSITES
2014:            WRITE(*,'(A,F8.2,A)') ' keywords> symmetric sites will be positioned along the z axis at a distance of ', RBSITEPOS,2013:             READ(299,*) LABEL, RBSITE(J1,1), RBSITE(J1,2), RBSITE(J1,3)
2015:      &          'from the body centre'2014:          END DO ! loop over all sites
2016:            ALLOCATE(RBSITE(NRBSITES,3)) 
2017:            ALLOCATE(RBCENTRE(NELLIPSOIDS,3)) 
2018:            ALLOCATE(SITEMASS(NRBSITES)) 
2019:            SITEMASS(:) = 1.D0 
2020:            DO J1=1,NELLIPSOIDS 
2021:               READ(299,*) LABEL, RBCENTRE(J1,1), RBCENTRE(J1,2), RBCENTRE(J1,3) 
2022:            END DO ! loop over all sites 
2023:            RBSITE(:,:)=0.0D0 
2024:            DO J1=1,NELLIPSOIDS 
2025:               RBSITE(J1,3)=RBCENTRE(J1,3)+RBSITEPOS 
2026:               RBSITE(J1+NELLIPSOIDS,3)=RBCENTRE(J1,3)-RBSITEPOS 
2027:            END DO 
2028:          ELSE 
2029:            NRBSITES=NELLIPSOIDS 
2030:            ALLOCATE(RBSITE(NRBSITES,3)) 
2031:            ALLOCATE(SITEMASS(NRBSITES)) 
2032:            SITEMASS(:) = 1.D0 
2033:            DO J1=1,NRBSITES 
2034:               READ(299,*) LABEL, RBSITE(J1,1), RBSITE(J1,2), RBSITE(J1,3) 
2035:            END DO ! loop over all sites 
2036:          END IF 
2037:       ELSE IF (WORD.EQ.'PY') THEN2015:       ELSE IF (WORD.EQ.'PY') THEN
2038:          NRBSITES = 12016:          NRBSITES = 1
2039:          ALLOCATE(RBSITE(NRBSITES,3))2017:          ALLOCATE(RBSITE(NRBSITES,3))
2040:          ALLOCATE(SITEMASS(NRBSITES)) 
2041:          SITEMASS(:)=1.0D0 
2042:          RBSITE(1,:) = 0.D02018:          RBSITE(1,:) = 0.D0
2043:       ELSE IF (WORD.EQ.'PYGRAVITY') THEN2019: !
2044:          EFIELDT=.TRUE. 
2045:  ! 
2046: ! Calculate a landscape Shannon entropy from harmonic equilibrium probabilities2020: ! Calculate a landscape Shannon entropy from harmonic equilibrium probabilities
2047: !2021: !
2048:       ELSE IF (WORD.EQ.'SHANNON') THEN2022:       ELSE IF (WORD.EQ.'SHANNON') THEN
2049:          SHANNONT=.TRUE.2023:          SHANNONT=.TRUE.
2050:          SHANNONTMIN=1.0D02024:          SHANNONTMIN=1.0D0
2051:          SHANNONTMAX=2.0D02025:          SHANNONTMAX=2.0D0
2052:          SHANNONTINC=0.1D02026:          SHANNONTINC=0.1D0
2053:          CALL READF(SHANNONTMIN)2027:          CALL READF(SHANNONTMIN)
2054:          CALL READF(SHANNONTMAX)2028:          CALL READF(SHANNONTMAX)
2055:          CALL READF(SHANNONTINC)2029:          CALL READF(SHANNONTINC)


r31908/minpermdistrbcom.f90 2017-02-14 09:30:36.563087857 +0000 r31907/minpermdistrbcom.f90 2017-02-14 09:30:38.963119656 +0000
 20: !      DOUBLE PRECISION   :: XA(3*NATOMS*NRBSITES/2),  XB(3*NATOMS*NRBSITES/2), XBS(3*NATOMS*NRBSITES/2) 20: !      DOUBLE PRECISION   :: XA(3*NATOMS*NRBSITES/2),  XB(3*NATOMS*NRBSITES/2), XBS(3*NATOMS*NRBSITES/2)
 21:       DOUBLE PRECISION   :: XA(3*NATOMS),  XB(3*NATOMS), XBS(3*NATOMS) 21:       DOUBLE PRECISION   :: XA(3*NATOMS),  XB(3*NATOMS), XBS(3*NATOMS)
 22:       DOUBLE PRECISION   :: XTMP(3*NATOMS) 22:       DOUBLE PRECISION   :: XTMP(3*NATOMS)
 23:       DOUBLE PRECISION   :: RMAT(3,3), RMATI(3,3), ENERGY, VNEW(3*NATOMS), DX, DY, DZ, RMS, DBEST, XBEST(3*NATOMS) 23:       DOUBLE PRECISION   :: RMAT(3,3), RMATI(3,3), ENERGY, VNEW(3*NATOMS), DX, DY, DZ, RMS, DBEST, XBEST(3*NATOMS)
 24:       DOUBLE PRECISION   :: ROTA(3,3), ROTINVA(3,3), ROTB(3,3), ROTBINV(3,3), RMATCUMUL(3,3), LMAT(3,3) 24:       DOUBLE PRECISION   :: ROTA(3,3), ROTINVA(3,3), ROTB(3,3), ROTBINV(3,3), RMATCUMUL(3,3), LMAT(3,3)
 25:       DOUBLE PRECISION   :: ROTINVBBEST(3,3), ROTABEST(3,3), RMATBEST(3,3), RMATWP(3,3) 25:       DOUBLE PRECISION   :: ROTINVBBEST(3,3), ROTABEST(3,3), RMATBEST(3,3), RMATWP(3,3)
 26:       DOUBLE PRECISION   :: CMAX, CMAY, CMAZ, CMBX, CMBY, CMBZ 26:       DOUBLE PRECISION   :: CMAX, CMAY, CMAZ, CMBX, CMBY, CMBZ
 27:       DOUBLE PRECISION   :: PDUMMYA(3*NATOMS), PDUMMYB(3*NATOMS), LDISTANCE, XDUMMY, BOXLX, BOXLY, BOXLZ, WORSTRAD 27:       DOUBLE PRECISION   :: PDUMMYA(3*NATOMS), PDUMMYB(3*NATOMS), LDISTANCE, XDUMMY, BOXLX, BOXLY, BOXLZ, WORSTRAD
 28:       DOUBLE PRECISION   :: Q(4), Q1(4), Q2(4), AMAT(4,4), BMAT(4,4), DIAG(4), P(3) 28:       DOUBLE PRECISION   :: Q(4), Q1(4), Q2(4), AMAT(4,4), BMAT(4,4), DIAG(4), P(3)
 29:       DOUBLE PRECISION   :: ST, THETA, THETAH, FCT, DUMMYC(3*NATOMS), DUMMYD(3*NATOMS) 29:       DOUBLE PRECISION   :: ST, THETA, THETAH, FCT, DUMMYC(3*NATOMS), DUMMYD(3*NATOMS)
 30:       LOGICAL            :: DEBUG, BULKT, LINEAR 30:       LOGICAL            :: DEBUG, BULKT
 31:       DOUBLE PRECISION   :: BESTA(3*NATOMS), RBDISTANCE, PVEC(3), RTEMP1(3,3), RTEMP2(3,3), SITEDIST 31:       DOUBLE PRECISION   :: BESTA(3*NATOMS), RBDISTANCE, PVEC(3), RTEMP1(3,3), RTEMP2(3,3), SITEDIST
 32:       DOUBLE PRECISION   :: QCUMUL(4), QBEST(4), QA(4), QB(4), QBINV(4), QTMP(4), QI(4) 32:       DOUBLE PRECISION   :: QCUMUL(4), QBEST(4), QA(4), QB(4), QBINV(4), QTMP(4), QI(4)
 33:       DOUBLE PRECISION   :: COORDSAS(3*NATOMS), COORDSBS(3*NATOMS), T(3*NATOMS), ITX, ITY, ITZ, PREVDIST 33:       DOUBLE PRECISION   :: COORDSAS(3*NATOMS), COORDSBS(3*NATOMS), T(3*NATOMS)
 34:  34: 
 35:       COORDSAS(1:3*NATOMS) = COORDSA(1:3*NATOMS) ! to trace error, see at the end 35:       COORDSAS(1:3*NATOMS) = COORDSA(1:3*NATOMS) ! to trace error, see at the end
 36:       COORDSBS(1:3*NATOMS) = COORDSB(1:3*NATOMS) ! to trace error, see at the end 36:       COORDSBS(1:3*NATOMS) = COORDSB(1:3*NATOMS) ! to trace error, see at the end
 37:  37: 
 38:       CMBX = 0.0D0; CMBY = 0.0D0; CMBZ = 0.0D0 38:       CMBX = 0.0D0; CMBY = 0.0D0; CMBZ = 0.0D0
 39:       DO J1 = 1, NATOMS 39:       DO J1 = 1, NATOMS
 40:          J2 = 3*J1 40:          J2 = 3*J1
 41:          CMBX = CMBX + COORDSB(J2-2) 41:          CMBX = CMBX + COORDSB(J2-2)
 42:          CMBY = CMBY + COORDSB(J2-1) 42:          CMBY = CMBY + COORDSB(J2-1)
 43:          CMBZ = CMBZ + COORDSB(J2) 43:          CMBZ = CMBZ + COORDSB(J2)
113: !      DO J1 = 1, 3*NRB113: !      DO J1 = 1, 3*NRB
114: !         DISTANCE = DISTANCE + (DUMMYA(J1) - DUMMYB(J1))**2114: !         DISTANCE = DISTANCE + (DUMMYA(J1) - DUMMYB(J1))**2
115: !      ENDDO115: !      ENDDO
116: !     !116: !     !
117: !     ----------------------------------------------------------------------------------------------117: !     ----------------------------------------------------------------------------------------------
118:       118:       
119:       DISTANCE = 0.D0119:       DISTANCE = 0.D0
120:       DO J1 = 1, 3*NATOMS120:       DO J1 = 1, 3*NATOMS
121:          DISTANCE = DISTANCE + (DUMMYA(J1) - DUMMYB(J1))**2121:          DISTANCE = DISTANCE + (DUMMYA(J1) - DUMMYB(J1))**2
122:       ENDDO122:       ENDDO
123:       IF(ABS(PREVDIST-DISTANCE)<1.0D-6) THEN123: 
124: !     distance did not improve, stop looping 
125:         NCHOOSE1=NORBIT1 
126:         NCHOOSE2=NORBIT2      
127:       END IF 
128:       PREVDIST=DISTANCE 
129: !     ----------------------------------------------------------------------------------------------124: !     ----------------------------------------------------------------------------------------------
130: !     !125: !     !
131: !      WRITE(975,'(I6)') NRB*NRBSITES126: !      WRITE(975,'(I6)') NRB*NRBSITES
132: !      WRITE(975,'(A,2I6,A,F20.10)') 'A sites before rotation'127: !      WRITE(975,'(A,2I6,A,F20.10)') 'A sites before rotation'
133: !      WRITE(975,'(A,3F20.10)') ('LA ',XA(3*(J3-1)+1:3*(J3-1)+3),J3=1,NRB*NRBSITES)128: !      WRITE(975,'(A,3F20.10)') ('LA ',XA(3*(J3-1)+1:3*(J3-1)+3),J3=1,NRB*NRBSITES)
134: !      WRITE(975,'(I6)') NRB*NRBSITES129: !      WRITE(975,'(I6)') NRB*NRBSITES
135: !      WRITE(975,'(A,2I6,A,F20.10)') 'B sites before rotation'130: !      WRITE(975,'(A,2I6,A,F20.10)') 'B sites before rotation'
136: !      WRITE(975,'(A,3F20.10)') ('LA ',XB(3*(J3-1)+1:3*(J3-1)+3),J3=1,NRB*NRBSITES)131: !      WRITE(975,'(A,3F20.10)') ('LA ',XB(3*(J3-1)+1:3*(J3-1)+3),J3=1,NRB*NRBSITES)
137: !     !132: !     !
138: !     ----------------------------------------------------------------------------------------------133: !     ----------------------------------------------------------------------------------------------
139: 134: 
140: !      IF (DEBUG) PRINT '(A,G20.10)',' minpermdistrbcom> after initial call to RBSITESORIENT distance=',SQRT(DISTANCE),NCHOOSE1,NCHOOSE2,DBEST135:       IF (DEBUG) PRINT '(A,G20.10)',' minpermdistrbcom> after initial call to RBSITESORIENT distance=',SQRT(DISTANCE)
141:       IF (DEBUG) WRITE(*,*) ' minpermdistrbcom> after initial call to RBSITESORIENT distance=',SQRT(DISTANCE),NCHOOSE1,NCHOOSE2,DBEST,NATOMS 
142: !136: !
143: !     Bipartite matching routine for permutations. Coordinates in DUMMYB do not change137: !     Bipartite matching routine for permutations. Coordinates in DUMMYB do not change
144: !     but the coordinates in DUMMYA do. DISTANCE is the distance in this case.138: !     but the coordinates in DUMMYA do. DISTANCE is the distance in this case.
145: !     We return to label 10 after every round of permutational/orientational alignment139: !     We return to label 10 after every round of permutational/orientational alignment
146: !     unless we have converged to the identity permutation.140: !     unless we have converged to the identity permutation.
147: !141: !
148: !     Atoms are not allowed to appear in more than one group.142: !     Atoms are not allowed to appear in more than one group.
149: !     The maximum number of pair exchanges associated with a group is two.143: !     The maximum number of pair exchanges associated with a group is two.
150: !144: !
151:       NTRIES = 0145:       NTRIES = 0


r31908/rbperm.f90 2017-02-14 09:30:36.815091197 +0000 r31907/rbperm.f90 2017-02-14 09:30:39.227123148 +0000
 31: !     The centres of coordinates for COORDSA and COORDSB can be anywhere. On return, the 31: !     The centres of coordinates for COORDSA and COORDSB can be anywhere. On return, the
 32: !     centre of coordinates of COORDSA will be the same as for COORDSB. 32: !     centre of coordinates of COORDSA will be the same as for COORDSB.
 33: ! 33: !
 34: !     ---------------------------------------------------------------------------------------------- 34: !     ----------------------------------------------------------------------------------------------
 35:   35:  
 36:       SUBROUTINE RBMINPERMDIST(COORDSB,COORDSA,DISTANCE,DIST2,QBEST,RMATBEST,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT) 36:       SUBROUTINE RBMINPERMDIST(COORDSB,COORDSA,DISTANCE,DIST2,QBEST,RMATBEST,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT)
 37:  37: 
 38: !     returns DISTANCE as the actual distance, rather than the squared distance 38: !     returns DISTANCE as the actual distance, rather than the squared distance
 39:  39: 
 40:       USE COMMONS, ONLY : NATOMS, NRBSITES, NTSITES, NRBGROUP, PAPT, RBSITE, RBOPS, EFIELDT, RBSYMT 40:       USE COMMONS, ONLY : NATOMS, NRBSITES, NTSITES, NRBGROUP, PAPT, RBSITE, RBOPS, EFIELDT, RBSYMT
 41:       USE COMMONS,ONLY : NPERMGROUP, NPERMSIZE, PERMGROUP, NSETS, SETS, GEOMDIFFTOL, MULTISITEPYT 41:       USE COMMONS,ONLY : NPERMGROUP, NPERMSIZE, PERMGROUP, NSETS, SETS, GEOMDIFFTOL
 42:  42: 
 43:       IMPLICIT NONE 43:       IMPLICIT NONE
 44:  44: 
 45:       INTEGER, PARAMETER :: MAXIMUMTRIES = 100 45:       INTEGER, PARAMETER :: MAXIMUMTRIES = 100
 46:       INTEGER            :: NPERM, PATOMS, NTRIES, NSIZE, JMAX, LOCMAX(1), J1, J2, J3, INFO, NRB 46:       INTEGER            :: NPERM, PATOMS, NTRIES, NSIZE, JMAX, LOCMAX(1), J1, J2, J3, INFO, NRB
 47:       INTEGER            :: INVERT, NORBIT1, NORBIT2, PERM(NATOMS), NCHOOSE2, NDUMMY, LPERM(NATOMS), NCHOOSE1 47:       INTEGER            :: INVERT, NORBIT1, NORBIT2, PERM(NATOMS), NCHOOSE2, NDUMMY, LPERM(NATOMS), NCHOOSE1
 48:       INTEGER            :: NEWPERM(NATOMS), ALLPERM(NATOMS) 48:       INTEGER            :: NEWPERM(NATOMS), ALLPERM(NATOMS)
 49:       DOUBLE PRECISION   :: COORDSA(3*NATOMS), COORDSB(3*NATOMS), DISTANCE, DISTWP, DIST2, TEMPA(9*NATOMS)  49:       DOUBLE PRECISION   :: COORDSA(3*NATOMS), COORDSB(3*NATOMS), DISTANCE, DISTWP, DIST2, TEMPA(9*NATOMS) 
 50:       DOUBLE PRECISION   :: DUMMYA(3*NATOMS), DUMMYB(3*NATOMS), DUMMY(3*NATOMS), DUMMYWP(3*NATOMS) 50:       DOUBLE PRECISION   :: DUMMYA(3*NATOMS), DUMMYB(3*NATOMS), DUMMY(3*NATOMS), DUMMYWP(3*NATOMS)
 51:       DOUBLE PRECISION   :: XA(3*NTSITES),  XB(3*NTSITES), XBS(3*NTSITES) 51:       DOUBLE PRECISION   :: XA(3*NTSITES),  XB(3*NTSITES), XBS(3*NTSITES)
 67:  67: 
 68:       IF (DEBUG) THEN 68:       IF (DEBUG) THEN
 69:          WRITE(*,'(3F20.10)')COORDSA(1:3*NATOMS) 69:          WRITE(*,'(3F20.10)')COORDSA(1:3*NATOMS)
 70:          WRITE(*,*) 70:          WRITE(*,*)
 71:          WRITE(*,'(3F20.10)')COORDSB(1:3*NATOMS) 71:          WRITE(*,'(3F20.10)')COORDSB(1:3*NATOMS)
 72:       ENDIF 72:       ENDIF
 73:  73: 
 74:       COORDSCOMA(:) = COORDSA(1:3*NATOMS/2) 74:       COORDSCOMA(:) = COORDSA(1:3*NATOMS/2)
 75:       COORDSCOMB(:) = COORDSB(1:3*NATOMS/2) 75:       COORDSCOMB(:) = COORDSB(1:3*NATOMS/2)
 76:  76: 
 77: !     do not call minpermdistrbCOM for gravity field       
 78:       IF(EFIELDT.AND.MULTISITEPYT) GOTO 100 
 79:  
 80:       NATOMS = NATOMS/2 77:       NATOMS = NATOMS/2
 81:  78: 
 82:       CALL MINPERMDISTRBCOM(COORDSCOMB,COORDSCOMA,DISTANCE,DIST2,QBEST,RMATBEST,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT) 79:       CALL  MINPERMDISTRBCOM(COORDSCOMB,COORDSCOMA,DISTANCE,DIST2,QBEST,RMATBEST,DEBUG,BOXLX,BOXLY,BOXLZ,BULKT)
 83:   80:  
 84:       NATOMS = 2*NATOMS 81:       NATOMS = 2*NATOMS
 85:  82: 
 86:       IF (SQRT(DISTANCE) <= GEOMDIFFTOL) THEN 83:       IF (SQRT(DISTANCE) <= GEOMDIFFTOL) THEN
 87:          DISTANCE = SQRT(DISTANCE) 84:          DISTANCE = SQRT(DISTANCE)
 88:          IF (DEBUG) PRINT '(A)',' psrbpermdist> minpermdistrbcom suggests identical' 85:          IF (DEBUG) PRINT '(A)',' psrbpermdist> minpermdistrbcom suggests identical'
 89:          CMAX = 0.0D0; CMAY = 0.0D0; CMAZ = 0.0D0 86:          CMAX = 0.0D0; CMAY = 0.0D0; CMAZ = 0.0D0
 90:          CMBX = 0.0D0; CMBY = 0.0D0; CMBZ = 0.0D0 87:          CMBX = 0.0D0; CMBY = 0.0D0; CMBZ = 0.0D0
 91:          DO J1 = 1, NATOMS/2 88:          DO J1 = 1, NATOMS/2
 92:             CMAX = CMAX + COORDSA(3*(J1-1)+1) 89:             CMAX = CMAX + COORDSA(3*(J1-1)+1)
125:       NRB   = (NATOMS/2)122:       NRB   = (NATOMS/2)
126:       NSIZE = NTSITES123:       NSIZE = NTSITES
127: 124: 
128:       CMBX = 0.0D0; CMBY = 0.0D0; CMBZ = 0.0D0125:       CMBX = 0.0D0; CMBY = 0.0D0; CMBZ = 0.0D0
129:       DO J1 = 1, NATOMS/2126:       DO J1 = 1, NATOMS/2
130:          CMBX = CMBX + COORDSB(3*(J1-1)+1)127:          CMBX = CMBX + COORDSB(3*(J1-1)+1)
131:          CMBY = CMBY + COORDSB(3*(J1-1)+2)128:          CMBY = CMBY + COORDSB(3*(J1-1)+2)
132:          CMBZ = CMBZ + COORDSB(3*(J1-1)+3)129:          CMBZ = CMBZ + COORDSB(3*(J1-1)+3)
133:        ENDDO130:        ENDDO
134:       CMBX = 2*CMBX/NATOMS; CMBY = 2*CMBY/NATOMS; CMBZ = 2*CMBZ/NATOMS131:       CMBX = 2*CMBX/NATOMS; CMBY = 2*CMBY/NATOMS; CMBZ = 2*CMBZ/NATOMS
135: ! do not move along the z direction for gravity field (currently implemented for MULTISITEPY) 
136:       IF(EFIELDT.AND.MULTISITEPYT) CMBZ=0.0D0 
137:  
138: !132: !
139: !     Bring COORDSB into standard orientation with respect to the site position133: !     Bring COORDSB into standard orientation with respect to the site position
140: !     The standard orientation needs to be done for the sites if we are going to identify134: !     The standard orientation needs to be done for the sites if we are going to identify
141: !     permutation-inversion isomers with respect to the sites metric!135: !     permutation-inversion isomers with respect to the sites metric!
142: !136: !
143: !     DUMMY(1:3*NATOMS)=DUMMYB(1:3*NATOMS)137: !     DUMMY(1:3*NATOMS)=DUMMYB(1:3*NATOMS)
144: !     CALL RBSITESORIENT(DUMMY,DUMMYB,NORBIT1,1,NORBIT2,1,NATOMS,DEBUG,ROTB,ROTINVB)138: !     CALL RBSITESORIENT(DUMMY,DUMMYB,NORBIT1,1,NORBIT2,1,NATOMS,DEBUG,ROTB,ROTINVB)
145: !139: !
146: !     ----------------------------------------------------------------------------------------------140: !     ----------------------------------------------------------------------------------------------
147: !     !141: !     !
669:             ENDDO663:             ENDDO
670:          ENDIF664:          ENDIF
671:       ENDDO665:       ENDDO
672: 666: 
673:       END SUBROUTINE SITEPOS667:       END SUBROUTINE SITEPOS
674: 668: 
675: !     ----------------------------------------------------------------------------------------------669: !     ----------------------------------------------------------------------------------------------
676: 670: 
677:       SUBROUTINE RBSITESORIENT(X, T1, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, NATOMS, Q2, DEBUG)671:       SUBROUTINE RBSITESORIENT(X, T1, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, NATOMS, Q2, DEBUG)
678: 672: 
679:       USE COMMONS, ONLY: NRBSITES, NTSITES, EFIELDT, MULTISITEPYT      673:       USE COMMONS, ONLY: NRBSITES, NTSITES, EFIELDT      
680: !                        674: !                        
681: !     This subroutine puts permutational isomers of a rigid-body system into a standard orientation675: !     This subroutine puts permutational isomers of a rigid-body system into a standard orientation
682: !     with respect to the sites676: !     with respect to the sites
683: !677: !
684:       IMPLICIT NONE678:       IMPLICIT NONE
685:       INTEGER          :: NATOMS, I, J, J1, J2, JMAX1, JMAX2, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, OFFSET, NSIZE679:       INTEGER          :: NATOMS, I, J, J1, J2, JMAX1, JMAX2, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, OFFSET, NSIZE
686:       DOUBLE PRECISION :: X(3*NATOMS), T1(3*NATOMS)680:       DOUBLE PRECISION :: X(3*NATOMS), T1(3*NATOMS)
687:       DOUBLE PRECISION :: XS(3*NTSITES), T1S(3*NTSITES), T2S(3*NTSITES), DIST(NTSITES)681:       DOUBLE PRECISION :: XS(3*NTSITES), T1S(3*NTSITES), T2S(3*NTSITES), DIST(NTSITES)
688:       DOUBLE PRECISION :: AX(3), P(3), Q2(4), ROTM(3,3), ROTMINV(3,3)682:       DOUBLE PRECISION :: AX(3), P(3), Q2(4), ROTM(3,3), ROTMINV(3,3)
689:       DOUBLE PRECISION :: THETA, THETAH, COST, SINT, COSTH, SINTH, ST, FCT683:       DOUBLE PRECISION :: THETA, THETAH, COST, SINT, COSTH, SINTH, ST, FCT
957: 951: 
958:       SINV(:,:) = A(:,:)/DET952:       SINV(:,:) = A(:,:)/DET
959: 953: 
960:       END SUBROUTINE INVMTRX954:       END SUBROUTINE INVMTRX
961: 955: 
962: !     ----------------------------------------------------------------------------------------------956: !     ----------------------------------------------------------------------------------------------
963: 957: 
964:       SUBROUTINE RBROT(T, X, Q2, NATOMS)958:       SUBROUTINE RBROT(T, X, Q2, NATOMS)
965: !     takes the set of rigid-body coordinates T and returns X after rotation via the quaternion Q2 959: !     takes the set of rigid-body coordinates T and returns X after rotation via the quaternion Q2 
966: !     about the origin960: !     about the origin
967:       USE COMMONS, ONLY : EFIELDT, MULTISITEPYT 
968: 961: 
969:       IMPLICIT NONE962:       IMPLICIT NONE
970: 963: 
971:       INTEGER          :: I, J, NATOMS964:       INTEGER          :: I, J, NATOMS
972:       DOUBLE PRECISION :: T(3*NATOMS), X(3*NATOMS), T1(1:3), Q2(4), P(3), RM(3,3) 965:       DOUBLE PRECISION :: T(3*NATOMS), X(3*NATOMS), T1(1:3), Q2(4), P(3), RM(3,3) 
973:       DOUBLE PRECISION :: CMX, CMY, CMZ966:       DOUBLE PRECISION :: CMX, CMY, CMZ
974: !967: !
975: !     Move centre of mass to the origin.968: !     Move centre of mass to the origin.
976: !969: !
977:       CMX = 0.D0; CMY = 0.D0; CMZ = 0.D0970:       CMX = 0.D0; CMY = 0.D0; CMZ = 0.D0
979:          J = 3*I972:          J = 3*I
980:          CMX = CMX + T(J-2)973:          CMX = CMX + T(J-2)
981:          CMY = CMY + T(J-1)974:          CMY = CMY + T(J-1)
982:          CMZ = CMZ + T(J)975:          CMZ = CMZ + T(J)
983:       ENDDO976:       ENDDO
984:       CMX = 2*CMX/NATOMS; CMY = 2*CMY/NATOMS; CMZ = 2*CMZ/NATOMS977:       CMX = 2*CMX/NATOMS; CMY = 2*CMY/NATOMS; CMZ = 2*CMZ/NATOMS
985:       DO I = 1, NATOMS/2978:       DO I = 1, NATOMS/2
986:          J      = 3*I979:          J      = 3*I
987:          X(J-2) = T(J-2) - CMX980:          X(J-2) = T(J-2) - CMX
988:          X(J-1) = T(J-1) - CMY981:          X(J-1) = T(J-1) - CMY
989:          IF(EFIELDT.AND.MULTISITEPYT) CMZ = 0.0D0 
990:          X(J)   = T(J)   - CMZ982:          X(J)   = T(J)   - CMZ
991:       ENDDO983:       ENDDO
992: 984: 
993: !     extract the rotation matrix corresponding to rotation via Q985: !     extract the rotation matrix corresponding to rotation via Q
994: 986: 
995:       CALL QROTMAT(Q2,RM)987:       CALL QROTMAT(Q2,RM)
996: 988: 
997:       DO I = 1, NATOMS/2989:       DO I = 1, NATOMS/2
998: 990: 
999:          J        = 3*I991:          J        = 3*I
1088:       RM(3,1) = 2.D0*(Q(2)*Q(4) - Q(1)*Q(3))1080:       RM(3,1) = 2.D0*(Q(2)*Q(4) - Q(1)*Q(3))
1089:       RM(3,2) = 2.D0*(Q(3)*Q(4) + Q(1)*Q(2))1081:       RM(3,2) = 2.D0*(Q(3)*Q(4) + Q(1)*Q(2))
1090:       RM(3,3) = Q(1)**2 + Q(4)**2 - Q(2)**2 - Q(3)**21082:       RM(3,3) = Q(1)**2 + Q(4)**2 - Q(2)**2 - Q(3)**2
1091: 1083: 
1092:       END SUBROUTINE1084:       END SUBROUTINE
1093: 1085: 
1094: !     ----------------------------------------------------------------------------------------------1086: !     ----------------------------------------------------------------------------------------------
1095: 1087: 
1096:       SUBROUTINE RBORIENT(X, T1, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, NATOMS, Q2, DEBUG)1088:       SUBROUTINE RBORIENT(X, T1, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, NATOMS, Q2, DEBUG)
1097:       1089:       
1098:       USE COMMONS, ONLY : EFIELDT, MULTISITEPYT 1090:       USE COMMONS, ONLY : EFIELDT 
1099: !                        1091: !                        
1100: !     This subroutine puts permutational isomers of a rigid-body system into a standard orientation.1092: !     This subroutine puts permutational isomers of a rigid-body system into a standard orientation.
1101: !1093: !
1102:       IMPLICIT NONE1094:       IMPLICIT NONE
1103:       INTEGER          :: NATOMS, I, J, J1, J2, JMAX1, JMAX2, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, OFFSET1095:       INTEGER          :: NATOMS, I, J, J1, J2, JMAX1, JMAX2, NORBIT1, NCHOOSE1, NORBIT2, NCHOOSE2, OFFSET
1104:       DOUBLE PRECISION :: X(3*NATOMS), DIST(NATOMS), T1(3*NATOMS), T2(3*NATOMS)1096:       DOUBLE PRECISION :: X(3*NATOMS), DIST(NATOMS), T1(3*NATOMS), T2(3*NATOMS)
1105:       DOUBLE PRECISION :: RM(3,3), AX(3), P(3), Q1(4), Q2(4), Q(4), ROTM(3,3), ROTMINV(3,3)1097:       DOUBLE PRECISION :: RM(3,3), AX(3), P(3), Q1(4), Q2(4), Q(4), ROTM(3,3), ROTMINV(3,3)
1106:       DOUBLE PRECISION :: THETA, THETAH, COST, SINT, COSTH, SINTH, ST, FCT1098:       DOUBLE PRECISION :: THETA, THETAH, COST, SINT, COSTH, SINTH, ST, FCT
1107:       DOUBLE PRECISION :: CMX, CMY, CMZ, DMAX, DUMMY, PROJ, DMAX2, CUTOFF1, DTEMP1099:       DOUBLE PRECISION :: CMX, CMY, CMZ, DMAX, DUMMY, PROJ, DMAX2, CUTOFF1, DTEMP
1108:       LOGICAL          :: DEBUG1100:       LOGICAL          :: DEBUG
1118:          CMX = CMX + X(J-2)1110:          CMX = CMX + X(J-2)
1119:          CMY = CMY + X(J-1)1111:          CMY = CMY + X(J-1)
1120:          CMZ = CMZ + X(J)1112:          CMZ = CMZ + X(J)
1121:       ENDDO1113:       ENDDO
1122: 1114: 
1123:       CMX = 2*CMX/NATOMS; CMY = 2*CMY/NATOMS; CMZ = 2*CMZ/NATOMS1115:       CMX = 2*CMX/NATOMS; CMY = 2*CMY/NATOMS; CMZ = 2*CMZ/NATOMS
1124:       DO I = 1, NATOMS/21116:       DO I = 1, NATOMS/2
1125:          J = 3*I1117:          J = 3*I
1126:          X(J-2) = X(J-2) - CMX1118:          X(J-2) = X(J-2) - CMX
1127:          X(J-1) = X(J-1) - CMY1119:          X(J-1) = X(J-1) - CMY
1128: ! do not move along the z direction for gravity field (currently implemented in MULTISITEPY) 
1129:          IF(EFIELDT.AND.MULTISITEPYT) CMZ=0.0D0 
1130:          X(J)   = X(J)   - CMZ1120:          X(J)   = X(J)   - CMZ
1131:       ENDDO1121:       ENDDO
1132: 1122: 
1133:       DMAX    = -1.D01123:       DMAX    = -1.D0
1134:       NORBIT1 = 11124:       NORBIT1 = 1
1135: 1125: 
1136:       IF (EFIELDT) THEN1126:       IF (EFIELDT) THEN
1137: 1127: 
1138:          T1(:) = X(:)1128:          T1(:) = X(:)
1139:          GOTO 1001129:          GOTO 100


r31908/rigidb.f90 2017-02-14 09:30:37.067094534 +0000 r31907/rigidb.f90 2017-02-14 09:30:39.483126542 +0000
  1: !  1: !
  2:       SUBROUTINE RBMINDIST(RA,RB,NATOMS,DIST,Q2,DEBUG)  2:       SUBROUTINE RBMINDIST(RA,RB,NATOMS,DIST,Q2,DEBUG)
  3:   3: 
  4: !     Follows the prescription of Kearsley, Acta Cryst. A, 45, 208-210, 1989, making necessary changes  4: !     Follows the prescription of Kearsley, Acta Cryst. A, 45, 208-210, 1989, making necessary changes
  5: !     to conform to right-handed rotation in the right-handed coordinate system.  5: !     to conform to right-handed rotation in the right-handed coordinate system.
  6:   6: 
  7: !     Returns DIST as the actual distance, rather than the squared distance  7: !     Returns DIST as the actual distance, rather than the squared distance
  8:   8: 
  9:       USE COMMONS, ONLY: NTSITES, RBSITE, DBPT, DBPTDT, DMBLPYT, MSSTOCKT, STOCKAAT, EFIELDT, MULTISITEPYT  9:       USE COMMONS, ONLY: NTSITES, RBSITE, DBPT, DBPTDT, DMBLPYT, MSSTOCKT, STOCKAAT, EFIELDT
 10:  10: 
 11:       IMPLICIT NONE 11:       IMPLICIT NONE
 12:  12: 
 13:       INTEGER          :: J1, J2, J3, J4, NATOMS, NSIZE, JMIN, INFO 13:       INTEGER          :: J1, J2, J3, J4, NATOMS, NSIZE, JMIN, INFO
 14:       DOUBLE PRECISION :: RA(3*NATOMS), RB(3*NATOMS), DIST, QMAT(4,4), TEMPA(9*NATOMS), XM, YM, ZM, XP, YP, ZP 14:       DOUBLE PRECISION :: RA(3*NATOMS), RB(3*NATOMS), DIST, QMAT(4,4), TEMPA(9*NATOMS), XM, YM, ZM, XP, YP, ZP
 15:       DOUBLE PRECISION :: DIAG(4), MINV, Q2(4), CMXA, CMYA, CMZA, CMXB, CMYB, CMZB 15:       DOUBLE PRECISION :: DIAG(4), MINV, Q2(4), CMXA, CMYA, CMZA, CMXB, CMYB, CMZB
 16:       DOUBLE PRECISION :: R(3), P(3), RM(3,3)  16:       DOUBLE PRECISION :: R(3), P(3), RM(3,3) 
 17:       DOUBLE PRECISION, ALLOCATABLE :: XA(:), XB(:) 17:       DOUBLE PRECISION, ALLOCATABLE :: XA(:), XB(:)
 18:       DOUBLE PRECISION :: ENERGY, VNEW(3*NATOMS), RMS, DUMMY 18:       DOUBLE PRECISION :: ENERGY, VNEW(3*NATOMS), RMS, DUMMY
 19:       LOGICAL          :: BULKT, PRESERVET, DEBUG 19:       LOGICAL          :: BULKT, PRESERVET, DEBUG
 20:  20: 
 21:       IF ((DBPT .OR. DBPTDT .OR. DMBLPYT .OR. MSSTOCKT .OR. STOCKAAT .OR. MULTISITEPYT) .AND. EFIELDT) THEN 21:       IF ((DBPT .OR. DBPTDT .OR. DMBLPYT .OR. MSSTOCKT .OR. STOCKAAT) .AND. EFIELDT) THEN
 22:       22:      
 23:  23: 
 24:          CALL FLDMINDIST(RA,RB,NATOMS,DIST,DEBUG,Q2) 24:          CALL FLDMINDIST(RA,RB,NATOMS,DIST,DEBUG,Q2)
 25:          RETURN 25:          RETURN
 26:  26: 
 27:       ENDIF  27:       ENDIF 
 28:  28: 
 29:       NSIZE = NTSITES 29:       NSIZE = NTSITES
 30:       ALLOCATE(XA(3*NSIZE),XB(3*NSIZE)) 30:       ALLOCATE(XA(3*NSIZE),XB(3*NSIZE))
 31:  31: 
166:       ENDDO166:       ENDDO
167: 167: 
168:       END SUBROUTINE RBNEWROTGEOM168:       END SUBROUTINE RBNEWROTGEOM
169: 169: 
170: !     ----------------------------------------------------------------------------------------------170: !     ----------------------------------------------------------------------------------------------
171: 171: 
172:       SUBROUTINE FLDMINDIST(RA,RB,NATOMS,DIST,DEBUG,Q2)172:       SUBROUTINE FLDMINDIST(RA,RB,NATOMS,DIST,DEBUG,Q2)
173: 173: 
174: !     returns DIST as the actual distance, rather than the squared distance174: !     returns DIST as the actual distance, rather than the squared distance
175: 175: 
176:       USE COMMONS, ONLY: NTSITES, RBSITE, STOCKAAT, MULTISITEPYT176:       USE COMMONS, ONLY: NTSITES, RBSITE, STOCKAAT
177: 177: 
178:       IMPLICIT NONE178:       IMPLICIT NONE
179: 179: 
180:       INTEGER          :: J1, J2, J3, J4, NATOMS, NSIZE, JMIN, INFO180:       INTEGER          :: J1, J2, J3, J4, NATOMS, NSIZE, JMIN, INFO
181:       DOUBLE PRECISION :: RA(3*NATOMS), RB(3*NATOMS), DIST, QMAT(2,2), XM, YM, ZM, XP, YP, ZP181:       DOUBLE PRECISION :: RA(3*NATOMS), RB(3*NATOMS), DIST, QMAT(2,2), XM, YM, ZM, XP, YP, ZP
182:       DOUBLE PRECISION :: MINV, Q2(4), CMXA, CMYA, CMZA, CMXB, CMYB, CMZB182:       DOUBLE PRECISION :: MINV, Q2(4), CMXA, CMYA, CMZA, CMXB, CMYB, CMZB
183:       DOUBLE PRECISION :: R(3), P(3), RM(3,3) 183:       DOUBLE PRECISION :: R(3), P(3), RM(3,3) 
184:       DOUBLE PRECISION, ALLOCATABLE :: XA(:), XB(:)184:       DOUBLE PRECISION, ALLOCATABLE :: XA(:), XB(:)
185:       DOUBLE PRECISION :: ENERGY, VNEW(3*NATOMS), RMS, DUMMY185:       DOUBLE PRECISION :: ENERGY, VNEW(3*NATOMS), RMS, DUMMY
186:       LOGICAL          :: DEBUG186:       LOGICAL          :: DEBUG
195:          J2 = 3*(J1-1)195:          J2 = 3*(J1-1)
196:          CMXA = CMXA + RA(J2+1)196:          CMXA = CMXA + RA(J2+1)
197:          CMYA = CMYA + RA(J2+2)197:          CMYA = CMYA + RA(J2+2)
198:          CMZA = CMZA + RA(J2+3)198:          CMZA = CMZA + RA(J2+3)
199:       ENDDO199:       ENDDO
200:       CMXA = 2.D0*CMXA/NATOMS; CMYA = 2.D0*CMYA/NATOMS; CMZA = 2.D0*CMZA/NATOMS200:       CMXA = 2.D0*CMXA/NATOMS; CMYA = 2.D0*CMYA/NATOMS; CMZA = 2.D0*CMZA/NATOMS
201:       DO J1 = 1, NATOMS/2201:       DO J1 = 1, NATOMS/2
202:          J2 = 3*(J1-1)202:          J2 = 3*(J1-1)
203:          RA(J2+1) = RA(J2+1) - CMXA203:          RA(J2+1) = RA(J2+1) - CMXA
204:          RA(J2+2) = RA(J2+2) - CMYA204:          RA(J2+2) = RA(J2+2) - CMYA
205: ! do not move along the z axis in case of a gravity field (currently implemented for MULTISITEPY) 
206:          IF(MULTISITEPYT) CMZA=0.0D0 
207:          RA(J2+3) = RA(J2+3) - CMZA205:          RA(J2+3) = RA(J2+3) - CMZA
208:       ENDDO206:       ENDDO
209: 207: 
210:       CMXB = 0.0D0; CMYB = 0.0D0; CMZB = 0.0D0208:       CMXB = 0.0D0; CMYB = 0.0D0; CMZB = 0.0D0
211:       DO J1 = 1, NATOMS/2209:       DO J1 = 1, NATOMS/2
212:          J2 = 3*(J1-1)210:          J2 = 3*(J1-1)
213:          CMXB = CMXB + RB(J2+1)211:          CMXB = CMXB + RB(J2+1)
214:          CMYB = CMYB + RB(J2+2)212:          CMYB = CMYB + RB(J2+2)
215:          CMZB = CMZB + RB(J2+3)213:          CMZB = CMZB + RB(J2+3)
216:       ENDDO214:       ENDDO
217:       CMXB = 2.D0*CMXB/NATOMS; CMYB = 2.D0*CMYB/NATOMS; CMZB = 2.D0*CMZB/NATOMS215:       CMXB = 2.D0*CMXB/NATOMS; CMYB = 2.D0*CMYB/NATOMS; CMZB = 2.D0*CMZB/NATOMS
218:       DO J1 = 1, NATOMS/2216:       DO J1 = 1, NATOMS/2
219:          J2 = 3*(J1-1)217:          J2 = 3*(J1-1)
220:          RB(J2+1) = RB(J2+1) - CMXB218:          RB(J2+1) = RB(J2+1) - CMXB
221:          RB(J2+2) = RB(J2+2) - CMYB219:          RB(J2+2) = RB(J2+2) - CMYB
222: ! do not move along the z axis in case of a gravity field (currently implemented for MULTISITEPY) 
223:          IF(MULTISITEPYT) CMZB=0.0D0 
224:          RB(J2+3) = RB(J2+3) - CMZB220:          RB(J2+3) = RB(J2+3) - CMZB
225:       ENDDO221:       ENDDO
226: 222: 
227: !     CONVERT TO THE CARTESIAN CORDINATES FOR THE SITES223: !     CONVERT TO THE CARTESIAN CORDINATES FOR THE SITES
228: 224: 
229:       IF (STOCKAAT) THEN225:       IF (STOCKAAT) THEN
230:          XA(:) = RA(:)226:          XA(:) = RA(:)
231:          XB(:) = RB(:)227:          XB(:) = RB(:)
232:       ELSE228:       ELSE
233:          CALL SITEPOS(RA,XA)229:          CALL SITEPOS(RA,XA)
282:             PRINT '(A,G20.10,A)','newmindist> WARNING MINV is ',MINV,' change to absolute value'278:             PRINT '(A,G20.10,A)','newmindist> WARNING MINV is ',MINV,' change to absolute value'
283:             MINV = -MINV279:             MINV = -MINV
284:          ENDIF280:          ENDIF
285:       ENDIF281:       ENDIF
286:       DIST = SQRT(MINV)282:       DIST = SQRT(MINV)
287:   283:   
288:       DO J1 = 1, NATOMS/2284:       DO J1 = 1, NATOMS/2
289:          J2 = 3*(J1-1)285:          J2 = 3*(J1-1)
290:          RB(J2+1) = RB(J2+1) - CMXB286:          RB(J2+1) = RB(J2+1) - CMXB
291:          RB(J2+2) = RB(J2+2) - CMYB287:          RB(J2+2) = RB(J2+2) - CMYB
292: ! do not move along the z axis in case of a gravity field (currently implemented for MULTISITEPY) 
293:          IF(MULTISITEPYT) CMZB=0.0D0 
294:          RB(J2+3) = RB(J2+3) - CMZB288:          RB(J2+3) = RB(J2+3) - CMZB
295:       ENDDO289:       ENDDO
296: 290: 
297:       IF (DEBUG) print *, 'Q2', Q2291:       IF (DEBUG) print *, 'Q2', Q2
298:       CALL RBNEWROTGEOM(NATOMS,RB,Q2,RM,CMXA,CMYA,CMZA)292:       CALL RBNEWROTGEOM(NATOMS,RB,Q2,RM,CMXA,CMYA,CMZA)
299: 293: 
300:       DEALLOCATE(XA,XB)294:       DEALLOCATE(XA,XB)
301: 295: 
302:       END SUBROUTINE FLDMINDIST296:       END SUBROUTINE FLDMINDIST
303: 297: 


legend
Lines Added 
Lines changed
 Lines Removed

hdiff - version: 2.1.0