Doesn’t matter, had array.

Array. Kind of.

I’m taking a break from profiles – yes, already. In particular, that parametric rig took a lot of work, and there was a lot of failing. So much failing. I’m not quite ready to talk about it. But to business - if you’re anything like me, you’re upset that there is no array within the massing environment for Revit or Vasari. Sure, there’s that wee little ‘p’ that allows you to repeat an adaptive component over a divided surface – it’s everyone’s darling right now, but seriously Autodesk come on. Frustratingly (or Tantalizingly, I can’t decide) Revit2012’s array icon in particular remains selectable until you get within arm’s length of any model geometry. All behold the terror:

However, not all is lost, there’s still a way! Ish. By nesting a rectangular (or other-wise) curtain panel, we can create an array-able family that can be hosted onto a divided surface. Then all that is required is the adjustment of the surface in terms of U or V divisions (whatever you like) and the curtain-array will repeat itself. Let’s go through this process using the example that led me to this: an adjustable sine wave.

The premise is simple, and really the most difficult bit is constraining the nested component within the curtain-panel family. I didn’t even use an adaptive component to nest with – it is a generic mass that contains model lines and quite simple parameters. To constrain it, all you need to decide on is which way you want the nested component to point, and then give the curtain panel some basic flexibility so that it can be read and adjusted adequately when applied to the divided surface.

So, after having decided which direction your nested component/family is going to point, you need to provide a reference plane to place it on. Using a curtain panel family (rectangle - just to keep it simple at this stage), you can place points at the midlines of the system reference frames and link via spline by points. It’s important to remember that these panel families are adaptive components, so your parameters and variables will need to always come back to the adaptive points, otherwise you’re going to have issues with things not constraining properly and blowing out.

You then need to provide an adaptable dimension, so that the length of your panel, and the length of your nested component/family can flex with a divided surface. You’ll need to build this parameter into your nested component/family. In the curtain panel, it’s simply a case of providing a reporting length/width parameter that you can link to the nested parameter. Constrain it to the reference plane, and one end to a desirable end (you can use the strong system plane for this).

Make sure you flex this one, it’ll most likely take a couple of go’s to get it functioning properly, but it seemed to work well for this simple sine wave rig. You can also rotate the divided surface by 90deg (in this example anyway) to get things pointing in the right direction.

Cons:

Unfortunately, due to the nature of this nest-host family relationship (and the fact that no elements can be part of a group), you can’t have ‘instance’ parameters to control everything placed on the divided surface. Your length/width (the reporting parameter) can be, but this is ultimately driven by the surface anyway. The nested family/component needs to be selected while on the divided surface, and variables adjusted with ‘type’ parameters. This is slightly frustrating, but in all honesty this is a hack and is imperfect in any case.

profiling

In my previous post, I made reference to the complications involved in profiles used for lofting…

When you get a little more advanced with this particular routine, you want to be able to adjust your profiles in place, so that you can control certain aspects of your design in ‘real-time’. I’m going to start using a project I’ve been working on as an example of the why, and hopefully describe the how. Let’s start with how a profile can be constructed.

Arcs and lines are a good starting point, because they allow you to come to grips with what it is you’re creating. As lofting tools, they are also quite stable and easily adjustable. Spline by points are also excellent to use for lofting, because they create smooth, flowing masses, which is all the contemporary faaaashin (Melbournite twang inclusive). But they are a little more unstable (this is something I'll post about later). A couple of basic rules:

1. You need at least two splines if you want a solid mass from a profile – you can’t link a single spline head to tail;
2. You need to find some way to constrain them, otherwise you’ll have difficulty in adjusting them if/when you need to.

Constraining spline by points is a tricky business, because you need to have some kind of rig or controller. I dealt with that in two different ways, that were dictated by the stage of the project. Each offered a different way of adjusting, and VERY different level of complexity. Let’s start with the simpler of the two – the 'reference rig'.

It’s shape was determined by site constraints and maximum floor plate size, and it consists of reference lines that are straights and arcs, all drawn on the default ‘level01’ of the mass file. The rig is easily adjustable, can be scaled, stretched, rotated etc etc. The spline by points (model lines) are then ‘drawn’ over the top, and flexes with the reference lines. Additionally, model lines are constrained to the front/back, left/right system reference planes, so that the profile can be positioned at the centre of the collector mass. Boomtown.

This 'reference rig' profile approach is excellent for quick mass studies that still allow a kind of flexibility – the profiles can be constrained to levels within a 'collector' mass, which means that you can control the area and height with relative ease. But what about a more developed design approach? What about adjusting your mass within the project, instead of within the mass environment? For that, we need to look at the second and more complicated profile - the 'parametric rig'.

(note: A general knowledge of adaptive components and how they work would probably be useful at this point…)

In this profile, there is a lot of complication in controlling some very basic, but specific functions of curves in relation to offsets. Simple trigonometry to determine where arcs should begin and finish, very quickly turned into a bit of a nightmare as this rig type was developed. Let’s have a bit of a look…

First of all, the profile required a structure of nested file relationships. It was necessary to have a few flexible nested families that could drive the profile family by providing points that a spline by point could be drawn on - one to control the arcs, and the other to control the straight lines. These are adaptive components, and required a divided surface to be placed on.

The overriding dimensions were length and width, as these would denote the location of the arcs' respective apexes. The placement points for the adaptive components are adjusted by reference lines that are driven by the afore mentioned nightmare-ish trigonometry. Thank sweet baby jesus that adaptive points love nodes.

In a quick overview, you can see how a few parameters can turn a simple ‘diamond’ shape profile with fillet corners, into a wild dance of adjustable reference planes and adaptive component families. Adjusting where an arc should begin and end, in relation to its radius and offset, mean that you need to supply it with this information at all four corners, in order to get it to work parametrically. Then, as with the first example, it’s simply a case of drawing over the rig points with splines by points.

So. That was heavy, and possibly I’ve raised more questions than answered. But what I want to focus on next is why these profiles don’t work – believe me it took a while to get these rigs to function, and I had a lot of questions that I couldn’t find answers to. 

My next post will be about trying to answer some of these questions (hopefully that's why you're here), as well as maximizing the success of profiles, and achieving lofting routines in a more stable manner. Chur.

do you even loft bro?

Entree

Lofting is really an evolution of older massing routines that used to be commonplace within Revit before the advent of exclusive massing and massing (adaptive, curtain panel etc) component files – namely sweep, blend, and swept blend. Now however, these functions are relegated to the component section of Revit project files, and are not strictly massing tools, but more family creators in-project. There, history lesson done.

So let’s talk about lofting as a more specific act of creating a mass. The principle is simple: draw two or more profiles at a relative distance, and then connect them via an extruded mass that ‘blends’ one profile to the next. Simple enough? Good.

So what happens when you want more complex profiles? Well, in short, your hurdles and sensitivity to failure increase exponentially, exacerbated by any large variables in your lofting profiles. Let’s discuss.

 

The Meat

I’m going to really give two examples here;

The first is creating a loft along a reference line, to which you can ‘host’ profiles and then create your mass along that path. It can be thought of as a complex ‘swept-blend’ – except that you’re using more than two profiles, and the opportunity for a more complicated path is exploited. Very simply like this:

The second seems more simple at first, but actually is quite difficult to get a firm handle on. In principle, it is a series of profiles that are hosted to reference planes and/or levels. These profiles can be created within the mass file ad-lib, or nested as external files that contain model lines.

In this example, I’ve used ‘spline by points’, which are great because they’re controllable through the points placed. They are a series of nested profiles, so that I can control the complexity of the mass in a more indirect way, and can keep the ‘collector’ mass file a little bit tidier. If I want to adjust a profile, I simply open that profiles *.rfa, adjust the underlying reference lines (I’ll do a post later about how to best do this), and then re-load into the collector. The mass will adjust itself and voila, job done. You’ll find that sometimes the mass will break when you re-load the profile, and this is more commonly because you’ve deleted a line and redrawn it (the specific line ID can no longer be seen by the mass), or the line complexity has changed so much that the mass can’t ‘flex’ itself adequately. 4 times out of 5, you can just select the lines again and recreate the mass. But that 1 time out of 5 you’ve done something it can’t reconcile, and that means you have to put your investigation hat on. And it’s an ugly, ugly piece of headwear. If you’re going to commit to a life of conceptual massing in Revit and Vasari, get used to this:

Dessert - But sir, it is only wafer thin

The reasons why they fail are many and varied. I’m going to use a project I’ve been working on for a while as a case study for going through these over a number of posts – it’s important that you understand it’s a collection of things, and that using Revit / Vasari is a frustrating and imperfect experience. In this blog, the word ‘hack’ is going to feature quite often, and I will be offering less than ideal solutions that are, to put it simply, necessary.

 

I realise that I’ve covered some basic fundamentals here, but this blog is really for exploring the more advanced aspects of creating parametric models in Revit / Vasari. It’s necessary to set this up in order to cover some more complicated issues. It's also important that the views of this blog are chiefly concerned with the implementation of these programs as tools - in no way should the act of creating parametrics replace the role of design.

In the immortal words of Cyberdyne Systems model 101, I’ll be back.