Talk to a counsellor
CoursesIIT ProgramsProjectsPlacementsFor BusinessBlogLog inTalk to a counsellor
Challenge

Creating Conceptual mass in REVIT and Creation of Sinusoidal curve and a Parametric stadium using Dynamo

DDipshi Kapoor9 Dec 2024

1) Creating a set of sinusoidal points in Dynamo, forming a curve, and then creating a surface from that curve involves several steps. Below, I’ll walk you through the steps and logic needed in Dynamo to achieve this:

Step-by-Step Guide for Creating Sinusoidal Points and Surface in Dynamo

1. Creating the Sinusoidal Points

  • Use a Range node to generate a list of values along the x-axis (e.g., 0 to 10).
    • Set the start to 0 and the end to the desired length (e.g., 10).
    • Set the step to control the density of points (e.g., 0.1).
  • Use a Math.Sin node to apply the sine function to each value in the list.
    • Connect the output of the Range node to the input of the Math.Sin node.
  • Create a list of points using the Point.ByCoordinates node.
    • Connect the output of the Range node to the x input (x-coordinates).
    • Connect the output of the Math.Sin node to the y input (y-coordinates).
    • Set a constant value for z (e.g., 0) to keep the points on the same plane.

2. Creating a Curve from the Points

  • Use a Curve.ByPoints node to create a curve from the list of points you generated.
    • Connect the output of the Point.ByCoordinates node to the input of Curve.ByPoints.

3. Creating a Surface from the Curve

  • Use a Surface.ByPatch node to create a surface from the curve.
    • Connect the output of the Curve.ByPoints node to the input of the Surface.ByPatch node.
  • Optionally, you can create a more complex surface by using additional points or curves and setting them as a boundary.

Dynamo Script Overview

Here is an overview of the logic you should follow in Dynamo:

  1. Generate X-coordinates using the Range node.
  2. Calculate Y-coordinates using the Math.Sin node.
  3. Create points with the Point.ByCoordinates node.
  4. Create a curve from the points using the Curve.ByPoints node.
  5. Create a surface using the Surface.ByPatch node.

Detailed Dynamo Node Setup

  1. Range Node:

    • Start: 0
    • End: 10
    • Step: 0.1

  2. Math.Sin Node:

    • Connect the output of the Range node to the input.

  3. Point.ByCoordinates Node:

    • X: Connect to the output of the Range node.
    • Y: Connect to the output of the Math.Sin node.
    • Z: Use a Number node-set to 0.

  4. Curve.ByPoints Node:

    • Input the output from Point.ByCoordinates.

  5. Surface.ByPatch Node:

    • Input the output from Curve.ByPoints.

Sample Code in Dynamo (Python Script for Advanced Users)

If you want more control or wish to automate the creation with Python, you can use a Python script node:

import math

# Input from Dynamo
x_values = IN[0]  # List of X values
y_values = [math.sin(x) for x in x_values]
z_value = 0  # Keep points on the same plane

# Generate points
points = [Point.ByCoordinates(x, y, z_value) for x, y in zip(x_values, y_values)]

# Create curve
curve = Curve.ByPoints(points)

# Output
OUT = curve

Expected Outcome

After running the script in Dynamo:

  • You should see a sinusoidal curve formed in the Revit environment.
  • The surface generated by the Surface.ByPatch node will be created from this curve, resulting in a 3D representation of a sine wave.

Customization

  • Adjust the range and step of the Range node to control the density and length of the sinusoidal curve.
  • Modify the amplitude of the sine wave by scaling the output from the Math.Sin node.

This workflow will create a sinusoidal curve and a surface in Dynamo that can be imported into your Revit model for further use or visualization.

2) Creating a conceptual layout of a floor plan in Dynamo and linking it to model elements in Revit, such as walls, involves several steps. Below, I'll provide you with a comprehensive guide for creating the layout, adding parameters for walls, and using sliders to control wall dimensions.

Step-by-Step Guide to Creating a Conceptual Floor Plan and Link Walls in Dynamo

