def plot_wlp(self, **kwargs):
"""
Plot weighted log prior
"""
if self.lp_func is None:
return
plt.plot(np.asarray(self.record.lp) * self.wlp, **kwargs)
def test_screenstate_1(self):
from gdesk import gui
from pylab import plt
from pathlib import Path
gui.load_layout('console')
samplePath = Path(r'./samples')
gui.img.select(1)
gui.img.open(samplePath / 'kodim05.png')
gui.img.zoom_fit()
plt.plot(gui.vs.mean(2).mean(1))
plt.title('Column means of image 1')
plt.xlabel('Column Number')
plt.ylabel('Mean')
plt.grid()
plt.show()
gui.img.select(2)
gui.img.open(samplePath / 'kodim23.png')
gui.img.zoom_full()
plt.figure()
plt.plot(gui.vs.mean(2).mean(0))
plt.title('Row means of image 2')
plt.xlabel('Row Number')
plt.ylabel('Mean')
plt.grid()
plt.show()
def plot2(self,
figNum,
time1,
data1,
time2,
data2,
title='',
units='',
options=''):
plt.figure(figNum)
# plt.hold(True);
plt.grid(True)
if title:
self.title = title
if not units:
self.units = units
# plt.cla()
if self.preTitle:
fig = plt.gcf()
fig.canvas.set_window_title("Figure %d - %s" %
(figNum, self.preTitle))
plt.title("%s" % (self.title))
plt.plot(time1, data1, options)
plt.plot(time2, data2, options)
plt.ylabel('(%s)' % (self.units))
plt.xlabel('Time (s)')
plt.margins(0.04)
def print_statistics(a1, a2, a1_type, a2_type):
''' Prints selected statistics.
Parameters
==========
a1, a2: ndarray objects
results objects from simulation
'''
sta1 = scs.describe(a1)
sta2 = scs.describe(a2)
print('%14s %14s %14s' % ('statistic', 'data set 1', 'data set 2'))
print(45 * "-")
print('%14s %14.0f %14.0f' % ('size', sta1[0], sta2[0]))
print('%14s %14.3f %14.3f' % ('min', sta1[1][0], sta2[1][0]))
print('%14s %14.3f %14.3f' % ('max', sta1[1][1], sta2[1][1]))
print('%14s %14.3f %14.3f' % ('mean', sta1[2], sta2[2]))
print('%14s %14.3f %14.3f' % ('std', np.sqrt(sta1[3]), np.sqrt(sta2[3])))
print('%14s %14.3f %14.3f' % ('skew', sta1[4], sta2[4]))
print('%14s %14.3f %14.3f' % ('kurtosis', sta1[5], sta2[5]))
a1_sort = np.sort(a1)
a2_sort = np.sort(a2)
plt.scatter(x=a1_sort, y=a2_sort, marker='.', color='darkred')
plt.plot(a1_sort, a1_sort, linestyle='dashed', color='darkblue', alpha=0.4)
plt.xlabel(a1_type)
plt.ylabel(a2_type)
def subplotSingle2x(self,
figNum,
plotNum,
numRows,
numCols,
time,
data,
title='',
units='',
options=''):
print("subplotSingle2x")
plt.figure(figNum)
if title:
self.title = title
if not units:
self.units = units
if self.preTitle:
fig = plt.gcf()
fig.canvas.set_window_title("%s" % (figNum, self.preTitle))
if not figNum in self.sharex.keys():
self.sharex[figNum] = plt.subplot(numRows, numCols, plotNum)
plt.plot(time, data, options)
plt.subplot(numRows, numCols, plotNum, sharex=self.sharex[figNum])
# plt.hold(True);
plt.grid(True)
plt.title("%s" % (self.title))
plt.plot(time, data, options)
plt.ylabel('(%s)' % (self.units))
plt.margins(0.04)
def plot_precision_recall(precisions, recalls, thresholds):
"""
Plots precision and recall by thresholds.
Requires imports:
from sklearn.metrics import precision_recall_curve, cross_val_predict
Returns:
Nothing
"""
from pylab import mpl, plt
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'arial'
np.random.seed(1000)
np.set_printoptions(suppress=True, precision=4)
plt.plot(thresholds, precisions[:-1], 'b--', label='Precision')
plt.plot(thresholds, recalls[:-1], 'g-', label='Recall')
plt.xlabel('Threshold')
plt.legend(loc='center left')
plt.ylim([0, 1])
def plot_roc_curve(fpr, tpr, label=None):
"""
Plots Rceiver Operating Characteristic (ROC) curve from false_positive_rate(fpr), true_positive_rate(tpr)
Requires imports:
from sklearn.metrics import roc_curve
Returns:
Nothing
"""
from pylab import mpl, plt
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'arial'
np.random.seed(1000)
np.set_printoptions(suppress=True, precision=4)
plt.plot(fpr, tpr, linewidth=2, label=label)
plt.plot([0, 1], [0, 1], 'k--')
plt.axis([0, 1, 0, 1])
plt.xlabel('False Positive Rate')
plt.ylabel('True Negatove Rate')
plot_roc_curve(fpr, tpr)
def initWidgets(self):
self.fig = plt.figure(1)
self.manager=get_current_fig_manager()
self.img = subplot(2,1,1)
self.TempGraph=subplot(2,1,2)
x1=sp.linspace(0.0,5.0)
y1=sp.cos(2*sp.pi*x1)*sp.exp(-x1)
plt.plot(x1,y1)
row=0
self.grid()
self.lblPower=tk.Label(self,text="Power")
self.lblPower.grid(row=row,column=0)
self.sclPower=tk.Scale(self,from_=0,to_=100000,orient=tk.HORIZONTAL)
self.sclPower.grid(row=row,column=1,columnspan=3)
#lastrow
row=row+1
self.btnOne=tk.Button(master=self,text="Run")
self.btnOne["command"]=self.Run
self.btnOne.grid(row=row,column=0)
self.btnTwo=tk.Button(master=self,text="Soak")
self.btnTwo["command"]=self.Soak
self.btnTwo.grid(row=row,column=2)
self.QUIT=tk.Button(master=self,text="QUIT")
self.QUIT["command"]=self.quit
self.QUIT.grid(row=row,column=3)
def lagger():
global cols, scores
lag_counts = range(1, lags + 1)
cols = []
scores = []
for lag in range(1, lags + 1):
col = 'lag_{}'.format(lag)
data[col] = np.sign(data['returns'].shift(lag))
cols.append(col)
data.dropna(inplace=True)
print('Iteration number: {}'.format(lag))
%time model.fit(data[cols], np.sign(data['returns']))
model.predict(data[cols])
data['prediction'] = model.predict(data[cols])
data['prediction'].value_counts()
score = accuracy_score(data['prediction'], np.sign(data['returns']))
scores.append(score)
plt.figure()
plt.plot(lag_counts, scores, lw=2)
plt.xlabel('# of Lags')
plt.ylabel('Test Score')
return scores, cols
def geometric_brownian_motion_option_pricing(
initial_val=100,
num_samples=10000,
riskless_rate=0.05,
volatility_sigma=0.25,
time_year=2.0,
num_time_interval_discretization=50):
dt = time_year / num_time_interval_discretization
samples = np.zeros((num_time_interval_discretization + 1, num_samples))
samples[0] = initial_val
for t in range(1, num_time_interval_discretization + 1):
samples[t] = samples[t - 1] * np.exp(
(riskless_rate - 0.5 * (volatility_sigma**2)) * dt +
volatility_sigma * np.sqrt(dt) * npr.standard_normal(num_samples))
print(45 * "=")
print(samples[1])
plt.figure(figsize=(10, 6))
plt.hist(samples[50], bins=50)
plt.title("Geometric Brownian Motion")
plt.xlabel('index level')
plt.ylabel('frequency')
plt.show()
plt.figure(figsize=(10, 6))
plt.plot(samples[:, :10], lw=1.5)
plt.xlabel('time')
plt.ylabel('index level')
plt.title('Sample Path')
plt.show()
return samples
def test_run(self):
plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
# 生成市场环境
me_gbm = MarketEnvironment('me_gbm', dt.datetime(2020, 1, 1))
me_gbm.add_constant('initial_value', 36.0)
me_gbm.add_constant('volatility', 0.2)
me_gbm.add_constant('final_date', dt.datetime(2020, 12, 31))
me_gbm.add_constant('currency', 'EUR')
me_gbm.add_constant('frequency', 'M')
me_gbm.add_constant('paths', 1000)
csr = ConstantShortRate('csr', 0.06)
me_gbm.add_curve('discount_curve', csr)
# 生成几何布朗运动模拟类
gbm = GeometricBrownianMotion('gbm', me_gbm)
gbm.generate_time_grid()
print('时间节点：{0};'.format(gbm.time_grid))
paths_1 = gbm.get_instrument_values()
print('paths_1: {0};'.format(paths_1.round(3)))
gbm.update(volatility=0.5)
paths_2 = gbm.get_instrument_values()
# 可视化结果
plt.figure(figsize=(10, 6))
p1 = plt.plot(gbm.time_grid, paths_1[:, :10], 'b')
p2 = plt.plot(gbm.time_grid, paths_2[:, :10], 'r-')
legend1 = plt.legend([p1[0], p2[0]],
['low volatility', 'high volatility'],
loc=2)
plt.gca().add_artist(legend1)
plt.xticks(rotation=30)
plt.show()
def square_root_diffusion_exact(initial_val=0.05,
kappa=3.0,
theta=0.02,
sigma=0.1,
time_year=2,
num_samples=10000,
num_time_interval_discretization=50):
x = np.zeros((num_time_interval_discretization + 1, num_samples))
x[0] = initial_val
dt = time_year / num_time_interval_discretization
for t in range(1, num_time_interval_discretization + 1):
df = 4 * theta * kappa / sigma**2
c = (sigma**2 * (1 - np.exp(-kappa * dt))) / (4 * kappa)
nc = np.exp(-kappa * dt) / c * x[t - 1]
x[t] = c * npr.noncentral_chisquare(df, nc, size=num_samples)
plt.figure(figsize=(10, 6))
plt.hist(x[-1], bins=50)
plt.title("Square root diffusion Exact")
plt.xlabel('value')
plt.ylabel('frequency')
plt.show()
plt.figure(figsize=(10, 6))
plt.plot(x[:, :10], lw=1.5)
plt.xlabel('time')
plt.ylabel('index level')
plt.title('Sample Path SRD Exact')
plt.show()
return x
def square_root_diffusion_euler(initial_val=0.05,
kappa=3.0,
theta=0.02,
sigma=0.1,
time_year=2,
num_samples=10000,
num_time_interval_discretization=50):
dt = time_year / num_time_interval_discretization
xh = np.zeros((num_time_interval_discretization + 1, num_samples))
x = np.zeros_like(xh)
xh[0] = initial_val
x[0] = initial_val
for t in range(1, num_time_interval_discretization + 1):
xh[t] = (xh[t - 1] + kappa * (theta - np.maximum(xh[t - 1], 0)) * dt +
sigma * np.sqrt(np.maximum(xh[t - 1], 0)) * math.sqrt(dt) *
npr.standard_normal(num_samples))
x = np.maximum(xh, 0)
plt.figure(figsize=(10, 6))
plt.hist(x[-1], bins=50)
plt.xlabel('value')
plt.ylabel('frequency')
plt.title('Square root diffusion Approx Euler')
plt.show()
plt.figure(figsize=(10, 6))
plt.plot(x[:, :10], lw=1.5)
plt.xlabel('time')
plt.ylabel('index level')
plt.title('Sample Path SRD approx')
plt.show()
return x
def plot_fit(self, size=None, tol=0.1, axis_on=True):
n, d = self.D.shape
if size:
nrows, ncols = size
else:
sq = np.ceil(np.sqrt(n))
nrows = int(sq)
ncols = int(sq)
ymin = np.nanmin(self.D)
ymax = np.nanmax(self.D)
print 'ymin: {0}, ymax: {1}'.format(ymin, ymax)
numplots = np.min([n, nrows * ncols])
plt.figure()
for n in xrange(numplots):
plt.subplot(nrows, ncols, n + 1)
plt.ylim((ymin - tol, ymax + tol))
plt.plot(self.L[n, :] + self.S[n, :], 'r')
plt.plot(self.L[n, :], 'b')
if not axis_on:
plt.axis('off')
def plot_wlp(self,**kwargs):
"""
Plot weighted log prior
"""
if self.lp_func is None:
return
plt.plot(np.asarray(self.record.lp)*self.wlp,**kwargs)
def create_image(csv_path):
csv_data, _, _ = read_csv_data(csv_path)
plt.figure()
plt.plot(csv_data)
plt.axis('off')
plt.savefig('wind_data.png', bbox_inches='tight', dpi=500)
def plot_spectral_points(self, spectra, fmt='r+', labels=None, lpos=None):
'''
Plots spectral profiles in feature space.
'''
m, n, c = self.__dims__
assert type(spectra) in (
list, tuple,
np.ndarray), 'Expected spectra to be a list, tuple, or numpy array'
if labels is not None and lpos is None:
lpos = [(30, -30)] * len(labels)
for i, spec in enumerate(spectra):
plt.plot(spec[m], spec[n], fmt, ms=20, mew=2)
if labels is not None:
xy = (spec[m], spec[n])
plt.annotate(labels[i],
xy=xy,
xytext=lpos[i],
textcoords='offset points',
ha='right',
va='bottom',
fontsize=14,
arrowprops=dict(arrowstyle='->',
connectionstyle='arc3,rad=0'))
def draw(cls, t_max, agents_proportions, eco_idx, parameters):
color_set = ["green", "blue", "red"]
for agent_type in range(3):
plt.plot(np.arange(t_max), agents_proportions[:, agent_type],
color=color_set[agent_type], linewidth=2.0, label="Type-{} agents".format(agent_type))
plt.ylim([-0.1, 1.1])
plt.xlabel("$t$")
plt.ylabel("Proportion of indirect exchanges")
# plt.suptitle('Direct choices proportion per type of agents', fontsize=14, fontweight='bold')
plt.legend(loc='upper right', fontsize=12)
print(parameters)
plt.title(
"Workforce: {}, {}, {}; displacement area: {}; vision area: {}; alpha: {}; tau: {}\n"
.format(
parameters["x0"],
parameters["x1"],
parameters["x2"],
parameters["movement_area"],
parameters["vision_area"],
parameters["alpha"],
parameters["tau"]
), fontsize=12)
if not path.exists("../../figures"):
mkdir("../../figures")
plt.savefig("../../figures/figure_{}.pdf".format(eco_idx))
plt.show()
def run_evo_plot(self):
""" Awesome! All agents become chips!"""
t_max = 100
culture_length = 5
env = Environment(culture_length=culture_length,
t_max=t_max,
n_agent=1000,
influence_type='linear')
all_possible_cultures = list(
product([False, True], repeat=culture_length))
all_time_cul = np.zeros((t_max, len(all_possible_cultures)))
#TODO: try to understand why
#all_time_cul = np.zeros((t_max, len(all_possible_cultures)))
# do not work
print(len(all_possible_cultures))
print(2**culture_length)
# env.plot()
for t in tqdm(range(t_max)):
env.one_step()
for agent in env.agents:
all_time_cul[
t, all_possible_cultures.index(tuple(agent.culture))] += 1
plt.figure()
plt.plot(all_time_cul)
def serve_css(name, length, keys, values):
from pylab import plt, mpl
mpl.rcParams['font.sans-serif'] = ['SimHei']
mpl.rcParams['axes.unicode_minus'] = False
from matplotlib.font_manager import FontProperties
# font = FontProperties(fname="d:\Users\ll.tong\Desktop\msyh.ttf", size=12)
font = FontProperties(fname="/usr/share/fonts/msyh.ttf", size=11)
plt.xlabel(u'')
plt.ylabel(u'出现次数',fontproperties=font)
plt.title(u'词频统计',fontproperties=font)
plt.grid()
keys = keys.decode("utf-8").split(' ')
values = values.split(' ')
valuesInt = []
for value in values:
valuesInt.append(int(value))
plt.xticks(range(int(length)), keys)
plt.plot(range(int(length)), valuesInt)
plt.xticks(rotation=defaultrotation, fontsize=9,fontproperties=font)
plt.yticks(fontsize=10,fontproperties=font)
name = name + str(datetime.now().date()).replace(':', '') + '.png'
imgUrl = 'static/temp/' + name
fig = matplotlib.pyplot.gcf()
fig.set_size_inches(12.2, 2)
plt.savefig(imgUrl, bbox_inches='tight', figsize=(20,4), dpi=100)
plt.close()
tempfile = static_file(name, root='./static/temp/')
#os.remove(imgUrl)
return tempfile
def MakePlot(x, y, styles, labels, axlabels):
plt.figure(figsize=(10, 6))
for i in range(len(x)):
plt.plot(x[i], y[i], styles[i], label=labels[i])
plt.xlabel(axlabels[0])
plt.ylabel(axlabels[1])
plt.legend(loc=0)
def plot(fn, marker, label):
result_file = fn
fid = vj.inv.ResultFileReader(result_file)
epochs = fid.epochs
rms = fid.rms_inland_at_epoch
plt.plot(epochs, rms, 'o-', label=label)
def plot_slip(slip, nx, ny,
label='x-',
legend = None
):
epochs = slip.get_epochs()
s = slip.get_cumu_slip_at_subfault(nx, ny)
plt.plot(epochs, s, label, label=legend)
def plot_stat(rows, cache):
"Use matplotlib to plot DAS statistics"
if not PLOT_ALLOWED:
raise Exception('Matplotlib is not available on the system')
if cache in ['cache', 'merge']: # cachein, cacheout, mergein, mergeout
name_in = '%sin' % cache
name_out = '%sout' % cache
else: # webip, webq, cliip, cliq
name_in = '%sip' % cache
name_out = '%sq' % cache
def format_date(date):
"Format given date"
val = str(date)
return '%s-%s-%s' % (val[:4], val[4:6], val[6:8])
date_range = [r['date'] for r in rows]
formated_dates = [format_date(str(r['date'])) for r in rows]
req_in = [r[name_in] for r in rows]
req_out = [r[name_out] for r in rows]
plt.plot(date_range, req_in , 'ro-',\
date_range, req_out, 'gv-',)
plt.grid(True)
plt.axis([min(date_range), max(date_range), \
0, max([max(req_in), max(req_out)])])
plt.xticks(date_range, tuple(formated_dates), rotation=17)
# plt.xlabel('dates [%s, %s]' % (date_range[0], date_range[-1]))
plt.ylabel('DAS %s behavior' % cache)
plt.savefig('das_%s.pdf' % cache, format='pdf', transparent=True)
plt.close()
def test_run(self):
# 生成几何布朗运动市场环境
me_gbm = MarketEnvironment('me_gbm', dt.datetime(2020, 1, 1))
me_gbm.add_constant('initial_value', 36.0)
me_gbm.add_constant('volatility', 0.2)
me_gbm.add_constant('final_date', dt.datetime(2020, 12, 31))
me_gbm.add_constant('currency', 'EUR')
me_gbm.add_constant('frequency', 'M')
me_gbm.add_constant('paths', 1000)
csr = ConstantShortRate('csr', 0.06)
me_gbm.add_curve('discount_curve', csr)
# 生成几何布朗运动模拟类
gbm = GeometricBrownianMotion('gbm', me_gbm)
gbm.generate_time_grid()
# 生成跳跃扩散市场环境
me_srd = MarketEnvironment('me_srd', dt.datetime(2020, 1, 1))
me_srd.add_constant('initial_value', .25)
me_srd.add_constant('volatility', 0.05)
me_srd.add_constant('final_date', dt.datetime(2020, 12, 31))
me_srd.add_constant('currency', 'EUR')
me_srd.add_constant('frequency', 'W')
me_srd.add_constant('paths', 10000)
# specific to simualation class
me_srd.add_constant('kappa', 4.0)
me_srd.add_constant('theta', 0.2)
me_srd.add_curve('discount_curve', ConstantShortRate('r', 0.0))
srd = SquareRootDiffusion('srd', me_srd)
srd_paths = srd.get_instrument_values()[:, :10]
plt.figure(figsize=(10, 6))
plt.plot(srd.time_grid, srd.get_instrument_values()[:, :10])
plt.axhline(me_srd.get_constant('theta'), color='r', ls='--', lw=2.0)
plt.xticks(rotation=30)
plt.show()
def plot_profits(self, player, period):
profits = self.results["profits"][-period:]
plt.title("Profits")
time_window = 100
x = np.arange(len(profits[:, player]))
y = []
for i in x:
if i < time_window:
y_value = np.mean(profits[:i + 1, player])
else:
y_value = np.mean(profits[i - time_window:i + 1, player])
y.append(y_value)
plt.plot(x, y, color="black")
maximum_profit = \
self.parameters["n_positions"] * \
self.parameters["n_prices"]
plt.ylim(0, maximum_profit)
plt.annotate("Time window: {}".format(time_window),
xy=(0.8, 0.1),
xycoords='axes fraction',
fontsize=6)
# plt.annotate(self.string_parameters, xy=(-0.05, -0.1), xycoords='axes fraction', fontsize=6)
plt.savefig(self.format_fig_name("profits_player{}".format(player)))
plt.close()
def test_run(self):
# 生成几何布朗运动市场环境
me_gbm = MarketEnvironment('me_gbm', dt.datetime(2020, 1, 1))
me_gbm.add_constant('initial_value', 36.0)
me_gbm.add_constant('volatility', 0.2)
me_gbm.add_constant('final_date', dt.datetime(2020, 12, 31))
me_gbm.add_constant('currency', 'EUR')
me_gbm.add_constant('frequency', 'M')
me_gbm.add_constant('paths', 1000)
csr = ConstantShortRate('csr', 0.06)
me_gbm.add_curve('discount_curve', csr)
# 生成几何布朗运动模拟类
gbm = GeometricBrownianMotion('gbm', me_gbm)
gbm.generate_time_grid()
# 生成跳跃扩散市场环境
me_jd = MarketEnvironment('me_jd', dt.datetime(2020, 1, 1))
me_jd.add_constant('lambda', 0.3)
me_jd.add_constant('mu', -0.75)
me_jd.add_constant('delta', 0.1)
me_jd.add_environment(me_gbm)
# 生成跳跃扩散模拟类
jd = JumpDiffusion('jd', me_jd)
paths_3 = jd.get_instrument_values()
jd.update(lamb=0.9)
paths_4 = jd.get_instrument_values()
# 绘制图形
plt.figure(figsize=(10, 6))
p1 = plt.plot(gbm.time_grid, paths_3[:, :10], 'b')
p2 = plt.plot(gbm.time_grid, paths_4[:, :10], 'r-')
lengend1 = plt.legend([p1[0], p2[0]],
['low intensity', 'high intensity'],
loc=3)
plt.gca().add_artist(lengend1)
plt.xticks(rotation=30)
plt.show()
def plot_stat(rows, cache):
"Use matplotlib to plot DAS statistics"
if not PLOT_ALLOWED:
raise Exception('Matplotlib is not available on the system')
if cache in ['cache', 'merge']: # cachein, cacheout, mergein, mergeout
name_in = '%sin' % cache
name_out = '%sout' % cache
else: # webip, webq, cliip, cliq
name_in = '%sip' % cache
name_out = '%sq' % cache
def format_date(date):
"Format given date"
val = str(date)
return '%s-%s-%s' % (val[:4], val[4:6], val[6:8])
date_range = [r['date'] for r in rows]
formated_dates = [format_date(str(r['date'])) for r in rows]
req_in = [r[name_in] for r in rows]
req_out = [r[name_out] for r in rows]
plt.plot(date_range, req_in , 'ro-',
date_range, req_out, 'gv-',
)
plt.grid(True)
plt.axis([min(date_range), max(date_range), \
0, max([max(req_in), max(req_out)])])
plt.xticks(date_range, tuple(formated_dates), rotation=17)
# plt.xlabel('dates [%s, %s]' % (date_range[0], date_range[-1]))
plt.ylabel('DAS %s behavior' % cache)
plt.savefig('das_%s.pdf' % cache, format='pdf', transparent=True)
plt.close()
def plot_cells(self, color='k', lw=0.5, offset=(0, 0)):
ox, oy = offset
if self.tess == 'II':
for c in xrange(self.nC):
xmin, ymin = self._xmins[c]
xmax, ymax = self._xmaxs[c]
# if (xmin == self.XMINS[0] or
# ymin == self.XMINS[1] or
# xmax == self.XMAXS[0] or
# ymax == self.XMAXS[1]):
# plt.plot([xmin,xmax,xmax,xmin,xmin],
# [ymin,ymin,ymax,ymax,ymin], color=color,lw=lw*10)
# else:
plt.plot(np.asarray([xmin, xmax, xmax, xmin, xmin]) + ox,
np.asarray([ymin, ymin, ymax, ymax, ymin]) + oy,
color=color,
lw=lw)
else:
for c in xrange(self.nC):
verts = self.tessellation.cells_verts_homo_coo[c, :, :-1]
x = np.asarray(
[verts[0, 0], verts[1, 0], verts[2, 0], verts[0, 0]])
y = np.asarray(
[verts[0, 1], verts[1, 1], verts[2, 1], verts[0, 1]])
plt.plot(x + ox, y + oy, color=color, lw=lw)
def plot_fit(self, size=None, tol=0.1, axis_on=True):
n, d = self.D.shape
if size:
nrows, ncols = size
else:
sq = np.ceil(np.sqrt(n))
nrows = int(sq)
ncols = int(sq)
ymin = np.nanmin(self.D)
ymax = np.nanmax(self.D)
print('ymin: {0}, ymax: {1}'.format(ymin, ymax))
numplots = np.min([n, nrows * ncols])
plt.figure()
for n in range(numplots):
plt.subplot(nrows, ncols, n + 1)
plt.ylim((ymin - tol, ymax + tol))
plt.plot(self.L[n, :] + self.S[n, :], 'r')
plt.plot(self.L[n, :], 'b')
if not axis_on:
plt.axis('off')
def square_root_diffusion_euler():
x0 = 0.25
kappa = 3.0
theta = 0.15
sigma = 0.1
I = 10000
M = 50
dt = T / M
xh = np.zeros((M + 1, I))
x = np.zeros_like(xh)
xh[0] = x0
x[0] = x0
for t in range(1, M + 1):
xh[t] = (xh[t - 1] + kappa * (theta - np.maximum(xh[t - 1], 0)) * dt +
sigma * np.sqrt(np.maximum(xh[t - 1], 0)) * math.sqrt(dt) *
npr.standard_normal(I))
x = np.maximum(xh, 0)
plt.figure(figsize=(10, 6))
plt.hist(x[-1], bins=50)
plt.xlabel('value(SRT(T)')
plt.ylabel('frequency')
plt.show()
plt.figure(figsize=(10, 6))
plt.plot(x[:, :100], lw=1.5)
plt.xlabel('time')
plt.ylabel('index level')
plt.show()
return x
def jump_diffusion():
S0 = 100.0
r = 0.05
sigma = 0.2
lamb = 0.05
mu = -0.6
delta = 0.25
rj = lamb * (math.exp(mu + 0.5 * delta**2) - 1)
T = 1.0
M = 50
I = 10000
dt = T / M
S = np.zeros((M + 1, I))
S[0] = S0
sn1 = npr.standard_normal((M + 1, I))
sn2 = npr.standard_normal((M + 1, I))
poi = npr.poisson(lamb * dt, (M + 1, I))
for t in range(1, M + 1, 1):
S[t] = S[t - 1] * (np.exp(
(r - rj - 0.5 * sigma**2) * dt + sigma * math.sqrt(dt) * sn1[t]) +
(np.exp(mu + delta * sn2[t]) - 1) * poi[t])
S[t] = np.maximum(S[t], 0)
plt.figure(figsize=(10, 6))
plt.hist(S[-1], bins=50)
plt.xlabel('value')
plt.ylabel('frequency')
plt.show()
plt.figure(figsize=(10, 6))
plt.plot(S[:, :100], lw=1.)
plt.xlabel('time')
plt.ylabel('index level')
plt.show()
def draw(cls, t_max, agents_proportions, eco_idx, parameters):
color_set = ["green", "blue", "red"]
for agent_type in range(3):
plt.plot(np.arange(t_max),
agents_proportions[:, agent_type],
color=color_set[agent_type],
linewidth=2.0,
label="Type-{} agents".format(agent_type))
plt.ylim([-0.1, 1.1])
plt.xlabel("$t$")
plt.ylabel("Proportion of indirect exchanges")
# plt.suptitle('Direct choices proportion per type of agents', fontsize=14, fontweight='bold')
plt.legend(loc='upper right', fontsize=12)
print(parameters)
plt.title(
"Workforce: {}, {}, {}; displacement area: {}; vision area: {}; alpha: {}; tau: {}\n"
.format(parameters["x0"], parameters["x1"], parameters["x2"],
parameters["movement_area"], parameters["vision_area"],
parameters["alpha"], parameters["tau"]),
fontsize=12)
if not path.exists("../../figures"):
mkdir("../../figures")
plt.savefig("../../figures/figure_{}.pdf".format(eco_idx))
plt.show()
def cumulative_freq_plot(rast,
band=0,
mask=None,
bins=100,
xlim=None,
nodata=-9999):
'''
Plots an empirical cumulative frequency curve for the input raster array
in a given band.
'''
if mask is not None:
arr = binary_mask(rast, mask)
else:
arr = rast.copy()
if nodata is not None:
arr = subarray(arr)
values, base = np.histogram(arr, bins=bins)
cumulative = np.cumsum(values) # Evaluate the cumulative distribution
plt.plot(base[:-1], cumulative, c='blue') # Plot the cumulative function
plt.set_title('Empirical Cumulative Distribution: Band %d' % band)
if xlim is not None:
axes = plt.gca()
axes.set_xlim(xlim)
plt.show()
return arr
def plot(fn, marker, label):
result_file = fn
fid = vj.inv.ResultFileReader(result_file)
epochs = fid.epochs
rms = fid.rms_inland_at_epoch
plt.plot(epochs, rms, 'o-', label=label)
def plot_xy_points(self,
coords,
fmt='r+',
labels=None,
lpos=None,
dd=True):
'''
Add point(s) to the plot, given by their longitude-latitude (XY)
coordinates, which will be displayed at the appropriate feature space
coordinates.
'''
assert not self.__raveled__, 'Cannot do this when the input array is raveled'
m, n, c = self.__dims__
pcoords = xy_to_pixel(coords, gt=self.__gt__, wkt=self.__wkt__, dd=dd)
if labels is not None and lpos is None:
lpos = [(10, -10)] * len(labels)
# http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot
for i, (x, y) in enumerate(pcoords):
spec = self.features[x, y, :]
plt.plot(spec[m], spec[n], fmt, ms=20, mew=2)
if labels is not None:
plt.annotate(labels[i],
xy=(spec[m], spec[n]),
xytext=lpos[i],
textcoords='offset points',
ha='right',
va='bottom',
fontsize=14,
arrowprops=dict(arrowstyle='->',
connectionstyle='arc3,rad=0'))
def disp_deformed_grid_lines(self,level,color=None,lw=1):
# return
if self.hlines is None or self.vlines is None:
raise ValueError
hlines,vlines=self.hlines,self.vlines
# for lines,c in zip([hlines,vlines],['r','b']):
# pts_at_0=np.asarray([lines[:,0,:].flatten(),
# lines[:,1,:].flatten()]).T
# pts_at_0 = CpuGpuArray(pts_at_0.copy())
# pts_at_T=CpuGpuArray.zeros_like(pts_at_0)
# self.calc_T_fwd(pts_src=pts_at_0,
# pts_fwd=pts_at_T,
# level=level,verbose=0,int_quality=1)
# if self.nCols != self.nCols:
# raise NotImplementedError
# pts_at_T.gpu2cpu()
# lines_new_x=pts_at_T.cpu[:,0].reshape(lines[:,0,:].shape).copy()
# lines_new_y=pts_at_T.cpu[:,1].reshape(lines[:,0,:].shape).copy()
# for line_new_x,line_new_y in zip(lines_new_x,lines_new_y):
#
# plt.plot(line_new_x,line_new_y,c)
if color is None:
colors=['r','b']
else:
colors=[color,color]
s = hlines.shape
if s[2]<=1:
raise ValueError
p = 0
L = 50000
if L >=s[2]:
while p < np.ceil(s[2]):
hlines=self.hlines[:,:,p:p+L]
vlines=self.vlines[:,:,p:p+L]
p+=L
for lines,c in zip([hlines,vlines],colors):
pts_at_0=np.asarray([lines[:,0,:].flatten(),
lines[:,1,:].flatten()]).T
if pts_at_0.size==0:
break
pts_at_0 = CpuGpuArray(pts_at_0.copy())
pts_at_T=CpuGpuArray.zeros_like(pts_at_0)
self.calc_T_fwd(pts_src=pts_at_0,
pts_fwd=pts_at_T,
level=level,int_quality=1)
if self.nCols != self.nCols:
raise NotImplementedError
pts_at_T.gpu2cpu()
lines_new_x=pts_at_T.cpu[:,0].reshape(lines[:,0,:].shape).copy()
lines_new_y=pts_at_T.cpu[:,1].reshape(lines[:,0,:].shape).copy()
for line_new_x,line_new_y in zip(lines_new_x,lines_new_y):
plt.plot(line_new_x,line_new_y,c,lw=lw)
else:
raise NotImplementedError
def plot_wlp_plus_ll(self,**kwargs):
"""
Plot log likelihood + weighted log prior
"""
if self.lp_func is None:
return
plt.plot(np.asarray(self.record.ll)+
np.asarray(self.record.lp)*self.wlp,**kwargs)
def plot_data(self):
plt.clf() # clear the figure
plt.title("Parent incomes vs. student grade")
plt.plot(self.incomes,
self.grades,
color='orange',
marker='o',
linestyle='')
def plot_wlp_plus_ll(self, **kwargs):
"""
Plot log likelihood + weighted log prior
"""
if self.lp_func is None:
return
plt.plot(
np.asarray(self.record.ll) + np.asarray(self.record.lp) * self.wlp,
**kwargs)
def test_dip(self):
xf = arange(0, 425)
dips = self.fm.get_dip(xf)
plt.plot(xf,dips)
plt.grid('on')
plt.gca().set_xticks(self.fm.Y_PC)
plt.ylim([0, 30])
plt.gca().invert_yaxis()
plt.savefig(join(self.outs_dir, '~y_fc_dips.png'))
plt.close()
def test_respace(self):
fn = '/home/zy/workspace/viscojapan/tests/share/slip0.h5'
arr = vj.epoch_3d_array.Slip.load(fn)
epochs = [0, 100, 200, 300]
arr1 = arr.respace(epochs)
nx= 2
ny = 13
plt.plot(arr.get_epochs(), arr.get_cumu_slip_at_subfault(nx, ny))
plt.plot(arr1.get_epochs(), arr1.get_cumu_slip_at_subfault(nx, ny), 'x')
def plot_smoothed_alpha_comparison(self,rmsval,suffix=''):
plt.plot(self.f,self.alpha,'ko',label='data set')
plt.plot(self.f,self.salpha,'c-',lw=2,label='smoothed angle $\phi$')
plt.xlabel('frequency in Hz')
plt.ylabel('angle $\phi$ in coordinates of circle')
plt.legend()
ylims=plt.axes().get_ylim()
plt.yticks((arange(9)-4)*0.5*pi, ['$-2\pi$','$-3\pi/2$','$-\pi$','$-\pi/2$','$0$','$\pi/2$','$\pi$','$3\pi/2$','$2\pi$'])
plt.ylim(ylims)
plt.title('RMS offset from smooth curve: {:.4f}'.format(rmsval))
if self.show: plt.show()
else: plt.savefig(join(self.sdc.plotpath,'salpha','c{}_salpha_on_{}_circle'.format(self.sdc.case,self.ZorY)+self.sdc.suffix+self.sdc.outsuffix+suffix+'.png'), dpi=240)
plt.close()
def draw(cls, t_max, agents_proportions, suffix):
color_set = ["green", "blue", "red"]
for agent_type in range(3):
plt.plot(np.arange(t_max), agents_proportions[:, agent_type],
color=color_set[agent_type], linewidth=1.0)
plt.ylim([0, 1])
# plt.suptitle('Direct choices proportion per type of agents', fontsize=14, fontweight='bold')
# plt.legend(loc='lower left', frameon=False)
plt.savefig("figure_{}.pdf".format(suffix))
def plot_axis_control(self, axis,
show_mux_cmd=True, show_asctec_cmd=True, show_vicon_meas=True, show_imu_meas=True):
axismap = {'roll': (self.v.control.roll_cmd, 2, +1, self.v.asctec_ctrl_input.roll_cmd, -1),
'pitch': (self.v.control.pitch_cmd, 1, -1, self.v.asctec_ctrl_input.pitch_cmd, -1),
'yaw': (self.v.control.yaw_cmd, 0, -1, self.v.asctec_ctrl_input.yaw_rate_cmd, +1) # not sure about the multiplier here
}
control_mode_cmd, state_axis, imu_mult, asctec_cmd, asctec_cmd_mult = axismap[axis]
newfig("%s Axis Control" % axis.capitalize(), "time [s]", "%s [deg]" % axis.capitalize())
# np.clip() and the [1:] stuff in the following to attempt deal with bogus initial data points in IMU data:
if show_mux_cmd:
plt.plot(self.v.control.t[self.v.control.istart:self.v.control.iend],
control_mode_cmd[self.v.control.istart:self.v.control.iend], label='cmd (from mux)')
if show_vicon_meas:
plt.plot(self.v.state.t[self.v.state.istart:self.v.state.iend],
self.v.state.ori_ypr[self.v.state.istart:self.v.state.iend, state_axis], label='meas (Vicon)')
if show_imu_meas:
plt.plot(np.clip(self.v.imu.t[self.v.imu.istart:self.v.imu.iend], 0, np.inf),
imu_mult*self.v.imu.ori_ypr[self.v.imu.istart:self.v.imu.iend, state_axis], label='meas (IMU)')
if show_asctec_cmd and axis is not 'yaw':
plt.plot(self.v.asctec_ctrl_input.t[self.v.asctec_ctrl_input.istart:self.v.asctec_ctrl_input.iend],
asctec_cmd_mult*asctec_cmd[self.v.asctec_ctrl_input.istart:self.v.asctec_ctrl_input.iend],
label='cmd (AscTec)')
# Plot difference between vicon and imu: (broken, comment it out for now..)
# tout, data_out = uniform_resample((('linear', self.v.imu.t[self.v.asctec_ctrl_input.istart:self.v.asctec_ctrl_input.iend],
# self.v.imu.ori_ypr[self.v.asctec_ctrl_input.istart:self.v.asctec_ctrl_input.iend,state_axis]),
# ('linear', self.v.state.t[self.v.state.istart:self.v.state.iend],
# self.v.state.ori_ypr[self.v.state.istart:self.v.state.iend, state_axis])),
# 0.02)
# plt.plot(tout, imu_mult*data_out[0][0] - data_out[1][0], label='IMU - Vicon')
plt.legend()
self._timeseries_postplot()
def plot_fault_framework(fault_framework):
fm = fault_framework
plt.plot(fm.Y_PC, fm.DEP, '-o')
plt.axis('equal')
plt.axhline(0, color='black')
plt.gca().set_yticks(fm.DEP)
plt.gca().set_xticks(fm.Y_PC)
plt.grid('on')
plt.xlabel('From trench to continent(km)')
plt.ylabel('depth (km)')
for xi, yi, dip in zip(fm.Y_PC, fm.DEP, fm.DIP_D):
plt.text(xi, yi, 'dip = %.1f'%dip)
plt.gca().invert_yaxis()
def plot_characteristic_freqs(self,annotate=True,size=8,spread=0.15):
cx,cy=self.center.real,self.center.imag; r=self.radius
if self.ZorY == 'Z':
philist,flist=[self.phi_a,self.phi_p,self.phi_n],[self.fa,self.fp,self.fn]
elif self.ZorY == 'Y':
philist,flist=[self.phi_m,self.phi_s,self.phi_r],[self.fm,self.fs,self.fr]
for p,f in zip(philist,flist):
if f is not None:
xpos=cx+r*cos(p); ypos=cy+r*sin(p); xos=spread*(xpos-cx); yos=spread*(ypos-cy)
plt.plot([0,xpos],[0,ypos],'co-')
if annotate:
self.ax.annotate('{:.3f} Hz'.format(f), xy=(xpos,ypos), xycoords='data',
xytext=(xpos+xos,ypos+yos), textcoords='data', #textcoords='offset points',
arrowprops=dict(arrowstyle="->", shrinkA=0, shrinkB=10), size=size
)
def plot(*args):
"""
Recibe señales que se desee graficar
Y muestra todas ellas en un mismo gráfico
"""
import numpy as np
from pylab import plt
plotargs = []
for arg in args:
x = np.arange(0, len(arg))
y = np.array([int(i) for i in arg])
plotargs.extend([x, y])
plt.plot(*plotargs)
plt.show()
def update_img((expected, output)):
plt.cla()
plt.ylim((vmin, vmin+vmax))
plt.xlim((vmin, vmin+vmax))
ax = fig.add_subplot(111)
plt.plot([vmin, vmin+vmax], [vmin, vmin+vmax])
ax.grid(True)
plt.xlabel("expected output")
plt.ylabel("network output")
plt.legend()
expected = expected*vmax + vmin
output = output*vmax + vmin
#scat.set_offsets((expected, output))
scat = ax.scatter(expected, output)
return scat
def test_dep(self):
xf = arange(0, 425)
deps = self.fm.get_dep(xf)
plt.plot(xf,deps)
plt.gca().set_yticks(self.fm.DEP)
plt.gca().set_xticks(self.fm.Y_PC)
plt.grid('on')
plt.title('Ground x versus depth')
plt.xlabel('Ground X (km)')
plt.ylabel('depth (km)')
plt.axis('equal')
plt.gca().invert_yaxis()
plt.savefig(join(self.outs_dir, '~Y_PC_vs_deps.png'))
plt.close()
def plot(site):
tp = np.loadtxt('../post_offsets/%s.post'%site)
t = dc.asmjd([ii[0] for ii in tp]) + dc.adjust_mjd_for_plot_date
e = [ii[1] for ii in tp]
n = [ii[2] for ii in tp]
u = [ii[3] for ii in tp]
plt.plot_date(t,e,'x-', label = 'eastings')
plt.plot(t,n,'x-', label = 'northings')
plt.plot(t,u,'x-', label = 'upings')
plt.gcf().autofmt_xdate()
plt.legend(loc=0)
plt.title(site)
plt.savefig('%s.png'%site)
#plt.show()
plt.close()
def plotter(mode,Bc,Tc,Q):
col = ['#000080','#0000FF','#4169E1','#6495ED','#00BFFF','#B0E0E6']
plt.figure()
ax = plt.subplot(111)
for p in range(Bc.shape[1]):
plt.plot(Tc[:,p],Bc[:,p],'-',color=str(col[p]))
plt.xlabel('Tc [TW]')
plt.ylabel('Bc normalised to total EU load')
plt.title(str(mode)+' flow')
# Shrink current axis by 25% to make room for legend
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.75, box.height])
plt.legend(\
([str(Q[i]*100) for i in range(len(Q))]),\
loc='center left', bbox_to_anchor=(1, 0.5),title='Quantiles')
plt.savefig('figures/bctc_'+str(mode)+'.eps')
def _plot_base(dep, val, deplim_small, xlim_small, xlabel):
plt.subplot(1,2,1)
plt.plot(val, dep)
plt.gca().invert_yaxis()
plt.grid('on')
plt.ylabel('depth/km')
plt.xlabel(xlabel)
locs, labels = plt.xticks()
plt.setp(labels, rotation=-45)
plt.subplot(1,2,2)
plt.plot(val, dep)
plt.gca().invert_yaxis()
plt.grid('on')
plt.ylim(deplim_small)
plt.xlim(xlim_small)
plt.xlabel(xlabel)
locs, labels = plt.xticks()
plt.setp(labels, rotation=-45)
def plot_axis_control(v, axis):
axismap = {'roll': (v.control.roll_cmd, 2, +1, v.asctec_ctrl_input.roll_cmd, -1),
'pitch': (v.control.pitch_cmd, 1, -1, v.asctec_ctrl_input.pitch_cmd, -1),
'yaw': (v.control.yaw_cmd, 0, -1, v.asctec_ctrl_input.yaw_rate_cmd, +1) # not sure about the multiplier here
}
control_mode_cmd, state_axis, imu_mult, asctec_cmd, asctec_cmd_mult = axismap[axis]
newfig("%s Axis Control" % axis.capitalize(), "time [s]", "%s [deg]" % axis.capitalize())
# np.clip() and the [1:] stuff in the following to attempt deal with bogus initial data points in IMU data:
plt.plot(v.control.t, control_mode_cmd, label='cmd (from mux)')
plt.plot(v.state.t[1:], v.state.ori_ypr[1:,state_axis], label='meas (Vicon)')
plt.plot(np.clip(v.imu.t[1:], 0, np.inf), imu_mult*v.imu.ori_ypr[1:,state_axis], label='meas (IMU)')
if axis is not 'yaw':
plt.plot(v.asctec_ctrl_input.t, asctec_cmd_mult*asctec_cmd, label='cmd (AscTec)')
# Plot difference between vicon and imu:
tout, data_out = uniform_resample((('linear', v.imu.t[1:], v.imu.ori_ypr[1:,state_axis]),
('linear', v.state.t[1:], v.state.ori_ypr[1:,state_axis])),
0.02)
plt.plot(tout, imu_mult*data_out[0][0] - data_out[1][0], label='IMU - Vicon')
plt.legend()
def plot_cells(self,color='k',lw=0.5,offset=(0,0)):
ox,oy=offset
if self.tess == 'II':
for c in xrange(self.nC):
xmin,ymin=self._xmins[c]
xmax,ymax=self._xmaxs[c]
# if (xmin == self.XMINS[0] or
# ymin == self.XMINS[1] or
# xmax == self.XMAXS[0] or
# ymax == self.XMAXS[1]):
# plt.plot([xmin,xmax,xmax,xmin,xmin],
# [ymin,ymin,ymax,ymax,ymin], color=color,lw=lw*10)
# else:
plt.plot(np.asarray([xmin,xmax,xmax,xmin,xmin])+ox,
np.asarray([ymin,ymin,ymax,ymax,ymin])+oy, color=color,lw=lw)
else:
for c in xrange(self.nC):
verts=self.tessellation.cells_verts_homo_coo[c,:,:-1]
x=np.asarray([verts[0,0],verts[1,0],verts[2,0],verts[0,0]])
y=np.asarray([verts[0,1],verts[1,1],verts[2,1],verts[0,1]])
plt.plot(x+ox,y+oy, color=color,lw=lw)
def plot_inference_summary(inference_record):
ll = []
lp = []
wlp_plus_ll=[]
for step in inference_record.steps:
ll += step.ll[1:] # start from 1 and not 0: to skip the initial guess
try:
lp += step.lp[1:]
wlp_plus_ll += list((step.wlp * np.asarray(step.lp[1:]) +
np.asarray(step.ll[1:])).tolist())
except AttributeError:
pass
plt.title('ll',fontsize=30)
plt.plot(ll,lw=2)
plt.plot(lp,lw=2)
plt.plot(wlp_plus_ll,lw=2)
counter = 0
for i,step in enumerate(inference_record.steps):
if i%2==1:
facecolor = ".2"
else:
facecolor = ".5"
plt.axvspan(counter, counter+step.nAccepted, facecolor=facecolor, alpha=0.2)
counter += step.nAccepted
def plot(mot_results):
bool_mot_results = np.asarray(mot_results) == 1
t_max = len(bool_mot_results)
average_t = np.zeros(t_max)
time_window = 10
for t in range(t_max):
if t < time_window:
average_t[t] = np.mean(bool_mot_results[:t+1])
else:
average_t[t] = np.mean(bool_mot_results[t-10:t+1])
try:
plt.plot(np.arange(t_max), average_t, linewidth=2)
plt.ylim([-0.01, 1.01])
plt.show("figure.pdf")
except:
print("Could not show the figure but here are the results:")
print(average_t)
def plot(cls, data, msg=""):
x = np.arange(len(data[:]))
plt.plot(x, data[:, 0], c="red", linewidth=2)
plt.plot(x, data[:, 1], c="blue", linewidth=2)
plt.plot(x, data[:, 2], c="green", linewidth=2)
plt.ylim([-0.01, 1.01])
plt.text(0, -0.12, "{}".format(msg))
plt.show()
def __init__(self, width):
# set plot to animated
self.x1s = [0]
self.y1s = [0]
self.x2s = [0]
self.y2s = [0]
self.x3s = [0]
self.y3s = [0]
self.plt1, self.plt2, self.plt3 = plt.plot(
self.x1s, self.y1s, 'rx',
self.x2s, self.y2s, 'b.',
self.x3s, self.y3s, 'gs',
alpha=0.05, linewidth=3)
self.latest = deque([0] * 20)
self.plt3.set_alpha = 0.8
plt.ylim([0, 100])
plt.xlim([0, width])
plt.ion()
def plot_overview(self,suffix=''):
x=self.x; y=self.y; r=self.radius; cx,cy=self.center.real,self.center.imag
ax=plt.axes()
plt.scatter(x,y, marker='o', c='b', s=40)
plt.axhline(y=0,color='grey', zorder=-1)
plt.axvline(x=0,color='grey', zorder=-2)
t=linspace(0,2*pi,201)
circx=r*cos(t) + cx
circy=r*sin(t) + cy
plt.plot(circx,circy,'g-')
plt.plot([cx],[cy],'gx',ms=12)
if self.ZorY == 'Z':
philist,flist=[self.phi_a,self.phi_p,self.phi_n],[self.fa,self.fp,self.fn]
elif self.ZorY == 'Y':
philist,flist=[self.phi_m,self.phi_s,self.phi_r],[self.fm,self.fs,self.fr]
for p,f in zip(philist,flist):
if f is not None:
xpos=cx+r*cos(p); ypos=cy+r*sin(p); xos=0.2*(xpos-cx); yos=0.2*(ypos-cy)
plt.plot([0,xpos],[0,ypos],'co-')
ax.annotate('{:.3f} Hz'.format(f), xy=(xpos,ypos), xycoords='data',
xytext=(xpos+xos,ypos+yos), textcoords='data', #textcoords='offset points',
arrowprops=dict(arrowstyle="->", shrinkA=0, shrinkB=10)
)
#plt.xlim(0,0.16)
#plt.ylim(-0.1,0.1)
plt.axis('equal')
if self.ZorY == 'Z':
plt.xlabel(r'resistance $R$ in Ohm'); plt.ylabel(r'reactance $X$ in Ohm')
if self.ZorY == 'Y':
plt.xlabel(r'conductance $G$ in Siemens'); plt.ylabel(r'susceptance $B$ in Siemens')
plt.title("fitting the admittance circle with Powell's method")
tx1='best fit (fmin_powell):\n'
tx1+='center at G+iB = {:.5f} + i*{:.8f}\n'.format(cx,cy)
tx1+='radius = {:.5f}; '.format(r)
tx1+='residue: {:.2e}'.format(self.resid)
txt1=plt.text(-r,cy-1.1*r,tx1,fontsize=8,ha='left',va='top')
txt1.set_bbox(dict(facecolor='gray', alpha=0.25))
idxlist=self.to_be_annotated('triple')
ofs=self.annotation_offsets(idxlist,factor=0.1,xshift=0.15)
for i,j in enumerate(idxlist):
xpos,ypos = x[j],y[j]; xos,yos = ofs[i].real,ofs[i].imag
ax.annotate('{:.1f} Hz'.format(self.f[j]), xy=(xpos,ypos), xycoords='data',
xytext=(xpos+xos,ypos+yos), textcoords='data', #textcoords='offset points',
arrowprops=dict(arrowstyle="->", shrinkA=0, shrinkB=10)
)
if self.show: plt.show()
else: plt.savefig(join(self.sdc.plotpath,'c{}_fitted_{}_circle'.format(self.sdc.case,self.ZorY)+suffix+'.png'), dpi=240)
plt.close()
