IFC Explained

2.2. IFC Schema  

Like all products in the construction sector, IFC is covered by an international standard. In this case, the relevant document is ISO 16739-1:2024 [8], which describes an Open Data schema for representing diverse concepts, objects, attributes, and relationships in BIM models [9]. The schema defines how the data should be organised or structured to allow different software packages to communicate with each other.   

The data is represented in a monolithic approach meaning that data is stored and manipulated from a single, centralised data store.  Unlike traditional interoperability approaches that require multiple data format conversions to accommodate different tools, IFC enables information exchange through a shared data schema, necessitating only one conversion and simplifying tool and data integration [5]. This is represented by Fig 1.

The very first IFC Schema was developed in 1997 and over time it has evolved to include more and more objects. The latest official schemas are IFC 2.3 and IFC 4.3.2. Their documentation is intended for software engineers, so the average user doesn’t need to interact with it. However, to work with IFC, the users need to understand the following basic concepts about the schema. A summary of these concepts is represented in Fig 2. 

2.3. IFC Specifications 

Specification is the detailed documentation and description of the IFC schema. It provides a human-readable interpretation of the schema, explaining how the various entities, attributes, and relationships should be used. Thus, it is intended for a broader audience and simplifies the understanding and navigation of the schema without requiring familiarity with the technical EXPRESS schema. 

2.4. Naming Conventions 

Everything represented in the schema begins with the prefix “ifc” and follows the CamelCase naming convention (no underscores, with the first letter of each word capitalised). For example, a wall is represented as “ifcWall”, and a wall type is represented as “ifcWallType” [10]. 

2.5. IFC Classes 

Class is a technical jargon in software engineering. A common user can understand it in a way that any concept which is represented in a Schema is known as a class. For example, Wall, Door, Window etc. are all classes [11]. 

2.6. Attributes 

Classes have attributes. For example, a Wall has a Name attribute. Attributes are represented without the prefix ,”ifc” [10]. They can store simple text data such as a Name or more complex data such as OwnerHistory. IFC classes have a fixed set of attributes (defined by the Schema) that users cannot change, so each class has a small, stable list of common, useful attributes that stay the same across different IFC versions [12]. 

2.7. Properties 

Properties can be assigned to an IFC class. Unlike attributes, which are defined with each IFC class, properties themselves are an IFC class and have attributes. Also, unlike attributes, related properties can be grouped into a property set and are represented by the prefix Pset_ [10].  

This Pset can exist as its own IFC class and then be linked to relevant IFC classes. For instance, a property named FireRating might have an attribute storing a value of “2 Hours.” This property is grouped in the Pset called Pset_WallCommon, which is linked to multiple IfcWall objects. Names like FireRating and Pset_WallCommon are defined in the IFC specification and cannot be changed by the end-user, similar to attributes. However, users can add their project-specific properties and group them into their Psets if they do not exist in the IFC specification [12]. 

2.8. Quantity 

Quantity is a special type of property that stores information that can be quantified like a length, area, volume, weight, time, or monetary value. Quantities and properties are very similar, in that they can be grouped, and then linked to multiple IFC classes, and users can add custom quantities if the ones in the IFC specification do not suit their needs [12]. A group of quantities are represented by the prefix Qto_ [10]. 

2.9. Inheritance 

Classes can inherit from other classes, building up a hierarchy of classes. If a class inherits from another class, it inherits all of its attributes and relationships. For example, the IfcElement class has an opening attribute, which can store the string value of whether there exists an opening or not. Because the IfcWall class inherits from the IfcElement class, it also has a Representation attribute to store the opening value. However, the IfcPerson class does not inherit from the IfcElement class, and so it does not have a Representation attribute.