diff --git a/applications/RomApplication/python_scripts/calculate_rom_basis_output_process.py b/applications/RomApplication/python_scripts/calculate_rom_basis_output_process.py
index 38fd530ebfb8..1a3af7fc2197 100644
--- a/applications/RomApplication/python_scripts/calculate_rom_basis_output_process.py
+++ b/applications/RomApplication/python_scripts/calculate_rom_basis_output_process.py
@@ -5,6 +5,7 @@
 
 # Importing the Kratos Library
 import KratosMultiphysics
+from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning
 from KratosMultiphysics.RomApplication.randomized_singular_value_decomposition import RandomizedSingularValueDecomposition
 
 def Factory(settings, model):
@@ -18,6 +19,8 @@ class CalculateRomBasisOutputProcess(KratosMultiphysics.OutputProcess):
     def __init__(self, model, settings):
         KratosMultiphysics.OutputProcess.__init__(self)
 
+        IssueDeprecationWarning("CalculateRomBasisOutputProcess", "This process is deprecated and will be removed. Please use the RomManager to compute the ROM basis.")
+
         # Validate input settings against defaults
         settings.ValidateAndAssignDefaults(self.GetDefaultParameters())
 
diff --git a/applications/RomApplication/python_scripts/rom_analysis.py b/applications/RomApplication/python_scripts/rom_analysis.py
index fdb0915b4f06..7d17c61d0920 100644
--- a/applications/RomApplication/python_scripts/rom_analysis.py
+++ b/applications/RomApplication/python_scripts/rom_analysis.py
@@ -12,7 +12,7 @@
 from os import remove
 from pathlib import Path
 
-def CreateRomAnalysisInstance(cls, global_model, parameters, nn_rom_interface=None):
+def CreateRomAnalysisInstance(cls, global_model, parameters, nn_rom_interface=None, rom_basis_output_folder=None, rom_basis_output_name=None):
     class RomAnalysis(cls):
 
         def __init__(self,global_model, parameters):
@@ -34,6 +34,11 @@ def _CreateSolver(self):
                                     self.rom_basis_output_name = parameter_set["Parameters"]["rom_basis_output_name"].GetString()
                                 if parameter_set["Parameters"].Has("rom_basis_output_folder"):
                                     self.rom_basis_output_folder = parameter_set["Parameters"]["rom_basis_output_folder"].GetString()
+            # Explicitly provided values (e.g. from the RomManager) take precedence
+            if rom_basis_output_name is not None:
+                self.rom_basis_output_name = rom_basis_output_name
+            if rom_basis_output_folder is not None:
+                self.rom_basis_output_folder = rom_basis_output_folder
             self.rom_basis_output_name = Path(self.rom_basis_output_name)
             self.rom_basis_output_folder = Path(self.rom_basis_output_folder)
 
diff --git a/applications/RomApplication/python_scripts/rom_manager.py b/applications/RomApplication/python_scripts/rom_manager.py
index b3f3655f0ecd..e3f3502fe179 100644
--- a/applications/RomApplication/python_scripts/rom_manager.py
+++ b/applications/RomApplication/python_scripts/rom_manager.py
@@ -1,12 +1,12 @@
 import numpy as np
 import importlib
+import shutil
 import json
 from pathlib import Path
 import types
 import KratosMultiphysics
 from KratosMultiphysics.RomApplication.rom_database import RomDatabase
 from KratosMultiphysics.RomApplication.rom_testing_utilities import SetUpSimulationInstance
-from KratosMultiphysics.RomApplication.calculate_rom_basis_output_process import CalculateRomBasisOutputProcess
 from KratosMultiphysics.RomApplication.randomized_singular_value_decomposition import RandomizedSingularValueDecomposition
 from KratosMultiphysics.RomApplication.empirical_cubature_method import EmpiricalCubatureMethod
 from KratosMultiphysics.RomApplication.rom_nn_interface import NN_ROM_Interface
@@ -17,7 +17,6 @@ class RomManager(object):
 
     def __init__(self,project_parameters_name="ProjectParameters.json", general_rom_manager_parameters=None, CustomizeSimulation=None, UpdateProjectParameters=None,UpdateMaterialParametersFile=None, mu_names=None):
         #FIXME:
-        # - Use a method (upcoming) for smothly retrieving solutions. In here we are using the RomBasisOutput process in order to store the solutions
         # - There is some redundancy between the methods that launch the simulations. Can we create a single method?
         # - Not yet paralellised with COMPSs
         self.project_parameters_name = project_parameters_name
@@ -381,7 +380,7 @@ def _LaunchFOM(self, mu_train, gid_and_vtk_name='FOM_Fit'):
             nonconverged_fom_in_database, _ = self.data_base.check_if_in_database("NonconvergedFOM", mu)
             if not fom_in_database or (NonConvergedSolutionsGathering and not nonconverged_fom_in_database):
                 parameters_copy = self.UpdateProjectParameters(parameters.Clone(), mu)
-                parameters_copy = self._AddBasisCreationToProjectParameters(parameters_copy) #TODO stop using the RomBasisOutputProcess to store the snapshots. Use instead the upcoming build-in function
+                parameters_copy = self._AddNumpyOutputToProjectParameters(parameters_copy)
                 parameters_copy = self._StoreResultsByName(parameters_copy,gid_and_vtk_name,mu,Id)
                 materials_file_name = self._GetMaterialsFileName(parameters_copy)
                 self.UpdateMaterialParametersFile(materials_file_name, mu)
@@ -393,10 +392,7 @@ def _LaunchFOM(self, mu_train, gid_and_vtk_name='FOM_Fit'):
                 simulation.Run()
                 if not fom_in_database:
                     self.data_base.add_to_database("QoI_FOM", mu, simulation.GetFinalData())
-                    for process in simulation._GetListOfOutputProcesses():
-                        if isinstance(process, CalculateRomBasisOutputProcess):
-                            BasisOutputProcess = process
-                    SnapshotsMatrix = BasisOutputProcess._GetSnapshotsMatrix() #TODO add a CustomMethod() as a standard method in the Analysis Stage to retrive some solution
+                    SnapshotsMatrix = self._GetSnapshotsMatrixFromNumpyOutput()
                     self.data_base.add_to_database("FOM", mu, SnapshotsMatrix)
                 if NonConvergedSolutionsGathering:
                     self.data_base.add_to_database("NonconvergedFOM", mu, simulation.GetNonconvergedSolutions())
