mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-15 18:14:08 +00:00
Ioannis P. Christovasilis
510 lines
21 KiB
Python
510 lines
21 KiB
Python
# Ifc2CA - IFC Code_Aster utility
|
|
# Copyright (C) 2020, 2021, 2023, 2024 Ioannis P. Christovasilis <ipc@aethereng.com>
|
|
#
|
|
# This file is part of Ifc2CA.
|
|
#
|
|
# Ifc2CA is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Lesser General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ifc2CA is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with Ifc2CA. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import itertools
|
|
import json
|
|
import os
|
|
import time
|
|
from pathlib import Path
|
|
|
|
import numpy as np
|
|
import salome
|
|
import salome_notebook
|
|
import salome_version
|
|
|
|
flatten = itertools.chain.from_iterable
|
|
|
|
mesh_size = {{ mesh_size }}
|
|
med_path = r"{{ med_path }}"
|
|
json_path = r"{{ json_path }}"
|
|
|
|
with open(json_path, "r") as f:
|
|
data = json.load(f)
|
|
|
|
|
|
class MODEL:
|
|
def __init__(self):
|
|
self.medFilename = med_path
|
|
self.mesh_size = mesh_size
|
|
self.tolLoc = 0
|
|
self.mesh = None
|
|
self.meshNodes = None
|
|
self.create()
|
|
|
|
def getGroupName(self, name):
|
|
if "|" in name:
|
|
info = name.split("|")
|
|
sortName = "".join(c for c in info[0] if c.isupper())
|
|
return f"{sortName[2:]}_{info[1]}"
|
|
else:
|
|
return name
|
|
|
|
def makePoint(self, pl):
|
|
"""Function to define a Point from
|
|
a polyline (list of 1 point)"""
|
|
|
|
(x, y, z) = pl
|
|
return self.geompy.MakeVertex(x, y, z)
|
|
|
|
def makeLine(self, pl):
|
|
"""Function to define a Line from
|
|
a polyline (list of 2 points)"""
|
|
|
|
(x, y, z) = pl[0]
|
|
P1 = self.geompy.MakeVertex(x, y, z)
|
|
(x, y, z) = pl[1]
|
|
P2 = self.geompy.MakeVertex(x, y, z)
|
|
|
|
return self.geompy.MakeLineTwoPnt(P1, P2)
|
|
|
|
def makeFace(self, pl):
|
|
"""Function to define a Face from
|
|
a polyline (list of points)"""
|
|
|
|
pointList = [None for _ in range(len(pl))]
|
|
for ip, (x, y, z) in enumerate(pl):
|
|
pointList[ip] = self.geompy.MakeVertex(x, y, z)
|
|
|
|
LineList = [None for _ in range(len(pl))]
|
|
for ip, P2 in enumerate(pointList):
|
|
P1 = pointList[ip - 1]
|
|
LineList[ip] = self.geompy.MakeLineTwoPnt(P1, P2)
|
|
|
|
return self.geompy.MakeFaceWires(LineList, 1)
|
|
|
|
def makeObject(self, geometry, geometry_type):
|
|
if geometry_type == "Vertex":
|
|
return self.makePoint(geometry)
|
|
if geometry_type == "Edge":
|
|
return self.makeLine(geometry)
|
|
if geometry_type == "Face":
|
|
return self.makeFace(geometry)
|
|
|
|
def makePartition(self, objects, geometry_type):
|
|
if geometry_type == "Vertex":
|
|
shapeType = "VERTEX"
|
|
if geometry_type == "Edge":
|
|
shapeType = "EDGE"
|
|
if geometry_type == "Face":
|
|
shapeType = "FACE"
|
|
return self.geompy.MakePartition(objects, [], [], [], self.geompy.ShapeType[shapeType], 0, [], 1)
|
|
|
|
def length(self, geometry):
|
|
return (
|
|
(geometry[1][0] - geometry[0][0]) ** 2
|
|
+ (geometry[1][1] - geometry[0][1]) ** 2
|
|
+ (geometry[1][2] - geometry[0][2]) ** 2
|
|
) ** 0.5
|
|
|
|
def create(self):
|
|
# Read data from input file
|
|
# data = data
|
|
|
|
self.elements = elements = data["elements"]
|
|
self.connections = connections = data["connections"]
|
|
# --> Delete this reference data and repopulate it with the objects
|
|
# while going through elements
|
|
for conn in connections:
|
|
conn["related_elements"] = []
|
|
# End <--
|
|
|
|
mesh_size = self.mesh_size
|
|
|
|
dec = 7 # 4 decimals for length in mm
|
|
tol = 10 ** (-dec - 3 + 1)
|
|
|
|
self.tolLoc = tol * 10 * 2
|
|
tolLoc = self.tolLoc
|
|
|
|
self.NEW_SALOME = NEW_SALOME = int(salome_version.getVersion()[0]) >= 9
|
|
salome.salome_init()
|
|
theStudy = salome.myStudy
|
|
notebook = salome_notebook.NoteBook(theStudy)
|
|
|
|
###
|
|
### GEOM component
|
|
###
|
|
import math
|
|
|
|
import GEOM
|
|
import SALOMEDS
|
|
from salome.geom import geomBuilder
|
|
|
|
gg = salome.ImportComponentGUI("GEOM")
|
|
if NEW_SALOME:
|
|
geompy = geomBuilder.New()
|
|
else:
|
|
geompy = geomBuilder.New(theStudy)
|
|
self.geompy = geompy
|
|
|
|
O = geompy.MakeVertex(0, 0, 0)
|
|
OX = geompy.MakeVectorDXDYDZ(1, 0, 0)
|
|
OY = geompy.MakeVectorDXDYDZ(0, 1, 0)
|
|
OZ = geompy.MakeVectorDXDYDZ(0, 0, 1)
|
|
geompy.addToStudy(O, "O")
|
|
geompy.addToStudy(OX, "OX")
|
|
geompy.addToStudy(OY, "OY")
|
|
geompy.addToStudy(OZ, "OZ")
|
|
|
|
if len([e for e in elements if e["geometry_type"] == "Edge"]) > 0:
|
|
buildingShapeType = "EDGE"
|
|
if len([e for e in elements if e["geometry_type"] == "Face"]) > 0:
|
|
buildingShapeType = "FACE"
|
|
|
|
### Define entities ###
|
|
start_time = time.time()
|
|
print("Defining Object Geometry")
|
|
init_time = start_time
|
|
|
|
# Loop 1
|
|
for el in elements:
|
|
el["elemObj"] = self.makeObject(el["geometry"], el["geometry_type"])
|
|
|
|
el["connObjs"] = [None for _ in el["connections"]]
|
|
el["linkObjs"] = [None for _ in el["connections"]]
|
|
el["linkPointObjs"] = [[None, None] for _ in el["connections"]]
|
|
for j, rel in enumerate(el["connections"]):
|
|
conn = [c for c in connections if c["ref_id"] == rel["related_connection"]][0]
|
|
if rel["eccentricity"]:
|
|
rel["index"] = len(conn["related_elements"]) + 1
|
|
conn["related_elements"].append(rel)
|
|
|
|
if not rel["eccentricity"]:
|
|
el["connObjs"][j] = self.makeObject(conn["geometry"], conn["geometry_type"])
|
|
else:
|
|
if conn["geometry_type"] == "Vertex":
|
|
geometry = rel["eccentricity"]["point_on_element"], conn["geometry"]
|
|
el["connObjs"][j] = self.makeObject(geometry[0], conn["geometry_type"])
|
|
|
|
el["linkPointObjs"][j][0] = self.geompy.MakeVertex(
|
|
geometry[0][0], geometry[0][1], geometry[0][2]
|
|
)
|
|
el["linkPointObjs"][j][1] = self.geompy.MakeVertex(
|
|
geometry[1][0], geometry[1][1], geometry[1][2]
|
|
)
|
|
el["linkObjs"][j] = self.geompy.MakeLineTwoPnt(
|
|
el["linkPointObjs"][j][0], el["linkPointObjs"][j][1]
|
|
)
|
|
else:
|
|
print("Eccentricity defined for a %s geometry_type" % conn["geometry_type"])
|
|
el["partObj"] = self.makePartition([el["elemObj"]] + el["connObjs"], el["geometry_type"])
|
|
el["elemObj"] = geompy.GetInPlace(el["partObj"], el["elemObj"], True)
|
|
for j, rel in enumerate(el["connections"]):
|
|
el["connObjs"][j] = geompy.GetInPlace(el["partObj"], el["connObjs"][j], True)
|
|
for conn in connections:
|
|
conn["connObj"] = self.makeObject(conn["geometry"], conn["geometry_type"])
|
|
|
|
# Make assemble of Building Object
|
|
bldObjs = []
|
|
bldObjs.extend([el["partObj"] for el in elements])
|
|
bldObjs.extend(flatten([[link for link in el["linkObjs"] if link] for el in elements]))
|
|
bldObjs.extend([conn["connObj"] for conn in connections])
|
|
|
|
bldComp = geompy.MakeCompound(bldObjs)
|
|
# bldComp = geompy.MakePartition(bldObjs, [], [], [], self.geompy.ShapeType[buildingShapeType], 0, [], 1)
|
|
geompy.addToStudy(bldComp, "bldComp")
|
|
|
|
# Loop 2
|
|
for el in elements:
|
|
# geompy.addToStudy(el['partObj'], self.getGroupName(el['ref_id']))
|
|
geompy.addToStudyInFather(el["partObj"], el["elemObj"], self.getGroupName(el["ref_id"]))
|
|
for j, rel in enumerate(el["connections"]):
|
|
conn = [c for c in connections if c["ref_id"] == rel["related_connection"]][0]
|
|
rel["conn_string"] = None
|
|
if conn["geometry_type"] == "Vertex":
|
|
rel["conn_string"] = "_0DC_"
|
|
if conn["geometry_type"] == "Edge":
|
|
rel["conn_string"] = "_1DC_"
|
|
if conn["geometry_type"] == "Face":
|
|
rel["conn_string"] = "_2DC_"
|
|
geompy.addToStudyInFather(
|
|
el["partObj"],
|
|
el["connObjs"][j],
|
|
self.getGroupName(el["ref_id"]) + rel["conn_string"] + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
if rel["eccentricity"]:
|
|
pass
|
|
# geompy.addToStudy(el['linkObjs'][j], self.getGroupName(el['ref_id']) + '_1DR_' + self.getGroupName(rel['related_connection']))
|
|
# geompy.addToStudyInFather(el['linkObjs'][j], el['linkPointObjs'][j][0], self.getGroupName(rel['related_connection']) + '_0DC_' + self.getGroupName(el['ref_id']))
|
|
# geompy.addToStudyInFather(el['linkObjs'][j], el['linkPointObjs'][j][0], self.getGroupName(rel['related_connection']) + '_0DC_%g' % rel['index'])
|
|
|
|
for conn in connections:
|
|
# geompy.addToStudy(conn['connObj'], self.getGroupName(conn['ref_id']))
|
|
geompy.addToStudyInFather(conn["connObj"], conn["connObj"], self.getGroupName(conn["ref_id"]))
|
|
|
|
elapsed_time = time.time() - init_time
|
|
init_time += elapsed_time
|
|
print("Building Geometry Defined in %g sec" % (elapsed_time))
|
|
|
|
# Define and add groups for all curve and surface members
|
|
if len([e for e in elements if e["geometry_type"] == "Edge"]) > 0:
|
|
# Make compound of requested group
|
|
compoundTemp = geompy.MakeCompound([e["elemObj"] for e in elements if e["geometry_type"] == "Edge"])
|
|
# Define group object and add to study
|
|
curveCompound = geompy.GetInPlace(bldComp, compoundTemp, True)
|
|
geompy.addToStudyInFather(bldComp, curveCompound, "CurveMembers")
|
|
|
|
rigid_links = list(flatten([[link for link in el["linkObjs"] if link] for el in elements]))
|
|
if len(rigid_links) > 0:
|
|
# Make compound of requested group
|
|
compoundTemp = geompy.MakeCompound(rigid_links)
|
|
# Define group object and add to study
|
|
rigidLinkCompound = geompy.GetInPlace(bldComp, compoundTemp, True)
|
|
geompy.addToStudyInFather(bldComp, rigidLinkCompound, "RigidLinks")
|
|
|
|
if len([e for e in elements if e["geometry_type"] == "Face"]) > 0:
|
|
# Make compound of requested group
|
|
compoundTemp = geompy.MakeCompound([e["elemObj"] for e in elements if e["geometry_type"] == "Face"])
|
|
# Define group object and add to study
|
|
surfaceCompound = geompy.GetInPlace(bldComp, compoundTemp, True)
|
|
geompy.addToStudyInFather(bldComp, surfaceCompound, "SurfaceMembers")
|
|
|
|
# Loop 3
|
|
for el in elements:
|
|
# el['partObj'] = geompy.RestoreGivenSubShapes(bldComp, [el['partObj']], GEOM.FSM_GetInPlace, False, False)[0]
|
|
geompy.addToStudyInFather(bldComp, el["elemObj"], self.getGroupName(el["ref_id"]))
|
|
|
|
for j, rel in enumerate(el["connections"]):
|
|
geompy.addToStudyInFather(
|
|
bldComp,
|
|
el["connObjs"][j],
|
|
self.getGroupName(el["ref_id"]) + rel["conn_string"] + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
if rel["eccentricity"]: # point geometry
|
|
geompy.addToStudyInFather(
|
|
bldComp,
|
|
el["linkObjs"][j],
|
|
self.getGroupName(el["ref_id"]) + "_1DR_" + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
geompy.addToStudyInFather(
|
|
bldComp,
|
|
el["linkPointObjs"][j][0],
|
|
self.getGroupName(rel["related_connection"]) + "_0DC_" + self.getGroupName(el["ref_id"]),
|
|
)
|
|
geompy.addToStudyInFather(
|
|
bldComp,
|
|
el["linkPointObjs"][j][1],
|
|
self.getGroupName(rel["related_connection"]) + "_0DC_%g" % rel["index"],
|
|
)
|
|
|
|
for conn in connections:
|
|
# conn['connObj'] = geompy.RestoreGivenSubShapes(bldComp, [conn['connObj']], GEOM.FSM_GetInPlace, False, False)[0]
|
|
geompy.addToStudyInFather(bldComp, conn["connObj"], self.getGroupName(conn["ref_id"]))
|
|
|
|
elapsed_time = time.time() - init_time
|
|
init_time += elapsed_time
|
|
print("Building Geometry Groups Defined in %g sec" % (elapsed_time))
|
|
|
|
###
|
|
### SMESH component
|
|
###
|
|
|
|
import SMESH
|
|
from salome.smesh import smeshBuilder
|
|
|
|
print("Defining Mesh Components")
|
|
|
|
if NEW_SALOME:
|
|
smesh = smeshBuilder.New()
|
|
else:
|
|
smesh = smeshBuilder.New(theStudy)
|
|
bldMesh = smesh.Mesh(bldComp)
|
|
Regular_1D = bldMesh.Segment()
|
|
Local_Length_1 = Regular_1D.LocalLength(mesh_size, None, tolLoc)
|
|
|
|
if buildingShapeType == "FACE":
|
|
NETGEN2D_ONLY = bldMesh.Triangle(algo=smeshBuilder.NETGEN_2D)
|
|
NETGEN2D_Pars = NETGEN2D_ONLY.Parameters()
|
|
NETGEN2D_Pars.SetMaxSize(mesh_size)
|
|
NETGEN2D_Pars.SetOptimize(1)
|
|
NETGEN2D_Pars.SetFineness(2)
|
|
NETGEN2D_Pars.SetMinSize(mesh_size / 5.0)
|
|
NETGEN2D_Pars.SetUseSurfaceCurvature(1)
|
|
NETGEN2D_Pars.SetQuadAllowed(1)
|
|
NETGEN2D_Pars.SetSecondOrder(0)
|
|
NETGEN2D_Pars.SetFuseEdges(254)
|
|
|
|
isDone = bldMesh.Compute()
|
|
|
|
## Set names of Mesh objects
|
|
smesh.SetName(Regular_1D.GetAlgorithm(), "Regular_1D")
|
|
smesh.SetName(Local_Length_1, "Local_Length_1")
|
|
|
|
if buildingShapeType == "FACE":
|
|
smesh.SetName(NETGEN2D_ONLY.GetAlgorithm(), "NETGEN2D_ONLY")
|
|
smesh.SetName(NETGEN2D_Pars, "NETGEN2D_Pars")
|
|
|
|
smesh.SetName(bldMesh.GetMesh(), "{{ mesh_name }}")
|
|
|
|
elapsed_time = time.time() - init_time
|
|
init_time += elapsed_time
|
|
print("Meshing Operations Completed in %g sec" % (elapsed_time))
|
|
|
|
# Define and add groups for all curve and surface members
|
|
if len([e for e in elements if e["geometry_type"] == "Edge"]) > 0:
|
|
tempgroup = bldMesh.GroupOnGeom(curveCompound, "CurveMembers", SMESH.EDGE)
|
|
smesh.SetName(tempgroup, "CurveMembers")
|
|
|
|
if len(rigid_links) > 0:
|
|
tempgroup = bldMesh.GroupOnGeom(rigidLinkCompound, "RigidLinks", SMESH.EDGE)
|
|
smesh.SetName(tempgroup, "RigidLinks")
|
|
|
|
if len([e for e in elements if e["geometry_type"] == "Face"]) > 0:
|
|
tempgroup = bldMesh.GroupOnGeom(surfaceCompound, "SurfaceMembers", SMESH.FACE)
|
|
smesh.SetName(tempgroup, "SurfaceMembers")
|
|
|
|
# Define groups in Mesh
|
|
for el in elements:
|
|
if el["geometry_type"] == "Edge":
|
|
shapeType = SMESH.EDGE
|
|
if el["geometry_type"] == "Face":
|
|
shapeType = SMESH.FACE
|
|
tempgroup = bldMesh.GroupOnGeom(el["elemObj"], self.getGroupName(el["ref_id"]), shapeType)
|
|
smesh.SetName(tempgroup, self.getGroupName(el["ref_id"]))
|
|
# tempgroup = bldMesh.GroupOnGeom(el["elemObj"], self.getGroupName(el["ref_id"]), SMESH.NODE)
|
|
# smesh.SetName(tempgroup, self.getGroupName(el["ref_id"]))
|
|
|
|
for j, rel in enumerate(el["connections"]):
|
|
tempgroup = bldMesh.GroupOnGeom(
|
|
el["connObjs"][j],
|
|
self.getGroupName(el["ref_id"]) + rel["conn_string"] + self.getGroupName(rel["related_connection"]),
|
|
SMESH.NODE,
|
|
)
|
|
smesh.SetName(
|
|
tempgroup,
|
|
self.getGroupName(el["ref_id"]) + rel["conn_string"] + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
rel["node"] = (bldMesh.GetIDSource(tempgroup.GetNodeIDs(), SMESH.NODE)).GetIDs()[0]
|
|
if rel["eccentricity"]:
|
|
tempgroup = bldMesh.GroupOnGeom(
|
|
el["linkObjs"][j],
|
|
self.getGroupName(el["ref_id"]) + "_1DR_" + self.getGroupName(rel["related_connection"]),
|
|
SMESH.EDGE,
|
|
)
|
|
smesh.SetName(
|
|
tempgroup,
|
|
self.getGroupName(el["ref_id"]) + "_1DR_" + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
|
|
tempgroup = bldMesh.GroupOnGeom(
|
|
el["linkPointObjs"][j][0],
|
|
self.getGroupName(rel["related_connection"]) + "_0DC_" + self.getGroupName(el["ref_id"]),
|
|
SMESH.NODE,
|
|
)
|
|
smesh.SetName(
|
|
tempgroup,
|
|
self.getGroupName(rel["related_connection"]) + "_0DC_" + self.getGroupName(el["ref_id"]),
|
|
)
|
|
rel["eccNode"] = (bldMesh.GetIDSource(tempgroup.GetNodeIDs(), SMESH.NODE)).GetIDs()[0]
|
|
|
|
tempgroup = bldMesh.GroupOnGeom(
|
|
el["linkPointObjs"][j][1],
|
|
self.getGroupName(rel["related_connection"])
|
|
+ "_0DC_"
|
|
+ self.getGroupName(rel["related_connection"]),
|
|
SMESH.NODE,
|
|
)
|
|
smesh.SetName(
|
|
tempgroup,
|
|
self.getGroupName(rel["related_connection"]) + "_0DC_%g" % rel["index"],
|
|
)
|
|
|
|
for conn in connections:
|
|
tempgroup = bldMesh.GroupOnGeom(conn["connObj"], self.getGroupName(conn["ref_id"]), SMESH.NODE)
|
|
smesh.SetName(tempgroup, self.getGroupName(conn["ref_id"]))
|
|
nodesId = bldMesh.GetIDSource(tempgroup.GetNodeIDs(), SMESH.NODE)
|
|
tempgroup = bldMesh.Add0DElementsToAllNodes(nodesId, self.getGroupName(conn["ref_id"]))
|
|
smesh.SetName(tempgroup, self.getGroupName(conn["ref_id"] + "_0D"))
|
|
if conn["geometry_type"] == "Vertex":
|
|
conn["node"] = nodesId.GetIDs()[0]
|
|
if conn["geometry_type"] == "Edge":
|
|
tempgroup = bldMesh.GroupOnGeom(conn["connObj"], self.getGroupName(conn["ref_id"]), SMESH.EDGE)
|
|
smesh.SetName(tempgroup, self.getGroupName(conn["ref_id"]))
|
|
if conn["geometry_type"] == "Face":
|
|
tempgroup = bldMesh.GroupOnGeom(conn["connObj"], self.getGroupName(conn["ref_id"]), SMESH.FACE)
|
|
smesh.SetName(tempgroup, self.getGroupName(conn["ref_id"]))
|
|
|
|
# create 1D SEG2 spring elements
|
|
for el in elements:
|
|
for j, rel in enumerate(el["connections"]):
|
|
conn = [c for c in connections if c["ref_id"] == rel["related_connection"]][0]
|
|
if conn["geometry_type"] == "Vertex":
|
|
grpName = bldMesh.CreateEmptyGroup(
|
|
SMESH.EDGE,
|
|
self.getGroupName(el["ref_id"]) + "_1DS_" + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
smesh.SetName(
|
|
grpName,
|
|
self.getGroupName(el["ref_id"]) + "_1DS_" + self.getGroupName(rel["related_connection"]),
|
|
)
|
|
if not rel["eccentricity"]:
|
|
conn = [conn for conn in connections if conn["ref_id"] == rel["related_connection"]][0]
|
|
grpName.Add([bldMesh.AddEdge([conn["node"], rel["node"]])])
|
|
else:
|
|
grpName.Add([bldMesh.AddEdge([rel["eccNode"], rel["node"]])])
|
|
|
|
self.mesh = bldMesh
|
|
self.meshNodes = bldMesh.GetNodesId()
|
|
|
|
elapsed_time = time.time() - init_time
|
|
init_time += elapsed_time
|
|
print("Mesh Groups Defined in %g sec" % (elapsed_time))
|
|
|
|
try:
|
|
if NEW_SALOME:
|
|
bldMesh.ExportMED(
|
|
self.medFilename,
|
|
auto_groups=0,
|
|
minor=40,
|
|
overwrite=1,
|
|
meshPart=None,
|
|
autoDimension=0,
|
|
)
|
|
else:
|
|
bldMesh.ExportMED(self.medFilename, 0, SMESH.MED_V2_2, 1, None, 0)
|
|
except:
|
|
print("ExportMED() failed. Invalid file name?")
|
|
|
|
# if salome.sg.hasDesktop():
|
|
# if NEW_SALOME:
|
|
# salome.sg.updateObjBrowser()
|
|
# else:
|
|
# salome.sg.updateObjBrowser(1)
|
|
|
|
elapsed_time = init_time - start_time
|
|
print("ALL Operations Completed in %g sec" % (elapsed_time))
|
|
|
|
|
|
model = MODEL()
|
|
|
|
for el in model.elements:
|
|
for j, conn in enumerate(el["connections"]):
|
|
d = model.geompy.MinDistance(el["elemObj"], el["connObjs"][j])
|
|
if d > 0:
|
|
print(f'NOTE: Element {el["ref_id"]} and connection {conn["ref_id"]} have a distance of {d}')
|
|
# elif d == 0:
|
|
# print(
|
|
# f'SUCCESS: Element {el["ref_id"]} and connection {conn["ref_id"]} have a distance of {d}'
|
|
# )
|
|
|
|
if salome.sg.hasDesktop():
|
|
if model.NEW_SALOME:
|
|
salome.sg.updateObjBrowser()
|
|
else:
|
|
salome.sg.updateObjBrowser(1)
|