def setUp(self): self.z = Connection() self.z.NewLens() self.model = SurfaceSequence(self.z, empty=True) self.model[0].comment.value = "OBJ" self.model[-1].comment.value = "IMG" self._list = ["OBJ", "IMG"]
def setUp(self): self.z = Connection() self.z.NewLens() model = SurfaceSequence(self.z) m1 = model.insert_new(1, surface.Toroidal) m1.comment.value = "M1" m1.glass.value = "MIRROR" m1.curvature.value = 1 m1.conic.value = 0.1 m1.ignored.value = True m1.semidia.value = 2 m1.thermal_expansivity.value = .001 m1.coating.value = "METAL" m1.thickness.value = 30 m1.norm_radius = 123.0 m1.num_poly_terms = 5 self.m1 = m1 self.m2 = model.insert_new(-1, surface.Toroidal) cb1 = model.insert_new(-1, surface.CoordinateBreak) cb1.rotate_x.value = 34 cb1.rotate_y.value = 42 cb1.rotate_z.value = 83 cb1.offset_x.value = 2.63 cb1.offset_y.value = 753.3 cb1.thickness.value = 322.3 self.cb1 = cb1 self.cb2 = model.insert_new(-1, surface.CoordinateBreak)
def setUp(self): self.z = Connection() self.z.NewLens() self.model = SurfaceSequence(self.z) self.system = SystemConfig(self.z) self.system.rayaimingtype = 0 self.model[0].thickness = 10.0 # insert fold mirror self.model.append_new(surface.CoordinateBreak, rotate_y=40.0, rotate_z=10.0) self.model.append_new(surface.Standard, glass="MIRROR") cb = self.model.append_new(surface.CoordinateBreak, thickness=-20.0) cb.rotate_x.align_to_chief_ray() cb.rotate_y.align_to_chief_ray() front = self.model.append_new(surface.Standard, curvature=-0.05, glass="BK7", thickness=-1.0) back = self.model.append_new(surface.Standard, curvature=-front.curvature.linked()) self.z.SetSystemAper(3, front.get_surf_num(), 2.5) back.thickness.focus_on_next(self.marginal_ray_solve_pupil_coordinate) self.z.GetUpdate()
def setUp(self): self.z = Connection() self.n = self.z.GetSystem()[0]+1 self.z.NewLens() for i in range(self.n): self.z.SetLabel(i, 0)
def runTest(self) : z = Connection() response = z.NewLens() self.assertFalse(response, "Can't create new lens") # find number of surfaces response = z.GetSystem() numsurfs1 = response[0] response = z.InsertSurface(2) self.assertFalse(response, "Can't insert a surface") # check number of surfaces increased response = z.GetSystem() numsurfs2 = response[0] self.assertEqual(numsurfs2, numsurfs1+1, "Number of surfaces didn't increase") # copy lens to editor response = z.PushLens() self.assertFalse(response, "Can't push lens to editor window") response = z.NewLens() self.assertFalse(response, "Can't create new lens") response = z.GetSystem() self.assertNotEqual(response[0], numsurfs2, "New lens has same number of surfaces as old (modified) one") # copy modified lens back into server memory response = z.GetRefresh() # check it's our modified lens response = z.GetSystem() self.assertEqual(response[0], numsurfs2, "Didn't get our lens back")
def runTest(self) : z = Connection() z.NewLens() model = SurfaceSequence(z) # setting the extra parameter on surface creation requires surface type to be set first, internally m1 = model.insert_new(1, surface.Toroidal, num_poly_terms=11) self.assertEqual(m1.num_poly_terms.value, 11)
def testPrematureRemove(self) : z = Connection() def open_tmpfile_and_delete() : with zemaxclient.tmpfile_callback(os.remove) as (response, f) : pass # if temporary file cannot be removed, this will raise WindowsError self.assertRaises(WindowsError, open_tmpfile_and_delete)
def setUp(self): self.z = Connection() self.z.NewLens() self.z.InsertSurface(1) self.z.InsertSurface(1) self.n = self.get_len() for i in range(self.n): self.z.SetLabel(i, i)
def setUp(self): self.z = Connection() self.z.NewLens() # self.model = SurfaceSequence(self.z) self.n = self.get_len() self.original_label = 1 self.new_label = 2 for i in range(self.n): self.z.SetLabel(i, self.original_label)
def runTest(self) : z = Connection() z.NewLens() model = SurfaceSequence(z) m1 = model.insert_new(1, surface.Standard, "M1", glass="MIRROR", curvature=1, ignored=True, semidia=2, thermal_expansivity=.001, coating="METAL") self.assertEqual( m1.comment.value, "M1" ) self.assertEqual( m1.glass.value, "MIRROR") self.assertAlmostEqual(m1.curvature.value, 1) self.assertEqual(m1.ignored.value, True) self.assertAlmostEqual(m1.semidia.value, 2) self.assertAlmostEqual(m1.thermal_expansivity.value, .001) self.assertEqual(m1.coating.value, "METAL")
def runTest(self): z = Connection() z.NewLens() model = SurfaceSequence(z) # id = model.insert_surface(1) # m1 = surface.Standard(z,id) m1 = model.insert_new(1, surface.Toroidal) m1.comment.value = "M1" self.assertEqual(m1.comment.value, "M1") m1.glass.value = "MIRROR" self.assertEqual(m1.glass.value, "MIRROR") m1.curvature.value = 1 self.assertAlmostEqual(m1.curvature.value, 1) m1.ignored.value = True self.assertEqual(m1.ignored.value, True) m1.semidia.value = 2 self.assertAlmostEqual(m1.semidia.value, 2) m1.thermal_expansivity.value = .001 self.assertAlmostEqual(m1.thermal_expansivity.value, .001) m1.coating.value = "METAL" self.assertEqual(m1.coating.value, "METAL") # "extra" type parameters m1.num_poly_terms = 11 self.assertEqual(m1.num_poly_terms.value, 11) m1.norm_radius = 123.0 self.assertAlmostEqual(m1.norm_radius.value, 123.0) def access_missing_attr(): item = m1.this_will_never_ever_exist print("Item: " + str(item)) return item self.assertRaises(AttributeError, access_missing_attr) def access_missing_attr_linked(): item = m1.this_will_never_ever_exist_linked return item self.assertRaises(AttributeError, access_missing_attr_linked)
def runTest(self): z = Connection() z.NewLens() model = SurfaceSequence(z, empty=True) build_coord_break_sequence(model) # set each surface to be the global reference, in turn last = None for surf in model: surf.make_global_reference() self.assertTrue(surf.is_global_reference) if last is not None: self.assertFalse(last.is_global_reference) rot, offset = z.GetGlobalMatrix(surf.get_surf_num()) self.assertAlmostEqual(abs(rot - numpy.eye(3)).max(), 0) self.assertAlmostEqual(abs(offset).max(), 0) last = surf
def testLimitLength(self) : z = Connection() z.NewLens() model = SurfaceSequence(z) # Zemax surface comments must be 32 characters or less, to survive saving and reloading surf = model.insert_new(1, surface.Standard) def set_comment() : surf.comment = "z" * (libzmx.CommentParameter.max_len+1) self.assertRaises(ValueError, set_comment) comment = "c"*20 tag = "t"*10 surf.comment = comment def set_tag() : surf.comment.tag = tag self.assertRaises(ValueError, set_tag)
def runTest(self): z = Connection() z.NewLens() model = SurfaceSequence(z) # id = model.insert_surface(1) # m1 = surface.Standard(z,id) s = model.insert_new(1, surface.Standard) # there are no adjustable variables self.assertEqual(0, len(s.fix_variables())) # make some parameters adjustable s.thickness.vary() s.curvature.vary() # there are some adjustable variables self.assertEqual(2, len(s.fix_variables())) # adjustable variables are now fixed self.assertEqual(0, len(s.fix_variables()))
def testTagging(self): z = Connection() z.NewLens() model = SurfaceSequence(z) els = NamedElements(model) surf = model.insert_new(1, surface.Standard) comment = "first comment" surf.comment = comment # if no tag set, comment matches "comment" verbatim self.assertEqual(comment, surf.comment._client_get_value()) self.assertEqual(comment, surf.comment.value) # Setting the surface as an attribute of a NamedElements instance, # causes the name to be stored as a tag on the surface. els.m1 = surf # value in zemax model now has tag embedded self.assertNotEqual(comment, surf.comment._client_get_value()) # the tag is invisible in the value of comment self.assertEqual(comment, surf.comment.value) # the tag can be accessed, however self.assertEqual("m1", surf.comment.tag) # Updating the comment does not alter the tag comment = "second comment" self.assertNotEqual(comment, surf.comment.value) surf.comment = comment self.assertEqual(comment, surf.comment.value) # the tag is unchanged self.assertEqual("m1", surf.comment.tag) # we can access the surface as a property of a newly-created # NamedElements instance els2 = NamedElements(model) self.assertEqual(comment, els2.m1.comment.value) self.assertEqual(surf.id, els2.m1.id) # named surfaces can be discovered in models self.assertTrue("m1" in dir(els2))
def testSaving(self): z = Connection() z.NewLens() model = SurfaceSequence(z) # Zemax surface comments must be 32 characters or less, to # survive saving and reloading surf = model.insert_new(1, surface.Standard) id = surf.id comment = "c"*20 tag = "t"*9 surf.comment = comment surf.comment.tag = tag self.assertEqual(len(surf.comment._client_get_value()), libzmx.CommentParameter.max_len) # Surface can be retrieved from unsaved model els = NamedElements(model) self.assertEqual(id, getattr(els, tag).id) # Save model (fd, modelf) = tempfile.mkstemp(".ZMX") z.SaveFile(modelf) n = len(model) z.NewLens() self.assertNotEqual(n, len(model)) # Reload model z.LoadFile(modelf) els2 = NamedElements(model) # Comment and tag are intact s2 = getattr(els2, tag) self.assertEqual(id, s2.id) self.assertEqual(s2.comment.value, comment) os.close(fd) os.remove(modelf)
def runTest(self): z = Connection() z.NewLens() model = SurfaceSequence(z) m1 = model.insert_new(1, surface.Standard) m1.coating.set_value("METAL") self.assertEqual(m1.coating.value, "METAL") self.assertEqual(m1.coating.get_value(), "METAL") # We allow direct access to attributes values (similar to Django Model) m1.coating = "METAL2" self.assertEqual(m1.coating.value, "METAL2") self.assertEqual(repr(m1.coating), repr("METAL2")) self.assertEqual(str(m1.coating), "METAL2") thickness = 3.1 m1.thickness = thickness self.assertAlmostEqual(m1.thickness.value, thickness) self.assertAlmostEqual(float(repr(m1.thickness)), thickness) self.assertAlmostEqual(float(str(m1.thickness)), thickness)
# Author: Darius Sullivan <*****@*****.**> # Thermo Fisher Scientific (Cambridge, UK). # $Rev: 351 $ # $Date: 2013-12-17 18:29:25 +0000 (Tue, 17 Dec 2013) $ # Loads one of the Zemax sample files "Cooke Triplet". # Performs an exercise from the Short Course, optimising the lens. from __future__ import print_function from zemaxclient import Connection from libzmx import * import surface # Establish a connection to the running Zemax application z = Connection() # Load a lens file into the Zemax server memory. # It won't yet appear in the zemax window. For that we need to do z.PushLens() z.LoadFile("C:\\Program Files\\ZEMAX\\Samples\\Short course\\sc_cooke1.zmx") # Get a SurfaceSequence instance. This behaves like a list of surfaces # (the same sequence as viewed in the Zemax lens data editor). model = SurfaceSequence(z) # Get a SystemConfig object. This allows us to get/set certain system # parameters (eg. the stop surface, ray aiming, etc.) systemconfig = SystemConfig(z) # Show the number of surfaces in the lens print("Number of surfaces in model : %d " % len(model)) # Display some information about each surface print("Surface number, radius, thickness....")
def setUp(self): self.z = Connection() self.z.NewLens() self.system = SystemConfig(self.z) self.model = SurfaceSequence(self.z)
def setUp(self): self.z = Connection() self.z.NewLens() self.model = SurfaceSequence(self.z, empty=True) self.first, self.last = build_coord_break_sequence(self.model)
def setUp(self): self.z = Connection() self.z.NewLens()
def setUp(self): self.z = Connection() self.model = SurfaceSequence(self.z, empty=True) make_singlet(self.z)
def runTest(self): z = Connection() self.assertTrue(z.GetVersion(), "Can't connect")