DIRECTORY
CD,
CDAtomicObjects,
CDBasics,
CDOps,
CDStretchyBackdoor,
CMosB,
Rope;

CMosBObsImpl: CEDAR PROGRAM 
IMPORTS CD, CDAtomicObjects, CDBasics, CDOps, CDStretchyBackdoor, CMosB, Rope =
BEGIN 

lambda: CD.Number = CMosB.lambda;
wellSurround: CD.Number = CMosB.wellSurround;


MatchTrans: PROC [me: CD.Object, r: CD.Rect, layer: CD.Layer, prim: BOOL, horz: BOOL] RETURNS [BOOL] = {
RETURN [layer=me.layer OR layer=CMosB.pol]
};

wellTransClass: CD.ObjectClass;
transClass: CD.ObjectClass;

FillTransistor: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
dExt: CD.Number = 3*lambda;
pExt: CD.Number = 2*lambda;
dif: CD.Layer;
inr: CD.Rect _ ob.bbox;
inr.x2 _ MAX[inr.x2, 2*lambda+2*pExt];
inr.y2 _ MAX[inr.y2, 2*lambda+2*dExt];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
ob.class _ wellTransClass;
IF ob.layer=CMosB.wpdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1-wellSurround+pExt, 
x2: inr.x2+wellSurround-pExt,
y1: inr.y1-wellSurround, 
y2: inr.y2+wellSurround], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE {
IF ob.layer=CMosB.pdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
};
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1+pExt, 
x2: inr.x2-pExt,
y1: inr.y1, 
y2: inr.y2], 
layer: dif
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1, 
x2: inr.x2,
y1: inr.y1+dExt, 
y2: inr.y2-dExt], 
layer: CMosB.pol
];
};

DescribeT: CD.DescribeProc = {
dExt: CD.Number = 3*lambda;
pExt: CD.Number = 2*lambda;
sz: CD.Position = CD.InterestSize[ob];
RETURN [
Rope.Cat[
"transistor ",
CDOps.LayerRope[ob.layer],
Rope.Cat[" [",
CDOps.LambdaRope[sz.x-2*pExt, lambda],
CDOps.LambdaRope[sz.y-2*dExt, lambda],
"]"]
]
]
};

lTransClass: CD.ObjectClass;
wellLTransClass: CD.ObjectClass;
oldBadWellLTransClass: CD.ObjectClass;

OldBadFillLTransistor: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
ob.class _ lTransClass;
RETURN [FillLTransistor[ob]]
};

FillLTransistor: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
pExt: CD.Number = 2*lambda; --poly extends gate
dExt: CD.Number = 3*lambda; --diffusion extends gate
dW: CD.Number = 2*lambda; --witdth of diffusion in gate (not width of gate)
pW: CD.Number = 2*lambda; --witdth of poly in gate (not width of gate)
minSz: CD.Number = pExt+2*dExt+dW;
dif: CD.Layer;
inr: CD.Rect _ ob.bbox;
inr.x2 _ MAX[inr.x2, minSz];
inr.y2 _ MAX[inr.y2, minSz];
ob.bbox _ inr;
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
wR: CD.Rect;
ob.class _ wellLTransClass;
IF ob.layer=CMosB.wpdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1-wellSurround+pExt, 
x2: inr.x2+wellSurround, 
y1: inr.y1-wellSurround , 
y2: inr.y1+wellSurround+dW+2*dExt], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
wR _ [x1: inr.x2-(dW+2*dExt)-wellSurround, 
x2: inr.x2+wellSurround, 
y1: inr.y1+wellSurround+dW+2*dExt, 
y2: inr.y2+wellSurround-pExt];
IF CDBasics.NonEmpty[wR] THEN
CDAtomicObjects.Incorporate[ob: ob, 
r: wR, 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE {
IF ob.layer=CMosB.pdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
};
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1+pExt, 
x2: inr.x2,
y1: inr.y1, 
y2: 2*dExt+dW], 
layer: dif
];
IF 2*dExt+dW < inr.y2-pExt THEN
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x2-2*dExt-dW, 
x2: inr.x2,
y1: 2*dExt+dW, 
y2: inr.y2-pExt ], 
layer: dif
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1, 
x2: inr.x2-dExt,
y1: dExt, 
y2: dExt+pW], 
layer: CMosB.pol
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x2-pW-dExt, 
x2: inr.x2-dExt,
y1: inr.y1+pW+dExt, 
y2: inr.y2], 
layer: CMosB.pol
];
};

