Hide menu
Loading...
Searching...
No Matches
Building Information Modeling (BIM)

Overview

Example of BIM model

In general, Building Information Modeling (BIM) is the set of approaches, processes and tools, based on digital model of building process and building data. The use of BIM allows to take advantage of information systems and technologies in the construction industry.

On the one hand, CAD and BIM processes both operates with similar enough data - 3D geometry and element properties, on the other hand, the BIM approach is mainly focused on BIM elements - their types, hierarchy and various properties.

To better support the work with BIM processes and data formats, the CAD Exchanger has developed a BIM Model, that reprsents tools for interaction with some part of BIM data, including spatial and hierarchical structure of building, BIM element type, 3D geometry, properties and material (substance) data. The BIM Model can be used independently from the original CAD Exchanger MCAD Data Model in more appropriate cases.

Changes in version 3.23.0

In version 3.23.0 ModelData_BIMModel was updated. Here is a list of changes essential for migration:

  • ModelData_BIMHostElement was renamed to ModelData_BIMHost
  • ModelData_BIMSpace was removed, for grouping elements please use ModelData_BIMCompositeElement
  • ModelData_BIMHostElement::AddElement was:
    • Renamed to Add.
    • Implemented only in concrete subclasses (Site, Building, Storey).
    • Restricted which types of children can be added (details)
      This means now BIMModel has a required structure (defails)

BIM Model Entities

Base Object

ModelData_BIMBaseObject defines contents common for all element types:

Hosts

ModelData_BIMHost represents a base class for BIM elements that can contain nested (child) elements and thus collectively encode the hierarchical structure of the building model.

There are three concrete host types:

  • ModelData_BIMSite, that represents the area of land, on which the building constructions are located;
  • ModelData_BIMBuilding, that represents a basic element within the spatial structure hierarchy for the components of a building project;
  • ModelData_BIMStorey, that represents a horizontal aggregation of building spaces (floor, level);

Concrete classes of ModelData_BIMHost, have Add method for adding children.

  • Site can have children of types Building or Element.
  • Building can have children of types Storey or Element.
  • Storey can have children of type Element.

Elements

BIM data model provides base BIM element class ModelData_BIMElement, which represent a concrete BIM entity (instead of structural BIM entity). There is two inherited BIM element types:

ModelData_BIMGeometryElement defines contents common for all geometrical BIM elements:

ModelData_BIMCompositeElement represents collection of BIMElements, grouped into single entity. It can be used to model any hierarchies apart from primary site-building-storey hierarchy. ModelData_BIMCompositeElement has method Add, for composing a structure, and ElementIterator for accesing the contents.

Construction elements

ModelData_BIMConstructionElement represents a base class for concrete construction (architectural, structural, etc.) BIM elements. It is inherited from ModelData_BIMGeometryElement.

BIM Model provides a number of concrete construction element types:

Also there is concrete type for representing BIM elements of other types or undefined building parts - ModelData_BIMCustomGeometryElement.

BIM Model Structure

ModelData_BIMModel class

The ModelData_BIMModel class encapsulates a data structure which contains information on the BIM data. ModelData_BIMModel provides access to a BIM elements hierarchy.

The BIM model object is used by readers when converting across supported formats, for instance here it is populated from the contents of IFC file:

ModelData_BIMModel aModel;
IFC_Reader aReader;
bool anIsOk = aReader.ReadFile (aSource) && aReader.Transfer (aModel);
ModelData_BIMSite aRootElement = aModel.Root();

The method ModelData_BIMModel::Root returns an entry element of building elements hierarhy for farther processing. The ModelData_BIMModel root always has ModelData_BIMSite type.

BIM Model required structure

BIM Model has a required structure, which constrains which host elements can be children of other elements. Requirements:

  • Site is always the root of the model.
  • Site can contain one or more Buildings or any number of elements.
  • Building can contain one or more Storeys or any number of elements.
  • Storey can contain only elements.
BIM Model required structure

Traversal of the BIM Model structure

Traversing BIM model structure can be done either with Iterator approach (through ModelData_BIMHost::ObjectIterator) or with Visitor approach (through ModelData_BIMVisitor).

