[Indigo]<Chipndale>5.2>nmos16>NMosTransistorsImpl.mesa!1

NMosTransistorsImpl.mesa (part of ChipNDale)

by Christian Jacobi June 24, 1983 5:03 pm

last edited Christian Jacobi May 8, 1984 11:15:40 am PDT

DIRECTORY

CD,

CDCallSpecific,

CDExtras,

CDInline,

CDIO,

CDLRUCache,

CDOrient,

CDValue,

NMos,

NMosTransistors,

Rope,

TokenIO;

NMosTransistorsImpl: CEDAR PROGRAM

IMPORTS CDCallSpecific, CDExtras, CDInline, CDIO, CDLRUCache, CDOrient, CDValue, NMos, Rope, TokenIO

EXPORTS NMosTransistors =

BEGIN OPEN NMos;

lambda: CD.DesignNumber = CD.lambda;

depletionOverlap: CD.DesignNumber = (3*lambda)/2;

wXExtension: CD.DesignNumber = NMosTransistors.wXExtension;

lXExtension: CD.DesignNumber = NMosTransistors.lXExtension;

TransistorPtr: TYPE = NMosTransistors.TransistorPtr;

TransistorRec: TYPE = NMosTransistors.TransistorRec;

tCache: CDLRUCache.LRUCache = CDLRUCache.Create[size: 10, aequivalenceProc: Aequivalent, newProc: NewTrans];

aCache: CDLRUCache.LRUCache = CDLRUCache.Create[size: 10, aequivalenceProc: Aequivalent, newProc: NewTrans];

pCache: CDLRUCache.LRUCache = CDLRUCache.Create[size: 10, aequivalenceProc: Aequivalent, newProc: NewTrans];

Aequivalent: PROC[mySpecific, other: REF ANY] RETURNS [BOOL] = {

WITH other SELECT FROM

tp2: TransistorPtr => RETURN [NARROW[mySpecific, TransistorPtr]^=tp2^];

ENDCASE => RETURN [FALSE]

};

NewTrans: PROC [] RETURNS [CD.ObPtr] = {

ob: CD.ObPtr ~ NEW[CD.ObjectDefinition];

ob.specificRef ← NEW[TransistorRec];

RETURN [ob]

};

Init: PROC [] =

BEGIN

pForTransistors.drawMe ← DrawMeForTransistors;

pForTransistors.internalRead ← ReadTrans;

pForTransistors.internalWrite ← WriteTrans;

pForTransistors.describe ← Describe;

pForTransistors.match ← MatchTrans;

CDCallSpecific.Register[$ChangeExt, pForTransistors, ChangeExtensionTrans];

CDCallSpecific.Register[$Lengthen, pForTransistors, LengthenTrans];

CDCallSpecific.Register[$Default, pForTransistors, DefaultenTrans];

CDCallSpecific.Register[$SetLength, pForTransistors, SetLengthTrans];

CDCallSpecific.Register[$SetWidth, pForTransistors, SetWidthTrans];

pForATransistors.drawMe ← DrawMeForATransistors;

pForATransistors.internalRead ← ReadATrans;

pForATransistors.internalWrite ← WriteATrans;

pForPullUps.drawMe ← DrawMeForPullUps;

pForPullUps.internalRead ← ReadPull;

pForPullUps.internalWrite ← WritePull;

pForPullUps.describe ← Describe;

pForPullUps.match ← MatchTrans;

CDCallSpecific.Register[$ChangeExt, pForPullUps, ChangeExtensionPullUps];

CDCallSpecific.Register[$Lengthen, pForPullUps, LengthenPullUps];

CDCallSpecific.Register[$Default, pForPullUps, DefaultenPullUps];

CDCallSpecific.Register[$SetLength, pForPullUps, SetLengthPullUps];

CDCallSpecific.Register[$SetWidth, pForPullUps, SetWidthPullUps];

END;

Describe: PROC[me: CD.ObPtr] RETURNS [Rope.ROPE] =

BEGIN

tp: TransistorPtr = NARROW[me.specificRef];

r: Rope.ROPE;

IF tp.pullup THEN r ← "pullup "