@@ -406,18 +402,16 @@ def _LaunchFOM(self, mu_train, gid_and_vtk_name='FOM_Fit'):
     def _LaunchComputeSolutionBasis(self, mu_train):
         in_database, hash_basis = self.data_base.check_if_in_database("RightBasis", mu_train)
         if not in_database:
-            BasisOutputProcess = self.InitializeDummySimulationForBasisOutputProcess()
             if self.general_rom_manager_parameters["ROM"]["use_non_converged_sols"].GetBool():
-                u,sigma = BasisOutputProcess._ComputeSVD(self.data_base.get_snapshots_matrix_from_database(mu_train, table_name='NonconvergedFOM')) #TODO this might be too large for single opeartion, add partitioned svd
+                u,sigma = self._ComputeSVD(self.data_base.get_snapshots_matrix_from_database(mu_train, table_name='NonconvergedFOM')) #TODO this might be too large for single opeartion, add partitioned svd
             else:
-                u,sigma = BasisOutputProcess._ComputeSVD(self.data_base.get_snapshots_matrix_from_database(mu_train, table_name='FOM'))
-            BasisOutputProcess._PrintRomBasis(u, sigma) #Calling the RomOutput Process for creating the RomParameter.json
+                u,sigma = self._ComputeSVD(self.data_base.get_snapshots_matrix_from_database(mu_train, table_name='FOM'))
+            self._PrintRomBasis(u, sigma)
             self.data_base.add_to_database("RightBasis", mu_train, u )
             self.data_base.add_to_database("SingularValues_Solution", mu_train, sigma )
         else:
-            BasisOutputProcess = self.InitializeDummySimulationForBasisOutputProcess()
             _ , hash_sigma = self.data_base.check_if_in_database("SingularValues_Solution", mu_train)
-            BasisOutputProcess._PrintRomBasis(self.data_base.get_single_numpy_from_database(hash_basis), self.data_base.get_single_numpy_from_database(hash_sigma) ) #this updates the RomParameters.json
+            self._PrintRomBasis(self.data_base.get_single_numpy_from_database(hash_basis), self.data_base.get_single_numpy_from_database(hash_sigma) ) #this updates the RomParameters.json
         self.GenerateDatabaseSummary()
 
     def _LoadSolutionBasis(self, mu_train):
@@ -433,9 +427,8 @@ def _LoadSolutionBasis(self, mu_train):
             err_msg = f'ROM basis not found for indicated training snapshots. Please run the Train method() to create it.'
             raise Exception(err_msg)
         else:
-            BasisOutputProcess = self.InitializeDummySimulationForBasisOutputProcess()
             _ , hash_sigma = self.data_base.check_if_in_database("SingularValues_Solution", mu_train)
-            BasisOutputProcess._PrintRomBasis(self.data_base.get_single_numpy_from_database(hash_basis), self.data_base.get_single_numpy_from_database(hash_sigma) ) #this updates the RomParameters.json
+            self._PrintRomBasis(self.data_base.get_single_numpy_from_database(hash_basis), self.data_base.get_single_numpy_from_database(hash_sigma) ) #this updates the RomParameters.json
         self.GenerateDatabaseSummary()
 
 
