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)