ELSE {

r ← "transistor ";

IF tp.angle THEN r ← Rope.Concat["angle ", r];

r ← Rope.Concat[r,

SELECT tp.implant FROM

NMosTransistors.enhancement => "enh ",

NMosTransistors.zeroTresh => "0-tresh ",

NMosTransistors.weakDepletion => "wk depl ",

NMosTransistors.strongDepletion => "depl ",

ENDCASE => "ERROR"

]

};

r ← Rope.Cat[

" [",

CDExtras.ToLambda[tp.width],

CDExtras.ToLambda[tp.length],

"]"

];

RETURN [r]

END;

MatchTrans: PROC [me: CD.ObPtr, r: CD.DesignRect, level: CD.Level, prim: BOOL, horz: BOOL] RETURNS [BOOL] =

BEGIN

RETURN [level=NMos.pol OR level=me.level]

END;

-- Transistor -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

pForTransistors: REF CD.ObjectProcs = RegisterObjectType[$NMosTransistor];

CreateTransistor: PUBLIC PROC [w, l: CD.DesignNumber,

implant: NMosTransistors.Implant←NMosTransistors.enhancement,

wExt: CD.DesignNumber←wXExtension,

lExt: CD.DesignNumber←lXExtension]

RETURNS [CD.ObPtr] =

BEGIN

tob: CD.ObPtr ~ tCache.UnusedOrNew[];

tp: TransistorPtr ~ NARROW[tob.specificRef];

tob.p ← pForTransistors;

w ← MAX[w, 2*lambda];

l ← MAX[l, 2*lambda];

wExt ← MAX[wExt, 0];

lExt ← MAX[lExt, 0];

tp.width ← w;

tp.length ← l;

tp.wExt ← wExt;

tp.lExt ← lExt;

tob.size ← [w+2*wExt, l+2*lExt];

tp.implant ← implant;

tp.angle ← FALSE;

tp.pullup ← FALSE;

tob.level ← dif;

RETURN [tCache.ReplaceByAequivalent[tob]]

END;

ReadTrans: CD.InternalReadProc --PROC [] RETURNS [ObPtr]-- =

BEGIN

w: INT = TokenIO.ReadInt[];

l: INT = TokenIO.ReadInt[];

implant: INT = TokenIO.ReadInt[];

wExt: INT = TokenIO.ReadInt[];

lExt: INT = TokenIO.ReadInt[];

IF CDIO.VersionKey[]>=2 THEN

RETURN [CreateTransistor[w: w, l: l, implant: implant, wExt: wExt, lExt: lExt]]

ELSE

RETURN [CreateTransistor[w: w, l: l, implant: (IF implant=1 THEN 3 ELSE 0), wExt: wExt, lExt: lExt]];

END;

WriteTrans: CD.InternalWriteProc -- PROC [me: ObPtr] -- =

BEGIN

tp: TransistorPtr = NARROW[me.specificRef];

TokenIO.WriteInt[tp.width];

TokenIO.WriteInt[tp.length];

TokenIO.WriteInt[tp.implant];

TokenIO.WriteInt[tp.wExt];

TokenIO.WriteInt[tp.lExt];

END;

ToPosition: PROC [x: REF] RETURNS [p: CD.DesignPosition] =

--y field defaults to lambda, x field defaults to 0

--[0, 0] if not done

BEGIN

IF x=NIL THEN p ← [0, lambda]

ELSE WITH x SELECT FROM

rp: REF CD.DesignPosition => p ← rp^;

rn: REF CD.DesignNumber => p ← [0, rn^];

ENDCASE => p ← [0, 0];

END;

AngleExt: PROC[tob: CD.ObPtr] RETURNS [CD.DesignNumber] = {

tp: TransistorPtr = NARROW[tob.specificRef];

RETURN [tp.width+tp.length+tp.wExt-tob.size.x]

};

ChangeExtensionTrans: CDCallSpecific.CallProc =

BEGIN

amount: CD.DesignPosition = ToPosition[x];

IF amount=[0, 0] THEN done ← FALSE

