[Cyan]<DATools6.0>Jasmine>JasmineNetwork.mesa!2

JasmineNetwork.mesa

Created by Neil Gunther, June 19, 1986 2:42:55 pm PDT

Last Edited by: Neil Gunther June 20, 1986 10:28:28 pm PDT

DIRECTORY

CStitching,

IO,

Jasmine,

Real,

Rope,

SymTab,

TerminalIO;

JasmineNetwork: CEDAR PROGRAM

IMPORTS CStitching, IO, Real, SymTab, TerminalIO

= BEGIN

OPEN Jasmine, Real;

AspectType: TYPE = {vert, horiz, square};

BranchType: TYPE = {none, leftT, rightT, inverseT, T, L, reverseL, inverseL, inverseRevL, straight, fourWay};

JasmineModelLocation: TYPE = RECORD [row: INT, col: INT];

JasmineMacro: TYPE = REF JasmineMacroRec;

JasmineMacroRec: TYPE = RECORD [

macroType: JasmineObject ← polyCont,

JMapLoc: JasmineModelLocation ← [0, 0],

wireAspect: AspectType ← vert,

branch: BranchType ← T,

resistance: REAL ← 0.0,

capacitance: REAL ← 0.0,

inductance: REAL ← 0.0,

xtorSize:

xtorCount: INT ← 0

];

resolution: INT ← 4;

Volts: TYPE = REAL;

kOhm: TYPE = REAL;

pF: TYPE = REAL;

mA: TYPE = REAL;

uH: TYPE = REAL;

ScaleMap: PROC [tile: CStitching.Tile] RETURNS [loc: JasmineModelLocation] = {

lambda: INT ← 8;

x, y, scale: INT ← 0;

r: CStitching.Rect ← CStitching.Area[tile];

IF resolution<1 THEN resolution𡤁

scale ← resolution*lambda;

x ← Round[Float[r.x1+(r.x2-r.x1)/2]/scale];

y ← Round[Float[r.y1+(r.y2-r.y1)/2]/scale];

IF x<1 THEN x𡤁 IF y<1 THEN y𡤁

IF x>INT.LAST THEN x←INT.LAST; IF y>INT.LAST THEN y←INT.LAST;

loc ← [x, y];

};

CreateModel: PROC [tesselation: CStitching.Tesselation] RETURNS [model: SymTab.Ref] = {

InsertMacro: CStitching.TileProc

--PROC [tile: Tile, data: REF]-- = {

JLayer: JasmineObjectInLayer ← NARROW[tile.value];

JObject: JasmineObject ← JLayer.object;

r: CStitching.Rect ← CStitching.Area[tile];

AccumulateTransistor: PROC [] = {

};

AspectRatio: PROC RETURNS [ar: AspectType] = {

-- Rect: TYPE = RECORD [x1, y1, x2, y2: INT];

ar ← SELECT TRUE FROM

(r.x2-r.x1)>(r.y2-r.y1) => horiz,

(r.x2-r.x1)<(r.y2-r.y1) => vert,

ENDCASE => square;

};

Branching: PROC RETURNS [branch: BranchType] = {

tWest, tEast, tSouth, tNorth: CStitching.Tile;

N, S, E, W: INT ← 0;

tEast ← CStitching.NE[tile];

IF tEast.value#NIL THEN E ← 1;

TRUSTED {tSouth ← LOOPHOLE[tile.wS]};

IF tSouth.value#NIL THEN S ← 1;

tWest ← CStitching.SW[tile];

IF tWest.value#NIL THEN W ← 1;

TRUSTED {tNorth ← LOOPHOLE[tile.eN]};

IF tNorth.value#NIL THEN N ← 1;

SELECT (N+S+E+W) FROM

4 => branch ← fourWay;

3 => SELECT TRUE FROM

N+(E+W)=3 => branch ← inverseT;

N+(E+S)=3 => branch ← rightT;

N+(W+S)=3 => branch ← leftT;

S+(E+W)=3 => branch ← T;

ENDCASE => NULL;

2 => SELECT TRUE FROM

N+S=2 => branch ← straight;

N+E=2 => branch ← L;

N+W=2 => branch ← reverseL;

S+E=2 => branch ← inverseL;

S+W=2 => branch ← inverseRevL;

ENDCASE => NULL;

1 => branch ← straight;

ENDCASE => NULL;

};

ContactResistance: PROC RETURNS [R: kOhm] = {

R ← SELECT JObject FROM

nDifCont => 30*1E-3,

pDifCont => 120*1E-3,

polyCont => 25*1E-3,

ENDCASE --Via-- => 1E-3;

};

WireResistance: PROC RETURNS [R: kOhm] = {

Squares: PROC [CStitching.Rect] RETURNS [sqrs: REAL] = {

len: INT ← (r.x2-r.x1);

wid: INT ← (r.y2-r.y1);

IF len > wid THEN sqrs ← Real.Float[len]/wid

ELSE sqrs ← Real.Float[wid]/len;

};

Re: QuickAndDirty.tioga

m1Resistivity: REAL ← 0.065;

m2Resistivity: REAL ← 0.042;

polyResistivity: REAL ← 3.5;

nDifResistivity: REAL ← 35;

pDifResistivity: REAL ← 120;

R ← SELECT JObject FROM

m1Wire => Squares[r]*m1Resistivity*1E-3,

m2Wire => Squares[r]*m2Resistivity*1E-3,

polyWire => Squares[r]*polyResistivity*1E-3,

nDifWire => Squares[r]*nDifResistivity*1E-3,

ENDCASE => Squares[r]*pDifResistivity*1E-3

};

WireInductance: PROC RETURNS [L: uH] = {

};

WireCapacitance: PROC RETURNS [C: pF] = {

};

symbol: Rope.ROPE;

jasmineMacro: JasmineMacro ← NEW[JasmineMacroRec];

jasmineMacro.macroType ← JObject;

SELECT jasmineMacro.macroType FROM

m1Wire, m2Wire, nDifWire, pDifWire, polyWire => {

jasmineMacro.wireAspect ← AspectRatio[];

jasmineMacro.resistance ← WireResistance[];

jasmineMacro.inductance ← WireInductance[];

jasmineMacro.capacitance ← WireCapacitance[];

jasmineMacro.branch ← Branching[];

};

nDifCont, pDifCont, polyCont, Via => {

jasmineMacro.resistance ← ContactResistance[];

jasmineMacro.branch ← Branching[];

};

nTran, nTranL, pTran, pTranL => {AccumulateTransistor[];};

ENDCASE => NULL;

symbol ← MapCovert[jasmineMacro.JMapLoc ← ScaleMap[tile]];

[] ← SymTab.Store[x: model, key: symbol, val: jasmineMacro];

}; --InsertMacro

model ← SymTab.Create[];

CStitching.EnumerateArea[plane: tesselation, rect: CStitching.all, eachTile: InsertMacro];

PrintModel[model];

}; --CreateModel

