Package: release.debian.org Severity: normal User: release.debian....@packages.debian.org Usertags: unblock
Dear release team, please unblock astroplan in the current freeze. It solves #855477 "Failure with broadcasts in schedulers", severity: important. Changelog entry: astroplan (0.2-5) unstable; urgency=medium * Fix broadcasts in schedulers (Closes: #855477) -- Vincent Prat <vincep...@free.fr> Sat, 18 Feb 2017 16:37:34 +0100 The debdiff is attached. Requested commands: unblock astroplan/0.2-5
diff -Nru astroplan-0.2/debian/changelog astroplan-0.2/debian/changelog --- astroplan-0.2/debian/changelog 2017-01-27 20:57:06.000000000 +0100 +++ astroplan-0.2/debian/changelog 2017-02-18 16:37:34.000000000 +0100 @@ -1,3 +1,9 @@ +astroplan (0.2-5) unstable; urgency=medium + + * Fix broadcasts in schedulers (Closes: #855477) + + -- Vincent Prat <vincep...@free.fr> Sat, 18 Feb 2017 16:37:34 +0100 + astroplan (0.2-4) unstable; urgency=medium * Github patches + failures marked as known (Closes: #851437) diff -Nru astroplan-0.2/debian/patches/disable_failing_tests.patch astroplan-0.2/debian/patches/disable_failing_tests.patch --- astroplan-0.2/debian/patches/disable_failing_tests.patch 2017-01-27 20:57:06.000000000 +0100 +++ astroplan-0.2/debian/patches/disable_failing_tests.patch 1970-01-01 01:00:00.000000000 +0100 @@ -1,40 +0,0 @@ -From: Ole Streicher <oleb...@debian.org> -Subject: Mark known failures ---- a/astroplan/tests/test_scheduling.py -+++ b/astroplan/tests/test_scheduling.py -@@ -6,6 +6,7 @@ - from astropy.time import Time - import astropy.units as u - from astropy.coordinates import SkyCoord -+from astropy.tests.helper import pytest - - from ..utils import time_grid_from_range - from ..observer import Observer -@@ -103,7 +104,8 @@ - assert np.abs(schedule.slots[0].end - new_duration - start) < 1*u.second - assert schedule.slots[1].start == schedule.slots[0].end - -- -+# see https://github.com/astropy/astroplan/pull/282 -+@pytest.mark.xfail() - def test_transitioner(): - blocks = [ObservingBlock(t, 55 * u.minute, i) for i, t in enumerate(targets)] - slew_rate = 1 * u.deg / u.second -@@ -132,6 +134,8 @@ - default_transitioner = Transitioner(slew_rate=1 * u.deg / u.second) - - -+# see https://github.com/astropy/astroplan/pull/282 -+@pytest.mark.xfail() - def test_priority_scheduler(): - constraints = [AirmassConstraint(3, boolean_constraint=False)] - blocks = [ObservingBlock(t, 55*u.minute, i) for i, t in enumerate(targets)] -@@ -157,6 +161,8 @@ - scheduler(blocks, schedule) - - -+# see https://github.com/astropy/astroplan/pull/282 -+@pytest.mark.xfail() - def test_sequential_scheduler(): - constraints = [AirmassConstraint(2.5, boolean_constraint=False)] - blocks = [ObservingBlock(t, 55 * u.minute, i) for i, t in enumerate(targets)] diff -Nru astroplan-0.2/debian/patches/pull-285-Fix-broadcasting.patch astroplan-0.2/debian/patches/pull-285-Fix-broadcasting.patch --- astroplan-0.2/debian/patches/pull-285-Fix-broadcasting.patch 1970-01-01 01:00:00.000000000 +0100 +++ astroplan-0.2/debian/patches/pull-285-Fix-broadcasting.patch 2017-02-18 16:37:34.000000000 +0100 @@ -0,0 +1,891 @@ +Author: Vincent Prat <vincep...@free.fr> +Description: Fix the broadcasting issue, that caused tests to fail. + The patch comes from https://github.com/astropy/astroplan/pull/285. +--- a/astroplan/constraints.py ++++ b/astroplan/constraints.py +@@ -404,7 +404,7 @@ + observer.pressure = 0 + + # find solar altitude at these times +- altaz = observer.altaz(times, get_sun(times)) ++ altaz = observer.altaz(times, get_sun(times), grid=False) + altitude = altaz.alt + # cache the altitude + observer._altaz_cache[aakey] = dict(times=times, +@@ -447,7 +447,7 @@ + self.max = max + + def compute_constraint(self, times, observer, targets): +- sunaltaz = observer.altaz(times, get_sun(times)) ++ sunaltaz = observer.altaz(times, get_sun(times), grid=False) + target_coos = [target.coord if hasattr(target, 'coord') else target + for target in targets] + target_altazs = [observer.altaz(times, coo) for coo in target_coos] +--- a/astroplan/observer.py ++++ b/astroplan/observer.py +@@ -11,6 +11,8 @@ + get_moon, Angle, Latitude, Longitude, + UnitSphericalRepresentation) + from astropy.extern.six import string_types ++from astropy.utils import isiterable ++from astropy.utils.compat.numpy import broadcast_to + import astropy.units as u + from astropy.time import Time + from astropy.utils import isiterable +@@ -20,6 +22,8 @@ + # Package + from .exceptions import TargetNeverUpWarning, TargetAlwaysUpWarning + from .moon import moon_illumination, moon_phase_angle ++from .target import get_skycoord ++ + + __all__ = ["Observer", "MAGIC_TIME"] + +@@ -64,6 +68,14 @@ + else: + time_grid = np.linspace(start, end, N)*u.day + ++ # broadcast so grid is first index, and remaining shape of t0 ++ # falls in later indices. e.g. if t0 is shape (10), time_grid ++ # will be shape (N, 10). If t0 is shape (5, 2), time_grid is (N, 5, 2) ++ while time_grid.ndim <= t0.ndim: ++ time_grid = time_grid[:, np.newaxis] ++ # we want to avoid 1D grids since we always want to broadcast against targets ++ if time_grid.ndim == 1: ++ time_grid = time_grid[:, np.newaxis] + return t0 + time_grid + + +@@ -110,20 +122,24 @@ + """ + Parameters + ---------- +- name : str +- A short name for the telescope, observatory or location. +- + location : `~astropy.coordinates.EarthLocation` + The location (latitude, longitude, elevation) of the observatory. + +- longitude : float, str, `~astropy.units.Quantity` (optional) +- The longitude of the observing location. Should be valid input for +- initializing a `~astropy.coordinates.Longitude` object. ++ timezone : str or `datetime.tzinfo` (optional) ++ The local timezone to assume. If a string, it will be passed ++ through ``pytz.timezone()`` to produce the timezone object. ++ ++ name : str ++ A short name for the telescope, observatory or location. + + latitude : float, str, `~astropy.units.Quantity` (optional) + The latitude of the observing location. Should be valid input for + initializing a `~astropy.coordinates.Latitude` object. + ++ longitude : float, str, `~astropy.units.Quantity` (optional) ++ The longitude of the observing location. Should be valid input for ++ initializing a `~astropy.coordinates.Longitude` object. ++ + elevation : `~astropy.units.Quantity` (optional), default = 0 meters + The elevation of the observing location, with respect to sea + level. Defaults to sea level. +@@ -137,10 +153,6 @@ + temperature : `~astropy.units.Quantity` (optional) + The ambient temperature. + +- timezone : str or `datetime.tzinfo` (optional) +- The local timezone to assume. If a string, it will be passed +- through ``pytz.timezone()`` to produce the timezone object. +- + description : str (optional) + A short description of the telescope, observatory or observing + location. +@@ -336,59 +348,64 @@ + + return Time(date_time, location=self.location) + +- def _transform_target_list_to_altaz(self, times, targets): ++ def _is_broadcastable(self, shp1, shp2): ++ """Test if two shape tuples are broadcastable""" ++ if shp1 == shp2: ++ return True ++ for a, b in zip(shp1[::-1], shp2[::-1]): ++ if a == 1 or b == 1 or a == b: ++ pass ++ else: ++ return False ++ return True ++ ++ def _preprocess_inputs(self, time, target=None, grid=True): + """ +- Workaround for transforming a list of coordinates ``targets`` to +- altitudes and azimuths. ++ Preprocess time and target inputs + +- Parameters +- ---------- +- times : `~astropy.time.Time` or list of `~astropy.time.Time` objects +- Time of observation ++ This routine takes the inputs for time and target and attempts to ++ return a single `~astropy.time.Time` and `~astropy.coordinates.SkyCoord` ++ for each argument, which may be non-scalar if necessary. + +- targets : `~astropy.coordinates.SkyCoord` or list of `~astropy.coordinates.SkyCoord` objects +- List of target coordinates ++ time : `~astropy.time.Time` or other (see below) ++ The time(s) to use in the calculation. It can be anything that ++ `~astropy.time.Time` will accept (including a `~astropy.time.Time` object) + +- location : `~astropy.coordinates.EarthLocation` +- Location of observer ++ target : `~astroplan.FixedTarget`, `~astropy.coordinates.SkyCoord`, or list ++ The target(s) to use in the calculation. + +- Returns +- ------- +- altitudes : list +- List of altitudes for each target, at each time ++ grid: bool ++ If True, and the time and target objects cannot be broadcast, ++ the target object will have extra dimensions packed onto the end, ++ so that calculations with M targets and N times will return an (M, N) ++ shaped result. Useful for grid searches for rise/set times etc. + """ +- if times.isscalar: +- times = Time([times]) +- +- if not isinstance(targets, list) and targets.isscalar: +- targets = [targets] +- +- targets_is_unitsphericalrep = [x.data.__class__ is +- UnitSphericalRepresentation for x in targets] +- if all(targets_is_unitsphericalrep) or not any(targets_is_unitsphericalrep): +- repeated_times = np.tile(times, len(targets)) +- ra_list = Longitude([x.icrs.ra for x in targets]) +- dec_list = Latitude([x.icrs.dec for x in targets]) +- repeated_ra = np.repeat(ra_list, len(times)) +- repeated_dec = np.repeat(dec_list, len(times)) +- inner_sc = SkyCoord(ra=repeated_ra, dec=repeated_dec) +- target_SkyCoord = SkyCoord(inner_sc.data.represent_as(UnitSphericalRepresentation), +- representation=UnitSphericalRepresentation) +- transformed_coord = target_SkyCoord.transform_to(AltAz(location=self.location, +- obstime=repeated_times)) +- else: +- # TODO: This is super slow. +- repeated_times = np.tile(times, len(targets)) +- repeated_targets = np.repeat(targets, len(times)) +- target_SkyCoord = SkyCoord(SkyCoord(repeated_targets).data.represent_as( +- UnitSphericalRepresentation), +- representation=UnitSphericalRepresentation) +- +- transformed_coord = target_SkyCoord.transform_to(AltAz(location=self.location, +- obstime=repeated_times)) +- return transformed_coord ++ # make sure we have a non-scalar time ++ if not isinstance(time, Time): ++ time = Time(time) + +- def altaz(self, time, target=None, obswl=None): ++ if target is None: ++ return time, None ++ ++ # convert any kind of target argument to non-scalar SkyCoord ++ target = get_skycoord(target) ++ ++ if grid: ++ # now we broadcast the targets array so that the first index ++ # iterates over targets, any other indices over times ++ if not target.isscalar: ++ if time.isscalar: ++ target = target[:, np.newaxis] ++ while target.ndim <= time.ndim: ++ target = target[:, np.newaxis] ++ if not self._is_broadcastable(target.shape, time.shape): ++ raise ValueError( ++ 'Time and Target arguments cannot be broadcast against each other with shapes {} and {}'.format( ++ time.shape, target.shape ++ )) ++ return time, target ++ ++ def altaz(self, time, target=None, obswl=None, grid=True): + """ + Get an `~astropy.coordinates.AltAz` frame or coordinate. + +@@ -411,6 +428,12 @@ + obswl : `~astropy.units.Quantity` (optional) + Wavelength of the observation used in the calculation. + ++ grid: bool ++ If True, and the time and target objects cannot be broadcast, ++ the target object will have extra dimensions packed onto the end, ++ so that calculations with M targets and N times will return an (M, N) ++ shaped result. Useful for grid searches for rise/set times etc. ++ + Returns + ------- + `~astropy.coordinates.AltAz` +@@ -440,8 +463,8 @@ + + >>> target_altaz = apo.altaz(time, target) # doctest: +SKIP + """ +- if not isinstance(time, Time): +- time = Time(time) ++ if target is not None: ++ time, target = self._preprocess_inputs(time, target, grid) + + altaz_frame = AltAz(location=self.location, obstime=time, + pressure=self.pressure, obswl=obswl, +@@ -451,24 +474,7 @@ + # Return just the frame + return altaz_frame + else: +- # If target is a list of targets: +- if isiterable(target) and not isinstance(target, SkyCoord): +- get_coord = lambda x: x.coord if hasattr(x, 'coord') else x +- transformed_coords = self._transform_target_list_to_altaz(time, +- list(map(get_coord, target))) +- n_targets = len(target) +- new_shape = (n_targets, int(len(transformed_coords)/n_targets)) +- +- for comp in transformed_coords.data.components: +- getattr(transformed_coords.data, comp).resize(new_shape) +- return transformed_coords +- +- # If single target is a FixedTarget or a SkyCoord: +- if hasattr(target, 'coord'): +- coordinate = target.coord +- else: +- coordinate = target +- return coordinate.transform_to(altaz_frame) ++ return target.transform_to(altaz_frame) + + def parallactic_angle(self, time, target): + """ +@@ -496,17 +502,7 @@ + .. [1] https://en.wikipedia.org/wiki/Parallactic_angle + + """ +- if not isinstance(time, Time): +- time = Time(time) +- +- if isiterable(target): +- get_coord = lambda x: x.coord if hasattr(x, 'coord') else x +- coordinate = SkyCoord(list(map(get_coord, target))) +- else: +- if hasattr(target, 'coord'): +- coordinate = target.coord +- else: +- coordinate = target ++ time, coordinate = self._preprocess_inputs(time, target) + + # Eqn (14.1) of Meeus' Astronomical Algorithms + LST = time.sidereal_time('mean', longitude=self.location.longitude) +@@ -530,9 +526,12 @@ + Parameters + ---------- + t : `~astropy.time.Time` +- Grid of times ++ Grid of N times, any shape. Search grid along first axis, e.g (N, ...) + alt : `~astropy.units.Quantity` + Grid of altitudes ++ Depending on broadcasting we either have ndim >=3 and ++ M targets along first axis, e.g (M, N, ...), or ++ ndim = 2 and targets/times in last axis + rise_set : {"rising", "setting"} + Calculate either rising or setting across the horizon + horizon : float +@@ -543,61 +542,88 @@ + Returns + ------- + Returns the lower and upper limits on the time and altitudes +- of the horizon crossing. +- """ +- alt = np.atleast_2d(Latitude(alt)) +- n_targets = alt.shape[0] ++ of the horizon crossing. The altitude limits have shape (M, ...) and the ++ time limits have shape (...). These arrays aresuitable for interpolation ++ to find the horizon crossing time. ++ """ ++ # handle different cases by enforcing standard shapes on ++ # the altitude grid ++ finesse_time_indexes = False ++ if alt.ndim == 1: ++ raise ValueError('Must supply more at least a 2D grid of altitudes') ++ elif alt.ndim == 2: ++ # TODO: this test for ndim=2 doesn't work. if times is e.g (2,5) ++ # then alt will have ndim=3, but shape (100, 2, 5) so grid ++ # is in first index... ++ ntargets = alt.shape[1] ++ ngrid = alt.shape[0] ++ unit = alt.unit ++ alt = broadcast_to(alt, (ntargets, ngrid, ntargets)).T ++ alt = alt*unit ++ extra_dimension_added = True ++ if t.shape[1] == 1: ++ finesse_time_indexes = True ++ else: ++ extra_dimension_added = False ++ output_shape = (alt.shape[0],) + alt.shape[2:] + + if rise_set == 'rising': + # Find index where altitude goes from below to above horizon +- condition = (alt[:, :-1] < horizon) * (alt[:, 1:] > horizon) ++ condition = (alt[:, :-1, ...] < horizon) * (alt[:, 1:, ...] > horizon) + elif rise_set == 'setting': + # Find index where altitude goes from above to below horizon +- condition = (alt[:, :-1] > horizon) * (alt[:, 1:] < horizon) +- +- target_inds, time_inds = np.nonzero(condition) ++ condition = (alt[:, :-1, ...] > horizon) * (alt[:, 1:, ...] < horizon) + +- if np.count_nonzero(condition) < n_targets: +- target_inds, _ = np.nonzero(condition) +- noncrossing_target_ind = np.setdiff1d(np.arange(n_targets), +- target_inds, +- assume_unique=True) # [0] +- +- warnmsg = ('Target(s) index {} does not cross horizon={} within ' +- '24 hours'.format(noncrossing_target_ind, horizon)) +- +- if (alt[noncrossing_target_ind, :] > horizon).all(): +- warnings.warn(warnmsg, TargetAlwaysUpWarning) +- else: +- warnings.warn(warnmsg, TargetNeverUpWarning) +- +- # Fill in missing time with MAGIC_TIME +- target_inds = np.insert(target_inds, noncrossing_target_ind, +- noncrossing_target_ind) +- time_inds = np.insert(time_inds.astype(float), +- noncrossing_target_ind, +- np.nan) +- elif np.count_nonzero(condition) > n_targets: +- old_target_inds = np.copy(target_inds) +- old_time_inds = np.copy(time_inds) +- +- time_inds = [] +- target_inds = [] +- for tgt, tm in zip(old_target_inds, old_time_inds): +- if tgt not in target_inds: +- time_inds.append(tm) +- target_inds.append(tgt) +- target_inds = np.array(target_inds, dtype=int) +- time_inds = np.array(time_inds) +- +- times = [t[int(i):int(i)+2] if not np.isnan(i) else np.nan for i in time_inds] +- altitudes = [alt[int(i), int(j):int(j)+2] if not np.isnan(j) else np.nan +- for i, j in zip(target_inds, time_inds)] ++ noncrossing_indices = np.sum(condition, axis=1, dtype=np.intp) < 1 ++ alt_lims1 = u.Quantity(np.zeros(output_shape), unit=u.deg) ++ alt_lims2 = u.Quantity(np.zeros(output_shape), unit=u.deg) ++ jd_lims1 = np.zeros(output_shape) ++ jd_lims2 = np.zeros(output_shape) ++ if np.any(noncrossing_indices): ++ for target_index in set(np.where(noncrossing_indices)[0]): ++ warnmsg = ('Target with index {} does not cross horizon={} within ' ++ '24 hours'.format(target_index, horizon)) ++ if (alt[target_index, ...] > horizon).all(): ++ warnings.warn(warnmsg, TargetAlwaysUpWarning) ++ else: ++ warnings.warn(warnmsg, TargetNeverUpWarning) + +- return times, altitudes ++ alt_lims1[np.nonzero(noncrossing_indices)] = np.nan ++ alt_lims2[np.nonzero(noncrossing_indices)] = np.nan ++ jd_lims1[np.nonzero(noncrossing_indices)] = np.nan ++ jd_lims2[np.nonzero(noncrossing_indices)] = np.nan ++ ++ before_indices = np.array(np.nonzero(condition)) ++ # we want to add an vector like (0, 1, ...) to get after indices ++ array_to_add = np.zeros(before_indices.shape[0])[:, np.newaxis].astype(int) ++ array_to_add[1] = 1 ++ after_indices = before_indices + array_to_add ++ ++ al1 = alt[tuple(before_indices)] ++ al2 = alt[tuple(after_indices)] ++ # slice the time in the same way, but delete the object index ++ before_time_index_tuple = np.delete(before_indices, 0, 0) ++ after_time_index_tuple = np.delete(after_indices, 0, 0) ++ if finesse_time_indexes: ++ before_time_index_tuple[1:] = 0 ++ after_time_index_tuple[1:] = 0 ++ tl1 = t[tuple(before_time_index_tuple)] ++ tl2 = t[tuple(after_time_index_tuple)] ++ ++ alt_lims1[tuple(np.delete(before_indices, 1, 0))] = al1 ++ alt_lims2[tuple(np.delete(before_indices, 1, 0))] = al2 ++ jd_lims1[tuple(np.delete(before_indices, 1, 0))] = tl1.utc.jd ++ jd_lims2[tuple(np.delete(before_indices, 1, 0))] = tl2.utc.jd ++ ++ if extra_dimension_added: ++ return (alt_lims1.diagonal(), alt_lims2.diagonal(), ++ jd_lims1.diagonal(), jd_lims2.diagonal()) ++ else: ++ return alt_lims1, alt_lims2, jd_lims1, jd_lims2 + + @u.quantity_input(horizon=u.deg) +- def _two_point_interp(self, times, altitudes, horizon=0*u.deg): ++ def _two_point_interp(self, jd_before, jd_after, ++ alt_before, alt_after, horizon=0*u.deg): + """ + Do linear interpolation between two ``altitudes`` at + two ``times`` to determine the time where the altitude +@@ -605,11 +631,17 @@ + + Parameters + ---------- +- times : `~astropy.time.Time` +- Two times for linear interpolation between ++ jd_before : `float` ++ JD(UTC) before crossing event ++ ++ jd_after : `float` ++ JD(UTC) after crossing event + +- altitudes : array of `~astropy.units.Quantity` +- Two altitudes for linear interpolation between ++ alt_before : `~astropy.units.Quantity` ++ altitude before crossing event ++ ++ alt_after : `~astropy.units.Quantity` ++ altitude after crossing event + + horizon : `~astropy.units.Quantity` + Solve for the time when the altitude is equal to +@@ -621,12 +653,10 @@ + Time when target crosses the horizon + + """ +- if not isinstance(times, Time): +- return MAGIC_TIME +- else: +- slope = (altitudes[1] - altitudes[0])/(times[1].jd - times[0].jd) +- return Time(times[1].jd - ((altitudes[1] - horizon)/slope).value, +- format='jd') ++ slope = (alt_after-alt_before)/((jd_after - jd_before)*u.d) ++ crossing_jd = (jd_after*u.d - ((alt_after - horizon)/slope)) ++ crossing_jd[np.isnan(crossing_jd)] = u.d*MAGIC_TIME.jd ++ return np.squeeze(Time(crossing_jd, format='jd')) + + def _altitude_trig(self, LST, target): + """ +@@ -648,6 +678,7 @@ + alt : `~astropy.unit.Quantity` + Array of altitudes + """ ++ LST, target = self._preprocess_inputs(LST, target) + alt = np.arcsin(np.sin(self.location.latitude.radian) * + np.sin(target.dec) + + np.cos(self.location.latitude.radian) * +@@ -677,9 +708,6 @@ + rise_set : str - either 'rising' or 'setting' + Compute prev/next rise or prev/next set + +- location : `~astropy.coordinates.EarthLocation` +- Location of observer +- + horizon : `~astropy.units.Quantity` + Degrees above/below actual horizon to use + for calculating rise/set times (i.e., +@@ -694,30 +722,21 @@ + ret1 : `~astropy.time.Time` + Time of rise/set + """ +- + if not isinstance(time, Time): + time = Time(time) + +- target_is_vector = isiterable(target) +- + if prev_next == 'next': + times = _generate_24hr_grid(time, 0, 1, N) + else: + times = _generate_24hr_grid(time, -1, 0, N) + +- altaz = self.altaz(times, target) ++ altaz = self.altaz(times, target, grid=True) + altitudes = altaz.alt + +- time_limits, altitude_limits = self._horiz_cross(times, altitudes, rise_set, +- horizon) +- if not target_is_vector: +- return self._two_point_interp(time_limits[0], altitude_limits[0], +- horizon=horizon) +- else: +- return Time([self._two_point_interp(time_limit, altitude_limit, +- horizon=horizon) +- for time_limit, altitude_limit in +- zip(time_limits, altitude_limits)]) ++ al1, al2, jd1, jd2 = self._horiz_cross(times, altitudes, rise_set, ++ horizon) ++ return self._two_point_interp(jd1, jd2, al1, al2, ++ horizon=horizon) + + def _calc_transit(self, time, target, prev_next, antitransit=False, N=150): + """ +@@ -742,9 +761,6 @@ + Toggle compute antitransit (below horizon, equivalent to midnight + for the Sun) + +- location : `~astropy.coordinates.EarthLocation` +- Location of observer +- + N : int + Number of altitudes to compute when searching for + rise or set. +@@ -754,11 +770,10 @@ + ret1 : `~astropy.time.Time` + Time of transit/antitransit + """ ++ # TODO FIX BROADCASTING HERE + if not isinstance(time, Time): + time = Time(time) + +- target_is_vector = isiterable(target) +- + if prev_next == 'next': + times = _generate_24hr_grid(time, 0, 1, N, for_deriv=True) + else: +@@ -771,26 +786,22 @@ + else: + rise_set = 'setting' + +- altaz = self.altaz(times, target) +- if target_is_vector: +- d_altitudes = [each_alt.diff() for each_alt in altaz.alt] ++ altaz = self.altaz(times, target, grid=True) ++ altitudes = altaz.alt ++ if altitudes.ndim > 2: ++ # shape is (M, N, ...) where M is targets and N is grid ++ d_altitudes = altitudes.diff(axis=1) + else: +- altitudes = altaz.alt +- d_altitudes = altitudes.diff() ++ # shape is (N, M) where M is targets and N is grid ++ d_altitudes = altitudes.diff(axis=0) + + dt = Time((times.jd[1:] + times.jd[:-1])/2, format='jd') + + horizon = 0*u.degree # Find when derivative passes through zero +- time_limits, altitude_limits = self._horiz_cross(dt, d_altitudes, +- rise_set, horizon) +- if not target_is_vector: +- return self._two_point_interp(time_limits[0], altitude_limits[0], +- horizon=horizon) +- else: +- return Time([self._two_point_interp(time_limit, altitude_limit, +- horizon=horizon) +- for time_limit, altitude_limit in +- zip(time_limits, altitude_limits)]) ++ al1, al2, jd1, jd2 = self._horiz_cross(dt, d_altitudes, ++ rise_set, horizon) ++ return self._two_point_interp(jd1, jd2, al1, al2, ++ horizon=horizon) + + def _determine_which_event(self, function, args_dict): + """ +@@ -828,19 +839,10 @@ + return previous_event + + if which == 'nearest': +- if isiterable(target): +- return_times = [] +- for next_e, prev_e in zip(next_event, previous_event): +- if abs(time - prev_e) < abs(time - next_e): +- return_times.append(prev_e) +- else: +- return_times.append(next_e) +- return Time(return_times) +- else: +- if abs(time - previous_event) < abs(time - next_event): +- return previous_event +- else: +- return next_event ++ mask = abs(time - previous_event) < abs(time - next_event) ++ return Time(np.where(mask, previous_event.utc.jd, ++ next_event.utc.jd), format='jd') ++ + + raise ValueError('"which" kwarg must be "next", "previous" or ' + '"nearest".') +@@ -1467,27 +1469,8 @@ + if not isinstance(time, Time): + time = Time(time) + +- # TODO: when astropy/astropy#5069 is resolved, replace this workaround which +- # handles scalar and non-scalar time inputs differently +- +- if time.isscalar: +- altaz_frame = AltAz(location=self.location, obstime=time) +- sun = get_sun(time).transform_to(altaz_frame) +- +- moon = get_moon(time, location=self.location, ephemeris=ephemeris).transform_to(altaz_frame) +- return moon +- +- else: +- moon_coords = [] +- for t in time: +- altaz_frame = AltAz(location=self.location, obstime=t) +- moon_coord = get_moon(t, location=self.location, ephemeris=ephemeris).transform_to(altaz_frame) +- moon_coords.append(moon_coord) +- obstime = [coord.obstime for coord in moon_coords] +- alts = u.Quantity([coord.alt for coord in moon_coords]) +- azs = u.Quantity([coord.az for coord in moon_coords]) +- dists = u.Quantity([coord.distance for coord in moon_coords]) +- return SkyCoord(AltAz(azs, alts, dists, obstime=obstime, location=self.location)) ++ moon = get_moon(time, location=self.location, ephemeris=ephemeris) ++ return self.altaz(time, moon, grid=False) + + @u.quantity_input(horizon=u.deg) + def target_is_up(self, time, target, horizon=0*u.degree, return_altaz=False): +@@ -1515,7 +1498,7 @@ + + Returns + ------- +- observable : boolean ++ observable : boolean or np.ndarray(bool) + True if ``target`` is above ``horizon`` at ``time``, else False. + + Examples +@@ -1538,10 +1521,13 @@ + time = Time(time) + + altaz = self.altaz(time, target) +- if isiterable(target): +- observable = [bool(alt > horizon) for alt in altaz.alt] ++ observable = altaz.alt > horizon ++ if altaz.isscalar: ++ observable = bool(observable) + else: +- observable = bool(altaz.alt > horizon) ++ # TODO: simply return observable if we move to ++ # a fully broadcasted API ++ observable = [value for value in observable.flat] + + if not return_altaz: + return observable +@@ -1571,7 +1557,7 @@ + + Returns + ------- +- sun_below_horizon : bool ++ sun_below_horizon : bool or np.ndarray(bool) + `True` if sun is below ``horizon`` at ``time``, else `False`. + + Examples +@@ -1590,7 +1576,12 @@ + time = Time(time) + + solar_altitude = self.altaz(time, target=get_sun(time), obswl=obswl).alt +- return bool(solar_altitude < horizon) ++ if solar_altitude.isscalar: ++ return bool(solar_altitude < horizon) ++ else: ++ # TODO: simply return solar_altitude < horizon if we move to ++ # a fully broadcasted API ++ return [val for val in (solar_altitude < horizon).flat] + + def local_sidereal_time(self, time, kind='apparent', model=None): + """ +@@ -1646,21 +1637,8 @@ + hour_angle : `~astropy.coordinates.Angle` + The hour angle(s) of the target(s) at ``time`` + """ +- if not isinstance(time, Time): +- time = Time(time) +- +- if isiterable(target): +- coords = [t.coord if hasattr(t, 'coord') else t +- for t in target] +- +- hour_angle = Longitude([self.local_sidereal_time(time) - coord.ra +- for coord in coords]) +- +- else: +- coord = target.coord if hasattr(target, 'coord') else target +- hour_angle = Longitude(self.local_sidereal_time(time) - coord.ra) +- +- return hour_angle ++ time, target = self._preprocess_inputs(time, target) ++ return Longitude(self.local_sidereal_time(time) - target.ra) + + @u.quantity_input(horizon=u.degree) + def tonight(self, time=None, horizon=0 * u.degree, obswl=None): +@@ -1689,11 +1667,16 @@ + A tuple of times corresponding to the start and end of current night + """ + current_time = Time.now() if time is None else time +- if self.is_night(current_time, horizon=horizon, obswl=obswl): +- start_time = current_time ++ night_mask = self.is_night(current_time, horizon=horizon, obswl=obswl) ++ sun_set_time = self.sun_set_time(current_time, which='next', horizon=horizon) ++ # workaround for NPY <= 1.8, otherwise np.where works even in scalar case ++ if current_time.isscalar: ++ start_time = current_time if night_mask else sun_set_time + else: +- start_time = self.sun_set_time(current_time, which='next', horizon=horizon) +- +- end_time = self.sun_rise_time(current_time, which='next', horizon=horizon) ++ start_time = np.where(night_mask, current_time, sun_set_time) ++ # np.where gives us a list of start Times - convert to Time object ++ if not isinstance(start_time, Time): ++ start_time = Time(start_time) ++ end_time = self.sun_rise_time(start_time, which='next', horizon=horizon) + + return start_time, end_time +--- a/astroplan/tests/test_target.py ++++ b/astroplan/tests/test_target.py +@@ -4,10 +4,13 @@ + + # Third-party + import astropy.units as u +-from astropy.coordinates import SkyCoord ++from astropy.coordinates import SkyCoord, GCRS, ICRS ++from astropy.time import Time ++from astropy.tests.helper import pytest + + # Package +-from ..target import FixedTarget ++from ..target import FixedTarget, get_skycoord ++from ..observer import Observer + + + def test_FixedTarget_from_name(): +@@ -40,3 +43,39 @@ + 'SkyCoord') + assert vega.coord.dec == vega_coords.dec == vega.dec, ('Retrieve Dec from ' + 'SkyCoord') ++ ++ ++def test_get_skycoord(): ++ m31 = SkyCoord(10.6847083*u.deg, 41.26875*u.deg) ++ m31_with_distance = SkyCoord(10.6847083*u.deg, 41.26875*u.deg, 780*u.kpc) ++ subaru = Observer.at_site('subaru') ++ time = Time("2016-01-22 12:00") ++ pos, vel = subaru.location.get_gcrs_posvel(time) ++ gcrs_frame = GCRS(obstime=Time("2016-01-22 12:00"), obsgeoloc=pos, obsgeovel=vel) ++ m31_gcrs = m31.transform_to(gcrs_frame) ++ m31_gcrs_with_distance = m31_with_distance.transform_to(gcrs_frame) ++ ++ coo = get_skycoord(m31) ++ assert coo.is_equivalent_frame(ICRS()) ++ with pytest.raises(TypeError) as exc_info: ++ len(coo) ++ ++ coo = get_skycoord([m31]) ++ assert coo.is_equivalent_frame(ICRS()) ++ assert len(coo) == 1 ++ ++ coo = get_skycoord([m31, m31_gcrs]) ++ assert coo.is_equivalent_frame(ICRS()) ++ assert len(coo) == 2 ++ ++ coo = get_skycoord([m31_with_distance, m31_gcrs_with_distance]) ++ assert coo.is_equivalent_frame(ICRS()) ++ assert len(coo) == 2 ++ ++ coo = get_skycoord([m31, m31_gcrs, m31_gcrs_with_distance, m31_with_distance]) ++ assert coo.is_equivalent_frame(ICRS()) ++ assert len(coo) == 4 ++ ++ coo = get_skycoord([m31_gcrs, m31_gcrs_with_distance]) ++ assert coo.is_equivalent_frame(m31_gcrs.frame) ++ assert len(coo) == 2 +--- a/astroplan/target.py ++++ b/astroplan/target.py +@@ -7,7 +7,7 @@ + + # Third-party + import astropy.units as u +-from astropy.coordinates import SkyCoord ++from astropy.coordinates import SkyCoord, ICRS, UnitSphericalRepresentation + + __all__ = ["Target", "FixedTarget", "NonFixedTarget"] + +@@ -185,3 +185,77 @@ + """ + Placeholder for future function. + """ ++ ++def get_skycoord(targets): ++ """ ++ Return an `~astropy.coordinates.SkyCoord` object. ++ ++ When performing calculations it is usually most efficient to have ++ a single `~astropy.coordinates.SkyCoord` object, rather than a ++ list of `FixedTarget` or `~astropy.coordinates.SkyCoord` objects. ++ ++ This is a convenience routine to do that. ++ ++ Parameters ++ ----------- ++ targets : list, `~astropy.coordinates.SkyCoord`, `Fixedtarget` ++ either a single target or a list of targets ++ ++ Returns ++ -------- ++ coord : `~astropy.coordinates.SkyCoord` ++ a single SkyCoord object, which may be non-scalar ++ """ ++ if not isinstance(targets, list): ++ return getattr(targets, 'coord', targets) ++ ++ # get the SkyCoord object itself ++ coords = [getattr(target, 'coord', target) for target in targets] ++ ++ # are all SkyCoordinate's in equivalent frames? If not, convert to ICRS ++ convert_to_icrs = not all([coord.frame.is_equivalent_frame(coords[0].frame) for coord in coords[1:]]) ++ ++ # we also need to be careful about handling mixtures of UnitSphericalRepresentations and others ++ targets_is_unitsphericalrep = [x.data.__class__ is ++ UnitSphericalRepresentation for x in coords] ++ ++ longitudes = [] ++ latitudes = [] ++ distances = [] ++ get_distances = not all(targets_is_unitsphericalrep) ++ if convert_to_icrs: ++ # mixture of frames ++ for coordinate in coords: ++ icrs_coordinate = coordinate.icrs ++ longitudes.append(icrs_coordinate.ra) ++ latitudes.append(icrs_coordinate.dec) ++ if get_distances: ++ distances.append(icrs_coordinate.distance) ++ frame = ICRS() ++ else: ++ # all the same frame, get the longitude and latitude names ++ lon_name, lat_name = [mapping.framename for mapping in ++ coords[0].frame_specific_representation_info['spherical']] ++ frame = coords[0].frame ++ for coordinate in coords: ++ longitudes.append(getattr(coordinate, lon_name)) ++ latitudes.append(getattr(coordinate, lat_name)) ++ if get_distances: ++ distances.append(coordinate.distance) ++ ++ # now let's deal with the fact that we may have a mixture of coords with distances and ++ # coords with UnitSphericalRepresentations ++ if all(targets_is_unitsphericalrep): ++ return SkyCoord(longitudes, latitudes, frame=frame) ++ elif not any(targets_is_unitsphericalrep): ++ return SkyCoord(longitudes, latitudes, distances, frame=frame) ++ else: ++ """ ++ We have a mixture of coords with distances and without. ++ Since we don't know in advance the origin of the frame where further transformation ++ will take place, it's not safe to drop the distances from those coords with them set. ++ ++ Instead, let's assign large distances to those objects with none. ++ """ ++ distances = [distance if distance != 1 else 100*u.kpc for distance in distances] ++ return SkyCoord(longitudes, latitudes, distances, frame=frame) +\ No newline at end of file +--- a/setup.py ++++ b/setup.py +@@ -102,7 +102,7 @@ + version=VERSION, + description=DESCRIPTION, + scripts=scripts, +- install_requires=['numpy>=1.6', 'astropy>=1.2', 'pytz'], ++ install_requires=['numpy>=1.6', 'astropy>=1.3', 'pytz'], + extras_require=dict( + plotting=['matplotlib>=1.4'], + docs=['sphinx_rtd_theme'] diff -Nru astroplan-0.2/debian/patches/series astroplan-0.2/debian/patches/series --- astroplan-0.2/debian/patches/series 2017-01-27 20:57:06.000000000 +0100 +++ astroplan-0.2/debian/patches/series 2017-02-18 16:27:41.000000000 +0100 @@ -4,4 +4,4 @@ pull-274-Stop-recognizing-scalar-SkyCoord-objects-as-vect.patch pull-273-Change-to-use-new-SkyCoord-prints.patch issues-282-Fix-more-test-failures-in-astroplan.patch -disable_failing_tests.patch +pull-285-Fix-broadcasting.patch
