Grasshopper & Revit Interoperability: Adaptive Components via Geometry Gym

About Geometry Gym:

The next plugin in the list of interop tools for Revit is one created by Geometry Gym. Geometry Gym is usually referred to as the plugin name, but it is technically a company created by the developer Jon Mirtschin. The plugins that Jon has been developing has recently been gaining names, in particular is the powerhouse geometry tool set which is now called BullAnt. Formally called StructDrawRhino, BullAnt has a lot of useful tools that are not available anywhere else. Some great examples of what you can generate with this base tool set can be seen here.

Geometry Gym: BIM Tools

In addition to the BullAnt plugin, Jon has been actively developing a set of very powerful interop tools from Rhino/Grasshopper to Revit, Vasari, Tekla, SDNF, Oasys GSA, Robot, SAP 2000, SOFiSTiK, SPACEGASS, STRAND7. I recognize only a few of those! So obviously we are only going to talk about the Grasshopper to Revit tools for this post. You can download all of the interop tools on his blog here.

Geometry Gym uses IFC, Industry Foundation Class, as the exchange format between Grasshopper and Revit. Because of this, the plugin comes packed with components for creating a proper IFC file with the proper relationships of IFC elements. Don’t let the sheer number of components overwhelm you. Prepare yourself when you expand a tab and realize their are dozens of components that are hidden from the panel window! Jon realizes the intimidation this causes, but I promise that once you start to understand the structure of IFC, and more importantly how Jon has organized the panels, they become a lot more friendly.

As with the other GH to RVT interop tools, I am going to briefly cover the available tabs of components that come with the plugin, but I will keep it brief for the purpose of keeping your attention. Another post on the Geometry Tools is way overdue.  From left to right on the GeoGym BIM tab.

ggIFC Tab

The ggIFC components tab is where the basic IFC components live. Creating the entry points for the IFC file using the Building, Project, and Site components as well as defining Building Stories (Levels), Spaces, Materials, and Profiles are all often used components when building the IFC file.

ggIFC Attributes Tab

The ggIFC Attributes components tab include components for creating Property Sets and values of specific types. These ultimately are streamed into element type components.

ggIFC Elements Tab

The ggIFC Elements components tab, I think, is a tab full of misfit components. Jon may have to weigh in on the use of this tab. My version of Geometry Gym is also an unofficial release, so the tab layout may be in limbo.

ggIFC Elements Building Tab

The ggIFC Elements Building components tab is where most of the magic happens. This is where you can create various Architectural IFC elements. You will notice that there are some duplicate components, but these are actually special case components. The components that end with “Standard Case” are used for creating Revit specific elements. This allows Jon to recreate native Revit elements even down to creating the Wall and Floor structural and material layers. The components that end in “Type” are for defining what type of element, and then the “Common Properties” components are for defining the properties most commonly associated with that element. So the sequence of the components generally go from “Common Properties” to “Type” to “IFC Element”.

ggIFC Element Services Tab

The ggIFC Element Services components tab is just like its Architectural counterpart, but Services related. There is no need to reiterate its usage.

ggIFC Entity Tab

The ggIFC Entity components tab include components for bringing an IFC file into Grasshopper and decomposing it to gain access to the elements inside it. The Beam, Column, and Slab components are basically filter components that allow you to stream the product or representation through it and only return a Column.

ggIFC Representations Tab

The ggIFC Representations components tab includes components for creating Line Styles, generic IFC geometry types like Curves, Verticies, Surfaces, and Solids. For efficiency, it is better to use the geometry type that best represents your representation. You may also notice some very interesting components like PointOnCurve.

Grasshopper to Revit Workflow: Placing Adaptive Components

IFC Entry Points

Using the same base again, we will use only the components necessary for getting the Adaptive Component into Revit. This means that we need to build a very basic IFC file. To do that, we need to create the entry point by placing two components, IFC Building and IFC Project. These components come loaded with default values to streamline the process, so be sure to change them to make sense for your project. Every IFC file you build with Geometry Gym will need these two components.

IFC Adaptive Component

Next we need to build up the IFC Element of an Adaptive Component. The Adaptive Component component for Geometry Gym is labeled “ggIFC Curtain Wall Standard Case Adaptive Component”. I am not sure why it is that long, but it may have to do with helping you know which component to use to define its Type.  The three required inputs that are required is the Container (IFC Building), the Curtain Wall Type, and the Points for the Adaptive Points. We have two of those, so now we just need to define the Curtain Wall Type.