MapCovert: PROC [jml: JasmineModelLocation] RETURNS [sym: Rope.ROPE] = {

sym ← IO.PutFR["[%g, %g]", IO.int[jml.row], IO.int[jml.col]];

};

PrintModel: PROC [model: SymTab.Ref] = {

PrintMacro: PROC = {

FOR i: INT IN [0..model.size] DO

searchLocation.row ← i;

FOR j: INT IN [0..model.size] DO

searchLocation.col ← j;

[thereIs, val] ← SymTab.Fetch[model, MapCovert[searchLocation]];

IF thereIs THEN {

macro: JasmineMacro ← NARROW[val];

TerminalIO.WriteRope["\nMacro: "];

TerminalIO.WriteRope[MapCovert[macro.JMapLoc]];

SELECT macro.macroType FROM

m1Wire, m2Wire, nDifWire, pDifWire, polyWire => {

IF macro.wireAspect=vert THEN TerminalIO.WriteRope[" | "]

ELSE TerminalIO.WriteRope[" -- "];

TerminalIO.WriteF[" %g K ", IO.real[macro.resistance]];

};

nDifCont, pDifCont, polyCont, Via => {

SELECT macro.branch FROM

leftT => TerminalIO.WriteRope[" --| "];

rightT=> TerminalIO.WriteRope[" |-- "];

inverseT=> TerminalIO.WriteRope[" —L "];

T=> TerminalIO.WriteRope[" T "];

L => TerminalIO.WriteRope[" L "];

reverseL => TerminalIO.WriteRope[" ←L "];

inverseL => TerminalIO.WriteRope[" F "];

inverseRevL => TerminalIO.WriteRope[" 𡤏 "];

straight => TerminalIO.WriteRope[" * "];

fourWay=> TerminalIO.WriteRope[" + "];

ENDCASE => NULL;

TerminalIO.WriteF[" %g K ", IO.real[macro.resistance]];

};

nTran, nTranL, pTran, pTranL => TerminalIO.WriteRope[" -[ "];

ENDCASE => NULL;

macroCount ← macroCount.SUCC;

};

ENDLOOP;

};

val: REF ANY;

thereIs: BOOL;

macroCount: INT ← 0;

searchLocation: JasmineModelLocation;

PrintMacro[];

TerminalIO.WriteF["\nTotal: %g, Scale: %g lambda\n\n", IO.int[macroCount], IO.int[resolution]];

}; --PrintModel

END.