optics / mstm-gui

  from pylab import *
  

  class SimParserClass:
  
      simResults = dict()

      
      sxNearField = 0
      syNearField = 0
      intersectedNearField = 0
      
      #near field data
      gridNearField = []
      maxNearField = []
      

      def __init__(self, parameters):
          
          self.params = parameters;
          
          self.simResults['lambda'] = list()      
  

          self.simResults['extinction_unpolarized'] = list()
          self.simResults['extinction_parallel'] = list()
          self.simResults['extinction_perpendicular'] = list()

          self.simResults['extinction_total'] = list()

          
          self.gridNearField = []
          self.maxNearField = []
          
          

      def parseSimFile(self, l, fileName):
          self.simResults['lambda'].append(l)
          inFile = open(fileName, 'r')
  

          while True:

              line = inFile.readline().strip()
  

              if int(self.params['fixed_or_random_orientation']) == 0:
                  if line == 'scattering matrix elements':
                      break
                  elif line == 'unpolarized total ext, abs, scat efficiencies, w.r.t. xv, and asym. parm':
                      values = inFile.readline().strip().split(' ')
                      self.simResults['extinction_unpolarized'].append(values[0])
                  elif line == 'parallel total ext, abs, scat efficiencies':
                      values = inFile.readline().strip().split(' ')
                      self.simResults['extinction_parallel'].append(values[0])
                  elif line == 'perpendicular total ext, abs, scat efficiencies':
                      values = inFile.readline().strip().split(' ')
                      self.simResults['extinction_perpendicular'].append(values[0])
              
              else:

                  if line == 'scattering matrix elements':
                      break
                  elif line == 'total ext, abs, scat efficiencies, w.r.t. xv, and asym. parm':
                      values = inFile.readline().strip().split(' ')
                      self.simResults['extinction_total'].append(values[0])

                      
      def parseNearField(self, fileName):
          
          inFile = open(fileName, 'r')
          
          #get the size of the near field grid
          line = inFile.readline().strip()
          self.sxNearField, self.syNearField = map(int, line.split())
          
          #get the number of spheres that are intersected
          line = inFile.readline().strip()
          self.intersectedNearField = int(line)
          
          #process intersections here-----------
          
  
          #get the field values
          self.gridNearField = []
          for y in range(self.syNearField):
              self.gridNearField.append([])
              for x in range(self.sxNearField):
                  line = inFile.readline().strip()
                  values = map(float, line.split())
                  self.gridNearField[y].append(values[2])
                  
          E = array(self.gridNearField)

          self.maxNearField.append(abs(E).max())

  
      def saveFile(self, fileName):
          outFile = open(fileName, 'w')
          outFile.write(str(self))

          outFile.close()

  
      def __getitem__(self, key):
          return self.simResults[key];
  
      def __str__(self):
          result = '';
  
          for i in range(len(self.simResults['lambda'])):

              result += str(self.simResults['lambda'][i])
              result += '\t' + str(self.simResults['extinction_unpolarized'][i])
              result += '\t' + str(self.simResults['extinction_parallel'][i])
              result += '\t' + str(self.simResults['extinction_perpendicular'][i])
              
              #parse the near field if it is included in the simulation
              if int(parameters['calculate_near_field']) == 1:
                  result += '\t' + str(maxNearField)
                  
              result += '\n'

          return result