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('Model "%s" converted' % model.Name) print("Number of elements: ", len(elements)) print("Number of connections: ", len(connections)) print("Number of materials: ", len(materialdb)) print("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(np.linalg.norm(np.array(c["eccentricity"]["pointOnElement"])), ">", length) self.warnings.append("Eccentricity in %s corrected" % (item.is_a() + "|" + str(item.id()))) 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( "Warning! Object Placement is of type %s, which is not supported. Default considered" % placement.is_a() ) 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"] 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))