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,