Step 1: Create the Conceptual Layout (Floor Plan) in Dynamo

  1. Open Dynamo from within Revit.

  2. Create a new workspace in Dynamo to start building your floor plan.

  3. Create Basic Geometry:

    • Use the Line.ByStartPointAndEndPoint node to create straight lines that will represent the walls of the floor plan.
    • Connect multiple Line.ByStartPointAndEndPoint nodes to build the outline of your floor plan. Adjust the start and end points to create corners and various shapes.

  4. Use Sliders for Flexibility:

    • Add Slider nodes to control the length and height of the walls.
      • Create a slider for the length of the wall (e.g., range from 5 ft to 50 ft).
      • Create a slider for the height of the wall (e.g., range from 8 ft to 20 ft).

Step 2: Link the Lines to Model Elements in Revit

  1. Import Revit Wall Elements:

    • Use the FamilyType node to select the wall types available in your project.
    • Connect the FamilyType node to a Wall.ByCurveAndLevel node to create walls from your lines.

  2. Create Walls with Parameters:

    • Connect the lines you created to the Wall.ByCurveAndLevel node's input for the curve.
    • Use a Level node to specify the level at which the wall is placed (e.g., "Level 1").
    • Connect the output of the slider for height to the Wall.ByCurveAndLevel node to control the wall height dynamically.

  3. Set Wall Parameters:

    • Use the Set Parameter node to link and modify parameters such as wall type, height, and other properties.
    • Connect the selected FamilyType to the Wall.ByCurveAndLevel node to specify the wall type.

Step 3: Customize Wall Parameters Using Sliders

  1. Link Sliders to Parameters:

    • Use a Slider node connected to the Wall.ByCurveAndLevel node's height parameter input to adjust the wall height interactively.
    • Connect a Slider node to the length input of the Line.ByStartPointAndEndPoint nodes to control the length of the walls dynamically.

  2. Modify Wall Types and Parameters:

    • Use the Set Parameter node to set the parameters of the walls, such as Wall Type, Height, Material, etc.
    • Connect the FamilyType or other nodes to apply different wall types as needed.

Dynamo Script for Conceptual Layout and Wall Creation

Here's a basic script outline for creating walls with adjustable parameters:

1. Create a `Line.ByStartPointAndEndPoint` node for each segment of your floor plan.
2. Create a `Slider` node for the length and height of the walls.
3. Use a `FamilyType` node to select the wall type from your project.
4. Create a `Wall.ByCurveAndLevel` node and connect the curve from `Line.ByStartPointAndEndPoint`, the level from `Level` node, and the wall type from `FamilyType`.
5. Use `Set Parameter` nodes to modify wall parameters (e.g., wall height, material).

Visual Representation and Interactivity

  • You should now be able to see the layout of the floor plan created in Dynamo and linked as walls in the Revit model.
  • The sliders will allow you to interactively change the length and height of the walls and see the updates in real time within the Revit environment.

Final Steps: Run and Test the Script

  1. Run the script in Dynamo to create the walls and update the parameters in Revit.
  2. Adjust the sliders to change the length and height of the walls and observe how the walls in Revit respond.
  3. Check the wall properties in Revit to ensure that the correct wall type and parameters have been applied.

Conclusion

This approach will help you create a conceptual floor plan layout in Dynamo and link it to model elements in Revit. By using sliders, you can dynamically control the dimensions and properties of the walls, providing a flexible and interactive design tool for your Revit projects.

3) Creating an array of model elements in Revit and using Dynamo to vary their properties involves a few steps. Here, I'll guide you through how to create an array of elements and then use Dynamo to control their properties using sliders or code blocks.

Step-by-Step Guide to Creating an Array and Vary Properties in Dynamo

Step 1: Create an Array of Model Elements

  1. Place Model Elements in Revit:

    • Create or select the model elements in Revit that you wish to array (e.g., columns, windows, or any other type of family).

  2. Open Dynamo:

    • Open Dynamo from the Revit ribbon to create a new workspace.

  3. Select Elements:

    • Use the Select Model Elements node to select the model elements in the Revit project.
    • Alternatively, use All Elements of Category to select a specific type of element (e.g., all columns or all windows).

  4. Create an Array:

    • Use the Array.ByCurve or Array node to create a linear array of the selected elements.
    • Connect the selected elements to the input of the array node.
    • Use a Line.ByStartPointAndEndPoint node to define the path for the array (e.g., a straight line along the x-axis).

  5. Add Control for Number of Elements:

    • Use a Slider node to control the number of elements in the array. Connect the slider to the Count input of the Array node.

