def test_scalarQoI(self):
systemsize = 3
mu = np.random.rand(systemsize)
std_dev = np.diag(np.random.rand(systemsize))
jdist = cp.MvNormal(mu, std_dev)
# Create QoI Object
QoI = Paraboloid3D(systemsize)
# Create the Monte Carlo object
QoI_dict = {
'paraboloid': {
'QoI_func': QoI.eval_QoI,
'output_dimensions': 1,
}
}
nsample = 1000000
mc_obj = MonteCarlo(nsample, jdist, QoI_dict)
mc_obj.getSamples(jdist)
# Get the mean and variance using Monte Carlo
mu_js = mc_obj.mean(jdist, of=['paraboloid'])
var_js = mc_obj.variance(jdist, of=['paraboloid'])
# Analytical mean
mu_j_analytical = QoI.eval_QoI_analyticalmean(mu, cp.Cov(jdist))
err = abs((mu_js['paraboloid'] - mu_j_analytical) / mu_j_analytical)
self.assertTrue(err < 1e-3)
# Analytical variance
var_j_analytical = QoI.eval_QoI_analyticalvariance(mu, cp.Cov(jdist))
err = abs((var_js['paraboloid'] - var_j_analytical) / var_j_analytical)
# print('var_js paraboloid = ', var_js['paraboloid'], '\n')
self.assertTrue(err < 1e-2)
def test_reduced_montecarlo(self):
systemsize = 4
eigen_decayrate = 2.0
# Create Hadmard Quadratic object
QoI = HadamardQuadratic(systemsize, eigen_decayrate)
true_eigenvals = np.array([0.08, 0.02, 0.005, 0.00888888888888889])
true_eigenvecs = np.array([[0.5, 0.5, -0.5, -0.5],
[0.5, -0.5, 0.5,
-0.5], [0.5, 0.5, 0.5, 0.5],
[0.5, -0.5, -0.5, 0.5]])
dominant_dir = true_eigenvecs[:, 0:3]
QoI_dict = {
'hadamard4_2': {
'QoI_func': QoI.eval_QoI,
'output_dimensions': 1,
}
}
# Create the distribution
mu = np.ones(systemsize)
std_dev = 0.2 * np.eye(systemsize)
jdist = cp.MvNormal(mu, std_dev)
# Create the Monte Carlo object
nsample = 100000
mc_obj = MonteCarlo(nsample,
jdist,
QoI_dict,
reduced_collocation=True,
dominant_dir=dominant_dir,
include_derivs=False)
mc_obj.getSamples(jdist, include_derivs=False)
mu_j_mc = mc_obj.mean(jdist, of=['hadamard4_2'])
# Compare against a reduced stochastic collocation object
sc_obj = StochasticCollocation2(jdist,
3,
'MvNormal',
QoI_dict,
reduced_collocation=True,
dominant_dir=dominant_dir)
sc_obj.evaluateQoIs(jdist)
mu_j_sc = sc_obj.mean(of=['hadamard4_2'])
rel_err = abs((mu_j_mc['hadamard4_2'] - mu_j_sc['hadamard4_2']) /
mu_j_sc['hadamard4_2'])
self.assertTrue(rel_err[0] < 1.e-3)
def test_derivatives_scalarQoI(self):
systemsize = 3
mu = np.random.rand(systemsize)
std_dev = np.diag(np.random.rand(systemsize))
jdist = cp.MvNormal(mu, std_dev)
# Create QoI Object
QoI = Paraboloid3D(systemsize)
# Create the Monte Carlo object
deriv_dict = {
'xi': {
'dQoI_func': QoI.eval_QoIGradient,
'output_dimensions': systemsize
}
}
QoI_dict = {
'paraboloid': {
'QoI_func': QoI.eval_QoI,
'output_dimensions': 1,
'deriv_dict': deriv_dict
}
}
nsample = 1000000
mc_obj = MonteCarlo(nsample, jdist, QoI_dict, include_derivs=True)
mc_obj.getSamples(jdist, include_derivs=True)
dmu_j = mc_obj.dmean(jdist, of=['paraboloid'], wrt=['xi'])
dvar_j = mc_obj.dvariance(jdist, of=['paraboloid'], wrt=['xi'])
# Analytical dmu_j
dmu_j_analytical = np.array([100 * mu[0], 50 * mu[1], 2 * mu[2]])
err = abs(
(dmu_j['paraboloid']['xi'] - dmu_j_analytical) / dmu_j_analytical)
self.assertTrue((err < 0.01).all())
# Analytical dvar_j
rv_dev = cp.Std(jdist)
dvar_j_analytical = np.array([(100 * rv_dev[0])**2,
(50 * rv_dev[1])**2, (2 * rv_dev[2])**2])
err = abs((dvar_j['paraboloid']['xi'] - dvar_j_analytical) /
dvar_j_analytical)
# Get the dominant directions
arnoldi_sample_sizes = [20, 25, 30, 35, 40, 46]
fname = './eigenmodes/eigenmodes_' + sys.argv[1] + '_samples.npz'
eigenmode = np.load(fname)
eigenvecs = eigenmode['eigenvecs']
n_dominant_dir = int(sys.argv[2]) # 11
dominant_dir = eigenvecs[:, 0:n_dominant_dir]
nsample = 1000
mc_obj = MonteCarlo(nsample,
jdist,
QoI_dict,
reduced_collocation=True,
include_derivs=False,
dominant_dir=dominant_dir)
mc_obj.getSamples(jdist, include_derivs=False)
else:
print('Using Full Monte Carlo')
nsample = 10000 # 5000
mc_obj = MonteCarlo(nsample,
jdist,
QoI_dict,
reduced_collocation=False,
include_derivs=False)
mc_obj.getSamples(jdist, include_derivs=False)
mu_j = mc_obj.mean(jdist, of=['time_duration'])
var_j = mc_obj.variance(jdist, of=['time_duration'])
# Print everything
print()
QoI.p['oas_scaneagle.wing.thickness_cp'] = design_point['thickness_cp']
QoI.p['oas_scaneagle.wing.twist_cp'] = design_point['twist_cp']
QoI.p['oas_scaneagle.wing.sweep'] = design_point['sweep']
QoI.p['oas_scaneagle.alpha'] = design_point['alpha']
QoI.p.final_setup()
QoI_dict = {'fuelburn' : {'QoI_func' : QoI.eval_QoI,
'output_dimensions' : 1
},
}
# Create the Monte Carlo object
start_time1 = time.time()
nsample = int(sys.argv[1])
mc_obj = MonteCarlo(nsample, jdist, QoI_dict) # tjdist: truncated normal distribution
mc_obj.getSamples(jdist) #
t1 = time.time()
# Compute the statistical moments using Monte Carlo
mu_j_mc = mc_obj.mean(jdist, of=['fuelburn'])
t2 = time.time()
var_j_mc = mc_obj.variance(jdist, of=['fuelburn'])
t3 = time.time()
print('Monte Carlo samples = ', nsample)
print("mean_mc = ", mu_j_mc['fuelburn'][0])
print("var_mc = ", var_j_mc['fuelburn'][0])
print()
# mean_sc_fuelburn = 5.269295151614887
# var_sc_fuelburn = 0.34932256
# err_mu = abs((mean_sc_fuelburn - mu_j_mc['fuelburn']) / mean_sc_fuelburn)
# err_var = abs((var_sc_fuelburn - var_j_mc['fuelburn']) / var_sc_fuelburn)
xi = np.zeros(uq_systemsize)
mu = np.array([0.071, 9.80665 * 8.6e-6, 10., 85.e9, 25.e9, 1.6e3])
# Get some information on the total number of constraints
n_thickness_intersects = UQObj.QoI.p[
'oas_scaneagle.AS_point_0.wing_perf.thickness_intersects'].size
n_CM = 3
n_constraints = 1 + n_thickness_intersects + 1 + n_CM + 3
# Create the Monte Carlo object based on the dominant directions
nsample = 1000
mc_obj = MonteCarlo(nsample,
UQObj.jdist,
UQObj.QoI_dict,
include_derivs=True)
mc_obj.getSamples(UQObj.jdist, include_derivs=True)
optProb = pyoptsparse.Optimization('UQ_OASScanEagle', objfunc_uq)
n_twist_cp = UQObj.QoI.input_dict['n_twist_cp']
n_thickness_cp = UQObj.QoI.input_dict['n_thickness_cp']
optProb.addVarGroup('twist_cp',
n_twist_cp,
'c',
lower=-5.,
upper=10,
value=init_twist_cp)
optProb.addVarGroup('thickness_cp',
n_thickness_cp,
'c',
lower=0.001,
upper=0.01,