def AddProcesses(self):
# Build sub_model_parts or submeshes (rearrange parts for the application of custom processes)
## Get the list of the submodel part in the object Model
for i in range(self.ProjectParameters["solver_settings"]
["processes_sub_model_part_list"].size()):
part_name = self.ProjectParameters["solver_settings"][
"processes_sub_model_part_list"][i].GetString()
if (self.main_model_part.HasSubModelPart(part_name)):
self.Model.update({
part_name:
self.main_model_part.GetSubModelPart(part_name)
})
# Obtain the list of the processes to be applied
import process_handler
process_parameters = KratosMultiphysics.Parameters("{}")
process_parameters.AddValue(
"echo_level", self.ProjectParameters["problem_data"]["echo_level"])
process_parameters.AddValue(
"constraints_process_list",
self.ProjectParameters["constraints_process_list"])
process_parameters.AddValue(
"loads_process_list", self.ProjectParameters["loads_process_list"])
if (self.ProjectParameters.Has("problem_process_list")):
process_parameters.AddValue(
"problem_process_list",
self.ProjectParameters["problem_process_list"])
if (self.ProjectParameters.Has("output_process_list")):
process_parameters.AddValue(
"output_process_list",
self.ProjectParameters["output_process_list"])
return (process_handler.ProcessHandler(self.Model, process_parameters))
def _get_processes(self):
# Obtain the list of the processes to be applied
import process_handler
process_parameters = KratosMultiphysics.Parameters("{}")
process_parameters.AddEmptyValue("echo_level").SetInt(self.echo_level)
if (self.ProjectParameters.Has("constraints_process_list")):
process_parameters.AddValue(
"constraints_process_list",
self.ProjectParameters["constraints_process_list"])
if (self.ProjectParameters.Has("loads_process_list")):
process_parameters.AddValue(
"loads_process_list",
self.ProjectParameters["loads_process_list"])
if (self.ProjectParameters.Has("problem_process_list")):
process_parameters.AddValue(
"problem_process_list",
self.ProjectParameters["problem_process_list"])
if (self.ProjectParameters.Has("output_process_list")):
process_parameters.AddValue(
"output_process_list",
self.ProjectParameters["output_process_list"])
if (self.ProjectParameters.Has("check_process_list")):
process_parameters.AddValue(
"check_process_list",
self.ProjectParameters["check_process_list"])
domain_model = self.model.GetModel()
return (process_handler.ProcessHandler(domain_model,
process_parameters))
def _get_processes(self):
# Obtain the list of the processes to be applied
import process_handler
# get processes parameters
processes_parameters = self._get_processes_parameters()
domain_model = self.model.GetModel()
return process_handler.ProcessHandler(domain_model, processes_parameters)
def Initialize(self):
# Add variables (always before importing the model part)
self.AddNodalVariablesToModelPart()
# Read model_part (note: the buffer_size is set here) (restart is read here)
self.solver.ImportModelPart()
# Add dofs (always after importing the model part)
if ((self.main_model_part.ProcessInfo).Has(
KratosMultiphysics.IS_RESTARTED)):
if (self.main_model_part.ProcessInfo[
KratosMultiphysics.IS_RESTARTED] == False):
self.solver.AddDofs()
else:
self.solver.AddDofs()
# Build sub_model_parts or submeshes (rearrange parts for the application of custom processes)
## Get the list of the submodel part in the object Model
for i in range(self.ProjectParameters["solver_settings"]
["processes_sub_model_part_list"].size()):
part_name = self.ProjectParameters["solver_settings"][
"processes_sub_model_part_list"][i].GetString()
if (self.main_model_part.HasSubModelPart(part_name)):
self.Model.update({
part_name:
self.main_model_part.GetSubModelPart(part_name)
})
#### Model_part settings end ####
#print model_part and properties
if (self.echo_level > 1):
print("")
print(self.main_model_part)
for properties in self.main_model_part.Properties:
print(properties)
#### Processes settings start ####
#obtain the list of the processes to be applied
import process_handler
process_parameters = KratosMultiphysics.Parameters("{}")
process_parameters.AddValue(
"echo_level", self.ProjectParameters["problem_data"]["echo_level"])
process_parameters.AddValue(
"constraints_process_list",
self.ProjectParameters["constraints_process_list"])
process_parameters.AddValue(
"loads_process_list", self.ProjectParameters["loads_process_list"])
if (self.ProjectParameters.Has("problem_process_list")):
process_parameters.AddValue(
"problem_process_list",
self.ProjectParameters["problem_process_list"])
if (self.ProjectParameters.Has("output_process_list")):
process_parameters.AddValue(
"output_process_list",
self.ProjectParameters["output_process_list"])
if (self.ProjectParameters.Has("processes_sub_model_part_tree_list")):
process_parameters.AddValue(
"processes_sub_model_part_tree_list",
self.ProjectParameters["processes_sub_model_part_tree_list"])
if (self.ProjectParameters.Has("check_process_list")):
process_parameters.AddValue(
"check_process_list",
self.ProjectParameters["check_process_list"])
self.model_processes = process_handler.ProcessHandler(
self.Model, process_parameters)
self.model_processes.ExecuteInitialize()
#### processes settings end ####
# --PLOT GRAPHS OPTIONS START--###############
#self.problem_path = os.getcwd() #current path
#plot_active = general_variables.PlotGraphs
#graph_plot = plot_utils.GraphPlotUtility(model_part, self.problem_path)
# --PLOT GRAPHS OPTIONS END--#################
#### START SOLUTION ####
self.computing_model_part = self.solver.GetComputingModelPart()
self.graphical_output = self.SetGraphicalOutput()
## Sets strategies, builders, linear solvers, schemes and solving info, and fills the buffer
self.solver.Initialize()
self.solver.InitializeStrategy()
self.solver.SetEchoLevel(self.echo_level)
# Initialize GiD I/O (gid outputs, file_lists)
self.GraphicalOutputExecuteInitialize()
#### Output settings end ####
# writing a initial state results file
current_id = 0
#if(load_restart == False):
# if (general_variables.TryToSetTheWeight):
# if (general_variables.TryToSetConstantWeight):
# conditions.SetConstantWeight( general_variables.TryToSetWeightVertical, general_variables.TryToSetWeightHorizontal);
# else:
# conditions.SetWeight();
# set solver info starting parameters
# solving_info = solving_info_utils.SolvingInfoUtility(model_part, SolverSettings)
print(" ")
print("::[KPFEM Simulation]:: Analysis -START- ")
self.model_processes.ExecuteBeforeSolutionLoop()
self.GraphicalOutputExecuteBeforeSolutionLoop()
# Set time settings
self.step = self.main_model_part.ProcessInfo[KratosMultiphysics.STEP]
self.time = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME]
self.end_time = self.ProjectParameters["problem_data"][
"end_time"].GetDouble()
self.delta_time = self.ProjectParameters["problem_data"][
"time_step"].GetDouble()
process_parameters.AddValue("constraints_process_list",
ProjectParameters["constraints_process_list"])
process_parameters.AddValue("loads_process_list",
ProjectParameters["loads_process_list"])
if (ProjectParameters.Has("problem_process_list")):
process_parameters.AddValue("problem_process_list",
ProjectParameters["problem_process_list"])
if (ProjectParameters.Has("output_process_list")):
process_parameters.AddValue("output_process_list",
ProjectParameters["output_process_list"])
if (ProjectParameters.Has("processes_sub_model_part_tree_list")):
process_parameters.AddValue(
"processes_sub_model_part_tree_list",
ProjectParameters["processes_sub_model_part_tree_list"])
model_processes = process_handler.ProcessHandler(Model, process_parameters)
model_processes.ExecuteInitialize()
#### processes settings end ####
# --PLOT GRAPHS OPTIONS START--###############
#problem_path = os.getcwd() #current path
#plot_active = general_variables.PlotGraphs
#graph_plot = plot_utils.GraphPlotUtility(model_part, problem_path)
# --PLOT GRAPHS OPTIONS END--#################
#### START SOLUTION ####
computing_model_part = solver.GetComputingModelPart()
- process_handler.py, bundled together with this script. Makes it possible to run locally or in a cluster with the Slurm queueing system
RUN:
python lfq_workflow.py
-project_folder=/absolute/or/relative/path/to/folder/where/results/will/be/created
-mzML_folder=/absolute/or/relative/path/to/mzML/
-id_results_folder=/absolute/or/relative/path/to/id_results/
-n_samples 5
-n_replica 4
'''
print("\n--lfq_worflow--\n")
ph = process_handler.ProcessHandler()()
print("ProcessHandler object created on pipeline.py\n")
#Read arguments , basic checkings and create folders for results
#-------------------------------------------------------------------------------------------------------------------------------------
apars = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
apars.add_argument('-project_folder',
help='folder where all results will be created',
required=True)
apars.add_argument('-mzML_folder',
default='mzML/',
help='dataset folder with mzML files',
required=True)
apars.add_argument('-id_results_folder',
