![[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.