ELSE {

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

sz: CD.DesignPosition ← CDInline.AddPoints[[x: tp.wExt, y: tp.lExt], amount];

IF sz.x<0 OR sz.y<0 THEN {done←FALSE; RETURN};

IF tp.angle THEN

ap.ob ← CreateAngleTransistor[w: tp.width, l: tp.length,

implant: tp.implant,

wExt: sz.x, lExt: sz.y,

aExt: AngleExt[aptr.ob]

]

ELSE

ap.ob ← CreateTransistor[w: tp.width, l: tp.length,

implant: tp.implant,

wExt: sz.x, lExt: sz.y

];

include ← LIST[ap];

removeMe ← TRUE;

repaintMe ← amount.x<0 OR amount.y<0;

repaintInclude ← amount.x>0 OR amount.y>0;
}

END;

LengthenTrans: CDCallSpecific.CallProc =

BEGIN

amount: CD.DesignPosition = ToPosition[x];

IF amount=[0, 0] THEN done ← FALSE

ELSE {

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

sz: CD.DesignPosition ← CDInline.AddPoints[[x: tp.width, y: tp.length], amount];

IF sz.x<=0 OR sz.y<=0 THEN {done←FALSE; RETURN};

ap.ob ← CreateTransistor[w: sz.x, l: sz.y, wExt: tp.wExt, lExt: tp.lExt, implant: tp.implant];

include ← LIST[ap];

removeMe ← TRUE;

repaintMe ← amount.x<0 OR amount.y<0;

repaintInclude ← amount.x>0 OR amount.y>0;

}

END;

DefaultenTrans: CDCallSpecific.CallProc =

BEGIN

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

ap.ob ← CreateTransistor[

w: CDValue.FetchInt[design, $NMosTransistorW]*lambda,

l: CDValue.FetchInt[design, $NMosTransistorH]*lambda,

wExt: tp.wExt,

lExt: tp.lExt,

implant: CDValue.FetchInt[design, $NMosTransistorImplant]

];

include ← LIST[ap];

removeMe ← TRUE;

repaintMe ← TRUE;

repaintInclude ← TRUE;

END;

SetWidthTrans: CDCallSpecific.CallProc =

BEGIN

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

newWidth: CD.DesignNumber ← NARROW[x, REF CD.DesignNumber]^;

oldWidth: CD.DesignNumber ← tp.width;

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

ap.ob ← CreateTransistor[w: newWidth, l: tp.length, wExt: tp.wExt, lExt: tp.lExt, implant: tp.implant];

include ← LIST[ap];

removeMe ← TRUE;

IF newWidth>oldWidth THEN repaintInclude ← TRUE ELSE repaintMe ← TRUE;

END;

SetLengthTrans: CDCallSpecific.CallProc =

BEGIN

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

newLength: CD.DesignNumber ← NARROW[x, REF CD.DesignNumber]^;

oldLength: CD.DesignNumber ← tp.length;

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

ap.ob ← CreateTransistor[w: tp.width, l: newLength, wExt: tp.wExt, lExt: tp.lExt, implant: tp.implant];

include ← LIST[ap];

removeMe ← TRUE;

IF newLength>oldLength THEN repaintInclude←TRUE ELSE repaintMe←TRUE;

END;

DrawMeForTransistors: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation, pr: CD.DrawRef] =

BEGIN

p: TransistorPtr = NARROW[aptr.ob.specificRef];

CDDraw: PROC[r: CD.DesignRect, l: CD.Level] = INLINE

uses outer stuff!!

BEGIN

pr.drawRect[

CDOrient.MapRect[

itemInCell: r,

cellSize: aptr.ob.size,

cellInstOrient: orient,

cellInstPos: pos],

pr];

END;

CDDraw[[p.wExt, 0, p.wExt+p.width, aptr.ob.size.y], aptr.ob.level]; -- dif or pdiff

CDDraw[[0, p.lExt, aptr.ob.size.x, p.lExt+p.length], pol];

IF p.implant>0 THEN

CDDraw[[p.wExt-depletionOverlap, p.lExt-depletionOverlap,

aptr.ob.size.x-p.wExt+depletionOverlap, aptr.ob.size.y-p.lExt+depletionOverlap],

SELECT p.implant FROM

NMosTransistors.strongDepletion => imp,

NMosTransistors.weakDepletion => impWeak,

NMosTransistors.zeroTresh => imp0,

NMosTransistors.enhancement => CD.highLightError,

ENDCASE => CD.highLightError

];

