hdiff output

r30049/climber_commons.f90 2016-03-16 18:34:26.675606992 +0000 r30048/climber_commons.f90 2016-03-16 18:34:27.847619042 +0000
  1: MODULE CLIMBERCOMMONS  1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/OPTIM/source/climber_commons.f90' in revision 30048
  2:    USE COMMONS,ONLY : NATOMS 
  3:    IMPLICIT NONE 
  4:    DOUBLE PRECISION, ALLOCATABLE , DIMENSION(:):: SAVEDXYZ,MOVINGXYZ 
  5:    INTEGER, ALLOCATABLE, DIMENSION(:,:) :: PAIRCONSTR !all pair constraints  
  6:    INTEGER :: NCONSTR,NBBCONSTR,NSCCONSTR             !number of constraints 
  7:    INTEGER, DIMENSION(:), ALLOCATABLE :: BBCONSTR,SCCONSTR !all atoms that can be used for constraints 
  8:    DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE :: TARGETDIST   !target structure is QEND, moving starts at QSTART 
  9:    LOGICAL,ALLOCATABLE :: CONSTRATOMS(:)  
 10:  
 11: END MODULE 
 12:  


r30049/climber.f90 2016-03-16 18:34:26.483605014 +0000 r30048/climber.f90 2016-03-16 18:34:27.655617069 +0000
  1:   1: svn: E195012: Unable to find repository location for 'svn+ssh://svn.ch.private.cam.ac.uk/groups/wales/trunk/OPTIM/source/climber.f90' in revision 30048
  2:  
  3: SUBROUTINE CLIMBERINT(QSTART,QEND) 
  4: USE PORFUNCS 
  5: USE CLIMBERCOMMONS 
  6: USE COMMONS, ONLY: NATOMS,DEBUG,PARAM1, PARAM2, PARAM3, NOPT  
  7: USE KEY, ONLY: BULKT, TWOD, RIGIDBODY, MUPDATE, BFGSSTEPS, CLIMBERSTEPS, CLIMBERSPRING, CLIMBERCONV 
  8: IMPLICIT NONE 
  9: DOUBLE PRECISION :: QSTART(3*NATOMS),QEND(3*NATOMS), NEWXYZ(3*NATOMS) 
 10: DOUBLE PRECISION :: STARTDIST , DIST2, RMAT(3,3) , DISTANCE,  EDUMMY, RMS2, RMS, EREAL, VNEW(NOPT) 
 11: INTEGER :: NSTRUCTURES,ITDONE 
 12: LOGICAL :: PTEST, MFLAG 
 13: DOUBLE PRECISION, PARAMETER :: RED_SPRING=0.5,INC_SPRING=1.5 
 14:  
 15: PTEST=.FALSE. 
 16: ALLOCATE(SAVEDXYZ(2*CLIMBERSTEPS*(3*NATOMS))) 
 17: ALLOCATE(MOVINGXYZ(3*NATOMS)) 
 18: ALLOCATE(CONSTRATOMS(3*NATOMS)) 
 19: CALL CLIMBERINPUT() !read in all possible contraints 
 20: !now get all constraints that are of the right distances after minpermdist 
 21: CALL MINPERMDIST(QSTART,QEND,NATOMS,DEBUG,PARAM1,PARAM2,PARAM3,BULKT,TWOD,STARTDIST,DIST2,RIGIDBODY,RMAT) 
 22: CALL CLIMBERPAIRCONSTR(QSTART,QEND) 
 23: NSTRUCTURES=1 
 24: SAVEDXYZ((NSTRUCTURES-1)*3*NATOMS+1:NSTRUCTURES*3*NATOMS)=QSTART(1:3*NATOMS) 
 25: DO 
 26: 56 NEWXYZ=MOVINGXYZ 
 27:    CALL MYLBFGS(NOPT,MUPDATE,NEWXYZ,.FALSE., & 
 28:   &         MFLAG,EDUMMY,RMS2,EREAL,RMS,BFGSSTEPS,.TRUE.,ITDONE,PTEST,VNEW,.TRUE.,.FALSE.) 
 29:    IF (MFLAG) WRITE(*,'(A,I6,A,G20.10)') 'climber> converged minimum with energy: ',EDUMMY,' iterations: ',ITDONE 
 30:    IF (.NOT.MFLAG) WRITE(*,'(A)') 'climber> optimisation did not converge' 
 31:  
 32:    CALL MINPERMDIST(NEWXYZ,QEND,NATOMS,DEBUG,PARAM1,PARAM2,PARAM3,BULKT,TWOD,DISTANCE,DIST2,RIGIDBODY,RMAT) 
 33:    IF (DISTANCE.LE.CLIMBERCONV) THEN 
 34:       NSTRUCTURES=NSTRUCTURES+1 
 35:       SAVEDXYZ((NSTRUCTURES-1)*3*NATOMS+1:NSTRUCTURES*3*NATOMS)=NEWXYZ(1:3*NATOMS) 
 36:       GOTO 57 
 37:    ENDIF 
 38:    IF (ABS(DISTANCE-STARTDIST).GE.1.5*STARTDIST/CLIMBERSTEPS) THEN  
 39:       WRITE(*,'(A,F15.5,A)') 'climber> structure accepted, Kspring=',CLIMBERSPRING,', decrease Kspring for next move' 
 40:       !save structure 
 41:       NSTRUCTURES=NSTRUCTURES+1 
 42:       SAVEDXYZ((NSTRUCTURES-1)*3*NATOMS+1:NSTRUCTURES*3*NATOMS)=NEWXYZ(1:3*NATOMS) 
 43:       MOVINGXYZ=NEWXYZ 
 44:       CLIMBERSPRING=CLIMBERSPRING*RED_SPRING 
 45:       GOTO 56 
 46:    ELSE 
 47:       WRITE(*,'(A)') 'climber> structure not accepted, increase Kspring' 
 48:       CLIMBERSPRING=CLIMBERSPRING*INC_SPRING 
 49:       GOTO 56 
 50:    ENDIF 
 51: 57 WRITE(*,'(A)') 'climber> structures converged' 
 52:    NSTRUCTURES=NSTRUCTURES+1 
 53:    SAVEDXYZ((NSTRUCTURES-1)*3*NATOMS+1:NSTRUCTURES*3*NATOMS)=QEND(1:3*NATOMS) 
 54:    CALL CLIMBEROUT(NSTRUCTURES) 
 55:    RETURN 
 56: ENDDO 
 57: END SUBROUTINE CLIMBERINT 
 58:  
 59: SUBROUTINE CLIMBEROUT(NSTRUCTURES) 
 60: USE COMMONS, ONLY: NATOMS 
 61: USE PORFUNCS 
 62: USE CLIMBERCOMMONS 
 63: IMPLICIT NONE 
 64: INTEGER :: J1,J2, GETUNIT, CLUNIT, NSTRUCTURES 
 65:  
 66: CLUNIT=GETUNIT() 
 67: OPEN(UNIT=CLUNIT,FILE='climber.xyz',STATUS='UNKNOWN') 
 68: DO J1=1,NSTRUCTURES 
 69:       WRITE(CLUNIT, '(I6)') NATOMS 
 70:       WRITE(CLUNIT, '(A)') 'points.xyz' 
 71:       DO J2 = 1, NATOMS 
 72:          WRITE(CLUNIT, '(3F20.10)') SAVEDXYZ((3*NATOMS*(J1-1)+3*J2-2):(3*NATOMS*(J1-1)+3*J2)) 
 73:       END DO 
 74: END DO 
 75: CLOSE(CLUNIT) 
 76: RETURN 
 77: END SUBROUTINE CLIMBEROUT 
 78:  
 79: SUBROUTINE CLIMBERINPUT() 
 80: USE CLIMBERCOMMONS 
 81: USE PORFUNCS 
 82: IMPLICIT NONE 
 83: INTEGER INPUNIT,GETUNIT,J1,NDUMMY,J2,J3 
 84: INTEGER , PARAMETER :: NWORDS=20 
 85: CHARACTER(100) :: ENTRY 
 86: CHARACTER(25) :: ENTRIES(NWORDS)='' 
 87:  
 88: INPUNIT=GETUNIT() 
 89: OPEN(INPUNIT,FILE='climber.constraints',STATUS='OLD',ACTION='READ') 
 90: READ(INPUNIT,'(I8)') NBBCONSTR 
 91: WRITE(*,'(A,I8)') 'climber> Number of C alpha for constraints: ',NBBCONSTR 
 92: ALLOCATE(BBCONSTR(NBBCONSTR)) 
 93: J1=NBBCONSTR/10 
 94: J1=J1+(NBBCONSTR-J1*10) 
 95: NDUMMY=1 
 96: DO J2=1,J1 
 97:    READ(INPUNIT,'(A)') ENTRY 
 98:    CALL READ_LINE(ENTRY,NWORDS,ENTRIES) 
 99:    J3=1 
