EDA Tool

84 阅读 0 评论 56 点赞

我是靠谱客的博主勤恳蜜蜂，最近开发中收集的这篇文章主要介绍EDA Tool，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

#1.ReadDeviceList.py :

import xlrd
def ReadDeviceList(ExcelPath,SheetName):
   #define output data
   DeviceDict={}
   #Tabel format：
   TableFormatHeader=['Device','Terminal','DeviceName','Instance Statement','Device Description (ADS explanation)','Equation']
   ColumnOfTable=len(TableFormatHeader)
   #read excel and parse
   with xlrd.open_workbook(ExcelPath) as Excel:
       #SheetName= Excel.sheet_names()[0]
       #get sheet contain Device List info
       Sheet=Excel.sheet_by_name(SheetName)
       #遍历每一行，count数行数
       Nrows=Sheet.nrows #获得sheet的总行数
       Section=0
       Count=0
       while Count<Nrows:
           RowList=Sheet.row_values(Count) #RowList是一个以每一行的各个列元素组合成的list
           Count+=1
       #read by lines, Section = 1 mean catch the table info of device list
           if (RowList[1].find(TableFormatHeader[0]) != -1): #RowList should be string or error occur
               Section=1 # the first section Mask Name table, extract Layers
               continue   #if catch header, jump out of this segment
           elif Section==1: #
               try:
                   DeviceDict[RowList[TableFormatHeader.index('DeviceName')+1]]=RowList[TableFormatHeader.index('Instance Statement')+1]
               except IndexError:
                   pass
           elif Section==2: #Section 2 is Design Rule Info
               pass
       if Count==0:
           pass
       #read failure
   #Excel.close() workbook do not have close() function
   return DeviceDict #output format {DeviceName:'statement'} statement format like {'qebe':'qbebxxx (E,B,C) we =2[1.6,5] le =20[10,50] ne=1[2,8] nb=3[::] nc=2 selft =1 trise = 0 rthpkg =0 cthpag =0'}

import re
def DeleteNullInList(StringList):
   for item in StringList:
       if (item=='' or item==[]):
           StringList.remove(item)
def ParseStatement(Statement):
   #define output
   ParameterDict={}
   Pins=[]
   PinsDict={}
   #
   if isinstance(Statement,str):
       RegularStatement=re.sub('=',' = ',Statement)
       #check if string
       Words=re.split('s',RegularStatement)
       DeleteNullInList(Words) # delete null cell
       #Words[0] is like 'qebexxx' represent the format
       #Words[1] is pins
       Pins=re.split('s|(|)|,',Words[1])
       DeleteNullInList(Pins)
       PinsDict['Pins']=Pins
       #Words[2+] is parameters
       WordLen=len(Words)
       i=Words.index('=') #initial i as the first index of '='
       while (i < WordLen):
           ParameterIndex=i-1
           ValueIndex=i+1
           OperatorIndex=i
           #check value exist & value
           try:
               if (Words[OperatorIndex] != '='):
                   break
               ValuePattern='s|[|]|,|:' #Notice [] represent the or relation of the sepeartors set
               ValueList=re.split(ValuePattern,Words[ValueIndex])
               DeleteNullInList(ValueList)
               ValueLen=len(ValueList)
               if ValueLen==3 or ValueLen==1:
                   ParameterValueList=[ValueLen]+ValueList
                   ParameterDict[Words[ParameterIndex]]=ParameterValueList
                   i=i+3
               else:
                   return 'FormatError','Statement format is unrecognizable' # waring that the format is unknown

           except IndexError:
               return 'IndexError','some words may missing or foramt is not unrecognizable' #error warning code & write log

       return ParameterDict,Pins
       #result is like {'we':[3,'2','1','10'],'le':}
       #multi expression []

else:
return 'TypeError','Arguement is not string'# error warning code

def ParseDeviceDict(DeviceDictRaw):
   DeviceDict={}
   for key in DeviceDictRaw:
       Paremeters,Pins=ParseStatement(DeviceDictRaw[key])
       TempDict={}
       TempDict.update(Parameters)
       TempDict.update(Pins)
       DeviceDict[key]=TempDict
   return DeviceDict

