Revolutionizing Prefabricated Buildings: Uniting Revit, Inventor, and BIM Integration

Hello, everyone. This is Ilkay Can-Standard. I'm here with my colleague, Elif Bulge Bulut. We are presenting today revolutionizing prefabricated buildings, uniting Revit Inventor and BIM Integration.

I want to talk a little bit about our company. We are a technology integrated project management company focusing on developers to designers and manufacturers. We focus on not just the product itself, but process. We-- production expertise and research into the projects. Our office is based in New York City and has a local office in Istanbul. We have done multiple projects globally. We have a wide range experience working with global-- working in the global market.

I want to show some of our projects, some architectural projects, again, dispersed around the world. Some of these projects, I haven't personally worked as an architect or as been consultant through GenX. After architectural experience, personally, myself, I have construction projects, which are, as you can see, mainly focusing in New York City. This is where we work, focused on virtual design and construction, pre-construction services, where we model, coordinate to clash detection, and prepare the drawings for shop drawings and fabrication.

We also work on infrastructure projects. We got a chance to work with Virgin Hyperloop and some other British projects where we develop both engineering and construction process management, where we look into different materials, construction process, and cost analysis for these projects.

In addition to those, we are also expanding into manufacturing process. These are some of the projects that we do fabrication. We will be talking two of these projects, focusing specifically on Autodesk products that are from design to fabrication.

We as a company also love to do research projects. We focus on AI, robotics, computational design, how to build a MARS, future applications, and should we go tall or should we go sprawl. We try to understand big picture problems and try to address those with detailed solutions.

That being said, we are also looking at big picture of construction process. What we are highlighting here, typical construction and how the process of design is split in the middle with architects and engineers designing and then passing it to general contractor to finish the project. This is where I was part of the architectural process for over 10 years. And I was really curious about understanding how projects after we design are built.

So I have been using Revit for a very long time and modeling this very complex, tall buildings. And turning them into constructible buildings seemed really impossible. So I was really curious. And this is how I kind of got into forming Generation X.

So again, industrialized construction is a big word that has been discussed. The way we are looking at it is we think design process with architecture involving all the way to the construction, but also bringing general contractor and manufacturers early into the table to give their input and feedback to the designers. So what is being designed can be built also cost effectively and scheduled on time and efficiently and sustainably. Of course, that being said, we are looking into AI and where AI can help this process overall. Again, early on the process during pre-construction and later on the projects where it will be integrated to manage for facility management and smart design for the buildings.

Getting into today's specific topic, we understand that when we look into design to fabrication, although the definitions are very important and most often very confusing. And these are things that are not discussed early on the project, which causes issues between parties. So we want to touch base on this a little bit.

Before we get into that, maybe we will talk about a general agenda here. We have some learning objectives, problem definitions from our point of view, design to fabrication process. We will talk about two projects, as I mentioned, modular facade workflow and a library building facade project, using both Revit and Inventor.

Surely our learning objective is to explain how a manufacturing process can be established seamlessly between BIM tools. And we are specifically focusing, of course, Autodesk tools for the coordination of fabrication. In this case, we'll be heavily talking about Inventor and, of course, how we will be having an accurate prefabricated elements at the end of the process.

Also, defining what the problems are-- I think these are very well known in the industry now is that every project is specific and different from each other and needs specific process development, custom to itself. And miscommunication between design and manufacturing process is known to be one of the biggest problems. The other thing that we can mention is the coordination and the use of different tools between different roles and professions causing the duplication of work, also miscommunication. The workflow, data workflow in general definitely adds complexity to this whole process.

Again, I guess it is important to mention the design when we talk about fabrication models at LOD level-- LOD levels are extremely important. So we put together a simple diagram here where we are explaining for both design, which is LOD 100, 200 and maybe all the way to LOD 300, where usually architects and engineers are involved in that level of design. And as we witnessed, mainly Revit and CAD tools are being utilized during this phase.

Later on, when it comes to LOD 350, that's where pre-construction phase happens. And we detail the models a bit further down the design to do the clash detections and also get some data out of it to be able to outline the bill of materials ordered, specifications, and-- or lists specifications and have details resolved before construction starts.

