def testExceptions(self):
        """
        Test that errors are produced whenever ObservationMetaData
        parameters are overwritten in an unintentional way
        """

        metadata = {'pointingRA':[1.5], 'pointingDec':[0.5],
                    'Opsim_expmjd':[52000.0],
                    'Opsim_rotskypos':[1.3],
                    'Opsim_filter':[2],
                    'Opsim_rawseeing':[0.7]}

        obs_metadata = ObservationMetaData(phoSimMetaData=metadata,
                                           boundType='circle',
                                           boundLength=0.1)

        with self.assertRaises(RuntimeError):
            obs_metadata.pointingRA=1.2

        with self.assertRaises(RuntimeError):
            obs_metadata.pointingDec=1.2

        with self.assertRaises(RuntimeError):
            obs_metadata.rotSkyPos=1.5

        with self.assertRaises(RuntimeError):
            obs_metadata.seeing=0.5

        with self.assertRaises(RuntimeError):
            obs_metadata.setBandpassM5andSeeing()

        obs_metadata = ObservationMetaData(pointingRA=1.5,
                                           pointingDec=1.5)
    def testM5andSeeingAssignment(self):
        """
        Test assignment of m5 and seeing seeing and bandpass in ObservationMetaData
        """
        obsMD = ObservationMetaData(bandpassName=['u','g'], m5=[15.0, 16.0], seeing=[0.7, 0.6])
        self.assertAlmostEqual(obsMD.m5['u'], 15.0, 10)
        self.assertAlmostEqual(obsMD.m5['g'], 16.0, 10)
        self.assertAlmostEqual(obsMD.seeing['u'], 0.7, 10)
        self.assertAlmostEqual(obsMD.seeing['g'], 0.6, 10)

        obsMD.setBandpassM5andSeeing(bandpassName=['i','z'], m5=[25.0, 22.0], seeing=[0.5, 0.4])
        self.assertAlmostEqual(obsMD.m5['i'], 25.0, 10)
        self.assertAlmostEqual(obsMD.m5['z'], 22.0, 10)
        self.assertAlmostEqual(obsMD.seeing['i'], 0.5, 10)
        self.assertAlmostEqual(obsMD.seeing['z'], 0.4, 10)

        with self.assertRaises(KeyError):
            obsMD.m5['u']

        with self.assertRaises(KeyError):
            obsMD.m5['g']

        obsMD.m5 = [13.0, 14.0]
        obsMD.seeing = [0.2, 0.3]
        self.assertAlmostEqual(obsMD.m5['i'], 13.0, 10)
        self.assertAlmostEqual(obsMD.m5['z'], 14.0, 10)
        self.assertAlmostEqual(obsMD.seeing['i'], 0.2, 10)
        self.assertAlmostEqual(obsMD.seeing['z'], 0.3, 10)

        obsMD.setBandpassM5andSeeing(bandpassName=['k', 'j'], m5=[21.0, 23.0])
        self.assertAlmostEqual(obsMD.m5['k'], 21.0, 10)
        self.assertAlmostEqual(obsMD.m5['j'], 23.0, 10)
        self.assertIsNone(obsMD.seeing)

        obsMD.setBandpassM5andSeeing(bandpassName=['w', 'x'], seeing=[0.9, 1.1])
        self.assertAlmostEqual(obsMD.seeing['w'], 0.9, 10)
        self.assertAlmostEqual(obsMD.seeing['x'], 1.1, 10)

        phoSimMD = {'Opsim_filter':[4]}
        obsMD.phoSimMetaData = phoSimMD
        self.assertEqual(obsMD.bandpass, 4)
        self.assertTrue(obsMD.m5 is None)
        self.assertTrue(obsMD.seeing is None)
Esempio n. 3
0
    def testM5andSeeingAssignment(self):
        """
        Test assignment of m5 and seeing seeing and bandpass in ObservationMetaData
        """
        obsMD = ObservationMetaData(bandpassName=['u', 'g'],
                                    m5=[15.0, 16.0],
                                    seeing=[0.7, 0.6])
        self.assertAlmostEqual(obsMD.m5['u'], 15.0, 10)
        self.assertAlmostEqual(obsMD.m5['g'], 16.0, 10)
        self.assertAlmostEqual(obsMD.seeing['u'], 0.7, 10)
        self.assertAlmostEqual(obsMD.seeing['g'], 0.6, 10)

        obsMD.setBandpassM5andSeeing(bandpassName=['i', 'z'],
                                     m5=[25.0, 22.0],
                                     seeing=[0.5, 0.4])
        self.assertAlmostEqual(obsMD.m5['i'], 25.0, 10)
        self.assertAlmostEqual(obsMD.m5['z'], 22.0, 10)
        self.assertAlmostEqual(obsMD.seeing['i'], 0.5, 10)
        self.assertAlmostEqual(obsMD.seeing['z'], 0.4, 10)

        with self.assertRaises(KeyError):
            obsMD.m5['u']

        with self.assertRaises(KeyError):
            obsMD.m5['g']

        obsMD.m5 = [13.0, 14.0]
        obsMD.seeing = [0.2, 0.3]
        self.assertAlmostEqual(obsMD.m5['i'], 13.0, 10)
        self.assertAlmostEqual(obsMD.m5['z'], 14.0, 10)
        self.assertAlmostEqual(obsMD.seeing['i'], 0.2, 10)
        self.assertAlmostEqual(obsMD.seeing['z'], 0.3, 10)

        obsMD.setBandpassM5andSeeing(bandpassName=['k', 'j'], m5=[21.0, 23.0])
        self.assertAlmostEqual(obsMD.m5['k'], 21.0, 10)
        self.assertAlmostEqual(obsMD.m5['j'], 23.0, 10)
        self.assertIsNone(obsMD.seeing)

        obsMD.setBandpassM5andSeeing(bandpassName=['w', 'x'],
                                     seeing=[0.9, 1.1])
        self.assertAlmostEqual(obsMD.seeing['w'], 0.9, 10)
        self.assertAlmostEqual(obsMD.seeing['x'], 1.1, 10)