#######################################################################

#2.ReadPDKCircuitAel.py

#get all file in PDK/circuit/ael document: path, filename
import os
def RecursionFileInDoc(PATH):
   if(PATH[-1]!='/'):
       PWD=PATH+'/'
   else:
       PWD=PATH # if not / add
   Files=[]

   CurrentDir=os.listdir(PATH)
   for i in range (len(CurrentDir)):
       if(os.path.isdir(PWD+CurrentDir[i])):
           Files=Files+(recursionFile(PWD+CurrentDir[i]))
       elif(os.path.isfile(PWD+CurrentDir[i])):
           Files.append(PWD+CurrentDir[i])
   return Files
#if the filename is not end with FilterKeywords like 'ael', it will be delete
def FilenameFilter(FileList,FilterKeyword):
   for filename in FileList:
       tempname=re.split('.',filename)
       if tempname[-1]!=FilterKeyword :
           FileList.remove(filename)

#ParseAel file
def ParseCircuitAel(FilePath):
   DeviceParameterList=[]
   with open(FilePath) as CircuitAelFile:
       #FilePath is CircuitAelFile
       #ParseWords=[]
       Count=0
       TempStringList=[]
       # 0: not parsing >0 parsing; different segment different parsing
       for row in CircuitAelFile:
           #remove //commmet
           CommentIndex=row.find('//')
           CodeString=row[0:CommentIndex]
           #when row catch 'create_item' start Parsing
           if row.find('create_item')!=-1:
               TempStringList.append(CodeString)
               Count=1
           elif row.find('create_parm')!=-1:
               TempStringList.append(CodeString)
               Count=Count+1
           if Count>0:
               TempStringList[Count-1]+=CodeString
       #TempStringList is code segements split by 'create_item' or 'create_parm'
       for item in TempStringList:
           #item is segment of code
           CommentIndexStart=item.find('/*')
           CommentIndexEnd=item.find('*/')
           CodeString=item[0:CommentIndexStart]+item[CommentIndexEnd:-1]
           #search prm("StdForm", "20 um") and first "item" prm(.*)
           StartIndex=CodeString.find('prm(')+4
           EndIndex=CodeString.find(')')
           DefaultString=CodeString[StartIndex:EndIndex]
           #search Parameter name lik "we"
           Words=re.split('"',CodeString)
           DeviceParameterList.append(Words[1])
       DeleteNullInList(DeviceParameterList) #why there may be null exist in list
       return DeviceParameterList

def ParseCircuitAelofPath(DocPath):
   DeviceParameterListSet=[]
   FileList=RecursionFileInDoc(DocPath)
   FilterKeyword='ael'
   FilenameFilter(FileList,FilterKeyword)
   for file in FileList:
       DeviceParameterListSet.append(ParseCircuitAel(file))
   return DeviceParameterListSet

def DataStructureTransform(DeviceParaListSet):
   DeviceParaDictSet={}
   ListLen=len(DeviceParaListSet)
   i=0
   while(i<ListLen):
       try:
           item=DeviceParaListSet[i]
           DeviceName=item[0]
           ParaList=item[1:]
           DeviceParaDictSet.update({DeviceName:ParaList})
       except IndexError:
           pass
           return 'IndexError: out of range'
       i+=1
   return DeviceParaDictSet
#test code####################################################################
DocPath='D:/10000130/ADS_PDK/PDK/Sanan_BIHEMT/circuit/ael/'
ParseCircuitAelofPath(DocPath)

#3.CatInfo2Csv.py

