def __init__(self, uq_systemsize):
mean_v = 248.136 # Mean value of input random variable
mean_alpha = 5 #
mean_Ma = 0.84
mean_re = 1.e6
mean_rho = 0.38
mean_cg = np.zeros((3))
std_dev = np.diag([0.2, 0.01]) # np.diag([1.0, 0.2, 0.01, 1.e2, 0.01])
rv_dict = { # 'v' : mean_v,
'alpha': mean_alpha,
'Mach_number': mean_Ma,
# 're' : mean_re,
# 'rho' : mean_rho,
}
self.QoI = examples.OASAerodynamicWrapper(uq_systemsize, rv_dict)
self.jdist = cp.Normal(self.QoI.rv_array, std_dev)
self.dominant_space = DimensionReduction(
n_arnoldi_sample=uq_systemsize + 1, exact_Hessian=False)
self.dominant_space.getDominantDirections(self.QoI,
self.jdist,
max_eigenmodes=1)
# print 'iso_eigenvals = ', self.dominant_space.iso_eigenvals
# print 'iso_eigenvecs = ', '\n', self.dominant_space.iso_eigenvecs
# print 'dominant_indices = ', self.dominant_space.dominant_indices
# print 'ratio = ', abs(self.dominant_space.iso_eigenvals[0] / self.dominant_space.iso_eigenvals[1])
print 'std_dev = ', cp.Std(self.jdist), '\n'
print 'cov = ', cp.Cov(self.jdist), '\n'
def setup(self):
print("In Setup!!")
self.std_dev_xi = np.array([0.3, 0.2, 0.1])
system_size = 3
mean_xi = np.ones(system_size)
# Inputs
self.add_input('mean_xi', val=mean_xi)
# Intermediate operations
jdist = cp.MvNormal(mean_xi, np.diag(self.std_dev_xi))
self.collocation_QoI = StochasticCollocation(system_size, "Normal")
self.collocation_QoI_grad = StochasticCollocation(
system_size, "Normal",
system_size) # Create a Stochastic collocation object
self.QoI = examples.Paraboloid3D(system_size) # Create QoI
threshold_factor = 0.9
self.dominant_space = DimensionReduction(threshold_factor,
exact_Hessian=True)
self.dominant_space.getDominantDirections(self.QoI, jdist)
# Outputs
self.add_output('mean_QoI', 0.0)
# Partial derivatives
self.declare_partials('mean_QoI', 'mean_xi')
class Paraboloid(ExplicitComponent):
"""
Lets try OpenMDAO api for our problems
"""
def setup(self):
print("In Setup!!")
self.std_dev_xi = np.array([0.3, 0.2, 0.1])
system_size = 3
mean_xi = np.ones(system_size)
# Inputs
self.add_input('mean_xi', val=mean_xi)
# Intermediate operations
jdist = cp.MvNormal(mean_xi, np.diag(self.std_dev_xi))
self.collocation_QoI = StochasticCollocation(system_size, "Normal")
self.collocation_QoI_grad = StochasticCollocation(
system_size, "Normal",
system_size) # Create a Stochastic collocation object
self.QoI = examples.Paraboloid3D(system_size) # Create QoI
threshold_factor = 0.9
self.dominant_space = DimensionReduction(threshold_factor,
exact_Hessian=True)
self.dominant_space.getDominantDirections(self.QoI, jdist)
# Outputs
self.add_output('mean_QoI', 0.0)
# Partial derivatives
self.declare_partials('mean_QoI', 'mean_xi')
def compute(self, inputs, outputs):
print("In compute")
mu = inputs['mean_xi']
# print("mu = ", mu)
jdist = cp.MvNormal(mu, np.diag(self.std_dev_xi))
QoI_func = self.QoI.eval_QoI
outputs['mean_QoI'] = self.collocation_QoI.normal.reduced_mean(
QoI_func, jdist, self.dominant_space)
def compute_partials(self, inputs, J):
print("In compute_partials")
mu = inputs['mean_xi']
jdist = cp.MvNormal(mu, np.diag(self.std_dev_xi))
QoI_func = self.QoI.eval_QoIGradient
val = self.collocation_QoI_grad.normal.reduced_mean(
QoI_func, jdist, self.dominant_space)
J['mean_QoI',
'mean_xi'] = val # self.collocation.normal.reduced_mean(QoI_func, jdist, self.dominant_space)
def sens(xdict, funcs):
mu = xdict['xvars']
# Initialize pyStatReduce
systemsize = len(mu)
sigma = np.array([0.3, 0.2, 0.1])
jdist = cp.MvNormal(mu, np.diag(sigma))
collocation = StochasticCollocation(3, "Normal", systemsize)
QoI = examples.Paraboloid3D(systemsize) # Create QoI
threshold_factor = 0.9
dominant_space = DimensionReduction(threshold_factor, exact_Hessian=True)
dominant_space.getDominantDirections(QoI, jdist)
QoI_func = QoI.eval_QoIGradient
funcsSens = {}
# funcsSens['obj', 'xvars'] = collocation.normal.mean(mu, sigma, QoI_func)
funcsSens['obj', 'xvars'] = collocation.normal.reduced_mean(
QoI_func, jdist, dominant_space)
fail = False
return funcsSens, fail
def run2DQuadratic(theta, std_dev, nx):
systemsize = 2
# nx = 100
xlow = -2 * np.ones(systemsize)
xupp = 2 * np.ones(systemsize)
x1 = np.linspace(xlow[0], xupp[0], num=nx)
x2 = np.linspace(xlow[1], xupp[1], num=nx)
error_mu_j = np.zeros((nx, nx))
threshold_factor = 0.9
tuple = (theta, )
for i in xrange(0, nx):
for j in xrange(0, nx):
x = np.array([x1[i], x2[j]])
# Create necessary objects
collocation = StochasticCollocation(3, "Normal")
QoI = examples.Paraboloid2D(systemsize, tuple)
jdist = cp.MvNormal(x, np.diag(std_dev))
dominant_space = DimensionReduction(threshold_factor,
exact_Hessian=True)
# Get dominant directions and perform reduced collocation
dominant_space.getDominantDirections(QoI, jdist)
QoI_func = QoI.eval_QoI
# mu_j_bar = collocation.normal.reduced_mean(QoI_func, jdist, dominant_space)
mu_j_bar = collocation.normal.reduced_mean2(
QoI_func, jdist, dominant_space)
# Check agaisnt full stochastic collocation
mu_j = collocation.normal.mean(x, std_dev, QoI_func)
error_mu_j[i, j] = abs((mu_j_bar - mu_j) / mu_j)
max_err = np.amax(error_mu_j)
return max_err
def objfunc(xdict):
mu = xdict['xvars']
funcs = {}
# Initialize pyStatReduce
systemsize = len(mu)
theta = 0
sigma = np.array([0.3, 0.2, 0.1])
jdist = cp.MvNormal(mu, np.diag(sigma)) # Create joint distribution
collocation = StochasticCollocation(
3, "Normal") # Create a Stochastic collocation object
QoI = examples.Paraboloid3D(systemsize) # Create QoI
threshold_factor = 0.9
dominant_space = DimensionReduction(threshold_factor, exact_Hessian=True)
dominant_space.getDominantDirections(QoI, jdist)
QoI_func = QoI.eval_QoI
# funcs['obj'] = collocation.normal.mean(mu, sigma, QoI_func)
funcs['obj'] = collocation.normal.reduced_mean(QoI_func, jdist,
dominant_space)
fail = False
return funcs, fail
if __name__ == "__main__":
# Instantiate the rosenbrock problem globally
rv_systemsize = 2
initial_seed = 2 * np.ones(rv_systemsize)
QoI = RosenbrockOpt(rv_systemsize)
std_dev = np.eye(rv_systemsize)
jdist = cp.MvNormal(initial_seed, std_dev)
collocation = StochasticCollocation(3, "Normal")
collocation_grad = StochasticCollocation(3,
"Normal",
QoI_dimensions=rv_systemsize)
threshold_factor = 0.9
dominant_space = DimensionReduction(threshold_factor,
n_arnoldi_sample=3,
exact_Hessian=False)
dominant_space.getDominantDirections(QoI, jdist)
# Setup the problem
optProb = Optimization('Paraboloid', objfunc)
lower_bound = -20 * np.ones(rv_systemsize)
upper_bound = 20 * np.ones(rv_systemsize)
optProb.addVarGroup('xvars',
rv_systemsize,
'c',
lower=lower_bound,
upper=upper_bound,
value=10 * np.ones(rv_systemsize))
optProb.addObj('obj')
# Optimizer