#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