From Mass Model to Fabrication

STEVE DEWITT: All right, welcome to the From Mass to Fab presentation. So building configurators are essential to the industrialized construction space. Companies like us need to be able to rapidly configure and mass customize our building product to conform to millions of building configurations. In this presentation, you'll learn how Revit and Dynamo can tie together industry and company rules and logic and constraints to create an assembled building while utilizing company product. See how we took a three week process down to one hour.

My name's Steve DeWitt. I've got 25 years of experience in design and construction. I'm passionate about solving the industry's problems. I'm a co-founder of KitConnect. I've been at FactoryOS for about two years now. I've spoken at several groups, including this is my third AU presentation. And the link below here is what will take you to a user group presentation that we did many years ago that was also based off of configurators if you'd like to see some additional ways to do things.

NATE KAYLOR: And hello. I'm Nate Kaylor. I'm the Director of Innovation at FactoryOS. And my background is originally in architecture. I got my architectural degree from the University of Kansas. And at that point, I kind of defected from traditional architecture to do more computational design. So I did my master's at the Institute for Computational Design in Germany. And since then, I've have worked at a variety of companies doing advanced engineering and fabrication projects.

So I've been at FactoryOS now for three years where Steve and I test and implement new hardware and software technology. And Revit is really central to a lot of what we do.

STEVE DEWITT: All right, so let's look at a class overview. First, we're going to look at relevance and terms. Next, we're going to look at logic and inputs. And then we're going to look at our master fab process. This is going to be our primary focus. And this is where we're going to look at Dynamo scripts and our processes to start from mass all the way to the fabrication model. And then lastly, we're going to look at outputs and optimization and utilization.

So relevance in terms, so why build a configurator? To quickly configure any building layout utilizing a templated or pre-designed assemblies where we are adhering to our company's rules and logic and the industry's rules, logic, and constraints so that we can rapidly create a bill of material or a ROM and then additionally kick off a Revit model for our design and collaboration. Why automate? So why automate?

So we know a lot about the industrialized construction process. We also know a lot about our process. So as an example, FactoryOS built wall panels in our own way, thus we know how they need to be designed, created, revised, updated, deleted, documented, and extracted in very specific ways. If automation creates the wall panel, then I can assume the next logical step would be to create a sheet for that panel, then to create a schedule for that panel and so on and so on and so on.

And at the rate of between 300 and 1,200 shop drawings per project, the question becomes, why would we not automate that task for our design team? Additionally, in any given model, we have about 1.2 million elements to manage, create, revise, update, and delete processes. So we need the help. And then lastly, and there's other reasons, but and lastly, for this presentation, it's because we need a consistent output as well.

NATE KAYLOR: So to continue the conversation of relevance, we've all seen the headlines coming out more and more. The US and California especially are experiencing shortages in affordable housing options. So the median housing prices are drifting farther and farther from the median household income over time. And this is largely due to the inefficiencies involved in conventional design and construction. So with offsite construction, we've proven that it's possible to reduce costs by up to 40% under ideal circumstances.

But we deal with the added complexity of needing to customize every building for different building codes but then especially for differentiated design intent from the architect. So this is why prefab architecture has not been so successful in the past. But now, with advances in 3D modeling and production technology, it's possible now more than ever to mass customize while producing standard outputs for manufacturing, so keeping costs down, allowing us to move quickly. That's it. Thank you.

STEVE DEWITT: All right so terms, let's look at what we're going to be using these terms throughout the presentation. So what is a dwelling? A dwelling is the apartment or the enclosed space. Next, we have dwelling segment. What is a dwelling segment? Look at each purple item here. The dwelling segment is the individual piece of each dwelling. So it's a single fabricated, the parent assembly. So this would mean that we could have one, two or three dwellings in any single dwelling.

What is a mod? A mod is what goes on the truck. It's our finished product. This is typically two dwelling segments adjacent from one another in the red, what goes inside of the mod? Everything that we've agreed to with our client, so this could be everything from a refrigerator. This could be definitely our wall panels, our floors, our standard assemblies. Enough is basically what's being delivered to the site to be installed.

