def __init__(self, ui, ally=None, active=True, interval=250):
super(Ally, self).__init__()
if ally is None:
return
self.ally = ally
# Create a dict so we now where we currently are
self.current = {
'velocity': None,
'my_state': None,
'opponent_state': None,
'ball_state': None,
'pidinfo': None,
'desired_position': None,
'desired_position_safe': None,
'other_opponent_state': None,
'other_ally_state': None
}
# Create a dictionary for last messages of different types
self.last = copy.deepcopy(self.current)
# Click to Drive positions (CTD)
self.CTD_x1 = self.CTD_y1 = None
self.CTD_x2 = self.CTD_y2 = None
# Setup the UI for this ally
self.ui = AllyUI(ui, ally=ally)
# After we've set up the GUI, if this ally is not active just bail
if not active:
self.ui.append_title('Inactive')
return
# Placeholders for child windows
self._step_resp = None
# Figure out my namespace based on who I am
ns = '/ally{}'.format(ally)
self.ns = ns
# If I am this ally, who is the other ally?
other_ally = 1 if ally == 2 else 2
# Connect ROS things
rospy.Subscriber('{}/ally{}_state'.format(ns,ally), \
RobotState, self._handle_my_state)
rospy.Subscriber('{}/ally{}_state'.format(ns,other_ally), \
RobotState, self._handle_other_ally_state)
rospy.Subscriber('{}/opponent{}_state'.format(ns,ally), \
RobotState, self._handle_opponent_state)
rospy.Subscriber('{}/opponent{}_state'.format(ns,other_ally), \
RobotState, self._handle_other_opponent_state)
rospy.Subscriber('{}/ball_state'.format(ns), \
BallState, self._handle_ball_state)
rospy.Subscriber('{}/desired_position'.format(ns), \
Pose2D, self._handle_des_pos)
rospy.Subscriber('{}/desired_position_safe'.format(ns), \
Pose2D, self._handle_des_pos_safe)
rospy.Subscriber('{}/vel_cmds'.format(ns), \
Twist, self._handle_vel)
rospy.Subscriber('{}/pidinfo'.format(ns), \
PIDInfo, self._handle_PID_error)
self.pub_des_pos = rospy.Publisher('{}/desired_position'.format(ns), \
Pose2D, queue_size=10)
# Connect Qt Buttons
self.ui.btn_clear.clicked.connect(self._btn_clear)
self.ui.btn_kick.clicked.connect(self._btn_kick)
self.ui.btn_battery.clicked.connect(self._btn_battery)
self.ui.btn_set_des_pos.clicked.connect(self._btn_des_pos)
self.ui.btn_stop_moving.clicked.connect(self._btn_stop_moving)
self.ui.btn_step_resp.clicked.connect(self._btn_step_resp)
# Connect Plot Mouse events
self.ui.plot_field.canvas.mpl_connect('button_press_event', self._plot_field_mouse_down)
self.ui.plot_field.canvas.mpl_connect('motion_notify_event', self._plot_field_mouse_move)
self.ui.plot_field.canvas.mpl_connect('button_release_event', self._plot_field_mouse_up)
# matplotlib create animation
# Look into using the same event_source for the two -- maybe this would help
# decrease overhead/latency? See matplotlib source code for more info
## Interval - I had interval=8ms and everything was smooth, but CPU was
## at 130%. I changed it to 500ms and it went down to 30%! But the plotting
## was severly discretized. A good in between was at 250ms (~60% CPU), but if
## you're on a faster machine, you may want to increase interval to ~100ms
self.animation_field = animation.FuncAnimation(self.ui.plot_field.canvas.fig, \
self._animate_field, init_func=self._animate_init_field, \
frames=None, interval=interval, blit=False, event_source=None)
if pkt.addr2 != None and pkt.addr2 not in excluded_macs and pkt.addr2 not in found_macs:
add_mac(pkt.addr2)
if args.exclude_file != None:
for mac in args.exclude_file:
excluded_macs.append(mac.strip().split()[0])
class PseudoPacket:
def __init__(self, mac):
self.addr2 = mac
if args.import_file != None:
for mac in args.import_file:
PacketHandler(PseudoPacket(mac.strip().split()[0]))
if not args.disable:
if args.graph:
# Start Packet Sniffer in separate thread
thread.start_new_thread(sniff, (),
dict(iface=args.interface, prn=PacketHandler))
else:
sniff(iface=args.interface, prn=PacketHandler)
if args.graph:
# Setup Pie Chart, Begin 1s refresh, and show initial graph
update_pie_chart(0)
ani = animation.FuncAnimation(fig, update_pie_chart, interval=1000)
plt.show()
idf = pd.read_csv('data/SPY_20110701_20120630_Bollinger.csv',
index_col=0,
parse_dates=True)
idf.shape
idf.head(3)
idf.tail(3)
df = idf.loc['2011-07-01':'2011-12-30', :]
fig = mpf.figure(style='charles', figsize=(7, 8))
ax1 = fig.add_subplot(2, 1, 1)
ax2 = fig.add_subplot(3, 1, 3)
def animate(ival):
if (22 + ival) > len(df):
print('no more data to plot')
ani.event_source.interval *= 3
if ani.event_source.interval > 12000:
exit()
return
data = df.iloc[0 + ival:(22 + ival)]
ax1.clear()
ax2.clear()
mpf.plot(data, ax=ax1, volume=ax2, type='ohlc')
ani = animation.FuncAnimation(fig, animate, interval=250)
mpf.show()
# animation function. This will be called sequentially with the frame number
def animate(i):
# we'll step two time-steps per frame. This leads to nice results.
i = (2 * i) % x_t.shape[1]
for line, pt, xi in zip(lines, pts, x_t):
x, y, z = xi[:i].T
line.set_data(x, y)
line.set_3d_properties(z)
pt.set_data(x[-1:], y[-1:])
pt.set_3d_properties(z[-1:])
ax.view_init(30, 0.3 * i)
fig.canvas.draw()
return lines + pts
# instantiate the animator.
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=500,
interval=30,
blit=True)
# Save as mp4. This requires mplayer or ffmpeg to be installed
#anim.save('lorentz_attractor.mp4', fps=15, extra_args=['-vcodec', 'libx264'])
plt.show()
line2, = ax.plot([], [], lw=2)
tot_time = 20
intv = 20
def init():
line.set_data([], [])
line2.set_data([], [])
return line,
def animate(i):
x = np.linspace(-8, 8, 1000)
y = np.sin(0.1 * x * i)
y2 = np.cos(0.1 * x * i)
line.set_data(x, y)
line2.set_data(x, y2)
return line,
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=(tot_time * 1000) // intv,
interval=intv,
blit=True)
#anim.save('basic_animation.mp4', fps=30, extra_args=['-vcodec', 'libx264'])
plt.show()
def plot(title):
ani = animation.FuncAnimation(fig, animate, interval=2)
print(title)
plt.title("{}\n".format(title))
plt.show()
ep.set_data([x_OA[k], x_OBp[k]], [y_OA[k], y_OBp[k]])
for j in range(theta.size):
es[j].set_data([x_OC[j][k], x_OBs[j][k]], [y_OC[j][k], y_OBs[j][k]])
for j in range(theta.size):
e0[j].set_data([x_OA[k], x_OC[j][k]], [y_OA[k], y_OC[j][k]])
ea.set_data([0., x_OA[k]], [0., y_OA[k]])
cp.set_data(alpha[0:k], OBp[0:k])
for j in range(theta.size):
cs[j].set_data(alpha[0:k], OBs[j][0:k])
return artists
if blit:
animation = ani.FuncAnimation(fig, animate, frames=frames, init_func=init,
interval=interval, blit=True)
else:
animation = ani.FuncAnimation(fig, animate, frames=frames,
interval=interval)
# *************************************
# - Output file generation -
# If selected the output option, graphic window will not be shown.
# !!! <--droid> option added to have a fast way to watch this animations
# in every android cell phone.
if filename:
print('Generating animation...')
animation.save(filename + '.mp4', fps=fps, writer='ffmpeg',
def draw_it(self, **kwargs):
sliding_window_size = (3, 3)
if 'sliding_window_size' in kwargs:
sliding_window_size = kwargs['sliding_window_size']
stride = 1
if 'stride' in kwargs:
stride = kwargs['stride']
# initialize figure
fig = plt.figure(figsize=(10, 4))
artist = fig
# create subplot with 3 panels, plot input function in center plot
gs = gridspec.GridSpec(1, 3, width_ratios=[1, 3, 1])
ax1 = plt.subplot(gs[0])
ax1.axis('off')
ax3 = plt.subplot(gs[2])
ax3.axis('off')
ax = plt.subplot(gs[1])
slider = []
for i in np.arange(
0,
np.shape(self.image)[0] - sliding_window_size[0] + 1, stride):
for j in np.arange(
0,
np.shape(self.image)[1] - sliding_window_size[1] + 1,
stride):
slider.append((i, j))
num_frames = np.shape(slider)[0]
print('starting animation rendering...')
# animation sub-function
def animate(k):
# clear the panel
ax.cla()
# print rendering update
if np.mod(k + 1, 25) == 0:
print('rendering animation frame ' + str(k + 1) + ' of ' +
str(num_frames))
if k == num_frames - 1:
print('animation rendering complete!')
time.sleep(1.5)
clear_output()
# plot original image
ax.imshow(cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB))
# plot sliding window
ax.add_patch(
patches.Rectangle(
(slider[k][1], slider[k][0]), # (x,y)
sliding_window_size[1], # width
sliding_window_size[0], # height
edgecolor="red",
linewidth=2,
facecolor="none"))
# remove tickmarks
ax.set_xticks([])
ax.set_yticks([])
return artist,
anim = animation.FuncAnimation(fig,
animate,
frames=num_frames,
interval=num_frames,
blit=True)
return (anim)
def spectral_anim(
RawData_Frames,
spectra_wl,
ts,
interval=15,
time_template = 'Gate Delay = %.1fns'
):
"""
Matplotlib Animation Example
author: Jake Vanderplas
email: [email protected]
website: http://jakevdp.github.com
license: BSD
Please feel free to use and modify this, but keep the above information.
Thanks!
TODO: add documentation
Parameters
----------
RawData_Frames
spectra_wl
ts
interval
Returns
-------
"""
xs = spectra_wl
# First set up the figure, the axis, and the plot element we want to animate
fig = plt.figure()
ax = plt.axes(
xlim=(xs[0], xs[-1]),
ylim=(0, 1.1)
)
line, = ax.plot(
[],
[],
lw=2
)
time_text = ax.text(
0.05,
0.9,
'',
transform=ax.transAxes
)
fig.tight_layout()
#
def init():
"""
TODO: improve documentation
initialization function: plot the background of each frame
Returns
-------
line
"""
line.set_data([], [])
time_text.set_text('')
ax.set_ylabel("Normalized Emission Intensity (a.u.)")
ax.set_xlabel("Wavelength (nm)")
return line,
def animate(i):
"""
TODO: improve documentation
animation function. This is called sequentially
Parameters
----------
i : int
Returns
-------
"""
y = RawData_Frames.iloc[:, i]#.as_matrix()
y = y / RawData_Frames.max().max()
line.set_data(
xs,
y
)
if time_template is not None:
time_text.set_text(time_template % ts[i])
else:
time_text.set_text(str(ts[i].astype('datetime64[ms]')))
return line, time_text
# call the animator.
# blit=True means only re-draw the parts that have changed.
anim = animation.FuncAnimation(
fig,
animate,
init_func=init,
frames=len(ts),
interval=interval,
blit=True
)
# # equivalent to rcParams['animation.html'] = 'html5'
# rc(
# 'animation',
# html='html5'
# )
return anim
# initialization function: plot the background of each frame
def init():
points.set_data([], [])
return points,
# animation function. This is called sequentially
def animate(i):
x = real_values[i, :]
y = imag_values[i, :]
points.set_data(x, y)
return points,
# call the animator. blit=True means only re-draw the parts that have changed.
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=len(indivs[:, 0]),
interval=800,
blit=True)
# save the animation as an mp4. This requires ffmpeg or mencoder to be
# installed. The extra_args ensure that the x264 codec is used, so that
# the video can be embedded in html5. You may need to adjust this for
# your system: for more information, see
# http://matplotlib.sourceforge.net/api/animation_api.html
anim.save(filename + '_animation.mp4', fps=fps)
plt.show()
y2 = -L2*cos(y[:, 2]) + y1
fig = plt.figure()
ax = fig.add_subplot(111, autoscale_on=False, xlim=(-2, 2), ylim=(-2, 2))
ax.set_aspect('equal')
ax.grid()
line, = ax.plot([], [], 'o-', lw=2)
time_template = 'time = %.1fs'
time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)
def init():
line.set_data([], [])
time_text.set_text('')
return line, time_text
def animate(i):
thisx = [0, x1[i], x2[i]]
thisy = [0, y1[i], y2[i]]
line.set_data(thisx, thisy)
time_text.set_text(time_template % (i*dt))
return line, time_text
ani = animation.FuncAnimation(fig, animate, range(1, len(y)),
interval=dt*1000, blit=True, init_func=init)
plt.show()
def init():
line.set_data([], [])
return line,
''' animation function. This is called sequentially and will be called by FuncAnimation repeatedly
in order to create the animation dictatedd by curve equation.'''
def animate(i):
'''print(i) #$$$$$To check if animation.FuncAnimation is calling this animate function multiple times or not$$$$$'''
(y, yt) = evw.evo_time(
) # The Getter, wave_evo(self) is a void method, instead the computation is done by the written method.
evw.wave_evo = y # Calls Setter
line.set_data(z, yt)
return line,
#----------------------------------------------------------------------------------------------
# CALL THE ANIMATOR. blit=true MEANS ONLY RE-DRAW THE PARTS THAT HAVE CHANGED.
anim = animation.FuncAnimation(fig, animate, init_func=init,\
frames=t, interval=30, blit=False)
#anim = anim.save('schrodinger_barrier.mp4', fps=20, extra_args=['-vcodec', 'libx264'])
plt.show()
#----------------------------------------------------------------------------------------------
sys.exit(
'TIMEOUT: MANIPULATE VARIABLES FOR DESIRED OUTCOME FOR THE NEXT ANIMATION')
mean1 = data[:,0].mean ()
mean2 = data[:,1].mean ()
std1 = data[:,0].std ()
std2 = data[:,1].std ()
params = np.array ( [(mean1 - 0.2, mean2 - 1, std1, std2, 0),
(mean1 + 0.2, mean2 + 1, std1, std2, 0)] )
weights = np.array ( [ 0.5, 0.5 ] )
#EM (data, params, weights)
res_EM = EM_2( data, params, weights )
#print(res_EM)
bounds = find_video_bounds ( data, res_EM )
# création de l'animation : tout d'abord on crée la figure qui sera animée
fig = plt.figure ()
ax = fig.gca (xlim=(bounds[0], bounds[1]), ylim=(bounds[2], bounds[3]))
# exécution de l'animation
anim = animation.FuncAnimation(fig, animate, frames = len ( res_EM ), interval=500 )
plt.show ()
'''
f= open('data.pkl','wb')
pkl.dump(data,f) # penser à sauver les données pour éviter de refaire les opérations
f.close()
'''
import matplotlib.animation as animation
import data_local as dataDevice
PADDING = 5
myData = dataDevice.device()
dispdata = []
timeplot = 0
fig, ax = plt.subplots()
line, = ax.plot(dispdata)
def update(data):
global dispdata, timeplot
timeplot += 1
dispdata.append(data)
ax.set_xlim(0, timeplot)
ymin = min(dispdata) - PADDING
ymax = max(dispdata) + PADDING
ax.set_ylim(ymin, ymax)
line.set_data(range(timeplot), dispdata)
return line
def data_gen():
while True:
yield myData.getNew()[1] / 1000
ani = animation.FuncAnimation(fig, update, data_gen, interval=1000)
plt.show()
#End
def update(num, data, line):
line.set_data(data[:2, :num])
line.set_3d_properties(data[2, :num])
#ROBERTO CARLOS FREE KICK
fig, cx = plt.subplots()
cx = plt.axes(projection='3d')
line, = cx.plot3D(x, y, z, '-r', label='soccer ball')
ani = animation.FuncAnimation(fig,
update,
N,
fargs=(data, line),
interval=10000 / N,
blit=False)
#SAVE ANIMATION
#Set up formatting for the movie files
#Writer = animation.writers['ffmpeg']
#writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)
#ani.save('Roberto_carlos.mp4', writer=writer)
#GOAL PLACEMENT
goal_z_p = np.linspace(2.44, 2.44, 50)
goal_x_p = np.linspace(Rf[0], Rf[0], 50)
goal_y_p = np.linspace(Rf[1], -Rf[1], 50)
cx.plot3D(goal_x_p, goal_y_p, goal_z_p, '-b', label='goal')
def spectral_anim_xr(
da,
interval=15,
time_template = 'Gate Delay = %.1fns'
):
xs = da.coords['wavelength'].values
ts = da.coords['time'].values
# First set up the figure, the axis, and the plot element we want to animate
fig, ax = plt.subplots()
lines = da.isel(time=0).plot(ax=ax)
line = lines[0]
time_text = ax.text(
0.05,
0.9,
'',
transform=ax.transAxes
)
ax.set_ylim(0,1.1*da.max().item())
ax.set_title('')
fig.tight_layout()
#
def init():
line.set_ydata([np.nan]*len(ts))
return line,
def animate(i):
"""
TODO: improve documentation
animation function. This is called sequentially
Parameters
----------
i : int
Returns
-------
"""
y = da.isel(time=i).values
# y = y / RawData_Frames.max().max()
line.set_data(
xs,
y
)
if time_template is not None:
time_text.set_text(time_template % ts[i])
else:
time_text.set_text(str(ts[i].astype('datetime64[ms]')))
return line, time_text
# call the animator.
# blit=True means only re-draw the parts that have changed.
anim = animation.FuncAnimation(
fig,
animate,
init_func=init,
frames=len(ts),
interval=interval,
blit=True
)
# # equivalent to rcParams['animation.html'] = 'html5'
# rc(
# 'animation',
# html='html5'
# )
return anim
m.colorbar(location='right')
m.drawcoastlines()
m.fillcontinents()
m.drawmapboundary()
m.drawparallels(W.lat[0:-1:5],labels=[1,0,0,0])
m.drawmeridians(W.lon[0:-1:5],labels=[0,0,0,1])
def update_quiver(t,plt,u,v) :
"""method required to animate quiver and contour plot
"""
plt.C=m.pcolormesh(x,y,W.wMag[t],shading='flat',cmap=plt.cm.jet)
plt.Q=m.quiver(x,y,W.u[t],W.v[t])
return plt
anim = animation.FuncAnimation(fig, update_quiver, frames=range(np.size(W.time)), fargs=(plt,W.u,W.v),
interval=50, blit=False)
plt.show()
#%%
# convert the lat/lon values to x/y projections.
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation
X, Y = np.mgrid[:2*np.pi:0.2,:2*np.pi:0.2]
U = np.cos(X)
V = np.sin(Y)
fig, ax = plt.subplots(1,1)
def show_data(indir,
plot_type,
print_flag,
save_flag,
data_only,
vOut=None,
pOut=None,
tOut=None):
pfx = 'mpet.'
sStr = "_"
ttl_fmt = "% = {perc:2.1f}"
# Read in the simulation results and calcuations data
dataFileName = "output_data.mat"
dataFile = os.path.join(indir, dataFileName)
data = sio.loadmat(dataFile)
try:
data[pfx + 'current'][0][0]
except KeyError:
pfx = ''
try:
data[pfx + "partTrodecvol0part0" + sStr + "cbar"]
except KeyError:
sStr = "."
# Read in the parameters used to define the simulation
dD_s, ndD_s = IO.read_dicts(os.path.join(indir, "input_dict_system"))
# simulated (porous) electrodes
Nvol = ndD_s["Nvol"]
trodes = ndD_s["trodes"]
dD_e = {}
ndD_e = {}
for trode in trodes:
dD_e[trode], ndD_e[trode] = IO.read_dicts(
os.path.join(indir, "input_dict_{t}".format(t=trode)))
# Pick out some useful constants/calculated values
k = dD_s['k'] # Boltzmann constant, J/(K Li)
Tref = dD_s['Tref'] # Temp, K
e = dD_s['e'] # Charge of proton, C
F = dD_s['F'] # C/mol
td = dD_s["td"]
Etheta = {"a": 0.}
for trode in trodes:
Etheta[trode] = -(k * Tref / e) * ndD_s["phiRef"][trode]
# Etheta[trode] = -(k*Tref/e) * ndD_e[trode]["muR_ref"]
Vstd = Etheta["c"] - Etheta["a"]
Nvol = ndD_s["Nvol"]
Npart = ndD_s["Npart"]
psd_len = dD_s["psd_len"]
# Discretization (and associated porosity)
Lfac = 1e6
Lunit = r"$\mu$m"
dxc = ndD_s["L"]["c"] / Nvol["c"]
dxvec = np.array(Nvol["c"] * [dxc])
porosvec = np.array(Nvol["c"] * [ndD_s["poros"]["c"]])
cellsvec = dxc * np.arange(Nvol["c"]) + dxc / 2.
if Nvol["s"]:
dxs = ndD_s["L"]["s"] / Nvol["s"]
dxvec_s = np.array(Nvol["s"] * [dxs])
dxvec = np.hstack((dxvec_s, dxvec))
poros_s = np.array(Nvol["s"] * [ndD_s["poros"]["s"]])
porosvec = np.hstack((poros_s, porosvec))
cellsvec += dD_s["L"]["s"] / dD_s["L"]["c"]
cellsvec_s = dxs * np.arange(Nvol["s"]) + dxs / 2.
cellsvec = np.hstack((cellsvec_s, cellsvec))
if "a" in trodes:
dxa = ndD_s["L"]["a"] / Nvol["a"]
dxvec_a = np.array(Nvol["a"] * [dxa])
dxvec = np.hstack((dxvec_a, dxvec))
poros_a = np.array(Nvol["a"] * [ndD_s["poros"]["a"]])
porosvec = np.hstack((poros_a, porosvec))
cellsvec += dD_s["L"]["a"] / dD_s["L"]["c"]
cellsvec_a = dxa * np.arange(Nvol["a"]) + dxa / 2.
cellsvec = np.hstack((cellsvec_a, cellsvec))
cellsvec *= dD_s["Lref"] * Lfac
facesvec = np.insert(np.cumsum(dxvec), 0, 0.) * dD_s["Lref"] * Lfac
# Extract the reported simulation times
times = data[pfx + 'phi_applied_times'][0]
numtimes = len(times)
tmin = np.min(times)
tmax = np.max(times)
# Simulation type
profileType = ndD_s['profileType']
# Colors for plotting concentrations
to_yellow = 0.3
to_red = 0.7
scl = 1.0 # static
# scl = 1.2 # movies
figsize = (scl * 6, scl * 4)
# Print relevant simulation info
if print_flag:
print("profileType:", profileType)
# for i in trodes:
# print "PSD_{l}:".format(l=l)
# print psd_len[l].transpose()
# print "Actual psd_mean [nm]:", np.mean(psd_len[l])
# print "Actual psd_stddev [nm]:", np.std(psd_len[l])
print("Cell structure:")
print(("porous anode | " if Nvol["a"] else "flat anode | ") +
("sep | " if Nvol["s"] else "") + "porous cathode")
if Nvol["a"]:
print("capacity ratio cathode:anode, 'z':", ndD_s["z"])
for trode in trodes:
print("solidType_{t}:".format(t=trode), ndD_e[trode]['type'])
print("solidShape_{t}".format(t=trode), ndD_e[trode]['shape'])
print("rxnType_{t}:".format(t=trode), ndD_e[trode]['rxnType'])
if profileType == "CC":
print("C_rate:", dD_s['Crate'])
print("current:", dD_s['currset'], "A/m^2")
else: # CV
print("Vset:", dD_s['Vset'])
print("Specified psd_mean, c [{unit}]:".format(unit=Lunit),
np.array(dD_s['psd_mean']["c"]) * Lfac)
print("Specified psd_stddev, c [{unit}]:".format(unit=Lunit),
np.array(dD_s['psd_stddev']["c"]) * Lfac)
# print "reg sln params:"
# print ndD["Omga"]
print("ndim B_c:", ndD_e["c"]["B"])
if Nvol["s"]:
print("Nvol_s:", Nvol["s"])
print("Nvol_c:", Nvol["c"])
if Nvol["a"]:
print("Nvol_a:", Nvol["a"])
print("Npart_c:", Npart["c"])
if Nvol["a"]:
print("Npart_a:", Npart["a"])
print("Dp [m^2/s]:", dD_s['Dp'])
print("Dm [m^2/s]:", dD_s['Dm'])
print("Damb [m^2/s]:", dD_s['Damb'])
print("td [s]:", dD_s["td"])
for trode in trodes:
print("k0_{t} [A/m^2]:".format(t=trode), dD_e[trode]['k0'])
rxnType = ndD_e[trode]['rxnType']
if rxnType == "BV":
print("alpha_" + trode + ":", ndD_e[trode]['alpha'])
elif rxnType in ["Marcus", "MHC"]:
print("lambda_" + trode + "/(kTref):", ndD_e[trode]["lambda"])
if ndD_s['simBulkCond'][trode]:
print(trode + " bulk conductivity loss: Yes -- " +
"sigma_s [S/m]: " + str(dD_s['sigma_s'][trode]))
else:
print(trode + " bulk conductivity loss: No")
try:
simSurfCond = ndD_e[trode]['simSurfCond']
if simSurfCond:
print(trode + " surface conductivity loss: Yes -- " +
"dim_scond [S]: " + str(dD_e[trode]['scond']))
else:
print(trode + " surface conductivity loss: No")
except:
pass
# if ndD['simSurfCond'][l]:
# print (l + " surface conductivity loss: Yes -- " +
# "dim_scond [S]: " + str(dD['scond'][l]))
# else:
# print l + " surface conductivity loss: No"
if plot_type in ["params"]:
return ndD_s, dD_s, ndD_e, dD_e
if plot_type in ["discData"]:
return cellsvec / Lfac, facesvec / Lfac
# Plot voltage profile
if plot_type in ["v", "vt"]:
voltage = (Vstd - (k * Tref / e) * data[pfx + 'phi_applied'][0])
ffvec = data[pfx + 'ffrac_c'][0]
fig, ax = plt.subplots(figsize=figsize)
if plot_type == "v":
if data_only:
plt.close(fig)
return ffvec, voltage
ax.plot(ffvec, voltage)
xmin = 0.
xmax = 1.
ax.set_xlim((xmin, xmax))
ax.set_xlabel("Cathode Filling Fraction [dimensionless]")
elif plot_type == "vt":
if data_only:
plt.close(fig)
return times * td, voltage
ax.plot(times * td, voltage)
ax.set_xlabel("Time [s]")
ax.set_ylabel("Voltage [V]")
if save_flag:
fig.savefig("mpet_v.pdf", bbox_inches="tight")
return fig, ax
# Plot surface conc.
if plot_type[:-2] in ["surf"]:
trode = plot_type[-1]
str_base = (
pfx +
"partTrode{trode}vol{{vInd}}part{{pInd}}".format(trode=trode) +
sStr + "c")
if data_only:
sol_str = str_base.format(pInd=pOut, vInd=vOut)
datay = data[sol_str][:, -1]
return times * td, datay
fig, ax = plt.subplots(Npart[trode],
Nvol[trode],
squeeze=False,
sharey=True,
figsize=figsize)
ylim = (0, 1.01)
datax = times
for pInd in range(Npart[trode]):
for vInd in range(Nvol[trode]):
sol_str = str_base.format(pInd=pInd, vInd=vInd)
# Remove axis ticks
ax[pInd, vInd].xaxis.set_major_locator(plt.NullLocator())
datay = data[sol_str][:, -1]
line, = ax[pInd, vInd].plot(times, datay)
return fig, ax
# Plot SoC profile
if plot_type[:-2] in ["soc"]:
trode = plot_type[-1]
ffvec = data[pfx + 'ffrac_{trode}'.format(trode=trode)][0]
if data_only:
return times * td, ffvec
fig, ax = plt.subplots(figsize=figsize)
print(ffvec[-1])
ax.plot(times * td, ffvec)
xmin = np.min(ffvec)
xmax = np.max(ffvec)
ax.set_ylim((0, 1.05))
ax.set_xlabel("Time [s]")
ax.set_ylabel("Filling Fraciton [dimless]")
if save_flag:
fig.savefig("mpet_soc.pdf", bbox_inches="tight")
return fig, ax
# Check to make sure mass is conserved in elyte
if plot_type == "elytecons":
fig, ax = plt.subplots(figsize=figsize)
eps = 1e-2
ymin = 1 - eps
ymax = 1 + eps
# ax.set_ylim((ymin, ymax))
ax.set_ylabel('Avg. Concentration of electrolyte [nondim]')
sep = pfx + 'c_lyte_s'
anode = pfx + 'c_lyte_a'
cath = pfx + 'c_lyte_c'
ax.set_xlabel('Time [s]')
cvec = data[cath]
if Nvol["s"]:
cvec_s = data[sep]
cvec = np.hstack((cvec_s, cvec))
if "a" in trodes:
cvec_a = data[anode]
cvec = np.hstack((cvec_a, cvec))
cavg = np.sum(porosvec * dxvec * cvec, axis=1) / np.sum(
porosvec * dxvec)
if data_only:
plt.close(fig)
return times * td, cavg
np.set_printoptions(precision=8)
print(cavg)
ax.plot(times * td, cavg)
return fig, ax
# Plot current profile
if plot_type == "curr":
current = data[pfx + "current"][0] * 3600 / td
ffvec = data[pfx + 'ffrac_c'][0]
if data_only:
return times * td, current
fig, ax = plt.subplots(figsize=figsize)
ax.plot(times * td, current)
xmin = np.min(ffvec)
xmax = np.max(ffvec)
ax.set_xlabel("Time [s]")
ax.set_ylabel("Current [C-rate]")
if save_flag:
fig.savefig("mpet_current.png", bbox_inches="tight")
return fig, ax
# Plot electrolyte concentration or potential
elif plot_type in [
"elytec", "elytep", "elytecf", "elytepf", "elytei", "elyteif",
"elytedivi", "elytedivif"
]:
fplot = (True if plot_type[-1] == "f" else False)
t0ind = (0 if not fplot else -1)
mpl.animation.Animation._blit_draw = _blit_draw
datax = cellsvec
c_sep, p_sep = pfx + 'c_lyte_s', pfx + 'phi_lyte_s'
c_anode, p_anode = pfx + 'c_lyte_a', pfx + 'phi_lyte_a'
c_cath, p_cath = pfx + 'c_lyte_c', pfx + 'phi_lyte_c'
datay_c = data[c_cath]
datay_p = data[p_cath]
L_c = dD_s['L']["c"] * Lfac
Ltot = L_c
if Nvol["s"]:
datay_s_c = data[c_sep]
datay_s_p = data[p_sep]
datay_c = np.hstack((datay_s_c, datay_c))
datay_p = np.hstack((datay_s_p, datay_p))
L_s = dD_s['L']["s"] * Lfac
Ltot += L_s
else:
L_s = 0
if "a" in trodes:
datay_a_c = data[c_anode]
datay_a_p = data[p_anode]
datay_c = np.hstack((datay_a_c, datay_c))
datay_p = np.hstack((datay_a_p, datay_p))
L_a = dD_s['L']["a"] * Lfac
Ltot += L_a
else:
L_a = 0
xmin = 0
xmax = Ltot
if plot_type in ["elytec", "elytecf"]:
ymin = 0
ymax = 2.2
ylbl = 'Concentration of electrolyte [M]'
datay = datay_c * dD_s["cref"] / 1000.
elif plot_type in ["elytep", "elytepf"]:
ymin = -50
ymax = 50
ylbl = 'Potential of electrolyte [V]'
datay = datay_p * (k * Tref / e) - Vstd
elif plot_type in ["elytei", "elyteif", "elytedivi", "elytedivif"]:
cGP_L, pGP_L = data["c_lyteGP_L"], data["phi_lyteGP_L"]
cmat = np.hstack((cGP_L.T, datay_c, datay_c[:, -1].reshape(
(numtimes, 1))))
pmat = np.hstack((pGP_L.T, datay_p, datay_p[:, -1].reshape(
(numtimes, 1))))
disc = geom.get_elyte_disc(Nvol, ndD_s["L"], ndD_s["poros"],
ndD_s["BruggExp"])
i_edges = np.zeros((numtimes, len(facesvec)))
for tInd in range(numtimes):
i_edges[tInd, :] = mod_cell.get_lyte_internal_fluxes(
cmat[tInd, :], pmat[tInd, :], disc["dxd1"],
disc["eps_o_tau_edges"], ndD_s)[1]
if plot_type in ["elytei", "elyteif"]:
ylbl = r'Current density of electrolyte [A/m$^2$]'
datax = facesvec
datay = i_edges * (F * dD_s["cref"] * dD_s["Dref"] /
dD_s["Lref"])
elif plot_type in ["elytedivi", "elytedivif"]:
ylbl = r'Divergence of electrolyte current density [A/m$^3$]'
datax = cellsvec
datay = np.diff(i_edges, axis=1) / disc["dxd2"]
datay *= (F * dD_s["cref"] * dD_s["Dref"] / dD_s["Lref"]**2)
if fplot:
datay = datay[t0ind]
if data_only:
return datax, datay, L_a, L_s
dataMin, dataMax = np.min(datay), np.max(datay)
dataRange = dataMax - dataMin
ymin = max(0, dataMin - 0.05 * dataRange)
ymax = dataMax + 0.05 * dataRange
fig, ax = plt.subplots(figsize=figsize)
ax.set_xlabel('Battery Position [{unit}]'.format(unit=Lunit))
ax.set_ylabel(ylbl)
ttl = ax.text(0.5,
1.05,
ttl_fmt.format(perc=0),
transform=ax.transAxes,
verticalalignment="center",
horizontalalignment="center")
ax.set_ylim((ymin, ymax))
ax.set_xlim((xmin, xmax))
# returns tuble of line objects, thus comma
if fplot:
line1, = ax.plot(datax, datay, '-')
else:
line1, = ax.plot(datax, datay[t0ind, :], '-')
ax.axvline(x=L_a, linestyle='--', color='g')
ax.axvline(x=(L_a + L_s), linestyle='--', color='g')
if fplot:
print("time =", times[t0ind] * td, "s")
if save_flag:
fig.savefig("mpet_{pt}.png".format(pt=plot_type),
bbox_inches="tight")
return fig, ax
def init():
line1.set_ydata(np.ma.array(datax, mask=True))
ttl.set_text('')
return line1, ttl
def animate(tind):
line1.set_ydata(datay[tind])
t_current = times[tind]
tfrac = (t_current - tmin) / (tmax - tmin) * 100
ttl.set_text(ttl_fmt.format(perc=tfrac))
return line1, ttl
# Plot solid particle-average concentrations
elif plot_type[:-2] in ["cbarLine", "dcbardtLine"]:
trode = plot_type[-1]
fig, ax = plt.subplots(Npart[trode],
Nvol[trode],
squeeze=False,
sharey=True,
figsize=figsize)
partStr = "partTrode{trode}vol{{vInd}}part{{pInd}}".format(
trode=trode) + sStr
type2c = False
if ndD_e[trode]["type"] in ndD_s["1varTypes"]:
if plot_type[:-2] in ["cbarLine"]:
str_base = pfx + partStr + "cbar"
elif plot_type[:-2] in ["dcbardtLine"]:
str_base = pfx + partStr + "dcbardt"
elif ndD_e[trode]["type"] in ndD_s["2varTypes"]:
type2c = True
if plot_type[:-2] in ["cbarLine"]:
str1_base = pfx + partStr + "c1bar"
str2_base = pfx + partStr + "c2bar"
elif plot_type[:-2] in ["dcbardtLine"]:
str1_base = pfx + partStr + "dc1bardt"
str2_base = pfx + partStr + "dc2bardt"
ylim = (0, 1.01)
datax = times * td
if data_only:
plt.close(fig)
if type2c:
sol1_str = str1_base.format(pInd=pOut, vInd=vOut)
sol2_str = str2_base.format(pInd=pOut, vInd=vOut)
datay1 = data[sol1_str][0]
datay2 = data[sol2_str][0]
datay = (datay1, datay2)
else:
sol_str = str_base.format(pInd=pOut, vInd=vOut)
datay = data[sol_str][0]
return datax, datay
xLblNCutoff = 4
xLbl = "Time [s]"
yLbl = "Particle Average Filling Fraction"
for pInd in range(Npart[trode]):
for vInd in range(Nvol[trode]):
if type2c:
sol1_str = str1_base.format(pInd=pInd, vInd=vInd)
sol2_str = str2_base.format(pInd=pInd, vInd=vInd)
if Nvol[trode] > xLblNCutoff:
# Remove axis ticks
ax[pInd,
vInd].xaxis.set_major_locator(plt.NullLocator())
else:
ax[pInd, vInd].set_xlabel(xLbl)
ax[pInd, vInd].set_ylabel(yLbl)
datay1 = data[sol1_str][0]
datay2 = data[sol2_str][0]
line1, = ax[pInd, vInd].plot(times, datay1)
line2, = ax[pInd, vInd].plot(times, datay2)
else:
sol_str = str_base.format(pInd=pInd, vInd=vInd)
if Nvol[trode] > xLblNCutoff:
# Remove axis ticks
ax[pInd,
vInd].xaxis.set_major_locator(plt.NullLocator())
else:
ax[pInd, vInd].set_xlabel(xLbl)
ax[pInd, vInd].set_ylabel(yLbl)
datay = data[sol_str][0]
line, = ax[pInd, vInd].plot(times, datay)
return fig, ax
# Plot all solid concentrations or potentials
elif plot_type[:-2] in ["csld", "musld"]:
timettl = False # Plot the current simulation time as title
# Plot title in seconds
ttlscl, ttlunit = 1, "s"
# For example, to plot title in hours:
# ttlscl, ttlunit = 1./3600, "hr"
save_shot = False
if save_shot:
t0ind = 300
print("Time at screenshot: {ts} s".format(ts=times[t0ind] * td))
else:
t0ind = 0
trode = plot_type[-1]
if plot_type[0] == "c":
plt_cavg = True
else:
plt_cavg = False
plt_legend = True
plt_axlabels = True
if ndD_e[trode]["type"] in ndD_s["1varTypes"]:
type2c = False
elif ndD_e[trode]["type"] in ndD_s["2varTypes"]:
type2c = True
Nv, Np = Nvol[trode], Npart[trode]
partStr = "partTrode{trode}vol{vInd}part{pInd}" + sStr
fig, ax = plt.subplots(Np,
Nv,
squeeze=False,
sharey=True,
figsize=figsize)
if not type2c:
cstr_base = pfx + partStr + "c"
cbarstr_base = pfx + partStr + "cbar"
cstr = np.empty((Np, Nv), dtype=object)
cbarstr = np.empty((Np, Nv), dtype=object)
lines = np.empty((Np, Nv), dtype=object)
elif type2c:
c1str_base = pfx + partStr + "c1"
c2str_base = pfx + partStr + "c2"
c1barstr_base = pfx + partStr + "c1bar"
c2barstr_base = pfx + partStr + "c2bar"
c1str = np.empty((Np, Nv), dtype=object)
c2str = np.empty((Np, Nv), dtype=object)
c1barstr = np.empty((Np, Nv), dtype=object)
c2barstr = np.empty((Np, Nv), dtype=object)
lines1 = np.empty((Np, Nv), dtype=object)
lines2 = np.empty((Np, Nv), dtype=object)
lines3 = np.empty((Np, Nv), dtype=object)
lens = np.zeros((Np, Nv))
if data_only:
print("tInd_{}".format(tOut), "time =", times[tOut] * td, "s")
lenval = psd_len[trode][vOut, pOut]
if type2c:
c1str = c1str_base.format(trode=trode, pInd=pOut, vInd=vOut)
c2str = c2str_base.format(trode=trode, pInd=pOut, vInd=vOut)
c1barstr = c1barstr_base.format(trode=trode,
pInd=pOut,
vInd=vOut)
c2barstr = c2barstr_base.format(trode=trode,
pInd=pOut,
vInd=vOut)
datay1 = data[c1str[pOut, vOut]][tOut]
datay2 = data[c2str[pOut, vOut]][tOut]
if plot_type[:-2] in ["musld"]:
c1bar = data[c1barstr[pOut, vOut]][0][tOut]
c2bar = data[c2barstr[pOut, vOut]][0][tOut]
muRfunc = props_am.muRfuncs(
ndD_s["T"], ndD_e[trode]["indvPart"][vOut,
pOut]).muRfunc
datay1, datay2 = muRfunc((datay1, datay2), (c1bar, c2bar),
ndD_e[trode]["muR_ref"])[0]
datay = (datay1, datay2)
numy = len(datay1)
else:
cstr = cstr_base.format(trode=trode, pInd=pOut, vInd=vOut)
cbarstr = cbarstr_base.format(trode=trode,
pInd=pOut,
vInd=vOut)
datay = data[cstr][tOut]
if plot_type[:-2] in ["musld"]:
cbar = data[cbarstr[pOut, vOut]][0][tOut]
muRfunc = props_am.muRfuncs(
ndD_s["T"], ndD_e[trode]["indvPart"][vOut,
pOut]).muRfunc
datay = muRfunc(datay, cbar, ndD_e[trode]["muR_ref"])[0]
numy = len(datay)
datax = np.linspace(0, lenval * Lfac, numy)
plt.close(fig)
return datax, datay
if plot_type[:-2] in ["csld"]:
ylim = (0, 1.01)
elif plot_type[:-2] in ["musld"]:
ylim = (-4, 4)
for pInd in range(Np):
for vInd in range(Nv):
lens[pInd, vInd] = psd_len[trode][vInd, pInd]
if type2c:
c1str[pInd, vInd] = c1str_base.format(trode=trode,
pInd=pInd,
vInd=vInd)
c2str[pInd, vInd] = c2str_base.format(trode=trode,
pInd=pInd,
vInd=vInd)
c1barstr[pInd, vInd] = c1barstr_base.format(trode=trode,
pInd=pInd,
vInd=vInd)
c2barstr[pInd, vInd] = c2barstr_base.format(trode=trode,
pInd=pInd,
vInd=vInd)
datay1 = data[c1str[pInd, vInd]][t0ind]
datay2 = data[c2str[pInd, vInd]][t0ind]
datay3 = 0.5 * (datay1 + datay2)
lbl1, lbl2 = r"$\widetilde{c}_1$", r"$\widetilde{c}_2$"
lbl3 = r"$\overline{c}$"
if plot_type[:-2] in ["musld"]:
lbl1, lbl2 = r"$\mu_1/k_\mathrm{B}T$", r"$\mu_2/k_\mathrm{B}T$"
c1bar = data[c1barstr[pInd, vInd]][0][t0ind]
c2bar = data[c2barstr[pInd, vInd]][0][t0ind]
muRfunc = props_am.muRfuncs(
ndD_s["T"], ndD_e[trode]["indvPart"][vInd,
pInd]).muRfunc
datay1, datay2 = muRfunc((datay1, datay2),
(c1bar, c2bar),
ndD_e[trode]["muR_ref"])[0]
numy = len(datay1)
datax = np.linspace(0, lens[pInd, vInd] * Lfac, numy)
line1, = ax[pInd, vInd].plot(datax, datay1, label=lbl1)
line2, = ax[pInd, vInd].plot(datax, datay2, label=lbl2)
if plt_cavg:
line3, = ax[pInd, vInd].plot(datax,
datay3,
'--',
label=lbl3)
lines3[pInd, vInd] = line3
lines1[pInd, vInd] = line1
lines2[pInd, vInd] = line2
else:
cstr[pInd, vInd] = cstr_base.format(trode=trode,
pInd=pInd,
vInd=vInd)
cbarstr[pInd, vInd] = cbarstr_base.format(trode=trode,
pInd=pInd,
vInd=vInd)
datay = data[cstr[pInd, vInd]][t0ind]
if plot_type[:-2] in ["musld"]:
cbar = np.array(data[cbarstr[pInd, vInd]][0][t0ind])
muRfunc = props_am.muRfuncs(
ndD_s["T"], ndD_e[trode]["indvPart"][vInd,
pInd]).muRfunc
datay = muRfunc(datay, cbar,
ndD_e[trode]["muR_ref"])[0]
numy = len(datay)
datax = np.linspace(0, lens[pInd, vInd] * Lfac, numy)
line, = ax[pInd, vInd].plot(datax, datay)
lines[pInd, vInd] = line
ax[pInd, vInd].set_ylim(ylim)
ax[pInd, vInd].set_xlim((0, lens[pInd, vInd] * Lfac))
if plt_legend:
ax[pInd, vInd].legend(loc="best")
if plt_axlabels:
ax[pInd,
vInd].set_xlabel(r"$r$ [{Lunit}]".format(Lunit=Lunit))
if plot_type[0] == "c":
ax[pInd, vInd].set_ylabel(r"$\widetilde{{c}}$")
elif plot_type[:2] == "mu":
ax[pInd, vInd].set_ylabel(r"$\mu/k_\mathrm{B}T$")
if timettl:
mpl.animation.Animation._blit_draw = _blit_draw
ttl = ax[pInd,
vInd].text(0.5,
1.04,
"t = {tval:3.3f} {ttlu}".format(
tval=times[t0ind] * td * ttlscl,
ttlu=ttlunit),
verticalalignment="center",
horizontalalignment="center",
transform=ax[pInd, vInd].transAxes)
if save_shot:
fig.savefig("mpet_{pt}.pdf".format(pt=plot_type),
bbox_inches="tight")
def init():
toblit = []
for pInd in range(Npart[trode]):
for vInd in range(Nvol[trode]):
if type2c:
numy = len(data[c1str[pInd, vInd]][t0ind])
maskTmp = np.zeros(numy)
lines1[pInd,
vInd].set_ydata(np.ma.array(maskTmp, mask=True))
lines2[pInd,
vInd].set_ydata(np.ma.array(maskTmp, mask=True))
lines_local = np.vstack((lines1, lines2))
if plt_cavg:
lines3[pInd, vInd].set_ydata(
np.ma.array(maskTmp, mask=True))
lines_local = np.vstack((lines_local, lines3))
else:
numy = len(data[cstr[pInd, vInd]][t0ind])
maskTmp = np.zeros(numy)
lines[pInd,
vInd].set_ydata(np.ma.array(maskTmp, mask=True))
lines_local = lines.copy()
toblit.extend(lines_local.reshape(-1))
if timettl:
ttl.set_text("")
toblit.extend([ttl])
return tuple(toblit)
def animate(tind):
toblit = []
for pInd in range(Npart[trode]):
for vInd in range(Nvol[trode]):
if type2c:
datay1 = data[c1str[pInd, vInd]][tind]
datay2 = data[c2str[pInd, vInd]][tind]
datay3 = 0.5 * (datay1 + datay2)
if plot_type[:-2] in ["musld"]:
c1bar = data[c1barstr[pInd, vInd]][0][tind]
c2bar = data[c2barstr[pInd, vInd]][0][tind]
muRfunc = props_am.muRfuncs(
ndD_s["T"],
ndD_e[trode]["indvPart"][vInd, pInd]).muRfunc
datay1, datay2 = muRfunc(
(datay1, datay2), (c1bar, c2bar),
ndD_e[trode]["muR_ref"])[0]
lines1[pInd, vInd].set_ydata(datay1)
lines2[pInd, vInd].set_ydata(datay2)
lines_local = np.vstack((lines1, lines2))
if plt_cavg:
lines3[pInd, vInd].set_ydata(datay3)
lines_local = np.vstack((lines_local, lines3))
else:
datay = data[cstr[pInd, vInd]][tind]
if plot_type[:-2] in ["musld"]:
cbar = data[cbarstr[pInd, vInd]][0][tind]
muRfunc = props_am.muRfuncs(
ndD_s["T"],
ndD_e[trode]["indvPart"][vInd, pInd]).muRfunc
datay = muRfunc(datay, cbar,
ndD_e[trode]["muR_ref"])[0]
lines[pInd, vInd].set_ydata(datay)
lines_local = lines.copy()
toblit.extend(lines_local.reshape(-1))
if timettl:
ttl.set_text("t = {tval:3.3f} {ttlu}".format(
tval=times[tind] * td * ttlscl, ttlu=ttlunit))
toblit.extend([ttl])
return tuple(toblit)
# Plot average solid concentrations
elif plot_type in ["cbar_c", "cbar_a", "cbar_full"]:
if plot_type[-4:] == "full":
trvec = ["a", "c"]
elif plot_type[-1] == "a":
trvec = ["a"]
else:
trvec = ["c"]
dataCbar = {}
for trode in trodes:
dataCbar[trode] = np.zeros((numtimes, Nvol[trode], Npart[trode]))
for tInd in range(numtimes):
for vInd in range(Nvol[trode]):
for pInd in range(Npart[trode]):
dataStr = (pfx +
"partTrode{t}vol{vInd}part{pInd}".format(
t=trode, vInd=vInd, pInd=pInd) + sStr +
"cbar")
dataCbar[trode][tInd, vInd,
pInd] = (data[dataStr][0][tInd])
if data_only:
return dataCbar
# Set up colors.
# Define if you want smooth or discrete color changes
# Option: "smooth" or "discrete"
color_changes = "discrete"
# color_changes = "smooth"
# Discrete color changes:
if color_changes == "discrete":
# Make a discrete colormap that goes from green to yellow
# to red instantaneously
cdict = {
"red": [(0.0, 0.0, 0.0), (to_yellow, 0.0, 1.0),
(1.0, 1.0, 1.0)],
"green": [(0.0, 0.502, 0.502), (to_yellow, 0.502, 1.0),
(to_red, 1.0, 0.0), (1.0, 0.0, 0.0)],
"blue": [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)]
}
cmap = mpl.colors.LinearSegmentedColormap("discrete", cdict)
# Smooth colormap changes:
if color_changes == "smooth":
# generated with colormap.org
cmaps = np.load("colormaps_custom.npz")
cmap_data = cmaps["GnYlRd_3"]
cmap = mpl.colors.ListedColormap(cmap_data / 255.)
# Implement hack to be able to animate title
mpl.animation.Animation._blit_draw = _blit_draw
size_frac_min = 0.10
fig, axs = plt.subplots(1, len(trvec), squeeze=False, figsize=figsize)
ttlx = 0.5 if len(trvec) < 2 else 1.1
ttl = axs[0, 0].text(ttlx,
1.05,
ttl_fmt.format(perc=0),
transform=axs[0, 0].transAxes,
verticalalignment="center",
horizontalalignment="center")
collection = np.empty(len(trvec), dtype=object)
for indx, trode in enumerate(trvec):
ax = axs[0, indx]
# Get particle sizes (and max size) (length-based)
lens = psd_len[trode]
len_max = np.max(lens)
len_min = np.min(lens)
ax.patch.set_facecolor('white')
# Don't stretch axes to fit figure -- keep 1:1 x:y ratio.
ax.set_aspect('equal', 'box')
# Don't show axis ticks
ax.xaxis.set_major_locator(plt.NullLocator())
ax.yaxis.set_major_locator(plt.NullLocator())
ax.set_xlim(0, 1.)
ax.set_ylim(0, float(Npart[trode]) / Nvol[trode])
# Label parts of the figure
# ylft = ax.text(-0.07, 0.5, "Separator",
# transform=ax.transAxes, rotation=90,
# verticalalignment="center",
# horizontalalignment="center")
# yrht = ax.text(1.09, 0.5, "Current Collector",
# transform=ax.transAxes, rotation=90,
# verticalalignment="center",
# horizontalalignment="center")
# xbtm = ax.text(.50, -0.05, "Electrode Depth -->",
# transform=ax.transAxes, rotation=0,
# verticalalignment="center",
# horizontalalignment="center")
# Geometric parameters for placing the rectangles on the axes
spacing = 1.0 / Nvol[trode]
size_fracs = 0.4 * np.ones((Nvol[trode], Npart[trode]))
if len_max != len_min:
size_fracs = (lens - len_min) / (len_max - len_min)
sizes = (size_fracs *
(1 - size_frac_min) + size_frac_min) / Nvol[trode]
# Create rectangle "patches" to add to figure axes.
rects = np.empty((Nvol[trode], Npart[trode]), dtype=object)
color = 'green' # value is irrelevant -- it will be animated
for (vInd, pInd), c in np.ndenumerate(sizes):
size = sizes[vInd, pInd]
center = np.array(
[spacing * (vInd + 0.5), spacing * (pInd + 0.5)])
bottom_left = center - size / 2
rects[vInd, pInd] = plt.Rectangle(bottom_left,
size,
size,
color=color)
# Create a group of rectange "patches" from the rects array
collection[indx] = mcollect.PatchCollection(rects.reshape(-1))
# Put them on the axes
ax.add_collection(collection[indx])
# Have a "background" image of rectanges representing the
# initial state of the system.
def init():
for indx, trode in enumerate(trvec):
cbar_mat = dataCbar[trode][0, :, :]
colors = cmap(cbar_mat.reshape(-1))
collection[indx].set_color(colors)
ttl.set_text('')
out = [collection[i] for i in range(len(collection))]
out.append(ttl)
out = tuple(out)
return out
def animate(tind):
for indx, trode in enumerate(trvec):
cbar_mat = dataCbar[trode][tind, :, :]
colors = cmap(cbar_mat.reshape(-1))
collection[indx].set_color(colors)
t_current = times[tind]
tfrac = (t_current - tmin) / (tmax - tmin) * 100
ttl.set_text(ttl_fmt.format(perc=tfrac))
out = [collection[i] for i in range(len(collection))]
out.append(ttl)
out = tuple(out)
return out
# Plot cathode potential
elif plot_type[0:5] in ["bulkp"]:
trode = plot_type[-1]
fplot = (True if plot_type[-3] == "f" else False)
t0ind = (0 if not fplot else -1)
mpl.animation.Animation._blit_draw = _blit_draw
fig, ax = plt.subplots(figsize=figsize)
ax.set_xlabel('Position in electrode [{unit}]'.format(unit=Lunit))
ax.set_ylabel('Potential of cathode [nondim]')
ttl = ax.text(0.5,
1.05,
ttl_fmt.format(perc=0),
transform=ax.transAxes,
verticalalignment="center",
horizontalalignment="center")
bulkp = pfx + 'phi_bulk_{trode}'.format(trode=trode)
datay = data[bulkp]
ymin = np.min(datay) - 0.2
ymax = np.max(datay) + 0.2
if trode == "a":
datax = cellsvec[:Nvol["a"]]
elif trode == "c":
datax = cellsvec[-Nvol["c"]:]
if data_only:
plt.close(fig)
return datax, datay[t0ind]
# returns tuble of line objects, thus comma
line1, = ax.plot(datax, datay[t0ind])
def init():
line1.set_ydata(np.ma.array(datax, mask=True))
ttl.set_text('')
return line1, ttl
def animate(tind):
line1.set_ydata(datay[tind])
t_current = times[tind]
tfrac = (t_current - tmin) / (tmax - tmin) * 100
ttl.set_text(ttl_fmt.format(perc=tfrac))
return line1, ttl
else:
raise Exception("Unexpected plot type argument. See README.md.")
ani = manim.FuncAnimation(fig,
animate,
frames=numtimes,
interval=50,
blit=True,
repeat=False,
init_func=init)
if save_flag:
fig.tight_layout()
ani.save("mpet_{type}.mp4".format(type=plot_type),
fps=25,
bitrate=5500)
return fig, ax, ani
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
fig, ax = plt.subplots()
sin_l, = ax.plot(np.sin(0))
cos_l, = ax.plot(np.cos(0))
ax.set_ylim(-1, 1)
ax.set_xlim(0, 5)
dx = 0.1
def update(i):
# i is a counter for each frame.
# We'll increment x by dx each frame.
x = np.arange(0, i) * dx
sin_l.set_data(x, np.sin(x))
cos_l.set_data(x, np.cos(x))
return sin_l, cos_l
ani = animation.FuncAnimation(fig, update, frames=51, interval=50)
plt.show()
def show(self):
plt.plot([], [], 'r-')
self.ani = animation.FuncAnimation(self.figure,
self.evolve,
interval=self.animationInterval)
plt.show()
newpop.append(n1)
newpop.append(n2)
population = newpop
def update(t):
fig.clear()
ax1 = fig.add_subplot(2, 1, 1)
ax1.plot(averageFitness)
ax1.set_title('g = ' + str(t))
ax1.plot(bestFitness)
ax1.set_xlabel("generaiton")
ax1.set_ylabel("average / best fitness")
ax2 = fig.add_subplot(2, 1, 2)
ax2.plot(sx, sy)
ax2.plot(pp, pf, ".")
ax2.set_xlabel("x")
ax2.set_ylabel("fitness")
fig.tight_layout()
ani = animation.FuncAnimation(fig,
main_loop,
np.arange(0, T),
interval=25,
repeat=False)
plt.show()
i2 = -1
xPBH1 = np.vstack([xPBH1, x[i1, :]])
zp = xPBH1[:, (2, )].T
#timetext.set_text("t = %0.3f kyr"%(time))
pTrack.set_xdata(xPBH1[:, (0, )])
pTrack.set_ydata(xPBH1[:, (1, )])
#print xPBH1[:, (2,)]
pTrack.set_3d_properties(zs=zp)
#pPBH1.set_offsets(x[i1,:])
#a,b,c = p2._offsets3d
pPBH1._offsets3d = (x[i1, (0, )], x[i1, (1, )], x[i1, (2, )])
#pPBH2.set_offsets(x[i2,:])
pPBH2._offsets3d = (x[i2, (0, )], x[i2, (1, )], x[i2, (2, )])
#p2.set_offsets(x2[:,:])
dinds = np.abs(x2[:, 2]) < zh
p2._offsets3d = (x2[dinds, 0], x2[dinds, 1], x2[dinds, 2])
#circle1.center = (x[:,0], x[:,1])
return pPBH1, pPBH2, p2, pTrack, tittext
anim = animation.FuncAnimation(fig, animate, frames=Nframes)
anim.save('../movies/2D_binary_' + runID + '.mp4',
fps=70,
bitrate=-1,
codec='libx264',
extra_args=['-pix_fmt', 'yuv420p'],
dpi=300)
def main():
######################################
### Parameter
######################################
mod_param = model_param.Model_params("CALTECH256", "VGG16_CAM5b_S",
'rmsProp', 1e-4, 5e-5, 5e-7)
model = Forward_model(mod_param, 44)
labels = model.mod_param.labels
PEPPER_IP = "10.0.165.29" # jmot.local
PEPPER_IP = "10.0.161.43" # jarc.local
LOCAL_IP = "10.0.164.160"
LOCAL_PORT = 8081
LOCAL_SERVER = "http://" + LOCAL_IP + ":8081/"
LOCAL_SERVER_FOLDER = '/home/cuda/work/cm_perso/py/image_server/'
######################################
### Load video stream of pepper
######################################
vStream = VideoStream(PEPPER_IP)
img = vStream.getFrame()
# Load naoqi tablet service to display image
from naoqi import ALProxy
tabletService = ALProxy("ALTabletService", PEPPER_IP, 9559)
tts = ALProxy("ALTextToSpeech", PEPPER_IP, 9559)
led = ALProxy("ALLeds", PEPPER_IP, 9559)
######################################
### To visualize on pepper,
### launch an HTTP server in :
### /home/cuda/work/cm_perso/py/image_server
### $ python2 -m SimpleHTTPServer 8081
######################################
# build the bar's colors
import colorsys
N = len(model.labels)
HSV_tuples = [(x * 1.0 / N, .8 if x % 2 else 1, .8 if x % 2 else 1)
for x in range(N)]
RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
colors = RGB_tuples
######################################
### Plotting time !!
######################################
img, named_preds, vis = get_img_pred_and_vis(do_resize=False)
summed_viz = summed_vis(model, vis)
lbl_idx = []
lbl_idx.append(labels.index("head-phones"))
lbl_idx.append(labels.index("people"))
lbl_idx.append(labels.index("soda-can"))
lbl_idx.append(labels.index("cereal-box"))
lbl_idx.append(labels.index("coffee-mug"))
lbl_idx.append(labels.index("eyeglasses"))
lbl_idx.append(labels.index("computer-keyboard"))
thresholds = {
'airplanes-101': 15.539495,
'ak47': 11.614439,
'american-flag': 10.979799,
'backpack': 12.223079,
'baseball-bat': 9.5437927,
'baseball-glove': 13.739741,
'basketball-hoop': 6.8361239,
'bat': 9.3481636,
'bathtub': 11.226589,
'bear': 12.300051,
'beer-mug': 10.193258,
'billiards': 13.462406,
'binoculars': 14.34924,
'birdbath': 8.5118666,
'blimp': 10.230799,
'bonsai-101': 14.111417,
'boom-box': 9.4953127,
'bowling-ball': 12.180779,
'bowling-pin': 13.188916,
'boxing-glove': 12.254652,
'brain-101': 10.274245,
'breadmaker': 12.863352,
'buddha-101': 9.4291439,
'bulldozer': 12.71928,
'butterfly': 12.233453,
'cactus': 11.847659,
'cake': 9.6894112,
'calculator': 11.544846,
'camel': 10.984636,
'cannon': 11.45732,
'canoe': 8.5938473,
'car-side-101': 15.239647,
'car-tire': 10.235177,
'cartman': 13.4251,
'cd': 14.570348,
'centipede': 11.146159,
'cereal-box': 9.5662346,
'chandelier-101': 14.05705,
'chess-board': 14.479905,
'chimp': 11.409027,
'chopsticks': 9.7986164,
'clutter': 6.7525487,
'cockroach': 11.884217,
'coffee-mug': 9.8205605,
'coffin': 7.9233661,
'coin': 13.396132,
'comet': 13.854059,
'computer-keyboard': 9.3863621,
'computer-monitor': 12.101433,
'computer-mouse': 9.4048815,
'conch': 10.171927,
'cormorant': 13.560222,
'covered-wagon': 10.693968,
'cowboy-hat': 11.713959,
'crab-101': 7.8341355,
'desk-globe': 11.701681,
'diamond-ring': 14.189276,
'dice': 12.145127,
'dog': 10.916739,
'dolphin-101': 13.114321,
'doorknob': 5.0762424,
'drinking-straw': 11.298171099057921,
'duck': 8.0495834,
'dumb-bell': 10.45462,
'eiffel-tower': 12.312577,
'electric-guitar-101': 12.958621,
'elephant-101': 14.492549,
'elk': 13.485504,
'ewer-101': 9.8520899,
'eyeglasses': 12.613165,
'faces-easy-101': 14.780043,
'fern': 14.704705,
'fighter-jet': 8.7353821,
'fire-extinguisher': 9.8947344,
'fire-hydrant': 11.806909,
'fire-truck': 13.965515,
'fireworks': 13.296287,
'flashlight': 8.1808243,
'floppy-disk': 7.1887569,
'football-helmet': 10.615582,
'french-horn': 13.687181,
'fried-egg': 10.432892,
'frisbee': 11.636504,
'frog': 9.7874126,
'frying-pan': 13.031361,
'galaxy': 13.235175,
'gas-pump': 9.2886629,
'giraffe': 11.326241,
'goat': 11.352355,
'golden-gate-bridge': 10.316961,
'goldfish': 9.4651136,
'golf-ball': 13.796005,
'goose': 10.911978,
'gorilla': 14.111794,
'grand-piano-101': 12.888706,
'grapes': 15.015621,
'grasshopper': 11.786924,
'greyhound': 10.316483,
'guitar-pick': 13.68029,
'hamburger': 15.062843,
'hammock': 9.5732231,
'harmonica': 9.8693962,
'harp': 11.529077,
'harpsichord': 11.165341,
'hawksbill-101': 11.578585,
'head-phones': 13.229425,
'helicopter-101': 10.342123,
'hibiscus': 15.14535,
'homer-simpson': 12.982221,
'horse': 10.339157,
'horseshoe-crab': 8.7140741,
'hot-air-balloon': 11.959567,
'hot-dog': 7.6435122,
'hot-tub': 14.082646,
'hourglass': 8.5736504,
'house-fly': 10.245955,
'human-skeleton': 11.28433,
'hummingbird': 13.007446,
'ibis-101': 13.071635,
'ice-cream-cone': 8.9562511,
'iguana': 10.795525,
'ipod': 11.828806,
'iris': 13.975347,
'jesus-christ': 7.8586192,
'joy-stick': 10.704171,
'kangaroo-101': 10.39012,
'kayak': 10.973958,
'ketch-101': 14.624043,
'killer-whale': 10.278771,
'knife': 7.0219631,
'ladder': 10.223049,
'laptop-101': 14.154712,
'lathe': 10.909991,
'leopards-101': 13.462743,
'license-plate': 9.1783524,
'light-house': 13.667336,
'lightbulb': 9.0387936,
'lightning': 14.409019,
'llama-101': 13.470165,
'mailbox': 6.5361915,
'mandolin': 7.0408216,
'mars': 15.681169,
'mattress': 13.038775,
'megaphone': 9.5789099,
'menorah-101': 11.231406,
'microscope': 13.210646,
'microwave': 12.780502,
'minaret': 14.352889,
'minotaur': 8.7425909,
'motorbikes-101': 14.512385,
'mountain-bike': 11.489552,
'mushroom': 9.2215405,
'mussels': 9.5242481,
'necktie': 12.587179,
'octopus': 10.618414,
'ostrich': 13.737724,
'owl': 12.664935,
'palm-pilot': 10.367587,
'palm-tree': 13.79882,
'paper-shredder': 10.851973,
'paperclip': 7.6281219,
'pci-card': 13.879761,
'penguin': 12.622005,
'people': 10.127394,
'pez-dispenser': 10.151289,
'photocopier': 12.675723,
'picnic-table': 11.054971,
'playing-card': 8.0703611,
'porcupine': 14.769379,
'pram': 8.6249542,
'praying-mantis': 7.9761715,
'pyramid': 9.2024403,
'raccoon': 13.569774,
'radio-telescope': 9.3716202,
'rainbow': 14.275431,
'refrigerator': 10.21283,
'revolver-101': 9.7003441,
'rifle': 7.8262658,
'rotary-phone': 8.7905035,
'roulette-wheel': 13.088307,
'saddle': 12.905226,
'saturn': 13.530177,
'school-bus': 14.30421,
'scorpion-101': 11.310881,
'screwdriver': 8.5278797,
'segway': 9.8139648,
'self-propelled-lawn-mower': 13.614111,
'sextant': 10.938291,
'sheet-music': 12.781863,
'skateboard': 5.3709097,
'skunk': 12.385101,
'skyscraper': 10.209162,
'smokestack': 8.4563723,
'snail': 10.329622,
'snake': 11.788112,
'sneaker': 11.271756,
'snowmobile': 12.525217,
'soccer-ball': 13.321915,
'socks': 12.545236,
'soda-can': 5.3792729,
'spaghetti': 14.648598,
'speed-boat': 8.1863899,
'spider': 10.452264,
'spoon': 7.7456422,
'stained-glass': 12.208684,
'starfish-101': 9.5304241,
'steering-wheel': 10.538023,
'stirrups': 9.0607805,
'sunflower-101': 15.126546,
'superman': 10.417388,
'sushi': 10.138167,
'swan': 13.547839,
'swiss-army-knife': 12.918182,
'sword': 6.741322,
'syringe': 11.86831,
't-shirt': 12.696012,
'tambourine': 11.732224,
'teapot': 11.243834,
'teddy-bear': 13.073026,
'teepee': 13.556503,
'telephone-box': 12.293881,
'tennis-ball': 13.999656,
'tennis-court': 13.988853,
'tennis-racket': 11.597626,
'tennis-shoes': 12.119856,
'theodolite': 8.5096235,
'toad': 14.345215,
'toaster': 8.2721653,
'tomato': 13.720393,
'tombstone': 8.7411394,
'top-hat': 10.413415,
'touring-bike': 13.964041,
'tower-pisa': 14.130401,
'traffic-light': 9.1431026,
'treadmill': 11.544156,
'triceratops': 9.1150694,
'tricycle': 7.9400773,
'trilobite-101': 9.9814043,
'tripod': 12.860129,
'tuning-fork': 8.508173,
'tweezer': 12.786347,
'umbrella-101': 14.133526,
'unicorn': 8.989871,
'vcr': 13.953634,
'video-projector': 13.71447,
'washing-machine': 13.383274,
'watch-101': 14.873101,
'waterfall': 11.931628,
'watermelon': 13.523896,
'welding-mask': 9.4707451,
'wheelbarrow': 6.9907722,
'windmill': 8.115716,
'wine-bottle': 11.967635,
'xylophone': 10.102029,
'yarmulke': 10.422739,
'yo-yo': 8.1963339,
'zebra': 12.6486
}
thresholds = {
'airplanes-101': 5.5431083e+14,
'ak47': 3.0300088e+16,
'american-flag': 3.5716338e+16,
'backpack': 1.9385098e+12,
'baseball-bat': 1.5624532e+09,
'baseball-glove': 1.6674185e+13,
'basketball-hoop': 21648198.0,
'bat': 5.3302285e+08,
'bathtub': 4.081619e+13,
'bear': 5.1944895e+13,
'beer-mug': 1.2813283e+09,
'billiards': 1.8982378e+19,
'binoculars': 2.4670087e+11,
'birdbath': 86495976.0,
'blimp': 5.466241e+10,
'bonsai-101': 1.2646443e+14,
'boom-box': 3.2918062e+09,
'bowling-ball': 2.4476167e+11,
'bowling-pin': 3.577533e+16,
'boxing-glove': 6.7875977e+13,
'brain-101': 9.9880776e+09,
'breadmaker': 3.2294382e+12,
'buddha-101': 3.8930813e+10,
'bulldozer': 6.2439028e+16,
'butterfly': 1.0646077e+11,
'cactus': 8.1894794e+09,
'cake': 7.40256e+09,
'calculator': 3.5660982e+11,
'camel': 1.664745e+10,
'cannon': 6.9733033e+09,
'canoe': 50444132.0,
'car-side-101': 3.7557727e+10,
'car-tire': 3.0141978e+08,
'cartman': 6.5723494e+13,
'cd': 6.4437289e+10,
'centipede': 1.2770371e+12,
'cereal-box': 2.6240285e+08,
'chandelier-101': 8.2653332e+13,
'chess-board': 2.2851635e+14,
'chimp': 7.410362e+11,
'chopsticks': 2.4793016e+11,
'clutter': 8339.2676,
'cockroach': 5.4527033e+10,
'coffee-mug': 1.480877e+08,
'coffin': 5039319.5,
'coin': 1.3312232e+11,
'comet': 2.0706677e+10,
'computer-keyboard': 1.0867948e+09,
'computer-monitor': 7.1442136e+12,
'computer-mouse': 47223632.0,
'conch': 1.8807533e+08,
'cormorant': 3.2918025e+15,
'covered-wagon': 5.9376696e+12,
'cowboy-hat': 2.4143793e+09,
'crab-101': 4341659.0,
'desk-globe': 9.4681735e+10,
'diamond-ring': 1.9219957e+14,
'dice': 1.4127444e+10,
'dog': 4.6726865e+10,
'dolphin-101': 5.9940569e+11,
'doorknob': 13459.243,
'drinking-straw': 1.4986623698626245e+19,
'duck': 3049474.0,
'dumb-bell': 4.0482092e+11,
'eiffel-tower': 3.5857907e+19,
'electric-guitar-101': 4.0460525e+16,
'elephant-101': 1.2808333e+15,
'elk': 1.1112351e+13,
'ewer-101': 1.4056063e+11,
'eyeglasses': 1.9051025e+11,
'faces-easy-101': 2.2937489e+11,
'fern': 7.1044002e+12,
'fighter-jet': 7798978.0,
'fire-extinguisher': 1.719988e+10,
'fire-hydrant': 9.6152668e+14,
'fire-truck': 3.3854999e+14,
'fireworks': 6.6339655e+12,
'flashlight': 1.5764622e+08,
'floppy-disk': 139934.2,
'football-helmet': 6.6389512e+10,
'french-horn': 9.3023247e+15,
'fried-egg': 4.9036191e+09,
'frisbee': 1.0446183e+08,
'frog': 6.0765036e+09,
'frying-pan': 3.2934395e+16,
'galaxy': 1.2823036e+11,
'gas-pump': 4.143339e+09,
'giraffe': 3.8628279e+12,
'goat': 7.5328881e+11,
'golden-gate-bridge': 7.8824473e+10,
'goldfish': 1.0932602e+09,
'golf-ball': 1.3780492e+20,
'goose': 6.2447514e+12,
'gorilla': 2.1993976e+12,
'grand-piano-101': 2.8961075e+15,
'grapes': 1.5072703e+13,
'grasshopper': 1.8578018e+10,
'greyhound': 1.8462416e+13,
'guitar-pick': 5.1328466e+13,
'hamburger': 4.2002609e+14,
'hammock': 3.3486584e+09,
'harmonica': 9.5709587e+08,
'harp': 8.1178002e+13,
'harpsichord': 3.7312467e+10,
'hawksbill-101': 7.3944072e+10,
'head-phones': 3.4009946e+13,
'helicopter-101': 2.1896231e+10,
'hibiscus': 1.8412439e+12,
'homer-simpson': 1.5423778e+12,
'horse': 5.6068927e+10,
'horseshoe-crab': 4.2088189e+09,
'hot-air-balloon': 3.2325625e+13,
'hot-dog': 7944667.0,
'hot-tub': 8.2769019e+14,
'hourglass': 7.5616689e+11,
'house-fly': 3.1041532e+10,
'human-skeleton': 5.0458438e+08,
'hummingbird': 1.7925873e+15,
'ibis-101': 1.9916933e+17,
'ice-cream-cone': 63787136.0,
'iguana': 2.2303822e+10,
'ipod': 1.207799e+13,
'iris': 1.0276757e+13,
'jesus-christ': 14475644.0,
'joy-stick': 7.2560395e+12,
'kangaroo-101': 4.879786e+10,
'kayak': 1.1078073e+12,
'ketch-101': 3.8059018e+12,
'killer-whale': 2.6241966e+09,
'knife': 19238.672,
'ladder': 1.5208937e+09,
'laptop-101': 1.1846513e+16,
'lathe': 1.7692549e+12,
'leopards-101': 1.6646305e+09,
'license-plate': 1.1828102e+12,
'light-house': 3.6549751e+21,
'lightbulb': 19177000.0,
'lightning': 1.4482883e+12,
'llama-101': 6.7335113e+13,
'mailbox': 2773471.5,
'mandolin': 18860346.0,
'mars': 1.6402625e+11,
'mattress': 3.1016109e+15,
'megaphone': 4.2023346e+10,
'menorah-101': 3.3722458e+12,
'microscope': 4.1738928e+13,
'microwave': 8.5503303e+13,
'minaret': 3.1610025e+18,
'minotaur': 32122660.0,
'motorbikes-101': 2.8167275e+14,
'mountain-bike': 5.9001851e+09,
'mushroom': 53559256.0,
'mussels': 2.2473357e+08,
'necktie': 3.1209993e+11,
'octopus': 2.6431208e+08,
'ostrich': 1.7842261e+15,
'owl': 6.5421483e+13,
'palm-pilot': 2.3683363e+12,
'palm-tree': 7.7542704e+12,
'paper-shredder': 1.3108989e+08,
'paperclip': 1352188.0,
'pci-card': 1.9177542e+14,
'penguin': 3.0658302e+14,
'people': 5.2147927e+09,
'pez-dispenser': 6.3548403e+14,
'photocopier': 1.0440469e+13,
'picnic-table': 3.8073414e+10,
'playing-card': 5538763.0,
'porcupine': 6.9250853e+12,
'pram': 18372230.0,
'praying-mantis': 1.560399e+08,
'pyramid': 4.8814873e+11,
'raccoon': 1.655157e+17,
'radio-telescope': 2.3465157e+10,
'rainbow': 8.7877876e+14,
'refrigerator': 44751656.0,
'revolver-101': 1.8511545e+12,
'rifle': 9.0105306e+08,
'rotary-phone': 2.1230793e+09,
'roulette-wheel': 3.5503577e+12,
'saddle': 3.9173898e+11,
'saturn': 9.6435749e+10,
'school-bus': 2.8633875e+16,
'scorpion-101': 2.0427739e+10,
'screwdriver': 26136550.0,
'segway': 1.8123455e+14,
'self-propelled-lawn-mower': 2.1806294e+14,
'sextant': 8.092094e+09,
'sheet-music': 3.0781233e+10,
'skateboard': 14456.855,
'skunk': 1.5204825e+16,
'skyscraper': 42357828.0,
'smokestack': 3.6834967e+09,
'snail': 3.002801e+08,
'snake': 1.6795233e+10,
'sneaker': 2.9544725e+12,
'snowmobile': 1.7613053e+13,
'soccer-ball': 2.3668703e+15,
'socks': 1.2557998e+12,
'soda-can': 4422.9951,
'spaghetti': 9.0263502e+13,
'speed-boat': 6.3242834e+09,
'spider': 2.2383148e+09,
'spoon': 17250952.0,
'stained-glass': 4.3774906e+13,
'starfish-101': 4.5136595e+08,
'steering-wheel': 2.6580664e+09,
'stirrups': 5.438729e+08,
'sunflower-101': 2.0106238e+15,
'superman': 1.3998532e+12,
'sushi': 3.5312387e+09,
'swan': 1.5102679e+14,
'swiss-army-knife': 2.9733163e+13,
'sword': 97893.102,
'syringe': 2.4944873e+11,
't-shirt': 8.4770243e+09,
'tambourine': 1.0646093e+10,
'teapot': 1.3279314e+10,
'teddy-bear': 3.1996138e+12,
'teepee': 4.4722962e+16,
'telephone-box': 1.7343836e+13,
'tennis-ball': 1.129395e+13,
'tennis-court': 1.6999828e+15,
'tennis-racket': 4.39301e+13,
'tennis-shoes': 2.5194111e+10,
'theodolite': 47372728.0,
'toad': 8.3253107e+12,
'toaster': 10031872.0,
'tomato': 5.2412243e+12,
'tombstone': 15937872.0,
'top-hat': 4.3982733e+08,
'touring-bike': 2.7450732e+11,
'tower-pisa': 7.2208215e+13,
'traffic-light': 6.6413796e+11,
'treadmill': 7.972144e+12,
'triceratops': 1.0741414e+09,
'tricycle': 11951269.0,
'trilobite-101': 1.2566726e+09,
'tripod': 4.0014282e+16,
'tuning-fork': 356258.0,
'tweezer': 6.7144122e+11,
'umbrella-101': 4.9185605e+13,
'unicorn': 6.2804467e+08,
'vcr': 1.2763661e+14,
'video-projector': 3.2985965e+12,
'washing-machine': 2.8531178e+13,
'watch-101': 1.230518e+13,
'waterfall': 2.739926e+11,
'watermelon': 1.5243077e+11,
'welding-mask': 2.7199916e+10,
'wheelbarrow': 97438696.0,
'windmill': 8.450663e+08,
'wine-bottle': 6.4735841e+14,
'xylophone': 2.0981789e+10,
'yarmulke': 2.365763e+10,
'yo-yo': 2.1747139e+08,
'zebra': 4.6917522e+13
}
# for key in thresholds: thresholds[key] *= 1.5
# First plot
fig, axs = plt.subplots(2, (len(lbl_idx) + 1) / 2)
axs = [a for b in axs for a in b]
ims = []
ims.append(axs[0].imshow(img, animated=True))
for i in range(len(lbl_idx)):
ims.append(axs[i + 1].imshow(summed_viz[0, :, :, lbl_idx[i]],
vmin=0,
vmax=thresholds.values()[lbl_idx[i]]))
axs[i + 1].set_title(labels[lbl_idx[i]])
# update function
def updatefig(*args):
img, named_preds, vis = get_img_pred_and_vis(do_resize=False)
summed_viz = summed_vis(model, vis)
# Update the axis
ims[0].set_array(img)
for i in range(len(lbl_idx)):
data = np.exp(summed_viz[0, :, :, lbl_idx[i]])
ims[i + 1].set_array(data)
# print_vis_stat(summed_viz, lbl_idx)
# print_sorted_preds(named_preds)
print_over_threshold(summed_viz, thresholds, named_preds)
return ims
ani1 = animation.FuncAnimation(fig, updatefig, interval=10, blit=False)
fig.show()
h = predict(theta, X)
print(np.sum(h==y) / len(y) * 100)
theta = history[0][0]
plot_x = np.array([min(X[:, 1]) - 2, max(X[:, 1]) + 2])
def cal_y(theta):
plot_y = -1 / theta[2] * (theta[1]*plot_x + theta[0])
return plot_y
line, = ax.plot(plot_x, cal_y(theta))
def animate(history):
def _wrapper(i):
theta, error = history[i]
h = predict(theta, X)
acc = np.sum(h==y) / len(y)
line.set_ydata(cal_y(theta))
sys.stdout.flush()
sys.stdout.write('{:5d} / {:5d}, {:5.2%} | {:6.3f}, {:6.2%}\r'.format(
i, len(history), i / len(history), error, acc))
return line
return _wrapper
anim = animation.FuncAnimation(fig, animate(history), np.arange(len(history)),
interval=10)
plt.show()
#---------------------------------------------------------------------------------------------------
# Again this is only ploting information
#---------------------------------------------------------------------------------------------------
# Trajectory of the vector in s-space
ax.plot(s[:,0],s[:,1],s[:,2], color = 'red')
# Initial frame
plot = [ax.quiver( 0, 0, 0, s[0,0], s[0,1], s[0,2], linewidth = 3.0, color = "orange"),
ax.quiver( 0, 0, 0, 0, 0, s[0,2], linewidth = 3.0, color = "green")]
# Animation
animate = animation.FuncAnimation(fig, update_plot, nmax, fargs=(v, plot))
#---------------------------------------------------------------------------------------------------
# Saving. You can change the name of the file.
# To generate a gif we need to install imagemagick. Then use the following line
animate.save('OBE.gif',writer='imagemagick')
# If we don't want to download imagemagick then we can just generate a mp4 file
#animate.save('OBE.mp4', writer = None)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
spaceresolution = 100
timeresolution = 60
fig, ax = plt.subplots()
x = np.linspace(0,1,spaceresolution)
line, = ax.plot(x, x*(1-x))
def draw(u):
line.set_ydata(x*u*(1-x))
return line,
plt.xlim(0, 1)
plt.ylim(0, 1)
plt.plot(x,x)
ani = animation.FuncAnimation(fig, draw, np.linspace(1,4,timeresolution), interval=10)
plt.show()
def draw_it(self, **args):
# user input functions to add
self.g1 = args['g1'] # input function
self.g2 = args['g2']
# input function
num_frames = 100
if 'num_frames' in args:
num_frames = args['num_frames']
min_range = -3
if 'min_range' in args:
min_range = args['min_range']
max_range = -3
if 'max_range' in args:
max_range = args['max_range']
if 'title1' in args:
title1 = args['title1']
else:
title1 = '$g_1$'
if 'title2' in args:
title2 = args['title2']
else:
title2 = '$g_2$'
if 'title3' in args:
title3 = args['title3']
else:
title3 = '$\\alpha\,g_1 + (1 - \\alpha)\,g_2$'
# initialize figure
fig = plt.figure(figsize=(15, 5))
artist = fig
ax1 = fig.add_subplot(131)
ax2 = fig.add_subplot(132)
ax3 = fig.add_subplot(133)
# generate base function for plotting on each slide
w_plot = np.linspace(min_range, max_range, 200)
g1_plot = self.g1(w_plot)
g2_plot = self.g2(w_plot)
# set vertical limit markers
g1_min = np.amin(g1_plot)
g2_min = np.amin(g2_plot)
g1_max = np.amax(g1_plot)
g2_max = np.amax(g2_plot)
g1_gap = 0.2 * (g1_max - g1_min)
g2_gap = 0.2 * (g2_max - g2_min)
g1_min = np.amin(g1_plot) - g1_gap
g2_min = np.amin(g2_plot) - g2_gap
g1_max = np.amax(g1_plot) + g1_gap
g2_max = np.amax(g2_plot) + g2_gap
# decide on number of slides
alpha_vals = np.linspace(1, 0, num_frames)
print('starting animation rendering...')
# animation sub-function
def animate(k):
# clear panels for next slide
ax1.cla()
ax2.cla()
ax3.cla()
# print rendering update
if np.mod(k + 1, 25) == 0:
print('rendering animation frame ' + str(k + 1) + ' of ' +
str(num_frames))
if k == num_frames - 1:
print('animation rendering complete!')
time.sleep(1.5)
clear_output()
# plot function 1
ax1.plot(w_plot, g1_plot, color='k', zorder=1)
ax1.set_title(title1, fontsize=15)
# plot function 2
ax2.plot(w_plot, g2_plot, color='k', zorder=1)
ax2.set_title(title2, fontsize=15)
# plot combination of both
alpha = alpha_vals[k]
g_combo = alpha * g1_plot + (1 - alpha) * g2_plot
ax3.plot(w_plot, g_combo, color='k', zorder=1)
ax3.set_title(title3, fontsize=15)
# set vertical limits
ax1.set_ylim([g1_min, g1_max])
ax2.set_ylim([g2_min, g2_max])
# set vertical limit markers
gmin = np.amin(g_combo)
gmax = np.amax(g_combo)
g_gap = 0.2 * (gmax - gmin)
gmin = gmin - g_gap
gmax = gmax + g_gap
ax3.set_ylim([gmin, gmax])
return artist,
anim = animation.FuncAnimation(fig,
animate,
frames=num_frames,
interval=num_frames,
blit=True)
return (anim)
# Fifty lines of random 3-D lines
data = [nd]
# Creating fifty line objects.
# NOTE: Can't pass empty arrays into 3d version of plot()
lines = [ax.plot(dat[0, 0:1], dat[1, 0:1], dat[2, 0:1])[0] for dat in data]
# Setting the axes properties
ax.set_xlim3d([0, 2])
ax.set_xlabel('t')
ax.set_ylim3d([-0.001, 0.001])
ax.set_ylabel('X')
ax.set_zlim3d([-0.001, 0.001])
ax.set_zlabel('Y')
ax.set_title('3D Test')
# Creating the Animation object
line_ani = animation.FuncAnimation(fig,
update_lines,
int(nd.shape[1] / 100),
fargs=(data, lines, ax),
interval=1,
blit=False)
plt.show()
pass
min_amp = int(math.floor(amp_data.min()))
max_amp = int(math.floor(amp_data.max()))
ax2.hist(amp_data, bins=range(min_amp, max_amp + 1, 1), facecolor='blue', alpha=1,
edgecolor='black', linewidth=.5)
ax2.set_xlabel('Amplitude/db', weight='bold', fontsize=12)
ax2.set_ylabel('Count', weight='bold', fontsize=12)
print(time.time() - start)
except Exception as e:
print(repr(e))
if __name__ == '__main__':
"""
Assumptions
Data is dumped at least after 5 seconds after inception
"""
data_plotter = FogDataPlotter()
# data_plotter.loaddata()
fig, ((axx1, axx2), (axx3, axx4)) = plt.subplots(2, 2)
fig.suptitle(' Fog View', fontsize=18, weight='bold')
fig.text(.485, .5, '.', fontsize='200', color='g')
fig.patch.set_facecolor((0.96, 0.968, 0.851))
simulation = animation.FuncAnimation(fig, data_plotter.update_data, repeat=False, fargs=(axx1, axx2, axx3, axx4))
# plt.tight_layout()
# plt.show()
right_side = np.dot(B_mat, s_t)
s_tnext = np.linalg.solve(A_mat, right_side)
s_t = s_tnext
Z = np.array([[0. for i in range(Q + 1)] for j in range(N_half)])
for i in range(N_half):
for j in range(Q):
if j == 0:
Z[i][j] = s_t[i * Q + j]
Z[i][Q] = s_t[i * Q + j]
else:
Z[i][j] = s_t[i * Q + j]
cont = plt.pcolormesh(X, Y, Z, cmap='plasma', vmin=temp_min, vmax=temp_max)
plt.title(r'$t$ = %i$\Delta t$' % (k))
plt.suptitle(r'Temperature $U/U_{0}$')
return cont
anim = animation.FuncAnimation(fig, animate, frames=20, blit=False)
# Un-commenting the following line will save the animation as a mp4 file.
#anim.save('ring_bc3.mp4', fps=15)
# Un-commenting the following line will show the animation of the solution being
# solved in real time.
plt.show()