As we come to LOD 400s and 450, it is where we are modeling at the level of manufacturing. We use the parts and products to integrate into the model itself so that it can be sent directly to fabrication. And during this time, we use, again, Inventor and Dynamo mainly to add to Revit and CAD.

And later on, LOD 500, there is other tools, like BIM 360 and robotics. We use Procore and other tools supporting BIM 360 to coordinate as-built information back into the model. So the owner or the developer has the finished product as it's designed or as is built, which may not be as it's designed. And during construction, things may change.

Today, we are focusing mainly on facade developments. So that means that we are showing a couple examples here, from two separate projects. One of them is a unitized wall system, as you see for a modular building. LOD 100 is a simple plane, just defining the geometry and the size of the system itself. Whereas LOD 200 shows openings and the solid parts. LOD 300 starts showing the structural elements and openings more defined with dimensions. This is where usually architects take too.

And LOD 350, 400, and 450 is the area where it gets a little bit blurry because it is, OK, what elements are 350 versus 450? Not everything needs to be LOD 450. And certain levels are enough and doesn't need to be developed too much because we want to avoid anything unnecessary or duplicated.

Again, you can see from a mullion design on the right side there are variations. And this rules what we are defining as LOD levels can be different for each project. What matters, I think, is that this is design discussed early on.

And I think this slide kind of shows that more specifically is what we do is we outline the profiles and assign an LOD level. And we discuss with the clients to understand that or understand we are on the same page, meaning that what we think that we should model at 400 versus 350 can be different. So we make sure that they agree with us. This is a simple chart we put together. And again, this can become a big problem for projects if these items are not item by item discussed to be included at the final model.

So we're going to talk a little bit more onto project workflows of this project. Looking at here, we will be talking first on the modular facade project. But any project that we start, initial analysis is crucial. And what we are showing here is that we look into architectural models, structures and manufacturing inputs. And manufacturing inputs are the profiles, parts, assemblies bolts, the screws, every single thing that will be used in the model to be assembling it.

Every project starts with understanding the geometry. So building geometry is essential for us to understand clearly and system analysis, meaning all the mechanical structural systems and how they integrate into the facade. From that, we create a data management setup. This is where we use Excel a lot and also coordinates and understand how many different types of conditions are happening.

And based on that, we coordinate our building systems. Again, what is reaching out to the facade? Again, mechanical systems may be protruding from the facade or structural elements or circulation items that are affecting the facade design in this case.

Once we understand both the candidate that we want to manage and also the building itself have to coordinate with the building systems, we look into parts and assemblies more in detail and usually develop a PMU or VMU, which is performance markup and virtual markup-- visual markup, sorry. This is where we test our fabrication details on assembly process. So manufacturers and the contractor can test and build it before they actually do it on the site on the building.

Getting into a little bit more in detail, for the initial inputs that we receive from the projects are architectural model, as shown here, the design from the building, usually exhibit model from the architect, sorry, and structural model from the engineer. And we receive a PDF set of drawings and information and then a scope file for us to understand different material types, different areas, how this is split between different contractors and builders, and, of course, manufacturing input with all the details and parts.

That being said, what we are trying to show here is all the things we receive can be different type of datas and different digital elements, different files, different programs. So difficulty is bringing all these things into one place and while doing so, not lose any of the information and keep the accuracy.

Looking into this a little bit further, again, everything starts for us as the building geometry. This is something we can do early on in Revit, or these other applications. As you see, we have a massing model on the left side where we identify the different type of materials, different type of elements, and coordinate that in plan, and make sure that our geometry sets-- overall geometry is set and confirmed with all the design partners and everyone on the project.

So when it comes to fabrication, a general workflow. And what we are showing here is kind of a VMU, a small portion of the building where we do a test before we start for the whole building. In this location, we have a simple Revit model as a placeholder surfaces, where we show different conditions, as in this case, corner and typical conditions.

That is our Revit model. And we use Inventor as to develop our assembly models for individual parts and assembly itself. And using Dynamo to place this Inventor model in back into Revit to create our final fabrication model.

Here, we have to highlight that the fabrication model usually becomes extremely heavy because of the level of detail that it includes. So this is not something we do share with everyone else. This is an information we use for coordination. We get our fabrication information directly from Inventor. We will get into this a little bit more in detail.