#final data structure {'device':[{parameter1:type,default,min,max....},{parameter2:type=1,default},{parameter3:value3}]}
#DeviceDict like {'qbeb':{'we':[3,'2','1','10'],'le':[1,'4'],'Pins':['a','b','c']},
#               'device2':{'we':[3,'2','1','10'],'nf':[3,'2','1','10'],'Pins':['a','b','c']}}
#               }
#DeviceParameterListSet like {'qbeb':['we','le'], 'device2':['we','nf'], }
#Output DeviceInfoListSet like {'device':[['we',3,'2','1','10'],['le',1,'4']]}
def SortInOrder(DeviceDict,DeviceParameterListSet):
   DeviceInfoListSet={}
   #intermedia variable
   TempDict={}
   for device in DeviceDict:
       try:
           ParameterDict=DeviceDict[device]
           ParameterList=DeviceParameterListSet[device]
           DeviceInfoList=[]
           for Parameter in ParameterList:
               try:
                   ValueListOfPara=ParameterDict[Parameter]
                   DeviceInfoList=[Parameter]+ValueListOfPara
               except IndexError:
                   pass
           DeviceInfoListSet[device]=DeviceInfoList
       except IndexError:
           return 'Error: device name not match'
   return DeviceInfoListSet

#define sampling method
def SimplingInScope(METHOD,Scope,Nmax):
   #define output var
   SimplingList=[]
   #case by method
   if METHOD==1:
       pass
   else:   #default case Max Min Medium
       if len(Scope)==2:
           Delta=(Scope[0]+Scope[1])/(Nmax+1)
           i=0
           while(i<Nmax+2):
               SimplingList.append(Scop[0]+i*Delta)
               i+=1
           return SimplingList
#!!!!Notice Generate Value type is String???

def Randomize(DeviceInfoListSet,Nmax): #Generate not more than Nmax
   #first get the list contain which parameter is randomizeable, scan all parameters
   for Device in DeviceInfoListSet:
       ParaListOfDevice=DeviceInfoListSet[Device] #format=[ParameterName,VarOrVal,Default,Min,Max]
       RandomizeIndexList=[]
       if ParaListOfDevice[1]==3 : #means Var not Val
           #simple and append the value to le Parameter List ['we',3,'2','1','10']->['we',3,'2','1','10','5','3'...]
       elif ParaListOfDevice[1]==1: # should complement parameter len to 3 like ['le',1,'4']->['le',1,'4','4','4']
           ParaListOfDevice+=[ParaListOfDevice[-1]]*Nmax
           DeviceInfoListSet[Device]=ParaListOfDevice
   return DeviceInfoListSet

def WriteCsvByDeviceInstance(CsvPath,DeviceInfoListSet):
for Device in DeviceInfoListSet:

#Final Type: {'DeviceName':[[ParameterList,value1,value2..],[ParameterList,value1,value2..]...,[Location,x,y,dx,dy]]}

#4.AelCodeGernator.py

