def test_euler_rotation_matrix(self): phi1, theta1, psi1 = np.radians(([10, 10, 10], [30, 30, 30], [0, 0, 0])) m1 = st.euler_rotation_matrix(phi1, theta1, psi1) M1 = np.array( [[0.98480775301220802, -0.1503837331804353, 0.086824088833465152], [0.17364817766693033, 0.85286853195244328, -0.49240387650610395], [0, 0.49999999999999994, 0.86602540378443871]]) phi2, theta2, psi2 = np.radians(([10, 10, 10], [30, 30, 30], [45, 45, 45])) m2 = st.euler_rotation_matrix(phi2, theta2, psi2) M2 = np.array( [[0.59002688280798476, -0.80270159783205308, 0.086824088833465152], [0.72585692637316113, 0.4802813184352156, -0.49240387650610395], [0.35355339059327368, 0.35355339059327373, 0.86602540378443871]]) phi3, theta3, psi3 = np.radians(([10, 10, 10], [30, 30, 30], [45, 0, 45])) m3 = st.euler_rotation_matrix(phi3, theta3, psi3) M3 = np.array([ [[0.59002688280798476, -0.80270159783205308, 0.086824088833465152], [0.72585692637316113, 0.4802813184352156, -0.49240387650610395], [0.35355339059327368, 0.35355339059327373, 0.86602540378443871]], [[0.98480775301220802, -0.1503837331804353, 0.086824088833465152], [0.17364817766693033, 0.85286853195244328, -0.49240387650610395], [0, 0.49999999999999994, 0.86602540378443871]], [[0.59002688280798476, -0.80270159783205308, 0.086824088833465152], [0.72585692637316113, 0.4802813184352156, -0.49240387650610395], [0.35355339059327368, 0.35355339059327373, 0.86602540378443871]] ]) self.assertTrue(np.allclose(m1, np.repeat(M1[None, ...], 3, axis=0))) self.assertTrue(np.allclose(m2, np.repeat(M2[None, ...], 3, axis=0))) self.assertTrue(np.allclose(m3, M3))
def test_LocalCivilTime2JulianDay(self): "Integrated Test: it includes also the LCT2GCD and GCD2JD function conversion" Jul_1_2013 = st.LocalCivilTime2JulianDay((3, 37, 0), (1, 7, 2013), UTC=4, DST=1) Jun_19_2009 = st.LocalCivilTime2JulianDay((18, 0, 0), (19, 6, 2009), UTC=0, DST=0) self.assertTrue(np.allclose(Jul_1_2013, 2456474.442)) self.assertTrue(np.allclose(Jun_19_2009, 2455002.25)) t = Time( ['2015-1-1 00:00:10', '2018-1-3 5:15:24.3', '1980-4-22 19:30:2']).jd T = np.array([ st.LocalCivilTime2JulianDay((0, 0, 10), (1, 1, 2015), UTC=0, DST=0), st.LocalCivilTime2JulianDay((5, 15, 24.3), (3, 1, 2018), UTC=0, DST=0), st.LocalCivilTime2JulianDay((19, 30, 2), (22, 4, 1980), UTC=0, DST=0) ]) self.assertTrue(np.allclose(t, T))
def test_hours2degrees(self): ang0 = st.hours2degrees(hours[1]) ang1 = st.hours2degrees(hours, decimal=True) self.assertTrue( np.allclose(ang0, st.dec2sex(st.sex2dec(hours[1]) * 15))) self.assertTrue(np.allclose(ang1, st.sex2dec(hours) * 15))
def test_get_nside_eff(self): fwhm_beam0 = np.array([0, 5, 0]) #deg (arcmin) fwhm_beam1 = np.array([0, 21, 0]) #deg (arcmin) fwhm_beam2 = np.array([0, 32, 0]) #deg (arcmin) self.assertEqual(st.get_nside_eff(fwhm_beam0), 1024) self.assertEqual(st.get_nside_eff(fwhm_beam1), 256) self.assertEqual(st.get_nside_eff(fwhm_beam2), 128)
def test_sex2dec(self): ang0 = st.sex2dec(angles) ang1 = st.sex2dec(angles[0], radians=True) self.assertTrue( np.allclose( ang0, np.array([-10.76638889, 30.587500, -180.422222, 3.06805556]))) self.assertEqual(ang1, np.radians(ang0[0]))
def test_LocalCivilTime2LocalSiderealTime(self): LONG = st.dec2sex(0.1) Jun_19_2009 = st.LocalCivilTime2LocalSiderealTime((18, 0, 0), (19, 6, 2009), LONG, UTC=0, DST=0) self.assertTrue(np.allclose(Jun_19_2009, np.array([11, 52, 46.843])))
def test_dec2sex(self): t0 = st.dec2sex(t) t00 = st.dec2sex(t[0]) self.assertTrue( np.allclose( t0, np.array([[1, 32, 47.706], [-0, 33, 36], [0, 20, 0], [-1, 0, 3.6]]))) self.assertTrue(np.allclose(t00, np.array([1, 32, 47.706])))
def get_full_fp_polarization_angles(self): def general_test(x_fp, i, j): self.assertTrue(np.allclose(x_fp[i, 0], x_fp[j, 0])) self.assertTrue(np.allclose(x_fp[i, 1], -x_fp[j, 1])) self.assertTrue(np.allclose(x_fp[i, 2], x_fp[j, 2])) full_psi, polarization_versor = st.get_full_fp_polarization_angles( './ScanningTools/fp_data/fp_psi.txt') self.assertTrue(np.allclose(np.sum(polarization_versor**2, axis=1), 1)) self.assertEqual(len(full_psi), 49) self.assertEqual(len(polarization_versor), 49) general_test(polarization_versor, 7, 42) general_test(polarization_versor, 8, 47) general_test(polarization_versor, 9, 46) general_test(polarization_versor, 10, 45) general_test(polarization_versor, 11, 44) general_test(polarization_versor, 12, 43) general_test(polarization_versor, 13, 48) general_test(polarization_versor, 14, 35) general_test(polarization_versor, 15, 40) general_test(polarization_versor, 16, 39) general_test(polarization_versor, 17, 38) general_test(polarization_versor, 18, 37) general_test(polarization_versor, 19, 36) general_test(polarization_versor, 20, 41) general_test(polarization_versor, 21, 28) general_test(polarization_versor, 22, 33) general_test(polarization_versor, 23, 32) general_test(polarization_versor, 24, 31) general_test(polarization_versor, 25, 30) general_test(polarization_versor, 26, 29) general_test(polarization_versor, 27, 34)
def test_get_full_fp(self): def general_test(x_fp, i, j): self.assertTrue(np.allclose(x_fp[i, 0], x_fp[j, 0])) self.assertTrue(np.allclose(x_fp[i, 1], -x_fp[j, 1])) self.assertTrue(np.allclose(x_fp[i, 2], x_fp[j, 2])) x_fp, n_horns = st.get_full_fp('./ScanningTools/fp_data/fp_theta.txt', './ScanningTools/fp_data/fp_phi.txt') self.assertTrue(np.allclose(np.sum(x_fp**2, axis=1), 1)) self.assertEqual(n_horns, 49) general_test(x_fp, 7, 42) general_test(x_fp, 8, 47) general_test(x_fp, 9, 46) general_test(x_fp, 10, 45) general_test(x_fp, 11, 44) general_test(x_fp, 12, 43) general_test(x_fp, 13, 48) general_test(x_fp, 14, 35) general_test(x_fp, 15, 40) general_test(x_fp, 16, 39) general_test(x_fp, 17, 38) general_test(x_fp, 18, 37) general_test(x_fp, 19, 36) general_test(x_fp, 20, 41) general_test(x_fp, 21, 28) general_test(x_fp, 22, 33) general_test(x_fp, 23, 32) general_test(x_fp, 24, 31) general_test(x_fp, 25, 30) general_test(x_fp, 26, 29) general_test(x_fp, 27, 34)
def test_get_horizon_coordinates(self): def general_tests(Alt, Az): self.assertTrue(np.degrees(Alt.max()) <= 90) self.assertTrue(np.degrees(Alt.min()) >= 0) self.assertTrue(np.degrees(Az.max()) <= 360) self.assertTrue(np.degrees(Az.min()) >= 0) x_fp, n_horns = st.get_full_fp('./ScanningTools/fp_data/fp_theta.txt', './ScanningTools/fp_data/fp_phi.txt') obs_time = (0, 2, 0, 0, 0) sampling_rate = 1 rpm = 4 day = 1 n1, n2 = (0, 15) obs_t, time, JD = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day) theta, phi, psi = st.get_engine_rotations(time, rpm, zenith_distance, polarization_angle) fpp = st.get_fp_rotations(phi, theta, psi, x_fp, n_horns, time, n=None, cartesian=False) fpp1 = st.get_fp_rotations(phi, theta, psi, x_fp, n_horns, time, n=n1, cartesian=False) fpp2 = st.get_fp_rotations(phi, theta, psi, x_fp, n_horns, time, n=n2, cartesian=False) Alt, Az = st.get_horizon_coordinates(fpp) Alt1, Az1 = st.get_horizon_coordinates(fpp1) Alt2, Az2 = st.get_horizon_coordinates(fpp2)
def test_engine_rotations(self): obs_time = (0, 0, 0, 30, 0) obs_t, time, JD = st.get_timeJD(LCT_start, LCD_start, 50, obs_time, UTC=UTC, DST=DST, day=None) rpm = 7 theta, phi, psi = st.get_engine_rotations(time, rpm, zenith_distance, polarization_angle) self.assertEqual(len(theta), len(time)) self.assertEqual(len(phi), len(time)) self.assertEqual(len(psi), len(time)) self.assertTrue(np.allclose(theta[1:] - theta[:-1], 0)) self.assertTrue(np.allclose(psi[1:] - psi[:-1], 0))
def pointing_test(name, JD, loc): object = SkyCoord.from_name(name) object_AltAz = object.transform_to( AltAz(obstime=Time(JD, format='jd'), location=loc)) object_Alt = object_AltAz.alt.rad object_Az = object_AltAz.az.rad object_Dec, object_Ra = st.get_icrs_coordinates( JD1, loc, object_Alt, object_Az) self.assertTrue(np.allclose(object.dec.rad, object_Dec)) self.assertTrue(np.allclose(object.ra.rad, object_Ra))
def test_period2sec(self): one_sidereal_year = st.period2sec(years=1, days=0, hours=0, min=0, sec=0, sidereal=True) one_solar_year = st.period2sec(years=1, days=0, hours=0, min=0, sec=0) one_sidereal_day = st.period2sec(years=0, days=1, hours=0, min=0, sec=0, sidereal=True) one_solar_day = st.period2sec(years=0, days=1, hours=0, min=0, sec=0) period_0 = st.period2sec(years=1, days=1, hours=0, min=0, sec=0, sidereal=True) period_1 = st.period2sec(years=5, days=30, hours=0, min=0, sec=0, sidereal=True) period_2 = st.period2sec(years=2, days=17, hours=0, min=0, sec=0, sidereal=True) period_3 = st.period2sec(years=10, days=21, hours=15, min=3, sec=25, sidereal=True) self.assertEqual(one_sidereal_year, 31558145) self.assertEqual(one_solar_year, 31536000) self.assertEqual(one_sidereal_day, 86164) self.assertEqual(one_solar_day, 86400) self.assertEqual(period_0, 31644309) self.assertEqual(period_1, 160375649) self.assertEqual(period_2, 64581080) self.assertEqual(period_3, 317445103)
def test_spin_generator(self): def general_spin_tests(phi, obs_time, time, sampling_rate, rpm, day=None): if day: self.assertEqual(len(phi), 86400 * sampling_rate) else: self.assertEqual(len(phi), obs_time * sampling_rate) self.assertEqual( np.sum(np.r_[True, phi[1:] > phi[:-1]] & np.r_[phi[:-1] > phi[1:], True]), rpm * len(phi) / sampling_rate / 60) self.assertEqual(phi.min(), 0) self.assertTrue(phi.max() < 2 * np.pi) obs_time1, obs_time2, obs_time3 = ((0, 30, 0, 0, 0), (0, 1, 0, 0, 0), (0, 0, 1, 0, 0)) sampling_rate1, sampling_rate2, sampling_rate3 = (1, 3, 50) rpm1, rpm2, rpm3 = (13, 1, 5) day1, day2, day3 = (2, None, None) obs_t1, time1, JD1 = st.get_timeJD(LCT_start, LCD_start, sampling_rate1, obs_time1, UTC=UTC, DST=DST, day=day1) phi1 = st.spin_generator(time1, rpm1) general_spin_tests(phi1, obs_t1, time1, sampling_rate1, rpm1, day=day1) obs_t2, time2, JD2 = st.get_timeJD(LCT_start, LCD_start, sampling_rate2, obs_time2, UTC=UTC, DST=DST, day=day2) phi2 = st.spin_generator(time2, rpm2) general_spin_tests(phi2, obs_t2, time2, sampling_rate2, rpm2, day=day2) obs_t3, time3, JD3 = st.get_timeJD(LCT_start, LCD_start, sampling_rate3, obs_time3, UTC=UTC, DST=DST, day=day3) phi3 = st.spin_generator(time3, rpm3) general_spin_tests(phi3, obs_t3, time3, sampling_rate3, rpm3, day=day3)
def tests_1d(LCT_start, LCD_start, obs_t, time, sampling_rate, JD, JD_step, t0, t1, UTC=UTC, DST=DST): general_tests(time, sampling_rate, JD, JD_step, t0, t1) obs_t0, time0, JD0 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=None) self.assertEqual(obs_t, 86400) self.assertEqual(obs_t, obs_t0) self.assertEqual(len(time), obs_t * sampling_rate) self.assertTrue(len(time), len(time0)) self.assertTrue(len(JD), len(JD0))
def test_get_polarization_angles(self): def general_tests(x_fp_pol_versors, pol_ang_proj, fp_pol_pointings): self.assertTrue((np.max(pol_ang_proj, axis=-1) <= np.pi).all()) self.assertTrue((np.min(pol_ang_proj, axis=-1) >= -np.pi).all()) zenith_distance, zenith_distance1 = (0, 10) boresight_angle = 0 obs_time, obs_time1 = ((0, 0, 0, 1, 0), (0, 1, 0, 0, 0)) sampling_rate, sampling_rate1 = (50, 1) rpm, rpm1 = (1, 5) day, day1 = (None, 1) n, n1 = (0, None) obs_t, time, JD = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day) obs_t1, time1, JD1 = st.get_timeJD(LCT_start, LCD_start, sampling_rate1, obs_time1, UTC=UTC, DST=DST, day=day1) theta, phi, psi = st.get_engine_rotations(time, rpm, zenith_distance, boresight_angle) theta1, phi1, psi1 = st.get_engine_rotations(time1, rpm1, zenith_distance1, boresight_angle) theta2, phi2, psi2 = st.get_engine_rotations(time1, rpm1, zenith_distance, boresight_angle) x_fp_pol_angles, x_fp_pol_versors = st.get_full_fp_polarization_angles( './ScanningTools/fp_data/fp_psi.txt') n_horns = len(x_fp_pol_versors) fp_pol_pointings = st.get_fp_rotations(phi, theta, psi, x_fp_pol_versors, n_horns, time, n=n, cartesian=True) #rad fp_pol_pointings1 = st.get_fp_rotations(phi1, theta1, psi1, x_fp_pol_versors, n_horns, time1, n=n1, cartesian=True) #rad pol_ang_proj = st.get_polarization_angles(phi, theta, psi, x_fp_pol_versors, n_horns, time, n=n) pol_ang_proj1 = st.get_polarization_angles(phi1, theta1, psi1, x_fp_pol_versors, n_horns, time1, n=n1) pol_ang_proj2 = st.get_polarization_angles(phi2, theta2, psi2, x_fp_pol_versors, n_horns, time1, n=n1) pol_ang_proj_expected = np.concatenate( (np.linspace(0, np.pi, sampling_rate * obs_t / 2 + 1), np.linspace(-np.pi, 0, sampling_rate * obs_t / 2 + 1)[1:-1])) self.assertTrue( np.allclose( np.arctan2(x_fp_pol_versors[..., 1], x_fp_pol_versors[..., 0]), x_fp_pol_angles)) self.assertTrue(np.allclose(pol_ang_proj2[..., 0], x_fp_pol_angles)) self.assertTrue(np.allclose(pol_ang_proj, pol_ang_proj_expected)) general_tests(x_fp_pol_versors, pol_ang_proj, fp_pol_pointings) general_tests(x_fp_pol_versors, pol_ang_proj1, fp_pol_pointings1)
def test_get_practical_icrs_coordinates(self): def general_tests(Dec, Ra, PDec, PRa, accuracy): self.assertTrue((np.abs(Dec - PDec) <= accuracy).all()) diff_Ra = np.abs(Ra - PRa).ravel() diff_Ra[diff_Ra > 6] = 2 * np.pi - diff_Ra[diff_Ra > 6] self.assertTrue((diff_Ra <= accuracy).all()) x_fp, n_horns = st.get_full_fp('./ScanningTools/fp_data/fp_theta.txt', './ScanningTools/fp_data/fp_phi.txt') obs_time = (0, 2, 0, 0, 0) sampling_rate = 0.01 rpm = 3 day1 = 2 n1, n2 = (48, None) obs_t1, time1, JD1 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day1) theta1, phi1, psi1 = st.get_engine_rotations(time1, rpm, zenith_distance, polarization_angle) fpp1 = st.get_fp_rotations(phi1, theta1, psi1, x_fp, n_horns, time1, n=n1, cartesian=False) fpp3 = st.get_fp_rotations(phi1, theta1, psi1, x_fp, n_horns, time1, n=n2, cartesian=False) Alt1, Az1 = st.get_horizon_coordinates(fpp1) Alt3, Az3 = st.get_horizon_coordinates(fpp3) Dec1, Ra1 = st.get_icrs_coordinates(JD1, loc, Alt1, Az1) #1 day 2; n = 48 Dec3, Ra3 = st.get_icrs_coordinates(JD1, loc, Alt3, Az3) #3 day 2; n = all PDec1, PRa1 = st.get_practical_icrs_coordinates(JD1, loc, Alt1, Az1) #1 day 2; n = 48 PDec3, PRa3 = st.get_practical_icrs_coordinates(JD1, loc, Alt3, Az3) #3 day 2; n = all accuracy = st.sex2dec(pointing_accuracy) general_tests(Dec1, Ra1, PDec1, PRa1, accuracy) general_tests(Dec3, Ra3, PDec3, PRa3, accuracy)
def test_degrees2hours(self): ang0 = st.degrees2hours(angles) ang1 = st.degrees2hours(angles[2], decimal=True) self.assertTrue(np.allclose(ang0, st.dec2sex(st.sex2dec(angles) / 15))) self.assertTrue(np.allclose(ang1, st.sex2dec(angles)[2] / 15))
def test_get_icrs_coordinates(self): x_fp, n_horns = st.get_full_fp('./ScanningTools/fp_data/fp_theta.txt', './ScanningTools/fp_data/fp_phi.txt') obs_time = (0, 2, 0, 0, 0) sampling_rate = 0.001 rpm = 3 day1, day2 = (2, None) n1, n2 = (48, None) obs_t1, time1, JD1 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day1) obs_t2, time2, JD2 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day2) theta1, phi1, psi1 = st.get_engine_rotations(time1, rpm, zenith_distance, polarization_angle) theta2, phi2, psi2 = st.get_engine_rotations(time2, rpm, zenith_distance, polarization_angle) fpp1 = st.get_fp_rotations(phi1, theta1, psi1, x_fp, n_horns, time1, n=n1, cartesian=False) fpp2 = st.get_fp_rotations(phi2, theta2, psi2, x_fp, n_horns, time2, n=n1, cartesian=False) fpp3 = st.get_fp_rotations(phi1, theta1, psi1, x_fp, n_horns, time1, n=n2, cartesian=False) fpp4 = st.get_fp_rotations(phi2, theta2, psi2, x_fp, n_horns, time2, n=n2, cartesian=False) Alt1, Az1 = st.get_horizon_coordinates(fpp1) Alt2, Az2 = st.get_horizon_coordinates(fpp2) Alt3, Az3 = st.get_horizon_coordinates(fpp3) Alt4, Az4 = st.get_horizon_coordinates(fpp4) Dec1, Ra1 = st.get_icrs_coordinates(JD1, loc, Alt1, Az1) #1 day 2; n = 48 Dec2, Ra2 = st.get_icrs_coordinates(JD2, loc, Alt2, Az2) #2 day all; n = 48 Dec3, Ra3 = st.get_icrs_coordinates(JD1, loc, Alt3, Az3) #3 day 2; n = all Dec4, Ra4 = st.get_icrs_coordinates(JD2, loc, Alt4, Az4) #4 day all; n = all Dec5, Ra5 = st.get_icrs_coordinates(JD1[0], loc, Alt1, Az1) #5 day 2 [t=0]; n = 48 self.assertTrue(np.allclose(Dec1, Dec3[n1])) self.assertTrue(np.allclose(Ra1, Ra3[n1])) self.assertTrue(np.allclose(Dec1, Dec2[len(Dec1):])) self.assertTrue(np.allclose(Ra1, Ra2[len(Ra1):])) self.assertTrue(np.allclose(Dec1, Dec4[n1, len(Dec1):])) self.assertTrue(np.allclose(Ra1, Ra4[n1, len(Dec1):])) self.assertTrue(np.allclose(Dec1[0], Dec5[0])) self.assertTrue(np.allclose(Ra1[0], Ra5[0])) self.assertFalse(np.allclose(Dec1[1:], Dec5[1:])) self.assertFalse(np.allclose(Ra1[1:], Ra5[1:])) def pointing_test(name, JD, loc): object = SkyCoord.from_name(name) object_AltAz = object.transform_to( AltAz(obstime=Time(JD, format='jd'), location=loc)) object_Alt = object_AltAz.alt.rad object_Az = object_AltAz.az.rad object_Dec, object_Ra = st.get_icrs_coordinates( JD1, loc, object_Alt, object_Az) self.assertTrue(np.allclose(object.dec.rad, object_Dec)) self.assertTrue(np.allclose(object.ra.rad, object_Ra)) name1, name2, name3 = ('M33', 'crab', 'NCG67') pointing_test(name1, JD1, loc) pointing_test(name2, JD1, loc) pointing_test(name3, JD1, loc)
def test_get_timeJD(self): def general_tests(time, sampling_rate, JD, JD_step, t0, t1): self.assertTrue( np.allclose(time[1:] - time[0:-1], 1 / sampling_rate)) self.assertEqual(len(JD), len(time)) self.assertEqual(np.sum(np.diff(JD_step)), 0) self.assertTrue( np.allclose((t1 - t0).sec, 1 / sampling_rate, rtol=1e-3)) def tests_1h(obs_t, time, sampling_rate, JD, JD_step, t0, t1): self.assertEqual(obs_t, 3600) self.assertEqual(len(time), obs_t * sampling_rate) general_tests(time, sampling_rate, JD, JD_step, t0, t1) def tests_1d(LCT_start, LCD_start, obs_t, time, sampling_rate, JD, JD_step, t0, t1, UTC=UTC, DST=DST): general_tests(time, sampling_rate, JD, JD_step, t0, t1) obs_t0, time0, JD0 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=None) self.assertEqual(obs_t, 86400) self.assertEqual(obs_t, obs_t0) self.assertEqual(len(time), obs_t * sampling_rate) self.assertTrue(len(time), len(time0)) self.assertTrue(len(JD), len(JD0)) def tests_1y(LCT_start, LCD_start, obs_t, time, sampling_rate, JD, JD_step, t0, t1, UTC=UTC, DST=DST, day=None): general_tests(time, sampling_rate, JD, JD_step, t0, t1) self.assertEqual(obs_t, 86400 * 365) if day: self.assertEqual(len(time), 86400 * sampling_rate) if day > 1: self.assertTrue(time[0] != 0) else: self.assertTrue(time[0] == 0) else: self.assertEqual(len(time), obs_t * sampling_rate) sampling_rate = 50 #Hz obs_time = (0, 0, 1, 0, 0) #y, d, h, m, s day = None obs_t, time, JD = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day) JD_step = JD[1:] - JD[:-1] t0 = Time(JD[0], format='jd', location=loc) t1 = Time(JD[0] + JD_step[0], format='jd', location=loc) tests_1h(obs_t, time, sampling_rate, JD, JD_step, t0, t1) sampling_rate = 5 #Hz obs_t, time, JD = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day) JD_step = JD[1:] - JD[:-1] t0 = Time(JD[0], format='jd', location=loc) t1 = Time(JD[0] + JD_step[0], format='jd', location=loc) tests_1h(obs_t, time, sampling_rate, JD, JD_step, t0, t1) sampling_rate = 3 #Hz obs_time = (0, 1, 0, 0, 0) #y, d, h, m, s day = 1 obs_t, time, JD = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day) JD_step = JD[1:] - JD[:-1] t0 = Time(JD[0], format='jd', location=loc) t1 = Time(JD[0] + JD_step[0], format='jd', location=loc) tests_1d(LCT_start, LCD_start, obs_t, time, sampling_rate, JD, JD_step, t0, t1, UTC=UTC, DST=DST) sampling_rate = 1 #Hz obs_time = (1, 0, 0, 0, 0) #y, d, h, m, s day0, day1, day2, day3, day4 = (1, 5, 364, None, None) obs_t0, time0, JD0 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day0) JD_step0 = JD0[1:] - JD0[:-1] t00 = Time(JD0[0], format='jd', location=loc) t10 = Time(JD0[0] + JD_step0[0], format='jd', location=loc) tests_1y(LCT_start, LCD_start, obs_t0, time0, sampling_rate, JD0, JD_step0, t00, t10, UTC=UTC, DST=DST, day=day0) obs_t1, time1, JD1 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day1) JD_step1 = JD1[1:] - JD1[:-1] t01 = Time(JD1[0], format='jd', location=loc) t11 = Time(JD1[0] + JD_step1[0], format='jd', location=loc) tests_1y(LCT_start, LCD_start, obs_t1, time1, sampling_rate, JD1, JD_step1, t01, t11, UTC=UTC, DST=DST, day=day1) obs_t2, time2, JD2 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day2) JD_step2 = JD2[1:] - JD2[:-1] t02 = Time(JD2[0], format='jd', location=loc) t12 = Time(JD2[0] + JD_step2[0], format='jd', location=loc) tests_1y(LCT_start, LCD_start, obs_t2, time2, sampling_rate, JD2, JD_step2, t02, t12, UTC=UTC, DST=DST, day=day2) obs_t3, time3, JD3 = st.get_timeJD(LCT_start, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day3) JD_step3 = JD3[1:] - JD3[:-1] t03 = Time(JD3[0], format='jd', location=loc) t13 = Time(JD3[0] + JD_step3[0], format='jd', location=loc) tests_1y(LCT_start, LCD_start, obs_t3, time3, sampling_rate, JD3, JD_step3, t03, t13, UTC=UTC, DST=DST, day=day3) LCT_start4 = (12, 0, 0) obs_t4, time4, JD4 = st.get_timeJD(LCT_start4, LCD_start, sampling_rate, obs_time, UTC=UTC, DST=DST, day=day4) JD_step4 = JD4[1:] - JD4[:-1] t04 = Time(JD4[0], format='jd', location=loc) t14 = Time(JD4[0] + JD_step4[0], format='jd', location=loc) tests_1y(LCT_start4, LCD_start, obs_t4, time4, sampling_rate, JD4, JD_step4, t04, t14, UTC=UTC, DST=DST, day=day4)
def test_fp_rotations(self): def general_tests(fp_pointings, fp_pointings_c): self.assertTrue( np.allclose(np.diff(fp_pointings_c[..., 2], axis=-1), 0)) self.assertTrue(np.degrees(fp_pointings[..., 0]).max() <= 365) self.assertTrue(np.degrees(fp_pointings[..., 1]).max() <= 365) self.assertTrue(np.allclose(np.sum(fp_pointings_c**2, axis=-1), 1)) x_fp, n_horns = st.get_full_fp('./ScanningTools/fp_data/fp_theta.txt', './ScanningTools/fp_data/fp_phi.txt') obs_time1, obs_time2 = ((0, 0, 0, 30, 0), (0, 90, 0, 0, 0)) rpm1, rpm2 = (7, 2) day1, day2 = (None, 10) sampling_rate1, sampling_rate2 = (50, 1) obs_t1, time1, JD1 = st.get_timeJD(LCT_start, LCD_start, sampling_rate1, obs_time1, UTC=UTC, DST=DST, day=day1) theta1, phi1, psi1 = st.get_engine_rotations(time1, rpm1, zenith_distance, polarization_angle) obs_t2, time2, JD2 = st.get_timeJD(LCT_start, LCD_start, sampling_rate2, obs_time2, UTC=UTC, DST=DST, day=day2) theta2, phi2, psi2 = st.get_engine_rotations(time2, rpm2, zenith_distance, polarization_angle) n1 = 30 n2 = None fp_rot1 = st.euler_rotation_matrix(phi1, theta1, psi1) fp_rot2 = st.euler_rotation_matrix(phi2, theta2, psi2) fp_pointings1 = st.get_fp_rotations(phi1, theta1, psi1, x_fp, n_horns, time1, n=n1, cartesian=False) fp_pointings1_c = st.get_fp_rotations(phi1, theta1, psi1, x_fp, n_horns, time1, n=n1, cartesian=True) fp_pointings2 = st.get_fp_rotations(phi2, theta2, psi2, x_fp, n_horns, time2, n=n2, cartesian=False) fp_pointings2_c = st.get_fp_rotations(phi2, theta2, psi2, x_fp, n_horns, time2, n=n2, cartesian=True) i = np.random.randint(0, len(time1)) self.assertTrue( np.allclose(np.dot(fp_rot1[i], x_fp[n1]), fp_pointings1_c[i])) rot1 = q.get_quaternion_from_euler(phi1[i], theta1[i], psi1[i]) self.assertTrue( np.allclose( rot1.rotate_vector_by_quaternion(x_fp[n1]).get_versor(), fp_pointings1_c[i, :])) general_tests(fp_pointings1, fp_pointings1_c) j = np.random.randint(0, len(time2)) p = np.random.randint(0, n_horns) self.assertTrue( np.allclose(np.dot(fp_rot2[j], x_fp[p]), fp_pointings2_c[p][j])) rot2 = q.get_quaternion_from_euler(phi2[j], theta2[j], psi2[j]) self.assertTrue( np.allclose( rot2.rotate_vector_by_quaternion(x_fp[p]).get_versor(), fp_pointings2_c[p, j, :])) general_tests(fp_pointings2, fp_pointings2_c)
def test_get_scanning_strategy(self): def general_tests(packed_values): (x_fp, x_fp_pol_angles, n_horns, time, JD, theta, phi, psi, fp_pointings_spherical, Alt, Az, Dec, Ra, polarization_angles) = packed_values self.assertTrue(np.allclose(x_fp.shape, (49, 3))) self.assertTrue(np.allclose(x_fp_pol_angles.shape, 49)) self.assertEqual(n_horns, 49) self.assertTrue(np.allclose(time.shape, JD.shape)) self.assertTrue(np.allclose(theta.shape, JD.shape)) self.assertTrue(np.allclose(theta.shape, phi.shape)) self.assertTrue(np.allclose(psi.shape, phi.shape)) self.assertTrue( np.allclose(psi.shape, fp_pointings_spherical.shape[-2])) self.assertTrue( np.allclose(Alt.shape, fp_pointings_spherical.shape[:-1])) self.assertTrue(np.allclose(Alt.shape, Az.shape)) self.assertTrue(np.allclose(Dec.shape, Az.shape)) self.assertTrue(np.allclose(Dec.shape, Ra.shape)) self.assertTrue(np.allclose(polarization_angles.shape, Ra.shape)) self.assertTrue(np.allclose(time.shape, Ra.shape[-1])) self.assertTrue( np.allclose(fp_pointings_spherical.shape[-2], time.shape)) obs_time = (0, 2, 0, 0, 0) sampling_rate = 2 zenith_distance, polarization_angle = (10, 0) rpm = 5 n1, n2 = (15, None) day1, day2 = (1, None) packed_values1 = st.get_scanning_strategy( obs_time, sampling_rate, zenith_distance, polarization_angle, rpm, n=n1, day=day2, LCT_start=(0, 0, 0), LCD_start=(1, 1, 2018), UTC=0, DST=0, LAT=np.array([28, 16, 24]), LONG=np.array([-16, 38, 32]), Height=2400, fp_theta_path='./ScanningTools/fp_data/fp_theta.txt', fp_phi_path='./ScanningTools/fp_data/fp_phi.txt', fp_psi_path='./ScanningTools/fp_data/fp_psi.txt') packed_values2 = st.get_scanning_strategy( obs_time, sampling_rate, zenith_distance, polarization_angle, rpm, n=n2, day=day1, LCT_start=(0, 0, 0), LCD_start=(1, 1, 2018), UTC=0, DST=0, LAT=np.array([28, 16, 24]), LONG=np.array([-16, 38, 32]), Height=2400, fp_theta_path='./ScanningTools/fp_data/fp_theta.txt', fp_phi_path='./ScanningTools/fp_data/fp_phi.txt', fp_psi_path='./ScanningTools/fp_data/fp_psi.txt') general_tests(packed_values1) general_tests(packed_values2)
angles = np.array([[-10, 45, 59], [30, 35, 15], [-180, 25, 20], [3, 4, 5]]) hours = np.array([[23, 59, 16], [7, 56, 59]]) t = np.array([1.546585, -0.56, 0.3333333333333333333, -1.001]) ### INSTRUMENT CHARACTERISTICS ### pointing_accuracy = np.array([0, 0, 25]) #deg (arcsec) ### ### LOCATION INFORMATION ### LAT = np.array([28, 16, 24]) #deg LONG = np.array([-16, 38, 32]) #deg Height = 2400 #m loc = st.get_location(LAT, LONG, Height) ### ### TIME INFORMATION ### LCT_start = (0, 0, 0) #h, m, s LCD_start = (1, 1, 2015) #g, m, y UTC, DST = (0, 0) #h ### ### ENGINE ROTATION INFORMATION ### zenith_distance = 31 #deg polarization_angle = 60 #deg ### class TestScanningTools(unittest.TestCase):