@@ -446,25 +439,21 @@ def _LaunchROM(self, mu_train, gid_and_vtk_name='ROM_Fit', nn_rom_interface = No
         """
         with open(self.project_parameters_name,'r') as parameter_file:
             parameters = KratosMultiphysics.Parameters(parameter_file.read())
-        BasisOutputProcess = None
         for Id, mu in enumerate(mu_train):
             in_database, _ = self.data_base.check_if_in_database("ROM", mu)
             if not in_database:
                 parameters_copy = self.UpdateProjectParameters(parameters.Clone(), mu)
-                parameters_copy = self._AddBasisCreationToProjectParameters(parameters_copy)  #TODO stop using the RomBasisOutputProcess to store the snapshots. Use instead the upcoming build-in function
+                parameters_copy = self._AddNumpyOutputToProjectParameters(parameters_copy)
                 parameters_copy = self._StoreResultsByName(parameters_copy,gid_and_vtk_name,mu,Id)
                 materials_file_name = self._GetMaterialsFileName(parameters_copy)
                 self.UpdateMaterialParametersFile(materials_file_name, mu)
                 model = KratosMultiphysics.Model()
-                analysis_stage_class = type(SetUpSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
+                analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
                 simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters_copy, mu)
 
                 simulation.Run()
                 self.data_base.add_to_database("QoI_ROM", mu, simulation.GetFinalData())
-                for process in simulation._GetListOfOutputProcesses():
-                    if isinstance(process, CalculateRomBasisOutputProcess):
-                        BasisOutputProcess = process
-                SnapshotsMatrix = BasisOutputProcess._GetSnapshotsMatrix() #TODO add a CustomMethod() as a standard method in the Analysis Stage to retrive some solution
+                SnapshotsMatrix = self._GetSnapshotsMatrixFromNumpyOutput()
                 self.data_base.add_to_database("ROM", mu, SnapshotsMatrix )
 
         self.GenerateDatabaseSummary()
@@ -484,12 +473,11 @@ def _LaunchTrainPG(self, mu_train):
                 in_database, _ = self.data_base.check_if_in_database("PetrovGalerkinSnapshots", mu)
                 if not in_database:
                     parameters_copy = self.UpdateProjectParameters(parameters.Clone(), mu)
-                    parameters_copy = self._AddBasisCreationToProjectParameters(parameters_copy)
                     parameters_copy = self._StoreNoResults(parameters_copy)
                     materials_file_name = self._GetMaterialsFileName(parameters_copy)
                     self.UpdateMaterialParametersFile(materials_file_name, mu)
                     model = KratosMultiphysics.Model()
-                    analysis_stage_class = type(SetUpSimulationInstance(model, parameters_copy))
+                    analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters_copy))
                     simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters_copy, mu)
                     simulation.Run()
                     PetrovGalerkinTrainingUtility = simulation.GetPetrovGalerkinTrainUtility()
@@ -527,7 +515,6 @@ def _LaunchTrainHROM(self, mu_train, nn_rom_interface = None):
                 in_database, _ = self.data_base.check_if_in_database("ResidualsProjected", mu)
                 if not in_database:
                     parameters_copy = self.UpdateProjectParameters(parameters.Clone(), mu)
-                    parameters_copy = self._AddBasisCreationToProjectParameters(parameters_copy) #TODO Remove the basis creation process. Here it generates the RomParameters.json, find a workaround
                     parameters_copy = self._AddResidualsProjectedOutputProcessToProjectParameters(parameters_copy)  #This deals with the creation of residuals
                     parameters_copy = self._StoreNoResults(parameters_copy)
                     # Remove the residuals of previous runs, so that only the ones of this mu are collected
@@ -537,7 +524,7 @@ def _LaunchTrainHROM(self, mu_train, nn_rom_interface = None):
                     materials_file_name = self._GetMaterialsFileName(parameters_copy)
                     self.UpdateMaterialParametersFile(materials_file_name, mu)
                     model = KratosMultiphysics.Model()
-                    analysis_stage_class = type(SetUpSimulationInstance(model, parameters_copy, nn_rom_interface))
+                    analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
                     simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters_copy, mu)
                     simulation.Run()
                     ResidualProjected = self._GetResidualProjected() # this method fetches the residuals projected from the corresponding folder.
@@ -623,24 +610,20 @@ def _LaunchHROM(self, mu_train, nn_rom_interface=None,gid_and_vtk_name ='HROM_Fi
         """
         with open(self.project_parameters_name,'r') as parameter_file:
             parameters = KratosMultiphysics.Parameters(parameter_file.read())
-        BasisOutputProcess = None
         for Id, mu in enumerate(mu_train):
             in_database, _ = self.data_base.check_if_in_database("HROM", mu)
             if not in_database:
                 parameters_copy = self.UpdateProjectParameters(parameters.Clone(), mu)
-                parameters_copy = self._AddBasisCreationToProjectParameters(parameters_copy)
+                parameters_copy = self._AddNumpyOutputToProjectParameters(parameters_copy)
                 parameters_copy = self._StoreResultsByName(parameters_copy,gid_and_vtk_name,mu,Id)
                 materials_file_name = self._GetMaterialsFileName(parameters_copy)
                 self.UpdateMaterialParametersFile(materials_file_name, mu)
                 model = KratosMultiphysics.Model()
-                analysis_stage_class = type(SetUpSimulationInstance(model, parameters_copy,nn_rom_interface))
+                analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
                 simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters_copy, mu)
                 simulation.Run()
                 self.data_base.add_to_database("QoI_HROM", mu, simulation.GetFinalData())
-                for process in simulation._GetListOfOutputProcesses():
-                    if isinstance(process, CalculateRomBasisOutputProcess):
-                        BasisOutputProcess = process
-                SnapshotsMatrix = BasisOutputProcess._GetSnapshotsMatrix() #TODO add a CustomMethod() as a standard method in the Analysis Stage to retrive some solution
+                SnapshotsMatrix = self._GetSnapshotsMatrixFromNumpyOutput()
                 self.data_base.add_to_database("HROM", mu, SnapshotsMatrix)
 
         self.GenerateDatabaseSummary()
@@ -676,7 +659,7 @@ def _LaunchRunROM(self, mu_run, nn_rom_interface=None):
             materials_file_name = self._GetMaterialsFileName(parameters_copy)
             self.UpdateMaterialParametersFile(materials_file_name, mu)
             model = KratosMultiphysics.Model()
-            analysis_stage_class = type(SetUpSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
+            analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
             simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters_copy, mu)
             simulation.Run()
             self.QoI_Run_ROM.append(simulation.GetFinalData())
@@ -702,7 +685,7 @@ def _LaunchRunHROM(self, mu_run, use_full_model_part, nn_rom_interface):
             materials_file_name = self._GetMaterialsFileName(parameters_copy)
             self.UpdateMaterialParametersFile(materials_file_name, mu)
             model = KratosMultiphysics.Model()
-            analysis_stage_class = type(SetUpSimulationInstance(model, parameters_copy,nn_rom_interface))
+            analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters_copy, nn_rom_interface=nn_rom_interface))
             simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters_copy, mu)
             simulation.Run()
             self.QoI_Run_HROM.append(simulation.GetFinalData())
@@ -720,28 +703,23 @@ def _LaunchTestNeuralNetworkReconstruction(self,mu_train, mu_validation):
         rom_nn_trainer = RomNeuralNetworkTrainer(self.general_rom_manager_parameters, mu_train, mu_validation, self.data_base)
         rom_nn_trainer.EvaluateNetwork()
 
-    def InitializeDummySimulationForBasisOutputProcess(self):
+    def InitializeDummySimulationForSnapshotsModelPart(self):
         with open(self.project_parameters_name,'r') as parameter_file:
             parameters = KratosMultiphysics.Parameters(parameter_file.read())
-        parameters = self._AddBasisCreationToProjectParameters(parameters)
         parameters = self._StoreNoResults(parameters)
         model = KratosMultiphysics.Model()
         analysis_stage_class = self._GetAnalysisStageClass(parameters)
         simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters)
         simulation.Initialize()
-        for process in simulation._GetListOfOutputProcesses():
-            if isinstance(process, CalculateRomBasisOutputProcess):
-                BasisOutputProcess = process
-        return BasisOutputProcess
+        return model[self.general_rom_manager_parameters["ROM"]["model_part_name"].GetString()]
 
 
     def InitializeDummySimulationForHromTrainingUtility(self, nn_rom_interface=None):
         with open(self.project_parameters_name,'r') as parameter_file:
             parameters = KratosMultiphysics.Parameters(parameter_file.read())
-        parameters = self._AddBasisCreationToProjectParameters(parameters)
         parameters = self._StoreNoResults(parameters)
         model = KratosMultiphysics.Model()
