hdiff output

r28922/bulkmindist.f90 2015-11-17 23:34:55.550054353 +0000 r28921/bulkmindist.f90 2015-11-17 23:34:55.754057087 +0000
 15: !   You should have received a copy of the GNU General Public License 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 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 17: !   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 18: ! 18: !
 19: ! 19: !
 20: ! This subroutine should match permutational isomers that correspond to the same orientation 20: ! This subroutine should match permutational isomers that correspond to the same orientation
 21: ! of the unit cell. We would have to consider all the cell symmetries as well to 21: ! of the unit cell. We would have to consider all the cell symmetries as well to
 22: ! identify all possible equivalent permutation-inversion isomers. 22: ! identify all possible equivalent permutation-inversion isomers.
 23: ! 23: !
 24: SUBROUTINE BULKMINDIST(DUMMYB,DUMMYA,XBEST, NATOMS,DISTANCE,TWOD,DEBUG,BOXLX,BOXLY,BOXLZ,PITEST,RESETA, TNMATCH, BMTEST) 24: SUBROUTINE BULKMINDIST(DUMMYB,DUMMYA,XBEST, NATOMS,DISTANCE,TWOD,DEBUG,BOXLX,BOXLY,BOXLZ,PITEST,RESETA, TNMATCH, BMTEST)
 25: USE COMMONS,ONLY : NPERMGROUP, NPERMSIZE, PERMGROUP, SETS, NSETS, GEOMDIFFTOL, ATOMMATCHFULL 25: USE COMMONS,ONLY : NPERMGROUP, NPERMSIZE, PERMGROUP, GEOMDIFFTOL, ATOMMATCHFULL
 26:  26: 
 27: IMPLICIT NONE 27: IMPLICIT NONE
 28: INTEGER J1, NATOMS, NPMIN, NGMIN, J2, PERM(NATOMS), PBEST(NATOMS), NDUMMY, NMATCHED, PATOMS, J3, J4, NMBEST, ND1 28: INTEGER J1, NATOMS, NPMIN, NGMIN, J2, PERM(NATOMS), PBEST(NATOMS), NDUMMY, NMATCHED, PATOMS, J3, J4, NMBEST, ND1
 29: INTEGER NMATCHSV, J5, J6, LPERM(NATOMS), SAMEPERM(NATOMS), NEWPERM(NATOMS), NREP, NREP2 29: INTEGER NMATCHSV, J5, J6, LPERM(NATOMS), NREP, NREP2
 30: DOUBLE PRECISION DUMMYB(3*NATOMS),DUMMYA(3*NATOMS),DISTANCE,BOXLX,BOXLY,BOXLZ,XSHIFT,YSHIFT,ZSHIFT,XTEMP(3*NATOMS) 30: DOUBLE PRECISION DUMMYB(3*NATOMS),DUMMYA(3*NATOMS),DISTANCE,BOXLX,BOXLY,BOXLZ,XSHIFT,YSHIFT,ZSHIFT,XTEMP(3*NATOMS)
 31: DOUBLE PRECISION XBEST(3*NATOMS), DMIN, DTOTAL, DIST, GDSQ, SAVECOORDS(3) 31: DOUBLE PRECISION XBEST(3*NATOMS), DMIN, DTOTAL, DIST, GDSQ
 32: DOUBLE PRECISION DIST2, LDISTANCE, WORSTRAD  32: DOUBLE PRECISION DIST2, LDISTANCE, WORSTRAD 
 33: LOGICAL TWOD,DEBUG,PITEST,SAMEMIN,RESETA, TNMATCH, BMTEST, BMTESTLOCAL  33: LOGICAL TWOD,DEBUG,PITEST,SAMEMIN,RESETA, TNMATCH, BMTEST, BMTESTLOCAL 
 34: COMMON /BULKSHIFT/ XSHIFT,YSHIFT,ZSHIFT 34: COMMON /BULKSHIFT/ XSHIFT,YSHIFT,ZSHIFT
 35: SAVE NMATCHSV 35: SAVE NMATCHSV
 36:  36: 
 37: IF (.NOT.TNMATCH) NMATCHSV=0  37: IF (.NOT.TNMATCH) NMATCHSV=0 
 38: ! 38: !
 39: ! Find smallest group of permutable atoms. 39: ! Find smallest group of permutable atoms.
 40: ! Translate first atom of group to all positions and then find nearest atom within 40: ! Translate first atom of group to all positions and then find nearest atom within
 41: ! the same group for every other atom. 41: ! the same group for every other atom.
 64:    ENDIF 64:    ENDIF
 65: ENDDO 65: ENDDO
 66: ND1=0 66: ND1=0
 67: ! ND1 is an offset index for the start of this permutational group 67: ! ND1 is an offset index for the start of this permutational group
 68: DO J1=1,NGMIN-1 68: DO J1=1,NGMIN-1
 69:    ND1=ND1+NPERMSIZE(J1) 69:    ND1=ND1+NPERMSIZE(J1)
 70: ENDDO 70: ENDDO
 71: IF (DEBUG) PRINT '(3(A,I6))',' bulkmindist> Smallest group of permutable atoms is number ',NGMIN,' with ',NPMIN,' members' 71: IF (DEBUG) PRINT '(3(A,I6))',' bulkmindist> Smallest group of permutable atoms is number ',NGMIN,' with ',NPMIN,' members'
 72: NREP=0 72: NREP=0
 73: NREP2=0 73: NREP2=0
 74:  
 75: ! Cycle through all atoms in the smallest group and superimpose their position in structure A over the position of the 74: ! Cycle through all atoms in the smallest group and superimpose their position in structure A over the position of the
 76: ! first atom of the same group in structure B. 75: ! first atom of the same group in structure B.
 77: outer: DO J1=ND1+1,ND1+NPMIN 76: outer: DO J1=ND1+1,ND1+NPMIN
 78: !  USED(1:NATOMS)=.FALSE. 77: !  USED(1:NATOMS)=.FALSE.
 79:    J2=PERMGROUP(J1) 78:    J2=PERMGROUP(J1)
 80:  
 81:    ! Perform the superposition 
 82:    XSHIFT=DUMMYA(3*(J2-1)+1)-DUMMYB(3*(PERMGROUP(ND1+1))+1)-BOXLX*NINT((DUMMYA(3*(J2-1)+1)-DUMMYB(3*(PERMGROUP(ND1+1))+1))/BOXLX) 79:    XSHIFT=DUMMYA(3*(J2-1)+1)-DUMMYB(3*(PERMGROUP(ND1+1))+1)-BOXLX*NINT((DUMMYA(3*(J2-1)+1)-DUMMYB(3*(PERMGROUP(ND1+1))+1))/BOXLX)
 83:    YSHIFT=DUMMYA(3*(J2-1)+2)-DUMMYB(3*(PERMGROUP(ND1+1))+2)-BOXLY*NINT((DUMMYA(3*(J2-1)+2)-DUMMYB(3*(PERMGROUP(ND1+1))+2))/BOXLY) 80:    YSHIFT=DUMMYA(3*(J2-1)+2)-DUMMYB(3*(PERMGROUP(ND1+1))+2)-BOXLY*NINT((DUMMYA(3*(J2-1)+2)-DUMMYB(3*(PERMGROUP(ND1+1))+2))/BOXLY)
 84:    IF (.NOT.TWOD) ZSHIFT=DUMMYA(3*(J2-1)+3)-DUMMYB(3*(PERMGROUP(ND1+1))+3)-BOXLZ*NINT((DUMMYA(3*(J2-1)+3)-DUMMYB(3*(PERMGROUP(ND1+1))+3))/BOXLZ) 81:    IF (.NOT.TWOD) ZSHIFT=DUMMYA(3*(J2-1)+3)-DUMMYB(3*(PERMGROUP(ND1+1))+3)-BOXLZ*NINT((DUMMYA(3*(J2-1)+3)-DUMMYB(3*(PERMGROUP(ND1+1))+3))/BOXLZ)
 85:    DO J2=1,NATOMS 82:    DO J2=1,NATOMS
 86:       XTEMP(3*(J2-1)+1)=DUMMYA(3*(J2-1)+1)-XSHIFT 83:       XTEMP(3*(J2-1)+1)=DUMMYA(3*(J2-1)+1)-XSHIFT
 87:       XTEMP(3*(J2-1)+2)=DUMMYA(3*(J2-1)+2)-YSHIFT 84:       XTEMP(3*(J2-1)+2)=DUMMYA(3*(J2-1)+2)-YSHIFT
 88:       IF (.NOT.TWOD) XTEMP(3*(J2-1)+3)=DUMMYA(3*(J2-1)+3)-ZSHIFT 85:       IF (.NOT.TWOD) XTEMP(3*(J2-1)+3)=DUMMYA(3*(J2-1)+3)-ZSHIFT
 89:    ENDDO 86:    ENDDO
 90:    NDUMMY=1 87:    NDUMMY=1
 91:  88:    PERM(1:NATOMS)=-1
 92:    ! Three arrays are used to keep track of the permutations. 
 93:    ! SAMEPERM is used to identify when two structures are identical up to a simple translation. Initially, all elements 
 94:    ! are set to -1, then each element is filled in with the index of the atom in XTEMP which best matches the corresponding 
 95:    ! atom in DUMMYB. If any non-trivial permutation is identified (i.e. SAMEPERM(J).NE.J for any J) then SAMEMIN is set 
 96:    ! to FALSE, i.e. we do not have identical structures. 
 97:    SAMEPERM(1:NATOMS)=-1 
 98:    ! NEWPERM is changed whenever a permutational match is found between an atom in DUMMYB and an atom in XTEMP, and unlike 
 99:    ! SAMEPERM it also takes into account secondary sets of permutable atoms which must be permuted every time the primary 