Step 2: Vary the Properties of Model Elements

  1. Add a Slider for Properties:

    • Use a Slider node to create a control for a specific property you want to vary (e.g., height, spacing, or angle of rotation).
    • Set the range of the slider to reflect the desired range for the property.

  2. Use Code Blocks for Advanced Control:

    • Create a Code Block node for more complex expressions, such as adjusting the height or rotation of the elements based on the slider input.
    • Example code block to vary height: 
      [element.Height] = [slider value]
    • This code block can be connected to the Set Parameter node to apply the height change to the array of elements.

  3. Set Parameter:

    • Use the Set Parameter node to modify specific parameters of the model elements, such as height, material, or visibility.
    • Connect the array of elements and the property values to the Set Parameter node.

  4. Apply Rotation (Optional):

    • If you want to rotate the array of elements, use the Element.Transform node.
    • Connect the array of elements and use a Slider node to control the angle of rotation.
    • You can use a Rotation node or a Matrix node to define the rotation transformation.

Detailed Dynamo Script for Creating an Array and Varying Properties

Here's an outline for a Dynamo script:

  1. Select Model Elements:

    • Use Select Model Elements or All Elements of Category.

  2. Create an Array:

    • Use Array.ByCurve or Array.
    • Connect a Line.ByStartPointAndEndPoint node to define the array path.
    • Connect a Slider for the Count input.

  3. Vary Properties:

    • Use a Slider for controlling the desired property (e.g., height, spacing).
    • Create a Set Parameter node to apply the change to the selected model elements.

  4. Optional - Apply Rotation:

    • Use Element.Transform and a Slider to rotate elements.
    • Connect the rotation input to the desired angle from a Slider.

Example Workflow for Varying the Height of Columns

  1. Select the Columns: Use the Select Model Elements node to pick the columns.
  2. Create an Array:
    • Use the Array.ByCurve node with a Line.ByStartPointAndEndPoint node to define a path.
    • Connect a Slider for the Count input to control the number of columns.
  3. Vary the Height:
    • Connect a Slider for the height of a Set Parameter node and select the Height parameter of the columns.
  4. Run the Script: Adjust the sliders to see the number of columns and their heights change in real-time in Revit.

Using a Code Block for Advanced Property Control

  • If you want to control the position or a more complex property, use a Code Block with an expression like: 
    height = slider_value;
  • Connect this output to the Set Parameter node to modify the elements.

Final Steps: Run and Test the Dynamo Script

  1. Run the Dynamo script to create an array of elements and vary their properties.
  2. Adjust the sliders to test the changes in the number of elements and their properties.
  3. Check the results in Revit to ensure the array and parameter changes are applied as intended.

Summary

This guide covers how to create an array of model elements in Dynamo and use sliders or code blocks to vary their properties interactively. The combination of these tools allows for dynamic and flexible design adjustments directly within Revit.

4) Creating a conceptual mass in Revit and developing a parametric column involves several steps. This process can include creating a mass, dividing its surfaces, and applying panels that form a parametric pattern, similar to the approach used in parametric walkway modelling. Here’s a detailed step-by-step guide:

Step 1: Create a Conceptual Mass in Revit

  1. Open Revit and Create a New Project:

    • Start a new project or open an existing project.
    • Go to the “Massing & Site” tab and select “In-Place Mass” to create a conceptual mass.

  2. Define the Mass Shape:

    • Choose the appropriate mass category, such as “Generic Models”.
    • Use the available tools (e.g., “Extrusion,” “Revolve,” “Sweep,” “Blend,” or “Loft”) to create the shape of the column. You could create a simple cylindrical or rectangular mass as the base shape.

  3. Finish the Mass:

    • Once the shape is defined, click on “Finish Mass” to complete the creation of the mass.

Step 2: Divide the Surface of the Mass

  1. Select the Mass:

    • Select the mass you just created in the 3D view.

  2. Divide the Surface:

    • Go to the “Massing & Site” tab, and click on “Divide Surface”.
    • Choose the surface of the mass that you want to divide. This will create a grid pattern on the surface of the mass.

  3. Adjust the Divisions:

    • Use the “Modify” options to adjust the grid pattern's size and alignment. You can use fixed or flexible divisions, or manually set the number of segments along each axis.
    • You can also create custom division patterns by editing the grid manually or by applying specific rules.

Step 3: Apply Parametric Panels to the Mass

  1. Create Panel Families:

    • Create a panel family using the “Family Editor” in Revit. Design the panel shape (triangular, square, or bent panels) according to your requirements.
    • Use “Reference Lines” and “Reference Planes” to create a parametric shape that can be adjusted based on parameters (e.g., size, rotation).
    • Ensure that the panel family is a “System Family” if you plan to place them in the mass as system panels.

  2. Load and Place Panels:

    • Load the panel family into the project by going to “Insert” > “Load Family” and selecting your panel family file.
    • Once loaded, select the “Place Panels” tool under the “Massing & Site” tab and click on the divided surface of the mass.
    • Choose the type of panel you want to place (e.g., triangular or square panels) and apply it to the surface.

  3. Adjust Parameters:

    • Use “Instance” or “Type” parameters to control the properties of the panels.
    • Adjust the parameters in the “Properties” panel to modify the size, rotation, and orientation of the panels on the surface of the mass.
    • You can create a parameter-driven array or apply formulas in the family editor to control how the panels interact with the surface.

Step 4: Apply Patterns and Finishes

  1. Apply Material Finishes:
    • Use the “Materials” tool to apply different finishes to the panels.
    • Assign materials to the panel types and apply them to the panels on the mass. You can create custom materials for wood, metal, or other finishes in the “Materials” dialogue.
  2. Adjust Panel Orientation:
    • If you want to create bent panels or change the orientation of the panels based on the surface curvature, apply constraints and modify the rotation angle to achieve the desired effect.

Step 5: Test and Refine the Parametric Column

  1. Test Parametric Adjustments:

    • Adjust the height, width, or rotation of the panels using the “Parameters” sliders or input values to test how the panels behave on the surface.
    • Use the “Family Editor” to create more complex formulas or parameters for dynamic control of the panel layout.

  2. Review and Finalize:

    • Check the finished column in 3D view to ensure the panels are applied correctly and have the desired appearance.
    • Refine the parameters and divisions as necessary to perfect the look and behaviour of the parametric column.

Bonus Tips for Workflow Efficiency

  • Use Dynamo for Automation: For more complex parametric controls, you can use Dynamo to automate the division and placement of panels, allowing you to dynamically modify the grid or panel placement based on custom parameters.
  • Create Adaptive Components: If you need the panels to adjust dynamically to the shape of the mass, consider creating adaptive components in the Family Editor that use points and reference lines to align with the mass surface.

By following these steps, you will be able to create a conceptual mass in Revit, divide its surface, and apply parametric panels that can be adjusted for a customizable and visually appealing column design.

5) Developing a parametric stadium in Dynamo involves creating a flexible, parametric model that can be adjusted based on different design requirements. To achieve this, we need to define key parameters that control the stadium's geometry, such as the number of tiers, the seating arrangement, and the shape of the structure. Below, I’ll outline the essential parameters, and explain how to use Dynamo to develop the model using visual programming concepts, concerning a parametric high-rise tower as discussed in class.

Step 1: Define Parameters for the Parametric Stadium

When modelling a stadium, it’s crucial to identify the parameters that will make the model adjustable and customizable. Here are some important parameters:

  1. Number of Tiers: The number of concentric seating levels.
  2. The radius of the Stadium: The distance from the centre point to the outer edge.
  3. Height of Each Tier: The vertical distance between each tier.
  4. Angle of Sector (or Number of Sectors): The angle covered by each sector (e.g., 360° divided by the number of sectors).
  5. Seating Capacity per Tier: The number of seats on each tier.
  6. Width of the Aisle: The space between the seating rows.
  7. Depth of the Stadium Bowl: The depth of the stadium from the lowest tier to the field level.
  8. Panel Size: The size and shape of the panels used for the exterior (e.g., triangular, square, or curved).

