def plot_bokeh(df, ticker):
p = figure(width=800, height=400, title=ticker.upper(), tools="")
hover = HoverTool(tooltips="""
<div>
<table>
<tr><td class="ttlab">Date:</td><td>@date_str</td></tr>
<tr><td class="ttlab">Close:</td><td>@close_str</td></tr>
</table>
</div>
""")
hover.mode = 'vline'
hover.line_policy = 'nearest'
p.add_tools(hover)
crosshair = CrosshairTool()
crosshair.dimensions = 'height'
crosshair.line_color = "#ffffff"
p.add_tools(crosshair)
dfcds = ColumnDataSource(df)
p.line('date', 'close', source=dfcds, color="#44ddaa")
p.xaxis.formatter = DatetimeTickFormatter(days=["%d %b"])
p.x_range = Range1d(df['date'].min(), df['date'].max())
p.toolbar.logo = None
p.toolbar_location = None
return p
def plot_setter(df, ticker):
p = figure(width=700, height=400, title="Ticker=" + ticker, tools="")
hover = HoverTool(tooltips=[
('date', '@date{%F}'),
('close', '$@close{%0.2f}'),
],
formatters={
'date': 'datetime',
'close': 'printf'
})
hover.mode = 'vline'
hover.line_policy = 'nearest'
p.add_tools(hover)
dfcds = ColumnDataSource(df)
p.line('date', 'close', source=dfcds, color="#000000")
p.xaxis.formatter = DatetimeTickFormatter(days=["%d %b"])
p.x_range = Range1d(df['date'].min(), df['date'].max())
p.toolbar.logo = None
p.toolbar_location = None
p.title.text_color = "#000000"
p.title.text_font_size = "1.5em"
p.axis.major_label_text_color = "#000000"
p.axis.major_label_text_font_size = "1.25em"
p.xgrid.grid_line_color = None
p.ygrid.grid_line_alpha = 0.5
p.ygrid.grid_line_dash = [2, 4]
p.outline_line_color = None
p.yaxis.axis_label = "Close"
return p
def bokehplot(df_1, ticker):
"""Create a time-series line plot in Bokeh."""
p = figure(width=600, height=300, title=ticker.upper(), tools="")
hover = HoverTool(tooltips="""
<div>
<table>
<tr><td class="ttlab">Date:</td><td>@date_str</td></tr>
<tr><td class="ttlab">Close:</td><td>@close</td></tr>
</table>
</div>
""")
hover.mode = 'vline'
hover.line_policy = 'nearest'
p.add_tools(hover)
crosshair = CrosshairTool()
crosshair.dimensions = 'height'
crosshair.line_color = "#ffffff"
p.add_tools(crosshair)
dfcds = ColumnDataSource(df_1)
p.line('date', 'close', source=dfcds, color="#44ddaa")
p.xaxis.formatter = DatetimeTickFormatter(days=["%d %b"])
p.x_range = Range1d(df_1['date'].min(), df_1['date'].max())
p.toolbar.logo = None
p.toolbar_location = None
# Style plot
p.background_fill_color = "#234567"
p.border_fill_color = "#234567"
p.title.text_color = "#ffffff"
p.title.text_font_size = "1.25em"
p.axis.major_label_text_color = "#ffffff"
p.axis.major_label_text_font_size = "0.875em"
p.axis.axis_line_color = "#ffffff"
p.axis.major_tick_line_color = "#ffffff"
p.axis.minor_tick_line_color = "#ffffff"
p.xgrid.grid_line_color = None
p.ygrid.grid_line_alpha = 0.5
p.ygrid.grid_line_dash = [4, 6]
p.outline_line_color = None
p.yaxis.axis_label = "Closing price"
p.yaxis.axis_label_text_color = "#ffffff"
p.yaxis.axis_label_text_font_size = "1em"
p.yaxis.axis_label_text_font_style = "normal"
p.yaxis.axis_label_standoff = 12
return p
def plot_ticker(ticker):
# Retrieve and process data:
url = urlhead + ticker + urltail
page = requests.get(url)
json = page.json()
df = pd.DataFrame(json['Time Series (Daily)'])
# New DataFrame to append values:
df_1 = pd.DataFrame()
close = np.asarray(df.iloc[3])
df_1['date'] = pd.to_datetime(list(df))
df_1['close'] = close
# Last 30 days:
df_1 = df_1[0:30]
# Create a new column with dates as string:
df_1['date_str'] = df_1['date'].map(lambda x: x.strftime("%Y-%m-%d"))
dfcds = ColumnDataSource(df_1)
# Create Bokeh plot:
p = figure(width=600, height=300, title=ticker.upper(), tools="")
hover = HoverTool(tooltips = [
('Date', '@date_str'),
('Close', '@close')])
hover.mode = 'vline'
hover.line_policy = 'nearest'
p.add_tools(hover)
crosshair = CrosshairTool()
crosshair.dimensions = 'height'
p.add_tools(crosshair)
p.line('date', 'close', source = dfcds)
p.xaxis.formatter=DatetimeTickFormatter(days=["%d %b"])
p.x_range=Range1d(df_1['date'].min(), df_1['date'].max())
p.toolbar.logo = None
p.toolbar_location = None
return p
def show_points(pointsList, w=400, h=400):
# Ensure it's a list going in
if type(pointsList) is not list:
pointsList = [pointsList]
# Create the hover tool
hover = HoverTool(tooltips=[("x", "@x"),
("y", "@y")])
hover.line_policy = "nearest"
# Make the figure
fig = figure(plot_width=w, plot_height=h)
fig.add_tools(hover)
colors = ['red', 'orange', 'yellow', 'green',
'blue', 'purple', 'indigo', 'violet']
# Plot all the points
for i, points in enumerate(pointsList):
# Grab the color
color = colors[i % len(colors)]
# Plot the vertices
fig.x(x=points[:, 0],
y=points[:, 1],
size=6, line_width=2, line_color=color)
# Plot the lines
x, y = [np.hstack([points[:, z], points[0, z]]) for z in [0, 1]]
fig.line(x=x,
y=y,
line_width=2,
line_color=color)
# Plot the point index next to the point
fig.text(x=points[:, 0],
y=points[:, 1],
text=range(points.shape[0]))
# Show the plot
show(fig)
def createHoverTool(simg, cols):
"""
"""
# Make the hovertool only follow the patches (still a hack)
htline = simg
ht = HoverTool()
ht.tooltips = [("Time", "@index{%F %T}")]
for col in cols:
fStr = "@%s{0.00}" % (col)
ht.tooltips.append((col, fStr))
ht.formatters = {'index': 'datetime'}
ht.show_arrow = False
ht.point_policy = 'follow_mouse'
ht.line_policy = 'nearest'
ht.renderers = [htline]
return ht
def create_figure():
G1 = copy.deepcopy(G)
nx.set_node_attributes(G1, dict(G1.degree(weight='Weight')), 'WDegree')
nx.set_node_attributes(G1, dict(G1.degree()), 'Degree')
rem_edg = []
for u,v,d in G1.edges(data=True):
if d['Weight'] < edf.value:
rem_edg.append((u,v))
G1.remove_edges_from(rem_edg)
rem_node = []
for u in G1.nodes():
if G1.node[u]['WDegree'] < ndf.value:
rem_node.append(u)
rem_node = rem_node+list(nx.isolates(G1))
G1.remove_nodes_from(rem_node)
node_df = ColumnDataSource(nodes_df(G1))
edge_df = ColumnDataSource(edges_df(G1))
color_mapper = CategoricalColorMapper(factors=states, palette=Category20b[20] + Category20c[20] + Category20[20])
mapper = LogColorMapper(palette=['#FDFDFD', '#FDF5CA', '#FDF2B1', '#FDEE98', '#FDE665', '#FDDF33', '#FDD700'],
low=min(edge_df.data['weight']), high=max(edge_df.data['weight']))
p = figure(title="US Air Flights in 97", toolbar_location="left", plot_width=1100, plot_height=600,
match_aspect=True, aspect_scale=0.7, x_range=[-140, -50], y_range=[20, 55])
r1 = p.circle('x', 'y', source=node_df, size='size', level='overlay',
color={'field': 'state', 'transform': color_mapper},
alpha=0.8, line_color='#240606', line_width=1, line_alpha=0.3)
r2 = p.multi_line('xs', 'ys', line_width='line_width', alpha='alphas',
color={'field': 'weight', 'transform': mapper},
source=edge_df)
node_hover = HoverTool(tooltips=[('Name', '@Name'), ('State', '@state'), ('No. of Connections', '@Degree'),
('Total Frequency', '@WDegree')], renderers=[r1])
node_hover.attachment = 'right'
edge_hover = HoverTool(tooltips=[('Airports', '@city1'), ('', '@city2'), ('Frequency', '@weight')], renderers=[r2])
edge_hover.line_policy = 'interp'
edge_hover.attachment = 'left'
p.add_tools(node_hover)
p.add_tools(edge_hover)
return p
def plot_filtering(time, raw, filtered):
"""
:param time:
:param raw:
:param filtered:
:return:
"""
hover = HoverTool()
hover.point_policy = 'snap_to_data'
hover.line_policy = 'nearest'
TOOLS = ['pan,wheel_zoom,box_zoom']
time = np.arange(0, raw.size)
p1 = figure(title="Timeseries SSH (raw vs filtered)",
tools=TOOLS,
plot_width=1000)
p1.grid.grid_line_alpha = 0.3
p1.xaxis.axis_label = 'Date (Julian days)'
p1.yaxis.axis_label = 'SSH'
p1.circle(time, raw, color='lightseagreen')
p1.line(time, raw, legend='raw', color='lightseagreen')
p1.circle(time, filtered, color='royalblue')
p1.line(time, filtered, legend='filtered',
color='royalblue') #, line_width=4)
p1.add_tools(
HoverTool(tooltips=[
('date', '@x'),
('SSH', '@y m'),
], mode='mouse'))
p1.legend.location = "top_left"
# output_file("Hss_timeseries.html", title="Hss_timeseries")
show(p1, plot_width=1000, plot_height=400)
def bokehTile(tileFile,
jsonFile,
TT=[0, 0, 0],
DD=[2019, 10, 1],
dynamic=False,
plotTitle=''):
citls, h = fitsio.read(tileFile, header=True)
w = (np.where(citls['IN_DESI'] == 1)[0])
inci = citls[w]
if jsonFile is not None:
with open(jsonFile, "r") as read_file:
data = json.load(read_file)
## Coloring scheme
palette = ['green', 'red', 'white']
dye = []
for tile in citls['TILEID']:
rang = 2 # 'orange'
if jsonFile is not None:
if str(tile) in data:
rang = 0 # 'green' #green default
if len(data[str(tile)]
['unassigned']) > 0: # not assigned (red)
rang = 1 # 'red' #'red'
if (0 in data[str(tile)]['gfa_stars_percam']):
print(data[str(tile)]['gfa_stars_percam'])
rang = 1 # 'cyan'
else:
rang = 0 # green if qa.json is not provided
dye.append(rang)
dye = np.asarray(dye)
w = (np.where(dye < 2)[0])
citls = citls[w]
dye = dye[w]
mapper = linear_cmap(field_name='DYE', palette=palette, low=0, high=2)
#########################################################
TOOLS = [
'pan', 'tap', 'wheel_zoom', 'box_zoom', 'reset', 'save', 'box_select'
]
obsTime = dt(DD[0], DD[1], DD[2], TT[0], TT[1], TT[2])
# print(get_kp_twilights(TT,DD))
if plotTitle == '' or plotTitle is None:
PTITLE = ''
else:
PTITLE = 'Program: ' + plotTitle
p = figure(tools=TOOLS,
toolbar_location="right",
plot_width=800,
plot_height=450,
title=PTITLE,
active_drag='box_select') # str(DD[1])+" - 2019")
p.title.text_font_size = '16pt'
p.title.text_color = 'black'
p.grid.grid_line_color = "gainsboro"
############################### adding ecliptic plane+ hour grid ####################3
add_plane(p, color='red', plane='ecliptic', projection='equatorial')
tiledata = dict(
RA=citls['RA'],
DEC=citls['DEC'],
TILEID=citls['TILEID'],
BRIGHTRA=citls['BRIGHTRA'][:, 0],
BRIGHTDEC=citls['BRIGHTDEC'][:, 0],
BRIGHTVTMAG=citls['BRIGHTVTMAG'][:, 0],
EBV_MED=np.round(citls['EBV_MED'], 3),
STAR_DENSITY=citls['STAR_DENSITY'],
DYE=dye,
program=citls['PROGRAM'],
selected=np.ones(len(citls), dtype=bool),
)
for colname in ['STAR_DENSITY', 'EBV_MED']:
if colname in citls.dtype.names:
tiledata[colname] = citls[colname]
tiles = ColumnDataSource(data=tiledata)
colformat = bktables.NumberFormatter(format='0,0.00')
columns = [
bktables.TableColumn(field='TILEID', title='TILEID', width=80),
bktables.TableColumn(field='RA', title='RA', formatter=colformat),
bktables.TableColumn(field='DEC', title='DEC', formatter=colformat),
]
for colname in ['STAR_DENSITY', 'EBV_MED']:
if colname in tiledata:
columns.append(
bktables.TableColumn(field=colname,
title=colname,
formatter=colformat))
columns.append(bktables.TableColumn(field='selected', title='Selected'))
tiletable = bktables.DataTable(columns=columns, source=tiles, width=800)
tiles.selected.js_on_change(
'indices',
CustomJS(args=dict(s1=tiles),
code="""
var inds = cb_obj.indices;
var d1 = s1.data;
for (var i=0; i<d1['selected'].length; i++) {
d1['selected'][i] = false;
}
for (var i = 0; i < inds.length; i++) {
d1['selected'][inds[i]] = true;
}
s1.change.emit();
"""))
render = p.circle(
'RA',
'DEC',
source=tiles,
size=9,
line_color='chocolate',
color=mapper,
alpha=0.4,
hover_color='orange',
hover_alpha=1,
hover_line_color='red',
# set visual properties for selected glyphs
selection_fill_color='orange',
selection_line_color='white',
# set visual properties for non-selected glyphs
nonselection_fill_alpha=0.4,
nonselection_fill_color=mapper)
p.xaxis.axis_label = 'RA [deg]'
p.yaxis.axis_label = 'Dec. [deg]'
p.xaxis.axis_label_text_font_size = "14pt"
p.yaxis.axis_label_text_font_size = "14pt"
p.grid.grid_line_color = "gainsboro"
p.yaxis.major_label_text_font_size = "12pt"
p.xaxis.major_label_text_font_size = "12pt"
p.x_range = Range1d(360, 0)
p.y_range = Range1d(-40, 95)
p.toolbar.logo = None
p.toolbar_location = None
# mytext = Label(x=180, y=-35, text="S", text_color='gray', text_font_size='12pt') ; p.add_layout(mytext)
# mytext = Label(x=180, y=88, text="N", text_color='gray', text_font_size='12pt') ; p.add_layout(mytext)
# mytext = Label(x=350, y=45, text="E", text_color='gray', text_font_size='12pt', angle=np.pi/2) ; p.add_layout(mytext)
# mytext = Label(x=4, y=45, text="W", text_color='gray', text_font_size='12pt', angle=np.pi/2) ; p.add_layout(mytext)
## Javascript code to open up custom html pages, once user click on a tile
code = """
var index_selected = source.selected['1d']['indices'][0];
var tileID = source.data['TILEID'][index_selected];
if (tileID!==undefined) {
var win = window.open("http://www.astro.utah.edu/~u6022465/cmx/ALL_SKY/dr8/allSKY_ci_tiles/sub_pages/tile-"+tileID+".html", " ");
try {win.focus();} catch (e){} }
"""
taptool = p.select(type=TapTool)
taptool.callback = CustomJS(args=dict(source=tiles), code=code)
## The html code for the hover window that contain tile infrormation
ttp = """
<div>
<div>
<span style="font-size: 14px; color: blue;">Tile ID:</span>
<span style="font-size: 14px; font-weight: bold;">@TILEID{int}</span>
</div>
<div>
<span style="font-size: 14px; color: blue;">RA:</span>
<span style="font-size: 14px; font-weight: bold;">@RA</span>
</div>
<div>
<span style="font-size: 14px; color: blue;">Dec:</span>
<span style="font-size: 14px; font-weight: bold;">@DEC</span>
</div>
<div>
<span style="font-size: 14px; color: blue;">EBV_MED:</span>
<span style="font-size: 14px; font-weight: bold;">@EBV_MED{0.000}</span>
</div>
<div>
<span style="font-size: 14px; color: blue;">STAR_DENSITY:</span>
<span style="font-size: 14px; font-weight: bold;">@STAR_DENSITY{0}</span>
</div>
<div>
<span style="font-size: 14px; color: blue;">BRIGHTEST_STAR_VTMAG:</span>
<span style="font-size: 14px; font-weight: bold;">@BRIGHTVTMAG</span>
</div>
<div>
<span style="font-size: 14px; color: blue;">BRIGHTEST_STAR_LOC:</span>
<span style="font-size: 14px; font-weight: bold;">(@BRIGHTRA, @BRIGHTDEC)</span>
</div>
</div>
"""
hover = HoverTool(tooltips=ttp, renderers=[render])
hover.point_policy = 'snap_to_data'
hover.line_policy = 'nearest'
# hover.mode='vline'
p.add_tools(hover)
cross = CrosshairTool()
# cross.dimensions='height'
cross.line_alpha = 0.3
cross.line_color = 'gray'
p.add_tools(cross)
# Setting the second y axis range name and range
p.extra_y_ranges = {"foo": p.y_range}
p.extra_x_ranges = {"joo": p.x_range}
# Adding the second axis to the plot.
p.add_layout(LinearAxis(y_range_name="foo"), 'right')
p.add_layout(LinearAxis(x_range_name="joo"), 'above')
p.xaxis.major_label_text_font_size = "12pt"
p.yaxis.major_label_text_font_size = "12pt"
if dynamic:
# twilight_source = get_kp_twilights(TT,DD) # evening and morning twilights at every TT and DD
circleSource_1 = skyCircle(TT, DD, 1.5)
p.circle('RA', 'DEC', source=circleSource_1, size=1.5, color='black')
circleSource_2 = skyCircle(TT, DD, 2.0)
p.circle('RA', 'DEC', source=circleSource_2, size=0.5, color='gray')
else:
circleSource = skyCircle(TT, DD, 1.5)
p.circle('RA', 'DEC', source=circleSource, size=1.5, color=None)
### Dealing with the Moon and Jupiter
inFile = 'moonLoc_jupLoc_fracPhase.csv' # 'moon_loc_jup_loc_fracPhase_namePhase.csv'
tbl_moon_jup = np.genfromtxt(inFile,
delimiter=',',
filling_values=-1,
names=True,
dtype=None) # , dtype=np.float)
loc = EarthLocation.of_site('Kitt Peak')
kp_lat = 31, 57, 48
kp_lon = -111, 36, 00
mooninfo_obj = pylunar.MoonInfo((kp_lat), (kp_lon))
m_ra, m_dec, frac_phase, name_phase = moonLoc(TT, DD, loc, mooninfo_obj)
j_ra, j_dec = jupLoc(TT, DD, loc)
#moonSource = ColumnDataSource({"moon_RAS": tbl_moon_jup['moon_ra'], "moon_DECS": tbl_moon_jup['moon_dec'],
# "Phase_frac": tbl_moon_jup['moon_phase_frac']})
moonSource = ColumnDataSource({
"moon_RAS":
tbl_moon_jup['moon_ra'],
"moon_DECS":
tbl_moon_jup['moon_dec'],
"Phase_frac":
np.round(100 * tbl_moon_jup['moon_phase_frac'])
})
####moon_RADEC = ColumnDataSource({"moon_ra": [m_ra.deg], "moon_dec": [m_dec.deg], "phase_frac": [frac_phase]})
moon_RADEC_ = ColumnDataSource({
"moon_ra": [m_ra.deg - 360],
"moon_dec": [m_dec.deg],
"phase_frac": [frac_phase]
})
moon_RADEC = ColumnDataSource({
"moon_ra": [m_ra.deg],
"moon_dec": [m_dec.deg],
"phase_frac": [frac_phase]
})
render_moon = p.circle('moon_ra',
'moon_dec',
source=moon_RADEC,
size=170,
color='cyan',
alpha=0.2)
render_moon = p.circle('moon_ra',
'moon_dec',
source=moon_RADEC,
size=4,
color='blue')
render_moon = p.circle('moon_ra',
'moon_dec',
source=moon_RADEC_,
size=170,
color='cyan',
alpha=0.2)
render_moon = p.circle('moon_ra',
'moon_dec',
source=moon_RADEC_,
size=4,
color='blue')
jupSource = ColumnDataSource({
"jup_RAS": tbl_moon_jup['jup_ra'],
"jup_DECS": tbl_moon_jup['jup_dec']
})
jup_RADEC = ColumnDataSource({
"jup_ra": [j_ra.deg],
"jup_dec": [j_dec.deg]
})
twilight = get_kp_twilights(
TT, DD) # evening and morning twilights at every TT and DD
twilight_source = ColumnDataSource({
"eve_twilight": [twilight[0]],
"mor_twilight": [twilight[1]]
})
render_jup = p.circle('jup_ra',
'jup_dec',
source=jup_RADEC,
size=5,
color='blue')
render_jup = p.circle('jup_ra',
'jup_dec',
source=jup_RADEC,
size=4,
color='gold')
from bokeh.models.glyphs import Text
TXTsrc = ColumnDataSource(
dict(x=[350],
y=[85],
text=['Moon Phase: ' + "%.0f" % (frac_phase * 100) + "%"]))
glyph = Text(x="x", y="y", text="text", angle=0, text_color="black")
p.add_glyph(TXTsrc, glyph)
TXTsrc_moon = ColumnDataSource(
dict(x=[m_ra.deg + 10], y=[m_dec.deg - 10], text=['Moon']))
glyph = Text(x="x",
y="y",
text="text",
angle=0,
text_color="blue",
text_alpha=0.3,
text_font_size='10pt')
p.add_glyph(TXTsrc_moon, glyph)
TXTsrc_jup = ColumnDataSource(
dict(x=[j_ra.deg + 5], y=[j_dec.deg - 8], text=['Jup.']))
glyph = Text(x="x",
y="y",
text="text",
angle=0,
text_color="black",
text_alpha=0.3,
text_font_size='10pt')
p.add_glyph(TXTsrc_jup, glyph)
callback = CustomJS(args=dict(source_sky1=circleSource_1,
source_sky2=circleSource_2,
source_moon=moonSource,
source_moon_RADEC=moon_RADEC,
source_moon_RADEC_=moon_RADEC_,
source_jup=jupSource,
source_jup_RADEC=jup_RADEC,
sourceTXT=TXTsrc,
sourceTXTmoon=TXTsrc_moon,
sourceTXTjup=TXTsrc_jup),
code="""
// First set times as if they were UTC
var t = new Date(time_slider.value);
var d = new Date(date_slider.value);
var data1 = source_sky1.data;
var ra_1 = data1['RA'];
var ra0_1 = data1['RA0'];
var data2 = source_sky2.data;
var ra_2 = data2['RA'];
var ra0_2 = data2['RA0'];
var data_moon = source_moon.data;
var ras_moon = data_moon['moon_RAS'];
var decs_moon = data_moon['moon_DECS'];
var phase_frac = data_moon['Phase_frac'];
var moonRADEC = source_moon_RADEC.data;
var moon_ra = moonRADEC['moon_ra'];
var moon_dec = moonRADEC['moon_dec'];
var moonRADEC_ = source_moon_RADEC_.data;
var moon_ra_ = moonRADEC_['moon_ra'];
var moon_dec_ = moonRADEC_['moon_dec'];
var data_jup = source_jup.data;
var ras_jup = data_jup['jup_RAS'];
var decs_jup = data_jup['jup_DECS'];
var jupRADEC = source_jup_RADEC.data;
var jup_ra = jupRADEC['jup_ra'];
var jup_dec = jupRADEC['jup_dec'];
var Hour = t.getUTCHours();
var Day = d.getDate();
var Month = d.getMonth();
var Year = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
var all_FULdays = 0;
for (var i = 0; i < Month; i++)
all_FULdays=all_FULdays+Year[i];
all_FULdays = all_FULdays + (Day-1);
if (Hour<12) all_FULdays=all_FULdays+1;
var all_minutes = all_FULdays*24+Hour;
if (all_minutes<8800) {
moon_ra[0] = ras_moon[all_minutes];
moon_dec[0] = decs_moon[all_minutes];
moon_ra_[0] = ras_moon[all_minutes]-360.;
moon_dec_[0] = decs_moon[all_minutes];
}
var jupTXTdata = sourceTXTjup.data;
var x_jup = jupTXTdata['x'];
var y_jup = jupTXTdata['y'];
var text_jup = jupTXTdata['text'];
if (all_minutes<8800) {
jup_ra[0] = ras_jup[all_minutes];
jup_dec[0] = decs_jup[all_minutes];
x_jup[0] = jup_ra[0]+5;
y_jup[0] = jup_dec[0]-8;
}
if (t.getUTCHours() < 12) {
d.setTime(date_slider.value + 24*3600*1000);
} else {
d.setTime(date_slider.value);
}
d.setUTCHours(t.getUTCHours());
d.setUTCMinutes(t.getUTCMinutes());
d.setUTCSeconds(0);
// Correct to KPNO local time
// d object still thinks in UTC, which is 7 hours ahead of KPNO
d.setTime(d.getTime() + 7*3600*1000);
// noon UT on 2000-01-01
var reftime = new Date();
reftime.setUTCFullYear(2000);
reftime.setUTCMonth(0); // Months are 0-11 (!)
reftime.setUTCDate(1); // Days are 1-31 (!)
reftime.setUTCHours(12);
reftime.setUTCMinutes(0);
reftime.setUTCSeconds(0);
// time difference in days (starting from milliseconds)
var dt = (d.getTime() - reftime.getTime()) / (24*3600*1000);
// Convert to LST
var mayall_longitude_degrees = -(111 + 35/60. + 59.6/3600);
var LST_hours = ((18.697374558 + 24.06570982441908 * dt) + mayall_longitude_degrees/15) % 24;
var LST_degrees = LST_hours * 15;
for (var i = 0; i < ra_1.length; i++) {
ra_1[i] = (ra0_1[i] + LST_degrees) % 360;
}
for (var i = 0; i < ra_2.length; i++) {
ra_2[i] = (ra0_2[i] + LST_degrees) % 360;
}
//// Here we gtake care of the moon phasde text
var TXTdata = sourceTXT.data;
var x = TXTdata['x'];
var y = TXTdata['y'];
var text = TXTdata['text'];
var moonTXTdata = sourceTXTmoon.data;
var x_moon = moonTXTdata['x'];
var y_moon = moonTXTdata['y'];
var text_moon = moonTXTdata['text'];
// x[0] = 1;
// y[0] = 40;
if (all_minutes<8800) {
text[0] = 'Moon Phase: ' + phase_frac[all_minutes]+'%';
x_moon[0] = moon_ra[0]+10;
y_moon[0] = moon_dec[0]-10;
}
sourceTXT.change.emit();
/////////////////////////////// Moon phase code ends.
source_sky1.change.emit();
source_sky2.change.emit();
//source_moon_RADEC.change.emit();
//source_moon_RADEC_.change.emit();
//source_jup_RADEC.change.emit();
sourceTXTmoon.change.emit();
sourceTXTjup.change.emit();
//alert(d);
""")
if dynamic:
### TIME
Timeslider = DateSlider(start=dt(2019, 9, 1, 16, 0, 0),
end=dt(2019, 9, 2, 8, 0, 0),
value=dt(2019, 9, 1, 16, 0, 0),
step=1,
title="KPNO local time(hh:mm)",
format="%H:%M",
width=800)
## DATE
Dateslider = DateSlider(start=dt(2019, 9, 1, 16, 0, 0),
end=dt(2020, 8, 31, 8, 0, 0),
value=dt(2019, 10, 1, 16, 0, 0),
step=1,
title="Date of sunset(4pm-8am)",
format="%B:%d",
width=800)
callback.args['time_slider'] = Timeslider
callback.args['date_slider'] = Dateslider
Dateslider.js_on_change('value', callback)
Timeslider.js_on_change('value', callback)
layout = column(p, Dateslider, Timeslider, tiletable)
# show(p)
return layout
return p
def plot_model(
model,
x_column,
y_column=None,
fig=None,
x_slider=None,
y_slider=None,
show_expt_data=True,
figsize=(10, 10),
dpi=100,
**kwargs,
):
"""
Plots a `model` object with a given model input as `x_column` against
the model's output: `y_column`. If `y_column` is not specified, then it
found from the `model`.
For model's with more than 1 inputs, the `y_column` is the variable to be
plotted on the y-axis, and then the plot type is a contour plot.
"""
pure_factors = model.get_factor_names(level=1)
dpi_max = dpi**3.5 # should be reasonable for most modern computers
per_axis_points = min(dpi, np.power(dpi_max, 1 / len(pure_factors)))
# `oneD=True`: the x-variable is a model input, and the y-axis is a response
oneD = False
if y_column and y_column not in pure_factors:
oneD = True
y_column = model.get_response_name()
param_names = [
model.get_response_name(),
]
param_names.extend(model.get_factor_names())
# Not always a great test: y = I(1/d) does not pick up that "d" is the model
# even though it is via the term encapsulated in I(...)
# assert x_column in param_names, "x_column must exist in the model."
assert y_column in param_names, "y_column must exist in the model."
xrange = model.data[x_column].min(), model.data[x_column].max()
xdelta = xrange[1] - xrange[0]
xlim = kwargs.get("xlim",
(xrange[0] - xdelta * 0.05, xrange[1] + xdelta * 0.05))
h_grid = np.linspace(xlim[0], xlim[1], num=per_axis_points)
plotdata = {x_column: h_grid}
if not oneD:
yrange = model.data[y_column].min(), model.data[y_column].max()
ydelta = yrange[1] - yrange[0]
ylim = kwargs.get(
"ylim", (yrange[0] - ydelta * 0.05, yrange[1] + ydelta * 0.05))
v_grid = np.linspace(ylim[0], ylim[1], num=per_axis_points)
H, V = np.meshgrid(h_grid, v_grid)
h_grid, v_grid = H.ravel(), V.ravel()
plotdata[x_column] = h_grid
plotdata[y_column] = v_grid
# TODO: handle the 2D case later
# if other_factors is not None and isinstance(other_factors, dict):
# plotdata = kwargs.update(other_factors)
## Look at which factors are included, and pop them out. The remaining
## factors are specified at their zero level
# unspecified_factors = [i for i in pure_factors if i not in kwargs.keys()]
# for factor in unspecified_factors:
# plotdata[factor] = np.zeros_like(h_grid)
# assert sorted(kwargs.keys()) == sorted(pure_factors), ("Not all factors "
# "were specified.")
Z = predict(model, **plotdata)
if not oneD:
assert False
else:
plotdata[y_column] = Z
yrange = Z.min(), Z.max()
ydelta = yrange[1] - yrange[0]
ylim = kwargs.get(
"ylim", (yrange[0] - ydelta * 0.05, yrange[1] + ydelta * 0.05))
if fig:
p = fig
prior_figure = True
else:
prior_figure = False
p = figure(
x_range=xlim,
y_range=ylim,
# https://github.com/bokeh/bokeh/issues/2351
tools="pan,wheel_zoom,box_zoom, box_select,lasso_select,reset,save",
)
h_line = p.line(
plotdata[x_column],
plotdata[y_column],
line_dash="solid",
color=kwargs.get("color", "black"),
line_width=kwargs.get("line_width", 2),
)
y_units = model.data.pi_units[y_column]
tooltips = [(x_column, "$x")]
if y_units:
tooltips.append((f"Prediction of {y_column} [{y_units}]", "$y"))
else:
tooltips.append((f"Prediction of {y_column}", "$y"))
tooltips.append(("Source", model.name or ""))
# custom tooltip for the predicted prediction line
h1 = HoverTool(tooltips=tooltips, renderers=[h_line])
h1.line_policy = "nearest"
if show_expt_data:
source = ColumnDataSource(data=dict(
x=model.data[x_column],
y=model.data[y_column],
output=model.data[model.get_response_name()].to_list(),
))
h_expts = p.circle(
x="x",
y="y",
color="black",
source=source,
size=10,
line_width=2,
name="Experimental_points",
)
h2 = HoverTool(
tooltips=[
(x_column, "$x"),
(y_column, "$y"),
("Experimental value", "@output"),
],
renderers=[h_expts],
)
h2.point_policy = "snap_to_data"
h2.line_policy = "none"
# Axis labels:
p.xaxis.axis_label_text_font_size = "14pt"
p.xaxis.axis_label = x_column
p.xaxis.major_label_text_font_size = "14pt"
p.xaxis.axis_label_text_font_style = "bold"
p.yaxis.major_label_text_font_size = "14pt"
p.yaxis.axis_label = y_column
p.yaxis.axis_label_text_font_size = "14pt"
p.yaxis.axis_label_text_font_style = "bold"
if prior_figure:
# p.xaxis.bounds =
p.x_range = Range1d(
min(xlim[0], p.x_range.start, min(model.data[x_column])),
max(xlim[1], p.x_range.end, max(model.data[x_column])),
)
p.y_range = Range1d(
min(ylim[0], p.y_range.start, min(model.data[y_column])),
max(ylim[1], p.y_range.end, max(model.data[y_column])),
)
else:
p.x_range = Range1d(xlim[0], xlim[1])
p.y_range = Range1d(ylim[0], ylim[1])
# Add the hover tooltips:
p.add_tools(h1)
p.add_tools(h2)
show_plot(p)
return p
def contour_plot_bokeh(
model,
xlabel=None,
ylabel=None,
main=None,
xlim=(-3.2, 3.2),
ylim=(-3.2, 3.2),
colour_function="terrain",
show=True,
show_expt_data=True,
figsize=(10, 10),
dpi=50,
other_factors=None,
):
# TODO: show labels of contour plot
# https://stackoverflow.com/questions/33533047/how-to-make-a-contour-plot-in-python-using-bokeh-or-other-libs
dpi_max = dpi**3.5
N = min(dpi, np.power(dpi_max, 0.5))
h_grid = np.linspace(xlim[0], xlim[1], num=N)
v_grid = np.linspace(ylim[0], ylim[1], num=N)
H, V = np.meshgrid(h_grid, v_grid)
h_grid, v_grid = H.ravel(), V.ravel()
pure_factors = model.get_factor_names(level=1)
if xlabel is None:
xlabel = pure_factors[0]
else:
xlabel = str(xlabel)
if ylabel is None:
ylabel = pure_factors[1]
else:
ylabel = str(ylabel)
kwargs = {xlabel: h_grid, ylabel: v_grid}
if other_factors is not None and isinstance(other_factors, dict):
kwargs = kwargs.update(other_factors)
# Look at which factors are included, and pop them out. The remaining
# factors are specified at their zero level
unspecified_factors = [i for i in pure_factors if i not in kwargs.keys()]
for factor in unspecified_factors:
kwargs[factor] = np.zeros_like(h_grid)
assert sorted(kwargs.keys()) == sorted(pure_factors), ("Not all factors "
"were specified.")
Z = predict(model, **kwargs)
Z = Z.values.reshape(N, N)
z_min, z_max = Z.min(), Z.max()
levels = np.linspace(z_min, z_max, N)
from matplotlib.pyplot import contour, clabel
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use("Agg")
# Turn interactive plotting off
plt.ioff()
CS = contour(H, V, Z, levels=levels, linestyles="dotted")
clabel(CS, inline=True, fontsize=10, fmt="%1.0f")
# contour_labels = [(float(q._x), float(q._y), float(q._text))\
# for q in CS.labelTexts]
# Convert the Matplotlib colour mapper to Bokeh
# https://stackoverflow.com/questions/49931311/using-matplotlibs-colormap-for-bokehs-color-bar
mapper = getattr(cm, colour_function)
colours = (255 * mapper(range(256))).astype("int")
colour_palette = [RGB(*tuple(rgb)).to_hex() for rgb in colours]
color_mapper = LinearColorMapper(palette=colour_palette,
low=z_min,
high=z_max)
# Another alternative:
# https://stackoverflow.com/questions/35315259/using-colormap-with-bokeh-scatter
# colors = ["#%02x%02x%02x" % (int(r), int(g), int(b)) for \
# r, g, b, _ in 255*mpl.cm.viridis(mpl.colors.Normalize()(radii))]
p = figure(
x_range=xlim,
y_range=ylim,
# https://github.com/bokeh/bokeh/issues/2351
tools="pan,wheel_zoom,box_zoom,box_select,lasso_select,reset,save",
)
# Create the image layer
source = {"Xax": [h_grid], "Yax": [v_grid], "predictions": [Z]}
h_image = p.image(
source=source,
image="predictions",
x=xlim[0],
y=ylim[0],
dw=xlim[1] - xlim[0],
dh=ylim[1] - ylim[0],
color_mapper=color_mapper,
global_alpha=0.5, # with some transparency
name="contour_image",
)
h1 = HoverTool(
tooltips=[
(xlabel, "@{Xax}{0.4g}"),
(ylabel, "@{Yax}{0.4f}"),
("Predicted", "@{predictions}{0.4g}"),
],
renderers=[h_image],
formatters={
"Predicted": "printf",
xlabel: "printf",
ylabel: "printf"
},
)
color_bar = ColorBar(
color_mapper=color_mapper,
major_label_text_font_size="8pt",
ticker=BasicTicker(max_interval=(z_max - z_min) / N * 2),
formatter=PrintfTickFormatter(format="%.2f"),
label_standoff=6,
border_line_color=None,
location=(0, 0),
)
p.add_layout(color_bar, "right")
# Contour lines using Scipy:
# scaler_y = (ylim[1] - ylim[0]) / (N - 1)
# scaler_x = (xlim[1] - xlim[0]) / (N - 1)
# for level in levels:
# contours = measure.find_contours(Z, level)
# for contour in contours:
# x = contour[:, 1] * scaler_y + ylim[0]
# y = contour[:, 0] * scaler_x + xlim[0]
for _, cccontour in enumerate(CS.allsegs):
if cccontour:
x = cccontour[0][:, 0]
y = cccontour[0][:, 1]
p.line(x, y, line_dash="dashed", color="darkgrey", line_width=1)
# TODO: bigger experimental markers
# TODO: hover for the data point shows the factor settings for the data point
if show_expt_data:
source = ColumnDataSource(data=dict(
x=model.data[xlabel],
y=model.data[ylabel],
output=model.data[model.get_response_name()].to_list(),
))
h_expts = p.circle(
x="x",
y="y",
color="black",
source=source,
# linestyle='',
# marker='o',
size=10,
line_width=2,
name="experimental_points",
)
# custom tooltip for the experimental points
h2 = HoverTool(
tooltips=[
(xlabel, "$x{0.4g}"),
(ylabel, "$y{0.4g}"),
("Actual value", "@{output}{0.4g}"), # why not working???
],
renderers=[h_expts],
formatters={
"Actual value": "printf",
xlabel: "printf",
ylabel: "printf"
},
)
h2.point_policy = "snap_to_data"
h2.line_policy = "none"
# Axis labels:
p.xaxis.axis_label_text_font_size = "14pt"
p.xaxis.axis_label = xlabel
p.xaxis.major_label_text_font_size = "14pt"
p.xaxis.axis_label_text_font_style = "bold"
p.xaxis.bounds = (xlim[0], xlim[1])
p.yaxis.major_label_text_font_size = "14pt"
p.yaxis.axis_label = ylabel
p.yaxis.axis_label_text_font_size = "14pt"
p.yaxis.axis_label_text_font_style = "bold"
p.yaxis.bounds = (ylim[0], ylim[1])
# Add the hover tooltips:
p.add_tools(h1)
p.add_tools(h2)
if show:
show_plot(p)
return p
# instantiate shared generic plot settings
# hover tool
hoverm = HoverTool(tooltips=[
("Age", "(@Age)"),
("Incidents", "(@Males{0,0.000})"),
],
mode='vline')
hoverf = HoverTool(tooltips=[
("Age", "(@Age)"),
("Incidents", "(@Females{0,0.000})"),
],
mode='hline')
hoverm.point_policy = 'snap_to_data'
hoverm.line_policy = 'nearest'
# graph tool bar
toolsm = ["box_select", hoverm, "reset"]
toolsf = ["box_select", hoverf, "reset"]
#create the main plot
def create_figure(*args):
#create new plot with sizing & labels
mplot = figure(x_range=label,
plot_width=900,
plot_height=400,
tools=toolsm,
title="Cancer Incidents in Males 2016")
#remove bokeh logo, add axis labels
std = np.std(delta)
rms = np.sqrt(np.mean(delta**2))
date = datetime.date.today().strftime("%B") + " " + datetime.date.today(
).strftime("%d") + ", " + datetime.date.today().strftime("%Y")
output_file("test.html")
hover = HoverTool(tooltips=[
("inc_x", "@inc_x"),
("inc_y", "@inc_y"),
("PGC", "@PGC"),
])
hover.point_policy = 'snap_to_data'
hover.line_policy = 'nearest' #'prev'
TOOLS = [hover, 'pan', 'tap', 'wheel_zoom', 'box_zoom', 'reset', 'save']
p = figure(tools=TOOLS,
toolbar_location="below",
logo="grey",
plot_width=500,
plot_height=400,
title="Last update: " + date)
p.grid.grid_line_color = "gainsboro"
p.line([0, 100], [0, 100], line_width=2, color="black", legend="equality")
p.line([0, 100], [5, 105],
line_width=1,
def plot_classification_probabilities(
x,
y,
cv_results,
output_html=None,
width=500,
height=500,
sizing_mode="stretch_both",
):
"""Plot the classification probabilities for each cross-validation split
Parameters
----------
x : numpy.ndarray
The original feature matrix
y : numpy.ndarray
The target array (i.e. "ground truth")
cv_results : list of SGLResult namedtuples
Results of each cross-validation split
output_html : string or None, default=None
Filename for bokeh html output. If None, figure will not be saved
width : int, default=500
Width of each beta plot (in pixels)
height : int, default=500
Height of each beta plot (in pixels)
sizing_mode : string
One of ("fixed", "stretch_both", "scale_width", "scale_height",
"scale_both"). Specifies how will the items in the layout resize to
fill the available space. Default is "stretch_both". For more
information on the different modes see
https://bokeh.pydata.org/en/latest/docs/reference/models/layouts.html#bokeh.models.layouts.LayoutDOM
"""
p = figure(plot_width=width, plot_height=height, toolbar_location="above")
p.title.text = "Classification probabilities for each CV split"
p.add_layout(
Title(
text="Click on legend entries to hide/show corresponding lines",
align="left",
),
"right",
)
names = ["cv_idx = {i:d}".format(i=i) for i in range(len(cv_results))]
hover = HoverTool(tooltips=[("Subject", "$index")], mode="vline")
hover.point_policy = "snap_to_data"
hover.line_policy = "nearest"
for res, color, name in zip(cv_results, Spectral10, names):
p.line(
np.arange(len(y)),
_sigmoid(x.dot(res.beta_hat)),
line_width=2,
color=color,
alpha=0.8,
legend=name,
)
p.line(np.arange(len(y)), y, line_width=3, alpha=0.8, legend="ground truth")
p.line(
np.arange(len(y)),
0.5 * np.ones(len(y)),
line_width=2,
line_dash="dashed",
alpha=0.8,
legend="threshold",
)
p.add_tools(hover)
p.legend.location = "top_right"
p.legend.click_policy = "hide"
p.xaxis.axis_label = "Subject ID"
p.xaxis.major_tick_line_color = None # turn off x-axis major ticks
p.xaxis.minor_tick_line_color = None # turn off x-axis minor ticks
p.xaxis.major_label_text_font_size = "0pt" # turn off x-axis tick labels
p.yaxis.axis_label = "Classification Probability"
p.sizing_mode = sizing_mode
if output_html is not None:
html = file_html(p, CDN, "my plot")
with open(op.abspath(output_html), "w") as fp:
fp.write(html)
else:
show(p)
def rca2(functionNode):
logger = functionNode.get_logger()
logger.info("==>>>> in rca2 (root cause analysis " +
functionNode.get_browse_path())
progressNode = functionNode.get_child("control").get_child("progress")
progressNode.set_value(0.1)
m = functionNode.get_model()
report = '<i>REPORT</i><br><div style="font-size:85%">'
annotations = functionNode.get_child("annotations").get_leaves()
#order = ["Step"+str(no) for no in range(1,19)]
order = ["Phase" + str(no) for no in range(3, 28)]
order = functionNode.get_child("annotationsOrder").get_value()
annotations = data_cleaning(annotations, order=order,
logger=logger) #Step1,Step2,...Step18
report += (f"found {len(annotations)} valid processes <br>")
#for now, flatten them out
annotations = [
subprocess for process in annotations for subprocess in process
]
algo = functionNode.get_child("selectedAlgorithm").get_value()
target = functionNode.get_child("selectedTarget").get_target()
progressNode.set_value(0.3)
#now we are building up the table by iterating all the children in "selection"
entries = functionNode.get_child("selection").get_children()
table = {"target": []}
firstVariable = True
for entry in entries:
logger.debug(f"entry {entry.get_name()}")
#each entry is a combination of variable, tags and feature
vars = entry.get_child("selectedVariables").get_targets()
tags = entry.get_child("selectedTags").get_value()
features = entry.get_child("selectedFeatures").get_value()
#for iterate over variables
for var in vars:
logger.debug(
f"processing variable: {var.get_name()} with tags {tags} and features {features}"
)
#columnName = var.get_name()+str(tags)+m.getRandomId()
for tag in tags:
row = 0
#table[columnName]=[]# make a column
for idx, anno in enumerate(annotations):
if anno.get_child("type").get_value() != "time":
continue
if tag in anno.get_child("tags").get_value():
startTime = anno.get_child("startTime").get_value()
endTime = anno.get_child("endTime").get_value()
data = var.get_time_series(startTime,
endTime)["values"]
#we take only the values "inside" the annotation
if len(data) > 2:
data = data[1:-1]
#now create the features
for feature in features:
feat = calc_feature(data, feature)
columnName = var.get_name(
) + "_" + tag + "_" + feature
if not columnName in table:
table[columnName] = []
table[columnName].append(feat)
targetValue = get_target(
target,
(date2secs(startTime) + date2secs(endTime)) / 2)
if targetValue:
if firstVariable:
#for the first variable we also write the target
table["target"].append(targetValue)
else:
#for all others we make sure we have the same target value for that case (sanity check)
if table["target"][row] != targetValue:
logger.warning(
f'problem target {table["target"][row]} !=> {targetValue}'
)
row = row + 1
else:
logger.warning(
f"no corrrect target value for {startTime} - {endTime}"
)
firstVariable = False
#now we have the table, plot it
import json
#print(json.dumps(table,indent=2))
progressNode.set_value(0.5)
#try a model
algo = functionNode.get_child("selectedAlgorithm").get_value()
if algo == "lasso":
reg = linear_model.LassoCV()
report += " using lasso Regression with auto-hyperparams <br>"
else:
#default
report += " using linear Regression <br>"
reg = linear_model.LinearRegression() #try rigde, lasso
columnNames = []
dataTable = []
for k, v in table.items():
if k == "target":
continue
dataTable.append(v)
columnNames.append(k)
dataTable = numpy.asarray(dataTable)
x = dataTable.T
y = table["target"]
x_train, x_test, y_train, y_test = train_test_split(x, y)
reg.fit(x_train, y_train)
print(reg.coef_)
y_hat = reg.predict(x_test)
y_repeat = reg.predict(x_train)
print(f"predict: {y_hat} vs real: {y_test}")
#check over/underfitting
r_train = r2_score(y_train, y_repeat)
r_test = r2_score(y_test, y_hat)
report += "R<sup>2</sup> train= %.4g, R<sup>2</sup> test = %.4g <br>" % (
r_train, r_test)
pearsons = []
for col in x.T:
pearsons.append(pearsonr(col, y)[0])
#and finally the correlations between y and yhat
y_pearson_train = pearsonr(y_train, y_repeat)[0]
y_pearson_test = pearsonr(y_test, y_hat)[0]
report += "pearsonCorr y/y_hat train:%.4g , test:%.4g <br>" % (
y_pearson_train, y_pearson_test)
report += "regression coefficients, pearsons correlations:<br>"
for col, coef, pear in zip(columnNames, reg.coef_, pearsons):
report += "    %s:%.4g,   %.4g <br>" % (col, coef, pear)
#write report
progressNode.set_value(0.8)
report += "<div>" #close the style div
functionNode.get_child("report").set_value(report)
#make a plot
hover1 = HoverTool(tooltips=[('x,y', '$x,$y')], mode='mouse')
hover1.point_policy = 'snap_to_data'
hover1.line_policy = "nearest"
tools = [
PanTool(),
WheelZoomTool(),
BoxZoomTool(),
ResetTool(),
SaveTool(), hover1
]
title = "prediction results on " + functionNode.get_child(
"selectedAlgorithm").get_value()
fig = figure(title=title, tools=tools, plot_height=400, plot_width=500)
fig.toolbar.logo = None
curdoc().theme = Theme(json=themes.darkTheme)
fig.xaxis.major_label_text_color = themes.darkTickColor
fig.yaxis.major_label_text_color = themes.darkTickColor
fig.xaxis.axis_label = target.get_name()
fig.xaxis.axis_label_text_color = "white"
fig.yaxis.axis_label = "predicted Values for " + target.get_name()
fig.yaxis.axis_label_text_color = "white"
fig.circle(y_train,
y_repeat,
size=4,
line_color="white",
fill_color="white",
name="train",
legend_label="train")
fig.circle(y_test,
y_hat,
line_color="#d9b100",
fill_color="#d9b100",
size=4,
name="test",
legend_label="test")
fileName = functionNode.get_child("outputFileName").get_value()
filePath = os.path.join(myDir, './../web/customui/' + fileName)
fig.legend.location = "top_left"
output_file(filePath, mode="inline")
save(fig)
return True
x = [0, 1, 2, 3, 4, 5]
y = [0, 1, 4, 9, 16, 25]
# set output to static HTML file
output_file("quad.html")
# create a new plot with a title and axis labels
p = figure(title="x^2 example",
x_axis_label='x',
y_axis_label='y',
active_scroll="wheel_zoom")
# add a line renderer with legend and line thickness
p.line(x, y, legend_label="x-val legend label", line_width=2)
# customize the hover_tool/tooltip
hover_tool = HoverTool(tooltips=[("x val", "$x"), ("y val", "$y")])
hover_tool.point_policy = "snap_to_data"
hover_tool.line_policy = "interp" # interpolate if between data points, makes it more continuous
hover_tool.mode = "vline" #shows value if in line vertically (no need to be directly on top of graph line)
p.add_tools(hover_tool)
# remove tools on the right and logo for clean look
p.toolbar.logo = None
p.toolbar_location = None
# show graph
show(p)
x_range = []
# for level in range (1,7):
# search_str_list.append ("LTE.*RSSI Level " + str(level))
#
# print (search_str_list)
hover = HoverTool(tooltips=[
("index", "$index"),
("Power", "@y"),
("desc", "@desc"),
],
names=["foo"],
mode='vline')
hover.point_policy = "snap_to_data"
hover.line_policy = "nearest"
p = figure(
plot_width=800,
plot_height=800,
title="LTE RSSI",
tools=[hover,
BoxZoomTool(),
ResetTool(),
PanTool(),
BoxSelectTool()])
for row in reader:
if row['Product'] == "Upper Limits----->":
for field in search_fieldlist:
upper_limit.append(float(row[field]))
source_im = ColumnDataSource(data=dict(x=x, y=y7))
source_na = ColumnDataSource(data=dict(x=x, y=y8))
source_ra = ColumnDataSource(data=dict(x=x, y=y9))
source_da = ColumnDataSource(data=dict(x=x, y=y10))
source_ic = ColumnDataSource(data=dict(x=x, y=y11))
source_pr = ColumnDataSource(data=dict(x=x, y=y12))
# Incidence vs Rt
source_phase_space = ColumnDataSource(data=dict(x=y5, y=y11))
# plot 1
hover = HoverTool(tooltips=[(PLOT_X_LABEL, "@x{0}"), (PLOT_Y_LABEL, "@y{0}")],
mode="vline")
hover.point_policy = 'snap_to_data'
hover.line_policy = 'nearest'
plot = figure(
plot_height=PLOT_HEIGHT,
plot_width=PLOT_WIDTH,
title=PLOT_TITLE,
tools=PLOT_TOOLS,
x_range=[0, DAYS],
)
plot.line('x',
'y',
source=source_active,
line_width=PLOT_LINE_WIDTH,
line_alpha=PLOT_LINE_ALPHA,
line_color=PLOT_LINE_ACTIVE_COLOR,
def varstatistics(functionNode):
logger = functionNode.get_logger()
logger.info("==>>>> statistics " + functionNode.get_browse_path())
progressNode = functionNode.get_child("control").get_child("progress")
progressNode.set_value(0)
#functionNode.get_child("control.signal").set_value(None)
vars = functionNode.get_child("variable").get_targets()
widget = functionNode.get_child("widget").get_target()
bins = functionNode.get_child("bins").get_value()
tags = functionNode.get_child("annotations").get_value()
startTime = date2secs(widget.get_child("startTime").get_value())
endTime = date2secs(widget.get_child("endTime").get_value())
vars = {var.get_id(): {"node": var} for var in vars}
#first 30% progress:
prog = Progress(progressNode)
progressNode.set_value(0.1)
prog.set_offset(0.1)
#prog.set_divisor()
if tags:
allAnnoNodes = widget.get_child(
"hasAnnotation.annotations").get_leaves()
allAnnos = []
prog.set_divisor(len(allAnnoNodes) / 0.2)
for index, node in enumerate(allAnnoNodes):
prog.set_progress(index)
if node.get_child("type").get_value() == "time":
thisTags = node.get_child("tags").get_value()
if any(tag in tags for tag in thisTags):
anno = {}
for child in node.get_children():
anno[child.get_name()] = child.get_value()
if date2secs(anno["startTime"]) >= startTime and date2secs(
anno["endTime"]
) <= endTime: #take this anno only if it is inside the current start/end time
allAnnos.append(anno)
if allAnnos == []:
give_up(functionNode, "no matching annotations in selected time")
return False
else:
allAnnos = []
progressNode.set_value(0.3)
logger.debug(f"statistics annotations to look at: {len(allAnnos)}")
prog.set_offset(0.3)
totalAnnos = max(len(allAnnos), 1)
totalCount = len(vars) * totalAnnos
prog.set_divisor(totalCount / 0.3)
totalValids = 0
for varIndex, var in enumerate(vars):
info = vars[var]
if tags:
#iterate over all start and end times
values = numpy.asarray([], dtype=numpy.float64)
for annoIndex, anno in enumerate(allAnnos):
thisValues = info["node"].get_time_series(
anno["startTime"], anno["endTime"])["values"]
values = numpy.append(values, thisValues)
myCount = varIndex * totalAnnos + annoIndex
prog.set_progress(myCount)
else:
values = info["node"].get_time_series(startTime, endTime)["values"]
valids = numpy.count_nonzero(~numpy.isfinite(values))
totalValids += valids
hist, edges = numpy.histogram(values, bins=bins)
hist = hist / len(values) #normalize
info["hist"] = hist
info["edges"] = edges
#make a plot
if totalValids == 0:
give_up(
functionNode,
"all Variables are have no data in the time and annotations selected"
)
return False
progressNode.set_value(0.6)
hover1 = HoverTool(tooltips=[('x,y', '$x,$y')], mode='mouse')
hover1.point_policy = 'snap_to_data'
hover1.line_policy = "nearest"
tools = [
PanTool(),
WheelZoomTool(),
BoxZoomTool(),
ResetTool(),
SaveTool(), hover1
]
title = "Statistics of " + str(
[info["node"].get_name() for var, info in vars.items()])
if tags:
title = title + " in annotation: " + str(tags)
fig = figure(title=title, tools=tools, plot_height=300)
fig.toolbar.logo = None
curdoc().theme = Theme(json=themes.darkTheme)
fig.xaxis.major_label_text_color = themes.darkTickColor
fig.yaxis.major_label_text_color = themes.darkTickColor
for index, var in enumerate(vars):
info = vars[var]
col = themes.darkLineColors[index]
hist = info["hist"]
edges = info["edges"]
fig.quad(top=hist,
bottom=0,
left=edges[:-1],
right=edges[1:],
fill_color=col,
line_color=col,
alpha=0.8,
legend_label=info["node"].get_name())
fig.legend.location = "top_left"
fileName = functionNode.get_child("fileName").get_value()
filePath = os.path.join(myDir, './../web/customui/' + fileName)
# now make the trend box plot, but only for tags
# for each variable we create statistics for the annotations and prepare the data
# {"node":Node(), "boxLower":[], "boxUpper", "mean", "limitUpper", "limitLower"}
#
startTime = date2secs(widget.get_child("startTime").get_value(
)) #we only take tags that are inside the current zoom of the widgets
endTime = date2secs(widget.get_child("endTime").get_value())
boxPlots = []
allTimes = []
if tags:
for index, var in enumerate(vars):
info = {
"node": vars[var]["node"],
"boxLower": [],
"boxUpper": [],
"median": [],
"time": [],
"limitUpper": [],
"limitLower": [],
"mean": []
}
for anno in allAnnos:
data = info["node"].get_time_series(anno["startTime"],
anno["endTime"])
if len(data["values"]):
data["values"] = data["values"][numpy.isfinite(
data["values"])]
#remove the nan
if len(data["values"]):
#make the statistics
info["time"].append(numpy.median(data["__time"]) * 1000)
allTimes.append(numpy.median(data["__time"]) * 1000)
info["limitLower"].append(
numpy.quantile(data["values"], 0.01))
info["limitUpper"].append(
numpy.quantile(data["values"], 0.99))
info["boxLower"].append(
numpy.quantile(data["values"], 0.25))
info["boxUpper"].append(
numpy.quantile(data["values"], 0.75))
info["median"].append(numpy.median(data["values"]))
info["mean"].append(numpy.mean(data["values"]))
boxPlots.append(info)
format = "%Y-%m-%d-T%H:%M:%S"
custom = """var local = moment(value).tz('UTC'); return local.format();""" #%self.server.get_settings()["timeZone"]
hover = HoverTool(tooltips=[('date', '@x{%F}')],
formatters={'@x': CustomJSHover(code=custom)},
mode='mouse')
hover.point_policy = 'snap_to_data'
hover.line_policy = "nearest"
tools = [
PanTool(),
BoxZoomTool(),
WheelZoomTool(),
ResetTool(), hover,
SaveTool()
]
fig2 = figure(title="trends",
tools=tools,
plot_height=300,
x_axis_type='datetime')
fig2.xaxis.major_label_text_color = themes.darkTickColor
fig2.yaxis.major_label_text_color = themes.darkTickColor
progressNode.set_value(0.7)
fig2.xaxis.formatter = DatetimeTickFormatter(years=format,
days=format,
months=format,
hours=format,
hourmin=format,
minutes=format,
minsec=format,
seconds=format)
fig2.toolbar.logo = None
#fig2.line([1,2,3],[1,2,3])
#calc with of vbars
if len(allAnnos) > 1:
xTimesStart = min(allTimes)
xTimesEnd = max(allTimes)
width = (xTimesEnd - xTimesStart) / 2 / len(allAnnos)
else:
width = 1000000
for index, info in enumerate(boxPlots):
#each info is for one variable
col = themes.darkLineColors[index]
fig2.segment(info["time"],
info["limitUpper"],
info["time"],
info["boxUpper"],
line_color=col)
fig2.segment(info["time"],
info["limitLower"],
info["time"],
info["boxLower"],
line_color=col)
width = 20
#fig2.vbar(info["time"],width=width,bottom=info["median"],top=info["boxUpper"],fill_color=col,line_color="black",width_units='screen')
#fig2.vbar(info["time"],width=width,bottom=info["boxLower"],top=info["median"],fill_color=col,line_color="black",width_units='screen')
#upper box
sizUpper = numpy.asarray(info["boxUpper"]) - numpy.asarray(
info["median"])
medUpper = numpy.asarray(info["median"]) + sizUpper / 2
fig2.rect(x=info["time"],
y=medUpper,
width_units='screen',
width=20,
height=sizUpper,
fill_color=col,
line_color="black")
#lower box
sizLower = numpy.asarray(info["median"]) - numpy.asarray(
info["boxLower"])
medLower = numpy.asarray(info["median"]) - sizLower / 2
fig2.rect(x=info["time"],
y=medLower,
width_units='screen',
width=20,
height=sizLower,
fill_color=col,
line_color="black")
#sort data for line
x = numpy.asarray(info["time"])
y = numpy.asarray(info["mean"])
order = numpy.argsort(x)
x = x[order]
y = y[order]
fig2.line(x, y, line_color=col)
progressNode.set_value(0.8)
else:
#no fig2
pass
output_file(
filePath, mode="inline"
) #inline: put the bokeh .js into this html, otherwise the default cdn will be taken, might cause CORS problems
if tags:
save(layout([[fig], [fig2]]))
else:
save(fig)
return True