100:    ! atom is permuted. 
101:    ! PERM is used to calculate distances between atoms (see below). It is copied from NEWPERM at the end of each loop 
102:    ! over a permutational group, because otherwise some atom indices get completely overwritten which then makes matching 
103:    ! those atoms impossible. 
104:    DO J2 = 1,NATOMS 
105:        NEWPERM(J2) = J2 
106:        PERM(J2) = J2 
107:    ENDDO 
108:    NMATCHED=0 89:    NMATCHED=0
109:    DTOTAL=0.0D0 90:    DTOTAL=0.0D0
110:  91: 
111:    DO J2=1,NPERMGROUP  ! Cycle through permutational groups 92:    DO J2=1,NPERMGROUP  ! Cycle through permutational groups
112:       IF(J2.GT.1) NDUMMY=NDUMMY+NPERMSIZE(J2-1) 93:       IF(J2.GT.1) NDUMMY=NDUMMY+NPERMSIZE(J2-1)
113:       PATOMS=NPERMSIZE(J2) 94:       PATOMS=NPERMSIZE(J2)
114:       loop1: DO J3=1,PATOMS    ! for each atom in fixed structure B that is in group J2 95:       loop1: DO J3=1,PATOMS    ! for each atom in fixed structure B that is in group J2
115:          DMIN=1.0D100 96:          DMIN=1.0D100
116:          loop2: DO J4=1,PATOMS ! which is the closest atom in the same group for the structure in XTEMP (shifted A)? 97:          loop2: DO J4=1,PATOMS ! which is the closest atom in the same group for the structure in XTEMP (shifted A)?
117: !           IF (USED(PERMGROUP(NDUMMY+J4-1)) CYCLE loop2 ! to prevent false matches with large distance cutoffs 98: !           IF (USED(PERMGROUP(NDUMMY+J4-1)) CYCLE loop2 ! to prevent false matches with large distance cutoffs
118:  99:             DIST=(XTEMP(3*(PERMGROUP(NDUMMY+J4-1)-1)+1)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+1) &
119: ! When we have secondary sets, we need to ensure that these atoms are permuted whenever the corresponding primary atom100:  &  - BOXLX*NINT((XTEMP(3*(PERMGROUP(NDUMMY+J4-1)-1)+1)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+1))/BOXLX))**2 &
120: ! is permuted, and that when we try to match these secondary atoms between the two structures we compare their101:             &  + (XTEMP(3*(PERMGROUP(NDUMMY+J4-1)-1)+2)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+2) &
121: ! permuted positions rather than their original positions otherwise we won't find the correct match.102:  &  - BOXLY*NINT((XTEMP(3*(PERMGROUP(NDUMMY+J4-1)-1)+2)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+2))/BOXLY))**2 
122: ! So we apply PERM to the XTEMP indices.103:             IF (.NOT.TWOD) DIST=DIST+(XTEMP(3*(PERMGROUP(NDUMMY+J4-1)-1)+3)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+3) &
123:             DIST=(XTEMP(3*(PERM(PERMGROUP(NDUMMY+J4-1))-1)+1)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+1) &104:  &  - BOXLZ*NINT((XTEMP(3*(PERMGROUP(NDUMMY+J4-1)-1)+3)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+3))/BOXLZ))**2
124:  &  - BOXLX*NINT((XTEMP(3*(PERM(PERMGROUP(NDUMMY+J4-1))-1)+1)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+1))/BOXLX))**2 & 
125:             &  + (XTEMP(3*(PERM(PERMGROUP(NDUMMY+J4-1))-1)+2)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+2) & 
126:  &  - BOXLY*NINT((XTEMP(3*(PERM(PERMGROUP(NDUMMY+J4-1))-1)+2)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+2))/BOXLY))**2 
127:             IF (.NOT.TWOD) DIST=DIST+(XTEMP(3*(PERM(PERMGROUP(NDUMMY+J4-1))-1)+3)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+3) & 
128:  &  - BOXLZ*NINT((XTEMP(3*(PERM(PERMGROUP(NDUMMY+J4-1))-1)+3)-DUMMYB(3*(PERMGROUP(NDUMMY+J3-1)-1)+3))/BOXLZ))**2 
129: 105: 
130:             IF (DIST.LT.DMIN) THEN106:             IF (DIST.LT.DMIN) THEN
131:             ! Remember, only if PERMGROUP(NDUMMY+J3-1)=PERMGROUP(NDUMMY+J4-1) for all J3, J4 do we have identical isomers107:                  PERM(PERMGROUP(NDUMMY+J3-1))=PERMGROUP(NDUMMY+J4-1)
132:                  SAMEPERM(PERMGROUP(NDUMMY+J3-1))=PERMGROUP(NDUMMY+J4-1) 
133:  
134:                  DMIN=DIST108:                  DMIN=DIST
135:  
136:                  IF (DIST.LT.GDSQ) THEN109:                  IF (DIST.LT.GDSQ) THEN
137: !                    PRINT '(A,I6,A,I6,A,G20.10)',' match found between atom ',PERMGROUP(NDUMMY+J3-1), &110: !                 PRINT '(A,I6,A,I6,A,G20.10)',' match found between atom ',PERMGROUP(NDUMMY+J3-1), &
138: ! &                                            ' and ',PERMGROUP(NDUMMY+J4-1),' DIST=',DIST111: ! &                                            ' and ',PERMGROUP(NDUMMY+J4-1),' DIST=',DIST
139:  
140:                     ! NEWPERM only holds "exact" matches 
141:                     NEWPERM(PERMGROUP(NDUMMY+J3-1))=PERMGROUP(NDUMMY+J4-1) 
142:                     ! sn402: If there are any secondary groups attached to the atom we have just permuted, we should 
143:                     ! permute these as well. 
144:                     IF (NSETS(J2).GT.0) THEN 
145:                         DO J5=1,NSETS(J2) 
146:                             NEWPERM(SETS(PERMGROUP(NDUMMY+J3-1),J5))=SETS(PERMGROUP(NDUMMY+J4-1),J5) 
147:                         ENDDO 
148:                     ENDIF 
149:  
150:                    NMATCHED=NMATCHED+1112:                    NMATCHED=NMATCHED+1
151: 113: 
152:                    DTOTAL=DTOTAL+DMIN114:                    DTOTAL=DTOTAL+DMIN
153:                    IF (SAMEPERM(PERMGROUP(NDUMMY+J3-1)).NE.PERMGROUP(NDUMMY+J3-1)) SAMEMIN=.FALSE.115:                    IF (PERM(PERMGROUP(NDUMMY+J3-1)).NE.PERMGROUP(NDUMMY+J3-1)) SAMEMIN=.FALSE.
154:                    CYCLE loop1116:                    CYCLE loop1
155:                  ENDIF117:                  ENDIF
156:             ENDIF118:             ENDIF
157:          ENDDO loop2119:          ENDDO loop2
158: !       DTOTAL=DTOTAL+DMIN120: !       DTOTAL=DTOTAL+DMIN
159: !       PRINT '(A,I6,A,G20.10,A,I6)',' match failed for atom ',PERMGROUP(NDUMMY+J3-1),' DMIN=',DMIN,' J1=',J1121: !       PRINT '(A,I6,A,G20.10,A,I6)',' match failed for atom ',PERMGROUP(NDUMMY+J3-1),' DMIN=',DMIN,' J1=',J1
160: 122: 
161:       IF (.NOT.BMTESTLOCAL) CYCLE outer ! If we reached here then we don't have a permutational isomer because123:       IF (.NOT.BMTESTLOCAL) CYCLE outer ! If we reached here then we don't have a permutational isomer because
162:                       ! the atom specified in the J3 loop does not have a partner.124:                       ! the atom specified in the J3 loop does not have a partner.
163: 125: 
168:             BMTESTLOCAL=.FALSE.130:             BMTESTLOCAL=.FALSE.
169:             CYCLE outer ! Match is not good enough - give up131:             CYCLE outer ! Match is not good enough - give up
170:           ENDIF 132:           ENDIF 
171:       ELSE133:       ELSE
172:           NREP2=0134:           NREP2=0
173:       ENDIF135:       ENDIF
174:       ENDDO loop1 136:       ENDDO loop1 
175: 137: 
176:       IF (DEBUG) PRINT '(A, I6)',' bulkmindist> number of matching atoms=', NMATCHED   138:       IF (DEBUG) PRINT '(A, I6)',' bulkmindist> number of matching atoms=', NMATCHED   
177:       IF (BMTESTLOCAL) THEN139:       IF (BMTESTLOCAL) THEN
178:         IF (J2.EQ.NPERMGROUP.AND.NMATCHED.GE.NMATCHSV) THEN ! We have cycled over all atoms. Record best match.140:       IF (J2.EQ.NPERMGROUP.AND.NMATCHED.GE.NMATCHSV) THEN ! We have cycled over all atoms. Record best match. 
179:             CALL MINPERM(NATOMS, DUMMYB, XTEMP, BOXLX, BOXLY, BOXLZ, .TRUE., LPERM, LDISTANCE, DIST2, WORSTRAD)141:        CALL MINPERM(NATOMS, DUMMYB, XTEMP, BOXLX, BOXLY, BOXLZ, .TRUE., LPERM, LDISTANCE, DIST2, WORSTRAD)
180:             IF (LDISTANCE.LT.DISTANCE) THEN142:        IF (LDISTANCE.LT.DISTANCE) THEN
181:                 NREP=0143:           NREP=0
182: !               PRINT*, 'From minperm', LDISTANCE, DIST2144: !      PRINT*, 'From minperm', LDISTANCE, DIST2
183:                 DISTANCE=LDISTANCE145:          DISTANCE=LDISTANCE
184:                 NMATCHSV=NMATCHED146:          NMATCHSV=NMATCHED
185:                 IF (RESETA) THEN147:        IF (RESETA) THEN
186:                     DO J6=1,NATOMS148:            DO J6=1,NATOMS
187:                         XBEST(3*(J6-1)+1)=XTEMP(3*(LPERM(J6)-1)+1)-BOXLX*NINT(XTEMP(3*(LPERM(J6)-1)+1)/BOXLX)149:              XBEST(3*(J6-1)+1)=XTEMP(3*(LPERM(J6)-1)+1)-BOXLX*NINT(XTEMP(3*(LPERM(J6)-1)+1)/BOXLX)
188:                         XBEST(3*(J6-1)+2)=XTEMP(3*(LPERM(J6)-1)+2)-BOXLY*NINT(XTEMP(3*(LPERM(J6)-1)+2)/BOXLY)150:              XBEST(3*(J6-1)+2)=XTEMP(3*(LPERM(J6)-1)+2)-BOXLY*NINT(XTEMP(3*(LPERM(J6)-1)+2)/BOXLY)
189:                         IF (.NOT.TWOD) XBEST(3*(J6-1)+3)=XTEMP(3*(LPERM(J6)-1)+3)-BOXLZ*NINT(XTEMP(3*(LPERM(J6)-1)+3)/BOXLZ)151:              IF (.NOT.TWOD) XBEST(3*(J6-1)+3)=XTEMP(3*(LPERM(J6)-1)+3)-BOXLZ*NINT(XTEMP(3*(LPERM(J6)-1)+3)/BOXLZ)
190:                     ENDDO152:            ENDDO
191:                 ENDIF153:        ENDIF
192:             ELSE IF (NMATCHED.EQ.NMATCHSV) THEN154:        ELSE IF (NMATCHED.EQ.NMATCHSV) THEN
193:                 NREP=NREP+1155:           NREP=NREP+1
194:                 IF (NREP.GT.10) THEN156:           IF (NREP.GT.10) THEN
195:                     IF (.NOT.ATOMMATCHFULL) BMTESTLOCAL=.FALSE.157:             IF (.NOT.ATOMMATCHFULL) BMTESTLOCAL=.FALSE. 
196:                     CYCLE outer ! Match is always the same - give up, still do the PI test158:             CYCLE outer ! Match is always the same - give up, still do the PI test
197:                 ENDIF159:           ENDIF
198:             ENDIF160:        ENDIF
199:         ELSE IF (J2.EQ.NPERMGROUP) THEN161:       ELSE IF (J2.EQ.NPERMGROUP) THEN
200:             NREP=0162:         NREP=0 
201:         ENDIF 
202:         IF (J2.EQ.NPERMGROUP.AND.NMATCHED.NE.NATOMS) CYCLE outer 
203:       ENDIF  163:       ENDIF  
204: 164:       IF (J2.EQ.NPERMGROUP.AND.NMATCHED.NE.NATOMS) CYCLE outer 
205:       ! sn402: Update the PERM arrays to hold the permutations identified for this group. NEWPERM should now contain165:       ENDIF  
206:       ! every atom index once and once only (we can't guarantee that that is true before this point) and therefore is166:    ENDDO
207:       ! ready to start being used for distance calculations. 
208:       SAMEPERM(:) = NEWPERM(:) 
209:       PERM(:) = NEWPERM(:) 
210:  
211:    ENDDO ! End of loop over J2 
212:    IF (SAMEMIN) THEN167:    IF (SAMEMIN) THEN
213:       IF (DEBUG) PRINT '(A,G20.10)',' bulkmindist> identical isomers identified, distance=',SQRT(DTOTAL)168:       IF (DEBUG) PRINT '(A,G20.10)',' bulkmindist> identical isomers identified, distance=',SQRT(DTOTAL)
214:    ELSE169:    ELSE
215:       IF (DEBUG) PRINT '(A,G20.10)',' bulkmindist> permutational isomers identified, distance=',SQRT(DTOTAL)170:       IF (DEBUG) PRINT '(A,G20.10)',' bulkmindist> permutational isomers identified, distance=',SQRT(DTOTAL)
216:    ENDIF171:    ENDIF
217:    PITEST=.TRUE.172:    PITEST=.TRUE.
218:    DISTANCE=DTOTAL173:    DISTANCE=DTOTAL
219:    IF (RESETA) THEN174:    IF (RESETA) THEN
220:       DO J2=1,NATOMS175:       DO J2=1,NATOMS
221:          DUMMYA(3*(J2-1)+1)=XTEMP(3*(PERM(J2)-1)+1)-BOXLX*NINT(XTEMP(3*(PERM(J2)-1)+1)/BOXLX)176:          DUMMYA(3*(J2-1)+1)=XTEMP(3*(PERM(J2)-1)+1)-BOXLX*NINT(XTEMP(3*(PERM(J2)-1)+1)/BOXLX)


legend
Lines Added 
Lines changed
 Lines Removed

hdiff - version: 2.1.0