def test_updatePointerAltAz_5(qtbot):
app.uiWindows['showHemisphereW']['classObj'].drawHemisphere()
app.mount.obsSite.Alt = api.Angle(degrees=5)
app.mount.obsSite.Az = api.Angle(degrees=5)
app.uiWindows['showHemisphereW']['classObj'].pointerAltAz = None
suc = app.uiWindows['showHemisphereW']['classObj'].updatePointerAltAz()
assert not suc
def test_from_altaz_parameters():
usno = api.earth.topos('38.9215 N', '77.0669 W', elevation_m=92.0)
p = usno(tt=api.T0)
a = api.Angle(degrees=10.0)
with assert_raises(ValueError, 'the alt= parameter with an Angle'):
p.from_altaz(alt='Bad value', alt_degrees=0, az_degrees=0)
with assert_raises(ValueError, 'the az= parameter with an Angle'):
p.from_altaz(az='Bad value', alt_degrees=0, az_degrees=0)
p.from_altaz(alt=a, alt_degrees='bad', az_degrees=0)
p.from_altaz(az=a, alt_degrees=0, az_degrees='bad')
def test_from_altaz_parameters(ts):
e = api.load('de421.bsp')
usno = e['earth'] + Topos('38.9215 N', '77.0669 W', elevation_m=92.0)
t = ts.tt(jd=api.T0)
p = usno.at(t)
a = api.Angle(degrees=10.0)
with assert_raises(ValueError, 'the alt= parameter with an Angle'):
p.from_altaz(alt='Bad value', alt_degrees=0, az_degrees=0)
with assert_raises(ValueError, 'the az= parameter with an Angle'):
p.from_altaz(az='Bad value', alt_degrees=0, az_degrees=0)
p.from_altaz(alt=a, alt_degrees='bad', az_degrees=0)
p.from_altaz(az=a, alt_degrees=0, az_degrees='bad')
def test_from_altaz_parameters(ts):
usno = Topos('38.9215 N', '77.0669 W', elevation_m=92.0)
t = ts.tt(jd=api.T0)
p = usno.at(t)
a = api.Angle(degrees=10.0)
d = api.Distance(au=0.234)
with assert_raises(ValueError, 'the alt= parameter with an Angle'):
p.from_altaz(alt='Bad value', alt_degrees=0, az_degrees=0)
with assert_raises(ValueError, 'the az= parameter with an Angle'):
p.from_altaz(az='Bad value', alt_degrees=0, az_degrees=0)
p.from_altaz(alt=a, alt_degrees='bad', az_degrees=0)
p.from_altaz(az=a, alt_degrees=0, az_degrees='bad')
assert str(p.from_altaz(alt=a, az=a).distance()) == '0.1 au'
assert str(p.from_altaz(alt=a, az=a, distance=d).distance()) == '0.234 au'
# The Sun orbits around the Solar System barycenter which is usually
# inside the Sun's radius but occasionally a bit outside of it. So we
# can very roughly imagine the Sun's orbit as its own circumference,
# give or take.
solar_radius_km = 696340
distance_sun_travels_in_one_orbit = solar_radius_km * api.tau
# It takes the Sun more than a decade to travel that path, as its orbit
# is roughly the opposite of Jupiter's (which takes 12 years to circle
# the Sun). So it turns out that it travels a bit slowly.
sun_km_per_s = distance_sun_travels_in_one_orbit / 10 / 365.25 / 24 / 60 / 60
print('Sun km/s:', sun_km_per_s)
light_delay_seconds = s2[0].position.length().light_seconds()
print('Sample light delay from Sun to Earth (seconds):', light_delay_seconds)
print('How far does the Sun move in that time?')
travel_km = light_delay_seconds * sun_km_per_s
print('Sun km moved during that light travel time:', travel_km)
print('What angle does that many kilometers subtend from Earth?')
earth_sun_distance_km = 150e6
travel_angle = api.Angle(radians=travel_km / earth_sun_distance_km)
print('Angle traveled by sun in arcseconds:', travel_angle.arcseconds())
print('Angle traveled by sun in mas:', travel_angle.mas())
print()
print(__doc__.rstrip())
def get_best_gridpoints(gps_start,
obs_source_ra_deg,
obs_source_dec_deg,
avoid_source_ra_deg,
avoid_source_dec_deg,
model="analytic",
min_gain=None,
max_beam_distance_deg=360,
channel=145,
verb_level=1,
logger=LOGGER,
duration=3600,
step=120,
min_elevation=30.00):
su.init_data()
frequency = channel * 1.28
if model not in ['analytic', 'advanced', 'full_EE', 'full_EE_AAVS05']:
logger.error("Model %s not found\n" % model)
gp_numbers = list(mwa_sweet_spots.all_grid_points.keys())
gp_numbers.sort()
gp_azes = numpy.array([mwa_sweet_spots.all_grid_points[i][1] for i in gp_numbers])
gp_alts = numpy.array([mwa_sweet_spots.all_grid_points[i][2] for i in gp_numbers])
gp_delays = [mwa_sweet_spots.all_grid_points[i][4] for i in gp_numbers]
obs_source = si.Star(ra=si.Angle(degrees=obs_source_ra_deg),
dec=si.Angle(degrees=obs_source_dec_deg))
avoid_source = si.Star(ra=si.Angle(degrees=avoid_source_ra_deg),
dec=si.Angle(degrees=avoid_source_dec_deg))
freq = frequency * 1e6
tracklist = [] # List of (starttime, duration, az, el) tuples
for starttime in range(int(gps_start), int(gps_start + duration), int(step)):
t = su.time2tai(starttime)
observer = su.S_MWAPOS.at(t)
obs_source_apparent = observer.observe(obs_source).apparent()
obs_source_alt, obs_source_az, _ = obs_source_apparent.altaz()
if obs_source_alt.degrees < min_elevation:
logger.debug("Source at %.2f [deg] below minimum elevation = %.2f [deg] at this time, skip this timestep." % (obs_source_alt.degrees,
min_elevation))
continue # Source below pointing horizon at this time, skip this timestep.
if min_gain is None:
current_min_gain = 0.5
if obs_source_alt.degrees < 50:
current_min_gain = 0.1
else:
current_min_gain = min_gain
avoid_source_apparent = observer.observe(avoid_source).apparent()
avoid_source_alt, avoid_source_az, _ = avoid_source_apparent.altaz()
if avoid_source_alt.degrees < 0.0:
tracklist.append((starttime, step, obs_source_az.degrees, obs_source_alt.degrees))
logger.debug("Avoided source below TRUE horizon, just use actual target az/alt for this timestep.")
continue # Avoided source below TRUE horizon, just use actual target az/alt for this timestep.
dist_deg = obs_source_apparent.separation_from(avoid_source_apparent).degrees
logger.debug("Observed source at (az,alt) = (%.4f,%.4f) [deg]" % (obs_source_az.degrees, obs_source_alt.degrees))
logger.debug("Avoided source at (az,alt) = (%.4f,%.4f) [deg]" % (avoid_source_az.degrees, avoid_source_alt.degrees))
logger.debug("Anglular distance = %.2f [deg]" % (dist_deg))
logger.debug("Gps time = %d" % su.tai2gps(t))
gp_positions = observer.from_altaz(alt_degrees=gp_alts,
az_degrees=gp_azes,
distance=si.Distance(au=9e90))
dist_obs_degs = obs_source_apparent.separation_from(gp_positions).degrees
dist_avoid_degs = avoid_source_apparent.separation_from(gp_positions).degrees
# select gridpoints within given angular distance :
best_gridpoint = None
r_max = -1000
best_gain_obs = 0
best_gain_avoid = 0
skipped_too_far = 0
skipped_gain_too_low = 0
for i in range(len(gp_numbers)):
gpnum = gp_numbers[i]
dist_obs = dist_obs_degs[i]
dist_avoid = dist_avoid_degs[i]
if verb_level > 1:
outstring = "\n\t\ttesting gridpoint %d, dist_obs_deg = %.2f [deg], dist_avoid_deg = %.2f [deg]"
logger.debug(outstring % (gpnum, dist_obs, dist_avoid))
# if dist_obs_deg < options.max_beam_distance_deg and dist_avoid_deg < options.max_beam_distance_deg :
if dist_obs < max_beam_distance_deg:
beam_obs = primarybeammap_tant.get_beam_power(gp_delays[i],
freq,
model=model,
pointing_az_deg=obs_source_az.degrees,
pointing_za_deg=90 - obs_source_alt.degrees,
zenithnorm=True)
beam_avoid = primarybeammap_tant.get_beam_power(gp_delays[i],
freq,
model=model,
pointing_az_deg=avoid_source_az.degrees,
pointing_za_deg=90 - avoid_source_alt.degrees,
zenithnorm=True)
gain_XX_obs = beam_obs['XX']
gain_XX_avoid = beam_avoid['XX']
r = gain_XX_obs / gain_XX_avoid
if r > 1.00 and gain_XX_obs > current_min_gain:
outstring = "\t\tSelected gridpoint = %d at (az,elev) = (%.4f,%.4f) [deg] at (distances %.4f and %.4f deg) "
outstring += "-> gain_obs=%.4f and gain_avoid=%.4f -> gain_obs/gain_avoid = %.4f"
logger.debug(outstring % (gpnum, gp_azes[i], gp_alts[i], dist_obs, dist_avoid, gain_XX_obs, gain_XX_avoid, r))
if r > r_max:
best_gridpoint = i
r_max = r
best_gain_obs = gain_XX_obs
best_gain_avoid = gain_XX_avoid
else:
skipped_gain_too_low = skipped_gain_too_low + 1
if verb_level > 1:
outstring = "\t\tSKIPPED gridpoint = %d at (az,elev) = (%.4f,%.4f) [deg] at (distances %.4f and %.4f deg) "
outstring += "-> gain_obs=%.4f (vs. min_gain=%.2f) and gain_avoid=%.4f -> gain_obs/gain_avoid = %.4f"
logger.debug(outstring % (gpnum,
gp_azes[i],
gp_alts[i],
dist_obs,
dist_avoid,
gain_XX_obs,
current_min_gain,
gain_XX_avoid, r))
else:
skipped_too_far = skipped_too_far + 1
if verb_level > 1:
outstring = "\t\t\tskipped as dist_obs_deg = %.2f [deg] and dist_avoid_deg = %.2f [deg] , one > "
outstring += "max_beam_distance_deg = %.2f [deg]"
logger.debug(outstring % (dist_obs, dist_avoid, max_beam_distance_deg))
logger.debug("Number of gridpoints skipped due to gain lower than minimum (=%.2f) = %d" % (current_min_gain,
skipped_gain_too_low))
outstring = "Number of gridpoints skipped due to being further than limit ( max_beam_distance_deg = %.2f [deg] ) = %d"
logger.debug(outstring % (max_beam_distance_deg, skipped_too_far))
if best_gridpoint is not None:
outstring = "Best gridpoint %d at (az,alt)=(%.4f,%.4f) [deg] at %s UTC to observe has ratio = %.2f = %.8f / %.8f\n"
logger.info(outstring % (gp_numbers[best_gridpoint],
gp_azes[best_gridpoint],
gp_alts[best_gridpoint],
t.utc_iso(), r_max,
best_gain_obs,
best_gain_avoid))
tracklist.append((starttime, step, gp_azes[best_gridpoint], gp_alts[best_gridpoint]))
return tracklist