simpleContactClass: CD.ObjectClass;
wellSimpleContactClass: CD.ObjectClass;
largeContactClass: CD.ObjectClass;
wellLargeContactClass: CD.ObjectClass;

FillSimpleCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
rimW: CD.Number ~ lambda; -- therefore NOT large
dif: CD.Layer;
inr: CD.Rect _ [0, 0, 2*lambda+2*rimW, 2*lambda+2*rimW];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
ob.class _ wellSimpleContactClass;
dif _ (IF ob.layer=CMosB.wpdif THEN CMosB.pdif ELSE CMosB.ndif);
CDAtomicObjects.Incorporate[ob: ob, 
r: CDBasics.Extend[inr, wellSurround], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE { 
dif _ ob.layer
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: dif];
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -rimW], layer: CMosB.cut];
};

FillLargeSimpleCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
rimW: CD.Number = 2*lambda; -- therefore large
dif: CD.Layer;
inr: CD.Rect _ ob.bbox;
inr.x2 _ MAX[inr.x2, 2*lambda+2*rimW];
inr.y2 _ MAX[inr.y2, 2*lambda+2*rimW];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
ob.class _ wellLargeContactClass;
dif _ (IF ob.layer=CMosB.wpdif THEN CMosB.pdif ELSE CMosB.ndif);
CDAtomicObjects.Incorporate[ob: ob, 
r: CDBasics.Extend[inr, wellSurround], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE {
dif _ ob.layer
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: dif];
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -rimW], layer: CMosB.cut];
};

DescribeC: CD.DescribeProc = {
RETURN [Rope.Cat["contact ", CDOps.LayerRope[ob.layer]]]
};

DescribeLargeC: CD.DescribeProc = {
RETURN [Rope.Cat["large contact ", CDOps.LayerRope[ob.layer]]]
};


wellDifShortContactClass: CD.ObjectClass;

FillDifShortCon: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
dif: CD.Layer;
inr: CD.Rect; 
innerW: CD.Number = 4*lambda;
innerH: CD.Number = 8*lambda;
h: CD.Number = innerH/2;
inr _ [x1: 0, y1: 0, x2: innerW, y2: innerH];
IF ob.layer=CMosB.wpdif OR ob.layer=CMosB.wndif THEN {
ob.class _ wellDifShortContactClass;
IF ob.layer=CMosB.wpdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
CDAtomicObjects.Incorporate[ob: ob, 
r: [-wellSurround, -wellSurround, innerW+wellSurround, innerH+wellSurround-h], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwell ELSE CMosB.pwell),
inside: FALSE
];
}
ELSE {
IF ob.layer=CMosB.pdif THEN dif _ CMosB.pdif ELSE dif _ CMosB.ndif;
};
CDAtomicObjects.Incorporate[ob: ob, r: inr, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1, 
x2: inr.x2,
y1: inr.y1, 
y2: inr.y1+h], 
layer: dif
];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: inr.x1, 
x2: inr.x2,
y1: inr.y1+h, 
y2: inr.y2], 
layer: (IF dif=CMosB.pdif THEN CMosB.nwellCont ELSE CMosB.pwellCont)
];
CDAtomicObjects.Incorporate[ob: ob, r: CDBasics.Extend[inr, -lambda], layer: CMosB.cut];
};



FillVia: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = { 
viaRimWidth: CD.Number = lambda;
cut2min: CD.Number = 2*lambda;
ob.bbox _ [0, 0, cut2min+2*viaRimWidth, cut2min+2*viaRimWidth];
ob.layer _ CMosB.met2;
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met2];
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: viaRimWidth, 
x2: cut2min+viaRimWidth,
y1: viaRimWidth,
y2: cut2min+viaRimWidth], 
layer: CMosB.cut2
];
};

FillLargeVia: PROC [ob: CD.Object] RETURNS [mustFail: BOOL_FALSE] = {
viaRimWidth: CD.Number = 2*lambda;
cut2min: CD.Number = 2*lambda;
ob.bbox.x2 _ MAX[ob.bbox.x2, cut2min+2*viaRimWidth];
ob.bbox.y2 _ MAX[ob.bbox.y2, cut2min+2*viaRimWidth];
ob.layer _ CMosB.met2;
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met2];
CDAtomicObjects.Incorporate[ob: ob, r: ob.bbox, layer: CMosB.met];
CDAtomicObjects.Incorporate[ob: ob, 
r: [x1: viaRimWidth, 
x2: ob.bbox.x2-viaRimWidth,
y1: viaRimWidth,
y2: ob.bbox.y2-viaRimWidth], 
layer: CMosB.cut2
];
};


