def test_slice_time_axis(time_intervals): axis = TimeMapAxis(time_intervals["t_min"], time_intervals["t_max"], time_intervals["t_ref"]) new_axis = axis.slice([2, 6, 9]) squashed = axis.squash() assert new_axis.nbin == 3 assert_allclose(squashed.time_max[0].mjd, 58937.041667) assert squashed.nbin == 1 assert_allclose(squashed.time_max[0].mjd, 58937.041667)
def test_bad_length_sort_time_axis(time_intervals): tref = time_intervals["t_ref"] tmin = time_intervals["t_min"] tmax_reverse = time_intervals["t_max"][::-1] tmax_short = time_intervals["t_max"][:-1] with pytest.raises(ValueError): TimeMapAxis(tmin, tmax_reverse, tref, name="time") with pytest.raises(ValueError): TimeMapAxis(tmin, tmax_short, tref, name="time")
def test_incorrect_time_axis(): tmin = np.linspace(0, 10, 20) * u.h tmax = np.linspace(1, 11, 20) * u.h # incorrect reference time with pytest.raises(ValueError): TimeMapAxis(tmin, tmax, reference_time=51000 * u.d, name="time") # overlapping time intervals with pytest.raises(ValueError): TimeMapAxis(tmin, tmax, reference_time=Time.now(), name="time")
def test_slice_squash_time_axis(time_intervals): axis = TimeMapAxis(time_intervals["t_min"], time_intervals["t_max"], time_intervals["t_ref"]) axis_squash = axis.squash() axis_slice = axis.slice(slice(1, 5)) assert axis_squash.nbin == 1 assert_allclose(axis_squash.time_min[0].mjd, 58927) assert_allclose(axis_squash.time_delta.to_value("d"), 10.04166666) assert axis_slice.nbin == 4 assert_allclose(axis_slice.time_delta.to_value("d")[0], 0.04166666666) assert axis_squash != axis_slice
def _make_source_object(self, index): """Make one source object. Parameters ---------- index : int Row index Returns ------- source : `SourceCatalogObject` Source object """ data = table_row_to_dict(self.table[index]) data[SourceCatalogObject._row_index_key] = index fp_energy_edges = getattr(self, "flux_points_energy_edges", None) if fp_energy_edges: data["fp_energy_edges"] = fp_energy_edges hist_table = getattr(self, "hist_table", None) hist2_table = getattr(self, "hist2_table", None) if hist_table: try: data["time_axis"] = TimeMapAxis.from_table(hist_table, format="fermi-fgl") except KeyError: pass if hist2_table: try: data["time_axis_2"] = TimeMapAxis.from_table( hist2_table, format="fermi-fgl") except KeyError: pass if "Extended_Source_Name" in data: name_extended = data["Extended_Source_Name"].strip() elif "Source_Name" in data: name_extended = data["Source_Name"].strip() else: name_extended = None try: idx = self._lookup_extended_source_idx[name_extended] data_extended = table_row_to_dict(self.extended_sources_table[idx]) except (KeyError, AttributeError): data_extended = None source = self.source_object_class(data, data_extended) return source
def test_TimeMapAxis_format_plot_xaxis(time_intervals): import matplotlib.pyplot as plt axis = TimeMapAxis(time_intervals["t_min"], time_intervals["t_max"], time_intervals["t_ref"], name="time") with mpl_plot_check(): ax = plt.gca() with quantity_support(): ax.plot(axis.center, np.ones_like(axis.center)) ax1 = axis.format_plot_xaxis(ax=ax) assert ax1.xaxis.label.properties()["text"] == "Time [iso]"
def test_time_axis(time_intervals): axis = TimeMapAxis(time_intervals["t_min"], time_intervals["t_max"], time_intervals["t_ref"]) axis_copy = axis.copy() assert axis.nbin == 20 assert axis.name == "time" assert axis.node_type == "intervals" assert_allclose(axis.time_delta.to_value("min"), 60) assert_allclose(axis.time_mid[0].mjd, 58927.020833333336) assert "time" in axis.__str__() assert "20" in axis.__str__() with pytest.raises(ValueError): axis.assert_name("bad") assert axis_copy == axis assert not axis.is_contiguous ax_cont = axis.to_contiguous() assert_allclose(ax_cont.nbin, 39)
def test_time_axis_plot_helpers(): time_ref = Time('1999-01-01T00:00:00.123456789') time_axis = TimeMapAxis(edges_min=[0, 1, 3] * u.d, edges_max=[0.8, 1.9, 5.4] * u.d, reference_time=time_ref) labels = time_axis.as_plot_labels assert labels[0] == "1999-01-01 00:00:00.123 - 1999-01-01 19:12:00.123" center = time_axis.as_plot_center assert center[0].year == 1999 edges = time_axis.to_contiguous().as_plot_edges assert edges[0].year == 1999
def test_mixed_axes(): label_axis = LabelMapAxis(labels=["label-1", "label-2", "label-3"], name="label") time_axis = TimeMapAxis( edges_min=[1, 10] * u.day, edges_max=[2, 13] * u.day, reference_time=Time("2020-03-19"), ) energy_axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=4) axes = MapAxes(axes=[energy_axis, time_axis, label_axis]) coords = axes.get_coord() assert coords["label"].shape == (1, 1, 3) assert coords["energy"].shape == (4, 1, 1) assert coords["time"].shape == (1, 2, 1) idx = axes.coord_to_idx(coords) assert_allclose(idx[0], np.arange(4).reshape((4, 1, 1))) assert_allclose(idx[1], np.arange(2).reshape((1, 2, 1))) assert_allclose(idx[2], np.arange(3).reshape((1, 1, 3))) hdu = axes.to_table_hdu(format="gadf") table = Table.read(hdu) assert table["LABEL"].dtype == np.dtype("<U7") assert len(table) == 24
def test_from_time_edges_time_axis(): t0 = Time("2020-03-19") t_min = t0 + np.linspace(0, 10, 20) * u.d t_max = t_min + 1 * u.h axis = TimeMapAxis.from_time_edges(t_min, t_max) axis_h = TimeMapAxis.from_time_edges(t_min, t_max, unit="h") assert axis.nbin == 20 assert axis.name == "time" assert_time_allclose(axis.reference_time, t0) assert_allclose(axis.time_delta.to_value("min"), 60) assert_allclose(axis.time_mid[0].mjd, 58927.020833333336) assert_allclose(axis_h.time_delta.to_value("h"), 1) assert_allclose(axis_h.time_mid[0].mjd, 58927.020833333336) assert axis == axis_h
def plot(self, time_range, ax=None, **kwargs): """ Plot Temporal Model. Parameters ---------- time_range : `~astropy.time.Time` times to plot the model ax : `~matplotlib.axes.Axes`, optional Axis to plot on **kwargs : dict Keywords forwarded to `~matplotlib.pyplot.errorbar` Returns ------- ax : `~matplotlib.axes.Axes`, optional axis """ time_min, time_max = time_range time_axis = TimeMapAxis.from_time_bounds(time_min=time_min, time_max=time_max, nbin=100) time_axis.time_format = "mjd" m = RegionNDMap.create(region=None, axes=[time_axis]) kwargs.setdefault("marker", "None") kwargs.setdefault("ls", "-") kwargs.setdefault("xerr", None) m.quantity = self(time_axis.time_mid) ax = m.plot(ax=ax, **kwargs) ax.set_ylabel("Norm / A.U.") return ax
def test_map_time_axis_read_write(map_type): time_axis = TimeMapAxis( edges_min=[0, 2, 4] * u.d, edges_max=[1, 3, 5] * u.d, reference_time="2000-01-01", ) energy_axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=5) m = Map.create( binsz=0.1, width=10.0, map_type=map_type, skydir=SkyCoord(0.0, 30.0, unit="deg"), axes=[energy_axis, time_axis], ) hdulist = m.to_hdulist(hdu="COUNTS") m2 = Map.from_hdulist(hdulist) time_axis_new = m2.geom.axes["time"] assert time_axis_new == time_axis assert time_axis.reference_time.scale == "utc" assert time_axis_new.reference_time.scale == "tt"
def test_map_with_time_axis(time_intervals): time_axis = TimeMapAxis(time_intervals["t_min"], time_intervals["t_max"], time_intervals["t_ref"]) energy_axis = MapAxis.from_energy_bounds(0.1, 10, 2, unit="TeV") region_map = RegionNDMap.create(region="fk5; circle(0,0,0.1)", axes=[energy_axis, time_axis]) assert region_map.geom.data_shape == (20, 2, 1, 1)
def test_from_gti_time_axis(): filename = "$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz" filename = make_path(filename) gti = GTI.read(filename) axis = TimeMapAxis.from_gti(gti) expected = Time(53090.123451203704, format="mjd", scale="tt") assert_time_allclose(axis.time_min[0], expected) assert axis.nbin == 1
def run(self, datasets): """Run light curve extraction. Normalize integral and energy flux between emin and emax. Parameters ---------- datasets : list of `~gammapy.datasets.SpectrumDataset` or `~gammapy.datasets.MapDataset` Spectrum or Map datasets. Returns ------- lightcurve : `~gammapy.estimators.FluxPoints` Light curve flux points """ datasets = Datasets(datasets) if self.time_intervals is None: gti = datasets.gti else: gti = GTI.from_time_intervals(self.time_intervals) gti = gti.union(overlap_ok=False, merge_equal=False) rows = [] valid_intervals = [] for t_min, t_max in progress_bar(gti.time_intervals, desc="Time intervals"): datasets_to_fit = datasets.select_time(time_min=t_min, time_max=t_max, atol=self.atol) if len(datasets_to_fit) == 0: log.info( f"No Dataset for the time interval {t_min} to {t_max}. Skipping interval." ) continue valid_intervals.append([t_min, t_max]) fp = self.estimate_time_bin_flux(datasets=datasets_to_fit) for name in ["counts", "npred", "npred_null"]: fp._data[name] = self.expand_map(fp._data[name], dataset_names=datasets.names) rows.append(fp) if len(rows) == 0: raise ValueError( "LightCurveEstimator: No datasets in time intervals") gti = GTI.from_time_intervals(valid_intervals) axis = TimeMapAxis.from_gti(gti=gti) return FluxPoints.from_stack( maps=rows, axis=axis, )
def test_single_interval_time_axis(time_interval): axis = TimeMapAxis(edges_min=time_interval["t_min"], edges_max=time_interval["t_max"], reference_time=time_interval["t_ref"]) coord = Time(58933, format="mjd") + u.Quantity([1.5, 3.5, 10], unit="d") pix = axis.coord_to_pix(coord) assert axis.nbin == 1 assert_allclose(axis.time_delta.to_value("d"), 10) assert_allclose(axis.time_mid[0].mjd, 58933) pix_min = axis.coord_to_pix(time_interval["t_min"] + 0.001 * u.s) assert_allclose(pix_min, -0.5) pix_max = axis.coord_to_pix(time_interval["t_max"] - 0.001 * u.s) assert_allclose(pix_max, 0.5) assert_allclose(pix, [0.15, 0.35, np.nan])
def test_from_table_time_axis(): t0 = Time("2006-02-12", scale="utc") t_min = np.linspace(0, 10, 10) * u.d t_max = t_min + 12 * u.h table = Table() table["TIME_MIN"] = t_min table["TIME_MAX"] = t_max table.meta.update(time_ref_to_dict(t0)) table.meta["AXCOLS1"] = "TIME_MIN,TIME_MAX" axis = TimeMapAxis.from_table(table, format="gadf") assert axis.nbin == 10 assert_allclose(axis.time_mid[0].mjd, 53778.25)
def test_axes_basics(): energy_axis = MapAxis.from_energy_edges([1, 3] * u.TeV) time_ref = Time('1999-01-01T00:00:00.123456789') time_axis = TimeMapAxis(edges_min=[0, 1, 3] * u.d, edges_max=[0.8, 1.9, 5.4] * u.d, reference_time=time_ref) axes = MapAxes([energy_axis, time_axis]) assert axes.shape == (1, 3) assert axes.is_unidimensional assert not axes.is_flat assert axes.primary_axis.name == "time"
def test_region_nd_map_plot_two_axes(): energy_axis = MapAxis.from_energy_edges([1, 3, 10] * u.TeV) time_ref = Time('1999-01-01T00:00:00.123456789') time_axis = TimeMapAxis(edges_min=[0, 1, 3] * u.d, edges_max=[0.8, 1.9, 5.4] * u.d, reference_time=time_ref) m = RegionNDMap.create("icrs;circle(0, 0, 1)", axes=[energy_axis, time_axis]) m.data = 10 + np.random.random(m.data.size) with mpl_plot_check(): m.plot(axis_name="energy") with mpl_plot_check(): m.plot(axis_name="time") with pytest.raises(ValueError): m.plot()
def test_coord_to_idx_time_axis(time_intervals): tmin = time_intervals["t_min"] tmax = time_intervals["t_max"] tref = time_intervals["t_ref"] axis = TimeMapAxis(tmin, tmax, tref, name="time") time = Time(58927.020833333336, format="mjd") times = axis.time_mid times[::2] += 1 * u.h times = times.insert(0, tref - [1, 2] * u.yr) idx = axis.coord_to_idx(time) indices = axis.coord_to_idx(times) pix = axis.coord_to_pix(time) pixels = axis.coord_to_pix(times) assert idx == 0 assert_allclose(indices[1::2], [-1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19]) assert_allclose(indices[::2], -1) assert_allclose(pix, 0, atol=1e-10) assert_allclose(pixels[1::2], [np.nan, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])
def test_time_map_axis_from_time_bounds(): t_min = Time("2006-02-12", scale="utc") t_max = t_min + 12 * u.h axis = TimeMapAxis.from_time_bounds(time_min=t_min, time_max=t_max, nbin=3) assert_allclose(axis.center, [0.083333, 0.25, 0.416667] * u.d, rtol=1e-5)