def addSourceParaxialBeam(self,
pg,
height,
sourceplane,
nrays=10,
wave=getDefaultWavelength(),
intensity=1.0):
"""
Add a ray paraxial ray pencil from a rounce to input of a paraxial group
"""
if isinstance(sourceplane, ParaxialPlane):
z = sourceplane.inputPlane()
else:
z = float(sourceplane)
dist = pg.inputPlane() - z
radius = pg.maxRadius()
yscan = linspace(-radius, radius, 2 * nrays + 1)
for y in yscan:
u = (y - height) / dist # Calcualte angle using paraxial approx
ray = ParaxialRay(height, u, z, wave, intensity)
self.append(ray)
return self
def __init__(self, intensity=1.0, wavelength=getDefaultWavelength()):
"""
Right circular polarsied beam
"""
amp = math.sqrt(intensity / 2.0)
JonesVector.__init__(self, amp, complex(0.0, -amp), wavelength)
def subPlot(self):
global CurrentWaveFront
wa = WaveFrontAnalysis(getCurrentLens(), getDesignWavelength())
CurrentWaveFront = wa.fitZernike(getCurrentAngle(),getDefaultWavelength(),ZernikeOrder,\
getReferencePointOption())
self.interferometer.setWaveFront(CurrentWaveFront)
self.displayPlot()
def zernikeButtonClicked(self):
m = MessageBox("Zernike Expansion w: {0:4.2f}".format(
getDefaultWavelength()),
repr(CurrentWaveFront),
parent=self)
m.setWindowTitle("Information")
m.show()
def getSystemImage(self, lens, mag, nrays=5, wavelength=None, design=None):
"""
Method to get the image of the object plane from and imaging system with specified lens and magnification.
The location of the object and image planes are given by paraxial optics using the design wavelength.
:param lens: the imaging lens
:type lens: OpticalGroup or Lens
:param mag: The magnification between object and image (normally negative for imaginig system)
:type mag: float
:param nrays: number or rays across radius in simulation. (Default = 5)
:type nrays: int
:param wave: wavelength of rays in simulation (Default = optics.wavelength.Default)
:type wave: float
:param design: wavelength used for the paraxial location of the planes (Default = None) (same as wave)
"""
design = getDefaultWavelength(design)
# Get location of object and image planes and design wavelength
obj, ima = lens.planePair(mag, self.xsize, self.ysize, design)
self.setPoint(obj.point) # Set self to correct location
im = self.getImage(lens, ima, nrays, wavelength) # get the image
return im
def addCollimatedParaxialBeam(self,
ca,
u,
nrays=10,
wave=getDefaultWavelength(),
intensity=1.0):
"""
Method to add a collimated paraxial beam
param ca aperture to fill
param u direction of rays
param nrays, number or rays aross radius, (default = 10)
param wave, the wavelength, (default = Default)
param intensity, the ray intensity, (default = 1.0)
param path, record path length
"""
if hasattr(ca, "maxRadius"):
if isinstance(ca.maxRadius, float):
radius = ca.maxRadius
else:
radius = ca.maxRadius()
else:
radius = 10.0
pt = ca.getPoint().z
yscan = linspace(-radius, radius, 2 * nrays + 1)
for y in yscan:
dist = radius + y * u
ray = ParaxialRay(y, u, pt, wave, intensity)
ray.propagate(-dist)
self.append(ray)
return self
def getIntensity(self, wavelength=None):
"""
Get the intensity as specified wavelength
:param wavelength: the wavelengh, (default to current default)
:type wavelength: float or None
"""
wavelength = getDefaultWavelength(wavelength)
return self.spectrum.getValue(wavelength)
def __init__(self, x=1.0, y=0.0, wavelength=getDefaultWavelength()):
"""
Constructor to create a JonesVector
"""
if isinstance(x, JonesVector):
self.__init__(x.x, x.y, x.wavelength)
else:
Ray.__init__(self, wavelength) # Set underlying wavelength
self.x = complex(x)
self.y = complex(y)
def __init__(self,
theta=0.0,
intensity=1.0,
wavelength=getDefaultWavelength()):
"""
Linear polarised beam
"""
amp = math.sqrt(intensity)
theta = parseAngle(theta)
JonesVector.__init__(self, amp * math.cos(theta),
amp * math.sin(theta), wavelength)
def setWavelength(self, wave=getDefaultWavelength()):
"""
Set the wavelength
"""
if isinstance(wave, JonesVector):
self.wavelength = wave.wavelength
else:
self.wavelength = float(wave)
self.phase = 2 * math.pi * (self.order +
self.delta) * self.design / self.wavelength
self.setAngle(self.angle)
def __init__(self, wavelength=None, intensity=1.0, index=None):
"""
Constuctor with two optional arguments
"""
self.wavelength = getDefaultWavelength(wavelength)
if isinstance(intensity, Spectrum):
self.intensity = intensity.getValue(self.wavelength)
else:
self.intensity = float(intensity)
self.refractiveindex = index
self.monitor = None # Hook for ray monitor
def main():
# Get lens and other info
lens = DataBaseLens()
angle = math.radians(getFloat("Angle in degrees"))
wave = getFloat("Wavelength of plot",getDefaultWavelength())
wa = WaveFrontAnalysis(lens)
wa.drawAberrationPlot(angle,wavelength=wave,legend = "lower left")
plt.show()
def __init__(self, lens, wavelength=None):
self.lens = lens
self.wavelength = getDefaultWavelength(wavelength)
self.op = lens.backFocalPlane()
self.angle = 0.0 # Control variables
self.delta = math.radians(1.0)
self.anglerange = math.radians(10)
# Set up plot and axis
self.fig = plt.figure()
self.ax = plt.axes()
self.ax.axis("equal")
self.ln, = self.ax.plot([], [])
def __init__(self,pt = Vector2d() ,pathlength = 0.0 , wavelength = None):
"""
Basic constructor for a wavepoint
:param pt: point in the plane
:type pt: Vector2d
:param pathlength : the pathlength (default = 0.0)
:type pathlength : float
:param wavelength : the wavelength (default = wavelength.Default)
:type wavelength :float
"""
self.set(pt)
self.pathlength = pathlength
self.wavelength = getDefaultWavelength(wavelength)
def __init__(self,
delta=0.5,
order=0,
theta=0.0,
design=getDesignWavelength(),
transmission=1.0):
"""
"""
self.delta = float(delta)
self.order = int(order)
self.design = float(design)
self.transmission = float(transmission)
self.angle = parseAngle(theta)
self.setWavelength(getDefaultWavelength())
def __init__(self,radius = 0.0, *args):
"""
Set max radius and append any WavPoints given.
:param radius: Radius distribution in plane, (default = 0.0)
This is auto-expanded as WavePoints are added if needed.
:type radius: float
:param \*args: WavePoint to be added on creation.
"""
list.__init__(self)
self.maxRadius = radius
self.wavelength = getDefaultWavelength()
for wp in args:
self.add(wp)
def __init__(self,
pos=0.0,
intensity=1.0,
major=1.0,
minor=None,
alpha=0.0,
wavelength=None):
"""
Constructor
"""
if isinstance(pos, float):
Vector3d.__init__(self, [0.0, 0.0, pos])
else:
Vector3d.__init__(self, pos)
self.intensity = 1.0
self.major = major
if minor == None:
self.minor = self.major
else:
self.minor = minor
self.alpha = alpha
self.wavelength = getDefaultWavelength(wavelength)
def main():
# Get lens from database
lens = DataBaseLens()
# Get angle of beam and wavelnegth
angle = getFloat("Angle in degrees", 0.0, 0.0, 15.0)
u = Unit3d(Angle().setDegrees(angle)) # Angle as unit vectr
wave = getFloat("Wavelength", getDefaultWavelength())
# Get optimal area psf and create a SpotDiagram
sd = SpotAnalysis(lens, u, 0, wavelength=wave)
# Go round loop plotting the sopt diagram as various zplane positions
while True:
zp = getFloat("Delta", 0.0)
sd.draw(zp, True)
pos = sd.plane.getPoint().z
print("Plane pos " + str(pos))
plt.title("Spot diagram")
plt.show(block=True)
def __init__(self,
lens,
source=0.0,
refopt=0,
wavelength=None,
design=None):
"""
The constrcutor
"""
# Sort out source
if isinstance(source, ray.SourcePoint): # From a sourcepoint
self.source = source
elif isinstance(source, float):
self.source = Unit3d(Angle(source)) # Infinite Object
else:
self.source = Unit3d(source)
wave = getDefaultWavelength(wavelength)
design = getDesignWavelength(design)
# Make raypencil (this is used in draw())
self.raypencil = ray.RayPencil().addBeam(lens,
source,
"array",
wavelength=wave)
self.raypencil *= lens # Propagate through lens
self.pt = lens.imagePoint(source, design)
if refopt == 1:
self.pt = Psf().setWithRays(
self.raypencil, self.pt.z) # Centre of PSF in image plane
if refopt == 2:
self.pt = Psf().optimalArea(
self.raypencil,
self.pt.z) # Optimal area PSF, not in image plane
def getRayPencil(self, ca, i, j, nrays=5, wavelength=None):
"""
Method to get a RayPencil from the i,j image pixel.
:param ca: circular apereture (or lens) to fill
:param i: the x the pixel coordinates.
:type i: int
:param j: the y pixel coordinate
:type j: int
:param nrays: number of ray across radius (default = 5)
:type nray: int
:param wave: wavelength of rays (default = Default)
:type wave: float
:return: RayPencil with an added Beam.
Note will return None if the pixel intensity is 0.0
"""
wavelength = getDefaultWavelength(wavelength)
source = self.getPixelSourcePoint(i, j)
if source.getIntensity() == 0.0:
return None
else:
return ray.RayPencil().addBeam(ca, source, "array", nrays,
wavelength)
def drawAberrationPlot(self,angle,wavelength = None ,colour=["r","g","b"],legend = "lower left"):
"""
Form and draw the plots at specified angle
:param angle: the ray angle
:type angle: float or Angle or Unit3d
:param colour: line colours is three elemnts list, Default = ["r","g","b"])
:param legend: location of ledgend, (Default = "lower left")
:type legend: str
"""
if isinstance(angle,float):
u = Unit3d(Angle(angle)) # direction of beam
else:
u = Unit3d(angle)
angle = Angle(u).theta
wavelength = getDefaultWavelength(wavelength)
ref = self.lens.imagePoint(u,self.design) # Get image point at design wavelength
ip = OpticalPlane(ref) # Image plane
nrays = 50
ca = self.lens.entranceAperture()
# Make list for plots
mvals = [] # Meridional
svalsx = [] # Sagittal x
svalsy = [] # Sagittal y
# Start of loop to make rays
rscan = np.linspace(-ca.maxRadius,ca.maxRadius,nrays + 1)
for r in rscan:
# Make two rays
mray = IntensityRay(ca.point + Vector3d(0.0, r, 0.0), u, wavelength)
sray = IntensityRay(ca.point + Vector3d(r, 0.0, 0.0), u, wavelength)
# Add to pencil and propagate both back to clear lens
pencil = RayPencil(mray,sray).propagate(-ca.maxRadius)
# propagate through lens to image surafce
pencil *= self.lens
pencil *= ip
# If rays valid (so not blocked), abberations to list
if mray:
mpos = mray.position - ref
mvals.append(mpos.y)
else:
mvals.append(float("nan"))
if sray:
spos = sray.position - ref
svalsx.append(spos.x)
svalsy.append(spos.y)
else:
svalsx.append(float("nan"))
svalsy.append(float("nan"))
# plots with suitable labels to the current axis.
plt.plot(rscan,mvals, color = colour[0], label="Meridional")
plt.plot(rscan,svalsx,color = colour[1], label="Sagittal x")
plt.plot(rscan,svalsy,color = colour[2], label="Sagittal y")
plt.title("{0:s}: a: {1:4.2f} w: {2:4.2f} d: {3:4.2f}".\
format(self.lens.title,math.degrees(angle),wavelength,\
self.design))
plt.legend(loc=legend,fontsize="small")
plt.grid()
def __init__(self, wavelength=None):
"""
Create a defaut monitor that just hold wavelnegth
"""
self.wavelength = getDefaultWavelength(wavelength)
def resetButtonClicked(self): # Reset both wavelengths to Green
c = getDefaultWavelength()
self.currentSpin.setValue(c)
self.designSpin.setValue(c)
setCurrentWavelength(c)
setDesignWavelength(c)
def setWavelength(self, wave=getDefaultWavelength()):
"""
Set the wavelength for all components
"""
for m in self:
m.setWavelength(wave)
