def __init__(self, systemsize, oas_object, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize, data_type=data_type)
self.data_type = data_type
self.p = oas_object.p
self.rvs = oas_object.rvs
self.rv_dict = oas_object.input_dict['rv_dict']
self.update_rv = oas_object.update_rv
def __init__(self, systemsize, eigen_decayrate):
QuantityOfInterest.__init__(self, systemsize)
self.eigen_decayrate = eigen_decayrate
self.eigen_vals = np.zeros(systemsize)
self.eigen_vectors = np.zeros((systemsize, systemsize))
self.getSyntheticEigenValues()
self.getSyntheticEigenVectors()
def __init__(self, systemsize, **kwargs):
QuantityOfInterest.__init__(self, systemsize)
self.V, self.R = np.linalg.qr(np.random.rand(systemsize, systemsize))
self.E = np.sort(np.random.rand(systemsize))
if kwargs['positive_definite'] == True:
pass
elif kwargs['positive_definite'] == False:
self.E[0] = 0.0
def __init__(self, systemsize, input_dict, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize, data_type=data_type)
self.input_dict = input_dict
# self.include_dict_rv = include_dict_rv # Bool for including random variables in the durface dictionary
self.rv_dict = self.input_dict['rv_dict']
self.p = Problem()
self.rvs = self.p.model.add_subsystem('random_variables',
IndepVarComp(),
promotes_outputs=['*'])
self.p.model.add_subsystem(
'oas_scaneagle',
OASScanEagle(mesh_dict=self.input_dict['mesh_dict'],
surface_dict_rv=self.rv_dict))
# Declare rvs units to ensure type stability
# self.rvs.add_output('Mach_number', val=0.071)
self.rvs.add_output('Mach_number', val=self.rv_dict['Mach_number'])
self.p.model.connect('Mach_number', 'oas_scaneagle.Mach_number')
# self.rvs.add_output('CT', val=9.80665 * 8.6e-6, units='1/s') # TSFC
self.rvs.add_output('CT', val=self.rv_dict['CT'], units='1/s') # TSFC
self.p.model.connect('CT', 'oas_scaneagle.CT')
# self.rvs.add_output('W0', val=10., units='kg')
self.rvs.add_output('W0', val=self.rv_dict['W0'], units='kg')
self.p.model.connect('W0', 'oas_scaneagle.W0')
self.rvs.add_output('E', val=self.rv_dict['E'], units='N/m**2')
self.p.model.connect('E', 'oas_scaneagle.wing.struct_setup.assembly.E')
self.p.model.connect(
'E', 'oas_scaneagle.AS_point_0.wing_perf.struct_funcs.vonmises.E')
self.rvs.add_output('G', val=self.rv_dict['G'], units='N/m**2')
self.p.model.connect('G', 'oas_scaneagle.wing.struct_setup.assembly.G')
self.p.model.connect(
'G', 'oas_scaneagle.AS_point_0.wing_perf.struct_funcs.vonmises.G')
self.rvs.add_output('mrho', val=self.rv_dict['mrho'], units='kg/m**3')
self.p.model.connect(
'mrho', 'oas_scaneagle.wing.struct_setup.structural_weight.mrho')
self.p.setup()
# Set up reusable arrays
self.dJ_ddv = np.zeros(
self.input_dict['ndv'],
dtype=self.data_type) # Used in eval_ObjGradient_dv
self.con_arr = np.zeros(
self.input_dict['n_constraints'],
dtype=self.data_type) # Used in eval_ConstraintQoI
self.con_jac = np.zeros(
(self.input_dict['n_constraints'], self.input_dict['ndv']),
dtype=self.data_type)
def __init__(self, systemsize, input_dict, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize, data_type=data_type)
self.input_dict = input_dict
num_segments = input_dict['num_segments']
transcription_order = input_dict['transcription_order']
transcription_type = input_dict['transcription_type']
solve_segments = input_dict['solve_segments']
self.interceptor_obj = InterceptorWrapper(num_segments=num_segments,
transcription_order=transcription_order,
transcription_type=transcription_type,
solve_segments=solve_segments)
def __init__(self, systemsize):
"""
Compute an exponential function of the form
f = exp(a^T * a)
where `a` is computed as
x = [ a[0], a[1]/2, a[2]/3, ..., a[systemsize-1]/systemsize ]
"""
QuantityOfInterest.__init__(self, systemsize)
def __init__(self, systemsize, rv_dict):
QuantityOfInterest.__init__(self, systemsize)
# self.input_dict = input_dict # TODO: Add this feature
# Default recommended values for the problem
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))
self.p = Problem() # Create problem object
self.rvs = self.p.model.add_subsystem('random_variables', IndepVarComp(), promotes_outputs=['*'])
self.rvs.add_output('mu', val=np.zeros(len(rv_dict)))
self.p.model.add_subsystem('oas_example1', OASAerodynamic(rv_dict=rv_dict))
# Figure out what are the random variables
ctr = 0
self.rv_array = np.array([])
rv_indices = []
if "v" in rv_dict:
self.rv_array = np.append(self.rv_array, mean_v)
rv_indices.append(ctr)
self.p.model.connect('mu', 'oas_example1.v', src_indices=[ctr])
ctr += 1
if "alpha" in rv_dict:
self.rv_array = np.append(self.rv_array, mean_alpha)
rv_indices.append(ctr)
self.p.model.connect('mu', 'oas_example1.alpha', src_indices=[ctr])
ctr += 1
if "Mach_number" in rv_dict:
self.rv_array = np.append(self.rv_array, mean_Ma)
rv_indices.append(ctr)
self.p.model.connect('mu', 'oas_example1.Mach_number', src_indices=[ctr])
ctr += 1
if "re" in rv_dict:
self.rv_array = np.append(self.rv_array, mean_re)
rv_indices.append(ctr)
self.p.model.connect('mu', 'oas_example1.re', src_indices=[ctr])
ctr += 1
if "rho" in rv_dict:
self.rv_array = np.append(self.rv_array, mean_rho)
rv_indices.append(ctr)
self.p.model.connect('mu', 'oas_example1.rho', src_indices=[ctr])
ctr += 1
self.p.setup(force_alloc_complex=True)
self.p['mu'] = self.rv_array
def __init__(self, systemsize, input_dict, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize, data_type=data_type)
# Load the eigenmodes
fname = input_dict['surrogate info full path']
surrogate_info = np.load(fname)
surrogate_samples = surrogate_info['input_samples']
fval_arr = surrogate_info['fvals']
# Create the surrogate
self.surrogate_type = input_dict['surrogate_type']
if self.surrogate_type == 'quadratic':
self.surrogate = QP()
elif self.surrogate_type == 'kriging':
theta0 = input_dict['kriging_theta']
self.surrogate = KRG(theta0=[theta0],
corr=input_dict['correlation function'])
else:
raise NotImplementedError
self.surrogate.set_training_values(surrogate_samples.T, fval_arr)
self.surrogate.train()
def __init__(self, systemsize, input_dict, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize, data_type=data_type)
# Default attributes
self.input_dict = input_dict
self._write_files = False
self._aggregate_solutions = False
num_segments = input_dict['num_segments']
transcription_order = input_dict['transcription_order']
transcription_type = input_dict['transcription_type']
solve_segments = input_dict['solve_segments']
use_polynomial_control = input_dict['use_polynomial_control']
if 'write_files' in input_dict:
self._write_files = True
self._ctr1 = 0
self._target_directory = input_dict['target_output_directory']
if 'aggregate_solutions' in input_dict:
self._aggregate_solutions = True
self._ctr2 = 0
self.altitude_aggregate = {} # np.zeros(transcription_order*num_segments + 1)
self.aoa_aggregate = {} # np.zeros(transcription_order*num_segments)
def __init__(self, systemsize=2, n_parameters=2, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize)
self.data_type = data_type
self.n_parameters = n_parameters
self.dv = np.ones(n_parameters, dtype=self.data_type)
def __init__(self, systemsize, tuple):
QuantityOfInterest.__init__(self, systemsize)
self.extra_args = tuple
self.quadratic_matrix = np.diag([50, 1])
def __init__(self, systemsize, input_dict, data_type=np.float):
QuantityOfInterest.__init__(self, systemsize, data_type=data_type)
self.input_dict = input_dict
self.rv_dict = self.input_dict['rv_dict']
self.p = Problem()
self.rvs = self.p.model.add_subsystem('random_variables',
IndepVarComp(),
promotes_outputs=['*'])
self.p.model.add_subsystem(
'oas_scaneagle',
OASScanEagle(mesh_dict=self.input_dict['mesh_dict'],
rv_dict=self.rv_dict))
# Declare rvs units to ensure type stability
if 'Mach_number' in self.rv_dict:
self.rvs.add_output('Mach_number',
val=self.rv_dict['Mach_number']['mean'])
self.p.model.connect('Mach_number', 'oas_scaneagle.Mach_number')
if 'CT' in self.rv_dict:
# self.rvs.add_output('CT', val=self.rv_dict['CT']['mean'], units='1/s') # TSFC
self.rvs.add_output('CT',
val=self.rv_dict['CT']['mean'],
units='1/h') # TSFC
self.p.model.connect('CT', 'oas_scaneagle.CT')
if 'W0' in self.rv_dict:
self.rvs.add_output('W0',
val=self.rv_dict['W0']['mean'],
units='kg')
self.p.model.connect('W0', 'oas_scaneagle.W0')
if 'R' in self.rv_dict:
self.rvs.add_output('R', val=self.rv_dict['R']['mean'], units='km')
self.p.model.connect('R', 'oas_scaneagle.R')
if 'load_factor' in self.rv_dict:
self.rvs.add_output('load_factor',
val=self.rv_dict['load_factor']['mean'])
self.p.model.connect('load_factor', 'oas_scaneagle.load_factor')
self.p.model.connect(
'load_factor',
'oas_scaneagle.AS_point_0.coupled.wing.load_factor')
if 'E' in self.rv_dict:
self.rvs.add_output('E',
val=self.rv_dict['E']['mean'],
units='N/m**2')
self.p.model.connect('E',
'oas_scaneagle.wing.struct_setup.assembly.E')
self.p.model.connect(
'E',
'oas_scaneagle.AS_point_0.wing_perf.struct_funcs.vonmises.E')
if 'G' in self.rv_dict:
self.rvs.add_output('G',
val=self.rv_dict['G']['mean'],
units='N/m**2')
self.p.model.connect('G',
'oas_scaneagle.wing.struct_setup.assembly.G')
self.p.model.connect(
'G',
'oas_scaneagle.AS_point_0.wing_perf.struct_funcs.vonmises.G')
if 'mrho' in self.rv_dict:
self.rvs.add_output('mrho',
val=self.rv_dict['mrho']['mean'],
units='kg/m**3')
self.p.model.connect(
'mrho',
'oas_scaneagle.wing.struct_setup.structural_weight.mrho')
if 'altitude' in self.rv_dict:
self.rvs.add_output('altitude',
val=self.rv_dict['altitude']['mean'],
units='km')
self.p.model.connect('altitude', 'oas_scaneagle.altitude')
self.p.setup(check=False)
# Set up reusable arrays
self.dJ_ddv = np.zeros(
self.input_dict['ndv'],
dtype=self.data_type) # Used in eval_ObjGradient_dv
self.con_arr = np.zeros(
self.input_dict['n_constraints'],
dtype=self.data_type) # Used in eval_ConstraintQoI
self.con_jac = np.zeros(
(self.input_dict['n_constraints'], self.input_dict['ndv']),
dtype=self.data_type)
def __init__(self, systemsize):
QuantityOfInterest.__init__(self, systemsize)
def __init__(self, systemsize):
QuantityOfInterest.__init__(self, systemsize)
self.A = np.random.rand(systemsize)
def __init__(self, systemsize):
QuantityOfInterest.__init__(self, systemsize)
self.quadratic_matrix = np.diag([50, 40, 30, 20, 1])
def __init__(self, systemsize=2):
QuantityOfInterest.__init__(self, systemsize)
self.local_minima = np.zeros(2)
self.global_minima = 0.5 * np.array([-3 - np.sqrt(7), -3 - np.sqrt(7)])
self.saddle_point = 0.5 * np.array([-3 + np.sqrt(7), -3 + np.sqrt(7)])
def __init__(self, systemsize):
QuantityOfInterest.__init__(self, systemsize)
self.a = np.array([0.7, 0.3])