100:    DO WHILE(J3.LE.10) 
101:       IF (NDUMMY.LE.NBBCONSTR) THEN 
102:          READ(ENTRIES(J3),'(I8)') BBCONSTR(NDUMMY) 
103:          NDUMMY=NDUMMY+1 
104:       END IF 
105:       J3=J3+1 
106:    END DO 
107: END DO 
108: READ(INPUNIT,'(I8)') NSCCONSTR 
109: WRITE(*,'(A,I8)') 'climber> Number of heavy atoms in sidechains for constraints: ', NSCCONSTR 
110: ALLOCATE(SCCONSTR(NSCCONSTR)) 
111: J1=NSCCONSTR/10 
112: J1=J1+(NSCCONSTR-J1*10) 
113: NDUMMY=1 
114: DO J2=1,J1 
115:    READ(INPUNIT,'(A)') ENTRY 
116:    CALL READ_LINE(ENTRY,NWORDS,ENTRIES) 
117:    J3=1 
118:    DO WHILE(J3.LE.10) 
119:       IF (NDUMMY.LE.NSCCONSTR) THEN 
120:          READ(ENTRIES(J3),'(I8)') SCCONSTR(NDUMMY) 
121:          NDUMMY=NDUMMY+1 
122:       END IF 
123:       J3=J3+1 
124:    END DO 
125: END DO 
126: CLOSE(INPUNIT) 
127: RETURN 
128: END SUBROUTINE CLIMBERINPUT 
129:  
130: SUBROUTINE CLIMBERPAIRCONSTR(QSTART,QEND) 
131: USE COMMONS, ONLY: NATOMS,DEBUG 
132: USE CLIMBERCOMMONS 
133: IMPLICIT NONE 
134: INTEGER :: J1,J2,J3,J4 
135: DOUBLE PRECISION :: DS,DF,QSTART(3*NATOMS),QEND(3*NATOMS) 
136:  
137: CONSTRATOMS(1:3*NATOMS)=.FALSE. 
138: ALLOCATE(PAIRCONSTR(10000,2)) 
139: ALLOCATE(TARGETDIST(10000)) 
140: NCONSTR=0 
141: DO J1=1,(NBBCONSTR-1) 
142:    J3=BBCONSTR(J1) 
143:    DO J2=(J1+1),NBBCONSTR 
144:       J4=BBCONSTR(J2) 
145:       DS=SQRT((QSTART(3*(J3-1)+1)-QSTART(3*(J4-1)+1))**2 & 
146:   &          +(QSTART(3*(J3-1)+2)-QSTART(3*(J4-1)+2))**2 & 
147:   &          +(QSTART(3*(J3-1)+3)-QSTART(3*(J4-1)+3))**2)  
148:       DF=SQRT((QEND(3*(J3-1)+1)-QEND(3*(J4-1)+1))**2 & 
149:   &          +(QEND(3*(J3-1)+2)-QEND(3*(J4-1)+2))**2 & 
150:   &          +(QEND(3*(J3-1)+3)-QEND(3*(J4-1)+3))**2)  
151:       IF (DEBUG) WRITE(*,'(A,2I8,A,2F15.5)') 'climber> Atoms: ',J3,J4,' distances in endpoints: ',DS,DF 
152:       IF ((DS.GT.10.0).AND.(DF.GT.10.0)) THEN 
153:          NCONSTR=NCONSTR+1 
154:          PAIRCONSTR(NCONSTR,1)=J3 
155:          PAIRCONSTR(NCONSTR,2)=J4 
156:          TARGETDIST(NCONSTR)=DF 
157:          WRITE(*,'(A,2I8,A,I8)')  'climber> New constraint for atoms: ',J3,J4,' Number of constraints: ',NCONSTR 
158:          CONSTRATOMS(J3)=.TRUE. 
159:          CONSTRATOMS(J4)=.TRUE. 
160:       END IF 
161:    END DO 
162: END DO 
163: DO J1=1,(NSCCONSTR-1) 
164:    J3=SCCONSTR(J1) 
165:    DO J2=(J1+1),NSCCONSTR 
166:       J4=SCCONSTR(J2) 
167:       DS=SQRT((QSTART(3*(J3-1)+1)-QSTART(3*(J4-1)+1))**2 & 
168:   &          +(QSTART(3*(J3-1)+2)-QSTART(3*(J4-1)+2))**2 & 
169:   &          +(QSTART(3*(J3-1)+3)-QSTART(3*(J4-1)+3))**2) 
170:       DF=SQRT((QEND(3*(J3-1)+1)-QEND(3*(J4-1)+1))**2 & 
171:   &          +(QEND(3*(J3-1)+2)-QEND(3*(J4-1)+2))**2 & 
172:   &          +(QEND(3*(J3-1)+3)-QEND(3*(J4-1)+3))**2)     
173:       IF (DEBUG) WRITE(*,'(A,2I8,A,2F15.5)') 'climber> Atoms: ',J3,J4,' distances in endpoints: ',DS,DF 
174:       IF ((DS.LT.10.0).AND.(DF.LT.10.0)) THEN 
175:          NCONSTR=NCONSTR+1 
176:          PAIRCONSTR(NCONSTR,1)=J3 
177:          PAIRCONSTR(NCONSTR,2)=J4 
178:          TARGETDIST(NCONSTR)=DF 
179:          WRITE(*,'(A,2I8,A,I8)')  'climber> New constraint for atoms: ',J3,J4,' Number of constraints: ',NCONSTR 
180:          CONSTRATOMS(J3)=.TRUE. 
181:          CONSTRATOMS(J4)=.TRUE. 
182:       END IF 
183:    END DO 
184: END DO 
185: END SUBROUTINE CLIMBERPAIRCONSTR 
186:  
187: SUBROUTINE CLIMBERENERGY(XYZ,ERESTRAINT) 
188: USE COMMONS, ONLY: NATOMS,DEBUG 
189: USE CLIMBERCOMMONS 
190: USE KEY,ONLY:CLIMBERSPRING 
191: IMPLICIT NONE 
192: DOUBLE PRECISION, INTENT(IN) :: XYZ(3*NATOMS) 
193: DOUBLE PRECISION :: DIST, ERESTRAINT, DISTSUM 
194: INTEGER :: J1 
195:  
196: DISTSUM=0 
197: DO J1=1,NCONSTR 
198:    DIST=SQRT((XYZ(3*(PAIRCONSTR(J1,1)-1)+1)-XYZ(3*(PAIRCONSTR(J1,2)-1)+1))**2 + & 
199:  &           (XYZ(3*(PAIRCONSTR(J1,1)-1)+2)-XYZ(3*(PAIRCONSTR(J1,2)-1)+2))**2 + & 
200:  &           (XYZ(3*(PAIRCONSTR(J1,1)-1)+3)-XYZ(3*(PAIRCONSTR(J1,2)-1)+3))**2) 
201:    IF (DEBUG) THEN 
202:       WRITE(*,'(A,2I8,A,F15.5)') 'climberenergy> Atoms: ',(PAIRCONSTR(J1,1)),(PAIRCONSTR(J1,2)),', distance: ', DIST 
203:    ENDIF 
204:    DISTSUM=DISTSUM+(DIST-TARGETDIST(J1))**2 
205: ENDDO 
206: ERESTRAINT=CLIMBERSPRING*SQRT(DISTSUM) 
207: RETURN 
208: END SUBROUTINE CLIMBERENERGY 
209:  
210:  
211: SUBROUTINE CLIMBERGRADIENT(XYZ,CLIMBER_GRADATOMS) 
212: USE CLIMBERCOMMONS 
213: USE COMMONS, ONLY : NATOMS 
214: USE KEY,ONLY : CLIMBERSPRING 
215: IMPLICIT NONE 
216: DOUBLE PRECISION :: XYZ(3*NATOMS),CLIMBER_GRADATOMS(3*NATOMS),ERESTRAINT,GRAD,SUMGRAD,DIST 
217: INTEGER :: J1,J2 
218:  
219: DO J1=1,NATOMS 
220:    IF (.NOT.CONSTRATOMS(J1)) THEN 
221:       CLIMBER_GRADATOMS(3*J1-2:3*J1)=0.0 
222:    ELSE 
223:       CALL CLIMBERENERGY(XYZ,ERESTRAINT) 
224:       GRAD=CLIMBERSPRING**2/ERESTRAINT 
225:       SUMGRAD=0.0 
226:       DO J2=1,NCONSTR 
227:          IF (J1.EQ.PAIRCONSTR(J2,1)) THEN 
228:             DIST=SQRT((XYZ(3*(PAIRCONSTR(J1,1)-1)+1)-XYZ(3*(PAIRCONSTR(J1,2)-1)+1))**2 + & 
229:  &                    (XYZ(3*(PAIRCONSTR(J1,1)-1)+2)-XYZ(3*(PAIRCONSTR(J1,2)-1)+2))**2 + & 
230:  &                    (XYZ(3*(PAIRCONSTR(J1,1)-1)+3)-XYZ(3*(PAIRCONSTR(J1,2)-1)+3))**2) 
231:             SUMGRAD=SUMGRAD+DIST 
232:          ELSE IF (J1.EQ.PAIRCONSTR(J2,2)) THEN 
233:             DIST=SQRT((XYZ(3*(PAIRCONSTR(J1,1)-1)+1)-XYZ(3*(PAIRCONSTR(J1,2)-1)+1))**2 + & 
234:  &                    (XYZ(3*(PAIRCONSTR(J1,1)-1)+2)-XYZ(3*(PAIRCONSTR(J1,2)-1)+2))**2 + & 
235:  &                    (XYZ(3*(PAIRCONSTR(J1,1)-1)+3)-XYZ(3*(PAIRCONSTR(J1,2)-1)+3))**2) 
236:             SUMGRAD=SUMGRAD-DIST 
237:          ENDIF 
238:       ENDDO 
239:       GRAD=GRAD*SUMGRAD 
240:       CLIMBER_GRADATOMS(3*J1-2:3*J1)=-GRAD !minus or plus??       
241:    ENDIF 
242: ENDDO 
243: RETURN 
244: END SUBROUTINE CLIMBERGRADIENT 
245:  
246:  
247: SUBROUTINE CLIMBER_ENERGY_GRADIENT(ATOMS,COORDS,CLIMBER_ENERGY,CLIMBER_GRADATOMS) 
248:  
249: USE COMMONS, ONLY: NATOMS,DEBUG 
250: IMPLICIT NONE 
251: DOUBLE PRECISION :: COORDS(3*NATOMS), CLIMBER_ENERGY, CLIMBER_GRADATOMS(3*NATOMS) 
252: INTEGER :: ATOMS 
253:  
254: CALL CLIMBERENERGY(COORDS,CLIMBER_ENERGY) 
255: IF (DEBUG) WRITE(*,'(A,G20.10)') 'climber> Restraint energy: ',CLIMBER_ENERGY 
256: CALL CLIMBERGRADIENT(COORDS,CLIMBER_GRADATOMS) 
257: RETURN 
258: END SUBROUTINE CLIMBER_ENERGY_GRADIENT 
259:  
260:  
261: SUBROUTINE READ_LINE(LINE,NWORDS,WORDSOUT) 
262:       CHARACTER(*), INTENT(IN) :: LINE 
263:       INTEGER, INTENT(IN) :: NWORDS 
264:       CHARACTER(*), DIMENSION(NWORDS), INTENT(OUT) :: WORDSOUT 
265:       INTEGER:: J1,START_IND,END_IND,J2 
266:       CHARACTER(25) :: WORD 
267:       START_IND=0 
268:       END_IND=0 
269:       J1=1 
270:       J2=0 
271:       DO WHILE(J1.LE.LEN(LINE)) 
272:           IF ((START_IND.EQ.0).AND.(LINE(J1:J1).NE.' ')) THEN 
273:              START_IND=J1 
274:           ENDIF 
275:           IF (START_IND.GT.0) THEN 
276:              IF (LINE(J1:J1).EQ.' ') END_IND=J1-1 
277:              IF (J1.EQ.LEN(LINE)) END_IND=J1 
278:              IF (END_IND.GT.0) THEN 
279:                 J2=J2+1 
280:                 WORD=LINE(START_IND:END_IND) 
281:                 WORDSOUT(J2)=TRIM(WORD) 
282:                 START_IND=0 
283:                 END_IND=0 
284:              ENDIF 
285:           ENDIF 
286:           J1=J1+1 
287:       ENDDO 
288:       RETURN 
289: END SUBROUTINE READ_LINE 
290:  


