Source Code for Module empro.toolkit.results.system

  1  # Copyright 1983-2017 Keysight Technologies, Inc  
  2   
  3  from empro.toolkit import Bunch 
  4  from empro.toolkit.results import UnavailableError, excitation_based 
  5   
  6 -class System(excitation_based.ExcitationBased): 
  7 -    def __init__(self, *args, **kwargs): 
  8          excitation_based.ExcitationBased.__init__(self, *args, **kwargs) 
  9   
 10 -    def _scalarValue(self, fromWhat): 
 11          try: 
 12              import empro 
 13              rawResult = empro.toolkit.dataset.getResult(sim=self._results._sim, run='Run0001', object='System', timeDependence='SteadyState', result=fromWhat) 
 14              self._results._extractAvailableExcitationToRun(rawResult.query) 
 15              self._availableExcitationsToRun = self._results._availableExcitationsToRun 
 16          except KeyError: 
 17              raise UnavailableError("") 
 18           
 19          outputObj = rawResult.query.getOutputObject() 
 20          metaData = outputObj.metaData() 
 21          materials = metaData.materials 
 22           
 23          scalarValues = {} 
 24           
 25          for portName, runIndex in self._availableExcitationsToRun.iteritems(): 
 26              rawResult = empro.toolkit.dataset.getResult(sim=self._results._sim, run=runIndex+1, object='System', timeDependence='SteadyState', result=fromWhat) 
 27              dim0 = rawResult.dimension(0) 
 28               
 29              if not self._frequencies: 
 30                  freqIndexRange = range(dim0.size()) 
 31              else: 
 32                  freqIndexRange = [x for x in range(dim0.size()) if dim0.at(x) in self._frequencies] 
 33                   
 34              for freqIndex in freqIndexRange: 
 35                  frequency = rawResult.dimension(0).at(freqIndex) 
 36                  excitationScaling = abs(self._excitationWeights.weight(portName, frequency)) 
 37                  value =  rawResult.at(freqIndex)*excitationScaling 
 38                  existingValue = scalarValues.get(frequency, Bunch(frequency=frequency, value=0.0)).value 
 39                  scalarValues[frequency] = Bunch(frequency=frequency,value=value+existingValue) 
 40          return scalarValues 
 41           
 42 -    def netInputPower(self): 
 43          return self._scalarValue('NetInputPower') 
 44           
 45 -    def netAvailablePower(self): 
 46          return self._scalarValue('NetAvailablePower') 
 47   
 48 -    def netComponentLoss(self): 
 49          return self._scalarValue('NetComponentLoss') 
 50   
 51 -    def radiatedPower(self): 
 52          return self._scalarValue('RadiatedPower') 
 53   
 54 -    def dissipatedPower(self): 
 55          return self._scalarValue('DissipatedPower') 
 56   
 57 -class FemSystem(System): 
 58 -    def __init__(self,  *args, **kwargs): 
 59          System.__init__(self,  *args, **kwargs) 
 60   
 61 -    def dissipatedPowerPerMaterial(self): 
 62          import pyfemPlugin 
 63          import os 
 64          import empro 
 65           
 66          femDir = os.path.join(empro.activeProject.rootDir,"%06d" % self._results._sim, "emds_dsn","design") 
 67          fields = pyfemPlugin.FieldEvaluator(femDir) 
 68          ports = fields.excitations() 
 69          freqs = fields.frequencies() 
 70          materials = fields.materials() 
 71          dissipatedPower = {} 
 72          roundedFrequencies = [int(x) for x in self._frequencies] 
 73          translatedFrequencies = [freq for freq in freqs if (int(freq) in roundedFrequencies)] 
 74           
 75          for frequency in translatedFrequencies: 
 76              excitationScaling = self._excitationWeights.weights(frequency) 
 77              reExcitationScaling = {} 
 78              for k,v in sorted(excitationScaling.iteritems()): 
 79                  reExcitationScaling[k]=complex(v) 
 80              fields.setup(frequency, reExcitationScaling) 
 81              rawPower = fields.dissipated_power(materials) 
 82              for materialName in rawPower: 
 83                  if materialName not in dissipatedPower: 
 84                      dissipatedPower[materialName] = {} 
 85                  dissipatedPower[materialName][frequency] = Bunch(frequency=frequency, material=materialName, value=rawPower[materialName][0]+rawPower[materialName][1]) 
 86          return dissipatedPower 
 87   
 88 -class FdtdSystem(System): 
 89 -    def __init__(self,  *args, **kwargs): 
 90          System.__init__(self,  *args, **kwargs) 
 91   
 92 -    def dissipatedPowerPerMaterial(self): 
 93          if self._coherent: 
 94              raise UnavailableError("") 
 95               
 96          try: 
 97              import empro 
 98              rawResult = empro.toolkit.dataset.getResult(sim=self._results._sim, run='Run0001', object='System', timeDependence='SteadyState', result='DissipatedPowerPerMaterial') 
 99              self._results._extractAvailableExcitationToRun(rawResult.query) 
100              self._availableExcitationsToRun = self._results._availableExcitationsToRun 
101          except KeyError: 
102              raise UnavailableError("") 
103          outputObj = rawResult.query.getOutputObject() 
104          metaData = outputObj.metaData() 
105          materials = metaData.materials 
106           
107          dissipatedPower = {} 
108           
109          for portName, runIndex in self._availableExcitationsToRun.iteritems(): 
110              rawResult = empro.toolkit.dataset.getResult(sim=self._results._sim, run=runIndex+1, object='System', timeDependence='SteadyState', result='DissipatedPowerPerMaterial') 
111              dim0 = rawResult.dimension(0) 
112              dim1 = rawResult.dimension(1) 
113              for matIndex in range(dim1.size()): 
114                   
115                  materialName = materials[matIndex] 
116                  if not self._frequencies: 
117                      freqIndexRange = range(dim0.size()) 
118                  else: 
119                      freqIndexRange = [x for x in range(dim0.size()) if dim0.at(x) in self._frequencies] 
120                  power = dissipatedPower.get(materialName, {}) 
121                       
122                  for freqIndex in freqIndexRange: 
123                      frequency = rawResult.dimension(0).at(freqIndex) 
124                      excitationScaling = abs(self._excitationWeights.weight(portName, frequency)) 
125                      value = rawResult.at(freqIndex,matIndex)*excitationScaling 
126                      existingValue = power.get(frequency, Bunch(frequency=frequency, value=0.0)).value 
127                      power[frequency] = Bunch(material=materialName, frequency=frequency,value=value+existingValue) 
128                       
129                  dissipatedPower[materialName] = power 
130          return dissipatedPower 
131