Example #1
0
class TestHorizontalLayers(TestCase):

    def setUp(self):
        TestCase.setUp(self)

        self.g1 = HorizontalLayers(Material.pure(29))
        self.g2 = HorizontalLayers(None) # No substrate
        self.g3 = HorizontalLayers(Material.pure(29)) # Empty layer

        self.g1.add_layer(Material.pure(30), 123.456)
        self.g1.add_layer(Material.pure(31), 456.789)

        self.g2.add_layer(Material.pure(30), 123.456)
        self.g2.add_layer(Material.pure(31), 456.789)

        self.g3.add_layer(Material.pure(30), 123.456)
        self.g3.add_layer(Material.pure(31), 456.789)
        self.g3.add_layer(VACUUM, 456.123)

    def tearDown(self):
        TestCase.tearDown(self)

    def testskeleton(self):
        # Horizontal layers 1
        self.assertTrue(self.g1.has_substrate())
        self.assertEqual('Copper', str(self.g1.substrate.material))

        self.assertEqual(2, len(self.g1.layers))
        self.assertEqual('Zinc', str(self.g1.layers[0].material))
        self.assertAlmostEqual(123.456, self.g1.layers[0].thickness_m, 4)
        self.assertEqual('Gallium', str(self.g1.layers[1].material))
        self.assertAlmostEqual(456.789, self.g1.layers[1].thickness_m, 4)

        # Horizontal layers 2
        self.assertFalse(self.g2.has_substrate())

        self.assertEqual(2, len(self.g2.layers))
        self.assertEqual('Zinc', str(self.g2.layers[0].material))
        self.assertAlmostEqual(123.456, self.g2.layers[0].thickness_m, 4)
        self.assertEqual('Gallium', str(self.g2.layers[1].material))
        self.assertAlmostEqual(456.789, self.g2.layers[1].thickness_m, 4)

        # Horizontal layers 3
        self.assertTrue(self.g3.has_substrate())
        self.assertEqual('Copper', str(self.g3.substrate.material))

        self.assertEqual(3, len(self.g3.layers))
        self.assertEqual('Zinc', str(self.g3.layers[0].material))
        self.assertAlmostEqual(123.456, self.g3.layers[0].thickness_m, 4)
        self.assertEqual('Gallium', str(self.g3.layers[1].material))
        self.assertAlmostEqual(456.789, self.g3.layers[1].thickness_m, 4)
        self.assertEqual('Vacuum', str(self.g3.layers[2].material))
        self.assertAlmostEqual(456.123, self.g3.layers[2].thickness_m, 4)

    def testsubstrate(self):
        self.g1.substrate.material = VACUUM
        self.assertFalse(self.g1.has_substrate())

        # Horizontal layers 1
        self.assertEqual(float('-inf'), self.g1.substrate.xmin_m)
        self.assertEqual(float('inf'), self.g1.substrate.xmax_m)
        self.assertEqual(float('-inf'), self.g1.substrate.ymin_m)
        self.assertEqual(float('inf'), self.g1.substrate.ymax_m)
        self.assertEqual(float('-inf'), self.g1.substrate.zmin_m)
        self.assertAlmostEqual(-580.245, self.g1.substrate.zmax_m, 4)

    def testlayers(self):
        # Horizontal layers 1
        self.assertEqual(float('-inf'), self.g1.layers[0].xmin_m)
        self.assertEqual(float('inf'), self.g1.layers[0].xmax_m)
        self.assertEqual(float('-inf'), self.g1.layers[0].ymin_m)
        self.assertEqual(float('inf'), self.g1.layers[0].ymax_m)
        self.assertAlmostEqual(-123.456, self.g1.layers[0].zmin_m, 4)
        self.assertAlmostEqual(0.0, self.g1.layers[0].zmax_m, 4)

        self.assertEqual(float('-inf'), self.g1.layers[1].xmin_m)
        self.assertEqual(float('inf'), self.g1.layers[1].xmax_m)
        self.assertEqual(float('-inf'), self.g1.layers[1].ymin_m)
        self.assertEqual(float('inf'), self.g1.layers[1].ymax_m)
        self.assertAlmostEqual(-580.245, self.g1.layers[1].zmin_m, 4)
        self.assertAlmostEqual(-123.456, self.g1.layers[1].zmax_m, 4)

        # Horizontal layers 2
        self.assertEqual(float('-inf'), self.g2.layers[0].xmin_m)
        self.assertEqual(float('inf'), self.g2.layers[0].xmax_m)
        self.assertEqual(float('-inf'), self.g2.layers[0].ymin_m)
        self.assertEqual(float('inf'), self.g2.layers[0].ymax_m)
        self.assertAlmostEqual(-123.456, self.g2.layers[0].zmin_m, 4)
        self.assertAlmostEqual(0.0, self.g2.layers[0].zmax_m, 4)

        self.assertEqual(float('-inf'), self.g2.layers[1].xmin_m)
        self.assertEqual(float('inf'), self.g2.layers[1].xmax_m)
        self.assertEqual(float('-inf'), self.g2.layers[1].ymin_m)
        self.assertEqual(float('inf'), self.g2.layers[1].ymax_m)
        self.assertAlmostEqual(-580.245, self.g2.layers[1].zmin_m, 4)
        self.assertAlmostEqual(-123.456, self.g2.layers[1].zmax_m, 4)

        # Horizontal layers 3
        self.assertEqual(float('-inf'), self.g3.layers[0].xmin_m)
        self.assertEqual(float('inf'), self.g3.layers[0].xmax_m)
        self.assertEqual(float('-inf'), self.g3.layers[0].ymin_m)
        self.assertEqual(float('inf'), self.g3.layers[0].ymax_m)
        self.assertAlmostEqual(-123.456, self.g3.layers[0].zmin_m, 4)
        self.assertAlmostEqual(0.0, self.g3.layers[0].zmax_m, 4)

        self.assertEqual(float('-inf'), self.g3.layers[1].xmin_m)
        self.assertEqual(float('inf'), self.g3.layers[1].xmax_m)
        self.assertEqual(float('-inf'), self.g3.layers[1].ymin_m)
        self.assertEqual(float('inf'), self.g3.layers[1].ymax_m)
        self.assertAlmostEqual(-580.245, self.g3.layers[1].zmin_m, 4)
        self.assertAlmostEqual(-123.456, self.g3.layers[1].zmax_m, 4)

        self.assertEqual(float('-inf'), self.g3.layers[2].xmin_m)
        self.assertEqual(float('inf'), self.g3.layers[2].xmax_m)
        self.assertEqual(float('-inf'), self.g3.layers[2].ymin_m)
        self.assertEqual(float('inf'), self.g3.layers[2].ymax_m)
        self.assertAlmostEqual(-1036.368, self.g3.layers[2].zmin_m, 4)
        self.assertAlmostEqual(-580.245, self.g3.layers[2].zmax_m, 4)

    def testget_bodies(self):
        self.assertEqual(3, len(self.g1.get_bodies()))
        self.assertEqual(2, len(self.g2.get_bodies()))
        self.assertEqual(4, len(self.g3.get_bodies()))

    def testget_materials(self):
        self.assertEqual(3, len(self.g1.get_materials()))
        self.assertEqual(2, len(self.g2.get_materials()))
        self.assertEqual(3, len(self.g3.get_materials()))

    def testexpand(self):
        self.assertEqual(1, len(expand(self.g1)))

        self.g1.add_layer(Material.pure(79), [1.0, 2.0])
        self.assertEqual(2, len(expand(self.g1)))