So we try to put together a simple diagram, kind of explaining this relationship between Revit, Inventor. Of course, as mentioned, the first step for us is Revit. This can start at LOD 100. We don't need LOD 300 per se to start our process. Because what we need here is geometry information, general dimensions as Revit file. And this is also where we develop our Excel. Excel is where we control the different topology and instances where we communicate between both Inventor, Dynamo, and Revit.

Once we have all our inputs in Revit, we use that input to create our Inventor, both parametric skeleton for modules themselves, individual modules of the facade units, or overall building surface or individual parts. Based on this, we are creating our content library, which has all the parts different or the assembly types to be included. As you can see, we have multiple versions, instances, of the assembly where we are getting our 3D model for the very detailed fabrication, but also the fabrication drawings, schedules and assembly data out.

Once we develop our Inventor files for each assembly parts, we use Dynamo and iLogic to transition that detailed model back into the Revit. So this is actually a full circle that is happening to create our fabrication model. One thing to mention here we use Dynamo is or iLogic is from inventory files as the files into Revit families. That's how we get that into our fabrication model here.

We will go into the steps a little bit more detail individually to focus on that first step, which is the geometry model. Again, we have our Revit model defining origin dimensions, or inputs, from the Excel. But I actually maybe go to the next slide, where we show this in 3D.

This is our main geometry as an example. This could be a massing model or a simple geometry exported from another application. From this we create-- use a place holder families. As you see different colors here defining the different types. These are just placeholders. We use their naming strategy to place them through Dynamo. We place the Inventor created assembly files, which are the detailed parts and assemblies, placed into the model by using this placeholder families, which are, again, defining the variations of the surfaces.

Giving a little bit more in detail, in this case, we have way more design types. We are just showing a few here as an example. Again, this process has to be very well managed and well coordinated. We have to fully understand the type of variations that we are using in the project.

For example, we have a fully metal element of an assembly. From this, we could have multiple instances that has different heights and different widths. But individually, because this has window inside and there is an opening, this has an operable window and a door, they create different instances or different types of files for each assembly.

From that, once we understand our types, we create-- we understand all the elements that will be attached or built into this assembly, basically all individual parts. In this case, we have a mateline that is kind of controlling the width and height as a skeleton, basically. And we have a secondary structural system that is assigned with the dimensions and controlled with parameters. We have sheet metal that goes over that. Is Eclipse as an attachment system, and finished metal panels that goes over that.

In this case, there's no window. So this assembly has all solid panels with the structure behind it. And the same way we develop individual type of assemblies, so these are individual separate files that can have different variations inside. As we show here, the window-- the door can be on the other side. But basically one type of file can be used to create similar variations within. So we don't have to create individual files for each type-- or each instances, sorry. We have each type model separately.

So second step at the Inventor phase, Elif, feel free to jump in where you are. I don't see the slide numbers, so you tell me. But I guess Inventor side, what we need to know is we start with a 2D sketch that creates the parametric skeleton. This is the controlling area that controls the geometry with the parameters.

Again, we create-- we use different tools, like frame generator or adaptive panels, sheet metals, iPart and iLogic to create our content library. And this is used at the module parametric model as the assembly. So those would never use Inventor. We are pretty new to it. And we find it easy to understand and implement. So we recommend everyone to test it out.

So we want to get into some basics to explain some of the things to simplify. IPT here represents for the part file. And IAM represents the assembly file. So basically the parts are integrated, inserted into the assembly files to be able to assemble the system itself. And from that, we can create multiple different instances, where it goes into different type of-- where it can have the outputs of fabrication and drawings.

I think we have an example for this. So we are showing all the different types that I mentioned previously, the one that has with the windows and different type of window configuration, metal sheets, and with the door and different door and window configurations. We will get into a little bit more into this one that we highlighted. But as you see, these panels have these dimensions that is controlled by parameters. I think Elif can say a little bit more in our videos.

So this diagram on the right actually from Autodesk, this kind of explains well in terms of the controls between the different types of files. So basically, you can have multiple part files and a subassembly file, which is multiple parts assembled together into different parts or main assembly files.

We use sketches to use as place component. These are controlled via parameters or sketches. As you see, there is the bidirectional relationship. This is either controlling to various inserted in or the part of the main assembly acts as an assembly. It can control the different parts length, heights, and different variations.