BIM object iterator can be used for listing contained elements of individual Host in the case all the elements need to be processed uniformly, without regard for their specific type. See below for an example of using an ObjectIterator:

ModelData_BIMModel aModel;
// create or import BIM Model
ModelData_BIMSite aRoot = aModel.Root();
ModelData_BIMHost::ObjectIterator anObjectIterator (aRoot);
size_t anIndex = 1;
for (; anObjectIterator.HasNext(); anIndex++) {
ModelData_BIMBaseObject anObject = anObjectIterator.Next();
std::cout << anIndex << ". " << anObject.Name() << std::endl;
// process object anObject
}

BIM visitor provides more customizable approach to traversing model hierarchy. Visitors can process elements based on their concrete BIM types. To implement a visitor, subclass ModelData_BIMVisitor and override visitation functions for each element. ModelData_BIMVoidVisitor is provided to simplify the implementation of visitors by allowing to override visitation functions only for a subset of element types.

The usage of ModelData_BIMVoidVisitor to count Walls and Windows in the model is presented below:

class BIMWindowAndWallCounter : public ModelData_BIMVoidVisitor
{
public:
void Visit (const ModelData_BIMWall& theWall) override
{
myWallCount += 1;
// process theWall
}
void Visit (const ModelData_BIMWindow& theWindow) override
{
myWindowCount += 1;
// process theWindow
}
size_t myWallCount = 0;
size_t myWindowCount = 0;
};
// ...
ModelData_BIMModel aModel;
// create or import BIM Model
BIMWindowAndWallCounter aCounter;
aModel.Accept (aCounter);
std::cout << "The Wall count: " << aCounter.myWallCount << std::endl;
std::cout << "The Window count: " << aCounter.myWindowCount << std::endl;

Creating the BIM Model structure

BIM Model can be created from scratch with a combination of BIMHost and concrete BIMElments.

In terms of code, you'll simply need to create the necessary subclasess of ModelData_BIMHost and ModelData_BIMConstructionElement and combine them appropriately with Add method.

This code creates BIM Model with one site, one building, one storey, one composite, two beams, two walls and one custom element.

ModelData_BIMModel aModel;
ModelData_BIMSite aSite;
ModelData_BIMBuilding aBuilding;
ModelData_BIMCustomGeometryElement aCustomElement;
ModelData_BIMBeam aBeam1;
ModelData_BIMBeam aBeam2;
ModelData_BIMCompositeElement aComposite;
aComposite.Add (aBeam2);
ModelData_BIMStorey aStorey;
ModelData_BIMWall aWall1;
ModelData_BIMWall aWall2;
aStorey.Add (aWall1);
aStorey.Add (aWall2);
aBuilding.Add (aBeam1);
aBuilding.Add (aComposite);
aBuilding.Add (aStorey);
aSite.Add (aBuilding);
aSite.Add (aCustomElement);
aModel.SetRoot (aSite);

Resulting BIM Model structure presented at the picture.

BIM Model element structure sample

BIM Properties

Properties concept provides the possibility to attach arbitrary key-value data to a BIM Hosts and Elements. The properties can be measures, element characteristics, or other domain-specific information. The key APIs for working with properties are ModelData_BIMBaseObject::Properties() method and ModelData_BIMPropertyLibrary class. The basis of BIM properties is the ModelData_PropertyTable class and CAD Exchanger Model Properties concept, which provides a way to store arbitrary key-value data in CAD Exchanger's generic data model. ModelData_BIMPropertyLibrary organizes a collection of named property tables, which group related sets of properties. Code below presents, how it can be used:

// 1. Add property tables into BIM Element
ModelData_BIMSlab aFloorSlab;
ModelData_PropertyTable aCommonTable;
aCommonTable.Add ("LoadBearing", true);
aCommonTable.Add ("IsExternal", false);
aCommonTable.Add ("ThermalTransmittance", 0.035);
aCommonTable.SetName ("Pset_SlabCommon");
ModelData_PropertyTable aQuantitiesTable;
aQuantitiesTable.Add ("Width", 450.0);
aQuantitiesTable.Add ("Length", 350.0);
aQuantitiesTable.Add ("Depth", 30.0);
aQuantitiesTable.SetName ("Qto_SlabBaseQuantities");
ModelData_BIMPropertyLibrary aSlabProperties = aFloorSlab.Properties();
aSlabProperties.Add (aCommonTable);
aSlabProperties.Add (aQuantitiesTable);
// 2. Get property tables of BIM Element
ModelData_BIMPropertyLibrary anElementProperties = aFloorSlab.Properties();
ModelData_BIMPropertyLibrary::PropertyTableIterator aPropTableIterator (anElementProperties);
while (aPropTableIterator.HasNext()) {
ModelData_PropertyTable aPropTable = aPropTableIterator.Next();
std::cout << aPropTable.Size() << std::endl;
// process property table aPropTable
}