r30049/key.f90 2016-03-16 18:34:26.875609046 +0000 r30048/key.f90 2016-03-16 18:34:28.043621068 +0000
295:       !ds656> Mie field(s) for modelling substrate effects295:       !ds656> Mie field(s) for modelling substrate effects
296:       LOGICAL :: MIEFT, MIEF_CUTT, MIEF_PBCT296:       LOGICAL :: MIEFT, MIEF_CUTT, MIEF_PBCT
297:       CHARACTER(LEN=130) :: MIEF_FILENAME297:       CHARACTER(LEN=130) :: MIEF_FILENAME
298:       INTEGER :: MIEF_NSITES,MIEF_N,MIEF_M298:       INTEGER :: MIEF_NSITES,MIEF_N,MIEF_M
299:       DOUBLE PRECISION :: MIEF_BOX(3), MIEF_RCUT299:       DOUBLE PRECISION :: MIEF_BOX(3), MIEF_RCUT
300:       DOUBLE PRECISION, ALLOCATABLE :: MIEF_EPS(:), MIEF_SIG(:), &300:       DOUBLE PRECISION, ALLOCATABLE :: MIEF_EPS(:), MIEF_SIG(:), &
301:            MIEF_SITES(:,:), MIEF_U_RCUT(:), MIEF_DUDR_RCUT(:)301:            MIEF_SITES(:,:), MIEF_U_RCUT(:), MIEF_DUDR_RCUT(:)
302:       302:       
303: ! AMBER 12 variables303: ! AMBER 12 variables
304:       LOGICAL :: AMBER12T304:       LOGICAL :: AMBER12T
305:       LOGICAL :: CLIMBERT 
306:       INTEGER :: CLIMBERSTEPS 
307:       DOUBLE PRECISION :: CLIMBERCONV,CLIMBERSPRING 
308:       INTEGER, DIMENSION(:,:), ALLOCATABLE :: BONDS 
309: 305: 
310:       DOUBLE PRECISION, ALLOCATABLE ::  MLPDAT(:,:)306:       DOUBLE PRECISION, ALLOCATABLE ::  MLPDAT(:,:)
311:       INTEGER, ALLOCATABLE ::  MLPOUTCOME(:)307:       INTEGER, ALLOCATABLE ::  MLPOUTCOME(:)
312: 308: 
313: 309: 
314: END MODULE KEY310: END MODULE KEY


