Session 13

Divide and Conquer Adaptive Components in Revit

v2013
Tim Waldock, PTW Architects

Class Description
This presentation will look in detail at the new Revit v2013 features Divide &
Repeat, particularly as they are used in adaptive components within projects. It will
build on my RTC 2011 presentation "Designing in Revit Using Parametric Formulas"
which looked at repetitive patterns in design. It will show how the new techniques
can be used to achieve similar results in a different, but more flexible fashion.

This time we will also be looking at generating curved shapes in a systematic way that
would aim to make the building designs more constructible. We will also look at
repetition on or within those shapes, demonstrating practical examples of their use.

About the Speaker:

Tim Waldock has been using Revit since 2005, and BIM since 1979. He has been
Technology Integration Manger at PTW Architects since 2006. He has worked with
numerous other BIM and 3D CAD programs over the past 25 years in the UK,
Singapore and Australia, often working closely with the software developers. He
presented at Revit Roadshow 2007, RTC 2008, 2010, RTC Aus 2011 & RTC US 2011. He is
treasurer of the Revit User Group Sydney (RUGSyd).

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Introduction
This document will cover two general topics:

New ways to create Repetitive patterns on surfaces

Creating regularised organic shapes

In covering these topics we will explore various tools and techniques, including new
Revit v2013 functionality. This document will assume some basic knowledge of the
relevant Revit tools so you may need to refer to the help files first if you are not
familiar with the tools.

New Divide Path functionality (2013)

Divide Surface functionality

New Repeat functionality (2013)

Repeat patterns on surfaces

Adaptive Components

Trigonometry in parametric formulas

The Reactor principle

There will be no use of API techniques

Examples of use of the techniques will be covered in detail, some of them as a stepby-step guide that you can use to create your own components:

Creating a rectangular surface grid rig adaptive component

Creating a Reactor adaptive component

Using the Reactor component as a repeater

Creating a star pattern adaptive component

Using the star pattern as a repeater

Creating an arc adaptive component

Adding repeating modules to the arc component for use as a space planning
tool

Page 2 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Part 1 Divide and Repeat

There are two parts to the new functionality in Revit 2013:

Divide Path
Repeat

Divide Path
This new functionality will create a divided path element that has equally spaced
nodes (points) on it. It does not actually divide the original element that it is placed
on, but creates a new one sitting on top still a single element, but having divisions,
marked by nodes. This is similar to the Divide Surface command that creates a
pattern on top of a surface.
A Divided path can be added to different element types:

o
o
o
o
o

line,
arc,
spline or
surface edge;
chain of multiple elements or edges (as a single divided path).

Issues with divide functionality:

It can only work within the conceptual massing environment (CME):

o Within an external mass family

o Within an in-place mass family
o Within an Adaptive Component

The number of nodes created on a divided path can be different to that on a

divided surface when they are set to fixed number
number.. On a divided path the
count refers to the actual number of nodes (including start and finish points); on a
surface it refers to the number of divisions,
divisions, thus a surface will have one more node
than a divided path the same fixed number.

Node visibility is not controlled from the properties dialog box, nor from Visibilty
Graphics it is set from a special Path/Surface Representation control accessed
from the ribbon. By default, when a path is divided, the nodes are visible; when a
surface is divided, they are not they need to be turned on.

Node visibility cannot be controlled from within the project it has to be done
within the family where the division was created.

Paths can also be divided by Intersects but that cannot be controlled

parametrically, so will not be considered here.

Page 3 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Divide Surface
This functionality has been available for some time in Revit, but it now has
another use for the new repeat command. Surfaces that have been divided will
have nodes available at intersections of each u & v grid (once made visible, as
above). These nodes will not be available if the divided surface is set to a pattern
(although existing repeaters previously placed on the nodes will be maintained).

Repeat
The new Repeat functionality is an alternative to the old array command. It
works by first adding a component(s) to a node(s) of a divided path or surface
this is then repeated across all available nodes of the entire path or surface. Thus
it can work in a linear repetition or a pattern in two directions.
There are many limitations to the repeat functionality,
functionality, including:

It can only work within the conceptual massing environment:

Within an external mass family

Within an in-place mass family

Within an Adaptive Component

The hosted component must be adaptive

You cannot control the setout (start point) of a repeater pattern. This becomes
important when you have irregular or alternating patterns, or when you have a
linear repeat along one row of a surface.

You cannot dissolve a repeater pattern if you need to change it, you have to
delete it, and lose the originally hosted components

An adaptive component with Shape Handle points in it may not repeat

properly (if at all).

Adaptive Components
There are several rules when placing adaptive components onto divide path or
surface nodes :

Hosting of adaptive points

One point adaptive components will be repeated on all host nodes.
Two or more point adaptives will only repeat on nodes where there is a
correspondingly located node available for all the adaptive points on the divided
path or surface pattern this means that you will invariably end up with a row of
empty nodes on one or more sides of the surface

Multiple point adaptives can be hosted

hosted on separate points/divided paths/divided
surfaces, and still be repeated. The more points you have the more complex the
rules, and unpredictable the patterns become.

Page 4 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Repeaters
This document does not try to replicate the Revit User Guide or Wiki help notes, so you
need to read those first. It assumes that you will be somewhat familiar with the
process of working with adaptive components.
Once one or more hosted adaptive component(s) have been converted to a
repeat pattern (called a Repeater) there are a number of limitations and behaviours
that you need to understand:

You can (tab)-select an individual component within the repeater pattern and
use Type Selector to exchange
exchange it for another compatible component (adaptive
with same number of adaptive po
points).
ints). For this presentation, we will not be
following this methodology because it goes against the parametric nature of
what we are looking at it is a one off manual intervention, and it can be lost
when the number of nodes is changed.

You can also select an individual component within the repeater and remove it
from the pattern by setting it to no component in the Type Selector. Again, we
will not follow this workflow.

When you create a repeater, it deletes and replaces the original hosted
components with a new pattern element this causes serious limitations to being
able to modify repeaters.

When you select a repeater pattern and delete it, the whole repeater and the
originally placed components are deleted you might expect it to reverse the
repeat command so that you are left with the original
original,, but no. This means that if
you want to change the pattern in any way, you have to start right from the
beginning with hosting the components again, and setting any instance
parameters that you might want. This is a bad workflow that we have to live with
so watch out!

It seems that if you tab-select

select a component within a repeater, it does not display
the system instance parameters (comment etc), but it does display any user
created parameters in the family. If you change these parameters, it changes all
of the instances in the repeater (unless you manually swap
swapped
ped them over to
another type).

if you tab-select a component within

within a repeater, it displays the adaptive
component Flip parameter, which allows you to invert a component on its host
node.

Page 5 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Repeater Patterns on Divided Surfaces

Below is a chart of the basic patterns that can be achieved using a single point
adaptive component hosted on a divided surface. The results are unexpected.

Single Repeater Patterns

Page 6 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Notice that patterns 10, 11 & 12 do not actually create a visible pattern, but the
repeater element is there, and can be selected this is because the patterns go off
the edge of the surface and cannot find nodes to repeat on.

Multiple repeater patterns:

Once you have 3 or more of the original hosted components (eg. 4 square as below),
Revit will no longer create one single repeater pattern,
pattern, but will create a number of
patterns that alternate with each other. This will happen regardless of whether the
originals are the same or different. In the example below it actually creates 4
separate repeater patterns (see one of them highlighted in orange). You can take
advantage of this to create a repeater pattern on alternate nodes by deleting the
repeaters that you dont want see end result to the right immediately below.

Page 7 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

You can create less regular looking patterns by making the originals all different, or
else you can work the system to create patterns that look right eg. A tartan
pattern by only changing the look of one of four hosted original components:

