technology.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

	/**
	 * Constructs a <CODE>Technology</CODE>.
	 * This should not be called directly, but instead is invoked through each subclass's factory.
	 */
	protected Technology(IdManager idManager, Generic generic, String techName, Foundry.Type defaultFoundry, int defaultNumMetals)
	{
        if (this instanceof Generic) {
            assert generic == null;
            generic = (Generic)this;
        }
        this.generic = generic;
		this.techId = idManager.newTechId(techName);
		//this.scale = 1.0;
		this.scaleRelevant = true;
		this.techIndex = techNumber++;
		userBits = 0;
		prefs = Pref.groupForPackage(Generic.class, true);
        userPrefs = Pref.groupForPackage(User.class, true);
//        ercPrefs = Pref.groupForPackage(ERC.class, true);
        cacheFoundry = makeStringSetting("SelectedFoundryFor"+techName,
        	"Technology tab", techName + " foundry", "Foundry", defaultFoundry.getName().toUpperCase());
        cacheNumMetalLayers = makeIntSetting(techName + "NumberOfMetalLayers",
            "Technology tab", techName + ": Number of Metal Layers", "NumMetalLayers", defaultNumMetals);

        cacheMaxSeriesResistance = makeParasiticSetting("MaxSeriesResistance", 10.0);
        cacheGateLengthSubtraction = makeParasiticSetting("GateLengthSubtraction", 0.0);
		cacheIncludeGate = makeParasiticSetting("Gate Inclusion", false);
		cacheIncludeGnd = makeParasiticSetting("Ground Net Inclusion", false);
//		cacheGlobalFanout = makeLESetting("GlobalFanout", DEFAULT_GLOBALFANOUT);
//		cacheConvergenceEpsilon = makeLESetting("ConvergenceEpsilon", DEFAULT_EPSILON);
//		cacheMaxIterations = makeLESetting("MaxIterations", DEFAULT_MAXITER);
//		cacheGateCapacitance = makeLESetting("GateCapacitance", DEFAULT_GATECAP);
//		cacheWireRatio = makeLESetting("WireRatio", DEFAULT_WIRERATIO);
//		cacheDiffAlpha = makeLESetting("DiffAlpha", DEFAULT_DIFFALPHA);
//        cacheKeeperRatio = makeLESetting("KeeperRatio", DEFAULT_KEEPERRATIO);
	}

    protected Object writeReplace() { return new TechnologyKey(this); }

    private static class TechnologyKey extends EObjectInputStream.Key<Technology> {
        public TechnologyKey() {}
        private TechnologyKey(Technology tech) { super(tech); }

        @Override
        public void writeExternal(EObjectOutputStream out, Technology tech) throws IOException {
            TechId techId = tech.getId();
            if (techId.idManager != out.getIdManager())
                throw new NotSerializableException(tech + " from other IdManager");
            if (out.getDatabase().getTechPool().getTech(techId) != tech)
                throw new NotSerializableException(tech + " not linked");
            out.writeInt(techId.techIndex);
        }

        @Override
        public Technology readExternal(EObjectInputStream in) throws IOException, ClassNotFoundException {
            int techIndex = in.readInt();
            TechId techId = in.getIdManager().getTechId(techIndex);
            Technology tech = in.getDatabase().getTech(techId);
            if (tech == null)
                throw new InvalidObjectException(techId + " not linked");
            return tech;
        }
    }

    public Technology(Generic generic, Xml.Technology t) {
        this(generic, t.techName, Foundry.Type.valueOf(t.defaultFoundry), t.defaultNumMetals);
        xmlTech = t;
        setTechShortName(t.shortTechName);
        setTechDesc(t.description);
        setFactoryScale(t.scaleValue, t.scaleRelevant);
        setFactoryParasitics(t.minResistance, t.minCapacitance);
        if (!t.transparentLayers.isEmpty())
            setFactoryTransparentLayers(t.transparentLayers.toArray(new Color[t.transparentLayers.size()]));
        HashMap<String,Layer> layers = new HashMap<String,Layer>();
        for (Xml.Layer l: t.layers) {
            Layer layer = Layer.newInstance(this, l.name, l.desc);
            layers.put(l.name, layer);
            layer.setFunction(l.function, l.extraFunction);
            if (l.cif != null)
                layer.setFactoryCIFLayer(l.cif);
            if (l.skill != null)
                layer.setFactorySkillLayer(l.skill);
            layer.setFactory3DInfo(l.thick3D, l.height3D, l.mode3D, l.factor3D);
            layer.setFactoryParasitics(l.resistance, l.capacitance, l.edgeCapacitance);
        }
        HashMap<String,ArcProto> arcs = new HashMap<String,ArcProto>();
        for (Xml.ArcProto a: t.arcs) {
            if (findArcProto(a.name) != null) {
                System.out.println("Error: technology " + getTechName() + " has multiple arcs named " + a.name);
                continue;
            }
            ArcLayer[] arcLayers = new ArcLayer[a.arcLayers.size()];
//            long minGridExtend = Long.MAX_VALUE;
//            long maxGridExtend = Long.MIN_VALUE;
//            for (int i = 0; i < arcLayers.length; i++) {
//                Xml.ArcLayer al = a.arcLayers.get(i);
//                long gridLayerExtend = DBMath.lambdaToGrid(al.extend.getLambda(context));
//                minGridExtend = Math.min(minGridExtend, gridLayerExtend);
//                maxGridExtend = Math.max(maxGridExtend, gridLayerExtend);
//            }
//            if (maxGridExtend < 0 || maxGridExtend > Integer.MAX_VALUE/8) {
//                System.out.println("ArcProto " + getTechName() + ":" + a.name + " has invalid width offset " + DBMath.gridToLambda(2*maxGridExtend));
//                continue;
//            }
//            long gridFullExtend = minGridExtend + DBMath.lambdaToGrid(a.elibWidthOffset*0.5);
            for (int i = 0; i < arcLayers.length; i++) {
                Xml.ArcLayer al = a.arcLayers.get(i);
                Distance d = new Distance();
                d.addLambda(al.extend.value);
                arcLayers[i] = new ArcLayer(layers.get(al.layer),al.style, d);
            }
//            if (minGridExtend < 0 || minGridExtend != DBMath.lambdaToGrid(a.arcLayers.get(0).extend.getLambda(context)))
//            	assert true;
            Double diskOffset1 = a.diskOffset.get(Integer.valueOf(1));
            Double diskOffset2 = a.diskOffset.get(Integer.valueOf(2));
            long halfElibWidthOffset = 0;
            if (diskOffset1 != null && diskOffset2 != null)
                halfElibWidthOffset = DBMath.lambdaToGrid(diskOffset1.doubleValue() - diskOffset2.doubleValue());
            ArcProto ap = new ArcProto(this, a.name, halfElibWidthOffset, 0, a.function, arcLayers, arcs.size());
//            ArcProto ap = new ArcProto(this, a.name, (int)maxGridExtend, (int)minGridExtend, defaultWidth, a.function, arcLayers, arcs.size());
            addArcProto(ap);

            if (a.oldName != null)
                oldArcNames.put(a.oldName, ap);
            arcs.put(a.name, ap);
            if (a.wipable)
                ap.setWipable();
            if (a.curvable)
                ap.setCurvable();
            if (a.special)
                ap.setSpecialArc();
            if (a.notUsed)
                ap.setNotUsed(true);
            if (a.skipSizeInPalette)
                ap.setSkipSizeInPalette();
            ap.setFactoryExtended(a.extended);
            ap.setFactoryFixedAngle(a.fixedAngle);
            ap.setFactoryAngleIncrement(a.angleIncrement);
            ERC.getERCTool().setAntennaRatio(ap, a.antennaRatio);
//            if (a.arcPin != null)
//                ap.makeWipablePin(a.arcPin.name, a.arcPin.portName, a.arcPin.elibSize, makeConnections(a.arcPin.portArcs, arcs));
        }
        setNoNegatedArcs();
        DistanceContext context = EMPTY_CONTEXT;
        for (Xml.PrimitiveNode n: t.nodes) {
            EPoint sizeCorrector1 = n.diskOffset.get(Integer.valueOf(1));
            EPoint sizeCorrector2 = n.diskOffset.get(Integer.valueOf(2));
            if (sizeCorrector2 == null)
                sizeCorrector2 = EPoint.ORIGIN;
            if (sizeCorrector1 == null)
                sizeCorrector1 = sizeCorrector2;
            String minSizeRule = null;
            long lx, hx, ly, hy;
            if (n.nodeSizeRule != null) {
                hx = DBMath.lambdaToGrid(0.5*n.nodeSizeRule.width);
                lx = -hx;
                hy = DBMath.lambdaToGrid(0.5*n.nodeSizeRule.height);
                ly = -hy;
                minSizeRule = n.nodeSizeRule.rule;
            } else {
                lx = Long.MAX_VALUE;
                hx = Long.MIN_VALUE;
                ly = Long.MAX_VALUE;
                hy = Long.MIN_VALUE;
                for (int i = 0; i < n.nodeLayers.size(); i++) {
                    Xml.NodeLayer nl = n.nodeLayers.get(i);
                    long x, y;
                    if (nl.representation == NodeLayer.BOX || nl.representation == NodeLayer.MULTICUTBOX) {
                        x = DBMath.lambdaToGrid(nl.lx.value);
                        lx = Math.min(lx, x);
                        hx = Math.max(hx, x);
                        x = DBMath.lambdaToGrid(nl.hx.value);
                        lx = Math.min(lx, x);
                        hx = Math.max(hx, x);
                        y = DBMath.lambdaToGrid(nl.ly.value);
                        ly = Math.min(ly, y);
                        hy = Math.max(hy, y);
                        y = DBMath.lambdaToGrid(nl.hy.value);
                        ly = Math.min(ly, y);
                        hy = Math.max(hy, y);
                    } else {
                        for (TechPoint p: nl.techPoints) {
                            x = p.x.getGridAdder();
                            lx = Math.min(lx, x);
                            hx = Math.max(hx, x);
                            y = p.y.getGridAdder();
                            ly = Math.min(ly, y);
                            hy = Math.max(hy, y);
                        }
                    }
                }
            }
            ERectangle fullRectangle = ERectangle.fromGrid(lx, ly, hx - lx, hy - ly);
            EPoint fullSize = EPoint.fromGrid((hx - lx + 1)/2, (hy - ly + 1)/2);
            boolean needElectricalLayers = false;
            ArrayList<NodeLayer> nodeLayers = new ArrayList<NodeLayer>();
            ArrayList<NodeLayer> electricalNodeLayers = new ArrayList<NodeLayer>();
            for (int i = 0; i < n.nodeLayers.size(); i++) {
                Xml.NodeLayer nl = n.nodeLayers.get(i);
                TechPoint[] techPoints;
                if (nl.representation == NodeLayer.BOX || nl.representation == NodeLayer.MULTICUTBOX) {
                    techPoints = new TechPoint[2];
                    if (nl.lx.value > nl.hx.value || nl.lx.k > nl.hx.k ||
                            nl.ly.value > nl.hy.value || nl.ly.k > nl.hy.k)
                        System.out.println("Strange polygon in " + getTechName() + ":" + n.name);
                    techPoints[0] = makeTechPoint(nl.lx, nl.ly, context, fullSize);
                    techPoints[1] = makeTechPoint(nl.hx, nl.hy, context, fullSize);
                } else {
                    techPoints = nl.techPoints.toArray(new TechPoint[nl.techPoints.size()]);
                    for (int j = 0; j < techPoints.length; j++)
                        techPoints[j] = makeTechPoint(techPoints[j], fullSize);
                }
                NodeLayer nodeLayer;
                Layer layer = layers.get(nl.layer);
                if (n.shrinkArcs) {
                    if (layer.getPseudoLayer() == null)
                        layer.makePseudo();
                    layer = layer.getPseudoLayer();
                }
                if (nl.representation == NodeLayer.MULTICUTBOX) {
                    nodeLayer = NodeLayer.makeMulticut(layer, nl.portNum, nl.style, techPoints, nl.sizex, nl.sizey, nl.sep1d, nl.sep2d);
                }
                else if (n.specialType == PrimitiveNode.SERPTRANS)
                    nodeLayer = new NodeLayer(layer, nl.portNum, nl.style, nl.representation, techPoints, nl.lWidth, nl.rWidth, nl.tExtent, nl.bExtent);
                else
                    nodeLayer = new NodeLayer(layer, nl.portNum, nl.style, nl.representation, techPoints);
                if (!(nl.inLayers && nl.inElectricalLayers))
                    needElectricalLayers = true;
                if (nl.inLayers)
                    nodeLayers.add(nodeLayer);
                if (nl.inElectricalLayers)
                    electricalNodeLayers.add(nodeLayer);
            }
            if (n.sizeOffset != null) {
                lx += n.sizeOffset.getLowXGridOffset();
                hx -= n.sizeOffset.getHighXGridOffset();
                ly += n.sizeOffset.getLowYGridOffset();
                hy -= n.sizeOffset.getHighYGridOffset();
            }
            ERectangle baseRectangle = ERectangle.fromGrid(lx, ly, hx - lx, hy - ly);
            PrimitiveNode pnp = PrimitiveNode.newInstance(n.name, this, sizeCorrector1, sizeCorrector2, minSizeRule,
                    DBMath.round(n.defaultWidth.value + 2*fullSize.getLambdaX()),
                    DBMath.round(n.defaultHeight.value + 2*fullSize.getLambdaY()),
                    fullRectangle, baseRectangle, nodeLayers.toArray(new NodeLayer[nodeLayers.size()]));
            if (n.oldName != null)
                oldNodeNames.put(n.oldName, pnp);
            pnp.setFunction(n.function);
            if (needElectricalLayers)
                pnp.setElectricalLayers(electricalNodeLayers.toArray(new NodeLayer[electricalNodeLayers.size()]));
            if (n.shrinkArcs) {
                pnp.setArcsWipe();
                pnp.setArcsShrink();
            }
            if (n.square)
                pnp.setSquare();
            if (n.canBeZeroSize)
                pnp.setCanBeZeroSize();
            if (n.wipes)
                pnp.setWipeOn1or2();
            if (n.lockable)
                pnp.setLockedPrim();
            if (n.edgeSelect)
                pnp.setEdgeSelect();
            if (n.skipSizeInPalette)
                pnp.setSkipSizeInPalette();
            if (n.notUsed)
                pnp.setNotUsed(true);
            if (n.lowVt)
                pnp.setNodeBit(PrimitiveNode.LOWVTBIT);
            if (n.highVt)