def GetFilePathOpen(FileType, name=""):
file_path = ""
valid_file = False
if name is not "":
name = " for: " + name
initial_directory = GetInitialDirectory()
if (FileType == "dat"):
file_path = tk.filedialog.askopenfilename(initialdir=initial_directory,
title="Open file" + name,
filetypes=[("salome mesh",
"*.dat")])
elif (FileType == conv_project_file_ending):
file_path = tk.filedialog.askopenfilename(
initialdir=initial_directory,
title="Open file" + name,
filetypes=[("converter files", "*" + conv_project_file_ending)])
elif (FileType == conv_scheme_file_ending):
file_path = tk.filedialog.askopenfilename(
initialdir=initial_directory,
title="Open file" + name,
filetypes=[("converter files", "*" + conv_scheme_file_ending)])
else:
print("Unsupported FileType") # TODO make messagebox
if file_path not in ["", ()
]: # () is the output of a cancelled file open dialog
valid_file = FileExists(file_path)
global_utils.LogDebug("File Path: " + file_path)
if valid_file:
SetInitialDirectory(file_path)
return file_path, valid_file
def Serialize(self):
# This function serializes the ModelPart such that it can be saved in a json file
global_utils.LogDebug("Serializing ModelPart")
serialized_dict = {}
for smp_name in sorted(self.sub_model_parts.keys()):
smp = self.sub_model_parts[smp_name]
serialized_dict.update(smp.Serialize())
return serialized_dict
def Serialize(self):
self.__CheckIsProperlyInitialized()
global_utils.LogDebug("Serializing " + self.smp_info_dict["smp_name"])
serialized_smp = {}
serialized_smp["submodelpart_information"] = self.smp_info_dict
serialized_smp["mesh_information"] = self.mesh_dict
serialized_smp["nodes_read"] = self.__SerializeNodesRead()
serialized_smp[
"geom_entities_read"] = self.__SerializeGeomEntitiesRead()
return {self.smp_info_dict["smp_name"]: serialized_smp}
def __WriteNodes(self, open_file, readable_mdpa):
open_file.write("Begin Nodes\n")
if readable_mdpa:
max_ID = max(self.nodes.keys())
global_utils.LogDebug("Max Node ID: " + str(max_ID))
spaces_coords_x = '{:>' + str(
len(str(int(self.max_node_coord_x))) + self.precision +
self.num_spaces) + '} '
spaces_coords_y = '{:>' + str(
len(str(int(self.max_node_coord_y))) + self.precision +
self.num_spaces) + '} '
spaces_coords_z = '{:>' + str(
len(str(int(self.max_node_coord_z))) + self.precision +
self.num_spaces) + '} '
format_str = '{:>' + str(
len(str(max_ID))
) + '} ' + spaces_coords_x + spaces_coords_y + spaces_coords_z
else:
format_str = '{} {} {} {}'
global_utils.LogDebug("Node Format String: " + str(format_str))
for ID in sorted(list(self.nodes.keys())):
coords = self.nodes[ID][0]
coords = [
round(coords[0], self.precision),
round(coords[1], self.precision),
round(coords[2], self.precision)
]
line = format_str.format(str(ID), coords[0], str(coords[1]),
str(coords[2])) + "\n"
open_file.write(line)
open_file.write("End Nodes\n\n")
def Deserialize(self, serialized_dict):
# This function constructs a modelpart from a serialized dictionary
self.Reset()
for smp_name in sorted(serialized_dict.keys()):
if smp_name != "general":
self.sub_model_parts[smp_name] = MeshSubmodelPart()
self.sub_model_parts[smp_name].Deserialize(
smp_name, serialized_dict[smp_name])
self.mesh_read = True
global_utils.LogDebug("Deserialized ModelPart")
def Deserialize(self, smp_name, serialized_smp):
smp_info_dict, mesh_dict = self.__DeserializeDictionary(serialized_smp)
nodes_read = {}
geom_entities_read = {}
if "nodes_read" in serialized_smp:
nodes_read = self.__DeserializeNodesRead(
serialized_smp["nodes_read"])
if "geom_entities_read" in serialized_smp: # Geometric Entities can only exist if there are nodes!
geom_entities_read = self.__DeserializeGeomEntitiesRead(
serialized_smp["geom_entities_read"])
self.FillWithEntities(smp_info_dict, mesh_dict, nodes_read,
geom_entities_read)
global_utils.LogDebug("Deserialized " + smp_name)
def __WriteConditions(self, open_file, readable_mdpa):
if readable_mdpa:
num_conditions = self.NumberOfConditions()
format_str = '{:>' + str(len(str(num_conditions))) + '} {:>' + str(
self.num_spaces) + '}'
space = "\t"
else:
format_str = '{} {}'
space = " "
global_utils.LogDebug("Condition Format String: " + str(format_str))
for condition_name in sorted(list(self.conditions.keys())):
open_file.write("Begin Conditions " + condition_name + "\n")
conditions_by_name = self.conditions[condition_name]
for cond in conditions_by_name:
open_file.write(cond.GetWriteLine(format_str, space) + "\n")
open_file.write("End Conditions // " + condition_name + "\n\n")
def __WriteElements(self, open_file, readable_mdpa):
if readable_mdpa:
num_elements = self.NumberOfElements()
format_str = '{:>' + str(len(str(num_elements))) + '} {:>' + str(
self.num_spaces) + '}'
space = "\t"
else:
format_str = '{} {}'
space = " "
global_utils.LogDebug("Element Format String: " + str(format_str))
for element_name in sorted(list(self.elements.keys())):
open_file.write("Begin Elements " + element_name + "\n")
elements_by_name = self.elements[element_name]
for elem in elements_by_name:
open_file.write(elem.GetWriteLine(format_str, space) + "\n")
open_file.write("End Elements // " + element_name + "\n\n")
