Source Code for Module empro.toolkit.adfi_import

  1  # Copyright 1983-2019 Keysight Technologies, Inc , Keysight Confidential 
  2  import os, sys 
  3   
  4  import empro 
  5  if ("activeProjectView" in empro.gui.__dict__): 
  6      notification = "gui" 
  7  else: 
  8      notification = "text" 
  9   
 10 -def _decode_path(path): 
 11      ''' 
 12      converts an UTF-8 path to Unicode. 
 13      ''' 
 14      import sys 
 15      if isinstance(path, bytes): 
 16          path = path.decode("utf-8") 
 17      if "win" in sys.platform: 
 18          path = os.path.abspath(path) 
 19          if not path.startswith(u"\\\\?\\"): 
 20              if path.startswith("\\\\"): 
 21                  path = u"\\\\?\\UNC\%s" % path[2:] 
 22              else: 
 23                  path = u"\\\\?\\%s" % path 
 24      return path 
 25   
 26 -class _environmentSetRestore: 
 27 -    def set_environment(self,ADS_HPEESOF_DIR): 
 28          import os,sys 
 29          if ADS_HPEESOF_DIR == "": 
 30              EMPROHOME = os.environ['EMPROHOME'] 
 31              ADS_HPEESOF_DIR = os.path.join(EMPROHOME,'mom') 
 32          ADSbinPath = os.path.join(ADS_HPEESOF_DIR,'bin') 
 33          ADSlibPath = os.path.join(ADS_HPEESOF_DIR,'lib') 
 34          if 'win' in sys.platform: 
 35              self.oldenviron = os.environ['PATH'] 
 36              os.environ['PATH']=ADSbinPath+";"+os.environ['PATH'] 
 37          else: 
 38              self.oldenviron = os.environ['PATH'] 
 39              os.environ['PATH']=ADSbinPath+":"+os.environ['PATH'] 
 40              self.oldlibpath = os.environ['LD_LIBRARY_PATH'] 
 41              os.environ['LD_LIBRARY_PATH']=os.path.join(ADSlibPath,"linux_x86")+":"+os.path.join(ADSlibPath,"linux_x86_64")+":"+ADSlibPath+":"+os.environ['LD_LIBRARY_PATH'] 
 42   
 43 -    def restore_environment(self): 
 44          os.environ['PATH']            = self.oldenviron 
 45          if not 'win' in sys.platform: 
 46              os.environ['LD_LIBRARY_PATH'] = self.oldlibpath 
 47   
 48   
 49 -def _dummyUpdateProgress(value): 
 50      pass 
 51   
 52 -class updateProgressClass: 
 53 -    def __init__(self,min,max,updateProgressFunction): 
 54          self.min = min # in percent 
 55          self.max = max # in percent 
 56          self.updateProgressFunction = updateProgressFunction 
 57   
 58 -    def updateProgress(self,value): 
 59          localValue = self.min + int(value * (self.max - self.min)/100.0) 
 60          self.updateProgressFunction(localValue) 
 61   
 62 -class AdfiImporter: 
 63 -    def __init__(self): 
 64          self._ADFIimportWarnings = [] 
 65          pass 
 66   
 67 -    def logWarning(self,msg): 
 68          self._ADFIimportWarnings.append("Warning: " + msg) 
 69 -    def logError(self,msg): 
 70          self._ADFIimportWarnings.append("Error: " + msg) 
 71   
 72 -    def _makeProjFiles(self,adfiFileName,workingDir,simFDTD): 
 73          # Copy proj*.opt files from template directory 
 74          import os 
 75          EMPROHOME = os.environ['EMPROHOME'] 
 76          if simFDTD: 
 77              simDirName="FDTD" 
 78          else: 
 79              simDirName="FEM" 
 80          optDirName = os.path.join(EMPROHOME,os.path.pardir,os.path.pardir,"data","ADS_option_templates",simDirName) 
 81          try: 
 82              import shutil 
 83              for fname in os.listdir(optDirName): 
 84                  sourceFile = os.path.join(optDirName,fname) 
 85                  targetFile = os.path.join(workingDir,fname) 
 86                  shutil.copyfile(_decode_path(sourceFile),_decode_path(targetFile)) 
 87          except: 
 88              # Option files are not critical for import 
 89              self.logWarning("Problem with copying ADS option files.") 
 90          # Extract directories and file base names 
 91          adfiFile = os.path.basename(os.path.abspath(adfiFileName)) 
 92          adfiBaseName,ext = os.path.splitext(adfiFile) 
 93          fileList = os.listdir(_decode_path(workingDir)) 
 94          hasExtLtd = lambda x: os.path.splitext(x)[1]==".ltd" 
 95          ltdFiles = filter(hasExtLtd,fileList) 
 96          longestLtdFileName = max(ltdFiles, key=len) 
 97          longestLtdBaseName = os.path.splitext(os.path.basename(longestLtdFileName))[0] 
 98          # Copy the following files 
 99          fileMapping = [(longestLtdBaseName+".slm","proj.slm"), 
100          (longestLtdBaseName+".ltd","proj.ltd"), 
101          (longestLtdBaseName+".lay","proj.lay"), 
102          (adfiBaseName+"_top.prt"  ,"proj.prt"), 
103          (adfiBaseName+"_top.pin"  ,"proj.pin"), 
104          (adfiBaseName+"_adfi.dbw" ,"proj.dbw"), 
105          (adfiBaseName+"_adfi_egs" ,"proj_a"  )] 
106          import shutil 
107          notFoundList = [] 
108          for source, target in fileMapping: 
109              sourceFile = os.path.join(workingDir,source) 
110              targetFile = os.path.join(workingDir,target) 
111              if os.path.exists(_decode_path(sourceFile)): 
112                  shutil.copy(_decode_path(sourceFile),_decode_path(targetFile)) 
113              else: 
114                  notFoundList.append(sourceFile) 
115          if len(notFoundList)>0: 
116              raise Exception("Could not find the following files: %s" % notFoundList) 
117   
118 -    def _runMomEngine(self,workingDir): 
119          import subprocess 
120          MomEngine_cmd = ["MomEngine","-GP","--mode=fem-preparation", os.path.join(workingDir,"proj"),os.path.join(workingDir,"proj")] 
121          try: 
122              startupinfo = subprocess.STARTUPINFO() 
123              startupinfo.dwFlags  |= subprocess.STARTF_USESHOWWINDOW 
124          except AttributeError: 
125              startupinfo = None 
126          try: 
127              sim_pr = subprocess.Popen(MomEngine_cmd,startupinfo=startupinfo, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) 
128              out,err=sim_pr.communicate() 
129          except subprocess.CalledProcessError, e: 
130              import traceback 
131              print out 
132              print err 
133              raise Exception("exit status %s of command %s" % (e.returncode, e.cmd)) 
134   
135 -    def _load_and_get_proj_module(self,dirname): 
136          "import proj in dirname" 
137          import imp 
138          fname = "proj.py" 
139          name = fname.split('.')[0] 
140          f, modpath, desc = imp.find_module(name, [dirname]) 
141          proj = imp.load_module(name, f, modpath, desc) 
142          return proj 
143   
144 -    def _get_proj_version(self,proj): 
145          try: 
146              proj_version = proj.getVersion() 
147          except AttributeError: 
148              proj_version = 0 
149          return proj_version 
150   
151 -    def _noSheetPorts(self): 
152          pList = empro.activeProject.circuitComponents() 
153          for i in range(pList.size()): 
154              p = pList.at(i) 
155              p.useExtent = False 
156   
157 -    def _importProj(self,dirName,topAssembly,bwMap,useJedecBondwires,sbMap,useSolderBalls,simFDTD,updateProgressFunction=_dummyUpdateProgress): 
158          usedFlow = "Adfi" 
159          proj = self._load_and_get_proj_module(dirName) 
160          projVersion = self._get_proj_version(proj) 
161          try: 
162              session = proj.get_session(usedFlow=usedFlow) 
163              session.setBondwireMap(bwMap) 
164              session.setUseJedecBondwires(useJedecBondwires) 
165              session.setSolderBallMap(sbMap) 
166              session.setUseSolderBalls(useSolderBalls) 
167              import empro.toolkit.simulation 
168              if simFDTD: 
169                  session.setSimulator(empro.toolkit.simulation.FDTD) 
170              else: 
171                  session.setSimulator(empro.toolkit.simulation.FEM) 
172          except: 
173              session = None 
174          if projVersion >= 4: 
175              if not simFDTD: 
176                  proj.ads_simulation_settings() 
177              if projVersion >= 7: 
178                  importer = proj.projImporter(usedFlow,session,updateProgressFunction=updateProgressFunction) 
179              else: 
180                  importer = proj.projImporter(usedFlow,session) 
181              if projVersion <= 5: 
182                  session.setProjImporter(importer) 
183              warnings = importer.ads_import(usedFlow=usedFlow,topAssembly = topAssembly,demoMode=False,includeInvalidPorts=False) 
184          else: 
185              try: 
186                  warnings = proj.ads_import(usedFlow=usedFlow,topAssembly = topAssembly,session=session,includeInvalidPorts=False) 
187              except TypeError: # includeInvalidPorts may not be available in proj file generated by old MomEngine 
188                  try: 
189                      warnings = proj.ads_import(usedFlow=usedFlow,topAssembly = topAssembly,session=session) 
190                  except TypeError: # usedFlow may not be available in proj file generated by old MomEngine 
191                      warnings = proj.ads_import() 
192          if simFDTD: 
193              self._noSheetPorts() 
194          try: 
195              self._ADFIimportWarnings.extend(warnings) 
196          except TypeError: 
197              pass # warnings may be None 
198          return warnings 
199   
200      # Parse adfi file with import of eemAdfiParse module 
201 -    def _adfi_parse(self,adfiFileName,targetDir,useJedecBondwires,useSolderBalls,bwMap,sbMap): 
202          import empro.toolkit.eemAdfiParse as eemAdfiParse 
203          # Redirect errors and warnings 
204          eemWriteWarn = eemAdfiParse.eemWriteWarn 
205          eemWriteError = eemAdfiParse.eemWriteError 
206          eemAdfiParse.eemWriteWarn = self.logWarning 
207          eemAdfiParse.eemWriteError = self.logError 
208          # Process adfi file 
209          if eemAdfiParse.eemAdfiProcessFile(adfiFileName,targetDir,useJedecBondwires,useSolderBalls,bwMap,sbMap,targetPlatform='empro') == 1: 
210              pass 
211          else: 
212              raise Exception("A problem occured when processing the ADFI file.") 
213          # Restore 
214          eemAdfiParse.eemWriteWarn = eemWriteWarn 
215          eemAdfiParse.eemWriteError = eemWriteError 
216   
217 -    def _openSubstrate(self, ltdFileName): 
218          import os 
219          import subprocess,string 
220          import empro.toolkit.gui 
221          envVars = os.environ.copy() 
222          subedCmd = ['eesofsubed',ltdFileName] 
223           
224          myProcess = subprocess.Popen(args=subedCmd, 
225                                       executable=None, 
226                                       stdin=None, 
227                                       stdout=subprocess.PIPE, 
228                                       stderr=subprocess.PIPE, 
229                                       startupinfo=None, 
230                                       shell=False, 
231                                       env=envVars, 
232                                       universal_newlines=True) 
233          #wait for termination of child process 
234          out,err=myProcess.communicate() 
235   
236          res=err.join(out) 
237          empro.toolkit.gui.InfoDialog("eesofsubed %s output: %s" % (ltdFileName,res), "%s import: intermission" % "Adfi",True) 
238           
239   
240 -    def _editSubstrate(self,targetDir): 
241          import empro.toolkit.gui 
242          import os.path 
243          ltdFileName = os.path.join(targetDir,"proj.ltd") 
244          try: 
245              self._openSubstrate(ltdFileName) 
246          except: 
247              empro.toolkit.gui.InfoDialog("Unable to open the substrate file %s" % ltdFileName, "%s import: intermission" % "Adfi",True) 
248   
249 -    def _adfi2proj(self,ADS_HPEESOF_DIR,adfiFileName,targetDir,useJedecBondwires,useSolderBalls,bwMap,sbMap,simFDTD,openSubstrateEditor=False): 
250          envObj = _environmentSetRestore() 
251          self._adfi_parse(adfiFileName,targetDir,useJedecBondwires,useSolderBalls,bwMap,sbMap) 
252          envObj.set_environment(ADS_HPEESOF_DIR) 
253          self._makeProjFiles(adfiFileName,targetDir,simFDTD) 
254          if openSubstrateEditor: 
255              envObj.restore_environment() 
256              self._editSubstrate(targetDir) 
257              envObj.set_environment(ADS_HPEESOF_DIR) 
258          self._runMomEngine(targetDir) 
259          envObj.restore_environment() 
260   
261 -    def _getBondwireMap(self,iAdfiFileName): 
262          import empro.toolkit.eemAdfiParse as eemAdfiParse 
263          iDom = eemAdfiParse.eemAdfiReadFile(iAdfiFileName) 
264          importer = eemAdfiParse.bondwireImporter() 
265          bwMap = importer.getBondwireMap(iDom) 
266          return bwMap 
267   
268 -    def _setSimulator(self,simFDTD=False): 
269          import empro 
270          sim=empro.activeProject.createSimulationData() 
271          if simFDTD: 
272              # Set simulator to FDTD 
273              sim.engine = empro.toolkit.simulation.FDTD 
274          else: 
275              sim.engine = empro.toolkit.simulation.FEM 
276              # Remove fixed points for FDTD mesh since they may make the ports invalid for FEM simulations 
277              gG = empro.activeProject.gridGenerator() 
278              gG.clearManualFixedPoints() 
279   
280 -    def importAdfiComponents(self,adfiFileName,useJedecBondwires=False,useSolderBalls=True,topAssembly=None): 
281          import empro.toolkit.eemAdfiParse as eemAdfiParse 
282          # Redirect errors and warnings 
283          eemWriteWarn = eemAdfiParse.eemWriteWarn 
284          eemWriteError = eemAdfiParse.eemWriteError 
285          eemAdfiParse.eemWriteWarn = self.logWarning 
286          eemAdfiParse.eemWriteError = self.logError 
287          # Import components 
288          eemAdfiParse.eemAdfiImportComponents(adfiFileName,useJedecBondwires,useSolderBalls,topAssembly) 
289          # Restore 
290          eemAdfiParse.eemWriteWarn = eemWriteWarn 
291          eemAdfiParse.eemWriteError = eemWriteError 
292          return self._ADFIimportWarnings 
293   
294 -    def importAdfi(self,ADS_HPEESOF_DIR,adfiFileName,useJedecBondwires=False,updateProgressFunction=_dummyUpdateProgress,useSolderBalls=True,simFDTD=False): 
295          import tempfile 
296          import empro 
297          import empro.toolkit.ads_import 
298          demoMode=empro.toolkit.ads_import.useDemoMode() 
299          try: 
300              tempDir = tempfile.mkdtemp() 
301              updateProgressFunction(10) 
302              # import geometry, ports, (opt. flattened bondwires) 
303              bwMap = {} 
304              sbMap = {} 
305              self._adfi2proj(ADS_HPEESOF_DIR,adfiFileName,tempDir,useJedecBondwires,useSolderBalls,bwMap,sbMap,simFDTD) 
306              updateProgressFunction(30) 
307              # Test 
308              test = False 
309              if test: 
310                  empro.toolkit.gui.InfoDialog("Time to edit proj.py in %s" % tempDir,"%s import: intermission" % "Adfi",True) 
311              topAssembly = empro.geometry.Assembly() 
312              topAssembly.name = 'Adfi_import' 
313              if demoMode: 
314                  empro.activeProject.geometry().append(topAssembly) 
315              progressUpdater = updateProgressClass(30,70,updateProgressFunction) 
316              self._importProj(tempDir,topAssembly,bwMap,useJedecBondwires,sbMap,useSolderBalls,simFDTD,updateProgressFunction=progressUpdater.updateProgress) 
317              updateProgressFunction(70) 
318              # Clean up tempDir 
319              import shutil 
320              shutil.rmtree(_decode_path(tempDir)) 
321              updateProgressFunction(75) 
322              # import components, (opt. JEDEC bondwires) 
323              self.importAdfiComponents(adfiFileName,False,False,topAssembly) 
324              updateProgressFunction(90) 
325              if not demoMode: 
326                  empro.activeProject.geometry().append(topAssembly) 
327          except Exception, err: 
328              self.logError(unicode(err)) 
329          finally: 
330              if (notification == "gui"): 
331                  empro.gui.activeProjectView().zoomGeometryViewToExtents() 
332              self._setSimulator(simFDTD) 
333              return self._ADFIimportWarnings 
334   
335   
336 -def importAdfiComponents(adfiFileName,useJedecBondwires=False,useSolderBalls=True,topAssembly=None): 
337      importer = AdfiImporter() 
338      return importer.importAdfiComponents(adfiFileName,useJedecBondwires,useSolderBalls,topAssembly) 
339   
340 -def importAdfi(ADS_HPEESOF_DIR,adfiFileName,useJedecBondwires=False,updateProgressFunction=_dummyUpdateProgress,useSolderBalls=True,simFDTD=False): 
341      importer = AdfiImporter() 
342      return importer.importAdfi(ADS_HPEESOF_DIR,adfiFileName,useJedecBondwires=useJedecBondwires,updateProgressFunction=updateProgressFunction,useSolderBalls=useSolderBalls,simFDTD=simFDTD) 
343   
344 -def _main(): 
345      print """Use this module as follows: 
346  warnings = empro.toolkit.adfi_import.importAdfi(ADS_HPEESOF_DIR,adfiFileName) 
347  """ 
348   
349  if __name__=="__main__": 
350      _main() 
351