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_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_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)
# Create a Monte Carlo Object
use_reduced_collocation = False
if use_reduced_collocation:
# 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'])
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)
var_j_full = sc_obj_full.variance(of=['fuelburn'])
time_elapsed_var = time.time() - t_before_var
print('mu_j_full = ', mu_j_full['fuelburn'][0])
print('var_j_full = ', var_j_full['fuelburn'][0, 0])
print("time for sampling = ", t_sampling - start_time)
print('time mu = ', time_elapsed_mu)
print('time var = ', time_elapsed_var)
elif sys.argv[1] == 'monte_carlo':
start_time = time.time()
# Create a Monte Carlo object
nsample = 100000
mc_obj = MonteCarlo(nsample, jdist, QoI_dict, include_derivs=False)
mc_obj.getSamples(jdist, include_derivs=False)
t_sampling = time.time()
mu_j = mc_obj.mean(jdist, of=['fuelburn'])
time_elapsed_mu = time.time() - t_sampling
t_before_var = time.time()
var_j = mc_obj.variance(jdist, of=['fuelburn'])
time_elapsed_var = time.time() - t_before_var
print('nsample = ', nsample)
print('mu_j_mc = ', mu_j['fuelburn'][0])
print('var_j_mc = ', var_j['fuelburn'][0])
print("time for sampling = ", t_sampling - start_time)
start_time = time.time()
uq_systemsize = 6
UQObj = UQScanEagleOpt(uq_systemsize, all_rv=True)
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',
'MvNormal',
UQObj.QoI_dict,
include_derivs=False)
red_colloc_obj = StochasticCollocation2(
UQObj.jdist,
3,
'MvNormal',
UQObj.QoI_dict,
include_derivs=False,
reduced_collocation=True,
# dominant_dir=custom_eigenvec[:,0:int(sys.argv[1])])
dominant_dir=UQObj.dominant_space.dominant_dir)
elif use_monte_carlo:
nsample = 100
colloc_obj = MonteCarlo(nsample,
UQObj.jdist,
UQObj.QoI_dict,
include_derivs=False)
red_colloc_obj = MonteCarlo(
nsample,
UQObj.jdist,
UQObj.QoI_dict,
reduced_collocation=True,
dominant_dir=UQObj.dominant_space.dominant_dir,
include_derivs=False)
# iso_grad, reg_grad = get_iso_gradients(sc_sol_dict['sc_init'])
# print('reg_grad = \n', reg_grad)
# print('iso_grad = \n', iso_grad)
key_name = 'sc_init' # 'act_init_7rv_2_2_lf1'
print('key_name = ', key_name)
if sys.argv[1] == "full":
start_time = time.time()
UQObj = scaneagle_opt.UQScanEagleOpt(rv_dict, design_point=sc_sol_dict[dict_val],
rdo_factor=2.0,
krylov_pert=1.e-1,
max_eigenmodes=len(rv_dict))
# 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 = 100 # 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, scale=1.e3, value=init_thickness_cp)
optProb.addVar('sweep', lower=10., upper=30., value=init_sweep)
optProb.addVar('alpha', lower=-10., upper=10., value=init_alpha)
# Constraints
optProb.addConGroup('con_failure', 1, upper=0.)
optProb.addConGroup('con_thickness_intersects', n_thickness_intersects,