def test_intersection_nominal_reconstruction():
"""
Testing the reconstruction of the position in the nominal frame with a three-telescopes system.
This is done using a squared configuration, of which the impact point occupies a vertex,
ad the three telescopes the other three vertices.
"""
hill_inter = HillasIntersection()
delta = 1.0 * u.m
horizon_frame = AltAz()
altitude = 70 * u.deg
azimuth = 10 * u.deg
array_direction = SkyCoord(alt=altitude, az=azimuth, frame=horizon_frame)
nominal_frame = NominalFrame(origin=array_direction)
focal_length = 28 * u.m
camera_frame = CameraFrame(
focal_length=focal_length, telescope_pointing=array_direction
)
cog_coords_camera_1 = SkyCoord(x=delta, y=0 * u.m, frame=camera_frame)
cog_coords_camera_2 = SkyCoord(x=delta / 0.7, y=delta / 0.7, frame=camera_frame)
cog_coords_camera_3 = SkyCoord(x=0 * u.m, y=delta, frame=camera_frame)
cog_coords_nom_1 = cog_coords_camera_1.transform_to(nominal_frame)
cog_coords_nom_2 = cog_coords_camera_2.transform_to(nominal_frame)
cog_coords_nom_3 = cog_coords_camera_3.transform_to(nominal_frame)
# x-axis is along the altitude and y-axis is along the azimuth
hillas_1 = HillasParametersContainer(
x=cog_coords_nom_1.fov_lat,
y=cog_coords_nom_1.fov_lon,
intensity=100,
psi=0 * u.deg,
)
hillas_2 = HillasParametersContainer(
x=cog_coords_nom_2.fov_lat,
y=cog_coords_nom_2.fov_lon,
intensity=100,
psi=45 * u.deg,
)
hillas_3 = HillasParametersContainer(
x=cog_coords_nom_3.fov_lat,
y=cog_coords_nom_3.fov_lon,
intensity=100,
psi=90 * u.deg,
)
hillas_dict = {1: hillas_1, 2: hillas_2, 3: hillas_3}
reco_nominal = hill_inter.reconstruct_nominal(hillas_parameters=hillas_dict)
nominal_pos = SkyCoord(
fov_lon=u.Quantity(reco_nominal[0], u.rad),
fov_lat=u.Quantity(reco_nominal[1], u.rad),
frame=nominal_frame,
)
np.testing.assert_allclose(
nominal_pos.altaz.az.to_value(u.deg), azimuth.to_value(u.deg), atol=1e-8
)
np.testing.assert_allclose(
nominal_pos.altaz.alt.to_value(u.deg), altitude.to_value(u.deg), atol=1e-8
)
def derive_lightcurve_info(lightcurve_pk):
"""
Function to derive extra information about the observations from the
fits files, calculate several parameters, and derive weather information
from external sources is possible.
This information is stored in the lightcurve database entry
"""
#-- get lightcurve
lightcurve = LightCurve.objects.get(pk=lightcurve_pk)
hjd, flux, header = lightcurve.get_lightcurve()
#-- load info from lightcurve header
data = instrument_headers.extract_header_info(header)
# HJD
lightcurve.hjd = data.get('hjd', 2400000)
lightcurve.hjd_start = data.get('hjd_start', 2400000)
lightcurve.hjd_end = data.get('hjd_end', 2400000)
# pointing info
lightcurve.objectname = data.get('objectname', '')
lightcurve.ra = data.get('ra', -1)
lightcurve.dec = data.get('dec', -1)
lightcurve.alt = data.get('alt', -1)
lightcurve.az = data.get('az', -1)
lightcurve.airmass = data.get('airmass', -1)
# telescope and instrument info
lightcurve.instrument = data.get('instrument', 'UK')
lightcurve.telescope = data.get('telescope', 'UK')
lightcurve.passband = data.get('passband', 'UK')
lightcurve.exptime = data.get('exptime', -1)
lightcurve.cadence = data.get('cadence', -1)
lightcurve.duration = data.get('duration', -1)
lightcurve.observer = data.get('observer', 'UK')
lightcurve.filetype = data.get('filetype', 'UK')
# observing conditions
if isfloat(data.get('wind_speed', -1)):
lightcurve.wind_speed = data.get('wind_speed', -1)
if isfloat(data.get('wind_direction', -1)):
lightcurve.wind_direction = data.get('wind_direction', -1)
lightcurve.seeing = data.get('seeing', -1)
#-- observatory
lightcurve.observatory = instrument_headers.get_observatory(header, lightcurve.project)
#-- save the changes
lightcurve.save()
#-- if the observatory is in space, no moon ect can be calculated
if lightcurve.observatory.space_craft:
return
#-- calculate moon parameters
time = Time(lightcurve.hjd, format='jd')
# moon illumination wit astroplan (astroplan returns a fraction, but we store percentage)
lightcurve.moon_illumination = np.round(moon_illumination(time=time)*100, 1)
# get the star and moon coordinates at time and location of observations
star = SkyCoord(ra=lightcurve.ra*u.deg, dec=lightcurve.dec*u.deg,)
moon = get_moon(time)
observatory = lightcurve.observatory.get_EarthLocation()
frame = AltAz(obstime=time, location=observatory)
star = star.transform_to(frame)
moon = moon.transform_to(frame)
# store the separation between moon and target
lightcurve.moon_separation = np.round(star.separation(moon).degree, 1)
#-- get object alt-az and airmass if not stored in header
if lightcurve.alt == 0:
lightcurve.alt = star.alt.degree
if lightcurve.az == 0:
lightcurve.az = star.az.degree
if lightcurve.airmass <= 0:
lightcurve.airmass = np.round(star.secz.value, 2)
#-- save the changes
lightcurve.save()
def test_contains(region):
geom = RegionGeom.create(region)
position = SkyCoord([0, 0], [0, 1.1], frame="galactic", unit="deg")
contains = geom.contains(coords={"skycoord": position})
assert_allclose(contains, [1, 0])
def plot(obs_parameters='', n=0, m=0, f_rest=0, slope_correction=False, dB=False, vlsr=False, meta=False, avg_ylim=[0,0], cal_ylim=[0,0], rfi=[], xlim=[0,0], ylim=[0,0], dm=0,
obs_file='observation.dat', cal_file='', waterfall_fits='', spectra_csv='', power_csv='', plot_file='plot.png'):
'''
Process, analyze and plot data.
Args:
obs_parameters: dict. Observation parameters (identical to parameters used to acquire data)
dev_args: string. Device arguments (gr-osmosdr)
rf_gain: float. RF gain
if_gain: float. IF gain
bb_gain: float. Baseband gain
frequency: float. Center frequency [Hz]
bandwidth: float. Instantaneous bandwidth [Hz]
channels: int: Number of frequency channels (FFT size)
t_sample: float: Integration time per FFT sample
duration: float: Total observing duration [sec]
loc: string: latitude, longitude, and elevation of observation (float, separated by spaces)
ra_dec: string: right ascension and declination of observation target (float, separated by space)
az_alt: string: azimuth and altitude of observation target (float, separated by space; takes precedence over ra_dec)
n: int. Median filter factor (spectrum)
m: int. Median filter factor (time series)
f_rest: float. Spectral line reference frequency used for radial velocity (Doppler shift) calculations [Hz]
slope_correction: bool. Correct slope in poorly-calibrated spectra using linear regression
dB: bool. Display data in decibel scaling
vlsr: bool. Display graph in VLSR frame of reference
meta: bool. Display header with date, time, and target
rfi: list. Blank frequency channels contaminated with RFI ([low_frequency, high_frequency]) [Hz]
avg_ylim: list. Averaged plot y-axis limits ([low, high])
cal_ylim: list. Calibrated plot y-axis limits ([low, high])
xlim: list. x-axis limits ([low_frequency, high_frequency]) [Hz]
ylim: list. y-axis limits ([start_time, end_time]) [Hz]
dm: float. Dispersion measure for dedispersion [pc/cm^3]
obs_file: string. Input observation filename (generated with virgo.observe)
cal_file: string. Input calibration filename (generated with virgo.observe)
waterfall_fits: string. Output FITS filename
spectra_csv: string. Output CSV filename (spectra)
power_csv: string. Output CSV filename (time series)
plot_file: string. Output plot filename
'''
import matplotlib
matplotlib.use('Agg') # Try commenting this line if you run into display/rendering errors
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
plt.rcParams['legend.fontsize'] = 14
plt.rcParams['axes.labelsize'] = 14
plt.rcParams['axes.titlesize'] = 18
plt.rcParams['xtick.labelsize'] = 12
plt.rcParams['ytick.labelsize'] = 12
def decibel(x):
if dB: return 10.0*np.log10(x)
return x
def shift(phase_num, n_rows):
waterfall[:, phase_num] = np.roll(waterfall[:, phase_num], -n_rows)
def SNR(spectrum, mask=np.array([])):
'''Signal-to-Noise Ratio estimator, with optional masking.
If mask not given, then all channels will be used to estimate noise
(will drastically underestimate S:N - not robust to outliers!)'''
if mask.size == 0:
mask = np.zeros_like(spectrum)
noise = np.nanstd((spectrum[2:]-spectrum[:-2])[mask[1:-1] == 0])/np.sqrt(2)
background = np.nanmean(spectrum[mask == 0])
return (spectrum-background)/noise
def best_fit(power):
'''Compute best Gaussian fit'''
avg = np.nanmean(power)
var = np.var(power)
gaussian_fit_x = np.linspace(np.min(power),np.max(power),100)
gaussian_fit_y = 1.0/np.sqrt(2*np.pi*var)*np.exp(-0.5*(gaussian_fit_x-avg)**2/var)
return [gaussian_fit_x, gaussian_fit_y]
# Load observation parameters from dictionary argument/header file
if obs_parameters != '':
frequency = obs_parameters['frequency']
bandwidth = obs_parameters['bandwidth']
channels = obs_parameters['channels']
t_sample = obs_parameters['t_sample']
loc = obs_parameters['loc']
ra_dec = obs_parameters['ra_dec']
az_alt = obs_parameters['az_alt']
else:
header_file = '.'.join(obs_file.split('.')[:-1])+'.header'
warnings.warn('No observation parameters passed. Attempting to load from header file ('+header_file+')...')
with open(header_file, 'r') as f:
headers = [parameter.rstrip('\n') for parameter in f.readlines()]
for i in range(len(headers)):
if 'mjd' in headers[i]:
mjd = float(headers[i].strip().split('=')[1])
elif 'frequency' in headers[i]:
frequency = float(headers[i].strip().split('=')[1])
elif 'bandwidth' in headers[i]:
bandwidth = float(headers[i].strip().split('=')[1])
elif 'channels' in headers[i]:
channels = int(headers[i].strip().split('=')[1])
elif 't_sample' in headers[i]:
t_sample = float(headers[i].strip().split('=')[1])
elif 'loc' in headers[i]:
loc = tuple(map(float, headers[i].strip().split('=')[1].split(' ')))
elif 'ra_dec' in headers[i]:
ra_dec = tuple(map(str, headers[i].split('=')[1].split(' ')))
elif 'az_alt' in headers[i]:
az_alt = tuple(map(float, headers[i].split('=')[1].split(' ')))
# Transform frequency axis limits to MHz
xlim = [x / 1e6 for x in xlim]
# Transform to VLSR
if vlsr:
from astropy import units as u
from astropy.coordinates import SpectralCoord, EarthLocation, SkyCoord
from astropy.time import Time
obs_location = EarthLocation.from_geodetic(loc[0], loc[1], loc[2])
obs_time = obs_location.get_itrs(obstime=Time(str(mjd), format='mjd', scale='utc'))
if az_alt!='':
obs_coord = SkyCoord(az=az_alt[0]*u.degree, alt=az_alt[1]*u.degree, frame='altaz', location=obs_location, obstime=Time(str(mjd), format='mjd', scale='utc'))
obs_coord = obs_coord.icrs
print (obs_coord)
else:
obs_coord = SkyCoord(ra=ra_dec[0]*u.degree, dec=ra_dec[1]*u.degree, frame='icrs')
#Transform center frequency
frequency = SpectralCoord(frequency * u.MHz, observer=obs_time, target=obs_coord)
frequency = frequency.with_observer_stationary_relative_to('lsrk')
frequency = frequency.quantity.value
# Define Radial Velocity axis limits
left_velocity_edge = -299792.458*(bandwidth-2*frequency+2*f_rest)/(bandwidth-2*frequency)
right_velocity_edge = 299792.458*(-bandwidth-2*frequency+2*f_rest)/(bandwidth+2*frequency)
# Transform sampling time to number of bins
bins = int(t_sample*bandwidth/channels)
# Load observation & calibration data
offset = 1
waterfall = offset*np.fromfile(obs_file, dtype='float32').reshape(-1, channels)/bins
# Delete first 3 rows (potentially containing outlier samples)
waterfall = waterfall[3:, :]
# Mask RFI-contaminated channels
if rfi != []:
for j in range(len(rfi)):
# Frequency to channel transformation
current_rfi = rfi[j]
rfi_lo = channels*(current_rfi[0] - (frequency - bandwidth/2))/bandwidth
rfi_hi = channels*(current_rfi[1] - (frequency - bandwidth/2))/bandwidth
# Blank channels
for i in range(int(rfi_lo), int(rfi_hi)):
waterfall[:, i] = np.nan
if cal_file != '':
waterfall_cal = offset*np.fromfile(cal_file, dtype='float32').reshape(-1, channels)/bins
# Delete first 3 rows (potentially containing outlier samples)
waterfall_cal = waterfall_cal[3:, :]
# Mask RFI-contaminated channels
if rfi != []:
for j in range(len(rfi)):
# Frequency to channel transformation
current_rfi = rfi[j]
rfi_lo = channels*(current_rfi[0] - (frequency - bandwidth/2))/bandwidth
rfi_hi = channels*(current_rfi[1] - (frequency - bandwidth/2))/bandwidth
# Blank channels
for i in range(int(rfi_lo), int(rfi_hi)):
waterfall_cal[:, i] = np.nan
# Compute average spectra
with warnings.catch_warnings():
warnings.filterwarnings(action='ignore', message='Mean of empty slice')
avg_spectrum = decibel(np.nanmean(waterfall, axis=0))
if cal_file != '':
avg_spectrum_cal = decibel(np.nanmean(waterfall_cal, axis=0))
# Number of sub-integrations
subs = waterfall.shape[0]
# Compute Time axis
t = t_sample*np.arange(subs)
# Compute Frequency axis; convert Hz to MHz
frequency = np.linspace(frequency-0.5*bandwidth, frequency+0.5*bandwidth,
channels, endpoint=False)*1e-6
# Perform de-dispersion
if dm != 0:
deltaF = float(np.max(frequency)-np.min(frequency))/subs
f_start = np.min(frequency)
for t_bin in range(subs):
f_chan = f_start+t_bin*deltaF
deltaT = 4149*dm*((1/(f_chan**2))-(1/(np.max(frequency)**2)))
n = int((float(deltaT)/(float(1)/channels)))
shift(t_bin, n)
# Define array for Time Series plot
power = decibel(np.nanmean(waterfall, axis=1))
# Apply Mask
mask = np.zeros_like(avg_spectrum)
mask[np.logical_and(frequency > f_rest*1e-6-0.2, frequency < f_rest*1e-6+0.8)] = 1 # Margins OK for galactic HI
# Define text offset for axvline text label
text_offset = 0
# Calibrate Spectrum
if cal_file != '':
if dB:
spectrum = 10**((avg_spectrum-avg_spectrum_cal)/10)
else:
spectrum = avg_spectrum/avg_spectrum_cal
spectrum = SNR(spectrum, mask)
if slope_correction:
idx = np.isfinite(frequency) & np.isfinite(spectrum)
fit = np.polyfit(frequency[idx], spectrum[idx], 1)
ang_coeff = fit[0]
intercept = fit[1]
fit_eq = ang_coeff*frequency + intercept
spectrum = SNR(spectrum-fit_eq, mask)
# Mitigate RFI (Frequency Domain)
if n != 0:
spectrum_clean = SNR(spectrum.copy(), mask)
for i in range(0, int(channels)):
spectrum_clean[i] = np.nanmedian(spectrum_clean[i:i+n])
# Apply position offset for Spectral Line label
text_offset = 60
# Mitigate RFI (Time Domain)
if m != 0:
power_clean = power.copy()
for i in range(0, int(subs)):
power_clean[i] = np.nanmedian(power_clean[i:i+m])
# Write Waterfall to file (FITS)
if waterfall_fits != '':
from astropy.io import fits
# Load data
hdu = fits.PrimaryHDU(waterfall)
# Prepare FITS headers
hdu.header['NAXIS'] = 2
hdu.header['NAXIS1'] = channels
hdu.header['NAXIS2'] = subs
hdu.header['CRPIX1'] = channels/2
hdu.header['CRPIX2'] = subs/2
hdu.header['CRVAL1'] = frequency[int(channels/2)]
hdu.header['CRVAL2'] = t[int(subs/2)]
hdu.header['CDELT1'] = bandwidth*1e-6/channels
hdu.header['CDELT2'] = t_sample
hdu.header['CTYPE1'] = 'Frequency (MHz)'
hdu.header['CTYPE2'] = 'Relative Time (s)'
try:
hdu.header['MJD-OBS'] = mjd
except NameError:
warnings.warn('Observation MJD could not be found and will not be part of the FITS header.')
pass
# Delete pre-existing FITS file
try:
os.remove(waterfall_fits)
except OSError:
pass
# Write to file
hdu.writeto(waterfall_fits)
# Write Spectra to file (csv)
if spectra_csv != '':
if cal_file != '':
np.savetxt(spectra_csv, np.concatenate((frequency.reshape(channels, 1),
avg_spectrum.reshape(channels, 1), avg_spectrum_cal.reshape(channels, 1),
spectrum.reshape(channels, 1)), axis=1), delimiter=',', fmt='%1.6f')
else:
np.savetxt(spectra_csv, np.concatenate((frequency.reshape(channels, 1),
avg_spectrum.reshape(channels, 1)), axis=1), delimiter=',', fmt='%1.6f')
# Write Time Series to file (csv)
if power_csv != '':
np.savetxt(power_csv, np.concatenate((t.reshape(subs, 1), power.reshape(subs, 1)),
axis=1), delimiter=',', fmt='%1.6f')
# Initialize plot
if cal_file != '':
fig = plt.figure(figsize=(27, 15))
gs = GridSpec(2, 3)
else:
fig = plt.figure(figsize=(21, 15))
gs = GridSpec(2, 2)
if meta:
from astropy.coordinates import get_constellation
epoch = (mjd - 40587) * 86400.0
meta_title = 'Date and Time: ' + time.strftime('%Y-%m-%d %H:%M:%S %Z', time.localtime(epoch)) + ' '
meta_title += 'Target: ' + obs_coord.to_string('hmsdms', precision=0) + ' in ' + get_constellation(obs_coord) + '\n'
plt.suptitle(meta_title, fontsize=18)
# Plot Average Spectrum
ax1 = fig.add_subplot(gs[0, 0])
ax1.plot(frequency, avg_spectrum)
if xlim == [0,0]:
ax1.set_xlim(np.min(frequency), np.max(frequency))
else:
ax1.set_xlim(xlim[0], xlim[1])
ax1.ticklabel_format(useOffset=False)
ax1.set_xlabel('Frequency (MHz)')
if avg_ylim != [0,0]:
ax1.set_ylim(avg_ylim[0], avg_ylim[1])
if dB:
ax1.set_ylabel('Relative Power (dB)')
else:
ax1.set_ylabel('Relative Power')
if vlsr:
cal_title = r'$Average\ Spectrum\ (V_{LSR})$'
else:
cal_title = 'Average Spectrum'
if f_rest != 0:
cal_title += '\n'
ax1.set_title(cal_title)
ax1.grid()
if xlim == [0,0] and f_rest != 0:
# Add secondary axis for Radial Velocity
ax1_secondary = ax1.twiny()
ax1_secondary.set_xlabel('Radial Velocity (km/s)', labelpad=5)
ax1_secondary.axvline(x=0, color='brown', linestyle='--', linewidth=2, zorder=0)
ax1_secondary.annotate('Spectral Line\nRest Frequency', xy=(460-text_offset, 5),
xycoords='axes points', size=14, ha='left', va='bottom', color='brown')
ax1_secondary.set_xlim(left_velocity_edge, right_velocity_edge)
ax1_secondary.tick_params(axis='x', direction='in', pad=-22)
#Plot Calibrated Spectrum
if cal_file != '':
ax2 = fig.add_subplot(gs[0, 1])
ax2.plot(frequency, spectrum, label='Raw Spectrum')
if n != 0:
ax2.plot(frequency, spectrum_clean, color='orangered', label='Median (n = '+str(n)+')')
if cal_ylim !=[0,0]:
ax2.set_ylim(cal_ylim[0],cal_ylim[1])
else:
ax2.set_ylim()
if xlim == [0,0]:
ax2.set_xlim(np.min(frequency), np.max(frequency))
else:
ax2.set_xlim(xlim[0], xlim[1])
ax2.ticklabel_format(useOffset=False)
ax2.set_xlabel('Frequency (MHz)')
ax2.set_ylabel('Signal-to-Noise Ratio (S/N)')
if vlsr:
cal_title = r'$Calibrated\ Spectrum\ (V_{LSR})$' + '\n'
else:
cal_title = 'Calibrated Spectrum\n'
if f_rest != 0:
ax2.set_title(cal_title)
else:
ax2.set_title('Calibrated Spectrum')
if n != 0:
if f_rest != 0:
ax2.legend(bbox_to_anchor=(0.002, 0.96), loc='upper left')
else:
ax2.legend(loc='upper left')
if xlim == [0,0] and f_rest != 0:
# Add secondary axis for Radial Velocity
ax2_secondary = ax2.twiny()
ax2_secondary.set_xlabel('Radial Velocity (km/s)', labelpad=5)
ax2_secondary.axvline(x=0, color='brown', linestyle='--', linewidth=2, zorder=0)
ax2_secondary.annotate('Spectral Line\nRest Frequency', xy=(400, 5),
xycoords='axes points', size=14, ha='left', va='bottom', color='brown')
ax2_secondary.set_xlim(left_velocity_edge, right_velocity_edge)
ax2_secondary.tick_params(axis='x', direction='in', pad=-22)
ax2.grid()
# Plot Dynamic Spectrum
if cal_file != '':
ax3 = fig.add_subplot(gs[0, 2])
else:
ax3 = fig.add_subplot(gs[0, 1])
ax3.imshow(decibel(waterfall), origin='lower', interpolation='None', aspect='auto',
extent=[np.min(frequency), np.max(frequency), np.min(t), np.max(t)])
if xlim == [0,0] and ylim != [0,0]:
ax3.set_ylim(ylim[0], ylim[1])
elif xlim != [0,0] and ylim == [0,0]:
ax3.set_xlim(xlim[0], xlim[1])
elif xlim != [0,0] and ylim != [0,0]:
ax3.set_xlim(xlim[0], xlim[1])
ax3.set_ylim(ylim[0], ylim[1])
ax3.ticklabel_format(useOffset=False)
ax3.set_xlabel('Frequency (MHz)')
ax3.set_ylabel('Relative Time (s)')
ax3.set_title('Dynamic Spectrum (Waterfall)')
# Adjust Subplot Width Ratio
if cal_file != '':
gs = GridSpec(2, 3, width_ratios=[16.5, 1, 1])
else:
gs = GridSpec(2, 2, width_ratios=[7.6, 1])
# Plot Time Series (Power vs Time)
ax4 = fig.add_subplot(gs[1, 0])
ax4.plot(t, power, label='Raw Time Series')
if m != 0:
ax4.plot(t, power_clean, color='orangered', label='Median (n = '+str(m)+')')
ax4.set_ylim()
if ylim == [0,0]:
ax4.set_xlim(0, np.max(t))
else:
ax4.set_xlim(ylim[0], ylim[1])
ax4.set_xlabel('Relative Time (s)')
if dB:
ax4.set_ylabel('Relative Power (dB)')
else:
ax4.set_ylabel('Relative Power')
ax4.set_title('Average Power vs Time')
if m != 0:
ax4.legend(bbox_to_anchor=(1, 1), loc='upper right')
ax4.grid()
# Plot Total Power Distribution
if cal_file != '':
gs = GridSpec(2, 3, width_ratios=[7.83, 1.5, -0.325])
else:
gs = GridSpec(2, 2, width_ratios=[8.8, 1.5])
ax5 = fig.add_subplot(gs[1, 1])
ax5.hist(power, np.max([int(np.size(power)/50),10]), density=1, alpha=0.5, color='royalblue', orientation='horizontal', zorder=10)
ax5.plot(best_fit(power)[1], best_fit(power)[0], '--', color='blue', label='Best fit (Raw)', zorder=20)
if m != 0:
ax5.hist(power_clean, np.max([int(np.size(power_clean)/50),10]), density=1, alpha=0.5, color='orangered', orientation='horizontal', zorder=10)
ax5.plot(best_fit(power_clean)[1], best_fit(power_clean)[0], '--', color='red', label='Best fit (Median)', zorder=20)
ax5.set_xlim()
ax5.set_ylim()
ax5.get_shared_x_axes().join(ax5, ax4)
ax5.set_yticklabels([])
ax5.set_xlabel('Probability Density')
ax5.set_title('Total Power Distribution')
ax5.legend(bbox_to_anchor=(1, 1), loc='upper right')
ax5.grid()
# Save plots to file
plt.tight_layout()
plt.savefig(plot_file)
plt.clf()
def aia_test_arc(aia171_test_map):
start = SkyCoord(735 * u.arcsec, -471 * u.arcsec, frame=aia171_test_map.coordinate_frame)
end = SkyCoord(-100 * u.arcsec, 800 * u.arcsec, frame=aia171_test_map.coordinate_frame)
return GreatArc(start, end)
imageDir = Dir + 'casa5.4/'
picDir = Dir + 'picture/'
regionDir = Dir + 'region/'
mom0file = imageDir + 'NGC5257_12CO21_combine_pbcor_mom0.fits'
mom1file = imageDir + 'NGC5257_12CO21_pbcor_cube_mom1.fits'
mom2file = imageDir + 'NGC5257_12CO21_pbcor_cube_mom2.fits'
############################################################
# basic information
galaxy = 'NGC5257'
line = '12CO21'
position = SkyCoord(dec=50.4167 * u.arcmin,
ra=204.9706 * u.degree,
frame='icrs')
beamra = 204 * u.degree + 58 * u.arcmin + 30 * u.arcsec
beamdec = 50 * u.arcmin + 3 * u.arcsec
beamposition = SkyCoord(dec=beamdec, ra=beamra, frame='icrs')
beammajor = 1.008 * u.arcsec / 2.0
beamminor = 0.513 * u.arcsec / 2.0
pa = -64.574 * u.degree
############################################################
# basic settings
testra = 204.97609228
testdec = 0.84611111
def gcrs_to_altaz(ra, dec):
altaz_frame = update_altaz()
gcrs_frame = update_GCRS()
pos_gcrs = SkyCoord(ra=ra * u.degree, dec=dec * u.degree, frame=gcrs_frame)
pos_altaz = pos_gcrs.transform_to(altaz_frame)
return (pos_altaz.az.degree, pos_altaz.alt.degree)
def get_gaia_data_for_toi(toi_num, use_cache=True, **kwargs):
info = get_info_for_toi(toi_num, use_cache=use_cache).iloc[0]
coord = SkyCoord(ra=info["RA"], dec=info["Dec"], unit=(u.hourangle, u.deg))
return get_gaia_data(coord, approx_mag=float(info["TESS Mag"]), **kwargs)
def get_gaia_data_for_tic(tic, **kwargs):
info = get_info_for_tic(tic)
coord = SkyCoord(
ra=float(info["ra"]) * u.deg, dec=float(info["dec"]) * u.deg
)
return get_gaia_data(coord, approx_mag=float(info["GAIAmag"]), **kwargs)
assert output
def test_mast_service_request(patch_post):
service = 'Mast.Caom.Cone'
params = {'ra': 23.34086, 'dec': 60.658, 'radius': 0.2}
result = mast.Mast.service_request(service, params)
assert isinstance(result, Table)
###########################
# ObservationsClass tests #
###########################
regionCoords = SkyCoord(23.34086, 60.658, unit=('deg', 'deg'))
# query functions
def test_observations_query_region_async(patch_post):
responses = mast.Observations.query_region_async(regionCoords, radius=0.2)
assert isinstance(responses, list)
def test_observations_query_region(patch_post):
result = mast.Observations.query_region(regionCoords, radius=0.2 * u.deg)
assert isinstance(result, Table)
def test_observations_query_object_async(patch_post):
def skycoord(self):
return SkyCoord(ra=self.ra, dec=self.dec, unit='deg')
def s1c_sp_calibration(fit_path,
masterdark_fname,
masterflat_fname,
solve_pars_fname,
save_fname=None,
area_rad=4,
med_size=31,
lat_deg=56.1501667,
lon_deg=46.1050833,
hei_m=183.):
if save_fname == None:
save_fname = solve_pars_fname.split('/')[-1][0:-11] + '.spcal'
hdulist = fits.open(masterdark_fname, ignore_missing_end=True)
masterdark = hdulist[0].data
hdulist.close()
hdulist = fits.open(masterflat_fname, ignore_missing_end=True)
masterflat = hdulist[0].data
hdulist.close()
err, az0, alt0, a, b, c, d = get_solve_pars(solve_pars_fname)
M_s1c = get_scale_and_orientation_info(c, d)
spath = "./.temp/"
if not os.path.exists(spath):
os.makedirs(spath)
fit_filenames = [fit_path + '/' + fn for fn in next(os.walk(fit_path))[2]]
R_median = np.zeros(len(fit_filenames))
R_std = np.zeros(len(fit_filenames))
fig = plt.figure(figsize=(12.8, 7.2))
fig.set_size_inches(12.8, 7.2)
# ax=plt.axes(position=[0.035000000000000003+dx/2, 0.061764705882352888, 0.50624999999999998, 0.89999999999999991])
ax = plt.axes(position=[
0.035000000000000003 + dx / 2, 0.26, 0.50624999999999998, 0.7
])
plt.axis('off')
ax1 = plt.axes(position=[
0.58205882352941185 + dx, 0.71052941176470596 - 0.15, 0.35, 0.4
])
plt.grid()
ax2 = plt.axes(
position=[0.58205882352941185 + dx, 0.061764705882352888, 0.35, 0.4])
plt.grid()
ax3 = plt.axes(
position=[0.035000000000000003 + dx / 2, 0.04, 0.5 / 4, 0.7 / 4])
plt.grid(b=True)
ax4 = plt.axes(position=[
0.035000000000000003 + dx / 2 + 0.19, 0.04, 0.5 / 4, 0.7 / 4
])
plt.grid(b=True)
ax5 = plt.axes(position=[
0.035000000000000003 + dx / 2 + 0.38, 0.04, 0.5 / 4, 0.7 / 4
])
plt.grid(b=True)
R_day = 0
vrange = 1000
vshift = 2000
alt_min = 83 * np.pi / 180
# area_rad=3
# med_size=31
XX, YY = np.meshgrid(range(2 * area_rad + 1), range(2 * area_rad + 1))
fid = open(save_fname, 'w')
fid.write(
"# Camera calibration coefficients [Rayleighs per ADC unit] for each fit file:\n"
)
for i in range(len(fit_filenames)):
# for i in range(5):
# for i in range(58,59):
sys.stdout.write('\r')
sys.stdout.write("Processing frame " + str(i + 1) + "/" +
str(len(fit_filenames)))
sys.stdout.flush()
fit_fname = fit_filenames[i]
hdulist = fits.open(fit_fname, ignore_missing_end=True)
img = hdulist[0].data.astype('float')
img0 = np.copy(img)
img = (img - masterdark.astype('float')) / masterflat.astype('float')
img_medfilt = img - ss.medfilt(img, kernel_size=med_size)
# np.save('img.npy',img)
hdulist.close()
med_img = np.median(img)
max_img0 = np.max(img0)
# print(max_img0)
s1c_site = EarthLocation(lat=lat_deg * u.deg,
lon=lon_deg * u.deg,
height=hei_m * u.m)
date_obs = s1c_get_date_obs(fit_fname, ut_shift=-4)
png_prefix = spath + "frame_s1c_" + str(
date_obs.year)[2::] + "{0:0>2}".format(
date_obs.month) + "{0:0>2}".format(date_obs.day) + "_"
BS_coord = SkyCoord(RA, DEC, frame='icrs', unit='rad')
altaz = BS_coord.transform_to(
AltAz(obstime=date_obs,
location=s1c_site,
temperature=20 * u.deg_C,
pressure=1013 * u.hPa,
relative_humidity=0.5,
obswl=630.0 * u.nm))
AZ = altaz.az.rad
ALT = altaz.alt.rad
X, Y = tan_hor2pix(AZ, ALT, az0, alt0, c, d)
# Catalog filtration
filt_mask = np.zeros(len(NUM), dtype=bool)
for j in range(len(NUM)):
if ALT[j] >= alt_min and X[j] >= 10 and Y[j] >= 10 and X[
j] <= img.shape[1] - 10 and Y[j] <= img.shape[0] - 10:
filt_mask[j] = True
NUM_filt = NUM[filt_mask]
BS_ID_filt = BS_ID[filt_mask]
RA_filt = RA[filt_mask]
DEC_filt = DEC[filt_mask]
MAG_filt = MAG[filt_mask]
FLUX_filt = FLUX[filt_mask]
SP_type_filt = [
SP_type[j] for j in range(len(SP_type)) if filt_mask[j] == True
]
ALT_filt = ALT[filt_mask]
AZ_filt = AZ[filt_mask]
X_filt = X[filt_mask]
Y_filt = Y[filt_mask]
star_pixels = np.zeros(len(NUM_filt), dtype=int)
star_adc = np.zeros(len(NUM_filt))
AREA = np.zeros((2 * area_rad + 1, 2 * area_rad + 1, len(NUM_filt)))
AREA0 = np.zeros((2 * area_rad + 1, 2 * area_rad + 1, len(NUM_filt)))
for j in range(len(NUM_filt)):
sum_temp = 0
num = 0
AREA[:, :, j] = np.copy(
img_medfilt[int(Y_filt[j]) - area_rad:int(Y_filt[j]) +
area_rad + 1,
int(X_filt[j]) - area_rad:int(X_filt[j]) +
area_rad + 1])
AREA0[:, :, j] = np.copy(
img0[int(Y_filt[j]) - area_rad:int(Y_filt[j]) + area_rad + 1,
int(X_filt[j]) - area_rad:int(X_filt[j]) + area_rad + 1])
arg_max = np.argmax(AREA[:, :, j])
# print("max=", np.max(AREA[:,:,j]))
x0 = XX.flat[arg_max]
y0 = YY.flat[arg_max]
AREA[:, :,
j] = np.copy(img_medfilt[int(Y_filt[j]) - area_rad + y0 -
area_rad:int(Y_filt[j]) + y0 + 1,
int(X_filt[j]) - area_rad + x0 -
area_rad:int(X_filt[j]) + x0 + 1])
AREA0[:, :, j] = np.copy(img0[int(Y_filt[j]) - area_rad + y0 -
area_rad:int(Y_filt[j]) + y0 + 1,
int(X_filt[j]) - area_rad + x0 -
area_rad:int(X_filt[j]) + x0 + 1])
Rast = np.sqrt((XX - area_rad)**2 + (YY - area_rad)**2)
# print(Rast)
area = np.copy(AREA[:, :, j])
for k in range((2 * area_rad + 1)**2):
if Rast.flat[k] <= area_rad:
num += 1
sum_temp += AREA[:, :, j].flat[k]
star_pixels[j] = num
star_adc[j] = sum_temp
# print(star_pixels[j],star_adc[j])
# print(AREA[:,:,j])
# print(" ")
# Catalog filtration 2
filt_mask = np.zeros(len(NUM_filt), dtype=bool)
for j in range(len(NUM_filt)):
if np.max(AREA0[:, :, j]) < 0.9 * max_img0:
filt_mask[j] = True
AREA_filt2 = np.copy(AREA[:, :, filt_mask])
AREA0_filt2 = np.copy(AREA0[:, :, filt_mask])
NUM_filt2 = NUM_filt[filt_mask]
BS_ID_filt2 = BS_ID_filt[filt_mask]
RA_filt2 = RA_filt[filt_mask]
DEC_filt2 = DEC_filt[filt_mask]
MAG_filt2 = MAG_filt[filt_mask]
FLUX_filt2 = FLUX_filt[filt_mask]
SP_type_filt2 = [
SP_type_filt[j] for j in range(len(SP_type_filt))
if filt_mask[j] == True
]
X_filt2 = X_filt[filt_mask]
Y_filt2 = Y_filt[filt_mask]
ALT_filt2 = ALT_filt[filt_mask]
AZ_filt2 = AZ_filt[filt_mask]
star_pixels_filt2 = star_pixels[filt_mask]
star_adc_filt2 = star_adc[filt_mask]
R = np.zeros(len(NUM_filt2))
for j in range(len(NUM_filt2)):
sol_angle = tan_get_pixel_solid_angle(M_s1c,
np.pi / 2 - ALT_filt2[j])
br = get_brightness_in_Rayleighs(100, sol_angle, 1, FLUX_filt2[j])
sa = star_adc_filt2[j]
R[j] = br / sa
# print('br[R]=', br, "; sa[ADC.u]=",sa,"; R=",R[j])
x_bord = np.arange(2 * area_rad + 1, dtype=float)
y1_bord = np.sqrt(area_rad**2 -
(x_bord - area_rad)**2) + area_rad + 0.5
y2_bord = -np.sqrt(area_rad**2 -
(x_bord - area_rad)**2) + area_rad + 0.5
if len(NUM_filt2) > 0:
sort_ord = np.argsort(star_pixels_filt2)
plt.sca(ax3)
idd = 0
area1 = AREA_filt2[:, :, sort_ord[idd]]
area1_max = np.max(AREA0_filt2[:, :, sort_ord[idd]])
area1_id = BS_ID_filt2[sort_ord[idd]]
plt.pcolormesh(area1, cmap="seismic", vmin=-1000, vmax=1000)
plt.plot(x_bord + 0.5, y1_bord, 'k-', lw=2)
plt.plot(x_bord + 0.5, y2_bord, 'k-', lw=2)
plt.ylim(area_rad * 2 + 1, 0)
plt.xlim(0, area_rad * 2 + 1)
plt.title(str(area1_id), loc='left', fontsize='smaller')
plt.title(str(int(star_adc_filt2[sort_ord[idd]])),
loc='right',
fontsize='smaller')
plt.title(str(int(R[sort_ord[idd]] * 1000) / 1000),
fontsize='smaller')
plt.ylabel(
str(int(R[sort_ord[idd]] * star_adc_filt2[sort_ord[idd]])))
if len(NUM_filt2) > 1:
plt.sca(ax4)
idd = 1
area2 = AREA_filt2[:, :, sort_ord[idd]]
area2_max = np.max(AREA0_filt2[:, :, sort_ord[idd]])
area2_id = BS_ID_filt2[sort_ord[idd]]
plt.pcolormesh(area2, cmap="seismic", vmin=-1000, vmax=1000)
plt.plot(x_bord + 0.5, y1_bord, 'k-', lw=2)
plt.plot(x_bord + 0.5, y2_bord, 'k-', lw=2)
plt.ylim(area_rad * 2 + 1, 0)
plt.xlim(0, area_rad * 2 + 1)
plt.title(str(area2_id), loc='left', fontsize='smaller')
plt.title(str(int(star_adc_filt2[sort_ord[idd]])),
loc='right',
fontsize='smaller')
plt.title(str(int(R[sort_ord[idd]] * 1000) / 1000),
fontsize='smaller')
plt.ylabel(
str(int(R[sort_ord[idd]] * star_adc_filt2[sort_ord[idd]])))
if len(NUM_filt2) > 2:
plt.sca(ax5)
idd = 2
area3 = AREA_filt2[:, :, sort_ord[idd]]
area3_max = np.max(AREA0_filt2[:, :, sort_ord[idd]])
area3_id = BS_ID_filt2[sort_ord[idd]]
plt.pcolormesh(area3, cmap="seismic", vmin=-1000, vmax=1000)
plt.plot(x_bord + 0.5, y1_bord, 'k-', lw=2)
plt.plot(x_bord + 0.5, y2_bord, 'k-', lw=2)
plt.ylim(area_rad * 2 + 1, 0)
plt.xlim(0, area_rad * 2 + 1)
plt.title(str(area3_id), loc='left', fontsize='smaller')
plt.title(str(int(star_adc_filt2[sort_ord[idd]])),
loc='right',
fontsize='smaller')
plt.title(str(int(R[sort_ord[idd]] * 1000) / 1000),
fontsize='smaller')
plt.ylabel(
str(int(R[sort_ord[idd]] * star_adc_filt2[sort_ord[idd]])))
# print(len(R),R)
if len(R) > 0:
R_median[i] = np.median(R)
temp = (R - R_median[i])**2
R_std[i] = np.sqrt(np.median(temp))
# print(R_median[i])
plt.sca(ax1)
plt.plot([0, 50000], [R_median[i], R_median[i]], c='r', lw=2)
plt.scatter(R * star_adc_filt2,
R,
s=np.pi * (star_adc_filt2 / 12000 * 7)**2)
# print(R[0]*star_adc_filt2[0])
# print(R[0]*star_adc_filt2[0]*star_pixels_filt2[0])
for j in range(len(X_filt2)):
plt.text(R[j] * star_adc_filt2[j], R[j],
str(BS_ID_filt2[j]) + "_" + str(star_pixels_filt2[j]))
plt.ylabel('Calibration coef. [R/ADCu]')
plt.xlabel('Star summ brightness [R]')
plt.title(date_obs, loc='left')
plt.title(R_median[i], loc='right')
ax1.set_xlim((0, 30000))
ax1.set_ylim((0, 5))
plt.grid(b=True)
plt.sca(ax2)
plt.xlim([0, len(fit_filenames) - 1])
plt.ylim([0, 5])
plt.plot(i, R_median[i], "r.")
plt.grid(b=True)
plt.ylabel('Calibration coef. [R/ADCu]')
plt.xlabel('frame number')
if i == len(fit_filenames) - 1:
R_day = np.median(R_median[np.where(R_median > 0)])
plt.plot([0, 5000], [R_day, R_day], c='b', lw=2)
plt.title(R_day, loc='right')
plt.sca(ax)
plt.pcolormesh(img,
cmap="gray",
vmin=np.median(img) - 100,
vmax=np.median(img) + 100)
plt.axis('equal')
plt.plot(X, Y, marker="o", lw=0., mew=mew, mec="b", mfc='none', ms=ms)
plt.plot(X_filt,
Y_filt,
marker="o",
lw=0.,
mew=mew,
mec="g",
mfc='none',
ms=ms)
plt.plot(X_filt2,
Y_filt2,
marker="o",
lw=0.,
mew=mew,
mec="r",
mfc='none',
ms=ms)
for j in range(len(X_filt2)):
plt.text(X_filt2[j],
Y_filt2[j],
str(BS_ID_filt2[j]) + "_" + "{0:4.2f}".format(R[j]),
color='w')
ax.set_xlim((1, 372))
ax.set_ylim((281, 1))
plt.title(
fit_fname.split('/')[-1] + " " + "{0:0>2}".format(date_obs.hour) +
":" + "{0:0>2}".format(date_obs.minute) + ":" +
"{0:0>2}".format(date_obs.second))
# plt.show()
plt.axis('off')
png_fname = png_prefix + "{0:0>4}".format(i + 1) + ".png"
# print(png_fname)
plt.savefig(png_fname)
ax.clear()
ax1.clear()
ax3.clear()
ax4.clear()
ax5.clear()
fid.write(
fit_fname.split('/')[-1] + " " + str(R_median[i]) + " " +
str(R_std[i]) + "\n")
plt.close()
sys.stdout.write('\n')
sys.stdout.flush()
fid.close()
return png_prefix, len(fit_filenames), R_median, R_std
def test_get_new_observer(aia171_test_map):
initial_obstime = aia171_test_map.date
rotation_interval = 2 * u.day
new_time = initial_obstime + rotation_interval
time_delta = new_time - initial_obstime
observer = get_earth(initial_obstime + rotation_interval)
# The observer time is set along with other definitions of time
for time in (rotation_interval, new_time, time_delta):
with pytest.raises(ValueError):
new_observer = _get_new_observer(initial_obstime, observer, time)
# Obstime property is present but the value is None
observer_obstime_is_none = SkyCoord(12 * u.deg,
46 * u.deg,
frame=frames.HeliographicStonyhurst)
with pytest.raises(ValueError):
new_observer = _get_new_observer(None, observer_obstime_is_none, None)
# When the observer is set, it gets passed back out
new_observer = _get_new_observer(initial_obstime, observer, None)
assert isinstance(new_observer, SkyCoord)
np.testing.assert_almost_equal(new_observer.transform_to(
frames.HeliographicStonyhurst).lon.to(u.deg).value,
observer.transform_to(
frames.HeliographicStonyhurst).lon.to(
u.deg).value,
decimal=3)
np.testing.assert_almost_equal(new_observer.transform_to(
frames.HeliographicStonyhurst).lat.to(u.deg).value,
observer.transform_to(
frames.HeliographicStonyhurst).lat.to(
u.deg).value,
decimal=3)
np.testing.assert_almost_equal(
new_observer.transform_to(frames.HeliographicStonyhurst).radius.to(
u.au).value,
observer.transform_to(frames.HeliographicStonyhurst).radius.to(
u.au).value,
decimal=3)
# When the time is set, a coordinate for Earth comes back out
for time in (rotation_interval, new_time, time_delta):
with pytest.warns(
UserWarning,
match="Using 'time' assumes an Earth-based observer"):
new_observer = _get_new_observer(initial_obstime, None, time)
assert isinstance(new_observer, SkyCoord)
np.testing.assert_almost_equal(
new_observer.transform_to(frames.HeliographicStonyhurst).lon.to(
u.deg).value,
observer.transform_to(frames.HeliographicStonyhurst).lon.to(
u.deg).value,
decimal=3)
np.testing.assert_almost_equal(
new_observer.transform_to(frames.HeliographicStonyhurst).lat.to(
u.deg).value,
observer.transform_to(frames.HeliographicStonyhurst).lat.to(
u.deg).value,
decimal=3)
np.testing.assert_almost_equal(
new_observer.transform_to(frames.HeliographicStonyhurst).radius.to(
u.au).value,
observer.transform_to(frames.HeliographicStonyhurst).radius.to(
u.au).value,
decimal=3)
# The observer and the time cannot both be None
with pytest.raises(ValueError):
new_observer = _get_new_observer(initial_obstime, None, None)
def test_reconstruction():
"""
a test of the complete fit procedure on one event including:
• tailcut cleaning
• hillas parametrisation
• direction fit
• position fit
in the end, proper units in the output are asserted """
filename = get_dataset_path("gamma_test_large.simtel.gz")
fit = HillasIntersection()
source = EventSource(filename, max_events=10)
calib = CameraCalibrator(source.subarray)
horizon_frame = AltAz()
reconstructed_events = 0
for event in source:
calib(event)
mc = event.simulation.shower
array_pointing = SkyCoord(az=mc.az, alt=mc.alt, frame=horizon_frame)
hillas_dict = {}
telescope_pointings = {}
for tel_id, dl1 in event.dl1.tel.items():
geom = source.subarray.tel[tel_id].camera.geometry
telescope_pointings[tel_id] = SkyCoord(
alt=event.pointing.tel[tel_id].altitude,
az=event.pointing.tel[tel_id].azimuth,
frame=horizon_frame,
)
mask = tailcuts_clean(
geom, dl1.image, picture_thresh=10.0, boundary_thresh=5.0
)
try:
moments = hillas_parameters(geom[mask], dl1.image[mask])
hillas_dict[tel_id] = moments
except HillasParameterizationError as e:
print(e)
continue
if len(hillas_dict) < 2:
continue
else:
reconstructed_events += 1
# divergent mode put to on even though the file has parallel pointing.
fit_result = fit.predict(
hillas_dict, source.subarray, array_pointing, telescope_pointings
)
print(fit_result)
print(event.simulation.shower.core_x, event.simulation.shower.core_y)
fit_result.alt.to(u.deg)
fit_result.az.to(u.deg)
fit_result.core_x.to(u.m)
assert fit_result.is_valid
assert reconstructed_events > 0
def gal2cel_angle(glon,glat,angle,offset=1e-7):
from astropy.coordinates import SkyCoord
import astropy.units as u
origin = SkyCoord(glon,glat,unit=u.deg,frame='galactic')
return estimate_angle(angle,origin,'fk5',offset)
def from_row(cls, row, fov=0.0333, layout=None):
coords = SkyCoord(row.RA, row.DEC, unit=(u.hourangle, u.deg))
return cls(coords, row.name, layout=layout)
def cel2gal_angle(ra,dec,angle,offset=1e-7):
from astropy.coordinates import SkyCoord
import astropy.units as u
origin = SkyCoord(ra,dec,unit=u.deg,frame='fk5')
return estimate_angle(angle,origin,'galactic',offset)
hpc_y = np.arange(-700, 800, 100) * u.arcsec
hpc_x = np.zeros_like(hpc_y)
##############################################################################
# Let's define how many days in the future we want to rotate to.
dt = TimeDelta(4*u.day)
future_date = aia_map.date + dt
##############################################################################
# Now let's plot the original and rotated positions on the AIA map.
fig = plt.figure()
ax = plt.subplot(projection=aia_map)
aia_map.plot(clip_interval=(1, 99.99)*u.percent)
ax.set_title('The effect of {} days of differential rotation'.format(dt.to(u.day).value))
aia_map.draw_grid()
for this_hpc_x, this_hpc_y in zip(hpc_x, hpc_y):
start_coord = SkyCoord(this_hpc_x, this_hpc_y, frame=aia_map.coordinate_frame)
rotated_coord = solar_rotate_coordinate(start_coord, time=future_date)
coord = SkyCoord([start_coord.Tx, rotated_coord.Tx],
[start_coord.Ty, rotated_coord.Ty],
frame=aia_map.coordinate_frame)
ax.plot_coord(coord, 'o-')
plt.ylim(0, aia_map.data.shape[1])
plt.xlim(0, aia_map.data.shape[0])
plt.show()
def json_to_sdss_dlasurvey(json_file, sdss_survey, add_pf=True, debug=False):
""" Convert JSON output file to a DLASurvey object
Assumes SDSS bookkeeping for sightlines (i.e. PLATE, FIBER)
Parameters
----------
json_file : str
Full path to the JSON results file
sdss_survey : DLASurvey
SDSS survey, usually human (e.g. JXP for DR5)
add_pf : bool, optional
Add plate/fiber to DLAs in sdss_survey
Returns
-------
ml_survey : LLSSurvey
Survey object for the LLS
"""
print("Loading SDSS Survey from JSON file {:s}".format(json_file))
# imports
from pyigm.abssys.dla import DLASystem
from pyigm.abssys.lls import LLSSystem
# Fiber key
for fkey in ['FIBER', 'FIBER_ID', 'FIB']:
if fkey in sdss_survey.sightlines.keys():
break
# Read
ml_results = ltu.loadjson(json_file)
use_platef = False
if 'plate' in ml_results[0].keys():
use_platef = True
else:
if 'id' in ml_results[0].keys():
use_id = True
# Init
#idict = dict(plate=[], fiber=[], classification_confidence=[], # FOR v2
# classification=[], ra=[], dec=[])
idict = dict(ra=[], dec=[])
if use_platef:
for key in ['plate', 'fiber', 'mjd']:
idict[key] = []
ml_tbl = Table()
ml_survey = LLSSurvey()
systems = []
in_ml = np.array([False]*len(sdss_survey.sightlines))
# Loop
for obj in ml_results:
# Sightline
for key in idict.keys():
idict[key].append(obj[key])
# DLAs
#if debug:
# if (obj['plate'] == 1366) & (obj['fiber'] == 614):
# sv_coord = SkyCoord(ra=obj['ra'], dec=obj['dec'], unit='deg')
# print("GOT A MATCH IN RESULTS FILE")
for idla in obj['dlas']:
"""
dla = DLASystem((sdss_survey.sightlines['RA'][mt[0]],
sdss_survey.sightlines['DEC'][mt[0]]),
idla['spectrum']/(1215.6701)-1., None,
idla['column_density'])
"""
if idla['z_dla'] < 1.8:
continue
isys = LLSSystem((obj['ra'],obj['dec']),
idla['z_dla'], None, NHI=idla['column_density'], zem=obj['z_qso'])
isys.confidence = idla['dla_confidence']
if use_platef:
isys.plate = obj['plate']
isys.fiber = obj['fiber']
elif use_id:
plate, fiber = [int(spl) for spl in obj['id'].split('-')]
isys.plate = plate
isys.fiber = fiber
# Save
systems.append(isys)
# Connect to sightlines
ml_coord = SkyCoord(ra=idict['ra'], dec=idict['dec'], unit='deg')
s_coord = SkyCoord(ra=sdss_survey.sightlines['RA'], dec=sdss_survey.sightlines['DEC'], unit='deg')
idx, d2d, d3d = match_coordinates_sky(s_coord, ml_coord, nthneighbor=1)
used = d2d < 1.*u.arcsec
for iidx in np.where(~used)[0]:
print("Sightline RA={:g}, DEC={:g} was not used".format(sdss_survey.sightlines['RA'][iidx],
sdss_survey.sightlines['DEC'][iidx]))
# Add plate/fiber to statistical DLAs
if add_pf:
dla_coord = sdss_survey.coord
idx2, d2d, d3d = match_coordinates_sky(dla_coord, s_coord, nthneighbor=1)
if np.min(d2d.to('arcsec').value) > 1.:
raise ValueError("Bad match to sightlines")
for jj,igd in enumerate(np.where(sdss_survey.mask)[0]):
dla = sdss_survey._abs_sys[igd]
try:
dla.plate = sdss_survey.sightlines['PLATE'][idx2[jj]]
except IndexError:
pdb.set_trace()
dla.fiber = sdss_survey.sightlines[fkey][idx2[jj]]
# Finish
ml_survey._abs_sys = systems
if debug:
ml2_coord = ml_survey.coord
minsep = np.min(sv_coord.separation(ml2_coord))
minsep2 = np.min(sv_coord.separation(s_coord))
tmp = sdss_survey.sightlines[used]
t_coord = SkyCoord(ra=tmp['RA'], dec=tmp['DEC'], unit='deg')
minsep3 = np.min(sv_coord.separation(t_coord))
pdb.set_trace()
ml_survey.sightlines = sdss_survey.sightlines[used]
for key in idict.keys():
ml_tbl[key] = idict[key]
ml_survey.ml_tbl = ml_tbl
# Return
return ml_survey
def compute_barycentric_correction(ras, decs, times, exps, site="SSO",
disable_auto_max_age=False,
overrid_iers=False):
"""Compute the barycentric corrections for a set of stars
In late 2019 issues were encountered accessing online files related to the
International Earth Rotation and Reference Systems Service. This is
required to calculate barycentric corrections for the data. This astopy
issue may prove a useful resource again if the issue reoccurs:
- https://github.com/astropy/astropy/issues/8981
Parameters
----------
ras: string array
Array of right ascensions in string form: "HH:MM:SS.S".
decs: string array
Array of declinations in string form: "DD:MM:SS.S".
times: string/float array
Array of times in MJD format.
site: string
The site name to look up its coordinates.
disable_auto_max_age: boolean, defaults to False
Useful only when IERS server is not working.
Returns
-------
bcors: float array
Array of barycentric corrections in km/s.
"""
# Get the location
loc = EarthLocation.of_site(site)
# Initialise barycentric correction array
bcors = []
if disable_auto_max_age:
#from astropy.utils.iers import IERS_A_URL
IERS_A_URL = 'ftp://cddis.gsfc.nasa.gov/pub/products/iers/finals.all'
#from astropy.utils.iers import conf
#conf.auto_max_age = None
# Override the IERS server if the mirror is down or not up to date
if overrid_iers:
from astropy.utils import iers
from astropy.utils.iers import conf as iers_conf
url = "https://datacenter.iers.org/data/9/finals2000A.all"
iers_conf.iers_auto_url = url
iers_conf.reload()
# Calculate the barycentric correction for every star
for ra, dec, time, exp in zip(tqdm(ras), decs, times, exps):
sc = SkyCoord(ra=ra, dec=dec, unit=(u.hourangle, u.deg))
# Get the *mid-point* of the observeration
time = Time(float(time), format="mjd") + 0.5*float(exp)*u.second
barycorr = sc.radial_velocity_correction(obstime=time, location=loc)
bcors.append(barycorr.to(u.km/u.s).value)
return bcors
def test_tpf_from_images():
"""Basic tests of tpf.from_fits_images()"""
# Not without a wcs...
with pytest.raises(Exception):
KeplerTargetPixelFile.from_fits_images(_create_image_array(),
size=(3, 3),
position=SkyCoord(-234.75,
8.3393,
unit='deg'))
# Make a fake WCS based on astropy.docs...
w = wcs.WCS(naxis=2)
w.wcs.crpix = [-234.75, 8.3393]
w.wcs.cdelt = np.array([-0.066667, 0.066667])
w.wcs.crval = [0, -90]
w.wcs.ctype = ["RA---AIR", "DEC--AIR"]
w.wcs.set_pv([(2, 1, 45.0)])
pixcrd = np.array([[0, 0], [24, 38], [45, 98]], np.float_)
header = w.to_header()
header['CRVAL1P'] = 10
header['CRVAL2P'] = 20
ra, dec = 268.21686048, -73.66991904
# Now this should work.
images = _create_image_array(header=header)
tpf = KeplerTargetPixelFile.from_fits_images(images,
size=(3, 3),
position=SkyCoord(
ra,
dec,
unit=(u.deg, u.deg)))
assert isinstance(tpf, KeplerTargetPixelFile)
with warnings.catch_warnings():
# Some cards are too long -- to be investigated.
warnings.simplefilter("ignore", VerifyWarning)
# Can we write the output to disk?
# `delete=False` is necessary below to enable writing to the file on Windows
# but it means we have to clean up the tmp file ourselves
tmp = tempfile.NamedTemporaryFile(delete=False)
try:
tpf.to_fits(tmp.name)
finally:
tmp.close()
os.remove(tmp.name)
# Can we read in a list of file names or a list of HDUlists?
hdus = []
tmpfile_names = []
for im in images:
tmpfile = tempfile.NamedTemporaryFile(delete=False)
tmpfile_names.append(tmpfile.name)
hdu = fits.HDUList([fits.PrimaryHDU(), im])
hdu.writeto(tmpfile.name)
hdus.append(hdu)
# Should be able to run with a list of file names
tpf_tmpfiles = KeplerTargetPixelFile.from_fits_images(
tmpfile_names,
size=(3, 3),
position=SkyCoord(ra, dec, unit=(u.deg, u.deg)))
# Should be able to run with a list of HDUlists
tpf_hdus = KeplerTargetPixelFile.from_fits_images(
hdus, size=(3, 3), position=SkyCoord(ra, dec, unit=(u.deg, u.deg)))
# Clean up the temporary files we created
for filename in tmpfile_names:
try:
os.remove(filename)
except PermissionError:
pass # This appears to happen on Windows
def save_packets(self):
for packet in self._open_avro():
print(f"working on {packet['objectId']}")
do_process = True
if self.only_pure and not self._is_alert_pure(packet):
do_process = False
if not do_process:
print(f"{self.fname}: not pure. Skipping")
continue
s = Source.query.filter(Source.id == packet["objectId"]).first()
if s:
print("Found: an existing source with id = " +
packet["objectId"])
source_is_varstar = s.varstar in [True]
if not self.clobber and s.origin == f"{os.path.basename(self.fname)}":
print(
f"already added this source with this avro packet {os.path.basename(self.fname)}"
)
continue
# make a dataframe and save the source/phot
dflc = self._make_dataframe(packet)
source_info = {
'id': packet["objectId"],
'ra': packet["candidate"]["ra"],
'dec': packet["candidate"]["dec"],
'ra_dis': packet["candidate"]["ra"],
'dec_dis': packet["candidate"]["dec"],
'dist_nearest_source': packet["candidate"].get("distnr"),
'mag_nearest_source': packet["candidate"].get("magnr"),
'e_mag_nearest_source': packet["candidate"].get("sigmagnr"),
'sgmag1': packet["candidate"].get("sgmag1"),
'srmag1': packet["candidate"].get("srmag1"),
'simag1': packet["candidate"].get("simag1"),
'objectidps1': packet["candidate"].get("objectidps1"),
'sgscore1': packet["candidate"].get("sgscore1"),
'distpsnr1': packet["candidate"].get("distpsnr1"),
'score': packet['candidate']['rb']
}
if s is None:
s = Source(**source_info,
origin=f"{os.path.basename(self.fname)}",
groups=[self.ztfpack.g])
source_is_varstar = False
new_source = True
else:
print("Found an existing source with id = " +
packet["objectId"])
new_source = False
# let's see if we have already
comments = Comment.query.filter(Comment.obj_id == packet["objectId"]) \
.filter(Comment.origin == f"{os.path.basename(self.fname)}")
skip = False
if self.clobber:
if comments.count() > 0:
print("removing preexisting comments from this packet")
comments.delete()
DBSession().commit()
else:
if comments.count() > 0:
skip = True
if not skip:
print(f"packet id: {packet['objectId']}")
if new_source:
s.comments = [Comment(text=comment, obj_id=packet["objectId"],
user=self.ztfpack.group_admin_user,
origin=f"{os.path.basename(self.fname)}")
for comment in ["Added by ztf_upload_avro", \
f"filename = {os.path.basename(self.fname)}"]]
else:
comment_list = [Comment(text=comment, obj_id=packet["objectId"],
user=self.ztfpack.group_admin_user,
origin=f"{os.path.basename(self.fname)}")
for comment in ["Added by ztf_upload_avro", \
f"filename = {os.path.basename(self.fname)}"]]
photdata = []
varstarness = []
ssdistnr = packet["candidate"].get("ssdistnr")
is_roid = False
if packet["candidate"].get("isdiffpos", 'f') in ["1", "t"]:
if not ((ssdistnr is None) or (ssdistnr < 0) or
(ssdistnr > 5)):
is_roid = True
for j, row in dflc.iterrows():
rj = row.to_dict()
if ((packet["candidate"].get("sgscore1", 1.0) or 1.0) >= 0.5) and \
((packet["candidate"].get("distpsnr1", 10) or 10) < 1.0) or \
(rj.get("isdiffpos", 'f') not in ["1", "t"] and \
not pd.isnull(rj.get('magpsf'))):
if not is_roid:
# make sure it's not a roid
varstarness.append(True)
else:
varstarness.append(False)
phot = {
"mag": rj.pop('magpsf'),
"e_mag": rj.pop("sigmapsf"),
"lim_mag": rj.pop('diffmaglim'),
"filter": str(rj.pop('fid')),
"score": rj.pop("rb"),
"candid": rj.pop("candid"),
"isdiffpos": rj.pop("isdiffpos") in ["1", "t"],
'dist_nearest_source': rj.pop("distnr"),
'mag_nearest_source': rj.pop("magnr"),
'e_mag_nearest_source': rj.pop("sigmagnr")
}
t = Time(rj.pop("jd"), format="jd")
phot.update({
"observed_at": t.iso,
"mjd": t.mjd,
"time_format": "iso",
"time_scale": "utc"
})
# calculate the variable star mag
sign = 1.0 if phot["isdiffpos"] else -1.0
mref = phot["mag_nearest_source"]
mref_err = phot["e_mag_nearest_source"]
mdiff = phot["mag"]
mdiff_err = phot["e_mag"]
# Three options here:
# diff is detected in positive (ref source got brighter)
# diff is detected in the negative (ref source got fainter)
# diff is undetected in the neg/pos (ref similar source)
try:
if not pd.isnull(mdiff):
total_mag = -2.5 * np.log10(10**(-0.4 * mref) +
sign * 10**(-0.4 * mdiff))
tmp_total_mag_errs = (-2.5*np.log10(10**(-0.4*mref) +
sign*10**(-0.4*(mdiff + mdiff_err))) \
- total_mag,
-2.5*np.log10(10**(-0.4*mref) +
sign*10**(-0.4*(mdiff - mdiff_err))) \
- total_mag)
# add errors in quadature -- geometric mean of diff err
# and ref err
total_mag_err = np.sqrt(-1.0 * tmp_total_mag_errs[0] *
tmp_total_mag_errs[1] +
mref_err**2)
else:
# undetected source
mref = packet["candidate"].get("magnr")
mref_err = packet["candidate"].get("sigmagnr")
# 5 sigma
diff_err = (-2.5 * np.log10(10**
(-0.4 * mref) + sign * 10**
(-0.4 * phot["lim_mag"])) -
mref) / 5
total_mag = mref
total_mag_err = np.sqrt(mref_err**2 + diff_err**2)
except:
#print("Error in varstar calc")
#print(mdiff, mref, sign, mdiff_err, packet["candidate"].get("magnr"), packet["candidate"].get("sigmagnr"))
total_mag = 99
total_mag_err = 0
phot.update({"var_mag": total_mag, "var_e_mag": total_mag_err})
# just keep all the remaining non-nan values for this epoch
altdata = dict()
for k in rj:
if not pd.isnull(rj[k]): altdata.update({k: rj[k]})
phot.update({"altdata": altdata})
photdata.append(copy.copy(phot))
photometry = Photometry.query.filter(Photometry.obj_id == packet["objectId"]) \
.filter(Photometry.origin == f"{os.path.basename(self.fname)}")
skip = False
if self.clobber:
if photometry.count() > 0:
print("removing preexisting photometry from this packet")
photometry.delete()
DBSession().commit()
else:
if photometry.count() > 0:
print(
"Existing photometry from this packet. Skipping addition of more."
)
skip = True
if not skip:
if new_source:
s.photometry = [
Photometry(instrument=self.ztfpack.i1,
obj_id=packet["objectId"],
origin=f"{os.path.basename(self.fname)}",
**row) for j, row in enumerate(photdata)
]
else:
phot_list = [
Photometry(instrument=self.ztfpack.i1,
obj_id=packet["objectId"],
origin=f"{os.path.basename(self.fname)}",
**row) for j, row in enumerate(photdata)
]
# s.spectra = []
source_is_varstar = source_is_varstar or any(varstarness)
s.varstar = source_is_varstar
s.is_roid = is_roid
s.transient = self._is_transient(dflc)
DBSession().add(s)
try:
DBSession().commit()
except:
print("error committing DB")
pass
for ttype, ztftype in [('new', 'Science'), ('ref', 'Template'),
('sub', 'Difference')]:
fname = f'{packet["candid"]}_{ttype}.png'
gzname = f'{packet["candid"]}_{ttype}.fits.gz'
t = Thumbnail(
type=ttype,
photometry_id=s.photometry[0].id,
file_uri=f'static/thumbnails/{packet["objectId"]}/{fname}',
origin=f"{os.path.basename(self.fname)}",
public_url=
f'/static/thumbnails/{packet["objectId"]}/{fname}')
tgz = Thumbnail(
type=ttype + "_gz",
photometry_id=s.photometry[0].id,
file_uri=f'static/thumbnails/{packet["objectId"]}/{gzname}',
origin=f"{os.path.basename(self.fname)}",
public_url=
f'/static/thumbnails/{packet["objectId"]}/{gzname}')
DBSession().add(t)
stamp = packet['cutout{}'.format(ztftype)]['stampData']
if (not os.path.exists(self.ztfpack.basedir/f'static/thumbnails/{packet["objectId"]}/{fname}') or \
not os.path.exists(self.ztfpack.basedir/f'static/thumbnails/{packet["objectId"]}/{gzname}')) and \
not self.clobber:
with gzip.open(io.BytesIO(stamp), 'rb') as f:
gz = open(f"/tmp/{gzname}", "wb")
gz.write(f.read())
gz.close()
f.seek(0)
with fits.open(io.BytesIO(f.read())) as hdul:
hdul[0].data = np.flip(hdul[0].data, axis=0)
ffig = aplpy.FITSFigure(hdul[0])
ffig.show_grayscale(
stretch='arcsinh',
invert=True) #ztftype != 'Difference')
ffig.save(f"/tmp/{fname}")
if not os.path.exists(
self.ztfpack.basedir /
f'static/thumbnails/{packet["objectId"]}'):
os.makedirs(self.ztfpack.basedir /
f'static/thumbnails/{packet["objectId"]}')
shutil.copy(
f"/tmp/{fname}", self.ztfpack.basedir /
f'static/thumbnails/{packet["objectId"]}/{fname}')
shutil.copy(
f"/tmp/{gzname}", self.ztfpack.basedir /
f'static/thumbnails/{packet["objectId"]}/{gzname}')
try:
s.add_linked_thumbnails()
except:
print("Not linking thumbnails...not on the 'net?")
# grab the photometry for this source and update relevant quanities
# ra, dec update
dat = pd.read_sql(
DBSession().query(Photometry).filter(
Photometry.obj_id == packet["objectId"]).filter(
Photometry.mag < 30).statement,
DBSession().bind)
if not s.varstar:
infos = [(x["altdata"]["ra"], x["altdata"]["dec"], x["mag"],
x["e_mag"], x["score"], x["filter"])
for i, x in dat.iterrows()]
else:
infos = [
(x["altdata"]["ra"], x["altdata"]["dec"], x["var_mag"],
x["var_e_mag"], x["score"], x["filter"])
for i, x in dat.iterrows()
]
ndet = len(dat[~pd.isnull(dat["mag"])])
s.detect_photometry_count = ndet
s.last_detected = np.max(
dat[~pd.isnull(dat["mag"])]["observed_at"])
calc_source_data = dict()
new_ra = np.average([x[0] for x in infos],
weights=[1. / x[3] for x in infos])
new_dec = np.average([x[1] for x in infos],
weights=[1. / x[3] for x in infos])
ra_err = np.std([x[0] for x in infos])
dec_err = np.std([x[1] for x in infos])
calc_source_data.update(
{"min_score": np.nanmin([x[4] for x in infos])})
calc_source_data.update(
{"max_score": np.nanmax([x[4] for x in infos])})
filts = list(set([x[-1] for x in infos]))
for f in filts:
ii = [x for x in infos if x[-1] == f]
rez = np.average([x[2] for x in ii],
weights=[1 / x[3] for x in ii])
if pd.isnull(rez):
rez = None
md = np.nanmax([x[2]
for x in ii]) - np.nanmin([x[2] for x in ii])
max_delta = md if not pd.isnull(md) else None
calc_source_data.update(
{f: {
"max_delta": max_delta,
"mag_avg": rez
}})
s = Source.query.get(packet["objectId"])
altdata = dict()
for k in calc_source_data:
if not pd.isnull(calc_source_data[k]):
altdata.update({k: calc_source_data[k]})
s.altdata = altdata
s.ra = new_ra
s.dec = new_dec
s.ra_err = ra_err
s.dec_err = dec_err
c1 = SkyCoord(s.ra_dis * u.deg, s.dec_dis * u.deg, frame='fk5')
c2 = SkyCoord(new_ra * u.deg, new_dec * u.deg, frame='fk5')
sep = c1.separation(c2)
s.offset = sep.arcsecond if not pd.isnull(sep.arcsecond) else 0.0
# TNS
tns = self._tns_search(s.ra_dis, s.dec_dis)
s.tns_info = tns
if tns["Name"]:
s.tns_name = tns["Name"]
# catalog search
result_table = customSimbad.query_region(SkyCoord(
f"{s.ra_dis}d {s.dec_dis}d", frame='icrs'),
radius='0d0m3s')
if result_table:
try:
s.simbad_class = result_table["OTYPE"][0].decode(
"utf-8", "ignore")
altdata = dict()
rj = result_table.to_pandas().dropna(
axis='columns').iloc[0].to_json()
s.simbad_info = rj
except:
pass
if s.simbad_class:
comments = [
Comment(text=comment,
obj_id=packet["objectId"],
user=self.ztfpack.group_admin_user,
ctype="classification",
origin=f"{os.path.basename(self.fname)}")
for comment in [f"Simbad class = {s.simbad_class}"]
]
result_table = customGaia.query_region(SkyCoord(ra=s.ra_dis,
dec=s.dec_dis,
unit=(u.deg,
u.deg),
frame='icrs'),
width="3s",
catalog=["I/345/gaia2"])
if result_table:
try:
rj = result_table.pop().to_pandas().dropna(
axis='columns').iloc[0].to_json()
s.gaia_info = rj
except:
pass
DBSession().commit()
print("added")
def non_helioprojective_skycoord():
return SkyCoord(0 * u.rad, 0 * u.rad, frame="icrs")
import astropy.units as u
from astropy.coordinates import SkyCoord
import sunpy.map
from sunpy.coordinates import frames
################################################################################
# First we will create a blank map using with an array of zeros.
# Since there is no WCS information, we will need to construct a header to pass to Map.
data = np.full((10, 10), np.nan)
# Define a reference coordinate and create a header using sunpy.map.make_fitswcs_header
skycoord = SkyCoord(0 * u.arcsec,
0 * u.arcsec,
obstime='2013-10-28',
observer='earth',
frame=frames.Helioprojective)
# Scale set to the following for solar limb to be in the field of view
header = sunpy.map.make_fitswcs_header(data,
skycoord,
scale=[220, 220] * u.arcsec / u.pixel)
# Use sunpy.map.Map to create the blank map
blank_map = sunpy.map.Map(data, header)
################################################################################
# Now we have constructed the map, we can plot it and mark important locations to it.
# Initialize the plot and add the map to it
star.rstar = dat["r"][i]*const.R_sun
star.d = dat["dpc"][i]*u.pc #pc
exoplanet=planet.PlanetClass()
exoplanet.rplanet = 1.0*const.R_earth #Re
exoplanet.a =float(dat["amin"][i])*u.AU #AU
exoplanet.albedo = 0.3
exoplanet.phase = np.pi/2.0
exoplanet.compute_reflectivity()
print("Star-Planet Contrast =",exoplanet.reflectivity)
contrast=exoplanet.reflectivity
ra=str(dat["ra"][i])
dec=str(dat["dec"][i])
radec=ra+" "+dec
c = SkyCoord(radec, unit=(u.hourangle, u.deg))
decdeg=(c.dec.degree)
amin=dat["amin"][i]
d=dat["dpc"][i]
sep=float(amin)/float(d)
if decdeg > -40:
col="C1"
else:
col="gray"
plt.plot([sep],[contrast],"o",color=col)
if str(dat["propername"][i])=="nan":
plt.text(sep,contrast,dat["name"][i],color=col,alpha=0.5,fontsize=13)
else:
plt.text(sep,contrast,dat["propername"][i],color=col,alpha=0.5,fontsize=13)
print("OK:",dat["name"][i])
def run_flux_sensitivity(**kwargs):
index = kwargs.get('index', 2.0)
sedshape = kwargs.get('sedshape', 'PowerLaw')
cutoff = kwargs.get('cutoff', 1e3)
curvindex = kwargs.get('curvindex', 1.0)
beta = kwargs.get('beta', 0.0)
dmmass = kwargs.get('DMmass', 100.0)
dmchannel = kwargs.get('DMchannel', 'bb')
emin = kwargs.get('emin', 10**1.5)
emax = kwargs.get('emax', 10**6.0)
nbin = kwargs.get('nbin', 18)
glon = kwargs.get('glon', 0.0)
glat = kwargs.get('glat', 0.0)
ltcube_filepath = kwargs.get('ltcube', None)
galdiff_filepath = kwargs.get('galdiff', None)
isodiff_filepath = kwargs.get('isodiff', None)
galdiff_fit_filepath = kwargs.get('galdiff_fit', None)
isodiff_fit_filepath = kwargs.get('isodiff_fit', None)
wcs_npix = kwargs.get('wcs_npix', 40)
wcs_cdelt = kwargs.get('wcs_cdelt', 0.5)
wcs_proj = kwargs.get('wcs_proj', 'AIT')
map_type = kwargs.get('map_type', None)
spatial_model = kwargs.get('spatial_model', 'PointSource')
spatial_size = kwargs.get('spatial_size', 1E-2)
obs_time_yr = kwargs.get('obs_time_yr', None)
event_class = kwargs.get('event_class', 'P8R2_SOURCE_V6')
min_counts = kwargs.get('min_counts', 3.0)
ts_thresh = kwargs.get('ts_thresh', 25.0)
nside = kwargs.get('hpx_nside', 16)
output = kwargs.get('output', None)
event_types = [['FRONT', 'BACK']]
if sedshape == 'PowerLaw':
fn = spectrum.PowerLaw([1E-13, -index], scale=1E3)
elif sedshape == 'PLSuperExpCutoff':
fn = spectrum.PLSuperExpCutoff([1E-13, -index, cutoff, curvindex],
scale=1E3)
elif sedshape == 'LogParabola':
fn = spectrum.LogParabola([1E-13, -index, beta], scale=1E3)
elif sedshape == 'DM':
fn = spectrum.DMFitFunction([1E-26, dmmass], chan=dmchannel)
log_ebins = np.linspace(np.log10(emin), np.log10(emax), nbin + 1)
ebins = 10**log_ebins
ectr = np.exp(utils.edge_to_center(np.log(ebins)))
c = SkyCoord(glon, glat, unit='deg', frame='galactic')
if ltcube_filepath is None:
if obs_time_yr is None:
raise Exception('No observation time defined.')
ltc = LTCube.create_from_obs_time(obs_time_yr * 365 * 24 * 3600.)
else:
ltc = LTCube.create(ltcube_filepath)
if obs_time_yr is not None:
ltc._counts *= obs_time_yr * 365 * \
24 * 3600. / (ltc.tstop - ltc.tstart)
gdiff = skymap.Map.create_from_fits(galdiff_filepath)
gdiff_fit = None
if galdiff_fit_filepath is not None:
gdiff_fit = skymap.Map.create_from_fits(galdiff_fit_filepath)
if isodiff_filepath is None:
isodiff = utils.resolve_file_path('iso_%s_v06.txt' % event_class,
search_dirs=['$FERMI_DIFFUSE_DIR'])
isodiff = os.path.expandvars(isodiff)
else:
isodiff = isodiff_filepath
iso = np.loadtxt(isodiff, unpack=True)
iso_fit = None
if isodiff_fit_filepath is not None:
iso_fit = np.loadtxt(isodiff_fit_filepath, unpack=True)
scalc = SensitivityCalc(gdiff,
iso,
ltc,
ebins,
event_class,
event_types,
gdiff_fit=gdiff_fit,
iso_fit=iso_fit,
spatial_model=spatial_model,
spatial_size=spatial_size)
# Compute Maps
map_diff_flux = None
map_diff_npred = None
map_int_flux = None
map_int_npred = None
map_nstep = 500
if map_type == 'hpx':
hpx = HPX(nside, True, 'GAL', ebins=ebins)
map_diff_flux = HpxMap(np.zeros((nbin, hpx.npix)), hpx)
map_diff_npred = HpxMap(np.zeros((nbin, hpx.npix)), hpx)
map_skydir = map_diff_flux.hpx.get_sky_dirs()
for i in range(0, len(map_skydir), map_nstep):
s = slice(i, i + map_nstep)
o = scalc.diff_flux_threshold(map_skydir[s], fn, ts_thresh,
min_counts)
map_diff_flux.data[:, s] = o['flux'].T
map_diff_npred.data[:, s] = o['npred'].T
hpx = HPX(nside, True, 'GAL')
map_int_flux = HpxMap(np.zeros((hpx.npix)), hpx)
map_int_npred = HpxMap(np.zeros((hpx.npix)), hpx)
map_skydir = map_int_flux.hpx.get_sky_dirs()
for i in range(0, len(map_skydir), map_nstep):
s = slice(i, i + map_nstep)
o = scalc.int_flux_threshold(map_skydir[s], fn, ts_thresh,
min_counts)
map_int_flux.data[s] = o['flux']
map_int_npred.data[s] = o['npred']
elif map_type == 'wcs':
wcs_shape = [wcs_npix, wcs_npix]
wcs_size = wcs_npix * wcs_npix
map_diff_flux = Map.create(c,
wcs_cdelt,
wcs_shape,
'GAL',
wcs_proj,
ebins=ebins)
map_diff_npred = Map.create(c,
wcs_cdelt,
wcs_shape,
'GAL',
wcs_proj,
ebins=ebins)
map_skydir = map_diff_flux.get_pixel_skydirs()
for i in range(0, len(map_skydir), map_nstep):
idx = np.unravel_index(np.arange(i, min(i + map_nstep, wcs_size)),
wcs_shape)
s = (slice(None), idx[1], idx[0])
o = scalc.diff_flux_threshold(map_skydir[slice(i, i + map_nstep)],
fn, ts_thresh, min_counts)
map_diff_flux.data[s] = o['flux'].T
map_diff_npred.data[s] = o['npred'].T
map_int_flux = Map.create(c, wcs_cdelt, wcs_shape, 'GAL', wcs_proj)
map_int_npred = Map.create(c, wcs_cdelt, wcs_shape, 'GAL', wcs_proj)
map_skydir = map_int_flux.get_pixel_skydirs()
for i in range(0, len(map_skydir), map_nstep):
idx = np.unravel_index(np.arange(i, min(i + map_nstep, wcs_size)),
wcs_shape)
s = (idx[1], idx[0])
o = scalc.int_flux_threshold(map_skydir[slice(i, i + map_nstep)],
fn, ts_thresh, min_counts)
map_int_flux.data[s] = o['flux']
map_int_npred.data[s] = o['npred']
o = scalc.diff_flux_threshold(c, fn, ts_thresh, min_counts)
cols = [
Column(name='e_min', dtype='f8', data=scalc.ebins[:-1], unit='MeV'),
Column(name='e_ref', dtype='f8', data=o['e_ref'], unit='MeV'),
Column(name='e_max', dtype='f8', data=scalc.ebins[1:], unit='MeV'),
Column(name='flux', dtype='f8', data=o['flux'], unit='ph / (cm2 s)'),
Column(name='eflux', dtype='f8', data=o['eflux'],
unit='MeV / (cm2 s)'),
Column(name='dnde',
dtype='f8',
data=o['dnde'],
unit='ph / (MeV cm2 s)'),
Column(name='e2dnde',
dtype='f8',
data=o['e2dnde'],
unit='MeV / (cm2 s)'),
Column(name='npred', dtype='f8', data=o['npred'], unit='ph')
]
tab_diff = Table(cols)
cols = [
Column(name='index', dtype='f8'),
Column(name='e_min', dtype='f8', unit='MeV'),
Column(name='e_ref', dtype='f8', unit='MeV'),
Column(name='e_max', dtype='f8', unit='MeV'),
Column(name='flux', dtype='f8', unit='ph / (cm2 s)'),
Column(name='eflux', dtype='f8', unit='MeV / (cm2 s)'),
Column(name='dnde', dtype='f8', unit='ph / (MeV cm2 s)'),
Column(name='e2dnde', dtype='f8', unit='MeV / (cm2 s)'),
Column(name='npred', dtype='f8', unit='ph'),
Column(name='ebin_e_min', dtype='f8', unit='MeV', shape=(len(ectr), )),
Column(name='ebin_e_ref', dtype='f8', unit='MeV', shape=(len(ectr), )),
Column(name='ebin_e_max', dtype='f8', unit='MeV', shape=(len(ectr), )),
Column(name='ebin_flux',
dtype='f8',
unit='ph / (cm2 s)',
shape=(len(ectr), )),
Column(name='ebin_eflux',
dtype='f8',
unit='MeV / (cm2 s)',
shape=(len(ectr), )),
Column(name='ebin_dnde',
dtype='f8',
unit='ph / (MeV cm2 s)',
shape=(len(ectr), )),
Column(name='ebin_e2dnde',
dtype='f8',
unit='MeV / (cm2 s)',
shape=(len(ectr), )),
Column(name='ebin_npred', dtype='f8', unit='ph', shape=(len(ectr), ))
]
cols_ebounds = [
Column(name='E_MIN', dtype='f8', unit='MeV', data=ebins[:-1]),
Column(name='E_MAX', dtype='f8', unit='MeV', data=ebins[1:]),
]
tab_int = Table(cols)
tab_ebounds = Table(cols_ebounds)
index = np.linspace(1.0, 5.0, 4 * 4 + 1)
for g in index:
fn = spectrum.PowerLaw([1E-13, -g], scale=10**3.5)
o = scalc.int_flux_threshold(c, fn, ts_thresh, 3.0)
row = [g]
for colname in tab_int.columns:
if colname == 'index':
continue
if 'ebin' in colname:
row += [o['bins'][colname.replace('ebin_', '')]]
else:
row += [o[colname]]
tab_int.add_row(row)
hdulist = fits.HDUList()
hdulist.append(fits.table_to_hdu(tab_diff))
hdulist.append(fits.table_to_hdu(tab_int))
hdulist.append(fits.table_to_hdu(tab_ebounds))
hdulist[1].name = 'DIFF_FLUX'
hdulist[2].name = 'INT_FLUX'
hdulist[3].name = 'EBOUNDS'
if map_type is not None:
hdu = map_diff_flux.create_image_hdu()
hdu.name = 'MAP_DIFF_FLUX'
hdulist.append(hdu)
hdu = map_diff_npred.create_image_hdu()
hdu.name = 'MAP_DIFF_NPRED'
hdulist.append(hdu)
hdu = map_int_flux.create_image_hdu()
hdu.name = 'MAP_INT_FLUX'
hdulist.append(hdu)
hdu = map_int_npred.create_image_hdu()
hdu.name = 'MAP_INT_NPRED'
hdulist.append(hdu)
hdulist.writeto(output, overwrite=True)
def region():
center = SkyCoord("0 deg", "0 deg", frame="galactic")
return CircleSkyRegion(center=center, radius=1 * u.deg)
peccObs.to_csv(os.path.join('.', 'pecc', 'obs-OBC-ecc-p.csv'),
header=['e', 'p'])
peccRec.to_csv(os.path.join('.', 'pecc', 'rec-OBC-ecc-p.csv'),
header=['e', 'p'])
#plot and save the histograms
saveHist(m1hAll, m1hObs, m1hRec, m1b, 'm1 (Msolar)', 'EBLSST_m1hist')
saveHist(qhAll, qhObs, qhRec, qb, 'q (m2/m1)', 'EBLSST_qhist')
saveHist(ehAll, ehObs, ehRec, eb, 'e', 'EBLSST_ehist')
saveHist(lphAll, lphObs, lphRec, lpb, 'log(P [days])', 'EBLSST_lphist')
saveHist(dhAll, dhObs, dhRec, db, 'd (kpc)', 'EBLSST_dhist')
saveHist(maghAll, maghObs, maghRec, magb, 'mag', 'EBLSST_maghist')
saveHist(rhAll, rhObs, rhRec, rb, 'r2/r1', 'EBLSST_rhist')
#make the mollweide
coords = SkyCoord(RA, Dec, unit=(units.degree, units.degree), frame='icrs')
lGal = coords.galactic.l.wrap_at(180. * units.degree).degree
bGal = coords.galactic.b.wrap_at(180. * units.degree).degree
RAwrap = coords.ra.wrap_at(180. * units.degree).degree
Decwrap = coords.dec.wrap_at(180. * units.degree).degree
plotPath = os.path.join('.', 'plots')
f, ax = plt.subplots(subplot_kw={'projection': "mollweide"},
figsize=(8, 5))
ax.grid(True)
#ax.set_xlabel(r"$l$",fontsize=16)
#ax.set_ylabel(r"$b$",fontsize=16)
#mlw = ax.scatter(lGal.ravel()*np.pi/180., bGal.ravel()*np.pi/180., c=np.log10(np.array(recFrac)*100.), cmap='viridis_r', s = 4)
ax.set_xlabel("RA", fontsize=16)
ax.set_ylabel("Dec", fontsize=16)
mlw = ax.scatter(np.array(RAwrap).ravel() * np.pi / 180.,
parser = argparse.ArgumentParser(
description='Convert RA and DEC to Alt and Az')
parser.add_argument("-R", "--input_RA", help="Input as: XXhYYmZZ.ZZZs")
parser.add_argument("-D", "--input_DEC", help="Input as: XXdYYmZZ.ZZZs")
parser.add_argument("-t", "--time", help="time for conversion to alt,az, MJD")
args = parser.parse_args()
RA = args.input_RA
DEC = args.input_DEC
time_MJD = args.time
#I-LOFAR
lat = 53.09469
lon = -7.92153
z = 75
#LOFAR-SE
#lat = 57.39885
#lon = 11.93029
#z = 18
target_coord = SkyCoord(RA, DEC, frame='icrs')
observer_coord = EarthLocation(lat=lat * u.deg,
lon=lon * u.deg,
height=z * u.m)
time = Time(time_MJD, format='mjd')
altaz = target_coord.transform_to(AltAz(obstime=time, location=observer_coord))
print(altaz)
def filter_aliases(table, week=None):
"""
Remove the few pesky sources that are known to be aliases of other sources
"""
if week is None:
print "no week supplied - not filtering aliases"
return table
print "filtering aliased sources"
# read lines from files
if week == 3:
f = "Week3_CenA_ghosts.reg"
elif week == 4:
f = "Week4_HerA_ghost.reg"
else:
print "there are no known aliased sources for week ", week
return table
if not os.path.exists(f):
if os.path.exists(mwa_code_base +
"/MWA_Tools/gleam_scripts/mosaics/scripts/" + f):
f = mwa_code_base + "/MWA_Tools/gleam_scripts/mosaics/scripts/" + f
else:
print "cannot find ", f
sys.exit(1)
lines = (a for a in open(f).readlines() if a.startswith('ellipse'))
# convert lines into ra,dec,a,b,pa
words = [re.split('[(,\s)]', line) for line in lines]
pos = [SkyCoord(w[1], w[2], unit=(u.hourangle, u.degree)) for w in words]
ra = np.array([p.ra.degree for p in pos])
dec = np.array([p.dec.degree for p in pos])
shape = [map(lambda x: float(x.replace('"', '')), w[3:6]) for w in words]
a, b, pa = map(np.array, zip(*shape))
# convert from ds9 to 'true' position angle
pa += 90
a /= 3600.
b /= 3600.
# all params are now in degrees
kill_list = []
# loops for now
for i in range(len(ra)):
# define a box that is larger than needed
dmin = dec[i] - 3 * a[i]
dmax = dec[i] + 3 * a[i]
rmin = ra[i] - 3 * a[i]
rmax = ra[i] + 3 * a[i]
# Select all sources within this box
mask = np.where((table['dec'] < dmax) & (table['dec'] > dmin)
& (table['ra'] > rmin) & (table['ra'] < rmax))[0]
if len(mask) < 1:
continue
# create a catalog of this subset
cat = SkyCoord(table[mask]['ra'],
table[mask]['dec'],
unit=(u.degree, u.degree))
# define our reference position and find all sources that are within the error ellipse
p = pos[i]
# yay for vectorized functions in astropy
offset = p.separation(cat).degree
pa_off = p.position_angle(cat).radian
pa_diff = pa_off - np.radians(pa[i])
radius = a[i] * b[i] / np.sqrt((b[i] * np.cos(pa_diff))**2 +
(a[i] * np.sin(pa_diff))**2)
# print 'radius', radius
# print 'offset', offset
to_remove = np.where(radius >= offset)[0]
# print 'sources within box', mask
# print 'marked for removal',to_remove,
# print mask[to_remove]
if len(to_remove) < 1:
continue
# save the index of the sources that are within the error ellipse
kill_list.extend(mask[to_remove])
print "table has ", len(table), "sources"
print "there are ", len(kill_list), "sources to remove"
table.remove_rows(kill_list)
print "there are now ", len(table), "sources left in the table"
return table
