We'll start by putting the Family Editor in context. Without oversimplifying or complicating matters, think about how you'd organize a design problem: constraints, building, content, documentation, and workflow. Interestingly enough, this parallels how Revit also views the design process: data, host families, component families, views, and worksharing.

Note

Now that you have a better understanding of where your component families sit in relation to your overall project, we'll discuss some specifics. If you attempt to create a new family (Revit

Figure 15.2. Template categories

Selecting the right template determines a lot of behavior about the family. In some cases, you can change the category of the template that you've selected from one to another. For example, in Figure 15.3, a Generic Models family template is capable of being turned into another template. This is helpful if you need a family to schedule in a different category than one you might have initially selected. But in many cases, categories cannot be switched, and nonhosted or non-face-based components cannot be changed to hosted or face-based (and vice versa). That's why you need to choose the category carefully.

Figure 15.3. Switching between family categories

Some categories are hardwired for specific behavior, and if you change from that category to another, you can't go back. For example, if you start a family in one of the baluster templates, you can switch to another template. But after having done so, you cannot switch back to a baluster family.

Scheduling

In addition, keep in mind as you start a new component that the category you select ultimately controls how the family component will schedule. So, if you're trying to determine which template to select, it will be helpful to ask yourself or your team members how the family should schedule. Figure 15.4 illustrates all the schedule categories that are available in Revit.

Figure 15.4. New Schedule dialog box

Projection and Cut Values

Another important characteristic of the family category is that it will control whether a family will "cut" when intersecting a view plane (plan, section, elevation, and so on). For example, convention dictates that when furniture encounters a cut plane, you should show a projected view.

Revit respects this convention by cutting some categories while not cutting others. You can figure out which categories cut or don't cut by going to the Manage tab and clicking Object Styles (Figure 15.5).

As you can see in Figure 15.5, categories such as Casework, Ceilings, and Columns cut, while categories such as Electrical Equipment, Electrical Fixtures, and Furniture do not.

Figure 15.5. Cut properties via Object Styles

Another important characteristic of the object properties is the default line weights given to objects when they're placed in a project. These line weights effect both projection and cut values. Just remember that it's probably best not to manipulate the Line Weights dialog box (Figure 15.6) unless you know what you're doing. If you intend to increase or decrease the line weight of a category of objects, use the object properties rather than the Line Weights dialog box.

Figure 15.6. Line Weights dialog box

First, keep in mind that hosted objects are meant to cut their host or create an opening or depression. Obviously a window (with few exceptions) needs to cut the wall that it will go into. Or a fire extinguisher case will often need to create a recess in the wall in which it will be placed. Second, if the component is to be hosted and you're certain that it needs to create an opening in its host, it can only cut one host. For example, a window that is wall hosted may not be hosted by a roof or ceiling.

Want to see a bad example of this? Open the Tub-Rectangular-3D family component in the Family Editor that comes with Revit (Figure 15.8).

What's wrong with this picture? Well, first, not all tubs need walls, so you'll have to make another family that has no host in order to place the tub where there is no wall. This seems a bit redundant, because one tub will do.

Figure 15.8. Wall-hosted plumbing fixtures

Second, if you delete a host, all the nested elements are deleted as well. This makes some sense when you delete a wall that contains a window. But it will certainly lead to a lot of frustration if you delete a wall that contains bathroom fixtures!

But what if you want the tub to move with the wall? There's a better way. Simply place the element and select the Moves With Nearby Elements option (Figure 15.9). When the host moves, the component will move as well.

Figure 15.9. Moves With Nearby Elements option

We can't stress enough: stay away from creating hosted relationships between objects that do not require hosting (that do not cut or otherwise modify the host). This brings up an interesting point of debate, though. Rather than use hosted elements, why not make elements face-based? There are some interesting advantages:

This brings up one last point with regard to hosting and face-based elements. Why not simply model the elements, share the parameters, and then nest? This often gives the most flexibility.

For example, lighting fixtures contain elements that allow the light to render once placed in the project environment. Balusters are another example of elements that have specific behaviors built in. If you don't select the appropriate category, you may find yourself starting over.