Esempio n. 4
0
    def test_eq(self):
        """
        Test that we implemented __eq__ and __ne__ correctly
        """
        empty_obs = ObservationMetaData()
        other_empty_obs = ObservationMetaData()
        self.assertEqual(empty_obs, other_empty_obs)
        self.assertTrue(empty_obs == other_empty_obs)
        self.assertFalse(empty_obs != other_empty_obs)

        dummy_site = Site(longitude=23.1, latitude=-11.1, temperature=11.0,
                          height=8921.01, pressure=734.1, humidity=0.1,
                          lapseRate=0.006)

        ref_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                      mjd=59580.1, rotSkyPos=91.2,
                                      bandpassName = 'u', m5=24.3,
                                      skyBrightness=22.1, seeing=0.8,
                                      site=dummy_site)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertEqual(ref_obs, other_obs)
        self.assertTrue(ref_obs == other_obs)
        self.assertFalse(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.41, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.2,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.2, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.1,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'g', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.1,
                                        skyBrightness=22.1, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.2, seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.81,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1,
                                        mjd=59580.1, rotSkyPos=91.2,
                                        bandpassName = 'u', m5=24.3,
                                        skyBrightness=22.1, seeing=0.8)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        # use assignment to bring other_obs back into agreement with
        # ref_obs
        other_obs.site = dummy_site
        self.assertEqual(ref_obs, other_obs)
        self.assertTrue(ref_obs == other_obs)
        self.assertFalse(ref_obs != other_obs)

        # now try cases of m5, bandpass, and seeing being lists
        ref_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                       m5=[22.1, 23.5, 24.2],
                                       seeing=[0.6, 0.7, 0.8])

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                         m5=[22.1, 23.5, 24.2],
                                         seeing=[0.6, 0.7, 0.8])

        self.assertEqual(ref_obs, other_obs)
        self.assertTrue(ref_obs == other_obs)
        self.assertFalse(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'i', 'z'],
                                         m5=[22.1, 23.5, 24.2],
                                         seeing=[0.6, 0.7, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                         m5=[22.1, 23.4, 24.2],
                                         seeing=[0.6, 0.7, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                         m5=[22.1, 23.5, 24.2],
                                         seeing=[0.2, 0.7, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'z'],
                                         m5=[22.1, 24.2],
                                         seeing=[0.2, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)
Esempio n. 5
0
    def test_eq(self):
        """
        Test that we implemented __eq__ and __ne__ correctly
        """
        empty_obs = ObservationMetaData()
        other_empty_obs = ObservationMetaData()
        self.assertEqual(empty_obs, other_empty_obs)
        self.assertTrue(empty_obs == other_empty_obs)
        self.assertFalse(empty_obs != other_empty_obs)

        dummy_site = Site(longitude=23.1,
                          latitude=-11.1,
                          temperature=11.0,
                          height=8921.01,
                          pressure=734.1,
                          humidity=0.1,
                          lapseRate=0.006)

        ref_obs = ObservationMetaData(pointingRA=23.44,
                                      pointingDec=-19.1,
                                      mjd=59580.1,
                                      rotSkyPos=91.2,
                                      bandpassName='u',
                                      m5=24.3,
                                      skyBrightness=22.1,
                                      seeing=0.8,
                                      site=dummy_site)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertEqual(ref_obs, other_obs)
        self.assertTrue(ref_obs == other_obs)
        self.assertFalse(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.41,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.2,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.2,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.1,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='g',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.1,
                                        skyBrightness=22.1,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.2,
                                        seeing=0.8,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.81,
                                        site=dummy_site)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs = ObservationMetaData(pointingRA=23.44,
                                        pointingDec=-19.1,
                                        mjd=59580.1,
                                        rotSkyPos=91.2,
                                        bandpassName='u',
                                        m5=24.3,
                                        skyBrightness=22.1,
                                        seeing=0.8)

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        # use assignment to bring other_obs back into agreement with
        # ref_obs
        other_obs.site = dummy_site
        self.assertEqual(ref_obs, other_obs)
        self.assertTrue(ref_obs == other_obs)
        self.assertFalse(ref_obs != other_obs)

        # now try cases of m5, bandpass, and seeing being lists
        ref_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                       m5=[22.1, 23.5, 24.2],
                                       seeing=[0.6, 0.7, 0.8])

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                         m5=[22.1, 23.5, 24.2],
                                         seeing=[0.6, 0.7, 0.8])

        self.assertEqual(ref_obs, other_obs)
        self.assertTrue(ref_obs == other_obs)
        self.assertFalse(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'i', 'z'],
                                         m5=[22.1, 23.5, 24.2],
                                         seeing=[0.6, 0.7, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                         m5=[22.1, 23.4, 24.2],
                                         seeing=[0.6, 0.7, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'],
                                         m5=[22.1, 23.5, 24.2],
                                         seeing=[0.2, 0.7, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)

        other_obs.setBandpassM5andSeeing(bandpassName=['u', 'z'],
                                         m5=[22.1, 24.2],
                                         seeing=[0.2, 0.8])

        self.assertNotEqual(ref_obs, other_obs)
        self.assertFalse(ref_obs == other_obs)
        self.assertTrue(ref_obs != other_obs)