END;

-- Angle Transistor -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

pForATransistors: REF CD.ObjectProcs = RegisterObjectType[$NMosATransistor];

CreateAngleTransistor: PUBLIC PROC [w, l: CD.DesignNumber,

implant: NMosTransistors.Implant←NMosTransistors.enhancement,

wExt: CD.DesignNumber←wXExtension,

lExt: CD.DesignNumber←lXExtension,

aExt: CD.DesignNumber𡤀]

RETURNS [CD.ObPtr] =

BEGIN

tob: CD.ObPtr ← aCache.UnusedOrNew[];

tp: TransistorPtr ← NARROW[tob.specificRef];

tob.p ← pForATransistors;

wExt ← MAX[wExt, 0];

lExt ← MAX[lExt, 0];

aExt ← MAX[aExt, -lExt];

w ← MAX[w, 2*lExt]; -- the width of the straight-line

-- parts of the gate, excluding corner

l ← MAX[l, 2*lambda];

tp.width ← w;

tp.length ← l;

tp.wExt ← wExt;

tp.lExt ← lExt;

tob.size ← [w+l+wExt-aExt, wExt+2*lExt+aExt+l];

tp.implant ← implant;

tp.angle ← TRUE;

tp.pullup ← FALSE;

tob.level ← dif;

RETURN [aCache.ReplaceByAequivalent[tob]]

END;

ReadATrans: CD.InternalReadProc --PROC [] RETURNS [ObPtr]-- =

BEGIN

w: INT = TokenIO.ReadInt[];

l: INT = TokenIO.ReadInt[];

implant: INT = TokenIO.ReadInt[];

wExt: INT = TokenIO.ReadInt[];

lExt: INT = TokenIO.ReadInt[];

aExt: INT = TokenIO.ReadInt[];

IF CDIO.VersionKey[]>=2 THEN

RETURN [ CreateAngleTransistor[w: w, l: l, implant: implant, wExt: wExt, lExt: lExt, aExt: aExt] ]

ELSE

RETURN [ CreateAngleTransistor[w: w, l: l, implant: (IF implant=1 THEN 3 ELSE 0), wExt: wExt, lExt: lExt, aExt: aExt] ];

END;

WriteATrans: CD.InternalWriteProc -- PROC [me: ObPtr] -- =

BEGIN

tp: TransistorPtr = NARROW[me.specificRef];

TokenIO.WriteInt[tp.width];

TokenIO.WriteInt[tp.length];

TokenIO.WriteInt[tp.implant];

TokenIO.WriteInt[tp.wExt];

TokenIO.WriteInt[tp.lExt];

TokenIO.WriteInt[tp.width+tp.length+tp.wExt-me.size.x];

END;

DrawMeForATransistors: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,

pr: CD.DrawRef] =

BEGIN

p: TransistorPtr = NARROW[aptr.ob.specificRef];

CDDraw: PROC[r: CD.DesignRect, l: CD.Level] = INLINE

--uses outer stuff!!

BEGIN

pr.drawRect[

CDOrient.MapRect[

itemInCell: r,

cellSize: aptr.ob.size,

cellInstOrient: orient,

cellInstPos: pos],

pr];

END;

--The transistor makes a 90-degree bend, going eastward and

--then southward. The diffusion on the outer side of the angle,

--that is, on the northeast side, is arbitrarily called the drain.

IF CDInline.Intersect[CDOrient.RectAt[pos, aptr.ob.size, orient], pr.worldClip] THEN

BEGIN

ele: CD.DesignNumber = 2*p.lExt+p.length;

hPoly: CD.DesignRect = [0, p.lExt, aptr.ob.size.x-p.lExt, p.length+p.lExt]; -- horizontal

vPoly: CD.DesignRect = [aptr.ob.size.x-p.length-p.lExt, hPoly.y2, hPoly.x2, aptr.ob.size.y]; -- vertical

nDrain: CD.DesignRect = [p.wExt, 0, aptr.ob.size.x, hPoly.y1]; -- north

