Dynamo and Curtain Panels: A Wild Brick Pattern Workflow in Revit

NICOLAS CATELLIER: Hello, everybody. My name is Nicolas Catellier. I am an architect and BIM specialist. You can follow me on Twitter, @nicocatellier. Today's presentation is called Dynamo & Curtain Panels-- A Wild Brick Pattern Workflow in Revit.

Before going through with the presentation, I would like to briefly introduce myself. I'm an architect and BIM specialist. I used to work at Atelier 21 Architects, here in Quebec City, for almost 10 years, where I was a design architect, project manager, and the BIM manager of the office. Last year, I went fully on my own as a BIM consultant at BIM Pure Productions.

In the community, I'm mostly known for creating the learning website revitpure.com, which I started in 2016. I am the host of Revit Pure Live, which is a show on YouTube where I receive multiple BIM experts to share their expertise about Revit or other BIM software. I've been, previously, a speaker at both BILT and Autodesk University, and I'm based in Quebec City, Canada. So that's a little bit about myself.

Today's presentation is about lots of things I love, like bricks, housing, and Dynamo. And, usually, while I present, I have to create fake projects because most projects I work on are under NDAs, and I cannot share them publicly. But for this one, I was very lucky that the firms I work with, the architect firm, let me share the work. And so thank you to L'OEUF architects, which are based in Montreal, to let me show this project, which is called Place Griffintown. And you can see the other-- name of the other collaborators in this slide.

And yes, this is a project I've been working on for a few months. And when I was brought in, it was in the process of a redesign of the facade to create more exciting facade and integrate special brickwork. And pretty early on, the designer had the idea to implement extruded brick facades. You can see a few examples of that here.

So the idea was to create a brick patterns using extruded brick, a little bit like this. So in the process of this project, I had to create multiple families, using different techniques. And in this presentation, I'm going to showcase a few of these techniques.

The presentation is going to be split in three parts. The first one, I'm going to show you how to create an extruded brick pattern using generic families in Revit. And the second part, we're going to try an alternate technique to do it, using curtain panels and curtain walls. And finally, the presentation is going to conclude by using Dynamo to create a dynamic brick facade based on an image, like you can see on the image on the right.

This course comes with a full dataset which you can download at this URL, which is revitpure.com/au2022. Or you can pause the video and scan this QR code to get the dataset, which includes a Revit [INAUDIBLE] file, multiple families, a Dynamo script, and a sample image. OK.

So let's start with the generic family. Early on in the project, I was working with the lead designer of Griffintown, who is called Ben Wareing. And its original idea was to create a special brick pattern in between the windows, as you can see in this image.

So he asked me what would be the best way to do it. And, immediately, I knew, first, that I had to avoid the model in-place technique, which could be quick, but I knew if there were any change, whatsoever, it would cause a lot of problems. So my idea was to create a generic model family and place it on the wall.

After many tests, I came to the conclusion that I had to use nested families and actually use multiple level of nested families, as you can see in this image. We have, actually, three images. OK, go back.

Three images, the first level being the singular-- the single brick. The second level is creating a vertical array based on this individual brick. And the third level is creating a full wall-hosted generate model that integrates these two other levels of nested families.

So during the presentation, we're going to explore all three steps to create this family. And, but first, I thought I would show you the end result, what this family can do. So this is an example of this family being placed on a project, and you can see that we do change the width and the height. And the family automatically adjusts.

And the limitation or, at least, the way this family is done is that the origin is placed at the bottom left, which means that you will always get full brick at the bottom and on the left. And the brick on the right and at the top will be cut, depending on the length and the height. This family adds customizable brick dimensions. As you can see, you can play around with the brick depth, the brick height, the brick offset, and two sizes of bricks, and get completely different results, as you can see in both these images.

All right. So I'm going to show you how to create specifically this family. But I thought, first, I will show you some principles of working with arrays in Revit. So arrays are essential to understand how to create these families. And they can be a little bit complicated, but you need to understand the basic principles and you will be all right.

