![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to setups.f CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / spice|
Return to setups.f CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / spice |
1.1 ! root 1: subroutine setup ! 2: implicit double precision (a-h,o-z) ! 3: c ! 4: c ! 5: c this routine drives the sparse matrix setup used by spice. ! 6: c ! 7: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 8: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 9: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 10: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 11: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 12: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 13: common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, ! 14: 1 nut,nlt,nxtrm,ndist,ntlin,ibr,numvs ! 15: common /miscel/ atime,aprog(3),adate,atitle(10),defl,defw,defad, ! 16: 1 defas,rstats(50),iwidth,lwidth,nopage ! 17: common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts, ! 18: 1 lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof ! 19: common /dc/ tcstar(2),tcstop(2),tcincr(2),icvflg,itcelm(2),kssop, ! 20: 1 kinel,kidin,kovar,kidout ! 21: common /ac/ fstart,fstop,fincr,skw2,refprl,spw2,jacflg,idfreq, ! 22: 1 inoise,nosprt,nosout,nosin,idist,idprt ! 23: common /blank/ value(1000) ! 24: integer nodplc(64) ! 25: complex*16 cvalue(32) ! 26: equivalence (value(1),nodplc(1),cvalue(1)) ! 27: c ! 28: c ! 29: call second(t1) ! 30: nstop=numnod+jelcnt(3)+jelcnt(6)+jelcnt(8)+jelcnt(9)+2*jelcnt(17) ! 31: c ! 32: c reserve matrix locations for each element ! 33: c ! 34: call matptr ! 35: if (nogo.ne.0) go to 1000 ! 36: c ! 37: c reorder matrix pointers for minimal fill-in ! 38: c ! 39: nttbr=0 ! 40: do 120 i=2,nstop ! 41: loc=isr+i ! 42: 110 if (nodplc(loc).eq.0) go to 120 ! 43: loc=nodplc(loc) ! 44: nttbr=nttbr+1 ! 45: go to 110 ! 46: 120 continue ! 47: c... add ground ! 48: nttbr=nttbr+1 ! 49: call reordr ! 50: if (nogo.ne.0) go to 1000 ! 51: nttar=nodplc(iur+nstop+1)-1+nodplc(ilc+nstop+1)-1+nstop ! 52: ifill=nttar-nttbr ! 53: perspa=100.0d0*(1.0d0-dfloat(nttar)/ ! 54: 1 (dfloat(nstop)*dfloat(nstop))) ! 55: iops=0 ! 56: do 130 i=2,nstop ! 57: noffr=nodplc(iur+i+1)-nodplc(iur+i) ! 58: noffc=nodplc(ilc+i+1)-nodplc(ilc+i) ! 59: iops=iops+noffr+noffc*(noffr+2)+1 ! 60: 130 continue ! 61: rstats(20)=nstop ! 62: rstats(21)=nttbr ! 63: rstats(22)=nttar ! 64: rstats(23)=ifill ! 65: rstats(24)=0.0d0 ! 66: rstats(25)=nttar ! 67: rstats(26)=iops ! 68: rstats(27)=perspa ! 69: c ! 70: c store matrix locations ! 71: c ! 72: call matloc ! 73: call clrmem(isr) ! 74: call clrmem(iseq) ! 75: call clrmem(iseq1) ! 76: call clrmem(neqn) ! 77: call clrmem(nodevs) ! 78: call clrmem(ndiag) ! 79: call clrmem(nmoffc) ! 80: call clrmem(numoff) ! 81: call clrmem(iequa) ! 82: call clrmem(jmnode) ! 83: c ! 84: c generate machine code ! 85: c ! 86: 1000 call second(t2) ! 87: rstats(2)=rstats(2)+t2-t1 ! 88: return ! 89: end ! 90: subroutine matptr ! 91: implicit double precision (a-h,o-z) ! 92: c ! 93: c this routine (by calls to the routine reserve) establishes the ! 94: c nonzero-element structure of the circuit equation coefficient matrix. ! 95: c ! 96: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 97: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 98: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 99: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 100: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 101: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 102: common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, ! 103: 1 nut,nlt,nxtrm,ndist,ntlin,ibr,numvs ! 104: common /blank/ value(1000) ! 105: integer nodplc(64) ! 106: complex*16 cvalue(32) ! 107: equivalence (value(1),nodplc(1),cvalue(1)) ! 108: c ! 109: c allocate and initialize storage ! 110: c ! 111: call getm4(isr,nstop+1) ! 112: numvs=jelcnt(3)+jelcnt(6)+jelcnt(8)+jelcnt(9)+2*jelcnt(17) ! 113: call getm4(iseq,numvs) ! 114: call getm4(iseq1,numvs) ! 115: call getm4(neqn,numvs) ! 116: call getm4(nodevs,numnod) ! 117: call getm4(ndiag,nstop) ! 118: call getm4(nmoffc,nstop) ! 119: call getm4(numoff,nstop) ! 120: call crunch ! 121: c ! 122: call zero4(nodplc(isr+1),nstop+1) ! 123: call zero4(nodplc(iseq1+1),numvs) ! 124: call zero4(nodplc(nodevs+1),numnod) ! 125: call zero4(nodplc(ndiag+1),nstop) ! 126: call zero4(nodplc(nmoffc+1),nstop) ! 127: call zero4(nodplc(numoff+1),nstop) ! 128: c ! 129: numvs=0 ! 130: nxtrm=0 ! 131: ndist=0 ! 132: ntlin=1 ! 133: ibr=numnod ! 134: c ! 135: c resistors ! 136: c ! 137: loc=locate(1) ! 138: 110 if (loc.eq.0) go to 120 ! 139: node1=nodplc(loc+2) ! 140: node2=nodplc(loc+3) ! 141: call reserv(node1,node1) ! 142: call reserv(node1,node2) ! 143: call reserv(node2,node1) ! 144: call reserv(node2,node2) ! 145: loc=nodplc(loc) ! 146: go to 110 ! 147: c ! 148: c capacitors ! 149: c ! 150: 120 loc=locate(2) ! 151: 130 if (loc.eq.0) go to 400 ! 152: node1=nodplc(loc+2) ! 153: node2=nodplc(loc+3) ! 154: call reserv(node1,node2) ! 155: call reserv(node2,node1) ! 156: ntemp=nodplc(ndiag+node1) ! 157: call reserv(node1,node1) ! 158: nodplc(ndiag+node1)=ntemp ! 159: ntemp=nodplc(ndiag+node2) ! 160: call reserv(node2,node2) ! 161: nodplc(ndiag+node2)=ntemp ! 162: nodplc(loc+8)=nxtrm+1 ! 163: nxtrm=nxtrm+2 ! 164: loc=nodplc(loc) ! 165: go to 130 ! 166: c ! 167: c inductors ! 168: c ! 169: 400 loc=locate(3) ! 170: 430 if (loc.eq.0) go to 440 ! 171: node1=nodplc(loc+2) ! 172: node2=nodplc(loc+3) ! 173: ibr=ibr+1 ! 174: nodplc(loc+5)=ibr ! 175: call reserv(node1,ibr) ! 176: call reserv(node2,ibr) ! 177: call reserv(ibr,node1) ! 178: call reserv(ibr,node2) ! 179: ntemp=nodplc(ndiag+ibr) ! 180: call reserv(ibr,ibr) ! 181: nodplc(ndiag+ibr)=ntemp ! 182: numvs=numvs+1 ! 183: nodplc(iseq+numvs)=loc ! 184: nodplc(neqn+numvs)=ibr ! 185: nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 ! 186: nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 ! 187: nodplc(loc+11)=nxtrm+1 ! 188: nxtrm=nxtrm+2 ! 189: loc=nodplc(loc) ! 190: go to 430 ! 191: c ! 192: c mutual inductors ! 193: c ! 194: 440 loc=locate(4) ! 195: 450 if (loc.eq.0) go to 460 ! 196: nl1=nodplc(loc+2) ! 197: nl2=nodplc(loc+3) ! 198: nl1=nodplc(nl1+5) ! 199: nl2=nodplc(nl2+5) ! 200: call reserv(nl1,nl2) ! 201: call reserv(nl2,nl1) ! 202: loc=nodplc(loc) ! 203: go to 450 ! 204: c ! 205: c nonlinear voltage-controlled current sources ! 206: c ! 207: 460 loc=locate(5) ! 208: 462 if (loc.eq.0) go to 464 ! 209: node1=nodplc(loc+2) ! 210: node2=nodplc(loc+3) ! 211: ndim=nodplc(loc+4) ! 212: ndim2=ndim+ndim ! 213: locn=nodplc(loc+6) ! 214: do 463 i=1,ndim2 ! 215: node=nodplc(locn+i) ! 216: call reserv(node1,node) ! 217: call reserv(node2,node) ! 218: 463 continue ! 219: nodplc(loc+12)=nxtrm+1 ! 220: nxtrm=nxtrm+1+ndim2 ! 221: loc=nodplc(loc) ! 222: go to 462 ! 223: c ! 224: c nonlinear voltage controlled voltage sources ! 225: c ! 226: 464 loc=locate(6) ! 227: 466 if (loc.eq.0) go to 468 ! 228: node1=nodplc(loc+2) ! 229: node2=nodplc(loc+3) ! 230: ibr=ibr+1 ! 231: nodplc(loc+6)=ibr ! 232: call reserv(node1,ibr) ! 233: call reserv(node2,ibr) ! 234: call reserv(ibr,node1) ! 235: call reserv(ibr,node2) ! 236: numvs=numvs+1 ! 237: nodplc(iseq+numvs)=loc ! 238: nodplc(neqn+numvs)=ibr ! 239: nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 ! 240: nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 ! 241: ndim=nodplc(loc+4) ! 242: ndim2=ndim+ndim ! 243: locn=nodplc(loc+7) ! 244: do 467 i=1,ndim2 ! 245: node=nodplc(locn+i) ! 246: call reserv(ibr,node) ! 247: 467 continue ! 248: nodplc(loc+13)=nxtrm+1 ! 249: nxtrm=nxtrm+2+ndim2 ! 250: loc=nodplc(loc) ! 251: go to 466 ! 252: c ! 253: c voltage sources ! 254: c ! 255: 468 loc=locate(9) ! 256: 470 if (loc.eq.0) go to 472 ! 257: node1=nodplc(loc+2) ! 258: node2=nodplc(loc+3) ! 259: ibr=ibr+1 ! 260: nodplc(loc+6)=ibr ! 261: call reserv(node1,ibr) ! 262: call reserv(node2,ibr) ! 263: call reserv(ibr,node1) ! 264: call reserv(ibr,node2) ! 265: numvs=numvs+1 ! 266: nodplc(iseq+numvs)=loc ! 267: nodplc(neqn+numvs)=ibr ! 268: nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 ! 269: nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 ! 270: loc=nodplc(loc) ! 271: go to 470 ! 272: c ! 273: c nonlinear current controlled current sources ! 274: c ! 275: 472 loc=locate(7) ! 276: 474 if (loc.eq.0) go to 476 ! 277: node1=nodplc(loc+2) ! 278: node2=nodplc(loc+3) ! 279: ndim=nodplc(loc+4) ! 280: locvs=nodplc(loc+6) ! 281: do 475 i=1,ndim ! 282: locvst=nodplc(locvs+i) ! 283: kbr=nodplc(locvst+6) ! 284: call reserv(node1,kbr) ! 285: call reserv(node2,kbr) ! 286: 475 continue ! 287: nodplc(loc+12)=nxtrm+1 ! 288: nxtrm=nxtrm+1+ndim+ndim ! 289: loc=nodplc(loc) ! 290: go to 474 ! 291: c ! 292: c nonlinear current controlled voltage sources ! 293: c ! 294: 476 loc=locate(8) ! 295: 478 if (loc.eq.0) go to 500 ! 296: node1=nodplc(loc+2) ! 297: node2=nodplc(loc+3) ! 298: ibr=ibr+1 ! 299: nodplc(loc+6)=ibr ! 300: call reserv(node1,ibr) ! 301: call reserv(node2,ibr) ! 302: call reserv(ibr,node1) ! 303: call reserv(ibr,node2) ! 304: numvs=numvs+1 ! 305: nodplc(iseq+numvs)=loc ! 306: nodplc(neqn+numvs)=ibr ! 307: nodplc(nodevs+node1)=nodplc(nodevs+node1)+1 ! 308: nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 ! 309: ndim=nodplc(loc+4) ! 310: locvs=nodplc(loc+7) ! 311: do 479 i=1,ndim ! 312: locvst=nodplc(locvs+i) ! 313: kbr=nodplc(locvst+6) ! 314: call reserv(ibr,kbr) ! 315: 479 continue ! 316: nodplc(loc+13)=nxtrm+1 ! 317: nxtrm=nxtrm+2+ndim+ndim ! 318: loc=nodplc(loc) ! 319: go to 478 ! 320: c ! 321: c diodes ! 322: c ! 323: 500 loc=locate(11) ! 324: 510 if (loc.eq.0) go to 520 ! 325: node1=nodplc(loc+2) ! 326: node2=nodplc(loc+3) ! 327: node3=nodplc(loc+4) ! 328: call reserv(node1,node1) ! 329: call reserv(node2,node2) ! 330: call reserv(node3,node3) ! 331: call reserv(node1,node3) ! 332: call reserv(node2,node3) ! 333: call reserv(node3,node1) ! 334: call reserv(node3,node2) ! 335: nodplc(loc+11)=nxtrm+1 ! 336: nxtrm=nxtrm+5 ! 337: nodplc(loc+12)=ndist+1 ! 338: ndist=ndist+7 ! 339: loc=nodplc(loc) ! 340: go to 510 ! 341: c ! 342: c transistors ! 343: c ! 344: 520 loc=locate(12) ! 345: 530 if (loc.eq.0) go to 540 ! 346: node1=nodplc(loc+2) ! 347: node2=nodplc(loc+3) ! 348: node3=nodplc(loc+4) ! 349: node4=nodplc(loc+5) ! 350: node5=nodplc(loc+6) ! 351: node6=nodplc(loc+7) ! 352: node7=nodplc(loc+30) ! 353: call reserv(node1,node1) ! 354: call reserv(node2,node2) ! 355: call reserv(node3,node3) ! 356: call reserv(node4,node4) ! 357: call reserv(node5,node5) ! 358: call reserv(node6,node6) ! 359: call reserv(node1,node4) ! 360: call reserv(node2,node5) ! 361: call reserv(node3,node6) ! 362: call reserv(node4,node5) ! 363: call reserv(node4,node6) ! 364: call reserv(node5,node6) ! 365: call reserv(node4,node1) ! 366: call reserv(node5,node2) ! 367: call reserv(node6,node3) ! 368: call reserv(node5,node4) ! 369: call reserv(node6,node4) ! 370: call reserv(node6,node5) ! 371: call reserv(node7,node7) ! 372: call reserv(node4,node7) ! 373: call reserv(node7,node4) ! 374: call reserv(node2,node4) ! 375: call reserv(node4,node2) ! 376: nodplc(loc+22)=nxtrm+1 ! 377: nxtrm=nxtrm+18 ! 378: nodplc(loc+23)=ndist+1 ! 379: ndist=ndist+21 ! 380: loc=nodplc(loc) ! 381: go to 530 ! 382: c ! 383: c jfets ! 384: c ! 385: 540 loc=locate(13) ! 386: 550 if (loc.eq.0) go to 560 ! 387: node1=nodplc(loc+2) ! 388: node2=nodplc(loc+3) ! 389: node3=nodplc(loc+4) ! 390: node4=nodplc(loc+5) ! 391: node5=nodplc(loc+6) ! 392: call reserv(node1,node1) ! 393: call reserv(node2,node2) ! 394: call reserv(node3,node3) ! 395: call reserv(node4,node4) ! 396: call reserv(node5,node5) ! 397: call reserv(node1,node4) ! 398: call reserv(node2,node4) ! 399: call reserv(node2,node5) ! 400: call reserv(node3,node5) ! 401: call reserv(node4,node5) ! 402: call reserv(node4,node1) ! 403: call reserv(node4,node2) ! 404: call reserv(node5,node2) ! 405: call reserv(node5,node3) ! 406: call reserv(node5,node4) ! 407: nodplc(loc+19)=nxtrm+1 ! 408: nxtrm=nxtrm+13 ! 409: loc=nodplc(loc) ! 410: go to 550 ! 411: c ! 412: c mosfets ! 413: c ! 414: 560 loc=locate(14) ! 415: 570 if (loc.eq.0) go to 600 ! 416: node1=nodplc(loc+2) ! 417: node2=nodplc(loc+3) ! 418: node3=nodplc(loc+4) ! 419: node4=nodplc(loc+5) ! 420: node5=nodplc(loc+6) ! 421: node6=nodplc(loc+7) ! 422: call reserv(node1,node1) ! 423: call reserv(node2,node2) ! 424: call reserv(node3,node3) ! 425: call reserv(node4,node4) ! 426: call reserv(node5,node5) ! 427: call reserv(node6,node6) ! 428: call reserv(node1,node5) ! 429: call reserv(node2,node4) ! 430: call reserv(node2,node5) ! 431: call reserv(node2,node6) ! 432: call reserv(node3,node6) ! 433: call reserv(node4,node5) ! 434: call reserv(node4,node6) ! 435: call reserv(node5,node6) ! 436: call reserv(node5,node1) ! 437: call reserv(node4,node2) ! 438: call reserv(node5,node2) ! 439: call reserv(node6,node2) ! 440: call reserv(node6,node3) ! 441: call reserv(node5,node4) ! 442: call reserv(node6,node4) ! 443: call reserv(node6,node5) ! 444: nodplc(loc+26)=nxtrm+1 ! 445: nxtrm=nxtrm+18 ! 446: loc=nodplc(loc) ! 447: go to 570 ! 448: c ! 449: c transmission lines ! 450: c ! 451: 600 loc=locate(17) ! 452: 610 if (loc.eq.0) go to 1000 ! 453: node1=nodplc(loc+2) ! 454: node2=nodplc(loc+3) ! 455: node3=nodplc(loc+4) ! 456: node4=nodplc(loc+5) ! 457: ni1=nodplc(loc+6) ! 458: ni2=nodplc(loc+7) ! 459: ibr1=ibr+1 ! 460: ibr2=ibr+2 ! 461: ibr=ibr+2 ! 462: nodplc(loc+8)=ibr1 ! 463: nodplc(loc+9)=ibr2 ! 464: call reserv(node1,node1) ! 465: call reserv(node1,ni1) ! 466: call reserv(node2,ibr1) ! 467: call reserv(node3,node3) ! 468: call reserv(node4,ibr2) ! 469: call reserv(ni1,node1) ! 470: call reserv(ni1,ni1) ! 471: call reserv(ni1,ibr1) ! 472: call reserv(ni2,ni2) ! 473: call reserv(ni2,ibr2) ! 474: call reserv(ibr1,node2) ! 475: call reserv(ibr1,node3) ! 476: call reserv(ibr1,node4) ! 477: call reserv(ibr1,ni1) ! 478: call reserv(ibr1,ibr2) ! 479: call reserv(ibr2,node1) ! 480: call reserv(ibr2,node2) ! 481: call reserv(ibr2,node4) ! 482: call reserv(ibr2,ni2) ! 483: call reserv(ibr2,ibr1) ! 484: call reserv(node3,ni2) ! 485: call reserv(ni2,node3) ! 486: numvs=numvs+1 ! 487: nodplc(iseq+numvs)=loc ! 488: nodplc(iseq1+numvs)=1 ! 489: nodplc(neqn+numvs)=ibr1 ! 490: nodplc(nodevs+ni1)=nodplc(nodevs+ni1)+1 ! 491: nodplc(nodevs+node2)=nodplc(nodevs+node2)+1 ! 492: numvs=numvs+1 ! 493: nodplc(iseq+numvs)=loc ! 494: nodplc(iseq1+numvs)=2 ! 495: nodplc(neqn+numvs)=ibr2 ! 496: nodplc(nodevs+ni2)=nodplc(nodevs+ni2)+1 ! 497: nodplc(nodevs+node4)=nodplc(nodevs+node4)+1 ! 498: nodplc(loc+30)=ntlin+1 ! 499: ntlin=ntlin+2 ! 500: loc=nodplc(loc) ! 501: go to 610 ! 502: c ! 503: c finished ! 504: c ! 505: 1000 return ! 506: end ! 507: subroutine reserv (node1,node2) ! 508: implicit double precision (a-h,o-z) ! 509: c ! 510: c this routine records the fact that the (node1, node2) element of ! 511: c the circuit equation coefficient matrix is nonzero. ! 512: c ! 513: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 514: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 515: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 516: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 517: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 518: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 519: common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts, ! 520: 1 lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof ! 521: common /blank/ value(1000) ! 522: integer nodplc(64) ! 523: complex*16 cvalue(32) ! 524: equivalence (value(1),nodplc(1),cvalue(1)) ! 525: c ! 526: c ! 527: if (nogo.ne.0) go to 300 ! 528: c... test for ground ! 529: if (node1.eq.1) go to 300 ! 530: if (node2.eq.1) go to 300 ! 531: c ! 532: c test for (node1,node2) matrix element ! 533: c ! 534: loc=isr+node1 ! 535: 100 if (nodplc(loc).eq.0) go to 110 ! 536: loc=nodplc(loc) ! 537: if (nodplc(loc+1).eq.node2) go to 300 ! 538: go to 100 ! 539: c ! 540: c reserve (node1,node2) matrix element ! 541: c ! 542: 110 nodplc(numoff+node1)=nodplc(numoff+node1)+1 ! 543: nodplc(nmoffc+node2)=nodplc(nmoffc+node2)+1 ! 544: call sizmem(numoff,isize) ! 545: newloc=numoff+isize+1 ! 546: nodplc(loc)=newloc ! 547: call extmem(numoff,2) ! 548: nodplc(newloc)=0 ! 549: nodplc(newloc+1)=node2 ! 550: c ! 551: c mark diagonal ! 552: c ! 553: if (node1.ne.node2) go to 300 ! 554: nodplc(ndiag+node1)=1 ! 555: c ! 556: c finished ! 557: c ! 558: 300 return ! 559: end ! 560: subroutine reordr ! 561: implicit double precision (a-h,o-z) ! 562: c ! 563: c this routine swaps rows in the coefficient matrix to eliminate ! 564: c singularity problems which can be recognized by examining the circuit ! 565: c topology. it then reorders the unknowns to minimize fillin terms ! 566: c which occur during lu factorization. (to maximize sparsity). ! 567: c ! 568: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 569: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 570: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 571: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 572: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 573: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 574: common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, ! 575: 1 nut,nlt,nxtrm,ndist,ntlin,ibr,numvs ! 576: common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts, ! 577: 1 lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof ! 578: common /blank/ value(1000) ! 579: integer nodplc(64) ! 580: complex*16 cvalue(32) ! 581: equivalence (value(1),nodplc(1),cvalue(1)) ! 582: c ! 583: c allocate and initialize storage ! 584: c ! 585: call getm4(iswap,nstop) ! 586: call getm4(iequa,nstop) ! 587: call getm4(iorder,nstop) ! 588: call getm4(jmnode,nstop) ! 589: call getm4(iur,nstop+1) ! 590: call getm4(ilc,nstop+1) ! 591: call getm4(iuc,0) ! 592: call getm4(ilr,0) ! 593: c ! 594: do 10 i=1,nstop ! 595: nodplc(iswap+i)=i ! 596: 10 continue ! 597: call copy4(nodplc(iswap+1),nodplc(iequa+1),nstop) ! 598: call copy4(nodplc(iswap+1),nodplc(iorder+1),nstop) ! 599: call copy4(nodplc(iswap+1),nodplc(jmnode+1),nstop) ! 600: c ! 601: c swap current equations into admittance part of equation matrix ! 602: c ! 603: nextv=1 ! 604: c ! 605: c find suitable voltage source ! 606: c ! 607: 100 if (nextv.gt.numvs) go to 150 ! 608: ix=0 ! 609: do 130 i=nextv,numvs ! 610: loc=nodplc(iseq+i) ! 611: node=nodplc(loc+2) ! 612: nflag=nodplc(iseq1+i) ! 613: if (nflag.eq.1) node=nodplc(loc+6) ! 614: if (nflag.eq.2) node=nodplc(loc+7) ! 615: if (node.eq.1) go to 110 ! 616: if (nodplc(nodevs+node).ge.2) go to 110 ! 617: if (nodplc(ndiag+node).eq.0) go to 140 ! 618: ix=i ! 619: locx=loc ! 620: nodex=node ! 621: 110 node=nodplc(loc+3) ! 622: if (nflag.eq.2) node=nodplc(loc+5) ! 623: if (node.eq.1) go to 130 ! 624: if (nodplc(nodevs+node).ge.2) go to 130 ! 625: 120 if (nodplc(ndiag+node).eq.0) go to 140 ! 626: ix=i ! 627: locx=loc ! 628: nodex=node ! 629: 130 continue ! 630: if (ix.eq.0) go to 590 ! 631: i=ix ! 632: loc=locx ! 633: node=nodex ! 634: c ! 635: c resequence voltage sources ! 636: c ! 637: 140 nodplc(iseq+i)=nodplc(iseq+nextv) ! 638: nodplc(iseq+nextv)=loc ! 639: ltemp=nodplc(iseq1+i) ! 640: nodplc(iseq1+i)=nodplc(iseq1+nextv) ! 641: nodplc(iseq1+nextv)=ltemp ! 642: ibr=nodplc(neqn+i) ! 643: nodplc(neqn+i)=nodplc(neqn+nextv) ! 644: nodplc(neqn+nextv)=ibr ! 645: node1=nodplc(loc+2) ! 646: if (ltemp.eq.1) node1=nodplc(loc+6) ! 647: if (ltemp.eq.2) node1=nodplc(loc+7) ! 648: node2=nodplc(loc+3) ! 649: if (ltemp.eq.1) node2=nodplc(loc+3) ! 650: if (ltemp.eq.2) node2=nodplc(loc+5) ! 651: nodplc(nodevs+node1)=nodplc(nodevs+node1)-1 ! 652: nodplc(nodevs+node2)=nodplc(nodevs+node2)-1 ! 653: c ! 654: c set row swap indicators ! 655: c ! 656: l=nodplc(iswap+ibr) ! 657: j=nodplc(iequa+node) ! 658: nodplc(iswap+j)=l ! 659: nodplc(iequa+l)=j ! 660: nodplc(iswap+ibr)=node ! 661: nodplc(iequa+node)=ibr ! 662: nextv=nextv+1 ! 663: go to 100 ! 664: c ! 665: c initialize matrix pointers ! 666: c ! 667: 150 nexnod=2 ! 668: nut=0 ! 669: nlt=0 ! 670: 160 nodplc(iur+nexnod)=nut+1 ! 671: nodplc(ilc+nexnod)=nlt+1 ! 672: if (nexnod.ge.nstop) go to 500 ! 673: c ! 674: c select row for reordering ! 675: c ! 676: load=nodplc(iorder+nexnod) ! 677: ir=nodplc(iswap+load) ! 678: imin=nodplc(numoff+ir)*nodplc(nmoffc+load) ! 679: nstart=nexnod+1 ! 680: do 200 i=nstart,nstop ! 681: lc=nodplc(iorder+i) ! 682: ir=nodplc(iswap+lc) ! 683: nrc=nodplc(numoff+ir)*nodplc(nmoffc+lc) ! 684: if (nrc.ge.imin) go to 200 ! 685: imin=nrc ! 686: load=lc ! 687: 200 continue ! 688: c ! 689: c set reorder indicators ! 690: c ! 691: ir=nodplc(iswap+load) ! 692: nodplc(numoff+ir)=nodplc(numoff+ir)-1 ! 693: nodplc(nmoffc+load)=nodplc(nmoffc+load)-1 ! 694: lc=nodplc(iorder+nexnod) ! 695: jr=nodplc(jmnode+load) ! 696: nodplc(iorder+jr)=lc ! 697: nodplc(jmnode+lc)=jr ! 698: nodplc(iorder+nexnod)=load ! 699: nodplc(jmnode+load)=nexnod ! 700: c ! 701: c set pointers for upper triangle ! 702: c ! 703: loc=isr+ir ! 704: 330 if (nodplc(loc).eq.0) go to 340 ! 705: loc=nodplc(loc) ! 706: ic=nodplc(loc+1) ! 707: jc=nodplc(jmnode+ic) ! 708: if (jc.le.nexnod) go to 330 ! 709: nodplc(nmoffc+ic)=nodplc(nmoffc+ic)-1 ! 710: call extmem(iuc,1) ! 711: nodplc(iuc+nut+1)=ic ! 712: nut=nut+1 ! 713: go to 330 ! 714: c ! 715: c set pointers for lower triangle ! 716: c ! 717: 340 do 390 jr=nstart,nstop ! 718: lc=nodplc(iorder+jr) ! 719: ir=nodplc(iswap+lc) ! 720: loc=isr+ir ! 721: 350 if (nodplc(loc).eq.0) go to 390 ! 722: loc=nodplc(loc) ! 723: if (nodplc(loc+1).ne.load) go to 350 ! 724: nodplc(numoff+ir)=nodplc(numoff+ir)-1 ! 725: call extmem(ilr,1) ! 726: nodplc(ilr+nlt+1)=lc ! 727: nlt=nlt+1 ! 728: c ! 729: c check for fill-in terms ! 730: c ! 731: nct=nodplc(iur+nexnod) ! 732: 360 if (nct.ge.(nut+1)) go to 390 ! 733: ic=nodplc(iuc+nct) ! 734: call reserv(ir,ic) ! 735: nct=nct+1 ! 736: go to 360 ! 737: 390 continue ! 738: c ! 739: c ! 740: nexnod=nexnod+1 ! 741: go to 160 ! 742: c ! 743: c reordering finished ! 744: c ! 745: 500 nodplc(iur+nstop+1)=nut+1 ! 746: nodplc(ilc+nstop+1)=nlt+1 ! 747: if (nut.eq.0) go to 515 ! 748: do 510 i=1,nut ! 749: j=nodplc(iuc+i) ! 750: nodplc(iuc+i)=nodplc(jmnode+j) ! 751: 510 continue ! 752: 515 if (nlt.eq.0) go to 600 ! 753: do 520 i=1,nlt ! 754: j=nodplc(ilr+i) ! 755: nodplc(ilr+i)=nodplc(jmnode+j) ! 756: 520 continue ! 757: go to 600 ! 758: c ! 759: c error - voltage-source/inductor/transmission-line loop detected ... ! 760: c ! 761: 590 nogo=1 ! 762: write (6,591) ! 763: c... loop should have been detected in topchk ! 764: 591 format('0*abort*: spice internal error in reordr'/) ! 765: c ! 766: c finished ! 767: c ! 768: 600 return ! 769: end ! 770: subroutine matloc ! 771: implicit double precision (a-h,o-z) ! 772: c ! 773: c this routine stores the locations of the various matrix terms to ! 774: c which the different circuit elements contribute. ! 775: c ! 776: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 777: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 778: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 779: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 780: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 781: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 782: common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, ! 783: 1 nut,nlt,nxtrm,ndist,ntlin,ibr,numvs ! 784: common /blank/ value(1000) ! 785: integer nodplc(64) ! 786: complex*16 cvalue(32) ! 787: equivalence (value(1),nodplc(1),cvalue(1)) ! 788: c ! 789: c resistors ! 790: c ! 791: loc=locate(1) ! 792: 690 if (loc.eq.0) go to 700 ! 793: node1=nodplc(loc+2) ! 794: node2=nodplc(loc+3) ! 795: nodplc(loc+4)=indxx(node1,node2) ! 796: nodplc(loc+5)=indxx(node2,node1) ! 797: nodplc(loc+6)=indxx(node1,node1) ! 798: nodplc(loc+7)=indxx(node2,node2) ! 799: loc=nodplc(loc) ! 800: go to 690 ! 801: c ! 802: c capacitors ! 803: c ! 804: 700 loc=locate(2) ! 805: 710 if (loc.eq.0) go to 720 ! 806: node1=nodplc(loc+2) ! 807: node2=nodplc(loc+3) ! 808: nodplc(loc+5)=indxx(node1,node2) ! 809: nodplc(loc+6)=indxx(node2,node1) ! 810: nodplc(loc+10)=indxx(node1,node1) ! 811: nodplc(loc+11)=indxx(node2,node2) ! 812: loc=nodplc(loc) ! 813: go to 710 ! 814: c ! 815: c inductors ! 816: c ! 817: 720 loc=locate(3) ! 818: 730 if (loc.eq.0) go to 740 ! 819: node1=nodplc(loc+2) ! 820: node2=nodplc(loc+3) ! 821: ibr=nodplc(loc+5) ! 822: nodplc(loc+6)=indxx(node1,ibr) ! 823: nodplc(loc+7)=indxx(node2,ibr) ! 824: nodplc(loc+8)=indxx(ibr,node1) ! 825: nodplc(loc+9)=indxx(ibr,node2) ! 826: nodplc(loc+13)=indxx(ibr,ibr) ! 827: loc=nodplc(loc) ! 828: go to 730 ! 829: c ! 830: c mutual inductances ! 831: c ! 832: 740 loc=locate(4) ! 833: 750 if (loc.eq.0) go to 760 ! 834: nl1=nodplc(loc+2) ! 835: nl2=nodplc(loc+3) ! 836: ibr1=nodplc(nl1+5) ! 837: ibr2=nodplc(nl2+5) ! 838: nodplc(loc+4)=indxx(ibr1,ibr2) ! 839: nodplc(loc+5)=indxx(ibr2,ibr1) ! 840: loc=nodplc(loc) ! 841: go to 750 ! 842: c ! 843: c nonlinear voltage controlled current sources ! 844: c ! 845: 760 loc=locate(5) ! 846: 762 if (loc.eq.0) go to 764 ! 847: node1=nodplc(loc+2) ! 848: node2=nodplc(loc+3) ! 849: ndim=nodplc(loc+4) ! 850: lnod=nodplc(loc+6) ! 851: lmat=nodplc(loc+7) ! 852: do 763 i=1,ndim ! 853: node3=nodplc(lnod+1) ! 854: node4=nodplc(lnod+2) ! 855: lnod=lnod+2 ! 856: nodplc(lmat+1)=indxx(node1,node3) ! 857: nodplc(lmat+2)=indxx(node1,node4) ! 858: nodplc(lmat+3)=indxx(node2,node3) ! 859: nodplc(lmat+4)=indxx(node2,node4) ! 860: lmat=lmat+4 ! 861: 763 continue ! 862: loc=nodplc(loc) ! 863: go to 762 ! 864: c ! 865: c nonlinear voltage controlled voltage sources ! 866: c ! 867: 764 loc=locate(6) ! 868: 766 if (loc.eq.0) go to 768 ! 869: node1=nodplc(loc+2) ! 870: node2=nodplc(loc+3) ! 871: ndim=nodplc(loc+4) ! 872: ibr=nodplc(loc+6) ! 873: lnod=nodplc(loc+7) ! 874: lmat=nodplc(loc+8) ! 875: nodplc(lmat+1)=indxx(node1,ibr) ! 876: nodplc(lmat+2)=indxx(node2,ibr) ! 877: nodplc(lmat+3)=indxx(ibr,node1) ! 878: nodplc(lmat+4)=indxx(ibr,node2) ! 879: lmat=lmat+4 ! 880: do 767 i=1,ndim ! 881: node3=nodplc(lnod+1) ! 882: node4=nodplc(lnod+2) ! 883: lnod=lnod+2 ! 884: nodplc(lmat+1)=indxx(ibr,node3) ! 885: nodplc(lmat+2)=indxx(ibr,node4) ! 886: lmat=lmat+2 ! 887: 767 continue ! 888: loc=nodplc(loc) ! 889: go to 766 ! 890: c ! 891: c nonlinear current controlled current sources ! 892: c ! 893: 768 loc=locate(7) ! 894: 770 if (loc.eq.0) go to 772 ! 895: node1=nodplc(loc+2) ! 896: node2=nodplc(loc+3) ! 897: ndim=nodplc(loc+4) ! 898: locvs=nodplc(loc+6) ! 899: lmat=nodplc(loc+7) ! 900: do 771 i=1,ndim ! 901: locvst=nodplc(locvs+i) ! 902: ibr=nodplc(locvst+6) ! 903: nodplc(lmat+1)=indxx(node1,ibr) ! 904: nodplc(lmat+2)=indxx(node2,ibr) ! 905: lmat=lmat+2 ! 906: 771 continue ! 907: loc=nodplc(loc) ! 908: go to 770 ! 909: c ! 910: c nonlinear current controlled voltage sources ! 911: c ! 912: 772 loc=locate(8) ! 913: 774 if (loc.eq.0) go to 780 ! 914: node1=nodplc(loc+2) ! 915: node2=nodplc(loc+3) ! 916: ndim=nodplc(loc+4) ! 917: ibr=nodplc(loc+6) ! 918: locvs=nodplc(loc+7) ! 919: lmat=nodplc(loc+8) ! 920: nodplc(lmat+1)=indxx(node1,ibr) ! 921: nodplc(lmat+2)=indxx(node2,ibr) ! 922: nodplc(lmat+3)=indxx(ibr,node1) ! 923: nodplc(lmat+4)=indxx(ibr,node2) ! 924: lmat=lmat+4 ! 925: do 775 i=1,ndim ! 926: locvst=nodplc(locvs+i) ! 927: kbr=nodplc(locvst+6) ! 928: nodplc(lmat+i)=indxx(ibr,kbr) ! 929: 775 continue ! 930: loc=nodplc(loc) ! 931: go to 774 ! 932: c ! 933: c voltage sources ! 934: c ! 935: 780 loc=locate(9) ! 936: 790 if (loc.eq.0) go to 800 ! 937: node1=nodplc(loc+2) ! 938: node2=nodplc(loc+3) ! 939: iptr=nodplc(loc+6) ! 940: nodplc(loc+7)=indxx(node1,iptr) ! 941: nodplc(loc+8)=indxx(node2,iptr) ! 942: nodplc(loc+9)=indxx(iptr,node1) ! 943: nodplc(loc+10)=indxx(iptr,node2) ! 944: loc=nodplc(loc) ! 945: go to 790 ! 946: c ! 947: c diodes ! 948: c ! 949: 800 loc=locate(11) ! 950: 810 if (loc.eq.0) go to 820 ! 951: node1=nodplc(loc+2) ! 952: node2=nodplc(loc+3) ! 953: node3=nodplc(loc+4) ! 954: nodplc(loc+7)=indxx(node1,node3) ! 955: nodplc(loc+8)=indxx(node2,node3) ! 956: nodplc(loc+9)=indxx(node3,node1) ! 957: nodplc(loc+10)=indxx(node3,node2) ! 958: nodplc(loc+13)=indxx(node1,node1) ! 959: nodplc(loc+14)=indxx(node2,node2) ! 960: nodplc(loc+15)=indxx(node3,node3) ! 961: loc=nodplc(loc) ! 962: go to 810 ! 963: c ! 964: c transistors ! 965: c ! 966: 820 loc=locate(12) ! 967: 830 if (loc.eq.0) go to 840 ! 968: node1=nodplc(loc+2) ! 969: node2=nodplc(loc+3) ! 970: node3=nodplc(loc+4) ! 971: node4=nodplc(loc+5) ! 972: node5=nodplc(loc+6) ! 973: node6=nodplc(loc+7) ! 974: node7=nodplc(loc+30) ! 975: nodplc(loc+10)=indxx(node1,node4) ! 976: nodplc(loc+11)=indxx(node2,node5) ! 977: nodplc(loc+12)=indxx(node3,node6) ! 978: nodplc(loc+13)=indxx(node4,node1) ! 979: nodplc(loc+14)=indxx(node4,node5) ! 980: nodplc(loc+15)=indxx(node4,node6) ! 981: nodplc(loc+16)=indxx(node5,node2) ! 982: nodplc(loc+17)=indxx(node5,node4) ! 983: nodplc(loc+18)=indxx(node5,node6) ! 984: nodplc(loc+19)=indxx(node6,node3) ! 985: nodplc(loc+20)=indxx(node6,node4) ! 986: nodplc(loc+21)=indxx(node6,node5) ! 987: nodplc(loc+24)=indxx(node1,node1) ! 988: nodplc(loc+25)=indxx(node2,node2) ! 989: nodplc(loc+26)=indxx(node3,node3) ! 990: nodplc(loc+27)=indxx(node4,node4) ! 991: nodplc(loc+28)=indxx(node5,node5) ! 992: nodplc(loc+29)=indxx(node6,node6) ! 993: nodplc(loc+31)=indxx(node7,node7) ! 994: nodplc(loc+32)=indxx(node4,node7) ! 995: nodplc(loc+33)=indxx(node7,node4) ! 996: nodplc(loc+34)=indxx(node2,node4) ! 997: nodplc(loc+35)=indxx(node4,node2) ! 998: loc=nodplc(loc) ! 999: go to 830 ! 1000: c ! 1001: c jfets ! 1002: c ! 1003: 840 loc=locate(13) ! 1004: 850 if (loc.eq.0) go to 860 ! 1005: node1=nodplc(loc+2) ! 1006: node2=nodplc(loc+3) ! 1007: node3=nodplc(loc+4) ! 1008: node4=nodplc(loc+5) ! 1009: node5=nodplc(loc+6) ! 1010: nodplc(loc+9)=indxx(node1,node4) ! 1011: nodplc(loc+10)=indxx(node2,node4) ! 1012: nodplc(loc+11)=indxx(node2,node5) ! 1013: nodplc(loc+12)=indxx(node3,node5) ! 1014: nodplc(loc+13)=indxx(node4,node1) ! 1015: nodplc(loc+14)=indxx(node4,node2) ! 1016: nodplc(loc+15)=indxx(node4,node5) ! 1017: nodplc(loc+16)=indxx(node5,node2) ! 1018: nodplc(loc+17)=indxx(node5,node3) ! 1019: nodplc(loc+18)=indxx(node5,node4) ! 1020: nodplc(loc+20)=indxx(node1,node1) ! 1021: nodplc(loc+21)=indxx(node2,node2) ! 1022: nodplc(loc+22)=indxx(node3,node3) ! 1023: nodplc(loc+23)=indxx(node4,node4) ! 1024: nodplc(loc+24)=indxx(node5,node5) ! 1025: loc=nodplc(loc) ! 1026: go to 850 ! 1027: c ! 1028: c mosfets ! 1029: c ! 1030: 860 loc=locate(14) ! 1031: 870 if (loc.eq.0) go to 900 ! 1032: node1=nodplc(loc+2) ! 1033: node2=nodplc(loc+3) ! 1034: node3=nodplc(loc+4) ! 1035: node4=nodplc(loc+5) ! 1036: node5=nodplc(loc+6) ! 1037: node6=nodplc(loc+7) ! 1038: nodplc(loc+10)=indxx(node1,node5) ! 1039: nodplc(loc+11)=indxx(node2,node4) ! 1040: nodplc(loc+12)=indxx(node2,node5) ! 1041: nodplc(loc+13)=indxx(node2,node6) ! 1042: nodplc(loc+14)=indxx(node3,node6) ! 1043: nodplc(loc+15)=indxx(node4,node2) ! 1044: nodplc(loc+16)=indxx(node4,node5) ! 1045: nodplc(loc+17)=indxx(node4,node6) ! 1046: nodplc(loc+18)=indxx(node5,node1) ! 1047: nodplc(loc+19)=indxx(node5,node2) ! 1048: nodplc(loc+20)=indxx(node5,node4) ! 1049: nodplc(loc+21)=indxx(node5,node6) ! 1050: nodplc(loc+22)=indxx(node6,node2) ! 1051: nodplc(loc+23)=indxx(node6,node3) ! 1052: nodplc(loc+24)=indxx(node6,node4) ! 1053: nodplc(loc+25)=indxx(node6,node5) ! 1054: nodplc(loc+27)=indxx(node1,node1) ! 1055: nodplc(loc+28)=indxx(node2,node2) ! 1056: nodplc(loc+29)=indxx(node3,node3) ! 1057: nodplc(loc+30)=indxx(node4,node4) ! 1058: nodplc(loc+31)=indxx(node5,node5) ! 1059: nodplc(loc+32)=indxx(node6,node6) ! 1060: loc=nodplc(loc) ! 1061: go to 870 ! 1062: c ! 1063: c transmission lines ! 1064: c ! 1065: 900 loc=locate(17) ! 1066: 910 if (loc.eq.0) go to 1000 ! 1067: node1=nodplc(loc+2) ! 1068: node2=nodplc(loc+3) ! 1069: node3=nodplc(loc+4) ! 1070: node4=nodplc(loc+5) ! 1071: ni1=nodplc(loc+6) ! 1072: ni2=nodplc(loc+7) ! 1073: ibr1=nodplc(loc+8) ! 1074: ibr2=nodplc(loc+9) ! 1075: nodplc(loc+10)=indxx(node1,node1) ! 1076: nodplc(loc+11)=indxx(node1,ni1) ! 1077: nodplc(loc+12)=indxx(node2,ibr1) ! 1078: nodplc(loc+13)=indxx(node3,node3) ! 1079: nodplc(loc+14)=indxx(node4,ibr2) ! 1080: nodplc(loc+15)=indxx(ni1,node1) ! 1081: nodplc(loc+16)=indxx(ni1,ni1) ! 1082: nodplc(loc+17)=indxx(ni1,ibr1) ! 1083: nodplc(loc+18)=indxx(ni2,ni2) ! 1084: nodplc(loc+19)=indxx(ni2,ibr2) ! 1085: nodplc(loc+20)=indxx(ibr1,node2) ! 1086: nodplc(loc+21)=indxx(ibr1,node3) ! 1087: nodplc(loc+22)=indxx(ibr1,node4) ! 1088: nodplc(loc+23)=indxx(ibr1,ni1) ! 1089: nodplc(loc+24)=indxx(ibr1,ibr2) ! 1090: nodplc(loc+25)=indxx(ibr2,node1) ! 1091: nodplc(loc+26)=indxx(ibr2,node2) ! 1092: nodplc(loc+27)=indxx(ibr2,node4) ! 1093: nodplc(loc+28)=indxx(ibr2,ni2) ! 1094: nodplc(loc+29)=indxx(ibr2,ibr1) ! 1095: nodplc(loc+31)=indxx(node3,ni2) ! 1096: nodplc(loc+32)=indxx(ni2,node3) ! 1097: loc=nodplc(loc) ! 1098: go to 910 ! 1099: c ! 1100: c .nodeset ! 1101: c ! 1102: 1000 call sizmem(nsnod,nic) ! 1103: if(nic.eq.0) go to 1020 ! 1104: call getm4(nsmat,nic) ! 1105: do 1010 i=1,nic ! 1106: node=nodplc(nsnod+i) ! 1107: nodplc(nsmat+i)=indxx(node,node) ! 1108: 1010 continue ! 1109: c ! 1110: c transient initial conditions ! 1111: c ! 1112: 1020 call sizmem(icnod,nic) ! 1113: if(nic.eq.0) go to 1100 ! 1114: call getm4(icmat,nic) ! 1115: do 1030 i=1,nic ! 1116: node=nodplc(icnod+i) ! 1117: nodplc(icmat+i)=indxx(node,node) ! 1118: 1030 continue ! 1119: c ! 1120: c finished ! 1121: c ! 1122: 1100 return ! 1123: end ! 1124: integer function indxx(node1,node2) ! 1125: implicit double precision (a-h,o-z) ! 1126: c ! 1127: c this routine maps a (row, column) matrix term specification into ! 1128: c the offset from the origin of the matrix storage at which the term is ! 1129: c actually located. ! 1130: c ! 1131: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 1132: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 1133: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 1134: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 1135: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 1136: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 1137: common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, ! 1138: 1 nut,nlt,nxtrm,ndist,ntlin,ibr,numvs ! 1139: common /blank/ value(1000) ! 1140: integer nodplc(64) ! 1141: complex*16 cvalue(32) ! 1142: equivalence (value(1),nodplc(1),cvalue(1)) ! 1143: c ! 1144: c check for ground ! 1145: c ! 1146: if (node1.eq.1) go to 400 ! 1147: if (node2.eq.1) go to 400 ! 1148: c ! 1149: n1=nodplc(iequa+node1) ! 1150: n1=nodplc(jmnode+n1) ! 1151: n2=nodplc(jmnode+node2) ! 1152: c ! 1153: c ! 1154: if (n1-n2) 100,200,300 ! 1155: c ! 1156: c upper triangle ! 1157: c ! 1158: 100 ns=nodplc(iur+n1) ! 1159: ne=nodplc(iur+n1+1) ! 1160: 110 if (ns.ge.ne) go to 400 ! 1161: if (nodplc(iuc+ns).eq.n2) go to 120 ! 1162: ns=ns+1 ! 1163: go to 110 ! 1164: 120 indxx=nstop+ns ! 1165: go to 500 ! 1166: c ! 1167: c diagonal ! 1168: c ! 1169: 200 indxx=node2 ! 1170: go to 500 ! 1171: c ! 1172: c lower triangle ! 1173: c ! 1174: 300 ns=nodplc(ilc+n2) ! 1175: ne=nodplc(ilc+n2+1) ! 1176: 310 if (ns.ge.ne) go to 400 ! 1177: if (nodplc(ilr+ns).eq.n1) go to 320 ! 1178: ns=ns+1 ! 1179: go to 310 ! 1180: 320 indxx=nstop+nut+ns ! 1181: go to 500 ! 1182: c ! 1183: c unused location ! 1184: c ! 1185: 400 indxx=1 ! 1186: c ! 1187: c finished ! 1188: c ! 1189: 500 return ! 1190: end ! 1191: subroutine codgen ! 1192: implicit double precision (a-h,o-z) ! 1193: c ! 1194: c this routine generates machine instructions (for the cdc 6400) to ! 1195: c lu-factor and solve the set of circuit equations. ! 1196: c ! 1197: common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, ! 1198: 1 isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, ! 1199: 2 junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, ! 1200: 3 nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, ! 1201: 4 lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, ! 1202: 5 imynl,imvn,lcvn,loutpt,nsnod,nsmat,nsval,icnod,icmat,icval ! 1203: common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, ! 1204: 1 nut,nlt,nxtrm,ndist,ntlin,ibr,numvs ! 1205: common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts, ! 1206: 1 lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,igoof,nogo,keof ! 1207: common /knstnt/ twopi,xlog2,xlog10,root2,rad,boltz,charge,ctok, ! 1208: 1 gmin,reltol,abstol,vntol,trtol,chgtol,eps0,epssil,epsox ! 1209: common /blank/ value(1000) ! 1210: integer nodplc(64) ! 1211: complex*16 cvalue(32) ! 1212: equivalence (value(1),nodplc(1),cvalue(1)) ! 1213: return ! 1214: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.