# -*- coding: utf-8 -*-
from ..Hurricane import DbU, DataBase
from ..helpers import trace
from ..helpers.io import ErrorMessage as Error
class Rules ( object ):
"""
The Rules object provides an easier access to the design rules stored
in the Technology databse. Instead of having to perform a function call
like:
.. code:: Python
tech = DataBase.getDB().getTechnology()
value = tech.getPhysicalRule( 'minEnclosure', 'pImplant', 'active' )
We can write access the rule as an attribute of the ``rule`` object.
.. code:: Python
import oroshi
value = oroshi.rules.minEnclosure_pImplant_active
Only the rules defined in the Rules.ruleSet list will be loaded.
"""
ruleSet = [ 'minSpacing_nWell'
, 'minWidth_pImplant'
, 'minSpacing_pImplant'
, 'minSpacing_rpolyh_pImplant'
, 'minEnclosure_pImplant_poly2con'
, 'minEnclosure_nImplant_active'
, 'minEnclosure_pImplant_active'
, 'minSpacing_nImplant_pImplant'
, 'minSpacing_cut0'
, 'minWidth_cut0'
, 'minWidth_active'
, 'minEnclosure_active_cut0'
, 'transistorMinL'
, 'transistorMinW'
, 'minSpacing_poly'
, 'minGateSpacing_poly'
, 'minSpacing_poly_active'
, 'minExtension_active_poly'
, 'minExtension_poly_active'
, 'minEnclosure_poly_cut0'
, 'minSpacing_cut0_poly'
, 'minWidth_cut0'
, 'minSpacing_cut0_active'
, 'minWidth_metal1'
, 'minSpacing_metal1'
, 'minEnclosure_metal1_cut0'
, 'minEnclosure_metal1_cut1'
, 'minWidth_cut1'
, 'minSpacing_cut1'
, 'minWidth_metal2'
, 'minSpacing_metal2'
, 'minEnclosure_metal2_cut1'
, 'minEnclosure_metal2_cut2'
, 'minWidth_cut2'
, 'minSpacing_cut2'
, 'minWidth_cut1'
, 'minSpacing_cut1'
, 'minWidth_metal3'
, 'minSpacing_metal3'
, 'minSpacingWide1_metal3'
, 'minEnclosure_metal3_cut2'
, 'minSpacingOnMetBot_cut2'
, 'minSpacingOnMetCap_cut2'
, 'maxWidth_metcap'
, 'minSpacing_metbot'
, 'minSpacing_cut1_metcap'
, 'minSpacing_cut2_metcap'
, 'minEnclosure_metbot_metcap'
, 'minEnclosure_metbot_cut1'
, 'minEnclosure_metbot_cut2'
, 'minEnclosure_metcap_cut2'
, 'minWidth_metcap'
, 'minWidth_metcapdum'
, 'minWidth_cpoly'
, 'minWidth_poly2'
, 'minWidth_rpolyh'
, 'minWidthHighPrec_rpolyh'
, 'minSpacing_cpoly'
, 'minSpacing_poly2'
, 'minSpacing_rpolyh'
, 'minSpacing_cut0_cpoly'
, 'minSpacing_diff_poly2'
, 'minSpacing_poly_poly2'
, 'minEnclosure_poly_cpoly'
, 'minEnclosure_cpoly_cut0'
, 'minEnclosure_poly2_cut0'
, 'MIMCap'
, 'PIPCap'
, 'MIMPerimeterCap'
, 'PIPPerimeterCap'
, 'RPOLYHSheetRes'
, 'RPOLY2PHSheetRes'
, 'MET1RPOLYHContRes'
, 'minWidth_hres'
, 'minSpacing_hres'
, 'minEnclosure_hres_poly2'
, 'minSpacing_hres_poly1'
, 'minSpacing_hres_poly2'
, 'minSpacing_hres_active'
, 'corrFactor90'
, 'corrFactor135'
, 'minRpolyhSquares'
]
def __init__ ( self ):
"""
Create an empty rule set. The rules must be loaded afterwards by calling
``Rules.load()``.
"""
trace( 100, '\tRules.__init__()\n' )
self.dtr = None
def isLoaded ( self ):
"""Tells if the rules have already been loaded."""
return self.dtr is not None
def load ( self, dtr ):
"""
Load the rule set from the technology into the Rules object.
.. note:: The ``dtr`` parameter is just another name for the currently
used Hurricane::Technology.
"""
trace( 100, '\tRules.load()\n' )
if self.dtr:
print( Error( 1, 'Rules.load(): Attempt to load rules from DTR a second time (ignored).' ))
return
self.dtr = dtr
for rule in Rules.ruleSet: self.addAttr(rule)
def getRealLayer ( self, stdName ):
"""
Get a Layer object by it's name. The alias translation from generic
names is used to return the real technology name.
For example:
================== ===================
Generic Layer Name SkyWater 130nm Name
================== ===================
nWell nwm
active difftap
pImplant psdm
cut0 licon
metal1 li
cut1 via
metal2 metal1
================== ===================
"""
return self.dtr.getLayer( stdName )
def attrTranslate ( self, attribute ):
"""
Translate a rule complete name, given in ``attribute``, using the *generic*
layer names into another string, using the target technology layer names.
For example, for SkyWater 130nm: ::
minEnclosure_pImplant_active => minSpacing_psdm_difftap
"""
words = attribute.split( '_' )
translateds = [ words[0] ]
for word in words[1:]:
realLayer = self.getRealLayer( word )
if realLayer is None:
print( Error( 1, 'rules.attrTranslate(): Unable to translate generic layer "{}".' \
.format( word )))
realLayerName = word
else:
realLayerName = realLayer.getName()
translateds.append( realLayerName )
return '_'.join( translateds )
def addAttr ( self, attribute ):
"""
Add a new attribute into the dictionnary of rule set. The attribute fields,
separated by '_' are broken down to get the corresponding rule in the
technology and be set as value of said attribute.
The attribute is the concatenation of the rule name and the various layers
it applies on. For example: ::
(minEnclosure, pImplant, active) => 'minEnclosure_pImplant_active'
"""
techAttribute = self.attrTranslate( attribute )
if attribute in self.__dict__: return
#print( 'Rules.addAttr(): {} -> {}'.format( attribute, techAttribute ))
value = None
words = techAttribute.split( '_' )
try:
if len(words) == 1:
if words[0].endswith('Cap' ): value = self.dtr.getUnitRule( words[0] ).getDoubleValue()
elif words[0].endswith('ContRes' ): value = self.dtr.getUnitRule( words[0] ).getDoubleValue()
elif words[0].endswith('Res' ): value = self.dtr.getUnitRule( words[0] ).getDoubleValue()
elif words[0].endswith('ctor90' ): value = self.dtr.getUnitRule( words[0] ).getDoubleValue()
elif words[0].endswith('ctor135' ): value = self.dtr.getUnitRule( words[0] ).getDoubleValue()
elif words[0].endswith('quares' ): value = self.dtr.getUnitRule( words[0] ).getDoubleValue()
if (value is None) and len(words) < 4:
rule = self.dtr.getPhysicalRule( *tuple(words) )
if rule.isDouble():
value = rule.getDoubleValue()
#print( 'Accessed value (Unit):{}'.format(value) )
else:
value = rule.getValue()
#print( 'Accessed value (DbU):{}'.format(DbU.getValueString(value)) )
except Exception as e:
print( e )
if not value is None:
self.__dict__[attribute] = value
return