| 1 |
C Copyright(C) 1999-2020 National Technology & Engineering Solutions |
| 2 |
C of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with |
| 3 |
C NTESS, the U.S. Government retains certain rights in this software. |
| 4 |
C |
| 5 |
C See packages/seacas/LICENSE for details |
| 6 |
|
| 7 |
SUBROUTINE RENUM (NPNODE, NPELEM, MXNFLG, MXSFLG, NPNBC, NPSBC, |
| 8 |
& NPWTS, NPREGN, MP, ML, MS, MR, MSC, MAXKXN, NNUID, NNXK, |
| 9 |
& MXLPS, IUNIT, NNN, KKK, KCRD, NL, NPBF, NLBF, NSBF, IPART, |
| 10 |
& LSTNBC, LSTSBC, NNFLG, NNPTR, NNLEN, NSFLG, NSPTR, NSLEN, |
| 11 |
& NVPTR, NVLEN, NSIDEN, NUID, XN, YN, NXK, MAT, KXN, LIST, LA, |
| 12 |
& LB, MATMAP, LISTN, WTNODE, WTSIDE, WTHOLD, IHERE, ILIST, XLIST, |
| 13 |
& NUMMAT, NBCNOD, NNLIST, NBCSID, NSLIST, NVLIST, COOR, ILINE, |
| 14 |
& LTYPE, LCON, ISIDE, NLPS, IFLINE, ILLIST, LINKP, LINKL, LINKS, |
| 15 |
& LINKR, IMAT, LINKB, JMAT, IPBF, NPPF, IFPB, LISTPB, IWTPBF, |
| 16 |
& ILBF, NLPF, IFLB, LISTLB, IWTLBF, ISBF, NSPF, IFSB, LISTSB, |
| 17 |
& IWTSBF, LINKPB, LINKLB, LINKSB, NUMBER, THREE, EIGHT, NINE, |
| 18 |
& OPTIM, ISBARS) |
| 19 |
C*********************************************************************** |
| 20 |
|
| 21 |
C SUBROUTINE RENUM = NUMBERS QMESH OUTPUT, AND RENUMBERS AS NEEDED FOR |
| 22 |
C OPTIMIZATION |
| 23 |
|
| 24 |
C*********************************************************************** |
| 25 |
|
| 26 |
C THE REFERENCE DOCUMENTS FOR THIS CODE ARE SLA-73-1088, JULY 1974, |
| 27 |
C AND SLA-74-0239, JULY 1974 |
| 28 |
|
| 29 |
C*********************************************************************** |
| 30 |
|
| 31 |
DIMENSION NLIST(20), IPART(3, NPREGN) |
| 32 |
DIMENSION COOR(2, MP), ILINE(ML), LTYPE(ML), LCON(3, ML) |
| 33 |
DIMENSION ISIDE(MS), NLPS(MS), IFLINE(MS), ILLIST(MS*3) |
| 34 |
DIMENSION LINKP(2, MP), LINKL(2, ML), LINKS(2, MS), LINKB(2, MS) |
| 35 |
DIMENSION LINKR(2, MR) |
| 36 |
DIMENSION IMAT(MR), JMAT(MS) |
| 37 |
DIMENSION IPBF(MP), NPPF(MP), IFPB(MP), LISTPB(2, MP) |
| 38 |
DIMENSION ILBF(ML), NLPF(ML), IFLB(ML), LISTLB(2, ML) |
| 39 |
DIMENSION ISBF(ML), NSPF(ML), IFSB(ML), LISTSB(2, ML) |
| 40 |
DIMENSION IWTPBF(3, MP), IWTLBF(3, ML), IWTSBF(3, ML) |
| 41 |
DIMENSION LINKPB(2, MP), LINKLB(2, ML), LINKSB(2, ML) |
| 42 |
|
| 43 |
DIMENSION LIST(NNUID), LISTN(NNUID), NUID(NNUID), XN(NPNODE) |
| 44 |
DIMENSION YN(NPNODE), NXK(NNXK, NPELEM), MAT(NPELEM) |
| 45 |
DIMENSION KXN(NNXK, MAXKXN), LA(NPNODE), LB(NPNODE) |
| 46 |
DIMENSION IHERE(NNUID), ILIST(MXLPS), XLIST(MXLPS) |
| 47 |
|
| 48 |
DIMENSION LSTNBC(NPNBC), LSTSBC(NPSBC), NSIDEN(NPSBC) |
| 49 |
DIMENSION NNFLG(MXNFLG), NNLEN(MXNFLG), NNPTR(MXNFLG) |
| 50 |
DIMENSION NSFLG(MXSFLG), NSLEN(MXSFLG), NSPTR(MXSFLG) |
| 51 |
DIMENSION WTHOLD(NPWTS), WTNODE(NPNBC), WTSIDE(NPSBC) |
| 52 |
DIMENSION NVLEN(MXSFLG), NVPTR(MXSFLG), MATMAP(3, NPREGN) |
| 53 |
|
| 54 |
DIMENSION KLIST(20) |
| 55 |
|
| 56 |
LOGICAL OPTIM, ERR, NOROOM, ALL, THREE, EIGHT, NINE |
| 57 |
LOGICAL ITSOK, ISBARS |
| 58 |
|
| 59 |
CHARACTER*80 NUMBER(MSC) |
| 60 |
|
| 61 |
C HEADER |
| 62 |
|
| 63 |
CALL MESSAGE(' ') |
| 64 |
CALL MESSAGE('NUMBERING OF GENERATED OUTPUT BEGUN') |
| 65 |
IF (OPTIM) CALL MESSAGE(' -- OPTIMIZATION IS ENABLED --') |
| 66 |
|
| 67 |
C READ THE MESH TAPE |
| 68 |
|
| 69 |
CALL RDMESH (NPNODE, NPELEM, NPNBC, NPSBC, NPREGN, MS, MR, NNUID, |
| 70 |
& NNXK, IUNIT, NNN, KKK, IPART, LSTNBC, LSTSBC, NUID, XN, YN, |
| 71 |
& NXK, MAT, MATMAP, NUMMAT, ISIDE, NLPS, IFLINE, ILLIST, LINKS, |
| 72 |
& LINKR, IMAT, LINKB, JMAT, NNNBC, NNSBC, ERR) |
| 73 |
IF (ERR) THEN |
| 74 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 75 |
RETURN |
| 76 |
END IF |
| 77 |
|
| 78 |
C SORT NODE LIST INTO INCREASING NUID-S |
| 79 |
|
| 80 |
DO 100 I = 1, NNN |
| 81 |
LISTN(I) = NUID(I) |
| 82 |
100 CONTINUE |
| 83 |
IF (OPTIM) THEN |
| 84 |
CALL NODORD (NPNODE, XN, YN, LISTN, NUID, NNN) |
| 85 |
ELSE |
| 86 |
DO 110 I = 1, NNN |
| 87 |
LIST(I) = I |
| 88 |
110 CONTINUE |
| 89 |
CALL SORT (NNN, NUID, LIST) |
| 90 |
END IF |
| 91 |
|
| 92 |
C CONVERT REFERENCES TO NUID-S TO REFERENCES TO |
| 93 |
C SEQUENCE NUMBERS |
| 94 |
|
| 95 |
DO 130 I = 1, 4 |
| 96 |
DO 120 K = 1, KKK |
| 97 |
IF (NXK(I, K) .GT. 0) THEN |
| 98 |
NEW = INDX(NNN, NUID, NXK(I, K)) |
| 99 |
IF (NEW .EQ. 0) THEN |
| 100 |
CALL MESSAGE('ERROR SORTING NUMBERING DATA -- NODE') |
| 101 |
CALL MESSAGE('*** NO MESH SAVED ***') |
| 102 |
KKK = 0 |
| 103 |
RETURN |
| 104 |
END IF |
| 105 |
IF (OPTIM) THEN |
| 106 |
NXK(I, K) = NEW |
| 107 |
ELSE |
| 108 |
NXK(I, K) = LIST(NEW) |
| 109 |
END IF |
| 110 |
END IF |
| 111 |
120 CONTINUE |
| 112 |
130 CONTINUE |
| 113 |
|
| 114 |
IF (NNNBC .GT. 0) THEN |
| 115 |
DO 140 I = 1, NNNBC |
| 116 |
IF (LSTNBC(I) .GT. 0) THEN |
| 117 |
NEW = INDX(NNN, NUID, LSTNBC(I)) |
| 118 |
IF (NEW .EQ. 0) THEN |
| 119 |
CALL MESSAGE('ERROR SORTING NUMBERING DATA -- NBC') |
| 120 |
CALL MESSAGE('*** NO MESH SAVED ***') |
| 121 |
KKK = 0 |
| 122 |
RETURN |
| 123 |
END IF |
| 124 |
IF (OPTIM) THEN |
| 125 |
LSTNBC(I) = NEW |
| 126 |
ELSE |
| 127 |
LSTNBC(I) = LIST(NEW) |
| 128 |
END IF |
| 129 |
END IF |
| 130 |
140 CONTINUE |
| 131 |
END IF |
| 132 |
|
| 133 |
C BUILD KXN ARRAY |
| 134 |
|
| 135 |
NUMKXN = NNN |
| 136 |
DO 160 I = 1, NNXK |
| 137 |
DO 150 J = 1, MAXKXN |
| 138 |
KXN(I, J) = 0 |
| 139 |
150 CONTINUE |
| 140 |
160 CONTINUE |
| 141 |
|
| 142 |
DO 180 I = 1, 4 |
| 143 |
DO 170 K = 1, KKK |
| 144 |
IF (NXK(I, K) .GT. 0) THEN |
| 145 |
CALL KXNADD (MAXKXN, NNXK, KXN, NUMKXN, K, NXK(I, K), |
| 146 |
& ERR) |
| 147 |
IF (ERR) THEN |
| 148 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 149 |
KKK = 0 |
| 150 |
RETURN |
| 151 |
END IF |
| 152 |
END IF |
| 153 |
170 CONTINUE |
| 154 |
180 CONTINUE |
| 155 |
IF (OPTIM) THEN |
| 156 |
|
| 157 |
C GET STARTING LIST FOR CUTHILL-MCKEE PROCESS |
| 158 |
|
| 159 |
IF (KCRD .GT. 0) THEN |
| 160 |
CALL GNLIST (NPNODE, NNUID, MSC, NPNODE, NPELEM, MAXKXN, |
| 161 |
& NNXK, KXN, NXK, NUID, XN, YN, LIST, NUML, NUMBER, KCRD, |
| 162 |
& NNN, ERR, NOROOM) |
| 163 |
IF (NOROOM) THEN |
| 164 |
CALL MESSAGE('TOO MANY NODES IN STARTING LIST') |
| 165 |
CALL MESSAGE('*** NO MESH SAVED ***') |
| 166 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 167 |
KKK = 0 |
| 168 |
RETURN |
| 169 |
ELSE IF (ERR) THEN |
| 170 |
CALL MESSAGE('ERROR GENERATING STARTING LIST') |
| 171 |
CALL MESSAGE('*** NO MESH SAVED ***') |
| 172 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 173 |
KKK = 0 |
| 174 |
RETURN |
| 175 |
END IF |
| 176 |
ELSE |
| 177 |
CALL MESSAGE('NO CARDS AVAILABLE FOR STARTING LIST') |
| 178 |
CALL MESSAGE('FIRST NODE IN THE OUTPUT USED') |
| 179 |
NUML = 1 |
| 180 |
LIST(1) = 1 |
| 181 |
END IF |
| 182 |
|
| 183 |
C INITIALIZE LISTS |
| 184 |
|
| 185 |
DO 190 I = 1, NNN |
| 186 |
LISTN(I) = I |
| 187 |
190 CONTINUE |
| 188 |
|
| 189 |
C USE LISTN AS A CHECK ON WHETHER THE NODE HAS BEEN USED (NEGATED) |
| 190 |
|
| 191 |
DO 200 I = 1, NUML |
| 192 |
LA(I) = LIST(I) |
| 193 |
NODE = LIST(I) |
| 194 |
LISTN(NODE) = -LISTN(NODE) |
| 195 |
200 CONTINUE |
| 196 |
|
| 197 |
NUMA = NUML |
| 198 |
|
| 199 |
C CREATE LIST OF NEW NODES CONNECTED TO LIST A |
| 200 |
|
| 201 |
210 CONTINUE |
| 202 |
NUMB = 0 |
| 203 |
DO 230 N = 1, NUMA |
| 204 |
ALL = .TRUE. |
| 205 |
CALL GETNXN (NPNODE, NPELEM, MAXKXN, NNXK, KXN, NXK, LISTN, |
| 206 |
& LA(N), NLIST, NUMB1, ALL, ERR) |
| 207 |
IF (ERR) THEN |
| 208 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 209 |
KKK = 0 |
| 210 |
RETURN |
| 211 |
END IF |
| 212 |
IF (NUMB1 .GT. 0) THEN |
| 213 |
IF ((NUMB + NUMB1) .GT. NPNODE) THEN |
| 214 |
CALL MESSAGE('LIST B HAS OVERFLOWED') |
| 215 |
CALL MESSAGE('*** NO MESH SAVED ***') |
| 216 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 217 |
KKK = 0 |
| 218 |
RETURN |
| 219 |
END IF |
| 220 |
DO 220 I = 1, NUMB1 |
| 221 |
NODE = NLIST(I) |
| 222 |
NUMB = NUMB + 1 |
| 223 |
LB(NUMB) = NODE |
| 224 |
LISTN(NODE) = -LISTN(NODE) |
| 225 |
220 CONTINUE |
| 226 |
END IF |
| 227 |
230 CONTINUE |
| 228 |
IF (NUMB .GT. 0) THEN |
| 229 |
|
| 230 |
C INCLUDE LIST B INTO FULL LIST |
| 231 |
C ALSO TRANSFER LIST B TO LIST A |
| 232 |
|
| 233 |
DO 240 I = 1, NUMB |
| 234 |
NUML = NUML + 1 |
| 235 |
LIST(NUML) = LB(I) |
| 236 |
LA(I) = LB(I) |
| 237 |
240 CONTINUE |
| 238 |
NUMA = NUMB |
| 239 |
|
| 240 |
C CHECK FOR CONVERGENCE |
| 241 |
|
| 242 |
IF (NUML .LT. NNN) GO TO 210 |
| 243 |
|
| 244 |
C PROCESS HAS CONVERGED |
| 245 |
C CHECK IF ALL NODES WERE COVERED |
| 246 |
|
| 247 |
ELSE IF (NUML .LT. NNN) THEN |
| 248 |
|
| 249 |
DO 250 I = 1, NNN |
| 250 |
IF (LISTN(I) .GT. 0) THEN |
| 251 |
|
| 252 |
C START THE LIST AGAIN WITH THE MISSED NODE |
| 253 |
|
| 254 |
CALL MESSAGE('A DISCONTINUITY (SLIDE LINE) IN THE '// |
| 255 |
& 'BODY HAS BEEN FOUND') |
| 256 |
CALL MESSAGE |
| 257 |
& ('SEPARATE PART NUMBERING WILL ALSO BE OPTIMIZED') |
| 258 |
NUMA = 1 |
| 259 |
LA(1) = I |
| 260 |
GO TO 210 |
| 261 |
END IF |
| 262 |
250 CONTINUE |
| 263 |
|
| 264 |
C DEFINITE ERROR IN THE NUMBERING PROCESS |
| 265 |
|
| 266 |
CALL MESSAGE('ALL NODES COULD NOT BE FOUND TO NUMBER') |
| 267 |
CALL MESSAGE(' *** NO MESH SAVED ***') |
| 268 |
CALL MESSAGE(' ** NUMBERING ABORT **') |
| 269 |
KKK = 0 |
| 270 |
RETURN |
| 271 |
END IF |
| 272 |
|
| 273 |
C PREPARE TO PUT NODE LIST INTO NEWLY DETERMINED ORDER |
| 274 |
C LISTN BECOMES THE POINTER FROM THE OLD NUMBER TO THE NEW |
| 275 |
|
| 276 |
DO 260 I = 1, NNN |
| 277 |
J = LIST(I) |
| 278 |
LISTN(J) = I |
| 279 |
260 CONTINUE |
| 280 |
|
| 281 |
C CONVERT NODE NUMBERS TO NEW NODE ORDER BY REDOING THE NXK ARRAY |
| 282 |
|
| 283 |
DO 280 I = 1, 4 |
| 284 |
DO 270 K = 1, KKK |
| 285 |
J = NXK(I, K) |
| 286 |
IF (J .GT. 0) NXK(I, K) = LISTN(J) |
| 287 |
270 CONTINUE |
| 288 |
280 CONTINUE |
| 289 |
|
| 290 |
IF (NNNBC .GT. 0) THEN |
| 291 |
DO 290 I = 1, NNNBC |
| 292 |
IF (LSTNBC(I) .GT. 0) THEN |
| 293 |
J = LSTNBC(I) |
| 294 |
LSTNBC(I) = LISTN(J) |
| 295 |
END IF |
| 296 |
290 CONTINUE |
| 297 |
END IF |
| 298 |
|
| 299 |
C PUT NODE LIST INTO NEW ORDER |
| 300 |
|
| 301 |
CALL NODORD (NPNODE, XN, YN, LISTN, NUID, NNN) |
| 302 |
|
| 303 |
C REBUILD KXN ARRAY |
| 304 |
|
| 305 |
NUMKXN = NNN |
| 306 |
DO 310 I = 1, NNXK |
| 307 |
DO 300 J = 1, MAXKXN |
| 308 |
KXN(I, J) = 0 |
| 309 |
300 CONTINUE |
| 310 |
310 CONTINUE |
| 311 |
|
| 312 |
DO 330 I = 1, 4 |
| 313 |
DO 320 K = 1, KKK |
| 314 |
IF (NXK(I, K) .GT. 0) THEN |
| 315 |
CALL KXNADD (MAXKXN, NNXK, KXN, NUMKXN, K, NXK(I, K), |
| 316 |
& ERR) |
| 317 |
IF (ERR) THEN |
| 318 |
CALL MESSAGE('** NUMBERING ABORT **') |
| 319 |
KKK = 0 |
| 320 |
RETURN |
| 321 |
END IF |
| 322 |
END IF |
| 323 |
320 CONTINUE |
| 324 |
330 CONTINUE |
| 325 |
|
| 326 |
C PUT ELEMENT NUMBERING INTO NEW ORDER USING LA AS TEMPORARY STORAGE |
| 327 |
|
| 328 |
DO 340 I = 1, KKK |
| 329 |
LA(I) = 0 |
| 330 |
LB(I) = 0 |
| 331 |
340 CONTINUE |
| 332 |
KOUNT = 0 |
| 333 |
DO 360 I = 1, NNN |
| 334 |
CALL GETKXN (NPNODE, MAXKXN, NNXK, KXN, NUID, I, KLIST, |
| 335 |
& NUMK, ERR) |
| 336 |
DO 350 J = 1, NUMK |
| 337 |
IF (LB(KLIST(J)) .EQ. 0) THEN |
| 338 |
KOUNT = KOUNT + 1 |
| 339 |
LA(KOUNT) = KLIST(J) |
| 340 |
LB(KLIST(J)) = 1 |
| 341 |
END IF |
| 342 |
350 CONTINUE |
| 343 |
360 CONTINUE |
| 344 |
|
| 345 |
C END OF OPTIMIZATION |
| 346 |
|
| 347 |
ELSE |
| 348 |
DO 370 I = 1, NNN |
| 349 |
NUID(I) = LISTN(I) |
| 350 |
370 CONTINUE |
| 351 |
END IF |
| 352 |
|
| 353 |
C STICK LSTNBC INTO LISTN AS A WORK ARRAY FOR SORTING NODAL BOUNDARY |
| 354 |
C CONDITIONS LISTS |
| 355 |
|
| 356 |
IF (NNNBC .GT. 0) THEN |
| 357 |
DO 380 I = 1, NNNBC |
| 358 |
LISTN(I) = LSTNBC(I) |
| 359 |
380 CONTINUE |
| 360 |
|
| 361 |
C SORT THROUGH LSTNBC AND RECREATE IT IN PLACE |
| 362 |
C USING LISTN AS THE ARRAY TO TAKE LSTNBC OVER |
| 363 |
C AND IHERE AS A WORK ARRAY |
| 364 |
C (LSTNBC NOW BECOMES THE NODES ARRAY FOR THE |
| 365 |
C GENESIS DATA BASE) |
| 366 |
|
| 367 |
CALL SRTNBC (MXNFLG, NPNBC, NNN, NNFLG, NNLEN, NNPTR, LSTNBC, |
| 368 |
& LISTN, IHERE, NNNBC, NBCNOD, NNLIST) |
| 369 |
ELSE |
| 370 |
NNLIST = 0 |
| 371 |
NBCNOD = 0 |
| 372 |
END IF |
| 373 |
|
| 374 |
C SORT THROUGH LSTSBC AND RECREATE IT IN PLACE |
| 375 |
C USING LISTN AS THE ARRAY TO TAKE LSTSBC OVER |
| 376 |
C AND KXN AS A WORK ARRAY |
| 377 |
C (LSTSBC NOW BECOMES THE NELEMS ARRAY FOR THE |
| 378 |
C GENESIS DATA BASE) |
| 379 |
|
| 380 |
IF (NNSBC .GT. 0) THEN |
| 381 |
DO 390 I = 1, NNSBC |
| 382 |
LISTN(I) = LSTSBC(I) |
| 383 |
390 CONTINUE |
| 384 |
|
| 385 |
CALL SRTSBC (MXSFLG, NPSBC, NPELEM, NNXK, NXK, NSFLG, NSLEN, |
| 386 |
& NSPTR, NVLEN, NVPTR, LISTN, LSTSBC, NSIDEN, IHERE, NNSBC, |
| 387 |
& NSLIST, NVLIST, NBCSID) |
| 388 |
|
| 389 |
ELSE |
| 390 |
NBCSID = 0 |
| 391 |
NSLIST = 0 |
| 392 |
NVLIST = 0 |
| 393 |
END IF |
| 394 |
|
| 395 |
C PUT WEIGHTS ON FLAGGED NODES AS NEEDED |
| 396 |
C USE THE IHERE ARRAY AS A WORK ARRAY |
| 397 |
|
| 398 |
CALL ADDWT (NNUID, NNXK, MAXKXN, NPNODE, NPELEM, MXLPS, MP, ML, |
| 399 |
& MS, NPNBC, NPSBC, MXNFLG, MXSFLG, NPWTS, COOR, ILINE, LTYPE, |
| 400 |
& LCON, ISIDE, NLPS, IFLINE, ILLIST, LINKP, LINKL, LINKS, IPBF, |
| 401 |
& NPPF, IFPB, LISTPB, IWTPBF, ILBF, NLPF, IFLB, LISTLB, IWTLBF, |
| 402 |
& ISBF, NSPF, IFSB, LISTSB, IWTSBF, LINKPB, LINKLB, LINKSB, XN, |
| 403 |
& YN, NUID, NXK, KXN, LSTNBC, NNFLG, NNPTR, NNLEN, NSFLG, NVPTR, |
| 404 |
& NVLEN, NSIDEN, WTNODE, WTSIDE, WTHOLD, NBCNOD, NNLIST, NBCSID, |
| 405 |
& NSLIST, NVLIST, ILIST, XLIST) |
| 406 |
|
| 407 |
C SORT NUMBERS ACCORDING TO MATERIAL TYPE |
| 408 |
C USE KXN AS A WORK ARRAY |
| 409 |
|
| 410 |
DO 410 J = 1, 4 |
| 411 |
DO 400 I = 1, KKK |
| 412 |
KXN(J, I) = NXK(J, I) |
| 413 |
400 CONTINUE |
| 414 |
410 CONTINUE |
| 415 |
|
| 416 |
C SET UP THE MATERIAL MAPPING ARRAY |
| 417 |
C MATMAP(1, I) = THE MATERIAL ID FOR THE I'TH BLOCK |
| 418 |
C MATMAP(2, I) = THE FIRST ELEMENT IN THE I'TH BLOCK |
| 419 |
C MATMAP(3, I) = THE LAST ELEMENT IN THE I'TH BLOCK |
| 420 |
|
| 421 |
KOUNT = 1 |
| 422 |
DO 440 I = 1, NUMMAT |
| 423 |
KMAT = MATMAP(1, I) |
| 424 |
MATMAP(2, I) = KOUNT |
| 425 |
DO 430 J = 1, KKK |
| 426 |
IF (MAT(J) .EQ. KMAT) THEN |
| 427 |
LISTN(J) = KOUNT |
| 428 |
LIST(KOUNT) = J |
| 429 |
DO 420 K = 1, 4 |
| 430 |
NXK(K, KOUNT) = KXN(K, J) |
| 431 |
420 CONTINUE |
| 432 |
KOUNT = KOUNT + 1 |
| 433 |
END IF |
| 434 |
430 CONTINUE |
| 435 |
MATMAP(3, I) = KOUNT - 1 |
| 436 |
440 CONTINUE |
| 437 |
IF (KOUNT - 1 .NE. KKK) THEN |
| 438 |
CALL MESSAGE('ALL ELEMENTS DID NOT HAVE AN ELEMENT ID') |
| 439 |
CALL MESSAGE('MESH NUMBERING ABORTED') |
| 440 |
KKK = 0 |
| 441 |
RETURN |
| 442 |
END IF |
| 443 |
|
| 444 |
C REDO THE REGION POINTER ARRAY |
| 445 |
|
| 446 |
DO 450 I = 1, NPREGN |
| 447 |
IPART(2, I) = LISTN(IPART(2, I)) |
| 448 |
IPART(3, I) = LISTN(IPART(3, I)) |
| 449 |
450 CONTINUE |
| 450 |
|
| 451 |
C REDO THE MATERIAL ARRAY |
| 452 |
|
| 453 |
DO 470 I = 1, NUMMAT |
| 454 |
DO 460 J = MATMAP(2, I), MATMAP(3, I) |
| 455 |
MAT(J) = MATMAP(1, I) |
| 456 |
460 CONTINUE |
| 457 |
470 CONTINUE |
| 458 |
|
| 459 |
C REDO THE MAPPING ARRAY IF OPTIMIZING RENUMBERING HAS BEEN DONE |
| 460 |
|
| 461 |
IF (OPTIM) THEN |
| 462 |
DO 480 I = 1, KKK |
| 463 |
LA(I) = LISTN(LA(I)) |
| 464 |
480 CONTINUE |
| 465 |
END IF |
| 466 |
|
| 467 |
C REDO THE ELEMENT SIDE BOUNDARY LISTING WITH THE CURRENT ELEMENT NO. |
| 468 |
|
| 469 |
DO 490 I = 1, NSLIST |
| 470 |
LSTSBC(I) = LISTN(LSTSBC(I)) |
| 471 |
490 CONTINUE |
| 472 |
|
| 473 |
C STORE THE LISTN POINTER SYSTEM FOR NOW |
| 474 |
|
| 475 |
DO 500 I = 1, KKK |
| 476 |
LIST(I) = LISTN(I) |
| 477 |
500 CONTINUE |
| 478 |
|
| 479 |
C ADD THE MID-SIDE NODES IF EIGHT OR NINE NODE QUADS ARE WANTED |
| 480 |
C OR IF THREE NODE BARS ARE WANTED |
| 481 |
|
| 482 |
IF ((EIGHT) .OR. (NINE) .OR. (THREE)) THEN |
| 483 |
|
| 484 |
C FLAG ALL ELEMENT SIDES ONLY ONCE (NO SHARED SIDE FLAGGED) |
| 485 |
|
| 486 |
CALL NXKBDY (NNXK * MAXKXN, NNXK, NPELEM, NXK, KKK, KXN, |
| 487 |
& THREE, EIGHT, NINE) |
| 488 |
|
| 489 |
C CREATE THE MIDSIDE NODES |
| 490 |
|
| 491 |
CALL MIDNOD (NPNODE, NNUID, NPELEM, NNXK, MP, ML, KKK, NNN, |
| 492 |
& NALL, NL, NXK, NUID, XN, YN, LISTN, COOR, ILINE, LTYPE, |
| 493 |
& LCON, LINKP, LINKL, THREE, EIGHT, NINE) |
| 494 |
|
| 495 |
C MODIFY THE IDENTIFIERS OF THE OLD NODES |
| 496 |
|
| 497 |
DO 510 I = 1, NNN |
| 498 |
LISTN(I) = I * 100000 |
| 499 |
510 CONTINUE |
| 500 |
NNN = NALL |
| 501 |
|
| 502 |
C ORDER THE EXPANDED NODE LIST |
| 503 |
|
| 504 |
CALL NODORD (NPNODE, XN, YN, LISTN, NUID, NNN) |
| 505 |
|
| 506 |
C EXPAND THE CONNECTIVITY ARRAY TO INCLUDE THE MIDSIDE NODES |
| 507 |
C WHILE REPOSITIONING THE CORNER NODES INTO PROPER SEQUENCE |
| 508 |
|
| 509 |
DO 540 I = 1, KKK |
| 510 |
IF ((THREE) .AND. (NXK (3, I) .EQ. 0)) THEN |
| 511 |
ITSOK = .TRUE. |
| 512 |
ELSEIF ((NXK (3, I) .NE. 0) .AND. ((EIGHT) .OR. (NINE))) |
| 513 |
& THEN |
| 514 |
ITSOK = .TRUE. |
| 515 |
ELSE |
| 516 |
ITSOK = .FALSE. |
| 517 |
ENDIF |
| 518 |
IF (ITSOK) THEN |
| 519 |
DO 520 J = 4, 1, -1 |
| 520 |
JJ = J + 1 |
| 521 |
IF (JJ .EQ. 5) JJ = 1 |
| 522 |
NODEA = IABS(NXK(J, I)) |
| 523 |
NODEB = IABS(NXK(JJ, I)) |
| 524 |
|
| 525 |
C CHECK FOR 3 NODE BAR ELEMENTS |
| 526 |
|
| 527 |
IF ((NODEA .GT. 0) .AND. (NODEB .GT. 0)) THEN |
| 528 |
NXK (J * 2 - 1, I) = NODEA * 100000 |
| 529 |
NLO = MIN0(NODEA, NODEB) |
| 530 |
NHI = MAX0(NODEA, NODEB) |
| 531 |
NXK (J * 2, I) = NLO * 100000 + NHI |
| 532 |
ELSE IF (NODEA .GT. 0) THEN |
| 533 |
NXK (J * 2 - 1, I) = NODEA * 100000 |
| 534 |
END IF |
| 535 |
520 CONTINUE |
| 536 |
ELSE |
| 537 |
DO 530 J = 1, 4 |
| 538 |
NXK (J, I) = IABS (NXK (J,I)) * 100000 |
| 539 |
530 CONTINUE |
| 540 |
ENDIF |
| 541 |
540 CONTINUE |
| 542 |
|
| 543 |
C GET THE LIST OF NODAL BOUNDARY FLAGS EXTENDED AND THE NEW IDENTIFIERS |
| 544 |
C IN PLACE (USE NUID AND WTHOLD AS WORK ARRAYS) |
| 545 |
|
| 546 |
IF (NBCNOD .GT. 0) THEN |
| 547 |
KOUNT = 0 |
| 548 |
DO 570 I = 1, NBCNOD |
| 549 |
JEND = NNLEN(I) + NNPTR(I) - 1 |
| 550 |
DO 560 J = NNPTR(I), JEND |
| 551 |
KOUNT = KOUNT + 1 |
| 552 |
NUID(KOUNT) = LSTNBC(J) * 100000 |
| 553 |
WTHOLD(KOUNT) = WTNODE(J) |
| 554 |
DO 550 K = J + 1, JEND |
| 555 |
ILO = MIN0(LSTNBC(J), LSTNBC(K)) |
| 556 |
IHI = MAX0(LSTNBC(J), LSTNBC(K)) |
| 557 |
ITRY = (ILO * 100000) + IHI |
| 558 |
IF (INDX(NNN, LISTN, ITRY) .GT. 0) THEN |
| 559 |
KOUNT = KOUNT + 1 |
| 560 |
NNLEN(I) = NNLEN(I) + 1 |
| 561 |
NUID(KOUNT) = ITRY |
| 562 |
WTHOLD(KOUNT) = (WTNODE(J) + WTNODE(K)) * .5 |
| 563 |
END IF |
| 564 |
550 CONTINUE |
| 565 |
560 CONTINUE |
| 566 |
IF (I .NE. 1) NNPTR(I) = NNPTR(I - 1) + NNLEN(I - 1) |
| 567 |
570 CONTINUE |
| 568 |
NNLIST = KOUNT |
| 569 |
DO 580 I = 1, NNLIST |
| 570 |
LSTNBC(I) = NUID(I) |
| 571 |
WTNODE(I) = WTHOLD(I) |
| 572 |
580 CONTINUE |
| 573 |
END IF |
| 574 |
|
| 575 |
C GET THE LIST OF SIDE BOUNDARY FLAGS EXTENDED AND THE NEW IDENTIFIERS |
| 576 |
C IN PLACE (USE NUID, WTHOLD, AND KXN AS WORK ARRAYS) |
| 577 |
|
| 578 |
IF (NBCSID .GT. 0) THEN |
| 579 |
KOUNT = 0 |
| 580 |
KOUNT2 = 0 |
| 581 |
DO 600 I = 1, NBCSID |
| 582 |
ISTART = NSPTR (I) |
| 583 |
IEND = NSPTR (I) + NSLEN (I) - 1 |
| 584 |
J = NVPTR (I) |
| 585 |
JEND = NVPTR (I) + NVLEN (I) - 1 |
| 586 |
DO 590 II = ISTART, IEND |
| 587 |
KELEM = LSTSBC (II) |
| 588 |
KOUNT = KOUNT + 1 |
| 589 |
KXN (1, KOUNT) = KELEM |
| 590 |
K = J + 1 |
| 591 |
KOUNT2 = KOUNT2 + 1 |
| 592 |
NUID(KOUNT2) = NSIDEN(J) * 100000 |
| 593 |
WTHOLD(KOUNT2) = WTSIDE(J) |
| 594 |
|
| 595 |
C DO THE ADJUSTMENTS IF THE ELEMENT IS ONE THAT HAS BEEN EXPANDED |
| 596 |
|
| 597 |
IF ( ((THREE) .AND. (NXK (4, KELEM) .EQ. 0)) .OR. |
| 598 |
& ( ((EIGHT) .OR. (NINE)) .AND. |
| 599 |
& (NXK (4, KELEM) .NE. 0) ) ) THEN |
| 600 |
KOUNT = KOUNT + 1 |
| 601 |
KXN (1, KOUNT) = LSTSBC(II) |
| 602 |
NSLEN (I) = NSLEN (I) + 1 |
| 603 |
ILO = MIN0(NSIDEN(J), NSIDEN(K)) |
| 604 |
IHI = MAX0(NSIDEN(J), NSIDEN(K)) |
| 605 |
ITRY = (ILO * 100000) + IHI |
| 606 |
KOUNT2 = KOUNT2 + 1 |
| 607 |
NUID(KOUNT2) = ITRY |
| 608 |
WTHOLD(KOUNT2) = (WTSIDE(J) + WTSIDE(K)) * .5 |
| 609 |
KOUNT2 = KOUNT2 + 1 |
| 610 |
NUID(KOUNT2) = ITRY |
| 611 |
WTHOLD(KOUNT2) = (WTSIDE(J) + WTSIDE(K)) * .5 |
| 612 |
NVLEN(I) = NVLEN(I) + 2 |
| 613 |
ENDIF |
| 614 |
KOUNT2 = KOUNT2 + 1 |
| 615 |
NUID(KOUNT2) = NSIDEN(K) * 100000 |
| 616 |
WTHOLD(KOUNT2) = WTSIDE(K) |
| 617 |
J = J + 2 |
| 618 |
590 CONTINUE |
| 619 |
IF (I .GT. 1) THEN |
| 620 |
NSPTR(I) = NSPTR(I - 1) + NSLEN(I - 1) |
| 621 |
NVPTR(I) = NVPTR(I - 1) + NVLEN(I - 1) |
| 622 |
ENDIF |
| 623 |
600 CONTINUE |
| 624 |
|
| 625 |
C TRANSFER THE ELEMENT BOUNDARIES BACK FROM THE WORK ARRAYS |
| 626 |
|
| 627 |
NSLIST = KOUNT |
| 628 |
DO 610 I = 1, NSLIST |
| 629 |
LSTSBC(I) = KXN(1, I) |
| 630 |
610 CONTINUE |
| 631 |
NVLIST = KOUNT2 |
| 632 |
DO 620 I = 1, NVLIST |
| 633 |
NSIDEN(I) = NUID(I) |
| 634 |
WTSIDE(I) = WTHOLD(I) |
| 635 |
620 CONTINUE |
| 636 |
END IF |
| 637 |
|
| 638 |
C ADD A CENTER NODE TO THE NODE LIST IF NEEDED |
| 639 |
|
| 640 |
IF (NINE) THEN |
| 641 |
NOLD = NNN |
| 642 |
DO 630 I = 1, KKK |
| 643 |
|
| 644 |
C WATCH OUT FOR 3 NODE BAR ELEMENTS |
| 645 |
|
| 646 |
IF (.NOT. ISBARS .OR. NXK(4, I) .GT. 0) THEN |
| 647 |
N2 = INDX(NOLD, LISTN, NXK(2, I)) |
| 648 |
N4 = INDX(NOLD, LISTN, NXK(4, I)) |
| 649 |
N6 = INDX(NOLD, LISTN, NXK(6, I)) |
| 650 |
N8 = INDX(NOLD, LISTN, NXK(8, I)) |
| 651 |
IF ((N2 .EQ. 0) .OR. (N4 .EQ. 0) .OR. |
| 652 |
& (N6 .EQ. 0) .OR. (N8 .EQ. 0)) THEN |
| 653 |
CALL MESSAGE('BAD LINK IN RENUM AT 8 NODE LIST') |
| 654 |
CALL MESSAGE('NO MESH SAVED') |
| 655 |
KKK = 0 |
| 656 |
RETURN |
| 657 |
END IF |
| 658 |
DIST1 = SQRT((XN(N2) - XN(N6)) **2 |
| 659 |
& + (YN(N2) - YN(N6)) **2) |
| 660 |
DIST2 = SQRT((XN(N8) - XN(N4)) **2 |
| 661 |
& + (YN(N8) - YN(N4)) **2) |
| 662 |
NNN = NNN + 1 |
| 663 |
IF (DIST1 .LT. DIST2) THEN |
| 664 |
XN(NNN) = .5 * (XN(N2) + XN(N6)) |
| 665 |
YN(NNN) = .5 * (YN(N2) + YN(N6)) |
| 666 |
ELSE |
| 667 |
XN(NNN) = .5 * (XN(N4) + XN(N8)) |
| 668 |
YN(NNN) = .5 * (YN(N4) + YN(N8)) |
| 669 |
END IF |
| 670 |
LISTN(NNN) = INT((MIN0(NXK(1, I), NXK(5, I))) + |
| 671 |
& (MAX0(NXK(1, I), NXK(5, I)) * .0001)) |
| 672 |
NXK(9, I) = LISTN(NNN) |
| 673 |
ELSE |
| 674 |
write (*,*) 'Element ', i, ' is a 3-node bar?' |
| 675 |
END IF |
| 676 |
630 CONTINUE |
| 677 |
|
| 678 |
C NOW, ORDER THE EXPANDED NODE LIST AGAIN |
| 679 |
|
| 680 |
CALL NODORD (NPNODE, XN, YN, LISTN, NUID, NNN) |
| 681 |
IEND = 9 |
| 682 |
ELSEIF (EIGHT) THEN |
| 683 |
IEND = 8 |
| 684 |
ELSE |
| 685 |
IEND = 4 |
| 686 |
END IF |
| 687 |
|
| 688 |
C NOW REPLACE THE NODE REFERENCES WITH AN EXPANDED ORDER NUMBER |
| 689 |
|
| 690 |
C FIRST FIX THE CONNECTIVITY (NXK ARRAY) |
| 691 |
|
| 692 |
DO 650 I = 1, IEND |
| 693 |
DO 640 K = 1, KKK |
| 694 |
|
| 695 |
C AGAIN, WATCH OUT FOR 3 NODE BAR ELEMENTS |
| 696 |
|
| 697 |
IF (.NOT. ISBARS .OR. NXK(I, K) .GT. 0) THEN |
| 698 |
NEW = INDX(NNN, LISTN, NXK(I, K)) |
| 699 |
IF (NEW .EQ. 0) THEN |
| 700 |
CALL MESSAGE('BAD LINK IN RENUM 8 NODE LIST') |
| 701 |
CALL MESSAGE('NO MESH SAVED') |
| 702 |
KKK = 0 |
| 703 |
RETURN |
| 704 |
END IF |
| 705 |
NXK(I, K) = NEW |
| 706 |
END IF |
| 707 |
640 CONTINUE |
| 708 |
650 CONTINUE |
| 709 |
|
| 710 |
C NOW FIX THE NODE BOUNDARY FLAGS |
| 711 |
|
| 712 |
IF (NBCNOD .GT. 0) THEN |
| 713 |
DO 660 I = 1, NNLIST |
| 714 |
NEW = INDX(NNN, LISTN, LSTNBC(I)) |
| 715 |
IF (NEW .EQ. 0) THEN |
| 716 |
CALL MESSAGE('BAD LINK IN RENUM AT 8 NODE NBC') |
| 717 |
CALL MESSAGE('NO MESH SAVED') |
| 718 |
KKK = 0 |
| 719 |
RETURN |
| 720 |
END IF |
| 721 |
LSTNBC(I) = NEW |
| 722 |
660 CONTINUE |
| 723 |
END IF |
| 724 |
|
| 725 |
C NOW FIX THE SIDE BOUNDARY FLAGS |
| 726 |
|
| 727 |
IF (NBCSID .GT. 0) THEN |
| 728 |
DO 670 I = 1, NVLIST |
| 729 |
NEW = INDX(NNN, LISTN, NSIDEN(I)) |
| 730 |
IF (NEW .EQ. 0) THEN |
| 731 |
CALL MESSAGE('BAD LINK IN RENUM AT 8 NODE SBC') |
| 732 |
CALL MESSAGE('NO MESH SAVED') |
| 733 |
KKK = 0 |
| 734 |
RETURN |
| 735 |
END IF |
| 736 |
NSIDEN(I) = NEW |
| 737 |
670 CONTINUE |
| 738 |
END IF |
| 739 |
END IF |
| 740 |
|
| 741 |
C RENUMBERING COMPLETED |
| 742 |
|
| 743 |
CALL MESSAGE(' ') |
| 744 |
CALL MESSAGE('**************************************************') |
| 745 |
CALL MESSAGE('** MESH PROCESSING COMPLETED **') |
| 746 |
IF (ISBARS .AND. NINE) THEN |
| 747 |
CALL MESSAGE('** THREE NODE BARS OUTPUT '// |
| 748 |
& ' **') |
| 749 |
ENDIF |
| 750 |
IF (NINE) THEN |
| 751 |
CALL MESSAGE('** NINE NODE QUADS OUTPUT '// |
| 752 |
& ' **') |
| 753 |
ELSE IF (EIGHT) THEN |
| 754 |
CALL MESSAGE('** EIGHT NODE QUADS OUTPUT '// |
| 755 |
& ' **') |
| 756 |
END IF |
| 757 |
IF (OPTIM) THEN |
| 758 |
CALL MESSAGE |
| 759 |
& ('** WITH NODE AND ELEMENT NUMBERING OPTIMIZED **') |
| 760 |
|
| 761 |
C FIND LARGEST NODE DIFFERENCE FOR AN ELEMENT |
| 762 |
|
| 763 |
LWID = 0 |
| 764 |
DO 680 K = 1, KKK |
| 765 |
N1 = NXK(1, K) |
| 766 |
N2 = NXK(2, K) |
| 767 |
N3 = NXK(3, K) |
| 768 |
N4 = NXK(4, K) |
| 769 |
IF ((N4 .GT. 0) .AND. ((EIGHT) .OR. (NINE))) THEN |
| 770 |
N5 = NXK(5, K) |
| 771 |
N6 = NXK(6, K) |
| 772 |
N7 = NXK(7, K) |
| 773 |
N8 = NXK(8, K) |
| 774 |
IF (NINE) THEN |
| 775 |
N9 = NXK(9, K) |
| 776 |
NLO = MIN0(N1, N2, N3, N4, N5, N6, N7, N8, N9) |
| 777 |
NHI = MAX0(N1, N2, N3, N4, N5, N6, N7, N8, N9) |
| 778 |
ELSE |
| 779 |
NLO = MIN0(N1, N2, N3, N4, N5, N6, N7, N8) |
| 780 |
NHI = MAX0(N1, N2, N3, N4, N5, N6, N7, N8) |
| 781 |
END IF |
| 782 |
ELSE |
| 783 |
IF (N3 .LE. 0) N3 = N1 |
| 784 |
IF (N4 .LE. 0) N4 = N2 |
| 785 |
NLO = MIN0(N1, N2, N3, N4) |
| 786 |
NHI = MAX0(N1, N2, N3, N4) |
| 787 |
END IF |
| 788 |
LWID = MAX0(LWID, NHI - NLO) |
| 789 |
680 CONTINUE |
| 790 |
WRITE(*, 10000) LWID |
| 791 |
END IF |
| 792 |
WRITE(*, 10010) NNN, KKK, NUMMAT |
| 793 |
CALL MESSAGE('**************************************************') |
| 794 |
|
| 795 |
C RESTORE THE NUID ARRAY AS A POINTER ARRAY OF OLD TO NEW ELEMENTS |
| 796 |
C (MAPDXG ARRAY) |
| 797 |
|
| 798 |
IF (OPTIM) THEN |
| 799 |
DO 690 I = 1, KKK |
| 800 |
NUID(I) = LA(I) |
| 801 |
LIST(NUID(I)) = I |
| 802 |
690 CONTINUE |
| 803 |
ELSE |
| 804 |
DO 700 I = 1, KKK |
| 805 |
NUID(I) = I |
| 806 |
LIST(I) = I |
| 807 |
700 CONTINUE |
| 808 |
END IF |
| 809 |
|
| 810 |
RETURN |
| 811 |
|
| 812 |
10000 FORMAT(' ** LARGEST NODE DIFFERENCE PER ELEMENT:', I6, ' **') |
| 813 |
10010 FORMAT(' ** NODES:', I6, '; ELEMENTS:', I6, '; MATERIALS:', I3, |
| 814 |
& ' **') |
| 815 |
|
| 816 |
END |