From 50b20111ecf9f6da14db3524bb89f06cfef568e7 Mon Sep 17 00:00:00 2001 From: Antony Chan Date: Thu, 17 Aug 2023 09:25:07 -0700 Subject: [PATCH 1/3] Define a thin lens to study infinite conjugate system When a surface as a curvature of `None`, assume an ideal thin lens having a focal length of 50.0 mm. Update the entrance and exit pupil position. Update the ray transfer matrix when the ideal thin lens is encountered. --- opticspy/ray_tracing/first_order_tools.py | 27 +++++++++++++++-------- opticspy/ray_tracing/trace.py | 20 ++++++++++++----- 2 files changed, 32 insertions(+), 15 deletions(-) diff --git a/opticspy/ray_tracing/first_order_tools.py b/opticspy/ray_tracing/first_order_tools.py index 9531111..35c6dda 100644 --- a/opticspy/ray_tracing/first_order_tools.py +++ b/opticspy/ray_tracing/first_order_tools.py @@ -3,6 +3,7 @@ import numpy as __np__ import matplotlib.pyplot as __plt__ +FOCAL_LENGTH = 50.0 def start_end(Lens,start_surface,end_surface): ''' @@ -31,6 +32,9 @@ def R(c,n_left,n_right): ''' return __np__.array([[1,0],[-c*(n_right-n_left),1]]) +def lens(focal_length, n_right): + return __np__.array([[1,0],[-1/focal_length,1/n_right]]) + def ABCD(matrix_list): ''' ABCD matrix calculator @@ -51,23 +55,28 @@ def ABCD_start_end(Lens,start_surface=0,end_surface=0): ''' s = Lens.surface_list start,end = start_end(Lens,start_surface,end_surface) + R_matrix = [] T_matrix = [] RT_matrix = [] - for i in range(start,end+1): - i = i - 1 - # print 'i:',i - # print 'surface_num',s[i].number - c = 1/s[i].radius + for i in range(start - 1,end): # now use central wavelength as reference n_left = s[i-1].indexlist[int(len(s[i-1].indexlist)/2)] n_right = s[i].indexlist[int(len(s[i].indexlist)/2)] - t = s[i].thickness + + if s[i].radius is None: + # Ideal thin lens + RT_matrix.append(lens(FOCAL_LENGTH,n_right)) + assert s[i+1].thickness == FOCAL_LENGTH + continue + + # print 'surface_num',s[i].number + c = 1/s[i].radius R1 = R(c,n_left,n_right) - T1 = T(t,n_right) - # print R1 - # print T1 RT_matrix.append(R1) + + t = s[i].thickness + T1 = T(t,n_right) if i+1 != end: RT_matrix.append(T1) # print '--------------------------------' diff --git a/opticspy/ray_tracing/trace.py b/opticspy/ray_tracing/trace.py index 023138b..f6d1835 100644 --- a/opticspy/ray_tracing/trace.py +++ b/opticspy/ray_tracing/trace.py @@ -3,6 +3,7 @@ import matplotlib.pyplot as __plt__ from . import field,first_order_tools,surface from . import output_tools +from .first_order_tools import FOCAL_LENGTH # Function: trace rays # input a list of ray @@ -231,8 +232,7 @@ def traceray(ray_list, surface1, surface2, wave_num): #print 'Pos',Pos KLM = ray.KLM #print 'KLM:',KLM - c1 = 1 / surface1.radius - c2 = 1 / surface2.radius + c2 = (None if surface2.radius is None else 1 / surface2.radius) n1 = surface1.indexlist[wave_num-1] n2 = surface2.indexlist[wave_num-1] tn1 = surface1.thickness @@ -243,9 +243,17 @@ def traceray(ray_list, surface1, surface2, wave_num): Pos_new = xyz + delta * KLM Pos_new_list.append(Pos_new) # calculate new ray direction - # if curvature == 0, it is a stop, object or image plane - # don't need to calculate the new ray direction - if c2 == 0: + if c2 == None: + # Assume an ideal eye-piece having an effective focal length of 10mm + Kp = KLM[0] - Pos_new[0] / FOCAL_LENGTH + Lp = KLM[1] - Pos_new[1] / FOCAL_LENGTH + Mp = KLM[2] - Pos_new[2] / FOCAL_LENGTH + KLM_new = __np__.asarray([Kp, Lp, Mp]) + #KLM_new = __np__.asarray(KLM) + + elif c2 == 0: + # if curvature == 0, it is a stop, object or image plane + # don't need to calculate the new ray direction KLM_new = KLM else: sigma = __np__.sqrt(n2 ** 2 - n1 ** 2 * (1 - cosI ** 2)) - n1 * cosI @@ -265,7 +273,7 @@ def pos(Pos, KLM, curvature): ''' calculate new position of a ray on spherical surface ''' - c = curvature + c = (0 if curvature is None else curvature) x0 = Pos[0] y0 = Pos[1] z0 = Pos[2] From ba6360e0627af2af6679cba62213fe4446723e45 Mon Sep 17 00:00:00 2001 From: Antony Chan Date: Thu, 17 Aug 2023 09:28:39 -0700 Subject: [PATCH 2/3] Depict thin lens as straight edge in the ray diagram In the ray diagram, whenever the surface curvature is `None`, draw a vertical line instead. --- opticspy/ray_tracing/draw.py | 45 +++++++++++++++++++++++++++--------- 1 file changed, 34 insertions(+), 11 deletions(-) diff --git a/opticspy/ray_tracing/draw.py b/opticspy/ray_tracing/draw.py index 5fcf0bc..60d573a 100644 --- a/opticspy/ray_tracing/draw.py +++ b/opticspy/ray_tracing/draw.py @@ -14,19 +14,33 @@ def draw_surface(r,x0,d1,d2): verts_1 = [] verts_2 = [] codes = [] - for y in np.linspace(0,d1/2,10): - if r > 0: - x = -np.sqrt(r**2-y**2) + r - else: - x = np.sqrt(r**2-y**2) + r - verts_1.append([x+x0,y]) - verts_2.append([x+x0,-y]) + r = (r if r is not None else np.inf) + + # Sample an arc with 10 control points + ymax = (6.0 if np.isnan(d1) else d2) / 2 + y = np.linspace(0, ymax, 10) + + sign = (-1.0 if r > 0 else 1.0) + x = sign * np.sqrt(r**2 - y**2) + r + + # Top half + verts_1 = np.vstack((x + x0, y)).T + + # Bottom half + verts_2 = np.vstack((x + x0, -y)).T + if d1 == d2: - verts = verts_1[::-1] + verts_2[1:] + # If the curved surface meets the lens edge, concat the vertices + verts = np.vstack((verts_1[::-1], verts_2[1:])) elif d1 < d2: - verts = [[verts_1[-1][0],d2/2]] + verts_1[::-1] + verts_2[1:] + [[verts_2[-1][0],-d2/2]] + # If the dome is smaller than the lens edge, add straight edges + verts = np.vstack(([verts_1[-1][0],d2/2], verts_1[::-1], verts_2[1:], [verts_2[-1][0],-d2/2])) + else: + print(f'Warning: ray position larger than lens diameter: d1: {d1:1.3g}, d2: {d2:1.3g}') + verts = np.vstack((verts_1[::-1], verts_2[1:])) + codes.append(Path.MOVETO) - for j in range(len(verts)-1): + for j in range(verts.shape[0] - 1): codes.append(Path.LINETO) return verts,codes,[verts[0],verts[-1]] @@ -117,6 +131,13 @@ def draw_system(Lens): patch = patches.PathPatch(path, facecolor='none', lw=1) ax.add_patch(patch) + # Also plot the control points + def draw_control_points(path): + x, y = zip(*path.vertices) + ax.plot(x, y, 'g+-') + + #draw_control_points(path) + # start drawing edge if num == 0: pass @@ -146,8 +167,10 @@ def draw_system(Lens): ax.set_xlim(-0.5*sum(thinkness_list[1:-1]),1.1*sum(thinkness_list[1:-1])) d = max(draw_diameter_list) ax.set_ylim(-d/4*3,d/4*3) + ax.set_ylim(-1, 1) plt.axis('equal') - plt.show() + plt.xlabel('x / mm') + plt.ylabel('y / mm') def draw_rays(Lens): From ff291af348fe4d82a110d5514e0172a13041a555 Mon Sep 17 00:00:00 2001 From: Antony Chan Date: Thu, 17 Aug 2023 09:45:07 -0700 Subject: [PATCH 3/3] Add finite conjugate optics analysis example --- finite_conjugate_optics_analysis1.ipynb | 221 ++++++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 finite_conjugate_optics_analysis1.ipynb diff --git a/finite_conjugate_optics_analysis1.ipynb b/finite_conjugate_optics_analysis1.ipynb new file mode 100644 index 0000000..f63e204 --- /dev/null +++ b/finite_conjugate_optics_analysis1.ipynb @@ -0,0 +1,221 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from opticspy.ray_tracing import lens, trace, draw, analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Objective lens, 0.2 NA, 4X, finite conjugate\n", + "Mock up of Patent US10754140B2\n" + ] + } + ], + "source": [ + "New_Lens = lens.Lens(lens_name='Objective lens, 0.2 NA, 4X, finite conjugate',creator='Mock up of Patent US10754140B2')\n", + "New_Lens.FNO = 5\n", + "New_Lens.lens_info()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add wavelength 656.3nm done\n", + "Add wavelength 587.6nm done\n", + "Add wavelength 486.1nm done\n" + ] + } + ], + "source": [ + "New_Lens.add_wavelength(wl = 656.30)\n", + "New_Lens.add_wavelength(wl = 587.60)\n", + "New_Lens.add_wavelength(wl = 486.10)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add field angle:0 degree done\n", + "Add field angle:2 degree done\n", + "Add field angle:4 degree done\n" + ] + } + ], + "source": [ + "New_Lens.add_field_YAN(angle=0)\n", + "New_Lens.add_field_YAN(angle=2)\n", + "New_Lens.add_field_YAN(angle=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add surface: 1\n", + "Add surface: 2\n", + "Add surface: 3\n", + "Add surface: 4\n", + "Add surface: 5\n", + "Add surface: 6\n", + "Add surface: 7\n", + "Add surface: 8\n", + "Add surface: 9\n", + "Add surface: 10\n", + "Add surface: 11\n", + "Add surface: 12\n", + "Add surface: 13\n" + ] + } + ], + "source": [ + "from opticspy.ray_tracing.first_order_tools import FOCAL_LENGTH\n", + "\n", + "# Imitate proprietary polymers with glass materials\n", + "APL = 'L-BSL7_ohara' #1.722\n", + "EP5000 = 'F2_schott' #1.634\n", + "#COC = 'glass|soda-lime-clear' #1.54\n", + "\n", + "# Eye-piece\n", + "i = 0\n", + "#i+=1;New_Lens.add_surface(number=i,radius=10000000,thickness=10.0,glass='air')\n", + "#i+=1;New_Lens.add_surface(number=i,radius=None,thickness=0,glass='air')\n", + "\n", + "# Image plane\n", + "i+=1;New_Lens.add_surface(number=i,radius=10000000,thickness=33.19 + FOCAL_LENGTH,glass='air')\n", + "\n", + "# Emission filter\n", + "i+=1;New_Lens.add_surface(number=i,radius=10000000,thickness=1.0 ,glass='Malitson_SiO2')\n", + "i+=1;New_Lens.add_surface(number=i,radius=10000000,thickness=0.3 ,glass='air')\n", + "\n", + "# APL\n", + "i+=1;New_Lens.add_surface(number=i,radius=3.81,thickness=1.286 ,glass=APL)\n", + "i+=1;New_Lens.add_surface(number=i,radius=-41.8,thickness=1.346,glass='air')\n", + "\n", + "# EP5000\n", + "i+=1;New_Lens.add_surface(number=i,radius=-3.6,thickness=0.893,glass=EP5000)\n", + "i+=1;New_Lens.add_surface(number=i,radius=27.75 ,thickness=1.420, glass='air')\n", + "\n", + "i+=1;New_Lens.add_surface(number=i,radius=10000000,thickness=0,glass='air', STO=True)\n", + "\n", + "# APL\n", + "i+=1;New_Lens.add_surface(number=i,radius=18.0,thickness=1.339,glass=APL)\n", + "i+=1;New_Lens.add_surface(number=i,radius=-11.96,thickness=0.106,glass='air')\n", + "\n", + "i+=1;New_Lens.add_surface(number=i,radius=4.37,thickness=1.719,glass=APL)\n", + "i+=1;New_Lens.add_surface(number=i,radius=3.26,thickness=4.982,glass='air')\n", + "\n", + "# 96-well bottom: OCO\n", + "#i+=1;New_Lens.add_surface(number=i,radius=100000000,thickness=0.19,glass=COC)\n", + "i+=1;New_Lens.add_surface(number=i,radius=100000000,thickness=0,glass='air')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------Calculating EFL---------------\n", + "start surface: 2\n", + "end surface: 12\n", + "Rear Focal Length f': 17.393337093560046\n", + "---------Calculating Entrance Pupil Position-----------\n", + "STOP Surface 8\n", + "STOP thickness 1.42\n", + "start surface: 2\n", + "end surface: 7\n", + "entrance pupil position EP: 8.573697446544195\n", + "------------Calculating OAL---------------\n", + "start surface: 2\n", + "end surface: 13\n", + "Overall length: 14.390999999999998\n", + "------------Calculating image position---------------\n", + "object distance -1000000\n", + "start surface: 2\n", + "end surface: 12\n", + "image position: 8.179929137180476\n", + "------------------start drawing lens system-------------\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "New_Lens.refresh_paraxial()\n", + "New_Lens.solve_imageposition()\n", + "trace.trace_draw_ray(New_Lens)\n", + "draw.draw_system(New_Lens)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "opticspy", + "language": "python", + "name": "opticspy" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}