#output format :CodeRowList [[Code Segment1],[CodeSegement2]....]
#input format: DeviceInfoListSet{'Device':[[Parameter1],[Parameter2],....[Loaction]]}
#LibInfo=[ProcessLibName,LibName,LibCellName]
#Test Input:
#DeviceInfoListSet={'RES_TFR':[['"Resistance"','"Resistance"','"Resistance"'],['"3 um"','"10 um"','"5 um"'],['"3 um"','"10 um"','"5 um"'],['""','""','""''],['"50 Ohm"','"50 Ohm"','"50 Ohm"],['"0"','"0"','"0"'],['"rt"','"rt"','"rt"'],[200,200,200,200]]}
#LibInfo=['"Sanan_P25ED"','"P25_ED"','"LayoutQA"']
#LayoutArraySetting=[1,5] #array cells by 1x5
def AelCodeGenerator(DeviceInfoListSet,LibInfo,LayoutArraySetting):
   #outpu definition
   CodeRowList=[]
   #Infomation May from input
   ProcessLibName=LibInfo[0]
   LibName=LibInfo[1]
   ADSCellName=LibInfo[2]
   #定义：需要与lib内容对应:
   CodeDefinitionSegment=[]
   CodeDefinitionSegment.append('//definition code segment start:')
   CodeDefinitionSegment.append('decl processLibName="%s";'%ProcessLibName)
   CodeDefinitionSegment.append('decl libName="%s";'%LibName)
   CodeDefinitionSegment.append('decl cellName="%s";'%ADSCellName)
   CodeDefinitionSegment.append('//definition code segment end')
   CodeRowList.append(CodeDefinitionSegment)
   #cycle body
   for Device in DeviceInfoListSet:
       #extract every type of device info from input
       DeviceInfoList=DeviceInfoListSet[Device]
       ParameterNum=len(DeviceInfoList)-1
       ParameterInfoList=DeviceInfoList[0:-1]
       dx=DeviceInfoList[-1][0]
       dy=DeviceInfoList[-1][1]
       colNum=LayoutArraySetting[1]
       DeviceName=Device
       LibCellName=ADSCellName #PDK lib里面定义的Cell的名字
       MaxNum=len(ParameterInfoList[0]) #device generate number
       #generate code for every device
       CodeRowListOfSingleDevice=[]
       CodeRowListOfSingleDevice.append('//%s code segment start:'%DeviceName)
       CodeRowListOfSingleDevice.append('decl dx = %f;'%dx)
       CodeRowListOfSingleDevice.append('decl dy = %f;'%dy)
       CodeRowListOfSingleDevice.append('decl colNum = %0.f;'%colNum)
       CodeRowListOfSingleDevice.append('decl deviceName="%s";'%DeviceName)
       CodeRowListOfSingleDevice.append('decl deviceArtworkFileName="%s";'%LibCellName) #like P25ED_Scalable...
       CodeRowListOfSingleDevice.append('decl context = db_oa_create_empty_design(%s, %s, %s, 2);'%(LibName,ADSCellName,DeviceName))
       CodeRowListOfSingleDevice.append('de_show_context_in_new_window(context);')
       CodeRowListOfSingleDevice.append('decl i = 0;')
       CodeRowListOfSingleDevice.append('decl MaxNum=%0.f;'%MaxNum)
       CodeRowListOfSingleDevice.append('while(i<MaxNum){')
       #for every Device generate layout
       i=0 #i means 1st/2nd/3rd/4th....ith instance of device
       while(i<MaxNum):
           #extract info
           CodeRowListOfSingleDevice.append('   decl itemName=strcat(%s,":",%s,":","layout");'%(ProcessLibName,LibCellName))
           CodeRowListOfSingleDevice.append('   decl itemInfo0LP = de_init_item(itemName);')
           CodeRowListOfSingleDevice.append('   de_place_item(itemInfo0LP, dx*(i%colNum), dy*(i/colNum));')
           CodeRowListOfSingleDevice.append('   //修改参数：参数必须对应')
           CodeRowListOfSingleDevice.append('   de_set_item_parameters(itemInfo0LP, list(')
           j=0 #j is the parameter No
           while(j<ParameterNum):
               CodeRowListOfSingleDevice.append('       prm_ex("Sanan_P25ED","StdForm","%s"),'%DeviceInfoList[j][i])
               j+=1
           CodeRowListOfSingleDevice.append('   de_end_edit_item(itemInfo0LP);')
           CodeRowListOfSingleDevice.append('   i+=1;')
           CodeRowListOfSingleDevice.append('}')
           i+=1
       #End of a device instance drawing
       CodeRowListOfSingleDevice.append('decl designName=strcat(%s,":", %s,":", %s);'%(LibName,ADSCellName,DeviceName))
       CodeRowListOfSingleDevice.append('de_save_oa_design(designName);')
       CodeRowListOfSingleDevice.append('de_close_window();')
       CodeRowListOfSingleDevice.append('//%s code segment end'%DeviceName)
       CodeRowList.append(CodeRowListOfSingleDevice)
   return CodeRowList

def WriteList2File(CodeRowList,FilePath):
   with open(FilePath,'w') as f:
       SegmentNum=len(CodeRowList)
       iSegment=0
       while(iSegment<SegmentNum):
           CodeSegment=CodeRowList[iSegment]
           RowNum=len(CodeSegment)
           iRow=0
           while(iRow<RowNum):
               #write
               f.write(CodeRowList[iSegment][iRow])
               f.write('n')
               iRow+=1
           iSegment+=1