def __init__(self, V, **kwargs): # Call parent ParametrizedProblem.__init__( self, os.path.join("test_eim_approximation_17_tempdir", expression_type, basis_generation, "mock_problem")) # Minimal subset of a ParametrizedDifferentialProblem self.V = V self._solution = Function(V) self.components = ["u", "s", "p"] # Parametrized function to be interpolated x = SpatialCoordinate(V.mesh()) mu = SymbolicParameters(self, V, (-1., -1.)) self.f00 = 1. / sqrt( pow(x[0] - mu[0], 2) + pow(x[1] - mu[1], 2) + 0.01) self.f01 = 1. / sqrt( pow(x[0] - mu[0], 4) + pow(x[1] - mu[1], 4) + 0.01) # Inner product f = TrialFunction(self.V) g = TestFunction(self.V) self.inner_product = assemble(inner(f, g) * dx) # Collapsed vector and space self.V0 = V.sub(0).collapse() self.V00 = V.sub(0).sub(0).collapse() self.V1 = V.sub(1).collapse()
def __init__(self, truth_problem, parametrized_expression, folder_prefix, basis_generation): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # Store the parametrized expression self.parametrized_expression = parametrized_expression self.truth_problem = truth_problem assert basis_generation in ("Greedy", "POD") self.basis_generation = basis_generation # $$ ONLINE DATA STRUCTURES $$ # # Online reduced space dimension self.N = 0 # Define additional storage for EIM self.interpolation_locations = parametrized_expression.create_interpolation_locations_container( ) # interpolation locations selected by the greedy (either a ReducedVertices or ReducedMesh) self.interpolation_matrix = OnlineAffineExpansionStorage( 1) # interpolation matrix # Solution self._interpolation_coefficients = None # OnlineFunction # $$ OFFLINE DATA STRUCTURES $$ # self.snapshot = None # will be filled in by Function, Vector or Matrix as appropriate in the EIM preprocessing self.snapshot_cache = dict() # of Function, Vector or Matrix # Basis functions container self.basis_functions = parametrized_expression.create_basis_container() # I/O self.folder["basis"] = os.path.join(self.folder_prefix, "basis") self.folder["cache"] = os.path.join(self.folder_prefix, "cache") self.folder["reduced_operators"] = os.path.join( self.folder_prefix, "reduced_operators") self.cache_config = config.get("EIM", "cache")
def __init__(self, reduced_problem, spectrum, eigensolver_parameters, folder_prefix): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # this class does not export anything self.reduced_problem = reduced_problem # Matrices/vectors resulting from the truth discretization self.operator = { "stability_factor_left_hand_matrix": None, # OnlineAffineExpansionStorage "stability_factor_right_hand_matrix": None # OnlineAffineExpansionStorage, even though it will contain only one matrix } self.spectrum = spectrum self.eigensolver_parameters = eigensolver_parameters # Solution self._eigenvalue = 0. self._eigenvector = None # OnlineFunction # I/O def _eigenvalue_cache_key_generator(*args, **kwargs): return args self._eigenvalue_cache = Cache( "reduced problems", key_generator=_eigenvalue_cache_key_generator ) def _eigenvector_cache_key_generator(*args, **kwargs): return args self._eigenvector_cache = Cache( "reduced problems", key_generator=_eigenvector_cache_key_generator )
def __init__(self, truth_problem, term, multiply_by_theta, spectrum, eigensolver_parameters, folder_prefix): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # this class does not export anything self.truth_problem = truth_problem # Matrices/vectors resulting from the truth discretization self.term = term assert isinstance(self.term, (tuple, str)) if isinstance(self.term, tuple): assert len(self.term) == 2 isinstance(self.term[0], str) isinstance(self.term[1], int) self.multiply_by_theta = multiply_by_theta assert isinstance(self.multiply_by_theta, bool) self.operator = None # AffineExpansionStorage self.inner_product = None # AffineExpansionStorage, even though it will contain only one matrix self.spectrum = spectrum self.eigensolver_parameters = eigensolver_parameters # Avoid useless computations self._eigenvalue = 0. self._eigenvalue_cache = dict() self._eigenvector = Function(truth_problem.V) self._eigenvector_cache = dict() self.folder["cache"] = os.path.join(folder_prefix, "cache") self.cache_config = config.get("problems", "cache")
def __init__(self, truth_problem, **kwargs): # Call parent ParametrizedProblem.__init__(self, os.path.join("test_eim_approximation_15_tempdir", expression_type, basis_generation, "mock_problem")) # Minimal subset of a ParametrizedReducedDifferentialProblem self.truth_problem = truth_problem self.basis_functions = BasisFunctionsMatrix(self.truth_problem.V) self.basis_functions.init(self.truth_problem.components) self._solution = None
def __init__(self, V, **kwargs): ParametrizedProblem.__init__(self, "") self.V = V # Minimal subset of a time dependent ParametrizedDifferentialProblem self.t0 = 0. self.t = 0. self.dt = 0. self.T = 0.
def __init__(self, truth_problem, term, multiply_by_theta, spectrum, eigensolver_parameters, folder_prefix): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # this class does not export anything self.truth_problem = truth_problem # Matrices/vectors resulting from the truth discretization self.term = term assert isinstance(self.term, (tuple, str)) if isinstance(self.term, tuple): assert len(self.term) == 2 isinstance(self.term[0], str) isinstance(self.term[1], int) self.multiply_by_theta = multiply_by_theta assert isinstance(self.multiply_by_theta, bool) self.operator = None # AffineExpansionStorage self.inner_product = None # AffineExpansionStorage, even though it will contain only one matrix self.spectrum = spectrum self.eigensolver_parameters = eigensolver_parameters # Avoid useless computations self._eigenvalue = 0. self._eigenvector = Function(truth_problem.V) # I/O self.folder["cache"] = os.path.join(folder_prefix, "cache") def _eigenvalue_cache_key_generator(*args, **kwargs): return args def _eigenvalue_cache_import(filename): self.import_eigenvalue(self.folder["cache"], filename) return self._eigenvalue def _eigenvalue_cache_export(filename): self.export_eigenvalue(self.folder["cache"], filename) def _eigenvalue_cache_filename_generator(*args, **kwargs): return self._cache_file(args) self._eigenvalue_cache = Cache( "problems", key_generator=_eigenvalue_cache_key_generator, import_=_eigenvalue_cache_import, export=_eigenvalue_cache_export, filename_generator=_eigenvalue_cache_filename_generator ) def _eigenvector_cache_key_generator(*args, **kwargs): return args def _eigenvector_cache_import(filename): self.import_eigenvector(self.folder["cache"], filename) return self._eigenvector def _eigenvector_cache_export(filename): self.export_eigenvector(self.folder["cache"], filename) def _eigenvector_cache_filename_generator(*args, **kwargs): return self._cache_file(args) self._eigenvector_cache = Cache( "problems", key_generator=_eigenvector_cache_key_generator, import_=_eigenvector_cache_import, export=_eigenvector_cache_export, filename_generator=_eigenvector_cache_filename_generator )
def __init__(self, truth_problem, parametrized_expression, folder_prefix, basis_generation): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # Store the parametrized expression self.parametrized_expression = parametrized_expression self.truth_problem = truth_problem assert basis_generation in ("Greedy", "POD") self.basis_generation = basis_generation # $$ ONLINE DATA STRUCTURES $$ # # Online reduced space dimension self.N = 0 # Define additional storage for EIM: # Interpolation locations selected by the greedy (either a ReducedVertices or ReducedMesh)_ self.interpolation_locations = parametrized_expression.create_interpolation_locations_container( ) # Interpolation matrix self.interpolation_matrix = OnlineAffineExpansionStorage(1) # Solution self._interpolation_coefficients = None # OnlineFunction # $$ OFFLINE DATA STRUCTURES $$ # self.snapshot = parametrized_expression.create_empty_snapshot() # Basis functions container self.basis_functions = parametrized_expression.create_basis_container() # I/O self.folder["basis"] = os.path.join(self.folder_prefix, "basis") self.folder["cache"] = os.path.join(self.folder_prefix, "cache") self.folder["reduced_operators"] = os.path.join( self.folder_prefix, "reduced_operators") def _snapshot_cache_key_generator(*args, **kwargs): assert args == self.mu assert len(kwargs) == 0 return self._cache_key() def _snapshot_cache_import(filename): snapshot = copy(self.snapshot) self.import_solution(self.folder["cache"], filename, snapshot) return snapshot def _snapshot_cache_export(filename): self.export_solution(self.folder["cache"], filename) def _snapshot_cache_filename_generator(*args, **kwargs): assert args == self.mu assert len(kwargs) == 0 return self._cache_file() self._snapshot_cache = Cache( "EIM", key_generator=_snapshot_cache_key_generator, import_=_snapshot_cache_import, export=_snapshot_cache_export, filename_generator=_snapshot_cache_filename_generator)
def __init__(self, truth_problem, folder_prefix, **kwargs): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # Store the parametrized problem object and the bc list self.truth_problem = truth_problem # Define additional storage for SCM self.B_min = BoundingBoxSideList( ) # minimum values of the bounding box mathcal{B}. Vector of size Q self.B_max = BoundingBoxSideList( ) # maximum values of the bounding box mathcal{B}. Vector of size Q self.training_set = None # SCM algorithm needs the training set also in the online stage self.greedy_selected_parameters = GreedySelectedParametersList( ) # list storing the parameters selected during the training phase self.greedy_selected_parameters_complement = dict( ) # dict, over N, of list storing the complement of parameters selected during the training phase self.UB_vectors = UpperBoundsList( ) # list of Q-dimensional vectors storing the infimizing elements at the greedily selected parameters self.N = 0 self.M_e = kwargs[ "M_e"] # integer denoting the number of constraints based on the exact eigenvalues, or None self.M_p = kwargs[ "M_p"] # integer denoting the number of constraints based on the previous lower bounds, or None # I/O self.folder["cache"] = os.path.join(self.folder_prefix, "reduced_cache") self.cache_config = config.get("SCM", "cache") self.folder["reduced_operators"] = os.path.join( self.folder_prefix, "reduced_operators") # Coercivity constant eigen problem self.exact_coercivity_constant_calculator = ParametrizedCoercivityConstantEigenProblem( truth_problem, "a", True, "smallest", kwargs["coercivity_eigensolver_parameters"], self.folder_prefix) # Store here input parameters provided by the user that are needed by the reduction method self._input_storage_for_SCM_reduction = dict() self._input_storage_for_SCM_reduction[ "bounding_box_minimum_eigensolver_parameters"] = kwargs[ "bounding_box_minimum_eigensolver_parameters"] self._input_storage_for_SCM_reduction[ "bounding_box_maximum_eigensolver_parameters"] = kwargs[ "bounding_box_maximum_eigensolver_parameters"] # Avoid useless linear programming solves self._alpha_LB = 0. self._alpha_LB_cache = dict() self._alpha_UB = 0. self._alpha_UB_cache = dict()
def __init__(self, V, **kwargs): # Call parent ParametrizedProblem.__init__(self, os.path.join("test_eim_approximation_12_tempdir", expression_type, basis_generation, "mock_problem")) # Minimal subset of a ParametrizedDifferentialProblem self.V = V self._solution = Function(V) self.components = ["u"] # Parametrized function to be interpolated x = SpatialCoordinate(V.mesh()) mu = SymbolicParameters(self, V, (1., )) self.f = (1-x[0])*cos(3*pi*mu[0]*(1+x[0]))*exp(-mu[0]*(1+x[0])) # Inner product f = TrialFunction(self.V) g = TestFunction(self.V) self.inner_product = assemble(f*g*dx)
def __init__(self, V, **kwargs): ParametrizedProblem.__init__(self, "") self.V = V
def __init__(self, truth_problem, spectrum, eigensolver_parameters, folder_prefix, expansion_index=None): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) self.truth_problem = truth_problem # Matrices/vectors resulting from the truth discretization self.expansion_index = expansion_index self.operator = { "stability_factor_left_hand_matrix": None, # AffineExpansionStorage "stability_factor_right_hand_matrix": None # AffineExpansionStorage, even though it will contain only one matrix } self.dirichlet_bc = None # AffineExpansionStorage self.spectrum = spectrum self.eigensolver_parameters = eigensolver_parameters # Solution self._eigenvalue = 0. self._eigenvector = Function(truth_problem.stability_factor_V) # I/O self.folder["cache"] = os.path.join(folder_prefix, "cache") def _eigenvalue_cache_key_generator(*args, **kwargs): return args def _eigenvalue_cache_import(filename): self.import_eigenvalue(self.folder["cache"], filename) return self._eigenvalue def _eigenvalue_cache_export(filename): self.export_eigenvalue(self.folder["cache"], filename) def _eigenvalue_cache_filename_generator(*args, **kwargs): return self._cache_file(args) self._eigenvalue_cache = Cache( "problems", key_generator=_eigenvalue_cache_key_generator, import_=_eigenvalue_cache_import, export=_eigenvalue_cache_export, filename_generator=_eigenvalue_cache_filename_generator) def _eigenvector_cache_key_generator(*args, **kwargs): return args def _eigenvector_cache_import(filename): self.import_eigenvector(self.folder["cache"], filename) return self._eigenvector def _eigenvector_cache_export(filename): self.export_eigenvector(self.folder["cache"], filename) def _eigenvector_cache_filename_generator(*args, **kwargs): return self._cache_file(args) self._eigenvector_cache = Cache( "problems", key_generator=_eigenvector_cache_key_generator, import_=_eigenvector_cache_import, export=_eigenvector_cache_export, filename_generator=_eigenvector_cache_filename_generator)
def __init__(self, truth_problem, folder_prefix): # Call the parent initialization ParametrizedProblem.__init__(self, folder_prefix) # Store the parametrized problem object and the bc list self.truth_problem = truth_problem # Define additional storage for SCM self.bounding_box_min = BoundingBoxSideList( ) # minimum values of the bounding box. Vector of size Q self.bounding_box_max = BoundingBoxSideList( ) # maximum values of the bounding box. Vector of size Q self.training_set = None # SCM algorithm needs the training set also in the online stage # greedy_selected_parameters: list storing the parameters selected during the training phase self.greedy_selected_parameters = GreedySelectedParametersList() # greedy_selected_parameters_complement: dict, over N, of list storing the complement of parameters # selected during the training phase self.greedy_selected_parameters_complement = dict() # upper_bound_vectors: list of Q-dimensional vectors storing the infimizing elements at the greedily # selected parameters self.upper_bound_vectors = UpperBoundsList() self.N = 0 # Storage for online computations self._stability_factor_lower_bound = 0. self._stability_factor_upper_bound = 0. # I/O self.folder["cache"] = os.path.join(self.folder_prefix, "reduced_cache") self.folder["reduced_operators"] = os.path.join( self.folder_prefix, "reduced_operators") def _stability_factor_cache_key_generator(*args, **kwargs): assert len(args) == 2 assert args[0] == self.mu assert len(kwargs) == 0 return self._cache_key(args[1]) def _stability_factor_cache_filename_generator(*args, **kwargs): assert len(args) == 2 assert args[0] == self.mu assert len(kwargs) == 0 return self._cache_file(args[1]) def _stability_factor_lower_bound_cache_import(filename): self.import_stability_factor_lower_bound(self.folder["cache"], filename) return self._stability_factor_lower_bound def _stability_factor_lower_bound_cache_export(filename): self.export_stability_factor_lower_bound(self.folder["cache"], filename) self._stability_factor_lower_bound_cache = Cache( "SCM", key_generator=_stability_factor_cache_key_generator, import_=_stability_factor_lower_bound_cache_import, export=_stability_factor_lower_bound_cache_export, filename_generator=_stability_factor_cache_filename_generator) def _stability_factor_upper_bound_cache_import(filename): self.import_stability_factor_upper_bound(self.folder["cache"], filename) return self._stability_factor_upper_bound def _stability_factor_upper_bound_cache_export(filename): self.export_stability_factor_upper_bound(self.folder["cache"], filename) self._stability_factor_upper_bound_cache = Cache( "SCM", key_generator=_stability_factor_cache_key_generator, import_=_stability_factor_upper_bound_cache_import, export=_stability_factor_upper_bound_cache_export, filename_generator=_stability_factor_cache_filename_generator) # Stability factor eigen problem self.stability_factor_calculator = ParametrizedStabilityFactorEigenProblem( self.truth_problem, "smallest", self.truth_problem._eigen_solver_parameters["stability_factor"], self.folder_prefix)