The insertion point determines the location about which the family will geometrically flex'not just in plan view but also in elevation. The reference level in the Family Editor directly corresponds to the datum level in your project. Keep in mind that not only does this relate to the visibility of your component in a view, but it also relates to how the component will schedule. This is important for a couple of reasons. First, when the family expands or contracts geometrically, the insertion point will remain relatively fixed.

But second (and often more importantly), the insertion point is the point of reference when two family components are exchanged. This is critical if the "design" family that you've used as a placeholder is being swapped out for something more specific at a later date. If the insertion points are not concurrent, the location of the new family will not agree with the location of the old one.

For example, the default Desk.rfa file in the following example has the insertion point located at the center of the object (Figure 15.10). This means the desk will flex about this point. But this is not desirable if the desk, table, or furniture object has a different insertion point that you are about to swap out for this example or if the family needs to flex from a different location.

Figure 15.10. Default Desk.rfa family component

Keep in mind that changing the insertion point is easy. As you would expect, you don't move the geometry to the insertion point. Rather, you simply select two reference planes and then make sure the Defines Origin option is selected. Based on our experience, we recommend that the insertion point for this particular family would best be located at the face of the desk, as shown in Figure 15.11. This would allow the desk to flex with respect to the seating, so that if the desk is larger or smaller you won't have to spend time relocating all the chairs.

Figure 15.11. Redefining the insertion point

If you're confident that what you're about to model in the Family Editor will need to flex (length, angle, location, and so on) from within the rules of the family (not just within the project), then it's important that you start modeling the geometry by first creating the rules that will allow the geometry to flex.

With little exception, you don't want to give parameters to the geometry itself. You'll want to create the necessary reference planes, lines, and points first. Then associate the parameters to these references and whenever possible test the parameters to make sure the references are flexing properly. Once you're confident the references are flexing, you can build the geometry in context to the references, again testing to make certain that when the references flex, the geometry is flexing as well.

Which reference you use is based on how you want the geometry to flex:

The great thing about reference lines is that because they contain endpoints, they're able to manage angular relationships.

Figure 15.13. Reference planes controlling the parameters of the default Desk.rfa family

Figure 15.14. Straight and curved reference lines

Parameterizing Reference Lines

Here's a simple tutorial for parameterizing reference lines. Don't even try this with reference planes. It would break'because by definition, "planes" don't have endpoints. So when you try to parameterize an angular value between two reference planes, they tend to lose their angular origin. Fortunately, lines have endpoints, so controlling them from an endpoint is far more predictable.

First, open a Generic Model template and draw a series of connected reference lines. If you are deliberate and make them all the same length and angle, it'll save some time. Here's what you should have when you're finished:

Now take a moment and add length and angle dimensions to each of the lines. Then parameterize all the length parameters together, and then do the same things for the angles. If you've drawn your reference lines carefully (all the same length and angle), you'll be able to parameterize them by selecting the dimensions all at once. If they're different, you'll need to select each length (and each angle) one at a time and associate with the appropriate parameter. When you're finished, it should look like this:

Now comes the interesting part: create a single swept form by picking each of the reference lines together. After you've finished your sweep, you'll realize that when you flex the angular and length parameters, the sweep will remain associated with the reference lines.

With this technique, you can imagine that modeling accordion panels shouldn't be a problem. You can show the panels as open or closed, driving the individual segment lengths from an "overall" length that is divided among the individual segments.

The time it takes for Revit to generate or regenerate a view depends on how much stuff in the view needs to be displayed. One of the great things about Revit is that it automatically assigns the level of detail based on the scale of the view (Figure 15.15).

Figure 15.15. View Scale-To-Detail Level Correspondence

When you're building smaller parts of a larger component (or if the elements are not visible in certain orientations), you should assign those elements to only reveal themselves at a certain level of detail (or only certain orientations). This will keep Revit from having to manage more information than necessary. Here's a rule of thumb: once the separate lines that represent something print as a single, merged line, there's little point in having that element display in that view or at that scale. Although this was an entirely intuitive realization when drawing with a pencil (don't draw over the same line twice), unfortunately computers have allowed us to draw beyond a point of diminishing returns.

To see how to fix it, open the default Desk.rfa family, which is fairly well built. But if you look closely, you'll notice that orientation and detail level are not being fully specified. All of the drawer faces and hardware are showing up at every view in every section or elevation.

