def test_goes_chianti_tem_case3(): # test case 3: satellite < 8 and != 6, abundances = coronal temp3, em3 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=5, date=DATE, abundances="coronal") assert all(temp3 < Quantity([11.43], unit="MK")) and \ all(temp3 > Quantity([11.42], unit="MK")) assert all(em3 < Quantity([3.85e+48], unit="1/cm**3")) and \ all(em3 > Quantity([3.84e+48], unit="1/cm**3"))
def test_goes_chianti_tem_case8(): # test case 8: satellite = 6, date > 1983-06-28, abundances = photospheric temp8, em8 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=6, date=DATE, abundances="photospheric") assert all(temp8 < Quantity(10.36, unit="MK")) and \ all(temp8 > Quantity(10.35, unit="MK")) assert all(em8 < Quantity(9.39e+48, unit="1/cm**3")) and \ all(em8 > Quantity(9.38e+48, unit="1/cm**3"))
def test_goes_chianti_tem_case2(): # test case 2: satellite > 7, abundances = photospheric temp2, em2 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=15, date=DATE, abundances="photospheric") assert all(temp2 < Quantity([10.25], unit="MK")) and \ all(temp2 > Quantity([10.24], unit="MK")) assert all(em2 < Quantity([1.12e+49], unit="1/cm**3")) and \ all(em2 > Quantity([1.11e+49], unit="1/cm**3"))
def test_goes_chianti_tem_case7(): # test case 7: satellite = 6, date > 1983-06-28, abundances = coronal temp7, em7 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=6, date=DATE, abundances="coronal") assert all(temp7 < Quantity(11.34, unit="MK")) and \ all(temp7 > Quantity(11.33, unit="MK")) assert all(em7 < Quantity(4.08e+48, unit="1/cm**3")) and \ all(em7 > Quantity(4.07e+48, unit="1/cm**3"))
def test_goes_chianti_tem_case6(): # test case 6: satellite = 6, date < 1983-06-28, abundances = photospheric temp6, em6 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=6, date="1983-06-27", abundances="photospheric") assert all(temp6 < Quantity(11.44, unit="MK")) and \ all(temp6 > Quantity(11.43, unit="MK")) assert all(em6 < Quantity(6.74e+48, unit="1/cm**3")) and \ all(em6 > Quantity(6.73e+48, unit="1/cm**3"))
def test_goes_chianti_tem_case5(): # test case 5: satellite = 6, date < 1983-06-28, abundances = coronal temp5, em5 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=6, date="1983-06-27", abundances="coronal") assert all(temp5 < Quantity(12.30, unit="MK")) and \ all(temp5 > Quantity(12.29, unit="MK")) assert all(em5 < Quantity(3.13e+48, unit="1/cm**3")) and \ all(em5 > Quantity(3.12e+48, unit="1/cm**3"))
def test_goes_chianti_tem_case4(): # test case 4: satellite < 8 and != 6, abundances = photospheric temp4, em4 = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=5, date=DATE, abundances="photospheric") assert all(temp4 < Quantity([10.42], unit="MK")) and \ all(temp4 > Quantity([10.41], unit="MK")) assert all(em4 < Quantity(8.81e+48, unit="1/cm**3")) and \ all(em4 > Quantity(8.80e+48, unit="1/cm**3"))
def test_calc_rad_loss_nokwags(): # Define input variables temp = Quantity([11.0, 11.0, 11.0, 11.0, 11.0, 11.0], unit="MK") em = Quantity([4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48], unit="1/cm**3") # Test output is correct when no kwags are set. rad_loss_test = goes._calc_rad_loss(temp[:2], em[:2]) rad_loss_expected = {"rad_loss_rate": 3.01851392e+19 * Quantity(np.ones(2), unit="J/s")} assert sorted(rad_loss_test.keys()) == sorted(rad_loss_expected.keys()) assert_quantity_allclose(rad_loss_test["rad_loss_rate"], rad_loss_expected["rad_loss_rate"], rtol=0.01)
def test_quantity_asanyarray(): array_of_quantities = [Quantity(1), Quantity(2), Quantity(3)] quantity_array = quantity_asanyarray(array_of_quantities) assert isinstance(quantity_array, Quantity) assert np.issubdtype(quantity_array.dtype, np.inexact) array_of_integers = [1, 2, 3] np_array = quantity_asanyarray(array_of_integers) assert isinstance(np_array, np.ndarray) assert np.issubdtype(np_array.dtype, np.integer) np_array = quantity_asanyarray(array_of_integers, dtype=np.inexact) assert np.issubdtype(np_array.dtype, np.inexact)
def test_goes_lx_date(): # Define input values of flux and time. longflux = Quantity([7e-6, 7e-6, 7e-6, 7e-6, 7e-6, 7e-6], unit="W/m**2") shortflux = Quantity([7e-7, 7e-7, 7e-7, 7e-7, 7e-7, 7e-7], unit="W/m**2") # Test output when date kwarg is set. lx_test = goes._goes_lx(longflux[:2], shortflux[:2], date="2014-04-21") lx_expected = {"longlum": Quantity([1.98649103e+18, 1.98649103e+18], unit="W"), "shortlum": Quantity([1.98649103e+17, 1.98649103e+17], unit="W")} assert sorted(lx_test.keys()) == sorted(lx_expected.keys()) assert_quantity_allclose(lx_test["longlum"], lx_expected["longlum"], rtol=0.001) assert_quantity_allclose(lx_test["shortlum"], lx_expected["shortlum"], rtol=0.001)
def test_goes_lx_obstime(): # Define input values of flux and time. longflux = Quantity([7e-6, 7e-6, 7e-6, 7e-6, 7e-6, 7e-6], unit="W/m**2") shortflux = Quantity([7e-7, 7e-7, 7e-7, 7e-7, 7e-7, 7e-7], unit="W/m**2") obstime = np.array([datetime.datetime(2014, 1, 1, 0, 0, 0), datetime.datetime(2014, 1, 1, 0, 0, 2), datetime.datetime(2014, 1, 1, 0, 0, 4), datetime.datetime(2014, 1, 1, 0, 0, 6), datetime.datetime(2014, 1, 1, 0, 0, 8), datetime.datetime(2014, 1, 1, 0, 0, 10)], dtype=object) # Test output when obstime and cumulative kwargs are set. lx_test = goes._goes_lx(longflux, shortflux, obstime) lx_expected = { "longlum": 1.96860565e+18 * Quantity(np.ones(6), unit='W'), "shortlum": 1.96860565e+17 * Quantity(np.ones(6), unit='W'), "longlum_int": Quantity([1.96860565e+19], unit="J"), "shortlum_int": Quantity([1.96860565e+18], unit="J"), "longlum_cumul": Quantity([3.93721131e+18, 7.87442262e+18, 1.18116339e+19, 1.57488452e+19, 1.96860565e+19], unit="J"), "shortlum_cumul": Quantity([3.93721131e+17, 7.87442262e+17, 1.18116339e+18, 1.57488452e+18, 1.96860565e+18], unit="J")} assert sorted(lx_test.keys()) == sorted(lx_expected.keys()) assert_quantity_allclose(lx_test["longlum"], lx_expected["longlum"], rtol=0.1) assert_quantity_allclose(lx_test["shortlum"], lx_expected["shortlum"], rtol=0.1) assert_quantity_allclose(lx_test["longlum_int"], lx_expected["longlum_int"], rtol=0.1) assert_quantity_allclose(lx_test["shortlum_int"], lx_expected["shortlum_int"], rtol=0.1) assert_quantity_allclose(lx_test["longlum_cumul"], lx_expected["longlum_cumul"], rtol=0.1) assert_quantity_allclose(lx_test["shortlum_cumul"], lx_expected["shortlum_cumul"], rtol=0.1)
def __init__(self, rate, angle, ra0=None, dec0=None, t0=None): self.rate = rate self.angle = angle self.t0 = t0 self.ra0 = Quantity(ra0) self.dec0 = Quantity(dec0) self.coordinate = None print("Combining frame at {} along angle {}".format( self.rate, self.angle)) r = self.rate.to('arcsec/hour').value a = self.angle.to('degree').value self.name = "R{:06.1f}A{:05.1f}".format(r, a) logging.debug( "Computing for rate: {} and angle: {} centred at {} {}".format( self.rate, self.angle, self.ra0, self.dec0))
def lst_to_array(lst, mask=None): """ Simple method to convert a list to an array Allows for a list of Quantity objects Parameters ---------- lst : list Should be number or Quantities mask : boolean array, optional Returns ------- array or Quantity array """ if mask is None: mask = np.array([True] * len(lst)) if isinstance(lst[0], Quantity): return Quantity(lst)[mask] else: return np.array(lst)[mask] # Generate the Table tbl = Table(clms, names=attrib) # Return return tbl
def RV_timeseries(self, ts, recalc=False): """ Radial Velocity time series for star 1 at given times ts. :param ts: Times. If not ``Quantity``, assumed to be in days. :type ts: array-like or ``Quantity`` :param recalc: (optional) If ``False``, then if called with the exact same ``ts`` as last call, it will return cached calculation. """ if type(ts) != Quantity: ts *= u.day if not recalc and hasattr(self, 'RV_measurements'): if (ts == self.ts).all(): return self._RV_measurements else: pass RVs = Quantity(np.zeros((len(ts), self.N)), unit='km/s') for i, t in enumerate(ts): RVs[i, :] = self.dRV(t, com=True) self._RV_measurements = RVs self.ts = ts return RVs
def test_gain_correct_quantity(ccd_data): init_data = ccd_data.data g = Quantity(3, u.electron / u.adu) ccd_data = gain_correct(ccd_data, gain=g) assert_array_equal(ccd_data.data, 3 * init_data) assert ccd_data.unit == u.electron
def test_goes_chianti_tem_errors(): # Define input variables. ratio = SHORTFLUX / LONGFLUX shortflux_toomany = Quantity(np.append(SHORTFLUX.value, SHORTFLUX.value[0]), unit="W/m**2") shortflux_toosmall = copy.deepcopy(SHORTFLUX) shortflux_toosmall.value[0] = -1 shortflux_toobig = copy.deepcopy(SHORTFLUX) shortflux_toobig.value[0] = 1 temp_test = Quantity(np.zeros(len(LONGFLUX)) + 10, unit="MK") temp_test_toomany = Quantity(np.append(temp_test.value, 0), unit="MK") temp_test_toosmall = copy.deepcopy(temp_test) temp_test_toosmall.value[0] = -1 temp_test_toobig = copy.deepcopy(temp_test) temp_test_toobig.value[0] = 101 # First test correct exceptions are raised if incorrect inputs are # entered. with pytest.raises(ValueError): temp, em = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, satellite=-1) with pytest.raises(ValueError): temp, em = goes._goes_chianti_tem(LONGFLUX, shortflux_toomany) with pytest.raises(ValueError): temp = goes._goes_get_chianti_temp(ratio, satellite=-1) with pytest.raises(ValueError): temp, em = goes._goes_chianti_tem(LONGFLUX, SHORTFLUX, abundances="Neither") with pytest.raises(ValueError): temp = goes._goes_get_chianti_temp(ratio, abundances="Neither") with pytest.raises(ValueError): temp, em = goes._goes_chianti_tem(LONGFLUX, shortflux_toobig) with pytest.raises(ValueError): em = goes._goes_get_chianti_em(LONGFLUX, temp_test, satellite=-1) with pytest.raises(ValueError): em = goes._goes_get_chianti_em(LONGFLUX, temp_test, abundances="Neither") with pytest.raises(ValueError): em = goes._goes_get_chianti_em(LONGFLUX, temp_test, abundances="Neither") with pytest.raises(ValueError): em = goes._goes_get_chianti_em(LONGFLUX, temp_test_toosmall) with pytest.raises(ValueError): em = goes._goes_get_chianti_em(LONGFLUX, temp_test_toobig)
def test_valid_ellipse_ds9(): reg_str1 = "image\nellipse (1, 2, 3, 4, 5)" reg_str2 = "fk5\nellipse (1, 2, 3, 4, 5)" reg_str3 = "image\nellipse (1, 2, 3, 4, 5, 6, 7)" # Elliptical Annulus shape1 = DS9Parser(reg_str1, 'warn').shapes[0] shape2 = DS9Parser(reg_str2, 'warn').shapes[0] shape3 = DS9Parser(reg_str3, 'warn').shapes[0] assert_quantity_allclose(shape1.coord[:2], [0, 1]) assert_quantity_allclose( shape2.coord[:2], [Quantity("1deg"), Quantity("2deg")]) assert_quantity_allclose(shape3.coord[:2], [0, 1]) assert_quantity_allclose(shape1.coord[2:-1], [6, 8]) assert_quantity_allclose( shape2.coord[2:-1], [Quantity("6deg"), Quantity("8deg")]) assert_quantity_allclose(shape3.coord[2:-1], [6, 8, 10, 12]) assert_quantity_allclose(shape1.coord[-1], Quantity("5deg")) assert_quantity_allclose(shape2.coord[-1], Quantity("5deg")) assert_quantity_allclose(shape3.coord[-1], Quantity("7deg"))
def x0(self): """X-axis coordinate of the first data point :type: `~astropy.units.Quantity` scalar """ try: return self._x0 except AttributeError: self._x0 = Quantity(0, self.xunit) return self._x0
def test_calculate_xray_luminosity(): # Check correct exceptions are raised to incorrect inputs not_goeslc = [] with pytest.raises(TypeError): goes_test = goes.calculate_xray_luminosity(not_goeslc) # Check function gives correct results. goeslc_input = lightcurve.GOESLightCurve.create("2014-01-01 00:00:00", "2014-01-01 00:00:10") goeslc_test = goes.calculate_xray_luminosity(goeslc_input) goeslc_expected = copy.deepcopy(goeslc_input) goeslc_expected.data["luminosity_xrsa"] = \ Quantity(np.array([2.49831950e+16, 2.49831950e+16, 2.49831950e+16, 2.52864004e+16, 2.49831950e+16], dtype="float32"), unit="J/s") goeslc_expected.data["luminosity_xrsb"] = \ Quantity(np.array([9.54399250e+17, 9.54399250e+17, 9.52985195e+17, 9.52985195e+17, 9.51571139e+17], dtype="float32"), unit="J/s") assert_frame_equal(goeslc_test.data, goeslc_expected.data)
def test_simulate_hexitec_on_photon_list_1pixel(): """Test simulate_masking_photon_list_1pixel().""" # Define a HexitecPileUp object. hpu = hexitec_simulation.HexitecSimulation(frame_rate=FRAME_RATE, detector_temperature=17 * u.deg_C, bias_voltage=-500 * u.V) # Define input photon list and waiting times. photon_energies = Quantity([1, 1, 2, 3, 5, 4, 6, 7, 8, 9, 10], unit=u.keV) photon_times = Quantity(np.array([ 0.25, 0.75, 1.25, 1.75, 2.25, 2.75, 4.5, 6., 7.5, 7.5, (hexitec_simulation.DATAFRAME_MAX_POINTS * hpu._sample_step / hpu.frame_duration).si.value + 0.5 ]) * hpu.frame_duration, unit=u.s) incident_photons = Table([photon_times, photon_energies], names=("time", "energy")) # Define expected output photon list. f = hpu._voltage_pulse_shape[np.where( hpu._voltage_pulse_shape == max(hpu._voltage_pulse_shape))[0][0] - 1] expected_energies = Quantity([1, 3, 5, 6, 7 * f, 7, 17, 10], unit=u.keV) expected_times = np.array([ 0., 1., 2., 4., 5., 6., 7., (hexitec_simulation.DATAFRAME_MAX_POINTS * hpu._sample_step / hpu.frame_duration).si.value ]) * hpu.frame_duration expected_next_frame_energy = Quantity([0., 0., 0., 0., 7., 0., 0., 0.], unit=u.keV) expected_photons = Table( [expected_times, expected_energies, expected_next_frame_energy], names=("time", "energy", "next frame first energy")) # Calculate test measured photon list by calling # simulate_hexitec_photon_list_1pixel(). hpu.measured_photons = hpu.simulate_hexitec_on_photon_list_1pixel( incident_photons) # Assert test photon list is the same as expected photon list. np.testing.assert_allclose(hpu.measured_photons["time"], expected_photons["time"], atol=hpu.frame_duration.to( hpu.measured_photons["time"].unit).value) assert all(hpu.measured_photons["energy"] == expected_photons["energy"]) assert all(hpu.measured_photons["next frame first energy"] == \ expected_photons["next frame first energy"])
def test_tagged_object_array(tmpdir): # See https://github.com/spacetelescope/asdf/issues/383 for feature # request astropy = pytest.importorskip('astropy') from astropy.units.quantity import Quantity objdata = np.empty((3, 3), dtype=object) for i, _ in enumerate(objdata.flat): objdata.flat[i] = Quantity(i, 'angstrom') helpers.assert_roundtrip_tree({'bizbaz': objdata}, tmpdir)
def x0(self, value): if value is None: del self.x0 return if not isinstance(value, Quantity): try: value = Quantity(value, self.xunit) except TypeError: value = Quantity(float(value), self.xunit) # if setting new x0, delete xindex ''' try: x0 = self._x0 except AttributeError: del self.xindex else: if value is None or self.x0 is None or value != x0: del self.xindex ''' self._x0 = value
def _enter_column_into_table_as_quantity(header_property_name, header, header_colnames, data, unit): """Used in initiation of IRISSpectrograph to convert auxiliary data to Quantities.""" index = np.where(np.array(header_colnames) == header_property_name)[0] if len(index) == 1: index = index[0] else: raise ValueError("Multiple property names equal to {0}".format( header_property_name)) pop_colname = header_colnames.pop(index) return Quantity(data[:, header[pop_colname]], unit=unit)
def test_calc_rad_loss_errors(): # Define input variables temp = 11.0 * Quantity(np.ones(6), unit="MK") em = 4.0e+48 * Quantity(np.ones(6), unit="1/cm**3") obstime = np.array([ datetime.datetime(2014, 1, 1, 0, 0, 0), datetime.datetime(2014, 1, 1, 0, 0, 2), datetime.datetime(2014, 1, 1, 0, 0, 4), datetime.datetime(2014, 1, 1, 0, 0, 6), datetime.datetime(2014, 1, 1, 0, 0, 8), datetime.datetime(2014, 1, 1, 0, 0, 10) ], dtype=object) temp_toolong = Quantity(np.append(temp.value, 0), unit="MK") obstime_toolong = np.array([ datetime.datetime(2014, 1, 1, 0, 0, 0), datetime.datetime(2014, 1, 1, 0, 0, 2), datetime.datetime(2014, 1, 1, 0, 0, 4), datetime.datetime(2014, 1, 1, 0, 0, 6), datetime.datetime(2014, 1, 1, 0, 0, 8), datetime.datetime(2014, 1, 1, 0, 0, 10), datetime.datetime(2014, 1, 1, 0, 0, 12) ], dtype=object) obstime_nonchrono = copy.deepcopy(obstime) obstime_nonchrono[1] = obstime[-1] obstime_nonchrono[-1] = obstime[1] obstime_notdatetime = copy.deepcopy(obstime) obstime_notdatetime[0] = 1 temp_outofrange = Quantity([101, 11.0, 11.0, 11.0, 11.0, 11.0], unit="MK") # Ensure correct exceptions are raised. with pytest.raises(ValueError): rad_loss_test = goes._calc_rad_loss(temp_toolong, em, obstime) with pytest.raises(ValueError): rad_loss_test = goes._calc_rad_loss(temp_outofrange, em, obstime) with pytest.raises(IOError): rad_loss_test = goes._calc_rad_loss(temp, em, obstime_toolong) with pytest.raises(TypeError): lx_test = goes._calc_rad_loss(temp, em, obstime_notdatetime) with pytest.raises(ValueError): rad_loss_test = goes._calc_rad_loss(temp, em, obstime_nonchrono)
def _make_quantity(parameters: Dict[str, Any]): parsed = {} for name, value in parameters.items(): if value == {}: pass elif name.isupper(): parsed[name] = value elif name.islower(): parsed[name] = Quantity(value) else: parsed[name] = Angle(value) return parsed
def test_goes_lx_errors(): # Define input values of flux and time. longflux = 7e-6 * Quantity(np.ones(6), unit="W/m**2") shortflux = 7e-7 * Quantity(np.ones(6), unit="W/m**2") obstime = np.array([datetime.datetime(2014, 1, 1, 0, 0, 0), datetime.datetime(2014, 1, 1, 0, 0, 2), datetime.datetime(2014, 1, 1, 0, 0, 4), datetime.datetime(2014, 1, 1, 0, 0, 6), datetime.datetime(2014, 1, 1, 0, 0, 8), datetime.datetime(2014, 1, 1, 0, 0, 10)], dtype=object) longflux_toolong = Quantity(np.append(longflux.value, 0), unit=longflux.unit) obstime_nonchrono = copy.deepcopy(obstime) obstime_nonchrono[1] = obstime[-1] obstime_notdatetime = copy.deepcopy(obstime) obstime_notdatetime[0] = 1 # Ensure correct exceptions are raised. with pytest.raises(ValueError): lx_test = goes._goes_lx(longflux_toolong, shortflux, obstime) with pytest.raises(TypeError): lx_test = goes._goes_lx(longflux, shortflux, obstime_notdatetime) with pytest.raises(ValueError): lx_test = goes._goes_lx(longflux, shortflux, obstime_nonchrono)
def __new__(cls, value, vunit=None, # Quantity attrs dx=None, x0=None, xunit=None, name=None, # Series attrs dtype=None, copy=True, order=None, # ndarray attrs subok=True, ndmin=0): # ndarray attrs new = super(Series, cls).__new__(cls, value, unit=vunit, dtype=dtype, copy=copy, order=order, subok=subok, ndmin=ndmin) if copy: new = new.copy() if name is not None: new.name = name if dx is not None: new.dx = Quantity(dx,unit=xunit) if x0 is not None: new.x0 = x0 new.nlen = len(value) new._series = Quantity(np.arange(new.nlen)*dx,unit=xunit) return new
def test_calc_rad_loss_obstime(): # Define input variables temp = Quantity([11.0, 11.0, 11.0, 11.0, 11.0, 11.0], unit="MK") em = Quantity([4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48], unit="1/cm**3") obstime = np.array([ datetime.datetime(2014, 1, 1, 0, 0, 0), datetime.datetime(2014, 1, 1, 0, 0, 2), datetime.datetime(2014, 1, 1, 0, 0, 4), datetime.datetime(2014, 1, 1, 0, 0, 6), datetime.datetime(2014, 1, 1, 0, 0, 8), datetime.datetime(2014, 1, 1, 0, 0, 10) ], dtype=object) # Test output is correct when obstime and cumulative kwargs are set. rad_loss_test = goes._calc_rad_loss(temp, em, obstime) rad_loss_expected = { "rad_loss_rate": 3.01851392e+19 * Quantity(np.ones(6), unit="J/s"), "rad_loss_int": Quantity(3.01851392e+20, unit="J"), "rad_loss_cumul": Quantity([ 6.03702783e+19, 1.20740557e+20, 1.81110835e+20, 2.41481113e+20, 3.01851392e+20 ], unit="J") } assert sorted(rad_loss_test.keys()) == sorted(rad_loss_expected.keys()) assert_quantity_allclose(rad_loss_test["rad_loss_rate"], rad_loss_expected["rad_loss_rate"], rtol=0.0001) assert_quantity_allclose(rad_loss_test["rad_loss_int"], rad_loss_expected["rad_loss_int"], rtol=0.0001) assert_quantity_allclose(rad_loss_test["rad_loss_cumul"], rad_loss_expected["rad_loss_cumul"], rtol=0.0001)
def test_calc_rad_loss_nokwags(): # Define input variables temp = Quantity([11.0, 11.0, 11.0, 11.0, 11.0, 11.0], unit="MK") em = Quantity([4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48, 4.0e+48], unit="1/cm**3") obstime = np.array([ parse_time((2014, 1, 1, 0, 0, 0)), parse_time((2014, 1, 1, 0, 0, 2)), parse_time((2014, 1, 1, 0, 0, 4)), parse_time((2014, 1, 1, 0, 0, 6)), parse_time((2014, 1, 1, 0, 0, 8)), parse_time((2014, 1, 1, 0, 0, 10)) ], dtype=object) # Test output is correct when no kwags are set. rad_loss_test = goes._calc_rad_loss(temp[:2], em[:2]) rad_loss_expected = { "rad_loss_rate": 3.01851392e+19 * Quantity(np.ones(2), unit="J/s") } assert sorted(rad_loss_test.keys()) == sorted(rad_loss_expected.keys()) assert_quantity_allclose(rad_loss_test["rad_loss_rate"], rad_loss_expected["rad_loss_rate"], rtol=0.01)
def test_shape_crtf(): reg_str = "circle[[18h12m24s, -23d11m00s], 2.3arcsec], linewidth=2, coord=J2000, symsize=2" parser = CRTFParser(reg_str) shape1 = parser.shapes[0] region = parser.shapes.to_regions() shape2 = to_shape_list(region, 'CRTF', 'fk5')[0] assert shape1.format_type == shape2.format_type assert shape1.coordsys == shape2.coordsys assert shape1.region_type == shape2.region_type assert shape1.include == shape2.include assert_quantity_allclose(shape1.coord, shape2.coord) # assert dict(shape1.meta) == dict(shape2.meta) assert shape1.composite == shape2.composite # Pixel origin is assumed to be 0 origin. Needs to be checked though. reg_str = "circle[[1pix, 2pix], 3pix], linewidth=2, coord=image, symsize=2" parser = CRTFParser(reg_str) shape = parser.shapes[0] assert_quantity_allclose(shape.coord, [Quantity("1"), Quantity("2"), Quantity("3")])