And mod segment, what is our mod segment? Our mod segment's highlighted in green here. And it's half of a mod. And then lastly, we're going to be using the term catalog quite a bit here. And so catalog is the-- it's a collection of predefined dwellings. So this is typically what we try to get our customers to utilize in design so that we can use old engineering drawings or existing engineering drawings. We value engineered this product so much that we've got this down to a science, and we are suggesting to use these components.

So these are really important to us because we want to try to utilize this geometry inside of construction and design drawings. And so what I'd like you to notice is when I play this video, this gray box that we see right here. This gray box ultimately is the definition of a mod. But within that mod, we can have several variations of each different segment.

So we design by dwelling, but we build by mod. So quite simply, there are billions of variations that we could accommodate for here inside of every single mod considering we are building by two different dwelling segments.

Logic and inputs, so an overview here, we're going to look at the building and dwelling logic, how these things flex, and we're going to show some examples of that. We're going to look at massing logic. We're going to look at the manufacturing logic. And then lastly, we're going to look at the Dynamo logic and inputs. So building logic, so our building logic is we need to be able to utilize any building length, any building width, any facade, variation or articulation, or any dwelling configuration within industry and company rules and constraints.

So we can configure a rectangle building. We could configure a u-shaped building. It doesn't matter. We need to be prepared for it. What is our dwelling logic? Our dwelling logic is pretty much the same. It needs to be any given length, any given articulation. And it can be located anywhere inside of a building. It could also have variations from ADA or HVI compliances.

So what this also means is any of these links, any of these locations inside of the building, these also need to have rules and constraints within them and within the building and how they relate to each other, so once again, millions of permutations that we need to be prepared for.

All right, so we're going to look at an example of some of what I'm saying bathroom logic and constraints, right? And so this isn't really just to show a bathroom dimensions and bathroom constraints. What's important is we really want to take what we're about to see on this slide, we want to apply similar logic, right? We want to say that the dwelling is going to have similar logic, or the way the bathroom interacts with the dwelling is going to have similar logic.

So let's look at constraints. So we have manufacturing constraints. This green highlighted component represents, we'll just say the toilet and the shower and tub here, right? And so these are dimensions that are hard coded into the manufacturer's geometry. So we have no flexibility here. Next, we have code requirements, right? Once again, we are restricted to certain values that maximums and minimums.

We have project constraints. We have construction constraints. Additionally, we have calculated values. And lastly, we have the remaining, which is like which parts are flexible. So we don't have a lot of flexibility here. But what is also important to recognize here is this is not just within the bathroom or within the dwelling and how these things interact together. We also have floors, roofs, ceilings, walls. All of these components need to have the same variables or the same values where they need to know how to flex.

So within a wall component, we need to know where the components can be added, where these things can be flexible, what components are stagnant, what components we're able to make modifications to without impacting or breaking any rules. So next, we're going to look at massing logic. And this is a very important slide. The slide is going to help us determine how we extract information so that we can start to place components.

So to start off very simply, we have this mass, right? And this mass has configuration values that have been assigned to it, like there's a bathroom. There's a kitchen. What's the location of these things, additionally, maybe even more information like what kind of unit is it? Is it something that we've already designed? What we have from this is a basic insertion point. And from insertion point, we can get edges faces and surfaces.

And what's important about that along with orientation and knowing if this component is mirrored, is we can extract points to then start to place geometry based off of those points. And so if we look at this video, you're going to see here that these faces really represent insertion points for other geometry like these wall components. And so as these things get placed, we're simply just extracting the information from the mass to find positions so that these components can be inserted.

NATE KAYLOR: So now for some manufacturing logic and constraints, in a traditional factory, identical parts are getting mass produced. And this is obviously a lot easier to automate in a factory. We, on the other hand, are dealing with a different configuration of a building on each project. But we still need to get that very precise, granular information about all the parts across the building for procurement and production purposes.

So when running our mass to fab script, we maintain the data structure as we're placing all the different parts across the building, which we can then use to do the same process in reverse by extracting that data to use for kitting and subassembly logic in addition to routing and machine code that's required for robotics and automation. So this also comes with specific constraints regarding the size of the equipment, the reach of the robot arms, et cetera.

STEVE DEWITT: Great. Next is looking at our overall Dynamo workflow. And so our first piece of information that's coming in is our geometric inputs. And so we're going to talk about Forma and AOR and KitConnect as geometric inputs. But ultimately whichever of these inputs are coming at us, they're ultimately informing our design. So what we want to do is we want to be able to utilize Dynamo as the middle person here to basically be able to figure out which rules, constraints, and logic have or have not been broken.

And that's within the building, the dwelling, our manufacturing constraints, architectural constraints, and how we like to assemble things. So we house a lot of that information in Dynamo, some of it in Revit. And we're going to talk about that later. And then while we're in Dynamo, we want to utilize the abilities of Dynamo like comparing geometry to start helping us pick out subcomponents and assemblies for manufactured elements.

We want to be able to duplicate families. We want to be able to place and Insert content. We want to be able to flex parameters to adhere to new building configurations. And we want to use the group commands. All of this is going to, combined, is ultimately going to kick out our Revit geometry and data to create a fabrication model.

Any lessons learned, we can roll those right back into our rules and logic. So we must take any one of these inputs and utilize the same company and industry rules, constraints, and logic to provide a set of consistent results. That's what's important here. And so these scripts that we're about to show should work for any of these inputs. So our common exchange point is really Dynamo. Our output is Revit data information and geometry.

NATE KAYLOR: So there are three ways in which we can receive a building layout that then becomes our input for the mass to fab process, so the first being we receive an existing layout from an external team or architect that we then configure our mass model on top of. And this scenario is going to be the focus for the rest of the content in the presentation. But the second option or scenario is us sharing a kit of components externally with external architects or designers.

Then we can use a tool like KitConnect, which is ideal for project types that employ productized or repeatable approaches to building design. We can share our company content with our partner design teams. And they can use it without making edits that compromise our rules and constraints. And then the third scenario, we don't have any existing layout to begin with. But instead, use computational or generative design tools.

So if you move to the next slide, we'll break down that last scenario a little bit more. So in this computational or generative scenario type platform like Autodesk's Forma can be used to generate a building or building options on a site. So if we use a custom extension or plugin, we can embed our standard configuration, logic, and constraints in Forma. And rather than limiting the design, instead, we're creating a tool that designers want to use to explore design options but while simultaneously adhering to standard design, logic, and constraints.

STEVE DEWITT: All right, now, we're going to review what we're calling the M2F, or the Mass to Fab process. And this is going to be primarily focused on the inputs and logic that we've already gained from the previous slides and how these are applied inside of Dynamo and inside of Revit. So an overview is step one, we're going to define your dwelling masses, right?

So we're going to find each unique dwelling segment. We're going to model that one segment. We're going to go through how Dynamo and Revit can be used to show us how we can adhere to design constraints and rules. And then our next step is we're going to lay out the building using some defined masses that Dynamo is going to suggest for us. We are going to create assembled dwellings for things that are not already pre-designed. And then our fourth step is we are going to place in these dwellings inside of the building itself.

So first step is defining temporary dwelling masses. So we are assuming here that we have an existing building layout, right, and that we're going to be starting from. So OK, so what we see here is an existing building layout. And what I'm doing is I'm overlaying a mass to quickly conform to this building's geometry. And I'm just putting in simple values, like does it have a kitchen? Does it have a bathroom? Where are the openings? What kind of openings do they have?

Next, we're going to copy this out, and we're going to look at this later. I'm going to highlight what we call broken design constraints, and this is going to highlight how we can immediately get real time feedback for things that aren't going to be configured properly. And so we're going to highlight how this works in a moment. Next, we're going to look at duplicating types and selecting from catalog elements. We had one type family before. Now, we have two types and.

So what this script does is it searches these two masses. And it says one of these is an exact match to a catalog number 17, and the other one is not. And so it created new types for us. So what we're going to be looking at here is overlaying geometry on an existing layout. We're going to be reviewing how broken design constraints are going to be helpful in the laying out of this and how sometimes rules need to be embedded in Revit versus in Dynamo.

And then we're going to look at how Dynamo can be a search engine as we apply criteria and as we apply configurations to these individual segments. So we've got four steps in here. And the first step is to define dwelling masses and broken design. And we're going to look at broken design constraints. And so if you remember, we had talked about how Dynamo or Revit can tell us if we are configuring something that is improper or is breaking rules.