So first, let's start with what is an array? An array is an element that is repeated a number of times. So in this context, the number of elements is determined by the family's length. You can see in this GIF that when the length of the family is modified, the number of arrays automatically adjusted using a formula.

The number one tip I would give you to create arrays in Revit, in a Revit family, is to nest the main element that you are going to array. You don't have to do it-- I mean if you have a really simple family, you could use a simple extrusion. But at the moment, you want to modify the height, the length, the depth, or change the material of the element you want to array, if you use a nested family, it will be much easier for you.

The second tip I would give you if you create arrays inside of Revit families is the number of elements in the arrays should be smaller-- at least two. If you try to put 1 or 0, it will not work and you will break the family. There are possible workarounds with this. But if you look over here, you can see in the GIF that if we change the length, that the number of array would go to 1 or to 0. The family breaks. We get a warning. It doesn't work. So it's something to keep in mind when using arrays in Revit.

The basic array formula is equal to total length divided by elements length. So in this case, we know that the length of all our family is 1680, like in this case. And we know that a single element is 280. So to find the amount of elements in the family, we use the formula that equals length divided by the length of the single element, which is 280 millimeters.

The second tip is to use a run down formula to avoid exceeding the length. So something to keep in mind when using a formula to find the amount of array is that rounding the number will always go-- well, for example, if you have 5.8 will round to 6. And if you have 5.3, it will run down to 5. However, as you can see on the image on the right, it is possible with this technique that the element will be longer than the length itself. To avoid this issue, you can use the round down. If you run down in the formula, it means that if you have a value of 5.9, it will run down to 5, meaning that it will never exceed the length of the family.

Finally, the fifth step is to add a filler element with a variable length. Depending on the expected result, you can add an element on the end with a variable length. As you can see here, we call this value VL1, which stands for variable length number one. And we put this formula, which is length minus amount array multiplied by 280. And you can see here, for example, the variable length is set at 265 millimeters.

Tip number six, elements with dimension equal or below 0 breaks. So if you have a formula that finds a dimension and the dimension is 0, or even a negative value, the family will break. You will get a warning, just like this. Your family will not work.

So the possible workaround if you want to avoid a situation like this is to use an if statement. And what this if statement does, if any of you had done any programming, it's one of the most basic formula you can use. And the if statements work is that you give a condition, if the result if true and then the result if false.

For example, you have if the length of the variable length would be 0 instead make it 1 millimeter. Ls just the regular length you would find regardless. And this way, you will ensure that you see in this case, VL1 should be 0 because of the if formula that we use, it is actually set to 1 millimeter. And the family doesn't break.

Finally, if the family is equal to 1 millimeter, we probably don't want to see it, right. We use this so the family doesn't break, but it means we shouldn't want to see it. That's when you can add a visibility parameter for the specific element so you can make the variable element invisible. In this case, we're going to use another kind of formula, which is not. And, basically, the visibility will be turned on if this parameter is false. So not, this I mentioned not visible if variable length 1 is equal to 1 millimeter.

So you can see VL1 here is equal to 1. In this case, the visibility is turned off. On the right, you can see VL1 is set to 120. And in this case, it is visible because it is not equal to 1 millimeter.

And the final tip to use arrays in Revit formulas is to avoid or at least be careful with horizontal and vertical arrays in the same family. While it is technically possible to have grid on the horizontal and vertical on the same family, it has a lot of complexity. And when you have more complexity in the family, you get more fragility, which means that the family might break more easily. So I've run into a few issues playing with arrays just like this.

So the solution that I found to create the brick family is to nest one of the array in another family. In this example, I've created a single brick I've created another family that only contains a vertical array or type then nested in another family where I created the horizontal arrays. This way, there's less fragility into the main family and less possibility that family will break. And it's a little bit faster I found as well.

OK. So this is the level one family, back to our brick family. The single brick unit, again, simply create a simple extrusion that has a height, length, and depth parameters, and can also map the brick material as well. And make sure to place the origin at the bottom left. So when you select the reference plane, make sure the define origins box is checked. That will be very important later on when the size of the brick will be changed. It will change the size to the right direction or going to the top instead of being centered. This is pretty important. And make sure to use the generic model kind of families for the single brick element.

All right. Take a bit of water.

So level 2 is the vertical array. So this is the end result that we want to have. We have a brick every other row, including a brick that might be cut on the top. So this is what you will have to recreate. And so here we have a little video that showcases what we can do with this family. You can see that when we change the height, for example, the array automatically adjusts. And we can also change the brick height and the brick length as well. And the family keeps working, so the height is customizable.

So the first things you should do in this family is to go in elevation view and create two horizontal reference planes with the brick height and set this parameter. And then the plan view, set the brick offset and set the brick depth parameter. And then you insert the single brick, the nested brick, into this array family.

And you're align and lock. So here is a little video that showcased this process. We are currently in Elevation View. We create the dimensions through are reference plates. Select the dimensions. Create a new parameter called brick height. It's a type-based parameter.

Sign it to the second row as well. You can adjust the value. Then you can go to the plan view and create the brick value as well as the brick offset. So this should be in the brick length as well. This is brick length. You can adjust the value, skip a little bit.

So now we can create on top here, this will be the break offset. And the other value is going to be the brick depth. Just like this. We have all over values.

And now you can see what we've done here. You can drag and drop a family from the project browser into the plan view, just like this. And then when you need to do, this a crucial step, is to map the parameters. You edit the type of the instance you placed, click on the small rectangle. So you have the brick height. You have parameters from this family, so make sure to map the brick height, map the brick length as well, and the brick depth. And it's not done here, but you should also map the brick material as well.

And then you need to align and lock. So you will see this process, there's a lot of align and lock, align and lock to make sure the family properly works. So now back to the Elevation View. You can also align and lock this family. All right. So the first brick element is placed.

Now, what you can do is to create the array. The array is located in the Modify tab. And you need to select the amount of array you want. But when creating it in a Revit family, you always place it to number 2, and you move to second. And then you will be able to set the amount of rows parameters.

So let's jump into the video. You can see we select the brick here. Use the array tool, number is 2, move to second. And I like to place it slightly above the top reference plane and then I can use the Align tool, set the reference plane, and then click on the brick to lock it. So this really to ensure that the lock icon is correct and that I've used the correct reference.

And then when I select one of the brick, I can click on the align over there. And in label, click on Add Parameter. And I call it a amount of rows. So this is a parameter for the array.

So I'm almost ready to create a formula to get the amount of brick we need. But first, let's create the height parameter. What is special about this is that we use also value called height minus offset. And the height minus offset value is found by taking the height and removing the brick vertical offset. And what is the brick vertical offset? It is the first row, basically. Because later on, we're going to use this family to be placed on the second row. So this is to ensure that the brick arrays placed on the second row are not tall.

So it's OK if you don't understand every formulas or every parameter. Don't forget that you have access, well, first, to the handout, and also to the data set so you can explore the families by yourself. It's OK if you don't understand every part of the formulas. The main idea is you get all the major points.

All right. So this is what you should be able to do. And you can see the amount of rows formula as set by taking height minus offset and dividing by brick height multiplied by 2. Why brick height multiplied by 2? Well, remember that we have a brick every second row. So for each brick, we have to add another brick to find the correct amount. So you can see that we flex the family. And when creating families like this, always test them as you go along to make sure that it properly works.

And finally, we need to create the top brick. So you will need to create a new type for the single brick. And what is special about this brick is that the height is variable. All the other parameters are the same, but the height might change depending on the total height of this family. So you will need to map all the other materials as you did so far.

And, again, remember that when a family dimension is set to 0, the family will break and you will get a warning just like this. So again, as I've mentioned earlier, you need to use an if statement formula just like this that says if this brick would be the dimension would be smaller than 0 or equal to 0, make it 0.1 millimeter instead just to make sure it doesn't break. If that is the case.

If the brick height is 0.1, well, we don't want to see it, so we use a visibly parameter. And since the formula used, not the brick height equals 0.1 millimeter. So it means if this is the value of the brick height, the brick will not be visible.

So here are all the parameters and formulas you should have. So it might look complicated, especially this one, the top brick height. It's not that bad actually. So the top brick height is basically saying, well, if it would be smaller than 0.1, make it 0.1 instead. Else, use the calculated height that we have found.

All right. And, again, make sure to make some tests to see if it properly works. You might need to work out with some of the align and lock. And for example, I can see the top break visibility here is automatically turn on. As you can see, this is the top brick. And over here, you can see the top brick visibly is turned off because, obviously, we don't want to see this little brick segment. Again, test the family to make sure it properly works. Seems to be the case.

All right. This is the level three. Now, the final level where we take the vertical offset family and now we put it in this level three family. And we'll take the vertical offset and place it multiple times with different types. You can see all the amount of times we've created in this family over here. Let me explain what this means.

So I've created this elevation view with a little nomenclature. You can use any nomenclature you want. But in this case, L1 means the longest brick. Longest brick. L2 means that the brick header, which are actually going to be protruding. L3, in this case, it's the small brick segment that is located on the left and that is found with a formula. R1 one in this case stands for the first row. R2 stands for the second row. VL4 and VL5 stands for variable length on number four and number five.

So remember that the origin is at the bottom left, which means at the bottom and on the left will always get full bricks. But on the right side and on the top, the bricks might vary. That's why on this side, we have variable brick length. So for the brick vertical array that is place into this family, we have to create multiple types. And you can see with the name the nomenclature that we use L1 for being the longest brick, R1 being the first row, and L1 R2 being this one, L2 R1 being this one and so on and on.

So this is the final family is a wall-hosted generic family. And go to the Elevation View and make sure to create the height and width parameter, just like this. And make sure that they are instance-based parameters if you want to see the arrows in elevations or 2D views that you can play around with.

Then the second thing you need to do is to be able to cut the wall so you don't have conflicting geometry. In this case, we go to an Elevation View, create a void extrusion, make sure to lock it to the height and width, and then go to the Plan View and lock it to the brick depth as well. And then you can use the cut tool, select the wall, select the void extrusion. It will cut the wall automatically just like this.

Here's a little video that explains the concept. So here, we create a void form, a void extrusion. I like to create it in the middle to make sure that when aligning and lock, it is done using the right references. There are other ways to do it. But for demonstration, I thought I would do it this way.

All right. And now, we go to a Plan View and also align this void extrusion to the correct reference planes. This one goes all the way to the brick depth. And go to the Elevation View again. Select the cut tool, select the wall, and then select the void extrusion. If I go to the preview, you can see there's a hole that has been placed on the wall.

Then in the Elevation View of this family, you need to recreate using reference planes the brick pattern. Using the dimensions like this with L1, L2, and L3, and locking the dimensions. And L3 is a formula, which is L1 minus L2 divided by 2. So you can recreate this brick pattern at least if you want the origin to be at the bottom left.

And then, again, like we did for the second level, you need to map the parameters. The brick depth, height, and length, and so on if you want to be able to modify these dimensions once the family is loaded into the project. And in this case, we will have different brick lengths. There might be L1, L2, or L3.

So in this case, we're going to map the parameters. You can see we map the brick depth, we map the brick height. In this case, this is L1, R1. And so we select the L1 brick length and map the height as well, just like this. Once that is done, you can place the family into a Plan View. Make sure to lock and align it to the referenced planes in the Plan View like this.

And then go to the Elevation View. Make sure it is aligned at the bottom and on the left side. Lock and align, again. Align and lock, align and lock. And then you're ready for the array. So you select the vertical array family and you will array it horizontally. So I like to place it a little further away like this and then use the Align tool and lock it to this reference plane and click on the lock icon. Then you're ready to select one of the array. Yeah, make sure to align it as well.

Then you select the array and click on the line with the number, and you can add a new parameters that is going to be called-- in this case, we call it C1. Let me pause it. As you will see later on, each of the array might have different formulas. So in this case, this is called C1. You'll see we also have C2, C3, and C4. Yeah, was there something else here. OK, great. C1. OK.

And then what is the C1 formula? How do we find how many bricks we should have? So after many tests, I ended up with this formula, which is run down with plus L2 divided by plus L1 plus L2. So basically the dividing element is this, basically two bricks, the main brick and the headers. And this is the full width we're going to use, which is the regular width of the element plus L2.

You can see that each of the array we're going to be placing has a slightly different formulas. So I don't have time to explain in details each of these formulas. You can have a look at the family by yourself or make your own calculations if you want to find out more or the reason I came to that. But I think that this graphic can explain the basic idea out of it. And yeah, the C stands for column, and it's the amount of columns for each of the arrays.

Again, always test the families. Here we modified width, modified the height to make sure the family properly works. And the family does flex and it doesn't break and you don't get any warnings.

Now, it's time to place the protruding header, which in this case, it's called L2. So you can see the formula right here. It's C2 round down width divided by L1 plus L2. So slightly a different formula. And in this case, you can see that we do map the brick offset parameter. In this case, it is 19 millimeters. So we make sure to map it.

So in this case, we create a new type. We edit the type, we duplicate it. And this one is going to be L2, R1. So the second length, but still on the first row. And again, it's all the same process. We map all the parameters once again just as we did. There's a little difference there. The length, we'll pick L2 and the brick offset. We do map it. We didn't map it for L1. And in this case, we do map it because it does have an offset. It's [INAUDIBLE] the offset to the wall, which means the brick is protruding.

And then you were ready to place this family and create. Go to the Plan View, make sure it is also locked on all directions like this. And then you're ready to create the array. It's the same process. Push it a little further. And then use align and lock to put it in the correct position. And then assign the formula, the C2 formula. So in this case, the first row is almost complete. You can see the result we have so far. We have the L1 brick and the L2 brick.

Now, you're ready to create the second row. The second row, we start with the L3, which only appears once in this family, so it doesn't need to an array. It's just placed on the left. So quite straightforward. And then you're ready to place the two other bricks are going to array.

So here's the example where we again create a new type. This one is going to be called L2R2. And we're going to map the brick depth. A lot of mapping while creating this family, by the way. The length we pick L2. And notice this, this is important. We set the offset. And now, we need to set the brick vertical offset. So what does it mean? The brick vertical offset means that this is the second row. So just to make sure that the height calculated is-- we remove the equivalent of a brick row from it. So it doesn't go beyond in terms of height. So we map the brick height to this parameters. You can see the brick vertical offset is equal to 67, which is the same as the brick height.

All right. So the mapping is done. All the other steps are the same. Go to the Plan view, align and lock, skip this, skip this just a little bit. And then in Elevation, ready to place it at to the correct reference planes. Lock it. And now what do you do? You create the array, of course. And you can see the result over here before the array is created.

So pretty quickly, you should have something like this. Almost all of the bricks are complete. Know what the leftovers are VL4 and VL5. What are VL4 and VL5? Again, it means variable length because on the right side, the length of the brick might vary. And again, we don't want these dimensions to be equal to 0 or less than 0 because the family will break. And you will get a warning. So, again, we use formulas that says if this brick would be smaller than 0, make it 0.1 millimeter instead. And if it's not smaller or equal to 0, smaller or just, use the calculated value instead.

And if you look at this image, you might see that sometimes this brick is protruding. So sometimes it's a header that is cut, sometimes it's not. So we have to find a formula that says how the offset is calculated if there is one or not. So I found this format it works pretty well, offset one or offset two, and gives it a formula that I've used here. Again, you can play with the family if you want to find out more.

And so all right, we have all the parameters. So this is the final family. You can see we have the brick depth, brick height, the brick offset which the users can change manually. The height and width are, when it says default, it means it's instance-based. So each instance of this family, you can use the arrows and play around with it, which is the dimension. We have the four arrays formula using the run down, all slightly different. And we have the VL4 and VL5 that says, if it's too small, make it 0.1 millimeter instead to make sure the family doesn't break. And OF1, OF2 basically calculating if there's going to be an offset for the brick on the right side, variable link, brick or not.

Again, I don't expect you watching this to fully understand all of it. You'll need to play around a little bit with the families. That's OK. But my hope is that you understood some concepts of using if statements, using a rundown, and using not formulas in Revit families and understanding arrays.

So load and test the family. When I create a family like this, I'll always create a dummy project. I never inserted directly in the main project I'm working on. So I create this small project like this. I place it, I change the dimensions, the brick height, the height, the width. I try everything to see if it breaks. And almost all of the time, it does. There are always a couple of issues. So I try to fix them. And I will say most of the issues are align and lock. So you need to align and lock some more. That's OK, it's part of the game.

The current limitation of this one is if you make the family too small the length, it might break because remember it might be smaller than at least two arrays in some cases. So I'll put the minimum length formula, the width formula that you need to have for this family to be OK. There could be workarounds with this. In this case, it was not necessary in this project, so I haven't done it. But you could use workaround to make sure the family doesn't break. So again, here are a couple of options that we can create with this family. A couple of different sizes rows and columns.

I wanted to show-- this is an alternative that I did. I wondered, OK, so there are three levels. If you remember correctly, the single brick, the vertical array, and the main family. I thought, is it possible to skip the second step and go straight from a single element to the main family. So I tried this. So this is the a family that only has a single brick and there are arrays in two directions, horizontal and vertical array. I wanted to see what it looked like because my bias was to think it wouldn't be a good idea and it would break. And it wouldn't work at all.

But for some reason, I managed to make it work. But the family is a little more complicated and, again, a little more fragile. A little more likely to break I would say, but it works. Perhaps it's not that bad a solution after all. So it's also included in the [INAUDIBLE]. You can have a look. Yeah.

All right. So we're over with the first part of this presentation, which was about the generic model family that is placed on a wall for the brick pattern. And pretty quickly with the design, after I created the families that go in between the windows that is regular, the designer came to me and said, actually, it would be cool if we had a gradient brick density on the whole facade. Well, basically like this. This is the end result that I did after creating the script. But this was the idea of it the designer presented me with. And I immediately knew that I would have to use Dynamo somehow. And I also thought of using curtain walls because I've played with curtain walls in the past and it work great when combined with Dynamo.

And so I made some research to learn about how I could use curtain walls and curtain panels to create a brick panel like this. And I found this video tutorial by a Revit channel called a Revit Boost. So shout out to Revit Boost and I included the link to this tutorial. And it is a super simple technique.

You can see it's a single family, just like this. So much more simple than what we've created. And it's basically a fixed size panel. So a height of 134 by 320. And in the curtain wall properties, you just need to set a fixed distance layout for the vertical and horizontal grid. It seems to probably work.

We can see the result here. And what I liked about this when I first tried it, it's super fast when compared to family. But first, it's much shorter to create. It was super fast. So I was really impressed and I thought, wow, maybe the generic model family is actually garbage and I should have done this in the first place instead of doing all these arrays, right.

But then I found out there were a few issues with that. For example, on the edges and corners, you can see that the dimensions is a little buggy. So corners, the top, and intersection were a little bit problematic with this technique. And I realized that generic model family was not a bad idea after all.

But I think-- Yeah. Let me show you this video where this is the current panel family. You can see the Exterior Elevation View. And now let's create one of these families. I'm creating a curtain wall like this. So we don't see much there. Let's change the view styles to consistent colors. So you can see the pattern. So this was created in about 5 seconds. So it's super fast when compared to generic model family.

But you can see on the edge, the brick is kind of deformed and the panel is stretched, which we don't want. There are workarounds with this, but still a potential issue. But you can see, we can scale it on the top and on the width and it's super fast. So that's something I liked about it this technique.

So I thought some more about it. And something-- I didn't want to remove the brick material from the main brick that other users were using to create regular full plans for the construction. So I didn't want to mess with that. So that's when I came with the idea that the curtain wall should only come in the headers. Just like in this little GIF here, you can see that we have curtain walls with only headers, and we place it on top of the brick wall just like this. So it's a secondary element.

And what I liked about this, since it is independent, you could place it on a different work set and shut down the work set if you want to improve performance. Because there are a lot of bricks in this project, a lot of producing brick, about 30,000 or something like that, so it can potentially hurt the performance of the main model. So you can place it on a different work set or even on a linked file if you want to be sure that you don't have any performance problem whatsoever.