eDrain: CD.DesignRect = [vPoly.x2, nDrain.y2, nDrain.x2, aptr.ob.size.y-p.wExt]; -- east

wSource: CD.DesignRect = [aptr.ob.size.x-ele, eDrain.y1, eDrain.x1, aptr.ob.size.y-p.wExt]; -- west

sSource: CD.DesignRect = [MIN[p.wExt, wSource.x1], nDrain.y2, wSource.x1, MIN[ele, wSource.y2]]; -- south

IF p.lExt>0 THEN

BEGIN

CDDraw[nDrain, aptr.ob.level];

CDDraw[eDrain, aptr.ob.level];

END;

CDDraw[wSource, aptr.ob.level];

CDDraw[sSource, aptr.ob.level];

CDDraw[hPoly, pol];

CDDraw[vPoly, pol];

IF p.implant>0 THEN

BEGIN

CDDraw[[nDrain.x1-depletionOverlap, hPoly.y1-depletionOverlap,

hPoly.x2+depletionOverlap, hPoly.y2+depletionOverlap],

imp];

CDDraw[[vPoly.x1-depletionOverlap, vPoly.y1-depletionOverlap,

vPoly.x2+depletionOverlap, eDrain.y2+depletionOverlap],

imp];

END

END;

-- PullUp -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

pForPullUps: REF CD.ObjectProcs = RegisterObjectType[$NMosPullUp];

CreatePullUp: PUBLIC PROC [w, l: CD.DesignNumber,

wExt: CD.DesignNumber←wXExtension,

lExt: CD.DesignNumber←lXExtension]

RETURNS [CD.ObPtr] =

BEGIN

puob: CD.ObPtr ~ pCache.UnusedOrNew[];

pup: TransistorPtr ~ NARROW[puob.specificRef];

w ← MAX[w, 2*lambda];

l ← MAX[l, 2*lambda];

wExt ← MAX[wExt, 0];

lExt ← MAX[lExt, 0];

pup.wExt ← wExt;

pup.lExt ← lExt;

pup.width ← w;

pup.length ← l;

pup.pullup ← TRUE;

puob.p ← pForPullUps;

puob.size ← [MAX[4*lambda, w+wExt*2], MAX[6*lambda, l+lExt+3*lambda]];

puob.level ← dif;

RETURN [pCache.ReplaceByAequivalent[puob]]

END;

ReadPull: CD.InternalReadProc --PROC [] RETURNS [ObPtr]-- =

BEGIN

w: INT = TokenIO.ReadInt[];

l: INT = TokenIO.ReadInt[];

wExt: INT = TokenIO.ReadInt[];

lExt: INT = TokenIO.ReadInt[];

RETURN [ CreatePullUp[w: w, l: l, wExt: wExt, lExt: lExt] ];

END;

WritePull: CD.InternalWriteProc -- PROC [me: ObPtr] -- =

BEGIN

tp: TransistorPtr = NARROW[me.specificRef];

TokenIO.WriteInt[tp.width];

TokenIO.WriteInt[tp.length];

TokenIO.WriteInt[tp.wExt];

TokenIO.WriteInt[tp.lExt];

END;

LengthenPullUps: CDCallSpecific.CallProc =

BEGIN

amount: CD.DesignPosition = ToPosition[x];

IF amount=[0, 0] THEN done ← FALSE

ELSE {

tp: TransistorPtr = NARROW[aptr.ob.specificRef];

ap: CD.ApplicationPtr = NEW[CD.Application𡤊ptr^];

sz: CD.DesignPosition = CDInline.AddPoints[[x: tp.width, y: tp.length], amount];

IF sz.x<=0 OR sz.y<=0 THEN {done←FALSE; RETURN};

ap.ob ← CreatePullUp[w: sz.x, l: sz.y, wExt: tp.wExt, lExt: tp.lExt];

include ← LIST[ap];

removeMe ← TRUE;

repaintMe ← amount.x<0 OR amount.y<0;

repaintInclude ← amount.x>0 OR amount.y>0;

}

END;

ChangeExtensionPullUps: CDCallSpecific.CallProc =

BEGIN

