optics / mstm-gui

  #this code parses the results of a simulation and stores them in a SimParserClass structure

  from pylab import *
  

  class SimParserClass:
  

  	simResults = dict()
  	
  	sxNearField = 0
  	syNearField = 0
  	intersectedNearField = 0
  	
  	#near field data
  	gridNearField = []
  	maxNearField = []
  	
  	#the stokes matrix is read from the output
  	stokesMatrix = []
  	scatAmpMatrix = []
  	

  	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.simResults['detector_field'] = 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 the simulation is for a single plane wave

  			if int(self.params['fixed_or_random_orientation']) == 0:
  				if line == 'scattering matrix elements':

  					#empty the stokes matrix
  					self.stokesMatrix = []
  					inFile.readline()
  					for s in range(0, 181):
  						values = map(float, inFile.readline().strip().split())
  						self.stokesMatrix.append(values)
  					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])
  				
  			#if the simulation is for random orientations
  			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)
  		#the enhancement is E^4 (so (E^2)^2)
  		self.maxNearField.append(pow(abs(E).max(), 2))
  		
  	#calculate and return the scattering amplitude matrix
  	def calcScatteringAmp(self):

  		#compute the number of entries in the stokes matrix
  		nEntries = len(self.stokesMatrix)
  		
  		#initialize the scattering amplitude matrix to empty
  		self.scatAmpMatrix = []
  		
  		for s in range(0, nEntries):
  			Z = self.stokesMatrix[s]
  			
  			scatEntry = []
  			s11 = complex(sqrt(0.5 * (Z[1] - Z[2] - Z[5] + Z[6])), 0.0)
  			scatEntry.append(s11)
  			scatEntry.append(complex(-0.5 * (Z[3] + Z[7]) / s11, 0.5 * (Z[4] + Z[8]) / s11))
  			scatEntry.append(complex(-0.5 * (Z[9] + Z[10]) / s11, -0.5 * (Z[13] + Z[14]) / s11))
  			scatEntry.append(complex(0.5 * (Z[11] + Z[12]) / s11, -0.5 * (Z[12] - Z[15]) / s11))
  			
  			self.scatAmpMatrix.append(scatEntry)
  			
  		S = self.scatAmpMatrix[0]
  		E = [S[0], S[2]]
  		self.simResults['detector_field'].append(E)
  		print(E)

  	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])
  			if int(self.params['fixed_or_random_orientation']) == 0:
  				result += '\t' + str(self.simResults['extinction_unpolarized'][i])
  				result += '\t' + str(self.simResults['extinction_parallel'][i])
  				result += '\t' + str(self.simResults['extinction_perpendicular'][i])
  			else:
  				result += '\t' + str(self.simResults['extinction_total'][i])
  				
  			#result += '\t' + str(self.simResults['detector_field'][i][0]) + '\t' + str(self.simResults['detector_field'][i][1])
  				
  			
  			
  			#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