xmlrules.java

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

                if (!searchFor && (maxR == null || maxR.getValue(0) > rule.getValue(0) || maxR.getValue(1) > rule.getValue(1)))
                {
                    maxR = rule;
                }
                else if (rule.maxWidth < wideS && rule.minLength <= length &&
                        (maxR == null || (maxR.maxWidth < rule.maxWidth && maxR.minLength < rule.minLength)))
                {
                    maxR = rule;
                }
            }
        }
        return (maxR);
     }

    /**
     * To set wide limit for old techs
//     * @param values
     */
    public void setWideLimits(double[] values)
    {
        System.out.println("Review XMLRules::setWideLimits");

        for (HashMap<XMLRules.XMLRule,XMLRules.XMLRule> map : matrix)
        {
            if (map == null) continue;

            for (XMLRule rule : map.values())
            {
                if (rule.maxWidth > 0 && rule.maxWidth != values[0])
                    rule.maxWidth = values[0];
            }
        }
    }

    private void addXMLRule(int index, XMLRule rule)
    {
        HashMap<XMLRules.XMLRule,XMLRules.XMLRule> map = matrix[index];
        if (map == null)
        {
            map = new HashMap<XMLRules.XMLRule,XMLRules.XMLRule>();
            matrix[index] = map;
        }

       map.put(rule, rule);
    }

    /**
     * Method to delete a given spacing rule
     * @param index
     * @param rule
     */
    public void deleteRule(int index, DRCTemplate rule)
    {
        HashMap<XMLRules.XMLRule,XMLRules.XMLRule> map = matrix[index];
        if (map == null) return; // no rule found

        for (XMLRule r : map.values())
        {
            if (r.ruleType == rule.ruleType && r.maxWidth == rule.maxWidth &&
                r.minLength == rule.minLength && r.multiCuts == rule.multiCuts &&
                r.ruleName.equals(rule.ruleName))
            {
                // found element to delete
                map.remove(r);
                return;
            }
        }
    }

    /** OLD FUNCTION*/
    public void addRule(int index, DRCTemplate rule, DRCTemplate.DRCRuleType spacingCase, boolean wideRules)
    {
        new Error("Not implemented");
    }
    /**
	 * Method to add a rule based on template
	 * @param index
     * @param rule
     */
	public void addRule(int index, DRCTemplate rule)
	{
		DRCTemplate.DRCRuleType internalType = rule.ruleType;
        List<Layer> list = null;

        // This is only required for this type of rule
        if (rule.ruleType == DRCTemplate.DRCRuleType.EXTENSION || rule.ruleType == DRCTemplate.DRCRuleType.EXTENSIONGATE)
        {
            list = new ArrayList<Layer>(2);
            list.add(tech.findLayer(rule.name1));
            list.add(tech.findLayer(rule.name2));
        }

		switch (rule.ruleType)
		{
			case SPACING:
//		    case SPACINGW:
				internalType = DRCTemplate.DRCRuleType.UCONSPA;
                XMLRule r = new XMLRule(rule);
                r.ruleType = DRCTemplate.DRCRuleType.CONSPA;
                addXMLRule(index, r);
                break;
        }
        XMLRule r = new XMLRule(rule);
        r.ruleType = internalType;
        addXMLRule(index, r);
//        addRule(index, rule.ruleName, rule.value1, internalType, rule.maxWidth, rule.minLength, rule.multiCuts, rule.when, list, rule.nodeName);
	}

     /**
      * Method to return min value rule depending on type and wire length
      */
    private double getMinRule(int index, DRCTemplate.DRCRuleType type, double maxW)
    {
        HashMap<XMLRules.XMLRule, XMLRules.XMLRule> map = matrix[index];
        if (map == null) return (0.0);
        double maxValue = 0.0; // get the largest value among the valid ones. It doesn't select the first
        // found only

        for (XMLRule rule : map.values())
        {
            if (rule.ruleType != type)
                continue;
            if (rule.maxWidth > maxW)
                continue;
            double val = rule.getValue(0);
            if (maxValue < val)
                maxValue = val;
//            if (rule.ruleType == type && rule.maxWidth <= maxW)
//                return (rule.getValue(0));
        }
        return (maxValue);
    }

	/**
	 * Method to find the spacing rule between two layer.
	 * @param layer1 the first layer.
     * @param layer2 the second layer.
     * @param connected true to find the distance when the layers are connected.
     * @param multiCut true to find the distance when this is part of a multicut contact.
     * @param wideS widest polygon
     * @param length length of the intersection
     * @return the spacing rule between the layers.
     * Returns null if there is no spacing rule.
	 */
	public DRCTemplate getSpacingRule(Layer layer1, Geometric geo1,
                                      Layer layer2, Geometric geo2, boolean connected,
                                      int multiCut, double wideS, double length)
	{
		int pIndex = getRuleIndex(layer1.getIndex(), layer2.getIndex());
		DRCTemplate.DRCRuleType type = (connected) ? DRCTemplate.DRCRuleType.CONSPA : DRCTemplate.DRCRuleType.UCONSPA;

        // Composing possible name if
        String n1 = null, n2 = null;
        if (geo1 != null) n1 = DRCTemplate.getSpacingCombinedName(layer1, geo1);
        if (geo2 != null) n2 = DRCTemplate.getSpacingCombinedName(layer2, geo2);
        List<String> list = new ArrayList<String>(2);
        list.add(n1); list.add(n2);

		XMLRule r = getRule(pIndex, type, wideS, length, multiCut, list, null);

        // Search for surrounding conditions not attached to nodes
//        if (r == null)
//        {
//            r = getRule(pIndex, DRCTemplate.DRCRuleType.SURROUND, wideS, length, multiCut, null, null);
//            if (r != null && r.nodeName != null) r = null; // only spacing rule if not associated to primitive nodes.
//        }

        return (r);
	}

    /**
     * Method to find all rules of specified type associated to Layer layer1
     * @param layer1 layer
     * @param type rule type
     * @return all rules of specified type associated to Layer layer1
     */
    public List<DRCTemplate> getRules(Layer layer1, DRCTemplate.DRCRuleType type)
    {
        List<DRCTemplate> tempList = new ArrayList<DRCTemplate>();
        int layerIndex = layer1.getIndex();
        if (layerIndex < 0) return tempList;
        HashMap<XMLRules.XMLRule, XMLRules.XMLRule> map = matrix[layerIndex];
        if (map == null) return tempList;

        for (XMLRule rule : map.values())
        {
            if (rule.ruleType == type)
                tempList.add(rule);
        }

//        List<DRCTemplate> tempList = new ArrayList<DRCTemplate>();
//        int layerIndex = layer1.getIndex();
//		int tot = tech.getNumLayers();
//        List<String> list = new ArrayList<String>(2);
//
//        for(int i=0; i<tot; i++)
//		{
//			int pIndex = getRuleIndex(layerIndex, i);
//            list.clear();
//            list.add(tech.getLayer(i).getName());  // layer1 must be the second name
//            list.add(layer1.getName());
//            DRCTemplate temp = getRule(pIndex, type, 0, 0, -1, null, list);
//            if (temp != null)
//                tempList.add(temp);
//        }

		return tempList;
    }

    /**
	 * Method to find the extension rule between two layer.
	 * @param layer1 the first layer.
     * @param layer2 the second layer.
     * @param isGateExtension to decide between the rule EXTENSIONGATE or EXTENSION
     * @return the extension rule between the layers.
     * Returns null if there is no extension rule.
	 */
	public DRCTemplate getExtensionRule(Layer layer1, Layer layer2, boolean isGateExtension)
	{
		int pIndex = getRuleIndex(layer1.getIndex(), layer2.getIndex());
        List<String> list = new ArrayList<String>(2);
        list.add(layer1.getName());
        list.add(layer2.getName());
        DRCTemplate.DRCRuleType rule = (isGateExtension) ? DRCTemplate.DRCRuleType.EXTENSIONGATE : DRCTemplate.DRCRuleType.EXTENSION;
        return (getRule(pIndex, rule, 0, 0, -1, null, list));
	}

    /**
     * Method to tell whether there are any design rules between two layers.
     * @param layer1 the first Layer to check.
     * @param layer2 the second Layer to check.
     * @return true if there are design rules between the layers.
     */
    public boolean isAnySpacingRule(Layer layer1, Layer layer2)
    {
        int pIndex = getRuleIndex(layer1.getIndex(), layer2.getIndex());
        HashMap<XMLRules.XMLRule, XMLRules.XMLRule> map = matrix[pIndex];
        if (map == null) return false;
        for (XMLRule rule : map.values())
        {
            if (rule.isSpacingRule()) return true;
        }
        return false;
    }

    /**
     * Method to determine if given node is not allowed by foundry
     * @param nodeIndex index of node in DRC rules map to examine
     * @param type rule type
     * @return the rule if this is a forbidden node otherwise returns null.
     */
    public DRCTemplate isForbiddenNode(int nodeIndex, DRCTemplate.DRCRuleType type)
    {
        HashMap<XMLRules.XMLRule, XMLRules.XMLRule> map = matrix[nodeIndex];
        if (map == null) return (null);

        for (XMLRule rule : map.values())
        {
            if (rule.ruleType == type)
            {
                // discard rules that are not valid for this particular tech mode (ST or TSMC)
//                if (rule.when != DRCTemplate.DRCMode.ALL.mode() && (rule.when&techMode) != techMode)
//                    continue;
                return rule; // found
            }
        }
        // nothing found
        return null;
    }

    /**
	 * Method to find the worst spacing distance in the design rules.
	 * Finds the largest spacing rule in the Technology.
	 * @return the largest spacing distance in the Technology. Zero if nothing found
     * @param lastMetal last metal to check if only metal values are requested
     */
    public double getWorstSpacingDistance(int lastMetal)
	{
		double worstDistance = 0;

        if (lastMetal != -1)
        {
            int numM = tech.getNumMetals();
            assert(numM >= lastMetal);
            numM = lastMetal;
            List<Layer> layers = new ArrayList<Layer>(numM);
            for (Iterator<Layer> itL = tech.getLayers(); itL.hasNext();)
            {
                Layer l = itL.next(); // skipping pseudo layers
                if (l != l.getNonPseudoLayer())
                    continue;
                if (l.getFunction().isMetal())
                    layers.add(l);
            }
            for (int i = 0; i < numM; i++)
            {
                Layer l1 = layers.get(i);
                for (int j = i; j < numM; j++) // starts from i so metal1-metal2(default one) can be checked
                {
                    int index = getRuleIndex(l1.getIndex(), layers.get(j).getIndex());
                    double worstValue = getMinRule(index, DRCTemplate.DRCRuleType.UCONSPA, Double.MAX_VALUE);
                    if (worstValue > worstDistance) worstDistance = worstValue;
                }
            }
        }
        else
        {
            for(int i = 0; i < matrix.length; i++)
            {
                double worstValue = getMinRule(i, DRCTemplate.DRCRuleType.UCONSPA, Double.MAX_VALUE);
                if (worstValue > worstDistance) worstDistance = worstValue;
            }
        }
        return worstDistance;
	}

    /**
	 * Method to find the maximum design-rule distance around a layer.
	 * @param layer the Layer to examine.
	 * @return the maximum design-rule distance around the layer. -1 if nothing found.
	 */
	public double getMaxSurround(Layer layer, double maxSize)
	{
		double worstLayerRule = -1;
		int layerIndex = layer.getIndex();
		int tot = tech.getNumLayers();

		for(int i=0; i<tot; i++)
		{
			int pIndex = getRuleIndex(layerIndex, i);
            double dist = getMinRule(pIndex, DRCTemplate.DRCRuleType.UCONSPA, maxSize);
			if (dist > worstLayerRule) worstLayerRule = dist;
		}

		return worstLayerRule;
	}

    /**
	 * Method to apply overrides to a set of rules.
	 * @param override the override string.
	 * @param tech the Technology in which these rules live.