Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
An open-source research platform for funicular form finding based on COMPAS
RhinoVAULT 2 (RV2) is an open-source research and development platform for funicular form-finding built with COMPAS, a Python-based framework for computational research and collaboration in Architecture, Engineering, and Digital Fabrication. More information about COMPAS is available here.
RV2 has a Rhino plugin that replaces RhinoVAULT for Rhino versions 6 and above. Unlike RhinoVAULT, RV2 no longer relies on Rhino for its computational implementation. Instead, it is built entirely with open source packages from the COMPAS ecosystem and will, therefore, be available not only for Rhino and Grasshopper, but also for Blender and other tools with a Python scripting interface, and ultimately even in the browser.
The core functionality of RV2 is based on the following COMPAS packages and can be used in any environment that supports Python.
Base data structures
File support
Numerical solvers
Geometry processing
Form, Force and Thrust Diagrams
Horizontal equilibrium
Vertical equilibrium
For the design of force patterns in Form Diagrams, we use
Pattern design based on topological features and placement of singularities in quad meshes.
Pattern design based on line skeletons.
Pattern design based on Constrained/Conforming Delaunay Triangulations.
CAD integration packages make this core functionality available in specific software like Blender or Rhino. The current release of RV2 provides only a plugin for Rhino (Blender and Grasshopper integration is under development and will be available soon):
Geometry and data structure conversions.
Drawing functionality.
Selections and interaction.
Remote Procedure Calls
The Rhino plugin is implemented as a CommandPlugin. In the current release, the following commands are available:
RV2boundary_boundaries
RV2boundary_openings
RV2boundary_supports
RV2clear_all
RV2cloud_check
RV2cloud_restart
RV2cloud_shutdown
RV2file_open
RV2file_save_as
RV2file_save
RV2force_attributes
RV2force
RV2force_modify_edges
RV2force_modify_vertices
RV2force_move_vertices
RV2form_attributes
RV2form
RV2form_modify_edges
RV2form_modify_vertices
RV2form_move_vertices
RV2form_relax
RV2form_smooth
RV2init
RV2pattern_attributes
RV2pattern_delete
RV2pattern_from_features
RV2pattern_from_lines
RV2pattern_from_mesh
RV2pattern_from_skeleton
RV2pattern_from_surface
RV2pattern_from_triangulation
RV2pattern_modify_edges
RV2pattern_modify_vertices
RV2pattern_move_vertices
RV2pattern_relax
RV2pattern_smooth
RV2pattern_subdivide
RV2redraw
RV2settings
RV2thrust_attributes
RV2thrust_modify_vertices
RV2thrust_move_supports
RV2tna_horizontal
RV2tna_vertical
Each command has a corresponding xxx_cmd.py
file. All command files have the same structure. For example, one of the simplest commands is RV2redraw
, which is defined in RV2redraw_cmd.py
Using a JSON config file, commands are then organised as menu items and toolbar buttons and compiled into a Rhino User Interface file (*.rui
). This is the file you loaded into Rhino during the installation process.
By initialising RV2, the COMPAS functionality is loaded and the commands are made available. At the same time, a server is started to run commands that require specific CPython functionality "in the cloud" through remote procedure calls.
The development of RV2 is hosted on Github and is entirely open source. The public repository is available here: https://github.com/BlockResearchGroup/compas-RV2.
Note that this is also the place where you can contribute to the development, report issues, or submit feature requests.
The current release of RV2 aims at providing similar functionality as the original RhinoVAULT plugin with the same workflow.
Integration of various force layout mechanisms through pattern design and modification.
Form, Force, and Thrust Diagrams re-implemented as half-edge data structures for more flexible and robust topological operations.
Automatic updating of unsupported boundaries.
Weighted horizontal equilibrium calculations (in pure Python).
Dynamic visualisation of horizontal equilibrium calculations.
Force scaling based on target heights.
Iterative vertical equilibrium calculations with automatic self-weight updating.
Form/Force Diagram geometry constraints.
Horizontal force constraints.
Internal openings.
Internal supports ("Drop-downs").
RV2 session files for saving and loading design sessions.
Synchronized topological operations on Form and Force Diagrams.
Integration of tension members.
Assignment of additional/live loads.
Lumped stress visualisation.
Interactive inspection of the topological relation between the diagrams.
Future releases will focus on the integration of recent recent at the BRG related to funicular form finding. This includes the following.
Automated force distribution finding based on target surfaces ("Best-fit").
Automated pattern modifications for live load cases.
Assignment of force distribution templates.
The relationship between: the compression equilibrium shape, the thrust network or the "thrust diagram" (G); its planar projection (primal grid Γ, or the "form diagram"); and the reciprocal diagram (dual grid Γ*, or the "force diagram" ).
The workflow of RV2 is based on the theoretical framework of TNA, which can be broken down into 7 main steps.
A Pattern
describes the topology of the FormDiagram
. A Pattern
is a collection of vertices interconnected by lines or "edges". RV2 provides several methods for generating a Pattern
and various mechanisms to modify and refine its geometry.
In this step, additional information is added to the Pattern
, such as identification of the support vertices and refinement of the geometry of the unsupported boundaries.
Once the support vertices have been defined and the boudaries have been properly modified, the FormDiagram
can be created from the Pattern
.
Once the FormDiagram
has been successfully created, the ForceDiagram
can be created. In its initial state, the ForceDiagram
is the topological dual of the FormDiagram
; the two diagrams are not yet reciprocal.
In order for the FormDiagram
and the ForceDiagram
to be reciprocal, the edges of one diagram needs to be perpendicular to the corresponding edge in the other diagram. Horizontal equilibrium solver iteratively repositions the vertices of the FormDiagram
and/or ForceDiagram
until the perpendicularity criteria (within desired angle tolerance) is met.
Once the FormDiagram
and ForceDiagram
are reciprocal (in other words, in horizontal equilibrium), the geometry of the ThrustDiagram
can be computed. The ThrustDiagram
is equivalent to the FormDiagram
with the updated z coordinates of its vertices (therefore updated self-weight at each vertex).
Given a desired target height of the eventual ThrustDiagram
, vertical equilibrium solver iteratively re-scales the ThrustDiagram
in the z-axis, until the highest vertex of the ThrustDigram
lies at the desired target height.
Once the vertical equilibrium has been computed, the geometry of the ThrustDiagram can then be used to develop materialisation and fabrication strategies.
There are three ways to access the functions and features of RV2:
the Rhino command line (all funcionalities and features available)
UI: the RV2 dropdown menu (all funcionalities and features available)
UI: the RV2 toolbar (most funcionalities and features available)
Any of the three methods can be used to use RV2, and th interface of choice is simply up to the user's preference. For this workshop, the dropdown menu and the toolbar will primarily be used.
Simply start typing RV2_...
in the Rhino command line, and you should see a dropdown list of all the available RV2 commands.
The RV2 menu is organized in the sequential order (0, 1a, 1b... 6, from top to bottom) of the steps of the RV2 workflow. The RV2 menu includes all available functions and features of RV2.
The RV2 toolbar is organized in the sequential order (0, 1a, 1b... 6, from left to right) of the steps of the RV2 workflow. The RV2 toolbar includes most of the available functions and features of RV2. It is the "condensed" kit of parts for the entire RV2 workflow, and offers the user a quick access through the command line, to all the key features of RV2.
This first tutorial highlights and describes the main features of RV2. This tutorial is intended to be a “quick start” guide of the main steps and procedures of the RV2 workflow. Specific parameters and optional features will not be addressed in detail. Further information about each of the procedures, methods and various optional parameters involved in each of the steps will be presented and discussed later in the week.
This first step initiates the RV2 engine, imports all the relevant packages and activates compas_cloud
server. The startup window also provides various links to useful information, such as the online documentation, tutorials, tutorials and terms of use. By clicking “YES,” you acknowledge that you have read and understood the Terms and Conditions, and the Data Donation Agreement.
A Pattern
is a collection of lines that define the topology of the form diagram. In this step, the user can create a Pattern
from:
Rhino lines
Rhino mesh
Rhino NURBS surface (untrimmed)
skeleton
triangulation from boundary curves
quad mesh from boundary curves and point features
In this tutorial, we will use a simple orthogonal surface, which can be created through the Rhino command, “Rectangular plane: corner to corner.” By choosing two corners, create a planar surface that is a square in plan.
In the RhinoVAULT 2 drop down menu, select “Create pattern”, then “From Surface.” Select the the surface in the viewport.
This command will generate a Pattern
from the input surface, using the UV mapping of the surface. The user has the option to enter values for “U” and “V.” For this tutorial, we keep the U and V to their default values of 10.
RV2 provides various mechanisms for modifying the geometry of the pattern, such as moving vertices, changing attributes of vertices and edges, smooth and relax. These features will not be used in this tutorial.
Once a Pattern
object has been generated, the boundary conditions will need to be defined. In RV2, the boundary conditions include: 1) identifying the supports (vertices of the structure where reactions are allowed); 2) defining and updating the openings; and 3) loading parameters and conditions.
In the RhinoVAULT 2 drop down menu, select “Define Boundary Conditions”, then “Identify Supports.”
The command will provide two options, to select or unselect vertices to define them as supports or not. Click 'Select'.
In this tutorial, we use the mode ByContinuousEdges, and select one edge on the left boundary and on edge on the right boundary of the pattern. Once the two edges are selected, press Enter, then all the vertices along that boundary from corner to corner, will be automatically selected (supports are shown in red).
The second step of defining boundary conditions involves updating the geometry of the openings. In this tutorial, the two boundaries at the top and the bottom are the openings (the edges are on the boundary of the pattern but have no support vertices along them).
Because openings have no supports (i.e. reaction or external forces), they cannot be straight; openings need to curve inward towards the center of the pattern, so that horizontal equilibrium can be resolved.
In the RhinoVAULT 2 drop down menu, select “Define Boundary Conditions”, then “Update Openings.”
If there are straight openings found in the pattern, an automatic sag of 5% of the span of the opening will be imposed. Per opening, the user has the option to enter a desired amount of sag, as a percentage of the span of the opening.
In this tutorial, sag of 10% is applied to opening 1, and sag of 20% is applied to opening 0.
Once the boundary conditions have been defined, the Pattern
can now be converted into a FormDiagram
.
In the RhinoVAULT 2 drop down menu, select “Create FormDiagram.”
If the creation of FormDiagram
is successful, it will be displayed with green vertices and edges. The ThrustDiagram
is also automatically created (displayed in light green), the geometry of which is equivalent to the FormDiagram
at this initial, vertically un-equilibrated state.
Once the FormDiagram
has been created, the ForceDiagram
can now be created.
In the RhinoVAULT 2 drop down menu, select “Create ForceDiagram.”
The ForceDiagram
will be automatically drawn to the right (+x) of the FormDiagram
. The initial ForceDiagram
is the topological dual of the FormDiagram
. The two diagrams are not yet reciprocal, meaning that the corresponding edges in the diagrams are not perpendicular to the other.
When the diagrams are not yet reciprocal (in other words, not perpendicular-ised or “equilibrated”), the edges with angle deviations above the defined angle tolerance will be displayed. The dots displaying the angle deviations are visual cues for the user, indicating that horizontal equilibrium has not yet been resolved.
Once the FormDiagram
and ForceDiagram
have been created, the horizontal equilibrium algorithm perpendicular-ises either or both diagrams, which converts them from dual to reciprocal diagrams.
In the RhinoVAULT 2 drop down menu, select “Horizontal Equilibrium.”
Under “Alpha” option, the user will be able to select a value that determine which of the two diagrams will have more weight during the perpendicular-isation process. Default is “form100,” which only allows the ForceDiagram to update in its geometry. User can also enter the number of iterations. Default number of iterations is 100.
If horizontal equilibrium has been found, meaning that all the corresponding edges now have angle deviations that are below the defined angle tolerance, the two diagrams should no longer have any dots displaying the angle deviation values, as shown below.
With the FormDiagram
and ForceDiagram
now reciprocal, the coordinates of the ThrustDiagram
can be iteratively computed based on a desired z-max (target height) value.
In the RhinoVAULT 2 drop down menu, select “Vertical Equilibrium.”
The user can manually enter a desired value for the target height of the vault, and the number of iterations for the algorithm. Default number of iterations is 100.
If the vertical equilibrium is successfully computed and found, the new ThrustDiagram
will be displayed, now with updated z coordinates.
Under “Settings,” various global parameters and visualisations options can be modified.
There are several features that facilitate analysis and enhance visualisation.
In Settings > RV2 > show, checking "Forces" draws the edges of the ForceDiagram
with a color gradient from blue, green to red, based on its the length (the horizontal force in the corresponding edge of the ThrustDiagram
). The corresponding edges in the FormDiagram
are also displayed with the same color, which makes the two diagrams much more legible and discernible (blue means smaller horizontal force, red means greater horizontal force).
With “Display Pipes,” the edges of the ThrustDiagram
can be visualised with pipes, the radii of which are proportional to the internal forces.
During the RV2 workflow, there may have been unintended modifications to the geometry of the diagrams, such as accidentally moving the vertices. In such cases, running the RV2redraw
command will simply redraw the three diagrams withouth executing any command.
When a work session has ended, and the user wishes to start a new file/design, RV2clear_all
command will delete all existing diagrams in the work session.
During any stage of the RV2 workflow, the three diagrams can be saved as .rv2 files. These files can be opened in the future, and the user can resume working with existing diagrams and resuming work where the user left off during the last session.
Skeleton is a new powerful feature of RV2 that enables fast and interactive generation of complex patterns. This example presents how to use the From Skeleton
feature to generate the topology of pattern.
Skeleton features in RV2 are part of the compas_skeleton package.
First, initialise the RV2 engine.
From Skeleton
takes a set of conencted lines as the input (not polylines). In Rhino, draw a network of connected lines, something like what is shown in the image below.
In the RhinoVAULT 2 drop down menu, select “Create Pattern”, then “From Skeleton.” Select the network of lines.
There are three main parameters of the skeleton that will define the overall shape of the pattern. For the first parameter, the user will need to interactively define how wide the pattern is going to be at the leaf vertices. Using the mouse, simply click at the location that is suitable for the size and shape of the skeleton.
For the second parameter, the user will need to interactively define how wide the pattern is going to be at the interior vertices.
For the third and the last parameter, the user will need to interactively define the inclination of the edges at the leaf vertices.
Once the three main parameters have been defined, the user can explore various other skeleton features, which can facilitate in refining the skeleton further. In this example, we will use just the Subdivide function, which automatically subdivides and smoothes the pattern. Subdivide function can be applied repeatedly. Merge function un-subdivides the pattern.
In this example, Subdivide function was applied twice.
Once the pattern has been successfully created, the boundary conditions need to be defined.
In the RhinoVAULT 2 drop down menu, select “Define Boundary Conditions”, then “Identify Supports.”
By using the vertex selection mode ByContinuousEdges, select the edges at the leaf vertices, which we will define as the supports of the vault (shown in red).
In certain applications, additional refinement and tweaking of the opening geometries (and relaxation) can improve the speed of the equilibrium algorithms later on in the workflow. However, Update Openings is not applied in this example.
Once the boundary conditions have been defined, the Pattern can now be converted into a FormDiagram. ThrustDiagram is also automatically generated (shown in magenta).
In the RhinoVAULT 2 drop down menu, select “Create FormDiagram.”
Once the FormDiagram has been created, the ForceDiagram can now be created.
In the RhinoVAULT 2 drop down menu, select “Create ForceDiagram.”
Once the FormDiagram and ForceDiagram have been created, the horizontal equilibrium algorithm perpendicular-ises either or both diagrams, which converts them from dual to reciprocal diagrams.
In the RhinoVAULT 2 drop down menu, select “Horizontal Equilibrium.”
With the FormDiagram and ForceDiagram now reciprocal, the coordinates of the ThrustDiagram can be iteratively computed based on a desired z-max (target height) value.
In the RhinoVAULT 2 drop down menu, select “Vertical Equilibrium.”
Generating patterns from Rhino objects
In RV2, three types of Rhino geometries can be used to generate a Pattern
. These pattern generation features would be particularly useful when there is already an existing structure with a geometry that one would like to recreate the pattern for.
Photographs and diagrams of different rose windows with complex mullion geometries, showing from left to right an outside picture, the equilibrated and piped form diagram, and the reciprocal force diagram: (a) Notre Dame de Mantes, France; (b) Notre Dame de Chartres, France (Photo by Holly Hayes); (c) Durham Cathedral, England (Photo by Carcharoth on Wikipedia); (d) Notre Dame de Paris, France (Photo by Ellen Brown); (e) Bisshop’s Eye of Lincoln Cathedral, England (Photo from Cornell University Library); (f) Sainte-Chapelle Paris, France.
One of the simplest, and the most manual, way to make the Pattern is to draw the edges of the Pattern
as Rhino lines. Each edge of the Pattern should be an individual line; all lines should be broken at all line intersections. In other words, these lines may not be overlapping.
Pattern
is a COMPAS mesh object. A mesh datastructure is network of faces, where the connectivities of the faces are defined by halfedge adjacencies. Therefore, the input set of lines must consist of closed loops of lines representing the faces of the Pattern.
If there are closed loops of lines, a Pattern
will be generated and all lines that do not form a closed loop, such as the "leaf" edges will be omitted.
A Rhino mesh object can be used to create a Pattern
. Since a Pattern is also a mesh object, the vertices and edges can be directly used to create the vertices and edges of the Pattern
.
A non-trimmed Rhino NURBS surface can be used to generate a Pattern
. UV mapping of the surface is used to subdivide the Pattern,
based on a subdivision value for U and V. Please refer to the first tutorial example to see how this feature is used.
RV2pattern_from_surface
only works with untrimmed surfaces; the input surface cannot have more than four edges.
This feature allows you to modify the attributes of the vertices of a Pattern
.
constraints : Rhino object to which the vertex is referenced or constrained to (not yet implemented)
is_fixed : fixes the x, y, z coordinates of the vertex
x : x coordinate of the vertex
y : y coordinate of the vertex
z : z coordinate of the vertex
This feature allows you to modify the attributes of the edges of a Pattern
.
lmax : maximum length desired for the edge during relaxation/smoothing
lmin : minimum length for the edge during relaxation/smoothing
q : force density
This feature allows you to manually move selected vertices of a Pattern
.
This feature allows you to delete vertices of a Pattern
. By deleting interior vertices of a pattern, holes can be created.
Using the force density method, this feature relaxes the entire Pattern
.
Using area-based smoothing (every vertex is repositioned to the centroid of its neighboring vertices), the pattern is smoothed.
Follow the instructions in the command window, choose outer boundary, inner boundaries and constraint curves. For the last step enter a target triangle edge length. Triangulated force pattern will be generated.
outer boundary is a closed polycurve that represents the outline of the diagram.
inner boundaries are openings of the intended design pattern.
constraint curves are where the vertices and edges will be forced to snapped onto.
Triangulation is a method that is fast and robust for creating a Pattern from a set of complex boundary features. However, triangulated patterns have no clear direction or hierarchy of the edges, which make it difficult to interact with (for example, if you wanted to attract forces using the force diagram).
A Pattern
object with identified supports and updated boundaries can be used to create the FormDiagram
. Any edges of the pattern, of which both endpoints are supports are removed from the FormDiagram
.
Depending on how the support vertices are defined, corners of the Pattern are automatically processed during the creation of the FormDiagram
.
The Force Diagram is the dual of the Form Diagram, in the sense that both diagrams have the same number of edges and that vertices in one diagram correspond to faces in the other, and vice versa.
Initially, the Force Diagram is created as the "centroidal dual" of the Form Diagram. This means that the geometry of the Force Diagram is defined by placing its vertices at the centroids of their corresponding faces in the Form Diagram.
In order for the Form and Force Diagram to describe the distribution of horizontal thrust in a three-dimensional network of compression forces in equilibrium with vertical loads applied to its nodes, they need to be not only dual, but also reciprocal.
Two diagrams are reciprocal if they are dual, and if their corresponding edges are at a constant angle with each other. Typically, corresponding edges are required to be parallel, or perpendicular, but any other constant angle is sufficient as well.
In RV2, the Form and Force Diagram are considered reciprocal if corresponding edges are perpendicular.
Once the Form and Force Diagram are reciprocal they describe the horizontal equilibrium of the corresponding three-dimensional force network. The edges of the Form Diagram define the directions and points of application of the forces, whereas the edges of the Force Diagram define the distribution of force magnitudes along those directions.
The magnitudes of horizontal forces are equal to the lengths of the edges in the Force Diagram, multiplied with a scaling factor.
In RV2, horizontal equilibrium is computed by parallelising the edges of the Form and Force Diagram to corresponding target vectors. These target vectors are defined as the weighted average of the vectors of corresponding edge pairs. Therefore, the most important parameter for the calculation of horizontal equilibrium in RV2 is alpha
, which is the weighting factor for the calculation of the target vectors.
If alpha = 100
, the target vectors are completely defined by the vectors of the edges of the Form Diagram. This means that only the geometry of the Force Diagram will be updated to achieve horizontal equilibrium. This is the default.
If alpha = 0
, the target vectors are completely defined by the edges of the force diagram. Therefore only the Form Diagram will be updated.
For all other values, the target vectors are calculated using the following formula:
Note that using alpha
efficiently requires a bit of practice and experience. Since the Form Diagram defines the intended layout of horizontal forces and RV2 has many tools for designing force layouts that provide a good starting point for form finding explorations, it is usually a good idea to start with alpha = 100
. However, once you have the horizontal equilibrium under control, playing around with lower alpha
values can have a significant influence on finding nicely balanced force distributions.
Computing horizontal equilibrium is an iterative process. The default number of iterations is 100
. For sensible force layouts, this value should go a long way. However, there are many cases in which more iterations are required. For example, if the Form Diagram has multiple open/unsupported edges, and especially if those edges have a low "sag" value, more iterations will typically be required to reduce all angle deviations between corresponding edges to less than 5 degrees.
Computing horizontal equilibrium is quite fast. Therefore, don't hesitate to set the number of iterations to 1000
or more if the need arises. However, don't go completely overboard either (10000
iterations is quite excessive in most cases), because the calculation has no stoppage criterion, since it tends to be more computationally expensive to check for convergence than to just run all the requested iterations.
Furthermore, resolving all angle deviations is not an absolute requirement, and is in many cases unnecessary. For example, the angle deviations between very short edges tend to be quite persistent as they are dominated by edges with (much) longer lengths during the calculation process. Since short edges in the Force Diagram also represent (relatively) small horizontal forces, these deviations can often be ignored.
The iterations of the horizontal equilibrium calculation process is dynamically visualised. The rate at which the diagrams are updated is controlled by the refreshrate. The default value is 10
, which means that the diagrams are updated every 10 iterations.
For large diagrams the dynamic visualisation slows down the calculations a little bit. In these cases, and/or for high numbers of iterations (> 1000
), it is therefore advisable to set the refreshrate to a higher value. For example, if the number of iterations is 1000
, then a refresh rate of 100
seems more appropriate.
Force distributions can be manipulated by moving around selections of vertices of the Force Diagram to stretch or compact parts of the Force Diagram. For example, to reduce the amount of thrust in an open edge
Alternatively, the lower and upper bounds for the length of the edges of the force diagram can be defined explicitly through Modify ForceDiagram
> Edges Attributes
. Next time horizontal equilibrium is executed, the solver will redistribute the forces such that the edges with explicitly defined bounds are shortened or elongated based on the defined minimum and maximum lengths.
Once the Form and Force Diagrams have been created and horizontal equilibrium has been established through parallelisation, the distribution of horizontal forces in the system is fixed. The actual magnitude of the horizontal forces depends on a scale factor and will determine the depth of the final thrust diagram. A higher scale factor results in higher horizontal forces and therefore a shallower three-dimensional shape. Vice versa, a lower scale factor results in lower horizontal thrust and thus a deeper solution.
The meaning of the scale factor and the magnitude of horizontal forces is related to the magnitude of the loads, which in turn are related to the self-weight of the resulting three-dimensional geometry.
Rather than asking you to "guess" the scale factor to get the three-dimensional shape you want, RV2 will determine the scale for you based on the desired height of the final solution.
The default value for the target height is 25% of the length of the diagonal of the bounding box of the Form Diagram (essentially of the bounding box of the footprint of your shell). This value tends to produce well-proportioned geometries.
The minimum value for the target height is 10% of the length of the diagonal. Currently this is hard-coded and can't be changed through the UI.
Modifying and controlling the geometry of force diagrams
The third tutorial session presents how to create a force diagram from a form diagram. The initial force diagram is a topologically dual diagram of the form diagram, and the horizontal equilibrium solver is needed to make the corresponding edges of the two diagrams perpendicular to each other, making the two diagrams dual and reciprocal. Additionally, how to modify and constrain the geometry of the force diagram is shown in this tutorial session.
What is covered in this tutorial session:
Creating force diagrams from a form diagram
Horizontal equilibrium solver and its parameters
How to modify and constrain the geometry of the force diagram
Here is the RV2 rui file including an updated toolbar with RV2file_open
and RV2file_save_as
commands, and a few Pattern
s that we generated together in Tutorial 2:
For this discretisation exercise, we will use the form diagram and thrust surface resulting from a pattern designed "from freatures" and inspired by the geometry and boundary conditions of the British Museum. We will generate a tessellation based on the dual of a remeshed triangulation of the thrust surface.
We will do this in small incremental steps using JSON files to store various updated versions of the Form Diagram mesh and communicate between parts of the procedure.
1) Create pattern: "From Surface":
Rectangular or square planar surface:
Use the Rhino command: "Rectangular plane: corner to corner".
2) Define boundary conditions:
Supports:
Make continuous linear supports on two opposite sides. (RV2>Define Boundary Conditions>Identify Supports>Select>ByContinuousEdges).
Openings:
No need to assign openings. This step has to be skipped and the openings on the two other sides will be automatically defined by RV2.
Explanation: since we have to constrain the forces to be almost 0 along the edges perpendicular to the openings, if we use the sag function (even only 5%), it will try to put some forces in that edges, so we skip this step.
2) Form Diagram: "Create Form Diagram".
3) Constrain force values in the edges of the form diagram:
The structural behaviour of a barrel vault can be approximated by a series of 2D arches put side by side. This means that the forces flow only along the edges parallel to the arches. In the other direction, perpendicular to the arches and parallel to the support lines, forces can be constrained to zero (hmax and hmin equal to 0.00001). In constraining the amount of forces in the edges corresponding to the arches, attention needs to be paid between the edges in the first and last arch, (hmax and hmin equal to 1.0), and the remaining ones in the middle of the vault, (hmax and hmin equal to 2.0). In the form diagram, a tributary area is assigned to each node and the load applied to the node is proportional to the amplitude of that area. The nodes in the first and last arch have a tributary area that is half of the one assigned to the nodes in the middle of the vault. For this reason, the force value in that edges is half (1.0), and the force assigned in the other edges is 2.0.
Select continuous edges perpendicular to the support, in the arch directions excluding the first and the last (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Continuous):
In the pop-up window assign 2.0 as hmax and hmin of the edges.
Repeat the same procedure for the other edges as described below.
Select the first and last continuous edges perpendicular to the supports (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Continuous):
In the pop-up window assign 1.0 as hmax and hmin of the edges.
Select continuous edges parallel to the support sides (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Continuous):
In the pop-up window assign 0.00001 as hmax and hmin of the edges.
4) Force Diagram: "Create Force Diagram".
5) run Horizontal Equilibrium:
Click on Horizontal Equilibrium>alpha>form100>enter
If the equilibrium is not found, change the number of iterations to 1000.
6) run Vertical Equilibrium
Click on Vertical Equilibrium>target_height
Input as target height half of the length of the side with an opening and then press enter.
7) Extra: change target height to 1/4 of the length of the side with an opening, and compare the components of the resultant forces with those obtained before.
To triangulate the Form Diagram mesh we can simply convert all quads to triangles. Note that the quality of the resulting mesh is not considered in this step. This is okay because we will still improve mesh quality through remeshing.
We will remesh in VS Code using the COMPAS viewer for visualisation, and again export the result to JSON to continue working with the remeshed triangulation in Rhino. The result is available for download at the bottom of this page.
Note that you could also do this directly from Rhino using the RPC cloud. However, the current procedure illustrates an alternative workflow using CPython directly in an editor outside of Rhino.
To avoid having to process the session file over and over again to extract the information about the form diagram, we export the Form Diagram data to a separate JSON file (form.json
) that can then be used as input instead. We also draw the form diagram as a simple mesh in Rhino.
After exporting the data we can create the form diagram as follows.
In this final set of tutorials we will explore how RV2 can be extended by using the functionality of the underlying packages directly through basic Python scripting (in Rhino). The following topics will be addressed:
Assignment of variable thickness distributions using Scipy grid data interpolation (and recalculation of the equilibrium geometry for this updated self-weight).
Smoothing and refinement of the thrust surface for further processing and discretisation.
Generation of basic cut data for discretised vault/shell blocks.
For the remeshing we will use compas_cgal
. The underlying remeshing function in CGAL is documented here:
RV2 bundles the following COMPAS packages
When you install RV2 using the installer, these packages are installed in a miniconda environment and registered in Rhino. It is the same as the "normal" installation process of COMPAS packages, but automated. Also the command plugin is installed with an automated version of the typical installation process for COMPAS-based Rhino command plugins.
This means that the COMPAS packages listed above (with the exception of compas_triangle
) are also available in the Rhino PythonScript Editor. To verify this, simply open the editor and run the following snippet:
Note that Rhino uses IronPython 2.7.8
. Therefore print statements are still in the "old" Python 2x format...
In this final tutorial, we will use these packages to extend the functionality of RV2 with custom Python scripts. For communication between these scripts and RV2, we will use the *.rv2
session files.
To load a Form Diagram from a RV2 session file and visualise it in a script, you could do the following:
Save the script in the same directoy as the session file ('bm-3.rv2'
), or provide the full path to the session file. Otherwise Rhino will not be able to find it.
To extract information from the Form Diagram you can simply use the typical COMPAS mechanisms for extracting data out of meshes.
Using the data and attribute "accessors", we can for example extract the values of the reaction forces at the supports, or the axial forces in the edges.
With this we can, for example, compute a rough approximation of the (lumped) stress at the nodes.
If you want to contribute to the development of RV2, or if you simply want to have access to all the latest changes and bug fixes before they are released, you may want to switch to a "dev install". This basically amounts to doing manually what otherwise the installer does for you.
Please use a version based on Python 3.
Please accept the default settings suggested by the installer!
The first step is setting up a conda environment.
For working with conda, please use the Anaconda Prompt, and not the Command Prompt.
For working with conda, please use the Terminal.
To install COMPAS packages into this environment, you have two options:
Clone the packages using your favourite Git client and install from source.
Install directly from the Github repos.
Here, we will procede with option 2. It is recommended to clone the repos into an easily accessible folder on your system. For a complete RV2 installation, we need the following repos:
If this doesn't work for you, you can install a released version of COMPAS using conda instead.
After installation, you can check your setup in an interactive Python session, import the core COMPAS library (compas
).
The installed packages have to be made available in Rhino with a few additional commands.
Uninstall any previously installed COMPAS packages.
Install the base COMPAS packages.
Install the RV2 packages.
In the above commands, the packages are installed for Rhino 7. If you are using Rhino 6, either specify the corresponding version (-v 6.0
), or just simply omit it since version 6 is the default.
The next step is to install the plugin.
One of the advantages of a "dev" setup is that you can add other COMPAS packages to extend the functionality of the base installation.
There, installation instructions for the viewers are also available...
In this case, you don't have to add the newly installed package to Rhino because when working in Rhino, compas_cgal
functionality has to be called via the RPC cloud anyway. In general, however, you should not forget to add newly installed packages to Rhino as well, to make their functinality directly available there...
Make sure to activate your "dev" environment before installing additional packages and/or registering packages in Rhino.
Don't forget to restart Rhino (if Rhino was open during any of the installation steps) after you make modifications.
Especially on Windows, there are two known issues with a pip-based COMPAS installation. They can be solved quite easily as documented here:
Finally we have to load the UI in Rhino. Please follow the general instllation instructions:
One of the additional packages used in was compas_cgal
, so i will use that as an example. Note however, that this package is under active development and still requires some modifications to the conda environment.
For more information about this installation process, please refer to the COMPAS CGAL documentation:
In order to apply the features of RV2 in a realistic design scenario, you will be asked to use all the techniques we will have presented throughout the week to design a shell structure in one of the two public spaces in Zurich, Switzerland.
Design a free-form shell for Sechseläutenplatz in Zurich. The surface of the shell may have a maximum area of 3,000 square meters. The shell may land around, but not in or on the existing site obstacles (umbrellas, trees and dark grey areas). The shell must be inside the red area shown in the second image below. The height of the shell should be at least 2.5 meters, so that it can be used as a passageway as well as a covering for the plaza.
Design a shell for the courtyard of the Landesmuseum (Swiss National Museum) in Zurich. Please pick one of the two regions of the courtyard as your site. The shell must be continuously supported on the boundaries, and it should not cover the trees or the cafe (tent) inside the courtyard.
In the Rhino file below, you will find the outlines of the two regions including within them circles corresponding to minimum clearance zones of the obstacles (trees and cafe). While the surface of the shell may not cover any part of these clearance zones, the shell may have landings anywhere on the ground level outside of these clearance zones. The trees and the cafe must be accessible on the ground level.
Although there is no prescribed minimum or maximum height of the shell, please remember that this a new "addition" to an existing, historical building!
To help the design of the shell, you will find the outlines of region 1 and 2 on the side of the model as shown in the picture below (layer "Outline_for_RV2"). Use them to generate the shell. After you are done, you can simply copy-paste your thrust network inside the courtyard and hide the "Outline" layer.
For my given site and my design intent, which method of pattern generation is appropriate?
What types of existing boundary condition constraints do I need to taken into account?
How does my pattern generation and modification strategies influence my eventual fabrication and construction schemes?
How can I control and modify the geometry of the force diagram to refine the shape of the Thrust Diagram?
Have I considered how the landings and openings of the Thrust Diagram relate to the program and the intended use of the space underneath?
On the last day of the workshop on Friday, July 3rd, you will be asked to present your design proposals to the instructors and invited guests. Before the start of Friday's 1st session, please compile the material below into a zip file (YourLastName_YourFirstName.zip), and upload it here.
16x9 format, 1920x1080 resolution min
These images may include but are not limited to:
Site strategy diagrams
Concept sketches and design development
Pattern generation techniques and development
evolution and refinement of form and force diagrams
fabrication strategies and development
perspectives/renderings
YourLastName_YourFirstName_##.png
Presentation board (16x9 format, 1920x1080 resolution min.) summarising the the design project
This board can be an organized compilation or a collage of the 8-10 images from above
YourLastName_YourFirstName_board.pdf (or jpg/png)
Final or a series of .rv2 session files
YourLastName_YourFirstName_##.rv2
If available, it would also be great to have any Rhino files of the final design, including the shell geometry as well as any materialisation and fabrication developments.
In addition to the instructors, there will be a panel of designers and engineers to critique and review the participants' projects.
Shajay Bhooshan (Head and co-founder of ZHCODE, Zaha Hadid Architects)
Dr. Robin Oval (Post-doctoral researcher, University of Cambridge)
Prof. Dr. Tomás Méndez Echenagucia (Assistant Professor, University of Washington)
Welcome to the homepage of DigitalFUTURES 2020 RV2 workshop!
In this workshop, you will learn to design efficient, compression-only shell structures using RhinoVAULT 2 (RV2), an open-source research and development platform for funicular form-finding built with COMPAS, the Python-based framework for computational research and collaboration in Architecture, Engineering, and Digital Fabrication.
We will use the RV2 plugin for Rhino 6 on Windows to explore funicular form finding through a series of hands-on tutorials and examples:
Tutorial 1: RV2 basics and overall workflow.
Tutorial 2: Force patterns and the Form Diagram.
Tutorial 3: Force Distributions.
Tutorial 4: Customisation.
In addition, you will learn how to extend the RV2 workflow with the functionality of other packages in the COMPAS ecosystem using basic Python scripting, and apply what you learned in a design project with real-world constraints and requirements.
Participants to receive installation and setup instructions
Encouraged but not required: print PDF of the workshop content on Gitbook, to make the tutorials easier to follow along
Participants to install RV2 on their own following the instructions on the workshop web page, and ask for help if not successful
09:00 - 11:00 GMT - Introduction
Short presentations by the instructors
Block Research Group
Thrust Network Analysis + rhinoVAULT
COMPAS + BRG Code + RV2
Outlook and overview of the workshop
12:00 - 14:00 GMT - Tutorial 1/5: RV2 basics
RV2 workflow summary and overview
Basic RV2 tutorial
14:00 - 16:00 GMT - Project work session 1/3
Introduce design project
Start developing concepts and ideas - implement what was learned that day
09:00 - 11:00 GMT - Tutorial 2/5: Force patterns
Explore methods for create patterns (focus on the pros/cons of each method)
Define boundary conditions
Create form diagram
12:00 - 14:00 GMT - Tutorial 3/5: Steering forces
Create force diagram (importance of link between force pattern and design/application intent)
Horizontal equilibrium
Controlling forces (modifying force diagrams)
Example: barrel/cross vault
14:00 - 16:00 GMT - Project work session 2/3
Develop strategies for generating force patterns (which method is more appropriate for the context and design intent?)
09:00 - 11:00 GMT - Session 4/5: Additional features
Drop downs
Various display modes
Saving and opening .rv2 session files
use the mesh datastructure of the diagrams to explore extended applications
modifying settings
12:00 - 14:00 GMT - Tutorial 5/5: Materialisation
RV2 + COMPAS part 1: Material distribution
RV2 + COMPAS part 2: Discretisation
RV2 + COMPAS part 3: Fabrication
14:00 - 16:00 GMT - Project work session 3/3
Develop strategies for materialisation and fabrication
09:00 - 11:00 GMT - Project presentations 1
12:00 - 14:00 GMT - Project presentations 2
14:00 - 16:00 GMT - Project presentations 3
16:00 GMT - Closing
Solution
Open Rhino.
Type EditPythonScript
to open the Python script editor.
Close Rhino.
Run the installer again.
Some parts of Rhino's internal folder structure are only created after the Python script editor has been opened at least once.
Solution
Open Rhino.
Type EditPythonScript
to open the Python script editor.
Restart Rhino.
Initialise RV2 again.
Python Plugin commands are not automatically recognised...
Solution
Unfortunately, with Python Command Plugins, you have to restart Rhino everytime you open a new file!
For any issues involving installation, errors or bugs, please file an issue on the with the label "DF2020", and a staff member will reach out to you as soon as possible.
We very much welcome your feedback! Please use the issue tracker of the to submit comments, feedback and feature requests.
Yes! You can contribute to the RV2 repository (an other packages in the COMPAS ecosystem) by following the COMPAS .
Philippe Block is Professor at the Institute of Technology in Architecture at ETH Zurich, where he co-directs the Block Research Group (BRG) together with Dr. Tom Van Mele. He is director of the Swiss National Centre of Competence in Research (NCCR) in Digital Fabrication. Block studied architecture and structural engineering at the VUB, Belgium, and at MIT, USA, where he earned his PhD in 2009.
Research at the BRG focuses on computational form finding, optimisation and construction of curved surface structures, specialising in unreinforced masonry vaults and concrete shells. Within the NCCR, BRG researchers develop innovative structurally informed bespoke prefabrication strategies and novel construction paradigms employing digital fabrication. The BRG applies their research into practice on the structural assessment of historic monuments in unreinforced masonry and the design and engineering of novel shell structures.
Dr. Tom Van Mele is Senior Scientist and co-director at the Block Research Group, where he leads the computational and technical developments. Tom is the lead developer of COMPAS, the open-source computational framework for collaboration and research in architecture, structures and digital fabrication. Tom received his PhD from VUB, Belgium in 2008.
Dr. Juney Lee is an architect and a postdoctoral researcher at the Block Research Group. His main areas of research include graphic statics, applied computational geometry, and sustainable construction. He is interested in developing computational methods in order to discover new design opportunities in architecture and structural engineering. Juney studied architecture and structural engineering at UC Berkeley and MIT in the USA, and received his PhD from ETH Zurich in 2018.
Li is a software engineer specialized in computational geometries and machine learning for computer vision. He studied Architecture at Southeast University, China, then completed his Master's degree at AADRL in London, UK. His thesis project researched adaptive 3D-printed structures utilising autonomous industrial robotic arms and generative algorithms.
Wenqian Yang is an architect and designer who has studied and practised in digital sculpturing, computational design, craftsmanship, robotic fabrication and 3D printing with an interest in exploring fabrication-informed design methods. Wenqian also worked in the Melbourne-based office LAB architecture studio as a senior architect and accomplished multiple architectural projects across scales. She joined the Block Research Group in November 2019 as an intern and has been working in the COMPAS development team. She is the lead developer of compas_skeleton
package.
Alessandro Dell’Endice is a building engineer and architect, and he is currently a PhD candidate at the Block Research Group. He has a strong interest in the field of computational design, digital fabrication and structural assessment of unreinforced masonry structures. Since November 2016, he was involved in the fabrication of several BRG’s projects, and in 2018 he started his PhD as part of the SNSF Project “Practical Stability Assessment Strategies for Unreinforced Masonry Structures”. His focus is on the development of computational methods, using discrete element modelling, for the structural assessment of historic masonry structures. Alessandro completed his Master in building engineering and architecture at Politecnico di Bari in Italy, and he received his Master in Advanced Studies in architecture and digital fabrication from ETH Zurich in 2016.
Dr. Robin Oval is a structural engineer from l’École des Ponts in Paris. His master’s thesis with the Block Research Group tackles the design of force patterns for funicular form finding and was applied for the ‘Beyond Bending’ exhibition at the 2016 Architecture Biennale in Venice. In December 2019, Robin completed a joint PhD with the Laboratoire Navier at l’École des Ponts in Paris and the Block Research Group at ETH Zürich on topology finding of force and structural patterns for shell and gridshell structures. He is currently a post-doctoral researcher in the ACORN - Automating Concrete Construction project, working with Dr. John Orr of University of Cambridge and Dr. Paul Shepherd of University of Bath. Robin is the lead developer of compas_singular
package.
An open source Python-based framework for computational research in Architecture, Engineering and Digital Fabrication.
The fundamental principle behind COMPAS is to provide to the research community a computational core that is independent of a specific CAD ecosystem and can be used in various environments across platforms.
Research and development based on COMPAS can therefore take better advantage of the available state of the art libraries for, for example geometry processing or robotic control, while maintaining compatibility with various software tools of the AEC industry. As a result, researchers can develop their work more freely and interact more easily with researchers from other fields, and with partners from industry.
The goal is to facilitate collaboration across disciplines and break the endless cycle of reinvention of methods and algorithms due to the lack of transparency and reproducibility of research in our field.
The main library of COMPAS provides flexible data structures, a geometry processing library, robot fundamentals, numerical solvers, and various other components as a base framework for computational research.
CAD tools are everywhere in Architecture, Engineering, Fabrication, and Construction (AEFC), both in research and in practice. COMPAS provides a consistent interface for visualising and interacting with data structures, and for working with geometry, in Blender, Rhino, RhinoMac, and Grasshopper.
To simplify the exchange between CAD systems, COMPAS supports several 3D geometry file formats for loading and saving 3D geometry. Currently, the following formats are supported: OBJ, OFF, PLY, STL, GLTF, URDF.
Using flexible data management with Python dictionaries and json serialisation, instances of COMPAS data structures and geometry objects can be saved to disk, sent over a network or to a subprocess, and reloaded witout loss of information.
In addition to the core library, COMPAS provides an ever-growing collection of plugins, extensions, and tools.
Plugins are packages developed and maintained by the core development team (compas-dev
) that provide missing functionality or faster alternatives to (pure Python) COMPAS core algorithms, often by wrapping state of the art, external libraries. Examples of plugins are compas_triangle, compas_libigl, and compas_cgal.
Extensions are packages built on top of the core library, and potentially some of its plugins, to provide entirely new functionality to the framework related to specific fields in the AEFC industry. Examples are COMPAS FAB and COMPAS FEA.
Tools focus on providing user interfaces for all of the above. RhinoVAULT 2 is the first example of a UI-based tool built entirely with packages and functionality from the COMPAS ecosystem.
RhinoVAULT 2 works both on Mac and Windows. However, there is currently no way to ship a UI with a Python-based CommandPlugin for Rhino on Mac. Therefore, for this workshop, you have to use Rhino 6 on Windows.
Open Rhino and run the command EditPythonScript
once, then exit Rhino (this will initialize some internal Rhino folder structure which is necessary for the installation of RV2).
Download RV2 installation file from https://nextcloud.ethz.ch/s/cg29DDoRXWFXMcy
Run the installation file. If you see following prompt, click on More info
then choose Run anyway
After the installation interface shows up, click on the Install RV2
button, then choose a location to install RV2 on your computer.
RV2 is a Rhino plugin. It is not software. We just need an installation location to set up some of the dependencies for the plugin.
Therefore, you can choose any folder for the installation, as long as there are no spaces in the installation path!
Paths likeD:\Program Files\...
will fail to install.
However, please, don't use your "Program Files" folder for the installation process since this requires special admin privileges. Instead, use something like:
C:/Tools
C:/RhinoVault2
C:/DF2020
C:/Users/username/Documents
C:/Users/username/Desktop
The installation usually takes 1~2 minutes. After the progress bar finishes, click Yes
twice in User Account Control.
The installation is successful if you see this message:
Note that you have to close the installer window after the installation.
In the top menu, go to Tools > Toolbar Layout
.
In the pop-up window, click File > Open
.
Go to the location where your RV2 is installed, for example D:\MySoftwares\RV2\
, enter the folder called dev
then find the file RV2.rui
and open it.
Tick RV2
in the Toolbars section.
The RV2 menu and toolbar will now both appear in user interface.
To check that everything worked, click the Initialise RV2
menu item or toolbar button. You will be asked to accept the "Terms and Conditions" and "User Agreement" (just click Yes
:) after which the welcome screen should disappear.
If the initialization step fails, please file an issue on the RV2 issue tracker and we will help you as quickly as possible.
If Rhino says Command not found: -_RV2init
, please type EditPythonScript
to open the script editor and restart Rhino. Then try the initialisation again...
Overview of the RV2 workflow and the user interface
The first tutorial session provides an overview of the RV2 workflow, the user interface and a step-by-step tutorial of a simple example, highlighting and describing the main features of RV2. This tutorial is intended to cover the main steps of the RV2 workflow with mostly default options and settings. Detailed options and parameters will be addressed more in depth in later tutorials.
What is covered in this tutorial session:
Organization and structure of the RV2 workflow; sequence of procedures and solvers
Overview of the RV2 user interface: the menu and the toolbar
A step-by-step tutorial of a simple example, highlighting the main features of RV2
Thrust Network Analysis (TNA), a methodology for generating compression-only vaulted surfaces and networks was developed by Prof. Philippe Block as part of his PhD (2009) at MIT, under the guidance of Prof. John Ochsendorf. The method finds possible funicular solutions under gravitational loading within a defined envelope. Using projective geometry, duality theory and linear optimization, it provides a graphical and intuitive method, adopting the same advantages of techniques such as graphic statics, but offering a viable extension to fully three-dimensional problems.
Block P. and Ochsendorf J. , Journal of the International Association for Shell and Spatial Structures, 48(3): 167-173, 2007.
Block P. , PhD dissertation, Massachusetts Institute of Technology, Cambridge, MA, USA, 2009.
Interactive design of funicular shells
The Rhinoceros® plug-in RhinoVAULT, developed by Dr. Matthias Rippmann at the Block Research Group of ETH Zurich, emerged from research on structural form finding using Thrust Network Analysis (TNA) and was developed to facilitate the creation and exploration of compression-only, funicular structures.
Based on TNA, RhinoVAULT provides an intuitive method for funicular form finding, adopting the same advantages of techniques such as graphic statics, but offering a viable extension to fully three-dimensional problems. The designer can control the many degrees of freedom of highly indeterminate three-dimensional equilibrium systems to explore structural form.
Since its release in 2014, RhinoVAULT has been downloaded by more than 30.000 people, it was awarded in the category "Structure / Physics Formation" at ALGODeQ, an international competition for algorithmic design programs, and it has been used to design surprising free-form masonry vaults and shell structures all over the world.
Rippmann M., Lachauer L. and Block P. RhinoVAULT - Interactive Vault Design, International Journal of Space Structures, 27(4): 219-230, 2012.
Rippmann M. Funicular Shell Design: Geometric Approaches to Form Finding and Fabrication of Discrete Funicular Structures, Doctoral dissertation, Department of Architecture, ETH Zurich, 2016.
RV2pattern_from_skeleton
is a powerful new RV2 feature that provides easy and intuitive method for generating complex patterns for free form vaults with just a few clicks.
RV2pattern_from_skeleton
is a feature based on the compas_skeleton
package. Fore more detailed information on the package, please check out its online documentation.
Choose "Create Pattern" --> "From Skeleton" from the tool bar, select a group of lines from Rhino and press Enter.
Follow the instructions in the command window, for each step click on the corresponding vertex, move cursor to input skeleton node width, leaf width and end extension respectively.
After initialising the skeleton, there will be available editing methods showing up in the command window. try out these options, get your ideal pattern.
increase the subdivision level of skeleton and finish editing. by clicking on "Finish", a force pattern diagram will be automatically generated.
Methods for creating topological patterns for form diagrams
The second tutorial session explores various methods for generating topological patterns of form diagrams. Each method has a direct influence not only on the topology of the shell structure, but also the type of application and interaction that is desired during the design process. Additionally, this tutorial session will cover how to set proper boundary condition constraints in order to create a form diagram object from a topological pattern.
What is covered in this tutorial session:
Exploration of various methods for generating patterns for form diagrams
Understanding the difference between "patterns" and form diagrams
Defining boundary condition constraints
There are many ways to generate a topological pattern. Each method has pros and cons, and the desired design or workflow will help determine which method is more appropriate.
How to obtain a structured quad-mesh pattern mapping a surface including optional point features on it
RV2pattern_from_features
is based on the compas_singular
package. For more information on the package, please check out its online documentation.
Using the RV2pattern_from_features
command is a powerful and an effective way to generate quad mesh patterns from complex or irregular boundary conditions and point features, such as the British Museum Great Courtyard Roof.
This algorithm works for trimmed, planar, curved and non-heightfield NURBS surfaces, but not NURBS polysurfaces or meshes.
The first example takes into account only the input surface to produce a pattern align with the boundaries. This aspect is important in funicular form finding in the case of non-supported boundaries.
The second example also takes into account point features on the surface to include pole points in the pattern. The point features at the corner can integrate local concentration of thrust. The other point features can integrate point loads or nodal supports. All these aspects are important to design a suitable pattern for funicular form finding.
Supports are vertices of the FormDiagram
where reaction forces can be present. If there already are vertices of the Pattern
which was fixed during the modification of the Pattern
, they will be automatically defined as supports. Please refer to the first tutorial example to see how the vertices of a Pattern can be selected or unselected as supports.
In order to update the unsupported boundaries of the Pattern
, the desired sag to span ratio is calculated. With the desired sag value for all or some of the unsupported boundaries, force density method is used to relax the Pattern
to the specific desired sag value.
Please refer to the first tutorial example to see how curvature can be introduced to unsupported boundaries of a Pattern.
In a cross vault the force distribution is more complex than in a barrel vault. Since you will manually constrain the forces in the vault, we use a square base to reduce the complexity and get help from the symmetry.
1) Create pattern: "From Lines":
A cross vault is supported in four points at the corners. The form diagram, that represents the horizontal projection of how the forces flow in the structure, should allow forces to end up in the corners. For this reason, in this case, our form diagram should look like the one in the picture below, with two diagonals added to the square pattern.
To build this form diagram, let's first create a square surface with the Rhino command "Rectangular Plane: Corner to Corner", typing in two times the length of the side.
Go to Create Pattern in the RV2 menu and use "from surface" to create the pattern. At this point, you will see a square pattern without diagonals.
Select the pattern and type the Rhino command "Ungroup" and press enter.
In Rhino, create a new layer called "Lines".
In Rhino, type "SelLine" and move all the selected lines to the layer "Lines" you just created.
Now type "SelPt" and delete all the points in the viewport.
In Rhino, select the command "Polyline" and draw the two diagonals from one corner to the other.
The edges in the form diagram should always be split at the point where they cross each other. For this reason, type the command "Split", select the two diagonals, press "Enter", and then select all the lines of the square pattern and press "Enter" again.
At the end of the previous step, you will see a pattern similar to the one in the picture above, with single lines.
Now you can click on Create pattern in the RV2 menu and use "from Lines".
2) Define boundary conditions:
Supports:
The supports of the cross vault are in the four corners (RV2>Define Boundary Conditions>Identify Supports>Select>Manual).
Openings:
No need to assign openings. This step has to be skipped and the openings on the four sides will be automatically defined by RV2.
Explanation: since we have to constrain the forces to be 0 along the edges perpendicular to the openings, if we use the sag function (even only 5%), it will try to put some forces in that edges.
2) Form Diagram: "Create Form Diagram".
3) Constrain force values in the edges of the form diagram:
In a cross vault, one possible way for the forces to flow within the structure is along the arches spanning between the diagonals and then from the diagonals directly to the supports. So, the edges perpendicular to the openings will carry zero forces. The arches on the boundaries will carry half of the load compared to the arches in the middle of the vault, due to the different tributary areas, as explained in the barrel vault example. So we will set the force for the arches on the boundaries equal to 1.0 and for the rest equal to 2.0. To avoid the collapse of the edges at the end of the diagonals, in the middle of the vault, we fix their force value equal to 1.0.
Select edges perpendicular to the openings (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Manual):
In the pop-up window assign 0.000001 as hmax and hmin of the edges.
Select all the edges on the boundaries (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Continuous):
In the pop-up window assign 1.0 as hmax and hmin of the edges.
Select the edges parallel to the openings and spanning between the diagonals, leaving the edges on the boundaries (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Manual):
In the pop-up window assign 2.0 as hmax and hmin of the edges.
Select the four edges at the end of the diagonals meeting in the center of the vault (RV2>ModifyFormDiagram>ModifyEdgesAttributes>Manual):
In the pop-up window assign 1.0 as hmax and hmin of the edges.
4) Force Diagram: "Create Force Diagram".
5) run Horizontal Equilibrium:
Click on Horizontal Equilibrium>alpha>form100>enter
If equilibrium is not reached, change the number of iterations and run again.
6) run Vertical Equilibrium
Click on Vertical Equilibrium>target_height
Input as target height half of the length of the side with an opening.