All right, let me take a bit of water.

OK. What is I saying? OK. This is the modified curtain panel family that I've created that only contains the headers. And something you might notice in this case, I'm using first L1, L2, and L3 formulas, the same as in the generic model of families I created earlier, and using the formula to find out L3. And I'm assigning and locking these dimensions.

And something you might notice as all the dimensions are locked on the right side. Which means that whatever width and the height of the panel is it will not affect this dimensions of the geometry. It will always stay the same, just like this. And the brick height are so constrained. And the result, well, you can see on top here, we have a width of 360 or width 460, and it doesn't effect the geometry whatsoever. The panels will always stay on the same side at the same size.

And you can see, however, a potential issue is that even when it should be a small panel, we still get a full turn panel, which means that we see the two bricks over here, which is potentially a problem. And I've realized that we need to use some formulas to make them hide automatically. So the systems I thought about is to add visibility parameters, first with the width. So you can see the end result at the bottom. So when you stretch the curtain wall, the brick individually appear.

So in the last slide, you can see that in this case, the two bricks appear. In this case, no bricks appear. When you move the width a little bit, one brick appears. And finally, two bricks appear. That's using this formula that basically says, do we have enough width for this panel to show the brick or not. And there are two bricks, B1 being the bottom left brick and B2 being the top right brick. So created two different formulas for them to show up or not using visibility parameters and using a not formula once again.

And something I've realized pretty quickly is that there's also a height parameter. There's a width and the height. And I also needed to add a similar formula for the height, which you can see here for both B1 and B2 two. And finally, I also wanted a manual switch so I could turn each brick individually on and off for openings and also to use with the Dynamo script that I will showcase later on. So there are three visibility parameters for each brick.

And a final one, which is called B1 visibility that integrates the three other visibility parameters. And I'm using N formula, a new formula here. So with the n formula, all these conditions have to be met for this box to be checked and for the brick to be visible. So it checks is the current panel high enough for this brick, for B1, to show up? And is there a sufficient width for this brick to show up? And is the B1 manual visibility box checked? If the answer is Yes to these three conditions, the brick will be visible. If not, it will be invisible. And then you can see the result here where the brick only show up to this length instead of having bricks that go beyond the extent of the curtain wall.

So we have a little video here that showcase this, you can see that the dimensions are locked to the right side and on the bottom. These are the parameters of this family. And you can see that the height and the width parameters and the positives to explain they are reporting parameters. What does this mean? It means that to not actually use to drive the width and height because the width and height in a curtain panel is determined automatically by the curtain wall. When you move the curtain height, curtain grids, or you just modify the height and width.

So in this case, reporting parameters means that it just takes this value. You can modify it. But you can use it in formulas. And that's what we want to do here.

So leave this again. Yes. So the height and width are reporting parameters just like this. And you can see all the formulas here, we're using the height and the width to find out if the elements are going to be visible or not.

And have a look at this. We move in this, we're moving the height reference planes to modify the height. And you can see here that the bricks turn gray, which means it will not be visible once loaded into the project because the height is too small for this brick to show up. And if you go back to the type properties and you scroll down over there, you can see that B2 height is unchecked, which means that the main B2 visibility is also unchecked, which means the break will be invisible because one of the conditions is unmet, the B2 too height condition.

All right. You can see the result in a 3D view where we move the extents of the curtain wall. Yeah.

Dealing with openings. So in this case, remember, we have the main walls, which might contain windows and doors, and we want the additional curtain wall elements to remove some of the panels that are in front of openings. So sadly, you have to do this automatically. Maybe it would be possible with Dynamo. I didn't have time to do a script that does that. So there's a bit of manual work there, but you have to manually select these panels.

And when it's full panels, so both bricks that are going to be invisible, I switched in to the anti-system panel just like this. And then if it's only one of the brick, you can see this image only the brick on the left, so the bottom left brick which is B1 should be invisible, you can select each current panel and uncheck the B1 visibility parameter just like this.