From 5bb869cbdbd7694195702a31b3645a03d7e56e09 Mon Sep 17 00:00:00 2001 From: Raul Bravo Date: Fri, 19 Apr 2024 16:12:04 +0200 Subject: [PATCH 1/5] eraring legacy solvers --- ...vection_diffusion_stationary_rom_solver.py | 49 ----------------- ...nvection_diffusion_transient_rom_solver.py | 49 ----------------- .../navier_stokes_solver_vmsmonolithic_rom.py | 40 -------------- ...l_mechanics_implicit_dynamic_rom_solver.py | 52 ------------------- .../structural_mechanics_static_rom_solver.py | 49 ----------------- 5 files changed, 239 deletions(-) delete mode 100644 applications/RomApplication/python_scripts/convection_diffusion_stationary_rom_solver.py delete mode 100644 applications/RomApplication/python_scripts/convection_diffusion_transient_rom_solver.py delete mode 100644 applications/RomApplication/python_scripts/navier_stokes_solver_vmsmonolithic_rom.py delete mode 100644 applications/RomApplication/python_scripts/structural_mechanics_implicit_dynamic_rom_solver.py delete mode 100644 applications/RomApplication/python_scripts/structural_mechanics_static_rom_solver.py diff --git a/applications/RomApplication/python_scripts/convection_diffusion_stationary_rom_solver.py b/applications/RomApplication/python_scripts/convection_diffusion_stationary_rom_solver.py deleted file mode 100644 index b6167e2f6346..000000000000 --- a/applications/RomApplication/python_scripts/convection_diffusion_stationary_rom_solver.py +++ /dev/null @@ -1,49 +0,0 @@ - -# Importing the Kratos Library -import KratosMultiphysics - -# Import applications -import KratosMultiphysics.ConvectionDiffusionApplication as ConvectionDiffusionApplication - -# Import base class file -from KratosMultiphysics.ConvectionDiffusionApplication.convection_diffusion_stationary_solver import ConvectionDiffusionStationarySolver -import KratosMultiphysics.RomApplication as romapp - -def CreateSolver(model, custom_settings): - return ROMSolver(model, custom_settings) - -class ROMSolver(ConvectionDiffusionStationarySolver): - """The stationary class for ROM convection-diffusion solvers. - - See convection_diffusion_stationary_solver.py for more information. - """ - - def __init__(self, model, custom_settings): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'convection_diffusion_stationary_rom_solver\'", "class is deprecated. Use the generic\'RomSolver\' one instead.") - - super(ROMSolver, self).__init__(model, custom_settings) - KratosMultiphysics.Logger.PrintInfo("::[ROMSolver]:: ", "Construction finished") - - #### Private functions #### - @classmethod - def GetDefaultParameters(cls): - default_settings = KratosMultiphysics.Parameters(""" - { - "rom_settings": { - "nodal_unknowns": [ "TEMPERATURE" ], - "number_of_rom_dofs": 3 - } - } - """) - default_settings.AddMissingParameters(super(ROMSolver,cls).GetDefaultParameters()) - return default_settings - - def AddVariables(self): - super(ROMSolver, self).AddVariables() #Adding nodal area variable - self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_AREA) - - def _CreateBuilderAndSolver(self): - linear_solver = self._GetLinearSolver() - rom_parameters=self.settings["rom_settings"] - builder_and_solver = romapp.ROMBuilderAndSolver(linear_solver, rom_parameters) - return builder_and_solver diff --git a/applications/RomApplication/python_scripts/convection_diffusion_transient_rom_solver.py b/applications/RomApplication/python_scripts/convection_diffusion_transient_rom_solver.py deleted file mode 100644 index 422c7f618a87..000000000000 --- a/applications/RomApplication/python_scripts/convection_diffusion_transient_rom_solver.py +++ /dev/null @@ -1,49 +0,0 @@ - -# Importing the Kratos Library -import KratosMultiphysics - -# Import applications -import KratosMultiphysics.ConvectionDiffusionApplication as ConvectionDiffusionApplication - -# Import base class file -from KratosMultiphysics.ConvectionDiffusionApplication.convection_diffusion_transient_solver import ConvectionDiffusionTransientSolver -import KratosMultiphysics.RomApplication as romapp - -def CreateSolver(model, custom_settings): - return ROMSolver(model, custom_settings) - -class ROMSolver(ConvectionDiffusionTransientSolver): - """The transient class for ROM convection-diffusion solvers. - - See convection_diffusion_transient_solver.py for more information. - """ - - def __init__(self, model, custom_settings): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'convection_diffusion_transient_rom_solver\'", "class is deprecated. Use the generic\'RomSolver\' one instead.") - - super(ROMSolver, self).__init__(model, custom_settings) - KratosMultiphysics.Logger.PrintInfo("::[ROMSolver]:: ", "Construction finished") - - #### Private functions #### - @classmethod - def GetDefaultParameters(cls): - default_settings = KratosMultiphysics.Parameters(""" - { - "rom_settings": { - "nodal_unknowns": [ "TEMPERATURE" ], - "number_of_rom_dofs": 3 - } - } - """) - default_settings.AddMissingParameters(super(ROMSolver,cls).GetDefaultParameters()) - return default_settings - - def AddVariables(self): - super(ROMSolver, self).AddVariables() #Adding nodal area variable - self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_AREA) - - def _CreateBuilderAndSolver(self): - linear_solver = self._GetLinearSolver() - rom_parameters=self.settings["rom_settings"] - builder_and_solver = romapp.ROMBuilderAndSolver(linear_solver, rom_parameters) - return builder_and_solver diff --git a/applications/RomApplication/python_scripts/navier_stokes_solver_vmsmonolithic_rom.py b/applications/RomApplication/python_scripts/navier_stokes_solver_vmsmonolithic_rom.py deleted file mode 100644 index 2da95966ec96..000000000000 --- a/applications/RomApplication/python_scripts/navier_stokes_solver_vmsmonolithic_rom.py +++ /dev/null @@ -1,40 +0,0 @@ -# Importing the Kratos Library -import KratosMultiphysics - -# Import applications -import KratosMultiphysics.FluidDynamicsApplication as KratosCFD - -# Import base class file -from KratosMultiphysics.FluidDynamicsApplication.navier_stokes_solver_vmsmonolithic import NavierStokesSolverMonolithic -import KratosMultiphysics.RomApplication as romapp - -def CreateSolver(model, custom_settings): - return ROMSolver(model, custom_settings) - -class ROMSolver(NavierStokesSolverMonolithic): - - def __init__(self, model, custom_settings): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'navier_stokes_solver_vmsmonolithic_rom\'", "class is deprecated. Use the generic\'RomSolver\' one instead.") - - super().__init__(model, custom_settings) - KratosMultiphysics.Logger.PrintInfo("::[ROMSolver]:: ", "Construction finished") - - #### Private functions #### - @classmethod - def GetDefaultParameters(cls): - default_settings = KratosMultiphysics.Parameters(""" - { - "rom_settings": { - "nodal_unknowns": [ "CFD_DOFS_USED_LISTED_HERE" ], - "number_of_rom_dofs": 3 - } - } - """) - default_settings.AddMissingParameters(super(ROMSolver,cls).GetDefaultParameters()) - return default_settings - - def _CreateBuilderAndSolver(self): - linear_solver = self._GetLinearSolver() - rom_parameters=self.settings["rom_settings"] - builder_and_solver = romapp.ROMBuilderAndSolver(linear_solver, rom_parameters) - return builder_and_solver diff --git a/applications/RomApplication/python_scripts/structural_mechanics_implicit_dynamic_rom_solver.py b/applications/RomApplication/python_scripts/structural_mechanics_implicit_dynamic_rom_solver.py deleted file mode 100644 index 6a4a1d3f1dec..000000000000 --- a/applications/RomApplication/python_scripts/structural_mechanics_implicit_dynamic_rom_solver.py +++ /dev/null @@ -1,52 +0,0 @@ - -# Importing the Kratos Library -import KratosMultiphysics - -# Import applications -import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication - -# Import base class file -from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_implicit_dynamic_solver import ImplicitMechanicalSolver -import KratosMultiphysics.RomApplication as romapp - -def CreateSolver(main_model_part, custom_settings): - return ROMSolver(main_model_part, custom_settings) - -class ROMSolver(ImplicitMechanicalSolver): - """The stationary class for ROM structural mechanics solvers. - - Public member variables: - stationary_settings -- settings for the implicit dynamic solvers. - - See structural_mechanics_implicit_dynamic_solver.py for more information. - """ - - def __init__(self, main_model_part, custom_settings): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'structural_mechanics_implicit_dynamic_rom_solver\'", "class is deprecated. Use the generic\'RomSolver\' one instead.") - - super(ROMSolver, self).__init__(main_model_part, custom_settings) - KratosMultiphysics.Logger.PrintInfo("::[ROMSolver]:: ", "Construction finished") - - #### Private functions #### - @classmethod - def GetDefaultParameters(cls): - default_settings = KratosMultiphysics.Parameters(""" - { - "rom_settings": { - "nodal_unknowns": [ "DISPLACEMENT_X", "DISPLACEMENT_Y", "DISPLACEMENT_Z"], - "number_of_rom_dofs": 10 - } - } - """) - default_settings.AddMissingParameters(super(ROMSolver,cls).GetDefaultParameters()) - return default_settings - - def AddVariables(self): - super(ROMSolver, self).AddVariables() #Adding nodal area variable - self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_AREA) - - def _CreateBuilderAndSolver(self): - linear_solver = self._GetLinearSolver() - rom_parameters=self.settings["rom_settings"] - builder_and_solver = romapp.ROMBuilderAndSolver(linear_solver, rom_parameters) - return builder_and_solver diff --git a/applications/RomApplication/python_scripts/structural_mechanics_static_rom_solver.py b/applications/RomApplication/python_scripts/structural_mechanics_static_rom_solver.py deleted file mode 100644 index 5fcf907c793a..000000000000 --- a/applications/RomApplication/python_scripts/structural_mechanics_static_rom_solver.py +++ /dev/null @@ -1,49 +0,0 @@ - -# Importing the Kratos Library -import KratosMultiphysics - -# Import applications -import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication - -# Import base class file -from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_static_solver import StaticMechanicalSolver -import KratosMultiphysics.RomApplication as romapp - -def CreateSolver(main_model_part, custom_settings): - return ROMSolver(main_model_part, custom_settings) - -class ROMSolver(StaticMechanicalSolver): - """The stationary class for ROM structural mechanics solvers. - - See structural_mechanics_static_solver.py for more information. - """ - - def __init__(self, main_model_part, custom_settings): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'stuctural_mechanics_static_rom_solver\'", "class is deprecated. Use the generic\'RomSolver\' one instead.") - - super(ROMSolver, self).__init__(main_model_part, custom_settings) - KratosMultiphysics.Logger.PrintInfo("::[ROMSolver]:: ", "Construction finished") - - #### Private functions #### - @classmethod - def GetDefaultParameters(cls): - default_settings = KratosMultiphysics.Parameters(""" - { - "rom_settings": { - "nodal_unknowns": [ "DISPLACEMENT_X", "DISPLACEMENT_Y", "DISPLACEMENT_Z"], - "number_of_rom_dofs": 3 - } - } - """) - default_settings.AddMissingParameters(super(ROMSolver,cls).GetDefaultParameters()) - return default_settings - - def AddVariables(self): - super(ROMSolver, self).AddVariables() #Adding nodal area variable - self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_AREA) - - def _CreateBuilderAndSolver(self): - linear_solver = self._GetLinearSolver() - rom_parameters=self.settings["rom_settings"] - builder_and_solver = romapp.ROMBuilderAndSolver(linear_solver, rom_parameters) - return builder_and_solver From 0e9b9dd9c75dc4a86dbef51bfe953aa73cd1e42d Mon Sep 17 00:00:00 2001 From: Raul Bravo Date: Fri, 19 Apr 2024 16:12:30 +0200 Subject: [PATCH 2/5] erasing legacy rom analysis stages --- .../convection_diffusion_analysis_rom.py | 45 ---------- .../fluid_dynamics_analysis_rom.py | 87 ------------------- .../structural_mechanics_analysis_rom.py | 77 ---------------- 3 files changed, 209 deletions(-) delete mode 100644 applications/RomApplication/python_scripts/convection_diffusion_analysis_rom.py delete mode 100644 applications/RomApplication/python_scripts/fluid_dynamics_analysis_rom.py delete mode 100644 applications/RomApplication/python_scripts/structural_mechanics_analysis_rom.py diff --git a/applications/RomApplication/python_scripts/convection_diffusion_analysis_rom.py b/applications/RomApplication/python_scripts/convection_diffusion_analysis_rom.py deleted file mode 100644 index 9cdb012eb2d3..000000000000 --- a/applications/RomApplication/python_scripts/convection_diffusion_analysis_rom.py +++ /dev/null @@ -1,45 +0,0 @@ -import KratosMultiphysics -import KratosMultiphysics.ConvectionDiffusionApplication -import KratosMultiphysics.RomApplication as romapp -from KratosMultiphysics.RomApplication import python_solvers_wrapper_rom as solver_wrapper - -from KratosMultiphysics.ConvectionDiffusionApplication.convection_diffusion_analysis import ConvectionDiffusionAnalysis - -import json - -class ConvectionDiffusionAnalysisROM(ConvectionDiffusionAnalysis): - - def __init__(self,model,project_parameters): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'ConvectionDiffusionAnalysisROM\'", "class is deprecated. Use the \'RomAnalysis\' one instead.") - super().__init__(model,project_parameters) - - #### Internal functions #### - def _CreateSolver(self): - """ Create the Solver (and create and import the ModelPart if it is not alread in the model) """ - ## Solver construction - with open('RomParameters.json') as rom_parameters: - rom_settings = KratosMultiphysics.Parameters(rom_parameters.read()) - self.project_parameters["solver_settings"].AddValue("rom_settings", rom_settings["rom_settings"]) - return solver_wrapper.CreateSolverByParameters(self.model, self.project_parameters["solver_settings"],self.project_parameters["problem_data"]["parallel_type"].GetString()) - - def _GetSimulationName(self): - return "::[ROM Simulation]:: " - - def ModifyAfterSolverInitialize(self): - """Here is where the ROM_BASIS is imposed to each node""" - super().ModifyAfterSolverInitialize() - computing_model_part = self._solver.GetComputingModelPart() - with open('RomParameters.json') as f: - data = json.load(f) - nodal_dofs = len(data["rom_settings"]["nodal_unknowns"]) - nodal_modes = data["nodal_modes"] - counter = 0 - rom_dofs= self.project_parameters["solver_settings"]["rom_settings"]["number_of_rom_dofs"].GetInt() - for node in computing_model_part.Nodes: - aux = KratosMultiphysics.Matrix(nodal_dofs, rom_dofs) - for j in range(nodal_dofs): - Counter=str(node.Id) - for i in range(rom_dofs): - aux[j,i] = nodal_modes[Counter][j][i] - node.SetValue(romapp.ROM_BASIS, aux ) # ROM basis - counter+=1 diff --git a/applications/RomApplication/python_scripts/fluid_dynamics_analysis_rom.py b/applications/RomApplication/python_scripts/fluid_dynamics_analysis_rom.py deleted file mode 100644 index 260da6a2fc7a..000000000000 --- a/applications/RomApplication/python_scripts/fluid_dynamics_analysis_rom.py +++ /dev/null @@ -1,87 +0,0 @@ -import KratosMultiphysics -import KratosMultiphysics.FluidDynamicsApplication -import KratosMultiphysics.RomApplication as romapp -from KratosMultiphysics.RomApplication import python_solvers_wrapper_rom as solver_wrapper -from KratosMultiphysics.RomApplication.empirical_cubature_method import EmpiricalCubatureMethod -from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis - -import json -import numpy as np - -class FluidDynamicsAnalysisROM(FluidDynamicsAnalysis): - - def __init__(self,model,project_parameters, path = '.', hyper_reduction_element_selector = None): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'FluidDynamicsAnalysisROM\'", "class is deprecated. Use the \'RomAnalysis\' one instead.") - self.path = path - super().__init__(model,project_parameters) - if hyper_reduction_element_selector != None : - if hyper_reduction_element_selector == "EmpiricalCubature": - self.hyper_reduction_element_selector = EmpiricalCubatureMethod() - self.time_step_residual_matrix_container = [] - else: - err_msg = "The requested element selection method \"" + hyper_reduction_element_selector + "\" is not in the rom application\n" - err_msg += "Available options are: \"EmpiricalCubature\"" - raise Exception(err_msg) - else: - self.hyper_reduction_element_selector = None - - - - #### Internal functions #### - def _CreateSolver(self): - """ Create the Solver (and create and import the ModelPart if it is not alread in the model) """ - ## Solver construction - with open(self.path +'/RomParameters.json') as rom_parameters: - rom_settings = KratosMultiphysics.Parameters(rom_parameters.read()) - self.project_parameters["solver_settings"].AddValue("rom_settings", rom_settings["rom_settings"]) - return solver_wrapper.CreateSolverByParameters(self.model, self.project_parameters["solver_settings"],self.project_parameters["problem_data"]["parallel_type"].GetString()) - - def _GetSimulationName(self): - return "::[ROM Simulation]:: " - - def ModifyAfterSolverInitialize(self): - """Here is where the ROM_BASIS is imposed to each node""" - super().ModifyAfterSolverInitialize() - computing_model_part = self._solver.GetComputingModelPart() - with open(self.path + '/RomParameters.json') as f: - data = json.load(f) - nodal_dofs = len(data["rom_settings"]["nodal_unknowns"]) - nodal_modes = data["nodal_modes"] - counter = 0 - rom_dofs= self.project_parameters["solver_settings"]["rom_settings"]["number_of_rom_dofs"].GetInt() - for node in computing_model_part.Nodes: - aux = KratosMultiphysics.Matrix(nodal_dofs, rom_dofs) - for j in range(nodal_dofs): - Counter=str(node.Id) - for i in range(rom_dofs): - aux[j,i] = nodal_modes[Counter][j][i] - node.SetValue(romapp.ROM_BASIS, aux ) # ROM basis - counter+=1 - if self.hyper_reduction_element_selector != None: - if self.hyper_reduction_element_selector.Name == "EmpiricalCubature": - self.ResidualUtilityObject = romapp.RomResidualsUtility(self._GetSolver().GetComputingModelPart(), self.project_parameters["solver_settings"]["rom_settings"], self._GetSolver()._GetScheme()) - - - def FinalizeSolutionStep(self): - if self.hyper_reduction_element_selector != None: - if self.hyper_reduction_element_selector.Name == "EmpiricalCubature": - print('\n\n\n\nGenerating matrix of residuals') - ResMat = self.ResidualUtilityObject.GetResiduals() - NP_ResMat = np.array(ResMat, copy=False) - self.time_step_residual_matrix_container.append(NP_ResMat) - super().FinalizeSolutionStep() - - def Finalize(self): - super().Finalize() - if self.hyper_reduction_element_selector != None: - if self.hyper_reduction_element_selector.Name == "EmpiricalCubature": - self.residuals_snapshots = self._ObtainBasis() - - def _ObtainBasis(self): - ### Building the Snapshot matrix #### - for i in range (len(self.time_step_residual_matrix_container)): - if i == 0: - SnapshotMatrix = self.time_step_residual_matrix_container[i] - else: - SnapshotMatrix = np.c_[SnapshotMatrix, self.time_step_residual_matrix_container[i]] - return SnapshotMatrix \ No newline at end of file diff --git a/applications/RomApplication/python_scripts/structural_mechanics_analysis_rom.py b/applications/RomApplication/python_scripts/structural_mechanics_analysis_rom.py deleted file mode 100644 index 7bfbd18dc261..000000000000 --- a/applications/RomApplication/python_scripts/structural_mechanics_analysis_rom.py +++ /dev/null @@ -1,77 +0,0 @@ -import KratosMultiphysics -import KratosMultiphysics.RomApplication as romapp -import KratosMultiphysics.StructuralMechanicsApplication -from KratosMultiphysics.RomApplication.empirical_cubature_method import EmpiricalCubatureMethod -from KratosMultiphysics.RomApplication import python_solvers_wrapper_rom as solver_wrapper -from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_analysis import StructuralMechanicsAnalysis - -import json -import numpy as np - -class StructuralMechanicsAnalysisROM(StructuralMechanicsAnalysis): - - def __init__(self,model,project_parameters, hyper_reduction_element_selector = None): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'StructuralMechanicsAnalysisROM\'", "class is deprecated. Use the \'RomAnalysis\' one instead.") - super().__init__(model,project_parameters) - if hyper_reduction_element_selector != None : - if hyper_reduction_element_selector == "EmpiricalCubature": - self.hyper_reduction_element_selector = EmpiricalCubatureMethod() - self.time_step_residual_matrix_container = [] - else: - err_msg = "The requested element selection method \"" + hyper_reduction_element_selector + "\" is not in the rom application\n" - err_msg += "Available options are: \"EmpiricalCubature\"" - raise Exception(err_msg) - else: - self.hyper_reduction_element_selector = None - - #### Internal functions #### - def _CreateSolver(self): - """ Create the Solver (and create and import the ModelPart if it is not alread in the model) """ - ## Solver construction - with open('RomParameters.json') as rom_parameters: - rom_settings = KratosMultiphysics.Parameters(rom_parameters.read()) - self.project_parameters["solver_settings"].AddValue("rom_settings", rom_settings["rom_settings"]) - return solver_wrapper.CreateSolverByParameters(self.model, self.project_parameters["solver_settings"],self.project_parameters["problem_data"]["parallel_type"].GetString()) - - def _GetSimulationName(self): - return "::[ROM Simulation]:: " - - def ModifyAfterSolverInitialize(self): - """Here is where the ROM_BASIS is imposed to each node""" - super().ModifyAfterSolverInitialize() - computing_model_part = self._solver.GetComputingModelPart() - with open('RomParameters.json') as f: - data = json.load(f) - nodal_dofs = len(data["rom_settings"]["nodal_unknowns"]) - nodal_modes = data["nodal_modes"] - counter = 0 - rom_dofs= self.project_parameters["solver_settings"]["rom_settings"]["number_of_rom_dofs"].GetInt() - for node in computing_model_part.Nodes: - aux = KratosMultiphysics.Matrix(nodal_dofs, rom_dofs) - for j in range(nodal_dofs): - Counter=str(node.Id) - for i in range(rom_dofs): - aux[j,i] = nodal_modes[Counter][j][i] - node.SetValue(romapp.ROM_BASIS, aux ) # ROM basis - counter+=1 - if self.hyper_reduction_element_selector != None: - if self.hyper_reduction_element_selector.Name == "EmpiricalCubature": - self.ResidualUtilityObject = romapp.RomResidualsUtility(self._GetSolver().GetComputingModelPart(), self.project_parameters["solver_settings"]["rom_settings"], self._GetSolver()._GetScheme()) - - def FinalizeSolutionStep(self): - if self.hyper_reduction_element_selector != None: - if self.hyper_reduction_element_selector.Name == "EmpiricalCubature": - print('\n\n\n\nGenerating matrix of residuals') - ResMat = self.ResidualUtilityObject.GetResiduals() - NP_ResMat = np.array(ResMat, copy=False) - self.time_step_residual_matrix_container.append(NP_ResMat) - super().FinalizeSolutionStep() - - def Finalize(self): - super().Finalize() - if self.hyper_reduction_element_selector != None: - if self.hyper_reduction_element_selector.Name == "EmpiricalCubature": - OriginalNumberOfElements = self._GetSolver().GetComputingModelPart().NumberOfElements() - ModelPartName = self._GetSolver().settings["model_import_settings"]["input_filename"].GetString() - self. hyper_reduction_element_selector.SetUp(self.time_step_residual_matrix_container, OriginalNumberOfElements, ModelPartName) - self.hyper_reduction_element_selector.Run() From 5bf08f979da387e31192052f94b99194d495b6bb Mon Sep 17 00:00:00 2001 From: Raul Bravo Date: Fri, 19 Apr 2024 16:12:59 +0200 Subject: [PATCH 3/5] erasing legacy python solver wrapper --- .../new_python_solvers_wrapper_rom.py | 78 ------------------- 1 file changed, 78 deletions(-) delete mode 100644 applications/RomApplication/python_scripts/new_python_solvers_wrapper_rom.py diff --git a/applications/RomApplication/python_scripts/new_python_solvers_wrapper_rom.py b/applications/RomApplication/python_scripts/new_python_solvers_wrapper_rom.py deleted file mode 100644 index 4b637c044211..000000000000 --- a/applications/RomApplication/python_scripts/new_python_solvers_wrapper_rom.py +++ /dev/null @@ -1,78 +0,0 @@ -import sys -import importlib - -import KratosMultiphysics -from KratosMultiphysics import kratos_utilities -from KratosMultiphysics.RomApplication import rom_solver - - -def _GetAvailableSolverWrapperModules(): - return { - "KratosMultiphysics.FluidDynamicsApplication" : "python_solvers_wrapper_fluid", - "KratosMultiphysics.StructuralMechanicsApplication" : "python_solvers_wrapper_structural", - "KratosMultiphysics.ConvectionDiffusionApplication" : "python_solvers_wrapper_convection_diffusion", - "KratosMultiphysics.CompressiblePotentialFlowApplication" : "python_solvers_wrapper_compressible_potential", - "KratosMultiphysics.GeoMechanicsApplication" : "geomechanics_solvers_wrapper" - } - - -def CreateSolverByParameters(model, solver_settings, parallelism, analysis_stage_module_name): - - if not isinstance(model, KratosMultiphysics.Model): - raise Exception("input is expected to be provided as a Kratos Model object") - - if not isinstance(solver_settings, KratosMultiphysics.Parameters): - raise Exception("input is expected to be provided as a Kratos Parameters object") - - # Get the corresponding application from the analysis_stage path - split_analysis_stage_module_name = analysis_stage_module_name.split('.') - application_module_name = split_analysis_stage_module_name[0] + "." + split_analysis_stage_module_name[1] - if not kratos_utilities.CheckIfApplicationsAvailable(split_analysis_stage_module_name[1]): - raise Exception("Module {} is not available.".format(application_module_name)) - - # Filter and retrieve the Python solvers wrapper from the corresponding application - #TODO: This filtering wouldn't be required if we were using a unified solvers wrapper module name - available_modules = _GetAvailableSolverWrapperModules() - - if application_module_name in available_modules: - solvers_wrapper_module_module_name = available_modules[application_module_name] - else: - err_msg = "Python module \'{0}\' is not available. Make sure \'{1}\' is compiled and implemented.\n".format( - application_module_name, split_analysis_stage_module_name[1]) - err_msg += "Currently implemented applications are:\n" - err_msg += "".join(" - {}\n".format(key) for key in available_modules) - err_msg += "To add a new implementation, do so in '{}' in {}".format( - _GetAvailableSolverWrapperModules.__name__, __file__) - raise Exception(err_msg) - solvers_wrapper_module = importlib.import_module(application_module_name + "." + solvers_wrapper_module_module_name) - - # Create a prototype class instance and get the module and name of the solver to be used as base - # Note that an auxiliary Kratos parameter settings without the rom_settings field is created to avoid the defaults error thrown - # Note that an auxiliary Kratos model is also created to avoid creating the main_model_part in the prototype class instance - #TODO: We could do the same exercise as we do in the stage (module_name to ClassName equal to ModuleName if we standarize the solver names) - aux_solver_settings = solver_settings.Clone() - aux_solver_settings.RemoveValue("rom_settings") - aux_solver_settings.RemoveValue("projection_strategy") - aux_solver_settings.RemoveValue("assembling_strategy") - aux_solver_settings.RemoveValue("monotonicity_preserving") - aux_base_solver_instance = solvers_wrapper_module.CreateSolverByParameters(KratosMultiphysics.Model(), aux_solver_settings, parallelism) - - # Create the ROM solver from the base solver - rom_solver_instance = rom_solver.CreateSolver(type(aux_base_solver_instance), model, solver_settings) - - return rom_solver_instance - -def CreateSolver(model, custom_settings): - - if (type(model) != KratosMultiphysics.Model): - raise Exception("input is expected to be provided as a Kratos Model object") - - if (type(custom_settings) != KratosMultiphysics.Parameters): - raise Exception("input is expected to be provided as a Kratos Parameters object") - - parallelism = custom_settings["problem_data"]["parallel_type"].GetString() - analysis_stage = custom_settings["analysis_stage"].GetString() - solver_settings = custom_settings["solver_settings"] - - return CreateSolverByParameters(model, solver_settings, parallelism, analysis_stage) - From 64da3be74e63054fc0b1759e74ecfd9a0c26b4df Mon Sep 17 00:00:00 2001 From: Raul Bravo Date: Fri, 19 Apr 2024 16:14:02 +0200 Subject: [PATCH 4/5] change name to new_python_solver_wrapper --> python_solver_wrapper --- .../python_solvers_wrapper_rom.py | 97 ++++++++++--------- 1 file changed, 49 insertions(+), 48 deletions(-) diff --git a/applications/RomApplication/python_scripts/python_solvers_wrapper_rom.py b/applications/RomApplication/python_scripts/python_solvers_wrapper_rom.py index 805789a8e854..4b637c044211 100644 --- a/applications/RomApplication/python_scripts/python_solvers_wrapper_rom.py +++ b/applications/RomApplication/python_scripts/python_solvers_wrapper_rom.py @@ -1,66 +1,66 @@ +import sys +import importlib import KratosMultiphysics -from importlib import import_module +from KratosMultiphysics import kratos_utilities +from KratosMultiphysics.RomApplication import rom_solver -def CreateSolverByParameters(model, solver_settings, parallelism): - KratosMultiphysics.Logger.PrintWarning('\x1b[1;31m[DEPRECATED CLASS] \x1b[0m',"\'python_solvers_wrapper_rom\'", "module is deprecated. Use the generic\'new_python_solvers_wrapper_rom\' one instead.") +def _GetAvailableSolverWrapperModules(): + return { + "KratosMultiphysics.FluidDynamicsApplication" : "python_solvers_wrapper_fluid", + "KratosMultiphysics.StructuralMechanicsApplication" : "python_solvers_wrapper_structural", + "KratosMultiphysics.ConvectionDiffusionApplication" : "python_solvers_wrapper_convection_diffusion", + "KratosMultiphysics.CompressiblePotentialFlowApplication" : "python_solvers_wrapper_compressible_potential", + "KratosMultiphysics.GeoMechanicsApplication" : "geomechanics_solvers_wrapper" + } - if (type(model) != KratosMultiphysics.Model): + +def CreateSolverByParameters(model, solver_settings, parallelism, analysis_stage_module_name): + + if not isinstance(model, KratosMultiphysics.Model): raise Exception("input is expected to be provided as a Kratos Model object") - if (type(solver_settings) != KratosMultiphysics.Parameters): + if not isinstance(solver_settings, KratosMultiphysics.Parameters): raise Exception("input is expected to be provided as a Kratos Parameters object") - solver_type = solver_settings["solver_type"].GetString() + # Get the corresponding application from the analysis_stage path + split_analysis_stage_module_name = analysis_stage_module_name.split('.') + application_module_name = split_analysis_stage_module_name[0] + "." + split_analysis_stage_module_name[1] + if not kratos_utilities.CheckIfApplicationsAvailable(split_analysis_stage_module_name[1]): + raise Exception("Module {} is not available.".format(application_module_name)) + # Filter and retrieve the Python solvers wrapper from the corresponding application + #TODO: This filtering wouldn't be required if we were using a unified solvers wrapper module name + available_modules = _GetAvailableSolverWrapperModules() - if solver_settings.Has("time_integration_method"): - time_integration_method = solver_settings["time_integration_method"].GetString() + if application_module_name in available_modules: + solvers_wrapper_module_module_name = available_modules[application_module_name] else: - time_integration_method = "implicit" # defaulting to implicit time-integration - - # Solvers for OpenMP parallelism - if (parallelism == "OpenMP"): - if (solver_type == "transient" or solver_type == "Transient"): - solver_module_name = "convection_diffusion_transient_rom_solver" - - elif (solver_type == "dynamic" or solver_type == "Dynamic"): - if time_integration_method == "implicit": - solver_module_name = "structural_mechanics_implicit_dynamic_rom_solver" - else: - err_msg = "The requested time integration method \"" + time_integration_method + "\" is not in the python solvers wrapper\n" - err_msg += "Available options are: \"implicit\"" - raise Exception(err_msg) - - elif solver_type == "static" or solver_type == "Static": - solver_module_name = "structural_mechanics_static_rom_solver" - - elif (solver_type == "stationary" or solver_type == "Stationary"): - solver_module_name = "convection_diffusion_stationary_rom_solver" - - elif (solver_type == "monolithic" or solver_type == "Monolithic"): - solver_module_name = "navier_stokes_solver_vmsmonolithic_rom" - - else: - err_msg = "The requested solver type \"" + solver_type + "\" is not in the python solvers wrapper\n" - err_msg += "Available options are: \"transient\", \"stationary\"" - raise Exception(err_msg) - - # Solvers for MPI parallelism - elif (parallelism == "MPI"): - err_msg = "The requested parallel type MPI is not yet available!\n" + err_msg = "Python module \'{0}\' is not available. Make sure \'{1}\' is compiled and implemented.\n".format( + application_module_name, split_analysis_stage_module_name[1]) + err_msg += "Currently implemented applications are:\n" + err_msg += "".join(" - {}\n".format(key) for key in available_modules) + err_msg += "To add a new implementation, do so in '{}' in {}".format( + _GetAvailableSolverWrapperModules.__name__, __file__) raise Exception(err_msg) + solvers_wrapper_module = importlib.import_module(application_module_name + "." + solvers_wrapper_module_module_name) - else: - err_msg = "The requested parallel type \"" + parallelism + "\" is not available!\n" - err_msg += "Available options are: \"OpenMP\", \"MPI\"" - raise Exception(err_msg) + # Create a prototype class instance and get the module and name of the solver to be used as base + # Note that an auxiliary Kratos parameter settings without the rom_settings field is created to avoid the defaults error thrown + # Note that an auxiliary Kratos model is also created to avoid creating the main_model_part in the prototype class instance + #TODO: We could do the same exercise as we do in the stage (module_name to ClassName equal to ModuleName if we standarize the solver names) + aux_solver_settings = solver_settings.Clone() + aux_solver_settings.RemoveValue("rom_settings") + aux_solver_settings.RemoveValue("projection_strategy") + aux_solver_settings.RemoveValue("assembling_strategy") + aux_solver_settings.RemoveValue("monotonicity_preserving") + aux_base_solver_instance = solvers_wrapper_module.CreateSolverByParameters(KratosMultiphysics.Model(), aux_solver_settings, parallelism) - module_full = 'KratosMultiphysics.RomApplication.' + solver_module_name - solver = import_module(module_full).CreateSolver(model, solver_settings) + # Create the ROM solver from the base solver + rom_solver_instance = rom_solver.CreateSolver(type(aux_base_solver_instance), model, solver_settings) - return solver + return rom_solver_instance def CreateSolver(model, custom_settings): @@ -71,7 +71,8 @@ def CreateSolver(model, custom_settings): raise Exception("input is expected to be provided as a Kratos Parameters object") parallelism = custom_settings["problem_data"]["parallel_type"].GetString() + analysis_stage = custom_settings["analysis_stage"].GetString() solver_settings = custom_settings["solver_settings"] - return CreateSolverByParameters(model, solver_settings, parallelism) + return CreateSolverByParameters(model, solver_settings, parallelism, analysis_stage) From b46d40a7880ce0e2c349cf90378c267549fbb4ad Mon Sep 17 00:00:00 2001 From: Raul Bravo Date: Fri, 19 Apr 2024 16:14:34 +0200 Subject: [PATCH 5/5] use python solver wrapper in RomAnalysis --- applications/RomApplication/python_scripts/rom_analysis.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/applications/RomApplication/python_scripts/rom_analysis.py b/applications/RomApplication/python_scripts/rom_analysis.py index d03c39f14324..727cbd1157ff 100644 --- a/applications/RomApplication/python_scripts/rom_analysis.py +++ b/applications/RomApplication/python_scripts/rom_analysis.py @@ -2,7 +2,7 @@ import KratosMultiphysics import KratosMultiphysics.RomApplication as KratosROM -from KratosMultiphysics.RomApplication import new_python_solvers_wrapper_rom +from KratosMultiphysics.RomApplication import python_solvers_wrapper_rom from KratosMultiphysics.RomApplication.hrom_training_utility import HRomTrainingUtility from KratosMultiphysics.RomApplication.petrov_galerkin_training_utility import PetrovGalerkinTrainingUtility from KratosMultiphysics.RomApplication.calculate_rom_basis_output_process import CalculateRomBasisOutputProcess @@ -97,7 +97,7 @@ def _CreateSolver(self): self.project_parameters["solver_settings"].AddString("assembling_strategy",self.assembling_strategy) # Create the ROM solver - return new_python_solvers_wrapper_rom.CreateSolver( + return python_solvers_wrapper_rom.CreateSolver( self.model, self.project_parameters)