MatchSimpleCon: PROC [me: CD.Object, r: CD.Rect, layer: CD.Layer, prim: BOOL, horz: BOOL] RETURNS [BOOL] = {
RETURN [layer=me.layer OR layer=CMosB.met]
};

Init: PROC [] = {

Register: PROC [key: ATOM, creator: CDAtomicObjects.FillObjectProc, desc: Rope.ROPE, match: CDStretchyBackdoor.MatchProc_NIL] RETURNS [p: CD.ObjectClass] = {
p _ CDAtomicObjects.RegisterAtomicObClass[key, creator, desc, CMosB.cmosB];
IF p=NIL THEN ERROR;
IF match=NIL THEN match _ MatchSimpleCon; 
CDStretchyBackdoor.InstallMatchProc[p, match];
};
transClass _ Register[$C2Trans, FillTransistor, "transistor", MatchTrans];
transClass.describe _ DescribeT;
wellTransClass _ Register[$C2WellTrans, FillTransistor, "transistor", MatchTrans];
wellTransClass.describe _ DescribeT;
lTransClass _ Register[$C2LTrans, FillLTransistor, "L-transistor", MatchTrans];
oldBadWellLTransClass _ Register[$CLWellTrans, OldBadFillLTransistor, "L-transistor", MatchTrans];
wellLTransClass _ Register[$C2LWellTrans, FillLTransistor, "L-transistor", MatchTrans];

simpleContactClass _ Register[$C2SimpleCon, FillSimpleCon, "contact"];
simpleContactClass.describe _ DescribeC;
wellSimpleContactClass _ Register[$C2WellSimpleCon, FillSimpleCon, "contact"];
wellSimpleContactClass.describe _ DescribeC;

largeContactClass _ Register[$C2LargeSimpleCon, FillLargeSimpleCon, "large contact"];
largeContactClass.describe _ DescribeLargeC;
wellLargeContactClass _ Register[$C2LargeWellSimpleCon, FillLargeSimpleCon, "large contact"];
wellLargeContactClass.describe _ DescribeLargeC;

[] _ Register[$C2DifShortCon, FillDifShortCon, "dif short contact"];
wellDifShortContactClass _ Register[$C2WellDifShortCon, FillDifShortCon, "dif short contact"];

[] _ Register[$C2Via, FillVia, "via"];
[] _ Register[$C2LargeVia, FillLargeVia, "large via"];
}; 

Init[];
END. 

bCMosBObsImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Created Christian Jacobi, March 22, 1985 11:09:09 am PST 
gbb May 30, 1986 12:37:21 pm PDT
Last edited by: Christian Jacobi, December 15, 1986 7:13:37 pm PST
-- straight transistors -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--poly, dif, welldif, via
-- Don't care about different diffusions and such

-- L transistors -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--horizontal piece of nwell
--vertical piece of nwell if ~empty
--horizontal piece of diff
--vertical piece of diff

-- simple contacts -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
-- DifShort -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--via -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
--poly, dif, welldif, via
-- Don't care about different diffusions and such

