def createToken(self, parent, info, page):
# Build the JSON data for plotting
data = self.settings['data']
if data is None:
raise common.exceptions.MooseDocsException("The 'data' setting is required.")
data = eval(data)
# Use Postprocessor file for data
filename = self.settings['filename']
if filename is not None:
filename = common.check_filenames(filename)
reader = mooseutils.PostprocessorReader(filename)
for i, line in enumerate(data):
data[i]['x'] = reader[line['x']].tolist()
data[i]['y'] = reader[line['y']].tolist()
flt = floats.create_float(parent, self.extension, self.reader, page, self.settings,
bottom=True)
scatter = ScatterToken(flt, data=data, layout=eval(self.settings['layout']))
if flt is parent:
scatter.attributes.update(**self.attributes)
return parent
def testRepr(self):
"""
Test the 'repr' method for writing scripts is working.
"""
# Load the files
data = mooseutils.PostprocessorReader(self._filename)
self.assertTrue(data)
# Get script text
output, imports = data.repr()
# Append testing content
output += ["print('SHAPE:', data.data.shape)"]
output += ["print('VALUE:', data['snow_depth_set_1'][10])"]
# Write the test script
script = '{}_repr.py'.format(self.__class__.__name__)
with open(script, 'w') as fid:
fid.write('\n'.join(imports))
fid.write('\n'.join(output))
# Run script
self.assertTrue(os.path.exists(script))
out = subprocess.check_output(['python', script])
# Test for output
self.assertIn('SHAPE: (742, 8)', out.decode())
self.assertIn('VALUE: 51', out.decode())
# Remove the script
os.remove(script)
def createToken(self, parent, info, page):
# Build the JSON data for plotting
data = self.settings['data']
if data is None:
raise common.exceptions.MooseDocsException(
"The 'data' setting is required.")
data = eval(data)
# Use Postprocessor file for data
filename = self.settings['filename']
if filename is not None:
filename = common.check_filenames(filename)
reader = mooseutils.PostprocessorReader(filename)
for i, line in enumerate(data):
data[i]['x'] = reader(line['x']).tolist()
data[i]['y'] = reader(line['y']).tolist()
flt = floats.create_float(parent, self.extension, self.reader, page,
self.settings)
ScatterToken(flt, data=data, layout=eval(self.settings['layout']))
if flt.children[0].name == 'Caption':
cap = flt.children[0]
cap.parent = None
cap.parent = flt
return parent
def testCallWarning(self):
"""
Test that a warning appears if 'time' is used.
"""
data = mooseutils.PostprocessorReader(self._filename)
data(self._keys[0], time=76)
output = sys.stdout.getvalue()
self.assertIn(" Supplying a time argument is not supported in the PostprocessorReader", output)
def testVariables(self):
"""
Test the the variables names are being read.
"""
data = mooseutils.PostprocessorReader(self._filename)
self.assertTrue(data)
self.assertIn('time', data.variables())
for k in self._keys:
self.assertIn(k, data.variables())
def setUp(self):
"""
Creates the GUI containing the ArtistGroupWidget and the matplotlib figure axes.
"""
data = [PostprocessorDataWidget(mooseutils.PostprocessorReader('../input/white_elephant_jan_2016.csv'))]
self._widget, self._window = main()
self._widget.FigurePlugin.setFixedSize(QtCore.QSize(500, 500))
self._widget.initialize(data)
def setUp(self):
"""
Creates the GUI.
"""
# Read some data
filename = '../input/white_elephant_jan_2016.csv'
self._reader = mooseutils.PostprocessorReader(filename)
# Create the widget with FigurePlugin only
self._widget = main()
self._window = self._widget.currentWidget().FigurePlugin
def setUp(self):
"""
Creates the GUI containing the ArtistGroupWidget and the matplotlib figure axes.
"""
import matplotlib
matplotlib.rcParams["figure.figsize"] = (5., 5.)
matplotlib.rcParams["figure.dpi"] = (100)
data = [PostprocessorDataWidget(mooseutils.PostprocessorReader('../input/white_elephant_jan_2016.csv'))]
self._widget, self._window = main()
self._widget.FigurePlugin.setFixedSize(QtCore.QSize(500, 500))
self._widget.call('onSetData', data)
def create(self, timer=False):
"""
Creates the widgets for testing.
This is done here rather than in setUp to allow for testing of delayed loading.
"""
self._reader = mooseutils.PostprocessorReader(self._filename)
self._data = PostprocessorDataWidget(self._reader, timer=timer)
# Build the widgets
self._control, self._widget, self._window = main(self._data)
self._widget.currentWidget().FigurePlugin.setFixedSize(QtCore.QSize(625, 625))
def testCall(self):
"""
Test that operator() method is working.
"""
data = mooseutils.PostprocessorReader(self._filename)
# Single key
x = data[self._keys[0]]
self.assertEqual(x.loc[10], 2.12)
# Multiple keys
x = data[self._keys]
self.assertEqual(x.loc[10][self._keys[0]], 2.12)
self.assertEqual(x.loc[10][self._keys[1]], 51.00)
def testBasic(self):
"""
Test that if a file exists it is loaded w/o error.
"""
# Test basic read
data = mooseutils.PostprocessorReader(self._filename)
self.assertEqual(self._filename, data.filename)
self.assertTrue(data)
# Key Testing
for k in self._keys:
self.assertTrue(k in data)
# Check data
x = data[self._keys]
self.assertEqual(x.loc[10][self._keys[0]], 2.12)
self.assertEqual(x.loc[10][self._keys[1]], 51.00)
def testNewDataReload(self):
"""
Test that new data is loaded automatically.
"""
# Copy partial data
tmp = "{}.csv".format(self.__class__.__name__)
shutil.copyfile(self._partial, tmp)
# Load data and inspect
data = mooseutils.PostprocessorReader(tmp)
self.assertEqual(data.data.shape, (287, 8))
# Wait and copy more data
time.sleep(1)
shutil.copyfile(self._filename, tmp)
data.update()
self.assertEqual(data.data.shape, (742, 8))
os.remove(tmp)
"""
python TestPostprocessorPluginManager_test_script.py
"""
import matplotlib.pyplot as plt
import mooseutils
# Create Figure and Axes
figure = plt.figure(facecolor='white')
axes0 = figure.add_subplot(111)
axes1 = axes0.twinx()
# Read Postprocessor Data
data = mooseutils.PostprocessorReader('../input/white_elephant_jan_2016.csv')
x = data('time')
y = data('air_temp_set_1')
axes1.plot(x, y, marker='', linewidth=5.0, color=[0.2, 0.627, 0.173, 1.0], markersize=1, linestyle=u'--', label='air_temp_set_1')
# Axes Settings
axes1.legend(loc='lower right')
axes0.set_title('Snow Data')
# y1-axis Settings
axes1.set_ylabel('Air Temperature [C]')
axes1.set_ylim([0.0, 35.939999999999998])
# Show figure and write pdf
plt.show()
figure.savefig("output.pdf")
layout.addWidget(control)
control.axesModified.connect(window.onAxesModified)
def axis_label():
"""
A labeling function for setting axis labels.
"""
x, y, y2 = control.getAxisLabels()
control._axes[0].set_xlabel(x)
control._axes[0].set_ylabel('; '.join(y))
control._axes[1].set_ylabel('; '.join(y2))
control.variablesChanged.connect(axis_label)
widget.show()
return control, widget, window
if __name__ == '__main__':
import sys
import mooseutils
from ..PostprocessorDataWidget import PostprocessorDataWidget
app = QtWidgets.QApplication(sys.argv)
filename = '../../../tests/input/white_elephant_jan_2016.csv'
reader = mooseutils.PostprocessorReader(filename)
data = PostprocessorDataWidget(reader)
control, widget, window = main(data)
sys.exit(app.exec_())
def createToken(self, parent, info, page, settings):
# Build the JSON data for plotting
data = settings['data']
layout = settings['layout']
# Use Postprocessor file for data
filename = settings['filename']
if filename is None:
raise common.exceptions.MooseDocsException(
"The 'filename' setting is required.")
filename = common.check_filenames(filename)
reader = mooseutils.PostprocessorReader(filename)
show_legend = True
if data is None:
vectors = reader.variables()
if not settings['vectors'] is None:
vectors = settings['vectors'].split(' ')
names = []
if settings['names'] is not None:
names = settings['names'].split(' ')
if not len(vectors) == len(names):
raise common.exceptions.MooseDocsException(
"Number of names must equal number of vectors.")
else:
names = vectors
data = [dict() for i in range(len(vectors))]
for i in range(len(vectors)):
if not vectors[i] in reader.variables():
string = "The vector " + vectors[
i] + " is not in " + filename
raise common.exceptions.MooseDocsException(string)
data[i]['type'] = 'histogram'
data[i]['x'] = reader[vectors[i]].tolist()
data[i]['xbins'] = settings['bins']
data[i]['opacity'] = settings['alpha']
if settings['probability']:
data[i]['histnorm'] = 'probability'
if len(names) > 0:
data[i]['name'] = names[i]
else:
data = eval(data)
for i, line in enumerate(data):
data[i]['x'] = reader[line['x']].tolist()
data[i]['type'] = 'histogram'
if layout is None:
xaxis = dict()
xaxis['title'] = settings['xlabel']
yaxis = dict()
yaxis['title'] = settings['ylabel']
layout = dict()
layout['xaxis'] = xaxis
layout['yaxis'] = yaxis
layout['showlegend'] = str(settings['legend'])
layout['title'] = settings['title']
else:
layout = eval(layout)
flt = floats.create_float(parent,
self.extension,
self.reader,
page,
settings,
bottom=True)
histogram = HistogramToken(flt, data=data, layout=layout)
if flt is parent:
histogram.attributes.update(**self.attributes(settings))
return parent
parser.add_argument('--alpha', default=0.75, type=float, help="Set the bar chart opacity alpha setting.")
parser.add_argument('--xlabel', default='Value', type=str, help="The X-axis label.")
parser.add_argument('--ylabel', default='Probability', type=str, help="The Y-axis label.")
parser.add_argument('--title', default=None, type=str, help="Title of figure.")
parser.add_argument('--output', default=None, type=str, help="File name to save figure")
return parser.parse_args()
if __name__ == '__main__':
# Command-line options
opt = command_line_options()
# Read data
data = []
for file in opt.filenames:
data.append(mooseutils.PostprocessorReader(os.path.abspath(file)))
# Set the default vector names
vectors = []
for dt in data:
if not opt.vectors:
vectors.extend(dt.variables())
else:
vectors.extend(opt.vectors)
# Plot the results
fig_data = [dict() for i in range(len(vectors))]
k = -1
for i in range(len(data)):
for j in range(len(data[i].variables())):
k += 1
nargs='+',
type=str,
help="Names to show on axes.")
parser.add_argument('--output',
default=None,
type=str,
help="File name to save figure")
return parser.parse_args()
if __name__ == '__main__':
# Command-line options
opt = command_line_options()
data = mooseutils.PostprocessorReader(opt.filename)
if not 'i_1' in data:
raise Exception('File must contain first order indices')
if not 'i_2' in data:
raise Exception('File must contain second order indices')
if opt.vector is None:
opt.vector = data.variables()[0]
ndim = max(data['i_1']) + 1
st = 0
if 'i_T' in data:
st += ndim
sobol = np.zeros((ndim, ndim))
for n in range(st, len(data[opt.vector])):
i = data['i_1'][n]
import matplotlib.pyplot as plt
import mooseutils
# Create Figure and Axes
figure = plt.figure(facecolor='white')
axes0 = figure.add_subplot(111)
# Read Postprocessor Data
data = mooseutils.PostprocessorReader('/home/alexander/Development/moose_projects/apollo/problems/3d_sc_trel_out.csv')
x = data['H_applied']
y = data['magnetization_domain']
a = 0.5
b = 0.5
d = 0.4
V = 2*a*2*b*d
def m(rmax, jc, h):
delta = h/(jc*rmax)
m = -jc*rmax*(delta-delta**2 +(delta**3)/3.0 )
return m
RMAX = 1.0
JC = 1.0
H = x
jc = 2.0
m_virgin = m(RMAX, JC, H)
x_positive = x[x>0]
m_virgin_positive = m(RMAX, JC, x_positive)
#print(delta)
m_down = m(RMAX, JC, 1)-2*m(RMAX, JC,(1-H)/2)
camera.SetPosition(250.0000, 250.0000, 984.7906)
camera.SetFocalPoint(250.0000, 250.0000, 0.0000)
reader = chigger.exodus.ExodusReader('refine_out.e', timestep=0)
result = chigger.exodus.ExodusResult(reader,
variable='c',
viewport=[0, 0, 0.5, 1],
opacity=1,
edges=True,
edge_color=[1, 1, 1],
range=[0, 1],
camera=camera)
cbar = chigger.exodus.ExodusColorBar(result, font_size=18)
result.update()
data = mooseutils.PostprocessorReader('refine_out.csv')
y1 = data['dt'].tolist()
y2 = data['dtnuc'].tolist()
x = range(len(y1))
line1 = chigger.graphs.Line(x, y1, width=2, color=[1, 1, 1], label='actual')
line2 = chigger.graphs.Line(x, y2, width=2, color=[0, 0.5, 0], label='maximum')
tracer = chigger.graphs.Line(color=[1, 0, 0], xtracer=True)
graph = chigger.graphs.Graph(line2, line1, tracer, viewport=[0.5, 0, 1, 1])
graph.setOptions('xaxis', title='Step', font_size=18)
graph.setOptions('yaxis', lim=[0, 300], title='timestep', font_size=18)
graph.setOptions('legend', point=[0.15, 0.9], label_font_size=18)
moose = ImageAnnotation(filename='moose.png',
position=[0.99, 0.975],
opacity=0.5,
parser.add_argument('--title', default=None, type=str, help="Title of figure.")
parser.add_argument('--output', default=None, type=str, help="File name to save figure")
return parser.parse_args()
if __name__ == '__main__':
# Command-line options
opt = command_line_options()
# Read data
data = dict()
for file in opt.filenames:
for fname in sorted(glob.glob(file)):
if '.csv' in fname:
vdata = mooseutils.PostprocessorReader(fname)
vars = vdata.variables()
ind = dict()
for vec in vars:
obj_val = vec.split(':')
if obj_val[-1] == 'converged':
ind[obj_val[0]] = np.where(vdata[vec])[0]
for vec in vars:
obj_val = vec.split(':')
if obj_val[-1] == 'converged':
continue
val = vdata[vec][ind[obj_val[0]]].tolist() if obj_val[0] in ind else vdata[vec].tolist()
if vec in data:
data[vec].extend(val)
else:
data[vec] = val
import matplotlib.pyplot as plt
import mooseutils
from matplotlib import rc
rc('font', **{'family': 'sans-serif', 'sans-serif': ['Helvetica']})
## for Palatino and other serif fonts use:
#rc('font',**{'family':'serif','serif':['Palatino']})
rc('text', usetex=True)
# Create Figure and Axes
figure = plt.figure(facecolor='white', figsize=(12, 6))
axes0 = figure.add_subplot(111)
# Read Postprocessor Data
data = mooseutils.PostprocessorReader(
'/home/alexander/Documents/Verification/hammerhead/bean_cylinder/3d_cyl_mag_out.csv'
)
x = data['H_applied']
y = data['magnetization_domain']
a = 0.5
b = 0.5
d = 0.4
V = 2 * a * 2 * b * d
def m(rmax, jc, h):
delta = h / (jc * rmax)
m = -jc * rmax * (delta - delta**2 + (delta**3) / 3.0)
return m
surr_cmd = opt.mpicmd + ' -n ' + str(opt.np) + ' ../../../../stochastic_tools-opt -i surr.i --allow-test-objects'
fom_cmd = opt.mpicmd + ' -n ' + str(opt.np) + ' ../../../../stochastic_tools-opt -i full_order.i --allow-test-objects'
no_pod_modes = [1, 2, 4, 8, 16, 32]
if(opt.runtrainer):
print('Obtaining Full-Order solutions for training (might be slow)')
os.system(train_cmd + ' > tmp.txt')
print('Training finished.')
if(opt.runfom):
print('Obtaining Full-Order solutions for testing (might be slow)')
os.system(fom_cmd + ' > tmp.txt')
print('Reference values obtained.')
os.system('rm surrs*0000.csv')
fom_data = mooseutils.PostprocessorReader(fom_results)
mean_rel_diff = []
max_rel_diff = []
for no_modes in no_pod_modes:
cmd = surr_cmd + " Surrogates/rbpod/new_ranks=" + str(no_modes)
print('Obtaining surrogate results with ', no_modes, ' POD modes.')
os.system(cmd) # + ' > tmp.txt')
print('Surrogate run finished.')
os.system('rm surrs*0000.csv')
rom_data = mooseutils.PostprocessorReader(rom_results)
os.system('mv surr_out_res_0001.csv surr_out_res_'+str(no_modes)+'.csv')
rel_diff = abs(fom_data['results:nodal_l2'].values - rom_data['value'].values)/abs(fom_data['results:nodal_l2'].values)
def frames():
camera = vtk.vtkCamera()
camera.SetViewUp(-0.0000000012, 0.9999999979, -0.0000646418)
camera.SetPosition(0.1520029313, 0.0128604224, 0.1612327470)
camera.SetFocalPoint(0.1520000000, 0.0128500000, 0.0000000000)
reader = chigger.exodus.ExodusReader('step8_out.e')
temp = chigger.exodus.ExodusResult(reader,
camera=camera,
variable='temperature',
range=[300, 350],
viewport=[0, 0.5, 1, 1],
cmap='plasma')
cbar = chigger.exodus.ExodusColorBar(temp,
length=0.6,
viewport=[0, 0, 1, 1],
colorbar_origin=[0.1, 0.85],
location='top')
cbar.setOptions('primary',
title='Temperature (K)',
num_ticks=6,
font_size=48,
font_color=[0, 0, 0])
time = chigger.annotations.TextAnnotation(position=[0.85, 0.85],
font_size=48,
text_color=[0, 0, 0],
justification='center')
pp_data = mooseutils.PostprocessorReader('step8_out.csv')
x = pp_data['time']
y0 = pp_data['average_temperature']
y1 = pp_data['outlet_heat_flux']
avg_temp = chigger.graphs.Line(color=[0.1, 0.1, 1], width=4, tracer=True)
out_flux = chigger.graphs.Line(color=[1, 0.2, 0.2],
width=4,
tracer=True,
corner='right-bottom')
graph = chigger.graphs.Graph(avg_temp,
out_flux,
viewport=[0, 0, 0.5, 0.65])
graph.setOptions('legend', visible=False)
graph.setOptions('xaxis',
title='Time (s)',
lim=[0, 100],
font_color=[0, 0, 0],
font_size=28)
graph.setOptions('yaxis',
title='Temperature (K)',
lim=[300, 350],
font_color=[0.1, 0.1, 1],
font_size=28,
num_ticks=6)
graph.setOptions('y2axis',
title='Heat Flux (W/m^2)',
lim=[0, 2.5],
font_color=[1, 0.2, 0.2],
font_size=28,
num_ticks=6)
vpp_data = mooseutils.VectorPostprocessorReader(
'step8_out_temperature_sample_*.csv')
line_temp = chigger.graphs.Line(color=[0.1, 0.1, 1], width=4, append=False)
graph2 = chigger.graphs.Graph(line_temp, viewport=[0.5, 0, 1, 0.65])
graph2.setOptions('legend', visible=False)
graph2.setOptions('yaxis',
title='y (cm)',
lim=[0, 0.026],
font_color=[0, 0, 0],
font_size=28,
axis_scale=100,
num_ticks=5)
graph2.setOptions('xaxis',
title='Temperature (K)',
lim=[300, 350],
font_color=[0, 0, 0],
font_size=28,
num_ticks=6)
window = chigger.RenderWindow(temp,
cbar,
time,
graph,
graph2,
size=[1920, 1080],
motion_factor=0.1,
background=[1, 1, 1])
for i, t in enumerate(reader.getTimes()):
reader.setOptions(timestep=i)
reader.setOptions(timestep=i)
reader.setOptions(timestep=i)
avg_temp.setOptions(x=[x[i]], y=[y0[i]])
out_flux.setOptions(x=[x[i]], y=[y1[i]])
vpp = vpp_data(['y', 'temperature'], time=i)
line_temp.setOptions(x=vpp['temperature'].tolist(),
y=vpp['y'].multiply(100).tolist())
time.setOptions(text='Time = {:.2f} sec.'.format(t))
filename = 'output/step08_{:05d}.png'.format(i)
window.write(filename)
window.start()
def main():
"""
Run plot widget alone
"""
from plugins.FigurePlugin import FigurePlugin
from plugins.MediaControlPlugin import MediaControlPlugin
from plugins.PostprocessorSelectPlugin import PostprocessorSelectPlugin
from plugins.AxesSettingsPlugin import AxesSettingsPlugin
from plugins.AxisTabsPlugin import AxisTabsPlugin
from plugins.OutputPlugin import OutputPlugin
widget = PostprocessorPluginManager(plugins=[FigurePlugin, MediaControlPlugin, PostprocessorSelectPlugin, AxesSettingsPlugin, AxisTabsPlugin, OutputPlugin])
widget.FigurePlugin.setFixedSize(QtCore.QSize(600,600))
widget.show()
return widget, widget.FigurePlugin
if __name__ == '__main__':
import sys
from PostprocessorDataWidget import PostprocessorDataWidget
app = QtWidgets.QApplication(sys.argv)
data = [PostprocessorDataWidget(mooseutils.PostprocessorReader('../../tests/input/white_elephant_jan_2016.csv'))]
#data = [PostprocessorDataWidget(mooseutils.VectorPostprocessorReader('../../tests/input/vpp_*.csv')),
# PostprocessorDataWidget(mooseutils.VectorPostprocessorReader('../../tests/input/vpp2_*.csv'))]
widget, _ = main()
widget.initialize(data)
sys.exit(app.exec_())
#*
#* All rights reserved, see COPYRIGHT for full restrictions
#* https://github.com/idaholab/moose/blob/master/COPYRIGHT
#*
#* Licensed under LGPL 2.1, please see LICENSE for details
#* https://www.gnu.org/licenses/lgpl-2.1.html
import matplotlib.pyplot as plt
import mooseutils
# Create Figure and Axes
figure = plt.figure(facecolor='white')
axes0 = figure.add_subplot(111)
# Read Postprocessor Data
data = mooseutils.PostprocessorReader(
'histogram_vector_postprocessor_out_histo_0001.csv')
# Grab upper and lower bin bounds
lower = data('value_lower')
upper = data('value_upper')
# Compute the midpoint and width of each bin
mid = (lower + upper) / 2.0
width = upper - lower
# Grab the data to be plotted
y = data('value')
# Plot everything
axes0.bar(mid, y, width=width)
