import optparse
from puqutil import dump_hdf5
import numpy as np
parser = optparse.OptionParser()
parser.add_option("--x1", type=float)
parser.add_option("--x2", type=float)
parser.add_option("--x3", type=float)
parser.add_option("--x4", type=float)
parser.add_option("--x5", type=float)
parser.add_option("--x6", type=float)
(options, args) = parser.parse_args()
x1 = options.x1
x2 = options.x2
x3 = options.x3
x4 = options.x4
x5 = options.x5
x6 = options.x6
def sobol(x, a):
g = (np.abs(4 * x - 2) + a) / (1. + a)
return g.prod()
a = np.array([78., 12., 0.5, 2., 97, 33])
g = sobol(np.array([x1, x2, x3, x4, x5, x6]), a)
dump_hdf5('sobol', g, "sobol g-function")
case_folder = '5_spot'
scripts_dir = PUQ_dir + 'scripts'
launch_dir = PUQ_dir + case_folder
result_dir = PUQ_dir + case_folder +'/test_output'
cmd = ['./xyzdtp_gen.out', str(x), str(y), str(z)]
call(cmd, cwd=os.getcwd())
# copy the input path file
#cmd =['cp', 'xyzdtp.dat', '../'+ case_folder +'/']
#call(cmd, cwd=scripts_dir)
# launch the simulation
truchas_binary = '/home/srdjans/projects/truchas-2.8.0-RC/install/linux.x86_64.intel.parallel.opt/bin/t-linux.x86_64.intel.parallel.opt-2.8.0'
cmd = ['mpirun', '-np', str(cpus), truchas_binary, 'test.inp']
call(cmd, cwd=launch_dir)
# postprocess the results
cmd = ['bash', scripts_dir+'/postprocessor.sh']
call(cmd, cwd=result_dir)
# extract quantity of interest
with open(result_dir+'/PHI.txt', 'r') as fin:
lines = fin.readlines()
qoi = float(lines[0].split(':')[1].lstrip(' ').strip('\n'))
# report the quantities of interest to PUQ
if qoi > 1:
print 'Case failed due to one or more errors'
sys.exit()
dump_hdf5('volume_fraction_of_equiaxed_grains', qoi)
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import numpy as np
usage = "usage: %prog --x x --y y"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
if x > 0.5:
z = 0.0
else:
z = np.sin(np.pi*x) * np.sin(np.pi*y)
dump_hdf5('z', z, "$f(x,y)\/=\/0\/for\/x>0.5\/else\/sin(x\pi)*sin(y\pi)$")
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import numpy as np
usage = "usage: %prog --x x --y y"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
z = x**2 + 0.75 * y**2 + 2 * y + x * y - 7
dump_hdf5('z', z)
#!/usr/bin/env python
''' This is just a test program for the UQ framework'''
import optparse
import numpy as np
## this is our random parameter
usage = "usage: %prog --v velocity --m mass"
parser = optparse.OptionParser(usage)
parser.add_option("--v", type=float)
parser.add_option("--m", type=float)
(options, args) = parser.parse_args()
v = options.v
m = options.m
both = v + m
from puqutil import dump_hdf5
#dump_hdf5('velocity', v, 'Velocity')
#dump_hdf5('mass', m, 'Mass')
dump_hdf5('both', both, 'M + V')
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import numpy as np
usage = "usage: %prog --x x --y y"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
z = x**2 + 0.75 * y**2 + 2*y + x*y - 7
dump_hdf5('z', z)
x_eq_0_5_line_cells = [ 65, 76, 88, 101, 115, 130, 146, 163, 181,
200, 219, 237, 254, 270, 285, 299, 312,
324, 335, 345]
y_eq_0_5_line_cells = [ 45 ,56 ,68 ,81 ,95 ,110,126,143,161,180,200,
220,239,257,274,290,305,319,332,344]
mesh0 = meshes[0]
vCells = flowFields.velocity[mesh0.getCells()].asNumPyArray()
## these are the four arrays with u and v velocity data that we want
## to post process to produce the mean and variances of
u_x_eq_0_5 = vCells[x_eq_0_5_line_cells,0]
v_x_eq_0_5 = vCells[x_eq_0_5_line_cells,1]
u_y_eq_0_5 = vCells[y_eq_0_5_line_cells,0]
v_y_eq_0_5 = vCells[y_eq_0_5_line_cells,1]
### the following code writes the above data in format suitable for
### plotting in Fluent. Replace this as needed to do our post processing
from puqutil import dump_hdf5
#dump_hdf5('Viscosity', viscosity)
dump_hdf5('u_x_eq_0_5', u_x_eq_0_5 , 'u velocity where x = 0.5')
dump_hdf5('v_x_eq_0_5', v_x_eq_0_5)
dump_hdf5('u_y_eq_0_5', u_y_eq_0_5)
dump_hdf5('v_y_eq_0_5', v_y_eq_0_5)
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
usage = "usage: %prog --x x --y y"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
f = x
g = y
h = x+y
dump_hdf5('f', f)
dump_hdf5('g', g)
dump_hdf5('h', h)
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import time
usage = "usage: %prog --x x --y y"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
# need to produce two correlated output variables, f and g
f = x
g = x + y
z = f * g
dump_hdf5('f', f, "$f(x,y)=x+y$")
dump_hdf5('g', g, "$g(x,y)=x+y$")
dump_hdf5('z', z, "$z(x,y)=x(x+y)$")
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import numpy as np
parser = optparse.OptionParser()
parser.add_option("--a", type=float)
parser.add_option("--b", type=float)
(options, args) = parser.parse_args()
a = options.a
b = options.b
p = a * b
dump_hdf5('p', p, "$p=a^2+a*b$")
# Example from
# http://publications.jrc.ec.europa.eu/repository/handle/111111111/8571
import optparse
from puqutil import dump_hdf5
import numpy as np
parser = optparse.OptionParser()
parser.add_option("--x1", type=float)
parser.add_option("--x2", type=float)
parser.add_option("--x3", type=float)
parser.add_option("--x4", type=float)
parser.add_option("--x5", type=float)
parser.add_option("--x6", type=float)
(options, args) = parser.parse_args()
x1 = options.x1
x2 = options.x2
x3 = options.x3
x4 = options.x4
x5 = options.x5
x6 = options.x6
def sobol ( x, a ):
g = (np.abs(4*x - 2 ) + a) / (1. + a)
return g.prod()
a = np.array([78., 12., 0.5, 2., 97, 33])
g = sobol(np.array([x1,x2,x3,x4,x5,x6]), a)
dump_hdf5('sobol', g, "sobol g-function")
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
parser = optparse.OptionParser()
parser.add_option("--a", type=float)
parser.add_option("--b", type=float)
(options, args) = parser.parse_args()
a = options.a
b = options.b
p = 2 * a + b
dump_hdf5('p', p, "$p=2*a+b$")
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import numpy as np
usage = "usage: %prog --x x --y y --z z"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
parser.add_option("--z", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
z = options.z
f = x**2 + 0.75 * y**2 + 2*y + x*y - 7*z + 2
dump_hdf5('f', f)
#!/usr/bin/env python
''' Example of dumping multiple output variables.'''
import optparse
from numpy import sin
from puqutil import dump_hdf5
## this is our random parameter
usage = "usage: %prog --v velocity --m mass"
parser = optparse.OptionParser(usage)
parser.add_option("--v", type=float)
parser.add_option("--m", type=float)
(options, args) = parser.parse_args()
v = options.v
m = options.m
ke = m * v * v * 0.5
e = m + v + 2*m*v
#f = sin(v) + sin(m)
#g = sin(v) * sin(m)
dump_hdf5('kinetic_energy', ke, 'The Kinetic Energy of the moving object.')
dump_hdf5('energy', e, 'A random energy equation.')
#dump_hdf5('f', f, 'sin + sin')
#dump_hdf5('g', g, 'sin * sin')
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import time
usage = "usage: %prog --f f --g g"
parser = optparse.OptionParser(usage)
parser.add_option("--g", type=float)
parser.add_option("--f", type=float)
(options, args) = parser.parse_args()
f = options.f
g = options.g
k = f * g
dump_hdf5('k', k, "$k(f,g)=f*g$")
#!/usr/bin/env python
# discontinuous sine function
import optparse
from puqutil import dump_hdf5
from numpy import sin, pi
usage = "usage: %prog --x x"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
(options, args) = parser.parse_args()
x = options.x
f = sin(x % (pi / 2))
dump_hdf5('f', f, "$f(x)= sin(x\ mod\ \\frac{\pi}{2})$")
#!/usr/bin/env python
# discontinuous sine function
import optparse
from puqutil import dump_hdf5
from numpy import sin, pi
usage = "usage: %prog --x x"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
(options, args) = parser.parse_args()
x = options.x
f = sin(x % (pi/2))
dump_hdf5('f', f, "$f(x)= sin(x\ mod\ \\frac{\pi}{2})$")
#!/usr/bin/env python
''' Example of dumping multiple output variables.'''
import optparse
from numpy import sin
from puqutil import dump_hdf5
## this is our random parameter
usage = "usage: %prog --v velocity --m mass"
parser = optparse.OptionParser(usage)
parser.add_option("--v", type=float)
parser.add_option("--m", type=float)
(options, args) = parser.parse_args()
v = options.v
m = options.m
ke = m * v * v * 0.5
e = m + v + 2 * m * v
#f = sin(v) + sin(m)
#g = sin(v) * sin(m)
dump_hdf5('kinetic_energy', ke, 'The Kinetic Energy of the moving object.')
dump_hdf5('energy', e, 'A random energy equation.')
#dump_hdf5('f', f, 'sin + sin')
#dump_hdf5('g', g, 'sin * sin')
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
parser = optparse.OptionParser()
parser.add_option("--a", type=float)
parser.add_option("--b", type=float)
(options, args) = parser.parse_args()
a = options.a
b = options.b
p = 2*a+b
dump_hdf5('p', p, "$p=2*a+b$")
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
usage = "usage: %prog --x x --y y --z z"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
parser.add_option("--y", type=float)
parser.add_option("--z", type=float)
(options, args) = parser.parse_args()
x = options.x
y = options.y
z = options.z
f = x + y * 2 - z
g = x**4 + z**2
dump_hdf5('f', f, "f(x,y,z)=x+y^2+z^3")
# We could do multiple outputs at once for
# non-adaptive methods
dump_hdf5('g', g, "g(x,y,z)=x^4+z^2")
#!/usr/bin/env python
''' This is just a test program for the UQ framework'''
import optparse
import numpy as np
from puqutil import dump_hdf5
## this is our random parameter
usage = "usage: %prog --v velocity --m mass"
parser = optparse.OptionParser(usage)
parser.add_option("--v1", type=float)
parser.add_option("--v2", type=float)
(options, args) = parser.parse_args()
v1 = options.v1
v2 = options.v2
v = v1 + v2
dump_hdf5('v1', v1)
dump_hdf5('v2', v2)
dump_hdf5('total_velocity', v, 'The velocities added together.')
#!/usr/bin/env python
import optparse
from puqutil import dump_hdf5
import numpy as np
parser = optparse.OptionParser()
parser.add_option("--a", type=float)
parser.add_option("--b", type=float)
(options, args) = parser.parse_args()
a = options.a
b = options.b
p = a*b
dump_hdf5('p', p, "$p=a^2+a*b$")
#!/usr/bin/env python
# 1d 2nd degree polymial function
import optparse
from puqutil import dump_hdf5
import math
usage = "usage: %prog --x x"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
(options, args) = parser.parse_args()
x = options.x
f = 2*x*x - 7*x + 12
dump_hdf5('f', f, 'foobar')
~/memosa/src/puq/examples/wrappers> ./sim_file_wrap.py 1 2 3 4
HDF5:{'name': 'z', 'value': 'Output of the quadratic.', 'desc': 27.0}:5FDH
"""
from puqutil import dump_hdf5
from sys import argv, exit
import os, re
# global search and replace in a file
def replace(fname, a, b):
data = open(fname, 'r').read().replace(a, str(b))
open(fname, 'w').write(data)
# modify the input file
replace('input.txt', 'AAA', argv[1])
replace('input.txt', 'BBB', argv[2])
replace('input.txt', 'CCC', argv[3])
replace('input.txt', 'XXX', argv[4])
# Note about paths. If your simulation is installed on your
# PATH, then everything works fine. I used ".." for a relative path
# to the simulation. I have to use ".." because this will be executed
# in a subdirectory because quad_file uses the newdir option.
cmd = "../sim_file.py"
if os.system(cmd) == 0:
out = open('output.txt', 'r').read()
z = re.findall(r'The answer is ([-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?)', out)[0][0]
dump_hdf5('z', float(z), 'Output of the quadratic.')
else:
exit(1)
#!/usr/bin/env python
''' This is just a test program for the UQ framework'''
import optparse
import numpy as np
## this is our random parameter
usage = "usage: %prog --v velocity"
parser = optparse.OptionParser(usage)
parser.add_option("--v", type=float)
(options, args) = parser.parse_args()
v = options.v
from puqutil import dump_hdf5
dump_hdf5('velocity', v, 'Velocity')
#!/usr/bin/env python
# 1d 2nd degree polymial function
import optparse
from puqutil import dump_hdf5
import math
usage = "usage: %prog --x x"
parser = optparse.OptionParser(usage)
parser.add_option("--x", type=float)
(options, args) = parser.parse_args()
x = options.x
f = 2 * x * x - 7 * x + 12
dump_hdf5('f', f, 'foobar')
#!/usr/bin/env python
''' This is just a test program for the UQ framework'''
import optparse
import numpy as np
from puqutil import dump_hdf5
## this is our random parameter
usage = "usage: %prog --v velocity --m mass"
parser = optparse.OptionParser(usage)
parser.add_option("--v", type=float)
parser.add_option("--m", type=float)
(options, args) = parser.parse_args()
v = options.v
m = options.m
ke = 0.5 * m * v * v
dump_hdf5('kinetic_energy', ke, 'The Kinetic Energy of the moving object.')