r30049/keywords.f 2016-03-16 18:34:27.067611025 +0000 r30048/keywords.f 2016-03-16 18:34:28.243623104 +0000
885:          MCPATHGWS=0.3D0885:          MCPATHGWS=0.3D0
886:          MCPATHGWQ=0.00025D0886:          MCPATHGWQ=0.00025D0
887:          COLLAGENOP=.FALSE.887:          COLLAGENOP=.FALSE.
888: 888: 
889:          DUMPFRQST=.FALSE.889:          DUMPFRQST=.FALSE.
890: 890: 
891:          CUDAT=.FALSE.891:          CUDAT=.FALSE.
892:          CUDAPOT=' '892:          CUDAPOT=' '
893:          CUDATIMET=.FALSE.893:          CUDATIMET=.FALSE.
894: 894: 
895:          CLIMBERT=.FALSE. 
896:          CLIMBERSTEPS=20 
897:          CLIMBERCONV=0.2 
898:          CLIMBERSPRING=5.0 
899:  
900: !895: !
901: ! Neural network potential896: ! Neural network potential
902: !897: !
903:          MLP3T=.FALSE.898:          MLP3T=.FALSE.
904:          MLPB3T=.FALSE.899:          MLPB3T=.FALSE.
905:          MLPPROB=.FALSE.900:          MLPPROB=.FALSE.
906:          MLPDONE=.FALSE.901:          MLPDONE=.FALSE.
907:          MLPNORM=.FALSE.902:          MLPNORM=.FALSE.
908:          MLPLAMBDA=0.0D0903:          MLPLAMBDA=0.0D0
909:          MLPDATSTART=1904:          MLPDATSTART=1
1653:          ELSE IF (WORD.EQ.'INE_NEW') THEN1648:          ELSE IF (WORD.EQ.'INE_NEW') THEN
1654:             CLSTRINGTST=.TRUE.1649:             CLSTRINGTST=.TRUE.
1655:             CLSTRINGT=.TRUE.1650:             CLSTRINGT=.TRUE.
1656:             EVOLVESTRINGT = .TRUE.1651:             EVOLVESTRINGT = .TRUE.
1657:             CALL READF(STTSRMSCONV)1652:             CALL READF(STTSRMSCONV)
1658:             CALL READI(ST_TSSTEP)1653:             CALL READI(ST_TSSTEP)
1659:             CALL READF(LAN_DIST)1654:             CALL READF(LAN_DIST)
1660:             CALL READI(LANSTEP)1655:             CALL READI(LANSTEP)
1661:             CALL READF(LANCONV)1656:             CALL READF(LANCONV)
1662:             CALL READF(LANFACTOR)1657:             CALL READF(LANFACTOR)
1663: ! kr366 climber input 
1664:          ELSE IF (WORD.EQ.'CLIMBER') THEN 
1665:             CLIMBERT=.TRUE. 
1666:             CALL READI(CLIMBERSTEPS) 
1667:             CALL READF(CLIMBERCONV) 
1668:             CALL READF(CLIMBERSPRING) 
1669:  
1670:          ELSE IF (WORD.EQ.'CLSTRING') THEN1658:          ELSE IF (WORD.EQ.'CLSTRING') THEN
1671:             CLSTRINGT=.TRUE.1659:             CLSTRINGT=.TRUE.
1672:             EVOLVESTRINGT = .TRUE.1660:             EVOLVESTRINGT = .TRUE.
1673:          ELSE IF (WORD.EQ.'COLLAGENOP') THEN1661:          ELSE IF (WORD.EQ.'COLLAGENOP') THEN
1674:             COLLAGENOP=.TRUE.1662:             COLLAGENOP=.TRUE.
1675:             CALL READI(COLLINDICES(1))1663:             CALL READI(COLLINDICES(1))
1676:             CALL READI(COLLINDICES(2))1664:             CALL READI(COLLINDICES(2))
1677:             CALL READI(COLLINDICES(3))1665:             CALL READI(COLLINDICES(3))
1678:             CALL READI(COLLINDICES(4))1666:             CALL READI(COLLINDICES(4))
1679: 1667: 