So another thing to mention here, we are showing individual parts of an assembly. If it's a surface, we use metal sheets. There is a extrusion types that are using general frame generator and rules. Again, these are individual type of tools in Inventor. Again, in this one because it's a surface, we are using sheet metal and adaptive panel. And in this case, we are using a frame generator and parametric setup to put together this full assembly.

Just again, for those who are new to Inventor, when you open the file first time, this is what you see. There are different type of files. We have used these three types, basically sheet metal IPT as the parts files and the standard part file and standard assembly file. On the right side, we were actually trying to show the script-- or, no sorry, this is showing the tree structure of file coordination or it's on the parts.

This is different than Revit itself. This is more similar to manufacturing tools like CATIA or SolidWorks or a couple other tools out there that has a tree structure. This records your functions, as well as your parameters and parts within a different setup than usual used Autodesk tools, I would say.

So we are zooming in a little bit more into the 3D structure here. As you can see, there is the origin. The view itself and the extrusions. Again, this is really different than typical Revit workflow or view or file structure. I believe what you are seeing here is a family version. What I can also highlight here is iLogic here, which is control parameter center that controls all the parameters between parts and assemblies and also in between relationships. This is another diagram showing how we put together different type of assemblies by parts and then putting it together to create our final assembly.

Looking into this again, we start with a parametric sketch, as you see here. This is a part file. This is where we control our important dimensions, the dimensions that is controlling individual parts here. And then its individual parts are built in separately, as separate files. And they're brought in here along with the sketch itself and connected so that the sketch parameters controlling the part's location, dimensions, and general parameters, as shown on the right side. So basically, you start with a parametric sketch and assemble the file and parameters that connects them and manages them in a way.

So when you put together an assembly file for a whole building, it is really best to start with a simple exercise. In this case, we tested individual assemblies just for the secondary structure. This is a test file where we uploaded to see if the correct type is coming to the correct locations. And if our parameters are controlled correctly. We recommend initial test to be done before moving forward, not testing any relationship between Revit and Inventor.

I think there's a video we have here. Elif, do you mind taking over from here?

ELIF BULGE BULUT: Yeah, sure. We can see the basic tests in the secondary structure application to the Revit's.

ILKAY CAN-STANDARD: This is Dynamo. We are using Dynamo to place them into Revit.

ELIF BULGE BULUT: Yes. With using a simple script, we can place the secondary structure modules into the exact locations. You can see the types and the modules.

ILKAY CAN-STANDARD: And they are placed here as Revit families. There's a way to edit them as families. But in our case, we used it as non-editable version of that. So I'm moving to the next slide if I can. Yeah, why don't you take over here, Elif.

ELIF BULGE BULUT: Yes, sure. As we talked about before, after all these developments, we can place all these module types. And we can replace with the families, placeholder families. And we can replace to the exact locations. So maybe we can continue with the video, I think.

Yes, you can see the fabrication model that we applied our fabrication module types with using Dynamo scripts. And you can see some parameters we initially set up. And all these module types and their heights, widths, and they're LOD 100s and 200s, basically, information level. And, yes, we can continue, I think.

And the third part of the project test workflow is integration between the software, which are Revit and Inventor, as we discussed. This setup has three step, basically. One of them is firstly a achieved with using iLogic. And the other two steps is achieved with using Dynamo and with-- yes. Thank you. We can continue.

With the first step, you can see an iLogic code from-- to the left, yes. And with this basic script, we can achieve-- we can basically convert the assembly module files in a batch process to the RFA files, which is Revit's family files. This step is important because even in a modular project, we have so many module types. And this kind of automation process is necessary for the modular project and especially for the facade projects.

And here you can see the integration. Left one is the Inventor. And right one is the RFA file.

We have a video to see that integration. It basically shows the iLogic code. We have two folders we already set up. One of them has the assembly files, assembly module files. And the other one is empty. With using this simple code, we just automate the process to file conversion, we can say basically.

And we have the other videos. They show the Dynamo process. As you can see that we have a geometry model with our placeholder model families. And we have this assembly modules in inventors with using a Dynamo code, scripts.