--transistors
--contacts
Κ|˜
codeš
œ™Kšœ
Οm
œ7™BKš
œ9™9K™ K™BK˜—š
Οk	˜	Kšžœ
˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜K˜Kš
œ˜K˜—šΟnœžœ
žœ
˜Kšžœ
žœE˜O—Kšžœ
˜K˜Kšœžœ˜!Kšœžœ˜-K˜Kš
œf™fK˜šŸ
œžœžœžœžœžœžœžœžœ˜hKš
œ™Kš
œ1™1Kšžœžœ˜*Kš
œ˜—K˜Kšœžœ
˜Kšœžœ
˜K˜šŸœžœžœ	žœžœ
žœ˜GKšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜&Kšœ	žœ˜&šžœžœžœ˜6Kš
œ˜Kšžœžœžœ˜Dš
œ$˜$š
œ"˜"Kš
œ˜Kš
œ˜Kš
œ˜—Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—Kš
œ
˜
—šžœ˜Kšžœžœžœ˜CKš
œ˜—š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
—Kš
œ
˜
Kš
œ˜—š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜—K˜šŸ	œžœ˜Kšœžœ˜Kšœžœ˜Kšœžœžœ˜&šžœ˜š
œ	˜	Kš
œ˜Kš
œ˜š
œ˜Kš
œ&˜&Kš
œ&˜&K˜—Kš
œ
˜
—Kš
œ
˜
—Kš
œ˜—K™Kš
œ_™_K˜Kšœ
žœ
˜Kšœžœ
˜ Kšœžœ
˜&K˜šŸœžœžœ	žœžœ
žœ˜NKš
œ˜Kšžœ˜K˜—K˜šŸœžœžœ	žœžœ
žœ˜HKšœžœΟc˜/Kšœžœ ˜4Kšœžœ 1˜KKšœžœ ,˜FKšœžœ˜"Kšœžœ˜Kšœžœ˜Kšœ	žœ˜Kšœ	žœ˜Kš
œ˜šžœžœžœ˜6Kš
œ˜Kš
œ˜Kšžœžœžœ˜DKš
œ™š
œ$˜$š
œ"˜"Kš
œ˜Kš
œ˜Kš
œ$˜$—Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—Kš
œ#™#š
œ+˜+Kš
œ˜Kš
œ#˜#Kš
œ˜—šžœž˜š
œ$˜$Kš
œ˜Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜——K˜
—šžœ˜Kšžœžœžœ˜CKš
œ˜—Kš
œ™š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ
˜
Kš
œ˜—Kš
œ™šžœž˜š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ
˜
Kš
œ˜——š
œ$˜$š
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜—Kš
œ˜Kš
œ˜—š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
—Kš
œ˜Kš
œ˜—Kš
œ˜—K™Kš
œa™aK˜Kšœžœ
˜#Kšœžœ
˜'Kšœžœ
˜"Kšœžœ
˜&K˜šŸ
œžœžœ	žœžœ
žœ˜FKšœžœ ˜0Kšœžœ˜Kšœžœ1˜8šžœžœžœ˜6Kš
œ"˜"Kšœžœžœžœ
˜@š
œ$˜$Kš
œ'˜'Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—K˜
—šžœ˜Kš
œ˜Kš
œ˜—Kš
œ8˜8Kš
œ>˜>Kš
œV˜VKš
œ˜K˜—šŸœžœžœ	žœžœ
žœ˜KKšœžœ ˜.Kšœžœ˜Kšœžœ˜Kšœ	žœ˜&Kšœ	žœ˜&šžœžœžœ˜6Kš
œ!˜!Kšœžœžœžœ
˜@š
œ$˜$Kš
œ'˜'Kšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—K˜
—šžœ˜Kš
œ˜Kš
œ˜—Kš
œ8˜8Kš
œ>˜>Kš
œV˜VKš
œ˜K˜—šŸ	œ˜Kšžœ2˜8Kš
œ˜—K˜šŸœ˜#Kšžœ8˜>Kš
œ˜—K˜Kš
œZ™ZK˜Kšœžœ
˜)K˜šŸœžœžœ	žœžœ
žœ˜HKšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kš
œ-˜-šžœžœžœ˜6Kš
œ$˜$Kšžœžœžœ˜Dš
œ$˜$Kš
œO˜OKšœžœžœ
žœ˜=Kšœž˜
Kš
œ˜—K˜
—šžœ˜Kšžœžœžœ˜CK˜—Kš
œ>˜>š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ
˜
Kš
œ˜—š
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
—Kšœžœžœžœ˜DKš
œ˜—Kš
œX˜XKš
œ˜K˜—K˜Kš
œ`™`K˜šŸœžœžœ	žœžœ
žœ˜AKšœ
žœ˜ Kšœ	žœ˜Kš
œ?˜?Kš
œ˜Kš
œC˜CKš
œB˜Bš
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜K˜—šŸœžœžœ	žœžœ
žœ˜EKšœ
žœ˜"Kšœ	žœ˜Kšœ
žœ$˜4Kšœ
žœ$˜4Kš
œ˜Kš
œC˜CKš
œB˜Bš
œ$˜$š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜K˜—Kš
œZ™ZK˜šŸœžœžœžœžœžœžœžœžœ˜lKš
œ™Kš
œ1™1Kšžœžœ˜*Kš
œ˜—K˜šŸœžœ˜K˜šŸœžœžœ6žœ&žœžœžœ˜
Kš
œK˜KKšžœžœ
žœ
žœ
˜Kšžœžœ
žœ˜*Kš
œ.˜.Kš
œ˜—K™Kš
œ
™
Kš
œJ˜JKš
œ ˜ Kš
œR˜RKš
œ$˜$Kš
œO˜OKš
œb˜bKš
œW˜WK˜Kš
œ
™
Kš
œF˜FKš
œ(˜(Kš
œN˜NKš
œ,˜,K˜Kš
œU˜UKš
œ,˜,Kš
œ]˜]Kš
œ0˜0K˜Kš
œD˜DKš
œ^˜^K˜Kš
œ&˜&Kš
œ6˜6Kš
œ˜K˜—K˜Kšžœ˜K˜—…—%Ά6”