def main():
"Main code for demo purposes"
logging.basicConfig(level=logging.DEBUG)
mysys = OpticalSystem(name="s")
mysys.lst = []
mysys.lst.append({})
mysys.lst.append({})
mysys.lst[0]["a"] = FloatOptimizableVariable(FixedState(3.0),
name="v1")
mysys.lst[1]["b"] = FloatOptimizableVariable(VariableState(7.0),
name="v2")
mysys.rootcoordinatesystem.decz = FloatOptimizableVariable(
FixedState(-99.0), name="decz")
listOptimizableVariables(mysys)
confmanager = ConfigManager(mysys, name="mc")
[mysys2, mysys3] = confmanager.set_optimizable_variables(
("s2", "s3"), {
"s.global.decz":
(("pickup", lambda x: x + 2.0), ("pickup", lambda x: x + 3.0)),
"s.global.decy": (("fixed", -2.), ("fixed", -3.))
})
mysys.rootcoordinatesystem.decx.setvalue(-98.0)
for syscopy in (mysys2, mysys3):
mydict = listOptimizableVariables(syscopy)
print(mydict)
def updatefunction_allsteps(my_s):
"""
Update coordinate systems of optical system.
"""
my_s.rootcoordinatesystem.update()
# optimize
s.elements["stdelem"].surfaces["lens4front"].shape.curvature.to_variable()
s.elements["stdelem"].surfaces["lens4rear"].shape.curvature.to_variable()
s.elements["stdelem"].surfaces["lens4rear"].shape.curvature.\
to_pickup((FunctionObject("f = lambda x: -x"), "f"),
(s.elements["stdelem"].surfaces["lens4front"].shape.curvature,))
listOptimizableVariables(s, max_line_width=80)
optimi = Optimizer(s, meritfunction_step2, backend=ScipyBackend(),
updatefunction=updatefunction_allsteps, name="step2")
optimi.meritparameters["initialbundle"] = initialbundle_step1
s = optimi.run()
# draw system with last lens biconvex
s.draw2d(axarr[1], color="grey", vertices=50, plane_normal=pn, up=up)
r2 = s.seqtrace(bundle_step1(nrays=9), seq) # trace again
for r in r2:
r.draw2d(axarr[1], color="blue", plane_normal=pn, up=up)
# Step 3: colour, field, more variables
########################################
curv2.to_variable()
curv2.set_interval(left=-0.35, right=0.35)
curv3 = s.elements["lenssys"].surfaces["surf3"].shape.curvature
curv3.to_variable()
curv3.set_interval(left=-0.35, right=0.35)
curv4 = s.elements["lenssys"].surfaces["surf4"].shape.curvature
curv4.to_variable()
curv4.set_interval(left=-0.35, right=0.35)
curv6 = s.elements["lenssys"].surfaces["surf6"].shape.curvature
curv6.to_variable()
curv6.set_interval(left=-0.35, right=0.35)
tltx_var = s.elements["lenssys"].surfaces["surf3"].rootcoordinatesystem.tiltx
tltx_var.to_variable()
tltx_var.set_interval(left=-3. * math.pi / 180., right=3. * math.pi / 180.)
listOptimizableVariables(s, filter_status='variable', max_line_width=80)
def osnone(my_s):
"""
Do nothing
"""
pass
def osupdate(my_s):
"""
Update all coordinate systems during run
"""
my_s.rootcoordinatesystem.update()
return variable
'''
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
s = OpticalSystem(name="s")
s.lst = []
s.lst.append({})
s.lst.append({})
s.lst[0]["a"] = FloatOptimizableVariable(FixedState(3.0), name="v1")
s.lst[1]["b"] = FloatOptimizableVariable(VariableState(7.0), name="v2")
s.rootcoordinatesystem.decz = FloatOptimizableVariable(FixedState(-99.0),
name="decz")
listOptimizableVariables(s)
m = ConfigManager(s, name="mc")
[s2, s3] = m.setOptimizableVariables(
("s2", "s3"), {
"s.global.decz":
(("pickup", lambda x: x + 2.0), ("pickup", lambda x: x + 3.0)),
"s.global.decy": (("fixed", -2.), ("fixed", -3.))
})
s.rootcoordinatesystem.decx.setvalue(-98.0)
for ss in (s2, s3):
mydict = listOptimizableVariables(ss)
# TODO: OptimizableVariable() documentation does not explain what an OptimizableVariable is and makes it cumbersome to use
return merit
def updatefunction_allsteps(s):
s.rootcoordinatesystem.update()
# optimize
s.elements["stdelem"].surfaces["lens4front"].shape.curvature.changetype(
"variable")
s.elements["stdelem"].surfaces["lens4rear"].shape.curvature.changetype(
"variable")
listOptimizableVariables(s, maxcol=80)
optimi = Optimizer(s,
meritfunction_step2,
backend=ScipyBackend(),
updatefunction=updatefunction_allsteps,
name="step2")
# TODO: Optimizer() is not well documented
s = optimi.run()
# draw system with last lens biconvex
s.draw2d(axarr[1], color="grey", vertices=50, plane_normal=pn,
up=up) # try for phi=0.
r2 = s.seqtrace(bundle_step1(nrays=9), seq) # trace again
for r in r2:
r.draw2d(axarr[1], color="blue", plane_normal=pn, up=up)
curv2.changetype("variable")
curv2.set_interval(-0.35, 0.35)
curv3 = s.elements["lenssys"].surfaces["surf3"].shape.curvature
curv3.changetype("variable")
curv3.set_interval(-0.35, 0.35)
curv4 = s.elements["lenssys"].surfaces["surf4"].shape.curvature
curv4.changetype("variable")
curv4.set_interval(-0.35, 0.35)
curv6 = s.elements["lenssys"].surfaces["surf6"].shape.curvature
curv6.changetype("variable")
curv6.set_interval(-0.35, 0.35)
tltx_var = s.elements["lenssys"].surfaces["surf3"].rootcoordinatesystem.tiltx
tltx_var.changetype("variable")
tltx_var.set_interval(-3.*math.pi/180., 3.*math.pi/180.)
listOptimizableVariables(s, filter_status='variable', max_line_width=80)
def osnone(my_s):
"""
Do nothing
"""
pass
def osupdate(my_s):
"""
Update all coordinate systems during run
"""
my_s.rootcoordinatesystem.update()
curv2.changetype("variable")
curv2.set_interval(-0.35, 0.35)
curv3 = s.elements["lenssys"].surfaces["surf3"].shape.curvature
curv3.changetype("variable")
curv3.set_interval(-0.35, 0.35)
curv4 = s.elements["lenssys"].surfaces["surf4"].shape.curvature
curv4.changetype("variable")
curv4.set_interval(-0.35, 0.35)
curv6 = s.elements["lenssys"].surfaces["surf6"].shape.curvature
curv6.changetype("variable")
curv6.set_interval(-0.35, 0.35)
tltx_var = s.elements["lenssys"].surfaces["surf3"].rootcoordinatesystem.tiltx
tltx_var.changetype("variable")
tltx_var.set_interval(-3. * math.pi / 180., 3. * math.pi / 180.)
listOptimizableVariables(s, filter_status='variable', maxcol=80)
def osnone(s):
pass
def osupdate(s):
s.rootcoordinatesystem.update()
def meritfunctionrms(s):
initialbundle = RayBundle(x0=o, k0=k, Efield0=E0, wave=wavelength)
rpaths = s.seqtrace(initialbundle, sysseq)
x = rpaths[0].raybundles[-1].x[-1, 0, :]
# set names of the new instances accordingly
self.debug("Setting name of instance %s" % (names_tuple[index]))
instance.setName(names_tuple[index])
return instance_list
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
s = OpticalSystem(name="s")
s.lst = []
s.lst.append({})
s.lst.append({})
s.lst[0]["a"] = OptimizableVariable(variable_type="fixed", name="v1", value=3.0)
s.lst[1]["b"] = OptimizableVariable(variable_type="variable", name="v2", value=7.0)
s.rootcoordinatesystem.decz = OptimizableVariable(name="decz", value=-99.0)
listOptimizableVariables(s)
m = ConfigManager(s, name="mc")
[s2, s3] = m.setOptimizableVariables(("s2", "s3"),
{"s.global.decz": (("pickup", lambda x: x + 2.0),
("pickup", lambda x: x + 3.0)),
"s.global.decy": (("fixed", -2.), ("fixed", -3.))})
s.rootcoordinatesystem.decx.setvalue(-98.0)
for ss in (s2, s3):
mydict = listOptimizableVariables(ss)
"""
my_s.rootcoordinatesystem.update()
# optimize
s.elements["stdelem"].surfaces["lens4front"].shape.curvature.\
changetype("variable")
s.elements["stdelem"].surfaces["lens4rear"].shape.curvature.\
changetype("variable")
s.elements["stdelem"].surfaces["lens4rear"].shape.curvature.\
changetype("pickup",
functionobject=(FunctionObject("f = lambda x: -x"), "f"),
args=(s.elements["stdelem"].surfaces["lens4front"].shape.curvature,))
listOptimizableVariables(s, max_line_width=80)
optimi = Optimizer(s, meritfunction_step2, backend=ScipyBackend(),
updatefunction=updatefunction_allsteps, name="step2")
s = optimi.run()
# draw system with last lens biconvex
s.draw2d(axarr[1], color="grey", vertices=50, plane_normal=pn, up=up)
r2 = s.seqtrace(bundle_step1(nrays=9), seq) # trace again
for r in r2:
r.draw2d(axarr[1], color="blue", plane_normal=pn, up=up)
# Step 3: colour, field, more variables
########################################