We achieve two things. One of them is we get the module assembly families as a fabrication module types to the Revit. And second one, we placed all those types in a batch process, again, to the exact locations. And, yeah, we achieved an automation integration between software with using this.

ILKAY CAN-STANDARD: I'm just skipping this part to show that.

ELIF BULGE BULUT: Yes, we can skip. In the next video, you can see the fabrication model in detail more. Yes, this one.

ILKAY CAN-STANDARD: Basically, the final version that Inventor model, Inventor assemblies place into Revit model.

ELIF BULGE BULUT: You can see all components in fabrication level, all the module types. They are all individual Revit RFA file, family file.

ILKAY CAN-STANDARD: Yeah, so we are opening the file itself to show. Moving to the next step. I am not able to, so I'm going to do an Escape here. There you go.

So we will fly through this one because it's really-- we don't have much time left. This is a beautiful design by Snohetta. This is a project that we worked on facade scope.

Skipping through really quickly, the scope of the work, us understanding the assembly and difficult parts of the building, also which parts to be built as a VMU to test. We, again, the geometry is extremely-- not extremely, but complex enough that we had to do plenty of geometry analysis and study and trying to understand typical, non-typical conditions, and especially focusing on the areas of transition between slanted surfaces and the curves and how this reflects back to fabrication information, and also understanding each component and how its components are controlled by each other, affected by each other, and the order of construction and sequencing of control and dimensions. And as you see, we have the different type of products and profiles that are putting these components together.

Again, we are trying to achieve a very detailed level of information because at a building like this needs to be coordinated, well down in the details to realize all the issues ahead of the construction. And, of course, we focus on transition areas, areas of complex geometries coming together. And these areas are not easy to recognize in 2D documentation process. Yeah, Elif, do you want to continue on this, explain--

ELIF BULGE BULUT: Thank you. We can see at a unitized system test workflow, which we used Inventor to test one unitized system in a fabrication level. And maybe we can continue with the other slides.

ILKAY CAN-STANDARD: Fine.

ELIF BULGE BULUT: Basically, you can see that we have part modeling, which is the blue one. And we use the part modeling, but in various tools and features in Inventor. And we used part and assembly modeling. And finally, we used the assembly modeling to put together everything and integrate.

I can-- yeah, yes, we can continue with that. You can see this one unitized system assembled set up here with the different tools we used in Inventor. For instance, we used frame generator for the horizontal and vertical mullions, or the linear elements generally, which provides us a sketch-based control with the components that we created into the library before.

And the other one is iCopy adaptive panel method, which we define some points to integrate the panels. And we use for front metal screen panels, insulated back panel, and the glazings. The other method is that. There's a customized setup, that sheet metal screen subassembly setup.

First, we did the part modeling with using the sheet metal IPT templates. We modeled individually each parts, which they are different from each other, different sheet metal panel types. And then we use the bottom up modeling technique to put together in an assembly file. And this is the result-- that sheet metal screen subassembly. We put those subassemblies to the main assembly file and integrate the parameters with using iLogic and the rules and the parameters.

ILKAY CAN-STANDARD: It's also worthy to mention that sheet metal tool allows you to enter material information, band allowance, some control that is specific to sheet metal itself. So that's the purpose why we use it for here.

So also, we can mention top-to-down method versus bottom-up modeling technique. There are a couple of different variations Autodesk website explain this two different approaches very well. So maybe something people are interested can look into that a little bit more in detail.

ELIF BULGE BULUT: I can continue. Yeah. And we wanted to show each workflow one by one quickly that we used to model the main assembly. You can see that first method that we need to create the library-- I mean, we need to create a parametric sketch test, which we start from scratch, from one unitized system setup. And then, we applied from one unit-- to one unitized system, sorry.

And you can see a sketch basically. We created 2D sketch in Inventor. And we set up the constraints and rules in the IPT file, sketch IPT file. And we tested in an assembly file with the components.

You can see the sketch, a parametric sketch for the first image. And then you can see the parameters and the variations we apply with those sketches and one unitized system assembly. And you can see in the video those set up.

ILKAY CAN-STANDARD: We are doing this test because this project specifically had many variations and changing of panel conditions. So we were testing our maximum dimensions and angles to understand, what kind of parameters you should be setting up. And again, the purpose here was to test what kind of processes actually would work for this specific project type.