Note, that it is not possible to create property values with certain units. Thus, property units are presented as follows - mm for length, area and volume measures, radians for angle measures, and SI units for others.

Geometry Element contents

Geometry

The geometry of the BIM geometry element is stored as a ModelData_Model object. This object represents complete geometrical representation of element, with sub-parts and B-Rep and/or Poly representations. This is a class that defines an instance of a part or an assembly in a particular spot in the world coordinates. The geometry itself is then stored in the B-Rep and/or Poly representations of parts. This machinery is shared between CAD Exchanger BIM data model and generic data model and its detailed description can be found in Product Structure and Part Representations help pages.

Accesing and setting geometry data can be done for ModelData_BIMGeometryElement instances with ModelData_BIMGeometryElement::Geometry attribute.

Material

BIM Material represents a substance that can be used to form physical elements, e.g particular cement, steel, plastic, wood, etc. ModelData_BIMMaterial entity can be attached to Geometry element. Material can be defined with:

  • text data (name, description and category);
  • appearance data (with ModelData_Appearance approach);
  • arbitrary data (with ModelData_BIMPropertyLibrary approach) - for attaching different physical based properties (e.g. mass density, porosity, Young modulus, etc.).

Using element prototype

BIM Model Prototype approach provides a way to aggregate and concentrate data related to many BIM elements in one special element - prototype element. It can be achieved with next steps:

  • creating prototype BIM Geometry element and define its properties, material or geometry;
  • creating some building structure BIM Geometry elements with associated Prototype element and possible Transformation via concrete BIM Element (e.g. ModelData_BIMBeam) constructor.

When processing a BIM Geometry element you can get its prototype with ModelData_BIMGeometryElement::Prototype and then to process prototype fields. Below is an example of using prototypes to create multiple similar beams:

// create material
ModelData_Color aColor (50, 255, 50);
ModelData_Appearance anAppearance (aColor);
ModelData_BIMMaterial aMaterial;
aMaterial.SetName ("BeamMaterial");
aMaterial.SetAppearance (anAppearance);
// create property table
ModelData_PropertyTable aPropertyTable;
aPropertyTable.Add ("LoadBearing", true);
aPropertyTable.Add ("IsExternal", false);
aPropertyTable.SetName ("Pset_BeamCommon");
// create prototype element
ModelData_BIMBeam aBeamPrototype;
aBeamPrototype.SetMaterial (aMaterial);
aBeamPrototype.Properties().Add (aPropertyTable);
// create prototype transformations
ModelData_Transformation aLeftTransformation;
ModelData_Transformation aRightTransformation;
ModelData_Vector aTranslation (10, 0, 0);
aRightTransformation.SetTranslation (aTranslation);
// create beam elements with the same prototype
ModelData_BIMBeam aLeftBeam (aBeamPrototype, aLeftTransformation);
aLeftBeam.SetName ("Beam_Left");
ModelData_BIMBeam aRightBeam (aBeamPrototype, aRightTransformation);
aRightBeam.SetName ("Beam_Right");
// now aLeftBeam and aRightBeam have the same prototype element aBeamPrototype
// with the same material and properties
// processing BIM element fields through prototype fields
if (aRightBeam.Prototype()) {
ModelData_BIMMaterial aMaterial = aRightBeam.Prototype().Material();
// fields access is automatically propagated from prototype.
ModelData_BIMMaterial aSimpleMaterial = aRightBeam.Material();
// assert (aMaterial == aSimpleMaterial)
}

BIM Formats

The BIM Model data could be transfered from the following formats: