Grasshopper Workshop

Day 2
Working on large projects often involves dealing with discontinuity, either because
several people are involved or because a single person works on the project
intermittently. It is therefore important to keep Grasshopper algorithms easy to
understand regardless of whether or not the user is familiar with them. While good
documentation of a file can go some way towards achieving this goal, it should be
considered to be the last resort. Ideally an algorithm is self explanatory. To achieve
this, algorithms need to be both clean and small, and sadly neither property comes
naturally to node based editors such as Grasshopper.

On this day each participant will be working on their own design project. By
adhering to certain rules regarding naming and formatting, each distinct step in
each individual project will become fungible with the respective step in any other
project.

Rather than creating a single file containing all the logical steps, and rather than
nesting files through clusters, the entire process will be split into six distinct * . gh
files, placed in sequence much like the beads on a necklace. The role of the cord
which strings together adjacent beads will be played by * . ghdata files, making it
possible to store computed results. These cached results allow for later files to
build on the hard work done by earlier files.

9ep14•t Stepl .ghdat.

Step3gh StepY9hdata

Step4.gh 9ep4.ghdata

*ep2.gh

StepS.gh

The exercises for today are designed to allow for greater freedom. Participants can
choose a difficulty level appropriate for their skill, or revisit topics they do not fully
understand.
Exercise 1: Writing Data

This exercise will introduce the mechanism by which a * . gh file can write data to
the disk. This allows us to separate not just different portions of an algorithm into
different files, but also to separate the algorithm and its computed results.

Each participant must draw a single, closed curve which represents the boundary
of an urban plaza or park. The curve must be fully within a 50mx 50msquare,
anchored to the world origin (0, 0, e).

In addition to the boundary, one or more curves must be drawn that represent
pedestrian paths through the park. These curves may be open or closed, many or
few, simple or complex.

Both the boundary curve and the path curves will be written to a data file called
Stepl .ghdata using the . component.

Goals:
1. Reference geometry from Rhino into Grasshopper
2. Internalise data to sever dependencies
3. Store results in a specialised file format

Components:
Curve Circle parameters
Data Output component

Boundary

Boundary
Paths Paths
Step 1
 'i

Exercise 2: Grid building

There are three reasons for using digital tools inside a design process; automation,
validation and computation. Tedious work can be eliminated and made more
reliable by relegating it to computers, and creative work which defies automation
may be checked for correctness by a computer. Lastly, certain processes are simply
too difficult or slow to do them by hand at all.

The last category is both very enticing and very dangerous. Legal and professional
responsibility for the correctness of a design remain with the human, yet every
decision made through computation weakens the designer's grip and
understanding of the end result.

Each participant will design a base grid onto which they will anchor their design.
The base grid is required to contain somewhere between one thousand and ten
thousand nodes, ideally with some control over the point density in the form of a
slider. A large amount of computation is encouraged, but crucially someform of
validation must be present as well. For example the detection of excessive or
insufficient local density.

Goals:
1. Using computation as part of a creative process
2. Validating data and highlighting violations

Components:
• Depends on the choices made by each participant

c
S

Ey DI
g Grid
c Step 2

0
p
Exercise 3: Path Clearing

Removal of unwanted data points is often a key step in computational processes.

Invalid, corrupt, or illegal values as well as statistical outliers must be excised
before the next step can be taken. Grasshopper provides many ways of doing so,
but this exercise focuses mostly on the cullingapproach which is good for removing
specific items from a list without leaving gaps.

Using the output data from exercises 1and 2, all grid points outside the design
boundary and all grid points too close to path curves must be removed.

The output of this file must be the reduced set of grid points.

Goals:
1. Fetching data from specialised file formats
2. Removing unwanted data using boolean or scalar thresholds

Components:
component
O Curve CP , Pull Point components
or other arithmetic comparisons
Cull Pattern Cull Index

Points
Step 2 Step 3

Boundary TODO: Remove points

Paths close to paths.
Step 1
Exercise 4: Random Clearing

Randomness is a strong form factor in the natural world and many post medieval
design schools make allowance for this. It is technically impossible for
deterministic machines such as digital computers to behave in a truly random
fashion. Instead computers provide pseudo-randomness which has the benefit of
looking random enough to humans while being fully reproducible.

Every sequence of pseudorandom numbers eventually starts repeating itself after a

couple of million or billion iterations. This is rarely a problem since sequences used
in design tend to be much shorter. Rather, problems with pseudorandom numbers
stem primarily from the incorrect use of integer seedvalues. Everyinteger yields a
unique random sequence, and related integers yield related sequences. If one is not
careful about seed selection, the not-really-randomness may become very
noticeable.

Instead of removing well defined grid points from their design, the participants
will reduce the remaining point population by culling items in a random fashion.
The participants may use design boundaries and paths from Exercise 1 if they so
wish, but this is not required.

Goals:
1. Understandingpseudorandomnumbers
2. Using randomness as part of a design process

Components:
Random Jitter components
Sort component
Cull Pattern SubList components

Boundary Q
Q Paths
Step 1

Step 3 R L Reduced
s Step 4

0 2500
Exercise 5: Categorising Data

In addition to removing unwanted data, splitting data into two or more separate
streams is an equally useful skill. This can be a far more complicated process,
especially if the data is only decoupled temporarily and must be recombined again
in the same order at some later stage in the process.

Grasshopper provides two components specificallydesigned for the separation and

recombination of data. These components make up the sift...combinepattern, which
is closely related to the if...then...elsepattern common to textual programming.

The key difference between sifting and culling is that sifting leaves gaps where
items have been removed. It then becomes possible to merge two or more sifted
data streams again by slotting items from stream B into the gaps of stream A.

Other methods for splitting data tend not to leave gaps but may nevertheless be
more apposite in certain cases.

In this exercise the remaining grid points will be divided into two categories; A and
B. Category A will contain approximately 80% of the population, with the
remaining 20% being allocated to category B.

Goals:

1. Splitting data
2. Cleaning data

Components:
or components
Sort and components
Clean Tree

Step 4
Step 5

resh 0 0.2
Exercise 6: Populating The Grid

Complicated shapes require more memory for storage and more time for display
than simple shapes. It can be easy to slow a computer to unworkable speeds by
generating large amounts of complex data.

One solution is to break a large project into smaller fragments. Designing a facade
system for a high-rise is much faster if the project model is limited to just two
floors, rather than fifty. Using the data file mechanism discussed today, various
representations of a project with varying levels of detail or completeness can be
generated and worked on.

Another solution is to delay the use of complex shapes as long as possible. A

building structure can be represented with simple lines rather than complicated
beams and girders. It may be possible to do most of the required processing using
just this simple line data. This has been the approach of today, where instead of
genuine design elements (trees, plants, benches, bollards, Hesburger kioski,
lakritsijäätelö stands ...), every element has been represented by a single
placeholder coordinate.

In this exercise the points from both the A and B categories will be replaced by
design elements through various transformations of template shapes. Shapes will
need to be positioned, oriented and possibly scaled atop each remaining point.

Goals:
1. Becomingfamiliar with geometric transformations
2. Transformation multiplication
3. A fleeting acquaintance with the concept of fields

Components:
Move Rotate Scale and components.
Line Charge Point Charge Spin Force
MergeFields Evaluate Field
Align Plane components.
Compound transformation component.