Again, answering the parameters here to testing different angles and different sizes. And--

ELIF BULGE BULUT: Sorry, please.

ILKAY CAN-STANDARD: So here again, we have the parameters. We spend quite some time to understand the parameters that needs to be controlled. And on the left side, we have the list of them ahead of time to test here. And this is basically the skeleton that is controlling individual parts. And this is where we tested the profiles. When we do a very complicated system like this, we test each part individually to see that system that we are setting up is working before we finish up without testing it.

Trying to go to the next one. So we are kind of showing different type of creations here. The part library where we did, again, the horizontal mullions by using a CAD file and producing the frame components. Again, in this case, we are using a iCopy to create different instances of the same part. Again, creating part modeling for component's connection parts here.

We have, I think, a final video here. This does have music. I'm going to mute that.

ELIF BULGE BULUT: You can see the mullion, a horizontal mullion component we created first as an initial setup. And we publish to the library so we can use those components with the parameters in any Inventor file. You can see that we apply this component as a frame generator to a parametric sketch.

ILKAY CAN-STANDARD: Enabled to get the drawings out of that detailed drawings. I'm going to skip this part, which you can also get the schedule in a way that is appropriate for publication purposes. I think we did skip this part.

OK, we did mention the iCopy and the adaptive panels. This is where things needs to be controlled in the corners by using variation, if there are variations of the systems, especially for surfaces that needs this by defined the parts. I'm trying to skip.

ELIF BULGE BULUT: There is a very short video to show this process.

ILKAY CAN-STANDARD: Yeah, picking up the--

ELIF BULGE BULUT: Yeah.

ILKAY CAN-STANDARD: That part looks pretty similar to Revit adaptive component. I'm trying to skip to the next slide. OK, so this is the sheet metal part, where we use setup rules, iLogic, and linking the parameters and constraints to integrate into the metal screen itself.

I think there's a-- yeah, so this one kind of explains in this case, this panel overall width has different variations. So each panel is different width. And that is throughout the building. So individual sheets inside are different sizes. And they are controlled by the overall width, so divided equally by the overall width. So they are controlled by the parameter of the overall dimension.

If anything else here, Elif, to highlight?

ELIF BULGE BULUT: It just shows the general setup. We can continue.

ILKAY CAN-STANDARD: Yeah. So this is the one that shows individual parameters. That controls the different type. This is the corner condition, the typical, and the other conditions that are controlled with the overall dimension of the screen itself. You want to mention here the iLogic setup?

ELIF BULGE BULUT: Yes, of course. You can see in an assembly file, metal screen assembly file. We created-- we use iLogic to create some rules and relationship between the different kinds of metal screen panels that we mentioned before. All these sheet metal parts needs some rules to put together.

And as we mentioned before, if the width change or if the angle change, it needs to be adapted based on the template we created. It basically provide us a kind of a template, a link between the panels, between the parts. Yeah. We can continue.

ILKAY CAN-STANDARD: This slide.

ELIF BULGE BULUT: You can see the variations of the different kinds of metal screen types. If the angle is changed, or the width is changed, they can adapt based on the rules and the parameters we set up with using iLogic and the parameters.

We also have-- sorry about that. Yeah. We also have a UI to control all these parameters with using iLogic forms.

ILKAY CAN-STANDARD: Sorry, I think I'm going ahead.

ELIF BULGE BULUT: Yeah. No worries. Yeah. I think--

ILKAY CAN-STANDARD: This one, I think this is a good one.

ELIF BULGE BULUT: Yes. And the last step is the main unit assembly development. After all these little workflows, we put together all these subassemblies and parts. And we set up the rules and the relationships into the main assembly file, main unitized assembly file. And we can control each component individually. And we can control main assembly, main subassembly. Yes, it provides us very nice, controllable environment basically.

You can see the entire system-- yes.

ILKAY CAN-STANDARD: And during this process, we do a lot of tests and trying to understand how to control these parameters. What we are showing here is actually a Zoom meeting, sketch-up, sketching or trying to understand what kind of parameters are important and what is controlled by what and how to place them correctly into its place to get the level of detail that we are looking for.

Perfect. We are done. Thank you so much for listening us. We are looking forward to seeing you guys at the conference. That is it for now.