-        analysis_stage_class = type(SetUpSimulationInstance(model, parameters,nn_rom_interface=nn_rom_interface))
+        analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters, nn_rom_interface=nn_rom_interface))
         simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters)
         simulation.Initialize()
         return simulation.GetHROM_utility()
@@ -750,10 +728,9 @@ def InitializeDummySimulationForHromTrainingUtility(self, nn_rom_interface=None)
     def InitializeDummySimulationForPetrovGalerkinTrainingUtility(self):
         with open(self.project_parameters_name,'r') as parameter_file:
             parameters = KratosMultiphysics.Parameters(parameter_file.read())
-        parameters = self._AddBasisCreationToProjectParameters(parameters)
         parameters = self._StoreNoResults(parameters)
         model = KratosMultiphysics.Model()
-        analysis_stage_class = type(SetUpSimulationInstance(model, parameters))
+        analysis_stage_class = type(self._SetUpRomSimulationInstance(model, parameters))
         simulation = self.CustomizeSimulation(analysis_stage_class,model,parameters)
         simulation.Initialize()
         return simulation.GetPetrovGalerkinTrainUtility()
@@ -948,6 +925,17 @@ def _UpdateDefaultsWithRomParams(self, defaults, rom_params):
                     defaults[key] = rom_params[key].GetDouble()
         return defaults
 
+    def _SetUpRomSimulationInstance(self, model, parameters, nn_rom_interface=None):
+        rom_params = self.general_rom_manager_parameters["ROM"]
+        return SetUpSimulationInstance(model, parameters, nn_rom_interface=nn_rom_interface,
+                                       rom_basis_output_folder=rom_params["rom_basis_output_folder"].GetString(),
+                                       rom_basis_output_name=rom_params["rom_basis_output_name"].GetString())
+
+
+    def _GetSnapshotsOutputPath(self):
+        return Path(self.general_rom_manager_parameters["ROM"]["rom_basis_output_folder"].GetString()) / "numpy_snapshots"
+
+
     def _GetMaterialsFileName(self, parameters):
         """Returns the materials file name, or None if it is not defined at the solver_settings level (e.g. coupled solvers)."""
         solver_settings = parameters["solver_settings"]
@@ -1050,16 +1038,108 @@ def _SetTrainHROMFlag(self, train_hrom):
             json.dump(f, parameter_file, indent=4)
             parameter_file.truncate()
 
-    #TODO get rid of this process in favor or Numpy output process
-    def _AddBasisCreationToProjectParameters(self, parameters):
-        #FIXME make sure no other rom_output already existed. If so, erase the prior and keep only the one in self.general_rom_manager_parameters["ROM"]
-        parameters["output_processes"].AddEmptyArray("rom_output")
-        rom_basis_parameters = self._SetUpRomBasisParameters()
-        parameters["output_processes"]["rom_output"].Append(rom_basis_parameters)
+    def _AddNumpyOutputToProjectParameters(self, parameters):
+        rom_params = self.general_rom_manager_parameters["ROM"]
+        numpy_output_parameters = KratosMultiphysics.Parameters("""{
+            "python_module" : "numpy_output_process",
+            "kratos_module" : "KratosMultiphysics.RomApplication",
+            "process_name"  : "NumpyOutputProcess",
+            "Parameters"    : {}
+        }""")
+        numpy_output_parameters["Parameters"].AddString("model_part_name", rom_params["model_part_name"].GetString())
+        numpy_output_parameters["Parameters"].AddString("output_control_type", rom_params["snapshots_control_type"].GetString())
+        numpy_output_parameters["Parameters"].AddDouble("output_interval", rom_params["snapshots_interval"].GetDouble())
+        numpy_output_parameters["Parameters"].AddValue("nodal_results", rom_params["nodal_unknowns"])
+        numpy_output_parameters["Parameters"].AddString("output_path", str(self._GetSnapshotsOutputPath()))
+        parameters["output_processes"].AddEmptyArray("rom_manager_numpy_output")
+        parameters["output_processes"]["rom_manager_numpy_output"].Append(numpy_output_parameters)
+
+        # Remove leftovers from previous runs so that only the upcoming simulation snapshots are fetched
+        shutil.rmtree(self._GetSnapshotsOutputPath(), ignore_errors=True)
 
         return parameters
 
 
