def _load_dicts(self, full_directory): assert DictIO.exists_file( full_directory, "component_name_to_basis_component_index") self._component_name_to_basis_component_index = DictIO.load_file( full_directory, "component_name_to_basis_component_index", globals={ "ComponentNameToBasisComponentIndexDict": ComponentNameToBasisComponentIndexDict }) assert DictIO.exists_file( full_directory, "component_name_to_basis_component_length") self._component_name_to_basis_component_length = DictIO.load_file( full_directory, "component_name_to_basis_component_length", globals={"OnlineSizeDict": OnlineSizeDict}) it = AffineExpansionStorageContent_Iterator( self._content, flags=["multi_index", "refs_ok"], op_flags=["readonly"]) while not it.finished: if self._component_name_to_basis_component_index is not None: self._content[ it. multi_index]._component_name_to_basis_component_index = self._component_name_to_basis_component_index if self._component_name_to_basis_component_length is not None: self._content[ it. multi_index]._component_name_to_basis_component_length = self._component_name_to_basis_component_length it.iternext()
def _read_from_xdmf_file(fun, directory, filename, suffix, components=None): if components is not None: filename = filename + "_component_" + "".join(components) function_name = "function_" + "".join(components) else: function_name = "function" fun_rank = fun.value_rank() fun_dim = product(fun.value_shape()) assert fun_rank <= 2 if ((fun_rank is 1 and fun_dim not in (2, 3)) or (fun_rank is 2 and fun_dim not in (4, 9))): fun_V = fun.function_space() for i in range(fun_dim): if components is not None: filename_i = filename + "_subcomponent_" + str(i) else: filename_i = filename + "_component_" + str(i) fun_i_V = get_function_subspace(fun_V, i) fun_i = Function(fun_i_V) if not _read_from_xdmf_file(fun_i, directory, filename_i, suffix, None): return False else: assign(fun.sub(i), fun_i) return True else: full_filename_checkpoint = os.path.join(str(directory), filename + "_checkpoint.xdmf") file_exists = False if is_io_process() and os.path.exists(full_filename_checkpoint): file_exists = True file_exists = is_io_process.mpi_comm.bcast(file_exists, root=is_io_process.root) if file_exists: if suffix is not None: assert SuffixIO.exists_file(directory, filename + "_suffix") last_suffix = SuffixIO.load_file(directory, filename + "_suffix") if suffix <= last_suffix: if full_filename_checkpoint in _all_xdmf_files: assert _all_xdmf_latest_suffix[ full_filename_checkpoint] == suffix - 1 _all_xdmf_latest_suffix[ full_filename_checkpoint] = suffix else: assert suffix == 0 _all_xdmf_files[full_filename_checkpoint] = XDMFFile( full_filename_checkpoint) _all_xdmf_latest_suffix[full_filename_checkpoint] = 0 _all_xdmf_files[full_filename_checkpoint].read_checkpoint( fun, function_name, suffix) return True else: return False else: with XDMFFile(full_filename_checkpoint) as file_checkpoint: file_checkpoint.read_checkpoint(fun, function_name, 0) return True else: return False
def _load_content_item_type_shape(self, full_directory): assert ContentItemTypeIO.exists_file(full_directory, "content_item_type") content_item_type = ContentItemTypeIO.load_file( full_directory, "content_item_type") assert ContentItemShapeIO.exists_file(full_directory, "content_item_shape") assert content_item_type in ("matrix", "vector", "function", "scalar", "functions_list", "basis_functions_matrix", "empty") if content_item_type == "matrix": (M, N) = ContentItemShapeIO.load_file( full_directory, "content_item_shape", globals={"OnlineSizeDict": OnlineSizeDict}) return backend.Matrix(M, N) elif content_item_type == "vector": N = ContentItemShapeIO.load_file( full_directory, "content_item_shape", globals={"OnlineSizeDict": OnlineSizeDict}) return backend.Vector(N) elif content_item_type == "function": N = ContentItemShapeIO.load_file( full_directory, "content_item_shape", globals={"OnlineSizeDict": OnlineSizeDict}) return backend.Function(N) elif content_item_type == "scalar": return 0. elif content_item_type == "functions_list": # self._content has already been populated with empty items assert isinstance(self._content[self._smallest_key], AbstractFunctionsList) return self._content[self._smallest_key] elif content_item_type == "basis_functions_matrix": # self._content has already been populated with empty items assert isinstance(self._content[self._smallest_key], AbstractBasisFunctionsMatrix) return self._content[self._smallest_key] elif content_item_type == "empty": return None else: # impossible to arrive here anyway thanks to the assert raise ValueError("Invalid content item type.")
def import_(solution, directory, filename, suffix=None, component=None): if TextIO.exists_file(directory, filename): loaded_solution = TextIO.load_file(directory, filename) assert len(solution) == len(loaded_solution) for (i, solution_i) in enumerate(loaded_solution): solution[i] = float(solution_i) return True else: return False
def import_(solution, directory, filename, suffix=None, component=None): if suffix is not None: filename = filename + "_" + str(suffix) if TextIO.exists_file(directory, filename): loaded_solution = TextIO.load_file(directory, filename) assert len(solution) == len(loaded_solution) for (i, solution_i) in enumerate(loaded_solution): solution[i] = float(solution_i) else: raise OSError
def load(self, directory, filename): if len(self._enrich_memory) > 0: # avoid loading multiple times return False else: assert LengthIO.exists_file(directory, filename + "_length") len_memory = LengthIO.load_file(directory, filename + "_length") for index in range(len_memory): memory = DelayedLinearSolver() memory.load(directory, filename + "_" + str(index)) self.enrich(memory) return True
def load(self, directory, filename): # Get full directory name full_directory = Folders.Folder(os.path.join(str(directory), filename)) # Load problem corresponding to self._lhs, and update self._lhs accordingly assert self._lhs is None assert LHSIO.exists_file(full_directory, "lhs_problem_name") lhs_problem_name = LHSIO.load_file(full_directory, "lhs_problem_name") lhs_problem = get_problem_from_problem_name(lhs_problem_name) lhs_reduced_problem = get_reduced_problem_from_problem(lhs_problem) self._lhs = lhs_reduced_problem._riesz_solve_inner_product # Load problem corresponding to self._solution, and update self._solution accordingly assert self._solution is None assert SolutionIO.exists_file(full_directory, "solution_problem_name") solution_problem_name = SolutionIO.load_file(full_directory, "solution_problem_name") solution_problem = get_problem_from_problem_name(solution_problem_name) solution_reduced_problem = get_reduced_problem_from_problem( solution_problem) self._solution = solution_reduced_problem._riesz_solve_storage # Load problem and operator corresponding to self._rhs, and update self._solution accordingly assert self._rhs is None assert RHSIO.exists_file(full_directory, "rhs_type") rhs_type = RHSIO.load_file(full_directory, "rhs_type") assert rhs_type in ("ParametrizedTensorFactory", "DelayedProduct") if rhs_type == "ParametrizedTensorFactory": assert RHSIO.exists_file(full_directory, "rhs_arg_0") (rhs_problem_name_0, rhs_term_0, rhs_index_0) = RHSIO.load_file(full_directory, "rhs_arg_0") rhs_problem_0 = get_problem_from_problem_name(rhs_problem_name_0) rhs_arg_0 = rhs_problem_0.operator[rhs_term_0][rhs_index_0] assert isinstance(rhs_arg_0, AbstractParametrizedTensorFactory) self._rhs = rhs_arg_0 elif rhs_type == "DelayedProduct": assert RHSIO.exists_file(full_directory, "rhs_arg_0") rhs_arg_0 = RHSIO.load_file(full_directory, "rhs_arg_0") assert rhs_arg_0 == -1.0 assert RHSIO.exists_file(full_directory, "rhs_arg_1") (rhs_problem_name_1, rhs_term_1, rhs_index_1) = RHSIO.load_file(full_directory, "rhs_arg_1") rhs_problem_1 = get_problem_from_problem_name(rhs_problem_name_1) rhs_arg_1 = rhs_problem_1.operator[rhs_term_1][rhs_index_1] assert isinstance(rhs_arg_1, AbstractParametrizedTensorFactory) assert RHSIO.exists_file(full_directory, "rhs_arg_2") (rhs_problem_name_2, rhs_component_2, rhs_index_2) = RHSIO.load_file(full_directory, "rhs_arg_2") rhs_problem_2 = get_problem_from_problem_name(rhs_problem_name_2) rhs_reduced_problem_2 = get_reduced_problem_from_problem( rhs_problem_2) if rhs_component_2 is not None: rhs_arg_2 = rhs_reduced_problem_2.basis_functions[ rhs_component_2][rhs_index_2] else: rhs_arg_2 = rhs_reduced_problem_2.basis_functions[rhs_index_2] rhs = DelayedProduct(rhs_arg_0) rhs *= rhs_arg_1 rhs *= rhs_arg_2 self._rhs = rhs else: raise TypeError("Invalid rhs") # Load problem corresponding to self._bcs, and update self._bcs accordingly assert self._bcs is None assert BCsIO.exists_file(full_directory, "bcs_problem_name") bcs_problem_name = BCsIO.load_file(full_directory, "bcs_problem_name") bcs_problem = get_problem_from_problem_name(bcs_problem_name) bcs_reduced_problem = get_reduced_problem_from_problem(bcs_problem) self._bcs = bcs_reduced_problem._riesz_solve_homogeneous_dirichlet_bc # Load parameters assert len(self._parameters) is 0 assert ParametersIO.exists_file(full_directory, "parameters") self._parameters = ParametersIO.load_file(full_directory, "parameters") # Return return True
def _diff_txt(reference_file, current_file): reference_content = TextIO.load_file("", reference_file) current_content = TextIO.load_file("", current_file) return _diff_content(reference_content, current_content, "")
def load(self, directory, filename): if self._type != "empty": # avoid loading multiple times if self._type in ("basis_functions_matrix", "functions_list"): delayed_functions = self._content[self._type] it = NonAffineExpansionStorageContent_Iterator( delayed_functions, flags=["c_index", "multi_index", "refs_ok"], op_flags=["readonly"]) while not it.finished: if isinstance(delayed_functions[it.multi_index], DelayedFunctionsList): assert self._type == "functions_list" if len( delayed_functions[it.multi_index] ) > 0: # ... unless it is an empty FunctionsList return False elif isinstance(delayed_functions[it.multi_index], DelayedBasisFunctionsMatrix): assert self._type == "basis_functions_matrix" if sum( delayed_functions[it.multi_index]. _component_name_to_basis_component_length. values() ) > 0: # ... unless it is an empty BasisFunctionsMatrix return False else: raise TypeError("Invalid delayed functions") it.iternext() else: return False # Get full directory name full_directory = Folders.Folder(os.path.join(str(directory), filename)) # Detect trivial case assert TypeIO.exists_file(full_directory, "type") imported_type = TypeIO.load_file(full_directory, "type") self._type = imported_type assert self._type in ("basis_functions_matrix", "empty", "error_estimation_operators_11", "error_estimation_operators_21", "error_estimation_operators_22", "functions_list", "operators") if self._type in ("basis_functions_matrix", "functions_list"): # Load delayed functions assert self._type in self._content delayed_functions = self._content[self._type] it = NonAffineExpansionStorageContent_Iterator( delayed_functions, flags=["c_index", "multi_index", "refs_ok"]) while not it.finished: delayed_function = delayed_functions[it.multi_index] delayed_function.load(full_directory, "delayed_functions_" + str(it.index)) it.iternext() elif self._type == "empty": pass elif self._type in ("error_estimation_operators_11", "error_estimation_operators_21", "error_estimation_operators_22"): # Load delayed functions assert "delayed_functions" not in self._content self._content["delayed_functions"] = [ NonAffineExpansionStorageContent_Base(self._shape[0], dtype=object), NonAffineExpansionStorageContent_Base(self._shape[1], dtype=object) ] for (index, delayed_functions) in enumerate( self._content["delayed_functions"]): it = NonAffineExpansionStorageContent_Iterator( delayed_functions, flags=["c_index", "refs_ok"]) while not it.finished: assert DelayedFunctionsTypeIO.exists_file( full_directory, "delayed_functions_" + str(index) + "_" + str(it.index) + "_type") delayed_function_type = DelayedFunctionsTypeIO.load_file( full_directory, "delayed_functions_" + str(index) + "_" + str(it.index) + "_type") assert DelayedFunctionsProblemNameIO.exists_file( full_directory, "delayed_functions_" + str(index) + "_" + str(it.index) + "_problem_name") delayed_function_problem_name = DelayedFunctionsProblemNameIO.load_file( full_directory, "delayed_functions_" + str(index) + "_" + str(it.index) + "_problem_name") delayed_function_problem = get_problem_from_problem_name( delayed_function_problem_name) assert delayed_function_type in ( "DelayedBasisFunctionsMatrix", "DelayedLinearSolver") if delayed_function_type == "DelayedBasisFunctionsMatrix": delayed_function = DelayedBasisFunctionsMatrix( delayed_function_problem.V) delayed_function.init( delayed_function_problem.components) elif delayed_function_type == "DelayedLinearSolver": delayed_function = DelayedLinearSolver() else: raise ValueError("Invalid delayed function") delayed_function.load( full_directory, "delayed_functions_" + str(index) + "_" + str(it.index) + "_content") delayed_functions[it.index] = delayed_function it.iternext() # Load inner product assert ErrorEstimationInnerProductIO.exists_file( full_directory, "inner_product_matrix_problem_name") inner_product_matrix_problem_name = ErrorEstimationInnerProductIO.load_file( full_directory, "inner_product_matrix_problem_name") inner_product_matrix_problem = get_problem_from_problem_name( inner_product_matrix_problem_name) inner_product_matrix_reduced_problem = get_reduced_problem_from_problem( inner_product_matrix_problem) self._content[ "inner_product_matrix"] = inner_product_matrix_reduced_problem._error_estimation_inner_product # Recompute shape assert "delayed_functions_shape" not in self._content self._content["delayed_functions_shape"] = DelayedTransposeShape( (self._content["delayed_functions"][0][0], self._content["delayed_functions"][1][0])) # Prepare precomputed slices self._precomputed_slices.clear() self._prepare_trivial_precomputed_slice() elif self._type == "empty": pass elif self._type == "operators": # Load truth content assert "truth_operators" not in self._content self._content[ "truth_operators"] = NonAffineExpansionStorageContent_Base( self._shape, dtype=object) it = NonAffineExpansionStorageContent_Iterator( self._content["truth_operators"], flags=["c_index", "multi_index", "refs_ok"]) while not it.finished: assert TruthContentItemIO.exists_file( full_directory, "truth_operator_" + str(it.index) + "_type") operator_type = TruthContentItemIO.load_file( full_directory, "truth_operator_" + str(it.index) + "_type") assert operator_type in ("NumericForm", "ParametrizedTensorFactory") if operator_type == "NumericForm": assert TruthContentItemIO.exists_file( full_directory, "truth_operator_" + str(it.index)) value = TruthContentItemIO.load_file( full_directory, "truth_operator_" + str(it.index)) self._content["truth_operators"][ it.multi_index] = NumericForm(value) elif operator_type == "ParametrizedTensorFactory": assert TruthContentItemIO.exists_file( full_directory, "truth_operator_" + str(it.index)) (problem_name, term, index) = TruthContentItemIO.load_file( full_directory, "truth_operator_" + str(it.index)) truth_problem = get_problem_from_problem_name(problem_name) self._content["truth_operators"][ it.multi_index] = truth_problem.operator[term][index] else: raise ValueError("Invalid operator type") it.iternext() assert "truth_operators_as_expansion_storage" not in self._content self._prepare_truth_operators_as_expansion_storage() # Load basis functions content assert BasisFunctionsContentLengthIO.exists_file( full_directory, "basis_functions_length") basis_functions_length = BasisFunctionsContentLengthIO.load_file( full_directory, "basis_functions_length") assert basis_functions_length in (0, 1, 2) assert "basis_functions" not in self._content self._content["basis_functions"] = list() for index in range(basis_functions_length): assert BasisFunctionsProblemNameIO.exists_file( full_directory, "basis_functions_" + str(index) + "_problem_name") basis_functions_problem_name = BasisFunctionsProblemNameIO.load_file( full_directory, "basis_functions_" + str(index) + "_problem_name") assert BasisFunctionsProblemNameIO.exists_file( full_directory, "basis_functions_" + str(index) + "_components_name") basis_functions_components_name = BasisFunctionsProblemNameIO.load_file( full_directory, "basis_functions_" + str(index) + "_components_name") basis_functions_problem = get_problem_from_problem_name( basis_functions_problem_name) basis_functions_reduced_problem = get_reduced_problem_from_problem( basis_functions_problem) basis_functions = basis_functions_reduced_problem.basis_functions if basis_functions_components_name != basis_functions_problem.components: basis_functions = basis_functions[ basis_functions_components_name] self._content["basis_functions"].append(basis_functions) # Recompute shape self._content["basis_functions_shape"] = DelayedTransposeShape( self._content["basis_functions"]) # Reset precomputed slices self._precomputed_slices.clear() self._prepare_trivial_precomputed_slice() else: raise ValueError("Invalid type") return True
def load_file(directory, filename): if not filename.endswith(".vmp"): filename = filename + ".vmp" return TextIO.load_file(directory, filename)
def _load_item_vector_dimension(self, full_directory): N = ItemVectorDimensionIO.load_file(full_directory, "item_vector_dimension") return OnlineVector(N)
def _load_len(self, full_directory): assert LenIO.exists_file(full_directory, "len") return LenIO.load_file(full_directory, "len")
def _init_last_index(self): if IndexIO.exists_file(self._directory, self._filename + "_index.sfx"): self._last_index = IndexIO.load_file(self._directory, self._filename + "_index.sfx") else: self._last_index = -1
def _load_content(self, item, it, full_directory): while not it.finished: self._content[it.multi_index] = ScalarContentIO.load_file( full_directory, "content_item_" + str(it.index)) it.iternext()
def _load_Nmax(self, full_directory): assert NmaxIO.exists_file(full_directory, "Nmax") return NmaxIO.load_file(full_directory, "Nmax")