def plot_device_log_curves(event=None):
# 作光态对数曲线
if device_list:
Plot.plot_log_curves('Light Log Curves', 'all', pls.log_x_label,
pls.log_y_label, pls.log_x_min, pls.log_x_max,
pls.log_y_min, pls.log_y_max, device_list,
legend_list)
def plotAbsolute(self):
self.logMessage("Plotting the absolute alignment profile...")
self.app.processEvents()
# checando se todos os arquivos foram devidamente carregados
if (not self.isNominalsLoaded or not self.isMeasuredLoaded
or not self.isLookuptableLoaded):
self.logMessage("error: not all required files were loaded")
return
# calculando desvios de todos dof de cada berço com o best-fit de seus pontos
diffAllDoFs = GirderGroup.evalDiff_bestFit(
self.girderNominal.pointGroup.ptList,
self.girderMeasured.pointGroup.ptList)
# definindo as propriedades do plot
plot_args = {
'y_list': ['Tx', 'Ty', 'Tz', 'Rx', 'Ry', 'Rz'],
'title_list': [
'Transversal', 'Longitudinal', 'Vertical', 'Pitch', 'Roll',
'Yaw'
],
'fig_title':
'Global Alignment Profile - Storage Ring'
}
# chamando o plot
Plot.plotGirderDeviation(diffAllDoFs,
'allDoFs',
plot_args,
freezePlot=True)
def __init__(self):
super().__init__()
pygame.init()
pygame.display.set_caption("ControlGUI(UWU")
self.screen_width = 400
self.screen_height = 300
self.screen = pygame.display.set_mode(
(self.screen_width, self.screen_height))
self.clock = pygame.time.Clock()
self.plot = Plot(self.screen, 400, 300)
self.movement = [0 for i in range(6)]
self.power = [0 for i in range(6)]
self.profile = -1
self.widgets = []
self.widgets.append((ProfilePopup(self.screen_width,
self.screen_height), (0, 0)))
self.widgets.append((EMPopup(self.screen_width, self.screen_height,
1), (0, 0)))
self.widgets.append((EMPopup(self.screen_width, self.screen_height,
2), (0, 0)))
self.widgets.append((InvertPopup(self.screen_width,
self.screen_height), (0, 0)))
self.charts = []
self.charts.append(
(Plot(['strafe', 'drive', 'yaw', 'ud', 'tilt', 'zero'],
self.screen_width, self.screen_height), (0, 0), 0))
self.charts.append(
(Plot(['FL', 'FR', 'BL', 'BR', 'TL', 'TR'], self.screen_width,
self.screen_height), (self.screen_width / 2, 0), 1))
def test_constructor(self):
#
# Define mesh, element, and dofhandler
#
mesh = QuadMesh(box=[0, 20, 0, 20],
resolution=(20, 20),
periodic={0, 1})
dim = mesh.dim()
element = QuadFE(dim, 'Q2')
dofhandler = DofHandler(mesh, element)
dofhandler.distribute_dofs()
basis = Basis(dofhandler, 'u')
alph = 2
kppa = 1
# Symmetric tensor gma T + bta* vv^T
gma = 0.1
bta = 25
p = lambda x: 10/np.pi*(0.75*np.sin(np.pi*x[:,0]/10)+\
0.25*np.sin(np.pi*x[:,1]/10))
f = Nodal(f=p, basis=basis)
fx = f.differentiate((1, 0))
fy = f.differentiate((1, 1))
#plot.contour(f)
x = np.linspace(0, 20, 12)
X, Y = np.meshgrid(x, x)
xy = np.array([X.ravel(), Y.ravel()]).T
U = fx.eval(xy).reshape(X.shape)
V = fy.eval(xy).reshape(X.shape)
v1 = lambda x: -0.25 * np.cos(np.pi * x[:, 1] / 10)
v2 = lambda x: 0.75 * np.cos(np.pi * x[:, 0] / 10)
U = v1(xy).reshape(X.shape)
V = v2(xy).reshape(X.shape)
#plt.quiver(X,Y, U, V)
#plt.show()
h11 = Explicit(lambda x: gma + bta * v1(x) * v1(x), dim=2)
h12 = Explicit(lambda x: bta * v1(x) * v2(x), dim=2)
h22 = Explicit(lambda x: gma + bta * v2(x) * v2(x), dim=2)
tau = (h11, h12, h22)
#tau = (Constant(2), Constant(1), Constant(1))
#
# Define default elliptic field
#
u = EllipticField(dofhandler, kappa=1, tau=tau, gamma=2)
Q = u.precision()
v = Nodal(data=u.sample(mode='precision', decomposition='chol'),
basis=basis)
plot = Plot(20)
plot.contour(v)
def plot_dark_log_curves(event=None):
# 作暗态对数曲线
if device_list:
Plot.plot_log_curves('Dark Log Curves', 'dark', pls.log_x_label,
pls.log_y_label, pls.log_x_min, pls.log_x_max,
pls.log_y_min, pls.log_y_max, device_list,
legend_list)
def plot_dark_line_curves(event=None):
# 作暗态线性曲线
if device_list:
Plot.plot_line_curves('Dark Line Curves', 'dark', pls.line_x_label,
pls.line_y_label, pls.line_x_min,
pls.line_x_max, pls.line_y_min,
pls.line_y_max, device_list, legend_list)
def plot_before (before, output_dir):
from chemotext_util import LoggingUtil
logger = LoggingUtil.init_logging (__file__)
if before.count () <= 0:
return
'''
before = before.reduceByKey (lambda x, y : x + y). \
mapValues (lambda x : filter (lambda v : v is not None, x))
'''
true_plots_dir = os.path.join (output_dir, "chart")
print ("-------------> before 0")
true_mentions = before. \
mapValues (lambda x : Plot.plot_true_mentions (x, true_plots_dir)). \
filter (lambda x : len(x[1]) > 0)
logger.info ("Plotted {0} sets of true mentions.".format (true_mentions.count ()))
print ("-------------> before 1")
false_plots_dir = os.path.join (output_dir, "chart", "false")
false_mentions = before.subtractByKey (true_mentions)
false_frequency = false_mentions. \
mapValues (lambda x : Plot.false_mention_histogram (x, false_plots_dir))
false_mentions = false_mentions. \
mapValues (lambda x : Plot.plot_false_mentions (x, false_plots_dir))
logger.info ("false mentions: {0}".format (false_mentions.count ()))
true_mentions = None
false_mentions = None
false_frequency = None
def set_source(self,source,nodes=None):
"""
Handles opening a new file. Creates a plot with the given source
file. Uses input plugins to convert file to SVG. This disregards
all previous settings, thus ui_updates should be called.
"""
height = self.material.length and self.material.length*UNITS[self.units] or None
p = Plot(width=self.material.width*UNITS[self.units],height=height,color=self.material.color)
m = self.material.margin
p.set_padding(top=m[0],right=m[1],bottom=m[2],left=m[3])
if type(source) == etree._ElementTree:
try:
# If certain nodes are selected, only plot them.
if nodes:
xml = etree.tostring(get_selected_nodes(source,nodes))
else:
xml = etree.tostring(source)
# Set a job name if none exists
if self.name is None:
self.name = "*inkscape.svg"
# Try to make a plot
p.set_graphic(xml)
self.plot = p
except (IOError,etree.XMLSyntaxError),trace:
log.debug(trace)
raise Exception("Failed to create plot. Reason: Failed to import the Inkscape file.")
def spm_geometry_and_inside_outside_test():
# # Write your own path here
# path = r'C:\Users\User\Documents\python\aero\airfoils_data'
# # Airfoil name
# name = 'ua79sff.txt'
# test_fig = figure.Airfoil(name, path)
test_fig = figure.Circle(10, num_points=20)
# test_fig = figure.Ellipse(10, 5, num_points=50)
# test_fig = figure.Square(10, num_points=50)
# test_fig = figure.Rectangle(10, 5, num_points=50)
# test_fig = figure.Triangle((0, 0), (6, 0), (3, 3))
# test_fig = figure.Triangle((0, 0), (0, 6), (3, 3))
# test_fig = figure.Triangle((0, 0), (6, 3), (3, 4))
# test_fig = figure.Polygon('Polygon',
# [(1, 1), (2, 2), (3, 3),
# (2, 3), (2, 4), (1, 4), (0, 3)])
# test_fig = figure.Ogive(2, 1, 5)
geometry = Geometry(test_fig, 1)
x0, y0, dx, dy = test_fig.rect
grid = figure.Grid(x0, y0,
1.5 * dx, 1.5 * dy, 20)
plt = Plot(grid)
plt.plot_figure(test_fig)
plt.plot_source_panel_method(geometry)
for x in grid.x:
for y in grid.y:
res = test_fig.is_inside(x, y)
if not res:
plt.plot_point(x, y, '.y')
plt.show()
def evaluate(self):
score = self.model.evaluate(self.testset[0],
self.testset[1],
verbose=0)
print('Test Accuracy: ', score[1])
figure = Plot(self.loss_hist)
figure.show_loss()
def main(p: Plot):
p.plot_size = 4
p.setup()
p.draw_bounding_box()
num_bins = round(100/p.inches_to_units(0.02))
audio = af.read('soundwave/caves.m4a')[0]
# take abs to get magnitude
audio = np.abs(audio)
# sum to mono
audio = np.sum(audio, axis=0)
# pad end to nearest multiple of bin width
pad_len = math.ceil(audio.shape[0]/num_bins)*num_bins - audio.shape[0]
audio = np.pad(audio, (0, pad_len))
# reshape into 2d array of bins
audio = np.reshape(audio, (num_bins, -1))
# sum bins to 1d array of values
audio = np.sum(audio, axis=1)
# normalize
audio = audio/np.max(audio)
max_width = 30
for i, sample in enumerate(audio):
x = 100*i/len(audio)
p.goto(x, 50 + max_width*sample)
p.lineto(x, 50 - max_width*sample)
def plot(cls):
Plot.draw_border()
cls.draw_ui()
if cls.view == "Info":
cls.draw_info()
else:
cls.draw_terrain()
def sample_counts_by_gene(self,
result,
tcga_cancer_code,
genie_cancer_code,
cancer_type_label,
rollup=False):
outpath = self.find_outpath(rollup)
indecies_to_drop = [
] # captures the row index where mutation gene is not in panel
result.sort_values('tcga_gene_sample_count',
inplace=True,
ascending=False)
for i, row in result.iterrows():
tcga_count = row['tcga_gene_sample_count']
genie_count = row['genie_gene_sample_count']
if tcga_count <= 5 and genie_count <= 5:
indecies_to_drop.append(i) # Add to drop list
continue
if i >= 40:
indecies_to_drop.append(i) # Add to drop list
continue
result.drop(indecies_to_drop, inplace=True)
# Generate plot...
print(
f"Plotting sample counts by gene results for TCGA cancer code: {tcga_cancer_code}"
)
Plot.reset()
Plot.sample_counts_by_gene(outpath,
str(os.getenv('SYNAPSE_RELEASE_VERSION')),
result, genie_cancer_code,
cancer_type_label)
def set_up_plot(self, settings=None):
self.plot = Plot()
if settings is not None:
for key in settings:
self.plot.settings[key] = settings[key]
self.settings['plot'] = self.plot.settings
n_rows = self.plot.settings['n_rows']
n_cols = self.plot.settings['n_cols']
if n_rows is not None and n_cols is not None:
print '\nSetting up {0:d}x{1:d} plot.'.format(n_rows, n_cols)
else:
e_str = 'Number of {0:s} must be an integer > 0.'
n_rows, n_cols = (0, 0)
while n_rows < 1 or n_cols < 1:
n_rows = utils.get_input_integer( \
'\nNumber of subplot rows?\n> ',
error_text=e_str.format('rows'))[0]
n_cols = utils.get_input_integer( \
'Number of subplot columns?\n> ',
error_text=e_str.format('columns'))[0]
if n_rows < 1 or n_cols < 1:
print 'Must have > 0 rows and columns.'
self.plot.set_up_plot_grid(n_rows, n_cols)
#self.plot.plot_grid.tight_layout(self.plot.figure)
self.plot.figure.set_tight_layout(True)
plt.show(block=False)
print '(If you cannot see the plot, try changing the '
print 'matplotlib backend. Current backend is ' + \
plt.get_backend() + '.)'
def main():
data = CollectData('192.168.1.69', 'AC:75:1D:57:8A:D8')
regression = Regression()
value = input('Would you like to collect data? [y/n] ')
n = 0
while (value == 'y' and n < 6):
# collect data foreach distance
val = data.collect()
# call AddRSSI of regression
regression.addRSSI(val)
print(regression._RSSIAritmetica)
print(regression._RSSIQuadratica)
value = input('Would you like to collect data?[y/n] ').strip(
'\r').strip('\n')
n += 1
# call regression
result = regression.linearRegression()
print(result)
# plot line above point with data gave from regression
p1 = Plot('DEVICE', '-log10(distance)', 'RSSI')
p1.pointsAndLine(regression.getLog10Distance(),
regression.getRSSIAritmetica(), -1, 1, 100,
result['arithmeticK'], result['arithmeticA'])
def test02():
"""
Spatially varying anisotropy
"""
print('Test 2:')
grid = Grid(box=[0, 20, 0, 20], resolution=(100, 100))
mesh = Mesh(grid=grid)
element = QuadFE(2, 'Q1')
system = System(mesh, element)
alph = 2
kppa = 1
# Symmetric tensor gma T + bta* vv^T
gma = 0.1
bta = 25
v2 = lambda x, y: -0.75 * np.cos(np.pi * x / 10)
v1 = lambda x, y: 0.25 * np.sin(np.pi * y / 10)
h11 = lambda x, y: gma + v1(x, y) * v1(x, y)
h12 = lambda x, y: v1(x, y) * v2(x, y)
h22 = lambda x, y: v2(x, y) * v2(x, y)
X = Gmrf.from_matern_pde(alph, kppa, mesh, element, tau=(h11, h12, h22))
x = X.sample(1).ravel()
fig, ax = plt.subplots()
plot = Plot()
ax = plot.contour(ax, fig, x, mesh, element, resolution=(200, 200))
plt.show()
def __init__(self, main):
super(Plugin, self).__init__("Stack Of Tasks plugin", main)
self.setObjectName("Stack Of Tasks plugin")
self.main = main
self.graph = Graph(self)
self.plot = Plot(self)
self.tabWidget = QtGui.QTabWidget(self)
self.setWidget(self.tabWidget)
self.tabWidget.addTab(self.graph.view, "SoT graph")
self.tabWidget.addTab(self.plot, "Plot")
toolBar = QtGui.QToolBar("SoT buttons")
toolBar.addAction(QtGui.QIcon.fromTheme("view-refresh"),
"Create entire graph", self.graph.createAllGraph)
toolBar.addSeparator()
toolBar.addAction(QtGui.QIcon.fromTheme("zoom-fit-best"),
"Zoom fit best", self.plot.zoomFitBest)
toolBar.addAction(QtGui.QIcon.fromTheme("media-playback-stop"),
"Stop fetching data", self.stopAnimation)
toolBar.addSeparator()
toolBar.addAction(QtGui.QIcon.fromTheme("window-new"), "Create viewer",
self.createRobotView)
toolBar.addSeparator()
toolBar.addAction(QtGui.QIcon.fromTheme("view-filter"),
"Set entity filter by name", self.entityFilterByName)
main.addToolBar(toolBar)
self.displaySignals = []
self.hookRegistered = False
self.displaySignalValuesStarted = False
def main(p: Plot, img_filename):
p.plot_size = 6
p.setup()
img = Image.open(img_filename)
max_res = 250
max_size = max(img.width, img.height)
img = img.resize((round(max_res * img.width / max_size),
round(max_res * img.height / max_size)))
pixels = [luminance(*c) for c in img.getdata()]
def getpix(r, c):
return pixels[r * img.width + c]
def setpix(r, c, col):
pixels[r * img.width + c] = col
def find_closest_palette_color(col):
return 255 if col > 127 else 0
for r in range(1, img.height - 1):
print('row {}/{}'.format(r, img.height - 2))
for c in range(1, img.width - 1):
oldpixel = getpix(r, c)
newpixel = find_closest_palette_color(oldpixel)
if newpixel == 0:
x = (c / max_res) * 100 + random.uniform(-0.1, 0.1)
y = (r / max_res) * 100 + random.uniform(-0.1, 0.1)
p.dot(x, y)
quant_error = oldpixel - newpixel
setpix(r, c + 1, getpix(r, c + 1) + quant_error * 7 / 16)
setpix(r + 1, c - 1, getpix(r + 1, c - 1) + quant_error * 3 / 16)
setpix(r + 1, c, getpix(r + 1, c) + quant_error * 5 / 16)
setpix(r + 1, c + 1, getpix(r + 1, c + 1) + quant_error * 1 / 16)
def __init__(self, port, baudrate, tag, buffer_len):
self.plot = Plot()
self.reader = Reader(port, baudrate, len(tag)+buffer_len)
self.reader.register_tag_listener(tag, buffer_len, self.process_flydata)
self.reader.start()
def test03():
"""
Constant Anisotropy
"""
print('Test 3:')
# Mesh
mesh = Mesh.newmesh([0, 20, 0, 20], grid_size=(40, 40))
mesh.refine()
element = QuadFE(2, 'Q1')
system = System(mesh, element)
gma = 1
bta = 8
tht = np.pi / 4
v = np.array([np.cos(tht), np.sin(tht)])
H = gma * np.eye(2, 2) + bta * np.outer(v, v)
Z = 10 * np.random.normal(size=system.n_dofs())
# Bilinear forms
bf = [(1,'u','v'), \
(H[0,0],'ux','vx'), (H[0,1],'uy','vx'),\
(H[1,0],'ux','vy'), (H[1,1],'uy','vy')]
A = system.assemble(bilinear_forms=bf, linear_forms=None)
M = system.assemble(bilinear_forms=[(1, 'u', 'v')])
m_lumped = np.array(M.sum(axis=1)).squeeze()
X = spla.spsolve(A.tocsc(), np.sqrt(m_lumped) * Z)
fig, ax = plt.subplots()
plot = Plot()
ax = plot.contour(ax, fig, X, mesh, element, resolution=(200, 200))
plt.show()
def train(self, epochs=500, batch=16):
figure = Plot()
fix_noise = np.random.normal(0, 5, (batch, 125, 1))
for i in range(epochs):
# train discriminator
random_index = np.random.randint(0, len(self.Xtrain), size=batch)
gt_data = self.Xtrain[random_index]
gen_noise = np.random.normal(0, 5, (batch, 125, 1))
fake_data = self.G.predict(gen_noise)
x_combined_batch = np.concatenate((gt_data, fake_data))
y_combined_batch = np.concatenate((np.ones(
(batch, 1)), np.zeros((batch, 1))))
d_loss = self.D.train_on_batch(x_combined_batch, y_combined_batch)
# train generator
noise = np.random.normal(0, 5, (batch, 125, 1))
y_gen_label = np.ones((batch, 1))
g_loss = self.G_and_D.train_on_batch(noise, y_gen_label)
print(
'epoch: %d, [Discriminator :: d_loss: %f], [ Generator :: loss: %f]'
% (i, d_loss, g_loss))
if i % 100 == 0:
figure.show_dataset(self.G.predict(fix_noise))
def plotSizes(self):
"""Generates a plot of the size of a data structure without actually performing the operations themselves.
Since the operations in bm_length may alter the data structure size significantly, all operations that are
benchmarked will be simulated, and the median data structure size will be used for each plot point."""
# Convenience lambda.
op = lambda x: self.operations[x][0]
size = 0
plot = Plot()
# Do operations until bm_start.
for i in range(self.bm_start):
size += MixedSIDBenchmarkPlot._simOp(op(i))
# Now plot points until we run out of road.
current_benchmark = self.bm_start
while current_benchmark < len(self.operations):
# Very first thing: establish the next benchmark and the end of the current benchmark, since we'll need
# both of these in various places.
next_benchmark = min(len(self.operations),
current_benchmark + self.bm_interval)
end_of_benchmark = min(len(self.operations),
current_benchmark + self.bm_length)
# We're at a plot point, so gather all the data structure sizes and plot the median value.
# We'll do the first by hand, then we can loop through easily.
bm_sizes = [
size + MixedSIDBenchmarkPlot._simOp(op(current_benchmark))
]
# Now we'll loop through the rest.
# Bounds explained:
# start at current_benchmark + 1 because we just did current_benchmark.
# End (exclusive of the end) at current_benchmark + bm_length (i.e. the last item being benchmarked),
# unless that exceeds the operations list, in which case, terminate after the last operation.
for index in range(current_benchmark + 1, end_of_benchmark):
bm_sizes.append(bm_sizes[-1] +
MixedSIDBenchmarkPlot._simOp(op(index)))
index += 1
# Now we'll plot the median value
plot.plotPoint(current_benchmark, statistics.median(bm_sizes))
# Having finished the benchmark, we'll simulate operations up to the next benchmark, then loop.
# First, a bit of clean-up.
size = bm_sizes[-1]
# Now, we'll simply loop, adjusting sizes.
for index in range(end_of_benchmark, next_benchmark):
size += MixedSIDBenchmarkPlot._simOp(op(index))
# Finally, we're at the next benchmark, so update current_benchmark and loop.
current_benchmark = next_benchmark
return plot
def draw_pointer(cls):
"""Draws cursor on screen."""
#TODO: use different char for cursor when moving ship
#TODO: rename to draw_cursor ?
#TODO: read char from config file
#TODO: have tile change background color when pointer on object
Plot.draw(cls.posx,cls.posy,cls.panx,cls.pany, '░', 4)
def main():
'''The main Program runs the Data and Plot objects to read and plot the
data from the radiosonde.'''
dat = Data('dats')
pl = Plot(dat)
pl.plot()
def __init__(self):
self.root = tk.Tk()
self.model = Model()
self.view = View(self.root, self.model, self)
self.popup = Popup(self.model)
self.plot = Plot(self.model)
self.config = configparser.ConfigParser()
self.config.read("config.ini")
def end(cls, exception=''):
"""Calls method to perform necessary steps for clean exit."""
Plot.end()
if exception:
Log.add(str(exception))
Log.add('Exiting program')
Log.print()
exit()
def plot(self, x, y):
# assign two columns (x,y) for plot
nofrow, noffeature = self.data.shape
graph = Plot()
if self.__type == 'supervise' and x < (noffeature - 1) and y < (noffeature - 1):
graph.plotting(self.data[:, x], self.data[:, y], self.data[:, -1])
else:
print 'Invalid feature number'
def main(p: Plot):
p.setup()
grid_size = 8
for r in range(grid_size + 1):
for c in range(grid_size + 1):
x = c * 100 / grid_size
y = r * 100 / grid_size
draw_blob(p, vec2(x, y), 25 / grid_size)
def fillPlot(draw_data, ax, mnist):
feed = {data: mnist.test.images.reshape([-1, 28, 28])}
test_elbo, test_codes, test_samples = sess.run(draw_data, feed)
print('Epoch', epoch, 'elbo', test_elbo)
ax[epoch, 0].set_ylabel('Epoch {}'.format(epoch))
Plot.plot_codes(ax[epoch, 0], test_codes, mnist.test.labels)
Plot.plot_samples(ax[epoch, 1:], test_samples)
def main(p: Plot):
p.setup()
p.draw_bounding_box(True)
num_waves = 7
for i in range(num_waves + 1):
yoffset = 100 * i / num_waves
size = 50 / num_waves
draw_wave(p, yoffset, 0, size)
def __standard_train(self, generator, discriminator, gan, config):
epochs = config["train"]["epochs"]
save_result_interval = config["train"]["save_result_interval"]
for epoch in range(epochs):
print("Epoch %d" % epoch)
self.__train_epoch(generator, discriminator, gan)
if epoch % save_result_interval == 0:
Plot.plot_generated_images(epoch, generator, config)
def plot_device_line_curves(event=None):
# 作器件线性曲线
if device_list:
Plot.plot_line_curves('Device Line Curves', 'all',
pls.line_x_label, pls.line_y_label,
pls.line_x_min, pls.line_x_max,
pls.line_y_min, pls.line_y_max, device_list,
legend_list)
def plot_light_line_curves(event=None):
# 作光态线性曲线
if device_list:
Plot.plot_line_curves('Light Line Curves', 'light',
pls.line_x_label, pls.line_y_label,
pls.line_x_min, pls.line_x_max,
pls.line_y_min, pls.line_y_max, device_list,
legend_list)
class TestPlotBasic(TestCase):
def setUp(self):
self.plot = Plot("star wars")
def test_init(self):
self.assertTrue(self.plot.name == "star wars")
self.assertTrue(len(self.plot.entities_at_time(0)) == 0)
self.assertTrue(len(self.plot.relations_at_time(0)) == 0)
def __init__( self, serial = None, *args ) :
"""TemperaturePlot constructor it add axis titles."""
Plot.__init__( self, *args )
self.curve.setTitle( self._tr('LHe level data') )
self.setAxisTitle( Qwt.QwtPlot.xBottom, self._tr('Time (min)') )
self.setAxisTitle( Qwt.QwtPlot.yLeft, self._tr('LHe level (mm)') )
self.serial = serial
def main():
imgSrc=os.listdir(c.test)
imagenes=[]
tmp=[]
for e in imgSrc:
img=Imagen(e).imagen
rects=f.detectCara(img)
im,key=opc.dibujarPuntos(img)
tmp.append((im,e))
plt=Plot()
plt.show(tmp,5)
def plot_distances (distances):
if distances.count () <= 0:
return
d = distances. \
map (lambda x : ( x[0], x[1], x[2], x[3] ) ). \
sample (False, 0.15). \
toDF().toPandas ()
d = d.rename (columns = { "_1" : "truth",
"_2" : "doc_dist",
"_3" : "par_dist",
"_4" : "sen_dist" })
Plot.plot_distances (d)
def setAxisAutoScale(self, axis, auto=True):
if axis != Qwt.QwtPlot.yRight:
Plot.setAxisAutoScale(self, axis, auto)
else:
if not hasattr(self, '_cmap'):
self._cmap = CmapJack()
if auto:
self.set_cbar(self._cmap, None)
else:
self.set_cbar(self._cmap, (self._axis_limits[axis][0],
self._axis_limits[axis][1]))
Plot.setAxisAutoScale(self, axis, auto)
def Run(self):
try:
field = Field(self._length, self._springconst, self._deltaslope)
field.addTubes(self._count)
plot = Plot(self._length)
tubes = field.getTubes()
# Debugging code
start = []
stop =[]
for key in field.getTubes().keys():
if field.getTubes()[key].getParams()['P'][0] <= 0:
start.append(key),","
if field.getTubes()[key].getParams()['Q'][0] >= self._length:
stop.append(key)
print "Starting Tubes:",start
print "Stopping Tubes:",stop
print "------------------------------------------"
#time.sleep(10)
plot.plotField(tubes)
end = 0
while end < 1:
field.calculateIntercepts()
point_forces = field.getPointForces()
for key in field.getTubes().keys():
print key,":",field.getTubes()[key].getParams()['neighbors'].keys()
print "=================================="
traverses = 0
neighbor_dict = {}
roots = []
leaves = []
for index in tubes.keys():
neighbor_dict[index] = list()
neighbor_dict[index] = tubes[index].getParams()['neighbors'].keys()
if tubes[index].getParams()['P'][0] <= 0:
roots.append(index)
if tubes[index].getParams()['Q'][0] >= self._length:
leaves.append(index)
#print index
for index in roots:
traverses += field.traverseNeighbors(index,neighbor_dict,leaves,())
print traverses
#if end % 1 == 0:
#plot.plotField(tubes)
#field.rotateTubes(point_forces)
end += 1
except EquitubeException, e:
raise EquitubeException(e.get_message())
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
# create plots for drawing on
self.accel_plot = Plot(self, ylabel="Acceleration (g)", numy=3, xrng=10, name="ACCEL")
self.gyro_plot = Plot(self, ylabel="Angular Velocity (degrees/s)", numy=3, xrng=10, name="GYRO")
self.mag_plot = Plot(self, ylabel="Field Strength", numy=3, xrng=10, name="MAG")
self.plots = (self.accel_plot, self.gyro_plot, self.mag_plot)
self.attitude_plot = Tiltmeter(self)
self.x = 0
self.y = 0
self.width = 0
self.height = 0
self.plotnext = 0
def __init__(self, parent):
Plot.__init__(self, parent)
# the plot and its data
self._raster_data = RasterData(self)
self._plot_item = Qwt.QwtPlotSpectrogram()
self._plot_item.setData(self._raster_data)
self._plot_item.attach(self)
# enable colormap and -bar
self._cbar = self.axisWidget(Qwt.QwtPlot.yRight)
self._cbar.setColorBarEnabled(True)
self.enableAxis(Qwt.QwtPlot.yRight)
self.set_cbar()
def processPage(img):
print "Finding all possible rectangles in the page"
rects = findAllRects(img)
plotOuts = []
for rect in rects:
plot = Plot(img)
plot.corners = rect
try:
pout = processPlot(plot)
except:
pass
if pout != False:
plotOuts.append(pout)
return plotOuts
def main():
imgSrc=os.listdir(c.test)
imagenes=[]
total=0
detectadas=0
for e in imgSrc:
total+=1
im,todo=f.detectFace(Imagen(e).imagen,e)
if todo:
detectadas+=1
tmp=Imagen(im,name=e)
imagenes.append(tmp)
plt=Plot()
tmp=[]
print "total caras = "+str(total)+" todo detectado = "+str(detectadas)
for e in imagenes:
tmp.append((e.imagen,e.name))
plt.show(tmp,5)
def init_ui(self):
self.init_radio()
self.acceleration_input.setText("9.8")
self.l1_input.setText("1.0")
self.l2_input.setText("1.0")
self.m1_input.setText("1.0")
self.m2_input.setText("1.0")
self.alpha_input.setText("120.0")
self.beta_input.setText("-10.0")
self.acceleration_input.textChanged[str].connect(self.change_argument)
self.l1_input.textChanged[str].connect(self.change_argument)
self.l2_input.textChanged[str].connect(self.change_argument)
self.m1_input.textChanged[str].connect(self.change_argument)
self.m2_input.textChanged[str].connect(self.change_argument)
self.alpha_input.textChanged[str].connect(self.change_argument)
self.beta_input.textChanged[str].connect(self.change_argument)
self.update_button.clicked.connect(self.update_animation)
layout = QtGui.QVBoxLayout(self)
splitter1 = QtGui.QSplitter(Qt.Vertical)
splitter1.addWidget(self.lbl1)
splitter1.addWidget(self.acceleration_input)
splitter1.addWidget(self.lbl2)
splitter1.addWidget(self.l1_input)
splitter1.addWidget(self.lbl3)
splitter1.addWidget(self.l2_input)
splitter1.addWidget(self.lbl4)
splitter1.addWidget(self.m1_input)
splitter1.addWidget(self.lbl5)
splitter1.addWidget(self.m2_input)
splitter1.addWidget(self.lbl7)
splitter1.addWidget(self.alpha_input)
splitter1.addWidget(self.lbl8)
splitter1.addWidget(self.beta_input)
splitter1.addWidget(self.lbl6)
splitter1.addWidget(self.r0)
splitter1.addWidget(self.r1)
splitter1.addWidget(self.r2)
splitter1.addWidget(self.r3)
splitter1.addWidget(self.update_button)
# splitter1.addWidget(left)
splitter0 = QtGui.QSplitter(Qt.Horizontal)
splitter0.addWidget(splitter1)
splitter2 = QtGui.QSplitter(Qt.Vertical)
splitter2.addWidget(self.toolbar)
splitter2.addWidget(self.canvas)
splitter0.addWidget(splitter2)
layout.addWidget(splitter0)
self.setLayout(layout)
self.p = Plot(self.figure, self.data)
def __init__(self, **kwargs):
# Initialize self.Fixed (subset of self.Prognostic which will NOT be time-marched)
if 'Fixed' in kwargs: self.Fixed = kwargs.pop('Fixed')
else: self.Fixed = []
# Initialize I/O
self.Io = IO(self, **kwargs)
# Get values from restart file, if available
if 'RestartFile' in kwargs:
ParamNames = Parameters().value.keys()
FieldNames = self.Required
kwargs = self.Io.readRestart(FieldNames, ParamNames, kwargs)
# Initialize scalar parameters
self.Params = Parameters(**kwargs)
# Frequency with which compute() will be executed
if 'UpdateFreq' in kwargs:
self.UpdateFreq = kwargs.pop('UpdateFreq')
else:
self.UpdateFreq = self.Params['dt']
# Initialize State
self.State = State(self, **kwargs)
self.Grid = self.State.Grid
# Dictionary to hold increments on prognos fields
self.Inc = {}
# Initialize diagnostics
self.compute(ForcedCompute=True)
# Create output file
self.Io.createOutputFile(self.State, self.Params.value)
# Write out initial state
if not self.Io.Appending: self.write()
# Initialize plotting facilities
self.Plot = Plot()
# Initialize runtime monitor
self.Monitor = Monitor(self,**kwargs)
# Notify user of unused input quantities
self._checkUnused(kwargs)
# Set some redundant attributes (mainly for backward compatibility)
self.nlon = self.Grid['nlon']
self.nlat = self.Grid['nlat']
self.nlev = self.Grid['nlev']
try: self.o3 = self.State['o3']
except: pass
def plotGains(coordinator_id ,tx_node_id, rx_node_id, year = None, month = None, day = None):
#call the method when you want to plot the results from the file
#open file with measurements and plot results from it
#specify year, month, day if you only want to take into account gain measurements made until that date. If those are not specified, then all measurements will be taken into account.
#first get data from the file
gains = GainCalculations.getFileResults(coordinator_id, tx_node_id, rx_node_id, year=year, month=month, day=day)
#gains will have the following form : [ [gain - linear , received_power[w] , noise_power[w], transmitted_power[w], date ], [gain - linear , received_power[w] , noise_power[w], transmitted_power[w], date ], .. ]
if gains is None:
aux = tx_node_id
tx_node_id = rx_node_id
rx_node_id = aux
print "There are no values available for this combination. Trying with gain_between_tx_%d_and_rx_%d.dat? (yes or no)" %(tx_node_id, rx_node_id)
choice = raw_input("")
if choice.lower() == "no":
print "You have chosen no"
return None
elif choice.lower() == "yes":
gains = GainCalculations.getFileResults(coordinator_id, tx_node_id, rx_node_id, year=year, month=month, day=day)
if gains is None:
print "Sorry, there are no measurements for this combination at all"
return None
else:
print "Invalid input, you were supposed to enter yes or no"
return None
print "Plot gains"
#define a gain_list : [[gain_dB], [date]]
gain_list = [[],[]]
for i in gains:
date = DateTime.strptime((i[4])[0:16], "%Y-%m-%d %H:%M")
gain_list[0].append(10.00 * math.log10(i[0]) )
gain_list[1].append(date)
#plot results
Plot.plotGains(gain_list[1], gain_list[0], "Number of measurements", "Gain [dB]", "Gain between tx%d and rx%d" %(tx_node_id, rx_node_id), False)
def onclickmethod(*args):
canvasExists = True
try:
canvas = doc['brythoncanvas']
except KeyError:
canvasExists = False
v = PlotParamValidator()
if v.isValid():
pr = FunctionParser()
if pr.canParse():
if (canvasExists == True):
ctx = canvas.getContext('2d')
mgr = CanvasManager(v, pr)
mgr.drawFunction(ctx)
else:
p = Plot(v, pr)
p.run()
else:
pr.block()
else:
v.block()
def __init__(self, firn, config):
"""
"""
self.firn = firn
self.config = config
# form the physics :
self.fe = Enthalpy(firn, config)
self.fv = Velocity(firn, config)
self.fd = FullDensity(firn, config)
if config['age']['on']:
self.fa = Age(firn, config)
if config['plot']['on']:
#plt.ion()
self.plot = Plot(firn, config)
def plot_implicit(expr, *args, **kwargs):
"""A plot function to plot implicit equations / inequalities.
Arguments
=========
- ``expr`` : The equation / inequality that is to be plotted.
- ``(x, xmin, xmax)`` optional, 3-tuple denoting the range of symbol
``x``
- ``(y, ymin, ymax)`` optional, 3-tuple denoting the range of symbol
``y``
The following arguments can be passed as named parameters.
- ``adaptive``. Boolean. The default value is set to True. It has to be
set to False if you want to use a mesh grid.
- ``depth`` integer. The depth of recursion for adaptive mesh grid.
Default value is 0. Takes value in the range (0, 4).
- ``points`` integer. The number of points if adaptive mesh grid is not
used. Default value is 200.
- ``title`` string .The title for the plot.
- ``xlabel`` string. The label for the x - axis
- ``ylabel`` string. The label for the y - axis
plot_implicit, by default, uses interval arithmetic to plot functions. If
the expression cannot be plotted using interval arithmetic, it defaults to
a generating a contour using a mesh grid of fixed number of points. By
setting adaptive to False, you can force plot_implicit to use the mesh
grid. The mesh grid method can be effective when adaptive plotting using
interval arithmetic, fails to plot with small line width.
Examples:
=========
Plot expressions:
>>> from sympy import plot_implicit, cos, sin, symbols, Eq, And
>>> x, y = symbols('x y')
Without any ranges for the symbols in the expression
>>> p1 = plot_implicit(Eq(x**2 + y**2, 5))
With the range for the symbols
>>> p2 = plot_implicit(Eq(x**2 + y**2, 3),
... (x, -3, 3), (y, -3, 3))
With depth of recursion as argument.
>>> p3 = plot_implicit(Eq(x**2 + y**2, 5),
... (x, -4, 4), (y, -4, 4), depth = 2)
Using mesh grid and not using adaptive meshing.
>>> p4 = plot_implicit(Eq(x**2 + y**2, 5),
... (x, -5, 5), (y, -2, 2), adaptive=False)
Using mesh grid with number of points as input.
>>> p5 = plot_implicit(Eq(x**2 + y**2, 5),
... (x, -5, 5), (y, -2, 2),
... adaptive=False, points=400)
Plotting regions.
>>> p6 = plot_implicit(y > x**2)
Plotting Using boolean conjunctions.
>>> p7 = plot_implicit(And(y > x, y > -x))
"""
has_equality = False # Represents whether the expression contains an Equality,
#GreaterThan or LessThan
def arg_expand(bool_expr):
"""
Recursively expands the arguments of an Boolean Function
"""
for arg in bool_expr.args:
if isinstance(arg, BooleanFunction):
arg_expand(arg)
elif isinstance(arg, Relational):
arg_list.append(arg)
arg_list = []
if isinstance(expr, BooleanFunction):
arg_expand(expr)
#Check whether there is an equality in the expression provided.
if any(isinstance(e, (Equality, GreaterThan, LessThan))
for e in arg_list):
has_equality = True
elif not isinstance(expr, Relational):
expr = Eq(expr, 0)
has_equality = True
elif isinstance(expr, (Equality, GreaterThan, LessThan)):
has_equality = True
free_symbols = set(expr.free_symbols)
range_symbols = set([t[0] for t in args])
symbols = set.union(free_symbols, range_symbols)
if len(symbols) > 2:
raise NotImplementedError("Implicit plotting is not implemented for "
"more than 2 variables")
#Create default ranges if the range is not provided.
default_range = Tuple(-5, 5)
if len(args) == 2:
var_start_end_x = args[0]
var_start_end_y = args[1]
elif len(args) == 1:
if len(free_symbols) == 2:
var_start_end_x = args[0]
var_start_end_y, = (Tuple(e) + default_range
for e in (free_symbols - range_symbols))
else:
var_start_end_x, = (Tuple(e) + default_range for e in free_symbols)
#Create a random symbol
var_start_end_y = Tuple(Dummy()) + default_range
elif len(args) == 0:
if len(free_symbols) == 1:
var_start_end_x, = (Tuple(e) + default_range for e in free_symbols)
#create a random symbol
var_start_end_y = Tuple(Dummy()) + default_range
else:
var_start_end_x, var_start_end_y = (Tuple(e) + default_range
for e in free_symbols)
use_interval = kwargs.pop('adaptive', True)
nb_of_points = kwargs.pop('points', 300)
depth = kwargs.pop('depth', 0)
#Check whether the depth is greater than 4 or less than 0.
if depth > 4:
depth = 4
elif depth < 0:
depth = 0
series_argument = ImplicitSeries(expr, var_start_end_x, var_start_end_y,
has_equality, use_interval, depth,
nb_of_points)
show = kwargs.pop('show', True)
#set the x and y limits
kwargs['xlim'] = tuple(float(x) for x in var_start_end_x[1:])
kwargs['ylim'] = tuple(float(y) for y in var_start_end_y[1:])
p = Plot(series_argument, **kwargs)
if show:
p.show()
return p
# This is a hacky way of re-plotting graphs...
from plot import Plot
from bandit_algorithms import IncrementalUniformAlgorithm
from bandit_algorithms import UCBAlgorithm
from bandit_algorithms import EpsilonGreedyAlgorithm
from bandit import SBRDBandit
# load old plot
arm_params = [(1,1)] # dummy params
b = SBRDBandit(arm_params, 'custom_bandit')
num_pulls = 10001
num_trials = 1000
plot_sample_rate = 1
algorithms = [IncrementalUniformAlgorithm(b), UCBAlgorithm(b), EpsilonGreedyAlgorithm(b)]
plot = Plot(num_pulls, num_trials, [a.get_name() for a in algorithms], plot_sample_rate)
print "loading data..."
plot.load('custom_bandit_data.npz')
# new plot
print "creating plots..."
sample_rate = 1
end_index = 501
plot.plot_cumulative_regret('new_'+b.get_name(), sample_rate, end_index)
plot.plot_simple_regret('new_'+b.get_name(), sample_rate, end_index)
def process(self):
"""
Converts the source svg to data svg using job requirements.
"""
req = self.requirements
plot = Plot(material)
plot.set_graphic(self.source)
plot.set_selected_nodes(req.plot_selected_nodes)
plot.set_margin(req.plot_margin_top,req.plot_margin_right,req.plot_margin_bottom,req.plot_margin_left)
plot.set_scale(req.scale_x*(invert_axis_x and 1 or -1),req.scale_y*(invert_axis_y and 1 or -1))
plot.set_copy_spacing(req.copy_spacing_x,req.copy_spacing_y)
plot.set_copies(req.copies)
plot.create()
self.data = self.source
def setUp(self):
self.plot = Plot("star wars")
self.plot.add_entity("vader")
self.plot.add_entity("luke")
self.plot.add_entity("emperor")
def create_record(self, root):
self.frame_record = Frame(root)
self.frame_record.pack(side=TOP, fill=BOTH, pady=(0,5))
self.frame_record1 = Frame(self.frame_record)
self.frame_record1.pack(side=TOP, fill=BOTH, pady=(0,10))
self.frame_record2 = Frame(self.frame_record) #12 between 1 and 2
self.frame_record2.pack(side=TOP, fill=BOTH, pady=(0,10))
self.frame_record3 = Frame(self.frame_record)
self.frame_record3.pack(side=BOTTOM, fill=NONE)
l_caption = Label(self.frame_record1, text="Record sound:")
l_caption.pack(side=LEFT)
b_help = Button(self.frame_record1, text="info", width=3, height=1)
b_help.pack(side=RIGHT)
self.l_selected_file_name_var = StringVar()
self.l_selected_file_name_var.set("[Selected file name:] none")
l_selected_file_name = Label(self.frame_record2, textvariable = self.l_selected_file_name_var, width = 30, height = 1, anchor = 'w')
l_selected_file_name.pack(side = LEFT)
self.b_waveform = Button(self.frame_record2, text = "WaveForm", width = 8, height = 1, command = lambda : Plot.plot_audio(self.full_file_path, "raw", self.radioIntVar))
self.b_waveform.pack(side = RIGHT)
self.b_waveform['state'] = 'disabled'
self.b_fft = Button(self.frame_record2, text = "FFT", width = 8, height = 1, command = lambda : Plot.plot_audio(self.full_file_path, "fft", self.radioIntVar))
self.b_fft.pack(side = RIGHT, padx = 3)
self.b_fft['state'] = 'disabled'
self.b_spectrogram = Button(self.frame_record2, text = "Spectrogram", width = 10, height = 1, command = lambda : Plot.plot_audio(self.full_file_path, "spectrogram", self.radioIntVar))
self.b_spectrogram.pack(side = RIGHT, padx = 3)
self.b_spectrogram['state'] = 'disabled'
self.radioIntVar = IntVar()
R1 = Radiobutton(self.frame_record2, text="2D", variable=self.radioIntVar, value=1, command= lambda: self.handleRadioSel())
R1.pack( side = RIGHT)
self.radioIntVar.set(1) # init 2D as default
R2 = Radiobutton(self.frame_record2, text="3D", variable=self.radioIntVar, value=2, command= lambda: self.handleRadioSel())
R2.pack( side = RIGHT)
global b_start
global l_time
b_start = Button(self.frame_record3, text='Record', width=12, height=2, command=lambda: self.main_button_click())
b_start.pack(pady=10, padx=15, side=LEFT)
self.l_timer_var.set('00:00')
l_time = Label(self.frame_record3, height=1, width=5, state='disabled', bg='white', textvariable=self.l_timer_var, foreground='black')
l_time.pack(pady=10, padx=(10,0), side=LEFT)
l_status = Label(self.frame_record3, text="...recording", foreground='red')
l_status.pack(pady=10, padx=(5,10), side=LEFT)
b_reset = Button(self.frame_record3, text='Reset', padx=2, command=self.reset_button_click())
b_reset.pack(pady=10, padx=20, side=LEFT)
def getX(t): return f(t)*math.cos(t*t_size)/x_size def getY(t): return f(t)*math.sin(t*t_size)/y_size x_values = [ getX(t) for t in range(int(t_min/t_size),int(t_max/t_size)) ] y_values = [ getY(t) for t in range(int(t_min/t_size),int(t_max/t_size)) ] x_max = max(x_max, max(x_values)) x_min = min(x_min, min(x_values)) y_max = max(y_max, max(y_values)) y_min = min(y_min, min(y_values)) x_max = int(x_max + 1) + 1 x_min = int(x_min - 1) - 1 y_max = int(y_max + 1) + 1 y_min = int(y_min - 1) - 1 plot = Plot(x_min, x_max, x_size, y_min, y_max, y_size, t_min, t_max, t_size) #Plot axes if plot_axes: plot.plot_axes #Fix descrepancies betwen functions and colors if len(functions) < len(colors): colors = colors[:len(functions)] if len(functions) > len(colors): colors += [default] * (len(functions)-len(colors)) #Plot functions for (function, color) in zip(functions,colors): if polar: plot.plot_polar(function, color)
def main():
figure = Plot.new_figure(figsize=(5,10))
fit_ids = ['a', 'b', 'c', 'd']
def data_path(fit_id):
if fit_id == 'c':
fit_type = 'parallel'
else:
fit_type = 'difference'
return os.path.join('json', 'fig_4' + fit_id + '_' + fit_type + '.json')
fits = [ Fit(data_path(fig)) for fig in fit_ids ]
for fit in fits[0:3]:
fit.maps['value_transforms']['Ω_C'] = lambda x: '%.2E' % round(x, 2)
for i in (0, 1): fits[i].meta['contact_type'] = 'tunneling'
fits[2].meta['contact_type'] = 'pinhole'
fits[3].meta['contact_type'] = 'transparent'
plots = []
for idx, fit in enumerate(fits):
n, m = 4, 1
options = {}
if idx != 0: options['sharex'] = plots[idx - 1].plt
plot = Plot(fit, figure.add_subplot(n, m, (m * idx + 1), **options))
plot.id = fit_ids[idx]
plots.append(plot)
for idx, plot in enumerate(plots):
plot.plot_data()
plot.plot_fit()
if idx == 2:
plot.add_ylabel(False)
else:
plot.add_ylabel(True)
plot.add_parameter_overlay()
plots[-1].add_xlabel()
matplotlib.pyplot.setp([ p.plt.get_xticklabels() for p in plots[0:3] ], visible=False)
figure.savefig(os.path.join('build', 'plot_fits.eps'), transparent=True)
plots[0].fit.save_info('build/plot_fits_info.tex', 'plotFitsInfo')
Plot.close_figure(figure)
class TransientSolver(object):
"""
"""
def __init__(self, firn, config):
"""
"""
self.firn = firn
self.config = config
# form the physics :
self.fe = Enthalpy(firn, config)
self.fv = Velocity(firn, config)
self.fd = FullDensity(firn, config)
if config['age']['on']:
self.fa = Age(firn, config)
if config['plot']['on']:
#plt.ion()
self.plot = Plot(firn, config)
#plt.show()
def solve(self):
"""
"""
s = '::: solving TransientSolver :::'
text = colored(s, 'blue')
print text
firn = self.firn
config = self.config
fe = self.fe
fv = self.fv
fd = self.fd
if config['age']['on']:
fa = self.fa
t0 = config['t_start']
tm = config['t_mid']
tf = config['t_end']
dt = config['time_step']
dt_list = config['dt_list']
if dt_list != None:
numt1 = (tm-t0)/dt_list[0] + 1 # number of time steps
numt2 = (tf-tm)/dt_list[1] + 1 # number of time steps
times1 = linspace(t0,tm,numt1) # array of times to evaluate in seconds
times2 = linspace(tm,tf,numt2) # array of times to evaluate in seconds
dt1 = dt_list[0] * ones(len(times1))
dt2 = dt_list[1] * ones(len(times2))
times = hstack((times1,times2))
dts = hstack((dt1, dt2))
else:
numt = (tf-t0)/dt + 1 # number of time steps
times = linspace(t0,tf,numt) # array of times to evaluate in seconds
dts = dt * ones(len(times))
firn.t = t0
self.times = times
self.dts = dts
for t,dt in zip(times[1:], dts[1:]):
# update timestep :
firn.dt = dt
firn.dt_v.assign(dt)
# update boundary conditions :
firn.update_Hbc()
firn.update_rhoBc()
firn.update_wBc()
#firn.update_omegaBc()
# newton's iterative method :
fe.solve()
fd.solve()
fv.solve()
if config['age']['on']:
fa.solve()
# update firn object :
firn.update_vars(t)
firn.update_height_history()
if config['free_surface']['on']:
if dt_list != None:
if t > tm+dt:
firn.update_height()
else:
firn.update_height()
# update model parameters :
if t != times[-1]:
firn.H_1.assign(firn.H)
firn.U_1.assign(firn.U)
firn.omega_1.assign(firn.omega)
firn.w_1.assign(firn.w)
firn.a_1.assign(firn.a)
firn.m_1.assign(firn.m)
# update the plotting parameters :
if config['plot']['on']:
self.plot.update_plot()
#plt.draw()
s = '>>> Time: %i yr <<<'
text = colored(s, 'red', attrs=['bold'])
print text % (t / firn.spy)
if config['plot']['on']:
pass
def main():
figure = Plot.new_figure(figsize=(5,10))
data_path = lambda x: os.path.join('json', 'fig_4d_difference_' + x + '_lifetime.json')
fits = [ Fit(data_path(fig)) for fig in ['large', 'larger'] ]
for fit in fits:
fit.maps['value_transforms']['τ'] = lambda x: '%.2E' % round(x, 2)
fit.meta['contact_type'] = 'transparent'
plots = []
for idx, fit in enumerate(fits):
n, m = 2, 1
options = {}
if idx != 0: options['sharex'] = plots[idx - 1].plt
plot = Plot(fit, figure.add_subplot(n, m, (m * idx + 1), **options))
plot.id = 'd.' + str(idx + 1)
plots.append(plot)
for plot in plots:
plot.plot_data()
plot.plot_fit()
plot.add_ylabel()
plot.add_parameter_overlay()
plots[-1].add_xlabel()
matplotlib.pyplot.setp(plots[0].plt.get_xticklabels(), visible=False)
figure.savefig(os.path.join('build', 'plot_fits_large_lifetime.eps'), transparent=True)
plots[0].fit.save_info('build/plot_fits_large_lifetime_info.tex', 'plotFitsLargeLifetimeInfo')
Plot.close_figure(figure)
epoch_list.append(range(num_learning_epochs))
avg_reward_list.append([])
for epoch in epoch_list[e]:
for trial in range(num_learning_trials):
qlearner.run_learning_trial()
avg_reward = 0
for trial in range(num_simulation_trials):
(total_reward, state_seq, action_seq) = qlearner.run_simulation_trial()
avg_reward += total_reward
avg_reward = 1.*avg_reward/num_simulation_trials
avg_reward_list[e].append(avg_reward)
print "MDP1 epoch {0}: {1}".format(epoch, avg_reward)
Plot.plot_multiple(epoch_list, avg_reward_list, [str(e) for e in epsilon_list], 'epsilon', 'MDP1 Learning: Epsilon', 'mdp1_epsilon_plot.png')
print
### PART III: MDP 1 alpha experiments
epsilon = 0.25
learning_rate_list = [0.001, 0.01, 0.1, 1.0]
epoch_list = []
avg_reward_list = []
for a, learning_rate in enumerate(learning_rate_list):
print "Alpha: {0}".format(learning_rate)
qlearner = QLearner(mdp1, initial_state1, epsilon=epsilon, alpha=learning_rate)
epoch_list.append(range(num_learning_epochs))
class Component:
"""
Abstract class defining methods inherited by all CliMT components.
"""
def __init__(self, **kwargs):
# Initialize self.Fixed (subset of self.Prognostic which will NOT be time-marched)
if 'Fixed' in kwargs: self.Fixed = kwargs.pop('Fixed')
else: self.Fixed = []
# Initialize I/O
self.Io = IO(self, **kwargs)
# Get values from restart file, if available
if 'RestartFile' in kwargs:
ParamNames = Parameters().value.keys()
FieldNames = self.Required
kwargs = self.Io.readRestart(FieldNames, ParamNames, kwargs)
# Initialize scalar parameters
self.Params = Parameters(**kwargs)
# Frequency with which compute() will be executed
if 'UpdateFreq' in kwargs:
self.UpdateFreq = kwargs.pop('UpdateFreq')
else:
self.UpdateFreq = self.Params['dt']
# Initialize State
self.State = State(self, **kwargs)
self.Grid = self.State.Grid
# Dictionary to hold increments on prognos fields
self.Inc = {}
# Initialize diagnostics
self.compute(ForcedCompute=True)
# Create output file
self.Io.createOutputFile(self.State, self.Params.value)
# Write out initial state
if not self.Io.Appending: self.write()
# Initialize plotting facilities
self.Plot = Plot()
# Initialize runtime monitor
self.Monitor = Monitor(self,**kwargs)
# Notify user of unused input quantities
self._checkUnused(kwargs)
# Set some redundant attributes (mainly for backward compatibility)
self.nlon = self.Grid['nlon']
self.nlat = self.Grid['nlat']
self.nlev = self.Grid['nlev']
try: self.o3 = self.State['o3']
except: pass
def compute(self, ForcedCompute=False):
"""
Updates component's diagnostics and increments
"""
# See if it's time for an update; if not, skip rest
if not ForcedCompute:
freq = self.UpdateFreq
time = self.State.ElapsedTime
if int(time/freq) == int((time-self['dt'])/freq): return
# Set up union of State, Grid and Params
Input = {}
for dic in [self.State.Now, self.Grid.value, self.Params.value]: Input.update(dic)
Input['UpdateFreq'] = self.UpdateFreq
# For implicit time stepping, replace current time level with previous (old) time level
if self.SteppingScheme == 'implicit': Input.update(self.State.Old)
# For semimplicit time stepping, append previous (old) time level to Input dict
if self.SteppingScheme == 'semi-implicit':
for key in self.Prognostic: Input[key+'old'] = self.State.Old[key]
# List of arguments to be passed to extension
args = [ Input[key] for key in self.ToExtension ]
# Call extension and build dictionary of ouputs
OutputValues = self.driver(*args)
if len(self.FromExtension) == 1: Output = {self.FromExtension[0]: OutputValues}
else: Output = dict( zip(self.FromExtension, OutputValues ) )
# Extract increments from Output
for key in self.Prognostic:
self.Inc[key] = Output.pop(key+'inc')
# Remove increments of Fixed variables
for key in self.Fixed:
if key in self.Inc: self.Inc.pop(key)
if key in Output: Output.pop(key)
# Update State
self.State.update(Output)
for key in Output: exec('self.'+key+'=Output[key]')
# No further need for input dictionary
del(Input)
def step(self, RunLength=1, Inc={}):
"""
Advances component one timestep and writes to output file if necessary.
Inc is an externally-specified set of increments added to the internally-computed
increments at each time step.
"""
# If RunLength is integer, interpret as number of time steps
if type(RunLength) is type(1):
NSteps = RunLength
# If RunLength is float, interpret as length of run in seconds
if type(RunLength) is type(1.):
NSteps = int(RunLength/self['dt'])
for i in range(NSteps):
# Add external increments
for key in Inc.keys():
if key in self.Inc.keys():
self.Inc[key] += Inc[key]
else:
self.Inc[key] = Inc[key]
# Avance prognostics 1 time step
self.State.advance(self)
# Bring diagnostics and increments up to date
self.compute()
# Bring calendar up to date
self['calday'] += self['dt']/self['lod']
if self['calday'] > self['daysperyear']:
self['calday'] -= self['daysperyear']
# Write to file, if it's time to
dt = self.Params['dt']
time = self.State.ElapsedTime
freq = self.Io.OutputFreq
if int(time/freq) != int((time-dt)/freq): self.write()
# Refresh monitor, if it's time to
if self.Monitor.Monitoring:
freq = self.Monitor.MonitorFreq
if int(time/freq) != int((time-dt)/freq): self.Monitor.refresh(self)
def __call__(self,**kwargs):
"""
# Provides a simple interface to extension, useful e.g. for diagnostics.
"""
# Re-initialize parameters, grid and state
self.Params = Parameters(**kwargs)
self.State = State(self, **kwargs)
self.Grid = self.State.Grid
# Bring diagnostics up to date
self.compute()
def write(self):
"""
Invokes write method of IO instance to write out current State
"""
self.Io.writeOutput(self.Params, self.State)
def open(self, OutputFileName='CliMT.nc'):
"""
"""
if self.Io.OutputFileName == OutputFileName:
print '\n +++ ClimT.Io: File %s is currently open for output'% OutputFileName
return
else:
print 'Opening %s for output'% OutputFileName
self.Io.OutputFileName = OutputFileName
self.Io.DoingOutput = True
self.Io.Appending = False
self.Io.OutputTimeIndex = 0
self.Io.createOutputFile(self.State, self.Params)
def plot(self, *FieldKeys):
self.Plot(self, *FieldKeys)
def setFigure(self, FigureNumber=None):
self.Plot.setFigure(FigureNumber)
def closeFigure(self, FigureNumber=None):
self.Plot.closeFigure(FigureNumber)
def usage(self):
print self.__doc__
def report(self):
print 'CliMT component:\n %s' % self.Name
keys = self.State.keys()
keys1 = []
for i in range(len(keys)):
if keys[i] in self.Prognostic: keys1.append('%12s %s' % (keys[i],'(prognostic)'))
for i in range(len(keys)):
if keys[i] in self.Diagnostic: keys1.append('%12s %s' % (keys[i],'(diagnostic)'))
for i in range(len(keys)):
if keys[i] not in self.Prognostic and keys[i] not in self.Diagnostic:
keys1.append('%12s %s' % (keys[i],'(Fixed)'))
print 'State variables:\n %s' % '\n '.join( keys1 )
def _checkUnused(self,kwargs):
'''
Notify of unused input quantities.
'''
unused = []
io_keys = ['RestartFile','OutputFile','OutputFreq','OutputFields','ElapsedTime']
monitor_keys = ['MonitorFields','MonitorFreq']
for key in kwargs:
if key not in self.Params \
and key not in self.Grid \
and key not in KnownFields \
and key not in io_keys \
and key not in monitor_keys:
unused.append(key)
if len(unused) > 0:
if len(unused) == 1: suffix = 'y'
else : suffix = 'ies'
print '\n ++++ CliMT.'+self.Name+'.initialize: WARNING: Input quantit%s %s not used.\n' \
% (suffix,str(list(unused)))
def _getShape3D(self, **kwargs):
'''
Returns shape of 3D arrays to be passed to extension.
'''
return (self._getAxisLength('lev', **kwargs),
self._getAxisLength('lat', **kwargs),
self._getAxisLength('lon', **kwargs))
def _getAxisLength(self, AxisName, **kwargs):
'''
Returns length of axis.
'''
# Check input
assert AxisName in ['lev','lat','lon'], \
'\n\n ++++ CliMT.%s: Axis name must be one of "lon", "lat", "lev"' % self.Name
# See if axis was supplied in input
n = None
if AxisName in kwargs:
if ndim(array(kwargs[AxisName])) == 0:
n = 1
else:
assert ndim(array(kwargs[AxisName])) == 1, \
'\n\n ++++ CliMT.%s.init: input %s must be rank 1' % (self.Name,AxisName)
n = len(array(kwargs[AxisName]))
# If not, see if some field was supplied
else:
for key in kwargs:
if key in KnownFields:
if KnownFields[key][2] == '2D' and AxisName != 'lev':
i = ['lat','lon'].index(AxisName)
try: n = array(kwargs[key]).shape[i]
except: n = 1
elif KnownFields[key][2] == '3D':
i = ['lev','lat','lon'].index(AxisName)
try: n = array(kwargs[key]).shape[i]
except: n = 1
# Last resort: get dimensions set in Makefile
if n is None: exec('n = get_n%s()' % AxisName)
# Check if extension enforces axis dimension, ensure consistency
try:
exec('n_ext = self.Extension.get_n%s()' % AxisName)
except:
n_ext = n
assert n_ext == n, \
'\n\n ++++ CliMT.%s.init: input %s has dimension %i but extension requires %i'% \
(self.Name, AxisName, n, n_ext)
return n
# Returns requested quantity from Params, Grid or State
def __getitem__(self, key):
for obj in [self.Params, self.Grid, self.State]:
if key in obj:
if type(obj[key]) is type('string'): return obj[key]
else: return squeeze(obj[key])
raise IndexError,'\n\n CliMT.State: %s not in Params, Grid or State' % str(key)
# Sets requested quantity in Params, Grid or State
def __setitem__(self, key, value):
if key in self.Params:
self.Params[key] = value
return
if key in self.Grid:
self.Grid[key] = value
return
elif key in self.State and KnownFields[key][2] == '2D':
self.State[key]=reshape(value,self.Grid.Shape3D[1:3])
return
elif key in self.State and KnownFields[key][2] == '3D':
self.State[key]=reshape(value,self.Grid.Shape3D)
return
else: raise IndexError,'\n\n CliMT.State: %s not in Params, Grid or State' % str(key)
