mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-12 10:33:20 +00:00
Dion Moult
649 lines
26 KiB
Python
649 lines
26 KiB
Python
|
|
# Ifc2CA - IFC Code_Aster utility
|
|
# Copyright (C) 2020, 2021 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/>.
|
|
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
import json
|
|
import ifcopenshell
|
|
import numpy as np
|
|
|
|
|
|
class IFC2CA:
|
|
def __init__(self, filename):
|
|
self.filename = filename
|
|
self.file = None
|
|
self.result = {}
|
|
self.warnings = []
|
|
self.tol = 1e-06
|
|
|
|
def convert(self):
|
|
self.file = ifcopenshell.open(self.filename)
|
|
for model in self.file.by_type("IfcStructuralAnalysisModel"):
|
|
elements = self.get_structural_items(model, item_type="IfcStructuralMember")
|
|
connections = self.get_structural_items(
|
|
model, item_type="IfcStructuralConnection"
|
|
)
|
|
|
|
materialdb = []
|
|
materials = list(dict.fromkeys([e["material"] for e in elements]))
|
|
for mat in [mat for mat in materials if mat]:
|
|
id = int(mat.split("|")[1])
|
|
material = self.get_material_properties(self.file.by_id(id))
|
|
material["relatedElements"] = [
|
|
e["ifcName"]
|
|
for e in elements
|
|
if "material" in e and e["material"] == mat
|
|
]
|
|
materialdb.append(material)
|
|
|
|
profiledb = []
|
|
profiles = list(
|
|
dict.fromkeys([e["profile"] for e in elements if "profile" in e])
|
|
)
|
|
for prof in [prof for prof in profiles if prof]:
|
|
id = int(prof.split("|")[1])
|
|
profile = self.get_profile_properties(self.file.by_id(id))
|
|
profile["relatedElements"] = [
|
|
e["ifcName"]
|
|
for e in elements
|
|
if "profile" in e and e["profile"] == prof
|
|
]
|
|
profiledb.append(profile)
|
|
|
|
self.result = {
|
|
"ifcName": model.is_a() + "|" + str(model.id()),
|
|
"name": model.Name,
|
|
"id": model.GlobalId,
|
|
"elements": elements,
|
|
"connections": connections,
|
|
"db": {"materials": materialdb, "profiles": profiledb},
|
|
"warnings": self.warnings,
|
|
}
|
|
|
|
print(f"Model {model.Name} converted")
|
|
print(f"Number of elements: {len(elements)}")
|
|
print(f"Number of connections: {len(connections)}")
|
|
print(f"Number of materials: {len(materialdb)}")
|
|
print(f"Number of profiles: {len(profiledb)}")
|
|
print("")
|
|
|
|
break
|
|
|
|
def get_structural_items(self, model, item_type="IfcStructuralItem"):
|
|
items = []
|
|
for group in model.IsGroupedBy:
|
|
for item in group.RelatedObjects:
|
|
if not item.is_a(item_type):
|
|
continue
|
|
data = self.get_item_data(item)
|
|
if data:
|
|
items.append(data)
|
|
return items
|
|
|
|
def get_item_data(self, item):
|
|
transformation = self.get_transformation(item.ObjectPlacement)
|
|
|
|
if item.is_a("IfcStructuralCurveMember"):
|
|
representation = self.get_representation(item, "Edge")
|
|
material_profile = self.get_material_profile(item)
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Member excluded"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
if not material_profile:
|
|
self.warnings.append(
|
|
"No material defined for in %s"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
self.warnings.append(
|
|
"No profile defined for in %s"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
materialId = None
|
|
profileId = None
|
|
else:
|
|
material = material_profile.Material
|
|
materialId = material.is_a() + "|" + str(material.id())
|
|
profile = material_profile.Profile
|
|
profileId = profile.is_a() + "|" + str(profile.id())
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_1D_orientation(geometry, item.Axis)
|
|
connections = self.get_connection_data(item.ConnectedBy)
|
|
for conn in connections:
|
|
if not conn["orientation"]:
|
|
conn["orientation"] = orientation
|
|
# --> Correct pointOnElement for eccentricity connection for ETABS files
|
|
length = np.linalg.norm(np.array(geometry[1]) - np.array(geometry[0]))
|
|
for c in connections:
|
|
if c["eccentricity"]:
|
|
if (
|
|
np.linalg.norm(np.array(c["eccentricity"]["pointOnElement"]))
|
|
> length + self.tol
|
|
):
|
|
print(
|
|
f"{np.linalg.norm(np.array(c['eccentricity']['pointOnElement']))} > {length}"
|
|
)
|
|
self.warnings.append(
|
|
f"Eccentricity in {item.is_a()}|{str(item.id())} corrected"
|
|
)
|
|
c["eccentricity"]["pointOnElement"][0] = length
|
|
# End <--
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(
|
|
orientation, transformation, include_translation=False
|
|
)
|
|
for c in connections:
|
|
c["orientation"] = self.transform_vectors(
|
|
c["orientation"], transformation, include_translation=False
|
|
)
|
|
if c["eccentricity"]:
|
|
c["eccentricity"]["vector"] = self.transform_vectors(
|
|
c["eccentricity"]["vector"],
|
|
transformation,
|
|
include_translation=False,
|
|
)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "line",
|
|
"predefinedType": item.PredefinedType,
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"material": materialId,
|
|
"profile": profileId,
|
|
"connections": connections,
|
|
}
|
|
|
|
elif item.is_a("IfcStructuralSurfaceMember"):
|
|
representation = self.get_representation(item, "Face")
|
|
material = self.get_material_profile(item)
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Member excluded"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
if not material:
|
|
self.warnings.append(
|
|
"No material defined for in %s"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
materialId = None
|
|
else:
|
|
materialId = material.is_a() + "|" + str(material.id())
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_2D_orientation(representation)
|
|
connections = self.get_connection_data(item.ConnectedBy)
|
|
for conn in connections:
|
|
if not conn["orientation"]:
|
|
conn["orientation"] = orientation
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(
|
|
orientation, transformation, include_translation=False
|
|
)
|
|
for c in connections:
|
|
c["orientation"] = self.transform_vectors(
|
|
c["orientation"], transformation, include_translation=False
|
|
)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "surface",
|
|
"predefinedType": item.PredefinedType,
|
|
"thickness": item.Thickness,
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"material": materialId,
|
|
"connections": connections,
|
|
}
|
|
|
|
elif item.is_a("IfcStructuralPointConnection"):
|
|
representation = self.get_representation(item, "Vertex")
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Connection excluded"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_0D_orientation(item.ConditionCoordinateSystem)
|
|
if not orientation:
|
|
orientation = np.eye(3).tolist()
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(
|
|
orientation, transformation, include_translation=False
|
|
)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "point",
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"appliedCondition": self.get_connection_input(item, "point"),
|
|
"relatedElements": [
|
|
con.is_a() + "|" + str(con.id())
|
|
for con in item.ConnectsStructuralMembers
|
|
],
|
|
}
|
|
|
|
elif item.is_a("IfcStructuralCurveConnection"):
|
|
representation = self.get_representation(item, "Edge")
|
|
if not representation:
|
|
self.warnings.append(
|
|
"No representation defined for %s. Connection excluded"
|
|
% (item.is_a() + "|" + str(item.id()))
|
|
)
|
|
return
|
|
|
|
geometry = self.get_geometry(representation)
|
|
orientation = self.get_1D_orientation(geometry, item.Axis)
|
|
if not orientation:
|
|
orientation = np.eye(3).tolist()
|
|
if transformation:
|
|
geometry = self.transform_vectors(geometry, transformation)
|
|
orientation = self.transform_vectors(
|
|
orientation, transformation, include_translation=False
|
|
)
|
|
|
|
return {
|
|
"ifcName": item.is_a() + "|" + str(item.id()),
|
|
"name": item.Name,
|
|
"id": item.GlobalId,
|
|
"geometryType": "line",
|
|
"geometry": geometry,
|
|
"orientation": orientation,
|
|
"appliedCondition": self.get_connection_input(item, "line"),
|
|
"relatedElements": [
|
|
con.is_a() + "|" + str(con.id())
|
|
for con in item.ConnectsStructuralMembers
|
|
],
|
|
}
|
|
|
|
def get_transformation(self, placement):
|
|
if not placement:
|
|
return None
|
|
if placement.is_a("IfcLocalPlacement"):
|
|
if placement.PlacementRelTo:
|
|
print(
|
|
"Warning! Object Placement with PlacementRelTo attribute is not supported and will be neglected"
|
|
)
|
|
axes = placement.RelativePlacement
|
|
location = np.array(self.get_coordinate(axes.Location))
|
|
if axes.Axis and axes.RefDirection:
|
|
xAxis = np.array(
|
|
axes.RefDirection.DirectionRatios
|
|
) # this can be not accurate (in the xz plane)
|
|
zAxis = np.array(axes.Axis.DirectionRatios)
|
|
zAxis /= np.linalg.norm(zAxis)
|
|
yAxis = np.cross(zAxis, xAxis)
|
|
yAxis /= np.linalg.norm(yAxis)
|
|
xAxis = np.cross(yAxis, zAxis)
|
|
xAxis /= np.linalg.norm(xAxis)
|
|
else:
|
|
if np.allclose(location, np.array([0.0, 0.0, 0.0])):
|
|
return None
|
|
xAxis = np.array([1.0, 0.0, 0.0])
|
|
yAxis = np.array([0.0, 1.0, 0.0])
|
|
zAxis = np.array([0.0, 0.0, 1.0])
|
|
if (
|
|
np.allclose(location, np.array([0.0, 0.0, 0.0]))
|
|
and np.allclose(xAxis, np.array([1.0, 0.0, 0.0]))
|
|
and np.allclose(yAxis, np.array([0.0, 1.0, 0.0]))
|
|
and np.allclose(zAxis, np.array([0.0, 0.0, 1.0]))
|
|
):
|
|
return None
|
|
return {
|
|
"location": location,
|
|
"rotationMatrix": np.array([xAxis, yAxis, zAxis]).transpose(),
|
|
}
|
|
else:
|
|
print(
|
|
f"Warning! Object Placement is of type {placement.is_a()}, which is not supported. Default considered"
|
|
)
|
|
return None
|
|
|
|
def get_representation(self, element, rep_type):
|
|
if not element.Representation:
|
|
return None
|
|
for representation in element.Representation.Representations:
|
|
rep = self.get_specific_representation(
|
|
representation, "Reference", rep_type
|
|
)
|
|
if rep:
|
|
return rep
|
|
else:
|
|
# print("Trying without rep identifier")
|
|
for representation in element.Representation.Representations:
|
|
rep = self.get_specific_representation(representation, None, rep_type)
|
|
if rep:
|
|
return rep
|
|
|
|
def get_specific_representation(self, representation, rep_id, rep_type):
|
|
if (
|
|
representation.RepresentationIdentifier == rep_id or rep_id is None
|
|
) and representation.RepresentationType == rep_type:
|
|
return representation
|
|
if representation.RepresentationType == "MappedRepresentation":
|
|
return self.get_specific_representation(
|
|
representation.Items[0].MappingSource.MappedRepresentation,
|
|
rep_id,
|
|
rep_type,
|
|
)
|
|
|
|
def get_geometry(self, representation):
|
|
# Maybe IfcOpenShell can use create_shape here to simplify this, but
|
|
# supposedly structural models are very simple anyway, so perhaps we
|
|
# can do without it.
|
|
item = representation.Items[0]
|
|
if item.is_a("IfcEdge"):
|
|
return [
|
|
self.get_coordinate(item.EdgeStart.VertexGeometry),
|
|
self.get_coordinate(item.EdgeEnd.VertexGeometry),
|
|
]
|
|
|
|
elif item.is_a("IfcFaceSurface"):
|
|
edges = item.Bounds[0].Bound.EdgeList
|
|
coords = []
|
|
for edge in edges:
|
|
coords.append(
|
|
self.get_coordinate(edge.EdgeElement.EdgeStart.VertexGeometry)
|
|
)
|
|
return coords
|
|
|
|
elif item.is_a("IfcVertexPoint"):
|
|
return self.get_coordinate(item.VertexGeometry)
|
|
|
|
def get_coordinate(self, point):
|
|
if point.is_a("IfcCartesianPoint"):
|
|
return list(point.Coordinates)
|
|
|
|
def get_0D_orientation(self, axes):
|
|
if axes and axes.Axis and axes.RefDirection:
|
|
xAxis = np.array(
|
|
axes.RefDirection.DirectionRatios
|
|
) # this can be not strictly perpendicular (in the xz plane)
|
|
zAxis = np.array(axes.Axis.DirectionRatios)
|
|
zAxis /= np.linalg.norm(zAxis)
|
|
yAxis = np.cross(zAxis, xAxis)
|
|
yAxis /= np.linalg.norm(yAxis)
|
|
xAxis = np.cross(yAxis, zAxis)
|
|
xAxis /= np.linalg.norm(xAxis)
|
|
|
|
return [xAxis.tolist(), yAxis.tolist(), zAxis.tolist()]
|
|
else: # return None and copy the elements orientation
|
|
return None
|
|
|
|
def get_1D_orientation(self, geometry, zAxis):
|
|
xAxis = np.array(geometry[1]) - np.array(geometry[0])
|
|
xAxis /= np.linalg.norm(xAxis)
|
|
zAxis = np.array(
|
|
zAxis.DirectionRatios
|
|
) # this can be not strictly perpendicular (in the xz plane)
|
|
yAxis = np.cross(zAxis, xAxis)
|
|
yAxis /= np.linalg.norm(yAxis)
|
|
zAxis = np.cross(xAxis, yAxis)
|
|
zAxis /= np.linalg.norm(zAxis)
|
|
|
|
return [xAxis.tolist(), yAxis.tolist(), zAxis.tolist()]
|
|
|
|
def get_2D_orientation(self, representation):
|
|
item = representation.Items[0]
|
|
if item.is_a("IfcFaceSurface"):
|
|
item.SameSense
|
|
axes = item.FaceSurface.Position
|
|
orientation = self.get_0D_orientation(axes)
|
|
if not item.SameSense:
|
|
orientation = [[-v for v in vec] for vec in orientation]
|
|
return orientation
|
|
|
|
def transform_vectors(self, geometry, trsf, include_translation=True):
|
|
if not any(
|
|
isinstance(el, list) for el in geometry
|
|
): # single point which contains no list
|
|
geometry = [geometry]
|
|
globalGeometry = []
|
|
|
|
for p in geometry:
|
|
gp = trsf["rotationMatrix"].dot(np.array(p))
|
|
if include_translation:
|
|
gp += trsf["location"]
|
|
globalGeometry.append(gp.tolist())
|
|
|
|
if len(globalGeometry) == 1: # single point
|
|
globalGeometry = globalGeometry[0]
|
|
|
|
return globalGeometry
|
|
|
|
def get_material_profile(self, element):
|
|
if not element.HasAssociations:
|
|
return None
|
|
for association in element.HasAssociations:
|
|
if not association.is_a("IfcRelAssociatesMaterial"):
|
|
continue
|
|
material = association.RelatingMaterial
|
|
if material.is_a("IfcMaterialProfileSet"):
|
|
# For now, we only deal with a single profile
|
|
return material.MaterialProfiles[0]
|
|
if material.is_a("IfcMaterialProfileSetUsage"):
|
|
return material.ForProfileSet.MaterialProfiles[0]
|
|
if material.is_a("IfcMaterial"):
|
|
return material
|
|
|
|
def get_material_properties(self, material):
|
|
psets = material.HasProperties
|
|
|
|
if self.get_pset_properties(psets, "Pset_MaterialMechanical"):
|
|
mechProps = self.get_pset_properties(psets, "Pset_MaterialMechanical")
|
|
else:
|
|
mechProps = self.get_pset_properties(psets, None)
|
|
|
|
if self.get_pset_properties(psets, "Pset_MaterialCommon"):
|
|
commonProps = self.get_pset_properties(psets, "Pset_MaterialCommon")
|
|
else:
|
|
commonProps = self.get_pset_properties(psets, None)
|
|
|
|
return {
|
|
"ifcName": material.is_a() + "|" + str(material.id()),
|
|
"name": material.Name,
|
|
"category": material.Category,
|
|
"mechProps": mechProps,
|
|
"commonProps": commonProps,
|
|
}
|
|
|
|
def get_pset_property(self, psets, pset_name, prop_name):
|
|
for pset in psets:
|
|
if pset.Name == pset_name or pset_name is None:
|
|
for prop in pset.Properties:
|
|
if prop.Name == prop_name:
|
|
return prop.NominalValue.wrappedValue
|
|
|
|
def get_pset_properties(self, psets, pset_name):
|
|
for pset in psets:
|
|
if pset.Name == pset_name or pset_name is None:
|
|
d = {}
|
|
for prop in pset.Properties:
|
|
propName = prop.Name[0].lower() + prop.Name[1:]
|
|
d[propName] = prop.NominalValue.wrappedValue
|
|
return d
|
|
|
|
def get_profile_properties(self, profile):
|
|
if profile.is_a("IfcRectangleProfileDef"):
|
|
return {
|
|
"ifcName": profile.is_a() + "|" + str(profile.id()),
|
|
"profileName": profile.ProfileName,
|
|
"profileType": profile.ProfileType,
|
|
"profileShape": "rectangular",
|
|
"xDim": profile.XDim,
|
|
"yDim": profile.YDim,
|
|
}
|
|
|
|
if profile.is_a("IfcIShapeProfileDef"):
|
|
psets = profile.HasProperties
|
|
|
|
if self.get_pset_properties(psets, "Pset_ProfileMechanical"):
|
|
mechProps = self.get_pset_properties(psets, "Pset_ProfileMechanical")
|
|
else:
|
|
mechProps = self.get_i_section_properties(profile, "iSymmetrical")
|
|
|
|
return {
|
|
"ifcName": profile.is_a() + "|" + str(profile.id()),
|
|
"profileName": profile.ProfileName,
|
|
"profileType": profile.ProfileType,
|
|
"profileShape": "iSymmetrical",
|
|
"mechProps": mechProps,
|
|
"commonProps": {
|
|
"flangeThickness": profile.FlangeThickness,
|
|
"webThickness": profile.WebThickness,
|
|
"overallDepth": profile.OverallDepth,
|
|
"overallWidth": profile.OverallWidth,
|
|
"filletRadius": profile.FilletRadius,
|
|
},
|
|
}
|
|
|
|
def get_connection_data(self, itemList):
|
|
return [
|
|
{
|
|
"ifcName": rel.is_a() + "|" + str(rel.id()),
|
|
"id": rel.GlobalId,
|
|
"relatingElement": rel.RelatingStructuralMember.is_a()
|
|
+ "|"
|
|
+ str(rel.RelatingStructuralMember.id()),
|
|
"relatedConnection": rel.RelatedStructuralConnection.is_a()
|
|
+ "|"
|
|
+ str(rel.RelatedStructuralConnection.id()),
|
|
"orientation": self.get_0D_orientation(rel.ConditionCoordinateSystem),
|
|
"appliedCondition": self.get_connection_input(
|
|
rel,
|
|
self.get_geometry_type_from_connection(
|
|
rel.RelatedStructuralConnection
|
|
),
|
|
),
|
|
"eccentricity": None
|
|
if not rel.is_a("IfcRelConnectsWithEccentricity")
|
|
else {
|
|
"vector": [
|
|
0.0
|
|
if not rel.ConnectionConstraint.EccentricityInX
|
|
else rel.ConnectionConstraint.EccentricityInX,
|
|
0.0
|
|
if not rel.ConnectionConstraint.EccentricityInY
|
|
else rel.ConnectionConstraint.EccentricityInY,
|
|
0.0
|
|
if not rel.ConnectionConstraint.EccentricityInZ
|
|
else rel.ConnectionConstraint.EccentricityInZ,
|
|
],
|
|
"pointOnElement": self.get_coordinate(
|
|
rel.ConnectionConstraint.PointOnRelatingElement
|
|
),
|
|
},
|
|
}
|
|
for rel in itemList
|
|
]
|
|
|
|
def get_geometry_type_from_connection(self, connection):
|
|
if connection.is_a("IfcStructuralPointConnection"):
|
|
return "point"
|
|
if connection.is_a("IfcStructuralCurveConnection"):
|
|
return "line"
|
|
if connection.is_a("IfcStructuralSurfaceConnection"):
|
|
return "surface"
|
|
|
|
def get_connection_input(self, connection, geometryType):
|
|
if connection.AppliedCondition:
|
|
if geometryType == "point":
|
|
return {
|
|
"dx": connection.AppliedCondition.TranslationalStiffnessX.wrappedValue,
|
|
"dy": connection.AppliedCondition.TranslationalStiffnessY.wrappedValue,
|
|
"dz": connection.AppliedCondition.TranslationalStiffnessZ.wrappedValue,
|
|
"drx": connection.AppliedCondition.RotationalStiffnessX.wrappedValue,
|
|
"dry": connection.AppliedCondition.RotationalStiffnessY.wrappedValue,
|
|
"drz": connection.AppliedCondition.RotationalStiffnessZ.wrappedValue,
|
|
}
|
|
|
|
if geometryType == "line":
|
|
return {
|
|
"dx": connection.AppliedCondition.TranslationalStiffnessByLengthX.wrappedValue,
|
|
"dy": connection.AppliedCondition.TranslationalStiffnessByLengthY.wrappedValue,
|
|
"dz": connection.AppliedCondition.TranslationalStiffnessByLengthZ.wrappedValue,
|
|
"drx": connection.AppliedCondition.RotationalStiffnessByLengthX.wrappedValue,
|
|
"dry": connection.AppliedCondition.RotationalStiffnessByLengthY.wrappedValue,
|
|
"drz": connection.AppliedCondition.RotationalStiffnessByLengthZ.wrappedValue,
|
|
}
|
|
|
|
if geometryType == "surface":
|
|
return {
|
|
"dx": connection.AppliedCondition.TranslationalStiffnessByAreaX.wrappedValue,
|
|
"dy": connection.AppliedCondition.TranslationalStiffnessByAreaY.wrappedValue,
|
|
"dz": connection.AppliedCondition.TranslationalStiffnessByAreaZ.wrappedValue,
|
|
}
|
|
|
|
return connection.AppliedCondition
|
|
|
|
def get_i_section_properties(self, profile, profileShape):
|
|
if profileShape == "iSymmetrical":
|
|
tf = profile.FlangeThickness
|
|
tw = profile.WebThickness
|
|
h = profile.OverallDepth
|
|
b = profile.OverallWidth
|
|
|
|
A = b * h - (b - tw) * (h - 2 * tf)
|
|
Iy = b * (h ** 3) / 12 - (b - tw) * ((h - 2 * tf) ** 3) / 12
|
|
Iz = (2 * tf) * (b ** 3) / 12 + (h - 2 * tf) * (tw ** 3) / 12
|
|
Jx = 1 / 3 * ((h - tf) * (tw ** 3) + 2 * b * (tf ** 3))
|
|
|
|
return {
|
|
"crossSectionArea": A,
|
|
"momentOfInertiaY": Iy,
|
|
"momentOfInertiaZ": Iz,
|
|
"torsionalConstantX": Jx,
|
|
}
|
|
|
|
|
|
if __name__ == "__main__":
|
|
fileNames = [
|
|
"cantilever_01",
|
|
"portal_01",
|
|
"grid_of_beams",
|
|
"slab_01",
|
|
"structure_01",
|
|
"building_02",
|
|
]
|
|
files = fileNames
|
|
|
|
for fileName in files:
|
|
BASE_PATH = "/home/jesusbill/Dev-Projects/github.com/IfcOpenShell/analysis-models/ifcFiles/"
|
|
ifc2ca = IFC2CA(BASE_PATH + fileName + ".ifc")
|
|
ifc2ca.convert()
|
|
with open(BASE_PATH + fileName + ".json", "w") as f:
|
|
f.write(json.dumps(ifc2ca.result, indent=4))
|