amount: CD.DesignPosition = ToPosition[x];

IF amount=[0, 0] THEN done ← FALSE

ELSE {

tp: TransistorPtr = NARROW[aptr.ob.specificRef];

ap: CD.ApplicationPtr = NEW[CD.Application𡤊ptr^];

sz: CD.DesignPosition ← CDInline.AddPoints[[x: tp.wExt, y: tp.lExt], amount];

IF sz.x<0 OR sz.y<0 THEN {done←FALSE; RETURN};

ap.ob ← CreatePullUp[w: tp.width, l: tp.length, wExt: sz.x, lExt: sz.y];

include ← LIST[ap];

removeMe ← TRUE;

repaintMe ← amount.x<0 OR amount.y<0;

repaintInclude ← amount.x>0 OR amount.y>0;

}

END;

DefaultenPullUps: CDCallSpecific.CallProc =

BEGIN

tp: TransistorPtr = NARROW[aptr.ob.specificRef];

ap: CD.ApplicationPtr = NEW[CD.Application𡤊ptr^];

ap.ob ← CreatePullUp[

w: CDValue.FetchInt[design, $NMosPullUpW]*lambda,

l: CDValue.FetchInt[design, $NMosPullUpH]*lambda,

wExt: tp.wExt,

lExt: tp.lExt];

include ← LIST[ap];

removeMe ← TRUE;

repaintMe ← TRUE;

repaintInclude ← TRUE;

END;

SetWidthPullUps: CDCallSpecific.CallProc =

BEGIN

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

newWidth: CD.DesignNumber ← NARROW[x, REF CD.DesignNumber]^;

oldWidth: CD.DesignNumber ← tp.width;

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

ap.ob ← CreatePullUp[w: newWidth, l: tp.length, wExt: tp.wExt, lExt: tp.lExt];

include ← LIST[ap];

removeMe ← TRUE;

IF newWidth>oldWidth THEN repaintInclude ← TRUE ELSE repaintMe ← TRUE;

END;

SetLengthPullUps: CDCallSpecific.CallProc =

BEGIN

tp: TransistorPtr ← NARROW[aptr.ob.specificRef];

newLength: CD.DesignNumber ← NARROW[x, REF CD.DesignNumber]^;

oldLength: CD.DesignNumber ← tp.length;

ap: CD.ApplicationPtr ← NEW[CD.Application𡤊ptr^];

ap.ob ← CreatePullUp[w: tp.width, l: newLength, wExt: tp.wExt, lExt: tp.lExt];

include ← LIST[ap];

removeMe ← TRUE;

IF newLength>oldLength THEN repaintInclude ← TRUE ELSE repaintMe ← TRUE;

END;

DrawMeForPullUps: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation, pr: CD.DrawRef] =

BEGIN

CDDraw: PROC[r: CD.DesignRect, l: CD.Level] = INLINE

--uses outer stuff!!

BEGIN

pr.drawRect[

CDOrient.MapRect[

itemInCell: r,

cellSize: aptr.ob.size,

cellInstOrient: orient,

cellInstPos: pos],

pr];

END;

IF CDInline.Intersect[CDOrient.RectAt[pos, aptr.ob.size, orient], pr.worldClip] THEN

BEGIN

p: TransistorPtr = NARROW[aptr.ob.specificRef];

middleX: CD.DesignNumber = aptr.ob.size.x/2;

metal: CD.DesignRect = [x1: middleX-2*lambda, y1: aptr.ob.size.y-6*lambda,

x2: middleX+2*lambda, y2: aptr.ob.size.y];

CDDraw[[p.wExt, 0, p.wExt+p.width, aptr.ob.size.y], aptr.ob.level];

CDDraw[[0, p.lExt, aptr.ob.size.x, p.lExt+p.length], pol];

CDDraw[[0, 0, aptr.ob.size.x, aptr.ob.size.y-lambda], imp];

CDDraw[[metal.x1, metal.y1+2*lambda, metal.x2, metal.y2], aptr.ob.level];

CDDraw[metal, met];

CDDraw[[metal.x1+lambda, metal.y1+lambda, metal.x2-lambda, metal.y2-lambda], cut];

END

END;

Init[];

END.