def airmass_plots(KPNO=False,ING=False,MLO=False): observer_site = Observer.at_site("Kitt Peak", timezone="US/Mountain") if KPNO: print('plotting airmass curves for Kitt Peak') observing_location = EarthLocation.of_site('Kitt Peak') observer_site = Observer.at_site("Kitt Peak", timezone="US/Mountain") start_time = Time('2017-03-12 01:00:00') # UTC time, so 1:00 UTC = 6 pm AZ mountain time end_time = Time('2017-03-12 14:00:00') elif MLO: print('plotting airmass curves for MLO') observing_location = EarthLocation.of_site(u'Palomar') observer_site = Observer.at_site("Palomar", timezone="US/Pacific") # for run starting 2019-Apr-04 at MLO start_time = Time('2019-04-03 01:00:00') # need to enter UTC time, MLO UTC+6? end_time = Time('2019-04-03 14:00:00') elif ING: print('plotting airmass curves for INT') observing_location = EarthLocation.of_site(u'Roque de los Muchachos') observer_site = Observer.at_site("Roque de los Muchachos", timezone="GMT") # for run starting 2019-Feb-04 at INT start_time = Time('2019-02-04 19:00:00') # INT is on UTC end_time = Time('2019-02-05 07:00:00') #observing_time = Time('2017-05-19 07:00') # 1am UTC=6pm AZ mountain time #observing_time = Time('2018-03-12 07:00') # 1am UTC=6pm AZ mountain time #aa = AltAz(location=observing_location, obstime=observing_time) #for i in range(len(pointing_ra)): delta_t = end_time - start_time observing_time = start_time + delta_t*np.linspace(0, 1, 75) nplots = int(sum(obs_mass_flag)/8.) print(nplots) for j in range(nplots): plt.figure() legend_list = [] for i in range(8): pointing_center = coords.SkyCoord(pointing_ra[8*j+i]*u.deg, pointing_dec[8*j+i]*u.deg, frame='icrs') if i == 3: plot_airmass(pointing_center,observer_site,observing_time,brightness_shading=True) else: plot_airmass(pointing_center,observer_site,observing_time) legend_list.append('Pointing %02d'%(8*j+i+1)) plt.legend(legend_list) #plt.ylim(0.9,2.5) plt.gca().invert_yaxis() plt.subplots_adjust(bottom=.15) #plt.axvline(x=7*u.hour,ls='--',color='k') plt.axhline(y=2,ls='--',color='k') plt.savefig(outfile_prefix+'airmass-%02d.png'%(j+1))
def test_is_night(): lco = Observer(location=EarthLocation.of_site('lco')) # Las Campanas aao = Observer(location=EarthLocation.of_site('aao')) # Sydney, Australia vbo = Observer(location=EarthLocation.of_site('vbo')) # India time1 = Time('2015-07-28 17:00:00') nights1 = [observer.is_night(time1) for observer in [lco, aao, vbo]] assert np.all(nights1 == [False, True, True]) time2 = Time('2015-07-28 02:00:00') nights2 = [observer.is_night(time2) for observer in [lco, aao, vbo]] assert np.all(nights2 == [True, False, False])
def test_is_night(): lco = Observer(location=EarthLocation.of_site('lco')) # Las Campanas aao = Observer(location=EarthLocation.of_site('aao')) # Sydney, Australia vbo = Observer(location=EarthLocation.of_site('vbo')) # India time1 = Time('2015-07-28 17:00:00') nights1 = [observer.is_night(time1) for observer in [lco, aao, vbo]] assert np.all(nights1 == [False, True, True]) time2 = Time('2015-07-28 02:00:00') nights2 = [observer.is_night(time2) for observer in [lco, aao, vbo]] assert np.all(nights2 == [True, False, False])
def plot2D(df, threshold, ax=None): ax = ax or plt.gca() df_selected = df.query(f'gammaness > {threshold}') crab = SkyCoord.from_name('crab') altaz = AltAz( location = EarthLocation.of_site('Roque de los Muchachos'), obstime = Time(df_selected.dragon_time, format='unix') ) telescope_pointing = SkyCoord( alt = u.Quantity(df_selected.alt_tel.to_numpy(), u.rad, copy=False), az = u.Quantity(df_selected.az_tel.to_numpy(), u.rad, copy=False), frame = altaz ) camera_frame = CameraFrame( focal_length = u.Quantity(df_selected.focal_length.to_numpy(), u.m, copy=False), telescope_pointing = telescope_pointing, location = EarthLocation.of_site('Roque de los Muchachos'), obstime = Time(df_selected.dragon_time, format='unix') ) crab_cf = crab.transform_to(camera_frame) #ax.hist2d(crab_cf.x.to_value(u.m), crab_cf.y.to_value(u.m), bins = 100) #ax.set_xlabel(r'$x \,/\, \mathrm{m}$') #ax.set_ylabel(r'$y \,/\, \mathrm{m}$') #crab_cf_1 = crab_cf.transform_to(altaz) #ax.hist2d( # crab_cf_1.az.to_value(u.deg) - telescope_pointing.az.to_value(u.deg), # crab_cf_1.alt.to_value(u.deg) - telescope_pointing.alt.to_value(u.deg), # bins = 100, # range = [[-0.5, 0.5], [-0.5, 0.5]] #) #ax.set_xlabel(r'$az \,/\, \mathrm{deg}$') #ax.set_ylabel(r'$alt \,/\, \mathrm{deg}$') crab_tf = crab_cf.transform_to(TelescopeFrame()) ax.hist2d( crab_tf.fov_lon.to_value(u.deg), crab_tf.fov_lat.to_value(u.deg), bins = 100, range = [[-0.3, 0.3], [-0.3, 0.3]] ) ax.set_xlabel(r'fov_lon$ \,/\, \mathrm{deg}$') ax.set_ylabel(r'fov_lat$ \,/\, \mathrm{deg}$') return ax
def get_telescope_coordinates(telescope): """Return the astropy.coordinates EarthLocation object associated with the position of the telescope. The input must be either a string with the name of a telescope listed in Astropy's sites list (https://github.com/astropy/astropy-data/blob/gh-pages/coordinates/sites.json), an EarthLocation object (which is passed through unchanged), or a 3-component tuple with the latitude [deg], longitude [deg], and height [m]. Since ASKAP is not yet listed in the Astropy sites list, it's position is manually coded in as a temporary measure. """ if type( telescope ) == EarthLocation: #Pass EarthLocations through without processing return telescope elif type(telescope) == str: #Hardcoded coordinates for some telescopes. if telescope == 'ASKAP': lat = -1 * 26 + 42 / 60 + 15 / 3600 #degree long = +1 * 116 + 39 / 60 + 32 / 3600 # degree height = 381.0 # else: return EarthLocation.of_site(telescope) return EarthLocation(lat=lat * u.deg, lon=long * u.deg, height=height * u.m) elif (type(telescope) == tuple) or (type(telescope) == list): return EarthLocation(lat=telescope[0] * u.deg, lon=telescope[1] * u.deg, height=telescope[2] * u.m)
def EarthVelocity(t, site, psr, rot): """Get the proper earth velocity in RA-DEC coordinates in the pulsar frame. For data taken from a given site, relative to the sun. Parameters ---------- t : `~astropy.time.Time` Time of the observation. site : `~astropy.coordinates.EarthLocation` or string Location or name of the observatory where data was taken. psr : `~astropy.coordinates.SkyCoord` Position of the pulsar. rot : `~astropy.coordinates.Angle` Angle at which to set the offset frame. Returns ------- v_earth : `~astropy.units.Quantity` Site XYZ velocities in units of km/s, with X and Y giving the velocities in the RA and DEC directions. """ psr_frame = SkyOffsetFrame(origin=psr, rotation=rot) if not isinstance(site, EarthLocation): site = EarthLocation.of_site(site) pos = site.get_gcrs(t).transform_to(psr_frame).cartesian vel = pos.differentials['s'] return vel.d_xyz.to(u.km / u.s)
def test_icrs_to_camera(): from ctapipe.coordinates import CameraFrame obstime = Time("2013-11-01T03:00") location = EarthLocation.of_site("Roque de los Muchachos") horizon_frame = AltAz(location=location, obstime=obstime) # simulate crab "on" observations crab = SkyCoord(ra="05h34m31.94s", dec="22d00m52.2s") telescope_pointing = crab.transform_to(horizon_frame) camera_frame = CameraFrame( focal_length=28 * u.m, telescope_pointing=telescope_pointing, location=location, obstime=obstime, ) ceta_tauri = SkyCoord(ra="5h37m38.6854231s", dec="21d08m33.158804s") ceta_tauri_camera = ceta_tauri.transform_to(camera_frame) camera_center = SkyCoord(0 * u.m, 0 * u.m, frame=camera_frame) crab_camera = crab.transform_to(camera_frame) assert crab_camera.x.to_value(u.m) == approx(0.0, abs=1e-10) assert crab_camera.y.to_value(u.m) == approx(0.0, abs=1e-10) # assert ceta tauri is in FoV assert camera_center.separation_3d(ceta_tauri_camera) < u.Quantity(0.6, u.m)
def test_EarthLocation(self): lowell = EarthLocation.of_site('Lowell Observatory') eph1 = Ephem.from_miriade("Ceres", location=lowell, epochs=Time('2019-01-01')) eph2 = Ephem.from_miriade("Ceres", epochs=Time('2019-01-01')) assert abs(eph1['RA'][0] - eph2['RA'][0]) > 0.0001 * u.deg
def _get_obs_param(ra, dec, mjd): ''' get observing condition given tileid and time of observation ''' from astropy.time import Time from astropy.coordinates import EarthLocation, SkyCoord, AltAz, get_sun, get_moon kpno = EarthLocation.of_site('kitt peak') # get observing conditions coord = SkyCoord(ra=ra * u.deg, dec=dec * u.deg) utc_time = Time(mjd, format='mjd') # observed time (UTC) kpno_altaz = AltAz(obstime=utc_time, location=kpno) coord_altaz = coord.transform_to(kpno_altaz) airmass = coord_altaz.secz # sun sun = get_sun(utc_time) sun_altaz = sun.transform_to(kpno_altaz) sun_alt = sun_altaz.alt.deg sun_sep = sun.separation(coord).deg # sun separation # moon moon = get_moon(utc_time) moon_altaz = moon.transform_to(kpno_altaz) moon_alt = moon_altaz.alt.deg moon_sep = moon.separation(coord).deg #coord.separation(self.moon).deg elongation = sun.separation(moon) phase = np.arctan2(sun.distance * np.sin(elongation), moon.distance - sun.distance * np.cos(elongation)) moon_phase = phase.value moon_ill = (1. + np.cos(phase)) / 2. return airmass, moon_ill.value, moon_alt, moon_sep, sun_alt, sun_sep
def test_EarthLocation_basic(): greenwichel = EarthLocation.of_site('greenwich') lon, lat, el = greenwichel.to_geodetic() assert_quantity_allclose(lon, Longitude('0:0:0', unit=u.deg), atol=10*u.arcsec) assert_quantity_allclose(lat, Latitude('51:28:40', unit=u.deg), atol=1*u.arcsec) assert_quantity_allclose(el, 46*u.m, atol=1*u.m) names = EarthLocation.get_site_names() assert 'greenwich' in names assert 'example_site' in names with pytest.raises(KeyError) as exc: EarthLocation.of_site('nonexistent site') assert exc.value.args[0] == "Site 'nonexistent site' not in database. Use EarthLocation.get_site_names to see available sites."
def visibility_altaz(self, source_radec, site, hardcoded=True): """ To each time grid point associates AltAz coordinates. :param source_radec: source coordinates (astropy SkyCoord object) :param site: (str) :return: """ if not hasattr(self, 'vis_points'): raise AttributeError( 'Must invoke visibility_points() before using this method') if not hardcoded: site_coords = EarthLocation.of_site(site) else: if site.lower() in ('north', 'roque de los muchachos'): #site_coords = EarthLocation.from_geodetic('342.1184', '28.7606', 2326. * u.meter) site_coords = EarthLocation.from_geocentric(5327285.09211954, -1718777.11250295, 3051786.7327476, unit="m") elif site.lower() in ('south', 'paranal'): #site_coords = EarthLocation.from_geodetic('289.5972', '-24.6253', 2635. * u.meter) site_coords = EarthLocation.from_geocentric(1946635.7979987, -5467633.94561753, -2642498.5212285, unit="m") else: raise Warning(f"{site} is not a valid site choice") self.altaz = source_radec.transform_to( AltAz(obstime=self.vis_points, location=site_coords)) return self
def test_icrs_to_camera(): from ctapipe.coordinates import CameraFrame obstime = Time('2013-11-01T03:00') location = EarthLocation.of_site('Roque de los Muchachos') horizon_frame = AltAz(location=location, obstime=obstime) # simulate crab "on" observations crab = SkyCoord(ra='05h34m31.94s', dec='22d00m52.2s') telescope_pointing = crab.transform_to(horizon_frame) camera_frame = CameraFrame( focal_length=28 * u.m, telescope_pointing=telescope_pointing, location=location, obstime=obstime, ) ceta_tauri = SkyCoord(ra='5h37m38.6854231s', dec='21d08m33.158804s') ceta_tauri_camera = ceta_tauri.transform_to(camera_frame) camera_center = SkyCoord(0 * u.m, 0 * u.m, frame=camera_frame) crab_camera = crab.transform_to(camera_frame) assert crab_camera.x.to_value(u.m) == approx(0.0, abs=1e-10) assert crab_camera.y.to_value(u.m) == approx(0.0, abs=1e-10) # assert ceta tauri is in FoV assert camera_center.separation_3d(ceta_tauri_camera) < u.Quantity(0.6, u.m)
def check_moon(file, avoid=30.*u.degree): if not isinstance(avoid, u.Quantity): avoid = float(avoid)*u.degree else: avoid = avoid.to(u.degree) header = fits.getheader(file) mlo = EarthLocation.of_site('Keck Observatory') # Update later obstime = Time(header['DATE-OBS'], format='isot', scale='utc', location=mlo) moon = get_moon(obstime, mlo) if 'RA' in header.keys() and 'DEC' in header.keys(): coord_string = '{} {}'.format(header['RA'], header['DEC']) target = SkyCoord(coord_string, unit=(u.hourangle, u.deg)) else: ## Assume zenith target = SkyCoord(obstime.sidereal_time('apparent'), mlo.latitude) moon_alt = moon.transform_to(AltAz(obstime=obstime, location=mlo)).alt.to(u.deg) if moon_alt < 0*u.degree: print('Moon is down') return True else: sep = target.separation(moon) print('Moon is up. Separation = {:.1f} deg'.format(sep.to(u.degree).value)) return (sep > avoid)
def at_site(cls, site_name, **kwargs): name = kwargs.pop('name', site_name) if 'location' in kwargs: raise ValueError("Location kwarg should not be used if " "initializing an Observer with Observer.at_site()") return cls(location=EarthLocation.of_site(site_name), name=name, **kwargs)
def mwa_alt_az_za(obsid, ra=None, dec=None, degrees=False): """ Calculate the altitude, azumith and zenith for an obsid Args: obsid : The MWA observation id (GPS time) ra : The right acension in HH:MM:SS dec : The declintation in HH:MM:SS degrees: If true the ra and dec is given in degrees (Default:False) """ from astropy.time import Time from astropy.coordinates import SkyCoord, AltAz, EarthLocation from astropy import units as u obstime = Time(float(obsid), format='gps') if ra is None or dec is None: #if no ra and dec given use obsid ra and dec ra, dec = get_common_obs_metadata(obsid)[1:3] if degrees: sky_posn = SkyCoord(ra, dec, unit=(u.deg, u.deg)) else: sky_posn = SkyCoord(ra, dec, unit=(u.hourangle, u.deg)) earth_location = EarthLocation.of_site('Murchison Widefield Array') #earth_location = EarthLocation.from_geodetic(lon="116:40:14.93", lat="-26:42:11.95", height=377.8) altaz = sky_posn.transform_to( AltAz(obstime=obstime, location=earth_location)) Alt = altaz.alt.deg Az = altaz.az.deg Za = 90. - Alt return Alt, Az, Za
def jd2hjd(self, jd, ra, dec): obj = SkyCoord(ra, dec, unit=(U.hourangle, U.deg), frame='icrs') greenwich = EarthLocation.of_site('greenwich') jd = tm(jd, format="jd", location=greenwich) ltt_helio = jd.light_travel_time(obj, 'heliocentric') return jd + ltt_helio
def __init__(self, setting="H/1/4", detector=1, orders=None): super().__init__() self.setting = setting self.detector = detector self.orders = orders self.pixels = 2048 self.resolution = 100_000 self.pixel_size = 18 * u.um self.collection_area = (8 * u.m)**2 self.integration_time = 5 * u.min self.bad_pixel_ratio = 4e5 / (2048**2) self.spectral_broadening = 2.3 self.observatory = EarthLocation.of_site("Cerro Paranal") # TODO: gain / readnoise for each detector / wavelength range self.gain = [2.15, 2.19, 2.00] self.readnoise = [11, 12, 12] self.efficiency = 0.5 # About 50 percent makes it though self.regions, self.norders = self.__class__.load_spectral_regions( setting, detector, orders) self.blaze = self.__class__.load_blaze_function( setting, detector, orders) assert (len(self.regions) == len(self.blaze) == sum( self.norders)), "Incompatible sizes, something went wrong" # Expand detector values to the wavelength regions self.gain = np.repeat(self.gain, self.norders) self.readnoise = np.repeat(self.readnoise, self.norders)
def __init__(self): self.config = yaml.safe_load(open('solar_config.yml', 'r')) self.nohardware = self.config['no-hardware'] self.site = EarthLocation.of_site('lowell') self.tz = pytz.timezone('US/Arizona') if self.nohardware: self.guider = FakeGuider() self.camera = FakeCamera() self.telescope = FakeTelescope() else: self.guider = Guider() self.camera = Camera() self.telescope = Telescope() self.planner = expres_solar_planner() self.sio = socketio.Client() self.sio.connect('http://localhost:8081') self.scheduler = BackgroundScheduler() self.scheduler.start() self.scheduler.add_job(self.getDayPlan, 'cron', hour=1, minute=0, replace_existing=True) self.getDayPlan() # Also need to run this on the first run through t = Time(datetime.now()) if (t < Time(self.planner.sun_up)): return elif (t < Time(self.planner.meridian_flip)): self.morning() elif (t < Time(self.planner.sun_down)): self.afternoon() else: return
def check_moon(file, avoid=30. * u.degree): if not isinstance(avoid, u.Quantity): avoid = float(avoid) * u.degree else: avoid = avoid.to(u.degree) header = fits.getheader(file) mlo = EarthLocation.of_site('Keck Observatory') # Update later obstime = Time(header['DATE-OBS'], format='isot', scale='utc', location=mlo) moon = get_moon(obstime, mlo) if 'RA' in header.keys() and 'DEC' in header.keys(): coord_string = '{} {}'.format(header['RA'], header['DEC']) target = SkyCoord(coord_string, unit=(u.hourangle, u.deg)) else: ## Assume zenith target = SkyCoord(obstime.sidereal_time('apparent'), mlo.latitude) moon_alt = moon.transform_to(AltAz(obstime=obstime, location=mlo)).alt.to(u.deg) if moon_alt < 0 * u.degree: print('Moon is down') return True else: sep = target.separation(moon) print('Moon is up. Separation = {:.1f} deg'.format( sep.to(u.degree).value)) return (sep > avoid)
def jd2bjd(self, jd, ra, dec): obj = SkyCoord(ra, dec, unit=(U.hourangle, U.deg), frame='icrs') greenwich = EarthLocation.of_site('greenwich') self.logger.warning("JD: {}".format(jd)) jd = tm(jd, format="jd", location=greenwich) ltt_bary = jd.light_travel_time(obj) return jd + ltt_bary
def MMT_barycentric_correction(sp, header_MMT) : # Applying barycentric correction to wavelengths thistime = Time('2014-05-05T09:21:00', format='isot', scale='utc') thisradec = SkyCoord("17:23:37.23", "+34:11:59.07", unit=(u.hourangle, u.deg), frame='icrs') mmt= EarthLocation.of_site('mmt') # Needs internet connection barycor_vel = jrr.barycen.compute_barycentric_correction(thistime, thisradec, location=mmt) header_MMT += ("# The barycentric correction factor for s1723 was" + str(barycor_vel)) jrr.barycen.apply_barycentric_correction(sp, barycor_vel, colwav='oldwave', colwavnew='wave') return(0)
def heliocorrection(ra, dec, ot): location = 'gemini_north' uh88 = EarthLocation.of_site(location) sc = SkyCoord(ra=ra * u.deg, dec=dec * u.deg) heliocorr = sc.radial_velocity_correction('heliocentric', obstime=ot, location=uh88) return (heliocorr.to(u.km / u.s))
def dct_loc(): location_name = 'Discovery Channel Telescope' try: dct_loc_dict = pickle.load(open(settings.DCT_LOC_PICKLE, 'rb')) except FileNotFoundError: dct_loc_dict = {'archive_time': dt.utcnow(), 'location': EarthLocation.of_site(location_name)} file = open(settings.DCT_LOC_PICKLE, 'wb') pickle.dump(dct_loc_dict, file) file.close() archive_time = dct_loc_dict['archive_time'] dct_loc_obj = dct_loc_dict['location'] if (dt.utcnow()-archive_time) > td(days=2): dct_loc_dict = {'archive_time': dt.utcnow(), 'location': EarthLocation.of_site(location_name)} file = open(settings.DCT_LOC_PICKLE, 'wb') pickle.dump(dct_loc_dict, file) file.close() return dct_loc_obj
def main(): parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--ra', type=float, default=25.0, help='Right Ascension (degrees)') parser.add_argument('--dec', type=float, default=12.0, help='Declination (degrees)') parser.add_argument('--mjd', type=float, default=55000.0, help='Modified Julien Date (days)') parser.add_argument('--scan-offset', type=float, default=15.0, help='Scan offset (hours)') parser.add_argument('--scan-width', type=float, default=4.0, help='Scan width (hours)') parser.add_argument('--scan-steps', type=int, default=100, help='Number of sampling points') parser.add_argument('--astropy-apo', action='store_true', help='User apo observatory from astropy') args = parser.parse_args() if args.astropy_apo: sdss = EarthLocation.of_site('apo') else: sdss = EarthLocation(lat=32.7797556*u.deg, lon=-(105+49./60.+13/3600.)*u.deg, height=2797*u.m) coord = SkyCoord(ra=args.ra*u.degree, dec=args.dec*u.degree, frame='icrs') # scan of time hours = args.scan_offset + np.linspace(-0.5*args.scan_width, 0.5*args.scan_width, args.scan_steps) my_alt = np.zeros((hours.size)) py_alt = np.zeros((hours.size)) py_ha = np.zeros((hours.size)) for i in range(hours.size): mjd_value = args.mjd*u.day + hours[i]*u.hour time = Time(val=mjd_value, scale='tai', format='mjd', location=sdss) # altitude from astropy py_alt[i] = coord.transform_to(AltAz(obstime=time, location=sdss)).alt.to(u.deg).value # this is supposed to be the hour angle from astropy py_ha[i] = time.sidereal_time('apparent').to(u.deg).value - args.ra # simple rotation to get alt,az based on ha my_alt[i], az = hadec2altaz(py_ha[i], args.dec, sdss.latitude.to(u.deg).value) print hours[i], py_ha[i], py_alt[i], my_alt[i] py_ha = np.array(map(normalize_angle, py_ha.tolist())) ii = np.argsort(py_ha) py_ha=py_ha[ii] py_alt=py_alt[ii] my_alt=my_alt[ii] fig = plt.figure(figsize=(8,6)) plt.plot(py_ha, py_alt - my_alt, 'o', c='b') plt.title('Compare hadec2altaz') # plt.title('(ra,dec) = (%.2f,%.2f)' % (args.ra, args.dec)) plt.xlabel('Hour Angle [deg]') plt.ylabel('astropy_alt - rotation_alt [deg]') plt.grid(True) plt.show()
def to_location_via_telescope_name(self): """Calculate the observatory location via the telescope name. Returns ------- loc : `astropy.coordinates.EarthLocation` Location of the observatory. """ return EarthLocation.of_site(self.to_telescope())
def test_to_skycoord(self): t = Time('2001-01-01 12:00:00', scale='utc') g = EarthLocation.of_site('greenwich') a = grand_tools.astro.AstroConversion(longitude=g.lon, latitude=g.lat, altitude=g.height) c = a.to_skycoord(theta='0d', phi='0d', time=t) self.assertAlmostEqual(c.ra.value, 281.20741528) self.assertAlmostEqual(c.dec.value, 51.47647952)
def __init__(self): super().__init__() # TODO :: Might need to change the tolerance of disperser angle in # pypeit setup (two BH2 nights where sufficiently different that this # was important). # TODO :: Might consider changing TelescopePar to use the astropy # EarthLocation. KBW: Fine with me! self.location = EarthLocation.of_site('Keck Observatory')
def test_EarthLocation_basic(): greenwichel = EarthLocation.of_site('greenwich') lon, lat, el = greenwichel.to_geodetic() assert_quantity_allclose(lon, Longitude('0:0:0', unit=u.deg), atol=10 * u.arcsec) assert_quantity_allclose(lat, Latitude('51:28:40', unit=u.deg), atol=1 * u.arcsec) assert_quantity_allclose(el, 46 * u.m, atol=1 * u.m) names = EarthLocation.get_site_names() assert 'greenwich' in names assert 'example_site' in names with pytest.raises(KeyError) as exc: EarthLocation.of_site('nonexistent site') assert exc.value.args[ 0] == "Site 'nonexistent site' not in database. Use EarthLocation.get_site_names to see available sites."
def test_detector_frame(): site_1 = EarthLocation.of_site('H1') site_2 = EarthLocation.of_site('L1') t = Time(1e9, format='gps') detector_frame = DetectorFrame(site_1=site_1, site_2=site_2, obstime=t) itrs_frame = ITRS(obstime=t) itrs_coord = SkyCoord(*(u.Quantity(site_1.geocentric) - u.Quantity(site_2.geocentric)).value, frame=itrs_frame) assert itrs_coord.transform_to(detector_frame).lat.deg == 90 detector_coord = SkyCoord(lon=0 * u.deg, lat=90 * u.deg, frame=detector_frame) converted = detector_coord.transform_to(itrs_frame) assert converted.spherical.lon.deg == approx(itrs_coord.spherical.lon.deg) assert converted.spherical.lat.deg == approx(itrs_coord.spherical.lat.deg)
def altitude(time, ra, dec): """ This returns altitude with respect to GBT given right ascension, declination, and time """ s = SkyCoord(ra=time * u.rad, dec=dec * u.rad, frame="icrs") time = Time(time, format="mjd", scale="utc") loc = EarthLocation.of_site("Green Bank Telescope") attribute = AltAz(obstime=time, location=loc) altaz = s.transform_to(attribute) alt = altaz.alt.value return alt
def __init__(self, filename, location): self.hdu_list = fits.open(filename) self.hdr = self.hdu_list[0].header self.ra = self.hdr['RA'] self.dec = self.hdr['DEC'] try: self.location = EarthLocation.of_site(location) except errors.UnknownSiteException: print('Unknown site, use one of these sites:') print(EarthLocation.get_site_names()) sys.exit(1)
def get_earth_location_coordinates(location): """ Gets the Lat and Long on earth from a location (Site) """ real_location = EarthLocation.of_site(location) long_lat_repr = real_location.to_geodetic() longi = long_lat_repr.lon.deg lat = long_lat_repr.lat.deg return lat, longi
def create(self, name=None): """Create site""" try: if name is None: return EarthLocation(lat=self._lati_, lon=self._long_, height=self._alti_ * units.m) else: return EarthLocation.of_site(name) except Exception as e: self.logger.error(e)
def BJDConvert(mjd, RA, Dec): times = mjd t = Time(times, format='mjd', scale='utc') t2 = t.tdb c = SkyCoord(RA, Dec, unit="deg") d = c.transform_to(BarycentricTrueEcliptic) Palomar = EarthLocation.of_site('Palomar') delta = t2.light_travel_time(c, kind='barycentric', location=Palomar) BJD_TDB = t2 + delta return BJD_TDB
def to_location(self): """Calculate the observatory location. Returns ------- location : `astropy.coordinates.EarthLocation` An object representing the location of the telescope. """ # Look up the value since files do not have location value = EarthLocation.of_site("paranal") return value
def __init__(self, date=None, site='sutherland', targets=None, tz=2*u.h, **options): #res self.sitename = site.title() self.siteloc = EarthLocation.of_site(self.sitename) #TODO from time import timezone self.tz = tz #can you get this from the site location?? #obs = Observer(self.siteloc) self.targets = {} self.trajectories = {} self.plots = OrderedDict() if not date: now = datetime.now() #current local time #default behaviour of this function changes depending on the time of day. #if calling during early morning hours (at telescope) - let midnight refer to previous midnight #if calling during afternoon hours - let midnight refer to coming midnight d = now.day# + (now.hour > 7) #FIXME =32?? date = datetime(now.year, now.month, d, 0, 0, 0) else: raise NotImplementedError self.date = date self.midnight = midnight = Time(date) - tz #midnight UTC in local time #TODO: efficiency here. Dont need to plot everything over self.hours = h = np.linspace(-12, 12, 250) * u.h #variable time self.t = t = midnight + h self.tp = t.plot_date self.frames = AltAz(obstime=t, location=self.siteloc) #self.tmoon #collect name, coordinates in dict if not targets is None: self.add_coordinates(targets) #Get sun, moon coordinates sun = get_sun(t) self.sun = sun.transform_to(self.frames) #WARNING: slow!!!! #TODO: other bright stars / planets #get dawn / dusk times self.dusk, self.dawn = self.get_daylight() self.sunset, self.sunrise = self.dusk['sunset'], self.dawn['sunrise'] #get moon rise/set times, phase, illumination etc... self.moon = get_moon(t).transform_to(self.frames) self.mooning = self.get_moonlight() self.moon_phase, self.moon_ill = self.get_moon_phase() self.setup_figure() #HACK self.cid = self.figure.canvas.mpl_connect('draw_event', self._on_first_draw)
def calc_dist(df, coord, n_offs, OFF=False): if coord is not None: crab = SkyCoord.from_name(coord) altaz = AltAz( location = EarthLocation.of_site('Roque de los Muchachos'), obstime = Time(df.dragon_time, format='unix') ) telescope_pointing = SkyCoord( alt = u.Quantity(df.alt_tel.to_numpy(), u.rad, copy=False), az = u.Quantity(df.az_tel.to_numpy(), u.rad, copy=False), frame = altaz ) camera_frame = CameraFrame( focal_length = u.Quantity(df.focal_length.to_numpy(), u.m, copy=False), telescope_pointing = telescope_pointing, location = EarthLocation.of_site('Roque de los Muchachos'), obstime = Time(df.dragon_time, format='unix') ) crab_cf = crab.transform_to(camera_frame) if OFF == False: dist = (df.source_x_prediction - crab_cf.x.to_value(u.m))**2 + (df.source_y_prediction - crab_cf.y.to_value(u.m))**2 elif OFF == True and n_offs != 1: r = np.sqrt(crab_cf.x.to_value(u.m)**2 + crab_cf.y.to_value(u.m)**2) phi = np.arctan2(crab_cf.y.to_value(u.m), crab_cf.x.to_value(u.m)) dist = pd.Series() for i in range(1, n_offs + 1): x_off = r * np.cos(phi + i * 2 * np.pi / (n_offs + 1)) y_off = r * np.sin(phi + i * 2 * np.pi / (n_offs + 1)) dist = dist.append( (df.source_x_prediction - x_off)**2 + (df.source_y_prediction - y_off)**2 ) else: dist = df.source_x_prediction**2 + df.source_y_prediction**2 else: dist = df.source_x_prediction**2 + df.source_y_prediction**2 return dist
def get_coordinates_from_observer(righta, dec, location, obstime): """ Gets the Alt and Az of an Ra and Dec from a location and time """ real_time = Time(obstime) real_location = EarthLocation.of_site(location) real_coordinates = SkyCoord(righta, dec, unit=("hour", "deg")) alt_az = real_coordinates.transform_to( AltAz(obstime=real_time, location=real_location)) return alt_az.az.deg, alt_az.alt.deg
def get_the_spectra(filenames, obslog, colwave='obswave') : df = {} for thisfile in filenames : print("loading file ", thisfile) df[thisfile] = pandas.read_table(thisfile, delim_whitespace=True, comment="#") # Apply the Barycentric correction thisobs = obslog.loc[thisfile] keck = EarthLocation.of_site('keck') my_target = SkyCoord(thisobs['RA'], thisobs['DEC'], unit=(units.hourangle, units.deg), frame='icrs') my_start_time = Time( thisobs['DATE-OBS'] + "T" + thisobs['UT_START'] , format='isot', scale='utc') midpt = TimeDelta(thisobs['EXPTIME'] / 2.0, format='sec') my_time = my_start_time + midpt # time at middle of observation barycor_vel = jrr.barycen.compute_barycentric_correction(my_time, my_target, location=keck) #print "DEBUGGING", my_target, thisobs, my_target, my_start_time print("FYI, the barycentric correction factor for", thisfile, "was", barycor_vel) jrr.barycen.apply_barycentric_correction(df[thisfile], barycor_vel, colwav='obswave', colwavnew='wave') # df[thisfile]['Nfiles'] = 1 # N of exposures that went into this spectrum return(df) # return a dictionary of dataframes of spectra
def getMonths(ra, dec): from astropy import units as u from astropy.time import Time from astropy.coordinates import SkyCoord, EarthLocation, AltAz, get_sun, FK5 from datetime import datetime fk5 = SkyCoord(ra, dec, frame='fk5') # fk5c = SkyCoord(ra, dec, frame='fk5') # print fk5c # same as SkyCoord.from_name('M33'): use the explicit coordinates to allow building doc plots w/o internet kpno = EarthLocation.of_site('kpno') utcoffset = -7*u.hour # Mountain Standard Time delta_midnight = np.linspace(-5, 5,11)*u.hour months = np.array([1,2,3,4,5,6,7,8,9,10,11,12]) days = np.array([7, 14, 21, 28]) monthDict = {1:'Jan', 2:'Feb', 3:'Mar', 4:'Apr', 5:'May', 6:'Jun', 7:'Jul', 8:'Aug', 9:'Sep', 10:'Oct', 11:'Nov', 12:'Dec'} monthBool = [] for m in months: upMonth = [False, False, False, False] for j,day in enumerate(days): t = datetime(2017, m, day, 00, 00, 00) midnight = Time(t) - utcoffset times = midnight + delta_midnight # print times altazframe = AltAz(obstime=times, location=kpno) # sunaltazs = get_sun(times).transform_to(altazframe) fk5altazs = fk5.transform_to(altazframe) am = fk5altazs.secz # print am up = np.where((am < 1.5) & (am > 1.0)) # print len(up[0]) if len(up[0]) >= 3: upMonth[j] = True # print upMonth if any(upMonth): monthBool.append(True) else: monthBool.append(False) monthBool = np.array(monthBool) obsmonths = months[monthBool] return obsmonths
def test_separation_is_the_same(): from ctapipe.coordinates import TelescopeFrame obstime = Time('2013-11-01T03:00') location = EarthLocation.of_site('Roque de los Muchachos') horizon_frame = AltAz(location=location, obstime=obstime) crab = SkyCoord(ra='05h34m31.94s', dec='22d00m52.2s') ceta_tauri = SkyCoord(ra='5h37m38.6854231s', dec='21d08m33.158804s') # simulate crab "on" observations telescope_pointing = crab.transform_to(horizon_frame) telescope_frame = TelescopeFrame( telescope_pointing=telescope_pointing, location=location, obstime=obstime, ) ceta_tauri_telescope = ceta_tauri.transform_to(telescope_frame) crab_telescope = crab.transform_to(telescope_frame) sep = ceta_tauri_telescope.separation(crab_telescope).to_value(u.deg) assert ceta_tauri.separation(crab).to_value(u.deg) == approx(sep, rel=1e-4)
def plot_moon(ra, dec, year, months, outfile='plot_moon.png'): """ This will plot distance/illumination of moon for one specified month """ # Setup local time. utc_offset = 10 * u.hour # Hawaii Standard Time month_labels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] # Observatory (for symbol) keck_loc = EarthLocation.of_site('keck') keck = ephem.Observer() keck.long = keck_loc.longitude.value keck.lat = keck_loc.latitude.value # Setup Object obj = ephem.FixedBody() obj._ra = ephem.hours(ra) obj._dec = ephem.degrees(dec) obj._epoch = 2000 obj.compute() month_labels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] # Labels and colors for different months. labels = [] label_fmt = '{0:s} {1:d}' for ii in range(len(months)): label = label_fmt.format(month_labels[months[ii]-1], year) labels.append(label) sym = ['rD', 'bD', 'gD', 'cD', 'mD', 'yD'] colors = ['r', 'b', 'g', 'c', 'm', 'y'] daysInMonth = np.arange(1, 31) moondist = np.zeros(len(daysInMonth), dtype=float) moonillum = np.zeros(len(daysInMonth), dtype=float) moon = ephem.Moon() py.close(3) py.figure(3, figsize=(7, 7)) py.clf() py.subplots_adjust(left=0.1) for mm in range(len(months)): for dd in range(len(daysInMonth)): # Set the date and time to midnight keck.date = '%d/%d/%d %d' % (year, months[mm], daysInMonth[dd], utc_offset.value) moon.compute(keck) obj.compute(keck) sep = ephem.separation((obj.ra, obj.dec), (moon.ra, moon.dec)) sep *= 180.0 / math.pi moondist[dd] = sep moonillum[dd] = moon.phase print( 'Day: %2d Moon Illum: %4.1f Moon Dist: %4.1f' % \ (daysInMonth[dd], moonillum[dd], moondist[dd])) py.plot(daysInMonth, moondist, sym[mm],label=labels[mm]) for dd in range(len(daysInMonth)): py.text(daysInMonth[dd] + 0.45, moondist[dd]-2, '%2d' % moonillum[dd], color=colors[mm]) py.plot([0,31], [30,30], 'k') py.legend(loc=2, numpoints=1) py.title('Moon distance and %% Illumination (RA = %s, DEC = %s)' % (ra, dec), fontsize=14) py.xlabel('Day of Month (UT)', fontsize = 16) py.ylabel('Moon Distance (degrees)', fontsize = 16) py.axis([0, 31, 0, 200]) py.savefig(outfile)
if os.path.exists(bis_g2_path): with fits.open(bis_g2_path) as image: for h in cal_header_keys: harps_results[trim_eso_header(h)][i] = image[0].header.get(h, np.nan) print(h, image[0].header.get(h, np.nan)) else: logger.warning(f"Could not find calibration file ({bis_g2_path}) for {dataset_identifier}") # Step 6: Add an astropy-calculated barycentric velocity correction to each # header. logger.info("Calculating barycentric velocity corrections") observatory = EarthLocation.of_site("lasilla") gaia_coord = SkyCoord(ra=gaia_result["ra"] * u.degree, dec=gaia_result["dec"] * u.degree, pm_ra_cosdec=gaia_result["pmra"] * u.mas/u.yr, pm_dec=gaia_result["pmdec"] * u.mas/u.yr, obstime=Time(2015.5, format="decimalyear"), frame="icrs") def apply_space_motion(coord, time): return SkyCoord(ra=coord.ra + coord.pm_ra_cosdec/np.cos(coord.dec.radian) * (time - coord.obstime), dec=coord.dec + coord.pm_dec * (time - coord.obstime), obstime=time, frame="icrs") berv_key = "ASTROPY BERV" harps_results[berv_key] = np.nan * np.ones(len(harps_results))
def main(): ##------------------------------------------------------------------------- ## Parse Command Line Arguments ##------------------------------------------------------------------------- ## create a parser object for understanding command-line arguments parser = argparse.ArgumentParser( description="Program description.") ## add flags ## add arguments parser.add_argument("-y", "--year", type=int, dest="year", default=-1, help="The calendar year to analyze") parser.add_argument("-s", "--site", type=str, dest="site", default='Keck Observatory', help="Site name to use") parser.add_argument("-z", "--timezone", type=str, dest="timezone", default='US/Hawaii', help='pytz timezone name') parser.add_argument("-d", "--dark_time", type=float, dest="dark_time", default=2, help='Minimum dark time required (hours)') parser.add_argument("-w", "--wait_time", type=float, dest="wait_time", default=2.5, help='Maximum time after dusk to wait for moon set (hours)') args = parser.parse_args() if args.year == -1: args.year = dt.now().year ##------------------------------------------------------------------------- ## ##------------------------------------------------------------------------- loc = EarthLocation.of_site(args.site) obs = Observer.at_site(args.site) utc = pytz.timezone('UTC') localtz = pytz.timezone(args.timezone) # hour = tdelta(seconds=60.*60.*1.) # pyephem_site = ephem.Observer() # pyephem_site.lat = str(loc.lat.to(u.degree).value) # pyephem_site.lon = str(loc.lon.to(u.deg).value) # pyephem_site.elevation = loc.height.to(u.m).value # pyephem_moon = ephem.Moon() oneday = TimeDelta(60.*60.*24., format='sec') date_iso_string = '{:4d}-01-01T00:00:00'.format(args.year) start_date = Time(date_iso_string, format='isot', scale='utc', location=loc) sunset = obs.sun_set_time(start_date, which='next') ical_file = 'DarkMoonCalendar_{:4d}.ics'.format(args.year) if os.path.exists(ical_file): os.remove(ical_file) with open(ical_file, 'w') as FO: FO.write('BEGIN:VCALENDAR\n'.format()) FO.write('PRODID:-//hacksw/handcal//NONSGML v1.0//EN\n'.format()) while sunset < start_date + 365*oneday: search_around = sunset + oneday sunset = analyze_day(search_around, obs, FO, localtz, args, verbose=True) FO.write('END:VCALENDAR\n')
import numpy as np import astropy.units as u from astropy.coordinates import SkyCoord, EarthLocation, AltAz from astropy.time import Time from pytest import approx location = EarthLocation.of_site('Roque de los Muchachos') def test_cam_to_nominal(): from ctapipe.coordinates import CameraFrame, NominalFrame telescope_pointing = SkyCoord(alt=70 * u.deg, az=0 * u.deg, frame=AltAz()) array_pointing = SkyCoord(alt=72 * u.deg, az=0 * u.deg, frame=AltAz()) cam_frame = CameraFrame(focal_length=28 * u.m, telescope_pointing=telescope_pointing) cam = SkyCoord(x=0.5 * u.m, y=0.1 * u.m, frame=cam_frame) nom_frame = NominalFrame(origin=array_pointing) cam.transform_to(nom_frame) def test_icrs_to_camera(): from ctapipe.coordinates import CameraFrame obstime = Time('2013-11-01T03:00') location = EarthLocation.of_site('Roque de los Muchachos') horizon_frame = AltAz(location=location, obstime=obstime) # simulate crab "on" observations crab = SkyCoord(ra='05h34m31.94s', dec='22d00m52.2s')
def plot_airmass(ra, dec, year, months, days, observatory, outfile='plot_airmass.png', date_idx = 0): """ ra = R.A. value of target (e.g. '17:45:40.04') dec = Dec. value of target (e.g. '-29:00:28.12') year = int value of year you want to observe months = array of months (integers) where each month will have a curve. days = array of days (integers), of same length as months. observatory = Either 'keck1' or 'keck2' date_idx = Index of day to use for twilight dashed lines. Defaults to first day. Notes: Months are 1-based (i.e. 1 = January). Same for days. """ # Setup the target target = SkyCoord(ra, dec, unit=(u.hour, u.deg), frame='icrs') # Setup local time. utc_offset = -10 * u.hour # Hawaii Standard Time month_labels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] # Observatory (for symbol) obs = 'keck' keck = EarthLocation.of_site('keck') # Labels and colors for different months. labels = [] label_fmt = '{0:s} {1:d}, {2:d} (HST)' for ii in range(len(months)): label = label_fmt.format(month_labels[months[ii]-1], days[ii], year) labels.append(label) colors = ['r', 'b', 'g', 'c', 'm', 'y'] # Get sunset and sunrise times on the first specified day midnight = Time('{0:d}-{1:d}-{2:d} 00:00:00'.format(year, months[date_idx], days[date_idx])) - utc_offset delta_midnight = np.arange(-12, 12, 0.01) * u.hour times = midnight + delta_midnight altaz_frame = AltAz(obstime=times, location=keck) sun_altaz = get_sun(times).transform_to(altaz_frame) sun_down = np.where(sun_altaz.alt < -0*u.deg)[0] twilite = np.where(sun_altaz.alt < -12*u.deg)[0] sunset = delta_midnight[sun_down[0]].value sunrise = delta_midnight[sun_down[-1]].value twilite1 = delta_midnight[twilite[0]].value twilite2 = delta_midnight[twilite[-1]].value # Get the half-night split times splittime = twilite1 + ((twilite2 - twilite1) / 2.0) print( 'Sunrise %4.1f Sunset %4.1f (hours around midnight HST)' % (sunrise, sunset)) print( '12-degr %4.1f 12-degr %4.1f (hours around midnight HST)' % (twilite1, twilite2)) py.close(3) py.figure(3, figsize=(7, 7)) py.clf() py.subplots_adjust(left=0.1) for ii in range(len(days)): midnight = Time('{0:d}-{1:d}-{2:d} 00:00:00'.format(year, months[ii], days[ii])) - utc_offset delta_midnight = np.arange(-7, 7, 0.2) * u.hour times = delta_midnight.value target_altaz = target.transform_to(AltAz(obstime=midnight + delta_midnight, location=keck)) airmass = target_altaz.secz # Trim out junk where target is at "negative airmass" good = np.where(airmass > 0)[0] times = times[good] airmass = airmass[good] # Find the points beyond the Nasmyth deck. Also don't bother with anything above sec(z) = 3 transitTime = times[airmass.argmin()] if observatory == 'keck2': belowDeck = (np.where((times >= transitTime) & (airmass >= 1.8)))[0] aboveDeck = (np.where(((times >= transitTime) & (airmass < 1.8)) | (times < transitTime)))[0] else: belowDeck = (np.where((times <= transitTime) & (airmass >= 1.8)))[0] aboveDeck = (np.where(((times <= transitTime) & (airmass < 1.8)) | (times > transitTime)))[0] py.plot(times[belowDeck], airmass[belowDeck], colors[ii] + 'o', mfc='w', mec=colors[ii], ms=12) py.plot(times[aboveDeck], airmass[aboveDeck], colors[ii] + 'o', mec=colors[ii], ms=12) py.plot(times, airmass, colors[ii] + '-') py.text(-3.5, airmass[15] + (ii*0.1) - 0.65, labels[ii], color=colors[ii]) # Make observatory name nice for title if observatory == "keck1": observatory = 'Keck I' if observatory == "keck2": observatory = 'Keck II' py.title('Obs. RA = 18:00, DEC = -30:00 from %s' %observatory, fontsize = 18) # py.title('Observing RA = %s, DEC = %s from %s' % (ra, dec, observatory), fontsize=14) py.xlabel('Local Time in Hours (0 = midnight)', fontsize=16) py.ylabel('Air Mass', fontsize=16) loAirmass = 1 hiAirmass = 2.2 # Draw on the 12-degree twilight limits py.axvline(splittime, color='k', linestyle='--') py.axvline(twilite1 + 0.5, color='k', linestyle='--') py.axvline(twilite2, color='k', linestyle='--') py.axis([sunset, sunrise, loAirmass, hiAirmass]) py.savefig(outfile)
def demo_site_chooser() : EarthLocation.get_site_names() # Print names of all sites astropy knows about. May need internet connection keck = EarthLocation.of_site('keck') lco = EarthLocation.of_site('Las Campanas Observatory') return(0)