One of the biggest advantages to using Geometry Gym to place Adaptive Components is that Geometry Gym can create the Adaptive Component for you! Though you do not have all the functionality as you do in Revit’s Conceptual Modeling Environment, you can create some parametric relationships that are available in the IFC definitions. One of those relationships that has been implemented is the PointOnCurve component. After talking with Jon, defining a PointOnSurface is also available but not implemented yet. I think that would be a great addition.

IFC Curtain Wall Type

Anyways, in the current release of Geometry Gym, we need to define “something” for the adaptive component whether it is in the Revit project already or not. This leads us to the required inputs of the Curtain Wall Type component. The only required input is the Representation input, though we really want to define a name as well. If the Name matches the name of an adaptive component in Revit, it will use that famiy. If the name does not exist, it will create what ever you have defined as the Representation as an adaptive component.

IFC Representation

To create a representation for the adaptive component, we need to build up the component using IFC geometry types. The adaptive component that we have been using with the previous plugins is extremely straightforward to create in Geometry Gym. Starting with 4 points, we need to convert those into IFC Vertex Points. The order that we stream them together will define the placement order in Revit. The IFC Vertex Points are then used to create an IFC Face. The IFC Face is then streamed into a IFC Face Set component. In order to input into the Curtain Wall Type component we need to have a Representation Map, so we can just stream the Face or Face Set into the IFC Representation Map. The Representation Map component basically acts as a “block” that contains all kinds of geometry for IFC.

Final Defintion

The final definition ends up being a total of 15 components to create the Adaptive Component. Three of them though are standard and are used every time whether you are creating an entire building or just adaptive components. You will notice that the output of the Geometry Gym components is the IFC data itself. When you add or delete elements/component from the definition, the IFC data is recomputed and compressed. Even the numbers that are associating the elements and attributes are recomputed to make sure that there are no unused numbers.

Bake IFC

When you are ready to save the IFC File, you can use the ggIFC BakeToFile component. This basically gathers all the IFC outputs of the Geometry Gym components and saves it to a folder location. The BakeToFile component also comes with some options that you should be aware of like the (IFC4 checkbox.

Geometry Gym Revit Addin

To bring in an IFC into Revit, you need to use the addin developed by Geometry Gym. Revit can import in an IFC file, but it will not create native Revit elements. Even if you export an IFC from Revit and bring it back in it does not retain its intelligence. Jon is also using a few “tags” in the IFC that allow him to do cool stuff like create Materials, Layers, and Adaptive Components. When start the addin, a window will appear giving you some options. None of these apply to our example.

A few issues you may or may not run into during this process are the unit conversion and the compiling of the IFC in Grasshopper. The units need to make sense especially when using the Adaptive Component. In this example, I had to change the units in Rhino from Millimeters to Centermeters or larger. It would throw an error in Revit otherwise. The other issue pointed out by Jon is only temporary and will be fixed when the new Grasshopper version is released soon. I don’t quite understand the problem, so I am not going to try to pretend that I do, but if you run into an issue with Revit throwing an error and you know it is not your units, try saving your Grasshopper definition, closing the definition (not GH), then reopening it.


My comments for this workflow and plugin in general are mixed. Jon has put in an extreme amount of effort creating this plugin and actually developing a viable IFC importer and exporter for both Rhino and Revit (among other applications). If you have not dealt with him, you will be pleasantly impressed with his responsiveness and eagerness to help in any way. If you need a feature, he will add it in a heart beat. You can tell that he is passionate about it and that he is not trying to sell his services or product to you, but truly cares about your project. Unlike most of the GH tools, Jon actually provides support and training for his tools.

Enough about the developer for now. As you will see, the tools and available properties that you can add to elements is mind boggling. There are some really interesting workflows and opportunities for non-Revit users that can come out of these tools. Learning the tools though is a pretty steep endeavor. The toughest part is learning how an IFC is constructed, but I actually think that using Geometry Gym is a really great way to get into IFC. It makes you understand the format at a fundamental level, much like Grasshopper makes you understand geometry at a fundamental level.

In saying that, it takes an insane amount of components to create the simplest things because you have to build up everything that defines an element. There also seems to be some inflexibility with creating multiple IFC files in one definition. Currently all components are compiled into a single IFC file. It could be useful to separate the IFC Walls, IFC Slabs, and other elements from each other without having to disable the components. That way, if the Floors were updated but the Walls or Stairs were not, the team does not have to disable anything or import elements that did not change.

I also think that through some creative customization of the GH component kernel, the amount of components could be reduced significantly.

Other blog posts on Geometry Gym

For additional information, check out the BIM 42 blog and its Geometry Gym posts.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s