← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/electric/jaunty

« back to all changes in this revision

Viewing changes to com/sun/electric/tool/user/tecEditWizard/TechEditWizardData.java

  • Committer: Bazaar Package Importer
  • Author(s): Onkar Shinde
  • Date: 2009-01-08 02:05:08 UTC
  • mfrom: (1.1.2 upstream) (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090108020508-0h3li7zt9mu5gf0i
Tags: 8.08-1
New upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
com/sun/electric/tool/user/tecEditWizard/TechEditWizardData.java
58
58
        private String tech_description;
59
59
        private int num_metal_layers;
60
60
        private int stepsize;
 
61
    private boolean pWellFlag = true; // to store if process is a pwell process or not. If true, Tech Creation Wizard will not create pwell layers
 
62
    private boolean horizontalFlag = true; // to store if transistor gates are aligned horizontally. True by default
61
63
 
62
 
        // DIFFUSION RULES
 
64
    // DIFFUSION RULES
63
65
        private WizardField diff_width = new WizardField();
64
66
        private WizardField diff_poly_overhang = new WizardField();             // min. diff overhang from gate edge
65
67
        private WizardField diff_contact_overhang = new WizardField();  // min. diff overhang contact
215
217
                num_metal_layers = n;
216
218
        }
217
219
 
218
 
        // DIFFUSION RULES
219
 
        public WizardField getDiffWidth() { return diff_width; }
220
 
        public void setDiffWidth(WizardField v) { diff_width = v; }
221
 
        public WizardField getDiffPolyOverhang() { return diff_poly_overhang; }
222
 
        public void setDiffPolyOverhang(WizardField v) { diff_poly_overhang = v; }
223
 
        public WizardField getDiffContactOverhang() { return diff_contact_overhang; }
224
 
        public void setDiffContactOverhang(WizardField v) { diff_contact_overhang = v; }
225
 
        public WizardField getDiffSpacing() { return diff_spacing; }
226
 
        public void setDiffSpacing(WizardField v) { diff_spacing = v; }
 
220
    // Flags
 
221
    boolean getPWellProcess() { return pWellFlag;}
 
222
    void setPWellProcess(boolean b) { pWellFlag = b; }
 
223
    boolean getHorizontalTransistors() { return horizontalFlag;}
 
224
    void setHorizontalTransistors(boolean b) { horizontalFlag = b; }
 
225
 
 
226
    // DIFFUSION RULES
 
227
        WizardField getDiffWidth() { return diff_width; }
 
228
        void setDiffWidth(WizardField v) { diff_width = v; }
 
229
        WizardField getDiffPolyOverhang() { return diff_poly_overhang; }
 
230
        void setDiffPolyOverhang(WizardField v) { diff_poly_overhang = v; }
 
231
        WizardField getDiffContactOverhang() { return diff_contact_overhang; }
 
232
        void setDiffContactOverhang(WizardField v) { diff_contact_overhang = v; }
 
233
        WizardField getDiffSpacing() { return diff_spacing; }
 
234
        void setDiffSpacing(WizardField v) { diff_spacing = v; }
227
235
 
228
236
        // POLY RULES
229
 
        public WizardField getPolyWidth() { return poly_width; }
230
 
        public void setPolyWidth(WizardField v) { poly_width = v; }
231
 
        public WizardField getPolyEndcap() { return poly_endcap; }
232
 
        public void setPolyEndcap(WizardField v) { poly_endcap = v; }
233
 
        public WizardField getPolySpacing() { return poly_spacing; }
234
 
        public void setPolySpacing(WizardField v) { poly_spacing = v; }
235
 
        public WizardField getPolyDiffSpacing() { return poly_diff_spacing; }
236
 
        public void setPolyDiffSpacing(WizardField v) { poly_diff_spacing = v; }
 
237
        WizardField getPolyWidth() { return poly_width; }
 
238
        void setPolyWidth(WizardField v) { poly_width = v; }
 
239
        WizardField getPolyEndcap() { return poly_endcap; }
 
240
        void setPolyEndcap(WizardField v) { poly_endcap = v; }
 
241
        WizardField getPolySpacing() { return poly_spacing; }
 
242
        void setPolySpacing(WizardField v) { poly_spacing = v; }
 
243
        WizardField getPolyDiffSpacing() { return poly_diff_spacing; }
 
244
        void setPolyDiffSpacing(WizardField v) { poly_diff_spacing = v; }
237
245
 
238
246
        // GATE RULES
239
 
        public WizardField getGateLength() { return gate_length; }
240
 
        public void setGateLength(WizardField v) { gate_length = v; }
241
 
        public WizardField getGateWidth() { return gate_width; }
242
 
        public void setGateWidth(WizardField v) { gate_width = v; }
243
 
        public WizardField getGateSpacing() { return gate_spacing; }
244
 
        public void setGateSpacing(WizardField v) { gate_spacing = v; }
245
 
        public WizardField getGateContactSpacing() { return gate_contact_spacing; }
246
 
        public void setGateContactSpacing(WizardField v) { gate_contact_spacing = v; }
 
247
        WizardField getGateLength() { return gate_length; }
 
248
        void setGateLength(WizardField v) { gate_length = v; }
 
249
        WizardField getGateWidth() { return gate_width; }
 
250
        void setGateWidth(WizardField v) { gate_width = v; }
 
251
        WizardField getGateSpacing() { return gate_spacing; }
 
252
        void setGateSpacing(WizardField v) { gate_spacing = v; }
 
253
        WizardField getGateContactSpacing() { return gate_contact_spacing; }
 
254
        void setGateContactSpacing(WizardField v) { gate_contact_spacing = v; }
247
255
 
248
256
 
249
257
    // CONTACT RULES
250
 
        public WizardField getContactSize() { return contact_size; }
251
 
        public void setContactSize(WizardField v) { contact_size = v; }
252
 
        public WizardField getContactSpacing() { return contact_spacing; }
253
 
        public void setContactSpacing(WizardField v) { contact_spacing = v; }
254
 
    public WizardField getContactArraySpacing() { return contact_array_spacing; }
255
 
        public void setContactArraySpacing(WizardField v) { contact_array_spacing = v; }
256
 
    public WizardField getContactMetalOverhangInlineOnly() { return contact_metal_overhang_inline_only; }
257
 
        public void setContactMetalOverhangInlineOnly(WizardField v) { contact_metal_overhang_inline_only = v; }
258
 
        public WizardField getContactMetalOverhangAllSides() { return contact_metal_overhang_all_sides; }
259
 
        public void setContactMetalOverhangAllSides(WizardField v) { contact_metal_overhang_all_sides = v; }
260
 
        public WizardField getContactPolyOverhang() { return contact_poly_overhang; }
261
 
        public void setContactPolyOverhang(WizardField v) { contact_poly_overhang = v; }
262
 
        public WizardField getPolyconDiffSpacing() { return polycon_diff_spacing; }
263
 
        public void setPolyconDiffSpacing(WizardField v) { polycon_diff_spacing = v; }
 
258
        WizardField getContactSize() { return contact_size; }
 
259
        void setContactSize(WizardField v) { contact_size = v; }
 
260
        WizardField getContactSpacing() { return contact_spacing; }
 
261
        void setContactSpacing(WizardField v) { contact_spacing = v; }
 
262
    WizardField getContactArraySpacing() { return contact_array_spacing; }
 
263
        void setContactArraySpacing(WizardField v) { contact_array_spacing = v; }
 
264
    WizardField getContactMetalOverhangInlineOnly() { return contact_metal_overhang_inline_only; }
 
265
        void setContactMetalOverhangInlineOnly(WizardField v) { contact_metal_overhang_inline_only = v; }
 
266
        WizardField getContactMetalOverhangAllSides() { return contact_metal_overhang_all_sides; }
 
267
        void setContactMetalOverhangAllSides(WizardField v) { contact_metal_overhang_all_sides = v; }
 
268
        WizardField getContactPolyOverhang() { return contact_poly_overhang; }
 
269
        void setContactPolyOverhang(WizardField v) { contact_poly_overhang = v; }
 
270
        WizardField getPolyconDiffSpacing() { return polycon_diff_spacing; }
 
271
        void setPolyconDiffSpacing(WizardField v) { polycon_diff_spacing = v; }
264
272
 
265
273
        // WELL AND IMPLANT RULES
266
 
        public WizardField getNPlusWidth() { return nplus_width; }
267
 
        public void setNPlusWidth(WizardField v) { nplus_width = v; }
268
 
        public WizardField getNPlusOverhangDiff() { return nplus_overhang_diff; }
269
 
    public void setNPlusOverhangDiff(WizardField v) { nplus_overhang_diff = v; }
270
 
    public WizardField getNPlusOverhangPoly() { return nplus_overhang_poly; }
271
 
    public void setNPlusOverhangPoly(WizardField v) { nplus_overhang_poly = v; }
272
 
        public WizardField getNPlusSpacing() { return nplus_spacing; }
273
 
        public void setNPlusSpacing(WizardField v) { nplus_spacing = v; }
274
 
 
275
 
        public WizardField getPPlusWidth() { return pplus_width; }
276
 
        public void setPPlusWidth(WizardField v) { pplus_width = v; }
277
 
        public WizardField getPPlusOverhangDiff() { return pplus_overhang_diff; }
278
 
        public void setPPlusOverhangDiff(WizardField v) { pplus_overhang_diff = v; }
279
 
        public WizardField getPPlusOverhangPoly() { return pplus_overhang_poly; }
280
 
        public void setPPlusOverhangPoly(WizardField v) { pplus_overhang_poly = v; }
281
 
        public WizardField getPPlusSpacing() { return pplus_spacing; }
282
 
        public void setPPlusSpacing(WizardField v) { pplus_spacing = v; }
283
 
 
284
 
        public WizardField getNWellWidth() { return nwell_width; }
285
 
        public void setNWellWidth(WizardField v) { nwell_width = v; }
286
 
        public WizardField getNWellOverhangDiffP() { return nwell_overhang_diff_p; }
287
 
        public void setNWellOverhangDiffP(WizardField v) { nwell_overhang_diff_p = v; }
288
 
        public WizardField getNWellOverhangDiffN() { return nwell_overhang_diff_n; }
289
 
        public void setNWellOverhangDiffN(WizardField v) { nwell_overhang_diff_n = v; }
290
 
        public WizardField getNWellSpacing() { return nwell_spacing; }
291
 
        public void setNWellSpacing(WizardField v) { nwell_spacing = v; }
 
274
        WizardField getNPlusWidth() { return nplus_width; }
 
275
        void setNPlusWidth(WizardField v) { nplus_width = v; }
 
276
        WizardField getNPlusOverhangDiff() { return nplus_overhang_diff; }
 
277
    void setNPlusOverhangDiff(WizardField v) { nplus_overhang_diff = v; }
 
278
    WizardField getNPlusOverhangPoly() { return nplus_overhang_poly; }
 
279
    void setNPlusOverhangPoly(WizardField v) { nplus_overhang_poly = v; }
 
280
        WizardField getNPlusSpacing() { return nplus_spacing; }
 
281
        void setNPlusSpacing(WizardField v) { nplus_spacing = v; }
 
282
 
 
283
        WizardField getPPlusWidth() { return pplus_width; }
 
284
        void setPPlusWidth(WizardField v) { pplus_width = v; }
 
285
        WizardField getPPlusOverhangDiff() { return pplus_overhang_diff; }
 
286
        void setPPlusOverhangDiff(WizardField v) { pplus_overhang_diff = v; }
 
287
        WizardField getPPlusOverhangPoly() { return pplus_overhang_poly; }
 
288
        void setPPlusOverhangPoly(WizardField v) { pplus_overhang_poly = v; }
 
289
        WizardField getPPlusSpacing() { return pplus_spacing; }
 
290
        void setPPlusSpacing(WizardField v) { pplus_spacing = v; }
 
291
 
 
292
        WizardField getNWellWidth() { return nwell_width; }
 
293
        void setNWellWidth(WizardField v) { nwell_width = v; }
 
294
        WizardField getNWellOverhangDiffP() { return nwell_overhang_diff_p; }
 
295
        void setNWellOverhangDiffP(WizardField v) { nwell_overhang_diff_p = v; }
 
296
        WizardField getNWellOverhangDiffN() { return nwell_overhang_diff_n; }
 
297
        void setNWellOverhangDiffN(WizardField v) { nwell_overhang_diff_n = v; }
 
298
        WizardField getNWellSpacing() { return nwell_spacing; }
 
299
        void setNWellSpacing(WizardField v) { nwell_spacing = v; }
292
300
 
293
301
        // METAL RULES
294
 
        public WizardField [] getMetalWidth() { return metal_width; }
295
 
        public void setMetalWidth(int met, WizardField value) { metal_width[met] = value; }
296
 
        public WizardField [] getMetalSpacing() { return metal_spacing; }
297
 
        public void setMetalSpacing(int met, WizardField value) { metal_spacing[met] = value; }
 
302
        WizardField [] getMetalWidth() { return metal_width; }
 
303
        void setMetalWidth(int met, WizardField value) { metal_width[met] = value; }
 
304
        WizardField [] getMetalSpacing() { return metal_spacing; }
 
305
        void setMetalSpacing(int met, WizardField value) { metal_spacing[met] = value; }
298
306
 
299
307
        // VIA RULES
300
 
        public WizardField [] getViaSize() { return via_size; }
301
 
        public void setViaSize(int via, WizardField value) { via_size[via] = value; }
302
 
        public WizardField [] getViaSpacing() { return via_spacing; }
303
 
        public void setViaSpacing(int via, WizardField value) { via_spacing[via] = value; }
304
 
        public WizardField [] getViaArraySpacing() { return via_array_spacing; }
305
 
        public void setViaArraySpacing(int via, WizardField value) { via_array_spacing[via] = value; }
306
 
        public WizardField [] getViaOverhangInline() { return via_overhang_inline; }
307
 
        public void setViaOverhangInline(int via, WizardField value) { via_overhang_inline[via] = value; }
 
308
        WizardField [] getViaSize() { return via_size; }
 
309
        void setViaSize(int via, WizardField value) { via_size[via] = value; }
 
310
        WizardField [] getViaSpacing() { return via_spacing; }
 
311
        void setViaSpacing(int via, WizardField value) { via_spacing[via] = value; }
 
312
        WizardField [] getViaArraySpacing() { return via_array_spacing; }
 
313
        void setViaArraySpacing(int via, WizardField value) { via_array_spacing[via] = value; }
 
314
        WizardField [] getViaOverhangInline() { return via_overhang_inline; }
 
315
        void setViaOverhangInline(int via, WizardField value) { via_overhang_inline[via] = value; }
308
316
 
309
317
        // ANTENNA RULES
310
318
        public double getPolyAntennaRatio() { return poly_antenna_ratio; }
311
 
        public void setPolyAntennaRatio(double v) { poly_antenna_ratio = v; }
 
319
        void setPolyAntennaRatio(double v) { poly_antenna_ratio = v; }
312
320
        public double [] getMetalAntennaRatio() { return metal_antenna_ratio; }
313
 
        public void setMetalAntennaRatio(int met, double value) { metal_antenna_ratio[met] = value; }
 
321
        void setMetalAntennaRatio(int met, double value) { metal_antenna_ratio[met] = value; }
314
322
 
315
323
        // GDS-II LAYERS
316
 
        public int getGDSDiff() { return gds_diff_layer; }
317
 
        public void setGDSDiff(int l) { gds_diff_layer = l; }
318
 
        public int getGDSPoly() { return gds_poly_layer; }
319
 
        public void setGDSPoly(int l) { gds_poly_layer = l; }
320
 
        public int getGDSNPlus() { return gds_nplus_layer; }
321
 
        public void setGDSNPlus(int l) { gds_nplus_layer = l; }
322
 
        public int getGDSPPlus() { return gds_pplus_layer; }
323
 
        public void setGDSPPlus(int l) { gds_pplus_layer = l; }
324
 
        public int getGDSNWell() { return gds_nwell_layer; }
325
 
        public void setGDSNWell(int l) { gds_nwell_layer = l; }
326
 
        public int getGDSContact() { return gds_contact_layer; }
327
 
        public void setGDSContact(int l) { gds_contact_layer = l; }
328
 
        public int [] getGDSMetal() { return gds_metal_layer; }
329
 
        public void setGDSMetal(int met, int l) { gds_metal_layer[met] = l; }
330
 
        public int [] getGDSVia() { return gds_via_layer; }
331
 
        public void setGDSVia(int via, int l) { gds_via_layer[via] = l; }
332
 
        public int getGDSMarking() { return gds_marking_layer; }
333
 
        public void setGDSMarking(int l) { gds_marking_layer = l; }
 
324
        int getGDSDiff() { return gds_diff_layer; }
 
325
        void setGDSDiff(int l) { gds_diff_layer = l; }
 
326
        int getGDSPoly() { return gds_poly_layer; }
 
327
        void setGDSPoly(int l) { gds_poly_layer = l; }
 
328
        int getGDSNPlus() { return gds_nplus_layer; }
 
329
        void setGDSNPlus(int l) { gds_nplus_layer = l; }
 
330
        int getGDSPPlus() { return gds_pplus_layer; }
 
331
        void setGDSPPlus(int l) { gds_pplus_layer = l; }
 
332
        int getGDSNWell() { return gds_nwell_layer; }
 
333
        void setGDSNWell(int l) { gds_nwell_layer = l; }
 
334
        int getGDSContact() { return gds_contact_layer; }
 
335
        void setGDSContact(int l) { gds_contact_layer = l; }
 
336
        int [] getGDSMetal() { return gds_metal_layer; }
 
337
        void setGDSMetal(int met, int l) { gds_metal_layer[met] = l; }
 
338
        int [] getGDSVia() { return gds_via_layer; }
 
339
        void setGDSVia(int via, int l) { gds_via_layer[via] = l; }
 
340
        int getGDSMarking() { return gds_marking_layer; }
 
341
        void setGDSMarking(int l) { gds_marking_layer = l; }
334
342
 
335
 
        public String errorInData()
 
343
        private String errorInData()
336
344
        {
337
345
                // check the General data
338
346
                if (tech_name == null || tech_name.length() == 0) return "General panel: No technology name";
431
439
                                        if (varName.equalsIgnoreCase("tech_name")) setTechName(stripQuotes(varValue)); else
432
440
                                        if (varName.equalsIgnoreCase("tech_description")) setTechDescription(stripQuotes(varValue)); else
433
441
                                        if (varName.equalsIgnoreCase("num_metal_layers")) setNumMetalLayers(TextUtils.atoi(varValue)); else
434
 
                                        if (varName.equalsIgnoreCase("stepsize")) setStepSize(TextUtils.atoi(varValue)); else
 
442
                    if (varName.equalsIgnoreCase("pwell_process")) setPWellProcess(Boolean.valueOf(varValue)); else
 
443
                    if (varName.equalsIgnoreCase("horizontal_transistors")) setHorizontalTransistors(Boolean.valueOf(varValue)); else
 
444
                    if (varName.equalsIgnoreCase("stepsize")) setStepSize(TextUtils.atoi(varValue)); else
435
445
 
436
446
                                        if (varName.equalsIgnoreCase("diff_width")) diff_width.v = TextUtils.atof(varValue); else
437
447
                                        if (varName.equalsIgnoreCase("diff_width_rule")) diff_width.rule = stripQuotes(varValue); else
625
635
 
626
636
        /************************************** EXPORT RAW NUMBERS TO DISK **************************************/
627
637
 
628
 
        public void exportData()
 
638
        void exportData()
629
639
        {
630
640
                String fileName = OpenFile.chooseOutputFile(FileType.TEXT, "Technology Wizard File", "Technology.txt");
631
641
                if (fileName == null) return;
650
660
                pw.println("$tech_name = \"" + tech_name + "\";");
651
661
                pw.println("$tech_description = \"" + tech_description + "\";");
652
662
                pw.println("$num_metal_layers = " + num_metal_layers + ";");
 
663
                pw.println("$num_metal_layers = " + num_metal_layers + ";");
 
664
                pw.println("$pwell_process = " + pWellFlag + ";");
 
665
                pw.println("$horizontal_transistors = " + horizontalFlag + ";");
653
666
                pw.println();
654
667
                pw.println("## stepsize is minimum granularity that will be used as movement grid");
655
668
                pw.println("## set to manufacturing grid or lowest common denominator with design rules");
859
872
 
860
873
        /************************************** WRITE XML FILE **************************************/
861
874
 
862
 
        public void writeXML()
 
875
        void writeXML()
863
876
        {
864
877
                String errorMessage = errorInData();
865
878
                if (errorMessage != null)
892
905
        List<String> portNames = new ArrayList<String>();
893
906
 
894
907
        for (Xml.NodeLayer lb : list)
 
908
        {
 
909
            if (lb == null) continue; // in case the pwell layer off
895
910
            nodesList.add(lb);
 
911
        }
896
912
 
897
913
        portNames.add(name);
898
914
        nodePorts.add(makeXmlPrimitivePort(name.toLowerCase(), 0, 180, 0, null, 0, 0, 0, 0, portNames));
911
927
        List<Xml.PrimitivePort> nodePorts = new ArrayList<Xml.PrimitivePort>();
912
928
 
913
929
        for (Xml.NodeLayer lb : list)
 
930
        {
 
931
            if (lb == null) continue; // in case the pwell layer off
914
932
            nodesList.add(lb);
 
933
        }
915
934
 
916
935
        nodePorts.add(makeXmlPrimitivePort(name.toLowerCase(), 0, 180, 0, null, 0, 0, 0, 0, portNames));
917
936
        return makeXmlPrimitive(nodes, name + "-Con", PrimitiveNode.Function.CONTACT, size, size, 0, 0,
1058
1077
        a.antennaRatio = DBMath.round(ant);
1059
1078
 
1060
1079
        for (Xml.ArcLayer al: arcLayers)
 
1080
        {
 
1081
            if (al == null) continue; // in case the pwell layer off
1061
1082
            a.arcLayers.add(al);
1062
 
 
1063
 
/*        // arc pins
1064
 
        a.arcPin = new Xml.ArcPin();
1065
 
        a.arcPin.name = name + "-Pin"; //arcPin.getName();
1066
 
//            PrimitivePort port = arcPin.getPort(0);
1067
 
        a.arcPin.portName = name; //port.getName();
1068
 
        a.arcPin.elibSize = 0; // 2*arcPin.getSizeCorrector(0).getX();
1069
 
//            for (ArcProto cap: port.getConnections()) {
1070
 
//                if (cap.getTechnology() == tech && cap != this)
1071
 
//                    a.arcPin.portArcs.add(cap.getName());
1072
 
//            }
1073
 
*/
 
1083
        }
1074
1084
        arcs.add(a);
1075
1085
        return a;
1076
1086
    }
1157
1167
 
1158
1168
    /**
1159
1169
     * Method to create the XML versio nof PrimitivePort
1160
 
     * @param name
1161
 
     * @param portAngle
1162
 
     * @param portRange
1163
 
     * @param portTopology
1164
 
     * @param minFullSize
1165
 
     * @param leftRight
1166
 
     * @param bottomTop
1167
 
     * @param portArcs
1168
1170
     * @return
1169
1171
     */
1170
1172
    private Xml.PrimitivePort makeXmlPrimitivePort(String name, int portAngle, int portRange, int portTopology,
1421
1423
            if (fun == null)
1422
1424
                throw new IOException("invalid number of vias");
1423
1425
            viaLayers.add(makeXmlLayer(t.layers, layer_width, "Via-"+metalNum, fun, Layer.Function.CONMETAL,
1424
 
                graph, (char)('A' + cifNumber++), via_size[i], false, false));
 
1426
                graph, (char)('A' + cifNumber++), via_size[i], true, false));
1425
1427
        }
1426
1428
 
1427
1429
        // Poly
1436
1438
        graph = new EGraphics(false, false, null, 0, contact_colour.getRed(), contact_colour.getGreen(),
1437
1439
            contact_colour.getBlue(), 1, true, nullPattern);
1438
1440
        // PolyCon
1439
 
        Xml.Layer polyCon = makeXmlLayer(t.layers, layer_width, "PolyCon", Layer.Function.CONTACT1,
1440
 
            Layer.Function.CONPOLY, graph, (char)('A' + cifNumber++), contact_size, false, false);
 
1441
        Xml.Layer polyConLayer = makeXmlLayer(t.layers, layer_width, "PolyCon", Layer.Function.CONTACT1,
 
1442
            Layer.Function.CONPOLY, graph, (char)('A' + cifNumber++), contact_size, true, false);
1441
1443
        // DiffCon
1442
 
        Xml.Layer diffCon = makeXmlLayer(t.layers, layer_width, "DiffCon", Layer.Function.CONTACT1,
1443
 
            Layer.Function.CONDIFF, graph, (char)('A' + cifNumber++), contact_size, false, false);
 
1444
        Xml.Layer diffConLayer = makeXmlLayer(t.layers, layer_width, "DiffCon", Layer.Function.CONTACT1,
 
1445
            Layer.Function.CONDIFF, graph, (char)('A' + cifNumber++), contact_size, true, false);
1444
1446
 
1445
1447
        // P-Diff and N-Diff
1446
1448
        graph = new EGraphics(false, false, null, 2, 0, 0, 0, 1, true, nullPattern);
1479
1481
        Xml.Layer pplusLayer = makeXmlLayer(t.layers, layer_width, "PPlus", Layer.Function.IMPLANTP, 0, graph,
1480
1482
            (char)('A' + cifNumber++), pplus_width, true, false);
1481
1483
 
1482
 
//              layers.add("N-Well");
 
1484
        // N-Well
1483
1485
        pattern = new int[] { 0x0202,   //       X       X
1484
1486
                        0x0101,   //        X       X
1485
1487
                        0x8080,   // X       X
1500
1502
            nwell_colour.getBlue(), 1, true, pattern);
1501
1503
        Xml.Layer nwellLayer = makeXmlLayer(t.layers, layer_width, "N-Well", Layer.Function.WELLN, 0, graph,
1502
1504
            (char)('A' + cifNumber++), nwell_width, true, false);
 
1505
        Xml.Layer pwellLayer = makeXmlLayer(t.layers, layer_width, "P-Well", Layer.Function.WELLP, 0, graph,
 
1506
            (char)('A' + cifNumber++), nwell_width, true, false);
1503
1507
 
1504
1508
        graph = new EGraphics(false, false, null, 0, 255, 0, 0, 0.4, true, nullPattern);
1505
1509
        // DeviceMark
1506
 
        makeXmlLayer(t.layers, layer_width, "DeviceMark", Layer.Function.CONTROL, 0, graph,
 
1510
        Xml.Layer deviceMarkLayer = makeXmlLayer(t.layers, layer_width, "DeviceMark", Layer.Function.CONTROL, 0, graph,
1507
1511
            (char)('A' + cifNumber++), nplus_width, true, false);
1508
1512
 
1509
1513
        // write arcs
1538
1542
        makeXmlPrimitiveCon(t.nodes, polyLayer.name, hla, null, portNames,
1539
1543
                makeXmlNodeLayer(metal1Over, metal1Over, metal1Over, metal1Over, m1Layer, Poly.Type.FILLED, true), // meta1 layer
1540
1544
                makeXmlNodeLayer(hla, hla, hla, hla, polyLayer, Poly.Type.FILLED, true), // poly layer
1541
 
                makeXmlMulticut(diffCon, contSize, contSpacing, contArraySpacing)); // contact
 
1545
                makeXmlMulticut(diffConLayer, contSize, contSpacing, contArraySpacing)); // contact
1542
1546
        
1543
1547
        /**************************** N/P-Diff Nodes/Arcs ***********************************************/
 
1548
 
1544
1549
        // NDiff/PDiff arcs
1545
1550
        makeXmlArc(t.arcs, "N-Diff", ArcProto.Function.DIFFN, 0,
1546
1551
                makeXmlArcLayer(diffNLayer, diff_width),
1547
 
                makeXmlArcLayer(nplusLayer, diff_width, nplus_overhang_diff));
 
1552
                makeXmlArcLayer(nplusLayer, diff_width, nplus_overhang_diff),
 
1553
            (!pWellFlag)?makeXmlArcLayer(pwellLayer, diff_width, nwell_overhang_diff_p):null);
1548
1554
        makeXmlArc(t.arcs, "P-Diff", ArcProto.Function.DIFFP, 0,
1549
1555
                makeXmlArcLayer(diffPLayer, diff_width),
1550
1556
                makeXmlArcLayer(pplusLayer, diff_width, pplus_overhang_diff),
1556
1562
        double psel = scaledValue(contact_size.v/2 + diff_contact_overhang.v + pplus_overhang_diff.v);
1557
1563
        double nwell = scaledValue(contact_size.v/2 + diff_contact_overhang.v + nwell_overhang_diff_p.v);
1558
1564
        double nso = scaledValue(nwell_overhang_diff_p.v); // valid for elements that have nwell layers
1559
 
        double pso = scaledValue(nplus_overhang_diff.v);
 
1565
        double pso = (!pWellFlag)?nso:scaledValue(nplus_overhang_diff.v);
1560
1566
 
1561
1567
        makeXmlPrimitivePin(t.nodes, "N-Diff", hla,
1562
1568
            new SizeOffset(pso, pso, pso, pso),
1563
1569
            makeXmlNodeLayer(hla, hla, hla, hla, diffNLayer, Poly.Type.CROSSED, true),
1564
 
            makeXmlNodeLayer(nsel, nsel, nsel, nsel, nplusLayer, Poly.Type.CROSSED, true));
 
1570
            makeXmlNodeLayer(nsel, nsel, nsel, nsel, nplusLayer, Poly.Type.CROSSED, true),
 
1571
            (!pWellFlag)?makeXmlNodeLayer(nwell, nwell, nwell, nwell, pwellLayer, Poly.Type.CROSSED, true):null);
1565
1572
        makeXmlPrimitivePin(t.nodes, "P-Diff", hla,
1566
1573
            new SizeOffset(nso, nso, nso, nso),
1567
1574
            makeXmlNodeLayer(hla, hla, hla, hla, diffPLayer, Poly.Type.CROSSED, true),
1578
1585
                makeXmlNodeLayer(metal1Over, metal1Over, metal1Over, metal1Over, m1Layer, Poly.Type.FILLED, true), // meta1 layer
1579
1586
                makeXmlNodeLayer(hla, hla, hla, hla, diffNLayer, Poly.Type.FILLED, true), // active layer
1580
1587
                makeXmlNodeLayer(nsel, nsel, nsel, nsel, nplusLayer, Poly.Type.FILLED, true), // select layer
1581
 
                makeXmlMulticut(diffCon, contSize, contSpacing, contArraySpacing)); // contact
 
1588
            (!pWellFlag)?makeXmlNodeLayer(nwell, nwell, nwell, nwell, pwellLayer, Poly.Type.FILLED, true):null,
 
1589
                makeXmlMulticut(diffConLayer, contSize, contSpacing, contArraySpacing)); // contact
1582
1590
        // pdiff contact
1583
1591
        portNames.clear();
1584
1592
        portNames.add(diffPLayer.name);
1588
1596
                makeXmlNodeLayer(hla, hla, hla, hla, diffPLayer, Poly.Type.FILLED, true), // active layer
1589
1597
                makeXmlNodeLayer(psel, psel, psel, psel, pplusLayer, Poly.Type.FILLED, true), // select layer
1590
1598
                makeXmlNodeLayer(nwell, nwell, nwell, nwell, nwellLayer, Poly.Type.FILLED, true), // well layer
1591
 
                makeXmlMulticut(diffCon, contSize, contSpacing, contArraySpacing)); // contact
 
1599
                makeXmlMulticut(diffConLayer, contSize, contSpacing, contArraySpacing)); // contact
1592
1600
 
1593
1601
        /**************************** N/P-Well Contacts ***********************************************/
1594
1602
        nwell = scaledValue(contact_size.v/2 + diff_contact_overhang.v + nwell_overhang_diff_n.v);
1595
1603
        nso = scaledValue(nwell_overhang_diff_n.v); // valid for elements that have nwell layers
 
1604
 
 
1605
        // NWell/PWell arcs
 
1606
        if (!pWellFlag)
 
1607
        {
 
1608
            makeXmlArc(t.arcs, "P-Well", ArcProto.Function.WELL, 0,
 
1609
                makeXmlArcLayer(pwellLayer, diff_width, nwell_overhang_diff_p));
 
1610
        }
 
1611
        makeXmlArc(t.arcs, "N-Well", ArcProto.Function.WELL, 0,
 
1612
                makeXmlArcLayer(nwellLayer, diff_width, nwell_overhang_diff_p));
 
1613
 
1596
1614
        portNames.clear();
1597
 
        portNames.add(diffNLayer.name);
 
1615
        if (!pWellFlag)
 
1616
            portNames.add(pwellLayer.name);
1598
1617
        portNames.add(m1Layer.name);
1599
1618
        // pwell contact
1600
1619
        makeXmlPrimitiveCon(t.nodes, "P-Well", hla, new SizeOffset(pso, pso, pso, pso), portNames,
1601
1620
                makeXmlNodeLayer(metal1Over, metal1Over, metal1Over, metal1Over, m1Layer, Poly.Type.FILLED, true), // meta1 layer
1602
1621
                makeXmlNodeLayer(hla, hla, hla, hla, diffPLayer, Poly.Type.FILLED, true), // active layer
1603
1622
                makeXmlNodeLayer(nsel, psel, psel, psel, pplusLayer, Poly.Type.FILLED, true), // select layer
1604
 
                makeXmlMulticut(diffCon, contSize, contSpacing, contArraySpacing)); // contact
 
1623
            (!pWellFlag)?makeXmlNodeLayer(nwell, nwell, nwell, nwell, pwellLayer, Poly.Type.FILLED, true):null,
 
1624
                makeXmlMulticut(diffConLayer, contSize, contSpacing, contArraySpacing)); // contact
1605
1625
        // nwell contact
1606
1626
        portNames.clear();
1607
 
        portNames.add(diffPLayer.name);
 
1627
        portNames.add(nwellLayer.name);
1608
1628
        portNames.add(m1Layer.name);
1609
1629
        makeXmlPrimitiveCon(t.nodes, "N-Well", hla, new SizeOffset(nso, nso, nso, nso), portNames,
1610
1630
                makeXmlNodeLayer(metal1Over, metal1Over, metal1Over, metal1Over, m1Layer, Poly.Type.FILLED, true), // meta1 layer
1611
1631
                makeXmlNodeLayer(hla, hla, hla, hla, diffNLayer, Poly.Type.FILLED, true), // active layer
1612
1632
                makeXmlNodeLayer(nsel, nsel, nsel, nsel, nplusLayer, Poly.Type.FILLED, true), // select layer
1613
1633
                makeXmlNodeLayer(nwell, nwell, nwell, nwell, nwellLayer, Poly.Type.FILLED, true), // well layer
1614
 
                makeXmlMulticut(diffCon, contSize, contSpacing, contArraySpacing)); // contact
 
1634
                makeXmlMulticut(diffConLayer, contSize, contSpacing, contArraySpacing)); // contact
1615
1635
 
1616
1636
        /**************************** Metals Nodes/Arcs ***********************************************/
1617
1637
        // Pins and contacts
1645
1665
                makeXmlMulticut(via, viaSize, viaSpacing, viaArraySpacing)); // via
1646
1666
        }
1647
1667
 
 
1668
        /**************************** Transistors ***********************************************/
1648
1669
        /** Transistors **/
1649
1670
        // write the transistors
1650
1671
        List<Xml.NodeLayer> nodesList = new ArrayList<Xml.NodeLayer>();
1651
1672
        List<Xml.PrimitivePort> nodePorts = new ArrayList<Xml.PrimitivePort>();
1652
 
        EPoint minFullSize = null; //EPoint.fromLambda(0, 0);  // default zero
1653
 
                for(int i = 0; i < 2; i++)
 
1673
        EPoint minFullSize = null; //EPoint.fromLambda(0, 0);  // default zero    horizontalFlag
 
1674
 
 
1675
        for(int i = 0; i < 2; i++)
1654
1676
        {
1655
1677
            String name;
1656
1678
            double selecty = 0, selectx = 0;
1657
1679
            Xml.Layer wellLayer = null, activeLayer, selectLayer;
1658
1680
            double sox = 0, soy = 0;
1659
 
            double width = scaledValue((gate_width.v));
1660
 
            double length = scaledValue((gate_length.v));
1661
1681
            double impx = scaledValue((gate_width.v)/2);
1662
1682
            double impy = scaledValue((gate_length.v+diff_poly_overhang.v*2)/2);
1663
1683
            double wellx = scaledValue((gate_width.v/2+nwell_overhang_diff_p.v));
1676
1696
            } else
1677
1697
                        {
1678
1698
                                name = "N";
 
1699
                if (!pWellFlag)
 
1700
                    wellLayer = pwellLayer;
1679
1701
                activeLayer = diffNLayer;
1680
1702
                selectLayer = nplusLayer;
1681
1703
                sox = scaledValue(poly_endcap.v+pplus_overhang_poly.v);
1687
1709
            nodePorts.clear();
1688
1710
            portNames.clear();
1689
1711
 
 
1712
            // Gate layer Electrical
 
1713
            double gatey = scaledValue(gate_length.v/2);
 
1714
            double gatex = impx;
 
1715
            // Poly layers
 
1716
            // left electrical
 
1717
            double endPolyx = scaledValue((gate_width.v+poly_endcap.v*2)/2);
 
1718
            double endPolyy = gatey;
 
1719
            double endLeftOrRight = -impx;   // for horizontal transistors. Default
 
1720
            double endTopOrBotton = endPolyy; // for horizontal transistors. Default
 
1721
            double diffX = 0, diffY = impy;
 
1722
            double xSign = 1, ySign = -1;
 
1723
            double polyX = endPolyx, polyY = 0;
 
1724
 
 
1725
            if (!horizontalFlag) // swap the numbers to get vertical transistors
 
1726
            {
 
1727
                double tmp;
 
1728
                tmp = impx; impx = impy; impy = tmp;
 
1729
                tmp = wellx; wellx = welly; welly = tmp;
 
1730
                tmp = sox; sox = soy; soy = tmp;
 
1731
                tmp = selectx; selectx = selecty; selecty = tmp;
 
1732
                tmp = gatex; gatex = gatey; gatey = tmp;
 
1733
                tmp = endPolyx; endPolyx = endPolyy; endPolyy = tmp;
 
1734
                tmp = diffX; diffX = diffY; diffY = tmp;
 
1735
                tmp = polyX; polyX = polyY; polyY = tmp;
 
1736
                tmp = xSign; xSign = ySign; ySign = tmp;
 
1737
                endLeftOrRight = endPolyx;
 
1738
                endTopOrBotton = -impx;
 
1739
            }
 
1740
 
1690
1741
            // Well layer
1691
1742
            if (wellLayer != null)
1692
1743
                nodesList.add(makeXmlNodeLayer(wellx, wellx, welly, welly, wellLayer, Poly.Type.FILLED, true));
1696
1747
            // top port
1697
1748
            portNames.clear();
1698
1749
            portNames.add(activeLayer.name);
1699
 
            nodePorts.add(makeXmlPrimitivePort("trans-diff-top", 90, 90, 0, minFullSize, 0, 0, impy, impy, portNames));
1700
 
            // right port
1701
 
            nodePorts.add(makeXmlPrimitivePort("trans-diff-bottom", 270, 90, 0, minFullSize, 0, 0, -impy, -impy, portNames));
 
1750
            nodePorts.add(makeXmlPrimitivePort("trans-diff-top", 90, 90, 0, minFullSize, diffX, diffX, diffY, diffY, portNames));
 
1751
            // bottom port
 
1752
            nodePorts.add(makeXmlPrimitivePort("trans-diff-bottom", 270, 90, 0, minFullSize, xSign*diffX, xSign*diffX,
 
1753
                ySign*diffY, ySign*diffY, portNames));
1702
1754
 
1703
1755
            // Gate layer Electrical
1704
 
            double gatey = scaledValue(gate_length.v/2);
1705
 
            nodesList.add(makeXmlNodeLayer(impx, impx, gatey, gatey, polyGateLayer, Poly.Type.FILLED, true));
 
1756
            nodesList.add(makeXmlNodeLayer(gatex, gatex, gatey, gatey, polyGateLayer, Poly.Type.FILLED, true));
1706
1757
 
1707
1758
            // Poly layers
1708
1759
            // left electrical
1709
 
            double endPoly = scaledValue((gate_width.v+poly_endcap.v*2)/2);
1710
 
            nodesList.add(makeXmlNodeLayer(endPoly, -impx, gatey, gatey, polyLayer, Poly.Type.FILLED, true));
 
1760
//            double endPoly = scaledValue((gate_width.v+poly_endcap.v*2)/2);
 
1761
            nodesList.add(makeXmlNodeLayer(endPolyx, endLeftOrRight, endPolyy, endTopOrBotton, polyLayer, Poly.Type.FILLED, true));
1711
1762
            // right electrical
1712
 
            nodesList.add(makeXmlNodeLayer(-impx, endPoly, gatey, gatey, polyLayer, Poly.Type.FILLED, true));
 
1763
            nodesList.add(makeXmlNodeLayer(endLeftOrRight, endPolyx, endTopOrBotton, endPolyy, polyLayer, Poly.Type.FILLED, true));
1713
1764
            // non-electrical poly (just one poly layer)
1714
 
            nodesList.add(makeXmlNodeLayer(endPoly, endPoly, gatey, gatey, polyLayer, Poly.Type.FILLED, false));
 
1765
            nodesList.add(makeXmlNodeLayer(endPolyx, endPolyx, endPolyy, endPolyy, polyLayer, Poly.Type.FILLED, false));
1715
1766
 
1716
1767
            // left port
1717
1768
            portNames.clear();
1718
1769
            portNames.add(polyLayer.name);
1719
 
            nodePorts.add(makeXmlPrimitivePort("trans-poly-left", 180, 90, 0, minFullSize, -endPoly, -endPoly, 0, 0, portNames));
 
1770
            nodePorts.add(makeXmlPrimitivePort("trans-poly-left", 180, 90, 0, minFullSize, ySign*polyX, ySign*polyX,
 
1771
                xSign*polyY, xSign*polyY, portNames));
1720
1772
            // right port
1721
 
            nodePorts.add(makeXmlPrimitivePort("trans-poly-right", 0, 180, 0, minFullSize, endPoly, endPoly, 0, 0, portNames));
 
1773
            nodePorts.add(makeXmlPrimitivePort("trans-poly-right", 0, 180, 0, minFullSize, polyX, polyX, polyY, polyY, portNames));
1722
1774
 
1723
1775
            // Select layer
1724
1776
            nodesList.add(makeXmlNodeLayer(selectx, selectx, selecty, selecty, selectLayer, Poly.Type.FILLED, true));
1730
1782
        
1731
1783
        /** RULES **/
1732
1784
        Xml.Foundry f = new Xml.Foundry();
1733
 
        f.name = Foundry.Type.NONE.name();
 
1785
        f.name = Foundry.Type.NONE.getName();
1734
1786
        t.foundries.add(f);
1735
 
        
 
1787
 
 
1788
        // Writting GDS values
 
1789
        makeLayerGDS(t, diffPLayer, String.valueOf(gds_diff_layer));
 
1790
        makeLayerGDS(t, diffNLayer, String.valueOf(gds_diff_layer));
 
1791
        makeLayerGDS(t, pplusLayer, String.valueOf(gds_pplus_layer));
 
1792
        makeLayerGDS(t, nplusLayer, String.valueOf(gds_nplus_layer));
 
1793
        makeLayerGDS(t, nwellLayer, String.valueOf(gds_nwell_layer));
 
1794
        makeLayerGDS(t, deviceMarkLayer, String.valueOf(gds_marking_layer));
 
1795
        makeLayerGDS(t, polyConLayer, String.valueOf(gds_contact_layer));
 
1796
        makeLayerGDS(t, diffConLayer, String.valueOf(gds_contact_layer));
 
1797
        makeLayerGDS(t, polyLayer, String.valueOf(gds_poly_layer));
 
1798
        makeLayerGDS(t, polyGateLayer, String.valueOf(gds_poly_layer));
 
1799
 
 
1800
        for (int i = 0; i < num_metal_layers; i++) {
 
1801
            Xml.Layer met = metalLayers.get(i);
 
1802
            makeLayerGDS(t, met, String.valueOf(gds_metal_layer[i]));
 
1803
 
 
1804
            if (i > num_metal_layers - 2) continue;
 
1805
 
 
1806
            Xml.Layer via = viaLayers.get(i);
 
1807
            makeLayerGDS(t, via, String.valueOf(gds_via_layer[i]));
 
1808
        }
 
1809
 
 
1810
        // Writting Layer Rules
1736
1811
        makeLayerRuleMinWid(t, diffPLayer, diff_width);
1737
1812
        makeLayerRuleMinWid(t, diffNLayer, diff_width);
1738
1813
        makeLayerRuleMinWid(t, pplusLayer, pplus_width);
1776
1851
//            dist.addRule(flds[i].rule, 1);
1777
1852
//        return dist;
1778
1853
//    }
1779
 
    
 
1854
 
 
1855
    private void makeLayerGDS(Xml.Technology t, Xml.Layer l, String gdsVal) {
 
1856
        for (Xml.Foundry f: t.foundries) {
 
1857
            f.layerGds.put(l.name, gdsVal);
 
1858
        }
 
1859
    }
 
1860
 
1780
1861
    private void makeLayerRuleMinWid(Xml.Technology t, Xml.Layer l, WizardField fld) {
1781
1862
        for (Xml.Foundry f: t.foundries) {
1782
1863
            f.rules.add(new DRCTemplate(fld.rule, DRCTemplate.DRCMode.ALL.mode(), DRCTemplate.DRCRuleType.MINWID,
1799
1880
        }
1800
1881
    }
1801
1882
 
1802
 
//    private void dumpTechnology(PrintWriter pw)
1803
 
//      {
1804
 
//              // LAYER COLOURS
1805
 
//              Color [] metal_colour = new Color[]
1806
 
//              {
1807
 
//                      new Color(0,150,255),   // cyan/blue
1808
 
//                      new Color(148,0,211),   // purple
1809
 
//                      new Color(255,215,0),   // yellow
1810
 
//                      new Color(132,112,255), // mauve
1811
 
//                      new Color(255,160,122), // salmon
1812
 
//                      new Color(34,139,34),   // dull green
1813
 
//                      new Color(178,34,34),   // dull red
1814
 
//                      new Color(34,34,178),   // dull blue
1815
 
//                      new Color(153,153,153), // light gray
1816
 
//                      new Color(102,102,102)  // dark gray
1817
 
//              };
1818
 
//              Color poly_colour = new Color(255,155,192);   // pink
1819
 
//              Color diff_colour = new Color(107,226,96);    // light green
1820
 
//              Color via_colour = new Color(205,205,205);    // lighter gray
1821
 
//              Color contact_colour = new Color(40,40,40);   // darker gray
1822
 
//              Color nplus_colour = new Color(224,238,224);
1823
 
//              Color pplus_colour = new Color(224,224,120);
1824
 
//              Color nwell_colour = new Color(140,140,140);
1825
 
//
1826
 
//        // write the header
1827
 
//              String foundry_name = "NONE";
1828
 
//              pw.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
1829
 
//              pw.println();
1830
 
//              pw.println("<!--");
1831
 
//              pw.println(" *");
1832
 
//              pw.println(" *  Electric technology file for process \"" + tech_name + "\"");
1833
 
//              pw.println(" *");
1834
 
//              pw.println(" *  Automatically generated by Electric's technology wizard");
1835
 
//              pw.println(" *");
1836
 
//              pw.println("-->");
1837
 
//              pw.println();
1838
 
//              pw.println("<technology name=\"" + tech_name + "\"");
1839
 
//              pw.println("    xmlns=\"http://electric.sun.com/Technology\"");
1840
 
//              pw.println("    xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
1841
 
//              pw.println("    xsi:schemaLocation=\"http://electric.sun.com/Technology ../../technology/Technology.xsd\">");
1842
 
//              pw.println();
1843
 
//              pw.println("    <shortName>" + tech_name + "</shortName>");
1844
 
//              pw.println("    <description>" + tech_description + "</description>");
1845
 
//              pw.println("    <numMetals min=\"" + num_metal_layers + "\" max=\"" + num_metal_layers + "\" default=\"" + num_metal_layers + "\"/>");
1846
 
//              pw.println("    <scale value=\"" + floaty(stepsize) + "\" relevant=\"true\"/>");
1847
 
//              pw.println("    <defaultFoundry value=\"" + foundry_name + "\"/>");
1848
 
//              pw.println("    <minResistance value=\"1.0\"/>");
1849
 
//              pw.println("    <minCapacitance value=\"0.1\"/>");
1850
 
//              pw.println();
1851
 
//
1852
 
//              // write the transparent layer colors
1853
 
//              int li = 1;
1854
 
//              pw.println("    <!-- Transparent layers -->");
1855
 
//              pw.println("    <transparentLayer transparent=\"" + (li++) + "\">");
1856
 
//              pw.println("        <r>" + poly_colour.getRed() + "</r>");
1857
 
//              pw.println("        <g>" + poly_colour.getGreen() + "</g>");
1858
 
//              pw.println("        <b>" + poly_colour.getBlue() + "</b>");
1859
 
//              pw.println("    </transparentLayer>");
1860
 
//              pw.println("    <transparentLayer transparent=\"" + (li++) + "\">");
1861
 
//              pw.println("        <r>" + diff_colour.getRed() + "</r>");
1862
 
//              pw.println("        <g>" + diff_colour.getGreen() + "</g>");
1863
 
//              pw.println("        <b>" + diff_colour.getBlue() + "</b>");
1864
 
//              pw.println("    </transparentLayer>");
1865
 
//              pw.println("    <transparentLayer transparent=\"" + (li++) + "\">");
1866
 
//              pw.println("        <r>" + metal_colour[0].getRed() + "</r>");
1867
 
//              pw.println("        <g>" + metal_colour[0].getGreen() + "</g>");
1868
 
//              pw.println("        <b>" + metal_colour[0].getBlue() + "</b>");
1869
 
//              pw.println("    </transparentLayer>");
1870
 
//              pw.println("    <transparentLayer transparent=\"" + (li++) + "\">");
1871
 
//              pw.println("        <r>" + metal_colour[1].getRed() + "</r>");
1872
 
//              pw.println("        <g>" + metal_colour[1].getGreen() + "</g>");
1873
 
//              pw.println("        <b>" + metal_colour[1].getBlue() + "</b>");
1874
 
//              pw.println("    </transparentLayer>");
1875
 
//              pw.println("    <transparentLayer transparent=\"" + (li++) + "\">");
1876
 
//              pw.println("        <r>" + metal_colour[2].getRed() + "</r>");
1877
 
//              pw.println("        <g>" + metal_colour[2].getGreen() + "</g>");
1878
 
//              pw.println("        <b>" + metal_colour[2].getBlue() + "</b>");
1879
 
//              pw.println("    </transparentLayer>");
1880
 
//
1881
 
//              // write the layers
1882
 
//              pw.println();
1883
 
//              pw.println("<!--  LAYERS  -->");
1884
 
//              List<String> layers = new ArrayList<String>();
1885
 
//              for(int i=1; i<=num_metal_layers; i++)
1886
 
//                      layers.add("Metal-"+i);
1887
 
//              for(int i=1; i<=num_metal_layers-1; i++)
1888
 
//                      layers.add("Via-"+i);
1889
 
//              layers.add("Poly");
1890
 
//              layers.add("PolyGate");
1891
 
//              layers.add("PolyCon");
1892
 
//              layers.add("DiffCon");
1893
 
//              layers.add("N-Diff");
1894
 
//              layers.add("P-Diff");
1895
 
//              layers.add("NPlus");
1896
 
//              layers.add("PPlus");
1897
 
//              layers.add("N-Well");
1898
 
//              layers.add("DeviceMark");
1899
 
//              for(int i=0; i<layers.size(); i++)
1900
 
//              {
1901
 
//                      String l = layers.get(i);
1902
 
//                      int tcol = 0;
1903
 
//                      String fun = "";
1904
 
//                      String extrafun = "";
1905
 
//                      int r = 255;
1906
 
//                      int g = 0;
1907
 
//                      int b = 0;
1908
 
//              double opacity = 0.4;
1909
 
//                      double la = -1;
1910
 
//                      String pat = null;
1911
 
//
1912
 
//                      if (l.startsWith("Metal"))
1913
 
//                      {
1914
 
//                              int metLay = TextUtils.atoi(l.substring(6));
1915
 
//                              int metLayDig = (metLay-1) % 10;
1916
 
//                              switch (metLayDig)
1917
 
//                              {
1918
 
//                                      case 0: tcol = 3;   break;
1919
 
//                                      case 1: tcol = 4;   break;
1920
 
//                                      case 2: tcol = 5;   break;
1921
 
//                                      case 3:
1922
 
//                                              pat="        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1923
 
//                                                      "        <pattern>                </pattern>\n" +
1924
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1925
 
//                                                      "        <pattern>                </pattern>\n" +
1926
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1927
 
//                                                      "        <pattern>                </pattern>\n" +
1928
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1929
 
//                                                      "        <pattern>                </pattern>\n" +
1930
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1931
 
//                                                      "        <pattern>                </pattern>\n" +
1932
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1933
 
//                                                      "        <pattern>                </pattern>\n" +
1934
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1935
 
//                                                      "        <pattern>                </pattern>\n" +
1936
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1937
 
//                                                      "        <pattern>                </pattern>";
1938
 
//                                              break;
1939
 
//                                      case 4:
1940
 
//                                              pat="        <pattern>X   X   X   X   </pattern>\n" +
1941
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1942
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1943
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1944
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1945
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1946
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1947
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1948
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1949
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1950
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1951
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1952
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1953
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1954
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1955
 
//                                                      "        <pattern> X   X   X   X  </pattern>";
1956
 
//                                              break;
1957
 
//                                      case 5:
1958
 
//                                              pat="        <pattern>   X   X   X   X</pattern>\n" +
1959
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1960
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1961
 
//                                                      "        <pattern> X X X X X X X X</pattern>\n" +
1962
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1963
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1964
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1965
 
//                                                      "        <pattern> X X X X X X X X</pattern>\n" +
1966
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1967
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1968
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1969
 
//                                                      "        <pattern> X X X X X X X X</pattern>\n" +
1970
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1971
 
//                                                      "        <pattern>XXXXXXXXXXXXXXXX</pattern>\n" +
1972
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1973
 
//                                                      "        <pattern> X X X X X X X X</pattern>";
1974
 
//                                              break;
1975
 
//                                      case 6:
1976
 
//                                              pat="        <pattern>X   X   X   X   </pattern>\n" +
1977
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1978
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1979
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1980
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1981
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1982
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1983
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1984
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1985
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1986
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1987
 
//                                                      "        <pattern>   X   X   X   X</pattern>\n" +
1988
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1989
 
//                                                      "        <pattern> X   X   X   X  </pattern>\n" +
1990
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1991
 
//                                                      "        <pattern>   X   X   X   X</pattern>";
1992
 
//                                              break;
1993
 
//                                      case 7:
1994
 
//                                              pat="        <pattern>  X   X   X   X </pattern>\n" +
1995
 
//                                                      "        <pattern>                </pattern>\n" +
1996
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
1997
 
//                                                      "        <pattern>                </pattern>\n" +
1998
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
1999
 
//                                                      "        <pattern>                </pattern>\n" +
2000
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
2001
 
//                                                      "        <pattern>                </pattern>\n" +
2002
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
2003
 
//                                                      "        <pattern>                </pattern>\n" +
2004
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
2005
 
//                                                      "        <pattern>                </pattern>\n" +
2006
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
2007
 
//                                                      "        <pattern>                </pattern>\n" +
2008
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
2009
 
//                                                      "        <pattern>                </pattern>";
2010
 
//                                              break;
2011
 
//                                      case 8:
2012
 
//                                              pat="        <pattern>                </pattern>\n" +
2013
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
2014
 
//                                                      "        <pattern>                </pattern>\n" +
2015
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
2016
 
//                                                      "        <pattern>                </pattern>\n" +
2017
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
2018
 
//                                                      "        <pattern>                </pattern>\n" +
2019
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
2020
 
//                                                      "        <pattern>                </pattern>\n" +
2021
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
2022
 
//                                                      "        <pattern>                </pattern>\n" +
2023
 
//                                                      "        <pattern>X   X   X   X   </pattern>\n" +
2024
 
//                                                      "        <pattern>                </pattern>\n" +
2025
 
//                                                      "        <pattern>  X   X   X   X </pattern>\n" +
2026
 
//                                                      "        <pattern>                </pattern>\n" +
2027
 
//                                                      "        <pattern>X   X   X   X   </pattern>";
2028
 
//                        break;
2029
 
//                    case 9:
2030
 
//                                              pat="        <pattern>X X X X X X X X </pattern>\n" +
2031
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2032
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2033
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2034
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2035
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2036
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2037
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2038
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2039
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2040
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2041
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2042
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2043
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2044
 
//                                                      "        <pattern>X X X X X X X X </pattern>\n" +
2045
 
//                                                      "        <pattern>X X X X X X X X </pattern>";
2046
 
//                                              break;
2047
 
//                              }
2048
 
//                              fun = "METAL" + metLay;
2049
 
//                              int metLayHigh = (metLay-1) / 10;
2050
 
//                              r = metal_colour[metLayDig].getRed() * (10-metLayHigh) / 10;
2051
 
//                              g = metal_colour[metLayDig].getGreen() * (10-metLayHigh) / 10;
2052
 
//                              b = metal_colour[metLayDig].getBlue() * (10-metLayHigh) / 10;
2053
 
//                      opacity = (75 - metLay * 5)/100.0;
2054
 
//                              la = metal_width[metLay-1].v / stepsize;
2055
 
//                      }
2056
 
//
2057
 
//                      if (l.startsWith("Via"))
2058
 
//                      {
2059
 
//                              int viaLay = TextUtils.atoi(l.substring(4));
2060
 
//                              fun = "CONTACT" + viaLay;
2061
 
//                              extrafun = "connects-metal";
2062
 
//                              r = via_colour.getRed();
2063
 
//                              g = via_colour.getGreen();
2064
 
//                              b = via_colour.getBlue();
2065
 
//                opacity = 0.7;
2066
 
//                              la = via_size[viaLay-1].v / stepsize;
2067
 
//                      }
2068
 
//
2069
 
//                      if (l.equals("DeviceMark"))
2070
 
//                      {
2071
 
//                              fun = "CONTROL";
2072
 
//                              la = nplus_width.v / stepsize;
2073
 
//                              pat="        <pattern>                </pattern>\n" +
2074
 
//                                      "        <pattern>                </pattern>\n" +
2075
 
//                                      "        <pattern>                </pattern>\n" +
2076
 
//                                      "        <pattern>                </pattern>\n" +
2077
 
//                                      "        <pattern>                </pattern>\n" +
2078
 
//                                      "        <pattern>                </pattern>\n" +
2079
 
//                                      "        <pattern>                </pattern>\n" +
2080
 
//                                      "        <pattern>                </pattern>\n" +
2081
 
//                                      "        <pattern>                </pattern>\n" +
2082
 
//                                      "        <pattern>                </pattern>\n" +
2083
 
//                                      "        <pattern>                </pattern>\n" +
2084
 
//                                      "        <pattern>                </pattern>\n" +
2085
 
//                                      "        <pattern>                </pattern>\n" +
2086
 
//                                      "        <pattern>                </pattern>\n" +
2087
 
//                                      "        <pattern>                </pattern>\n" +
2088
 
//                                      "        <pattern>                </pattern>";
2089
 
//                      }
2090
 
//
2091
 
//                      if (l.equals("Poly"))
2092
 
//                      {
2093
 
//                              fun = "POLY1";
2094
 
//                              tcol = 1;
2095
 
//                opacity = 1;
2096
 
//                              la = poly_width.v / stepsize;
2097
 
//                      }
2098
 
//
2099
 
//                      if (l.equals("PolyGate"))
2100
 
//                      {
2101
 
//                              fun = "GATE";
2102
 
//                              tcol = 1;
2103
 
//                opacity = 1;
2104
 
//                      }
2105
 
//
2106
 
//                      if (l.equals("P-Diff"))
2107
 
//                      {
2108
 
//                              fun = "DIFFP";
2109
 
//                              tcol = 2;
2110
 
//                opacity = 1;
2111
 
//                              la = diff_width.v / stepsize;
2112
 
//                      }
2113
 
//
2114
 
//                      if (l.equals("N-Diff"))
2115
 
//                      {
2116
 
//                              fun = "DIFFN";
2117
 
//                              tcol = 2;
2118
 
//                opacity = 1;
2119
 
//                              la = diff_width.v / stepsize;
2120
 
//                      }
2121
 
//
2122
 
//                      if (l.equals("NPlus"))
2123
 
//                      {
2124
 
//                              fun = "IMPLANTN";
2125
 
//                              r = nplus_colour.getRed();
2126
 
//                              g = nplus_colour.getGreen();
2127
 
//                              b = nplus_colour.getBlue();
2128
 
//                opacity = 1;
2129
 
//                              la = nplus_width.v / stepsize;
2130
 
//                              pat="        <pattern>   X       X    </pattern>\n" +
2131
 
//                                      "        <pattern>  X       X     </pattern>\n" +
2132
 
//                                      "        <pattern> X       X      </pattern>\n" +
2133
 
//                                      "        <pattern>X       X       </pattern>\n" +
2134
 
//                                      "        <pattern>       X       X</pattern>\n" +
2135
 
//                                      "        <pattern>      X       X </pattern>\n" +
2136
 
//                                      "        <pattern>     X       X  </pattern>\n" +
2137
 
//                                      "        <pattern>    X       X   </pattern>\n" +
2138
 
//                                      "        <pattern>   X       X    </pattern>\n" +
2139
 
//                                      "        <pattern>  X       X     </pattern>\n" +
2140
 
//                                      "        <pattern> X       X      </pattern>\n" +
2141
 
//                                      "        <pattern>X       X       </pattern>\n" +
2142
 
//                                      "        <pattern>       X       X</pattern>\n" +
2143
 
//                                      "        <pattern>      X       X </pattern>\n" +
2144
 
//                                      "        <pattern>     X       X  </pattern>\n" +
2145
 
//                                      "        <pattern>    X       X   </pattern>";
2146
 
//                      }
2147
 
//
2148
 
//
2149
 
//                      if (l.equals("PPlus"))
2150
 
//                      {
2151
 
//                              fun = "IMPLANTP";
2152
 
//                              r = pplus_colour.getRed();
2153
 
//                              g = pplus_colour.getGreen();
2154
 
//                              b = pplus_colour.getBlue();
2155
 
//                opacity = 1;
2156
 
//                              la = pplus_width.v / stepsize;
2157
 
//                              pat="        <pattern>   X       X    </pattern>\n" +
2158
 
//                                      "        <pattern>  X       X     </pattern>\n" +
2159
 
//                                      "        <pattern> X       X      </pattern>\n" +
2160
 
//                                      "        <pattern>X       X       </pattern>\n" +
2161
 
//                                      "        <pattern>       X       X</pattern>\n" +
2162
 
//                                      "        <pattern>      X       X </pattern>\n" +
2163
 
//                                      "        <pattern>     X       X  </pattern>\n" +
2164
 
//                                      "        <pattern>    X       X   </pattern>\n" +
2165
 
//                                      "        <pattern>   X       X    </pattern>\n" +
2166
 
//                                      "        <pattern>  X       X     </pattern>\n" +
2167
 
//                                      "        <pattern> X       X      </pattern>\n" +
2168
 
//                                      "        <pattern>X       X       </pattern>\n" +
2169
 
//                                      "        <pattern>       X       X</pattern>\n" +
2170
 
//                                      "        <pattern>      X       X </pattern>\n" +
2171
 
//                                      "        <pattern>     X       X  </pattern>\n" +
2172
 
//                                      "        <pattern>    X       X   </pattern>";
2173
 
//                      }
2174
 
//
2175
 
//                      if (l.equals("N-Well"))
2176
 
//                      {
2177
 
//                              fun = "WELLN";
2178
 
//                              r = nwell_colour.getRed();
2179
 
//                              g = nwell_colour.getGreen();
2180
 
//                              b = nwell_colour.getBlue();
2181
 
//                opacity = 1;
2182
 
//                              la = nwell_width.v / stepsize;
2183
 
//                              pat="        <pattern>       X       X</pattern>\n" +
2184
 
//                                      "        <pattern>X       X       </pattern>\n" +
2185
 
//                                      "        <pattern> X       X      </pattern>\n" +
2186
 
//                                      "        <pattern>  X       X     </pattern>\n" +
2187
 
//                                      "        <pattern>   X       X    </pattern>\n" +
2188
 
//                                      "        <pattern>    X       X   </pattern>\n" +
2189
 
//                                      "        <pattern>     X       X  </pattern>\n" +
2190
 
//                                      "        <pattern>      X       X </pattern>\n" +
2191
 
//                                      "        <pattern>       X       X</pattern>\n" +
2192
 
//                                      "        <pattern>X       X       </pattern>\n" +
2193
 
//                                      "        <pattern> X       X      </pattern>\n" +
2194
 
//                                      "        <pattern>  X       X     </pattern>\n" +
2195
 
//                                      "        <pattern>   X       X    </pattern>\n" +
2196
 
//                                      "        <pattern>    X       X   </pattern>\n" +
2197
 
//                                      "        <pattern>     X       X  </pattern>\n" +
2198
 
//                                      "        <pattern>      X       X </pattern>";
2199
 
//                      }
2200
 
//
2201
 
//                      if (l.equals("PolyCon"))
2202
 
//                      {
2203
 
//                              fun = "CONTACT1";
2204
 
//                              extrafun = "connects-poly";
2205
 
//                              r = contact_colour.getRed();
2206
 
//                              g = contact_colour.getGreen();
2207
 
//                              b = contact_colour.getBlue();
2208
 
//                opacity = 1;
2209
 
//                              la = contact_size.v / stepsize;
2210
 
//                      }
2211
 
//
2212
 
//                      if (l.equals("DiffCon"))
2213
 
//                      {
2214
 
//                              fun = "CONTACT1";
2215
 
//                              extrafun = "connects-diff";
2216
 
//                              r = contact_colour.getRed();
2217
 
//                              g = contact_colour.getGreen();
2218
 
//                              b = contact_colour.getBlue();
2219
 
//                opacity = 1;
2220
 
//                              la = contact_size.v / stepsize;
2221
 
//                      }
2222
 
//
2223
 
//                      pw.println();
2224
 
//                      pw.println("    <layer name=\"" + l + "\" " + (fun.length() > 0 ? ("fun=\"" + fun + "\"") : "") +
2225
 
//                              (extrafun.length() > 0 ? (" extraFun=\"" + extrafun + "\"") : "") + ">");
2226
 
//                      if (tcol == 0)
2227
 
//                      {
2228
 
//                              pw.println("        <opaqueColor r=\"" + r + "\" g=\"" + g + "\" b=\"" + b + "\"/>");
2229
 
//                      } else
2230
 
//                      {
2231
 
//                              pw.println("        <transparentColor transparent=\"" + tcol + "\"/>");
2232
 
//                      }
2233
 
//                      pw.println("        <patternedOnDisplay>" + (pat == null ? "false" : "true") + "</patternedOnDisplay>");
2234
 
//                      pw.println("        <patternedOnPrinter>" + (pat == null ? "false" : "true") + "</patternedOnPrinter>");
2235
 
//                      if (pat == null)
2236
 
//                      {
2237
 
//                              for(int j=0; j<16; j++)
2238
 
//                                      pw.println("        <pattern>                </pattern>");
2239
 
//                      } else
2240
 
//                      {
2241
 
//                              pw.println(pat);
2242
 
//                      }
2243
 
//                      pw.println("        <outlined>NOPAT</outlined>");
2244
 
//                      pw.println("        <opacity>" + opacity + "</opacity>");
2245
 
//                      pw.println("        <foreground>true</foreground>");
2246
 
//                      pw.println("        <display3D thick=\"1.0\" height=\"1.0\" mode=\"NONE\" factor=\"1.0\"/>");
2247
 
//                      char cifLetter = (char)('A' + i);
2248
 
//                      pw.println("        <cifLayer cif=\"C" + cifLetter + cifLetter + "\"/>");
2249
 
//                      pw.println("        <skillLayer skill=\"" + l + "\"/>");
2250
 
//                      pw.println("        <parasitics resistance=\"1.0\" capacitance=\"0.0\" edgeCapacitance=\"0.0\"/>");
2251
 
//                      if (fun.startsWith("METAL") || fun.startsWith("POLY") || fun.startsWith("DIFF"))
2252
 
//                      {
2253
 
//                              pw.println("        <pureLayerNode name=\"" + l + "-Node\" port=\"Port_" + l + "\">");
2254
 
//                              pw.println("            <lambda>" + floaty(la) + "</lambda>");
2255
 
//                              pw.println("            <portArc>" + l + "</portArc>");
2256
 
//                              pw.println("        </pureLayerNode>");
2257
 
//                      }
2258
 
//                      pw.println("    </layer>");
2259
 
//              }
2260
 
//
2261
 
//              // write the arcs
2262
 
//              List<String> arcs = new ArrayList<String>();
2263
 
//              for(int i=1; i<=num_metal_layers; i++)
2264
 
//                      arcs.add("Metal-"+i);
2265
 
//              arcs.add("Poly");
2266
 
//              arcs.add("N-Diff");
2267
 
//              arcs.add("P-Diff");
2268
 
//              pw.println();
2269
 
//              pw.println("<!--  ARCS  -->");
2270
 
//              for(String l : arcs)
2271
 
//              {
2272
 
//                      String fun = "";
2273
 
//                      int ant = -1;
2274
 
//                      double la = 0;
2275
 
//                      List<String> h = new ArrayList<String>();
2276
 
//                      if (l.startsWith("Metal"))
2277
 
//                      {
2278
 
//                              int metalLay = TextUtils.atoi(l.substring(6));
2279
 
//                              fun = "METAL" + metalLay;
2280
 
//                              la = metal_width[metalLay-1].v / stepsize;
2281
 
//                              ant = (int)Math.round(metal_antenna_ratio[metalLay-1]) | 200;
2282
 
//                              h.add(l + "=" + la);
2283
 
//                      }
2284
 
//
2285
 
//                      if (l.equals("N-Diff"))
2286
 
//                      {
2287
 
//                              fun = "DIFFN";
2288
 
//                              h.add("N-Diff=" + (diff_width.v/stepsize));
2289
 
//                              h.add("NPlus=" + ((nplus_overhang_diff.v*2+diff_width.v)/stepsize));
2290
 
//                      }
2291
 
//
2292
 
//                      if (l.equals("P-Diff"))
2293
 
//                      {
2294
 
//                              fun = "DIFFP";
2295
 
//                              h.add("P-Diff=" + (diff_width.v / stepsize));
2296
 
//                              h.add("PPlus=" + ((pplus_overhang_diff.v*2 + diff_width.v) / stepsize));
2297
 
//                              h.add("N-Well=" + ((nwell_overhang_diff.v*2 + diff_width.v) / stepsize));
2298
 
//                      }
2299
 
//
2300
 
//                      if (l.equals("Poly"))
2301
 
//                      {
2302
 
//                              fun = "POLY1";
2303
 
//                              la = poly_width.v / stepsize;
2304
 
//                              ant = (int)Math.round(poly_antenna_ratio) | 200;
2305
 
//                              h.add(l + "=" + la);
2306
 
//                      }
2307
 
//
2308
 
//                      double max = 0;
2309
 
//                      for(String hEach : h)
2310
 
//                      {
2311
 
//                              int equalsPos = hEach.indexOf('=');
2312
 
//                              double lim = TextUtils.atof(hEach.substring(equalsPos+1));
2313
 
//                              if (lim > max) max = lim;
2314
 
//                      }
2315
 
//
2316
 
//                      if (ant >= 0) ant = Math.round(ant);
2317
 
//                      pw.println();
2318
 
//                      pw.println("    <arcProto name=\"" + l + "\" fun=\"" + fun + "\">");
2319
 
//                      pw.println("        <wipable/>");
2320
 
//                      pw.println("        <extended>true</extended>");
2321
 
//                      pw.println("        <fixedAngle>true</fixedAngle>");
2322
 
//                      pw.println("        <angleIncrement>90</angleIncrement>");
2323
 
//            if (ant >= 0)
2324
 
//                pw.println("        <antennaRatio>" + floaty(ant) + "</antennaRatio>");
2325
 
//
2326
 
//                      for(String each : h)
2327
 
//                      {
2328
 
//                              int equalsPos = each.indexOf('=');
2329
 
//                              String nom = each.substring(0, equalsPos);
2330
 
//                              double lim = TextUtils.atof(each.substring(equalsPos+1));
2331
 
//
2332
 
//                              pw.println("        <arcLayer layer=\"" + nom + "\" style=\"FILLED\">");
2333
 
//                              pw.println("            <lambda>" + floaty(lim/2) + "</lambda>");
2334
 
//                              pw.println("        </arcLayer>");
2335
 
//                      }
2336
 
//                      pw.println("    </arcProto>");
2337
 
//              }
2338
 
//
2339
 
//              // write the pins
2340
 
//              pw.println();
2341
 
//              pw.println("<!--  PINS  -->");
2342
 
//              for(int i=1; i<=num_metal_layers; i++)
2343
 
//              {
2344
 
//                      double hla = metal_width[i-1].v / (stepsize*2);
2345
 
//            String shla = floaty(hla);
2346
 
//            pw.println();
2347
 
//                      pw.println("    <primitiveNode name=\"Metal-" + i + "-Pin\" fun=\"PIN\">");
2348
 
//                      pw.println("        <shrinkArcs/>");
2349
 
//            pw.println("        <sizeOffset lx=\"" + shla + "\" hx=\"" + shla +
2350
 
//                              "\" ly=\"" + shla + "\" hy=\"" + shla +"\"/>");
2351
 
//            pw.println("        <nodeLayer layer=\"Metal-" + i + "\" style=\"CROSSED\">");
2352
 
//                      pw.println("            <box>");
2353
 
//                      pw.println("                <lambdaBox klx=\"-" + shla + "\" khx=\"" + shla +
2354
 
//                              "\" kly=\"-" + shla + "\" khy=\"" + shla +"\"/>");
2355
 
//                      pw.println("            </box>");
2356
 
//                      pw.println("        </nodeLayer>");
2357
 
//                      pw.println("        <primitivePort name=\"M" + i + "\">");
2358
 
//                      pw.println("            <portAngle primary=\"0\" range=\"180\"/>");
2359
 
//                      pw.println("            <portTopology>0</portTopology>");
2360
 
//                      pw.println("            <box>");
2361
 
//                      pw.println("                <lambdaBox klx=\"0.0\" khx=\"0.0\" kly=\"0.0\" khy=\"0.0\"/>");
2362
 
//                      pw.println("            </box>");
2363
 
//                      pw.println("            <portArc>Metal-" + i + "</portArc>");
2364
 
//                      pw.println("        </primitivePort>");
2365
 
//                      pw.println("    </primitiveNode>");
2366
 
//              }
2367
 
//              double hla = poly_width.v / (stepsize*2);
2368
 
//        String shla = floaty(hla);
2369
 
//        pw.println();
2370
 
//              pw.println("    <primitiveNode name=\"Poly-Pin\" fun=\"PIN\">");
2371
 
//              pw.println("        <shrinkArcs/>");
2372
 
//        pw.println("        <sizeOffset lx=\"" + shla + "\" hx=\"" + shla +
2373
 
//            "\" ly=\"" + shla + "\" hy=\"" + shla +"\"/>");
2374
 
//        pw.println("        <nodeLayer layer=\"Poly\" style=\"CROSSED\">");
2375
 
//              pw.println("            <box>");
2376
 
//              pw.println("                <lambdaBox klx=\"-" + shla + "\" khx=\"" + shla +
2377
 
//                      "\" kly=\"-" + shla + "\" khy=\"" + shla + "\"/>");
2378
 
//              pw.println("            </box>");
2379
 
//              pw.println("        </nodeLayer>");
2380
 
//              pw.println("        <primitivePort name=\"Poly\">");
2381
 
//              pw.println("            <portAngle primary=\"0\" range=\"180\"/>");
2382
 
//              pw.println("            <portTopology>0</portTopology>");
2383
 
//              pw.println("            <box>");
2384
 
//              pw.println("                <lambdaBox klx=\"0.0\" khx=\"0.0\" kly=\"0.0\" khy=\"0.0\"/>");
2385
 
//              pw.println("            </box>");
2386
 
//              pw.println("            <portArc>Poly</portArc>");
2387
 
//              pw.println("        </primitivePort>");
2388
 
//              pw.println("    </primitiveNode>");
2389
 
//
2390
 
//              pw.println();
2391
 
//              pw.println("<!--  P-Diff AND N-Diff PINS  -->");
2392
 
//              for(int i=0; i<=1; i++)
2393
 
//              {
2394
 
//                      String t, d1, d2, d3;
2395
 
//                      if (i == 1)
2396
 
//                      {
2397
 
//                              t = "P";
2398
 
//                              d1 = floaty(diff_width.v/(stepsize*2));
2399
 
//                              d2 = floaty((diff_width.v+pplus_overhang_diff.v*2)/(stepsize*2));
2400
 
//                              d3 = floaty((diff_width.v+nwell_overhang_diff.v*2)/(stepsize*2));
2401
 
//                      } else
2402
 
//                      {
2403
 
//                              t = "N";
2404
 
//                              d1 = floaty(diff_width.v/(stepsize*2));
2405
 
//                              d2 = floaty((diff_width.v+nplus_overhang_diff.v*2)/(stepsize*2));
2406
 
//                              d3 = d2;
2407
 
//                      }
2408
 
//
2409
 
//                      String x = floaty(TextUtils.atof(d3) - TextUtils.atof(d1));
2410
 
//                      pw.println();
2411
 
//                      pw.println("    <primitiveNode name=\"" + t + "-Diff-Pin\" fun=\"PIN\">");
2412
 
//                      pw.println("        <shrinkArcs/>");
2413
 
////                    pw.println("        <diskOffset untilVersion=\"1\" x=\"" + d3 + "\" y=\"" + d3 + "\"/>");
2414
 
////                    pw.println("        <diskOffset untilVersion=\"2\" x=\"" + d1 + "\" y=\"" + d1 + "\"/>");
2415
 
//                      pw.println("        <sizeOffset lx=\"" + x + "\" hx=\"" + x + "\" ly=\"" + x + "\" hy=\"" + x + "\"/>");
2416
 
//                      if (t.equals("P"))
2417
 
//                      {
2418
 
//                              pw.println("        <nodeLayer layer=\"N-Well\" style=\"CROSSED\">");
2419
 
//                              pw.println("            <box>");
2420
 
//                              pw.println("                <lambdaBox klx=\"-" + d3 + "\" khx=\"" + d3 + "\" kly=\"-" + d3 + "\" khy=\"" + d3 + "\"/>");
2421
 
//                              pw.println("            </box>");
2422
 
//                              pw.println("        </nodeLayer>");
2423
 
//                      }
2424
 
//                      pw.println("        <nodeLayer layer=\"" + t + "Plus\" style=\"CROSSED\">");
2425
 
//                      pw.println("            <box>");
2426
 
//                      pw.println("                <lambdaBox klx=\"-" + d2 + "\" khx=\"" + d2 + "\" kly=\"-" + d2 + "\" khy=\"" + d2 + "\"/>");
2427
 
//                      pw.println("            </box>");
2428
 
//                      pw.println("        </nodeLayer>");
2429
 
//                      pw.println("        <nodeLayer layer=\"" + t + "-Diff\" style=\"CROSSED\">");
2430
 
//                      pw.println("            <box>");
2431
 
//                      pw.println("                <lambdaBox klx=\"-" + d1 + "\" khx=\"" + d1 + "\" kly=\"-" + d1 + "\" khy=\"" + d1 + "\"/>");
2432
 
//                      pw.println("            </box>");
2433
 
//                      pw.println("        </nodeLayer>");
2434
 
//                      pw.println("        <primitivePort name=\"" + t + "-Diff\">");
2435
 
//                      pw.println("            <portAngle primary=\"0\" range=\"180\"/>");
2436
 
//                      pw.println("            <portTopology>0</portTopology>");
2437
 
//                      pw.println("            <box>");
2438
 
//                      pw.println("                <lambdaBox klx=\"0.0\" khx=\"0.0\" kly=\"0.0\" khy=\"0.0\"/>");
2439
 
//                      pw.println("            </box>");
2440
 
//                      pw.println("            <portArc>" + t + "-Diff</portArc>");
2441
 
//                      pw.println("        </primitivePort>");
2442
 
//                      pw.println("    </primitiveNode>");
2443
 
//              }
2444
 
//
2445
 
//              // write the contacts
2446
 
//              pw.println();
2447
 
//              pw.println("<!--  METAL TO METAL VIAS / CONTACTS  -->");
2448
 
//              for(int alt=0; alt<=1; alt++)
2449
 
//              {
2450
 
//                      for(int vl=0; vl<num_metal_layers; vl++)
2451
 
//                      {
2452
 
//                              String src, il;
2453
 
//                              if (vl == 0) { src = "Poly"; il = "PolyCon"; } else { src = "Metal-" + vl; il = "Via-" + vl; }
2454
 
//                              String dest = "Metal-" + (vl+1);
2455
 
//                              String upperx, uppery, lowerx, lowery, cs, cs2, c;
2456
 
//                              if (vl == 0)
2457
 
//                              {
2458
 
//                                      // poly
2459
 
//                                      if (alt != 0)
2460
 
//                                      {
2461
 
//                                              upperx = floaty((contact_metal_overhang_inline_only.v*2+contact_size.v)/(stepsize*2));
2462
 
//                                              uppery = floaty(contact_size.v/(stepsize*2));
2463
 
//                                      } else
2464
 
//                                      {
2465
 
//                                              upperx = floaty((contact_metal_overhang_all_sides.v*2+contact_size.v)/(stepsize*2));
2466
 
//                                              uppery = upperx;
2467
 
//                                      }
2468
 
//                                      lowerx = floaty((contact_poly_overhang.v*2+contact_size.v)/(stepsize*2));
2469
 
//                                      lowery = lowerx;
2470
 
//
2471
 
//                                      cs = floaty(contact_spacing.v/stepsize);
2472
 
//                                      cs2 = cs;
2473
 
//                                      c = floaty(contact_size.v/stepsize);
2474
 
//                              } else
2475
 
//                              {
2476
 
//                                      if (alt != 0)
2477
 
//                                      {
2478
 
//                                              upperx = floaty(via_size[vl-1].v/(stepsize*2));
2479
 
//                                              uppery = floaty((via_overhang_inline[vl-1].v*2+via_size[vl-1].v)/(stepsize*2));
2480
 
//                                              lowerx = uppery;
2481
 
//                                              lowery = upperx;
2482
 
//                                      } else
2483
 
//                                      {
2484
 
//                                              upperx = floaty((via_overhang_inline[vl-1].v*2+via_size[vl-1].v)/(stepsize*2));
2485
 
//                                              uppery = floaty(via_size[vl-1].v/(stepsize*2));
2486
 
//                                              lowerx = upperx;
2487
 
//                                              lowery = uppery;
2488
 
//                                      }
2489
 
//
2490
 
//                                      c = floaty(via_size[vl-1].v/stepsize);
2491
 
//                                      cs = floaty(via_spacing[vl-1].v/stepsize);
2492
 
//                                      cs2 = floaty(via_array_spacing[vl-1].v/stepsize);
2493
 
//                              }
2494
 
//
2495
 
//                              double maxx = TextUtils.atof(upperx);
2496
 
//                              if (TextUtils.atof(lowerx) > maxx) maxx = TextUtils.atof(lowerx);
2497
 
//                              double maxy = TextUtils.atof(uppery);
2498
 
//                              if (TextUtils.atof(lowery) > maxy) maxy = TextUtils.atof(lowery);
2499
 
//                              double minx = TextUtils.atof(upperx);
2500
 
//                              if (TextUtils.atof(lowerx) < minx) minx = TextUtils.atof(lowerx);
2501
 
//                              double miny = TextUtils.atof(uppery);
2502
 
//                              if (TextUtils.atof(lowery) < miny) miny = TextUtils.atof(lowery);
2503
 
//                              String ox = floaty(maxx-minx);
2504
 
//                              String oy = floaty(maxy-miny);
2505
 
//
2506
 
//                              pw.println();
2507
 
//                              pw.println("    <primitiveNode name=\"" + src + "-" + dest + "-Con" + (alt != 0 ? "-X" : "") + "\" fun=\"CONTACT\">");
2508
 
////                            pw.println("        <diskOffset untilVersion=\"2\" x=\"" + maxx + "\" y=\"" + maxy + "\"/>");
2509
 
////                            pw.println("        <sizeOffset lx=\"" + ox + "\" hx=\"" + ox + "\" ly=\"" + oy + "\" hy=\"" + oy + "\"/>");
2510
 
//                              pw.println("        <nodeLayer layer=\"" + src + "\" style=\"FILLED\">");
2511
 
//                              pw.println("            <box>");
2512
 
//                              pw.println("                <lambdaBox klx=\"-" + lowerx + "\" khx=\"" + lowerx + "\" kly=\"-" + lowery + "\" khy=\"" + lowery + "\"/>");
2513
 
//                              pw.println("            </box>");
2514
 
//                              pw.println("        </nodeLayer>");
2515
 
//                              pw.println("        <nodeLayer layer=\"" + dest + "\" style=\"FILLED\">");
2516
 
//                              pw.println("            <box>");
2517
 
//                              pw.println("                <lambdaBox klx=\"-" + upperx + "\" khx=\"" + upperx + "\" kly=\"-" + uppery + "\" khy=\"" + uppery + "\"/>");
2518
 
//                              pw.println("            </box>");
2519
 
//                              pw.println("        </nodeLayer>");
2520
 
//                              pw.println("        <nodeLayer layer=\"" + il + "\" style=\"FILLED\">");
2521
 
//                              pw.println("            <multicutbox sizex=\"" + c + "\" sizey=\"" + c + "\" sep1d=\"" + cs + "\" sep2d=\"" + cs2 + "\">");
2522
 
//                              pw.println("                <lambdaBox klx=\"0.0\" khx=\"0.0\" kly=\"0.0\" khy=\"0.0\"/>");
2523
 
//                              pw.println("            </multicutbox>");
2524
 
//                              pw.println("        </nodeLayer>");
2525
 
//                              pw.println("        <primitivePort name=\"" + src + "-" + dest + "\">");
2526
 
//                              pw.println("            <portAngle primary=\"0\" range=\"180\"/>");
2527
 
//                              pw.println("            <portTopology>0</portTopology>");
2528
 
//                              pw.println("            <box>");
2529
 
//                              pw.println("                <lambdaBox klx=\"-" + minx + "\" khx=\"" + minx + "\" kly=\"-" + miny + "\" khy=\"" + miny + "\"/>");
2530
 
//                              pw.println("            </box>");
2531
 
//                              pw.println("            <portArc>" + src + "</portArc>");
2532
 
//                              pw.println("            <portArc>" + dest + "</portArc>");
2533
 
//                              pw.println("        </primitivePort>");
2534
 
//                              pw.println("        <minSizeRule width=\"" + floaty(2*maxx) + "\" height=\"" + floaty(2*maxy) + "\" rule=\"" + src + "-" + dest + " rules\"/>");
2535
 
//                              pw.println("    </primitiveNode>");
2536
 
//                      }
2537
 
//              }
2538
 
//
2539
 
//              pw.println();
2540
 
//              pw.println("<!--  N-Diff-Metal-1 and P-Diff-Metal-1  -->");
2541
 
//              for(int alt=0; alt<=1; alt++)
2542
 
//              {
2543
 
//                      for(int i=0; i<2; i++)
2544
 
//                      {
2545
 
//                              String t = "", sx = "", mx = "", my = "";
2546
 
//                              if (i == 0)
2547
 
//                              {
2548
 
//                                      t = "N";
2549
 
//                                      sx = floaty((nplus_overhang_diff.v*2+diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2550
 
//                              } else
2551
 
//                              {
2552
 
//                                      t = "P";
2553
 
//                                      sx = floaty((pplus_overhang_diff.v*2+diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2554
 
//                              }
2555
 
//
2556
 
//                              if (alt != 0)
2557
 
//                              {
2558
 
//                                      mx = floaty((contact_metal_overhang_inline_only.v*2+contact_size.v)/(stepsize*2));
2559
 
//                                      my = floaty(contact_size.v/(stepsize*2));
2560
 
//                              } else
2561
 
//                              {
2562
 
//                                      mx = floaty((contact_metal_overhang_all_sides.v*2+contact_size.v)/(stepsize*2));
2563
 
//                                      my = mx;
2564
 
//                              }
2565
 
//
2566
 
//                              String dx = floaty((diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2567
 
//                              String wx = floaty((nwell_overhang_diff.v*2+diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2568
 
//
2569
 
//                              String maxx = mx;
2570
 
//                              if (TextUtils.atof(dx) > TextUtils.atof(maxx)) maxx = dx;
2571
 
//                              if (i==1 && TextUtils.atof(wx) > TextUtils.atof(maxx)) maxx = wx;
2572
 
//                              String maxy = my;
2573
 
//                              if (TextUtils.atof(dx) > TextUtils.atof(maxy)) maxy = dx;
2574
 
//                              if (i==1 && TextUtils.atof(wx) > TextUtils.atof(maxy)) maxy = wx;
2575
 
//
2576
 
//                              String minx = mx;
2577
 
//                              if (TextUtils.atof(dx) < TextUtils.atof(minx)) minx = dx;
2578
 
//                              if (i==1 && TextUtils.atof(wx) < TextUtils.atof(minx)) minx = wx;
2579
 
//                              String miny = my;
2580
 
//                              if (TextUtils.atof(dx) < TextUtils.atof(miny)) miny = dx;
2581
 
//                              if (i==1 && TextUtils.atof(wx) < TextUtils.atof(miny)) miny = wx;
2582
 
//
2583
 
//                              String sox = floaty(TextUtils.atof(maxx)-TextUtils.atof(dx));
2584
 
//                              String soy = floaty(TextUtils.atof(maxy)-TextUtils.atof(dx));
2585
 
//
2586
 
//                              pw.println();
2587
 
//                              pw.println("    <primitiveNode name=\"" + t + "-Diff-Metal-1" + (alt != 0 ? "-X" : "") + "\" fun=\"CONTACT\">");
2588
 
////                            pw.println("        <diskOffset untilVersion=\"1\" x=\"" + maxx + "\" y=\"" + maxy + "\"/>");
2589
 
////                            pw.println("        <diskOffset untilVersion=\"2\" x=\"" + minx + "\" y=\"" + miny + "\"/>");
2590
 
//                              pw.println("        <sizeOffset lx=\"" + sox + "\" hx=\"" + sox + "\" ly=\"" + soy + "\" hy=\"" + soy + "\"/>");
2591
 
//                              pw.println("        <nodeLayer layer=\"Metal-1\" style=\"FILLED\">");
2592
 
//                              pw.println("            <box>");
2593
 
//                              pw.println("                <lambdaBox klx=\"-" + mx + "\" khx=\"" + mx + "\" kly=\"-" + my + "\" khy=\"" + my + "\"/>");
2594
 
//                              pw.println("            </box>");
2595
 
//                              pw.println("        </nodeLayer>");
2596
 
//                              pw.println("        <nodeLayer layer=\"" + t + "-Diff\" style=\"FILLED\">");
2597
 
//                              pw.println("            <box>");
2598
 
//                              pw.println("                <lambdaBox klx=\"-" + dx + "\" khx=\"" + dx + "\" kly=\"-" + dx + "\" khy=\"" + dx + "\"/>");
2599
 
//                              pw.println("            </box>");
2600
 
//                              pw.println("        </nodeLayer>");
2601
 
//                              if (i != 0)
2602
 
//                              {
2603
 
//                                      pw.println("        <nodeLayer layer=\"N-Well\" style=\"FILLED\">");
2604
 
//                                      pw.println("            <box>");
2605
 
//                                      pw.println("                <lambdaBox klx=\"-" + wx + "\" khx=\"" + wx + "\" kly=\"-" + wx + "\" khy=\"" + wx + "\"/>");
2606
 
//                                      pw.println("            </box>");
2607
 
//                                      pw.println("        </nodeLayer>");
2608
 
//                              }
2609
 
//                              pw.println("        <nodeLayer layer=\"" + t + "Plus\" style=\"FILLED\">");
2610
 
//                              pw.println("            <box>");
2611
 
//                              pw.println("                <lambdaBox klx=\"-" + sx + "\" khx=\"" + sx + "\" kly=\"-" + sx + "\" khy=\"" + sx + "\"/>");
2612
 
//                              pw.println("            </box>");
2613
 
//                              pw.println("        </nodeLayer>");
2614
 
//                              pw.println("        <nodeLayer layer=\"DiffCon\" style=\"FILLED\">");
2615
 
//                              pw.println("            <multicutbox sizex=\"" + floaty(contact_size.v/stepsize) + "\" sizey=\"" +
2616
 
//                                      floaty(contact_size.v/stepsize) + "\" sep1d=\"" + (floaty(contact_spacing.v/stepsize)) +
2617
 
//                                      "\" sep2d=\"" + floaty(contact_spacing.v/stepsize) + "\">");
2618
 
//                              pw.println("                <lambdaBox klx=\"0.0\" khx=\"0.0\" kly=\"0.0\" khy=\"0.0\"/>");
2619
 
//                              pw.println("            </multicutbox>");
2620
 
//                              pw.println("        </nodeLayer>");
2621
 
//                              pw.println("        <primitivePort name=\"" + t + "-Diff-Metal-1" + "\">");
2622
 
//                              pw.println("            <portAngle primary=\"0\" range=\"180\"/>");
2623
 
//                              pw.println("            <portTopology>0</portTopology>");
2624
 
//                              pw.println("            <box>");
2625
 
//                              pw.println("                <lambdaBox klx=\"-" + dx + "\" khx=\"" + dx + "\" kly=\"-" + dx + "\" khy=\"" + dx + "\"/>");
2626
 
//                              pw.println("            </box>");
2627
 
//                              pw.println("            <portArc>" + t + "-Diff</portArc>");
2628
 
//                              pw.println("            <portArc>Metal-1</portArc>");
2629
 
//                              pw.println("        </primitivePort>");
2630
 
//                              pw.println("        <minSizeRule width=\"" + floaty(2*TextUtils.atof(maxx)) + "\" height=\"" +
2631
 
//                                      floaty(2*TextUtils.atof(maxy)) + "\" rule=\"" + t + "-Diff, " + t + "+, M1" +
2632
 
//                                      (i==1 ? ", N-Well" : "") + " and Contact rules\"/>");
2633
 
//                              pw.println("    </primitiveNode>");
2634
 
//                      }
2635
 
//              }
2636
 
//
2637
 
//              pw.println();
2638
 
//              pw.println("<!--  VDD-Tie-Metal-1 and VSS-Tie-Metal-1  -->");
2639
 
//              for(int alt=0; alt<=1; alt++)
2640
 
//              {
2641
 
//                      for(int i=0; i<2; i++)
2642
 
//                      {
2643
 
//                              String t, fun, dt, sx, mx, my;
2644
 
//                              if (i == 0)
2645
 
//                              {
2646
 
//                                      t = "VDD";
2647
 
//                                      fun = "WELL";
2648
 
//                                      dt = "N";
2649
 
//                                      sx = floaty((nplus_overhang_diff.v*2+diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2650
 
//                              } else
2651
 
//                              {
2652
 
//                                      t = "VSS";
2653
 
//                                      fun = "SUBSTRATE";
2654
 
//                                      dt = "P";
2655
 
//                                      sx = floaty((pplus_overhang_diff.v*2+diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2656
 
//                              }
2657
 
//
2658
 
//                              if (alt != 0)
2659
 
//                              {
2660
 
//                                      mx = floaty((contact_metal_overhang_inline_only.v*2+contact_size.v)/(stepsize*2));
2661
 
//                                      my = floaty(contact_size.v/(stepsize*2));
2662
 
//                              } else
2663
 
//                              {
2664
 
//                                      mx = floaty((contact_metal_overhang_all_sides.v*2+contact_size.v)/(stepsize*2));
2665
 
//                                      my = mx;
2666
 
//                              }
2667
 
//
2668
 
//                              String dx = floaty((diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2669
 
//                              String wx = floaty((nwell_overhang_diff.v*2+diff_contact_overhang.v*2+contact_size.v)/(stepsize*2));
2670
 
//
2671
 
//                              String maxx = mx;
2672
 
//                              if (TextUtils.atof(dx) > TextUtils.atof(maxx)) maxx = dx;
2673
 
//                              if (i==0 && TextUtils.atof(wx)>TextUtils.atof(maxx)) maxx = wx;
2674
 
//                              String maxy = my;
2675
 
//                              if (TextUtils.atof(dx) > TextUtils.atof(maxy)) maxy = dx;
2676
 
//                              if (i==0 && TextUtils.atof(wx)>TextUtils.atof(maxy)) maxy = wx;
2677
 
//
2678
 
//                              String minx = mx;
2679
 
//                              if (TextUtils.atof(dx) < TextUtils.atof(minx)) minx = dx;
2680
 
//                              if (i==0 && TextUtils.atof(wx)<TextUtils.atof(minx)) minx = wx;
2681
 
//                              String miny = my;
2682
 
//                              if (TextUtils.atof(dx) < TextUtils.atof(miny)) miny = dx;
2683
 
//                              if (i==0 && TextUtils.atof(wx)<TextUtils.atof(miny)) miny = wx;
2684
 
//
2685
 
//                              String sox = floaty(TextUtils.atof(maxx)-TextUtils.atof(dx));
2686
 
//                              String soy = floaty(TextUtils.atof(maxy)-TextUtils.atof(dx));
2687
 
//
2688
 
//                              pw.println();
2689
 
//                              pw.println("    <primitiveNode name=\"" + t + "-Tie-Metal-1" + (alt != 0 ? "-X" : "") + "\" fun=\"" + fun + "\">");
2690
 
////                            pw.println("        <diskOffset untilVersion=\"1\" x=\"" + maxx + "\" y=\"" + maxy + "\"/>");
2691
 
////                            pw.println("        <diskOffset untilVersion=\"2\" x=\"" + minx + "\" y=\"" + miny + "\"/>");
2692
 
//                              pw.println("        <sizeOffset lx=\"" + sox + "\" hx=\"" + sox + "\" ly=\"" + soy + "\" hy=\"" + soy + "\"/>");
2693
 
//                              pw.println("        <nodeLayer layer=\"Metal-1\" style=\"FILLED\">");
2694
 
//                              pw.println("            <box>");
2695
 
//                              pw.println("                <lambdaBox klx=\"-" + mx + "\" khx=\"" + mx + "\" kly=\"-" + my + "\" khy=\"" + my + "\"/>");
2696
 
//                              pw.println("            </box>");
2697
 
//                              pw.println("        </nodeLayer>");
2698
 
//                              pw.println("        <nodeLayer layer=\"" + dt + "-Diff\" style=\"FILLED\">");
2699
 
//                              pw.println("            <box>");
2700
 
//                              pw.println("                <lambdaBox klx=\"-" + dx + "\" khx=\"" + dx + "\" kly=\"-" + dx + "\" khy=\"" + dx + "\"/>");
2701
 
//                              pw.println("            </box>");
2702
 
//                              pw.println("        </nodeLayer>");
2703
 
//                              if (i != 1)
2704
 
//                              {
2705
 
//                                      pw.println("        <nodeLayer layer=\"N-Well\" style=\"FILLED\">");
2706
 
//                                      pw.println("            <box>");
2707
 
//                                      pw.println("                <lambdaBox klx=\"-" + wx + "\" khx=\"" + wx + "\" kly=\"-" + wx + "\" khy=\"" + wx + "\"/>");
2708
 
//                                      pw.println("            </box>");
2709
 
//                                      pw.println("        </nodeLayer>");
2710
 
//                              }
2711
 
//                              pw.println("        <nodeLayer layer=\"" + dt + "Plus\" style=\"FILLED\">");
2712
 
//                              pw.println("            <box>");
2713
 
//                              pw.println("                <lambdaBox klx=\"-" + sx + "\" khx=\"" + sx + "\" kly=\"-" + sx + "\" khy=\"" + sx + "\"/>");
2714
 
//                              pw.println("            </box>");
2715
 
//                              pw.println("        </nodeLayer>");
2716
 
//                              pw.println("        <nodeLayer layer=\"DiffCon\" style=\"FILLED\">");
2717
 
//                              pw.println("            <multicutbox sizex=\"" + floaty(contact_size.v/stepsize) + "\" sizey=\"" +
2718
 
//                                      floaty(contact_size.v/stepsize) + "\" sep1d=\"" + floaty(contact_spacing.v/stepsize) +
2719
 
//                                      "\" sep2d=\"" + floaty(contact_spacing.v/stepsize) + "\">");
2720
 
//                              pw.println("                <lambdaBox klx=\"0.0\" khx=\"0.0\" kly=\"0.0\" khy=\"0.0\"/>");
2721
 
//                              pw.println("            </multicutbox>");
2722
 
//                              pw.println("        </nodeLayer>");
2723
 
//                              pw.println("        <primitivePort name=\"" + t + "-Tie-M1" + "\">");
2724
 
//                              pw.println("            <portAngle primary=\"0\" range=\"180\"/>");
2725
 
//                              pw.println("            <portTopology>0</portTopology>");
2726
 
//                              pw.println("            <box>");
2727
 
//                              pw.println("                <lambdaBox klx=\"-" + dx + "\" khx=\"" + dx + "\" kly=\"-" + dx + "\" khy=\"" + dx + "\"/>");
2728
 
//                              pw.println("            </box>");
2729
 
//                              pw.println("            <portArc>Metal-1</portArc>");
2730
 
//                              pw.println("        </primitivePort>");
2731
 
//                              pw.println("        <minSizeRule width=\"" + floaty(2*TextUtils.atof(maxx)) + "\" height=\"" +
2732
 
//                                      floaty(2*TextUtils.atof(maxy)) + "\" rule=\"" + dt + "-Diff, " + dt + "+, M1" +
2733
 
//                                      (i==0 ? ", N-Well" : "") + " and Contact rules\"/>");
2734
 
//                              pw.println("    </primitiveNode>");
2735
 
//                      }
2736
 
//              }
2737
 
//
2738
 
//              // write the transistors
2739
 
//              for(int i=0; i<2; i++)
2740
 
//              {
2741
 
//                      String wellx = "", welly = "", t, impx, impy;
2742
 
//                      if (i==0)
2743
 
//                      {
2744
 
//                              t = "P";
2745
 
//                              wellx = floaty((gate_width.v+nwell_overhang_diff.v*2)/(stepsize*2));
2746
 
//                              welly = floaty((gate_length.v+diff_poly_overhang.v*2+nwell_overhang_diff.v*2)/(stepsize*2));
2747
 
//                              impx = floaty((gate_width.v+pplus_overhang_diff.v*2)/(stepsize*2));
2748
 
//                              impy = floaty((gate_length.v+diff_poly_overhang.v*2+pplus_overhang_diff.v*2)/(stepsize*2));
2749
 
//                      } else
2750
 
//                      {
2751
 
//                              t = "N";
2752
 
//                              impx = floaty((gate_width.v+nplus_overhang_diff.v*2)/(stepsize*2));
2753
 
//                              impy = floaty((gate_length.v+diff_poly_overhang.v*2+nplus_overhang_diff.v*2)/(stepsize*2));
2754
 
//                      }
2755
 
//                      String diffx = floaty(gate_width.v/(stepsize*2));
2756
 
//                      String diffy = floaty((gate_length.v+diff_poly_overhang.v*2)/(stepsize*2));
2757
 
//                      String porty = floaty((gate_length.v+diff_poly_overhang.v*2-diff_width.v)/(stepsize*2));
2758
 
//                      String polyx = floaty((gate_width.v+poly_endcap.v*2)/(stepsize*2));
2759
 
//                      String polyy = floaty(gate_length.v/(stepsize*2));
2760
 
//                      String polyx2 = floaty((poly_endcap.v*2)/(stepsize*2));
2761
 
//                      String sx = floaty(TextUtils.atof(polyx)-TextUtils.atof(diffx));
2762
 
//                      String sy = floaty(TextUtils.atof(diffy)-TextUtils.atof(polyy));
2763
 
//                      pw.println();
2764
 
//                      pw.println("<!-- " + t + "-Transistor -->");
2765
 
//                      pw.println();
2766
 
//                      pw.println("    <primitiveNode name=\"" + t + "-Transistor\" fun=\"TRA" + t + "MOS\">");
2767
 
////                    pw.println("        <diskOffset untilVersion=\"2\" x=\"" + polyx + "\" y=\"" + diffy + "\"/>");
2768
 
////                    pw.println("        <sizeOffset lx=\"" + sx + "\" hx=\"" + sx + "\" ly=\"" + sy + "\" hy=\"" + sy + "\"/>");
2769
 
//
2770
 
//                      pw.println("        <nodeLayer layer=\"Poly\" style=\"FILLED\">");
2771
 
//                      pw.println("        <box>");
2772
 
//                      pw.println("            <lambdaBox klx=\"-" + polyx + "\" khx=\"" + polyx + "\" kly=\"-" + polyy + "\" khy=\"" + polyy + "\"/>");
2773
 
//                      pw.println("        </box>");
2774
 
//                      pw.println("        </nodeLayer>");
2775
 
//
2776
 
//                      pw.println("        <nodeLayer layer=\"PolyGate\" style=\"FILLED\">");
2777
 
//                      pw.println("        <box>");
2778
 
//                      pw.println("            <lambdaBox klx=\"-" + diffx + "\" khx=\"" + diffx + "\" kly=\"-" + polyy + "\" khy=\"" + polyy + "\"/>");
2779
 
//                      pw.println("        </box>");
2780
 
//                      pw.println("        </nodeLayer>");
2781
 
//
2782
 
//                      pw.println("        <nodeLayer layer=\"" + t + "-Diff\" style=\"FILLED\">");
2783
 
//                      pw.println("        <box>");
2784
 
//                      pw.println("            <lambdaBox klx=\"-" + diffx + "\" khx=\"" + diffx + "\" kly=\"-" + diffy + "\" khy=\"" + diffy + "\"/>");
2785
 
//                      pw.println("        </box>");
2786
 
//                      pw.println("        </nodeLayer>");
2787
 
//
2788
 
//                      pw.println("        <nodeLayer layer=\"" + t + "Plus\" style=\"FILLED\">");
2789
 
//                      pw.println("        <box>");
2790
 
//                      pw.println("            <lambdaBox klx=\"-" + impx + "\" khx=\"" + impx + "\" kly=\"-" + impy + "\" khy=\"" + impy + "\"/>");
2791
 
//                      pw.println("        </box>");
2792
 
//                      pw.println("        </nodeLayer>");
2793
 
//
2794
 
//                      pw.println("        <nodeLayer layer=\"DeviceMark\" style=\"FILLED\">");
2795
 
//                      pw.println("        <box>");
2796
 
//                      pw.println("            <lambdaBox klx=\"-" + impx + "\" khx=\"" + impx + "\" kly=\"-" + impy + "\" khy=\"" + impy + "\"/>");
2797
 
//                      pw.println("        </box>");
2798
 
//                      pw.println("        </nodeLayer>");
2799
 
//
2800
 
//                      if (i==0)
2801
 
//                      {
2802
 
//                              pw.println("        <nodeLayer layer=\"N-Well\" style=\"FILLED\">");
2803
 
//                              pw.println("        <box>");
2804
 
//                              pw.println("            <lambdaBox klx=\"-" + wellx + "\" khx=\"" + wellx + "\" kly=\"-" + welly + "\" khy=\"" + welly + "\"/>");
2805
 
//                              pw.println("        </box>");
2806
 
//                              pw.println("        </nodeLayer>");
2807
 
//                      }
2808
 
//
2809
 
//                      pw.println("        <primitivePort name=\"Gate-Left\">");
2810
 
//                      pw.println("            <portAngle primary=\"180\" range=\"90\"/>");
2811
 
//                      pw.println("            <portTopology>0</portTopology>");
2812
 
//                      pw.println("            <box>");
2813
 
//                      pw.println("                <lambdaBox klx=\"-" + polyx + "\" khx=\"-" + polyx2 + "\" kly=\"-" + polyy + "\" khy=\"" + polyy + "\"/>");
2814
 
//                      pw.println("            </box>");
2815
 
//                      pw.println("            <portArc>Poly</portArc>");
2816
 
//                      pw.println("        </primitivePort>");
2817
 
//
2818
 
//                      pw.println("        <primitivePort name=\"Diff-Top\">");
2819
 
//                      pw.println("            <portAngle primary=\"90\" range=\"90\"/>");
2820
 
//                      pw.println("            <portTopology>1</portTopology>");
2821
 
//                      pw.println("            <box>");
2822
 
//                      pw.println("                <lambdaBox klx=\"-" + diffx + "\" khx=\"" + diffx + "\" kly=\"" + porty + "\" khy=\"" + porty + "\"/>");
2823
 
//                      pw.println("            </box>");
2824
 
//                      pw.println("            <portArc>" + t + "-Diff</portArc>");
2825
 
//                      pw.println("        </primitivePort>");
2826
 
//
2827
 
//                      pw.println("        <primitivePort name=\"Gate-Right\">");
2828
 
//                      pw.println("            <portAngle primary=\"0\" range=\"90\"/>");
2829
 
//                      pw.println("            <portTopology>0</portTopology>");
2830
 
//                      pw.println("            <box>");
2831
 
//                      pw.println("                <lambdaBox klx=\"" + polyx2 + "\" khx=\"" + polyx + "\" kly=\"-" + polyy + "\" khy=\"" + polyy + "\"/>");
2832
 
//                      pw.println("            </box>");
2833
 
//                      pw.println("            <portArc>Poly</portArc>");
2834
 
//                      pw.println("        </primitivePort>");
2835
 
//
2836
 
//                      pw.println("        <primitivePort name=\"Diff-Bottom\">");
2837
 
//                      pw.println("            <portAngle primary=\"270\" range=\"90\"/>");
2838
 
//                      pw.println("            <portTopology>2</portTopology>");
2839
 
//                      pw.println("            <box>");
2840
 
//                      pw.println("                <lambdaBox klx=\"-" + diffx + "\" khx=\"" + diffx + "\" kly=\"-" + porty + "\" khy=\"-" + porty + "\"/>");
2841
 
//                      pw.println("            </box>");
2842
 
//                      pw.println("            <portArc>" + t + "-Diff</portArc>");
2843
 
//                      pw.println("        </primitivePort>");
2844
 
//                      pw.println("    </primitiveNode>");
2845
 
//              }
2846
 
//
2847
 
//              // write trailing boilerplate
2848
 
//              pw.println();
2849
 
//              pw.println("<!--  SKELETON HEADERS  -->");
2850
 
//              pw.println();
2851
 
//              pw.println("    <spiceHeader level=\"1\">");
2852
 
//              pw.println("        <spiceLine line=\"* Spice header (level 1)\"/>");
2853
 
//              pw.println("    </spiceHeader>");
2854
 
//              pw.println();
2855
 
//              pw.println("    <spiceHeader level=\"2\">");
2856
 
//              pw.println("        <spiceLine line=\"* Spice header (level 2)\"/>");
2857
 
//              pw.println("    </spiceHeader>");
2858
 
//
2859
 
//              // write the component menu layout
2860
 
//              int ts = 5;
2861
 
//              pw.println();
2862
 
//              pw.println("<!--  PALETTE  -->");
2863
 
//              pw.println();
2864
 
//              pw.println("    <menuPalette numColumns=\"3\">");
2865
 
//              for(int i=1; i<=num_metal_layers; i++)
2866
 
//              {
2867
 
//                      int h = i-1;
2868
 
//                      pw.println();
2869
 
//                      pw.println("        <menuBox>");
2870
 
//                      pw.println("            <menuArc>Metal-" + i + "</menuArc>");
2871
 
//                      pw.println("        </menuBox>");
2872
 
//                      pw.println("        <menuBox>");
2873
 
//                      pw.println("            <menuNode>Metal-" + i + "-Pin</menuNode>");
2874
 
//                      pw.println("        </menuBox>");
2875
 
//                      if (i != 1)
2876
 
//                      {
2877
 
//                              pw.println("        <menuBox>");
2878
 
//                String name = "Metal-" + h + "-Metal-" + i + "-Con";
2879
 
//                pw.println("            <menuNodeInst protoName=\"" + name + "\" function=\"CONTACT\">");
2880
 
//                              pw.println("                <menuNodeText text=\"" + name + "\" size=\"" + ts + "\"/>");
2881
 
//                              pw.println("            </menuNodeInst>");
2882
 
//                              pw.println("            <menuNodeInst protoName=\"" + name + "-X\" function=\"CONTACT\"/>");
2883
 
//                              pw.println("        </menuBox>");
2884
 
//                      } else
2885
 
//                      {
2886
 
//                              pw.println("        <menuBox>");
2887
 
//                              pw.println("        </menuBox>");
2888
 
//                      }
2889
 
//              }
2890
 
//              pw.println();
2891
 
//              pw.println("        <menuBox>");
2892
 
//              pw.println("            <menuArc>Poly</menuArc>");
2893
 
//              pw.println("        </menuBox>");
2894
 
//              pw.println("        <menuBox>");
2895
 
//              pw.println("            <menuNode>Poly-Pin</menuNode>");
2896
 
//              pw.println("        </menuBox>");
2897
 
//              pw.println("        <menuBox>");
2898
 
//              pw.println("            <menuNodeInst protoName=\"Poly-Metal-1-Con\" function=\"CONTACT\"/>");
2899
 
////            pw.println("            </menuNodeInst>");
2900
 
//              pw.println("            <menuNodeInst protoName=\"Poly-Metal-1-Con-X\" function=\"CONTACT\"/>");
2901
 
//              pw.println("        </menuBox>");
2902
 
//              pw.println();
2903
 
//              pw.println("        <menuBox>");
2904
 
//              pw.println("            <menuArc>P-Diff</menuArc>");
2905
 
//              pw.println("        </menuBox>");
2906
 
//              pw.println("        <menuBox>");
2907
 
//              pw.println("            <menuNode>P-Diff-Pin</menuNode>");
2908
 
//              pw.println("        </menuBox>");
2909
 
//              pw.println("        <menuBox>");
2910
 
//              pw.println("            <menuNodeInst protoName=\"P-Transistor\" function=\"TRAPMOS\">");
2911
 
//              pw.println("                <menuNodeText text=\"P\" size=\"" + ts + "\"/>");
2912
 
//              pw.println("            </menuNodeInst>");
2913
 
//              pw.println("        </menuBox>");
2914
 
//              pw.println();
2915
 
//              pw.println("        <menuBox>");
2916
 
//              pw.println("            <menuArc>N-Diff</menuArc>");
2917
 
//              pw.println("        </menuBox>");
2918
 
//              pw.println("        <menuBox>");
2919
 
//              pw.println("            <menuNode>N-Diff-Pin</menuNode>");
2920
 
//              pw.println("        </menuBox>");
2921
 
//              pw.println("        <menuBox>");
2922
 
//              pw.println("            <menuNodeInst protoName=\"N-Transistor\" function=\"TRANMOS\">");
2923
 
//              pw.println("                <menuNodeText text=\"N\" size=\"" + ts + "\"/>");
2924
 
//              pw.println("            </menuNodeInst>");
2925
 
//              pw.println("        </menuBox>");
2926
 
//              pw.println();
2927
 
//              pw.println("        <menuBox>");
2928
 
//              pw.println("            <menuNodeInst protoName=\"VSS-Tie-Metal-1\" function=\"SUBSTRATE\">");
2929
 
//              pw.println("                <menuNodeText text=\"VSS-Tie\" size=\"" + ts + "\"/>");
2930
 
//              pw.println("            </menuNodeInst>");
2931
 
//              pw.println("            <menuNodeInst protoName=\"VSS-Tie-Metal-1-X\" function=\"SUBSTRATE\"/>");
2932
 
//              pw.println("        </menuBox>");
2933
 
//              pw.println();
2934
 
//              pw.println("        <menuBox>");
2935
 
//              pw.println("            <menuNodeInst protoName=\"N-Diff-Metal-1\" function=\"CONTACT\">");
2936
 
//              pw.println("                <menuNodeText text=\"N-Con\" size=\"" + ts + "\"/>");
2937
 
//              pw.println("            </menuNodeInst>");
2938
 
//              pw.println("            <menuNodeInst protoName=\"N-Diff-Metal-1-X\" function=\"CONTACT\"/>");
2939
 
//              pw.println("        </menuBox>");
2940
 
//              pw.println("        <menuBox>");
2941
 
//              pw.println("        </menuBox>");
2942
 
//              pw.println();
2943
 
//              pw.println("        <menuBox>");
2944
 
//              pw.println("            <menuNodeInst protoName=\"VDD-Tie-Metal-1\" function=\"WELL\">");
2945
 
//              pw.println("                <menuNodeText text=\"VDD-Tie\" size=\"" + ts + "\"/>");
2946
 
//              pw.println("            </menuNodeInst>");
2947
 
//              pw.println("            <menuNodeInst protoName=\"VDD-Tie-Metal-1-X\" function=\"WELL\"/>");
2948
 
//              pw.println("        </menuBox>");
2949
 
//              pw.println("        <menuBox>");
2950
 
//              pw.println("            <menuNodeInst protoName=\"P-Diff-Metal-1\" function=\"CONTACT\">");
2951
 
//              pw.println("                <menuNodeText text=\"P-Con\" size=\"" + ts + "\"/>");
2952
 
//              pw.println("            </menuNodeInst>");
2953
 
//              pw.println("            <menuNodeInst protoName=\"P-Diff-Metal-1-X\" function=\"CONTACT\"/>");
2954
 
//              pw.println("        </menuBox>");
2955
 
//              pw.println("        <menuBox>");
2956
 
//              pw.println("        </menuBox>");
2957
 
//              pw.println();
2958
 
//              pw.println("        <menuBox>");
2959
 
//              pw.println("            <menuText>Pure</menuText>");
2960
 
//              pw.println("        </menuBox>");
2961
 
//              pw.println("        <menuBox>");
2962
 
//              pw.println("            <menuText>Misc.</menuText>");
2963
 
//              pw.println("        </menuBox>");
2964
 
//              pw.println("        <menuBox>");
2965
 
//              pw.println("            <menuText>Cell</menuText>");
2966
 
//              pw.println("        </menuBox>");
2967
 
//              pw.println("    </menuPalette>");
2968
 
//              pw.println();
2969
 
//              pw.println("    <Foundry name=\"" + foundry_name + "\">");
2970
 
//
2971
 
//        // write GDS layers
2972
 
//              pw.println();
2973
 
//              for(int i=1; i<=num_metal_layers; i++)
2974
 
//              {
2975
 
//                      pw.println("        <layerGds layer=\"Metal-" + i + "\" gds=\"" + gds_metal_layer[i-1] + "\"/>");
2976
 
//                      if (i != num_metal_layers)
2977
 
//                      {
2978
 
//                              pw.println("        <layerGds layer=\"Via-" + i + "\" gds=\"" + gds_via_layer[i-1] + "\"/>");
2979
 
//                      }
2980
 
//              }
2981
 
//              pw.println("        <layerGds layer=\"Poly\" gds=\"" + gds_poly_layer + "\"/>");
2982
 
//              pw.println("        <layerGds layer=\"PolyGate\" gds=\"" + gds_poly_layer + "\"/>");
2983
 
//              pw.println("        <layerGds layer=\"DiffCon\" gds=\"" + gds_contact_layer + "\"/>");
2984
 
//              pw.println("        <layerGds layer=\"PolyCon\" gds=\"" + gds_contact_layer + "\"/>");
2985
 
//              pw.println("        <layerGds layer=\"N-Diff\" gds=\"" + gds_diff_layer + "\"/>");
2986
 
//              pw.println("        <layerGds layer=\"P-Diff\" gds=\"" + gds_diff_layer + "\"/>");
2987
 
//              pw.println("        <layerGds layer=\"NPlus\" gds=\"" + gds_nplus_layer + "\"/>");
2988
 
//              pw.println("        <layerGds layer=\"PPlus\" gds=\"" + gds_pplus_layer + "\"/>");
2989
 
//              pw.println("        <layerGds layer=\"N-Well\" gds=\"" + gds_nwell_layer + "\"/>");
2990
 
//              pw.println("        <layerGds layer=\"DeviceMark\" gds=\"" + gds_marking_layer + "\"/>");
2991
 
//
2992
 
//              // write GDS layers
2993
 
//              pw.println();
2994
 
//              for(int i=1; i<=num_metal_layers; i++)
2995
 
//              {
2996
 
//                      pw.println("        <layerGds layer=\"Metal-" + i + "\" gds=\"" + gds_metal_layer[i-1] + "\"/>");
2997
 
//                      if (i != num_metal_layers)
2998
 
//                      {
2999
 
//                              pw.println("        <layerGds layer=\"Via-" + i + "\" gds=\"" + gds_via_layer[i-1] + "\"/>");
3000
 
//                      }
3001
 
//              }
3002
 
//              pw.println("        <layerGds layer=\"Poly\" gds=\"" + gds_poly_layer + "\"/>");
3003
 
//              pw.println("        <layerGds layer=\"PolyGate\" gds=\"" + gds_poly_layer + "\"/>");
3004
 
//              pw.println("        <layerGds layer=\"DiffCon\" gds=\"" + gds_contact_layer + "\"/>");
3005
 
//              pw.println("        <layerGds layer=\"PolyCon\" gds=\"" + gds_contact_layer + "\"/>");
3006
 
//              pw.println("        <layerGds layer=\"N-Diff\" gds=\"" + gds_diff_layer + "\"/>");
3007
 
//              pw.println("        <layerGds layer=\"P-Diff\" gds=\"" + gds_diff_layer + "\"/>");
3008
 
//              pw.println("        <layerGds layer=\"NPlus\" gds=\"" + gds_nplus_layer + "\"/>");
3009
 
//              pw.println("        <layerGds layer=\"PPlus\" gds=\"" + gds_pplus_layer + "\"/>");
3010
 
//              pw.println("        <layerGds layer=\"N-Well\" gds=\"" + gds_nwell_layer + "\"/>");
3011
 
//              pw.println("        <layerGds layer=\"DeviceMark\" gds=\"" + gds_marking_layer + "\"/>");
3012
 
//              pw.println();
3013
 
//
3014
 
//              // Write basic design rules not implicit in primitives
3015
 
//
3016
 
//              // WIDTHS
3017
 
//              for(int i=0; i<num_metal_layers; i++)
3018
 
//              {
3019
 
//                      pw.println("        <LayerRule ruleName=\"" + metal_width[i].rule + "\" layerName=\"Metal-" + (i+1) + "\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(metal_width[i].v/stepsize) + "\"/>");
3020
 
//              }
3021
 
//
3022
 
//              pw.println("        <LayerRule ruleName=\"" + diff_width.rule + "\" layerName=\"N-Diff\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(diff_width.v/stepsize) + "\"/>");
3023
 
//              pw.println("        <LayerRule ruleName=\"" + diff_width.rule + "\" layerName=\"P-Diff\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(diff_width.v/stepsize) + "\"/>");
3024
 
//              pw.println("        <LayerRule ruleName=\"" + nwell_width.rule + "\" layerName=\"N-Well\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(nwell_width.v/stepsize) + "\"/>");
3025
 
//              pw.println("        <LayerRule ruleName=\"" + nplus_width.rule + "\" layerName=\"NPlus\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(nplus_width.v/stepsize) + "\"/>");
3026
 
//              pw.println("        <LayerRule ruleName=\"" + pplus_width.rule + "\" layerName=\"PPlus\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(pplus_width.v/stepsize) + "\"/>");
3027
 
//              pw.println("        <LayerRule ruleName=\"" + poly_width.rule + "\" layerName=\"Poly\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(poly_width.v/stepsize) + "\"/>");
3028
 
//              pw.println("        <LayerRule ruleName=\"" + poly_width.rule + "\" layerName=\"PolyGate\" type=\"MINWID\" when=\"ALL\" value=\"" + floaty(poly_width.v/stepsize) + "\"/>");
3029
 
//
3030
 
//              // SPACINGS
3031
 
//              pw.println("        <LayersRule ruleName=\"" + diff_spacing.rule + "\" layerNames=\"{N-Diff,N-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(diff_spacing.v/stepsize) + "\"/>");
3032
 
//              pw.println("        <LayersRule ruleName=\"" + diff_spacing.rule + "\" layerNames=\"{N-Diff,P-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(diff_spacing.v/stepsize) + "\"/>");
3033
 
//              pw.println("        <LayersRule ruleName=\"" + diff_spacing.rule + "\" layerNames=\"{P-Diff,P-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(diff_spacing.v/stepsize) + "\"/>");
3034
 
//              pw.println("        <LayersRule ruleName=\"" + poly_diff_spacing.rule + "\" layerNames=\"{Poly,N-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(poly_diff_spacing.v/stepsize) + "\"/>");
3035
 
//              pw.println("        <LayersRule ruleName=\"" + poly_diff_spacing.rule + "\" layerNames=\"{Poly,P-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(poly_diff_spacing.v/stepsize) + "\"/>");
3036
 
//              pw.println("        <LayersRule ruleName=\"" + poly_spacing.rule + "\" layerNames=\"{Poly,Poly}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(poly_spacing.v/stepsize) + "\"/>");
3037
 
//
3038
 
//              pw.println("        <LayersRule ruleName=\"" + gate_spacing.rule + "\" layerNames=\"{PolyGate,PolyGate}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(gate_spacing.v/stepsize) + "\"/>");
3039
 
//
3040
 
//              pw.println("        <LayersRule ruleName=\"" + nwell_spacing.rule + "\" layerNames=\"{N-Well,N-Well}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(nwell_spacing.v/stepsize) + "\"/>");
3041
 
//              pw.println("        <LayersRule ruleName=\"" + nplus_spacing.rule + "\" layerNames=\"{NPlus,NPlus}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(nplus_spacing.v/stepsize) + "\"/>");
3042
 
//              pw.println("        <LayersRule ruleName=\"" + pplus_spacing.rule + "\" layerNames=\"{PPlus,PPlus}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(pplus_spacing.v/stepsize) + "\"/>");
3043
 
//
3044
 
//              pw.println("        <LayersRule ruleName=\"" + contact_spacing.rule + "\" layerNames=\"{PolyCon,PolyCon}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(contact_spacing.v/stepsize) + "\"/>");
3045
 
//              pw.println("        <LayersRule ruleName=\"" + contact_spacing.rule + "\" layerNames=\"{DiffCon,DiffCon}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(contact_spacing.v/stepsize) + "\"/>");
3046
 
//
3047
 
//              pw.println("        <LayersRule ruleName=\"" + polycon_diff_spacing.rule + "\" layerNames=\"{PolyCon,N-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(polycon_diff_spacing.v/stepsize) + "\"/>");
3048
 
//              pw.println("        <LayersRule ruleName=\"" + polycon_diff_spacing.rule + "\" layerNames=\"{PolyCon,P-Diff}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(polycon_diff_spacing.v/stepsize) + "\"/>");
3049
 
//
3050
 
//              pw.println("        <LayersRule ruleName=\"" + gate_contact_spacing.rule + "\" layerNames=\"{DiffCon,Poly}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(gate_contact_spacing.v/stepsize) + "\"/>");
3051
 
//              pw.println("        <LayersRule ruleName=\"" + gate_contact_spacing.rule + "\" layerNames=\"{DiffCon,PolyGate}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(gate_contact_spacing.v/stepsize) + "\"/>");
3052
 
//
3053
 
//        System.out.println("2DCut rules are missing");
3054
 
//
3055
 
//        for(int i=1; i<=num_metal_layers; i++)
3056
 
//              {
3057
 
//                      pw.println("        <LayersRule ruleName=\"" + metal_spacing[i-1].rule + "\" layerNames=\"{Metal-" + i + ",Metal-" + i + "}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(metal_spacing[i-1].v/stepsize) + "\"/>");
3058
 
//                      if (i != num_metal_layers)
3059
 
//                      {
3060
 
//                              pw.println("        <LayersRule ruleName=\"" + via_spacing[i-1].rule + "\" layerNames=\"{Via-" + i + ",Via-" + i + "}\" type=\"UCONSPA\" when=\"ALL\" value=\"" + floaty(via_spacing[i-1].v/stepsize) + "\"/>");
3061
 
//                      }
3062
 
//              }
3063
 
//              pw.println("    </Foundry>");
3064
 
//              pw.println();
3065
 
//              pw.println("</technology>");
3066
 
//      }
3067
 
 
3068
 
//      private String floaty(double v)
3069
 
//      {
3070
 
//        if (v < 0)
3071
 
//            System.out.println("Negative distance of " + v + " in the tech editor wizard");
3072
 
//        double roundedV = DBMath.round(v);
3073
 
//        return roundedV + "";  // the "" is needed to call the String constructor
3074
 
//      }
3075
 
 
3076
1883
    private double scaledValue(double val) { return DBMath.round(val / stepsize); }
3077
1884
}