def skycoord(self): ''' Manage and fix sky coordinates ''' head = self.head.copy() # time if self.obstime not in head: head['JD'] = Time.now().jd # earthlocation location = EarthLocation(lon=self.lon, lat=self.lat, height=self.alt) timekey = head[self.obstime] # log.warning(timekey) if 'MJD' in self.obstime: obstime = Time(timekey, format='mjd') elif self.obstime == 'JD': obstime = Time(timekey, format='jd') # elif isinstance(self.obstime, list): # obstime = Time(Time(timekey[0]).unix+timekey[1]) elif 'DATE' in self.obstime: obstime = Time(timekey) else: obstime = Time(timekey) obstime.location = location # skycoord if self.ra in head and self.dec in head: coord = SkyCoord( ra=head[self.ra], dec=head[self.dec], location=location, obstime=obstime, equinox=obstime.jyear_str[:-2], # frame='icrs', frame='fk5', unit=self.unit) elif self.obj in head: coord = SkyCoord.from_name( head[self.obj], #location=location, #obstime=obstime, # frame='icrs', #equinox=obstime.jyear_str[:-2] frame='fk5') else: log.error("No (RA DEC) and no OBJECT in header") return coord = coord.transform_to(FK5(equinox='J2000')) # Meteo if self.temperature and self.temperature in head: coord.temperature = head[self.temperature] * u.deg_C if self.pressure and self.pressure in head: coord.pressure = head[self.pressure] * u.hPa if self.humidity and self.humidity in head: coord.relative_humidity = head[self.humidity] / 100 # coord.obstime=obstime self.coord = coord return coord
def test_asdf_url_mapper(): """Make sure specutils asdf extension url_mapping doesn't interfere with astropy schemas""" frame = FK5() af = asdf.AsdfFile() af.tree = {'frame': frame}
@pytest.fixture(params=[None] + LSRD_EQUIV) def observer(request): return request.param # Target located in direction of motion of LSRD with no velocities LSRD_DIR_STATIONARY = Galactic(u=9 * u.km, v=12 * u.km, w=7 * u.km, representation_type='cartesian') LSRD_DIR_STATIONARY_EQUIV = [ LSRD_DIR_STATIONARY, SkyCoord(LSRD_DIR_STATIONARY), # as a SkyCoord LSRD_DIR_STATIONARY.transform_to(FK5()), # different frame LSRD_DIR_STATIONARY.transform_to(ICRS()).transform_to( Galactic()) # different representation ] @pytest.fixture(params=[None] + LSRD_DIR_STATIONARY_EQUIV) def target(request): return request.param def test_create_spectral_coord_observer_target(observer, target): with nullcontext() if target is None else pytest.warns( AstropyUserWarning, match='No velocity defined on frame'): coord = SpectralCoord([100, 200, 300] * u.nm,
def main(targ_file, survey='2r', radec=None, deci=None, fpath=None, EPOCH=0., DSS=None, BW=False, imsize=5., show_spec=False): ''' Parameters: --------- targ_file: string or List of string ASCII file for targets (Name, RA, DEC) or a List Colon separated RA, DEC expected radec: integer (0) Flag indicating type of input 0 = ASCII file 1 = List or ['Name', 'RA', 'DEC'] BW: bool (False) B&W image? show_spec: bool (False) Try to grab and show an SDSS spectrum ''' import radec as x_r reload(x_r) import matplotlib.pyplot as plt import matplotlib.cm as cm # Init if fpath is None: fpath = './' cradius = imsize / 50. # Read in the Target list ra_tab = get_coord(targ_file, radec=radec) # Grab ra, dec in decimal degrees if deci != None: return # Convert to decimal degress x_r.stod(ra_tab) #ra_tab['RA'][q], ra_tab['DEC'][q], TABL) # Precess (as necessary) if EPOCH > 1000.: from astropy import units as u from astropy.coordinates import FK5 from astropy.time import Time # Precess to 2000. tEPOCH = Time(EPOCH, format='jyear', scale='utc') # Load into astropy fk5c = FK5(ra=ra_tab['RAD'], dec=ra_tab['DECD'], equinox=tEPOCH, unit=(u.degree, u.degree)) # Precess newEPOCH = Time(2000., format='jyear', scale='utc') newfk5 = fk5c.precess_to(newEPOCH) # Save ra_tab['RAD'] = newfk5.ra.degree ra_tab['DECD'] = newfk5.dec.degree # Strings too? ra_tab['RA'] = str(newfk5.ra.to_string(unit=u.hour, sep=':')) ra_tab['DEC'] = str(newfk5.dec.to_string(unit=u.hour, sep=':')) ## # Main Loop nobj = len(ra_tab) for qq in range(nobj): # Outfil outfil = fpath + ra_tab['Name'][qq] + '.pdf' print(outfil) # Grab the Image from xastropy.obs import x_getsdssimg as xgs reload(xgs) img, oBW = xgs.getimg(ra_tab['RAD'][qq], ra_tab['DECD'][qq], imsize, BW=BW, DSS=DSS) # Generate the plot plt.clf() fig = plt.figure(dpi=1200) fig.set_size_inches(8.0, 10.5) # Font plt.rcParams['font.family'] = 'times new roman' ticks_font = matplotlib.font_manager.FontProperties( family='times new roman', style='normal', size=16, weight='normal', stretch='normal') ax = plt.gca() for label in ax.get_yticklabels(): label.set_fontproperties(ticks_font) for label in ax.get_xticklabels(): label.set_fontproperties(ticks_font) # Image if oBW == 1: cmm = cm.Greys_r else: cmm = None plt.imshow(img, cmap=cmm, aspect='equal', extent=(-imsize / 2., imsize / 2, -imsize / 2., imsize / 2)) # Axes plt.xlim(-imsize / 2., imsize / 2.) plt.ylim(-imsize / 2., imsize / 2.) # Label plt.xlabel('Relative ArcMin', fontsize=20) xpos = 0.12 * imsize ypos = 0.02 * imsize plt.text(-imsize / 2. - xpos, 0., 'EAST', rotation=90., fontsize=20) plt.text(0., imsize / 2. + ypos, 'NORTH', fontsize=20, horizontalalignment='center') # Title plt.text(0.5, 1.24, str(ra_tab['Name'][qq]), fontsize=32, horizontalalignment='center', transform=ax.transAxes) plt.text(0.5, 1.16, 'RA (J2000) = ' + str(ra_tab['RA'][qq]), fontsize=28, horizontalalignment='center', transform=ax.transAxes) plt.text(0.5, 1.10, 'DEC (J2000) = ' + str(ra_tab['DEC'][qq]), fontsize=28, horizontalalignment='center', transform=ax.transAxes) #import pdb; pdb.set_trace() # Circle circle = plt.Circle((0, 0), cradius, color='y', fill=False) plt.gca().add_artist(circle) # Spectrum?? if show_spec: spec_img = xgs.get_spec_img(ra_tab['RAD'][qq], ra_tab['DECD'][qq]) plt.imshow(spec_img, extent=(-imsize / 2.1, imsize * (-0.1), -imsize / 2.1, imsize * (-0.2))) # Write if show_spec: plt.savefig(outfil, dpi=300) else: plt.savefig(outfil) print 'finder: Wrote ' + outfil #xdb.set_trace() print 'finder: All done.' return
def compute_paral_angles(header, latitude, ra_key, dec_key, lst_key, acqtime_key, date_key='DATE-OBS'): """Calculates the parallactic angle for a frame, taking coordinates and local sidereal time from fits-headers (frames taken in an alt-az telescope with the image rotator off). The coordinates in the header are assumed to be J2000 FK5 coordinates. The spherical trigonometry formula for calculating the parallactic angle is taken from Astronomical Algorithms (Meeus, 1998). Parameters ---------- header : dictionary Header of current frame. latitude : float Latitude of the observatory in degrees. The dictionaries in vip/conf/param.py can be used like: latitude=LBT['latitude']. ra_key, dec_key, lst_key, acqtime_key, date_key : strings Keywords where the values are stored in the header. Returns ------- pa.value : float Parallactic angle in degrees for current header (frame). """ obs_epoch = Time(header[date_key], format='iso', scale='utc') # equatorial coordinates in J2000 ra = header[ra_key] dec = header[dec_key] coor = SkyCoord(ra=ra, dec=dec, unit=(hourangle, degree), frame=FK5, equinox='J2000.0') # recalculate for DATE-OBS (precession) coor_curr = coor.transform_to(FK5(equinox=obs_epoch)) # new ra and dec in radians ra_curr = coor_curr.ra dec_curr = coor_curr.dec lst_split = header[lst_key].split(':') lst = float(lst_split[0]) + old_div(float(lst_split[1]), 60) + old_div( float(lst_split[2]), 3600) exp_delay = old_div((header[acqtime_key] * 0.5), 3600) # solar to sidereal time exp_delay = exp_delay * 1.0027 # hour angle in degrees hour_angle = (lst + exp_delay) * 15 - ra_curr.deg hour_angle = np.deg2rad(hour_angle) latitude = np.deg2rad(latitude) # PA formula from Astronomical Algorithms pa = -np.rad2deg(np.arctan2(-np.sin(hour_angle), np.cos(dec_curr) * \ np.tan(latitude) - np.sin(dec_curr) * np.cos(hour_angle))) #if dec_curr.value > latitude: pa = (pa.value + 360) % 360 return pa.value
from astropy import coordinates import numpy as np from astropy.coordinates import FK5 from astropy.time import Time df = pd.read_csv("gaume1995_format.tab", header=0, delim_whitespace=True) # df = pd.read_csv('gaume1995.csv') header = fits.open('../data/abcd_006_lpf_new.fits')[0].header mywcs = wcs.WCS(header).celestial df['G95_X'] = np.ones_like(df['G95_RA']) df['G95_Y'] = np.ones_like(df['G95_DEC']) df['G95_A'] = df['G95_A']/0.05 df['G95_B'] = df['G95_B']/0.05 for i in range(df.shape[0]): cen_coor = coordinates.SkyCoord(str(df['G95_RA'][i]), str(df['G95_DEC'][i]), unit=(u.h, u.deg), frame='fk4', equinox='B1950') cen_coor = cen_coor.transform_to(FK5(equinox='J2000')) # print(cen_coor) (df['G95_X'][i], df['G95_Y'][i]) = mywcs.wcs_world2pix([[cen_coor.ra.deg, cen_coor.dec.deg]], 0)[0].astype(int) # print('%s %s' % (df['G95_RA'][i], df['G95_DEC'][i]) print('%.0f %.0f' % (df['G95_X'][i], df['G95_Y'][i])) df.to_csv('gaume1995.csv', index=False)
def calc_vobs(self, ra_2000, dec_2000): x_2000 = [] x = [] x_solar = [] v_earth = [] v_solar = [] solar_tmp = [] #1.85m at nobeyama #glongitude = 138.472153 #nanten2 at atacama (nanten2wiki) glongitude = -67.70308139 #1.85m at nobeyama #glatitude = 35.940874 #nanten2 at atacama (nanten2wiki) glatitude = -22.96995611 #1.85m at nobeyama #gheight = 1386 #nanten2 at atacama gheight = 4863.85 #init a = math.cos(dec_2000) x_2000 = [ a * math.cos(ra_2000), a * math.sin(ra_2000), math.sin(dec_2000) ] tu = (self.t.jd - 2451545.) / 36525. #correction(precession, nutation) sc_fk5 = SkyCoord(ra=ra_2000 * u.radian, dec=dec_2000 * u.radian, frame="fk5") trans = sc_fk5.transform_to( FK5(equinox="J{}".format(2000. + tu * 100.))) ranow = trans.ra.radian delnow = trans.dec.radian x = self.nutation(ranow, delnow) #Earth velocity to object earthloc = EarthLocation(lon=glongitude * u.deg, lat=glatitude * u.deg, height=gheight * u.m) earthloc_gcrs = earthloc.get_gcrs(self.t) sc_earth = SkyCoord(earthloc_gcrs).fk5 v_earth = sc_earth.velocity.d_xyz.value vobs = -(v_earth[0] * x_2000[0] + v_earth[1] * x_2000[1] + v_earth[2] * x_2000[2]) #solar sc_fk4_sol = SkyCoord(ra=18 * 15 * u.deg, dec=30 * u.deg, frame="fk4") trans_sol = sc_fk4_sol.transform_to( FK5(equinox="J{}".format(2000. + tu * 100.))) rasol = trans_sol.ra.radian delsol = trans_sol.dec.radian solar_tmp = self.nutation(rasol, delsol) v_solar = [solar_tmp[0] * 20, solar_tmp[1] * 20, solar_tmp[2] * 20] vobs = -(vobs - (v_solar[0] * x[0] + v_solar[1] * x[1] + v_solar[2] * x[2])) return vobs
def test_fk5_time(tmpdir): tree = {'coord': FK5(equinox="2011-01-01T00:00:00")} assert_roundtrip_tree(tree, tmpdir)
def stack_npixels( npixels, level_neighbours=5, params=None, max_data=1000, calc_flux=True, use_flagged_pixels=False, skip_detections=False, custom_bkg=False, moc_masked_sources=None, order=16, with_plots=False, plotfile=None, scale=None, ): ecf_pn = { "6": ECF.ecf_det_eband("PN", "6"), "7": ECF.ecf_det_eband("PN", "7"), "8": ECF.ecf_det_eband("PN", "8"), } num_neighbours = sum([8 * k for k in range(level_neighbours + 1)]) + 1 ebands = ["6", "7", "8"] src_stack = np.zeros((max_data, num_neighbours, len(ebands))) bkg_stack = np.zeros((max_data, num_neighbours, len(ebands))) exp_stack = np.zeros((max_data, num_neighbours, len(ebands))) eef_stack = np.ones((max_data, num_neighbours, len(ebands))) ac_stack = np.zeros((max_data, num_neighbours, len(ebands))) npixels_bkg_stack = np.ones((max_data, num_neighbours, len(ebands))) ecf_stack = np.zeros((max_data, len(ebands))) if calc_flux: src_flux_center = np.full((max_data, len(ebands)), np.nan) bkg_flux_center = np.full((max_data, len(ebands)), np.nan) src_flux_err_center = np.full((max_data, len(ebands)), np.nan) bkg_flux_err_center = np.full((max_data, len(ebands)), np.nan) if params: params_stack = np.zeros((max_data, len(params.colnames))) hp = HEALPix(nside=2**order, order="nested", frame=FK5()) n, nsrc = 0, 0 for j, npixel in enumerate(tqdm(npixels)): sorted_neighbours = get_neighbours(npixel, hp, level=level_neighbours) data = rapidxmm.query_npixels(sorted_neighbours["npixel"], obstype="pointed", instrum="PN") if len(data) == 0: continue nsrc += 1 data = data.group_by(["obsid", "instrum"]) for group in data.groups: data_obs_order = join(sorted_neighbours, group, keys=["npixel"], join_type="left") data_obs_order.sort("order") if skip_detections: if np.any(data_obs_order["band8_flags"] >= 8): continue if custom_bkg: bkg_data = get_bkg_data(npixel, group["obsid"][0], hp) if bkg_data is None: # We couldn't find a good background region for this npixel, # so it's rejected from the stack continue for i, eband in enumerate(ebands): if use_flagged_pixels: mask = [True] * len(sorted_neighbours) else: mask = data_obs_order[f"band{eband}_flags"] == 0 src_stack[n, mask, i] = data_obs_order[f"band{eband}_src_counts"][mask] exp_stack[n, mask, i] = data_obs_order[f"band{eband}_exposure"][mask] eef_stack[n, mask, i] = data_obs_order["eef"][mask] ac_stack[n, mask, i] = data_obs_order["area_ratio"][mask] if custom_bkg: mask_bkg = bkg_data[f"band{eband}_flags"] == 0 # The same average bkg value is assigned to all npixels in the detection bkg_counts = bkg_data[f"band{eband}_bck_counts"][mask_bkg] bkg_stack[n, mask, i] = np.mean(bkg_counts) npixels_bkg_stack[n, mask, i] = len(bkg_counts) else: bkg_stack[ n, mask, i] = data_obs_order[f"band{eband}_bck_counts"][mask] if calc_flux and np.any(mask): ecf_stack[n, i] = ecf_pn[eband][group["filt"][0]].get_ecf( params["NHGAL"][j], 1.9) exp = np.mean(exp_stack[n, mask, i]) ngood = len(exp_stack[n, mask, i]) src_flux_center[n, i] = (np.sum(src_stack[n, mask, i]) / exp / ecf_stack[n, i] / 1e11 / ngood) src_flux_err_center[n, i] = ( np.sqrt(np.sum(src_stack[n, mask, i])) / exp / ecf_stack[n, i] / 1e11 / ngood) if custom_bkg: exp_bkg = np.mean( bkg_data[f"band{eband}_exposure"][mask_bkg]) ngood_bkg = len( bkg_data[f"band{eband}_exposure"][mask_bkg]) bkg_flux_center[n, i] = (np.sum(bkg_counts) / exp_bkg / ecf_stack[n, i] / 1e11 / ngood_bkg) bkg_flux_err_center[n, i] = (np.sqrt(np.sum(bkg_counts)) / exp_bkg / ecf_stack[n, i] / 1e11 / ngood_bkg) else: bkg_flux_center[n, i] = (np.sum(bkg_stack[n, mask, i]) / exp / ecf_stack[n, i] / 1e11 / ngood) bkg_flux_err_center[n, i] = ( np.sqrt(np.sum(bkg_stack[n, mask, i])) / exp / ecf_stack[n, i] / 1e11 / ngood) if params: for i, col in enumerate(params.colnames): params_stack[n, i] = params[col][j] n += 1 src_stack = src_stack[:n, :, :] bkg_stack = bkg_stack[:n, :, :] exp_stack = exp_stack[:n, :, :] ecf_stack = ecf_stack[:n, :] if custom_bkg: # No need to take into account the area correction when using custom # backgrounds, since counts are extracted in regions with the same size ac_stack = None npixels_bkg_stack = npixels_bkg_stack[:n, :] else: ac_stack = ac_stack[:n, :] npixels_bkg_stack = None if n < 2: return None, None, None, None, None, None, None cr, cr_mad, snr, snr_mad, ecf, texp = stats_bootstrap(src_stack, bkg_stack, exp_stack, eef_stack, ecf_stack, ac_stack, npixels_bkg_stack, nsim=1000) flux, flux_mad = None, None flux2, flux2_mad = None, None if calc_flux: src_flux_center = src_flux_center[:n, :] src_flux_err_center = src_flux_err_center[:n, :] bkg_flux_center = bkg_flux_center[:n, :] bkg_flux_err_center = bkg_flux_err_center[:n, :] flux, flux_mad = flux_bootstrap(src_flux_center, src_flux_err_center, bkg_flux_center, bkg_flux_err_center, nsim=1000) flux2 = np.mean(cr, axis=0) / ecf / 1e11 flux2_mad = np.sqrt(np.mean(cr_mad**2, axis=0)) / ecf / 1e11 if with_plots: scale = plot_stack(sorted_neighbours["npixel"], hp, cr, snr, plotfile, scale) plot_radial(sorted_neighbours["npixel"], level_neighbours, hp, cr, cr_mad, snr, snr_mad, plotfile) print_stats(cr, cr_mad, snr, snr_mad, texp, flux, flux_mad) if params: average_params = print_params(params.colnames, params_stack[:n, :]) else: average_params = None return flux, flux_mad, flux2, flux2_mad, average_params, scale, n, nsrc
def setcelest(self, celestin, ra_unit=u.hourangle, dec_unit=u.deg): """Sets the celestial coords. Input can be a SkyCoord instance, a list or tuple of (ra,dec) or (ra,dec,equinox), or a character string. If it's a character string it has to be e.g. 18:22:22.3 -0:18:33 18:22:22.3 -0:18:33 2015 18 22 22.3 -0 18 33 18 22 22.3 -0 18 33 2015 specifying "ra_unit = u.deg" will accept ras. """ if isinstance(celestin, SkyCoord): # if it's a SkyCoord, just copy it. self.celest = celestin elif isinstance(celestin, tuple) or isinstance(celestin, list): # if len(celestin) == 2: self.celest = SkyCoord(celestin[0], celestin[1], unit=(ra_unit, dec_unit)) # parse a tuple elif len(celestin) == 3: # print("celestin[2] = ",celestin[2]) eq = float(celestin[2]) if eq == 2000.: self.celest = SkyCoord(celestin[0], celestin[1], unit=(ra_unit, dec_unit)) else: eq = "J%7.2f" % (eq) self.celest = SkyCoord(celestin[0], celestin[1], unit=(ra_unit, dec_unit), frame=FK5(equinox=eq)) elif isinstance(celestin, str): # str includes unicode in python3. pieces = celest.splitin() if len(pieces ) >= 6: # space-separated fields - glue back together. rastr = pieces[0] + ":" + pieces[1] + ":" + pieces[2] decstr = pieces[3] + ":" + pieces[4] + ":" + pieces[5] if len(pieces) == 7: # if there's an equinox ... eqstr = pieces[6] else: eqstr = '2000.' else: # e.g. 21:29:36.2 so split gets ra and dec separately rastr = pieces[0] decstr = pieces[1] if len(pieces) > 2: eqstr = pieces[2] # if there's an equinox ... else: eqstr = '2000.' # print "rastr decstr eqstr",rastr,decstr,eqstr if float(eqstr) == 2000.: # default to ICRS if 2000. self.celest = SkyCoord(rastr, decstr, unit=(ra_unit, dec_unit)) else: # or set in FK5 frame of date if not 2000. eq = "J" + eqstr self.celest = SkyCoord(rastr, decstr, unit=(ra_unit, dec_unit), frame=FK5(equinox=eq)) # print(" ************ IN SETCELEST ************ ") # print( "self.celest:",self.celest) # print( "frame.name:",self.celest.frame.name) if self.celest.frame.name == 'icrs' or self.celest.frame.name == 'gcrs': self.cel_J2000 = self.celest elif self.celest.frame.name == 'precessedgeocentric': self.cel_J2000 = self.celest.transform_to('gcrs') else: self.cel_J2000 = self.celest.transform_to('icrs')
def main(): args = parse_args() np.warnings.filterwarnings('ignore') # Find calibrator position calib = SkyCoord.from_name(args.calibname) # Put all the output from drift_scan_auto_corr.ipynb in a unique folder per source, per set of drift scans. datafiles = glob(args.root + '*exported_data.csv') datafiles.sort() posfiles = glob(args.root + '*hadec.csv') posfiles.sort() # Put calibrator into apparent coordinates (because that is what the telescope observes it in.) test = calib.transform_to('fk5') calibnow = test.transform_to(FK5(equinox='J{}'.format(taskid2equinox(args.taskid)))) corr_im = [] diff_im = [] for beam in range(40): print(beam, end=' ') # Create the vectors which contain all data from all scans for a given beam which has been specified above. x, y, z_xx, z_yy = [], [], [], [] for file, pos in zip(datafiles, posfiles): data = Table.read(file, format='csv') hadec = Table.read(pos, format='csv') hadec_start = SkyCoord(ra=hadec['ha'], dec=hadec['dec'], unit=(u.rad, u.rad)) # From ALTA (same as above) time_mjd = Time(data['time'] / (3600 * 24), format='mjd') lst = time_mjd.sidereal_time('apparent', westerbork().lon) HAcal = lst - calibnow.ra # in sky coords dHAsky = HAcal - hadec_start[beam].ra + (24 * u.hourangle) # in sky coords in hours dHAsky.wrap_at('180d', inplace=True) dHAphys = dHAsky * np.cos(hadec_start[beam].dec.deg * u.deg) # physical offset in hours x = np.append(x, dHAphys.deg) y = np.append(y, np.full(len(dHAphys.deg), hadec_start[beam].dec.deg)) z_xx = np.append(z_xx, data['auto_corr_beam_' + str(beam) + '_xx'] - np.median( data['auto_corr_beam_' + str(beam) + '_xx'])) z_yy = np.append(z_yy, data['auto_corr_beam_' + str(beam) + '_yy'] - np.median( data['auto_corr_beam_' + str(beam) + '_yy'])) # # Add a fake drift that goes to zero power at 1 deg above last scan # x=np.append(x,dHAphys.deg) # y=np.append(y,np.full(len(dHAphys.deg),max(y)+1.0)) # z_xx=np.append(z_xx,np.full(len(dHAphys.deg),1)) # z_yy=np.append(z_yy,np.full(len(dHAphys.deg),1)) # # Add a fake drift that goes to zero power at 1 deg below first scan # x=np.append(x,dHAphys.deg) # y=np.append(y,np.full(len(dHAphys.deg),min(y)-1.0)) # z_xx=np.append(z_xx,np.full(len(dHAphys.deg),1)) # z_yy=np.append(z_yy,np.full(len(dHAphys.deg),1)) # Create the 2D grid and do a cubic interpolation cell_size = 105. / 3600. tx = np.arange(min(x), max(x), cell_size) ty = np.arange(min(y), max(y), cell_size) XI, YI = np.meshgrid(tx, ty) gridcubx = interpolate.griddata((x, y), z_xx, (XI, YI), method='cubic') # median already subtracted gridcuby = interpolate.griddata((x, y), z_yy, (XI, YI), method='cubic') # Find the reference pixel at the apparent coordinates of the calibrator ref_pixy = (calibnow.dec.deg - min(y)) / cell_size ref_pixx = (-min(x)) / cell_size # Find the peak of the primary beam to normalize norm_xx = np.max(gridcubx[int(ref_pixy)-3:int(ref_pixy)+4, int(ref_pixx)-3:int(ref_pixx)+4]) norm_yy = np.max(gridcuby[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) if beam == 0: norm0_xx = np.max(gridcubx[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) norm0_yy = np.max(gridcuby[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) # Convert to decibels db_xx = np.log10(gridcubx/norm_xx) * 10. db_yy = np.log10(gridcuby/norm_yy) * 10. # db0_xx = np.log10(gridcubx/norm0_xx) * 10. # db0_yy = np.log10(gridcuby/norm0_yy) * 10. wcs = WCS(naxis=2) wcs.wcs.cdelt = np.array([-cell_size, cell_size]) wcs.wcs.ctype = ['RA---TAN', 'DEC--TAN'] wcs.wcs.crval = [calib.ra.to_value(u.deg), calib.dec.to_value(u.deg)] wcs.wcs.crpix = [ref_pixx, ref_pixy] header = wcs.to_header() hdux_db = fits.PrimaryHDU(db_xx, header=header) hduy_db = fits.PrimaryHDU(db_yy, header=header) hdux = fits.PrimaryHDU(gridcubx/norm_xx, header=header) hduy = fits.PrimaryHDU(gridcuby/norm_yy, header=header) # hdulx = fits.HDUList([hdux]) # hduly = fits.HDUList([hduy]) # Save the FITS files hdux_db.writeto(args.root + '{}_{}_{:02}xx_db.fits'.format(args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) hduy_db.writeto(args.root + '{}_{}_{:02}yy_db.fits'.format(args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) hdux.writeto(args.root + '{}_{}_{:02}xx.fits'.format(args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) hduy.writeto(args.root + '{}_{}_{:02}yy.fits'.format(args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) fig1 = plt.figure(figsize=(6, 9)) ax1 = fig1.add_subplot(2, 1, 1, projection=wcs.celestial) ax1.grid(lw=1, color='white') ax1.set_title("Beam {:02} - XX Correlation - Cubic".format(beam)) ax1.set_ylabel("Declination [J2000]") ax1.set_xlabel("Right Ascension [J2000]") im1 = ax1.imshow(gridcubx/norm0_xx, vmax=0.10, vmin=-0.03, cmap='magma', animated=True) ax2 = fig1.add_subplot(2, 1, 2, projection=wcs.celestial) ax2.grid(lw=1, color='white') ax2.set_title("Beam {:02} - YY Correlation - Cubic".format(beam)) ax2.set_ylabel("Declination [J2000]") ax2.set_xlabel("Right Ascension [J2000]") im2 = ax2.imshow(gridcuby/norm0_yy, vmax=0.10, vmin=-0.03, cmap='magma', animated=True) corr_im.append([im1, im2]) plt.savefig(args.root + '{}_{}_{:02}db0_reconstructed.png'.format(args.calibname.replace(" ", ""), args.taskid, beam)) plt.close('all') # Plot the difference between XX and YY for every beam diffcub = gridcubx/norm_xx - gridcuby/norm_yy fig2 = plt.figure(figsize=(10, 9)) ax1 = fig2.add_subplot(1, 1, 1, projection=wcs.celestial) ax1.grid(lw=1, color='white') ax1.set_title("Beam {:02} - Difference (XX$-$YY)".format(beam)) ax1.set_ylabel("Declination [J2000]") ax1.set_xlabel("Right Ascension [J2000]") ax1.scatter(ref_pixx, ref_pixy, marker='x', color='black') im3 = ax1.imshow(diffcub, vmin=-0.1, vmax=0.1) plt.colorbar(im3) diff_im.append([im3]) plt.savefig(args.root + '{}_{}_{:02}_difference.png'.format(args.calibname.replace(" ", ""), args.taskid, beam)) plt.close('all') if args.make_gifs: make_gifs(args.root)
def __init__(self, **kwargs): ''' Possible arguments: - lon: Longitude (in degrees otherwise specify lon_unit as an astropy unit) - lat: Latitude (in degrees otherwise specify lat_unit as an astropy unit) - height: Altitude (in meters otherwise specify height_unit as an astropy unit) - time: time of the observation in unix format and in seconds or as an astropy.time.core.Time object - ra: Right ascension (in degrees otherwise specify coord1_unit as an astropy unit) - dec: Declination (in degrees otherwise specify coord2_unit as an astropy unit) - az: Azimuth (in degrees otherwise specify coord1_unit as an astropy unit) - alt: Elevation (in degrees otherwise specify coord2_unit as an astropy unit) - radec_frame: Frame of the Equatorial system, ICRS, current or J2000. Default is current if a time is defined, otherwise is J2000 ''' ra = kwargs.get('ra') dec = kwargs.get('dec') if ra is not None and dec is not None: self.system = 'celestial' coord1 = ra coord2 = dec az = kwargs.get('az') alt = kwargs.get('alt') if az is not None and alt is not None: self.system = 'horizontal' coord1 = az coord2 = alt coord1_unit = kwargs.get('coord1_unit', u.degree) if isinstance(coord1, u.quantity.Quantity): self.coord1 = coord1 else: self.coord1 = coord1*coord1_unit coord2_unit = kwargs.get('coord2_unit', u.degree) if isinstance(coord2, u.quantity.Quantity): self.coord2 = coord2 else: self.coord2 = coord2*coord2_unit lon = kwargs.get('lon') lon_unit = kwargs.get('lon_unit', u.degree) if isinstance(lon, u.quantity.Quantity): self.lon = lon else: self.lon = lon*lon_unit lat = kwargs.get('lat') lat_unit = kwargs.get('lat_unit', u.degree) if isinstance(lat, u.quantity.Quantity): self.lat = lat else: self.lat = lat*lat_unit height = kwargs.get('height', 0.) height_unit = kwargs.get('height_unit', u.meter) if isinstance(height, u.quantity.Quantity): self.height = height else: self.height = height*height_unit time = kwargs.get('time') if isinstance(time, core.Time): self.time = Time else: if time is not None: self.time = Time(time*u.s, format='unix', scale='utc') else: self.time = Time('J2000') if time is not None: radec_frame = kwargs.get('radec_frame', 'current') else: radec_frame = 'j2000' if radec_frame.lower() == 'icrs': self.radec_frame = ICRS() elif radec_frame.lower() == 'j2000': self.radec_frame = FK5(equinox='j2000') elif radec_frame.lower() == 'current': time_epoch = np.mean(self.time.unix) self.radec_frame = FK5(equinox=Time(time_epoch, format='unix', scale='utc')) else: self.radec_frame = radec_frame self.location = EarthLocation(lon=self.lon, lat=self.lat, height=self.height) self.altaz_frame = AltAz(obstime = self.time, location = self.location) self.coordinates = [] if self.system == 'celestial': self.coordinates = SkyCoord(self.coord1, self.coord2, frame=self.radec_frame) elif self.system == 'horizontal': self.coordinates = SkyCoord(self.coord1, self.coord2, frame=self.altaz_frame)
spm_dec = '+15:20:10.84' # penso il centro del campo, pixel 516 # Scala in gradi: 0.000138 gradi per pixel. # Il target si trova ai pixel 430, 385 # Differenza in pixel: -82,-131 → -0.0114,0.0182 gradi spm_jd = 2458829.827152778 spm_equinox = 'J2019.9' spm = SkyCoord(ra=spm_ra, dec=spm_dec, obstime=Time(spm_jd, format="jd"), frame="fk5", equinox=spm_equinox, unit=(u.hourangle, u.deg) ) spm_2000 = spm.transform_to(FK5(equinox="J2000")) # SIMBAD gj = SkyCoord.from_name("GJ3470").fk5 ########################################## # Generic2 ########################################## # INIT pattern = "gj3470/*/*/*.fit*" filenames = glob.glob(pattern, recursive=True) db = minidb(filenames) keys = ["CCDXBIN"]
a = source.split(',') from_info = [int(a[2]), int(a[4]), int(a[5])] if from_file == from_info: ra = float(a[0]) dec = float(a[1]) trigger = 1 break f1.close() if trigger == 1: #ie if a match is detected ## Get Pixel Coordinates header = fits.getheader('./fits/' + name[:-1]) a = WCS(header) c = FK5(float(ra), float(dec), unit='deg') output = astropy.wcs.utils.skycoord_to_pixel(c, a) # pix1 = np.floor(output[0]) pix2 = np.floor(output[1]) # Check if the peak coincides with centre and shift if it does not. temp = fits.getdata('./fits/' + name[:-1]) temp = temp[pix2 - 5:pix2 + 6, pix1 - 5:pix1 + 6] new_pix = np.argmax(temp) new_pix = np.unravel_index(new_pix, (11, 11)) pix2 = pix2 + (new_pix[0] - 5) pix1 = pix1 + (new_pix[1] - 5) # Now with given peak value, form an image cutout
def radec_to_altaz(radec: SkyCoord, time: Time, observer: EarthLocation = nenufar_position, fast_compute: bool = True) -> SkyCoord: r""" Converts a celestial object equatorial coordinates to horizontal coordinates. If ``fast_compute=True`` is selected, the computation is accelerated using Local Sidereal Time approximation (see :func:`~nenupy.astro.astro_tools.local_sidereal_time`). The altitude :math:`\theta` and azimuth :math:`\varphi` are computed as follows: .. math:: \cases{ \sin(\theta) = \sin(\delta) \sin(l) + \cos(\delta) \cos(l) \cos(h)\\ \cos(\varphi) = \frac{\sin(\delta) - \sin(l) \sin(\theta)}{\cos(l)\cos(\varphi)} } with :math:`\delta` the object's declination, :math:`l` the ``observer``'s latitude and :math:`h` the Local Hour Angle (see :func:`~nenupy.astro.astro_tools.hour_angle`). If :math:`\sin(h) \geq 0`, then :math:`\varphi = 2 \pi - \varphi`. Otherwise, :meth:`~astropy.coordinates.SkyCoord.transform_to` is used. :param radec: Celestial object equatorial coordinates. :type radec: :class:`~astropy.coordinates.SkyCoord` :param time: Coordinated universal time. :type time: :class:`~astropy.time.Time` :param observer: Earth location where the observer is at. Default is NenuFAR's position. :type observer: :class:`~astropy.coordinates.EarthLocation` :param fast_compute: If set to ``True``, it enables faster computation time for the conversion, mainly relying on an approximation of the local sidereal time. All other values would lead to accurate coordinates computation. Differences in coordinates values are of the order of :math:`10^{-2}` degrees or less. :type fast_compute: `bool` :returns: Celestial object's horizontal coordinates. If either ``radec`` or ``time`` are 1D arrays, the resulting object will be of shape ``(time, positions)``. :rtype: :class:`~astropy.coordinates.SkyCoord` :Example: .. code-block:: python from nenupy.astro import radec_to_altaz from astropy.time import Time from astropy.coordinates import SkyCoord altaz = radec_to_altaz( radec=SkyCoord([300, 200], [45, 45], unit="deg"), time=Time("2022-01-01T12:00:00"), fast_compute=True ) """ if not time.isscalar: time = time.reshape((time.size, 1)) radec = radec.reshape((1, radec.size)) if fast_compute: radec = radec.transform_to(FK5(equinox=time)) ha = hour_angle(radec=radec, time=time, observer=observer, fast_compute=fast_compute) two_pi = Angle(360.0, unit='deg') ha = hour_angle(radec=radec, time=time, observer=observer, fast_compute=fast_compute) sin_dec = np.sin(radec.dec.rad) cos_dec = np.cos(radec.dec.rad) sin_lat = np.sin(observer.lat.rad) cos_lat = np.cos(observer.lat.rad) # Compute elevation sin_elevation = sin_dec * sin_lat + cos_dec * cos_lat * np.cos(ha.rad) elevation = Latitude(np.arcsin(sin_elevation), unit="rad") # Compute azimuth cos_azimuth = (sin_dec - np.sin(elevation.rad)*sin_lat)/\ (np.cos(elevation.rad)*cos_lat) azimuth = Longitude(np.arccos(cos_azimuth), unit="rad") if azimuth.isscalar: if np.sin(ha.rad) > 0: azimuth *= -1 azimuth += two_pi else: posMask = np.sin(ha.rad) > 0 azimuth[posMask] *= -1 azimuth[posMask] += two_pi return SkyCoord(azimuth, elevation, frame=AltAz(obstime=time, location=observer)) else: return radec.transform_to(AltAz(obstime=time, location=observer))
def main(): args = parse_args() np.warnings.filterwarnings('ignore') # Find calibrator position calib = SkyCoord.from_name(args.calibname) cell_size = 100. / 3600. freqchunks = 10 # Put all the output from drift_scan_auto_corr.ipynb in a unique folder per source, per set of drift scans. datafiles = glob(args.root + '*_exported_data_frequency_split.csv') datafiles.sort() posfiles = glob(args.root + '*hadec.csv') posfiles.sort() # Put calibrator into apparent coordinates (because that is what the telescope observes it in.) test = calib.transform_to('fk5') calibnow = test.transform_to( FK5(equinox='J{}'.format(taskid2equinox(args.taskid)))) # Read data once and be smart about how we search it. data_tab, hadec_tab = [], [] print("\nReading in all the data...") for file, pos in zip(datafiles, posfiles): data_tab.append(Table.read(file, format='csv')) # list of tables hadec_tab.append(Table.read(pos, format='csv')) # list of tables print("Making beam maps: ", end=' ') for beam in range(0, 40): print(beam, end=' ') for f in range(freqchunks): x, y, z_xx, z_yy = [], [], [], [] for data, hadec in zip(data_tab, hadec_tab): hadec_start = SkyCoord(ra=hadec['ha'], dec=hadec['dec'], unit=(u.rad, u.rad)) time_mjd = Time(data['time'] / (3600 * 24), format='mjd') lst = time_mjd.sidereal_time('apparent', westerbork().lon) HAcal = lst - calibnow.ra # in sky coords dHAsky = HAcal - hadec_start[beam].ra + ( 24 * u.hourangle) # in sky coords in hours dHAsky.wrap_at('180d', inplace=True) dHAphys = dHAsky * np.cos(hadec_start[beam].dec.deg * u.deg) # physical offset in hours x = np.append(x, dHAphys.deg) y = np.append( y, np.full(len(dHAphys.deg), hadec_start[beam].dec.deg)) z_xx = np.append( z_xx, data['auto_corr_beam_{}_freq_{}_xx'.format(beam, f)] - np.median(data['auto_corr_beam_{}_freq_{}_xx'.format( beam, f)])) z_yy = np.append( z_yy, data['auto_corr_beam_{}_freq_{}_yy'.format(beam, f)] - np.median(data['auto_corr_beam_{}_freq_{}_yy'.format( beam, f)])) # Create the 2D plane, do a cubic interpolation, and append it to the cube. tx = np.arange(min(x), max(x), cell_size) ty = np.arange(min(y), max(y), cell_size) XI, YI = np.meshgrid(tx, ty) gridcubx = interpolate.griddata( (x, y), z_xx, (XI, YI), method='cubic') # median already subtracted gridcuby = interpolate.griddata((x, y), z_yy, (XI, YI), method='cubic') # Find the reference pixel at the apparent coordinates of the calibrator ref_pixy = (calibnow.dec.deg - min(y)) / cell_size + 1 # FITS indexed from 1 ref_pixx = (-min(x)) / cell_size + 1 # FITS indexed from 1 ref_pixz = 1 # FITS indexed from 1 # Find the peak of the primary beam to normalize norm_xx = np.max(gridcubx[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) norm_yy = np.max(gridcuby[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) # if beam == 0: # norm0_xx = np.max(gridcubx[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) # norm0_yy = np.max(gridcuby[int(ref_pixy) - 3:int(ref_pixy) + 4, int(ref_pixx) - 3:int(ref_pixx) + 4]) # Create 3D array with proper size for given scan set to save data as a cube if f == 0: cube_xx = np.zeros( (freqchunks, gridcubx.shape[0], gridcubx.shape[1])) cube_yy = np.zeros( (freqchunks, gridcuby.shape[0], gridcuby.shape[1])) db_xx = np.zeros( (freqchunks, gridcubx.shape[0], gridcubx.shape[1])) db_yy = np.zeros( (freqchunks, gridcuby.shape[0], gridcuby.shape[1])) cube_xx[f, :, :] = gridcubx / norm_xx cube_yy[f, :, :] = gridcuby / norm_yy # Convert to decibels db_xx[f, :, :] = np.log10(gridcubx / norm_xx) * 10. db_yy[f, :, :] = np.log10(gridcuby / norm_yy) * 10. stokesI = np.sqrt(0.5 * cube_yy**2 + 0.5 * cube_xx**2) squint = cube_xx - cube_yy wcs = WCS(naxis=3) wcs.wcs.cdelt = np.array([-cell_size, cell_size, 12.207e3 * 1500]) wcs.wcs.ctype = ['RA---TAN', 'DEC--TAN', 'FREQ'] wcs.wcs.crval = [ calib.ra.to_value(u.deg), calib.dec.to_value(u.deg), 1219.609e6 + (12.207e3 * (500 + 1500 / 2)) ] wcs.wcs.crpix = [ref_pixx, ref_pixy, ref_pixz] wcs.wcs.specsys = 'TOPOCENT' wcs.wcs.restfrq = 1.420405752e+9 header = wcs.to_header() # hdux_db = fits.PrimaryHDU(db_xx, header=header) # hduy_db = fits.PrimaryHDU(db_yy, header=header) hdux = fits.PrimaryHDU(cube_xx, header=header) hduy = fits.PrimaryHDU(cube_yy, header=header) hduI = fits.PrimaryHDU(stokesI, header=header) hdusq = fits.PrimaryHDU(squint, header=header) # Save the FITS files # hdux_db.writeto(args.root + '{}_{}_{:02}xx_db_cube.fits'.format(args.calibname.replace(" ", ""), # args.taskid[:-3], # beam), overwrite=True) # hduy_db.writeto(args.root + '{}_{}_{:02}yy_db_cube.fits'.format(args.calibname.replace(" ", ""), # args.taskid[:-3], # beam), overwrite=True) hdux.writeto(args.root + '{}_{}_{:02}xx.fits'.format( args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) hduy.writeto(args.root + '{}_{}_{:02}yy.fits'.format( args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) hduI.writeto(args.root + '{}_{}_{:02}_I.fits'.format( args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True) hdusq.writeto(args.root + '{}_{}_{:02}_diff.fits'.format( args.calibname.replace(" ", ""), args.taskid[:-3], beam), overwrite=True)
import numpy as np from astropy.coordinates import (SkyCoord, FK5, Latitude, Angle, ICRS, concatenate, UnitSphericalRepresentation, CartesianRepresentation, match_coordinates_sky) from astropy import units as u from astropy.time import Time def time_latitude(): Latitude(3.2, u.degree) ANGLES = Angle(np.ones(10000), u.deg) J2010 = Time('J2010') fk5_J2010 = FK5(equinox=J2010) rnd = np.random.RandomState(seed=42) def time_angle_array_repr(): # Prior to Astropy 3.0, this was very inefficient repr(ANGLES) def time_angle_array_str(): # Prior to Astropy 3.0, this was very inefficient str(ANGLES) def time_angle_array_repr_latex(): # Prior to Astropy 3.0, this was very inefficient
mwatime = Time(dt) logger.info('Computing for %s=%10.0f' % (mwatime.iso, mwatime.gps)) source = SkyCoord(ra=RA, dec=Dec, frame='icrs', unit=(astropy.units.deg, astropy.units.deg)) source.location = config.MWAPOS source.obstime = mwatime source_altaz = source.transform_to('altaz') Alt, Az = source_altaz.alt.deg, source_altaz.az.deg # Transform to Topocentric Alt/Az at the current epoch if precess: source_now = source.transform_to( FK5(equinox=mwatime )) # Transform to FK5 coordinates at the current epoch RAnow, Decnow = source_now.ra.deg, source_now.dec.deg else: RAnow, Decnow = RA, Dec # print "DEBUG = %s" % (Az) # different than what it was in the original version # print "DEBUG = %s" % (Alt) # go from altitude to zenith angle theta = (90 - Alt) * math.pi / 180 phi = Az * math.pi / 180 logger.info('Time (get beam): %s' % datetime.datetime.now().time()) # BUGFIX by MS 2016-04-20 - described in details in odt document. The essence is that python reads images transposed with respect to cross-diagonal # however later Tim calculates map of ra,dec then az,alt using WCS parameters which results in having coordinates for non-transposed image.
def time_init_nodata(self): FK5()
(row['time_2'] - row['time_1']).to(u.h).value, axis=1) data['timespan'] = data.apply(lambda row: row['time_1'] + np.linspace( 0, row['obs_length'], 100) * u.hour, axis=1) data['altazframe'] = data.apply( lambda row: AltAz(location=WSRT, obstime=row['timespan']), axis=1) data['my_obj'] = data.apply(lambda row: SkyCoord( ra=row['ra'], dec=row['dec'], unit=(u.hourangle, u.deg)), axis=1) data['my_obj_altaz'] = data.apply( lambda row: row['my_obj'].transform_to(row['altazframe']), axis=1) data['my_obj_fk5'] = data.apply( lambda row: row['my_obj'].transform_to(FK5(equinox=row['timespan'])), axis=1) data['my_obj_HA'] = data.apply(lambda row: row['my_obj_fk5'].ra - row[ 'timespan'].sidereal_time('apparent', longitude=WSRT.lon), axis=1) data['LST'] = data.apply( lambda row: row['timespan'].sidereal_time('apparent', longitude=WSRT.lon), axis=1) data['my_obj_LHA'] = data.apply(lambda row: row['timespan'].sidereal_time( 'apparent', longitude=WSRT.lon) - row['my_obj_fk5'].ra, axis=1) data['my_obj_LHA_2'] = data.apply(lambda row: add_12(row['my_obj_LHA'].value), axis=1) #-------------------------------------------------- # make elevation plot
def time_init_scalar(self): FK5(self.scalar_ra, self.scalar_dec)
def get_sunset_and_sunrise(tnow, loc, refalt_set, refalt_rise): # Get time nmjd = 64 mjd0 = np.floor(tnow.mjd) mnow = tnow.mjd - mjd0 mjd = np.linspace(mjd0 - 1.0, mjd0 + 3.0, nmjd) t = Time(mjd, format='mjd', scale='utc') # Get sun position psun = get_sun(t) # Correct for precession by converting to FK5 pos = SkyCoord(ra=psun.ra.degree, dec=psun.dec.degree, frame='icrs', unit='deg').transform_to(FK5(equinox=t)) # Compute altitude extrema de = np.mean(pos.dec) minalt = np.arcsin( np.sin(loc.lat) * np.sin(de) - np.cos(loc.lat) * np.cos(de)) maxalt = np.arcsin( np.sin(loc.lat) * np.sin(de) + np.cos(loc.lat) * np.cos(de)) # Never sets, never rises? if minalt > min(refalt_set, refalt_rise): return "sun never sets", t[0], t[0] elif maxalt < max(refalt_set, refalt_rise): return "sun never rises", t[0], t[0] # Prevent discontinuities in right ascension dra = pos[-1].ra - pos[0].ra ra = pos.ra.degree if dra < 0.0: c = pos.ra.degree < 180.0 ra[c] = pos[c].ra.degree + 360.0 # Set up interpolating function fra = interpolate.interp1d(t.mjd, ra) fde = interpolate.interp1d(t.mjd, pos.dec.degree) # Get GMST gmst0 = Time(mjd0, format='mjd', scale='utc').sidereal_time('mean', 'greenwich') # Get transit time mtransit = np.mod( (fra(mjd0) * u.degree - loc.lon - gmst0) / (360.0 * u.degree), 1.0) while True: gmst = gmst0 + 360.985647 * u.deg * mtransit ra = fra(mjd0 + mtransit) * u.deg ha = gmst + loc.lon - ra mtransit -= ha / (360.0 * u.deg) if np.abs(ha.degree) < 1e-9: break # Hour angle offset ha0 = np.arccos( (np.sin(refalt_set) - np.sin(loc.lat) * np.sin(np.mean(pos.dec))) / (np.cos(loc.lat) * np.cos(np.mean(pos.dec)))) # Get set time mset = mtransit + ha0 / (360.0 * u.deg) while True: gmst = gmst0 + 360.985647 * u.deg * mset ra = fra(mjd0 + mset) * u.deg de = fde(mjd0 + mset) * u.deg ha = gmst + loc.lon - ra alt = np.arcsin( np.sin(loc.lat) * np.sin(de) + np.cos(loc.lat) * np.cos(de) * np.cos(ha)) dm = (alt - refalt_set) / (360.0 * u.deg * np.cos(de) * np.cos(loc.lat) * np.sin(ha)) mset += dm # Break loop or find sunset on next day if np.abs(dm) < 1e-9: if mset >= mnow: break else: mset += 1.0 # Set set time tset = Time(mjd0 + mset.value, format='mjd', scale='utc') # Get rise time mrise = mtransit - ha0 / (360.0 * u.deg) while True: gmst = gmst0 + 360.985647 * u.deg * mrise ra = fra(mjd0 + mrise) * u.deg de = fde(mjd0 + mrise) * u.deg ha = gmst + loc.lon - ra alt = np.arcsin( np.sin(loc.lat) * np.sin(de) + np.cos(loc.lat) * np.cos(de) * np.cos(ha)) dm = (alt - refalt_rise) / (360.0 * u.deg * np.cos(de) * np.cos(loc.lat) * np.sin(ha)) mrise += dm # Break loop or find sunrise on next day if np.abs(dm) < 1e-9: if mrise >= mnow: break else: mrise += 1.0 # Set rise time trise = Time(mjd0 + mrise.value, format='mjd', scale='utc') return "sun rises and sets", tset, trise
def time_init_array(self): FK5(self.array_ra, self.array_dec)
def test_overlay_coords(self, ignore_matplotlibrc, tmpdir): wcs = WCS(self.msx_header) fig = plt.figure(figsize=(4, 4)) canvas = fig.canvas ax = WCSAxes(fig, [0.1, 0.1, 0.8, 0.8], wcs=wcs) fig.add_axes(ax) # On some systems, fig.canvas.draw is not enough to force a draw, so we # save to a temporary file. fig.savefig(tmpdir.join('test1.png').strpath) # Testing default displayed world coordinates string_world = ax._display_world_coords(0.523412, 0.518311) assert string_world == '0\xb029\'45" -0\xb029\'20" (world)' # Test pixel coordinates event1 = KeyEvent('test_pixel_coords', canvas, 'w') fig.canvas.key_press_event(event1.key, guiEvent=event1) string_pixel = ax._display_world_coords(0.523412, 0.523412) assert string_pixel == "0.523412 0.523412 (pixel)" event3 = KeyEvent('test_pixel_coords', canvas, 'w') fig.canvas.key_press_event(event3.key, guiEvent=event3) # Test that it still displays world coords when there are no overlay coords string_world2 = ax._display_world_coords(0.523412, 0.518311) assert string_world2 == '0\xb029\'45" -0\xb029\'20" (world)' overlay = ax.get_coords_overlay('fk5') # Regression test for bug that caused format to always be taken from # main world coordinates. overlay[0].set_major_formatter('d.ddd') # On some systems, fig.canvas.draw is not enough to force a draw, so we # save to a temporary file. fig.savefig(tmpdir.join('test2.png').strpath) event4 = KeyEvent('test_pixel_coords', canvas, 'w') fig.canvas.key_press_event(event4.key, guiEvent=event4) # Test that it displays the overlay world coordinates string_world3 = ax._display_world_coords(0.523412, 0.518311) assert string_world3 == '267.176\xb0 -28\xb045\'56" (world, overlay 1)' overlay = ax.get_coords_overlay(FK5()) # Regression test for bug that caused format to always be taken from # main world coordinates. overlay[0].set_major_formatter('d.ddd') # On some systems, fig.canvas.draw is not enough to force a draw, so we # save to a temporary file. fig.savefig(tmpdir.join('test3.png').strpath) event5 = KeyEvent('test_pixel_coords', canvas, 'w') fig.canvas.key_press_event(event4.key, guiEvent=event4) # Test that it displays the overlay world coordinates string_world4 = ax._display_world_coords(0.523412, 0.518311) assert string_world4 == '267.176\xb0 -28\xb045\'56" (world, overlay 2)' overlay = ax.get_coords_overlay(FK5(equinox=Time("J2030"))) # Regression test for bug that caused format to always be taken from # main world coordinates. overlay[0].set_major_formatter('d.ddd') # On some systems, fig.canvas.draw is not enough to force a draw, so we # save to a temporary file. fig.savefig(tmpdir.join('test4.png').strpath) event6 = KeyEvent('test_pixel_coords', canvas, 'w') fig.canvas.key_press_event(event5.key, guiEvent=event6) # Test that it displays the overlay world coordinates string_world5 = ax._display_world_coords(0.523412, 0.518311) assert string_world5 == '267.652\xb0 -28\xb046\'23" (world, overlay 3)'
def time_init_scalar_diff(self): FK5(self.scalar_ra, self.scalar_dec, pm_ra_cosdec=self.scalar_pmra, pm_dec=self.scalar_pmdec)
when = time.Time.now() + time.TimeDelta(60 * args.offset, format='sec') print('\nUT =', when) # Get location info = SITES[args.telescope] site = coord.EarthLocation.from_geodetic(info['long'], info['lat'], info['height']) print('Lat = {:0.2f} degrees'.format(site.lat.value)) print('Lon = {:0.2f} degrees'.format(site.lon.value)) # Get position position = SkyCoord(args.position, unit=(u.hourangle, u.deg)) lst = when.sidereal_time(kind='apparent', longitude=site.lon) print('LST =', lst) FK5_when = FK5(equinox=when) position_when = position.transform_to(FK5_when) ha = lst - position_when.ra.to(u.hourangle) print('HA =', ha) # now convert to alt/az altazframe = AltAz(obstime=when, location=site) altaz = position_when.transform_to(altazframe) print('Az = {:0.2f} degrees'.format(altaz.az.value)) print('Alt = {:0.2f} degrees'.format(altaz.alt.value)) # Compute latitude, alt, az, dec and ha, all in radians lat = math.radians(site.lat.value) alt = math.radians(altaz.alt.value) az = math.radians(altaz.az.value)
def main(inp, survey='2r', radec=None, deci=None, fpath=None, show_circ=True, EPOCH=0., DSS=None, BW=False, imsize=5. * astrou.arcmin, show_spec=False, OUT_TYPE='PDF'): ''' Parameters: --------- inp: Input string or List of strings or List of several items 'ra_dec_list.txt' -- ASCII file with columns of Name,RA,DEC and RA,DEC are string or float (deg) ['NAME_OF_TARG', '10:31:38.87', '+25:59:02.3'] ['NAME_OF_TARG', 124.24*u.deg, -23.244*u.deg] ['NAME_OF_TARG', SkyCoord] radec: integer (0) [DEPRECATED!] Flag indicating type of input 0 = ASCII file with columns of Name,RA,DEC and RA,DEC are string or float (deg) 1 = List of string ['Name', 'RA', 'DEC'] 2 = ['Name', ra_deg, dec_deg] BW: bool (False) B&W image? show_circ: bool (True) Show a yellow circle on the target show_spec: bool (False) Try to grab and show an SDSS spectrum imsize: Quantity, optional Image size OUT_TYPE: str, optional File type -- 'PDF', 'PNG' ''' reload(x_r) reload(xgs) import matplotlib.pyplot as plt import matplotlib.cm as cm # Init if fpath is None: fpath = './' try: imsize = imsize.to('arcmin').value except AttributeError: raise AttributeError('finder: Input imsize needs to be an Angle') cradius = imsize / 50. # Read in the Target list if isinstance(inp, basestring): ra_tab = get_coord(targ_file, radec=radec) else: ira_tab = {} ira_tab['Name'] = inp[0] if isinstance(inp[1], basestring): ra, dec = x_r.stod1((inp[1], inp[2])) ira_tab['RA'] = ra ira_tab['DEC'] = dec elif isinstance(inp[1], float): ira_tab['RA'] = inp[1] * astrou.deg ira_tab['DEC'] = inp[2] * astrou.deg elif isinstance(inp[1], SkyCoord): ira_tab['RA'] = inp[1].ra.deg ira_tab['DEC'] = inp[1].dec.deg else: # Should check it is a Quantity ira_tab['RA'] = inp[1] ira_tab['DEC'] = inp[2] # Strings ras, decs = x_r.dtos1((ira_tab['RA'], ira_tab['DEC'])) ira_tab['RAS'] = ras ira_tab['DECS'] = decs # Make a list ra_tab = [ira_tab] # Grab ra, dec in decimal degrees if deci is not None: return #xdb.set_trace() #x_r.stod(ra_tab) #ra_tab['RA'][q], ra_tab['DEC'][q], TABL) # Precess (as necessary) if EPOCH > 1000.: from astropy import units as u from astropy.coordinates import FK5 from astropy.time import Time # Precess to 2000. tEPOCH = Time(EPOCH, format='jyear', scale='utc') # Load into astropy fk5c = FK5(ra=ra_tab['RA'], dec=ra_tab['DEC'], equinox=tEPOCH, unit=(u.degree, u.degree)) # Precess newEPOCH = Time(2000., format='jyear', scale='utc') newfk5 = fk5c.precess_to(newEPOCH) # Save ra_tab['RA'] = newfk5.ra.degree ra_tab['DEC'] = newfk5.dec.degree # Strings too? ra_tab['RAS'] = str(newfk5.ra.to_string(unit=u.hour, sep=':')) ra_tab['DECS'] = str(newfk5.dec.to_string(unit=u.hour, sep=':')) ## # Main Loop for obj in ra_tab: # Outfil nm = "".join(obj['Name'].split()) if OUT_TYPE == 'PNG': outfil = fpath + nm + '.png' else: outfil = fpath + nm + '.pdf' print(outfil) # Grab the Image reload(xgs) img, oBW = xgs.getimg(obj['RA'], obj['DEC'], imsize, BW=BW, DSS=DSS) # Generate the plot plt.clf() fig = plt.figure(dpi=1200) fig.set_size_inches(8.0, 10.5) # Font plt.rcParams['font.family'] = 'times new roman' ticks_font = matplotlib.font_manager.FontProperties( family='times new roman', style='normal', size=16, weight='normal', stretch='normal') ax = plt.gca() for label in ax.get_yticklabels(): label.set_fontproperties(ticks_font) for label in ax.get_xticklabels(): label.set_fontproperties(ticks_font) # Image if oBW == 1: cmm = cm.Greys_r else: cmm = None plt.imshow(img, cmap=cmm, aspect='equal', extent=(-imsize / 2., imsize / 2, -imsize / 2., imsize / 2)) # Axes plt.xlim(-imsize / 2., imsize / 2.) plt.ylim(-imsize / 2., imsize / 2.) # Label plt.xlabel('Relative ArcMin', fontsize=20) xpos = 0.12 * imsize ypos = 0.02 * imsize plt.text(-imsize / 2. - xpos, 0., 'EAST', rotation=90., fontsize=20) plt.text(0., imsize / 2. + ypos, 'NORTH', fontsize=20, horizontalalignment='center') # Title plt.text(0.5, 1.24, str(nm), fontsize=32, horizontalalignment='center', transform=ax.transAxes) plt.text(0.5, 1.16, 'RA (J2000) = ' + str(obj['RAS']), fontsize=28, horizontalalignment='center', transform=ax.transAxes) plt.text(0.5, 1.10, 'DEC (J2000) = ' + str(obj['DECS']), fontsize=28, horizontalalignment='center', transform=ax.transAxes) #import pdb; pdb.set_trace() # Circle if show_circ: circle = plt.Circle((0, 0), cradius, color='y', fill=False) plt.gca().add_artist(circle) # Spectrum?? if show_spec: spec_img = xgs.get_spec_img(obj['RA'], obj['DEC']) plt.imshow(spec_img, extent=(-imsize / 2.1, imsize * (-0.1), -imsize / 2.1, imsize * (-0.2))) # Write if show_spec: plt.savefig(outfil, dpi=300) else: plt.savefig(outfil) print 'finder: Wrote ' + outfil plt.close() #xdb.set_trace() print 'finder: All done.' return oBW