In this Desk.rfa family, everything is showing up in every level of detail. This isn't necessarily a big deal with just a few objects. But multiply this by all the other elements that will make up your plans, reflected ceiling plans, elevations, and sections, and you'll notice that your views don't refresh, rotate, print, and export as fast as you'd expect. When this happens, one of the first things we look for is an object in a view that is being shown at a level of detail that is far too high. In some cases the object only prints as a small, black dot. But when you zoom in you'll notice that it's full of detail.

Controlling the detail parametrically is done through the Family Elements Visibility Settings dialog box (Figure 15.16).

Figure 15.16. Family Elements Visibility Settings dialog box

Notice that the box for the Plan/RCP option is unchecked? This is appropriate for the desk, because little more than the surface of the top of the desk needs to show up in plan. The legs, the hardware, and even the faces of the drawers don't need to show up in plan.

But what about the elevations? By turning off the Thin Lines option, you can see that all the geometry is showing up at every level of detail in a view that's set for 1/8' = 1'-0" (Figure 15.17).

Figure 15.17. Lines beginning to merge

In these cases, Zoom To Sheet Size is your friend. Figure 15.18 shows the same desk in elevation when that option is active. It's obvious that we'd never need that level of detail at that scale.

It's pretty obvious that there's far more detail than necessary for this view and the solution is simple. Set the drawer faces to show up at a Medium detail level or finer, and set the hardware to only show up at a Fine detail level. Do this to all your content and performance should noticeably increase (Figure 15.19).

Figure 15.18. Zoom To Sheet Size

Figure 15.19. Adjusting detail level

Materials are crucial to a family. But keep this in balance'don't obsess about the material that will display when a family is being rendered. What's more important is the Shading setting and the Transparency value of the material because they communicate much about the intent of your design in the early stages (Figure 15.20).

In addition, material options are often not easily created in Revit. Yes, a family can have a material parameter. But expressing many different parameters for visualization purposes is probably left to the visualization specialist who understands the subtleties of creating an emotive image, not just a "rendering"—and it's unlikely they'll be using Revit to iterate or emotively visualize your design.

Figure 15.20. Shading and Transparency in the Materials dialog box

As mentioned earlier, dimensions are useful for controlling the geometry parameters of your families. But it's best to keep the dimensions outside of Sketch mode. Let's use the desk as an example. In plan view, you can see all the reference planes and dimensions (Figure 15.21).

Figure 15.21. Parameterized dimensions

Now select the top of the desk and select the Edit Extrusion option. What you'll find are dimensions to the edge of the desktop (Figure 15.22).

Figure 15.22. Dimensions inside Sketch mode

These dimensions are "inside" the Sketch mode of the desktop. This is fine in the sense that they'll work. But as a best practice, don't put parameterized dimensions inside Sketch mode. The reason is that when you complete the sketch, the dimensions will be hidden. Then when you're trying to troubleshoot or modify parameters, you won't be able to easily find the values that correspond to in the model view.

So whenever possible, keep all dimensions outside of Sketch mode.

Revit has predefined a number of hardwired family categories. These categories can't be modified or added. As mentioned earlier, they define how elements display, schedule, export, and so on. But within the default object categories, you can create subcategories for model, annotation, and imported objects (Figure 15.23).

Figure 15.23. Object Styles dialog box

Although you can use subcategories to control the visibility of some part of the whole component, keep in mind that the detail level and visibility settings already manage visibility. The subcategories are most important when you're exporting your project, because each category and subcategory is permitted its own CAD layer (Figure 15.24).

Figure 15.24. Export options for categories and subcategories

So if your project is being exported to CAD in such a way that you'll need to associate objects with granular layer settings, creating and assigning subcategories to elements is necessary. But don't rely on subcategories to manage visibility.

The key difference is that modifying a type parameter will always modify all the other components of the same time. On the other hand, an instance parameter will only modify the components that you have selected. Figure 15.25 shows the parameters of the default Desk.rfa family.

Figure 15.25. Parameters of the Desk.rfa family

You can tell all these parameters are type parameters because any time you have an instance parameter, the text "(default)" appears after the parameter value. In this case, it's likely important that the dimensions are type parameters. You don't want users to create random or arbitrary Depth, Height, and Width values.