Step 2: Visual Programming in Dynamo for Parametric Stadium Modeling

To model the stadium using Dynamo, follow these steps:

Step 2.1: Create the Base Shape of the Stadium

  1. Create a Center Point:

    • Use a Point.ByCoordinates node to create the centre point of the stadium.

  2. Create Circular Tiers:

    • Use a Circle.ByCenterPointRadius Node to create circles representing each tier of the stadium. Connect the centre point to the input and use sliders or code blocks to control the radius and height for each tier.

  3. Create Levels for Each Tier:

    • Use the Level.ByName node to create levels for each tier. Connect a range of numbers to define the height of each level based on the Height of Each Tier parameter.

Step 2.2: Divide the Circular Surface into Seating Arrangements

  1. Divide the Circular Surface:

    • Use the Divide Surface Node to create a grid of points on each circular tier. This will represent the positions where seating rows will be located.

  2. Adjust Grid Density:

    • Use a Slider to control the number of divisions or density of the grid, which represents the number of seats in a row.

  3. Create Seating Rows:

    • Connect the grid points to Line.ByStartPointAndEndPoint nodes to create lines representing the seating rows on each tier.

Step 2.3: Add a Parameter for the Angle of Sector

  1. Create Angular Sectors:
    • Use a Number node or Code Block To create the number of sectors. The total angle is 360°, so dividing it by the number of sectors gives the angle per sector.
    • Use the Rotate node to rotate the seating rows to create different sectors of the stadium.

Step 2.4: Model the Stadium Bowl

  1. Create the Stadium Bowl:

    • Use Revolve or Sweep Nodes to create the exterior shape of the stadium bowl. The input should be the profile curve created by connecting points at each tier.

  2. Add Depth:

    • Use the Offset node to create the depth of the bowl, making sure the curve extends inward to form the seating tiers.

Step 2.5: Model Exterior Panels (Optional)

  1. Create Panel Shapes:
    • Create a simple panel family or use a Rectangle.ByWidthHeight node to create the shapes of panels that will be placed on the exterior of the stadium.
  2. Apply Panels to the Exterior:
    • Use the Surface.ByPatch or Array Nodes to place the panels along the outer surface of the stadium, with the number of panels controlled by the angle of sectors and radius.

Step 2.6: Add Parameters for Customization

  1. Create Sliders:

    • Add sliders for each parameter such as the number of tiers, radius, height, number of sectors, and panel size to make the model parametric.

  2. Use Code Blocks:

    • Use Code Block Nodes to calculate the position and properties of the seating rows dynamically. For example: 
      radius = [slider value];
height = [slider value];
numberOfSectors = [slider value];

  3. Link Parameters to the Model:

    • Connect the sliders and code blocks to the relevant nodes to ensure that changing the slider values updates the model in real time.

Step 3: Example Dynamo Script for Parametric Stadium

Here's a summary of how the script logic would be structured:

  1. Create the centre point.
  2. Generate circles for each tier using. Circle.ByCenterPointRadius.
  3. Create grid points on each circle using. Divide Surface.
  4. Generate lines for seating rows using. Line.ByStartPointAndEndPoint.
  5. Use the Rotate node to form sectors and distribute the seating arrangement.
  6. Create the stadium bowl using Revolve or Sweep.
  7. Add panels for the exterior finish using Surface.ByPatch or an array of panels.
  8. Link sliders and code blocks to all parameters for interactivity.

Step 4: Run and Test the Dynamo Script

  1. Run the script in Dynamo to generate the parametric stadium in Revit.
  2. Adjust the sliders to see how different parameters affect the stadium model (e.g., number of tiers, radius, sector angle).
  3. Review the final model in Revit and make any necessary adjustments for further refinement.

Final Thoughts

By following these steps, you can create a conceptual parametric stadium in Revit using Dynamo. This approach leverages visual programming and the concepts of parametric high-rise tower modelling to ensure the stadium is highly adjustable, scalable, and suitable for various design iterations.

Your portfolio, next

Ship work like this
in your own course.

Talk to a career counsellor

Free 20-minute call. We'll map the right course to where you want to work.

By submitting you agree to our Terms and Privacy Policy.