And so how we start with this is we start off with a simple mass, right? And this is a floor plan view of a mass that has unconfigured elements inside of it, right? But what's important about this is we are going to just take one simple value of this width dwelling segment. And we are going to use this value in multiple formulas to calculate some outputs, right?

And so this one value right here can get written into this formula, which ultimately gets written into another formula, which can give us direct feedback of you are submitting a building that has broken rules. And so the idea is if we zoom out, and we look at the massing scale, right, and so if the outputs keep us within our basic confounds and ensure proper geometry creation, then we've done a good job, right?

If not, we can get results directly from Revit information-- directly from the Revit family here saying we've configured an improper mass. And this is super important because we want to start off with the right content. Maybe sometimes we need to figure out do we want Revit to house this information, these rules and constraints? Or do we want Dynamo to give us these results back in this particular case?

Because of how we like to design in these first few steps, we thought it would be more valuable to hold those constraints within the nested family itself versus to have Dynamo kind of procure what these results should be. So that's something to think about as you go through, and you start to want to make a configurator is where do my rules live? Where should they live? What makes sense?

Next, we're going to look at, we're still in step one here, but we're going to look at using the compare to catalog tool and so how this works. And so we start off with an unconfigured mass, right? Nothing is there. There's no bathrooms. There's no windows. There's no walls. There's no configuration at all, right? So you can see that this graphic box here has zero items checked, right?

And so if you look inside of there, it says there's a bathroom to the left. There's a bathroom to the right. There's an exterior deck there's a deck that's recessed. And so these are just lightweight configuration inputs. There are other inputs that we use as well besides dimensions and other things. But these are the ones that we're going to highlight today. So let's look at a configured mass, right, so a configured mass.

As we start checking these boxes and defining these links, they'll start to populate geometry inside of this mass so that we can then use this to create our search and compare to our catalogs. And so this is the basic information that we need to identify what components we've already built in the past and what components we want to call part of our catalog.

And so as these things get configured, and these dimensions get defined, and these other values start to get derived, we can use that extract to search from our catalog of components and have Dynamo make suggestions to what components that need to be used inside of our next few steps. What's important is if there is no match, then Dynamo is going to create a new type for us. So in this situation that we're about to show, Dynamo is going to suggest a catalog, one catalog element and two non-catalog elements for the next series of steps.

Step two is laying out the building with the suggested catalog or newly defined catalog elements. And so all we're doing here is we've replaced the ones that we created initially, and we're utilizing the ones that Dynamo created that were the new type and the catalog. So we just simply place these in the building so that we can have all the represented masses inside of the building so that we can then start to populate this in a couple slides.

So this is a manual effort here. Dynamo is not doing anything, right? Except for in the previous slide, it made the suggestions on which ones to use. And so this is a manual effort here. So we're not going to highlight any features as far as how we got to this point. Next, we're going to select these three pieces of geometry that have already been defined by Dynamo. And we're going to ask it to assemble the components in there.

The one that assembled first is a catalog element. And it came with all the parts and pieces. The ones that are being assembled right now are the ones that did not have a catalog element and therefore require an assembly process and additionally need to be grouped. So you'll see here in a second as I go through, I'm going to individually select these. And now, these have all been grouped, or we have now associations to these components. So they understand they belong together.

So to be clear, we've got three masses. One is a catalog, and then all the others need to be assembled at the same time. So while these things are being inserted as well, we are duplicating families. We are flexing the values of those parameters so that these things can adjust to conform to the project specific dimensions. And then we're placing them and rotating them and grouping them. So that's kind of what's going on in here. And we're going to discuss how that works in Dynamo in a minute.

So placing components, so how do we go from the two boxes at the top here, which has nothing to the box to the right, which is starting to place geometry? So how it works in Dynamo, I'm going to go step by step by step and kind of show the sequence of events that has to happen in order to play out this whole entire process, right? So very first item we have is the selection, so you've got to be able to select something. So this is our select node.