r30049/OPTIM.F 2016-03-16 18:34:26.287602999 +0000 r30048/OPTIM.F 2016-03-16 18:34:27.463615093 +0000
637:                      CALL GEOPT(FNAMEF,EFNAME,FIN,VECS,MFLAG,ENERGY,EVALMIN,VNEW)637:                      CALL GEOPT(FNAMEF,EFNAME,FIN,VECS,MFLAG,ENERGY,EVALMIN,VNEW)
638:                   ENDIF638:                   ENDIF
639:                   REOPTIMISEENDPOINTS=.FALSE.639:                   REOPTIMISEENDPOINTS=.FALSE.
640:                   GOTO 555640:                   GOTO 555
641:                ELSE641:                ELSE
642:                   CALL TSUMMARY642:                   CALL TSUMMARY
643:                   CALL FLUSH(6)643:                   CALL FLUSH(6)
644:                   GOTO 765644:                   GOTO 765
645:                ENDIF645:                ENDIF
646:             ENDIF646:             ENDIF
647:             IF (CLIMBERT) THEN 
648:                CALL CLIMBERINT(Q,FIN) 
649:                RETURN 
650:             ENDIF 
651:             CALL MINPERMDIST(Q,FIN,NATOMS,DEBUG,PARAM1,PARAM2,PARAM3,BULKT,TWOD,DIST,DIST2,RIGIDBODY,RMAT)647:             CALL MINPERMDIST(Q,FIN,NATOMS,DEBUG,PARAM1,PARAM2,PARAM3,BULKT,TWOD,DIST,DIST2,RIGIDBODY,RMAT)
652:             IF (PERMDISTINIT) PERMDIST=.FALSE.648:             IF (PERMDISTINIT) PERMDIST=.FALSE.
653:             IF (ATOMMATCHINIT) ATOMMATCHDIST=.FALSE.649:             IF (ATOMMATCHINIT) ATOMMATCHDIST=.FALSE.
654:             IF (BISECTT) THEN650:             IF (BISECTT) THEN
655:                CALL BISECT_OPT(NATOMS,EINITIAL,Q,EFINAL,FIN,DIST)651:                CALL BISECT_OPT(NATOMS,EINITIAL,Q,EFINAL,FIN,DIST)
656:             ELSE652:             ELSE
657:                IF (ALLOCATED(SAVES)) DEALLOCATE(SAVES)653:                IF (ALLOCATED(SAVES)) DEALLOCATE(SAVES)
658:                IF (ALLOCATED(SAVEF)) DEALLOCATE(SAVEF)654:                IF (ALLOCATED(SAVEF)) DEALLOCATE(SAVEF)
659:                ALLOCATE(SAVES(NOPT),SAVEF(NOPT))655:                ALLOCATE(SAVES(NOPT),SAVEF(NOPT))
660:                SAVES(1:NOPT)=Q(1:NOPT)656:                SAVES(1:NOPT)=Q(1:NOPT)