+    def _GetSnapshotsMatrixFromNumpyOutput(self):
+        snapshots_output_path = self._GetSnapshotsOutputPath()
+        # Files are named 'solution_<step>' or 'solution_<time>', sort them numerically
+        snapshot_files = sorted(snapshots_output_path.glob("solution_*.npy"), key=lambda f: float(f.stem[len("solution_"):]))
+        snapshots_matrix = np.block([np.load(f) for f in snapshot_files])
+        shutil.rmtree(snapshots_output_path)
+
+        return snapshots_matrix
+
+
+    def _ComputeSVD(self, snapshots_matrix):
+        # Calculate the randomized SVD of the snapshots matrix
+        svd_truncation_tolerance = self.general_rom_manager_parameters["ROM"]["svd_truncation_tolerance"].GetDouble()
+        u,sigma,_,_= RandomizedSingularValueDecomposition().Calculate(snapshots_matrix, svd_truncation_tolerance)
+        return u, sigma
+
+
+    def _PrintRomBasis(self, u, sigma):
+        rom_params = self.general_rom_manager_parameters["ROM"]
+        rom_basis_output_format = rom_params["rom_basis_output_format"].GetString()
+        rom_basis_output_folder = Path(rom_params["rom_basis_output_folder"].GetString())
+        rom_basis_output_name = rom_params["rom_basis_output_name"].GetString()
+        print_singular_values = rom_params["print_singular_values"].GetBool()
+        if print_singular_values and rom_basis_output_format == "json":
+            err_msg = 'Cannot print singular values if using the "json" output format. Please use "numpy" instead.'
+            raise Exception(err_msg)
+
+        # Note that the nodal unknowns are sorted alphabetically, consistently with the NumpyOutputProcess
+        nodal_unknowns = sorted(rom_params["nodal_unknowns"].GetStringArray())
+        n_nodal_unknowns = len(nodal_unknowns)
+        model_part = self.InitializeDummySimulationForSnapshotsModelPart()
+
+        # Initialize the Python dictionary with the default settings
+        rom_basis_dict = {
+            "rom_manager" : True,
+            "train_hrom": False,
+            "run_hrom": False,
+            "projection_strategy": "galerkin",
+            "assembling_strategy": "global",
+            "rom_format": rom_basis_output_format,
+            "rom_settings": {
+                "rom_bns_settings": {},
+                "nodal_unknowns": nodal_unknowns,
+                "number_of_rom_dofs": np.shape(u)[1],
+                "petrov_galerkin_number_of_rom_dofs": 0
+            },
+            "hrom_settings": {
+                "hrom_format": rom_basis_output_format
+            },
+            "nodal_modes": {},
+            "elements_and_weights" : {}
+        }
+
+        # Create the folder if it doesn't already exist
+        if not rom_basis_output_folder.exists():
+            rom_basis_output_folder.mkdir(parents=True)
+
+        if rom_basis_output_format == "json":
+            # Storing modes in JSON format
+            i = 0
+            for node in model_part.Nodes:
+                rom_basis_dict["nodal_modes"][node.Id] = u[i:i+n_nodal_unknowns].tolist()
+                i += n_nodal_unknowns
+        elif rom_basis_output_format == "numpy":
+            # Storing modes in Numpy format
+            node_ids = np.array([node.Id for node in model_part.Nodes])
+            np.save(rom_basis_output_folder / "RightBasisMatrix.npy", u)
+            np.save(rom_basis_output_folder / "NodeIds.npy", node_ids)
+            if print_singular_values:
+                np.save(rom_basis_output_folder / "SingularValuesVector.npy", sigma)
+        else:
+            err_msg = f"Unsupported output format {rom_basis_output_format}. Available options are 'json' and 'numpy'."
+            raise Exception(err_msg)
+
+        # Creating the ROM JSON file containing or not the modes depending on the output format
+        output_filename = rom_basis_output_folder / f"{rom_basis_output_name}.json"
+        with output_filename.open('w') as f:
+            json.dump(rom_basis_dict, f, indent = 4)
+
+
     def _AddResidualsProjectedOutputProcessToProjectParameters(self, parameters):
         if not parameters.Has("output_processes"):
             parameters.AddEmptyValue("output_processes")