If you generate a repeater that creates a pattern on nodes that are already
occupied, Revit seems quite happy to do this.
Page 8 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Multiple Point Repeaters

Two point adaptive components can be hosted on nodes on one divided path or
surface. They can also be hosted on nodes
nodes on two separate divided path or surfaces
in this case their behaviour becomes more difficult to predict.

Single Surface
A two point adaptive component hosted on adjacent nodes on a surface will
behave much the same as a single point component.

The exception to this being that it will not place repeats where it cannot find
equivalent locations for both nodes so it may omit half a row/column. In this
example the repeater is stretched across two non-adjacent nodes, so that when it
gets to the last column, it can only place the first adaptive point on a node, but the
second one would be off the surface so it omits them:

If you want to alternate patterns by row, it will not work if you just place two different
components adjacent to each other it will just create one column or row of
repeaters not across the whole surface. To achieve this you need to place two
pairs of components in a square pattern. It will actually create four separate
repeaters but it looks correct:

Page 9 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

If you try to reverse the direction of one of the

adaptive components, it will create a repeater in
the same place as the originals but does not
extend the pattern.

The way to get around this would be to create a square group of four of the first
component type and repeat those it creates four repeaters; then delete two of the
repeaters to get alternate rows; then place another square group of the second
type (reversed direction of the same type in this case). Once these are repeated,
you can delete half of those repeaters on different alternate rows:

Spline and Surface

In the following example a two point adaptive arc on a spline and a surface will
repeat along the spline, and only along one direction of the surface but in this
instance the repeat stops at three because it hits the edge of the surface as it copies
down in one direction, and the copies in the other direction hit the end of the spline.
Page 10 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

This looks like some kind of bug at first, but if you increase the number of nodes on the
spline, it increases the repeats as it now has more nodes.

By placing two of the adaptives in a horizontal order on the surface it forces the
repeater to copy the other way on the surface, giving quite a different result. It can
take a lot of experimentation to get the right result.

Point and Surface

In the following example a two point adaptive arc hosted on a free point and a
surface will repeat to every available node on the surface
surface.. The adaptive component
will stretch/distort according to the distance between each node on the surface and
the free point. This technique is invaluable as will be seen later.

Page 11 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Part 2 - Setting up Components for Repeaters

Adaptive Component Rectangular Rig
My presentation at RTC last year showed how to create a two-directional array by
multiple nesting of components. By nesting this within an adaptive component it
showed how to make facade panels change colour depending
depending on their distance
from a control point. Using the Repeater technique it is now much simpler to create a
similar result initially as a rectangular adaptive component that can be placed on a
face. The first step is to create a rectangular rig adaptive component to support a
divided surface. There are various ways this could be done, depending on whether
you want a flat surface or one that can distort. For a flat surface, it can be tricky to
ensure that the rectangle and its surface pattern remain orthogonal to the adaptive
placement points. However, it is assumed here that you have already created a
rectangle of lines attached to adaptive points as required:

Create an adaptive (or mass) family and place four lines in a rectangle. Choose
your desired method of controlling the size and orientation
orientation of the family- be it
hosted on rig on adaptive points, or directly onto adaptive points .

Select the 4 lines.

Click on the Create Form command

or a plane
.
You could create a box
If you create a plane, the surface does not know which is inside or outside so
you may get unpredictable results later on with the hosting orientations. A box is
a safer option for this reason, but you might not want the surface to have a
thickness.

Test the family by flexing all the parameters, and also by moving the adaptive
points. NB. When moving the adaptive points, it is important not to move them by
clicking and dragging, because this will slightly change the z height (in a 3D view)
of the point. It is much better to move the points using the Move command or
else by dragging one of the axis arrows on the point (this will lock the movement
to one axis at a time). Try dragging an adaptive point up in the Z axis to check
that it flexes in 3D.

Select the top facet of the box; it will show a temporary height dimension. Turn
this into a Height parameter.

Load the family into a project and test placing it and flexing its parameters again.
Follow the same rules (just described) when moving the adaptive points.

Page 12 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Adding a surface pattern

Back in the family, select the (top) surface.

Click on Divide Surface, to give it a pattern

Select the surface, and look at its properties.

You could change the Layout type for U & V grids, but leave them on Fixed
Number for the moment.

Select the button to the right of Number for the U Grid

Give it a parameter such as U grid number; repeat a similar process for the V
Grid.

On the Modify Divide Surface tab, go to the Surface representation panel, and
click on the little arrow
. This takes you to a dialog box where
.
you can turn on the nodes

These nodes can then be used in the next step of the process.

Creating a Reactor adaptive component

My RTC 2011 presentation described how to create a box component that changes
colour parametrically, using nested components and multiple types (Designing in
Revit Using Parametric Formulas, RTC2011). That process is summarised agian here,
with a few additional options.
Alternatively, you could just create an adaptive box component with an instance
parameter for height (length and width as type parameters) this would react to its
situation by changing height;
Page 13 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Create a new adaptive component;

Place two points on the origin and along Y axis; and make them adaptive;

Draw a reference plane between the points (remember 3D snapping);

Next you need to create a box that will remain orthogonal along the reference
line between the points. There are various ways to do this.

You could create a rectangle of lines on the vertical reference plane of the first
adaptive point (perpendicular to the adaptive direction); then create a form
from that; then apply parameter dimensions remember the height above the
reference line must be an instance parameter.

Flex adaptive point 2 to make sure that the box follows the orientation of the
linking reference line between the adaptive points (Adaptive point 2 and this line
are used only to control the box orientation);

(Optional) At this stage you could give the box a material parameter, and create
(say 10) multiple types, each with a different coloured material.

This adaptive component needs to be set as a shared component before nesting

into another adaptive component. This is important in order to get the Reactor
principle to work later.

Save the component eg. as 2 pt adapt box. NB. If you are not doing the
optional material/colour control, you could skip the nesting stage and just add a
third adaptive point into this component skip past the next step and just add a
third adaptive point)

Create another new adaptive component;