r30049/potential.f 2016-03-16 18:34:27.267613079 +0000 r30048/potential.f 2016-03-16 18:34:28.443625169 +0000
 62:          CHARACTER(LEN=132) STRING 62:          CHARACTER(LEN=132) STRING
 63:          COMMON /STRINGS/ ESTRING, GPSTRING, NSTRING, FSTRING 63:          COMMON /STRINGS/ ESTRING, GPSTRING, NSTRING, FSTRING
 64:          DOUBLE PRECISION C1, C2, C3, IZ, ROT, EDISP, EIND 64:          DOUBLE PRECISION C1, C2, C3, IZ, ROT, EDISP, EIND
 65:          LOGICAL ETEST, SSTEST, YESNO, AMIDEFAIL,GAUSSIANTEST 65:          LOGICAL ETEST, SSTEST, YESNO, AMIDEFAIL,GAUSSIANTEST
 66:          COMMON /CAS/ AMAT, AINV, NELEMENTS, NTYPE 66:          COMMON /CAS/ AMAT, AINV, NELEMENTS, NTYPE
 67:          COMMON /PCALL/ NPCALL, ECALL, FCALL, SCALL, ETIME, FTIME, STIME 67:          COMMON /PCALL/ NPCALL, ECALL, FCALL, SCALL, ETIME, FTIME, STIME
 68:          LOGICAL KNOWE, KNOWG, KNOWH 68:          LOGICAL KNOWE, KNOWG, KNOWH
 69:          COMMON /KNOWN/ KNOWE, KNOWG, KNOWH 69:          COMMON /KNOWN/ KNOWE, KNOWG, KNOWH
 70:  70: 
 71:          DOUBLE PRECISION VPLUS(3*NATOMS), VMINUS(3*NATOMS), DIFF, EPLUS1, EPLUS2, EMINUS1, EMINUS2 71:          DOUBLE PRECISION VPLUS(3*NATOMS), VMINUS(3*NATOMS), DIFF, EPLUS1, EPLUS2, EMINUS1, EMINUS2
 72:          DOUBLE PRECISION :: CLIMBER_ENERGY,CLIMBER_GRADATOMS(3*NATOMS) 
 73:  72: 
 74:          ! double precision upperE, lowerE, deltaCoord, numericalGrad(3*NATOMS), RMSdiff 73:          ! double precision upperE, lowerE, deltaCoord, numericalGrad(3*NATOMS), RMSdiff
 75:          ! double precision dummyGrad(3*NATOMS), upperGrad(3*NATOMS), lowerGrad(3*NATOMS) 74:          ! double precision dummyGrad(3*NATOMS), upperGrad(3*NATOMS), lowerGrad(3*NATOMS)
 76:          ! double precision numericalSD, tempHess(3*NATOMS,3*NATOMS) 75:          ! double precision numericalSD, tempHess(3*NATOMS,3*NATOMS)
 77:          double precision HESSDUM(NATOMS,NATOMS) 76:          double precision HESSDUM(NATOMS,NATOMS)
 78:  77: 
 79:          ! sf344> NAB & AMBER additions 78:          ! sf344> NAB & AMBER additions
 80:          DOUBLE PRECISION,dimension(:),allocatable  ::  temphess 79:          DOUBLE PRECISION,dimension(:),allocatable  ::  temphess
 81:          DOUBLE PRECISION  :: GRAD1(3*NATOMS) 80:          DOUBLE PRECISION  :: GRAD1(3*NATOMS)
 82:          integer i,j,k 81:          integer i,j,k
