def optimiselens(beam, n): """Find the best two lens curvatures to produce the minimum rms value, with n = number of curvature increments between -1 and 1, and beam = input beam""" rms = [] outputplane = rt.OutputPlane(200) for i in np.linspace(-1.0, 1.0, n): for x in np.linspace(-1.0, 1.0, n): lens1 = rt.SphericalRefraction(100.0, i, 1.0, 1.5168, 29.74944) lens2 = rt.SphericalRefraction(105.0, x, 1.5168, 1.0, 29.74944) beam.trace2(lens1, lens2, outputplane) rms.append([i, x, beam.rms(outputplane)]) m = MinList(rms, [0, 0, 100]) print "lens 1 curvature = %s, lens 2 curvature = %s, rms = %s" % ( m[0], m[1], m[1])
def propagateray(ray, lens_type, lens_curvature, lens_2nd_curvature = 0, word = "Yes"): """ This function propagates the ray towards the lens. The RMS deviation at the focal point and the new ray object is returned. """ if lens_type == 0: lens = rt.SphericalRefraction(lens_z0, lens_aperture, lens_curvature, surrounding_refractive_index, lens_refractive_index, word) elif lens_type == 1: lens = rt.PlanoConvex(lens_z0, lens_depth, lens_curvature, surrounding_refractive_index, lens_refractive_index, word) elif lens_type == 2: lens = rt.BiSurface(lens_z0, lens_aperture, lens_depth, lens_curvature, lens_2nd_curvature, surrounding_refractive_index, lens_refractive_index, word) temp = ray.propagate(lens) if temp is None: return -1, -1 if focal_method == 0: focal_position = ray.focalpoint_std() elif focal_method == 1: focal_position = ray.focalpoint_maxlength() if focal_position is None: output = rt.OutputPlane((lens_z0+lens_depth)*2.5) print "No focal point outside of the lens" else: output = rt.OutputPlane(focal_position[-1]) temp = ray.propagate(output) if temp is None: return -1, -1 rms = ray.rms_deviation("output") return rms, ray
def Lens_trial(c,z0,z1,rmax,z0_out): """ This method produces a function that returns an rms value. The rms value will be minimised using an numerical optimisation function. c is a list with the curvatures of the two refractive surface elements. z0 is the intecept of the first spherical refraction surface with the z axis while z1 is the intercept for the second surface. rmax is the beam radius. z0_out is the position of the output plane. """ test_rays = Bundle.bundle(n=5 , rmax=5 , m=4, initial_z = 0, direction = [0,0,1]) Surface1 = rt.SphericalRefraction(100,c[0],1,1.5168,50) Surface2 = rt.SphericalRefraction(155,c[1],1.5168,1,50) Output = rt.OutputPlane(z0_out) for ray in test_rays: Surface1.propagate_ray(ray) Surface2.propagate_ray(ray) Output.propagate_ray(ray) rms = root_mean_square(test_rays) return rms
def append(self): """ Takes each set of spherical refraction surface element parameters and creates a list of the corresponding surface elements """ para = self.__para list_of_elements = [] for i in para: ith_element = rt.SphericalRefraction(i[0],i[1],i[2],i[3],i[4]) list_of_elements.append(ith_element) return list_of_elements
def __init__(self, z, curve, n1, n2, aperture, separation): type = "convex-plano lens" self.z = z self.curve = curve self.n1 = n1 self.n2 = n2 self.aperture = aperture self.separation = separation self.left = rt.SphericalRefraction(z_0=z, curve=curve, n1=n1, n2=n2, aperture=aperture) self.right = rt.SphericalRefraction(z_0=z + separation, curve=-curve, n1=n2, n2=n1, aperture=aperture) rt.OpticalElement.__init__(self, type, n1, n2, curve)
def work(n, rmax, m): q=0 u=0 for ray in bundlerays(n, rmax, m): sphere = raytracer.SphericalRefraction(2.,0.03,1.,1.5,20.) H=raytracer.OutputPlane(150) sphere.propagate(ray) H.propagate(ray) k = ray.vertices() tmp = zip(*k) pyl.plot(tmp[2],tmp[0]) #pyl.plot(tmp[1][-1],tmp[0][-1],'bo') #pyl.plot(tmp[1][0],tmp[0][0],'ro') q += tmp[0][-1]**2 + tmp[1][-1]**2 u +=1
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Fri Dec 16 01:01:42 2016 @author: barnabysandeford """ import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import raytracer as rt reload(rt) s = rt.SphericalRefraction(100, 0.03, 1.0, 1.5, (1 / 0.03)) # Finding the paraxial focal point of the spherical optical element F = rt.focal_point1(s) # The output plane is automatically placed at the paraxial focal point of "s". p = rt.OutputPlane(F, 10000) def zx_plot(n, rmax, m): """Creates a z-x plot of a bundle of rays propogated through "s". Parameters ---------- n: integer_type The number of concentric circles of rays within the distribution. rmax: float_type The maximum radius of the distribution of rays. m: integer_type The rate at which the number of rays per concentric circle
"""Module to implement the raytracer model and propagate a bundle of rays through different refractive media.""" import matplotlib.pyplot as plt import raytracer as rt import genpolar as gp import numpy as np #Lens definitions for first and second orientations respectively SR1 = rt.SphericalRefraction(100.0, 0ol0o, 1.0, 1.5168, 10.0) #plane surface first SR2 = rt.SphericalRefraction(105.0, -0.02, 1.5168, 1.0, 10.0) #negative curvature SR3 = rt.SphericalRefraction(100.0, 0.02, 1.0, 1.5168, 10.0) #positive curvature SR4 = rt.SphericalRefraction(105.0, 0, 1.5168, 1.0, 10.0) #plane surface second def findzintercept(lens1,lens2): """Finds intersection point of ray with z-axis""" TR = rt.Ray([0.1,0.1,80],[0.0,0.0,1.0]) #test ray close to z-axis lens1.propagate_ray(TR) lens2.propagate_ray(TR) ratio = -(TR._p[0])/(TR._k[0]) intercept = TR._p + (ratio*TR._k) return intercept def findrms(raylist): """Finds rms value of a bundle of rays""" sum = 0
Author: Cara Created: 30/10/19 10:52 A test for a concave spherical refracting surface. """ import raytracer as rt from raybundle import Bundle import matplotlib.pyplot as plt import scipy as sp from mpl_toolkits import mplot3d # create a spherical surface and an output plane at the paraxial focus surface = rt.SphericalRefraction(z_0=100, curve=-0.03, n1=1.0, n2=1.5, aperture=30.) # a concave lens only has an imaginary focus behind it output = rt.OutputPlane(z_1=250) # creates a collimated beam with (radius, line density around outer circumference) beam = Bundle(2, 3) fig = plt.figure() ax = plt.axes() """ origins = beam.con_circs() # get points of rays into individual arrays and plot them for o in origins:
""" Modelling a planoconvex singlet lens. """ import numpy as np import matplotlib.pyplot as plt import raytracer as rt # Defining the planoconvex lens with the curved surface first, with a # refractive index of 1.5168. convex = rt.SphericalRefraction(100, 0.02, 1.0, 1.5168, 21.8 ) plane1 = rt.SphericalRefraction(105, 0, 1.5168, 1.0, 21.8) # Defining the planoconvex lens with the curved surface last. concave = rt.SphericalRefraction(105, -0.02, 1.5168, 1.0, 21.8 ) plane2 = rt.SphericalRefraction(100, 0, 1.0, 1.5168, 21.8) # Defining the wavelength of the incident rays. L = (588*10**(-9)) def zxPlot(n, rmax, m , lens1, lens2): """ Creates a plot in the z-x plane of a bundle of rays through two optical elements. The optical elements can be chosen such that they form planoconvex lenses. Parameters ---------- n: integer_type The number of concentric circles of rays within the distribution. rmax: float_type The maximum radius of the distribution of rays. m: integer_type The rate at which the number of rays per concentric circle
import raytracer s = raytracer.SphericalRefraction(z_0=1, curve=0.25, n1=1, n2=0.8, aperture=3) r = raytracer.Ray(pos=[1., 2., 3.], direc=[1., 2., 3.]) print(s.intercept(r)) s2 = raytracer.SphericalRefraction(z_0=0, curve=0.8, n1=1, n2=0.8, aperture=10) r2 = raytracer.Ray(pos=[4., 5., 6.], direc=[1., 2., 3.]) print(s2.intercept(r2)) # imag result, filtered as expected s3 = raytracer.SphericalRefraction(z_0=1, curve=0.4, n1=1, n2=0.8, aperture=5) r3 = raytracer.Ray(pos=[7., 8., 9.], direc=[4., 0., 1.]) print(s3.intercept(r3)) # imag result, filtered as expected # Would be much easier to see these intercepts are in the right place once plotting multiple rays