On the other hand, each new option can create a lot of new types. By default, loading a family into your project will also load all the types. If you want to create the potential for many types but be selective about which types are loaded, you can use a type catalog to load only specific types.

One of the great things in Revit is that the relationship between solid geometry and cutting void is nonlinear. Solids that are joined together may still maintain independent relationships. They're not locked together after they're joined.

Additionally, not all voids must cut all solids. The void may selectively cut one solid but not another solid, even though the two solids are joined together. For example, in Figure 15.29 we've joined the solids from the previous image and overlapped them with a single void. Notice how the void is cutting all of the joined solids.

Figure 15.29. Single extruded void overlapping all joined solids

Figure 15.30 shows the results of finishing the sketch.

Figure 15.30. All joined solids cut

This is often not desirable because now you'll have to go back and "uncut" three of the four joined solids. So in many cases you'd rather model a void that only selectively cuts. The trick here is not to model the void as a void. If you do, then by default it will cut all the solids that came before it. Rather, model the geometry as a solid (Figure 15.31).

Figure 15.31. Initially modeling the desired void as a solid

Now you can convert the solid to a void from the Properties dialog box, as shown in Figure 15.32.

Figure 15.32. Converting a solid to a void

Figure 15.33 shows the results. The void doesn't cut any of the solids. This is desirable when you want to complete the void and still see it, because by default, once a void cuts a solid it becomes invisible, which makes it rather hard to find. This technique still shows the void for editing (Figure 15.33).

Figure 15.33. Noncutting voids remain visible.

Now you can selectively cut only what you want to cut (Figure 15.34).

Figure 15.34. Selectively cutting forms

To review this file, you can download it from the Chapter 15 folder at the book's web page (www.sybex.com/go/masteringrevit2011); it's called Solid Void.rfa.

If you're really 3D savvy, creating complex geometry often involves creating what you need with complex modeling tools in order to reach some final result. The process in Revit is often different and has some wonderful benefits as well.

Think of a sculptural process as being additive or subtractive. Creating sculpture as an additive process means that you're casting the desired shape. Creating sculpture as a subtractive process means starting with more stuff than you need and then carving away until you have the final result.

Many complex geometry applications create complex forms as an additive process. In other words, you create a form and then manipulate that result with other tools; pushing, pulling, and twisting until you've morphed the final shape.

Think of Revit as more of a hybrid process that relies heavily on a subtractive approach that carves away what you don't need. Although this may seem a bit counterintuitive at first (because in many 3D modeling tools, cutting geometry is a linear process that doesn't lend itself well to parametric editing), in Revit the void is a live thing that can be quickly and easily modified.

For example, you may not believe that the form shown in Figure 15.35 has been created in Revit. If you're trying to create this form using an additive process, it's quite complicated. But if you create it using a subtractive approach, then it's quite easy, and the results can be surprisingly elegant.

Figure 15.35. Sculptural forms

Furthermore, the form consists of only three (copied) extrusions and a single void. But it's easily done and with just a few steps.

Complex Forms Made Simple

Creating that sculptural form is not hard. Don't believe us? Follow these steps:

1. Create the extrusion sketch shown here in a Front/Back elevation. In this case, the overall height is 6'. The width is 0'-4".

   

2. When you finish the sketch, set the overall length to 9'-0". This is the resulting shape.

   

3. Go to your Left/Right elevation and use Copy/Rotate to move the form 90 degrees so that the copy is vertical. You'll also have to select the Disjoin option.

4. Go to the Top/Bottom view and use Copy/Rotate to move the original form 90 degrees to that the copy is facing left/right.

5. Use the Join Geometry tool and join all three forms together. When you're done, the form should look like this:

   

   Now it gets really interesting! We'll show you how to cut multiple solids from a single void after you initially modeled the void as a solid. Here's the sketch of the solid revolve in the Front elevation:

   

6. When you finish the form, you want to make certain that none of the geometry from the star form is showing outside the revolve that you've created, as shown here:

   

7. Change the solid revolve into a void. The void won't cut! This is what you want: the ability to model solids and voids with the flexibility to cut the void when you're ready, not before.

   

   Here's a tip for cutting a lot of geometry with a void without having to select elements one by one. First, select the void and select Cut To Clipboard (or press Ctrl+X). This will remove the void! Don't worry.