3045:             END IF3044:             END IF
3046:             IF (CUDAT) THEN3045:             IF (CUDAT) THEN
3047:                ! This call copies CPU coordinates to GPU, calculates energy/gradient and copies energy/gradient back to CPU3046:                ! This call copies CPU coordinates to GPU, calculates energy/gradient and copies energy/gradient back to CPU
3048:                CALL CUDA_ENEGRAD_WRAPPER(NATOMS, COORDS, ENERGY, GRADATOMS)3047:                CALL CUDA_ENEGRAD_WRAPPER(NATOMS, COORDS, ENERGY, GRADATOMS)
3049:             ELSE3048:             ELSE
3050:                CALL AMBER12_ENERGY_AND_GRADIENT(NATOMS,3049:                CALL AMBER12_ENERGY_AND_GRADIENT(NATOMS,
3051:      &                                          COORDS,3050:      &                                          COORDS,
3052:      &                                          ENERGY,3051:      &                                          ENERGY,
3053:      &                                          GRADATOMS,3052:      &                                          GRADATOMS,
3054:      &                                          ENERGY_DECOMP)3053:      &                                          ENERGY_DECOMP)
3055:                IF (CLIMBERT) THEN 
3056:                   CALL CLIMBER_ENERGY_GRADIENT(NATOMS,COORDS,CLIMBER_ENERGY,CLIMBER_GRADATOMS) 
3057:                   GRADATOMS=GRADATOMS+CLIMBER_GRADATOMS 
3058:                   ENERGY=ENERGY+CLIMBER_ENERGY 
3059:                ENDIF 
3060:             END IF3054:             END IF
3061:             VNEW(1:3*NATOMS) = GRADATOMS(:)3055:             VNEW(1:3*NATOMS) = GRADATOMS(:)
3062: ! Calculate the numerical hessian3056: ! Calculate the numerical hessian
3063:             IF (STEST) THEN3057:             IF (STEST) THEN
3064:                IF (.NOT. ALLOCATED(HESS)) ALLOCATE(HESS(3*NATOMS, 3*NATOMS))3058:                IF (.NOT. ALLOCATED(HESS)) ALLOCATE(HESS(3*NATOMS, 3*NATOMS))
3065:                CALL AMBER12_NUM_HESS(NATOMS, COORDS, DELTA=1.0D-5, HESSIAN=HESS(:, :))3059:                CALL AMBER12_NUM_HESS(NATOMS, COORDS, DELTA=1.0D-5, HESSIAN=HESS(:, :))
3066:             END IF3060:             END IF
3067:             IF (PTEST) THEN3061:             IF (PTEST) THEN
3068:                WRITE(*,10) ' potential> Energy for last cycle=',ENERGY,' kcal/mol'3062:                WRITE(*,10) ' potential> Energy for last cycle=',ENERGY,' kcal/mol'
3069:                WRITE(ESTRING,10) 'Energy for last cycle=',ENERGY,' kcal/mol'3063:                WRITE(ESTRING,10) 'Energy for last cycle=',ENERGY,' kcal/mol'


legend
Lines Added 
Lines changed
 Lines Removed

hdiff - version: 2.1.0