But what's also important to note here is we have constants. And so we all probably aware of what constants are in Dynamo. But how I'm applying it to the industrialized construction rules and constraints logic is a constant in my term here as an example would be, let's pretend we have a corridor width that can vary between project to project. Say it's five foot, sometimes 5 and 1/2 foot, six foot. So this is a variable, but it's still a constant within the values of the project.

So I'm going to have constants in here that I can always change based off of a project by project scenario. Another example would be, say maybe the spaces between the mods or the spaces between the mods and the grid lines. So that can change on a per-project basis. So constants are something that are good to have because you're going to have variables that are always going to change on a project by project basis. And this is where I keep them at the very front near the Selection tool.

So we select the unique masses, right? These are our inputs. So we don't select the whole building at this point. We're just selecting the three isolated ones that we've identified as all the unique dwellings inside of our project. Our next step is we are going to filter by company product. So we have more products than multifamily. And so this is basically looking at the content, and it says, hey, I know I'm multifamily stuff, so it creates a subcategory and list of components that we're going to start to use that are only specifically for multifamily.

Next, we're going to filter by yes, we have a dwelling segment, or no we do not have a dwelling segment. That's a catalog dwelling, excuse me. So if we have a catalog dwelling, then it's going to send those to the next series of nodes. We're going to extract the points of that cataloged element in this particular case, because we only had one. And then lastly, we're going to place that catalog element, right? So essentially, what this is doing is we already have a predefined configuration that is actually a Revit group.

And it's just grabbing that group, and it's placing it inside of that one mass. If we do not have-- if there is not a catalog element, this is the remaining masses, not catalog dwellings, right? So this is our sublist of components that we don't have catalogs for. So we're going to extract a list of parameters from these masses. And it's going to suggest inside of Revit. It's going to basically start to create filters and start to pair up components n that need to start associating to each other.

So what this means is we're going to filter for all the families that we have based on product type. To be truthful, it's really kind of a cheat. I have a prefix in front of my family names so that it automatically knows what wall panel or what floor or what ceiling or what roof belongs or should be duplicated based off of each individual configuration. This is the input of the families that are needed. This is the actual families that need to be used.

And then we're going to match the input with the actual families to produce, place, duplicate, and flex the perimeter exterior walls, to place, duplicate, flex interior walls. And just some extra information here, some configurations don't require interior walls. So you're going to have to create filters for things that do or don't need certain product types. Second to last here, we're going to place, duplicate, flex floors, ceilings, and roofs. And then lastly, we're going to create Revit groups out of each of those that are being placed.

So step three, this is going to be an example of how we place non-cataloged assemblies. So we're not looking at something that we already have predefined as a whole entire dwelling. We're going to look at now how to assemble a new dwelling, something that hasn't been predefined, OK? And so we saw this slide at the very beginning. But the idea here this is an example of a non-cataloged mass being assembled, right?

So a catalog mass already has components assembled and is a predefined Revit group. So what we're going to look at here is the non-catalog masses being assembled. So we start off on the very right hand, or excuse me, on the very left hand side. We have a library of components that can be used. On the bottom middle here, we, see a mass, right? So this mass ultimately has configurations that have been-- or configuration values that have been set.

And if you recall those checkboxes, so those checkboxes have been identified. It can then explore the library of components that's within that Revit file. And the middle section here shows Dynamo starting to configure and figure out which components need to be used. And then the last very top animation here is defining the final choice that Dynamo has made. And then it creates a Revit group so that these things understand that they have associations to each other.

Step four is to place the dwellings inside of the building mass. So our steps here are to-- so at this point, we've completed step one. We've defined our temporary masses. Dynamo has suggested cataloged dwellings and to create new types to be used. Step two, we've used Dynamo's suggestions for catalogs and non-catalog elements. We've used those to mass the whole entire building.

And then in step three, we're using Dynamo to place catalog groups with catalog masses and then assemble non catalog masses within the Revit group. And so in summary here, this script is simply placing Revit groups inside of the associated masses that we had in step two.

So let's look at the breakdown of how this works. So how do we go from components on the very left to a full entire building? We select the building. We've identified the masses. We go find its pair or its partner, which is a group. And then we place that group inside of the building mass. And how does that work? Excuse me. So at the beginning here, we have our constant values that we've talked about before. We have some script notes, and then we have our Selection tool here.

