optics / mstm-gui

  class ParameterClass:
      #minimum and maximum wavelengths for the simulation
      minLambda = 0.300
      maxLambda = 0.700

      snapshotLambda = 0.300

      #number of spectral samples
      nSamples = 40
      

      #spatial samples
      nSteps = 100
      
      #sphere size and separation
      a = 0.025
      d = 0.005
      

      #material file name
      matFilename = 'etaSilver.txt'
      #are the sphere's in water?
      inWater = False

      
      #show console output from the MS-TM FORTRAN program
      showOutput = False

  
      paramDict = {}
      sphereList = []
  
      sphereParamNames = ['radius', 'X', 'Y', 'Z', 'n', 'k', 'Xr', 'Xi']
  
      def __init__(self, fileName):
          self.loadFile(fileName)
  
      def __getitem__(self, key):
          return self.paramDict[key];
  
      def __setitem__(self, key, value):

          self.paramDict[key] = value;

  
      def clearSpheres(self):
          self.sphereList = []
  
      def addSphere(self, a, x, y, z, n = 1.0, k=1.0):
          s = [a, x, y, z, n, k]
          self.sphereList.append(s)
  
      def loadFile(self, fileName):
          inpFID = open(fileName, 'r')
          selfparamDict = {}
  
          while 1:
              key = inpFID.readline().strip()

              #deal with sphere sizes and positions
              if key == 'sphere_sizes_and_positions':
                  
                  while True:
                      #load the parameters for a sphere
                      value = inpFID.readline().strip()
                      if value == 'end_of_options':
                          break
                      
                      self.sphereList.append(value.split(' '))           
                      
  
              elif not key:
                  break
              elif key == 'end_of_options':
                  break

              #deal with the near field plane
              elif key == 'near_field_plane_vertices':
                  value = inpFID.readline().strip()
                  #self.paramDict[key] = list(map(float, value.split(',')))
                  self.paramDict[key] = [-1, -1, 1, 1]
              

              else:                
                  value = inpFID.readline().strip()
                  self.paramDict[key] = value

                  
          #update the length scale factor to deal with the UI
          self.paramDict['length_scale_factor'] = (2.0 * 3.14159)/self.snapshotLambda

  
          inpFID.close()
  

      def saveFile(self, l, fileName):
          
          #print(self)

  
          #open the output file
          outFID = open(fileName, 'w')
  
          #write the parameters
          for key in self.paramDict.keys():
              outFID.write(key + '\n')

              
              #deal with the near field plane
              if key == 'near_field_plane_vertices':
                  #these have to be scaled by the length scale factor
                  ls = (2 * 3.14159)/l
                  v = self.paramDict[key]
                  outFID.write(str(v[0]*ls) + ',' + str(v[1]*ls) + ',' + str(v[2]*ls) + ',' + str(v[3]*ls) + '\n')
              elif key == 'spacial_step_size':
                  ls = (2 * 3.14159)/l
                  dx = self.paramDict[key] * ls
                  outFID.write(str(dx) + '\n')
                  
              else:
                  outFID.write(str(self.paramDict[key]) + '\n')

  
          #write the spheres
          outFID.write("sphere_sizes_and_positions\n")
          for s in self.sphereList:
              for p in s:
                  outFID.write(str(p) + ' ')
              outFID.write('\n')
          outFID.write("end_of_options")
          
  
      def __str__(self):
          #print(self.paramDict)
          result = ""
          for key in self.paramDict.keys():

              #deal with the near field plane
              if key == 'near_field_plane_vertices':
                  v = map(str, self.paramDict[key])                
                  result += key + ": " + v[0] + ',' + v[1] + ',' + v[2] + ',' + v[3] + '\n'
              else:
                  result += key + ": " + str(self.paramDict[key]) + '\n'

  
          result += "\n"
          result += "Spheres:\n"
          #iterate through each sphere
          for s in self.sphereList:
              result += "------------------\n"
              for i in range(len(s)):
                  result += self.sphereParamNames[i] + ": " + str(s[i]) + '\n'
  
          return result