Place three points on the origin and along X & Y axes; and make them adaptive
(origin point should be #1);

Link the points with reference lines;

Dimension between points 1 & 3, making sure that you set the reference line as
the work plane

Page 14 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Set the dimension as an instance reporting parameter, called Dist (for distance
from control point)

(optional) Load the 2 point family into the 3 point family;

Place it by snapping on adaptive point 1 and then point 2 just placing the
adaptive point of a nested family onto a point in the host is enough to lock
them together.

Flex the family by moving adaptive point 2 the box should rotate:

Reactor
The component is now ready to have the Reactor capability added:

Adaptive point 1 will control the location of the component;

Adaptive point 2 will control the orientation of the component;

Adaptive point 3 will not actually drive any geometry directly but its distance
from point 1 can be used to drive a formula, which in turn will make the geometry
react in some way. In this instance it could be either the height or the
material/colour of the nested component.

First the nested component needs to have its parameters linked to equivalent
ones in the parent component (Optional only if doing materials/colours nested
component):
Select the component, and add new parameters for each of its dimensions
Height being the most important.

Add a parameter for its Type, from the Label menu on the Options Bar

Page 15 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Family Types

You need to create a new Family Type parameter for each of the different
types in the nested component (one for each colour/material); then assign a type
to each parameter;

To make Revit choose one of these types for each instance that the component is
placed, you need to create a nested if statement formula that relies on an
integer being fed into it. That formula is actually the last step in the process, so it is
best to start at the beginning:

The choice of type has to react to the distance of the control point (adaptive
point 3) from the component in this case the reporting parameter Dist, that
needs to drive a formula. There are various ways to do this the method used
here is a bit elaborate but it sets up a lot of possibilities for ways to control the
reaction.

First a couple of variables need to be defined: a user defined Pattern Length

that defines the overall distance over which the pattern of colours (types) is
spread. Then a preset number of colours (Types)

These variables then need to be converted to a value that can be used to set
ranges of values to compare with the actual reporting parameter Dist.

Next a series of distance parameters need to be set up for the comparison

Then the distance parameters need to be converted to an integer parameter,

eg. Col = if(Dist < d1, 1, if(Dist < d2, 2, if(Dist < d3, 3, if(Dist < d4, 4, if(Dist < d5, 5,
if(Dist < d6, 6, if(Dist < d7, 7, if(Dist < d8, 8, if(Dist < d9, 9, 0)))))))))

Page 16 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

This integer can then be fed into the final formula applied to the original family/
type label that was set up to start with - that assigns it to each type, with a default
value of 0 resulting in the choice of Col_0 if the formula doesnt work out:
Colour_type = if(Col = 1, Col_1, if(Col = 2, Col_2, if(Col
if(Col = 3, Col_3, if(Col = 4, Col_4,
if(Col = 5, Col_5, if(Col = 6, Col_6, if(Col = 7, Col_7, if(Col = 8, Col_8, if(Col = 9,
Col_9, Col_0)))))))))

In the case of controlling just the height (and not the colour), that whole complex
process can be replaced by a very simple formula:

Test that it is working, by flexing adaptive point 3. As it moves further away, the
height and/or colour of the box (nested component) should change.

Using a sine wave calculation

To make this relationship between control point distance and height or colour a
little more interesting, you could try using a sine wave calculation so that the
colour/height pattern repeats itself once the distance exceeds the user defined
Pattern Length parameter:

First the Dist reporting parameter needs to be converted to a numeric value

according to a sine wave calculation
calculation,, dependant on the overall pattern
repetition length. It takes a bit of experimenting to get a formula that gives
workable results. Since the sine function works with angles, the Dist value needs to
be converted to angle units (multiply by 1). The Pattern Length has to be divided
into quadrants of 360, so divide it by 90 first. The number also needs to be
multiplied by 10 so that it is in a range of 1 10 (rather than 0 1)

The result needs to be converted to an integer for use in the Colour_type formula, but
first some of the effects of the sine wave need to be adjusted:

Negative values need to become positive,:

As the number approaches the top or bottom of the sine wave, the wave flattens
out so you get too many values in that zone, so it needs to be balanced out using
an interim number parameter of NumSin =
if(NumPos > 9.5, rounddown(NumPos + 0.1), if(NumPos > 8, rounddown(NumPos 0.8), if(NumPos > 7, rounddown(NumPos - 0.7), if(NumPos > 4, rounddown(NumPos
- 0.6), rounddown(NumPos - 0.1)))))

Page 17 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

and converted to an integer:

IntSin = if(NumSin > 0, NumSin, -NumSin)

A final check to ensure a valid result (positive integers from 1 - 10)

The result can be fed into the final calculation without having to set up a range of
integer parameters as before:
Colour_type = if(Col = 1, Col_1, if(Col = 2, Col_2, if(Col = 3, Col_3, if(Col = 4, Col_4,
if(Col = 5, Col_5, if(Col = 6, Col_6, if(Col = 7, Col_7, if(Col = 8, Col_8, if(Col = 9,
Col_9, Col_0)))))))))

The reactor component is now ready to use in a pattern, but if you want to be really
tricky, you could combine the two calculation methods, with a checkbox to choose
between them:

Page 18 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Part 3 -Practical Examples of the Repeater

Reactor Repeater Pattern
The two previously created components can be combined to create a reactor
pattern on a flat rectangular grid this can be placed on any surface in a project.

Open the rectangular rig adaptive component created previously;

Save its as a new component eg Rectangular

Rectangular Reactor Pattern;

Add another point on the base level work plane; make it adaptive (it should be
point 3) this will become the control point;

Load the 3 point adaptive Box into the rectangular rig component

Place a component starting at the second node of the surface pattern avoid
the first one as it is coincident with the host point on the rig, and you might select
the wrong point;

Place the second adaptive point on an adjacent node to control the

orientation of the box;

Place the third adaptive point on the free control point - off the surface.

The height (and colour) of the box should adjust according to its parameter
values and the distance of the control point.

Flex it by moving the control point (remember not to click and drag as the z offset
will change slightly) it should change the height and/or colour of the box as the
distance changes;

Select the component. Because this is an adaptive component, hosted on a

divided surface node, it will
will now be possible to turn it into a repeater pattern by
clicking on the array icon. The icon looks a little different to normal it has a red
letter P next to it.

Page 19 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

It may take a while to calculate all the adjustments to each component in the
repeater pattern, but it is worth the wait

Adjust the Pattern length parameter, so that the pattern repeats itself. It is
simpler to do this if it is a type parameter. However, it is still possible even if it is an
instance parameter you need to select across the whole pattern, then filter the
selection to just the 3 point adaptive box.

Adjust the pattern length to a value much smaller than the distance between
each node, and youll get a more or less random pattern

Page 20 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Reactor Repeater pattern on curved surface

In a conceptual mass (In-Place or external family) the same reactor adaptive
component can be used on a curved divided surface. You need only show the
nodes and place a component onto them
.

In this example you need to create mass (or adaptive component)

Generate a curved surface, from say two splines.

Add a control point in free space

Place a Reactor 3 point adaptive box component onto two adjacent nodes
and the control point.

Select the component; then click on the repeat icon

Page 21 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

With a curved surface, the vertical direction of the box (its height) is
perpendicular to the surface, so it can give some strange results.

To make this pattern more useful, we could make the box flatter, and derive its width
and depth from the surface pattern. To do this we need to go back to the 3 point
adaptive component and save it as a 4 point component:

First move the control adaptive point out of the way;

Add another adaptive point onto the reference plane axis, and make it point 3
(control point will become 4);

Link it to point 1 with a reference plane;

Add a dimension between the points (1 & 3), and make it a reporting parameter
called Width;

Repeat the process to create a dimension reporting parameter Depth,

between points 1 and 2;

Select the box component and link its dimensional parameters (Length &
Thickness) to the two new reporting parameters; it should change shape to

Page 22 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

match the new Width and Depth parameters

Now we need to replace the 3 point adaptive with the new 4 point component.
Load it into the newly created mass (with repeater pattern)
pattern).. NB if you did not
rename the new component, but just modified it and reloaded, Revit would give
an error message because the number of adaptive points have changed, and it
cannot resolve the hosting on the nodes.

This is where we discover one of the limitations with the repeat command there
is no Dissolve option, so you cannot go back to the original hosted component
setup. What this means is that you have to delete the repeater pattern, and it
deletes the originally placed component. In this example it is not a big deal, but it
can be if you have spent a lot of time setting up a series of different instance
parameters.

Delete the repeater. NB if it is an In-Place mass component, it may not refresh the
screen immediately so you may need to save the mass and edit it again.

Place a new one on the surface points make sure that you do it in the same
order as the point numbers in the component. Unfortunately the orientation of
the box will still be defined as perpendicular to the surface at point 1, rather than
being rotated to attach its bottom face to the 3 points it is hosted on. To resolve
this you would need to create a box that has its geometry
geometry defined by the
adaptive points probably a 5 point adaptive component that would no longer
be rectangular.

Page 23 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Adaptive Star Repeater

The following is a description of how to use the new Divide Path command to make a
parametric flexible star shap
shaped
ed adaptive family in Revit that can be placed on a
surface pattern node.

Creating the rig:

Create a new family using the Generic Model Adaptive template;

Place an adaptive point on the intersection of the two reference planes;

Make the point adaptive;

Set the work plane to the horizontal plane of the adaptive point;

Place a reference line circle onto the adaptive point;

Turn its temporary radius dimension into a real one;

Flex the point up and horizontally to check its hosting to the point has worked
the circle should move up;

Return the point to the reference planes intersection;

Turn the radius dimension into an instance parameter called Radius outer;

Flex the radius parameter to check it works;

Repeat the process of adding a smaller reference circle

circle to the adaptive point;
flex; add a radius parameter called Radius inner;

Save the family as 1 point adaptive star;

Select the outer circle, and click on the Divide Path tool;
It will place divide nodes on the circle (probably 6 of them) at equal spacing; if
the number is not 6, click on the number and change it to 6 (or change it in the
properties dialog box);

Page 24 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Select the inner circle and click on the Divide Path tool; Change its number of
divisions to 12

Draw a series of reference lines b

between
etween the nodes on the outer circle to
alternating ones on the inside one (every other node, but not aligning with the
outer nodes) this should create a star shape. NB. You must enable 3D snapping

for this to work (in the options bar)

When you complete the star it will probably give you a warning about identical
instances of the point this cannot be avoided;

Flex the two radius parameters, and the size and proportions of the star should
change;

Place a point on the middle of one of the lines; If it is properly hosted, it will
display smaller than the other points;

Select the point and change its property Show reference Planes to Always;

Set the Work Plane to that visible plane on the point;

Place another point onto the first one it should give an error message about
identical points (ignore it);

Page 25 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Select the point, and move it up, using the blue arrow

Then move it sideways using one of the orange arrows (but keep it in plane);

Repeat this process 3 times - Place 3 points and move each of them so that they
form a rectangle around the original host point.

Now the points need to be dimensioned to ensure they are equally spaced
around the host point, then width and depth dimension parameters need to be
added. This could be done
done by putting equals dimensions between each pair of
points and the host, and then overall dimensions, but this is quite tricky to set up.
An alternative way is to place individual dimension parameters from the host to
each point; these can then be used in a formula:

Set the work plane to be that of the host point by picking it;

Place a dimension from one of the central lines of the host reference plane to a
point this ensures it is orthogonal (if
(if you dimension between the points it usually
goes off orthogonal). Each point needs a vertical and horizontal dimension.

These need to be parameterised as Half W and Half D (for half width and
depth)

Page 26 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Flex these parameters to make sure that the points move correctly;

Flex the host point location to check that the four points are correctly locked in
the normal direction: Select the host point, and change its Normalise Curve
Parameter to 0.5 it should move along the line, along with its rectangle of
points.

If that is all working, the four points can be joined by reference lines to create a
rectangle make sure that 3D snapping is on;

Go to the Family Types dialog box, and add two more dimension parameters:
Width and Depth; give them values (about twice the Half values);

Add simple formulas to the Half W and Half D parameters:

Half W = Width/2
Half D = Depth/2

Flex the Width and Depth parameters to make sure the rectangle changes size
correctly;

Creating the star:

This is the easy part.
Page 27 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Select the reference lines that make up the rectangle and the star shape

Click on Create Form

You should now have a solid star shaped form

Flex all the dimensions to change the size and proportions of the star.

Hide the node visibility (otherwise they will show when thi
thiss is loaded into another
family):

Select the divided path (circle);

Click on the arrow in the bottom right corner of the Path Representation panel on
the ribbon
;

Make sure the Nodes box is unticked;

Repeat this process for the other path;

NB sadly it is not possible to do this with multiple selections of divided paths;

This process has to be done in the component where the divided surface exists
because there is no control for this in View Visibility once nested into another
family or a project.

Page 28 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Controlling the star proportion:

Now we need to control the proportions of the star:

Add a number parameter Proportion in the Constraints group

Set this parameter to 0.5;

Give the Radius inner parameter a formula:

Radius outside * Proportion so that
that it is now calculated automatically

Try flexing the Proportion parameter. A value of 1 will make it a dodecahedron; a

value of 0 will give an error message, so we need to put in some error checking.

You could modify the existing formula but it is easier

easier to follow and change later if
you create a separate check stage. Add a new number parameter Check ;
give it a formula:
if(Proportion < 0.1, 0.1, Proportion)
Then modify the original formula to use this check instead of the Proportion
parameter: Radius inner = Radius outside * Check. This will prevent negative,
zero and small number values. This will not be totally foolproof as there are various
small number values above 0.1 that will still give an error depending on the
combinations of Width and Radius outside values.

Add a text parameter called Proportion note in the Constraints group. Give it
a formula of "Min. Proportion = 0.1" make sure you put it in double quotes. This
will be a reminder for users that the value will never go any lower than 0.1.

Page 29 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Flex the Proportion parameter to make sure the error checking is working try
values less than 0.1

Select the star and give it a material parameter Star material

Repeating the star as a pattern:

Open the rectangular rig component

component and save it as a new family Rectangular
Star Pattern;

Select the surface pattern, and change its grid parameters:

Fixed distance, say 1000mm

Rotate the grids by 60 & 30 degrees;

Load the 1 Point Star into the family;

Place a star onto a surface grid node;

The distance between nodes should be 1155. Set the Outside radius of the star to
half that distance: 577.5mm;

(Optional) You could automate the link between pattern size a star size:

As the grids are at 30 degrees, the node spacing should be:

Distance between grids / cosine(30)

The radius of the star will be half that. Create a parameter called Star
radius.

Create a Grid spacing parameter for both the Grid distances; link the
surface Distance properties to it.

Create a parameter for Node spacing, with formulas to calculate the

spacing and Star radius

Link the Outside radius to the new Star radius parameter

Page 30 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Select the star and create a repeater pattern from it.

The points of the stars should just overlap each other.

Hide the surface grid pattern and nodes

turn on the original surface visibility too

Test out what happens when the Proportion parameter is changed try values
from 0.1 upwards to see how it changes the pattern radically:

0.1
Page 31 of 70

, but make sure to

0.25

Divide and Conquer Adaptive Components

Tim Waldock, PTW

0.5

0.7

0.88

1.0

1.2

2.0

2.5

3.2

Page 32 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

2 Point Star
The next variation on this theme is to create a 2 point adaptive star that will change
its size dependant on the node spacing on a non-regular grid. This might be
appropriate on a curved surface.

Save the 1 point adaptive star as a new family 2 point adaptive star

Add another point along the X axis;

Make it adaptive

Draw a reference line between adaptive points 1 & 2, making sure you snap to 3d

points

Place a dimension between the two adaptive points, making sure that
you first select the reference line as the work plane

Select the dimension and make it a parameter called Length; make it a

reporting instance parameter

Set the Radius outside parameter to = Length / 2

Open your Rectangular Star Pattern component and save it as a new family
Rectangular 2 Point Star Pattern;

Delete the repeater pattern, and you should be left with just the surface pattern
(although the grid will not be visible);

Make the nodes visible again

Load the 2 point star adaptive family into your new rectangular pattern
family;

Place the star component onto two adjacent nodes it will require two clicks,
since it has two adaptive points;

Notice that it places the star with a radius exactly half the distance between the
two points this is because you set the formula for star size to equal half the
distance between the two adaptive points. So the radius is reacting to that
distance even though its geometry is not directly linked
linked to the second point.

Page 33 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Flex the parameter for Grid spacing (make it half the size, say 500mm) to prove
that the star size changes too. Note that the hosted star will most likely move
dramatically the movement of the host node is mysterious! If you make the Grid
spacing larger, the hosted component will most likely disappear, although it still
exists somewhere.

Revert the Grid spacing parameter to 1000mm, then select the hosted
component and repeat it;

Notice that it does not place repeats o

on
n the nodes that do not have another
spare node adjacent to it in the same direction as originally placed in this case
to the right.

Page 34 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

This is difficult to deal with you could place two more star components on
adjacent empty aligned nodes, with the sec
second
ond point going back in the opposite
direction; when repeated, it will fill in a line of blanks:

The process needs to be repeated for the other line of empty nodes

The only problem with this is that if the length of the repeater changes, it does not
move the end rows they stay where originally placed. This means that the
technique would only work if your surface is set at its final length that will not
change, before you add the end rows.

Another alternative would be to put a single 2 point component on an empty node,

with the second point going back in the opposite direction; when repeated, it will
cover most of the surface, giving an error message about identical
identical instances (every
time the surface extent is adjusted).
Hopefully this problem with missing edge components on a repeater pattern will be
resolved in future upgrades of the software. Likewise there appears to be no way to
prevent overhanging components around the edge voids will not cut into repeater
patterns. You could always select individual components around the edge of a
repeater and swap them for half-versions of the component, which have already
been cut by voids within them but this is a laborious process that would be messed
up as soon as the overall surface grid is modified.

Page 35 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Non-Orthogonal Surface Pattern

Now we will try a similar process but with a non-orthogonal or organic surface:

Create a new generic adaptive family;

Place four points the first on the origin, second along the x axis, third along the y
axis and fourth to make up a rectangle; make them adaptive;

Join them with reference lines (3d snapping on);

Select the lines and turn them into a surface

Divide the surface

Set the surface grids properties as before: 60 & 30 degrees; fixed distance;
distances linked to a Grid spacing parameter

Select point 4 and drag it vertically (z direction) using the blue arrow you may
notice that as soon as the point goes off its base reference level, the U and V grid
rotation angles switch around

In this instance we want the grid to run the other way when it is distorted in the z
direction, so we need to swap the grid angles
angles over: make the U Grid 30, and the
V grid 60 (knowing that it will swap back when it distorts).

Page 36 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Try flexing point 4 in the z direction again, and notice how it the grids curve
around as the surface distorts; the nodes on the grids in one direction (between
points 2 & 3) keep their distance apart reasonably consistent as that curve is less
stretched; the nodes on the other grids (points 1 to 4) are elongated, so the
nodes get further apart. We can use this to our advantage in the next step

Return point 4 back to the horizontal plane notice that the 3d level highlights
when the point gets close, and then snaps to it when you let go

The 2 point star component needs to be adjusted so that its proportion changes in
response to the reporting parameter
parameter distance between points:

Page 37 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Place the star component , making sure that you choose two points that will
adjust their distance apart when the surface is distorted.

Repeat it.

Change the surface representation of the grid: hide the nodes and gridlines;
show the original surface and give it a material with a colour (either by selecting a
material or linking it to a material parameter)

Change the material property of the star component give it a light contrasting
colour to the surface background.

Select adaptive point 4 and drag it up in the Z direction this distorts the
underlying surface and its grid, and hence the length reporting parameter of
each star, which in turn changes the value of the Proportion parameter that
drives the shape of the star.

Page 38 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Part 4 - Space Planning

At RTC 2011, I showed a linear adaptive component that would generate a run of
rooms along a corridor.

Then I issued a challenge to myself to create a curved version. Parametric radial

arrays certainly are a challenge in Revit, so it was not going to be simple. Along
came Divide & Repeat in v2013 and it suddenly became a whole lot easier. In the
linear example shown above, I created an array within a generic line based family,
and then nested it into an adaptive component. The latter step was optional for a
single run, but vital for two linked runs.

With the advent of Divide & Repeat, the array part is better done in the adaptive
component, so the process becomes a little different. However, it is still sensible to
have at least two levels of nesting unless you want to build some complex radial
geometry in the adaptive component environment (only recommended for genii).
You could probably tackle this in a number of different ways, but here is the
approach that I took.
There are a number of steps to be taken, and you need to be sure that the process
will work properly before you embark on the detail of a particular method so it is
wise to do a mock up first, and then convert it to the real geometry. This particularly
applies to such things as:

nesting,
shared families,
linking of parameters,
controlling x,y,z rotation of nested components,
controlling orientation of nested components when adaptive points move,
repeater patterns

For this reason, well start with a simple box representing the room, and then turn it
into the correct shape later on. We will also take a few wrong turns in the process
and then show how to correct them the reason being to show that the simple,
obvious solutions do not always work.
Page 39 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Create Room Object

1. Create a new Generic family;

Add a couple of reference planes to make a rectangular shape; dimension

them and convert them to parameters Width and Depth

Create a rectangular extrusion, locking the lines to the reference planes;

Save the family as Room

2. Create another family from the Generic Adaptive template

Place two points on the origin and along the X axis (snap in a plan view or
place in 3D and align to axis afterwards);

;
Make the two points adaptive
Place a reference line between the points (3D snapping on)

Place a dimension between the points, ensuring that the work plane is the
reference line;

Make the dimension into a reporting parameter called Length (it is probably
wise to make this a shared parameter in case you want to schedule it later);

Flex the adaptive points in all 3 axes to make sure the reference line and
dimension are properly linked

Set the family parameters to Shared, so it can be scheduled later on (NB. You
need to plan ahead as to which level of nesting is the one to be scheduled
and this is probably the best one);

Save the family as 2 pt AC Room Module;

Page 40 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

3. Load the generic Room family into your new 2 point adaptive component;

Place the component onto the origin point;

Flex the second point, and notice that the Room component does not rotate
with the reference line

The obvious solution would be to align and lock the component to the
reference line, or to one of the planes of the first adaptive point but if you try
this, it breaks the constraints as soon as you flex the adaptive points. There
appears to be no way to control the orientation of the nested component;

4. This is where we back-track: delete and purge the Room component;

5. Create a new family from the Generic line based template. The reason for using
a line based family is to control the orientation of the nested family, as it is very
difficult to do so otherwise.

Add a horizontal reference plane to create a rectangular framework;

Dimension it and turn it into a (shared) parameter Module Depth;

Create a rectangular extrusion, locking its lines to the reference planes;

In an elevation view, add a reference plane, give it a height (shared)

parameter Module Height; lock the top of the box to the reference plane;

Save the family as Room Module

6. Load the family into the adaptive component;

7. To place the component, you need to follow a specific workflow exactly,
otherwise it wont work you need to snap the start of the component to
adaptive point 1, and the end to point 2; it is easiest in a 3d view:

It will probably default to Place on Face, which wont work set it to Place
on Work Plane; set the placement
placement plane or work plane and pick the
reference line

Page 41 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

or

Select adaptive point 1 tab several times to get it; then select adaptive point
2 (even more tabs); NB do not snap to endpoints;
endpoints; the component will stretch
to fit the distance between the adaptive points;

Flex point 2 in all three directions (drag the arrows); notice how the component
will rotate to match the direction defined by the two adaptive points, but will
not change its width

We need to link its length to the parent family length. The problem here is that
the line based component does not allow its length to be linked to a
parameter it is greyed out.

8. This requires a fix back in the Room Module family.

You need to add a reference plane and (shared) instance parameter for
Module Width, and align/lock the box to that instead of the right hand
Length reference plane;

Page 42 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Load the family back into the adaptive component and overwrite;

Select the Room Module component, and link its Module Width parameter to
the Length reporting parameter

Notice how it changes width to match the length between adaptive points.

Now it is time to link the parameters for depth and height to corresponding
parameters of the same name in the parent family.

9. Save the adaptive family, and then make a copy of it called 2 pt AC arc
repeater
Create Rig for Repeating Pattern
10. In the copied family (repeater), delete the placed component. You now have a
2 point adaptive component with a reporting parameter for the length.
11. Set the Work Plane as the reference line
12. Place a start-end-radius arc between the adaptive points
13. Temporarily hide the reference line;
14. Align the end points of the arc with the reference planes of the adaptive points
and lock them (both X & Y planes for each end point)

15. Drag point 2 along the X axis to make the length much longer;
16. Select the arc reference line, and turn its temporary dimension into a permanent
one; Give it a parameter Radius

Page 43 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

17. Give the Radius parameter a simple formula =Length. This is a temporary
formula that will allow flexing of the component to work safely until we allow user
input for the radius and add some error checking later on.
18. Select the arc; Click on Divide Path
19. It will create a new Divided Path element
element attached to the original arc, and will
place a series of nodes on the path with editable properties. The number that
appears above the divided path corresponds to the properties number and is
editable in both places

20. The Layout of the divided path could be changed to Fixed Number, Fixed
Distance etc, but cannot be given a parameter leave it for now.

21. Load the 2 pt AC Room Module family into the arc component.
22. Place one onto two adjacent nodes on the divided path arc it will snap to the
nodes provided Place on Face is selected

23. Notice how the component has gone below the horizontal base level plane this
is one of the confusing aspects of the adaptable component environment:

it is very hard to predict or control the x,y,z rotation of elements hosted on points
(or on lines). You can go to Zach Krons Buildz blog and try to understand the
explanations of what is happening with internal coordinates and axes of the
points and lines but it can take a lot of time trying to figure
figure it out. Sometimes it is
just easier to correct the problem by trial and error.
Page 44 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

24. In this case, nodes on a divided path cannot display their own reference planes
or axes so there are a few things you can try to correct the problem:

In the properties is a Flip checkbox. Try ticking it and the box is now above
the base level

We need to check what it has actually done. Go to the Type properties for the
Room Module and change the depth value to see what it has does to the
proportions

Unfortunately it becomes obvious that the Y axis of the nested component is

now aligned with the Z axis of the host family. The Flip command mirrors the
component about its host work plane not useful in this particular situation;

So we need to backtrack into the nested family (2 pt AC Room Module);

Normally a generic or adaptive family will have an Always Vertical family

parameter ticking this would do the trick.
But in this case it does not work because the only model elements in it are
another nested family, and that is Shared so it has its own behaviour, not
affected by its parent. (test it if you like);

So we need to edit the nested family again. However, since this is a line based
family it does not have that property available!

So, back into the two point AC you would need to re-orient the nested line
based component: You cannot just give it a new workplane, but have to

Page 45 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

delete and place it again on the vertical work plane of the reference line;
then relink all its instance parameters (hence tthe
he need to fix the workflow
before the geometry).

The Y axis of the nested component is now aligned with

with the Z axis of the parent,
and the Z axis with the Y axis of the parent.

Load this back into the adaptive arc family and youll see that it has corrected
the orientation back to how it should be.

25. Once we have established that the geometry is in the right orientation here, there
is one more check to do: load the arc family into a project and place one, just to
make sure that there is no further rotation. It should be fine;
26. Now think about linking the Room module component parameters to its parent
again. Youll discover that as they are Type parameters, and it is a shared family,
you cannot link them here.

Youll need to make a choice either change them to instance parameters (in
the next level up), or else rely on changing the parameters in the project, which
would have the benefit of being able to change parameters from a schedule, so
well go with the latter and leave them as type parameters, not linked to parent
parameters.

27. (Optional) At this time you might also create a quick mock-up of a schedule in
the project to check that the information that you need will come through in the
right format.
28. Now it is time to test the repeater patterns:
Create Repeating Pattern
29. The hosted module needs to be turned into a repeating pattern:

In the arc family, select the Room Module hosted onto the arc

Page 46 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Click on the Array/Repeater icon

Flex adaptive point 2 location. The arc should follow the point, getting longer
and flatter; the hosted components should also get wider

Assuming that they represent rooms, it is more likely that well want a specific
room width. Select the divided path (Tab to get it) and change its Layout
property to Minimum Distance. Notice that it reports Path Length and Distance
(Chord Length in this case)

Select the Minimum Distance property and turn it into a parameter Min dist
outside

30. A second pattern needs to be created on the inside of the arc:

Place another component onto two adjacent nodes,

nodes, but in the reverse
direction it will rotate it to the inside of the arc; turn it into a repeater

Page 47 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

This time the rooms overlap. Imagine that they will ultimately become wedge
shaped to avoid overlapping, and it becomes apparent that the rooms on the
inside will be much smaller in area than those on the outside so we need a
different repeater pattern for the inside.

This is easier than expected:

Delete the inside repeater;

Select the original reference (line) arc, and use Divide Path on it again it puts
another path in the same place as the first one.

Set it to Minimum Distance again, but give it a larger value than the outside
one;

Turn it into a parameter Min dist inside

Place a component on the new nodes again. They will be further apart;

This would be a good point to create a different type duplicate it and give it
a name Module Inside;

Rename the other component type to Module Outside;

Turn the inside one into a repeater

31. Test this in a project load and place a couple of examples

32. Create a simple multi-category schedule in the project to make sure it works as
required. NB. The adaptive repeater component will also schedule, so you need
to filter it out

Page 48 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Alternate Repeating Pattern

In reality it is likely that these rooms will have back to back bathrooms, so the arc
family needs to cope with alternating (ABAB) repeater patterns, which is a little more
complicated.
In order to test this and establish the workflow, it will be necessary to create two
different types of room module for left and right (or A and B). At this stage the easiest
way to make them look different is to give them different depths (even if this is not the
desired final layout).

33. Back in the repeater family we need to change tthe

he patterns. Unfortunately in
v2013 there is no way to modify a whole repeater pattern. Even though it is
possible to select and change or exclude individual
individual components in a pattern,
that is of no use here because we do not know how many units there will be in the
finally placed repeater. You have to delete the repeater, and lose any initial
setup work (with instance parameters) fortunately not yet much in this case;

Delete both repeaters;

Select and temporarily hide the divided path for the inside modules;

Place two of the outside components on alternate nodes, leaving a gap

between them

Rename the component type to Outside Type A

Place two more alternating outside components in the gap and the next
available nodes;

Select them both, duplicate the type to Outside Type B

Give them a different depth value

While those two are select, turn them into a repeater;

Page 49 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Select the other two and repeat them. NB. Do not try to select all four and turn
them into a repeater pattern as you would get a different (undesired) result.

Show the hidden divided path, then temporarily hide the new repeater
patterns and their host divided path (it has more nodes than the inside one);

34. Repeat the process of creating two different types in alternating repeater
patterns for the inside arc;
arc; Before you can do this, you may need to flex adaptive
point 2 by dragging it away along the X axis, so that there are enough nodes on
the arc. NB. You may notice that some hosted components may reappear (a
graphics glitch?), even though the repeater is hidden so youll need to hide
them individually or restart the hide process

Name the inside components as Inside type C and Inside type D

Turn them into alternating repeaters as before

Page 50 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Tapered Room Module

Now is the time to convert the room module to a tapered shape. This process will
start simple, and then become increasingly more complex as the shape is refined to
closer match reality. You can stop at various stages, depending on the required
complexity. The tapered room requires angled geometry and the locating of arcs
these are both notoriously diffi
difficult
cult to control. I have found that if you try to use
angled reference lines, it is almost impossible to lock the start and end points of arcs
to them, so this process uses orthogonal reference planes, which are located using
trigonometry. This means that you are doing the calculation work instead of leaving it
to Revit, but it has given me more consistent results and less broken constraints.

Trigonometry
First we need to go over some principles of trigonometry that will be used repeatedly
in creating this tapered component.
If we know the radius of the arc, and the distance between nodes (chord length),
then it is possible to calculate the required angle of room module taper.

Page 51 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

In the right-angled triangle above, we know the hypotenuse (Radius) and Opposite
length (half of chord length), so we can calculate the angle and adjacent side
length using one of the 3 trigonometry formulas (OHS-AHC-OAT) (the latter
calculation could also be done using Pythagoras theorem):

Opposite/Hypotenuse= Sine Angle

Adjacent/Hypotenuse= Cosine Angle
Opposite/ Adjacent = Tan Angle

In this case, the sine formula is appropriate. However, since we dont actually know
the angle, we have to use the reverse calculation Arcsine to get it, so the formula
becomes:
Angle = ArcSine(Opposite/Hypotenuse)
In Revit the arcsine function is asin
By always using 3 letter abbreviated trigonometric terms and a suffix for each
calculation it helps to keep track of multiple calculations. In this case the first
calculation is A. If you break up the calculation, it is easier to read later:

HypA = Radius
OppA = Chord Length / 2
AngA = asin(OppA / HypA)
35. Edit the line based Room Module;
36.

open the family types dialog to start adding formulas

First we need to add the previously described

described Angle calculation this requires
the addition of several instance parameters: OppA (Length), AdjA (Length),
AngA (Angle), Angle (Angle), Radius (Length);

Give a default value to the radius parameter (greater than Module Width)

Taper angle between sides of the module: Angle = AngA * 2

Add the formulas:

OppA = Module Width/2
HypA = Radius
AngA = asin(OppA/HypA)

Page 52 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

37. For better control, all horizontal dimensions should be set out from the centreline
of the room (as this remains orthogonal);

Draw a new vertical reference plane in the middle of the room, and constrain it
with equal dimensions between the Module Width reference planes;
Since the room will now be tapered with a curved outside face, the reference
plane representing the outside depth is used to locate the corners, and will no
longer be an orthogonal measurement. Select the Module Depth dimension
and change it to a new parameter called yB

Place two more vertical reference planes outside of the Module Width;
Dimension these back to the room centreline (not to the outside extents of the
room);
Give the dimensions an interim parameter xB it is better to do this so that a
calculation can later be used to push these horizontally inside or outside of the
rectangular room shape.

Page 53 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

38. Now we need to calculate the values of xB and yB to locate the outside corners
of the room, using another trig formula

Add three new instance parameters,

parameters, and give them formulas:
HypB (Length), = Module Depth
OppB (Length), = sin(AngA) * HypB
AdjB (Length); = cos(AngA) * HypB

These can then be used to drive the reference plane parameters, xB and yB
with simple formulas. Some steps and parameters could be combined into
single more complex formulas, but then it becomes much harder to check or
follow when revisited later.

39. Now it is time to apply this to the geometry. Edit the extrusion;

Delete all four lines and draw two new ones that define the sides of the new
tapered shape;
Align and lock each end point to both reference planes (tab to select end
points) that means eight locks. If you miss this important step the room shape
will not be controllable later.

Page 54 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Draw a Start-End-Radius arc between the bottom two corners, and

immediately click on the dimension symbol to turn its temp dimension into a
real one;

Assign the radius dimension to the parameter Radius

As the end points of the arc are linked to the lines ends, their location is locked,
so the radius should change without disturbing the angled lines.

Draw another arc between the

the outside corners, but this time turn its radius into
a new parameter called Radius outside

Finish the sketch;

40. Add a formula to the Radius outside parameter: = Radius+Module Depth

Page 55 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

41. Flex the component by changing the Module Width, Depth and Radius values.

42.

load the family into the 2 pt AC Room Module;

43. Select the tapered component;

44. Link its Radius parameter to a new equivalent instance parameter of the same
name in the parent family.

45. Save the component and load it into the 2pt AC repeater family. You should see
the modules changing to a tapered shape, but without the correct angles; the
inside modules will also be tapered the wrong way

46. This is because the Radius parameter needs to be linked to the parent Radius
parameter. Unfortunately this is
is not so simple because we had to make the
adaptive room module Radius an instance parameter (it is a shared component
so type parameters cannot be linked)
linked).. This is also where the lack of a Dissolve
command for the repeater is a real pain, because it is not possible to get at the
original components used in the repeaters. There are two ways to tackle this:

Method one (read all of it before trying it!): go to the family browser, and rightclick on the type (Outside Type A), and Select All Instances in Project; The Type
selector will tell you that it has selected multiple types, which seems illogical;
go to the filter, and deselect the repeater

Page 56 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Now it will display the properties for those selected types, and you can select
the Radius, and link it to the parent family Radius
Radius.. The tapered rooms change
angle, and all seems good until you flex adaptive point 2 newly added
repeats do not respect the new angle. Hence you cannot use this method.
Method two: Delete the repeater; place the two components; link their Radius
parameters; regenerate the repeater. This has to be done for each of the four
repeaters. The inside tapered rooms still look wrong

47. Go back to the line based Room Module component, where we need to allow
the room to taper the other way for the inside modules.

Add two new yes/no type parameters Concave & Convex; make
them mutually exclusive by giving one a not if formula of the other

Change the formula for xB to = if(Concave, OppA - OppB, OppA + OppB)

Flex the component by ticking & unticking the Concave parameter, and the
taper should reverse

48. Save and

load the family into the 2 pt AC Room Module;

49. Select the tapered component;

Page 57 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

50.

Link its Concave parameter to a new equivalent Yes/No type

parameter of the same name in the parent family. If you want you can add
Convex parameter with the same not(Concave) formula it wont do anything,
but will make it obvious that it iiss a choice in the repeater component.

51. Make sure that Types A & B are set to Convex (if they exist as types here)

52. Save and

load the family into the 2 pt AC repeater;

53. All being well, the inside modules should now taper the correct way. If not, then
make sure that Types A & B are set to Convex (and C & D to Concave)

54. Flex the adaptive points to make sure that the repeater works
works properly at different
lengths and rotations. At this stage the radius will change with the length.
Note that curvature on the inside modules is wrong, so that needs to be fixed back in
the line based Room Module.

55. This might also be a good time to do some house-keeping.

In Object Styles, create a new sub-category called Space Planning

Select the extrusion and change it to the

the Space Planning sub-category;

Give it a new material called Space planning Room type A; give the shaping
property a colour with 50% transparency;

Convert it to a type parameter Module material;

Link the Visibility property to the Convex parameter

56. Copy the extrusion, and link the Visibility property of the copy to the Concave
parameter;
Page 58 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

57. Edit the extrusion:

Delete the two arcs;

The ends of the two angled lines need to be locked to the reference planes
(the copy process loses those locks) align and lock 8 times;

Redraw the two arcs, but this time make sure the centre points are above the
line, so the arcs curve the opposite way to the originals;
Link their radius dimensions to the appropriate Radius parameters
parameters (Radius for
the lower, and Radius outside for the upper);
Finish the sketch. There are now two extrusions, but only one is visible at any
one time, controlled by the existing Concave/Convex settings all the way
through the nesting process.
Make sure that the height of the copied extrusion is linked to the height
reference plane (again this gets lost in the copy process);
58. One more correction to do on one of the formulas, to take account of the effects
of switching between concave and convex tapering:
Radius outside = if(Concave, Radius - Module Depth, Radius + Module Depth)

59. Save and

60.

load the family into the 2 pt AC Room Module;

Link its Material parameter to a new equivalent type parameter

of the same name in the parent family.

61. Flex the Concave checkbox to ensure that the curvature of the modules changes
accordingly;

62. Save and

load the family into the 2 pt AC repeater;

63. Change the view visual style to shaded or consistent colours;

64. Give each of the four types a different material and colour. Note that the
curvature on the inside modules is now concave

Page 59 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Area Calculation
To find the area of the room modules, we can calculate it as a proportion of the
whole circle area

65. The first step is to put the area calculation in the right place it needs to be in the
shared family ie in the 2 pt AC Room Module (not in the line based Room
Module nested into it).
66.

This does mean that some of the calculations done in the nested family
needs to be replicated in the parent family:

Angle; Radius inside; Radius outside

67. Add some new area calculation formulas in the Room module:

Area of a circle is r (Pi Radius squared). In Revit this is pi() Radius^2

Segment areas are a proportion of the whole circle.

circle. Create a Segment
parameter that can be applied to each radius value

Page 60 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Make sure the Module Area is a shared parameter

This calculation does not work when the tapering is reversed (you get a minus
area), so we need to add an if(Concave) statement you could do this within
the Module Area formula, but
but I prefer to add an interim calculation for clarity:

68. Save & Load the family into the 2pt AC Arc Repeater.

Save & load the repeater family into the test project

Check that the area parameter shows up in the schedule

Adding a corridor component

69. Make a copy of the line based Room Module as Corridor Module this can be
adapted to become a centre-line based curved corridor. Well maintain the
concave/convex controls although we only need a convex version (you could
simplify it by removing them, but youd lose some formulas).
70.

Some changes need to be made to the parameters and formulas:

Rename the assigned material to Space Planning Corridor, and change its
colour;

Rename Module Depth to Half_width, and move it to Others this will

ensure that formulas are changed automatically (it no longer needs to be a
shared parameter);

Add a new shared length parameter: Circulation Width;

Page 61 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Give Half_width, a formula = Circulation Width / 2

Add a new length parameter: Radius inside;

inside; give it a formula =
if(Concave, Radius + Half_depth, Radius - Half_depth)
NB. Just copy the Radius outside formula and swap the minus and plus

Rename Module Width to Chord length, and move it to Others (it no

longer needs to be a shared parameter);

Add a new shared length parameter Circulation Length this will be the
actual arc length along centreline of corridor;

Give it a formula = pi() * 2 * Radius *(Angle / 360)

71. The geometry needs to be changed to match the formulas:

Add a horizontal reference plane below reference line; dimension it as yB

below the line;

Add two vertical reference planes either side of the centreline; dimension
them with a new parameter xC;

Page 62 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

give xC a formula = if(Concave, OppA + OppB, OppA - OppB)

You can copy xB formula and reverse the plus and minus

Edit one of the extrusions; delete the arc on the base line;

Drag the free end points of the lines to the intersections of the new reference
planes (break the constraints);

Lock the ends of the lines to the reference planes (4 x align & lock);

Draw a new arc between the points;

Give it a radius parameter of Radius inside

Finish the extrusion sketch;

Repeat this process for the other extrusion, but with the arc curved the other
way;

Page 63 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

72. An area calculation needs to be added as per the 2 pt AC Room Module:

73. Flex the component to test it;

74. NB. If you find that the arcs misbehave (eg. centrepoint of arc can sometimes
move from one side of the chord to the other, giving dramatic results), you may
need to use a different technique: Instead of using the radius parameter directly
to control the geometry, you can use a dimension parameter to control the
height of the arc above the chord (Sagitta), which needs to use a Pythagoras
based formula something like:
Sagitta = Radius sqrt((Radius ^2) (HalfChordLength ^ 2)).
This same principle can also be used in the room component I have found this
to be a more stable method of controlling arc geometry (but only discovered
after this process was documented here).
75. Change its family property to Shared so it will schedule (NB. important to do this
before next step as it is hard to change later)

76.

Save and load it directly into 2 pt AC arc Repeater family (it does not
need an intermediate nesting via an adaptive component);

77. It needs to be placed onto the adaptive points, so it is easier if you hide all the
repeaters and arcs first:

Set the work plane as the reference line between the two points;

Place its start and end points onto the adaptive points it will not extend the
full length yet;

Flex the adaptive points in all 3 axes to check it is properly hosted

Select the corridor component;

Page 64 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Link its Radius to parent Radius; link its Chord length to Length

78. Now the corridor is overlapping the room modules, so that needs to be fixed,:

Back in the Room Module family, add a horizontal reference plane above the
base line; give it a dimension parameter yC;

Add two vertical reference planes either side of the centreline; dimension
them with a new parameter xC;

79.

Add some new instance length parameters:

Corridor width
(give this a default value of 2000mm);
Half_width formula = Corridor width/2
Radius inside = if(Concave, Radius - Half_width, Radius + Half_width)

Change Radius outside formula = if(Concave, Radius inside - Module Depth,

Radius inside + Module Depth)

Add 3 more length instance parameters, with formulas:

HypC = Half_width
AdjC
= cos(AngA) * HypC
OppC = sin(AngA) * HypC

Page 65 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Add formulas to xC and yC:

xC
= if(Concave, OppA - OppC, OppA + OppC)
yC
= AdjC
(this extra step for clarity and future flexibility)

Now the two extrusions need to be edited, using exactly the same process
used in the corridor component modification, to get the tapered shapes cut
back to the corridor line.

Page 66 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

80. Save and

load the family into the 2 pt AC Room Module;

81. Select the Room module and link its Corridor width parameter to a new shared
parameter Circulation Width;

82.

Load the family into the 2 pt AC arc Repeater;

83. The room modules should no longer overlap the corridor.

84. Flex the component to test it.
85. Load it into the test project overwrite all the parameters and shared families,
including their parameters
86. Notice that the divided nodes are visible. There is no way to hide these directly in
the project, so it has to be done in the repeater family

87. Select the divided path and go to the Path Representation on the ribbon click
on the little arrow
; turn off nodes;

88. Repeat the process for the second path;

89. Save and load into the test project

Page 67 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

User Defined Radius

This step has been left to last because of a bug. We need to allow the radius to be
user defined, but also have error checking to ensure valid values (it must have a
minimum value slightly greater than half the length).

90.

In the 2 pt AC Arc Repeater command, add a new length parameter:

Desired radius

Rename Radius to Actual radius; give it a formula:

if(Desired radius < Length 0.75, Length * 0.75, Desired radius)

You could give the user a bit more control by setting the minimum proportion.
This in itself needs error checking to make sure it never goes below 0.75 (this is a
figure that seems to work, but could vary)

Try flexing the component by dragging an adaptive point. Sadly you will get
an error message that is caused by the if statement this is a bug (new in
v2013). It will not cause a problem in the project only in the family
environment.

This means that you can no longer flex the component by dragging adaptive
points in the family environment.

Load it into the project to test it there.

Page 68 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Double Curved Adaptive Room Modules

Once you have set up the basic principles and building blocks, you can explore all
kinds of variations. In the following example, by creating a new 3 point adaptive
component you can link two curved room modules together you need to load the
2 pt AC Arc Repeater into it and p
place
lace it from point 1 to 2 and then reverse the
direction from point 3 to 2; then the parameters need to be linked to equivalent ones
in the 3 point parent family.

By changing the radius of the first arc it automatically adjusts the second arc radius to
keep the transition tangential. In order to achieve this you need to set up some
reporting parameters to track the angles between the chords (points 1 to 2 & 2 to 3).

To get this working properly, you may need to add some further error checking so
that a realistic radius is set for each segment, in order to maintain a smooth transition.
Page 69 of 70

Divide and Conquer Adaptive Components

Tim Waldock, PTW

Summary
The new Divide Path and Repeat functions open up all sorts of exciting new
possibilities in Revit. The examples shown here are just a small sample of what can be
achieved I have chosen a specific methodology to explore. These commands are
not available in the main part of Revit only within adaptive components and the
conceptual massing environment
environment.. Hopefully that will change in the future, as these
tools are developed further.

Partially built Revit model of a hotel laid out using the curvy space planning component

Page 70 of 70