Our next step is going to be like in the previous slide, we are in the previous Dynamo script we explored, we have to separate by company product type. We have to determine is it a catalog, yes or no? If it is a catalog, then we get the points and rotation factors of that catalog. And then we place the cataloged dwellings that are groups. We get the remaining masses that were needed to be assembled.

We're going to get the points and rotation factors for the remaining masses. And then we're going to simply place those remaining masses inside of the building itself. Now, let's look at our outputs and utilization.

NATE KAYLOR: Yeah, so the reason we need to build all of these tools to begin with is ultimately to drive several other areas of the company. So looking first at the design process, so we are providing data about the manufacturing process up front to make informed design decisions. And then in preconstruction, we are accelerating and boosting the feasibility and estimating processes.

And then later on in production, we are ensuring that our manufacturing outputs are quality controlled and available when they're needed. And in this way, through this process, model data is integrated and utilized across the entire value stream.

STEVE DEWITT: OK, so a couple lessons learned here, writing instance parameter values to thousands or millions of elements is very slow. Placing groups with system families is also very slow. And kind of a brief conversation about analyzing unique conditions versus the whole entire building, originally, when Nate and I created this concept, we would define the whole entire building with masses as we did before.

But instead of isolating out the unique scenarios, we searched the whole entire building for our product, right? And so we would search the whole building, and then we would start to just Insert product into the whole entire building. And this really was laborious for either my processor or for our machines in general. But it took a very long time. And so what we decided to do is to only focus on the unique conditions that needed to be modeled.

So therefore, we could just evaluate geometry that is unique to the building versus the whole entire building. So it really sped up our entire process. So I thought that was important to highlight because there is reason to maybe analyze a whole entire building. But we found it best suited just to search the unique dwellings inside of the building.

Some other lessons learned here is what we did to validate our accuracy here is we have a lot of amazing data on what we've produced in our past not just geometry-wise, but how much it costs, how much lumber and timber and components went into every single module. So what we were able to do is we were lucky. We were able to reverse engineer several projects because we already had cost, and we already had quantity takeoff.

So we basically found every building we possibly could. And we tested it by modeling this process and seeing where our errors and gaps were and eventually getting to a point now where we are about 2.5% off that we've seen in any one building. So we're very happy with those results. Probably went through about, I'd say 40, probably 40 different building configurations and testing them multiple times to get to this level.

Next, is I would say keep the output data so that you can save metrics like evaluating how many typical dwellings are used, what configurations have we done? How many non-typical dwellings have we done? Where can we improve? What kind of deviations do we have from the catalog, and what kind of deviations?

Additionally, probably like everybody here, ChatGPT has helped us out and some of these ways. It's helped us in a couple of different fashions from creating some algorithms for [? Bubble ?] or creating some search algorithms, and then additionally, help writing our white paper for this class. So thanks, ChatGPT. And then manual efforts, and so this is one thing that I feel like is one thing that's it's hard to define up front.

And so this is trying to figure out what should be a manual effort, and what should be automated? Why are there manual efforts? And some of those answers are simple. Well, not all Revit APIs are exposed. So therefore, it has to be a manual effort. Or sometimes the effort to automate is greater, thus it outweighs the benefits, right? As an example, when I create those groups, I, for the life of me had one of the hardest times figuring out how I could manipulate the insertion point and change its Z point to match what I needed.

If I have 20 unique scenarios, I can modify that point in about four seconds for each group. And since the risk was high of the insertion point not being correct, and the effort was high to figure out how to change that insertion, I decided I'll make that a manual effort. So trying to figure out where those manual efforts should come is important to figure out. And then I have, throughout all of my nodes, these things called QA/QC nodes right Quality Assurance, Quality Control.

And these nodes basically, because I'm using just an insane amount of lists, there's a lot of ways I can just compare lists. Is this list total or count equal to this list total or count? If yes, then always spit out yes. And then that's a quick way for me to know that my lists are equal. Therefore, it is a solid chance, or a 100% chance that these inputs are correct, right? And so it's a good way for me to isolate and pinpoint where things are wrong.

And then additionally, it's a good way for us to assure ourselves that the data were outputting here is correct. Because there's billions of data points as we know. So that's it. Thank you.