8. Select Paste

   

As a result, you should begin to understand that complex form making in Revit is quite often a subtractive process'you create more geometry than necessary and then use a void to carve away what you don't need.

There are some great examples of creating sculptural forms in Chapter 26. Carving geometry is a technique that set designer Bryan Sutton (profiled in that chapter) uses extensively. If you want to explore this file further, just look in the Chapter 15 folder on the book's web page for the file Egg Sculpture.rvt.

As discussed previously, reference planes, points, and lines are most often used to drive geometric form. If you've been using Revit for any length of time, you've been creating parametric content. But there will be some cases where these three options alone are just not enough. This is particularly difficult with linear or tubular forms, as shown in Figure 15.36.

To learn how to drive geometry with geometry, follow these steps:

Once loaded into the project, the extrusion will be hidden, and because of the parameters that drive the extrusion, you can create new types (Figure 15.46).

If you want to explore this file further, just look in the Chapter 15 folder on the book's web page for the file Tube Chairs.rvt.

Figure 15.46. Final form in the project environment

You'll start by building one of the two brackets.

To nest these two brackets in your shelf family, follow these steps:

Now when the Shelf Depth length changes, the bracket will grow to match.

Figure 15.57. Parameterized reference planes

Now that you've nested the brackets and tested the parameters, you'll continue by adding Family Type parameters, which will allow you to select between the nested bracket families.

Now that you've associated Family Type parameters to the brackets, you'll continue by creating a parametric array in order to control the number of brackets on a case-by-case basis once the family is loaded into the project environment.

Figure 15.61. You can parameterize the grouped array.

Figure 15.62. Parameterizing the number of brackets

Figure 15.63. Be sure to lock the shelf bracket when aligning.

After you've aligned and locked both brackets, their locations should flex when you change the Shelf Width parameter. Go ahead and test this now. In fact, as a best practice, it's a good idea to test the parameters after every few steps.

Now let's create a formula that adds brackets as the length of the shelf increases. We'll show how to do this simply at first, and then we'll add some complexity.

Figure 15.67. Creating the Actual Bracket Space parameter

Figure 15.68. Creating the Minimum Bracket Space parameter

Now let's associate the material of the shelf with a parameter to control the material.

Figure 15.71. Adding the Material parameter to the shelf

Now you can open the Family Types dialog box and see that the material of the shelf geometry has been parameterized to associate with a material (Figure 15.72). Once this family is loaded into the project environment, you can change the material of a shelf as a type. You'll also be able to specify the bracket, as well as the spacing of the bracket.

Figure 15.72. Material parameter in Family Types dialog box

Now let's consider all the possible permutations of this shelf. Imagine the following:

How many Type permutations might exist?

Easy! 2 x 2 x 2 x 3 x 3 = 72 Types

That's a lot of types to build and load into a project, especially if you really only want to use just a few of the types in your project. You have a couple of options:

Type catalogs can be intimidating at first because small errors will cause either the type catalog or the corresponding family to fail, so just go slow and test frequently. You don't want to test the catalog at the end of your process and be faced with untangling spaghetti.

We'll start simple. First, keep in mind that the type catalog needs to be in the same location as the family that it references, and it should have the same name. So in this case the family is called Parametric Shelf.rfa, so the type catalog will be called Parametric Shelf.txt. In addition, spelling counts, and parameter names are case sensitive as well, just like when you're working in the Family Editor.

Parameter values can be expressed as length, area, volume, angle, force, linear force, and "other." For this example, we'll be using length (for lengths) and other (for Family Types). We'll use decimals when appropriate. While we could create this in Excel and export as a comma-delimited text file, we'll walk you through creating the type catalog as a text file (which is a little bit harder, but we will explain a lot in the process).

Figure 15.77 shows the result when you attempt to load the family into the project.

Figure 15.77. Completed type catalog

Now that you've created the type catalog in a text editor, you'll want to consider editing (or even creating) it in Excel. The important thing is that you'll need to import and export the catalog in a specific way.

From left to right, Figure 15.83 shows Type 1 through Type 4, respectively. If you want to download the Shelf family and type catalog, look in the Chapter 15 folder on the book's web page for the files Parametric Shelf.rfa and Parametric Shelf.txt.

Figure 15.83. Completed family types