@@ -1242,30 +1322,6 @@ def DefaultUpdateMaterialParametersFile(self, material_parametrs_file_name=None,
         #     json.dump(data, f, indent=4)
         #     f.truncate()
 
-    def _SetUpRomBasisParameters(self):
-        defaults = self._GetDefaulRomBasisOutputParameters()
-        defaults["Parameters"]["rom_manager"].SetBool(True)  # Set the flag to true when inside the RomManager to trigger particular behavior for multiple parameters
-
-        rom_params = self.general_rom_manager_parameters["ROM"]
-
-        keys_to_copy = [
-            "svd_truncation_tolerance",
-            "model_part_name",
-            "rom_basis_output_format",
-            "rom_basis_output_name",
-            "rom_basis_output_folder",
-            "nodal_unknowns",
-            "snapshots_interval",
-            "print_singular_values"
-        ]
-
-        for key in keys_to_copy:
-            if key in rom_params.keys():
-                defaults["Parameters"][key] = rom_params[key]
-
-        return defaults
-
-
     def _SetUpProjectedResidualsOutputProcessParameters(self, model_part_name, sub_solver_name=""):
         process_settings = self._GetDefaulProjectedResidualsOutputProcessParameters()
         rom_params = self.general_rom_manager_parameters["ROM"]
@@ -1308,30 +1364,6 @@ def _GetAnalysisStageClass(self, parameters):
         return analysis_stage_class
 
 
-    def _GetDefaulRomBasisOutputParameters(self):
-        rom_training_parameters = KratosMultiphysics.Parameters("""{
-                "python_module" : "calculate_rom_basis_output_process",
-                "kratos_module" : "KratosMultiphysics.RomApplication",
-                "process_name"  : "CalculateRomBasisOutputProcess",
-                "help"          : "This process should write the Rom basis",
-                "Parameters"    :
-                {
-                    "model_part_name": "",
-                    "rom_manager" : false,      // set to false for manual manipulation of ROM via flags in the RomParameters
-                    "snapshots_control_type": "step",
-                    "snapshots_interval": 1.0,
-                    "nodal_unknowns":  [],
-                    "rom_basis_output_format": "json",
-                    "rom_basis_output_name": "RomParameters",
-                    "rom_basis_output_folder": "rom_data",
-                    "svd_truncation_tolerance": 1e-3,
-                    "print_singular_values": false
-                }
-            }""")
-        return rom_training_parameters
-
-
-
     def _GetDefaulProjectedResidualsOutputProcessParameters(self):
         return KratosMultiphysics.Parameters("""{
             "python_module": "projected_residuals_output_process",
diff --git a/applications/RomApplication/python_scripts/rom_testing_utilities.py b/applications/RomApplication/python_scripts/rom_testing_utilities.py
index e54c5c3fe763..3e06a2051bfb 100644
--- a/applications/RomApplication/python_scripts/rom_testing_utilities.py
+++ b/applications/RomApplication/python_scripts/rom_testing_utilities.py
@@ -3,7 +3,7 @@
 import KratosMultiphysics
 import KratosMultiphysics.RomApplication.rom_analysis
 
-def SetUpSimulationInstance(model, parameters, nn_rom_interface=None):
+def SetUpSimulationInstance(model, parameters, nn_rom_interface=None, rom_basis_output_folder=None, rom_basis_output_name=None):
     """ Creates and returns a ROM simulation instance """
 
     # Get the parent simulation class
@@ -22,7 +22,9 @@ def SetUpSimulationInstance(model, parameters, nn_rom_interface=None):
         analysis_stage_class,
         model,
         parameters,
-        nn_rom_interface=nn_rom_interface)
+        nn_rom_interface=nn_rom_interface,
+        rom_basis_output_folder=rom_basis_output_folder,
+        rom_basis_output_name=rom_basis_output_name)
 
     return simulation
 
diff --git a/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/NodeIds_Results.npy b/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/NodeIds_Results.npy
deleted file mode 100644
index 9d306534f5f6..000000000000
Binary files a/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/NodeIds_Results.npy and /dev/null differ
diff --git a/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/RightBasisMatrix_Results.npy b/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/RightBasisMatrix_Results.npy
deleted file mode 100644
index f10501b18858..000000000000
Binary files a/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/RightBasisMatrix_Results.npy and /dev/null differ
diff --git a/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/RomParameters_test_Results.json b/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/RomParameters_test_Results.json
deleted file mode 100644
index 2efbc1977488..000000000000
--- a/applications/RomApplication/tests/calculate_rom_basis_output_process_test_files/RomParameters_test_Results.json
+++ /dev/null
@@ -1,52 +0,0 @@
-{
-    "rom_manager": false,
-    "train_hrom": false,
-    "run_hrom": false,
-    "projection_strategy": "galerkin",
-    "assembling_strategy": "global",
-    "rom_format": "json",
-    "rom_settings": {
-        "rom_bns_settings": {},
-        "nodal_unknowns": [
-            "TEMPERATURE"
-        ],
-        "number_of_rom_dofs": 2,
-        "petrov_galerkin_number_of_rom_dofs": 0
-    },
-    "hrom_settings": {
-        "hrom_format": "json"
-    },
-    "nodal_modes": {
-        "2": [
-            [
-                -0.01983405679273213,
-                0.5993762115792658
-            ]
-        ],
-        "5": [
-            [
-                -0.04391666176273041,
-                0.5763832650962621
-            ]
-        ],
-        "12": [
-            [
-                -0.10010940669272668,
-                0.5227330566359412
-            ]
-        ],
-        "69": [
-            [
-                -0.5576789011226962,
-                0.08586707345904437
-            ]
-        ],
-        "102": [
-            [
-                -0.8225875557926786,
-                -0.16705533785390972
-            ]
-        ]
-    },
-    "elements_and_weights": {}
-}
\ No newline at end of file
diff --git a/applications/RomApplication/tests/hrom_training_utility_test_files/ProjectParameters.json b/applications/RomApplication/tests/hrom_training_utility_test_files/ProjectParameters.json
index 983305f9cd03..8906c3ffeaec 100644
--- a/applications/RomApplication/tests/hrom_training_utility_test_files/ProjectParameters.json
+++ b/applications/RomApplication/tests/hrom_training_utility_test_files/ProjectParameters.json
@@ -9,21 +9,7 @@
     },
     "output_processes" : {
         "gid_output" : [],
-        "vtk_output" : [],
-        "rom_output": [{
-            "python_module" : "calculate_rom_basis_output_process",
-            "kratos_module" : "KratosMultiphysics.RomApplication",
-            "process_name"  : "CalculateRomBasisOutputProcess",
-            "Parameters": {
-            "model_part_name": "FluidModelPart",
-            "snapshots_control_type": "step",
-            "snapshots_interval": 1.0,
-            "nodal_unknowns": ["VELOCITY_X","VELOCITY_Y","PRESSURE"],
-            "rom_basis_output_format": "numpy",
-            "rom_basis_output_name": "RomParameters",
-            "svd_truncation_tolerance": 1e-6
-            }
-        }]
+        "vtk_output" : []
     },
     "solver_settings"  : {
         "model_part_name"             : "FluidModelPart",
diff --git a/applications/RomApplication/tests/test_RomApplication.py b/applications/RomApplication/tests/test_RomApplication.py
index c6625a94dd57..8e716ea247a1 100644
--- a/applications/RomApplication/tests/test_RomApplication.py
+++ b/applications/RomApplication/tests/test_RomApplication.py
@@ -10,8 +10,6 @@
 from test_structural_rom import TestStructuralRom
 from test_randomized_singular_value_decomposition import TestRandomizedSVD
 from test_empirical_cubature_method import TestEmpiricalCubatureMethod
-from test_calculate_rom_basis_output_process_json import TestCalculateRomBasisOutputProcessJSON
-from test_calculate_rom_basis_output_process_numpy import TestCalculateRomBasisOutputProcessNumpy
 from test_compressible_potiential_rom import TestCompressiblePotentialRom
 from test_fluid_lspg_rom import TestFluidLSPGRom
 from test_thermal_lspg_rom import TestThermalLSPGRom
@@ -52,8 +50,6 @@ def AssembleTestSuites():
     smallSuite.addTests(KratosUnittest.TestLoader().loadTestsFromTestCases([TestFluidRom]))
     smallSuite.addTests(KratosUnittest.TestLoader().loadTestsFromTestCases([TestThermalRom]))
     smallSuite.addTests(KratosUnittest.TestLoader().loadTestsFromTestCases([TestStructuralRom]))
-    smallSuite.addTests(KratosUnittest.TestLoader().loadTestsFromTestCases([TestCalculateRomBasisOutputProcessJSON]))
-    smallSuite.addTests(KratosUnittest.TestLoader().loadTestsFromTestCases([TestCalculateRomBasisOutputProcessNumpy]))
     smallSuite.addTest(TestRandomizedSVD('test_radomized_svd'))
     smallSuite.addTest(TestEmpiricalCubatureMethod('test_empirical_cubature_method'))
     smallSuite.addTests(KratosUnittest.TestLoader().loadTestsFromTestCases([TestCompressiblePotentialRom]))
diff --git a/applications/RomApplication/tests/test_calculate_rom_basis_output_process_json.py b/applications/RomApplication/tests/test_calculate_rom_basis_output_process_json.py
deleted file mode 100644
index 7991da9b3c59..000000000000
--- a/applications/RomApplication/tests/test_calculate_rom_basis_output_process_json.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import os
-import json
-
-import KratosMultiphysics
-import KratosMultiphysics.KratosUnittest as KratosUnittest
-import KratosMultiphysics.kratos_utilities as kratos_utilities
-from KratosMultiphysics.compare_two_files_check_process import CompareTwoFilesCheckProcess
-from KratosMultiphysics.RomApplication.calculate_rom_basis_output_process import CalculateRomBasisOutputProcess
-
-class TestCalculateRomBasisOutputProcessJSON(KratosUnittest.TestCase):
-
-    def setUp(self):
-        # Test data
-        self.print_output = False
-        self.work_folder = "calculate_rom_basis_output_process_test_files"
-
-        # List containing the fake total times
-        self.time_steps_list = [1.0,2.0,4.0]
-
-        # Create a model part to perform the ROM basis calculation
-        self.model = KratosMultiphysics.Model()
-        model_part = self.model.CreateModelPart("MainModelPart")
-        model_part.AddNodalSolutionStepVariable(KratosMultiphysics.TEMPERATURE)
-        node_ids_non_ordered = [2,5,12,69,102]
-        n_nodes = len(node_ids_non_ordered)
-        for i in range(n_nodes):
-            model_part.CreateNewNode(node_ids_non_ordered[i],float(i),0.0,0.0)
-
-    def testCalculateRomBasisOutputProcess(self):
-        # Create a CalculateROMBasisOutputProcess instance
-        self.process_settings = KratosMultiphysics.Parameters("""{
-            "model_part_name": "MainModelPart",
-            "snapshots_control_type": "step",
-            "snapshots_interval": 1.0,
-            "nodal_unknowns": ["TEMPERATURE"],
-            "rom_basis_output_format": "json",
-            "rom_basis_output_name": "RomParameters_test",
-            "rom_basis_output_folder": "rom_data_test",
-            "svd_truncation_tolerance": 1.0e-6
-        }""")
-
-        # Run a "fake" simulation to calculate the ROM basis from its results
-        self.__ExecuteTest(self.process_settings)
-
-        # Check results
-        check_hrom_settings = False
-        self.__CheckResults(check_hrom_settings)
-
-    def tearDown(self):
-        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
-            if not self.print_output:
-                for path in os.listdir():
-                    full_path = os.path.join(os.getcwd(), path)
-                    if not "_Results" in path:
-                        if os.path.isfile(full_path):
-                            kratos_utilities.DeleteFileIfExisting(full_path)
-                        elif os.path.isdir(full_path):
-                            kratos_utilities.DeleteDirectoryIfExisting(full_path)
-
-
-    def __ExecuteTest(self, process_settings):
-        # Emulate a simulation to get the ROM basis output
-        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
-            # Create a calculate ROM basis process instance
-            rom_basis_process = CalculateRomBasisOutputProcess(self.model, process_settings)
-
-            # Emulate simulation to fill the database and calculate the ROM basis
-            rom_basis_process.ExecuteInitialize()
-            rom_basis_process.Check()
-            rom_basis_process.ExecuteBeforeSolutionLoop()
-
-            model_part = self.model.GetModelPart("MainModelPart")
-            for time,step in zip(self.time_steps_list, range(1,len(self.time_steps_list)+1,1)):
-                # Fake time advance
-                model_part.CloneTimeStep(time)
-                model_part.ProcessInfo[KratosMultiphysics.STEP] = step
-
-                # Set nodal values
-                if step % 2 == 0:
-                    get_value = lambda node_id, time : node_id*time**2 + step
-                else:
-                    get_value = lambda node_id, time : -node_id/time**step
-                for node in model_part.Nodes:
-                    node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE, get_value(node.Id, time))
-
-                # Call the process instance methods
-                rom_basis_process.ExecuteInitializeSolutionStep()
-                if rom_basis_process.IsOutputStep():
-                    rom_basis_process.ExecuteBeforeOutputStep()
-                    rom_basis_process.PrintOutput()
-                    rom_basis_process.ExecuteAfterOutputStep()
-                rom_basis_process.ExecuteFinalizeSolutionStep()
-
-            rom_basis_process.ExecuteFinalize()
-
-    def __CheckResults(self, check_hrom_settings):
-        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
-            # Load ROM basis output file
-            output_folder = self.process_settings["rom_basis_output_folder"].GetString()
-            full_output_filename = os.path.join(output_folder, "{}.{}".format(self.process_settings["rom_basis_output_name"].GetString(), self.process_settings["rom_basis_output_format"].GetString()))
-            with open(full_output_filename) as f:
-                output_data = json.load(f)
-
-            # Load reference file
-            reference_filename = "{}_Results.{}".format(self.process_settings["rom_basis_output_name"].GetString(), self.process_settings["rom_basis_output_format"].GetString())
-            with open(reference_filename) as f:
-                reference_data = json.load(f)
-
-            # Check files
-            # Note that we need to do it manually as literal (deterministic) file comparison cannot be used because of the basis float values
-            self.assertEqual(output_data["rom_settings"], reference_data["rom_settings"])
-            for node_output, node_reference in zip(output_data["nodal_modes"],reference_data["nodal_modes"]):
-                self.assertEqual(node_output, node_reference)
-                for dof_basis_output, dof_basis_reference in zip(output_data["nodal_modes"][node_output], reference_data["nodal_modes"][node_reference]):
-                    self.assertVectorAlmostEqual(dof_basis_output, dof_basis_reference)
-
-            if check_hrom_settings:
-                self.assertEqual(output_data["hrom_settings"], reference_data["hrom_settings"])
-                self.assertEqual(output_data["train_hrom"], reference_data["train_hrom"])
-                self.assertEqual(output_data["run_hrom"], reference_data["run_hrom"])
-                self.assertEqual(output_data["elements_and_weights"], reference_data["elements_and_weights"])
-
-##########################################################################################
-
-if __name__ == '__main__':
-    KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING)
-    KratosUnittest.main()
diff --git a/applications/RomApplication/tests/test_calculate_rom_basis_output_process_numpy.py b/applications/RomApplication/tests/test_calculate_rom_basis_output_process_numpy.py
deleted file mode 100644
index b3c3fae1400b..000000000000
--- a/applications/RomApplication/tests/test_calculate_rom_basis_output_process_numpy.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import os
-
-import KratosMultiphysics
-import KratosMultiphysics.KratosUnittest as KratosUnittest
-import KratosMultiphysics.kratos_utilities as kratos_utilities
-from KratosMultiphysics.RomApplication.calculate_rom_basis_output_process import CalculateRomBasisOutputProcess
-import numpy as np
-
-class TestCalculateRomBasisOutputProcessNumpy(KratosUnittest.TestCase):
-
-    def setUp(self):
-        # Test data
-        self.print_output = False
-        self.work_folder = "calculate_rom_basis_output_process_test_files"
-
-        # List containing the fake total times
-        self.time_steps_list = [1.0,2.0,4.0]
-
-        # Create a model part to perform the ROM basis calculation
-        self.model = KratosMultiphysics.Model()
-        model_part = self.model.CreateModelPart("MainModelPart")
-        model_part.AddNodalSolutionStepVariable(KratosMultiphysics.TEMPERATURE)
-        node_ids_non_ordered = [2,5,12,69,102]
-        n_nodes = len(node_ids_non_ordered)
-        for i in range(n_nodes):
-            model_part.CreateNewNode(node_ids_non_ordered[i],float(i),0.0,0.0)
-
-    def testCalculateRomBasisOutputProcess(self):
-        # Create a CalculateROMBasisOutputProcess instance
-        self.process_settings = KratosMultiphysics.Parameters("""{
-            "model_part_name": "MainModelPart",
-            "snapshots_control_type": "step",
-            "snapshots_interval": 1.0,
-            "nodal_unknowns": ["TEMPERATURE"],
-            "rom_basis_output_format": "numpy",
-            "rom_basis_output_name": "RomParameters_test",
-            "rom_basis_output_folder": "rom_data_test",
-            "svd_truncation_tolerance": 1.0e-6
-        }""")
-
-        # Run a "fake" simulation to calculate the ROM basis from its results
-        self.__ExecuteTest(self.process_settings)
-
-        # Check results
-        self.__CheckResults()
-
-    def tearDown(self):
-        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
-            if not self.print_output:
-                for path in os.listdir():
-                    full_path = os.path.join(os.getcwd(), path)
-                    if not "_Results" in path:
-                        if os.path.isfile(full_path):
-                            kratos_utilities.DeleteFileIfExisting(full_path)
-                        elif os.path.isdir(full_path):
-                            kratos_utilities.DeleteDirectoryIfExisting(full_path)
-
-
-    def __ExecuteTest(self, process_settings):
-        # Emulate a simulation to get the ROM basis output
-        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
-            # Create a calculate ROM basis process instance
-            rom_basis_process = CalculateRomBasisOutputProcess(self.model, process_settings)
-
-            # Emulate simulation to fill the database and calculate the ROM basis
-            rom_basis_process.ExecuteInitialize()
-            rom_basis_process.Check()
-            rom_basis_process.ExecuteBeforeSolutionLoop()
-
-            model_part = self.model.GetModelPart("MainModelPart")
-            for time,step in zip(self.time_steps_list, range(1,len(self.time_steps_list)+1,1)):
-                # Fake time advance
-                model_part.CloneTimeStep(time)
-                model_part.ProcessInfo[KratosMultiphysics.STEP] = step
-
-                # Set nodal values
-                if step % 2 == 0:
-                    get_value = lambda node_id, time : node_id*time**2 + step
-                else:
-                    get_value = lambda node_id, time : -node_id/time**step
-                for node in model_part.Nodes:
-                    node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE, get_value(node.Id, time))
-
-                # Call the process instance methods
-                rom_basis_process.ExecuteInitializeSolutionStep()
-                if rom_basis_process.IsOutputStep():
-                    rom_basis_process.ExecuteBeforeOutputStep()
-                    rom_basis_process.PrintOutput()
-                    rom_basis_process.ExecuteAfterOutputStep()
-                rom_basis_process.ExecuteFinalizeSolutionStep()
-
-            rom_basis_process.ExecuteFinalize()
-
-    def __CheckResults(self):
-        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
-            # Load ROM basis output file
-            output_folder = self.process_settings["rom_basis_output_folder"].GetString()
-            RightBasisOutput_name = os.path.join(output_folder, "{}.{}".format("RightBasisMatrix", "npy")) #TODO allow name customization in Numpy
-            NodeIdsOutput_name = os.path.join(output_folder, "{}.{}".format("NodeIds", "npy")) #TODO allow name customization in Numpy
-            RightBasisOutput = np.load(RightBasisOutput_name)
-            NodeIdsOutput = np.load(NodeIdsOutput_name)
-
-            # Load reference file
-            RightBasisReference_name = "{}_Results.{}".format("RightBasisMatrix", "npy")
-            NodeIdsReference_name = "{}_Results.{}".format("NodeIds", "npy")
-            RightBasisReference = np.load(RightBasisReference_name)
-            NodeIdsReference = np.load(NodeIdsReference_name)
-
-
-
-            for node_output, node_reference in zip(NodeIdsOutput,NodeIdsReference):
-                self.assertEqual(node_output, node_reference)
-            for i in range(RightBasisOutput.shape[0]):
-                for j in range(RightBasisOutput.shape[1]):
-                    self.assertAlmostEqual(RightBasisOutput[i,j], RightBasisReference[i,j])
-
-            #JSON part tested in the JSON test already
-
-
-##########################################################################################
-
-if __name__ == '__main__':
-    KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING)
-    KratosUnittest.main()
diff --git a/applications/RomApplication/tests/test_nn_trainer_class.py b/applications/RomApplication/tests/test_nn_trainer_class.py
index b5e7839c8f07..51a46572f056 100644
--- a/applications/RomApplication/tests/test_nn_trainer_class.py
+++ b/applications/RomApplication/tests/test_nn_trainer_class.py
@@ -4,7 +4,6 @@
 import KratosMultiphysics
 import KratosMultiphysics.KratosUnittest as KratosUnittest
 import KratosMultiphysics.kratos_utilities as kratos_utilities
-from KratosMultiphysics.RomApplication.calculate_rom_basis_output_process import CalculateRomBasisOutputProcess
 
 if kratos_utilities.CheckIfApplicationsAvailable("StructuralMechanicsApplication"):
     import KratosMultiphysics.StructuralMechanicsApplication