def do_plot(self, dataset):
#for dataset in r533:
points, plot_type, lons, lats, num_pts_lon, num_pts_lat, params = dataset
plot_dt, plot_title, freq, idx = params
#plt.figure(figsize=(12,6))
m = Basemap(projection='cyl', resolution='l')
m.drawcoastlines(color='black', linewidth=0.75)
m.drawcountries(color='grey')
m.drawmapboundary(color='black', linewidth=1.0)
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
X,Y = np.meshgrid(lons, lats)
#todo remove hard-coded values for vmin and vmax
#im = m.pcolormesh(X, Y, points, shading='gouraud', cmap=plt.cm.jet, latlon=True, vmin=-20, vmax=40)
#im = m.pcolormesh(X, Y, points, shading='gouraud', cmap=plt.cm.jet, latlon=True, vmin=-20, vmax=40)
im = m.imshow(points, interpolation='bilinear', vmin=0, vmax=100)
if self.plot_terminator:
m.nightshade(plot_dt)
cb = m.colorbar(im,"bottom", size="5%", pad="2%")
plt.title(plot_title)
plot_fn = "area_{:s}_{:s}_{:s}.png".format(plot_type, plot_dt.strftime("%H%M_%b_%Y"), "d".join(str(freq).split('.')))
print ("Saving file ", plot_fn)
plt.savefig(plot_fn, dpi=float(self.dpi), bbox_inches='tight')
def polar_quiver_wind(self, ax, ns='N'):
# Wind vector in lat-long coordinates.
# For different map projections, the arithmetics to calculate xywind
# are different
if self.empty:
return
from mpl_toolkits.basemap import Basemap
from apexpy import Apex
# Creat polar coordinates
projection,fc = ('npstere',1) if ns=='N' else ('spstere',-1)
m = Basemap(projection=projection,boundinglat=fc*40,lon_0=0,resolution='l')
m.drawcoastlines(color='gray',zorder=1)
m.fillcontinents(color='lightgray',zorder=0)
dt = self.index.min() + (self.index.max()-self.index.min())/2
m.nightshade(dt,zorder=2)
#m.drawparallels(np.arange(-80,81,20))
#m.drawmeridians(np.arange(-180,181,60),labels=[1,1,1,1])
# Calculate mlat and mlon
lat_grid = np.arange(-90,91,10)
lon_grid = np.arange(-180,181,10)
lon_grid, lat_grid = np.meshgrid(lon_grid, lat_grid)
gm = Apex(date=2005)
mlat,mlon = gm.convert(lat_grid,lon_grid,'geo','apex')
hc1 = m.contour(lon_grid,lat_grid,mlat,levels=np.arange(-90,91,10),
colors='k', zorder=3, linestyles='dashed',
linewidths=1, latlon=True)
# hc2 = m.contour(lon_grid,lat_grid,mlon,levels=np.arange(-180,181,45),
# colors='k', zorder=3, linestyles='dashed', latlon=True)
plt.clabel(hc1,inline=True,colors='k',fmt='%d')
# plt.clabel(hc2,inline=True,colors='k',fmt='%d')
# Calculate and plot x and y winds
lat = self.lat
lon = self.long
wind = self.wind
winde1 = self.winde
winde = winde1*wind
windn1 = self.windn
windn = windn1*wind
# only appropriate for the npstere and spstere
xwind = fc*winde*np.cos(lon/180*np.pi)-windn*np.sin(lon/180*np.pi)
ywind = winde*np.sin(lon/180*np.pi)+fc*windn*np.cos(lon/180*np.pi)
hq = m.quiver(np.array(lon),np.array(lat),xwind,ywind,color='blue',
scale=300, scale_units='inches',zorder=3, latlon=True)
#plt.quiverkey(hq,1.05,1.05,100,'100 m/s',coordinates='axes',labelpos='E')
#m.scatter(np.array(lon),np.array(lat),
# s=50, c=self.index.to_julian_date(),linewidths=0, zorder=4,latlon=True)
return m
def plotBase(fig, dt=None):
m = Basemap(projection='merc',
lon_0=0,lat_0=0,lat_ts=0,
llcrnrlat=0,urcrnrlat=50,
llcrnrlon=-100,urcrnrlon=-50,
resolution='l')
m.drawcountries(linewidth=1, color='k')
m.drawmapscale(-90, 5, -90, 5, 1000, barstyle='fancy')
m.bluemarble(scale=1)
# Get Position of NYC, longitude -74.0064, latitude 40.7142
x,y = m(-74.0064, 40.7142)
# Plot NYC
m.scatter(x, y, s=100, marker='*', color='0.5', alpha=1)
plt.text(x,y,'NYC', fontsize='15')
if dt is not None: m.nightshade(dt, alpha = 0.3)
return m
def geramapa(idx):
lon = stars[idx].ra - datas[idx].sidereal_time('mean', 'greenwich')
m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution='l')
# draw coastlines, country boundaries, fill continents.
m.shadedrelief()
m.drawcoastlines(linewidth=0.25)
m.drawcountries(linewidth=0.4)
m.drawstates(linewidth=0.4)
#m.fillcontinents(color='coral',lake_color='aqua')
# draw the edge of the map projection region (the projection limb)
#m.drawmapboundary(fill_color='aqua')
# draw lat/lon grid lines every 30 degrees.
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
if os.path.isfile(sitearq) == True:
xpt,ypt = m(sites['lon'],sites['lat'])
m.plot(xpt,ypt,'bo')
CS=m.nightshade(datas[idx].datetime, alpha=0.2)
a, b =m(lon.value, stars[idx].dec.value)
a = a*u.m
b = b*u.m
dista = (dist[idx].to(u.km)*ca[idx].to(u.rad)).value*u.km
disterr = (dist[idx].to(u.km)*erro.to(u.rad)).value*u.km
ax = a + dista*np.sin(pa[idx])
ax2 = ax + 1000*u.km*vec*np.cos(pa[idx])
ax3 = ax2 - tamanho/2*np.sin(pa[idx])
ax4 = ax2 + tamanho/2*np.sin(pa[idx])
ax5 = a + (dista-disterr)*np.sin(pa[idx]) + 1000*u.km*vec*np.cos(pa[idx])
ax6 = a + (dista+disterr)*np.sin(pa[idx]) + 1000*u.km*vec*np.cos(pa[idx])
by = b + dista*np.cos(pa[idx])
by2 = by - 1000*u.km*vec*np.sin(pa[idx])
by3 = by2 - tamanho/2*np.cos(pa[idx])
by4 = by2 + tamanho/2*np.cos(pa[idx])
by5 = b + (dista-disterr)*np.cos(pa[idx]) - 1000*u.km*vec*np.sin(pa[idx])
by6 = b + (dista+disterr)*np.cos(pa[idx]) - 1000*u.km*vec*np.sin(pa[idx])
m.plot(ax,by, 'ro', markersize=20)
m.plot(ax2.to(u.m),by2.to(u.m), 'ro', markersize=8)
m.plot(ax3.to(u.m), by3.to(u.m), 'b')
m.plot(ax4.to(u.m), by4.to(u.m), 'b')
m.plot(ax5.to(u.m), by5.to(u.m), 'r--')
m.plot(ax6.to(u.m), by6.to(u.m), 'r--')
fig = plt.gcf()
fig.set_size_inches(18.0, 15.0)
plt.title('-{} D={}- dots each 1000km or {:.2f} <> offsets (mas): {:.1f}, {:.1f}\n'.format(obj, tamanho, np.absolute(1000*u.km/vel[idx]), off_ra[idx].value, off_de[idx].value), fontsize=25, fontproperties='FreeMono')
plt.xlabel('\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
.format(datas[idx].iso, dados['afh'][idx], dados['afm'][idx], dados['afs'][idx], dados['ded'][idx], dados['dem'][idx], dados['des'][idx], ca[idx].value, pa[idx].value, dados['vel'][idx],
dist[idx].value, dados['mR'][idx], dados['mK'][idx], dados['long'][idx]), fontsize=21, fontproperties='FreeMono')
plt.savefig('{}_{}.png'.format(obj, datas[idx].isot),dpi=100)
print 'Gerado: {}_{}.png'.format(obj, datas[idx].isot)
plt.clf()
def plot():
import numpy as np
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
from datetime import datetime
# miller projection
# map = Basemap(projection='mill',lon_0=180)
map = Basemap(projection='kav7',lon_0=180)
# plot coastlines, draw label meridians and parallels.
map.drawcoastlines()
map.drawparallels(np.arange(-90,90,30),labels=[1,0,0,0])
map.drawmeridians(np.arange(map.lonmin,map.lonmax+30,60),labels=[0,0,0,1])
# fill continents 'coral' (with zorder=0), color wet areas 'aqua'
map.drawmapboundary(fill_color='aqua')
map.fillcontinents(color='coral',lake_color='aqua')
# shade the night areas, with alpha transparency so the
# map shows through. Use current time in UTC.
date = datetime.utcnow()
CS=map.nightshade(date)
plt.title('Day/Night Map for %s (UTC)' % date.strftime("%d %b %Y %H:%M:%S"))
plt.show()
# line1 = 'ISS (ZARYA)'
# line2 = '1 25544U 98067A 19015.25189318 .00000401 00000-0 13432-4 0 9995' # noqa
# line3 = '2 25544 51.6418 41.9123 0002387 289.9764 167.0424 15.53761231151490' # noqa
iss_pos = ephem.readtle(line1, line2, line3)
fig = plt.figure(figsize=(8, 6), edgecolor='w')
map = Basemap(projection='mill', lon_0=0)
map.drawcoastlines()
map.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0])
map.drawmeridians(np.arange(map.lonmin, map.lonmax + 30, 60),
labels=[0, 0, 0, 1])
map.drawmapboundary(fill_color='aqua')
map.fillcontinents(color='coral', lake_color='aqua')
map.nightshade(datetime.utcnow())
# text = plt.text(0, 0, 'International\n Space Station', fontweight='bold',
# color=(0, 0.2, 1))
# iss_point, = plt.plot([], [], 'ob', markersize=10)
iss_image = Image.open('icon/iss_new.png')
# process_image(iss_image, (12, 12, 36))
# iss_image.save('icon/iss_new.png')
imagebox = OffsetImage(iss_image, zoom=0.08)
iss_icon = AnnotationBbox(imagebox,
map(0, 0),
xybox=(0, -4),
xycoords='data',
boxcoords='offset points',
def geramapa(idx):
lons1, lats1, lons2, lats2 = calcfaixa(idx)
lon = stars[idx].ra - datas[idx].sidereal_time('mean', 'greenwich')
m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution=resolution)
# m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution=resolution, llcrnrx=-7000000,llcrnry=-7000000,urcrnrx=7000000,urcrnry=7000000)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
m.drawmapboundary()
ptcolor = 'black'
lncolor = 'black'
dscolor = 'black'
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '3':
m.shadedrelief()
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '4':
m.bluemarble()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
elif mapstyle == '5':
m.etopo()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
if os.path.isfile(sitearq) == True:
xpt,ypt = m(sites['lon'],sites['lat'])
m.plot(xpt,ypt,'bo')
CS=m.nightshade(datas[idx].datetime, alpha=0.2)
a, b =m(lon.value, stars[idx].dec.value)
a = a*u.m
b = b*u.m
dista = (dist[idx].to(u.km)*ca[idx].to(u.rad)).value*u.km
disterr = (dist[idx].to(u.km)*erro.to(u.rad)).value*u.km
vec = np.arange(0,7000,(np.absolute(vel[idx])*(60*u.s)).value)*u.km + np.absolute(vel[idx])*(60*u.s)
vec = np.concatenate((vec.value,-vec.value), axis=0)*u.km
ax = a + dista*np.sin(pa[idx])
ax2 = ax + vec*np.cos(pa[idx])
ax3 = ax2 - tamanho/2*np.sin(pa[idx])
ax4 = ax2 + tamanho/2*np.sin(pa[idx])
ax5 = a + (dista-disterr)*np.sin(pa[idx]) + vec*np.cos(pa[idx])
ax6 = a + (dista+disterr)*np.sin(pa[idx]) + vec*np.cos(pa[idx])
by = b + dista*np.cos(pa[idx])
by2 = by - vec*np.sin(pa[idx])
by3 = by2 - tamanho/2*np.cos(pa[idx])
by4 = by2 + tamanho/2*np.cos(pa[idx])
by5 = b + (dista-disterr)*np.cos(pa[idx]) - vec*np.sin(pa[idx])
by6 = b + (dista+disterr)*np.cos(pa[idx]) - vec*np.sin(pa[idx])
xs, ys = m(lons1, lats1)
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, 'b')
xt, yt = m(lons2, lats2)
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, 'b')
# m.plot(ax,by, 'o', color=ptcolor, markersize=mapsize[0].value*20/46)
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=mapsize[0].value*8/46)
# m.plot(ax3.to(u.m), by3.to(u.m), color=lncolor)
# m.plot(ax4.to(u.m), by4.to(u.m), color=lncolor)
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
plt.title('-{} D={}- dots each 60 s <> offsets (mas): obj=({:.1f},{:.1f}), star=({:.1f},{:.1f})\n'
.format(obj, tamanho, ob_off_ra[idx].value, ob_off_de[idx].value, st_off_ra[idx].value, st_off_de[idx].value), fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
plt.xlabel('\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
.format(datas[idx].iso, int(stars[idx].ra.hms.h), int(stars[idx].ra.hms.m), stars[idx].ra.hms.s, int(stars[idx].dec.dms.d), np.absolute(int(stars[idx].dec.dms.m)), np.absolute(stars[idx].dec.dms.s),
ca[idx].value, pa[idx].value, vel[idx].value, dist[idx].value, magR[idx], magK[idx], longi[idx]), fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
plt.savefig('{}_{}.png'.format(obj, datas[idx].isot),dpi=100)
print 'Gerado: {}_{}.png'.format(obj, datas[idx].isot)
plt.clf()
def geramapa(delt):
deltatime = delt * u.s
datas1 = datas[idx] + TimeDelta(deltatime)
datas1.delta_ut1_utc = 0
lon = stars[idx].ra - datas1.sidereal_time('mean', 'greenwich')
m = Basemap(projection='ortho',
lat_0=stars[idx].dec.value,
lon_0=lon.value,
resolution=resolution)
# m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution=resolution, llcrnrx=-7000000,llcrnry=-7000000,urcrnrx=7000000,urcrnry=7000000)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0, 360, 30))
m.drawparallels(np.arange(-90, 90, 30))
m.drawmapboundary()
ptcolor = 'black'
lncolor = 'black'
dscolor = 'black'
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral', lake_color='aqua')
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '3':
m.shadedrelief()
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '4':
m.bluemarble()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
elif mapstyle == '5':
m.etopo()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
if os.path.isfile(sitearq) == True:
xpt, ypt = m(sites['lon'], sites['lat'])
m.plot(xpt, ypt, 'bo')
CS = m.nightshade(datas1.datetime, alpha=0.2)
a, b = m(lon.value, stars[idx].dec.value)
a = a * u.m
b = b * u.m
dista = (dist[idx].to(u.km) * ca[idx].to(u.rad)).value * u.km
disterr = (dist[idx].to(u.km) * erro.to(u.rad)).value * u.km
ax = a + dista * np.sin(pa[idx]) + (deltatime * vel[idx]) * np.cos(pa[idx])
by = b + dista * np.cos(pa[idx]) - (deltatime * vel[idx]) * np.sin(pa[idx])
m.plot(ax, by, 'o', color=ptcolor, markersize=mapsize[0].value * 20 / 46)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value,
mapsize[1].to(u.imperial.inch).value)
plt.title(
'-{} D={}- dots each 60 s <> offsets (mas): obj=({:.1f},{:.1f}), star=({:.1f},{:.1f})\n'
.format(obj, tamanho, ob_off_ra[idx].value, ob_off_de[idx].value,
st_off_ra[idx].value, st_off_de[idx].value),
fontsize=mapsize[0].value * 25 / 46,
fontproperties='FreeMono',
weight='bold')
plt.xlabel(
'\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
.format(datas1.iso, int(stars[idx].ra.hms.h), int(stars[idx].ra.hms.m),
stars[idx].ra.hms.s, int(stars[idx].dec.dms.d),
np.absolute(int(stars[idx].dec.dms.m)),
np.absolute(stars[idx].dec.dms.s), ca[idx].value,
pa[idx].value, vel[idx].value, dist[idx].value, magR[idx],
magK[idx], longi[idx]),
fontsize=mapsize[0].value * 21 / 46,
fontproperties='FreeMono',
weight='bold')
plt.savefig('{}_{:05d}.png'.format(obj,
np.where(g == delt)[0][0] + 1),
dpi=100)
print 'Gerado: {}_{:05d}.png'.format(obj, np.where(g == delt)[0][0] + 1)
plt.clf()
def geramapa(idx):
lon = stars[idx].ra - datas[idx].sidereal_time('mean', 'greenwich')
m = Basemap(projection='ortho',
lat_0=stars[idx].dec.value,
lon_0=lon.value,
resolution='l')
# draw coastlines, country boundaries, fill continents.
m.shadedrelief()
m.drawcoastlines(linewidth=0.25)
m.drawcountries(linewidth=0.4)
m.drawstates(linewidth=0.4)
#m.fillcontinents(color='coral',lake_color='aqua')
# draw the edge of the map projection region (the projection limb)
#m.drawmapboundary(fill_color='aqua')
# draw lat/lon grid lines every 30 degrees.
m.drawmeridians(np.arange(0, 360, 30))
m.drawparallels(np.arange(-90, 90, 30))
if os.path.isfile(sitearq) == True:
xpt, ypt = m(sites['lon'], sites['lat'])
m.plot(xpt, ypt, 'bo')
CS = m.nightshade(datas[idx].datetime, alpha=0.2)
a, b = m(lon.value, stars[idx].dec.value)
a = a * u.m
b = b * u.m
dista = (dist[idx].to(u.km) * ca[idx].to(u.rad)).value * u.km
disterr = (dist[idx].to(u.km) * erro.to(u.rad)).value * u.km
ax = a + dista * np.sin(pa[idx])
ax2 = ax + 1000 * u.km * vec * np.cos(pa[idx])
ax3 = ax2 - tamanho / 2 * np.sin(pa[idx])
ax4 = ax2 + tamanho / 2 * np.sin(pa[idx])
ax5 = a + (dista - disterr) * np.sin(pa[idx]) + 1000 * u.km * vec * np.cos(
pa[idx])
ax6 = a + (dista + disterr) * np.sin(pa[idx]) + 1000 * u.km * vec * np.cos(
pa[idx])
by = b + dista * np.cos(pa[idx])
by2 = by - 1000 * u.km * vec * np.sin(pa[idx])
by3 = by2 - tamanho / 2 * np.cos(pa[idx])
by4 = by2 + tamanho / 2 * np.cos(pa[idx])
by5 = b + (dista - disterr) * np.cos(pa[idx]) - 1000 * u.km * vec * np.sin(
pa[idx])
by6 = b + (dista + disterr) * np.cos(pa[idx]) - 1000 * u.km * vec * np.sin(
pa[idx])
m.plot(ax, by, 'ro', markersize=20)
m.plot(ax2.to(u.m), by2.to(u.m), 'ro', markersize=8)
m.plot(ax3.to(u.m), by3.to(u.m), 'b')
m.plot(ax4.to(u.m), by4.to(u.m), 'b')
m.plot(ax5.to(u.m), by5.to(u.m), 'r--')
m.plot(ax6.to(u.m), by6.to(u.m), 'r--')
fig = plt.gcf()
fig.set_size_inches(18.0, 15.0)
plt.title(
'-{} D={}- dots each 1000km or {:.2f} <> offsets (mas): {:.1f}, {:.1f}\n'
.format(obj, tamanho, np.absolute(1000 * u.km / vel[idx]),
off_ra[idx].value, off_de[idx].value),
fontsize=25,
fontproperties='FreeMono')
plt.xlabel(
'\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
.format(datas[idx].iso, dados['afh'][idx], dados['afm'][idx],
dados['afs'][idx], dados['ded'][idx], dados['dem'][idx],
dados['des'][idx], ca[idx].value, pa[idx].value,
dados['vel'][idx], dist[idx].value, dados['mR'][idx],
dados['mK'][idx], dados['long'][idx]),
fontsize=21,
fontproperties='FreeMono')
plt.savefig('{}_{}.png'.format(obj, datas[idx].isot), dpi=100)
print 'Gerado: {}_{}.png'.format(obj, datas[idx].isot)
plt.clf()
# your code here # <headingcell level=1> # Advanced Features # <codecell> from datetime import datetime m = Basemap(projection='mill', lon_0=180) m.drawmapboundary(fill_color='royalblue') m.drawcoastlines() m.fillcontinents() m.drawcountries() CS = m.nightshade(datetime.utcnow()) # <headingcell level=2> # Great circles # <codecell> from mpl_toolkits.basemap import Basemap import numpy as np import matplotlib.pyplot as plt # setup lambert azimuthal map projection. # create new figure fig=plt.figure() m = Basemap(llcrnrlon=-100.,llcrnrlat=20.,urcrnrlon=20.,urcrnrlat=60.,\
def geramapa(star,
data,
title,
labelx,
nameimg,
mapstyle='1',
resolution='l',
centermap=None,
lats=None,
erro=None,
ring=None,
atm=None,
clat=None,
sitearq=None,
fmt='png',
dpi=100,
mapsize=None):
lon = star.ra - data.sidereal_time('mean', 'greenwich')
center_map = EarthLocation(lon.value, star.dec.value)
if not centermap == None:
center_map = EarthLocation(centermap[0], centermap[1])
m = Basemap(projection='ortho',
lat_0=center_map.latitude.value,
lon_0=center_map.longitude.value,
resolution=resolution)
# m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution,llcrnrx=-2000000.,llcrnry=-1500000.,urcrnrx=2000000.,urcrnry=1500000.)
# kx = fig.add_axes([-0.003,-0.001,1.006,1.002])
# kx.set_rasterization_zorder(1)
m.nightshade(data.datetime, alpha=0.2, zorder=0.5)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0, 360, 30))
m.drawparallels(np.arange(-90, 90, 30))
m.drawmapboundary()
style = {
'1': {
'ptcolor': 'red',
'lncolor': 'blue',
'ercolor': 'blue',
'rncolor': 'blue',
'atcolor': 'blue'
},
'2': {
'ptcolor': 'red',
'lncolor': 'blue',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black'
},
'3': {
'ptcolor': 'red',
'lncolor': 'blue',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black'
},
'4': {
'ptcolor': 'red',
'lncolor': 'red',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black'
},
'5': {
'ptcolor': 'red',
'lncolor': 'red',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black'
}
}
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral', lake_color='aqua')
elif mapstyle == '3':
m.shadedrelief()
elif mapstyle == '4':
m.bluemarble()
elif mapstyle == '5':
m.etopo()
if not lats == None:
xs, ys = m(lats[0], lats[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['lncolor'])
xt, yt = m(lats[2], lats[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['lncolor'])
if not erro == None:
xs, ys = m(erro[0], erro[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['ercolor'])
xt, yt = m(erro[2], erro[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['ercolor'])
if not ring == None:
xs, ys = m(ring[0], ring[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['rncolor'])
xt, yt = m(ring[2], ring[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['rncolor'])
if not atm == None:
xs, ys = m(atm[0], atm[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['atcolor'])
xt, yt = m(atm[2], atm[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['atcolor'])
if not clat == None:
xc, yc = m(clon, clat)
labe = [lab[i] for i in np.arange(len(lab)) if xc[i] < 1e+30]
xc = [i for i in xc if i < 1e+30]
yc = [i for i in yc if i < 1e+30]
m.plot(xc, yc, 'o', color=style[mapstyle]['ptcolor'])
# m.plot(ax,by, 'o', color=ptcolor, markersize=int(mapsize[0].value*20/46))
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=int(mapsize[0].value*12/46))
# m.plot(ax3.to(u.m), by3.to(u.m), color='red')
# m.plot(ax4.to(u.m), by4.to(u.m), color='red')
# m.quiver(a-0*u.m,b-600000*u.m, 20, 0, width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
#
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
# for label, axpt, bypt in zip(labe, xc, yc):
# kx.text(axpt + 0, bypt + 350000, label, rotation=60, weight='bold')
# if os.path.isfile(sitearq) == True:
# xpt,ypt = m(sites['lon'],sites['lat'])
# m.plot(xpt,ypt,'bo')
# offset = [[xpt[0] + 100000,xpt[0] + 100000,xpt[0] + 100000,xpt[3] + 400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000],[10000,-30000,-60000,70000,30000,-20000,-70000,-30000,-70000]]
# for i in np.arange(len(xpt)):
# ax.text(offset[0][i],ypt[i]+offset[1][i],sites['nome'][i], weight='bold')
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value,
mapsize[1].to(u.imperial.inch).value)
plt.title(title,
fontsize=mapsize[0].value * 25 / 46,
fontproperties='FreeMono',
weight='bold')
plt.xlabel(labelx,
fontsize=mapsize[0].value * 21 / 46,
fontproperties='FreeMono',
weight='bold')
plt.savefig('{}.{}'.format(nameimg, fmt), format=fmt, dpi=dpi)
print 'Gerado: {}.{}'.format(nameimg, fmt)
plt.clf()
def __init__(self, in_file,
vg_files = [1],
data_type = 1,
projection = 'cyl',
color_map = 'jet',
face_colour = "white",
time_zone = 0,
filled_contours = False,
plot_contours = False,
plot_center = 't',
plot_meridians = True,
plot_parallels = True,
plot_nightshade = True,
resolution = 'c',
points_of_interest = [],
save_file = '',
run_quietly = False,
dpi = 150,
parent = None,
datadir=None):
self.run_quietly = run_quietly
self.dpi=float(dpi)
self.datadir = datadir
try:
plot_parameters = VOAFile((in_file))
plot_parameters.parse_file()
except zipfile.BadZipFile as e:
if parent is None:
print("Invalid .vgz file")
sys.exit(1)
if (plot_parameters.get_projection() != 'cyl'):
print(_("Error: Only lat/lon (type 1) input files are supported"))
sys.exit(1)
grid = plot_parameters.get_gridsize()
self.image_defs = VOAAreaPlot.IMG_TYPE_DICT[int(data_type)]
# TODO This needs a little more work... what if the pcenter card is not specified
if plot_center == 'p':
plot_centre_location = plot_parameters.get_location(plot_parameters.P_CENTRE)
else:
plot_centre_location = plot_parameters.get_location(plot_parameters.TX_SITE)
self.points_of_interest = [plot_centre_location]
if len(points_of_interest) > 0:
self.points_of_interest.extend(points_of_interest)
imageBuf = np.zeros([grid, grid], float)
area_rect = plot_parameters.get_area_rect()
# The checks ought to be performed in the area_rect.
# Do a few basic sanity checks #
#if ( (area_rect.get_sw_lon() < -180) or (area_rect.get_ne_lon() > 180.0) or (area_rect.get_sw_lat() < -90) or (area_rect.get_ne_lat() > 90.0) ):
# print "Input file latitudes/longitudes are out of range"
# print "-180 < Latitude < 180.0, -90 < Longitude < 90"
# sys.exit(1)
#if ( (area_rect.get_sw_lon() == area_rect.get_ne_lon()) or (area_rect.get_sw_lat() == area_rect.get_ne_lat()) ):
# print "Input file latitudes/longitudes are the same"
# print "-180 < Latitude < 180.0, -90 < Longitude < 90"
# sys.exit(1)
colString = 'matplotlib.cm.'+color_map
colMap = eval(colString)
self.subplots = []
self.number_of_subplots = len(vg_files)
matplotlib.rcParams['axes.edgecolor'] = 'gray'
matplotlib.rcParams['axes.facecolor'] = 'white'
matplotlib.rcParams['figure.facecolor'] = face_colour
#matplotlib.rcParams['figure.figsize'] = (6, 10)
matplotlib.rcParams['figure.subplot.hspace'] = 0.45
matplotlib.rcParams['figure.subplot.wspace'] = 0.35
matplotlib.rcParams['figure.subplot.right'] = 0.85
colorbar_fontsize = 12
if self.number_of_subplots <= 1:
self.num_rows = 1
self.main_title_fontsize = 24
matplotlib.rcParams['legend.fontsize'] = 12
matplotlib.rcParams['axes.labelsize'] = 12
matplotlib.rcParams['axes.titlesize'] = 10
matplotlib.rcParams['xtick.labelsize'] = 10
matplotlib.rcParams['ytick.labelsize'] = 10
matplotlib.rcParams['figure.subplot.top'] = 0.8 # single figure plots have a larger title so require more space at the top.
elif ((self.number_of_subplots >= 2) and (self.number_of_subplots <= 6 )):
self.num_rows = 2
self.main_title_fontsize = 18
matplotlib.rcParams['legend.fontsize'] = 10
matplotlib.rcParams['axes.labelsize'] = 10
matplotlib.rcParams['axes.titlesize'] = 11
matplotlib.rcParams['xtick.labelsize'] = 8
matplotlib.rcParams['ytick.labelsize'] = 8
#self.x_axes_ticks = P.arange(0,25,4)
else:
self.num_rows = 3
self.main_title_fontsize = 16
matplotlib.rcParams['legend.fontsize'] = 8
matplotlib.rcParams['axes.labelsize'] = 8
matplotlib.rcParams['axes.titlesize'] = 10
matplotlib.rcParams['xtick.labelsize'] = 6
matplotlib.rcParams['ytick.labelsize'] = 6
#self.x_axes_ticks = P.arange(0,25,4)
self.num_cols = int(math.ceil(float(self.number_of_subplots)/float(self.num_rows)))
self.fig=Figure()
self.main_title_label = self.fig.suptitle(str(self.image_defs['title']), fontsize=self.main_title_fontsize)
if projection == 'ortho':
self.show_subplot_frame = False
for plot_ctr, vg_file in enumerate(vg_files):
points = np.zeros([grid,grid], float)
lons = np.arange(area_rect.get_sw_lon(), area_rect.get_ne_lon()+0.001,(area_rect.get_ne_lon()-area_rect.get_sw_lon())/float(grid-1))
lons[-1] = min(180.0, lons[-1])
lats = np.arange(area_rect.get_sw_lat(), area_rect.get_ne_lat()+0.001,(area_rect.get_ne_lat()-area_rect.get_sw_lat())/float(grid-1))
lats[-1] = min(90.0, lats[-1])
ax = self.fig.add_subplot(self.num_rows,
self.num_cols,
plot_ctr+1,
frame_on = self.show_subplot_frame,
axisbg = 'white')
self.subplots.append(ax)
ax.label_outer()
if in_file.endswith('.vgz'):
base_filename = get_base_filename(in_file)
zf = zipfile.ZipFile(in_file)
vgFile = io.TextIOWrapper(zf.open("{:s}.vg{:d}".format(base_filename, vg_file)), 'utf-8')
else:
vgFile = open("{:s}.vg{:d}".format(os.path.splitext(in_file)[0], vg_file))
pattern = re.compile(r"[a-z]+")
for line in vgFile:
match = pattern.search( line )
if not match:
value = float(line[int(self.image_defs['first_char']):int(self.image_defs['last_char'])])
# TODO Does this need to be normalised here if it's also being done in the plot?
value = max(self.image_defs['min'], value)
value = min(self.image_defs['max'], value)
points[int(line[3:6])-1][int(line[0:3])-1] = value
vgFile.close()
if 'zf' in locals():
zf.close()
m_args={}
if projection in ('cyl', 'mill', 'gall'):
m_args.update({"llcrnrlon":area_rect.get_sw_lon(),
"llcrnrlat":area_rect.get_sw_lat(),
"urcrnrlon":area_rect.get_ne_lon(),
"urcrnrlat":area_rect.get_ne_lat()})
if projection in ('robin', 'vandg', 'sinu', 'mbtfpq', 'eck4',
'kav7', 'moll', 'hammer', 'gnom',
'laea', 'aeqd', 'cea', 'merc'):
m_args.update({"lat_0":plot_centre_location.get_latitude(),
"lon_0":plot_centre_location.get_longitude()})
if projection in ('cea', 'merc'):
m_args['lat_ts']=0
m = Basemap(ax=ax, projection=projection, resolution=resolution, **m_args)
m.drawcoastlines(color='black')
m.drawcountries(color='grey')
m.drawmapboundary(color='black', linewidth=1.0)
#points = np.clip(points, self.image_defs['min'], self.image_defs['max'])
#colMap.set_under(color ='k', alpha=0.0)
lons, lats = np.meshgrid(lons, lats)
points = np.clip(points, self.image_defs['min'], self.image_defs['max'])
if (filled_contours):
im = m.contourf(lons, lats, points, self.image_defs['y_labels'],
latlon=True,
cmap = colMap)
plot_contours = True
else:
im = m.pcolormesh(lons, lats, points,
latlon=True,
vmin = self.image_defs['min'],
vmax = self.image_defs['max'],
cmap = colMap,
shading='gouraud')
if plot_contours:
ct = m.contour(lons, lats, points, self.image_defs['y_labels'][1:],
latlon=True,
linestyles='solid',
linewidths=0.5,
colors='k',
vmin=self.image_defs['min'],
vmax=self.image_defs['max'] )
#######################
# Plot greyline
#######################
if plot_nightshade:
m.nightshade(plot_parameters.get_daynight_datetime(vg_files[plot_ctr]-1))
##########################
# Points of interest
##########################
for location in self.points_of_interest:
if area_rect.contains(location.get_latitude(), location.get_longitude()):
xpt,ypt = m(location.get_longitude(),location.get_latitude())
ax.plot([xpt],[ypt],'ro')
ax.text(xpt+100000,ypt+100000,location.get_name())
if plot_meridians:
if (area_rect.get_lon_delta() <= 90.0):
meridians = np.arange(-180, 190.0, 10.0)
elif (area_rect.get_lon_delta() <= 180.0):
meridians = np.arange(-180.0, 210.0, 30.0)
else:
meridians = np.arange(-180, 240.0, 60.0)
if ((projection == 'ortho') or (projection == 'vandg')):
m.drawmeridians(meridians)
else:
m.drawmeridians(meridians,labels=[1,1,0,1])
if plot_parallels:
if (area_rect.get_lat_delta() <= 90.0):
parallels = np.arange(-90.0, 120.0, 60.0)
else:
parallels = np.arange(-90.0, 120.0, 30.0)
if ((projection == 'ortho') or (projection == 'vandg')):
m.drawparallels(parallels)
else:
m.drawparallels(parallels,labels=[1,1,0,1])
#add a title
title_str = plot_parameters.get_plot_description_string(vg_files[plot_ctr]-1, self.image_defs['plot_type'], time_zone)
if self.number_of_subplots == 1:
title_str = plot_parameters.get_plot_description_string(vg_files[plot_ctr]-1, self.image_defs['plot_type'], time_zone)
title_str = title_str + "\n" + plot_parameters.get_detailed_plot_description_string(vg_files[plot_ctr]-1)
else :
title_str = plot_parameters.get_minimal_plot_description_string(vg_files[plot_ctr]-1, self.image_defs['plot_type'], time_zone)
self.subplot_title_label = ax.set_title(title_str)
# Add a colorbar on the right hand side, aligned with the
# top of the uppermost plot and the bottom of the lowest
# plot.
# create an axes on the right side of ax. The width of cax will be 5%
# of ax and the padding between cax and ax will be fixed at 0.05 inch.
if self.number_of_subplots > 1:
self.cb_ax = self.fig.add_axes(self.get_cb_axes())
else:
divider = make_axes_locatable(ax)
self.cb_ax = divider.append_axes("right", size="5%", pad=0.05)
self.fig.colorbar(im, cax=self.cb_ax,
orientation='vertical',
ticks=self.image_defs['y_labels'],
format = FuncFormatter(eval('self.'+self.image_defs['formatter'])))
#print self.image_defs['y_labels']
for t in self.cb_ax.get_yticklabels():
t.set_fontsize(colorbar_fontsize)
#self.fig.tight_layout()
canvas = FigureCanvas(self.fig)
self.fig.canvas.mpl_connect('draw_event', self.on_draw)
canvas.show()
if save_file :
self.save_plot(canvas, save_file)
#todo this ought to a command line param
if not self.run_quietly:
dia = VOAPlotWindow('pythonProp - ' + self.image_defs['title'], canvas, parent=parent, datadir=self.datadir)
return
def FoV_selections(sim_file,
lattice_files,
datetime,
centre,
map_bkgd='bluemarble',
out='show',
**mission_params):
"""
Plots the fields of view chosen by the intelligent pointing algorithm onto a map.
Args:
- sim_file: GMAT output file path to use
- lattice_files: list - List of lattice files used for the mission
- datetime: dt.datetime instance - Time at which to plot points
- center: tuple: (latitude, longitude) to be used as the center of an orthographic projection
- map_bkgd: Background to plot on the map
- out: either 'save' or 'show. Saves or shows the figure
mission_params:
- kwargs for retrievals.Mission instance.
"""
mission = retrievals.Mission(sim_file, *lattice_files, **mission_params)
obs_time = time_utils.Time(datetime, mission.satellite.times[0].ref)
# find the closest apogee point to obs_time
apogees = mission.satellite.get_apogees()
apogee_ind = time_utils.closest_index(obs_time, apogees)
# create the ObservationPeriod instance, and generate the Retrieval instances
obs = retrievals.ObservationPeriod(
mission, apogees[apogee_ind],
mission.lattice_files[apogee_ind % len(lattice_files)])
obs.main_filter()
obs.generate_retrievals()
print(len(obs.retrievals))
# find the closest segment of the observation period
obs_ind = time_utils.closest_index(obs_time, obs.obs_middle)
proj_cld = Basemap(projection='ortho',
lat_0=centre[0],
lon_0=centre[1],
resolution='c')
proj_cld.drawcoastlines()
proj_cld.drawcountries()
# draw cloud data that was used to determine FOV locations
obs.cloud_collection.show_clouds_ortho(obs.cloud_times[obs_ind],
centre,
map_bkgd=map_bkgd,
out='')
proj_cld.nightshade(datetime)
# draw a red border around each of the selected FOVs
for ret in obs.retrievals[obs_ind]:
lats = np.concatenate([
ret.pixel_lats[:, 0], ret.pixel_lats[-1, :],
ret.pixel_lats[::-1, -1], ret.pixel_lats[0, ::-1]
])
lons = np.concatenate([
ret.pixel_lons[:, 0], ret.pixel_lons[-1, :],
ret.pixel_lons[::-1, -1], ret.pixel_lons[0, ::-1]
])
x, y = proj_cld(lons, lats)
coords = np.vstack([x, y]).T
if not np.sum(coords > 1e15):
p = Polygon(coords, fill=False, edgecolor='r', zorder=10)
plt.gca().add_patch(p)
plt.title('FoV Selections {0} - {1} UTC'.format(
obs.obs_times[obs_ind].strf('%d %B %Y %H:%M'),
obs.obs_times[obs_ind + 1].strf('%H:%M')))
if out == 'show':
plt.show()
elif out == '':
pass
else:
plt.savefig(out)
plt.close()
def plt_map(df, t0, tend, dt, out_path_map, data_dir):
tmp_t = t0
t = [0, 0]
while (tmp_t < tend):
time_loop0 = datetime.datetime.now()
# print tmp_t
t1 = tmp_t
t2 = tmp_t + datetime.timedelta(minutes=dt)
print t1, t2
#Sort the data by band and time, then group by band.
srt = df.sort(['band', 'timestamp'])
grouped = srt.groupby('band')
# condition for selecting
cond0 = ((df['timestamp'] > t1) & (df['timestamp'] < t2))
# (df['rx_lat'] > 30) & (df['rx_lat'] < 70) &
# (df['tx_lat'] > 30) & (df['tx_lat'] < 70) &
# (df['rx_lon'] < 50) & (df['rx_lon'] > -20) &
# (df['tx_lon'] < 50) & (df['tx_lon'] > -20) )
# Set up a dictionary which identifies which bands we want and some plotting attributes for each band
bands = {}
bands[50] = {'name': '6 m / 50 MHz', 'color': 'red', 'i': 7, 'f': 50}
bands[28] = {'name': '10 m / 28 MHz', 'color': 'pink', 'i': 5, 'f': 28}
bands[21] = {
'name': '15 m / 21 MHz',
'color': 'orange',
'i': 3,
'f': 21
}
bands[14] = {
'name': '20 m / 14 MHz',
'color': 'yellow',
'i': 1,
'f': 14
}
bands[10] = {
'name': '30 m / 10 MHz',
'color': 'green',
'i': 6,
'f': 10
}
bands[7] = {'name': '40 m / 7 MHz', 'color': 'blue', 'i': 4, 'f': 7}
bands[3] = {
'name': '80 m / 3.5 MHz',
'color': 'purple',
'i': 2,
'f': 3
}
bands[1] = {
'name': '160 m / 1.5 MHz',
'color': 'black',
'i': 0,
'f': 1
}
# Determine the aspect ratio of each histogram.
xsize = 10.
ysize = 2.5
nx_plots = 2 # Let's just do 1 panel across.
ny_plots = len(
bands.keys()
) # But we will do a stackplot with one panel for each band of interest.
fig = plt.figure(
figsize=(nx_plots * xsize, ny_plots *
ysize)) # Create figure with the appropriate size.
subplot_nr = 0 # Counter for the subplot
xrng = (0, 5000)
#make a color map
# from http://stackoverflow.com/questions/9707676/defining-a-discrete-colormap-for-imshow-in-matplotlib
colorList = [bands[x]['color'] for x in sorted(bands.keys())]
cmap = colors.ListedColormap(colorList)
bounds = [np.int(bands[x]['f']) for x in sorted(bands.keys())]
bounds.insert(0, 0)
norm = colors.BoundaryNorm(bounds, cmap.N)
cmap.set_over('0.25')
cmap.set_under('0.75')
# make basemap
fig2 = plt.figure(figsize=(8, 8))
gs = grd.GridSpec(2,
2,
width_ratios=[50, 1],
height_ratios=[1, 1],
wspace=0.1,
hspace=0.25)
ax2 = plt.subplot(gs[0])
ax3 = plt.subplot(gs[1])
m = Basemap(llcrnrlon=-179.,llcrnrlat=-80.,urcrnrlon=179.,urcrnrlat=80,\
rsphere=(6378137.00,6356752.3142),\
resolution='i',projection='merc',\
ax=ax2)
m.drawcountries()
m.drawcoastlines()
m.drawstates()
m.fillcontinents(color='#bbbbbf')
CS = m.nightshade(t1)
# draw parallels
m.drawparallels(np.arange(-90, 90, 10), labels=[1, 1, 0, 1])
# draw meridians
m.drawmeridians(np.arange(-180, 180, 20), labels=[1, 1, 0, 1])
ax2.set_title('WSPR Map: ' + t1.strftime('%d %b %Y %H%M UT - ') +
t2.strftime('%d %b %Y %H%M UT'))
cb1 = mpl.colorbar.ColorbarBase(ax3,
cmap=cmap,
norm=norm,
boundaries=bounds,
spacing='uniform',
orientation='vertical')
cb1.set_label('Frequency (MHz)')
plot_time = datetime.datetime.utcnow()
txt_2 = ('Plotted: ' + plot_time.strftime('%d %b %Y %H%M UT'))
ax2.set_xlabel('\n' + txt_2)
gs00 = grd.GridSpecFromSubplotSpec(4, 2, subplot_spec=gs[2])
#sys.exit()
# want to include shareex somewhere in here...?
for band_key in sorted(bands.keys(
)): # Now loop through the bands and create 1 histogram for each.
#subplot_nr += 1 # Increment subplot number... it likes to start at 1.# do the calculation, cond0 is defined above
subplot_nr = np.int(bands[band_key]['i'])
print band_key, subplot_nr
ax = plt.Subplot(fig2, gs00[subplot_nr])
# ax = fig2.add_subplot(ny_plots,nx_plots,subplot_nr)
fig2.add_subplot(ax)
dist = grouped.get_group(band_key)['dist'][cond0]
bins_in = np.arange(0, 5000, 200)
hist, bins_out = np.histogram(dist, bins=bins_in)
#code from: http://stackoverflow.com/questions/17874063/is-there-a-parameter-in-matplotlib-pandas-to-have-the-y-axis-of-a-histogram-as-p
ax.bar(bins_out[:-1],
hist.astype(np.float32),
width=(bins_out[1] - bins_out[0]),
color=bands[band_key]['color'],
label=bands[band_key]['name'])
ax.set_ylim(0, 30)
# grouped.get_group(band_key)['dist'][cond0].hist(bin=bins_in,norm=True,
# ax=ax,color=bands[band_key]['color'],label=bands[band_key]['name']) #Pandas has a built-in wrapper for the numpy and matplotlib histogram function.
ax.legend(loc='upper right')
ax.set_xlim(xrng)
ax.set_ylabel('WSPR Spots (#)')
tx_lon = grouped.get_group(band_key)['tx_lon'][cond0].values
rx_lon = grouped.get_group(band_key)['rx_lon'][cond0].values
tx_lat = grouped.get_group(band_key)['tx_lat'][cond0].values
rx_lat = grouped.get_group(band_key)['rx_lat'][cond0].values
if (subplot_nr == 0) | (subplot_nr == 1):
txt = []
txt.append('WSPRNet Distances')
txt.append(
t1.strftime('%d %b %Y %H%M UT - ') +
t2.strftime('%d %b %Y %H%M UT'))
ax.set_title(
'\n'.join(txt)
) #\n creates a new line... here I'm joining two strings in a list to form a single string with \n as the joiner
if subplot_nr == len(bands.keys()):
txt_2 = ('Plotted: ' + plot_time.strftime('%d %b %Y %H%M UT'))
ax.set_xlabel('WSPR Reported Distance [km]' + txt_2)
# setup mercator map projection.
print tx_lon
map(partial(m.drawgreatcircle, color=bands[band_key]['color']),
tx_lon, tx_lat, rx_lon, rx_lat)
#fig2.tight_layout() #This often cleans up subplot spacing when you have multiple panels.
# filename = os.path.join(out_path_hist,'%s.png' % t1.strftime('%H%MUT_WSPRHist') )
#sys.exit()
#fig.savefig(filename)#,bbox_inches='tight') # bbox_inches='tight' removes whitespace at the edge of the figure. Very useful when creating PDFs for papers.
file_map = os.path.join(out_path_map,
'%s.png' % t1.strftime('%m%d_%H%MUT')) #Y%m%d
fig2.savefig(file_map) #, bbox_inches='tight')
plt.close('all')
tmp_t = tmp_t + datetime.timedelta(minutes=dt)
# os.chdir(out_path_map)
# call(['ffmpeg', '-framerate', '4','-pattern_type','glob','-i', '*.png',
# '-s:v','1280x720','-c:v','libx264','-profile:v','high',
# '-crf','23','-pix_fmt','yuv420p','-r','30','%s.mp4'% t1.strftime('%m%d')])
#
# os.chdir(data_dir)
# out_files = os.path.join(out_path_hist,'*.png')
# out_mov = os.path.join(out_path_hist,'test.mp4')
# command1 = 'ffmpeg -framerate 4 -pattern_type glob -i '+out_files+' -s:v 1280x720 -c:v libx264 -profile:v high -crf 23 -pix_fmt yuv420p -r 30 '+ out_mov
# call(command1, shell=True)
time_1 = datetime.datetime.now()
print 'Total processing time is %.1f s.' % (time_1 -
time_0).total_seconds()
return None
def animate_FoV(sim_file, lattice_files, date_range, map_bkgd='mask', out='show', **mission_params):
print("animate_FOV")
assert type(sim_file) == str
assert type(lattice_files) == list
assert type(date_range) == tuple
"""
Creates an animation (avi file) of field-of-view selections and cloud cover over time for one satellite.
Args:
- sim_file: GMAT output file path to use
- lattice_file: list - List of lattice files used for the mission. Must be given in order of W-E, starting with the first apogee
- date_range: tuple of dt.datetime instances - (start time, end time) tuple for the animation. Requires year, month, day, hour.
- map_bkgd: Background to plot on the map
- out: either 'save' or 'show. Saves or shows the figure
mission_params:
- kwargs for retrievals.Mission instance.
"""
# Set up the mission instance and find the apogees
mission = retrievals.Mission(sim_file, *lattice_files, **mission_params)
apogees = mission.satellite.get_apogees()
# Get the start and end times and convert them from dt.datetime instances to time_utils.Time instances
start_time = time_utils.Time(date_range[0], mission.satellite.times[0].ref)
end_time = time_utils.Time(date_range[1], mission.satellite.times[0].ref)
# Get the indices of the first and last apogees relevant to the time period
apogee_start_ind = time_utils.closest_index(start_time, apogees)
apogee_last_ind = time_utils.closest_index(end_time, apogees)
# Empty directory to store temporary images before making the animation
temp_dir = '../figures/animation_temp'
if not os.path.exists(temp_dir):
os.mkdir(temp_dir)
# Generate a retrievals.ObservationPeriod instance for every apogee in the relevant time frame
for k in range(apogee_start_ind, apogee_last_ind + 1):
# create the ObservationPeriod instance, and generate the Retrieval instances
if lattice_files == []:
lat_file = None
else:
lat_file = mission.lattice_files[k%len(lattice_files)]
obs = retrievals.ObservationPeriod(mission, apogees[k], lat_file)
obs.main_filter()
obs.generate_retrievals()
# after this point we're just plotting stuff, no actual analysis
col = 'xkcd:red'
lat_0 = 90
lon_0 = -95
map_params = {"projection": 'ortho',
"lat_0": lat_0,
"lon_0": lon_0,
"resolution": 'c'}
# Plot cloud data and pointing selections for each segment of each observation period
for i in range(len(obs.retrievals)):
proj_cld = Basemap(**map_params)
# draw cloud data that was used to determine FOV locations
obs.cloud_collection.show_clouds_ortho(
obs.cloud_times[i], (lat_0, lon_0), map_bkgd=map_bkgd, out='')
# Draw terminator
proj_cld.nightshade(
obs.obs_times[i].to_datetime64().astype(dt.datetime))
# Draw a bullseye at the sub-satellite point
satx, saty = proj_cld(obs.satlon[i], obs.satlat[i])
inner = Circle(
(satx,saty), radius=9e4, color=col, zorder=10)
outer = Circle(
(satx,saty), radius=2e5, linewidth=1.5, facecolor = 'k',
edgecolor=col, zorder = 10 )
plt.gca().add_patch(outer)
plt.gca().add_patch(inner)
for ret in obs.retrievals[i]:
# draw a border around each of the selected FOVs
lats = np.concatenate([ret.pixel_lats[:,0],
ret.pixel_lats[-1,:],
ret.pixel_lats[::-1,-1],
ret.pixel_lats[0,::-1]])
lons = np.concatenate([ret.pixel_lons[:,0],
ret.pixel_lons[-1,:],
ret.pixel_lons[::-1,-1],
ret.pixel_lons[0,::-1]])
x,y = proj_cld(lons, lats)
coords = np.vstack([x,y]).T
if not np.sum(coords > 1e15):
p = Polygon(coords, fill=False, edgecolor=col, zorder=10,
antialiased = True)
plt.gca().add_patch(p)
plt.title('{0} - {1} UTC'.format(
obs.obs_times[i].strftime('%d %B %H:%M'),
obs.obs_times[i+1].strftime('%H:%M')))
# Save the figure in the temporary directory
fname = 'FoVs{0}.png'.format(
obs.obs_times[i].strftime('%y%m%d%H:%M'))
fpath = os.path.join(temp_dir, fname)
plt.savefig(fpath, dpi=500)
print('Saved figure: {0}-{1}.png'.format(
obs.obs_times[i].strftime('%m%d%Y%H:%M'),
obs.obs_times[i+1].strftime('%H:%M')))
#plt.show()
plt.close()
# Create an animation using all the temporary images
os.system(('mencoder -o '
'../figures/constellationview_{0}_{1}.avi '
'mf://../figures/animation_temp/FoVs*.png '
'-ovc lavc -lavcopts vcodec=msmpeg4v2 -mf '
'fps=2').format(start_time.strftime('%y%m%d'),
end_time.strftime('%y%m%d')))
# Delete the temporary images
os.system('rm ../figures/animation_temp/*.png')
os.system('rmdir ../figures/animation_temp')
def polar_quiver_wind(self, ax, ns='N'):
# Wind vector in lat-long coordinates.
# For different map projections, the arithmetics to calculate xywind
# are different
if self.empty:
return
from mpl_toolkits.basemap import Basemap
from apexpy import Apex
# Creat polar coordinates
projection, fc = ('npstere', 1) if ns == 'N' else ('spstere', -1)
m = Basemap(projection=projection,
boundinglat=fc * 40,
lon_0=0,
resolution='l')
m.drawcoastlines(color='gray', zorder=1)
m.fillcontinents(color='lightgray', zorder=0)
dt = self.index.min() + (self.index.max() - self.index.min()) / 2
m.nightshade(dt, zorder=2)
#m.drawparallels(np.arange(-80,81,20))
#m.drawmeridians(np.arange(-180,181,60),labels=[1,1,1,1])
# Calculate mlat and mlon
lat_grid = np.arange(-90, 91, 10)
lon_grid = np.arange(-180, 181, 10)
lon_grid, lat_grid = np.meshgrid(lon_grid, lat_grid)
gm = Apex(date=2005)
mlat, mlon = gm.convert(lat_grid, lon_grid, 'geo', 'apex')
hc1 = m.contour(lon_grid,
lat_grid,
mlat,
levels=np.arange(-90, 91, 10),
colors='k',
zorder=3,
linestyles='dashed',
linewidths=1,
latlon=True)
# hc2 = m.contour(lon_grid,lat_grid,mlon,levels=np.arange(-180,181,45),
# colors='k', zorder=3, linestyles='dashed', latlon=True)
plt.clabel(hc1, inline=True, colors='k', fmt='%d')
# plt.clabel(hc2,inline=True,colors='k',fmt='%d')
# Calculate and plot x and y winds
lat = self.lat
lon = self.long
wind = self.wind
winde1 = self.winde
winde = winde1 * wind
windn1 = self.windn
windn = windn1 * wind
# only appropriate for the npstere and spstere
xwind = fc * winde * np.cos(lon / 180 * np.pi) - windn * np.sin(
lon / 180 * np.pi)
ywind = winde * np.sin(lon / 180 * np.pi) + fc * windn * np.cos(
lon / 180 * np.pi)
hq = m.quiver(np.array(lon),
np.array(lat),
xwind,
ywind,
color='blue',
scale=300,
scale_units='inches',
zorder=3,
latlon=True)
#plt.quiverkey(hq,1.05,1.05,100,'100 m/s',coordinates='axes',labelpos='E')
#m.scatter(np.array(lon),np.array(lat),
# s=50, c=self.index.to_julian_date(),linewidths=0, zorder=4,latlon=True)
return m
def plotonmap(obs,
sun_lat,
sun_lon,
city_lat,
city_lon,
city,
projection='ortho',
redraw=False,
bluemarble=False):
if os.path.exists("movies/%s.mp4" % city):
return
filename = "images/%s/plot_%s_00.png" % (
city, obs.date.datetime().strftime("%Y%m%d"))
if not redraw and os.path.exists(filename):
return
else:
plt.style.use('dark_background')
plt.figure(figsize=(19.2, 10.80))
m = Basemap(projection=projection,
resolution='l',
lat_0=20,
lon_0=city_lon)
m.bluemarble()
# draw terminator
_ = m.nightshade(
obs.date.datetime(),
delta=0.7,
alpha=0.5,
)
# draw tropics and equator
draw_parallel(m,
23.5,
city_lon,
color='ivory',
label="Tropic of\nCancer")
draw_parallel(m,
-23.5,
city_lon,
color='ivory',
label="Tropic of\nCapricorn")
draw_parallel(m, 0, city_lon, color='ivory', label='Equator')
# mark city
citydot(m, city_lat, city_lon, 'white')
# mark sun position
sundot(m, sun_lat, sun_lon, 'y', label='subsolar')
draw_parallel(m, sun_lat, city_lon, color='yellow')
datestring = obs.date.datetime().strftime("%Y-%m-%d")
frames = 1
if '6-21' in datestring or '12-21' in datestring or '6-.8020' in datestring:
datestring += " Solstice"
frames = 20
if '3-19' in datestring or '9-23' in datestring:
datestring += " Equinox"
frames = 40
plt.annotate(datestring,
xy=(10, 10),
fontsize=20,
textcoords='data',
color='w')
plt.savefig(filename, transparent=True)
plt.close()
from PIL import Image
fg = Image.open(filename, 'r')
bg = Image.open('starfield.png', 'r')
text_img = Image.new('RGBA', (1920, 1080), (0, 0, 0, 0))
text_img.paste(bg, (0, 0))
text_img.paste(fg, (0, 0), mask=fg)
text_img.save(filename, format="png")
for x in range(1, frames):
filename2 = "images/%s/plot_%s_%02d.png" % (
city, obs.date.datetime().strftime("%Y%m%d"), x)
shutil.copyfile(filename, filename2)
def geramapa(star, data, title, labelx, nameimg, mapstyle='1', resolution='l', centermap=None, lats=None, erro=None, ring=None, atm=None, clat=None, sitearq='sites.dat', fmt='png', dpi=100, mapsize=None, cpoints=60, off=0):
lon = star.ra - data.sidereal_time('mean', 'greenwich')
center_map = EarthLocation(lon.value, star.dec.value)
fig = plt.figure(figsize=(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value))
if not centermap == None:
center_map = EarthLocation(centermap[0],centermap[1])
# m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution)
m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution,llcrnrx=-3500000.,llcrnry=-3717000.,urcrnrx=500000.,urcrnry=-413000.)
kx = fig.add_axes([0.105,0.1,0.894,0.894])
kx.set_rasterization_zorder(1)
m.nightshade(data.datetime, alpha=0.3, zorder=0.5) ## desenha a sombra da noite
m.drawcoastlines(linewidth=0.5) ## desenha as linhas da costa
m.drawcountries(linewidth=0.5) ## desenha os paises
# m.drawstates(linewidth=0.5) ## Desenha os estados
m.drawmeridians(np.arange(0,360,30)) ## desenha os meridianos
m.drawparallels(np.arange(-90,90,30)) ## desenha os paralelos
m.drawmapboundary() ## desenha o contorno do mapa
mapsstyle = {'STE' : 'blue', 'JPL' : 'red', '22fev' : 'black', '03mar' : 'green'}
pontos = {'STE' : '-', 'JPL' : '--', '22fev' : '-.', '03mar' : ':'}
style = {'1': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'blue', 'rncolor':'blue', 'atcolor':'blue', 'outcolor':'red'},
'2': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'},
'3': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'},
'4': {'ptcolor': 'red', 'lncolor': 'red', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'},
'5': {'ptcolor': 'red', 'lncolor': 'red', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'}}
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
elif mapstyle == '3':
m.shadedrelief()
elif mapstyle == '4':
m.bluemarble()
elif mapstyle == '5':
m.etopo()
for tipo in ['STE', 'JPL', '22fev', '03mar']:
# if not lats == None:
xs, ys = m(lats[tipo][0], lats[tipo][1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
# m.plot(xs, ys, color=mapsstyle[tipo])
xt, yt = m(lats[tipo][2], lats[tipo][3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
# m.plot(xt, yt, color=mapsstyle[tipo])
# m.plot(lats[tipo][4], lats[tipo][5], color=mapsstyle[tipo], zorder=-0.2)
# m.plot(lats[tipo][6], lats[tipo][7], color=mapsstyle[tipo], zorder=-0.2)
# else:
# m.plot(lats[4], lats[5], color=style[mapstyle]['outcolor'], clip_on=False, zorder=0.2)
# m.plot(lats[6], lats[7], color=style[mapstyle]['outcolor'], clip_on=False, zorder=0.2)
# if not erro == None:
# xs, ys = m(erro[0], erro[1])
# xs = [i for i in xs if i < 1e+30]
# ys = [i for i in ys if i < 1e+30]
# m.plot(xs, ys, '--', color=style[mapstyle]['ercolor'])
# xt, yt = m(erro[2], erro[3])
# xt = [i for i in xt if i < 1e+30]
# yt = [i for i in yt if i < 1e+30]
# m.plot(xt, yt, '--', color=style[mapstyle]['ercolor'])
# if not ring == None:
# xs, ys = m(ring[0], ring[1])
# xs = [i for i in xs if i < 1e+30]
# ys = [i for i in ys if i < 1e+30]
# m.plot(xs, ys, '--', color=style[mapstyle]['rncolor'])
# xt, yt = m(ring[2], ring[3])
# xt = [i for i in xt if i < 1e+30]
# yt = [i for i in yt if i < 1e+30]
# m.plot(xt, yt, '--', color=style[mapstyle]['rncolor'])
# if not atm == None:
# xs, ys = m(atm[0], atm[1])
# xs = [i for i in xs if i < 1e+30]
# ys = [i for i in ys if i < 1e+30]
# m.plot(xs, ys, color=style[mapstyle]['atcolor'])
# xt, yt = m(atm[2], atm[3])
# xt = [i for i in xt if i < 1e+30]
# yt = [i for i in yt if i < 1e+30]
# m.plot(xt, yt, color=style[mapstyle]['atcolor'])
# if not clat == None:
xc, yc, lab = [], [], []
cp = Time(clat[tipo][5], format='iso')
vec = np.arange(0, (cp[-1] - data).sec, cpoints)
vec = np.sort(np.concatenate((vec,-vec[1:]), axis=0))*u.s
# for i in vec:
# g = data + TimeDelta(i) + TimeDelta(off*u.s)
# if g.iso in clat[tipo][2]:
# a = np.where(np.array(clat[tipo][2]) == g.iso)
# x, y = m(np.array(clat[tipo][0])[a], np.array(clat[tipo][1])[a])
# xc.append(x)
# yc.append(y)
# lab.append(g.iso.split()[1][0:8])
# elif g.iso in clat[tipo][5]:
# a = np.where(np.array(clat[tipo][5]) == g.iso)
# xc.append(np.array(clat[tipo][3])[a])
# yc.append(np.array(clat[tipo][4])[a])
# lab.append(g.iso.split()[1][0:8])
# else:
# if len(clat[tipo][2]) == 0:
# a = [0]
# else:
# co = Time(clat[tipo][2], format='iso')
# a = np.argsort(np.absolute(co - g))[0:2]
# if 0 not in a and len(co)-1 not in a:
# b = np.absolute((co[a] - g).sec)
# x, y = m(np.array(clat[tipo][0])[a], np.array(clat[tipo][1])[a])
# xc.append(np.sum(x*(1/b))/np.sum(1/b))
# yc.append(np.sum(y*(1/b))/np.sum(1/b))
# lab.append(g.iso.split()[1][0:8])
# else:
# co = Time(clat[tipo][5], format='iso')
# a = np.argsort(np.absolute(co - g))[0:2]
# b = np.absolute((co[a] - g).sec)
# xc.append(np.sum(np.array(clat[tipo][3])[a]*(1/b))/np.sum(1/b))
# yc.append(np.sum(np.array(clat[tipo][4])[a]*(1/b))/np.sum(1/b))
# lab.append(g.iso.split()[1][0:8])
x, y = m(np.array(clat[tipo][0]), np.array(clat[tipo][1]))
m.plot(x, y, color=mapsstyle[tipo])#, markersize=mapsize[0].value*8/46)
m.plot(clat[tipo][6][0], clat[tipo][6][1], 'o', color=mapsstyle[tipo], markersize=mapsize[0].value*10/46)#, marker=(2,0,165))
# print clat[6][0], clat[6][1]
# for label, axpt, bypt in zip(lab, xc, yc):
# plt.text(axpt + 0, bypt + 350000, label, rotation=60, weight='bold')
# m.plot(ax,by, 'o', color=ptcolor, markersize=int(mapsize[0].value*20/46))
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=int(mapsize[0].value*12/46))
# m.plot(ax3.to(u.m), by3.to(u.m), color='red')
# m.plot(ax4.to(u.m), by4.to(u.m), color='red')
# m.quiver(a-0*u.m,b-600000*u.m, 20, 0, width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
#
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
if os.path.isfile(sitearq) == True:
sites = np.loadtxt(sitearq, dtype={'names': ('lat', 'lon', 'alt', 'nome'), 'formats': ('f8', 'f8', 'f8', 'S30')})
xpt,ypt = m(sites['lon'],sites['lat'])
m.plot(xpt,ypt,'go')
# offset = [[xpt[0] + 100000,xpt[0] + 100000,xpt[0] + 100000,xpt[3] + 400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000],[10000,-30000,-60000,70000,30000,-20000,-70000,-30000,-70000]]
# for i in np.arange(len(xpt)):
# ax.text(offset[0][i],ypt[i]+offset[1][i],sites['nome'][i], weight='bold')
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
# m.plot(5771363.97687, 4156344.21479, '+', color='black', markersize=mapsize[0].value*20/46)
#5771363.97687 4156344.21479
# fig = plt.gcf()
# fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
# plt.title(title, fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
# plt.xlabel(labelx, fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
# e,w = m(center_map.longitude.value,center_map.latitude.value)
e, w = clat['STE'][6][0], clat['STE'][6][1]
plt.errorbar(e - 50000, w + 1250000, yerr=75000, color='black')
plt.errorbar(e - 50000, w + 1000000, yerr=98000, color='black')
plt.text(e, w + 1225000, 'Himalia Diameter (150 km)', fontsize=sizel)
plt.text(e, w + 975000, 'Estimated Error (60 mas)', fontsize=sizel)
plt.xscale(u'linear')
plt.xticks(np.arange(-2500000, 1500000, 500000) + e, np.arange(-2.5, 1.5, 0.5), fontsize=sizel)
plt.xlabel(r'$\times 10^{3}$(km)', fontsize=sizel)
plt.yscale(u'linear')
plt.yticks(np.arange(-1500000, 2000000, 500000) + w, np.arange(-1.5, 2.0, 0.5), fontsize=sizel)#, rotation=90)
plt.ylabel(r'$\times 10^{3}$(km)', fontsize=sizel)
plt.savefig('HIMALIA.{}'.format(fmt), format=fmt, dpi=dpi, bbox_inches='tight')
print 'Gerado: HIMALIA.{}'.format(fmt)
plt.clf()
class ISSData():
Arrays = []
rows = 0
n = 0
step = 1104
Headers = []
Directory = ''
normPath = ""
chatty = False
map = ""
ag = ""
def __init__(self, fileName, directory=""):
""" Check to see if files exists
"""
self.map = Basemap(projection='mill', lon_0=-10)
normPath = os.path.normpath(directory + fileName)
try:
dFile = open(normPath, "r")
except:
print "Cannot open", normPath
# save tested path for later use
self.normPath = normPath
dFile.close()
def readDataFromFile(self):
NL = 0
with open(self.normPath) as file:
for line in file:
line = line.rstrip()
NL += 1
ns = line.split(",")
if (NL == 1):
headers = ns
for h in headers:
self.Headers.append(h)
self.Headers.pop(
-1) # remove time stamp header as time is not a float
for val in ns:
empty = []
self.Arrays.append(empty)
else:
nv = 0
for val in ns:
self.Arrays[nv].append(val)
nv += 1
file.close()
self.rows = len(self.Arrays[0])
nh = 0
print " File", self.normPath, " rows=", self.rows, self.rows / 360, "hours"
print self.Arrays[19][0], " - ", self.Arrays[19][-1]
print " Measurement # min max median average stddev"
for h in self.Headers:
narray = np.array(self.Arrays[nh]).astype(np.float32)
if (nh == 0):
# each data point is 10 secs so this scales x axis to minutes
narray = narray / 6.0
#Calculate some basic stats on each row
max = np.amax(narray)
if (headers[nh] == "pitch") or (headers[nh] == "yaw"):
if (max >= 20000.):
# convert from radians to degrees?
# in the first Spacecraft dataset only (I think)
narray = narray / 57.3
nv = 0
for val in narray:
if (val <= -180.0):
narray[nv] = narray[nv] + 360.0
elif (val >= 180.0):
narray[nv] = narray[nv] - 360.0
nv += 1
# pitch looks better when normalized about zero
max = np.amax(narray)
min = np.amin(narray)
med = np.median(narray)
aver = np.average(narray)
stddev = np.std(narray)
print "%12s %6s %10.5f %10.5f %10.5f %10.5f %10.5f" % (
h, nh, min, max, med, aver, stddev)
self.Arrays[nh] = narray
nh += 1
# Normalize
def printStats(self, param=1, n=0, step=1104):
print step,"datapoints - ", (self.Arrays[19][n])," - ", \
(self.Arrays[19][n+step])
print " Measurement # min max median average stddev"
min = np.amin(self.Arrays[param][n:n + step])
max = np.amax(self.Arrays[param][n:n + step])
med = np.median(self.Arrays[param][n:n + step])
aver = np.average(self.Arrays[param][n:n + step])
stddev = np.std(self.Arrays[param][n:n + step])
print "%12s %6s %10.5f %10.5f %10.5f %10.5f %10.5f" % (
self.Headers[param], param, min, max, med, aver, stddev)
def drawNightDay(self, param=1, n=0, step=1104):
if (self.chatty): print self.Headers[param], n, step
cn = int(n + step / 2)
ct = self.Arrays[19][cn]
print "Centre time period = ", ct
# miller projection
# plot coastlines, draw label meridians and parallels.
self.map.drawcoastlines()
self.map.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0])
self.map.drawmeridians(np.arange(self.map.lonmin, self.map.lonmax + 30,
60),
labels=[0, 0, 0, 1])
# fill continents 'coral' (with zorder=0), color wet areas 'aqua'
self.map.drawmapboundary(fill_color='white')
self.map.fillcontinents(color='coral', lake_color='white')
# shade the night areas, with alpha transparency so the
# map shows through. Use current time in UTC.
#en = el.findIndexFromDate(ct)
#eo = el.extractISSfromIndex(en)
#print eo
date = el.findDateFromString(ct)
if (step <= 1104):
self.map.nightshade(date)
else:
print "Track too long for night shading"
plt.title('ISS Track %s (UTC)' % ct)
# self.drawIssTrack(elements,param,n,step)
def drawIssTrack(self, elements, param=1, n=0, step=1104):
st = self.Arrays[19][n]
et = self.Arrays[19][n + step]
print "Plotting from - ", st, " to ", et
cn = int(n + step / 2)
ct = self.Arrays[19][cn]
line1, line2 = elements.elemsFromDateString(ct)
if (self.chatty): print "drawIssTrack", n, step, ct, line1, line2
for nn in range(n, n + step, 6):
ntime = self.Arrays[19][nn]
#if self.chatty: print ntime
tle_rec = ephem.readtle("ISS", line1, line2)
tle_rec.compute(ntime)
#convert to strings#
lat2string = str(tle_rec.sublat)
long2string = str(tle_rec.sublong)
lati = lat2string.split(":")
longt = long2string.split(":")
#if self.chatty: print "ISS SUBSURFACE -", lati,longt
lat = float(
lati[0]) + float(lati[1]) / 60. + float(lati[2]) / 3600.
lon = float(
longt[0]) + float(longt[1]) / 60. + float(longt[2]) / 3600.
xpt, ypt = self.map(lon, lat)
# drawing style
kargs = "g+"
if (nn == n):
plt.text(xpt, ypt, "start")
if (nn >= (n + step - 6)):
plt.text(xpt, ypt, "end")
# make every 5 mins dot
if ((nn % 30) == 0): kargs = "g."
self.map.plot(xpt, ypt, kargs)
def drawDataPlot(self, param=1, n=0, step=1104):
plt.figure(1)
plt.clf()
plt.title(self.Headers[param])
plt.plot(self.Arrays[0][n:(n + step)],
self.Arrays[param][n:(n + step)])
#self.ag.set_xdata(self.Arrays[0][n:(n+step)])
plt.draw()
a, b = map(-30, -15)
plt.text(a, b, timestr, fontsize='xx-small',
color='white') ##########TIMESTAMP FOR MAP >>ATLANTIC<<
plt.text(a - 120, b, timestr, fontsize='xx-small',
color='white') ##########TIMESTAMP FOR MAP >>Pacific<<
plt.text(a + 118, b, timestr, fontsize='xx-small',
color='white') ##########TIMESTAMP FOR MAP >>INDIAN<<
m, n = map(-20, -20)
#img = mpimg.imread('/shared/sos/json/legend.png')
#m.imshow(img, extent=(m,m-10,n,n-20)
log = open("/shared/sos/json/logs/AVedge.txt", "a")
log.writelines("GENERATED----MAP ----" + timestr + "\n")
#x, y = map(40.8228,47.9151)
#plt.plot(x, y, marker='D',color='yellow',markersize=1)
date = datetime.utcnow()
CS = map.nightshade(date)
#plt.title('Day/Night Map for %s (UTC)' %strftime("%d %b %Y %H:%M:%S"))
#plt.show()
plt.savefig('/shared/sos/json/dataset/' + timestr + ".png",
bbox_inches='tight',
pad_inches=-0.037,
dpi=200)
plt.savefig("/shared/sos/json/dataset/flights.png",
bbox_inches='tight',
pad_inches=-0.037,
dpi=200)
def combined_all_ghgs(sim_file, lattice_files, datetime, centre, xco2_lims=None, xco_lims=None, xch4_lims=None, map_bkgd='bluemarble', cmap='jet', out='show', **kwargs):
fig = plt.figure(figsize=(15,12))
xco2_ax = fig.add_subplot(231)
xco_ax = fig.add_subplot(232)
xch4_ax = fig.add_subplot(233)
cld_ax = fig.add_subplot(223)
ret_ax = fig.add_subplot(224)
#####################################
plt.sca(xco2_ax)
xco2, xco2_lats, xco2_lons = ec_cas.global_XCO2(datetime)
proj_xco2 = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='l')
proj_xco2.drawcoastlines(linewidth=0.75)
proj_xco2.drawcountries(linewidth=0.5)
proj_xco2.drawmeridians(np.arange(-180, 181, 30), latmax=90, linewidth=0.5)
proj_xco2.drawparallels(np.arange(-90, 91, 15), latmax=90, linewidth=0.5)
lon, lat = np.meshgrid(xco2_lons, xco2_lats)
x,y = proj_xco2(lon, lat)
xco2_mask = np.ma.masked_greater(x, 1e15).mask
xco2_masked = np.ma.array(xco2, mask=xco2_mask)
if xco2_lims:
vmin_xco2, vmax_xco2 = xco2_lims
else:
vmin_xco2 = xco2_masked.min() // 1.
vmax_xco2 = xco2_masked.max() // 1. + 1.
sm_xco2 = ScalarMappable(Normalize(vmin=vmin_xco2, vmax=vmax_xco2), cmap=cmap)
levs_xco2 = np.linspace(vmin_xco2, vmax_xco2, 256)
clevs_xco2 = [sm_xco2.to_rgba(lev) for lev in levs_xco2]
xco2_ctr = plt.contourf(x, y, xco2_masked, levs_xco2, colors=clevs_xco2, extend='both')
xco2_cbar = plt.colorbar(xco2_ctr, orientation='vertical', fraction=0.05, aspect=40, shrink=0.75)
xco2_cbar.set_label('XCO$_2$ [ppm]')
xco2_cbar.set_ticks(np.arange(vmin_xco2, vmax_xco2+0.25, 0.5))
plt.title(datetime.strftime('XCO$_2$ %d %b %Y %H:%M:%S'))
######################################
plt.sca(xco_ax)
xco, xch4, xlats, xlons = ec_cas.global_ghg(datetime)
proj_xco = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='l')
proj_xco.drawcoastlines(linewidth=0.75)
proj_xco.drawcountries(linewidth=0.5)
proj_xco.drawmeridians(np.arange(-180, 181, 30), latmax=90, linewidth=0.5)
proj_xco.drawparallels(np.arange(-90, 91, 15), latmax=90, linewidth=0.5)
lon, lat = np.meshgrid(xlons, xlats)
x,y = proj_xco(lon, lat)
xco_mask = np.ma.masked_greater(x, 1e15).mask
xco_masked = np.ma.array(xco, mask=xco_mask)
if xco_lims:
vmin_xco, vmax_xco = xco_lims
else:
vmin_xco = xco_masked.min() // 1.
vmax_xco = xco_masked.max() // 1. + 1.
sm_xco = ScalarMappable(Normalize(vmin=vmin_xco, vmax=vmax_xco), cmap=cmap)
levs_xco = np.linspace(vmin_xco, vmax_xco, 256)
clevs_xco = [sm_xco.to_rgba(lev) for lev in levs_xco]
xco_ctr = plt.contourf(x, y, xco_masked, levs_xco, colors=clevs_xco, extend='both')
xco_cbar = plt.colorbar(xco_ctr, orientation='vertical', fraction=0.1, aspect=40, shrink=0.75)
xco_cbar.set_label('XCO [ppb]')
xco_cbar.set_ticks(np.int64(np.arange(vmin_xco, vmax_xco+1, 10)))
plt.title(datetime.strftime('XCO %d %b %Y %H:%M:%S'))
#######################################
plt.sca(xch4_ax)
proj_xch4 = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='l')
proj_xch4.drawcoastlines(linewidth=0.75)
proj_xch4.drawcountries(linewidth=0.5)
proj_xch4.drawmeridians(np.arange(-180, 181, 30), latmax=90, linewidth=0.5)
proj_xch4.drawparallels(np.arange(-90, 91, 15), latmax=90, linewidth=0.5)
lon, lat = np.meshgrid(xlons, xlats)
x,y = proj_xch4(lon, lat)
xch4_mask = np.ma.masked_greater(x, 1e15).mask
xch4_masked = np.ma.array(xch4, mask=xch4_mask)
if xch4_lims:
vmin_xch4, vmax_xch4 = xch4_lims
else:
vmin_xch4 = xch4_masked.min() // 1.
vmax_xch4 = xch4_masked.max() // 1. + 1.
sm_xch4 = ScalarMappable(Normalize(vmin=vmin_xch4, vmax=vmax_xch4), cmap=cmap)
levs_xch4 = np.linspace(vmin_xch4, vmax_xch4, 256)
clevs_xch4 = [sm_xch4.to_rgba(lev) for lev in levs_xch4]
xch4_ctr = plt.contourf(x, y, xch4_masked, levs_xch4, colors=clevs_xch4, extend='both')
xch4_cbar = plt.colorbar(xch4_ctr, orientation='vertical', fraction=0.1, aspect=40, shrink=0.75)
xch4_cbar.set_label('XCH$_4$ [ppb]')
xch4_cbar.set_ticks(np.int64(np.arange(vmin_xch4, vmax_xch4 + 1, 20)))
plt.title(datetime.strftime('XCH$_4$ %d %b %Y %H:%M:%S'))
##############################################################
plt.sca(cld_ax)
mission = retrievals.Mission(sim_file, *lattice_files, **kwargs)
obs_time = time_utils.Time(datetime, mission.satellite.times[0].ref)
# find the closest apogee point to obs_time
apogees = mission.satellite.get_apogees()
apogee_ind = time_utils.closest_index(obs_time, apogees)
# create the ObservationPeriod instance, and generate the Retrieval instances
obs = retrievals.ObservationPeriod(mission, apogees[apogee_ind], mission.lattice_files[apogee_ind%2])
obs.main_filter()
obs.generate_retrievals()
# find the closest segment of the observation period
obs_ind = time_utils.closest_index(obs_time, obs.obs_middle)
clat, clon = centre
proj_cld = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='c')
# draw cloud data that was used to determine FOV locations
obs.cloud_collection.show_clouds_ortho(obs.cloud_times[obs_ind], centre, map_bkgd=map_bkgd, out='')
proj_cld.nightshade(datetime)
# draw a red border around each of the selected FOVs
for ret in obs.retrievals[obs_ind]:
lats = np.concatenate([ret.pixel_lats[:,0], ret.pixel_lats[-1,:], ret.pixel_lats[::-1,-1], ret.pixel_lats[0,::-1]])
lons = np.concatenate([ret.pixel_lons[:,0], ret.pixel_lons[-1,:], ret.pixel_lons[::-1,-1], ret.pixel_lons[0,::-1]])
x,y = proj_cld(lons, lats)
coords = np.vstack([x,y]).T
if not np.sum(coords > 1e15):
p = Polygon(coords, fill=False, edgecolor='r', zorder=10)
plt.gca().add_patch(p)
plt.title('FoV Selections {0} - {1} UTC'.format(obs.obs_times[obs_ind].strf('%d %B %Y %H:%M'), obs.obs_times[obs_ind+1].strf('%H:%M')))
##############################################################
plt.sca(ret_ax)
proj_ret = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='l')
if map_bkgd == 'bluemarble':
proj_ret.bluemarble()
elif map_bkgd == 'etopo':
proj_ret.etopo()
elif map_bkgd == 'mask':
proj_ret.drawlsmask(land_color='limegreen', ocean_color='dodgerblue', resolution='l')
proj_ret.drawcoastlines(linewidth=0.75)
proj_ret.drawcountries(linewidth=0.5)
proj_ret.drawmeridians(np.arange(-180, 181, 30), latmax=90, linewidth=0.5)
proj_ret.drawparallels(np.arange(-90, 91, 15), latmax=90, linewidth=0.5)
else:
raise ValueError('invalid map background specification')
proj_ret.nightshade(datetime)
for ret in obs.retrievals[obs_ind]:
x,y = proj_ret(ret.pixel_lons, ret.pixel_lats)
if not np.sum(x > 1e15):
ret_mask = ret.valid_retrievals == 0
ret_masked = np.ma.array(np.ones(ret.pixel_lats.shape), mask=ret_mask)
ret_ctr = plt.contourf(x, y, ret_masked, [0,1], colors=['red'], extend='both')
plt.title('AIM-North Retrievals {0} - {1} UTC'.format(obs.obs_times[obs_ind].strf('%d %B %Y %H:%M'), obs.obs_times[obs_ind+1].strf('%H:%M')))
##############################################################
plt.subplots_adjust(left=0.01, right=0.95, bottom=0.025, top = 0.975, wspace=0.175, hspace=0.1)
if out == 'show':
plt.show()
elif out == '':
pass
else:
plt.savefig(os.path.join('../figures/combined_plots/', out))
plt.close()
def plot_burst_map(sub_axis, gps_data, burst,
show_terminator = True, plot_trajectory=True, show_transmitters=True,
TLE_file = 'resources/VPM_TLEs.json', TX_file='resources/nb_transmitters.conf'):
logger = logging.getLogger()
#m_ax = fig.add_subplot(1,1,1)
m_ax = sub_axis
m = Basemap(projection='mill',lon_0=0,ax=m_ax, llcrnrlon=-180,llcrnrlat=-70,urcrnrlon=180,urcrnrlat=70)
lats = [x['lat'] for x in gps_data]
lons = [x['lon'] for x in gps_data]
T_gps = [x['timestamp'] for x in gps_data]
# still trying to fix this
#for ti, tt in enumerate(T_gps):
# if datetime.datetime.utcfromtimestamp(tt).year == 1980:
# T_gps.pop(ti)
# lats.pop(ti)
# lons.pop(ti)
T_gps = np.array(T_gps)
sx,sy = m(lons, lats)
m.drawcoastlines(color='k',linewidth=1,ax=m_ax);
m.drawparallels(np.arange(-90,90,30),labels=[1,0,0,0]);
m.drawmeridians(np.arange(m.lonmin,m.lonmax+30,60),labels=[0,0,1,0]);
m.drawmapboundary(fill_color='cyan');
m.fillcontinents(color='white',lake_color='cyan');
#check_lat = [x['lat'] for x in gps_data]
#check_lon = [x['lon'] for x in gps_data]
#if check_lat[0] == 0 and check_lon[0] == 0:
# TLE_lib = load_TLE_library(TLE_file)
# quick fix for missing gps
start_timestamp = datetime.datetime.utcfromtimestamp(burst['header_timestamp'])
avg_ts = float(burst['header_timestamp']) + 10
if show_terminator:
try:
# Find the median timestamp to use:
#avg_ts = np.mean([k['timestamp'] for k in gps_data if k['time_status'] > 19])
CS=m.nightshade(datetime.datetime.utcfromtimestamp(avg_ts))
except:
logger.warning('Problem plotting day/night terminator')
if plot_trajectory:
try:
# (Here's the old method, where you pass a TLE to it as text)
# if TLE_file:
# try:
# with open(TLE_file,'r') as file:
# TLE = file.read().split('\n')
# logger.info(
# f'loaded TLE file {TLE_file}')
# except:
# logger.warning(f'failed to load TLE file {TLE_file}')
# else:
# logger.info('using default TLE')
# # A default TLE, from mid-may 2020.
# TLE = ["1 45120U 19071K 20153.15274580 +.00003602 +00000-0 +11934-3 0 9995",
# "2 45120 051.6427 081.8638 0012101 357.8092 002.2835 15.33909680018511"]
# 10-27-2020: This version to find the closest TLE in the JSON file
# You can change the length of the ground track plot by changing t1, t2, and tvec
TLE_lib = load_TLE_library(TLE_file)
#avg_ts = np.mean([k['timestamp'] for k in gps_data if k['time_status'] > 19])
t_mid = datetime.datetime.utcfromtimestamp(avg_ts)
t1 = t_mid - datetime.timedelta(minutes=15)
t2 = t_mid + datetime.timedelta(minutes=15)
#traj, tvec = compute_ground_track(TLE, t1, t2, tstep=datetime.timedelta(seconds=10))
tvec = [(t1 + datetime.timedelta(seconds=int(x))) for x in np.arange(0,30*60, 10)]
simtime = [x.replace(tzinfo=datetime.timezone.utc).timestamp() for x in tvec]
traj,_ = get_position_from_TLE_library(simtime, TLE_lib)
tlats = traj[:,1]
tlons = traj[:,0]
mid_ind = np.argmin(np.abs(np.array(tvec) - t_mid))
zx,zy = m(tlons, tlats)
z = m.scatter(zx,zy,c=simtime, marker='.', s=10, alpha=0.5, cmap = get_cmap('plasma'), zorder=100, label='TLE')
z2 =m.scatter(zx[mid_ind], zy[mid_ind],edgecolor='k', marker='*',s=50, zorder=101, label='Center (TLE)')
except:
logger.warning('Problem plotting ground track from TLE')
if show_transmitters:
try:
call_sign_config = ConfigParser()
try:
fp = open(TX_file)
call_sign_config.read_file(fp)
fp.close()
except:
logger.warning('failed to load transmitters file')
for tx_name, vals in call_sign_config.items('NB_Transmitters'):
vv = vals.split(',')
tx_freq = float(vv[0])
tx_lat = float(vv[1])
tx_lon = float(vv[2])
px,py = m(tx_lon, tx_lat)
p = m.scatter(px,py, marker='p', s=20, color='r',zorder=99)
name_str = '{:s} \n{:0.1f} '.format(tx_name.upper(), tx_freq/1000)
m_ax.text(px, py, name_str, fontsize=8, fontweight='bold', ha='left',
va='bottom', color='k', label='TX')
p.set_label('TX')
s = m.scatter(sx,sy,c=T_gps, marker='o', s=20, cmap = get_cmap('plasma'), zorder=100, label='GPS')
except:
logger.warning('Problem plotting narrowband transmitters')
m_ax.legend(bbox_to_anchor=(1.05,1), loc='upper left', ncol=2)
gstr = ''
for entry in gps_data:
print('hey',entry)
time = datetime.datetime.strftime(datetime.datetime.utcfromtimestamp(entry['timestamp']),'%D %H:%M:%S')
tloc = entry['time_status'] > 20
ploc = entry['solution_status'] ==0
if time[6:8] == '20': # don't include the 1980 ones
gstr+= '{:s} ({:1.2f}, {:1.2f}):\ntime lock: {:b} position lock: {:b}\n'.format(time, entry['lat'], entry['lon'], tloc,ploc)
time = datetime.datetime.strftime(datetime.datetime.utcfromtimestamp(burst['header_timestamp']),'%D %H:%M:%S')
gstr = '{:s}'.format(time) + ' (' + str(round(tlats[len(tlats)//2],2)) + ', ' + str(round(tlons[len(tlons)//2],2)) + ') \n TLE generated'
gstr = '06/14/20 06:59:20 (-43.64, -120.91): \ntime lock: 1 position lock: 1 \n06/14/20 06:59:32 (-44.03, -120.06): \ntime lock: 1 position lock: 1 \n06/14/20 06:59:44 (-44.41, -119.19): \ntime lock: 1 position lock: 1 \n06/14/20 06:59:56 (-44.79, -118.31): \ntime lock: 1 position lock: 1 \n06/14/20 07:00:08 (-45.16, -117.42): \ntime lock: 1 position lock: 1 \n'
#m_ax.text(1, 0, gstr, fontsize='10') # ha='center', va='bottom')
return gstr
def bluemarble_daynight1(date, lon, lat, scale):
# Define Bluemarble and Nightshade objects
fig, axes = plt.subplots(1, figsize=(16, 16))
m = Basemap(projection='ortho',
resolution=None,
lat_0=lat[0],
lon_0=lon[0],
area_thresh=None,
ax=axes)
bm = m.bluemarble(scale=scale)
ns = m.nightshade(date, alpha=0.5)
bm_rgb = bm.get_array()
bm_ext = bm.get_extent()
axes.cla()
# Get the x and y index spacing
x = np.linspace(bm_ext[0], bm_ext[1], bm_rgb.shape[1])
y = np.linspace(bm_ext[2], bm_ext[3], bm_rgb.shape[0])
# Define coordinates of the Bluemarble image
x3d, y3d = np.meshgrid(x, y)
pts = np.hstack((x3d.flatten()[:, np.newaxis], y3d.flatten()[:,
np.newaxis]))
# Find which coordinates fall in Nightshade
# The following could be tidied up as there should only ever one polygon. Although
# the length of ns.collections is 3? I'm sure there's a better way to do this.
paths, polygons = [], []
for i, polygons in enumerate(ns.collections):
for j, paths in enumerate(polygons.get_paths()):
#print j, i
msk = paths.contains_points(pts)
# Redefine mask
msk = np.reshape(msk, bm_rgb[:, :, 0].shape)
msk_s = np.zeros(msk.shape)
msk_s[~msk] = 1.
# Smooth interface between Night and Day
for s in range(
int(bm_rgb.shape[1] / 50)
): # Make smoothing between day and night a function of Bluemarble resolution
msk_s = 0.25 * ( np.vstack( (msk_s[-1,: ], msk_s[:-1, : ]) ) \
+ np.vstack( (msk_s[1:,: ], msk_s[0 , : ]) ) \
+ np.hstack( (msk_s[: ,0, np.newaxis], msk_s[: , :-1 ]) ) \
+ np.hstack( (msk_s[: ,1: ], msk_s[: , -1,np.newaxis]) ) )
# Define new RGBA array
bm_rgba = np.dstack((bm_rgb[:, :, 0:3], msk_s))
# Plot up Bluemarble Nightshade
m = Basemap(projection='ortho',
resolution=None,
lat_0=lat[0],
lon_0=lon[0],
area_thresh=None,
ax=axes)
bm_n = m.warpimage('./earth_lights_lrg.jpg', scale=scale)
#from https://eoimages.gsfc.nasa.gov/images/imagerecords/55000/55167/earth_lights_lrg.jpg
bm_d = m.imshow(bm_rgba)
x, y = m(lon[0], lat[0])
plt.plot(x, y, 'or', markersize=10)
plt.title('Day/Night Map for %s (UTC)' %
date.strftime("%d %b %Y %H:%M:%S"),
fontsize=20)
plt.subplots_adjust(left=0.02, right=0.98, top=0.98, bottom=0.02)
plt.savefig('output/fig/0/f1.jpg')
size = np.size(lon)
xy = np.zeros([size, 2])
for i in range(size):
x, y = m(lon[i], lat[i])
xy[i, 0] = x
xy[i, 1] = y
print(xy)
np.savetxt('output/fig/0/positionxy.dat', xy)
def geramapa():
lon = stars.ra - datas.sidereal_time('mean', 'greenwich')
fig = plt.figure(figsize=(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value))
m = Basemap(projection='ortho',lat_0=stars.dec.value,lon_0=lon.value,resolution=resolution,llcrnrx=-1800000.,llcrnry=-1200000.,urcrnrx=2200000.,urcrnry=1800000., area_thresh=2000)
# m = Basemap(projection='ortho',lat_0=stars.dec.value,lon_0=lon.value,resolution=resolution,llcrnrx=-800000.,llcrnry=-450000.,urcrnrx=1200000.,urcrnry=1050000., area_thresh=2000)
axf = fig.add_axes([-0.001,-0.001,1.002,1.002])
axf.set_rasterization_zorder(1)
# m = Basemap(projection='ortho',lat_0=stars.dec.value,lon_0=lon.value,resolution=resolution, llcrnrx=-7000000,llcrnry=-7000000,urcrnrx=7000000,urcrnry=7000000)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
# m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
m.drawmapboundary()
ptcolor = 'red'
lncolor = 'black'
dscolor = 'black'
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '3':
m.shadedrelief()
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '4':
m.bluemarble()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
elif mapstyle == '5':
m.etopo()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
if os.path.isfile(sitearq) == True:
xpt,ypt = m(sites['lon'],sites['lat'])
m.plot(xpt,ypt,'bo')
for i in np.arange(len(xpt)):
plt.text(xpt[i]+50000,ypt[i]-5000,sites['nome'][i])
CS=m.nightshade(datas.datetime, alpha=0.2, zorder=0.5)
a, b =m(lon.value, stars.dec.value)
a = a*u.m
b = b*u.m
dista = (dist.to(u.km)*ca.to(u.rad)).value*u.km
disterr = (dist.to(u.km)*erro.to(u.rad)).value*u.km
vec = np.arange(0,7000,(np.absolute(vel)*(60*u.s)).value)*u.km + np.absolute(vel)*(60*u.s)
vec = np.concatenate((vec.value,-vec.value), axis=0)*u.km
ax = a + dista*np.sin(pa)
ax2 = ax + vec*np.cos(pa)
ax3 = ax2 - tamanho/2*np.sin(pa)
ax4 = ax2 + tamanho/2*np.sin(pa)
ax5 = a + (dista-disterr)*np.sin(pa) + vec*np.cos(pa)
ax6 = a + (dista+disterr)*np.sin(pa) + vec*np.cos(pa)
by = b + dista*np.cos(pa)
by2 = by - vec*np.sin(pa)
by3 = by2 - tamanho/2*np.cos(pa)
by4 = by2 + tamanho/2*np.cos(pa)
by5 = b + (dista-disterr)*np.cos(pa) - vec*np.sin(pa)
by6 = b + (dista+disterr)*np.cos(pa) - vec*np.sin(pa)
m.plot(ax,by, 'o', color=ptcolor, markersize=mapsize[0].value*20/46)
m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=mapsize[0].value*10/46)
m.plot(ax3.to(u.m), by3.to(u.m), color=lncolor)
m.plot(ax4.to(u.m), by4.to(u.m), color=lncolor)
m.quiver(ax+800000*u.m,by-1000000*u.m, 10*np.cos(pa),-10*np.sin(pa), width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
# for label, axpt, bypt in zip(labels, ax2.value, by2.value):
# plt.text(axpt + 30000, bypt + 250000, label, rotation=60, weight='bold')
# if os.path.isfile(sitearq) == True:
# xpt,ypt = m(sites['lon'],sites['lat'])
# m.plot(xpt,ypt,'bo')
# for i in np.arange(len(xpt)):
# plt.text(xpt[i]+50000,ypt[i]+15000,sites['nome'][i])
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
# plt.title('Objeto Diam dots <> ra_off_obj_de ra_of_star_de\n{:10s} {:4.0f} km 60 s <> {:+6.1f} {:+6.1f} {:+6.1f} {:+6.1f} \n'
# .format(obj, tamanho.value, ob_off_ra.value, ob_off_de.value, st_off_ra.value, st_off_de.value), fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
# plt.xlabel('\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
#{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
# .format(datas.iso, int(stars.ra.hms.h), int(stars.ra.hms.m), stars.ra.hms.s, int(stars.dec.dms.d), np.absolute(int(stars.dec.dms.m)), np.absolute(stars.dec.dms.s),
# ca.value, pa.value, vel.value, dist.value, magR, magK, longi), fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
# plt.savefig('{}_{}.eps'.format(obj, datas.isot),dpi=300, format='eps')
plt.savefig('{}_{}.eps'.format(obj, datas.isot), format='eps', dpi=300)
print 'Gerado: {}_{}.eps'.format(obj, datas.isot)
plt.clf()
from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt from datetime import datetime map = Basemap(projection="vandg", lon_0=0, resolution="c") map.drawmapboundary(fill_color="#7777ff") map.fillcontinents(color="#ddaa66", lake_color="#7777ff") map.drawcoastlines() map.nightshade(datetime.now(), delta=0.2) plt.show()
def combined(sim_file, lattice_files, datetime, centre, xco2_lims=None, map_bkgd='bluemarble', cmap='jet', out='show', **kwargs):
"""
Create a combined plot
"""
_, (xco2_ax, cld_ax, ret_ax) = plt.subplots(nrows=1, ncols=3, figsize=(15,8))
##############################################################
plt.sca(xco2_ax)
xco2, xco2_lats, xco2_lons = ec_cas.global_XCO2(datetime)
proj_xco2 = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='l')
proj_xco2.drawcoastlines(linewidth=0.75)
proj_xco2.drawcountries(linewidth=0.5)
proj_xco2.drawmeridians(np.arange(-180, 181, 30), latmax=90, linewidth=0.5)
proj_xco2.drawparallels(np.arange(-90, 91, 15), latmax=90, linewidth=0.5)
lon, lat = np.meshgrid(xco2_lons, xco2_lats)
x,y = proj_xco2(lon, lat)
xco2_mask = np.ma.masked_greater(x, 1e15).mask
xco2_masked = np.ma.array(xco2, mask=xco2_mask)
if xco2_lims:
vmin_xco2, vmax_xco2 = xco2_lims
else:
vmin_xco2 = xco2.min() // 1.
vmax_xco2 = xco2.max() // 1. + 1.
sm_xco2 = ScalarMappable(Normalize(vmin=vmin_xco2, vmax=vmax_xco2), cmap=cmap)
levs_xco2 = np.linspace(vmin_xco2, vmax_xco2, 256)
clevs_xco2 = [sm_xco2.to_rgba(lev) for lev in levs_xco2]
xco2_ctr = plt.contourf(x, y, xco2_masked, levs_xco2, colors=clevs_xco2, extend='both')
xco2_cbar = plt.colorbar(xco2_ctr, orientation='horizontal', fraction=0.1, aspect=40)
xco2_cbar.set_label('Xco$_2$ [ppm]')
xco2_cbar.set_ticks(np.arange(vmin_xco2, vmax_xco2 + 1, 1))
plt.title(datetime.strftime('EC-CAS Run %d %b %Y %H:%M:%S'))
##############################################################
plt.sca(cld_ax)
mission = retrievals.Mission(sim_file, *lattice_files, **kwargs)
obs_time = time_utils.Time(datetime, mission.satellite.times[0].ref)
# find the closest apogee point to obs_time
apogees = mission.satellite.get_apogees()
apogee_ind = time_utils.closest_index(obs_time, apogees)
# create the ObservationPeriod instance, and generate the Retrieval instances
obs = retrievals.ObservationPeriod(mission, apogees[apogee_ind], mission.lattice_files[apogee_ind%2])
obs.main_filter()
obs.generate_retrievals()
# find the closest segment of the observation period
obs_ind = time_utils.closest_index(obs_time, obs.obs_middle)
# clat, clon = centre
proj_cld = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='c')
# draw cloud data that was used to determine FOV locations
obs.cloud_collection.show_clouds_ortho(obs.cloud_times[obs_ind], centre, map_bkgd=map_bkgd, out='')
proj_cld.nightshade(datetime)
# draw a red border around each of the selected FOVs
for ret in obs.retrievals[obs_ind]:
lats = np.concatenate([ret.pixel_lats[:,0], ret.pixel_lats[-1,:], ret.pixel_lats[::-1,-1], ret.pixel_lats[0,::-1]])
lons = np.concatenate([ret.pixel_lons[:,0], ret.pixel_lons[-1,:], ret.pixel_lons[::-1,-1], ret.pixel_lons[0,::-1]])
x,y = proj_cld(lons, lats)
coords = np.vstack([x,y]).T
if not np.sum(coords > 1e15):
p = Polygon(coords, fill=False, edgecolor='r', zorder=10)
plt.gca().add_patch(p)
plt.title('FoV Selections {0} - {1} UTC'.format(obs.obs_times[obs_ind].strf('%d %B %Y %H:%M'), obs.obs_times[obs_ind+1].strf('%H:%M')))
##############################################################
plt.sca(ret_ax)
proj_ret = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='l')
if map_bkgd == 'bluemarble':
proj_ret.bluemarble()
elif map_bkgd == 'etopo':
proj_ret.etopo()
elif map_bkgd == 'mask':
proj_ret.drawlsmask(land_color='limegreen', ocean_color='dodgerblue', resolution='l')
proj_ret.drawcoastlines(linewidth=0.75)
proj_ret.drawcountries(linewidth=0.5)
proj_ret.drawmeridians(np.arange(-180, 181, 30), latmax=90, linewidth=0.5)
proj_ret.drawparallels(np.arange(-90, 91, 15), latmax=90, linewidth=0.5)
else:
raise ValueError('invalid map background specification')
proj_ret.nightshade(datetime)
sm_ret = ScalarMappable(Normalize(vmin=vmin_xco2, vmax=vmax_xco2), cmap=cmap)
levs_ret = np.linspace(vmin_xco2, vmax_xco2, 256)
clevs_ret = [sm_ret.to_rgba(lev) for lev in levs_ret]
xco2_interp = RegularGridInterpolator((xco2_lats, xco2_lons), xco2, bounds_error=False, fill_value=None)
for ret in obs.retrievals[obs_ind]:
x,y = proj_ret(ret.pixel_lons, ret.pixel_lats)
if not np.sum(x > 1e15):
latlon_arr = np.dstack([ret.pixel_lats, ret.pixel_lons])
xco2_ret = xco2_interp(latlon_arr)
retmask = ret.valid_retrievals == 0
xco2_ret_masked = np.ma.array(xco2_ret, mask=retmask)
ret_ctr = plt.contourf(x, y, xco2_ret_masked, levs_ret, colors=clevs_ret, extend='both')
ret_cbar = plt.colorbar(ret_ctr, orientation='horizontal', fraction=0.1, aspect=40)
ret_cbar.set_label('Xco$_2$ [ppm]')
ret_cbar.set_ticks(np.arange(vmin_xco2, vmax_xco2 + 1, 1))
plt.title('AIM-North Retrievals {0} - {1} UTC'.format(obs.obs_times[obs_ind].strf('%d %B %Y %H:%M'), obs.obs_times[obs_ind+1].strf('%H:%M')))
##############################################################
plt.suptitle('AIM-North Observing Strategy')
plt.subplots_adjust(wspace=0.05, left=0.05, right=0.95, top=1., bottom=0.1)
cld_ax.set_position([0.35, 0.2525, 0.3, 0.675])
if out == 'show':
plt.show()
elif out == '':
pass
else:
plt.savefig(os.path.join('../figures/combined_plots/', out))
plt.close()
from mpl_toolkits.basemap import Basemap
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
# create new figure, axes instances.
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
# setup mercator map projection.
m = Basemap(llcrnrlon=-180.,llcrnrlat=-30.,urcrnrlon=180.,urcrnrlat=30.,\
resolution='l',projection='merc',\
# lat_0=40.,lon_0=-20.,lat_ts=20.
)
m.drawcoastlines()
m.fillcontinents()
m.drawparallels(np.arange(-30, 30, 20), labels=[1, 1, 0, 1])
# draw meridians
m.drawmeridians(np.arange(-180, 180, 60), labels=[1, 1, 0, 1])
date = datetime.utcnow()
m.nightshade(date)
ax.set_title('Great Circle from New York to London')
plt.show()
def geramapa(star, data, title, labelx, nameimg, mapstyle='1', resolution='l', centermap=None, lats=None, erro=None, ring=None, atm=None, clat=None, sitearq=None, fmt='png', dpi=100, mapsize=None):
lon = star.ra - data.sidereal_time('mean', 'greenwich')
center_map = EarthLocation(lon.value, star.dec.value)
if not centermap == None:
center_map = EarthLocation(centermap[0],centermap[1])
m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution)
# m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution,llcrnrx=-2000000.,llcrnry=-1500000.,urcrnrx=2000000.,urcrnry=1500000.)
# kx = fig.add_axes([-0.003,-0.001,1.006,1.002])
# kx.set_rasterization_zorder(1)
m.nightshade(data.datetime, alpha=0.2, zorder=0.5)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
m.drawmapboundary()
style = {'1': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'blue', 'rncolor':'blue', 'atcolor':'blue'},
'2': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black'},
'3': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black'},
'4': {'ptcolor': 'red', 'lncolor': 'red', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black'},
'5': {'ptcolor': 'red', 'lncolor': 'red', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black'}}
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
elif mapstyle == '3':
m.shadedrelief()
elif mapstyle == '4':
m.bluemarble()
elif mapstyle == '5':
m.etopo()
if not lats == None:
xs, ys = m(lats[0], lats[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['lncolor'])
xt, yt = m(lats[2], lats[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['lncolor'])
if not erro == None:
xs, ys = m(erro[0], erro[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['ercolor'])
xt, yt = m(erro[2], erro[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['ercolor'])
if not ring == None:
xs, ys = m(ring[0], ring[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['rncolor'])
xt, yt = m(ring[2], ring[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['rncolor'])
if not atm == None:
xs, ys = m(atm[0], atm[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['atcolor'])
xt, yt = m(atm[2], atm[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['atcolor'])
if not clat == None:
xc, yc = m(clon, clat)
labe = [lab[i] for i in np.arange(len(lab)) if xc[i] < 1e+30]
xc = [i for i in xc if i < 1e+30]
yc = [i for i in yc if i < 1e+30]
m.plot(xc, yc, 'o', color=style[mapstyle]['ptcolor'])
# m.plot(ax,by, 'o', color=ptcolor, markersize=int(mapsize[0].value*20/46))
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=int(mapsize[0].value*12/46))
# m.plot(ax3.to(u.m), by3.to(u.m), color='red')
# m.plot(ax4.to(u.m), by4.to(u.m), color='red')
# m.quiver(a-0*u.m,b-600000*u.m, 20, 0, width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
#
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
# for label, axpt, bypt in zip(labe, xc, yc):
# kx.text(axpt + 0, bypt + 350000, label, rotation=60, weight='bold')
# if os.path.isfile(sitearq) == True:
# xpt,ypt = m(sites['lon'],sites['lat'])
# m.plot(xpt,ypt,'bo')
# offset = [[xpt[0] + 100000,xpt[0] + 100000,xpt[0] + 100000,xpt[3] + 400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000],[10000,-30000,-60000,70000,30000,-20000,-70000,-30000,-70000]]
# for i in np.arange(len(xpt)):
# ax.text(offset[0][i],ypt[i]+offset[1][i],sites['nome'][i], weight='bold')
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
plt.title(title, fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
plt.xlabel(labelx, fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
plt.savefig('{}.{}'.format(nameimg, fmt), format=fmt, dpi=dpi)
print 'Gerado: {}.{}'.format(nameimg, fmt)
plt.clf()
map = Basemap(projection='ortho',
lat_0=0,
lon_0=lon,
resolution='l',
area_thresh=1000.)
map.drawmapboundary()
map.drawmeridians(np.arange(0, 360, 15), color="0.5", latmax=90)
map.drawparallels(np.arange(-90, 90, 15), color="0.5", latmax=90)
map.drawcoastlines()
map.drawmapboundary(fill_color='aqua')
map.fillcontinents(color='coral', lake_color='aqua')
CS = map.nightshade(d)
f = plt.gcf()
f.set_size_inches(7.2, 7.2)
plt.text(0.5,
0.95,
p,
transform=f.transFigure,
horizontalalignment="center",
fontsize="large")
plt.text(0.5,
0.05,
"noon UTC",
transform=f.transFigure,
def _make_EICS_plots(dtime=None,
vplot_sized=False,
contour_den=8,
s_loc=False,
quiver_scale=30):
"""
@Parameter: dtime input as a string
@Parameter: s_loc input as a bool, which means the locations of the virtual stations.
"""
dtype = 'EICS'
if not os.path.exists(CONFIG['plots_dir']):
os.makedirs(CONFIG['plots_dir'])
dtime_range = [dtime, dtime]
pathformat_prefix = dtype + '/%Y/%m/'
pathformat_unzipped = pathformat_prefix + '%d/' + dtype + '%Y%m%d_%H%M%S.dat'
filename_unzipped = dailynames(file_format=pathformat_unzipped,
trange=dtime_range,
res=10)
out_files_unzipped = [
CONFIG['local_data_dir'] + rf_res for rf_res in filename_unzipped
]
Data_Days_time = read_data_files(out_files=out_files_unzipped,
dtype=dtype,
out_type='df')
J_comp = Data_Days_time['Jy']
Jc_max, Jc_min = J_comp.max(), J_comp.min()
Jcm_abs = max(abs(Jc_max), abs(Jc_min))
contour_density = np.linspace(-Jcm_abs, Jcm_abs, num=contour_den)
tp = dtime
datetime_tp = tp[0:4] + tp[5:7] + tp[8:10] + '_' + tp[11:13] + tp[
14:16] + tp[17:19]
lon = Data_Days_time['longitude']
lat = Data_Days_time['latitude']
Jx = Data_Days_time['Jx'] # Note: positive is Northward
Jy = Data_Days_time['Jy'] # Note: positive is Eastward
# plot 1:
# plot map ground (North hemisphere)
fig1 = plt.figure(figsize=(8, 8))
ax1 = plt.gca()
m = Basemap(projection='lcc',
resolution='c',
width=8E6,
height=8E6,
lat_0=60,
lon_0=-100)
# draw coastlines, country boundaries, fill continents.
m.drawcoastlines(linewidth=0.25)
m.drawcountries(linewidth=0.25)
m.fillcontinents(color='None', lake_color='None')
# draw the edge of the map projection region (the projection limb)
m.drawmapboundary(fill_color=None)
# m.drawgreatcircle(-100,0,0,90)
m.drawlsmask()
# m.bluemarble()
m.shadedrelief()
# draw parallels and meridians.
# label parallels on right and top
# meridians on bottom and left
parallels = np.arange(0., 81, 10.)
# labels = [left,right,top,bottom]
m.drawparallels(parallels, labels=[False, True, True, False])
meridians = np.arange(10., 351., 20.)
m.drawmeridians(meridians, labels=[True, False, False, True])
date_nightshade = datetime.strptime(dtime, '%Y-%m-%d/%H:%M:%S')
m.nightshade(date=date_nightshade)
draw_map(m)
# plot vector field:
lon = lon.to_numpy()
lat = lat.to_numpy()
Jx = Jx.to_numpy() # Note: positive is Northward
Jy = Jy.to_numpy() # Note: positive is Eastward
Jx_uni = Jx / np.sqrt(Jx**2 + Jy**2)
Jy_uni = Jy / np.sqrt(Jx**2 + Jy**2)
n = -2
color = np.sqrt(((Jx_uni - n) / 2)**2 + ((Jy_uni - n) / 2)**2)
if vplot_sized == False:
qv = m.quiver(
lon,
lat,
Jx_uni,
Jy_uni,
color,
headlength=7,
latlon=True,
cmap='GnBu') # autumn_r #, color=cm(norm(o)))#, cmap = 'jet')
plt.colorbar()
else:
Jy_rot, Jx_rot, x, y = m.rotate_vector(Jy, Jx, lon, lat, returnxy=True)
qv = m.quiver(lon,
lat,
Jy_rot,
Jx_rot,
headlength=7,
latlon=True,
scale_units='dots',
scale=quiver_scale) # , transform='lcc')
qk = ax1.quiverkey(qv,
0.3,
-0.1,
100,
r'$100 \ mA/m$',
labelpos='E',
coordinates='data') # figure
plt.title(label='EICS ' + tp, fontsize=20, color="black", pad=20)
plt.tight_layout()
plt.savefig(CONFIG['plots_dir'] + 'EICS' + '_vector_' +
date_nightshade.strftime('%Y%m%d%H%M%S') + '.jpeg')
plt.show()
# plot 2: contour plot
# plot map ground (North hemisphere)
fig2 = plt.figure(figsize=(8, 8))
ax2 = plt.gca()
m = Basemap(projection='lcc',
resolution='c',
width=8E6,
height=8E6,
lat_0=60,
lon_0=-100)
# draw coastlines, country boundaries, fill continents.
m.drawcoastlines(linewidth=0.25)
m.drawcountries(linewidth=0.25)
m.fillcontinents(color='None', lake_color='None')
# draw the edge of the map projection region (the projection limb)
m.drawmapboundary(fill_color=None)
m.drawlsmask()
m.shadedrelief()
# draw parallels and meridians.
# label parallels on right and top
# meridians on bottom and left
parallels = np.arange(0., 81, 10.)
m.drawparallels(parallels, labels=[False, True, True, False])
meridians = np.arange(10., 351., 20.)
m.drawmeridians(meridians, labels=[True, False, False, True])
date_nightshade = datetime.strptime(dtime, '%Y-%m-%d/%H:%M:%S')
# m.nightshade(date=date_nightshade, alpha = 0.0)
delta = 0.25
lons_dd, lats_dd, tau, dec = daynight_terminator(date_nightshade, delta,
m.lonmin, m.lonmax)
xy = [lons_dd, lats_dd]
xy = np.array(xy)
xb, yb = xy[0], xy[1]
m.plot(xb, yb, marker=None, color='m',
latlon=True) # for dawn-dusk circle line
# Plot the noon-midnight line.
n_interval = len(lons_dd)
ni_half = int(np.floor(len(lons_dd) / 2))
ni_otherhalf = n_interval - ni_half
noon_midnight = noon_midnight_meridian(dtime, delta)
m.plot(noon_midnight['lons_noon'],
noon_midnight['lats_noon'],
marker=None,
color='deepskyblue',
latlon=True) # noon semi-circle
m.plot(noon_midnight['lons_midnight'],
noon_midnight['lats_midnight'],
marker=None,
color='k',
latlon=True) # midnight semi-circle
draw_map(m)
Jy_log = Jy / np.abs(Jy) * np.log10(np.abs(Jy))
norm_cb = CenteredNorm()
# norm_cb = NoNorm()
# norm_cb = CenteredNorm(vmin=Jy.min(), vcenter=0, vmax=Jy.max())
# use Jy for the contour map, not Jy_rot.
ctrf = m.contourf(lon,
lat,
Jy,
contour_density,
latlon=True,
tri=True,
cmap='jet_r',
norm=norm_cb)
##ctrf = m.contourf(lon, lat, Jy, contour_density, latlon=True, tri=True, cmap='jet_r', norm=norm_cb)
# -------------
if s_loc:
m.scatter(lon, lat, latlon=True, marker='*', c='black')
# -------------
cb = m.colorbar(matplotlib.cm.ScalarMappable(norm=norm_cb, cmap='jet_r'),
pad='15%')
cb.set_label(r'$\mathit{J}_y \ (mA/m)$')
ax_cb = cb.ax
text = ax_cb.yaxis.label
font_cb = matplotlib.font_manager.FontProperties(family='times new roman',
style='italic',
size=20)
text.set_font_properties(font_cb)
plt.title(label='EICS ' + tp, fontsize=20, color="black", pad=20)
plt.tight_layout()
plt.savefig(CONFIG['plots_dir'] + 'EICS' + '_contour_' +
date_nightshade.strftime('%Y%m%d%H%M%S') + '.jpeg')
plt.show()
print('EICS plots completed!')
return
def bluemarble_daynight(date, scale):
mpl.rcParams['savefig.pad_inches'] = 0
# Define Bluemarble and Nightshade objects
#fig, axes = plt.subplots(1, figsize=(12,8), frameon=False)
fig = plt.figure(figsize=(12, 8))
axes = plt.axes([0, 0, 1, 1], frameon=False)
axes.get_xaxis().set_visible(False)
axes.get_yaxis().set_visible(False)
plt.autoscale(tight=True)
m = Basemap(projection='cyl', resolution=None, area_thresh=None, ax=axes)
bm = m.bluemarble(scale=scale)
ns = m.nightshade(date, alpha=0.5)
bm_rgb = bm.get_array()
bm_ext = bm.get_extent()
axes.cla()
# Get the x and y index spacing
x = np.linspace(bm_ext[0], bm_ext[1], bm_rgb.shape[1])
y = np.linspace(bm_ext[2], bm_ext[3], bm_rgb.shape[0])
# Define coordinates of the Bluemarble image
x3d, y3d = np.meshgrid(x, y)
pts = np.hstack((x3d.flatten()[:, np.newaxis], y3d.flatten()[:,
np.newaxis]))
# Find which coordinates fall in Nightshade
# The following could be tidied up as there should only ever one polygon. Although
# the length of ns.collections is 3? I'm sure there's a better way to do this.
paths, polygons = [], []
for i, polygons in enumerate(ns.collections):
for j, paths in enumerate(polygons.get_paths()):
#print j, i
msk = paths.contains_points(pts)
# Redefine mask
msk = np.reshape(msk, bm_rgb[:, :, 0].shape)
msk_s = np.zeros(msk.shape)
msk_s[~msk] = 1.
# Smooth interface between Night and Day
for s in range(
bm_rgb.shape[1] // 50
): # Make smoothing between day and night a function of Bluemarble resolution
msk_s = 0.25 * ( np.vstack( (msk_s[-1,: ], msk_s[:-1, : ]) ) \
+ np.vstack( (msk_s[1:,: ], msk_s[0 , : ]) ) \
+ np.hstack( (msk_s[: ,0, np.newaxis], msk_s[: , :-1 ]) ) \
+ np.hstack( (msk_s[: ,1: ], msk_s[: , -1,np.newaxis]) ) )
# Define new RGBA array
bm_rgba = np.dstack((bm_rgb, msk_s))
# Plot up Bluemarble Nightshade
m = Basemap(projection='cyl', resolution=None, area_thresh=None, ax=axes)
bm_n = m.warpimage('/home/pi/Mimic/Pi/imgs/orbit/earth_lights_lrg.jpg',
scale=scale)
bm_d = m.imshow(bm_rgba)
plt.savefig('/home/pi/Mimic/Pi/imgs/orbit/map.jpg',
bbox_inches='tight',
pad_inches=0)
def geramapa(star,
data,
title,
labelx,
nameimg,
mapstyle='1',
resolution='l',
centermap=None,
lats=None,
erro=None,
ring=None,
atm=None,
clat=None,
sitearq=None,
fmt='png',
dpi=100,
mapsize=None,
cpoints=60,
off=0):
lon = star.ra - data.sidereal_time('mean', 'greenwich')
center_map = EarthLocation(lon.value, star.dec.value)
if not centermap == None:
center_map = EarthLocation(centermap[0], centermap[1])
m = Basemap(projection='ortho',
lat_0=center_map.latitude.value,
lon_0=center_map.longitude.value,
resolution=resolution)
# m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution,llcrnrx=-2000000.,llcrnry=-1500000.,urcrnrx=2000000.,urcrnry=1500000.)
# kx = fig.add_axes([-0.003,-0.001,1.006,1.002])
# kx.set_rasterization_zorder(1)
m.nightshade(data.datetime, alpha=0.3,
zorder=0.5) ## desenha a sombra da noite
m.drawcoastlines(linewidth=0.5) ## desenha as linhas da costa
m.drawcountries(linewidth=0.5) ## desenha os paises
m.drawstates(linewidth=0.5) ## Desenha os estados
m.drawmeridians(np.arange(0, 360, 30)) ## desenha os meridianos
m.drawparallels(np.arange(-90, 90, 30)) ## desenha os paralelos
m.drawmapboundary() ## desenha o contorno do mapa
style = {
'1': {
'ptcolor': 'red',
'lncolor': 'blue',
'ercolor': 'blue',
'rncolor': 'blue',
'atcolor': 'blue',
'outcolor': 'red'
},
'2': {
'ptcolor': 'red',
'lncolor': 'blue',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black',
'outcolor': 'red'
},
'3': {
'ptcolor': 'red',
'lncolor': 'blue',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black',
'outcolor': 'red'
},
'4': {
'ptcolor': 'red',
'lncolor': 'red',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black',
'outcolor': 'red'
},
'5': {
'ptcolor': 'red',
'lncolor': 'red',
'ercolor': 'red',
'rncolor': 'black',
'atcolor': 'black',
'outcolor': 'red'
}
}
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral', lake_color='aqua')
elif mapstyle == '3':
m.shadedrelief()
elif mapstyle == '4':
m.bluemarble()
elif mapstyle == '5':
m.etopo()
if not lats == None:
xs, ys = m(lats[0], lats[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['lncolor'])
xt, yt = m(lats[2], lats[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['lncolor'])
m.plot(lats[4],
lats[5],
color=style[mapstyle]['outcolor'],
clip_on=False,
zorder=-0.2)
m.plot(lats[6],
lats[7],
color=style[mapstyle]['outcolor'],
clip_on=False,
zorder=-0.2)
# else:
# m.plot(lats[4], lats[5], color=style[mapstyle]['outcolor'], clip_on=False, zorder=0.2)
# m.plot(lats[6], lats[7], color=style[mapstyle]['outcolor'], clip_on=False, zorder=0.2)
if not erro == None:
xs, ys = m(erro[0], erro[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['ercolor'])
xt, yt = m(erro[2], erro[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['ercolor'])
if not ring == None:
xs, ys = m(ring[0], ring[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['rncolor'])
xt, yt = m(ring[2], ring[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['rncolor'])
if not atm == None:
xs, ys = m(atm[0], atm[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['atcolor'])
xt, yt = m(atm[2], atm[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['atcolor'])
if not clat == None:
xc, yc, lab = [], [], []
cp = Time(clat[5], format='iso')
vec = np.arange(0, (cp[-1] - data).sec, cpoints)
vec = np.sort(np.concatenate((vec, -vec[1:]), axis=0)) * u.s
for i in vec:
g = data + TimeDelta(i) + TimeDelta(off * u.s)
if g.iso in clat[2]:
a = np.where(np.array(clat[2]) == g.iso)
x, y = m(np.array(clat[0])[a], np.array(clat[1])[a])
xc.append(x)
yc.append(y)
lab.append(g.iso.split()[1][0:8])
elif g.iso in clat[5]:
a = np.where(np.array(clat[5]) == g.iso)
xc.append(np.array(clat[3])[a])
yc.append(np.array(clat[4])[a])
lab.append(g.iso.split()[1][0:8])
else:
if len(clat[2]) == 0:
a = [0]
else:
co = Time(clat[2], format='iso')
a = np.argsort(np.absolute(co - g))[0:2]
if 0 not in a and len(co) - 1 not in a:
b = np.absolute((co[a] - g).sec)
x, y = m(np.array(clat[0])[a], np.array(clat[1])[a])
xc.append(np.sum(x * (1 / b)) / np.sum(1 / b))
yc.append(np.sum(y * (1 / b)) / np.sum(1 / b))
lab.append(g.iso.split()[1][0:8])
else:
co = Time(clat[5], format='iso')
a = np.argsort(np.absolute(co - g))[0:2]
b = np.absolute((co[a] - g).sec)
xc.append(
np.sum(np.array(clat[3])[a] * (1 / b)) / np.sum(1 / b))
yc.append(
np.sum(np.array(clat[4])[a] * (1 / b)) / np.sum(1 / b))
lab.append(g.iso.split()[1][0:8])
m.plot(xc,
yc,
'o',
color=style[mapstyle]['ptcolor'],
clip_on=False,
markersize=mapsize[0].value * 8 / 46)
m.plot(clat[6][0],
clat[6][1],
'o',
color=style[mapstyle]['ptcolor'],
clip_on=False,
markersize=mapsize[0].value * 20 / 46)
# for label, axpt, bypt in zip(lab, xc, yc):
# plt.text(axpt + 0, bypt + 350000, label, rotation=60, weight='bold')
# m.plot(ax,by, 'o', color=ptcolor, markersize=int(mapsize[0].value*20/46))
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=int(mapsize[0].value*12/46))
# m.plot(ax3.to(u.m), by3.to(u.m), color='red')
# m.plot(ax4.to(u.m), by4.to(u.m), color='red')
# m.quiver(a-0*u.m,b-600000*u.m, 20, 0, width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
#
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
# if os.path.isfile(sitearq) == True:
# xpt,ypt = m(sites['lon'],sites['lat'])
# m.plot(xpt,ypt,'bo')
# offset = [[xpt[0] + 100000,xpt[0] + 100000,xpt[0] + 100000,xpt[3] + 400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000],[10000,-30000,-60000,70000,30000,-20000,-70000,-30000,-70000]]
# for i in np.arange(len(xpt)):
# ax.text(offset[0][i],ypt[i]+offset[1][i],sites['nome'][i], weight='bold')
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value,
mapsize[1].to(u.imperial.inch).value)
plt.title(title,
fontsize=mapsize[0].value * 25 / 46,
fontproperties='FreeMono',
weight='bold')
plt.xlabel(labelx,
fontsize=mapsize[0].value * 21 / 46,
fontproperties='FreeMono',
weight='bold')
plt.savefig('{}.{}'.format(nameimg, fmt), format=fmt, dpi=dpi)
print 'Gerado: {}.{}'.format(nameimg, fmt)
plt.clf()
def to_run(self):
"""Interactive plotting of satellite postion after data generation.
This is the function that the thread runs.
"""
# Setup lat long of telescope
home = ephem.Observer()
# NITK credentials
home.long = np.deg2rad(74.7421430) # +E
home.lat = np.deg2rad(13.3408810) # +N
home.elevation = 0 # meters
home.date = datetime.datetime.now()
# Read TLE file
tlefile = open('./TLE/' + self.id + '.txt', 'r').read()
tlesplit = tlefile.split('\n')
assert len(tlesplit) >= 3
satellite = ephem.readtle(tlesplit[0], tlesplit[1], tlesplit[2])
# Make some datetimes
# We will plot the path for thepast hour then start real time tracking
# We pre compute values for 24 hours
current_time = datetime.datetime.now()
past_time = current_time + timedelta(hours=-1)
dt = [
current_time + timedelta(seconds=1 * x)
for x in range(0, 24 * 60 * 60)
]
dt_past = [
past_time + timedelta(seconds=1 * x) for x in range(0, 60 * 60)
]
# Compute satellite locations at each datetime
sat_lat, sat_lon, sat_latp, sat_lonp = [], [], [], []
for date in dt:
home.date = date
satellite.compute(home)
sat_lon.append(np.rad2deg(satellite.sublong))
sat_lat.append(np.rad2deg(satellite.sublat))
for date in dt_past:
home.date = date
satellite.compute(home)
sat_lonp.append(np.rad2deg(satellite.sublong))
sat_latp.append(np.rad2deg(satellite.sublat))
# Calibrate everything to have positive values
for i in range(len(sat_lon)):
if sat_lon[i] < 0:
sat_lon[i] = 360 + sat_lon[i]
for i in range(len(sat_lonp)):
if sat_lonp[i] < 0:
sat_lonp[i] = 360 + sat_lonp[i]
# miller projection using Basemap
mymap = Basemap(projection='mill', lon_0=180)
# plot coastlines, draw label meridians and parallels.
mymap.drawcoastlines()
mymap.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0])
mymap.drawmeridians(np.arange(mymap.lonmin, mymap.lonmax + 30, 60),
labels=[0, 0, 0, 1])
# fill continents 'coral' (with zorder=0), color wet areas 'aqua'
mymap.drawmapboundary(fill_color='aqua')
# shade the night areas, with alpha transparency so the
# mymap shows through. Use current time in UTC.
# Prepare values to plot
date = datetime.datetime.utcnow()
# convert to map projection co-ordinates
x, y = mymap(sat_lon, sat_lat)
xp, yp = mymap(sat_lonp, sat_latp)
# Convert to numpy arrays
# atleast_1d makes sure arrays are atleast 1-d, unnecessary check for scalars
x = np.atleast_1d(x)
y = np.atleast_1d(y)
xp = np.atleast_1d(xp)
yp = np.atleast_1d(yp)
# compute night shade for the given date
CS = mymap.nightshade(date)
# Set some properties for the plot window
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
# Plot the past hour data
plt.scatter(xp, yp, color='y', s=5, label="Past Hour")
# Now we start plotting interactively
plt.ion()
plt.scatter(x[0], y[0], color='#FF3F35', label="Real time")
# Position legend and set transparency
leg = plt.legend(fancybox=True, shadow=True, loc=4)
leg.get_frame().set_alpha(0.1)
# We have calculated data for every second for 24 hours from current time
# We plot eachdata point with one second delaytosimulate real time plotting
for i in range(1, len(sat_lon)):
plt.scatter(x[i], y[i], color='#FF3F35', label="Real time")
plt.pause(1)
# If done plotting everything, just pause
while self.running:
plt.pause(1)
plt.close('all')
rsphere=(6378137.00,6356752.3142),\
resolution='l',area_thresh=1000.,projection='lcc',\
lat_1=50.,lon_0=-107.,ax=ax)
# transform to nx x ny regularly spaced 5km native projection grid
nx = int((m.xmax-m.xmin)/5000.)+1; ny = int((m.ymax-m.ymin)/5000.)+1
# topodat = m.transform_scalar(topoin,lons,lats,nx,ny)
# plot image over map with imshow.
# im = m.imshow(topodat,cm.GMT_haxby)
# draw coastlines and political boundaries.
m.drawcoastlines()
m.drawcountries()
m.drawstates()
# draw parallels and meridians.
# label on left and bottom of map.
parallels = np.arange(0.,80,20.)
m.drawparallels(parallels,labels=[1,0,0,1])
meridians = np.arange(10.,360.,30.)
m.drawmeridians(meridians,labels=[1,0,0,1])
# add colorbar
# cb = m.colorbar(im,"right", size="5%", pad='2%')
ax.set_title('ETOPO5 Topography - Lambert Conformal Conic')
from datetime import datetime
date = datetime.utcnow()
CS=m.nightshade(date)
plt.show()
# We now know how many counts there are per bin on the grid. We can now plot the grid locations with number of counts
lat_bin = gridx[np.where(grid > 0)[0]]
lon_bin = gridy[np.where(grid > 0)[1]]
count_bin = grid[np.where(grid > 0)]
# Make a plot of the world
plt.figure(figsize=(30, 15))
map = Basemap()
map.drawcoastlines()
map.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0])
map.drawmeridians(np.arange(map.lonmin, map.lonmax + 30, 60),
labels=[0, 0, 0, 1])
map.fillcontinents('white', lake_color='white')
map.drawcountries(linewidth=1, linestyle='solid', color='black', zorder=30)
date = datetime.utcnow()
CS = map.nightshade(date.replace(hour=8, minute=0, second=0,
microsecond=0))
plt.title('Wikipedia Edit Locations')
# Overlay the lat and long bins
# Scale the size and color so they are sensible
size = count_bin
plt.scatter(lat_bin,
lon_bin,
s=size,
alpha=0.8,
c=count_bin,
cmap='inferno',
zorder=10)
plt.colorbar(fraction=0.023, pad=0.04)
plt.savefig('./Report/Images/editlocations.png')
print './Report/Images/editlocations.png'
plt.clf()
def to_run(self):
# Setup lat long of telescope
home = ephem.Observer()
home.long = np.deg2rad(74.7421430) # +E
home.lat = np.deg2rad(13.3408810) # +N
home.elevation = 0 # meters
home.date = datetime.datetime.now()
# Always get the latest ISS TLE data from:
# http://spaceflight.nasa.gov/realdata/sightings/SSapplications/Post/JavaSSOP/orbit/ISS/SVPOST.html
iss = ephem.readtle(
'ISS',
'1 25544U 98067A 16274.50033672 .00016717 00000-0 10270-3 0 9003',
'2 25544 51.6383 252.7108 0006713 21.8902 338.2536 15.54019889 21364'
)
# Make some datetimes
current_time = datetime.datetime.now()
past_time = current_time + timedelta(hours=-1)
dt = [
current_time + timedelta(seconds=1 * x)
for x in range(0, 24 * 60 * 60)
]
dt_past = [
past_time + timedelta(seconds=1 * x) for x in range(0, 60 * 60)
]
# Compute satellite locations at each datetime
sat_lat, sat_lon, sat_latp, sat_lonp = [], [], [], []
for date in dt:
home.date = date
iss.compute(home)
sat_lon.append(np.rad2deg(iss.sublong))
sat_lat.append(np.rad2deg(iss.sublat))
for date in dt_past:
home.date = date
iss.compute(home)
sat_lonp.append(np.rad2deg(iss.sublong))
sat_latp.append(np.rad2deg(iss.sublat))
for i in range(len(sat_lon)):
if sat_lon[i] < 0:
sat_lon[i] = 360 + sat_lon[i]
for i in range(len(sat_lonp)):
if sat_lonp[i] < 0:
sat_lonp[i] = 360 + sat_lonp[i]
# miller projection
map = Basemap(projection='mill', lon_0=180)
# plot coastlines, draw label meridians and parallels.
map.drawcoastlines()
map.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0])
map.drawmeridians(np.arange(map.lonmin, map.lonmax + 30, 60),
labels=[0, 0, 0, 1])
# fill continents 'coral' (with zorder=0), color wet areas 'aqua'
map.drawmapboundary(fill_color='aqua')
# map.fillcontinents(color='coral',lake_color='aqua')
# shade the night areas, with alpha transparency so the
# map shows through. Use current time in UTC.
date = datetime.datetime.utcnow()
x, y = map(sat_lon, sat_lat)
x = np.atleast_1d(x)
y = np.atleast_1d(y)
xp, yp = map(sat_lonp, sat_latp)
xp = np.atleast_1d(xp)
yp = np.atleast_1d(yp)
CS = map.nightshade(date)
plt.scatter(xp, yp, color='y', s=5, label="Past Hour")
plt.ion()
for i in range(len(sat_lon)):
plt.scatter(x[i], y[i], color='r', label="realtime")
plt.pause(1)
while self.running:
plt.pause(1)
# plt.title('Day/Night Map for %s (UTC)' % date.strftime("%d %b %Y %H:%M:%S"))
# plt.show()
plt.close('all')
def map_plot(self, time, TLE):
start_mode = self.mode_choice.GetSelection()
m = Basemap(projection='mill',
area_thresh=1000.0,
llcrnrlat=south,
urcrnrlat=north,
llcrnrlon=west,
urcrnrlon=east)
#m.shadedrelief()
im = Image.open(resource_path('default_map.png'))
m.imshow(im, alpha=1)
m.nightshade(time + datetime.timedelta(hours=10))
#m.drawcoastlines()
# 一分ごとの人工衛星の位置をプロット
time_list = []
for t in range(-10, 100):
time_list.append(time + datetime.timedelta(minutes=t))
for t in time_list:
satellite = ephem.readtle(TLE[0], TLE[1], TLE[2])
satellite.compute(t)
latitude = satellite.sublat / ephem.degree
longitude = satellite.sublong / ephem.degree - 150
if longitude < -180:
longitude += 360
x1, y1 = m(longitude, latitude)
m.plot(x1, y1, marker=".", markersize=1, c='blue')
if self.mode_choice.GetSelection() != start_mode:
if self.mode_choice.GetSelection():
time = datetime.datetime.utcnow()
else:
time = self.get_time()
self.map_plot(time, TLE)
return 0
satellite = ephem.readtle(TLE[0], TLE[1], TLE[2])
satellite.compute(time)
latitude = satellite.sublat / ephem.degree
longitude = satellite.sublong / ephem.degree - 150
if longitude < -180:
longitude += 360
earth_radius = 6371000.
sat_loc = (latitude, longitude)
# define the position of the satellite
orbit = Orbital(TLE[0], line1=TLE[1], line2=TLE[2])
lon_dum, lat_dum, altitude = orbit.get_lonlatalt(time)
print(altitude)
position = [altitude * 1000, latitude, longitude]
radius = math.degrees(
math.acos(earth_radius / (earth_radius + position[0])))
print(longitude)
x1, y1 = m(longitude, latitude)
m.plot(x1, y1, marker="*", markersize=5, c='red')
if longitude < -90:
diff = longitude - (-180)
m = Basemap(projection='mill',
area_thresh=1000.0,
llcrnrlat=south,
urcrnrlat=north,
llcrnrlon=0,
urcrnrlon=360)
m.tissot(diff, latitude, radius, 100, facecolor='white', alpha=0.5)
m = Basemap(projection='mill',
area_thresh=1000.0,
llcrnrlat=south,
urcrnrlat=north,
llcrnrlon=-360,
urcrnrlon=0)
m.tissot(diff, latitude, radius, 100, facecolor='white', alpha=0.5)
elif longitude > 90:
diff = longitude - 180
m = Basemap(projection='mill',
area_thresh=1000.0,
llcrnrlat=south,
urcrnrlat=north,
llcrnrlon=0,
urcrnrlon=360)
m.tissot(diff, latitude, radius, 100, facecolor='white', alpha=0.5)
m = Basemap(projection='mill',
area_thresh=1000.0,
llcrnrlat=south,
urcrnrlat=north,
llcrnrlon=-360,
urcrnrlon=0)
m.tissot(diff, latitude, radius, 100, facecolor='white', alpha=0.5)
else:
m.tissot(longitude,
latitude,
radius,
100,
facecolor='white',
alpha=0.5)
plt.gca().spines['right'].set_visible(False)
plt.gca().spines['top'].set_visible(False)
plt.gca().spines['left'].set_visible(False)
plt.gca().spines['bottom'].set_visible(False)
plt.subplots_adjust(left=0, right=1, bottom=0, top=1)
buf = io.BytesIO()
plt.savefig(buf,
format='png',
dpi=300,
transparent=False,
bbox_inches='tight',
pad_inches=0)
#plt.savefig('map.png',format='png', dpi = 600, transparent = False, bbox_inches = 'tight', pad_inches = 0)
plt.close()
buf.seek(0)
self.output_map = buf
if self.mode_choice.GetSelection() != start_mode:
if self.mode_choice.GetSelection():
time = datetime.datetime.utcnow()
else:
time = self.get_time()
self.map_plot(time, TLE)
return 0
self.Image = wx.Image(buf, wx.BITMAP_TYPE_ANY)
self.wxImage = wx.Bitmap(self.Image) #画像リサイズ対象=wx.Bitmap
self.wxImage_re = scale_bitmap(self.wxImage, int(16 * self.ratio),
int(9 * self.ratio))
self.tracking_map.SetBitmap(self.wxImage_re)
import numpy as np
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
from datetime import datetime
# miller projection
map = Basemap(projection='mill',lon_0=180)
# plot coastlines, draw label meridians and parallels.
map.drawcoastlines()
map.drawparallels(np.arange(-90,90,30),labels=[1,0,0,0])
map.drawmeridians(np.arange(map.lonmin,map.lonmax+30,60),labels=[0,0,0,1])
# fill continents 'coral' (with zorder=0), color wet areas 'aqua'
map.drawmapboundary(fill_color='aqua')
map.fillcontinents(color='coral',lake_color='aqua')
# shade the night areas, with alpha transparency so the
# map shows through. Use current time in UTC.
date = datetime.utcnow()
CS=map.nightshade(date)
plt.title('Day/Night Map for %s (UTC)' % date.strftime("%d %b %Y %H:%M:%S"))
plt.show()
def compute(elem):
print("============== Gerando o mapa para a predicao ==============")
print("Predicao: [ %s ] Star RA: [ %s ] Dec: [ %s ]" %(elem, stars[elem].ra, stars[elem].dec))
r = 6370997.0
print("r: %s" % r)
########## aplica offsets ######
print("-------------- Aplica Offsets --------------")
off_ra = 0.0*u.mas
off_de = 0.0*u.mas
ob_ra = 0.0*u.mas
ob_de = 0.0*u.mas
if 'off_o' in kwargs.keys():
off_ra = off_ra + kwargs['off_o'][0]*u.mas
off_de = off_de + kwargs['off_o'][1]*u.mas
ob_ra = ob_off_ra[elem] + kwargs['off_o'][0]*u.mas
ob_de = ob_off_de[elem] + kwargs['off_o'][1]*u.mas
st_off_ra = st_off_de = 0.0*u.mas
if 'off_s' in kwargs.keys():
off_ra = off_ra - kwargs['off_s'][0]*u.mas
off_de = off_de - kwargs['off_s'][1]*u.mas
st_off_ra = kwargs['off_s'][0]*u.mas
st_off_de = kwargs['off_s'][1]*u.mas
dca = off_ra*np.sin(posa[elem]) + off_de*np.cos(posa[elem])
dt = ((off_ra*np.cos(posa[elem]) - off_de*np.sin(posa[elem])).to(u.rad)*dist[elem].to(u.km)/np.absolute(vel[elem])).value*u.s
ca1 = ca[elem] + dca
data = datas[elem] + dt
print("off_ra: %s" % off_ra)
print("off_de: %s" % off_de)
print("ob_ra: %s" % ob_ra)
print("ob_de: %s" % ob_de)
print("st_off_ra: %s" % st_off_ra)
print("dca: %s" % dca)
print("dt: %s" % dt)
print("ca1: %s" % ca1)
print("data: %s" % data)
##### define parametros do mapa #####
print("-------------- define parametros do mapa --------------")
lon = stars[elem].ra - data.sidereal_time('mean', 'greenwich')
center_map = EarthLocation(lon, stars[elem].dec)
centert = True
if 'centermap' in kwargs.keys():
if not type(kwargs['centermap']) == EarthLocation:
raise TypeError('centermap must be an Astropy EarthLocation Object')
center_map = kwargs['centermap']
centert = False
fig = plt.figure(figsize=(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value))
if not limits:
m = Basemap(projection='ortho',lat_0=center_map.lat.value,lon_0=center_map.lon.value,resolution=resolution)
elif np.array(limits).shape == (3,):
if maplats:
m = Basemap(projection='ortho',lat_0=center_map.lat.value,lon_0=center_map.lon.value,resolution=resolution)
cx, cy = m(limits[1], limits[0])
limits[0] = (cx - r)/1000.0
limits[1] = (cy - r)/1000.0
if np.any(np.absolute(limits[0:2]) > r):
raise ValueError('Value for limits out of range (not in the map)')
if mapsize[1] < mapsize[0]:
ly = (limits[1]*u.km).to(u.m).value - r/limits[2]
uy = (limits[1]*u.km).to(u.m).value + r/limits[2]
lx = (limits[0]*u.km).to(u.m).value - (r/limits[2])*(mapsize[0]/mapsize[1])
ux = (limits[0]*u.km).to(u.m).value + (r/limits[2])*(mapsize[0]/mapsize[1])
else:
lx = (limits[0]*u.km).to(u.m).value - r/limits[2]
ux = (limits[0]*u.km).to(u.m).value + r/limits[2]
ly = (limits[1]*u.km).to(u.m).value - (r/limits[2])*(mapsize[1]/mapsize[0])
uy = (limits[1]*u.km).to(u.m).value + (r/limits[2])*(mapsize[1]/mapsize[0])
m = Basemap(projection='ortho',lat_0=center_map.lat.value,lon_0=center_map.lon.value,resolution=resolution,llcrnrx=lx,llcrnry=ly,urcrnrx=ux,urcrnry=uy, area_thresh=2000)
axf = fig.add_axes([-0.001,-0.001,1.002,1.002])
axf.set_rasterization_zorder(1)
else:
raise ValueError('limits keyword must be an array with 3 elements: [centerx, centery, zoom]')
if mapstyle == 1:
m.drawmapboundary(fill_color='0.9')
m.fillcontinents(color='1.0',lake_color='0.9')
ptcolor= 'red'
lncolor= 'blue'
ercolor= 'blue'
rncolor= 'blue'
atcolor= 'blue'
outcolor= 'red'
elif mapstyle == 2:
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
ptcolor= 'red'
lncolor= 'blue'
ercolor= 'red'
rncolor= 'black'
atcolor= 'black'
outcolor= 'red'
elif mapstyle == 3:
m.shadedrelief()
ptcolor= 'red'
lncolor= 'blue'
ercolor= 'red'
rncolor= 'black'
atcolor= 'black'
outcolor= 'red'
elif mapstyle == 4:
m.bluemarble()
ptcolor= 'red'
lncolor= 'red'
ercolor= 'red'
rncolor= 'black'
atcolor= 'black'
outcolor= 'red'
elif mapstyle == 5:
m.etopo()
ptcolor= 'red'
lncolor= 'red'
ercolor= 'red'
rncolor= 'black'
atcolor= 'black'
outcolor= 'red'
m.drawcoastlines(linewidth=0.5) ## desenha as linhas da costa
m.drawcountries(linewidth=0.5) ## desenha os paises
if 'states' in kwargs.keys():
m.drawstates(linewidth=0.5) ## Desenha os estados
m.drawmeridians(np.arange(0,360,meridians)) ## desenha os meridianos
m.drawparallels(np.arange(-90,90,parallels)) ## desenha os paralelos
m.drawmapboundary() ## desenha o contorno do mapa
m.nightshade(data.datetime, alpha=0.25, zorder=1.2) ## desenha a sombra da noite
if 'ptcolor' in kwargs.keys():
ptcolor = kwargs['ptcolor']
if 'lncolor' in kwargs.keys():
lncolor = kwargs['lncolor']
if 'ercolor' in kwargs.keys():
ercolor = kwargs['ercolor']
if 'rncolor' in kwargs.keys():
rncolor = kwargs['rncolor']
if 'atcolor' in kwargs.keys():
atcolor = kwargs['atcolor']
if 'outcolor' in kwargs.keys():
outcolor = kwargs['outcolor']
########### calcula caminho ##################
print("-------------- calcula caminho --------------")
vec = np.arange(0, int(8000/(np.absolute(vel[elem].value))), step)
vec = np.sort(np.concatenate((vec,-vec[1:]), axis=0))
pa = Angle(posa[elem])
pa.wrap_at('180d', inplace=True)
if pa > 90*u.deg:
paplus = pa - 180*u.deg
elif pa < -90*u.deg:
paplus = pa + 180*u.deg
else:
paplus = pa
deltatime = vec*u.s
datas1 = data + TimeDelta(deltatime)
datas1.delta_ut1_utc = 0
longg = stars[elem].ra - datas1.sidereal_time('mean', 'greenwich')
centers = EarthLocation(longg, stars[elem].dec, height=0.0*u.m)
a = r*u.m
b = r*u.m
dista = (dist[elem].to(u.km)*ca1.to(u.rad)).value*u.km
ax = a + dista*np.sin(pa) + (deltatime*vel[elem])*np.cos(paplus)
by = b + dista*np.cos(pa) - (deltatime*vel[elem])*np.sin(paplus)
ax2 = ax - (diam/2.0)*np.sin(paplus)
by2 = by - (diam/2.0)*np.cos(paplus)
ax3 = ax + (diam/2.0)*np.sin(paplus)
by3 = by + (diam/2.0)*np.cos(paplus)
lon1, lat1 = xy2latlon(ax2.value, by2.value, centers.lon.value, centers.lat.value)
j = np.where(lon1 < 1e+30)
xs, ys = m(lon1[j], lat1[j])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=lncolor)
if centert:
j = np.where(lon1 > 1e+30)
m.plot(ax2[j].value, by2[j].value, color=outcolor, clip_on=False, zorder=-0.2)
lon2, lat2 = xy2latlon(ax3.value, by3.value, centers.lon.value, centers.lat.value)
j = np.where(lon2 < 1e+30)
xt, yt = m(lon2[j], lat2[j])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=lncolor)
if centert:
j = np.where(lon2 > 1e+30)
m.plot(ax3[j].value, by3[j].value, color=outcolor, clip_on=False, zorder=-0.2)
##### plot erro #####
if erro:
err = erro*u.mas
errd = (dist[elem].to(u.km)*err.to(u.rad)).value*u.km
ax2 = ax - errd*np.sin(paplus) - (diam/2.0)*np.sin(paplus)
by2 = by - errd*np.cos(paplus) - (diam/2.0)*np.cos(paplus)
ax3 = ax + errd*np.sin(paplus) + (diam/2.0)*np.sin(paplus)
by3 = by + errd*np.cos(paplus) + (diam/2.0)*np.cos(paplus)
lon1, lat1 = xy2latlon(ax2.value, by2.value, centers.lon.value, centers.lat.value)
j = np.where(lon1 < 1e+30)
xs, ys = m(lon1[j], lat1[j])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=ercolor)
lon2, lat2 = xy2latlon(ax3.value, by3.value, centers.lon.value, centers.lat.value)
j = np.where(lon2 < 1e+30)
xt, yt = m(lon2[j], lat2[j])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=ercolor)
##### plot ring #####
if ring:
rng = ring*u.km
ax2 = ax - rng*np.sin(paplus)
by2 = by - rng*np.cos(paplus)
ax3 = ax + rng*np.sin(paplus)
by3 = by + rng*np.cos(paplus)
lon1, lat1 = xy2latlon(ax2.value, by2.value, centers.lon.value, centers.lat.value)
j = np.where(lon1 < 1e+30)
xs, ys = m(lon1[j], lat1[j])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=rncolor)
lon2, lat2 = xy2latlon(ax3.value, by3.value, centers.lon.value, centers.lat.value)
j = np.where(lon2 < 1e+30)
xt, yt = m(lon2[j], lat2[j])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=rncolor)
##### plot atm #####
if atm:
atmo = atm*u.km
ax2 = ax - atmo*np.sin(paplus)
by2 = by - atmo*np.cos(paplus)
ax3 = ax + atmo*np.sin(paplus)
by3 = by + atmo*np.cos(paplus)
lon1, lat1 = xy2latlon(ax2.value, by2.value, centers.lon.value, centers.lat.value)
j = np.where(lon1 < 1e+30)
xs, ys = m(lon1[j], lat1[j])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=atcolor)
lon2, lat2 = xy2latlon(ax3.value, by3.value, centers.lon.value, centers.lat.value)
j = np.where(lon2 < 1e+30)
xt, yt = m(lon2[j], lat2[j])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=atcolor)
##### plot clat #####
vec = np.arange(0, int(8000/(np.absolute(vel[elem].value))), cpoints)
deltatime = np.sort(np.concatenate((vec,-vec[1:]), axis=0))*u.s
axc = a + dista*np.sin(pa) + (deltatime*vel[elem])*np.cos(paplus)
byc = b + dista*np.cos(pa) - (deltatime*vel[elem])*np.sin(paplus)
if centert:
m.plot(axc.value, byc.value, 'o', color=ptcolor, clip_on=False, markersize=mapsize[0].value*pscale*8.0/46.0, zorder=-0.2)
datas2 = data + TimeDelta(deltatime)
datas2.delta_ut1_utc = 0
lon3 = stars[elem].ra - datas2.sidereal_time('mean', 'greenwich')
clon1, clat1 = xy2latlon(axc.value, byc.value, lon3.value, stars[elem].dec.value)
j = np.where(clon1 < 1e+30)
xc, yc = m(clon1[j], clat1[j])
xc = [i for i in xc if i < 1e+30]
yc = [i for i in yc if i < 1e+30]
m.plot(xc, yc, 'o', color=ptcolor, clip_on=False, markersize=mapsize[0].value*pscale*8.0/46.0)
# xc, yc = m(lon.value, stars[elem].dec.value)
if centert:
m.plot(a + dista*np.sin(pa), b + dista*np.cos(pa), 'o', color=ptcolor, clip_on=False, markersize=mapsize[0].value*pscale*24.0/46.0)
######## Define o titulo e o label da saida #########
title = 'Object Diam Tmax dots <> ra_off_obj_de ra_of_star_de\n{:10s} {:4.0f} km {:5.1f}s {:02d} s <>{:+6.1f} {:+6.1f} {:+6.1f} {:+6.1f} \n'\
.format(obj, diam.value, (diam/np.absolute(vel[elem])).value, cpoints, ob_ra.value, ob_de.value, st_off_ra.value, st_off_de.value)
labelx = '\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta G* long\n\
{} {:02d} {:02d} {:07.4f} {:+03d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:3.0f}'.format(data.iso,
int(stars[elem].ra.hms.h), int(stars[elem].ra.hms.m), stars[elem].ra.hms.s, int(stars[elem].dec.dms.d), np.absolute(int(stars[elem].dec.dms.m)), np.absolute(stars[elem].dec.dms.s),
ca1.value, posa[elem].value, vel[elem].value, dist[elem].value, magR[elem], longi[elem])
########### plota seta de direcao ##################
print("--------- plota seta de direcao ---------")
print("Limits: %s" % limits)
if not limits:
print(a+5500000*u.m,b-5500000*u.m, np.sin(paplus+90*u.deg)*np.sign(vel[elem]), np.cos(paplus+90*u.deg)*np.sign(vel[elem]))
tmp_sin = np.sin(paplus+90*u.deg)*np.sign(vel[elem])
tmp_cos = np.cos(paplus+90*u.deg)*np.sign(vel[elem])
# plt.quiver(11870997,870997, 0.84395364, 0.53641612, width=0.005)
plt.quiver(a+5500000*u.m,b-5500000*u.m, tmp_sin.value, tmp_cos.value, width=0.005)
# plt.quiver(a+5500000*u.m,b-5500000*u.m, np.sin(paplus+90*u.deg)*np.sign(vel[elem]), np.cos(paplus+90*u.deg)*np.sign(vel[elem]), width=0.005)
else:
plt.quiver(a.value + lx + (ux-lx)*0.9,b.value + ly + (uy-ly)*0.1, np.sin(paplus+90*u.deg)*np.sign(vel[elem]), np.cos(paplus+90*u.deg)*np.sign(vel[elem]), width=0.005, zorder = 1.3)
####### imprime os nomes dos paises #####
print("--------- imprime os nomes dos paises ---------")
if os.path.isfile(country) == True:
paises = np.loadtxt(country, dtype={'names': ('nome', 'lat', 'lon'), 'formats': ('S30', 'f8', 'f8')}, delimiter=',', ndmin=1)
xpt,ypt = m(paises['lon'], paises['lat'])
for i in np.arange(len(xpt)):
plt.text(xpt[i],ypt[i],np.char.strip(paises['nome'][i]), weight='bold', color='grey', fontsize=30*cscale)
####### imprime os sitios ##############
print("--------- imprime os sitios ---------")
if os.path.isfile(sitearq) == True:
sites = np.loadtxt(sitearq, ndmin=1, dtype={'names': ('lat', 'lon', 'alt', 'nome', 'offx', 'offy', 'color'), 'formats': ('f8', 'f8', 'f8', 'S30', 'f8', 'f8', 'S30')}, delimiter=',')
print(sites)
xpt,ypt = m(sites['lon'],sites['lat'])
sss = EarthLocation(sites['lon']*u.deg,sites['lat']*u.deg,sites['alt']*u.km)
for i in np.arange(len(xpt)):
m.plot(xpt[i],ypt[i],'o', markersize=mapsize[0].value*sscale*10.0/46.0, color=sites['color'][i].strip().decode('utf-8'))
plt.text(xpt[i] + sites['offx'][i]*1000,ypt[i]+sites['offy'][i]*1000, sites['nome'][i].strip().decode('utf-8'), weight='bold', fontsize=25*nscale)
####### finaliza a plotagem do mapa#####
print("--------- finaliza a plotagem do mapa ---------")
plt.title(title, fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
plt.xlabel(labelx, fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
if 'nameimg' in kwargs.keys():
nameimg = kwargs['nameimg']
else:
nameimg = '{}_{}'.format(obj, data.isot)
print("nameimg: %s" % nameimg)
print("fmt: %s" % fmt)
print("dpi: %s" % dpi)
plt.savefig('{}.{}'.format(nameimg, fmt), format=fmt, dpi=dpi)
print('Gerado: {}.{}'.format(nameimg, fmt))
plt.clf()
plt.close()
def geramapa(delt):
deltatime = delt*u.s
datas1 = datas[idx] + TimeDelta(deltatime)
datas1.delta_ut1_utc = 0
lon = stars[idx].ra - datas1.sidereal_time('mean', 'greenwich')
m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution=resolution)
# m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution=resolution, llcrnrx=-7000000,llcrnry=-7000000,urcrnrx=7000000,urcrnry=7000000)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
m.drawmapboundary()
ptcolor = 'black'
lncolor = 'black'
dscolor = 'black'
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '3':
m.shadedrelief()
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '4':
m.bluemarble()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
elif mapstyle == '5':
m.etopo()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
if os.path.isfile(sitearq) == True:
xpt,ypt = m(sites['lon'],sites['lat'])
m.plot(xpt,ypt,'bo')
CS=m.nightshade(datas1.datetime, alpha=0.2)
a, b =m(lon.value, stars[idx].dec.value)
a = a*u.m
b = b*u.m
dista = (dist[idx].to(u.km)*ca[idx].to(u.rad)).value*u.km
disterr = (dist[idx].to(u.km)*erro.to(u.rad)).value*u.km
ax = a + dista*np.sin(pa[idx]) + (deltatime*vel[idx])*np.cos(pa[idx])
by = b + dista*np.cos(pa[idx]) - (deltatime*vel[idx])*np.sin(pa[idx])
m.plot(ax,by, 'o', color=ptcolor, markersize=mapsize[0].value*20/46)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
plt.title('-{} D={}- dots each 60 s <> offsets (mas): obj=({:.1f},{:.1f}), star=({:.1f},{:.1f})\n'
.format(obj, tamanho, ob_off_ra[idx].value, ob_off_de[idx].value, st_off_ra[idx].value, st_off_de[idx].value), fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
plt.xlabel('\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
.format(datas1.iso, int(stars[idx].ra.hms.h), int(stars[idx].ra.hms.m), stars[idx].ra.hms.s, int(stars[idx].dec.dms.d), np.absolute(int(stars[idx].dec.dms.m)), np.absolute(stars[idx].dec.dms.s),
ca[idx].value, pa[idx].value, vel[idx].value, dist[idx].value, magR[idx], magK[idx], longi[idx]), fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
plt.savefig('{}_{:05d}.png'.format(obj, np.where(g==delt)[0][0] + 1),dpi=100)
print 'Gerado: {}_{:05d}.png'.format(obj, np.where(g==delt)[0][0] + 1)
plt.clf()
def geramapa(idx):
lons1, lats1, lons2, lats2, clon, clat, lab = calcfaixa(idx)
# lon = stars[idx].ra - datas1.sidereal_time('mean', 'greenwich')
center_map = EarthLocation('-77 02 28.3','38 49 19.1')
fig = plt.figure(figsize=(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value))
m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution,llcrnrx=-2000000.,llcrnry=-1500000.,urcrnrx=2000000.,urcrnry=1500000.)
# m = Basemap(projection='ortho',lat_0=stars[idx].dec.value,lon_0=lon.value,resolution=resolution)
ax = fig.add_axes([-0.003,-0.001,1.006,1.002])
ax.set_rasterization_zorder(1)
m.nightshade(datas.datetime, alpha=0.2, zorder=0.5)
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawstates(linewidth=0.5)
m.drawmeridians(np.arange(0,360,30))
m.drawparallels(np.arange(-90,90,30))
m.drawmapboundary()
ptcolor = 'red'
lncolor = 'black'
dscolor = 'black'
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '3':
m.shadedrelief()
ptcolor = 'red'
lncolor = 'blue'
dscolor = 'red'
elif mapstyle == '4':
m.bluemarble()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
elif mapstyle == '5':
m.etopo()
ptcolor = 'red'
lncolor = 'red'
dscolor = 'red'
a, b =m(center_map.longitude.value, center_map.latitude.value)
a = a*u.m
b = b*u.m
# dista = (dist[idx].to(u.km)*ca[idx].to(u.rad)).value*u.km
# disterr = (dist[idx].to(u.km)*erro.to(u.rad)).value*u.km
# vec = np.arange(0,7000,(np.absolute(vel)*(30*u.s)).value)*u.km + np.absolute(vel)*(30*u.s)
# vec = np.concatenate((vec.value,-vec.value), axis=0)*u.km
# ax = a + dista*np.sin(pa[idx])
# ax2 = ax + vec*np.cos(pa[idx])
# ax3 = ax2 - tamanho/2*np.sin(pa[idx])
# ax4 = ax2 + tamanho/2*np.sin(pa[idx])
# ax5 = a + (dista-disterr)*np.sin(pa[idx]) + vec*np.cos(pa[idx])
# ax6 = a + (dista+disterr)*np.sin(pa[idx]) + vec*np.cos(pa[idx])
# by = b + dista*np.cos(pa[idx])
# by2 = by - vec*np.sin(pa[idx])
# by3 = by2 - tamanho/2*np.cos(pa[idx])
# by4 = by2 + tamanho/2*np.cos(pa[idx])
# by5 = b + (dista-disterr)*np.cos(pa[idx]) - vec*np.sin(pa[idx])
# by6 = b + (dista+disterr)*np.cos(pa[idx]) - vec*np.sin(pa[idx])
xs, ys = m(lons1, lats1)
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, 'b')
xt, yt = m(lons2, lats2)
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, 'b')
xc, yc = m(clon, clat)
labe = [lab[i] for i in np.arange(len(lab)) if xc[i] < 1e+30]
xc = [i for i in xc if i < 1e+30]
yc = [i for i in yc if i < 1e+30]
m.plot(xc, yc, 'or')
# m.plot(ax,by, 'o', color=ptcolor, markersize=int(mapsize[0].value*20/46))
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=int(mapsize[0].value*12/46))
# m.plot(ax3.to(u.m), by3.to(u.m), color=lncolor)
# m.plot(ax4.to(u.m), by4.to(u.m), color=lncolor)
m.quiver(a-0*u.m,b-600000*u.m, 20, 0, width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
#
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
for label, axpt, bypt in zip(labe, xc, yc):
ax.text(axpt + 0, bypt + 350000, label, rotation=60, weight='bold')
if os.path.isfile(sitearq) == True:
xpt,ypt = m(sites['lon'],sites['lat'])
m.plot(xpt,ypt,'bo')
offset = [[xpt[0] + 100000,xpt[0] + 100000,xpt[0] + 100000,xpt[3] + 400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000],[10000,-30000,-60000,70000,30000,-20000,-70000,-30000,-70000]]
for i in np.arange(len(xpt)):
ax.text(offset[0][i],ypt[i]+offset[1][i],sites['nome'][i], weight='bold')
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
# plt.title('Objeto Diam dots <> ra_off_obj_de ra_of_star_de\n{:10s} {:4.0f} km 60 s <> {:+6.1f} {:+6.1f} {:+6.1f} {:+6.1f} \n'
# .format(obj, tamanho.value, ob_off_ra[idx].value, ob_off_de[idx].value, st_off_ra[idx].value, st_off_de[idx].value), fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
# plt.xlabel('\n year-m-d h:m:s UT ra__dec__J2000__candidate C/A P/A vel Delta R* K* long\n\
#{} {:02d} {:02d} {:07.4f} {:+02d} {:02d} {:06.3f} {:6.3f} {:6.2f} {:6.2f} {:5.2f} {:5.1f} {:4.1f} {:3.0f}'
# .format(datas[idx].iso, int(stars[idx].ra.hms.h), int(stars[idx].ra.hms.m), stars[idx].ra.hms.s, int(stars[idx].dec.dms.d), np.absolute(int(stars[idx].dec.dms.m)), np.absolute(stars[idx].dec.dms.s),
# ca[idx].value, pa[idx].value, vel[idx].value, dist[idx].value, magR[idx], magK[idx], longi[idx]), fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
plt.savefig('{}_{}.eps'.format(obj, datas.isot), format='eps', dpi=300)
print 'Gerado: {}_{}.eps'.format(obj, datas.isot)
plt.clf()
from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt from datetime import datetime map = Basemap(projection='vandg',lon_0=0,resolution='c') map.drawmapboundary(fill_color="#7777ff") map.fillcontinents(color="#ddaa66",lake_color="#7777ff") map.drawcoastlines() map.nightshade(datetime.now(), delta=0.2) plt.show()
class ISSData():
Arrays=[]
rows = 0
n = 0
step = 1104
Headers = []
Directory = ''
normPath = ""
chatty = False
map = ""
ag =""
def __init__(self,fileName,directory=""):
""" Check to see if files exists
"""
self.map = Basemap(projection='mill',lon_0=-10)
normPath = os.path.normpath(directory+fileName)
try:
dFile= open(normPath,"r")
except:
print "Cannot open", normPath
# save tested path for later use
self.normPath = normPath
dFile.close()
def readDataFromFile(self):
NL=0
with open(self.normPath) as file:
for line in file:
line= line.rstrip()
NL +=1
ns = line.split(",")
if (NL==1):
headers= ns
for h in headers:
self.Headers.append(h)
self.Headers.pop(-1) # remove time stamp header as time is not a float
for val in ns:
empty=[]
self.Arrays.append(empty)
else:
nv = 0
for val in ns:
self.Arrays[nv].append(val)
nv +=1
file.close()
self.rows = len(self.Arrays[0])
nh=0
print " File", self.normPath, " rows=", self.rows, self.rows/360, "hours"
print self.Arrays[19][0]," - ", self.Arrays[19][-1]
print " Measurement # min max median average stddev"
for h in self.Headers:
narray = np.array(self.Arrays[nh]).astype(np.float32)
if (nh == 0):
# each data point is 10 secs so this scales x axis to minutes
narray = narray / 6.0
#Calculate some basic stats on each row
max = np.amax(narray)
if (headers[nh] == "pitch") or (headers[nh] == "yaw") :
if (max >= 20000.):
# convert from radians to degrees?
# in the first Spacecraft dataset only (I think)
narray = narray / 57.3
nv=0
for val in narray:
if (val <= -180.0):
narray[nv] = narray[nv] + 360.0
elif (val >= 180.0):
narray[nv] = narray[nv] - 360.0
nv +=1
# pitch looks better when normalized about zero
max = np.amax(narray)
min = np.amin(narray)
med = np.median(narray)
aver = np.average(narray)
stddev = np.std(narray)
print "%12s %6s %10.5f %10.5f %10.5f %10.5f %10.5f" % (h, nh, min,max, med, aver, stddev)
self.Arrays[nh] = narray
nh +=1
# Normalize
def printStats(self,param=1,n=0,step=1104):
print step,"datapoints - ", (self.Arrays[19][n])," - ", \
(self.Arrays[19][n+step])
print " Measurement # min max median average stddev"
min = np.amin(self.Arrays[param][n:n+step])
max = np.amax(self.Arrays[param][n:n+step])
med = np.median(self.Arrays[param][n:n+step])
aver = np.average(self.Arrays[param][n:n+step])
stddev = np.std(self.Arrays[param][n:n+step])
print "%12s %6s %10.5f %10.5f %10.5f %10.5f %10.5f" % ( self.Headers[param], param, min,max, med, aver, stddev)
def drawNightDay(self,param=1,n=0,step=1104):
if (self.chatty): print self.Headers[param], n,step
cn = int(n + step /2)
ct = self.Arrays[19][cn]
print "Centre time period = ", ct
# miller projection
# plot coastlines, draw label meridians and parallels.
self.map.drawcoastlines()
self.map.drawparallels(np.arange(-90,90,30),labels=[1,0,0,0])
self.map.drawmeridians(np.arange(self.map.lonmin,self.map.lonmax+30,60),labels=[0,0,0,1])
# fill continents 'coral' (with zorder=0), color wet areas 'aqua'
self.map.drawmapboundary(fill_color='white')
self.map.fillcontinents(color='coral',lake_color='white')
# shade the night areas, with alpha transparency so the
# map shows through. Use current time in UTC.
#en = el.findIndexFromDate(ct)
#eo = el.extractISSfromIndex(en)
#print eo
date = el.findDateFromString(ct)
if (step <= 1104):
self.map.nightshade(date)
else: print "Track too long for night shading"
plt.title('ISS Track %s (UTC)' % ct)
# self.drawIssTrack(elements,param,n,step)
def drawIssTrack(self,elements,param=1,n=0,step=1104):
st = self.Arrays[19][n]
et = self.Arrays[19][n+step]
print "Plotting from - ", st, " to ", et
cn = int(n + step /2)
ct = self.Arrays[19][cn]
line1,line2=elements.elemsFromDateString(ct)
if (self.chatty): print "drawIssTrack", n,step, ct, line1, line2
for nn in range(n,n+step,6):
ntime = self.Arrays[19][nn]
#if self.chatty: print ntime
tle_rec = ephem.readtle("ISS", line1, line2)
tle_rec.compute(ntime)
#convert to strings#
lat2string = str(tle_rec.sublat)
long2string = str(tle_rec.sublong)
lati = lat2string.split(":")
longt = long2string.split(":")
#if self.chatty: print "ISS SUBSURFACE -", lati,longt
lat = float(lati[0]) + float(lati[1])/60. + float(lati[2])/3600.
lon = float(longt[0]) + float(longt[1])/60. + float(longt[2])/3600.
xpt,ypt=self.map(lon,lat)
# drawing style
kargs = "g+"
if (nn == n):
plt.text(xpt,ypt,"start")
if (nn >= (n+step -6) ):
plt.text(xpt,ypt,"end")
# make every 5 mins dot
if ((nn % 30) == 0): kargs = "g."
self.map.plot(xpt,ypt,kargs)
def drawDataPlot(self,param=1,n=0,step=1104):
plt.figure(1)
plt.clf()
plt.title(self.Headers[param])
plt.plot(self.Arrays[0][n:(n+step)],self.Arrays[param][n:(n+step)])
#self.ag.set_xdata(self.Arrays[0][n:(n+step)])
plt.draw()
def plot_simulated_data(ivm, filename=None):
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
from matplotlib.collections import LineCollection
from mpl_toolkits.basemap import Basemap
if filename is None:
out_fname = './summary_orbit_simulated_data.png'
else:
out_fname = filename
# make monotonically increasing longitude signal
diff = ivm['glong'].diff()
idx, = np.where(diff < 0.)
for item in idx:
ivm[item:, 'glong'] += 360.
f = plt.figure(figsize=(8.5, 7))
time1 = ivm.data.index[0].strftime('%Y-%h-%d %H:%M:%S')
if ivm.data.index[0].date() == ivm.data.index[-1].date():
time2 = ivm.data.index[-1].strftime('%H:%M:%S')
else:
time2 = ivm.data.index[-1].strftime('%Y-%h-%d %H:%M:%S')
# Overall Plot Title
plt.suptitle(''.join(('SPORT IVM ', time1, ' -- ', time2)), fontsize=18)
# create grid for plots
gs = gridspec.GridSpec(5, 2, width_ratios=[12, 1])
ax = f.add_subplot(gs[0, 0])
plt.plot(np.log10(ivm['ion_dens']), 'k', label='total')
plt.plot(np.log10(ivm['ion_dens'] * ivm['frac_dens_o']), 'r', label='O+')
plt.plot(np.log10(ivm['ion_dens'] * ivm['frac_dens_h']), 'b', label='H+')
# plt.plot(np.log10(ivm['ion_dens']*ivm['frac_dens_he']), 'g', label='He+')
plt.legend(loc=(01.01, 0.15))
ax.set_title('Log Ion Density')
ax.set_ylabel('Log Density (N/cc)')
ax.set_ylim([1., 6.])
ax.axes.get_xaxis().set_visible(False)
ax2 = f.add_subplot(gs[1, 0], sharex=ax)
plt.plot(ivm['ion_temp'])
plt.legend(loc=(1.01, 0.15))
ax2.set_title('Ion Temperature')
ax2.set_ylabel('Temp (K)')
ax2.set_ylim([500., 1500.])
ax2.axes.get_xaxis().set_visible(False)
# determine altitudes greater than 770 km
# idx, = np.where(ivm['alt'] > 770.)
ax3 = f.add_subplot(gs[2, 0], sharex=ax)
plt.plot(ivm['sim_wind_sc_x'], color='b', linestyle='--')
plt.plot(ivm['sim_wind_sc_y'], color='r', linestyle='--')
plt.plot(ivm['sim_wind_sc_z'], color='g', linestyle='--')
ax3.set_title('Neutral Winds in S/C X, Y, and Z')
ax3.set_ylabel('Velocity (m/s)')
ax3.set_ylim([-200., 200.])
ax3.axes.get_xaxis().set_visible(False)
plt.legend(loc=(1.01, 0.15))
ax3.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%H:%M'))
# # xlabels = [label[0:6] for label in xlabels]
# plt.setp(ax3.xaxis.get_majorticklabels(), rotation=20, ha='right')
ax4 = f.add_subplot(gs[3, 0], sharex=ax)
plt.plot(ivm['B_sc_x'] * 1e5, color='b', linestyle='--')
plt.plot(ivm['B_sc_y'] * 1e5, color='r', linestyle='--')
plt.plot(ivm['B_sc_z'] * 1e5, color='g', linestyle='--')
ax4.set_title('Magnetic Field in S/C X, Y, and Z')
ax4.set_ylabel('Gauss')
ax4.set_ylim([-3.5, 3.5])
# ax3.axes.get_xaxis().set_visible(False)
plt.legend(loc=(1.01, 0.15))
ax4.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%H:%M'))
# # xlabels = [label[0:6] for label in xlabels]
plt.setp(ax4.xaxis.get_majorticklabels(), rotation=20, ha='right')
# ivm info
ax6 = f.add_subplot(gs[4, 0])
# do world plot if time to be plotted is less than 285 minutes, less than 3 orbits
time_diff = ivm.data.index[-1] - ivm.data.index[0]
if time_diff > pds.Timedelta(minutes=285):
# # do long time plot
ivm['glat'].plot(label='glat') #legend=True, label='mlat')
ivm['mlt'].plot(label='mlt') #legend=True, label='mlt')
plt.title('Satellite Position')
plt.legend(['mlat', 'mlt'], loc=(1.01, 0.15))
# ivm['glong'].plot(secondary_y = True, label='glong')#legend=True, secondary_y = True, label='glong')
else:
# make map the same size as the other plots
s1pos = plt.get(ax, 'position').bounds
s6pos = plt.get(ax6, 'position').bounds
ax6.set_position([s1pos[0], s6pos[1] + .008, s1pos[2], s1pos[3]])
#fix longitude range for plot. Pad longitude so that first sample aligned with
#ivm measurement sample
lon0 = ivm[0, 'glong']
lon1 = ivm[-1, 'glong']
# print (lon0, lon1)
# enforce minimal longitude window, keep graphics from being too disturbed
if (lon1 - lon0) < 90:
lon0 -= 45.
lon1 += 45.
if lon1 > 720:
lon0 -= 360.
lon1 -= 360.
ivm[:, 'glong'] -= 360.
# print (lon0, lon1)
m=Basemap(projection='mill', llcrnrlat=-60, urcrnrlat=60., urcrnrlon=lon1.copy(), \
llcrnrlon=lon0.copy(), resolution='c', ax=ax6, fix_aspect=False)
# m is an object which manages drawing to the map
# it also acts as a transformation function for geo coords to plotting coords
# coastlines
m.drawcoastlines(ax=ax6)
# get first longitude meridian to plot
plon = np.ceil(lon0 / 60.) * 60.
m.drawmeridians(np.arange(plon, plon + 360. - 22.5, 60),
labels=[0, 0, 0, 1],
ax=ax6)
m.drawparallels(np.arange(-20, 20, 20))
# time midway through ivm to plot terminator locations
midDate = ivm.data.index[len(ivm.data.index) // 2]
# plot day/night terminators
try:
cs = m.nightshade(midDate)
except ValueError:
pass
x, y = m(ivm['glong'].values, ivm['glat'].values)
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
plot_norm = plt.Normalize(300, 500)
try:
plot_cmap = plt.get_cmap('viridis')
except:
plot_cmap = plt.get_cmap('jet')
lc = LineCollection(segments,
cmap=plot_cmap,
norm=plot_norm,
linewidths=5.0)
lc.set_array(ivm['alt'].values)
sm = plt.cm.ScalarMappable(cmap=plot_cmap, norm=plot_norm)
sm._A = []
ax6.add_collection(lc)
ax6_bar = f.add_subplot(gs[4, 1])
#plt.colorbar(sm)
cbar = plt.colorbar(cax=ax6_bar,
ax=ax6,
mappable=sm,
orientation='vertical',
ticks=[300., 400., 500.])
plt.xlabel('Altitude')
plt.ylabel('km')
f.tight_layout()
# buffer for overall title
f.subplots_adjust(bottom=0.06, top=0.91, right=.91)
plt.subplots_adjust(hspace=.44)
plt.savefig(out_fname)
return
def plot_burst_map(fig,
gps_data,
show_terminator=True,
plot_trajectory=True,
show_transmitters=True,
TLE_file=None,
print_GPS_entries=True,
TX_file='resources/nb_transmitters.conf'):
logger = logging.getLogger()
m_ax = fig.add_subplot(1, 1, 1)
m = Basemap(projection='mill',
lon_0=0,
ax=m_ax,
llcrnrlon=-180,
llcrnrlat=-70,
urcrnrlon=180,
urcrnrlat=70)
lats = [x['lat'] for x in gps_data]
lons = [x['lon'] for x in gps_data]
T_gps = np.array([x['timestamp'] for x in gps_data])
sx, sy = m(lons, lats)
m.drawcoastlines(color='k', linewidth=1, ax=m_ax)
m.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(m.lonmin, m.lonmax + 30, 60),
labels=[0, 0, 1, 0])
m.drawmapboundary(fill_color='cyan')
m.fillcontinents(color='white', lake_color='cyan')
if show_terminator:
try:
# Find the median timestamp to use:
avg_ts = np.mean(
[k['timestamp'] for k in gps_data if k['time_status'] > 20])
CS = m.nightshade(datetime.datetime.utcfromtimestamp(avg_ts))
except:
logger.warning('Problem plotting day/night terminator')
if plot_trajectory:
try:
if TLE_file:
try:
with open(TLE_file, 'r') as file:
TLE = file.read().split('\n')
logger.info(f'loaded TLE file {TLE_file}')
except:
logger.warning(f'failed to load TLE file {TLE_file}')
else:
logger.info('using default TLE')
# A default TLE, from mid-may 2020.
TLE = [
"1 45120U 19071K 20153.15274580 +.00003602 +00000-0 +11934-3 0 9995",
"2 45120 051.6427 081.8638 0012101 357.8092 002.2835 15.33909680018511"
]
avg_ts = np.mean(
[k['timestamp'] for k in gps_data if k['time_status'] > 20])
t_mid = datetime.datetime.utcfromtimestamp(avg_ts)
t1 = t_mid - datetime.timedelta(minutes=15)
t2 = t_mid + datetime.timedelta(minutes=15)
traj, tvec = compute_ground_track(
TLE, t1, t2, tstep=datetime.timedelta(seconds=10))
tlats = traj[:, 1]
tlons = traj[:, 0]
simtime = [
x.replace(tzinfo=datetime.timezone.utc).timestamp()
for x in tvec
]
mid_ind = np.argmin(np.abs(np.array(tvec) - t_mid))
zx, zy = m(tlons, tlats)
z = m.scatter(zx,
zy,
c=simtime,
marker='.',
s=10,
alpha=0.5,
cmap=get_cmap('plasma'),
zorder=100,
label='TLE')
z2 = m.scatter(zx[mid_ind],
zy[mid_ind],
edgecolor='k',
marker='*',
s=50,
zorder=101,
label='Center (TLE)')
except:
logger.warning('Problem plotting ground track from TLE')
if show_transmitters:
try:
call_sign_config = ConfigParser()
try:
fp = open(TX_file)
call_sign_config.read_file(fp)
fp.close()
except:
logger.warning('failed to load transmitters file')
for tx_name, vals in call_sign_config.items('NB_Transmitters'):
vv = vals.split(',')
tx_freq = float(vv[0])
tx_lat = float(vv[1])
tx_lon = float(vv[2])
px, py = m(tx_lon, tx_lat)
p = m.scatter(px, py, marker='p', s=20, color='r', zorder=99)
name_str = '{:s} \n{:0.1f} '.format(tx_name.upper(),
tx_freq / 1000)
m_ax.text(px,
py,
name_str,
fontsize=8,
fontweight='bold',
ha='left',
va='bottom',
color='k',
label='TX')
p.set_label('TX')
s = m.scatter(sx,
sy,
c=T_gps,
marker='o',
s=20,
cmap=get_cmap('plasma'),
zorder=100,
label='GPS')
except:
logger.warning('Problem plotting narrowband transmitters')
m_ax.legend()
if print_GPS_entries:
gstr = ''
for entry in gps_data:
time = datetime.datetime.strftime(
datetime.datetime.utcfromtimestamp(entry['timestamp']),
'%D %H:%M:%S')
tloc = entry['time_status'] > 20
ploc = entry['solution_status'] == 0
gstr += '{:s} ({:1.2f}, {:1.2f}): time lock: {:b} position lock: {:b}\n'.format(
time, entry['lat'], entry['lon'], tloc, ploc)
fig.text(.5, 0, gstr, ha='center', va='bottom')
fig.tight_layout()
def geramapa(star, data, title, labelx, nameimg, mapstyle='1', resolution='l', centermap=None, lats=None, erro=None, ring=None, atm=None, clat=None, sitearq=None, fmt='png', dpi=100, mapsize=None, cpoints=60, off=0):
lon = star.ra - data.sidereal_time('mean', 'greenwich')
center_map = EarthLocation(lon.value, star.dec.value)
if not centermap == None:
center_map = EarthLocation(centermap[0],centermap[1])
m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution)
# m = Basemap(projection='ortho',lat_0=center_map.latitude.value,lon_0=center_map.longitude.value,resolution=resolution,llcrnrx=-2000000.,llcrnry=-1500000.,urcrnrx=2000000.,urcrnry=1500000.)
# kx = fig.add_axes([-0.003,-0.001,1.006,1.002])
# kx.set_rasterization_zorder(1)
m.nightshade(data.datetime, alpha=0.3, zorder=0.5) ## desenha a sombra da noite
m.drawcoastlines(linewidth=0.5) ## desenha as linhas da costa
m.drawcountries(linewidth=0.5) ## desenha os paises
m.drawstates(linewidth=0.5) ## Desenha os estados
m.drawmeridians(np.arange(0,360,30)) ## desenha os meridianos
m.drawparallels(np.arange(-90,90,30)) ## desenha os paralelos
m.drawmapboundary() ## desenha o contorno do mapa
style = {'1': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'blue', 'rncolor':'blue', 'atcolor':'blue', 'outcolor':'red'},
'2': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'},
'3': {'ptcolor': 'red', 'lncolor': 'blue', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'},
'4': {'ptcolor': 'red', 'lncolor': 'red', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'},
'5': {'ptcolor': 'red', 'lncolor': 'red', 'ercolor':'red', 'rncolor':'black', 'atcolor':'black', 'outcolor':'red'}}
if mapstyle == '2':
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='coral',lake_color='aqua')
elif mapstyle == '3':
m.shadedrelief()
elif mapstyle == '4':
m.bluemarble()
elif mapstyle == '5':
m.etopo()
if not lats == None:
xs, ys = m(lats[0], lats[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['lncolor'])
xt, yt = m(lats[2], lats[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['lncolor'])
m.plot(lats[4], lats[5], color=style[mapstyle]['outcolor'], clip_on=False, zorder=-0.2)
m.plot(lats[6], lats[7], color=style[mapstyle]['outcolor'], clip_on=False, zorder=-0.2)
# else:
# m.plot(lats[4], lats[5], color=style[mapstyle]['outcolor'], clip_on=False, zorder=0.2)
# m.plot(lats[6], lats[7], color=style[mapstyle]['outcolor'], clip_on=False, zorder=0.2)
if not erro == None:
xs, ys = m(erro[0], erro[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['ercolor'])
xt, yt = m(erro[2], erro[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['ercolor'])
if not ring == None:
xs, ys = m(ring[0], ring[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, '--', color=style[mapstyle]['rncolor'])
xt, yt = m(ring[2], ring[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, '--', color=style[mapstyle]['rncolor'])
if not atm == None:
xs, ys = m(atm[0], atm[1])
xs = [i for i in xs if i < 1e+30]
ys = [i for i in ys if i < 1e+30]
m.plot(xs, ys, color=style[mapstyle]['atcolor'])
xt, yt = m(atm[2], atm[3])
xt = [i for i in xt if i < 1e+30]
yt = [i for i in yt if i < 1e+30]
m.plot(xt, yt, color=style[mapstyle]['atcolor'])
if not clat == None:
xc, yc, lab = [], [], []
cp = Time(clat[5], format='iso')
vec = np.arange(0, (cp[-1] - data).sec, cpoints)
vec = np.sort(np.concatenate((vec,-vec[1:]), axis=0))*u.s
for i in vec:
g = data + TimeDelta(i) + TimeDelta(off*u.s)
if g.iso in clat[2]:
a = np.where(np.array(clat[2]) == g.iso)
x, y = m(np.array(clat[0])[a], np.array(clat[1])[a])
xc.append(x)
yc.append(y)
lab.append(g.iso.split()[1][0:8])
elif g.iso in clat[5]:
a = np.where(np.array(clat[5]) == g.iso)
xc.append(np.array(clat[3])[a])
yc.append(np.array(clat[4])[a])
lab.append(g.iso.split()[1][0:8])
else:
if len(clat[2]) == 0:
a = [0]
else:
co = Time(clat[2], format='iso')
a = np.argsort(np.absolute(co - g))[0:2]
if 0 not in a and len(co)-1 not in a:
b = np.absolute((co[a] - g).sec)
x, y = m(np.array(clat[0])[a], np.array(clat[1])[a])
xc.append(np.sum(x*(1/b))/np.sum(1/b))
yc.append(np.sum(y*(1/b))/np.sum(1/b))
lab.append(g.iso.split()[1][0:8])
else:
co = Time(clat[5], format='iso')
a = np.argsort(np.absolute(co - g))[0:2]
b = np.absolute((co[a] - g).sec)
xc.append(np.sum(np.array(clat[3])[a]*(1/b))/np.sum(1/b))
yc.append(np.sum(np.array(clat[4])[a]*(1/b))/np.sum(1/b))
lab.append(g.iso.split()[1][0:8])
m.plot(xc, yc, 'o', color=style[mapstyle]['ptcolor'], clip_on=False, markersize=mapsize[0].value*8/46)
m.plot(clat[6][0], clat[6][1], 'o', color=style[mapstyle]['ptcolor'], clip_on=False, markersize=mapsize[0].value*20/46)
# for label, axpt, bypt in zip(lab, xc, yc):
# plt.text(axpt + 0, bypt + 350000, label, rotation=60, weight='bold')
# m.plot(ax,by, 'o', color=ptcolor, markersize=int(mapsize[0].value*20/46))
# m.plot(ax2.to(u.m),by2.to(u.m), 'o', color=ptcolor, markersize=int(mapsize[0].value*12/46))
# m.plot(ax3.to(u.m), by3.to(u.m), color='red')
# m.plot(ax4.to(u.m), by4.to(u.m), color='red')
# m.quiver(a-0*u.m,b-600000*u.m, 20, 0, width=0.005)
# ax2 = a + dista*np.sin(pa) + [(i - datas).sec for i in temposplot]*u.s*vel*np.cos(paplus)
# by2 = b + dista*np.cos(pa) - [(i - datas).sec for i in temposplot]*u.s*vel*np.sin(paplus)
#
# labels = [i.iso.split()[1][0:8] for i in temposplot]
# m.plot(ax2, by2, 'ro')
# if os.path.isfile(sitearq) == True:
# xpt,ypt = m(sites['lon'],sites['lat'])
# m.plot(xpt,ypt,'bo')
# offset = [[xpt[0] + 100000,xpt[0] + 100000,xpt[0] + 100000,xpt[3] + 400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000,xpt[3] +400000],[10000,-30000,-60000,70000,30000,-20000,-70000,-30000,-70000]]
# for i in np.arange(len(xpt)):
# ax.text(offset[0][i],ypt[i]+offset[1][i],sites['nome'][i], weight='bold')
# m.plot(ax5.to(u.m), by5.to(u.m), '--', color=dscolor, label='+-{} error'.format(erro))
# m.plot(ax6.to(u.m), by6.to(u.m), '--', color=dscolor)
# plt.legend(fontsize=mapsize[0].value*21/46)
fig = plt.gcf()
fig.set_size_inches(mapsize[0].to(u.imperial.inch).value, mapsize[1].to(u.imperial.inch).value)
plt.title(title, fontsize=mapsize[0].value*25/46, fontproperties='FreeMono', weight='bold')
plt.xlabel(labelx, fontsize=mapsize[0].value*21/46, fontproperties='FreeMono', weight='bold')
plt.savefig('{}.{}'.format(nameimg, fmt), format=fmt, dpi=dpi)
print 'Gerado: {}.{}'.format(nameimg, fmt)
plt.clf()
def plot_flux_basemap(flux, in_lats, in_lons, flashes=None, plottime=None,
logscale=False, clims=[0,1], num_contours=10, mode='counts'):
lons, lats = np.meshgrid(in_lons, in_lats)
# print np.shape(lons)
# print np.shape(lats)
new_coords = transform_coords(lats.ravel(), lons.ravel(),
100*np.ones_like(lons.ravel()),'geomagnetic','geographic')
mag_lons = new_coords[:,1].T.reshape(np.shape(lons))
mag_lats = new_coords[:,0].T.reshape(np.shape(lats))
# print np.shape(mag_lons)
# print np.shape(mag_lats)
fig = plt.figure()
ax1 = plt.subplot(111)
m = Basemap(ax1,resolution='c',projection='robin', lon_0 = 0)
x, y = m(mag_lons, mag_lats)
# CS1 = m.contourf(x,y,flux,cmap=plt.cm.jet,extend='both')
m.drawcoastlines(color='white')
m.drawmapboundary()
m.fillcontinents(color='grey',alpha=0.3)
if plottime is not None:
if isinstance(plottime,str):
plottime = datetime.datetime.strptime(plottime,'%Y-%m-%dT%H:%M:%S')
m.nightshade(plottime, alpha=0.25)
contours = np.linspace(clims[0],clims[1],num_contours+1)
# log scale?
if logscale:
pd = np.log10(flux).ravel()
else:
pd = flux.ravel()
# Clip flux to min and max contours
pd = np.clip(pd, contours[0], contours[-1])
# Plot flux
CS1 = plt.tricontourf(x.ravel(),y.ravel(),pd, contours,cmap=plt.cm.jet)
cbar = m.colorbar(CS1, size="2%", pad=0.5)
if logscale:
ctix = np.arange(clims[0], clims[1]+1)
# print ctix
cbar.set_ticks(ctix)
cbar.set_ticklabels(['$10^{%d}$'%f for f in ctix])
# if logscale:
# logstr = 'log$_{10}$'
# else:
# logstr=''
if mode == 'energy':
cbar.set_label('Energy flux [mErg/cm$^2$ sec]')
elif mode == 'counts':
cbar.set_label('Particle flux [el/cm$^2$ sec]')
if flashes is not None:
new_flash_coords= transform_coords(flashes[:,0], flashes[:,1],
100*np.ones_like(flashes[:,0]), 'geomagnetic','geographic')
xf, yf = m(new_flash_coords[:,1], new_flash_coords[:,0])
msize = abs(flashes[:,2])*2
mcolor= flashes[:,3]
p2 = m.scatter(xf, yf, marker='o', c=mcolor,s=msize,alpha=0.8,edgecolor='None', cmap=plt.cm.Reds_r)
# divider = make_axes_locatable(ax1)
# cax2 = divider.append_axes("bottom",size="2%",pad=0.5)
# plt.colorbar(p2, cax=cax2)
ax1.set_title(plottime)
plt.tight_layout()
#plt.subplots_adjust(0,0,1,1,0,0)
return fig
