Civil

Structural

SAP2000

What if you could automate this process? With the SAP2000 API and Python, you can transform a traditional workflow into an efficient and seamless one. It is straightforward to generate and define load patterns, combinations, and mass sources through code. Additionally, automation stands out in tasks such as assigning restraints to nodes, generating elements like beams, columns, and slabs, and distributing uniform or point loads. 

**In this blog, we'll explore how to use Python to create frame sections for SAP2000 automatically by reading section properties from an Excel file.** 

By the end, you will have an automated workflow that reduces manual effort and enhances your productivity. 


[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)
 

## Getting Started 

Using the SAP2000 API, we connect to an active instance of the program and define material properties, cross-sectional geometries, and reinforcement details for frames. We'll start with some simple examples of creating individual beam and column sections, and later show how to automate the entire process using data from Excel. 
 

## 1. Import Necessary Libraries 

To begin, we need to import the required libraries: `comtypes` to connect with SAP2000 and `pandas` to read Excel data: 

```python 
from comtypes.client import GetActiveObject 
import pandas as pd 
``` 

## 2. Connect to SAP2000 

Ensure that SAP2000 is open, then connect to the active instance using the following code: 

```python 
try: 
SapModel = GetActiveObject("CSI.SAP2000.API.SapObject").SapModel  
print("Successfully connected to SAP2000.") 
except Exception as e:  
print("Failed to connect to SAP2000. Ensure the program is open.")  
print(f"Error details: {e}") 
``` 

## 3. Create Materials 

In this section, we will first learn how to use the SAP2000 API functions to define materials step by step.  

Once we understand the process, we will move on to a more efficient approach by reading data from an Excel file. This allows us to create multiple materials automatically. 

### Reinforcement Steel 

We must indicate the units with which we will work, using the following code we will define the work units of Kg, m and C, which have the number 8 as a label:


```python 
kgf_m_C = 8 
SapModel.SetPresentUnits(kgf_m_C) 
``` 

Next, we create the material properties this involves setting material type, modulus of elasticity, Poisson's ratio, thermal coefficient, and strength properties for the reinforcement steel grade 60 with a yield strength of 4200 kg/cm² and a modulus of elasticity of 2.0E10 kg/cm². 
```python
material_id = 6  # Rebar

SapModel.PropMaterial.SetMaterial(
    'fy=4200',  # Material name
    material_id  # Material Type ID
)

SapModel.PropMaterial.SetMPIsotropic(
    'fy=4200',
    2.0E10,       # Modulus of elasticity
    0.2,          # Poisson's ratio
    9.90E-06      # Thermal coefficient
)

SapModel.PropMaterial.SetWeightAndMass(
    'fy=4200',
    1,            # 1: Weight, 2: Mass per unit volume
    7850          # Value
)

SapModel.PropMaterial.SetORebar(
    'fy=4200',
    42000000,     # Yield strength
    63000000,     # Tensile strength
    46000000,     # Expected Yield strength
    69000000,     # Expected Tensile strength
    2,            # Stress-strain curve type
    2,            # Stress-strain curve type - Hysteretic
    0.02,         # Strain at Hardening
    0.1,          # Strain Ultimate
    False         # True: Uses Caltrans controlling strain values
)
```

### Read Excel File "SectionData.xlsx" 

We then read section properties from an Excel file that contains all necessary details about the materials, dimensions, and types of frames (beams or columns): 


![SECTIONS.png](https://cms.viktor.ai/uploads/SECTIONS_5320354e33.png)

```python 
df = pd.read_excel("SectionData.xlsx") 
``` 

If you would like to use the same Excel sheet as is used in this blog, feel free to download it [here](https://docs.google.com/spreadsheets/d/1_020QUELIuPpyM4tSomwMEjjA7DE6esq/edit?usp=sharing&ouid=108263379813418635874&rtpof=true&sd=true).

It is important to know the units of the data that Excel contains. 

The column `ID` is the element label, `b` and `h` are the base and height in *centimeters*, respectively, and `fc` is the concrete compressive strength in *kg/cm²*: 


| Type   |  ID  |   b   |   h   |  fc  | 
|--------|------|-------|-------|------| 
| COL    |  C1  |   30  |   60  | 210  | 
| COL    |  C2  |   30  |   50  | 280  | 
| COL    |  C3  |   30  |   60  | 175  | 
| BEAM   |  VP1 |   30  |   60  | 210  | 
| BEAM   |  VS1 |   30  |   50  | 280  | 
| BEAM   |  VB1 |   30  |   60  | 210  | 

 

### Create Concrete Material from Excel Data 

After reading the Excel file, we will identify the unique compressive strength (f'c) values ​​that will be assigned to the frame element sections. Then, we will create a dictionary with the names that each material will have. 

```python 
fc = df["fc"].unique() 
name_material = {fc_i: f'fc={fc_i}' for fc_i in fc} 
``` 

Next, we will start creating the concrete materials, assigning their properties, such as modulus of elasticity and strength, according to specific f'c values. 

```python 
for fc_i in fc: 
    material_id = 2  # Concrete 
    material = name_material.get(fc_i) 
    SapModel.PropMaterial.SetMaterial(material, material_id) 
    E = 15100 * (fc_i ** 0.5) * 10000  # (kgf/m²) 
    SapModel.PropMaterial.SetMPIsotropic(material, E, 0.25, 9.90E-06) 
    SapModel.PropMaterial.SetWeightAndMass(material, 1, 2400) 
    SapModel.PropMaterial.SetOConcrete(material, 2800000, False, 0, 1, 2, 0.0022, 0.0052) 
``` 


[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)
 

## 4. Creating Beam and Column Sections 

Before we move on to automation, let's look at some examples of how to create sections. We'll do an example of a beam and a column to demonstrate the basic workflow. 

**Example:** 

We define a beam section (`BEAM_1`) with the dimensions 0.6 m depth and 0.3 m width and a column section (`COLUMN_1`) with dimensions 0.45 m by 0.45 m, using the `SetRectangle` method.  

Let's not forget that we have defined our work unit in meters and it is important to note that the material `fc=280` must exist.
 

```python 
# Define rectangular section properties for a beam 
SapModel.PropFrame.SetRectangle('BEAM_1',    # Section name 
                                'fc=280',    # Existing material name 
                                0.6,         # Depth  
                                0.3)         # Width  
# Define rectangular section properties for a column 
SapModel.PropFrame.SetRectangle('COLUMN_1', 'fc=280', 0.25, 0.50) 

``` 

### Creating a Beam Section 
`SetRebarBeam` adds longitudinal and transverse reinforcement. 

```python 
# Define rebar properties for the beam 
SapModel.PropFrame.SetRebarBeam('BEAM_1',  
  # Section name 
                                'fy=4200',   # Longitudinal rebar material 

                                'fy=4200',   # Transverse rebar material 

                                0.06,        # Top cover  

                                0.06,        # Bottom cover  

                                0,              # Top left area  

                                0,              # Top right area  

                                0 ,             # Bottom left area  

                                0)              # Bottom right area  

``` 

![Beam_Section (1).png](https://cms.viktor.ai/uploads/Beam_Section_1_ce1454f3ae.png)

 ### Creating a Column Section 

Here, we also specify the rebar arrangement using `SetRebarColumn`, including longitudinal and Confinement reinforcement properties. 

For this, we will work with the data provided in the plan. The column section will measure 0.25m x 0.50m, with 10 longitudinal reinforcement bars of #10 diameter. The concrete's compressive strength will be 280 kg/cm², and the reinforcement steel's yield strength will be 4200 kg/cm². The bars and stirrups will be distributed as indicated in the plan.  

![data column (1).png](https://cms.viktor.ai/uploads/data_column_1_50e057496c.png)

```python 
# Define rebar properties for the column 
SapModel.PropFrame.SetRebarColumn('COLUMN_1',  # Section name 

                                  'fy=4200',   # Longitudinal rebar material 

                                  'fy=4200',   # Transverse rebar material 

                                  1,           # Rectangular pattern 

                                  1,           # Confinement type (ties) 

                                  0.04,    # Cover 

                                  0,           # Applies only to circular columns 

                                  4,           # Number of bars along local axis 3 

                                  3,           # Number of bars along local axis 2 

                                  '#10',       # Longitudinal bar size  

                                  '#5',        # Confinement bar size 

                                  0.125,       # Tie spacing (m) 

                                  2,           # Number of ties along axis 2 

                                  2,           # Number of ties along axis 3 

                                  True)       # To be designed 

``` 

![Column_Section (1).png](https://cms.viktor.ai/uploads/Column_Section_1_1092da95bf.png)

### Automate Section Creation for Beams and Columns Using Excel Data 

First we must change our work units, because the Excel sheet contains information in units of kg and cm 

```python 
kg_cm_C = 14 
SapModel.SetPresentUnits(kg_cm_C) 
``` 

Finally, we automate the process for creating beam and column sections using the data from the Excel file. The script iterates through each row of the DataFrame and creates the appropriate section in SAP2000: 

```python 
for _, row in df.iterrows(): 
    material = name_material.get(row["fc"]) 
    name_section = f'{row["ID"]}-{row["b"]}x{row["h"]}' 
    SapModel.PropFrame.SetRectangle(name_section, material, row["h"], row["b"]) 
    if row["Type"] == "COL": 
        SapModel.PropFrame.SetRebarColumn(name_section, 'fy=4200', 'fy=4200', 1, 1, 4, 0, 4, 5, "#5", "#3", 12.5, 4, 2, True) 
    elif row["Type"] == "BEAM": 
        SapModel.PropFrame.SetRebarBeam(name_section, 'fy=4200', 'fy=4200', 6, 6, 0, 0, 0, 0) 
    print(f'{name_section} {material} has been created') 
```

[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)
 
## 5. Final Code 

For your convenience, the complete code can be found here:  

```python
from comtypes.client import GetActiveObject
import pandas as pd

try:
    SapModel = GetActiveObject("CSI.SAP2000.API.SapObject").SapModel
    print("Successfully connected to SAP2000.")
except Exception as e:
    print("Failed to connect to SAP2000. Ensure the program is open.")
    print(f"Error details: {e}")

# Set units to kgf, m, C
kgf_m_C = 8
SapModel.SetPresentUnits(kgf_m_C)

# Set material properties for reinforcement steel
material_id = 6  # Rebar
SapModel.PropMaterial.SetMaterial('fy=4200', material_id)
SapModel.PropMaterial.SetMPIsotropic('fy=4200', 2.0E10, 0.2, 9.90E-06)
SapModel.PropMaterial.SetWeightAndMass('fy=4200', 1, 7850)
SapModel.PropMaterial.SetORebar('fy=4200', 42000000, 63000000, 46000000, 69000000, 2, 2, 0.02, 0.1, False)

# Read data from Excel
df = pd.read_excel("SectionData.xlsx")

# Create concrete materials from Excel data
fc = df["fc"].unique()
name_material = {fc_i: f'fc={fc_i}' for fc_i in fc}
for fc_i in fc:
    material_id = 2  # Concrete
    material = name_material.get(fc_i)
    SapModel.PropMaterial.SetMaterial(material, material_id)
    E = 15100 * (fc_i ** 0.5) * 10000  # (kgf/m²)
    SapModel.PropMaterial.SetMPIsotropic(material, E, 0.25, 9.90E-06)
    SapModel.PropMaterial.SetWeightAndMass(material, 1, 2400)
    SapModel.PropMaterial.SetOConcrete(material, 2800000, False, 0, 1, 2, 0.0022, 0.0052)

# Change units to kg, cm, C
kg_cm_C = 14
SapModel.SetPresentUnits(kg_cm_C)

# Create sections from Excel data
for _, row in df.iterrows():
    material = name_material.get(row["fc"])
    name_section = f'{row["ID"]}-{row["b"]}x{row["h"]}'
    SapModel.PropFrame.SetRectangle(name_section, material, row["h"], row["b"])
    if row["Type"] == "COL":
        SapModel.PropFrame.SetRebarColumn(name_section, 'fy=4200', 'fy=4200', 1, 1, 4, 0, 4, 5, "#5", "#3", 12.5, 4, 2, True)
    elif row["Type"] == "BEAM":
        SapModel.PropFrame.SetRebarBeam(name_section, 'fy=4200', 'fy=4200', 6, 6, 0, 0, 0, 0)
    print(f'{name_section} {material} has been created')
```
 

Each beam and column section is created automatically, saving a significant amount of time compared to manual input. 

## Conclusion 

The SAP2000 API combined with Python opens the door to streamlined, efficient workflows in structural engineering. From defining materials and creating sections to automating repetitive tasks, these tools help reduce errors, improve consistency, and save valuable time when managing complex projects. 

But this is just the beginning—Python's versatility allows you to enhance every aspect of your engineering processes. Ready to take your automation skills further? Explore how you can create intuitive and shareable web applications to make your workflows even more powerful. Start automation and unlock the full potential of modern structural engineering today! 


large_Frame section creation SAP2000 v2 2.png

medium_Frame section creation SAP2000 v2 2.png

small_Frame section creation SAP2000 v2 2.png

thumbnail_Frame section creation SAP2000 v2 2.png

Frame section creation SAP2000 v2 2.png

In this blog, we'll explore how to use Python to create frame sections for SAP2000 automatically by reading section properties from an Excel file. 


Automate frame section creation in SAP2000 using Python and Excel 

ETABS

## New ETABS & SAP2000 integration

Want to integrate ETABS or SAP2000 into your VIKTOR apps? Our new integration makes it simple to build apps that run ETABS or SAP2000 in the background, with results displayed directly in the VIKTOR interface.

Ready to dive in but unsure where to start? [Check out our tutorial](https://docs.viktor.ai/docs/tutorials/integrations/etabs-sap2000-tutorial/) to guide you through!

![Frame 47.png](https://cms.viktor.ai/uploads/Frame_47_fb7b878eb9.png)

</br>

## Set parameters from a WebView

WebViews just got a major upgrade! As a developer, you can now capture the actions of users (e.g. a selection) within the WebView and automatically send the results to your app's input side, where it can be used for further calculations. 

Ready to set up this interaction? Our JavaScript SDK allows you to send back all parameters with just one line of code. [Learn more in the documentation.](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/html/#interactive-visualizations)

![plotly_interaction.gif](https://cms.viktor.ai/uploads/plotly_interaction_068a1741f5.gif)

</br>

## Developers can now create their own workers

As a developer, you can now set up any third-party software integration with a worker directly for your development workspace - no need for your organization admin to get involved.

Want to get started right away? You can manage your workers for your development workspaces in your user settings! [Learn more in the documentation.](https://docs.viktor.ai/docs/worker/#installation)

![image (2).png](https://cms.viktor.ai/uploads/image_2_325ce73843.png)

</br>

## Community spotlight

This month, we’re highlighting [Build-ing](https://www.linkedin.com/company/build-ing-a-greener-future/)'s Heatwave application, designed to analyze historical data and reveal whether selected areas have experienced heatwaves. Powered by data from the European Space Agency (ESA) within the Copernicus program, this app is definitely worth exploring—[give it a try](https://build-ing.viktor.ai/public/heatwave)! 

<div style="padding:75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1031133589?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="build.ing heatwave application"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

*Would you like to share your application with the rest of the community as well? Please let us know by sending an email to support@viktor.ai!*

## Other changes

**SDK**

- SDK version v14.16.2 is now available: [changelog](https://docs.viktor.ai/sdk/changelog/)

**CLI**

- CLI version v0.41.5 is now available: [changelog](https://docs.viktor.ai/docs/create-apps/references/cli/changelog/)

**PLATFORM**

- Fixed various small issues on the developer dashboard and starter guide 
- Added support for preselecting an app creation method via link 
- Added the functionality to sort by timestamp in the audit data table 
- Renamed the 'get-started' viktor-cli command to 'activate' in the developer activation dialog
- Implemented the app card redesign 
- Changed the link color in tooltips to be more easily readable 
- Fixed the visual builder page not loading 
- Fixed potential login failure due to user duplication on SSO environments during invitation 
- Updated onboarding steps to auto-complete if next step is completed 
- Fix user recreation 
- Set refresh token grace period and handle disconnected clients on SSO flows 
- Added workspaces to the app details page 
- Updated the VIKTOR labs page to include sections for released and beta features 
- Fixed a GeometryView crash when loading non-static geometries 




large_Blog header November.png

medium_Blog header November.png

small_Blog header November.png

thumbnail_Blog header November.png

Blog header November.png

New ETABS & SAP2000 integration, set parameters from a WebView, and developers can now create their own workers. Read more on VIKTOR.ai. 

What's new in VIKTOR (November 2024)


[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)


</br> 

In recent years, Python has undeniably revolutionized how we do structural engineering. Engineers proficient in Python have a distinct advantage, as it unlocks a wide array of possibilities to [automate structural engineering workflows](https://www.viktor.ai/why-viktor/structural-engineering-design) and significantly enhance productivity. 

You may already be aware that Python, combined with the SAP2000 / ETABS API, can be used to pre-process data, generate models, and extract and post-process results. However, did you know that you can take this a step further? In this blog, I will share 6 examples on how you can leverage VIKTOR, a platform to create web applications with Python, to create ETABS / SAP2000 applications that not only automate a larger portion of your workflow but also offer a user-friendly interface in which you can collaborate with colleagues. Let's dive in!  

## 1. Create ETABS and SAP2000 models faster 

As a structural engineer working in infrastructure, buildings, oil and gas, mining, energy, or agriculture, you've likely encountered numerous structures with a high degree of standardization. Common examples include foundations, warehouses, tanks and silos, overpasses, retaining walls, box culverts, chimneys, and transmission towers. 

Rather than creating a new ETABS/SAP2000 model from scratch for each project, a more efficient approach is to develop a parametric application using Python and VIKTOR. This application allows you to define all key parameters of your model, such as dimensions, material properties, sections, and loads, which then automatically generates the model for you. 

One of the major advantages of having an application with a clean user interface is the ability to easily modify parameters and instantly visualize the changes in VIKTOR's 3D geometry viewer. This streamlined process enables you to swiftly run calculations and iterate on your design, significantly enhancing your workflow efficiency. 

![ETABS Tutorial Screenshot.png](https://cms.viktor.ai/uploads/ETABS_Tutorial_Screenshot_d21c3d99e7.png)

## 2. Integrate larger parts of your workflow 

Improving your structural modeling workflow is quite valuable, but I think you would agree that it is only one of many steps involved in a large engineering project. Usually, the bottlenecks and more challenging parts of a project come from collaboration and data exchange between multidisciplinary teams across different engineering domains.  

This is where you can take advantage of VIKTOR’s other integrations, beyond SAP2000 and ETABS, linking multiple analyses to another in one single application.  

</br> 

For example, you could create an app that integrates the mechanical and structural engineering domains. When designing the support for mechanical equipment, you might get the load from an analysis conducted in ANSYS and then pass those loads to SAP2000. All structures require a foundation, so you can also integrate geotechnical information by adding [PLAXIS](https://www.viktor.ai/blog/74/PLAXIS-in-the-Cloud) or SAFE to your VIKTOR app. After the analysis, you can export the design to [Revit](https://docs.viktor.ai/docs/create-apps/software-integrations/revit/) or [Tekla](https://docs.viktor.ai/docs/create-apps/software-integrations/tekla/) and even generate a [custom report.](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/report/)
This way, you can have the inputs and outputs of all domains connected in one app, eliminating the need to go back and forth between multiple teams. 

![Integrations ETABS SAP2000.svg](https://cms.viktor.ai/uploads/Integrations_ETABS_SAP_2000_cc93d8ee29.svg)

## 3. Multi-Objective optimization with ETABS and SAP2000 

In the previous section I mentioned that you can integrate ETABS and SAP2000 apps with other software packages, Excel sheets, Python scripts, and more.  

With that in place, you can take it a step further: run multiple – even hundreds – calculations across all packages to find the optimal design for all kinds of criteria, like minimizing cost, material weight, carbon footprint, and more.  

VIKTOR offers built-in tools for this purpose, like the [OptimizationButton](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/optimization-routine/). With a single click, you can run an optimization routine that tests different input combinations, run your model multiple times with various geometries and cross-sections, and stories and compare the results. Additionally, VIKTOR has multiple visualization options like graphs, tables, 3D models, maps, and more, enabling you to show the data from ETABS, SAP2000 and all the other software packages in a single place so you have a better overview and more insight into the effect of your design choices.  

![Optimization.svg](https://cms.viktor.ai/uploads/Optimization_a99e1ba825.svg)

## 4. Collaboration and data management with ETABS and SAP2000 

Data is an important part of any project, and you will have a ton of it when working on larger projects in which you design several structures or run optimizations. If there is one thing certain, it is that data – like geotechnical input, geometry, loads, and other requirements – constantly change throughout the course of a project. Therefore, managing this data correctly and making it accessible to all stakeholders is an essential part of turning any project into a success.  

By creating an app for your project that integrates with ETABS, SAP2000, or any other third-party software, you leverage VIKTOR’s built-in database with version control. You create a single source of truth for all your project data, which all stakeholders can access by simply logging into the platform. 

For example, in a VIKTOR app you can store different designs, so you can access them any time without losing the data. Moreover, VIKTOR automatically tracks design changes. In your ‘history’ you can see who made changes, what was changed and why it was changed, and you can reload previous design versions if needed.    

Additionally, you can connect different VIKTOR apps using the API so you can, for example, push and pull data directly from and to your app that integrates with ETABS or SAP2000 to another app used by a geotechnical engineer. 

![Collaborate ETABS SAP2000.svg](https://cms.viktor.ai/uploads/Collaborate_ETABS_SAP_2000_e9a36e8be3.svg)

## 5. Create better post-processing tools for ETABS and SAP2000 

For complex structures, it’s often necessary to extract ETABS or SAP2000 models and calculation results from the CSI environment to perform custom or advanced analyses. However, exporting large models into Excel can be cumbersome and time-consuming. 

With VIKTOR and Python, you can manage large amounts of data in an organized manner, avoiding the hassle of managing hundreds of rows and multiple Excel sheets or text files. You can use the results, organize them, and pass them on to other VIKTOR apps for post-processing. In this way, you can focus on the engineering and the awesome part of the project by automating the boring and repetitive tasks. 

[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)](https://www.viktor.ai/why-viktor/structural-engineering-design) 
 
</br> 

Through VIKTOR, you can also access the entire Python ecosystem, so you can create custom visualizations for your clients and users, because let’s face it, no one likes a structural report with hundreds of tables. VIKTOR has a lot of features like [PlotlyView](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/plots-charts-graphs/) and [TableView](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/data-and-tables/), so you can manage your data with Pandas and display it in your web app using Matplotlib and Plotly. It is really a game changer. The best part is that you can have it all in just one shareable app! 

![Picture1.png](https://cms.viktor.ai/uploads/Picture1_49bed6d124.png)

## 6. Make your knowledge scalable 

Most likely, not everyone in your team knows Python – but everyone can use a web app! By creating user-friendly interfaces with VIKTOR, you make your expertise accessible to the whole team.  

Using different [building blocks](https://docs.viktor.ai/docs/create-apps/user-input/) like input fields, visualizations, and interactive components, you can build apps that empower your colleagues to perform complex tasks without needing to code. [Visualizations](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/) such as interactive graphs, maps, and 3D models make the data more comprehensible and engaging. This way, you can scale your knowledge across the team, ensuring everyone benefits from these workflows. 

With VIKTOR, you can create intuitive, user-friendly applications that make your expertise accessible to the entire team. Using [building blocks](https://docs.viktor.ai/docs/create-apps/user-input/) you can create apps with features like input fields, interactive components, and [visualizations](https://docs.viktor.ai/docs/create-apps/results-and-visualizations/), you empower your colleagues to perform complex tasks without needing to code. Interactive graphs, maps, and 3D models make the data clearer and more engaging, helping your team understand and utilize complex information. This way, your knowledge and workflows become scalable, benefiting everyone involved. 

![Collage 1.png](https://cms.viktor.ai/uploads/Collage_1_20e54c3ecc.png)


## Conclusion 

If you’ve made it this far, you’ve seen how integrating ETABS, SAP2000, and [VIKTOR](https://www.viktor.ai/why-viktor/structural-engineering-design) can transform your workflow across various scenarios. From creating models more quickly to enhancing collaboration and data management, the benefits are clear. You can start right away by following this [tutorial](https://docs.viktor.ai/docs/tutorials/integrations/etabs-sap2000-tutorial/).

If you’ve made it this far, you’ve seen how integrating ETABS, SAP2000, and [VIKTOR](https://www.viktor.ai/why-viktor/structural-engineering-design) can transform your workflow across various scenarios. From creating models more quickly to enhancing collaboration and data management, the benefits are clear. You can start right away by following this tutorial and extend it to your own use case.  
 

[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)

</br> 

large_6 ways ETABS SAP2000 blog header 1.png

medium_6 ways ETABS SAP2000 blog header 1.png

small_6 ways ETABS SAP2000 blog header 1.png

thumbnail_6 ways ETABS SAP2000 blog header 1.png

6 ways ETABS SAP2000 blog header 1.png

Boost your productivity in SAP2000 and ETABS with Python and VIKTOR! Learn five strategies to improve workflows, automate tasks, and make your knowledge scalable across your team.

6 Ways to improve your SAP2000 and ETABS workflows 

[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)

Process automation in structural engineering, driven by programming languages such as Python, is growing exponentially due to its ability to minimize errors, reduce time, and optimize results. 

SAP2000 is a finite element software by CSI (Computers & Structures, Inc), used for modeling, structural analysis, seismic-resistant design and dimensioning of structures in civil engineering projects, ranging from bridges and buildings to stadiums and dams. It allows for detailed and accurate simulations. 

While SAP2000 offers a wide range of features, it can take time to perform the initial setup, modeling and extraction of results. To address this, its API allows repetitive tasks to be automated, reducing the likelihood of user error and increasing work efficiency. 

Through the API, several tasks can be automated, including: 

- **Templates:** Define commonly used structural elements. 

- **Preprocessors:** Automate load applications and configurations. 

- **Postprocessors:** Create custom algorithms for project verifications. 

- **Parametric Models:** Script-based model creation and modification. 

- **Custom Plugins:** Develop tools to add functionality to SAP2000. 


## Data Exchange: Bi-directional connections with Revit and other tools. 

CSI's API is currently available for SAP2000, ETABS and CSiBridge, it has been developed to be as consistent as possible between the various CSI products, allowing any tool and/or application to be easily adapted between products. 

In this blog we will provide tutorials to learn how to automate data entry and extraction with the SAP2000 API. 

Let's get started! 

To start you should have Python installed and then configured Visual Studio Code (VS Code).

**Install necessary libraries** 

To properly follow this blog series, you’ll need to install the comtypes, numpy, pandas, and matplotlib libraries. 

You can install numpy by running “pip install numpy” at the command prompt or in the terminal. Similarly, you can install pandas by running “pip install pandas” and comtypes by running “pip install comtypes==1.1.14”.

 
[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)


</br>

## SAP2000 API Documentation 

The SAP2000 API documentation provides the information necessary to use its functions and methods. It includes detailed descriptions of the functions, their parameters and usage examples. 

API documentation is available within the CSI_OAPI_Documentation.chm Windows help file, located in the SAP2000 installation directory. 

*“C:\Program Files\Computers and Structures\SAP2000 24\CSI_OAPI_Documentation.chm”* 

![Imagen1.png](https://cms.viktor.ai/uploads/Imagen1_ab95add901.png)

Every action we perform in the SAP2000 software interface, such as creating a new concrete material, defining a rectangular section, assigning a distributed load to a Frame element, running the model, reading tables, and more, can be performed using Python code. 

**Example Code** 

To start using the API functions the documentation provides an example with Python where a structure is modeled, properties are defined and the analysis is executed to extract the results. To see the code used we must follow the following path in the documentation:  

*Example Code -> Example 7 (Python COM)*

![Imagen2.png](https://cms.viktor.ai/uploads/Imagen2_f3207a2c33.png)

[Here is the example Python file from the documentation](https://drive.google.com/file/d/1IcBCvUueyiHqYmo5ayYBDFFk1bjB9z1C/view?usp=sharing)

You will have to run the code in VS Code and wait... 

![blog-sap2000-1-6.png](https://cms.viktor.ai/uploads/blog_sap2000_1_6_2698c6f1e1.png)

The code will automatically open SAP2000, initialize a new blank model, create a concrete material, define a rectangular Frame section, set up the units, draw the Frame elements, apply node constraints, create load patterns, assign point and distributed loads, save the model, run the analysis, extract the results from the nodes, and finally close the program. 

![image 979.png](https://cms.viktor.ai/uploads/image_979_fe94a95847.png)
![image (17).png](https://cms.viktor.ai/uploads/image_17_45ad84b928.png)


**Let's break down the sample code!** 

The first 60 lines of the example code in the documentation will allow us to open the latest version of the SAP2000 program that we have installed. But I share with you a more summarized version of that code to open SAP2000 with Python: 

```import os
import sys
import comtypes.client

# create API helper object
helper = comtypes.client.CreateObject('SAP2000v1.Helper')
helper = helper.QueryInterface(comtypes.gen.SAP2000v1.cHelper)

# create an instance of the SAPObject from the latest installed SAP2000
mySapObject = helper.CreateObjectProgID("CSI.SAP2000.API.SapObject")

# start SAP2000 application
mySapObject.ApplicationStart()

# create SapModel object
SapModel = mySapObject.SapModel
```

A new model is started using the **New Blank Template, with the option to select other templates such as 'NewGridOnly' or 'Steel Deck'. 

```# initialize model
SapModel.InitializeNewModel()

# create new blank model
ret = SapModel.File.NewBlank()
```

The properties of a new reinforced concrete material called *“CONC”* are defined using the **SetMaterial** method of the **PropMaterial** property of the SapModel object **(SapModel.PropMaterial.SetMaterial)**, according to the documentation the enumeration for the material type Concrete is 2 and for the reinforcing steel is 6.  

To define the mechanical properties and set the symmetry as isotropic, we use the **SetMPIsotropic** method **(SapModel.PropMaterial.SetMaterial)**, the documentation indicates the parameters to enter. 

```# define material property
MATERIAL_CONCRETE = 2
ret = SapModel.PropMaterial.SetMaterial('CONC', MATERIAL_CONCRETE)

# assign isotropic mechanical properties to material
ret = SapModel.PropMaterial.SetMPIsotropic('CONC', 3600, 0.2, 0.0000055)
```
![blog-sap2000-1-9.png](https://cms.viktor.ai/uploads/blog_sap2000_1_9_48896eac86.png)

To create a rectangular section we use the **SetRectangle** method of the **PropFrame** property of the SapModel object **(SapModel.PropFrame.SetRectangle)**. The section will be called *'R1'* and will be associated with the previously defined *'CONC'* material. Its dimensions will be 12 inches by 12 inches. In addition, for defining section property modifiers, the SetModifiers method is used. It is crucial to use the API documentation to understand the necessary parameters.  

```# define rectangular frame section property
ret = SapModel.PropFrame.SetRectangle('R1', 'CONC', 12, 12)

# define frame section property modifiers
ModValue = [1000, 0, 0, 1, 1, 1, 1, 1]
ret = SapModel.PropFrame.SetModifiers('R1', ModValue)
```
![blog-sap2000-1-2.png](https://cms.viktor.ai/uploads/blog_sap2000_1_2_b0e383700e.png)

Note that when defining the mechanical properties of the material and the geometry of the section. By default, we are working in kip, inches, and degrees Fahrenheit." 

To change the unit system, use the **SetPresentUnits** method. This is critical if you need your input/output data in specific units. The documentation lists the enumeration for each type of combination of force, length and temperature units. 

```# switch to k-ft units
kip_ft_F = 4
ret = SapModel.SetPresentUnits(kip_ft_F)
```
![blog-sap2000-1-10.png](https://cms.viktor.ai/uploads/blog_sap2000_1_10_4e3efcf2a8.png)

With the **AddByCoord** method of **FrameObj (SapModel.FrameObj.AddByCoord)** the Frame elements defined by their start and end coordinates will be drawn, and the “R1” section created earlier is assigned to them. To know the necessary parameters, we must use the API documentation. Where the parameters *Name, UserName* and *CSys* are options or default parameters. 
```# add frame object by coordinates
FrameName1 = ''
FrameName2 = ''
FrameName3 = ''
[FrameName1, ret] = SapModel.FrameObj.AddByCoord(0, 0, 0, 0, 0, 10, FrameName1, 'R1', '1', 'Global')
[FrameName2, ret] = SapModel.FrameObj.AddByCoord(0, 0, 10, 8, 0, 16, FrameName2, 'R1', '2', 'Global')
[FrameName3, ret] = SapModel.FrameObj.AddByCoord(-4, 0, 10, 0, 0, 10, FrameName3, 'R1', '3', 'Global')
```
![blog-sap2000-1-21.png](https://cms.viktor.ai/uploads/blog_sap2000_1_21_08c69b38a0.png)

To assign restrictions to a node we use the **SetRestraint** method of **PointObj (SapModel.PointObj.SetRestraint)** but for this we will need to obtain the UniqueName of the Frame node to which we will assign the restrictions, for this we will use the **GetPoints** method of **FrameObj (SapModel.FrameObj.GetPoints).** 
```# assign point object restraint at base
PointName1 = ''
PointName2 = ''
Restraint = [True, True, True, True, False, False]
[PointName1, PointName2, ret] = SapModel.FrameObj.GetPoints(FrameName1, PointName1, PointName2)
ret = SapModel.PointObj.SetRestraint(PointName1, Restraint)

# assign point object restraint at top
Restraint = [True, True, False, False, False, False]
[PointName1, PointName2, ret] = SapModel.FrameObj.GetPoints(FrameName2, PointName1, PointName2)
ret = SapModel.PointObj.SetRestraint(PointName2, Restraint)
```
![blog-sap2000-1-13.png](https://cms.viktor.ai/uploads/blog_sap2000_1_13_31dc4bfc13.png)

To add load patterns the **Add** method of **LoadPatterns** is used. Each load pattern is defined by a name and a load type. Consulting the documentation is essential to understand the enumeration of load types. 

```# add load patterns
LTYPE_OTHER = 8
ret = SapModel.LoadPatterns.Add('1', LTYPE_OTHER, 1, True)
ret = SapModel.LoadPatterns.Add('2', LTYPE_OTHER, 0, True)
ret = SapModel.LoadPatterns.Add('3', LTYPE_OTHER, 0, True)
ret = SapModel.LoadPatterns.Add('4', LTYPE_OTHER, 0, True)
ret = SapModel.LoadPatterns.Add('5', LTYPE_OTHER, 0, True)
ret = SapModel.LoadPatterns.Add('6', LTYPE_OTHER, 0, True)
ret = SapModel.LoadPatterns.Add('7', LTYPE_OTHER, 0, True)
```
![blog-sap2000-1-3.png](https://cms.viktor.ai/uploads/blog_sap2000_1_3_aeda9c8203.png)

To assign forces to a node, we first obtain the UniqueName of the node through the GetPoints method of **FrameObj**. Then, we use the **SetLoadForce** method of **PointObj** to assign a point load to one of the ends of the frame. Distributed loads are applied through the **SetLoadDistributed** method of **FrameObj**. Here, the documentation will guide you to understand the parameters that define the magnitudes of the loads and the directions in which they are applied. 

```# assign loading for load pattern 2
[PointName1, PointName2, ret] = SapModel.FrameObj.GetPoints(FrameName3, PointName1, PointName2)
PointLoadValue = [0, 0, -10, 0, 0, 0]
ret = SapModel.PointObj.SetLoadForce(PointName1, '2', PointLoadValue)
ret = SapModel.FrameObj.SetLoadDistributed(FrameName3, '2', 1, 10, 0, 1, 1.8, 1.8)

# assign loading for load pattern 3
[PointName1, PointName2, ret] = SapModel.FrameObj.GetPoints(FrameName3, PointName1, PointName2)
PointLoadValue = [0, 0, -17.2, 0, -54.4, 0]
ret = SapModel.PointObj.SetLoadForce(PointName2, '3', PointLoadValue)

# assign loading for load pattern 4
ret = SapModel.FrameObj.SetLoadDistributed(FrameName2, '4', 1, 11, 0, 1, 2, 2)

# assign loading for load pattern 5
ret = SapModel.FrameObj.SetLoadDistributed(FrameName1, '5', 1, 2, 0, 1, 2, 2, 'Local')
ret = SapModel.FrameObj.SetLoadDistributed(FrameName2, '5', 1, 2, 0, 1, -2, -2, 'Local')

# assign loading for load pattern 6
ret = SapModel.FrameObj.SetLoadDistributed(FrameName1, '6', 1, 2, 0, 1, 0.9984, 0.3744, 'Local')
ret = SapModel.FrameObj.SetLoadDistributed(FrameName2, '6', 1, 2, 0, 1, -0.3744, 0, 'Local')

# assign loading for load pattern 7
ret = SapModel.FrameObj.SetLoadPoint(FrameName2, '7', 1, 2, 0.5, -15, 'Local')
```
![blog-sap2000-1-16.png](https://cms.viktor.ai/uploads/blog_sap2000_1_16_66ddbf6d15.png)

![blog-sap2000-1-11.png](https://cms.viktor.ai/uploads/blog_sap2000_1_11_d96305aa09.png)

After saving the model using the **File.Save** method, specify the file path with the *ModelPath* variable. 

```# full path to the model
# set it to the desired path of your model
APIPath = 'C:\\CSiAPIexample'
os.makedirs(APIPath, exist_ok=True)
ModelPath = APIPath + os.sep + 'API_1-001.sdb'

# save model
ret = SapModel.File.Save(ModelPath)
```

To run the model analysis the **Analyze.RunAnalysis** method is used.  

```
# run model (this will create the analysis model)
ret = SapModel.Analyze.RunAnalysis()
```

And your model is ready! 

## What's next? 

Using Python is a game changer in structural engineering. If you master the skills to automate your work with Python, you stand out from the crowd. Rather than dealing with repetitive tasks, Python allows you to spend more time creating innovative solutions. 

With VIKTOR, you can turn your Python automations into intuitive and sharable web apps that further streamline your workflow, boost your team's efficiency, and enable you to deliver optimal solutions within no-time.  

[![Structural CTA full width block (1).svg](https://cms.viktor.ai/uploads/Structural_CTA_full_width_block_1_a8400c62f8.svg)
](https://www.viktor.ai/why-viktor/structural-engineering-design)
 



large_SAP2000 and Python.png

medium_SAP2000 and Python.png

small_SAP2000 and Python.png

thumbnail_SAP2000 and Python.png

SAP2000 and Python.png

Discover how to use the SAP2000 API to automate processes and optimize project efficiency with Python.

How to use Python to automate SAP2000 

![Picture2.png](https://cms.viktor.ai/uploads/Picture2_bf7a656ead.png)

In the world of Architecture, Engineering, and Construction, Computer-Aided Design (CAD) has been a go-to technology for decades. While it was a significant breakthrough in its time, it has its limitations, and many industries now find it inefficient and lacking in collaboration. This has led to the rise of Building Information Modeling (BIM), which has brought many benefits to the table. Real-life projects such as hospitals, schools, and high-rise buildings have implemented BIM and have seen significant improvements in their project lifecycle across all AEC disciplines. In fact, industry leaders have also recognized the potential of BIM and have embraced it as a way to enhance their performance.

To give an example regarding the influence of BIM: Shanghai Tower – the tallest building in China - is one of the tallest skyscrapers in the world, standing at a height of 632 meters and 128-stories. The tower's design and construction were made possible using BIM technology. The project team used BIM to model the tower's complex geometry, enabling them to identify and resolve design conflicts before construction began. This resulted in significant cost savings and helped the team to complete the tower on time. In addition, BIM was used throughout the construction process to manage materials and logistics, monitor progress, and ensure that the tower was built to the highest quality standards. BIM also enabled the project team to track the performance of the building's systems and optimize energy efficiency.

Industry leaders in Shanghai Tower project: Gensler (Architecture), Thornton Tomasetti (Structural engineering), Cosentini Associates (Mechanical engineering) And Shanghai Construction Group (Contractors) used BIM to streamline their workflows, reduce errors and rework, and ultimately deliver projects that are more sustainable, efficient, and cost-effective. Additionally, the tower has achieved LEED Platinum certification for its sustainable design and operations.
Shanghai Tower is just one example of how BIM can help architects, engineers, and contractors to collaborate more effectively and achieve better project outcomes. By leveraging the power of BIM, industry leaders like the Shanghai Tower project team are able to avoid critical AEC workflow problems.  

If you are an engineer, you have probably read and heard about it a million times before: Building Information Modeling (BIM). But what exactly is BIM?  And how can it be used successfully within your organization? In this article, we will tell you everything you need to know; from how BIM can be used successfully within the AEC industry, to the latest trends (including BIM 3.0), challenges surrounding this popular design method, and how to overcome these. 



small_pexels-pixabay-302769 (3).png

thumbnail_pexels-pixabay-302769 (3).png

pexels-pixabay-302769 (3).png

Get a detailed understanding of how VIKTOR envisions efficiently pioneering today & next-gen BIM cloud-based Automation! 

BIM innovations in AEC: Building Information Modeling, 3D modeling, Digital twin, and more!

![ezgif.com-resize (1).gif](https://cms.viktor.ai/uploads/ezgif_com_resize_1_6c091d790e.gif)



In simple terms, BIM is a cutting-edge system to communicate information regarding AEC (architecture, engineering and construction).
In traditional AEC design systems, graphical, usually 2D, drawings are used to communicate AEC information to eventually produce printable drawings and specifications of what to be constructed.  A well-known example of this is CAD (Computer-Aided Design) tools, such as AutoCAD (Autodesk) or MicroStation (Bentley Systems). This means that non-graphical information cannot be included in a design and thus must be confined by the experience and intuition of engineers and architects. 

It is safe to say CAD was already a fancy upgrade from the manual labour of drawing designs. However, with the digital evolution of 2D and 3D modeling, the graphical capabilities of communicating information have continued to upgrade beyond just computer-aided design. This is where BIM comes into the picture. 
BIM aims to evolve AEC's traditional systems that are incapable of storing non-graphical information that cause too much room for data discrepancies and losses. How? By combining 3D modeling capabilities with an efficient manifestation and usage of non-graphical information into one holistic system. For example:
In traditional systems, a thick line equals a wall. With BIM, however, a thick line conveys a spatial representation and its metadata, resulting in a wall with specific dimensions, a bill of quantities, supplier information, expected maintenance dates, and more. 

A brief history of BIM: 
The notion of BIM has been around since the 1970s. In essence, BIM is a methodology (approach) for dealing efficiently with data around a model. Under the BIM flag there is a multitude of diverse tools - such as plugins, software packages, applications, and programs - developed by various companies with differing characteristics and qualities, all serving the BIM methodology in their unique ways.  It is quite essential to distinguish between different BIM methodologies and tools, like: Autodesk Revit (architecture), Tekla structures (structure engineering), Openroads (civil engineering)  and more!


What is Building Information Modeling (BIM)?

AEC is a highly sophisticated field with lots of disciplines involved, such as: architecture, structural engineering, HVAC engineering, building management, and many more. Besides, there is room for human error, communication gaps, and poor collaboration among project teams.  Additionally, lack of standardization and quality control measures in design and construction processes have been always part of the AEC nature. Therefore, there is a high frequency of inaccuracy and mistakes. Mistakes can have serious consequences in terms of cost overruns, delays, safety hazards, and quality issues. Usually, it costs an arm and leg to fix the mistakes. Besides the financial burden, it may take ages! 

For example, although the Sydney Opera House is one of the best-known iconic buildings, known globally as a symbol of Australia, its design crucially lacked efficient coordination between participating parties. In 1957, it was planned to be fully constructed within 4 years, using AUS $7 million. However, ultimately it was opened in 1973, consuming 16 years, with a total cost of AUS $102 million.

![operaaa.jpg](https://cms.viktor.ai/uploads/operaaa_8ca4c6dc77.jpg)



BIM aims to reduce error by having a centralized model where all different disciplines come to work together and stay up to date regarding each other's data and processes. Accordingly, any clash between different disciplines could be detected as early as possible in the design phase and much before the execution phases. 
For instance, BIM outplaces 2D drawings of a building with a unified 3D model for all disciplines. Having the geometries / spatial data that belong to architectural, civil and HVAC simultaneously. Therefore, a clash between a beam and a ventilation duct can already be detected early in the design process. Consequently, necessary procedures to avoid this conflict in real life are considered. 

The majority of the AEC pioneers found a huge improvement in switching from CAD to BIM. Gradually, the receptivity of BIM adoption exposed BIM platforms to constant improvement and focus on developing new capabilities for the industry, creating what we can describe as BIM trends! 


BIM for Architecture, Engineering and Construction (AEC)

1. What is parametric design, and how is it evolving
2. Collaborative parametric design: working together for better results
3. How to make tools available to others
4. Active collaboration on parametric design tools
5. Parametric design in a billion-euro project
6. What collaborative parametric design means for you



Parametric design is a design approach that uses flexible models that can be adjusted and solved quickly. The goal is to see the effect of specific choices on your design by just changing the input variables. 

The benefits are:

- **Flexibility:** Parametric design allows you to react quickly to changes at a low cost. Always generate the best solution for your project no matter the time pressure.

- **Better decisions:** Automatically calculate thousands of different solutions, get deep insight, and mitigate risks. Make better decisions and provide more added value to clients.

- **Digital Assets:** Create models and data that are reusable in new projects. Improve them over time, building up digital capital

This white paper is for engineers, architects, project leaders, and innovation and business managers. You will learn how collaborative parametric design in the cloud helps organizations get better results with real study cases such as a billion-euro infrastructure project.
 
Additionally, we talk about how you can transform Python, Dynamo and Grasshopper scripts into user-friendly web apps and significantly impact your organization performance. 

Learn how collaborative parametric design models allow you to work together for better solutions.

Download the white paper and get INSPIRED

This white paper is for engineers, project leaders, and innovation and business managers that want to learn more about what collaborative parametric design can mean for them. Discover more about this new way of working in which stakeholders collaborate to find the best solution for a project.

The Future of Parametric Design is COLLABORATION

Relatively speaking, BIM itself is a fresh concept in the lifespan of AEC. However, over the last years, some trends within BIM have also started their rise. In this article, we have picked the 4 to elaborate on:   


##  1. Parametric design  


![ghdynmao2.gif](https://cms.viktor.ai/uploads/ghdynmao2_48a57f1a11.gif)


Whereas it is both a new born as well as a constantly evolving system, BIM gets constantly exposed to the evolving technology usage in the AEC industry. An efficient design technique that is remarkably manifesting itself thanks to technology nowadays is: [Parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction).   

BIM can project the principles of the parametric design onto the whole design and construction process. Information models developed by BIM enable different involved disciplines (architects, civil engineers, etc ) to take part in the process. Therefore, it is imaginable to consider that involved discipline inputs as parameters shaping the final construction.  BIM easily utilizes tweaking these parameters to reach the best design output (based on your preferences, for example, regarding costs, material usage, and more). The holistic approach keeps it obvious to what extent parameters can be tweaked without causing failures in the parameters from other disciplines. 

The most famous parametric design platforms in the AEC are Grasshopper for Rhinoceros and Dynamo for Revit. Due to the strong capabilities of both platforms, they are an asset to your BIM workflow. Both are node-based programming languages that are easy to grasp by engineers and architects without any programming experience.    

By linking parameters to the design process, designers can create a design system that is inherently more intelligent and efficient. Parametric design allows designers to explore a wide range of design options and iterate quickly, making it a powerful tool for innovation and creativity in the design process. 
For example, Shanghai Tower utilized parametric design extensively throughout its construction. The tower's unique design, with its twisted form and tapering profile, presented significant challenges in terms of structural engineering and construction. To address these challenges, the project team used advanced parametric modeling software to create a digital twin of the tower, which allowed for the testing of various design options and the optimization of structural systems, facade engineering, and glass joints. The team also used parametric design tools to generate detailed shop drawings and fabrication models.




##  2. BIM dimensions

The essence of BIM is adding and efficiently handling more information to the model. Therefore, there is a huge need to find a way of efficiently sorting information. So it is accessible to engineers and decision-makers. As a result, BIM dimensions were introduced to give a better understanding of the model. Each BIM dimension is oriented for a specific theme. While different firms can comprehend the dimensions differently- not internationally verified definitions-, it is agreed upon 7 BIM dimensions: 

![Group 14 (1).png](https://cms.viktor.ai/uploads/Group_14_1_6aa212a450.png)

**BIM 3D**: Manifestation of the geometrical model with its geographical context.

**BIM 4D:** Adding a timeline to the 3D BIM model, leading to allowing for better project scheduling, sequencing, and visualization of construction processes.

**BIM 5D:** Integrating financial data, leading to better cost estimation and budget analysis for the BIM model. This helps project teams to make informed decisions and operate budgets effectively. 

**BIM 6D:** Sustainability and energy efficiency date. 

**BIM 7D:** Building management and maintenance.

While the first three dimensions are concerned with the 3D geometry, the 4th and the 5th are more focused on scheduling and cost management. The new edition of the 6th and 7th dimension bring value to the material life cycle and [building management](https://www.viktor.ai/customer-cases/9/digital-twin-python-bridge). 
Building materials suppliers such as window providers, for example, can provide a BIM model of their product with all the specifications and expected maintenance, data costs, and options. Therefore, it's much easier for contractors to understand the value of the product and its implementation. Additionally, owners now can have an interactive geometry- BIM model where they can have an overview of the building management of an as-built model.

The notion of dimensions gives a vivid impression of BIM structure. However, the question remains whether BIM dimensions are causing high clarity and efficient practicality.  This raises the concern of interested bodies to assess the practicality of the implementation of BIM dimensions in the AEC. 

Adrian August Wildenauer researched the understanding of BIM dimensions by professional firms in his research paper *“CRITICAL ASSESSMENT OF THE EXISTING DEFINITIONS OF BIM DIMENSIONS ON THE EXAMPLE OF SWITZERLAND”*. He states: 



![Group 32.png](https://cms.viktor.ai/uploads/Group_32_8e38ccdc2f.png)



It’s worth mentioning that the notion of BIM dimensions brings value to the process. However, due to the complexity of the AEC, the industry barely implements the 5th dimension, BIM level 2.  Furthermore, each AEC firm is highly subjected to having a distinctive understanding of the dimensions.



## 3. Revolution of plugins

![Group 21.png](https://cms.viktor.ai/uploads/Group_21_2de827855b.png)


Although BIM is meant to be one holistic approach to rule them all, it faced an essential problem due to the diversity of platforms involved. In simple terms, every involved discipline uses a set of software, and each software internally has a set of plugins that bring additional value to said software. This is not an issue, until it’s decided to digitally merge data from different non-natively compatible software. For example: Architects tend to use Dynamo as a plugin for Autodesk Revit, which can be used to model complex geometries. On the other hand, structural engineers may want to use Karamba3D, a plugin for Rhino-Grasshopper, to execute some structural analysis. Sadly, data from Karamba3D is not natively compatible with Dynamo workflow. Which motivates VIKTOR to offer a solution.



## 4. Possible synergies?  

![Group 22.png](https://cms.viktor.ai/uploads/Group_22_9cfd927338.png)


It can be said that each BIM dimension has its own interested AEC discipline. Each professional entity has its own parameters that contribute to the model with various software used to interact with their inputs.  However, to achieve more efficient management of all those who are involved, there was an emphasis on a new mentality of Integrated Project Delivery (IPD). The Integrated Project Delivery approach aims to optimize project goals, minimize waste and maximize efficiency in all stages of the project. This is done by integrating people, systems and business models into the process



Trends in BIM

## Get the white paper

**INDEX**

1. Construction companies and digital transformation
2. Technology trends for a different approach
3. Technology trends in the construction industry
4. A new technology trend for the construction industry
5. Low code for the construction industry
6. The VIKTOR platform
7. What does it cost?
8. How to start
9. What's next?


What are the current trends in digital transformation and how do they affect the engineering and construction industry? 

This white paper is for every engineer, manager, director, or anyone else that wants to learn more about (new) technology trends that help boost digital transformation in engineering and construction, such as BIM, parametric or generative design, and low-code and no-code. 

Discover how web applications can help you find the best solution fast, get the best insights, capture knowledge into assets, and make work more joyful! 






Learn about trends in digital transformation and how they affect the engineering and construction industry.

Download the White Paper and get INSPIRED

This white paper is for every engineer, manager, director, or anyone else that wants to learn more about (new) technology trends that help boost digital transformation in engineering and construction, such as BIM, parametric or generative design, and low-code and no-code. 

Digital Transformation: Engineering and Construction Industry

In 2021,  there was no widely accepted definition of BIM level 3. However, some experts in the industry have started to use the term BIM level 3.0 to refer to the integration of BIM with other emerging technologies, such as sensors, drones, augmented reality, virtual reality, and the Internet of Things (IoT).
This would represent a significant shift from the current state of BIM, which primarily focuses on design, construction, and the higher BIM dimensions. BIM 3.0 would expand the scope of BIM to include the utilization of new technology in the operation and maintenance of buildings and infrastructure, as well as the use of real-time data and analytics to optimize building performance and reduce costs.
It's important to note that BIM 3.0 is not an official industry standard or version of BIM, but rather a conceptual framework that is still being defined and refined by experts in the field.

## New BIM, new BIM challenges

### Interoperability 

![Group 11.png](https://cms.viktor.ai/uploads/Group_11_071e79da17.png)

The modern landscape of BIM depends on multiple software working together as a workflow, even inside one discipline. Different software are being used for different analyses. Each software is developed by distinctive developers, a model can be integrated into different pieces of software for various analyses or reasons. Subsequently, data loss is very expected. Data loss can easily lead to absolutely wrong calculations. which can be very harmful to scheduling and budgeting. Therefore there is a huge need to make sure then the integration between different platforms has highly efficient interoperability. Accordingly, the question is: how to make sure all these platforms can speak to each other with 0%  data lost?
It's worth noting that interoperability issues can arise due to a variety of factors, including software version, format settings, and project complexity, so it's important to test the interoperability of different software combinations before committing to a project.  To partially achieve interoperability, a neutral file format called IFC (Industry Foundation Classes) was developed to easily migrate data between different software. 


### BIM washing

![BIM washing.gif](https://cms.viktor.ai/uploads/BIM_washing_865ffc7fb3.gif)

 Although BIM is gaining huge popularity, New systems need time to be fully utilized inside the AEC workflow. It takes time for professionals to fully grasp the techniques and build the skillsets needed to switch to a BIM workflow. Combining this with the highly competitive environment of the AEC, it's notable that some firms get marketed as BIM competent while their services actually still need to be improved to meet the industry standards. As Bilal Succar - Director of ChangeAgents AEC, Founder of the BIMe Initiative, Head Editor of the BIM Dictionary - describes it: “A BIM-Competent Organization is the one that has consistently delivers (not can deliver) a set of high-quality BIM products and services”
Although, at first, Bilal wrote this blog back in 2011, it’s still relevant in the BIM communities till this day.

In short, to deliver BIM-competent services, professionals need efficient skills + minimum data loss. It’s logical to enable BIM-skilled professionals to build the tools themselves. Therefore, it's important to equip them with a toolset at their disposal to shape the data flow between different platforms. Hence, **VIKTOR is the solution to your challenges!**
While teaching all employees how to use specific tools can be mentally, financially and time consuming, there might be a better and easy-to-apply solution. Simply, having the cloud-based parametric BIM model running behind a super-friendly user interface that everyone can use intuitively.  How?  By having one Python-skilled individual, it is possible to build an app that utilizes the data flow into a parametric model. Hence, the rest of the team will enjoy playing with the parameters to reach the required goal. Additionally, all involved parties can see what happens in a centralized parametric model so there is no conflict happening by adjusting the model locally on the computer and then sending it to the other party.





So, what is next? BIM level 3?

*Remember, it's not about the length of the article - it's how you use it!*

So, to recap, BIM is a holistic approach to dealing with the AEC information. It depends on various software tools that face problems of data loss when used by different disciplines. BIM has the high aim to enhance the AEC and create a better-built environment. Therefore, it is of crucial importance to have an efficient mechanism between its various parts. 
With VIKTOR, you can facilitate this interoperable BIM workflow yourself. Here's how:

-  	Cloud-based parametric design with wider parameters.
-  	Various software integrations, let different software speak to each other.
-  	Digital Twins: Building maintenance and management (BIM 7D).
-  	Automation of boring tasks.
-  	Intuitive UIs.
- 	Apps gallery.


Solve your BIM challenge with VIKTOR!

With VIKTOR, different stakeholders can take part in the BIM process simultaneously. Your parametric model can be hosted in VIKTOR platform, where a multidisciplinary user can parametrically adjust the model. Access is guaranteed to everyone without the burden of sharing a local file between different devices. While users can access the app, monitoring logic is restricted to developers.  For this reason, the logic is kept safe from unwanted tweaks systematically. 

*Could VIKTOR go one step further?*

Yes of course! With the reliance on Python, VIKTOR can utilize various inputs from a diversity of software as parameters into one parametric model on the VIKTOR platform.

![useless2.gif](https://cms.viktor.ai/uploads/useless2_a7f1b8d43b.gif)



Cloud-based parametric design

VIKTOR enables all users to thoroughly exploit the whole BIM ecosystem. Therefore, enlarge the previous ideology (of parametric design) to the whole BIM ecosystem. Meaning, building interoperability and utilizing different platforms to exchange data fluently on the VIKTOR platform.

Data interoperability is a fundamental potential of BIM. The way VIKTOR enables this is by letting software developed by different firms have a common medium of data translation, as well as minimizing data loss. And here comes the rule of Python. For example: VIKTOR has the ability to integrate data with various platforms individually, therefore it has the ability to channel the data in between them.  VIKTOR integrates with all software that allow for external integration. Let’s have one example of the feasibility of two different software ecosystems speaking to each other through VIKTOR!

**Architectural form finding process = VIKTOR + Dynamo (Autodesk)**

VIKTOR is compatible with Autodesk [Dynamo sandbox](https://www.viktor.ai/customer-cases/14/python-dynamo-civil3D-MXroad). The use of VIKTOR with Dynamo in access to Autodesk workflow. It’s mainly used by architects for enabling geometrical manipulations. 


**Structural analysis and design = VIKTOR + RFEM (Dlubal)**

VIKTOR is used by [RFEM ](https://www.viktor.ai/customer-cases/19/web-application-automation-RFEM-python)structural engineers users to provide structural analysis and design alternatives. For example, it's used for calculating fender systems to be performed automatically so that multiple iterations can be done easily. This collaboration is a connection in the Dlubal Software workflow.



Interoperability = VIKTOR + RFEM (Dlubal)  + Dynamo (Autodesk)

![Group 23.png](https://cms.viktor.ai/uploads/Group_23_398610e61b.png)

 
As VIKTOR is having strong integration with both workflows. It is achievable to utilize both software capabilities into one VIKTOR app. Using a VIKTOR app to bridge different platforms was interesting for leading digital engineering professionals. Mark van den Brink,  a Digital Lead at WSP formulated the use of VIKTOR in BIM workflow as: 


![Group 25 (1).png](https://cms.viktor.ai/uploads/Group_25_1_88efd02b7a.png)


Various software integrations: let different software speak to each other

![Group 12.png](https://cms.viktor.ai/uploads/Group_12_455a7faf18.png)


Having a digital twin from an existing building can be very helpful for building maintenance and management. Building digital twin refers to the creation of a virtual replica of a physical building, which can be used for simulation, analysis, and optimization. It involves capturing and integrating data from various sources such as sensors, BIM models, and IoT devices, to create a digital representation of the building and its operations. Building a digital twin has the potential to improve building performance, reduce energy consumption, and enhance occupant comfort and safety. It also enables building owners and operators to make data-driven decisions and predict and prevent potential issues before they occur. Efficient management of an existing building has various benefits, such as: by having an automatic detection of defections (usually reported by sensors) it's easier to lower maintenance costs by precisely pointing out the type of failure, the number of affected elements, defection degree and the life span of each element.  Therefore, costs exclude any unnecessities. VIKTOR offers a way of replacing periodical maintenance visits by offering a  platform hosting the information of sensors and automatic failure detection. VIKTOR is used in Automated measurements to anticipate dilation of the [Binnenhavenbrug](https://www.viktor.ai/customer-cases/9/digital-twin-python-bridge) 



Digital Twins: Building maintenance and management (BIM 7D)

In VIKTOR  we believe that engineers are meant for awesome tasks only.  All repetitive and boring tasks should be automated by emerging technology. VIKTOR  has been used by engineers in automating reporting and calculation of [crane foundations](https://www.viktor.ai/customer-cases/43/how-vinci-yearly-saves-300-days-calculating-crane-foundation-designs) designs and automating the generative design process to[ optimal architectural plan for residential towers](https://www.viktor.ai/customer-cases/37/parametric-design-residential-towers-Cloud). 

In a recent interview with the structure design team in Arcadis Netherlands, about their “Building Structural Design Tool”, VIKTOR automation is valued in allowing engineers to promptly explore more design solutions in addition to having an evaluation of each alternative. Therefore, engineers have the luxury of taking well-informed decisions, without the struggle of doing the math for each alternative.  As described by Michael van Telgen,  senior Design Automation specialist and Product Owner.

![Group 26.png](https://cms.viktor.ai/uploads/Group_26_0df9265076.png)

 Another point was made by Igor Pecanac, Junior design Engineer at Arcadis:

![Group 27.png](https://cms.viktor.ai/uploads/Group_27_7e8792e86b.png)


Automation of boring tasks

![Group 29.png](https://cms.viktor.ai/uploads/Group_29_17402e4b3e.png)


At VIKTOR, our goal is to provide engineers with the best possible user experience, allowing them to devote available time and energy to logic development. That's why we've created a user-friendly and pleasing user interface that comes packed with all the features you need to streamline your workflow. With VIKTOR, you can expect an efficient and seamless experience that allows you to easily navigate 3D models and seamlessly switch to metadata and non-graphical information using our vector tabs. Whether you're a seasoned pro or just getting started, VIKTOR is handy to assist you to achieve your engineering goals. In an interview with Jeffrey van Tol ( BIM Manager at Mobilis) about assisting engineers with VIKTOR:

![Group 30.png](https://cms.viktor.ai/uploads/Group_30_3a5d06bbad.png)


A user interface is also a strong addition to the users as it affords extensive and critical information to be used by decision-makers!  As Igor Pecanac, Junior design Engineer at Arcadis describes it

> **“… So if I want to have less embodied carbon. Then I now know what to focus on. I will probably have the most impact if I change something in my concrete floors. It's also this kind of information that you can give to the structural engineer which can give him the tools to make informed decisions for his next design. Just try to give him as much information as possible while also keeping it user-friendly. You do not want to have 50 pages of information, because nobody is going to read that. You need to keep it concise, but at the same time as much information as possible.”**



Intuitive UIs

In today's fast-paced and constantly evolving world, keeping up with the latest knowledge and trends in your field is essential for personal and professional growth. However, it's not always easy to find the time and resources to stay up-to-date. That's where the power of knowledge sharing and leveraging free resources comes in. By tapping into [VIKTOR's apps gallery](https://www.viktor.ai/apps-gallery/category/all/1), you can view apps developed by fellow engineers. The source code behind these apps is also available, so you can start where others ended and avoid reinventing the wheel!

![ezgif.com-gif-maker (1).gif](https://cms.viktor.ai/uploads/ezgif_com_gif_maker_1_5bd3b061de.gif)


Apps gallery

In conclusion, BIM technology is transforming the way professionals approach construction projects, and the benefits of using BIM software are clear: Efficient collaboration, less waste and costs and better building management. However, to truly unlock the power of BIM, professionals have a huge need to streamline their interoperability and improve collaboration within one team as well as collaboration between teams in different disciplines.

That's where VIKTOR comes in, with the vision to efficiently pioneer today & next-gen BIM cloud-based Automation!  VIKTOR achieves this by the intuitive and user-friendly interface, VIKTOR makes it easy to work with BIM apps and access all the information provided by various software to make informed decisions. And with features like automated clash detection and real-time collaboration, VIKTOR is a game-changer for architecture, engineering and construction teams looking to stay ahead of the curve. So, if you're ready to upgrade your BIM skillset, give VIKTOR a try, and remember to: Automate the boring. Engineer the awesome!
![Group 31.png](https://cms.viktor.ai/uploads/Group_31_22e5013532.png)



Conclusion

How BIM innovations are transforming AEC

The Architecture, Engineering, and Construction (AEC) industry is notorious for its fragmented workflows, with multiple stakeholders often using incompatible software tools to create and manage building data. This results in costly inefficiencies and errors, as data must be manually translated or re-entered between different systems.  To address this problem, Building Information Modelling (BIM) was developed as a holistically well-coordinated workflow for AEC.

The International Foundation Classes (IFC) was developed as a tactic for achieving BIM goals. IFC is an open, neutral file format for sharing digital building information between different software applications. It was developed by buildingSMART, an industry alliance of architects, engineers, contractors, and software vendors. The development of IFC was a collaborative effort, with input from multiple stakeholders in the AEC industry. The resulting standard enables interoperability between different software tools, making it easier for project teams to collaborate and share information. In this way, IFC helps to improve the efficiency and quality of building projects, while reducing costs and errors.

Professionals need to review IFC files in a viewer before linking or even opening them in another BIM modeling software (such as Revit).  IFC viewers are used for visualization and navigation of Building Information Models (BIM) that are saved in the Industry Foundation Classes (IFC) format. IFC is an open standard for sharing and exchanging data between different BIM software applications, but not all software applications can read and interpret IFC files in the same way. Therefore, IFC viewers provide a way to view IFC models in a consistent and standardized way, regardless of the software application used to create the model. IFC viewers allow users to explore the model geometry, review the properties and attributes of objects, and analyze the model's data. They are commonly used in design review, clash detection, and collaboration workflows in the AEC industry.

Here is how it works:

<iframe width="100%" height="600" style="box-shadow: 0 0 0 1px #E0E0E0; border: none;" src="https://demo.viktor.ai/embed/ifc-viewer"></iframe>
</br>

[Click here to try the application yourself](https://demo.viktor.ai/public/ifc-viewer)

During a recent hackathon, our colleague Yannick Macken (Application Developer), developed an [IFC viewer app](https://demo.viktor.ai/public/ifc-viewer) in 4 hours using Python and the VIKTOR platform. With the app, you can import, view, separate, and download the elements of IFC files. The app utilizes the IfcOpenShell (open-source Python library) to enable users to view and interact with IFC files, making collaborating and sharing information between different software platforms easier. Using the VIKTOR toolbox, a filter function has been added that isolates selected IFC elements to get clearer navigation in complex models, in addition to having the ability to download selected elements.

![ifc filter.gif](https://cms.viktor.ai/uploads/ifc_filter_39fc865b37.gif)

The [VIKTOR IFC viewer](https://demo.viktor.ai/public/ifc-viewer) is a demo to embody the potential of using web-based applications for a more collaborative BIM workflow. The app is hosted on our platform and can be accessed by different users simultaneously. With VIKTOR and Python, you can add attributes, and properties and build more custom features to customize the app and reach your goal. The possibilities are endless!  

Keeping up to date with the latest news regarding BIM, IFC, and AEC can be a little bit demanding. Luckily, there is a valuable resource that helped us to build our content. If you're interested in learning more about digital technology in AEC, we highly recommend checking out Lejla Secerbegovic’s channel, [BIM me up!](https://www.youtube.com/@BIMmeup/featured)  Lejla provides informative and insightful videos on these topics that are both educational and entertaining.





large_ifc cover.jpg

medium_ifc cover.jpg

small_ifc cover.jpg

thumbnail_ifc cover.jpg

ifc cover.jpg

Enhancing BIM collaboration with VIKTOR's IFC Viewer web-app. You can effortlessly view and share BIM data with VIKTOR!

Viktor IFC Viewer app, IFC, BIM, Model, Data, Software, Collaboration, Construction, Building, Information, Design, Architecture, 3D, Revit, AutoCAD, COBie, Clash Detection, Visualization, OpenBIM, Digital, Engineering, Standards

Streamlining BIM Workflows: IFC Viewer Saves Time and Money

As technology advances, each emergent technology shapes the ideologies of design strategies in the AEC. It is a fact that the rise of steel shaped the built environments of Manhattan with skyscrapers, marking the beginning of the international style. The innovative side of engineering always involved utilizing new technologies in the process of engineering. With the rise of algorithms and digital innovation a design language of parametric design gained promising momentum for benefiting the AEC. In this article, we are going to discuss a powerful tool of parametric design: Dynamo. How to use it? How to develop cloud-based apps with Dynamo and VIKTOR! 

# Parametric design:

![Group 34.png](https://cms.viktor.ai/uploads/Group_34_e25947dbf0.png)

Let’s start with the general notion of parametric design.
Parametric design is an approach to design where the shape, dimensions, and other properties of a product or structure are determined by a set of parameters or rules. These parameters can be adjusted or modified, allowing designers to quickly generate and explore a wide range of variations and alternatives. Parametric design is commonly used in architecture, engineering, and product design. By using parametric modelling software, designers can create complex and highly customized designs that would be difficult or impossible to achieve using traditional methods. More information regarding Parametric design can be found in our elaborate [article](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction)!  
It is noted that a powerful parametric modelling platform in the AEC industry is Dynamo!

# Dynamo:

![paracircle5.gif](https://cms.viktor.ai/uploads/paracircle5_521836fb1a.gif)


Dynamo is a parametric design tool developed by Autodesk. It can be used to generate complex [BIM](https://www.viktor.ai/blog/100/how-BIM-innovations-transform-AEC) geometries. In addition to modelling, Dynamo has a solid ability to automate repetitive tasks, run analyses like structure, environmental calculations etc.  Since it is a very powerful tool in the AEC, it is under constant development and integration with new plugins and APIs. As Autodesk’s Matt Jezyk describes: 

> “Ian Keough [Father of Dynamo] created it to smooth out building design workflows while he was at Buro Happold in NYC, because he was constantly working between Rhino and Revit transferring data. The basic thesis was we should be able to teach Revit to do computational design in the same way that Grasshopper can drive Rhino.”

# How to use Dynamo?


Dynamo started as a plugin for Revit, and this integration is still the main focus. However, it’s getting integrated with different Autodesk tools like: Civil 3D, FormIt and more to come. Additionally, Dynamo Sandbox is a stand-alone version that runs independently.  Progressively, Dynamo is expanding its added value to be implemented with various software in AEC, allowing for innovative workflows like [Data-driven decision-making](https://www.viktor.ai/blog/37/revit-data-driven-decision-making-app)! 


# So, Why Dynamo cloud-based VIKTOR apps? 


The answer is straightforward: Cloud-based accessibility!
To unlock more capabilities of parametric design, it is interesting to think about democratizing logic. Put simply, having the parametric logic saved on the cloud and giving authorized professional access to perform the computations. Furthermore, an intuitive UI hides the complexity of the logic! 
It is a win-win situation: more professionals can take part in the design process. Meanwhile, the logic is maintained against any unintended modifications. 

# How to Integrate VIKTOR and Dynamo?

Yes, it is time to start the technical discussion, let’s begin with a diagram:

![image correct two.png](https://cms.viktor.ai/uploads/image_correct_two_837f238be8.png)

 
VIKTOR allows for complete integration with Dynamo thanks to the VIKTOR worker. This worker computes the Dynamo model using the command-line interface included within Dynamo Sandbox. The geometry of the model is generated and converted to a mesh, which is rendered and visualized in VIKTOR.

## What is a worker? 

A worker is a program that connects VIKTOR with third-party software to execute tasks and retrieve results through the platform. The worker communicates with the VIKTOR cloud via an encrypted connection, eliminating the need to open public ports on the network. For the Dynamo integration, the generic worker must be installed.

# Build your own Dynamo app with our guided tutorial:

<div style="padding:75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/819529383?h=294fa6f431&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="luukvideo.mp4"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>


Are you curious to build your own VIKTOR and Dynamo app? With our GitHub Dynamo tutorial, you can get a concrete understanding of how it works.  The tutorial contains a detailed step-by-step demonstration of how to build a parametric 3D geometry app yourself. This tutorial will guide you through the process of using Dynamo and VIKTOR to create a 3D model of a basic house, complete with customizable parameters such as the number of houses, width, depth, number of floors, and heights for floors and roofs. Besides the geometry results, the app will provide numerical values of total floor area, total costs, Dutch Environmental Indicator (MKI) and CO2 emissions of each generated result!

[Start now!](https://github.com/viktor-platform/sample-dynamo/tree/Tuturial_read_me)

large_Group 39 (1).png

medium_Group 39 (1).png

small_Group 39 (1).png

thumbnail_Group 39 (1).png

Group 39 (1).png

Adding cloud-based solutions to Dynamo is empowering professionals to streamline their workflows, reduce costs, and improve overall project outcomes.

BIM Automation Made Easy with Dynamo and VIKTOR

In the AEC industry, the conceptual design phase is the first step in the design process, where architects and engineers work to develop initial design ideas for a building project. During this phase, the design team evaluates various design options and makes key decisions that will shape the overall direction of the project. By incorporating cost and sustainability and other considerations into the conceptual design phase, the design team can optimize the design for these factors at an early stage, before significant resources have been invested in developing the design further.

Early-stage design optimization can also help to reduce the likelihood of costly changes or redesigns later on in the project. By identifying potential issues or challenges early on, the design team can make adjustments to the design that will improve its performance and reduce the risk of problems arising during construction or operation. This article will discuss some practical implementations of Early-stage design optimization.

## Look before you leap

The notion of Early-stage design optimization in the AEC is very much like the Design For Manufacturing (DFM) principle in engineering! Where both concepts investigate how a project is developed as an essential point of shaping the final product.  By applying DFM in the early design stages, different stakeholders in the project improve quality while optimizing criteria like cost sustainability and delivery time.  

![P1 Topologic art.png](https://cms.viktor.ai/uploads/P1_Topologic_art_dfb65c3948.png)

Generally speaking, AEC workflows follows these phases. Each phase has its own criteria to meet: 

1.	Conceptual Design: This is the initial stage of the project where architects and engineers work on developing the design concept and layout of the project.

2.	Schematic Design: During this phase, the design team develops the project further by creating preliminary drawings and plans that show the basic layout and scope of the project.

3.	Design Development: This phase involves the detailed development of the project, including the selection of materials, systems, and equipment, and the development of detailed drawings and specifications.

4.	Construction Documentation: This phase involves the preparation of detailed construction drawings and specifications that will be used to build the project.

5.	Construction: During this phase, the project is built according to the plans and specifications developed in the previous phases.

6.	Post-Construction: This phase involves the final inspection, testing, and commissioning of the project, as well as any necessary post-construction activities such as maintenance and repair.

In the fast-paced AEC industry, a frequent issue is moving forward to a new phase without satisfying the requirements of the previous phase, with the assumption that it can be addressed later. However, making modifications to meet the previous criteria in a later phase requires significant effort and usually even might be unfeasible. One effective solution to avoid this issue is to incorporate analysis during the conceptual design phase to optimize the design. By doing so, if the design does not meet the criteria, even a small adjustment in the conceptual phase can lead to a significant solution, preventing the need for costly modifications in later phases.

So, what analysis can help AEC professionals to stay on track? How could these analyses prevent problems? 

## AEC conceptual design phases analyses

It’s common during the conceptual design phase for AEC professionals to do some analyses. Mainly to get a better overview and be able to make informed decisions. For example: 

- Cost estimating: This involves predicting the cost of a building based on its design, materials, and construction methods. It helps architects and builders to stay within budget and identify areas where cost savings can be made.

Traditionally, cost estimation was the most dominant analysis as it had a straightforward impact on the stakeholders. However, due to the rising challenges of the environmental impacts of AEC, other useful analyses can be:

- Energy modelling: This involves simulating how a building will consume energy over time, taking into account factors such as orientation, materials, HVAC systems, and lighting. It helps architects and engineers to optimize building performance and reduce energy consumption.

- Daylighting analysis: This involves simulating the amount and quality of natural light that will enter a building, taking into account factors such as orientation, shading, and window placement. It helps architects to create spaces that are well-lit and comfortable for occupants.

- Thermal comfort analysis: This involves simulating the temperature and airflow within a building, taking into account factors such as orientation, insulation, and HVAC systems. It helps architects to create spaces that are comfortable and healthy for occupants.

It is noteworthy that if any of the analyses performed during the conceptual design phase highlight the need to meet certain standards, it is more practical to address them at this stage. For instance, it would be more reasonable to adjust the number of floors to reduce costs and fit the available budget, rather than keeping the same floors and substituting all fixtures and finishes (walls, doors, windows, floors …etc) with cheaper alternatives in a later phase.

The same principle goes with environmental and energy analyses: 

It is more efficient to adjust the orientation of a residential tower to increase the amount of exposure to natural light (measured in LUX) instead of opting for larger windows or facade openings after the building's structural skeleton has been completed.

These two examples demonstrate the need of having strong analysis that provides decision-makers with the right information at the right time. Therefore, software developers aimed to address this need, especially in tandem with [innovative BIM technology](https://www.viktor.ai/blog/100/how-BIM-innovations-transform-AEC).  While it is easy to find powerful cost estimation software, it is trickier in the environmental and energy analyses counterpart. Mainly, because of different file formats, data transitions between various software, as well as the large file sizes of detailed geometrical files. Luckily, there was a solution that also depends on ‘’early-stage design optimization’’ mindset on a technical level. How?

## BIM LOD, a key to optimization

![P2 Topologic Art.png](https://cms.viktor.ai/uploads/P2_Topologic_Art_1d68447ce6.png) *Image courtesy of theengineeringcommunity.org*


BIM LOD stands for Building Information Modelling Level of Detail or Development. It is a measure of the level of detail and accuracy of information within a BIM model at different stages of a construction project. The higher the LOD, the more detailed and accurate the information in the model is expected to be. Correspondingly, the file size is. 

There are typically five LOD levels ranging from LOD 100 (conceptual design, smallest file size) to LOD 500 (as built- and facility management, largest file size). The use of LOD helps ensure that all stakeholders have a clear understanding of the expected level of detail and accuracy of the BIM model at different stages of the project.

In the early stages of a project, during the conceptual design phases, the LOD is typically low because there is limited detail available. As the design progresses, the LOD increases, and more information and detail are added to the model. The level of analysis also tends to increase as the LOD increases. For example, in the conceptual design phase, a daylighting analysis may only be a rough estimate, while in later design phases with a higher LOD, a more detailed and accurate analysis can be performed. So, the LOD and the level of analysis tend to be correlated, with a higher LOD allowing for more detailed and accurate analysis. While LOD increase gives more accurate results, it is usually assuring the results of the first analyses calculated with lower LOD.  Although this solution emphasizes the importance of low LOD analyses, professionals seek seamless data transitions between various software.

## Topologic by Wassim Jabi

Prof. Wassim Jabi is an architect, researcher, and educator. He is currently a Chair in Computational Methods in Architecture at Cardiff University. Known for his work in the field of computational design and BIM. He has published extensively on the topic. He has also been involved in several international conferences and workshops related to BIM and digital design. In his work, Jabi emphasizes the importance of manipulating and analysing BIM data with low LOD. As he frames it: 

![Jabi 1.png](https://cms.viktor.ai/uploads/Jabi_1_f396911ca5.png)

Jabi and his team aim to address the gap between academia and industry in the AEC. That is why they developed a software called “Topologic”, written in C++, with a Python binding on top that makes Topologic compatible with various BIM software and plugins. Topologic provides different geometrical manipulations and analysis for conceptual architectural masses (BIM LOD 100) that can be super useful for Early-stage design optimization. Such as: Space syntax Analysis, Structural analysis and Building Energy Analysis. Topologic has an innovative approach of utilizing non-manifold geometry in the early stages of BIM to maintain the same geometries even though modifications had taken place!

## Topologic web-apps for quick deployment

Topologic has a Python binding that makes it easier to integrate useful Python packages for AEC software. Therefore, it is compatible with Grasshopper, Dynamo, various AI and ML packages. Additionally, a strong synergy is possible with VIKTOR which can be helpful due to offering web-based accessibility.

Jabi created 2 Topologic and VIKTOR apps that can be accessed through our [apps gallery](https://www.viktor.ai/apps-gallery/category/all/tag/all/1).

### 1. Centrality Analysis App 

![1681552270122.gif](https://cms.viktor.ai/uploads/1681552270122_f51b56dc5e.gif)

A centrality analysis can be useful to get an immediate indication of the most integrated and connected zones in the facility. This analysis can be useful for architects in decision-making. For example:  creating an intuitively accessible building core (vertical circulation zone, which houses the primary vertical transport, such as elevators, stairs, and sometimes mechanical systems, electrical and plumbing systems). It can also help in determining the placement of private areas away from the most central spaces to minimize noise for occupants.

*This Centrality Analysis demo app provides a quick 3D representation of centrality analysis in a building consisting of a platform and two towers.* 

### 2. Shadow Calculator app

To achieve visual comfort inside a facility as well as energy saving, it is essential to have good natural light rates (measured in LUX) inside the facility.  Natural daylighting analysis depends on some factors, including shadow calculations of the location, urban context, and timespan. Usually, architects run these analyses on different proposals to reach compliance with building codes. Moreover, Electrical Engineers (Lighting Designers) use this info to optimize the dependence on artificial lighting systems in shaded areas to balance light levels and energy usage.

*The Shadow Calculator demo app enables users to select the timespan, context, and upload conceptual mass. Then execute the analysis.*

![Topologic gif 2.gif](https://cms.viktor.ai/uploads/Topologic_gif_2_a940a8c00a.gif)

## More apps, more possibilities, more optimizations

Thanks to the Topologic Python binding it can integrate with various analysis software and plugins such as: Ladybug Tools and Green Building XML (gbXML). Ladybug Tools is a collection of free computer applications that support environmental design and education, like solar radiation analysis, microclimate analysis, thermal comfort analysis, daylight analysis, and wind analysis for buildings and urban environments. Meanwhile, (gbXML) was created to simplify the process of transferring building data from Building Information Models (BIMs) to engineering analysis tools, promoting interoperability between BIM and building performance simulation. 

While these analyses are quite useful to have in BIM LOD 100, they might be challenging as well as time-consuming to build.  AEC professionals need a quick interface to run the analyses, as the ultimate goal is early-stage design optimization.  With VIKTOR included in the game, it is possible to avoid building the logic each time. Instead, it is feasible to have Topologic, gbXML open schema and Ladybug Tools scripts running behind the parametric app and ready to be deployed onto customized geometrical or numerical inputs. 

Why stop there? Topologic has proven examples of successfully delivering multi-objective optimizations process. It’s possible to create apps that aim for more optimized BIM workflows!

## Conclusion

In conclusion, technology continues to revolutionize the AEC industry, transforming the way architects, engineers, and contractors approach building design and construction. AEC early-stage optimization has become a critical component in achieving better outcomes in building performance and occupant comfort. 

The AEC workflow has been enhanced with various design phases analyses, such as cost estimating, energy modelling, and thermal comfort analysis. Low BIM LOD has also facilitated better coordination, collaboration, and communication among project stakeholders. 

Tools like Topologic are specifically tailored to make huge use of the early BIM phases. Combining this strong value with cloud-based VIKTOR apps, intuitive UIs, and various software logics can enable AEC professionals to streamline and significantly speed up Early-stage design optimization. These innovative solutions have the potential to unlock new opportunities and possibilities in the AEC industry, paving the way for a more sustainable, resilient, and cost-effective built environment.

small_App preview (2).png

thumbnail_App preview (2).png

App preview (2).png

Professor of the University of Cardiff designs game-changing VIKTOR applications featuring Topologic for Early-Stage Design Optimizations in AEC.

Unlocking Early-Stage Design Optimizations with Topologic and BIM

## The use of Dynamo
Structural designers make extensive use of BIM and CAD software, such as Autodesk Revit and AutoCAD, while road designers use Autodesk Civil3D and Bentley MX Road. Skilled designers automate their workflows in these packages with Dynamo. By creating Dynamo scripts, manual actions can be automated in those structural design software.

Dura Vermeer’s engineers and technical modellers are highly acquainted with those software packages and use Dynamo intensively in their design process. Their experience, expertise, and the concept of visual programming enable them to quickly develop models with Dynamo. However, some needs are yet to be covered: the exchange of data and versioning of that data is challenging.

## Why VIKTOR?

Also, although Dynamo is a very handy tool, it has a learning curve: often only a specialist knows how it works, making other disciplines dependent on the time and resources of these specialized individuals. That’s where VIKTOR comes into play. VIKTOR is a web application development platform for engineers and has a large variety of digital building blocks (digital LEGO) such as integrations with structural design software. VIKTOR’s web applications provide a central database with version control on the data and offers an intuitive user interface where other disciplines can easily use encapsulated expert knowledge. This is also known as: Democratization of Knowledge.

But how do you leverage Dura Vermeer’s existing expertise in Dynamo and VIKTOR’s distribution and data control, one would ask? By building an integration between the two. VIKTOR and Dura Vermeer collaborated and developed a Dynamo-VIKTOR node package: nodes where data can be fetched and pushed from Dynamo to VIKTOR.

## Single Source of Truth
Often the exchange of parameters between the different disciplines takes place via mail or quick hand-drawn sketches, which is not foolproof and can become increasingly risky when many versions and alterations are made. By developing a VIKTOR web application that automatically integrates with different design software, manual output exchanges are no longer necessary. Of course, active communication between the different professionals is still required, but less normative.

### Creating Dynamo scripts
The Dynamo-VIKTOR node package consists of several nodes (in Dynamo terms, a node is a visual representation of methods/functions with only input and output). When properly placed, the nodes can perform a task such as establishing a connection between Dynamo and VIKTOR. The following figure shows a representation that makes it possible to acquire the input parameters of an entity from VIKTOR to Dynamo. Other configurations of these nodes can create alternative tasks, such as getting results, getting files and even pushing data to VIKTOR.

![The Dynamo-VIKTOR node package](/uploads/Dynamo_VIKTOR_node_package_3359b129c6.png)

By connecting these strings of nodes to other Dynamo nodes, actions and even designs can be automated using the design software. These series of nodes is called a Dynamo script. Once the script is executed, multiple tasks that can be used in Revit will be performed. Since Dynamo is not only supported in Revit, scripts can also be developed for AutoCAD, Civil3D, Inventor, etc.

### Using the Dynamo-VIKTOR node package
The video shows the same Dynamo-VIKTOR node package used in both Revit and Civil 3D. The video shows how the cross-section is manipulated using the parameters given in VIKTOR. No external exchange file is necessary resulting in a live connection between all disciplines (in this case the structural engineer, road designer and structural modeller) which is basically practicing the single source of truth principle.

[See here how it's done!](https://www.youtube.com/watch?v=PBBTTD-0HWk)

## Connecting both software and knowledge
The collaboration between VIKTOR and Dura Vermeer has created a difference in which all software is deployed independently. Not only are software packages connected, but also the knowledge of the professionals. Both parties ended up speaking the same digital language, even though their knowledge backgrounds are so different.

In only one sprint (a two-week development period) the live connection between VIKTOR and structural design software was explored and finally established. Further development will most likely yield many more functionalities and applications, as all kind of design software can tap into this single source of truth.

![Dynamo-VIKTOR node package 2.png](/uploads/Dynamo_VIKTOR_node_package_2_d2c946aacc.png)


## A reusable package for future automation efforts
The Dynamo-VIKTOR node package is a very general utility to exchange data between VIKTOR and Dynamo. It is generalised: it can be linked to any VIKTOR app for which credentials are available and any Dynamo script. That is why this is a digital building block that Dura Vermeer can reuse in their future automation efforts. In the long term, VIKTOR can continue to provide digital building blocks with which Dura Vermeer can realize their vision to become the best digital contractor in the Netherlands.

If you are interested or have are any questions or remarks about this development do not hesitate to contact us at: pmadlener@viktor.ai.


large_Dynamo script - tower.PNG

medium_Dynamo script - tower.PNG

small_Dynamo script - tower.PNG

thumbnail_Dynamo script - tower.PNG

Blog_dynamo_python_in_cloud_easy_sharing_accescibility_2

Design and construction of objects requires many disciplines, all with different software programmaes, to come together. By integrating software, such as Dynamo, with VIKTOR, data can be exchanged and automatically generated.

Facilitating design and construction through integration with Dynamo

## Building an application 

During my study and career, I moved from Excel to visual programming tools like Grasshopper and eventually ended up working with Python. Currently, I'm involved in a project where all of these aspects come together. We are making an application to automatically create complex truss structure geometries and perform structural analysis. I am responsible for the Python part, which mostly provides the user interface. Our partner-colleagues from FrameFlux, who have the domain knowledge, work with Grasshopper to design the truss structures and perform the structural analysis. Seeing them work with Grasshopper and talking about it passionately, I got excited to get my hands dirty and play around with it myself. I decided to build an application to parametrically design a facade. In other words, something with a lot of visual feedback, but not too complex. 

![Visual programming in VIKTOR](/uploads/visual_programming_in_VIKTOR_dcc238316b.png)

*An application that allows parametric facade design, built on the VIKTOR platform*

## Visual programming as introduction to coding

As a default, most engineers turn to Excel. However, once you become better at Excel and try to apply more and more complex logic you will find yourself limited. On the other hand, the leap towards coding may feel too great to take. For beginners, coding can be overwhelming. All of the weird words, abbreviations, tons of special characters and, last but not least, all of the colors can give you a feeling of anxiety.

To be able to smoothen the transition of knowing nothing, to knowing something visual programming tools are often used. Like Scratch, probably the most famous example, which introduces the concepts of coding to children (see image below). Or Osmo, which takes this principle to the physical realm.

![Visual programming in Scratch](/uploads/Visual_programming_in_Scratch_50c3d41715.png)

*Visual programming with Scratch*

For me too, visual programming helped a lot. At my previous job I stumbled into it while I was trying to create a Virtual Reality experience in Autodesk 3DS Max, known as Stingray at the time. Despite my experience with Matlab during college, some basic coding principles finally clicked when I worked with the flow nodes of 3DS Max. With some basic building blocks I was able to create complex structures to manipulate the 3D objects on my screen. Pretty awesome! 

![An example of complex structures in Stingray Editor](/uploads/Complex_structures_in_Stingray_editor_07208645d2.jpg)

*Visual programming with building blocks in Autodesk 3DS Max (Stingray)*

## Visual programming as a professional tool

As I learned with 3DS Max, visual programming is far more than an introduction to coding. It truly empowers people to build complex logic, which is unachievable within Excel. I went to explore the possibilities of Autodesk Dynamo and got in touchwith engineers using the tool to automate their calculations or repetitive work: From automating their drawing-sheet outputs to filling data gaps in their models to [parametrically designing](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) a tunnel. In almost all cases the engineers were lone-wolfs who were the only ones profiting from their own scripts. Turning these valuable tools into company-wide assets is even more difficult than turning an Excel-sheet into one, since only a small amount of people know how to operate these scripts.

Another limitation is found within the provided building blocks. With the default building blocks you are limited in what you can build. This hurdle is overcome by allowing users to build custom blocks with code. For what I was trying to achieve at the time, the default blocks were insufficient and because of that it didn’t take long before I was learning how to code. Initially, my goal was to build these custom blocks, but eventually I moved away from visual programming all together.

## Building web applications with Python

With some new skills and confidence acquired through visual programming, I was ready to take the leap towards coding. Enjoying the freedom and flexibility that coding provides, I started to work on web applications from scratch. The goal was to build applications aimed at automating the boring work of my colleagues. To be honest, it never really took off. There was so much to figure out: The logic of the application, front-end, hosting, database management, and what not. It was a relief to discover VIKTOR, which takes away all of the hassle and lets you focus on the logic of your app with its Python binding (I was so charmed about it that it even made me change jobs…).

What I didn’t know back then, but realized during the project I’m working on now, is that this logic does not even need to be written in Python, but could be build with tools like Grasshopper for instance. I think this is really cool! This means that you don’t need to know or learn how to write scary code, but you could build or contribute to a web-application with a user-friendy interface like Grasshopper. This empowers a lot of people (non-coders) to build custom web-applications themselves.

## My facade generator as web application

After some “extensive” searching (hit 4 on YouTube with search terms ‘grasshopper tutorial façade’), I found this tutorial from Parametric House.  They show and explain how to build the script for this from scratch.

![tutorial parametric house building script from scratch](/uploads/tutorial_parametric_house_building_script_from_scratch_6598e0c923.png)

*Tutorial on how to build a script from scratch*

I have to say, I had a lot of fun building it myself. It’s very intuitively to drag the output from one block to the input of another. Also, the flow of your logic is easy to follow. That is if you manage to keep your script small. Because, as my script began to grow, I was reminded of one of the down sides of visual programming: With all the lines and blocks on your screen, it may become difficult to keep a nice clear structure.  

### Integrating Grasshopper with VIKTOR

Once I had the logic of my Grasshopper script in place and after I played around with it a little (it’s very satisfying to move your sliders and see the geometry change), it was time to integrate it with my VIKTOR application. Connecting the Grasshopper script to my application was simply done by uploading it.  

![integrated grasshopper script with VIKTOR application](/uploads/integrated_grasshopper_script_with_VIKTOR_application_b143b3d8ea.png)

*An integrated Grasshopper script with a web-based application on the VIKTOR platform*

### Little coding required

Although you could create most of your logic in Grasshopper, there is no going around it: You will need some Python code to set up your VIKTOR application. However, I kept it really simple and only set up the input fields to resemble the parameters that are required for the Grasshopper script and a little bit of code to visualize the output from Grasshopper.  

As I mentioned before, I know code can be overwhelming for those who are unfamiliar with it. But don’t be scared, and take a look at the picture below. You can see with just how little code my input fields are created, only using Python. If you really can’t handle it though, feel free to scroll down to the end result.

![Python code as setup for VIKTOR application](/uploads/Python_code_as_setup_for_VIKTOR_application_5498dd6e64.png)

*Python code as setup for a VIKTOR application*

### Visualizing the input

My application collects the input from the user and sends it to the uploaded Grasshopper file. The Grasshopper script is triggered and executes its' logic, returning coordinates from triangles extracted from the generated facade. These triangles are easily visualized in my application. 

![Visualization of Python code](/uploads/Visualization_of_Python_code_94c7cf0afc.png)

*Visualization of Python code*

Et voila! All of a sudden my Grasshopper script turned into a professional web application, available to the world! Check out the result here:

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/477572964?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Grasshopper"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

## Grashopper and VIKTOR: A powerful combination

Grasshopper is a great tool for creating complex logic in a quick and visual manner, ideal for those who are not quite ready for coding yet. Grasshopper easily integrates with your VIKTOR web application, empowering Grasshopper users to contribute to applications or even take over most of the coding. Deploying the Grasshopper script is easily done by pushing it to our worker [in the cloud](https://www.viktor.ai/parametric-design-software).  

In other words, VIKTOR and Grasshopper is a powerful combination of visual programming and code, empowering a whole new group of people to contribute to [online web application development](https://www.viktor.ai/parametric-design-software).









medium_grasshopper building blocks - resize.png

small_grasshopper building blocks - resize.png

thumbnail_grasshopper building blocks - resize.png

Blog_grasshopper_parametric_design_9

Some projects require different programming tools, from Excel to Grasshopper and Python, to come together. With the VIKTOR web application, these tools can easily be integrated with each other. 

Parametric design in the Cloud with Grasshopper

## Dike design tool Wilma: a new, digital way of designing

The Wilma dike design tool on the VIKTOR platform is a renewed design environment for the geotechnical consultant developed by the Graaf Reinaldalliantie on the Gorinchem-Waardenburg dike reinforcement project.

The innovation consists of the combination of the cleverness and insights of the designer and the infinite computing power of the computer via the VIKTOR platform. In the Wilma tool, the design software (D-series and Plaxis) for the various design mechanisms is integrally linked and the data is centrally managed in accordance with the BIM philosophy. Changes in starting points or information can therefore be made transparent very quickly, so that the design can be adapted quickly. The flexibility that this provides in the design process has already proven itself within the dike improvement project.

## A challenging project

The Graaf Reinaldalliantie was established to strengthen the river dike between Gorinchem and Waardenburg. The alliance consists of the Water Board Rivierland and the contractor consortium ‘Waalensemble’ consisting of Heijmans, GMB and de Vries & van de Wiel. Royal HaskoningDHV is associated with the alliance as an advisory party. This dike improvement project is approximately 23 kilometers long and is particularly complex in terms of tasks related to reinforcement. Not least because of the highly heterogeneous soil structure, which was created in the past on the north side of the Waal by the many old river channels and fillings, the diversity of soil layers and the filling in at the site of old dike breaches. The dike body itself also varies in structure due to the construction of the dike over the centuries and the reinforcements and relocations of the past decades. In order for this dike section to meet current safety standards, several improvement measures are needed that, together with the built environment, the soil conditions and the transition to undrained modeling, make it a very challenging project.

## Taking initiative
In the tendering phase of the Gorinchem-Waardenburg (GoWa) dike reinforcement project, Waalensemble took the initiative to perform the design calculations in a smarter, more efficient way. This is based on the positive experiences from previous Heijmans projects (Wilhelminakanaal, Wintrack) where repetitive design issues in particular were efficiently automated. In these examples, design software (D-Series, SCIA, Excel) is linked by means of assumptions and existing equations, resulting in an automated process. This principle has been adopted by the Gorinchem-Waardenburg dike improvement project, further elaborated and further professionalised through the availability of the VIKTOR platform, among other things. The Viktor platform makes it possible to link design software in a much easier way and with extra functionality than was previously possible in the aforementioned Heijmans projects. During the project, the functionality of the dike design tool was expanded in various versions with settlement and failure mechanisms such as macro stability, piping and overtopping, which can be calculated simultaneously per cross section, for both embankments and dike relocations. An example of a schematic of a profile is shown in the picture below.

![An example of a cross section schematized by Wilma with a crown displacement and inward embankment in a D-GeoStability calculation.](/uploads/Cross_section_schematized_by_Wilma_8ed53a86da.png)

*An example of a cross section schematized by Wilma with a crown displacement and inward embankment in a D-GeoStability calculation.*

### The first development
The first development motif arises from the request to support the designer in achieving a higher quality of the stability calculations. The application of the undrained CSSM model requires a schematisation with boundary tensions and a course of the effective tension due to changed water levels and previous loads. Within the functionality of the then available D-GeoStability version 18, this required a far-reaching division of the soil layers with additional stress calculations by the designer. The first version of Wilma has been developed to achieve an accurate calculation of the stresses and to develop an efficient method to include these results in the D-GeoStability model.

### The second development
After a successful application of the first version, the second development started almost immediately. The functionality has been extended to centrally manage the input and output of the various design software. This is in line with the BIM method for quality assurance and version management. In a design analysis, the geotechnical properties per soil layer and the derived parameters that are determined by means of a calculation method, always originate from Wilma and are independent of other design calculations. The old and the new process diagram, where the design tool is central, is shown here:

![Traditional vs Parametric vs Generative designwilma design process (1).svg](https://cms.viktor.ai/uploads/Traditional_vs_Parametric_vs_Generative_designwilma_design_process_1_dcdd3d64a0.svg)


*Traditional design process versus new design process with Wilma.*

From this central position, Wilma compiles the input files and sends them to the existing design software, such as the D-series or Plaxis. The results from the design software are then collected and presented via the tool. By automating the data flow in the design process, the effort for the designer has shifted from drawing up calculation files to supervising the quality assurance of the calculations and assessing the results.

[![CTA_start_using_PD](https://cms.viktor.ai/uploads/solutions_page_banner_4_f474c9c318.svg)](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction)


## A new design methodology
The greatest gains, however, come from a different design method. The traditional design method is based on the manual input of cross sections by a consultant, which forces planning to make choices about how many cross sections can be calculated. In a complex project such as this dike improvement, this quickly means that major simplifications are needed to realise a design within time and money. One calculation that is normative for hundreds of meters of dike is common. As a result, the design is over-dimensioned, which in principle is not wrong from a safety point of view, but does lead to strict and heavy measures that affect the environment and are therefore not always desirable from stakeholders.

### An automated way
A new automated way of calculating means that it will be possible to calculate a very large number of cross sections, instead of one standard profile. In theory, a transverse profile can be calculated with possible variants for each dike stretch where a different situation arises. This is shown schematically in figure 3, where each block represents a new situation.

![The schematic choice for a standard profile (red) or several representative profiles (yellow)](/uploads/the_schematic_choice_for_a_standard_profile_red_or_several_representative_profiles_yellow_1acc3b2033.png)

*The schematic choice for a standard profile (red) or several representative profiles (yellow)*

The ability to design a large number of profiles provides the following benefits:

1. The consultant needs considerably less time to calculate cross sections, which means more time for interpreting and analysing results and translating them into the design. This leads to great efficiency.
2. There is the possibility to perform sensitivity analyses in a simple manner with all kinds of starting points, so that a better insight is obtained which parameter influences the calculation result. This makes it possible to conduct targeted additional research quickly.
3. The calculations were adapted and carried out very quickly. While changes in the traditional design process can have major consequences for the interfaces of the design, this is no longer a problem due to all the connections built up in Wilma. Adjustments to the design or starting points can now be directly calculated for the entire route.

### Qualitatively better design
All this results in a qualitatively better design, whereby freedom is created in choosing a design solution based on the calculation results. It is therefore no longer necessary to funnel the output data in advance to compose a benchmark profile, because making the assessment is more extensive than designing an additional profile. In addition, the thinking for weighing up the various possible normative aspects is retained in the result of an additional design profile. The figure below shows this as an example through sketches and illustrations, in which the dike sections are the product of a normative cross section and the white line represents a possible design profile that, as is to be expected, more closely follows the soil structure found. Because the design profile of the white line has actually been calculated, it is possible to choose a more average design profile that fits better in the landscape. The robustness of the design is known at that time.

![The division into dike sections with a schematic representation of the design assignment.png](/uploads/The_division_into_dike_sections_with_a_schematic_representation_of_the_design_assignment_7ac20fa4a5.png)

*The division into dike sections with a schematic representation of the design assignment*

### Inclusion of additional soil research
An additional positive effect is that carrying out additional soil research now pays off because it can be processed more easily in the built-up subsurface model. With the traditional design method, additional soil investigation is often intended as a risk mitigation to verify the subsurface model. This advantage remains, however, with the design method with Wilma, the additional research is immediately included in the calculations and the design is adjusted.

## Quality assurance

### Processing results
Quality assurance of the design calculations is not formally included in Wilma. The role of the tool is to compile and start the calculations and to process the results. These design calculations are always performed with the original (and therefore validated) design software. For example, a stability calculation is performed in D-GeoStability, after which the files are also available, in such a way that it looks like a colleague has supplied the calculations. Each calculation is delivered separately from the tool and manually checked by the designer. This workflow of the calculation files also makes it possible to deliver and view the design without having Wilma.

### Centralized storage
The quality assurance of the design calculations has deliberately been left with the designer. However, the design tool makes it easier for the designer to perform the checks. Firstly, because the process of illustrating through schematics, calculating and checking is almost continuous because the lead time for a design calculation is next to nothing. In addition, Wilma can compile overviews of the required control points. All basic principles and relationships important for the design can be checked because the results are stored centrally and are available to everyone.

An example of a simple check is a graphical representation of the stresses in the soil layers or the assignment of the rise height to soil layers. Such a control screen is shown in figure 5. The calculated values ​​are presented for each black-marked point in the design profile. The applied calculation values ​​can be checked at a glance because the assumptions and equations have been consistently and unambiguously applied by Wilma on the basis of the predefined protocol. There are no quality differences due to the preparation of cross sections by several consultants.

![Customer_case_calculations_with_cloud_computing_5](https://cms.viktor.ai/uploads/A_control_screen_in_Wilma_for_the_determination_of_the_boundary_voltages_7a07277148.png)

*A control screen in Wilma for the determination of the boundary voltages.*

### Background testing
In order to properly verify Wilma’s work processes, various tests have been built into the Viktor platform during the development of the tool. This checks in the background whether the routines carried out by Wilma always run in accordance with the geotechnical specification. These tests roughly consist of three categories:

1. Rules of thumb; the obvious design rules are checked. Because Wilma applies standard rules, contradictions can arise, as a result of which the schematization steps are correct in accordance with the “design rules”, but the schematization as a whole is geotechnically incorrect. An example of such a test is the descending height to the hinterland.
2. Realistic modeling with fully elaborated schematics of calculations and links. When going through these tests, the routines must always give the same results.
3. Edge cases with exceptional cases to test the routines of the schematisation. During these tests, unrealistic situations are presented from a geotechnical and hydraulic engineering point of view. This ensures that the routines and rules of thumb are robust and that new exceptions are noticed.

By continuously testing with both realistic modeling that is expected within the project, and with edge cases, the behavior of the tool becomes predictable, so that the quality control focuses on exceptions. These exceptions in turn complement the design routines. The systematic elaboration of these exceptions in a design rule results in a more substantiated design methodology and the percentage of exceptional cases is further reduced. This continuous development of the design tool with the insertion of exceptional cases has resulted in the design capacity increasing quadratically. This increase is based on the difference between the number of design profiles per consultant in the exploration phase and the plan elaboration phase.


## The next step
The tool is currently being further developed for more geotechnical functionalities and applications throughout the design process. The possible future expansion of the functionality of the tool can be sought in expanding the tool in the field of computing in the cloud, but also in adding IoT data from sensor technology in dikes. Both seem far away for now, but will sooner or later enrich the world of the civil industry.



large_A parametric design calculation tool for dike improvement - resize.jpg

medium_A parametric design calculation tool for dike improvement - resize.jpg

small_A parametric design calculation tool for dike improvement - resize.jpg

thumbnail_A parametric design calculation tool for dike improvement - resize.jpg

Customer_case_calculations_with_cloud_computing_9

See how parametric design is used in a web application to help with the reinforcement of the GoWa dyke in the Netherlands. Read more on VIKTOR.ai.

Parametric design calculation tool for dike improvement

A parametric design calculation tool for dike improvement

It is impossible to conceive any large project without hundreds of different models in CAD software such as Autodesk. The "manual" work of today consists of many mouse clicks behind a desk. Most skilled modelers have improved their workflow by automating parts of their work, reducing the number of clicks and saving time on large projects. 

## The advantages and disadvantages of Dynamo 

One of the most beloved tools by modelers to automate their work is Dynamo, a visual programming tool. By no longer requiring programming experience, it makes automation more accessible and allows modelers to quickly automate repetitive tasks. The engineers at Arcadis are clearly aware of the many advantages this provides, as many of them use Dynamo a lot in their work. 

However, Dynamo also has some disadvantages. Since it is very easy to start with Dynamo, it is also very easy to make complex models resemble big knots that can be very difficult for someone else to untie. 

Much like a very complex Excel sheet made by somebody else, these complicated models are very difficult to share among co-workers. So, everybody tends to make their own program, as this is usually faster than understanding how to use somebody else's.  

## Use it, without breaking it 

This is where VIKTOR comes in. VIKTOR is a web application development platform with a Python framework. Amongst others, it has an integration with Dynamo. VIKTOR enables easy sharing of Dynamo [parametric design models](https://www.viktor.ai/parametric-design-software) with your colleagues. It provides an easy-to-use user interface that asks for input and shows the results. This allows you to use a model you don’t know, without being afraid to break it. You don't need to learn another new tool, or program, and you can use models from your colleagues easily. Obviously, this can save enormous amounts of time. Furthermore, this can prevent mistakes from happening as you can polish one model rather than having ten different versions made by ten different colleagues floating around. Indeed, as soon as you finish it, the app is instantly available online. Additionally, providing access to colleagues is easy and fast. 

## Finished by lunchtime 

Arcadis has proven the development speed by converting some of their Dynamo models to VIKTOR-based interfaces. A day was setup where some of their engineers met with people from VIKTOR to move some of their most used projects to the VIKTOR platform. The expectation was that it would be a lot of work and they set aside an entire day for it, but in reality, they were finished by lunchtime. 

The main advantage for Arcadis is that the skills of their engineers are now easily transferable. There is no steep learning curve and no need for inhouse web-development. All they needed was their existing Dynamo knowledge and 10 to 20 lines of Python code that are mostly reusable. 


## From spaghetti to just three sliders 

In a single morning they managed to create two web apps from their Dynamo projects. Both are shown here. The first generates a design for a Highrise building based on three parameters. The second generates a model of a Dome with four parameters. 

 ![inspriational 1.jpg](/uploads/inspriational_1_356d1c6f86.jpg)

*A design of a Highrise building based on three parametesr*

![Slide1.PNG](/uploads/Slide1_8f4b1ecab4.PNG)

*A model of a dome based on four parameters*

As you can see, the Dynamo code is not very intuitive. In the presented ‘spaghetti’ it is not easy to understand what is happening and what you need to do. To someone that is not ‘in the know’, it will take time and explanations to be able to use it. Confusion and mistakes are likely. 

Below, we have the VIKTOR web-app. This is the same Dynamo code, just with a wrapper around it. In this case, it is very easy to understand what is happening. There are three parameters. Based on those, a design for a building is generated and visualized within the same screen. Almost no explanation is needed to be able use this, even someone that never used Dynamo could figure it out alone in a few minutes. This allows tools and knowledge to easily be shared within teams and within a company. No need for everyone to build their own version and to reinvent the wheel. One model is enough. 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/563612861?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="LinkedIn_Tower"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

<iframe src="https://player.vimeo.com/video/513789510" width="640" height="564" frameborder="0" allow="autoplay; fullscreen" allowfullscreen></iframe>

**Automate the boring. Engineer the awesome!**



thumbnail_Dynamo and arcadis.jpg

Dynamo and arcadis.jpg

Find out how you can use Python to share Dynamo models with colleagues & facilitate collaboration on VIKTOR.ai.

How to share Dynamo models in the Cloud with Python

Dynamo and Python in the Cloud for easy sharing and accessibility

## Data-driven decision-making with Revit 

Revit is a software package for BIM (Building Information Modelling) that can be used to build 3D design and construction models, much alike Tekla. Revit is an excellent tool for those in need of software for collaborative and multidisciplinary design processes. It provides access to intelligent and model-based processes to plan, design, construct, and manage buildings and infrastructure and is therefore a popular tool for companies in the Engineering and Construction industry. Especially for people from different disciplines, like Architecture, Engineering, and Construction, Revit is a great tool to facilitate working together in a collaborative design environment. 

Besides using Revit to generate and optimize design models, you may also want to use it for other purposes, such as getting better insights, enhancing decision making, and managing your projects. But how? Unfortunately, Revit’s database is hard to access, and therefore you will need other tools to acquire this information. The solution is building your own application with VIKTOR that you can use to automate and optimize design and provide simplified interactive insights from source applications such as BIM360, Relatics, Primavera, Excel, and Revit. This way you are not only able to use your source application’s software for automated and optimized designs, but also have access to a dashboard where you can view, analyse, compare, and check all project data. 

![appdashboarding.png](/uploads/appdashboarding_b78867e415.png)

*Dashboarding with interactive graphs, charts, and tabels in a VIKTOR application* 

## Great potential, little accessibility 

Especially compared to other software packages, Revit software is more data-intensive and can be used to build more sustainable designs. Where AutoCAD is most used for the creation of 2D drawings, Revit can also be used for modelling, cost schedule generation, collaboration, and change management.  

### Specialists required 

Although software programs like Revit are very handy design tools, they do have a learning curve: Often only a specialist knows how it works. This makes other disciplines depend on both time and resources of these specialized individuals. Additionally, when working with design software, models are normally built manually. For example, when you design a house, you draw the roof, the walls, etc. one-by-one by hand. This could really slow down a project if something needs to change or if mistakes are made, because in that case everything needs to be redesigned manually (by the specialist) as well. On top of that, Revit does not provide its’ users with an option to extract, view, and analyse data from its’ database, which causes a lot of valuable insights to become lost. 

### Black box 

Even though Revit is a very data-intensive software program, the contents of its’ database remain a mystery to users. It is clear that when it comes to design features, Revit is already a popular tool for many companies. However, many software programs like Revit are also black boxes and in order to access the information that is hidden inside, a tool is needed to extract, visualize, verify, compare, and analyse data from a source application. Only then, the full potential of a software program is unlocked, and data can be used to optimize not only the design process, but other processes as well. 

## Great potential, lots of accessibility! 

Luckily, there is a solution to both problems. By building a web-based application for any part of your workflow on the VIKTOR platform, you can integrate with every source application you want. Because VIKTOR is a platform made for engineers, it has a large variety of digital buildings blocks (like LEGO’s), such as integrations with structural design software like Revit and Civil 3D. VIKTOR web apps provide a central database, where data is provided with version control, and an intuitive user-friendly interface where other disciplines can easily use encapsulated expert knowledge. Additionally, the interface provides you with a customizable dashboard where you can visualize interactive results to clearly interpret, analyse, and compare data. You can also quickly and easily generate and optimize designs based on a few input [parameters]https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction). This way, you can become the specialist yourself and also use data from your source application to create more value on projects!

![Iconsicions.png](/uploads/Iconsicions_577d386566.png)

*Turn your knowledge into asset!* 

### Become the specialist 

If you build an application on the VIKTOR platform that integrates with a software program, you can create a customized interface that you can use to control your source application. That means, if you integrate with Revit, you can work with Revit software without actually having to open Revit or have it installed on your device at all.  

Because applications on the VITKOR platform are based on [parametric design methods](https://www.viktor.ai/parametric-design-software), you don’t have to (hire a specialist) to calculate your designs manually any longer. Based on only a few input parameters and a set of additional requirements, you can use your application to generate the most optimal design for you within moments of time, that can easily be collaborated on or shared with others. 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/574320490?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="DV_Dynamo-VIKTOR_nodes_ViktorUBak_v3 (online-video-cuttercom)"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> 

*The creation of a design model through an integration with Revit, Civil3D, and Dynamo on the VIKTOR platform* 

### Unlock full potential 

If you integrate a source application with your custom application on the VIKTOR platform, you immediately gain access to the source application’s database. Using [Machine Learning](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction) algorithms, your application analyses data from all previous projects you have been working on. Based on that experience, the application automatically builds analytical models on demand. Since the applications learns from previous input, the more data and iterations (from different disciplines) you feed the application, the more specific these outcome predictions will become.   

![appgrowth.png](/uploads/appgrowth_bd9a589fc0.png)

*Improve your learning-curve!* 

Using this information, data can be visualized and used to communicate things clearly and effectively. You can customize your dashboard and visualize the desired data in the form of interactive graphs, plots, and infographics. For example, to: 

- Test whether objects meet the required standards 
- Apply [Artificial intelligence and Machine Learning techniques](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction) to analyse and transform data 
- Use knowledge you gained from one project and apply it to another project (optimize and predict processes) 
- Make complex data more accessible, usable, and understandable 
- Compare results 
- Get valuable insights 
- Enhance decision-making 
- Anticipate errors 

Additionally, you can integrate with multiple source applications, connecting tools and data from several projects. Especially once you start expanding your database this way, you can really start applying your knowledge and improve your learning-curve! 

![App previewintegration.png](/uploads/App_previewintegration_af3d49db4b.png)

*Integrate with as many software programs as you want to expand your database!* 

The first step to data visualization is the extraction of data. A powerful tool that is especially created as a plug-in on Revit, which allows for the extraction of data to different platforms (Excel, Access, Microsoft SQL, MySQL, and SQLite) and data serialization formats (Json, XML, HTML, etc.) using the standard nodes or packages, is Dynamo. Read more about how Revit’s structural design software can be used, specifically through this [Dynamo plug-in, on the VIKTOR platform](https://www.viktor.ai/blog/12/web-application-python-Dynamo-civil3d). 

See how you can [build your own parametric design application](https://www.viktor.ai/parametric-design-software) now!

 


small_appRevit - VIKTOR (1).png

thumbnail_appRevit - VIKTOR (1).png

Blog_data_driven_decision_making_revit_2

Software programs are used to automate and optimize object design, but what about data-driven decision-making? With VIKTOR you can easily build your own apps to automate and optimize design and extract, visualize, and analyse data for valuable insights! 

Data-driven decision-making with Revit

## Pros and cons of Grasshopper

Grasshopper is a strong tool when it comes to 3D modelling and quickly developing scripts to manipulate geometries. Grasshopper seamlessly integrates with Rhino, which makes it possible to visualize changes in 3D models immediately, and is famous when it comes to architecture and BIM. Over the past years, different plug-ins have made it possible to integrate Grasshopper software with other software as well. 

However, sharing Grasshopper scripts internally is difficult, and externally impossible without revealing any of your source code. Additionally, managing and processing large amounts of data or performing numerical calculations and matrix operations for the optimization of designs can be difficult as well. 

## A Grasshopper web app 

That is why VIKTOR enables the development of web applications that you can use to link Grasshopper models to an interface and share these with internal and external users without requiring any downloads or knowledge about Grasshopper.

In this article, we give an example of such an application. You can find the open-source Python code in our [GitHub repository](https://github.com/viktor-platform).

## Using the functionality 

You can use the code out-of-the-box with VIKTOR.

When using the web app with VIKTOR, you should:

1. Make sure you have Rhino installed at ``C:\Program Files\Rhino 7\System\Rhino.exe``
2. Install a generic worker found on https://docs.viktor.ai/docs/worker. Make sure you select ``generic``.
3. Replace the config.yaml file in your worker folder with the file found at ``app/grasshopper/data/config.yaml``.
4. Copy the file found at ``app/grasshopper/data/run_grasshopper.bat`` in the same worker folder.

Below, you see a snippet of the Python code that shows how little lines of code are needed to run Grasshopper analysis and retrieve files. 

```python
# Run the analysis on grasshopper
generic_analysis = GenericAnalysis(files=files, executable_key="run_grasshopper,output_filenames=["output.txt", "output.obj", "output.mtl"])
generic_analysis.execute(timeout=300)

# Retrieve all files from the analysis
grass_hopper_data_bytes = generic_analysis.get_output_file("output.txt")
object_file = generic_analysis.get_output_file("output.obj")
material_file = generic_analysis.get_output_file("output.mtl")
```

In the video, you can see how a football stadium is [parametrically created](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) through an integration with Grasshopper. On the left side of the application are all input parameters and a download button, in the middle you can see a 3D view of the mesh, and on the right side you can find all calculated information.

<div style="padding:48.75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/706022495?h=9bdfe52a5e&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Sample app parametric football stadium with Grasshopper"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>


## Parametric football stadium in 3 steps

Complete the following three steps to parametrically design a football stadium with Grasshopper using the sample application. 

1. **Define input parameters**, such as the shape, pitch width, offset from pitch, depth factor, asymmetrie along length and width, and height. 
2. **Create a 3D model**. Based on the input parameters, the field width, field length, and number of seats are calculated. 
3. **Download the 3D model**. Unfold 'downloads' to download a .glb (Graphic Language Bytes) file of the design. 

![Parametrically design football stadium grasshopper](https://cms.viktor.ai/uploads/Blog_sample_app_parametric_stadium_grasshopper_98ab0e1008.png)





Blog_sample_app_grasshopper

Discover how you can make your Grasshopper scripts more accessible with this open-source web app. Read more on VIKTOR.ai.

Parametric design of football stadium with Grasshopper

Parametric football stadium with Grasshopper

Manual facility management and maintenance have been a time-consuming and error-prone process in the architecture, engineering, and construction (AEC) industry for decades. The traditional approach relies heavily on physical inspections, which can lead to missed defects, inaccurate measurements, and inefficient maintenance practices. However, the advent of digital twins has revolutionized the way to manage and maintain buildings. By having a digital replica that continually declares the conditions of the physical entity, AEC professionals can benefit from a range of advantages. Like: real-time data monitoring, predictive maintenance, and improved efficiency. 

This article explores the potential benefits of digital twins in facility management and maintenance, and how they can be leveraged to optimize AEC workflows with a real-life example!

## Facility maintenance

Maintenance is a crucial aspect of ensuring that facilities remain functional, safe, and comfortable for the occupants. The goal of maintenance is to preserve the value of the facility, extend the lifespan, and reduce the likelihood of costly repairs or replacements. Maintenance can be classified into two main types: preventive and corrective. Preventive maintenance involves planned inspections and repairs to prevent breakdowns and failures, while corrective maintenance involves fixing problems as they occur. To carry out maintenance effectively, Facility owners and managers need to develop a comprehensive maintenance plan that includes regular inspections, routine maintenance tasks, and a system for recording and addressing any issues that arise. However, it is easy to miss a failure, wrongly spot problems or have a sudden failure straight after the inspection!

## Challenges in facility maintenance

Although manual maintenance has been used in the majority of built environments, a radical shift is happening thanks to Building Information Modelling (BIM). Creating a need for a newer, more innovative and optimized system! Especially, to avoid:

- Inefficiency. Maintenance should be as efficient as possible. Inspection depending on manual processes for maintenance, including paper-based checklists and schedules easily leads to errors and inefficiencies. In addition, lacking a complete and accurate record of facility systems, equipment, and materials, makes it difficult to plan and execute maintenance activities. 

- Cost & time consumption. Without an accurate record of facility systems and equipment, repairs can be expensive and time-consuming, requiring additional time to diagnose and resolve the issue.

- Safety Concerns Maintenance personnel in buildings may not have access to accurate and up-to-date information, which can pose safety risks as they might be exposed to undetected critical failure.

## Digital Twins, an innovative solution

![Picture2 DT and Viktor.png](https://cms.viktor.ai/uploads/Picture2_DT_and_Viktor_785376580a.png)

In early 2000, there was a new envision of having a digital representation of an existing physical model. The digital replica can give an accurate representation of the physical entity. This conception was articulated as “Digital Twin” by Michael Grieves at a Society of Manufacturing Engineers conference in Troy, Michigan. In essence, the vision is that having a digital representation of a materialistic entity can help in serving as the effectively identical digital replica of it for practical purposes, such as simulation, integration, testing, monitoring, and maintenance. 

In the context of the AEC  industry, a digital twin is a virtual representation of the physical facility that contains all of the information about the building, including its design, construction, operation, and maintenance data. Digital Twins can help owners and operators optimize the performance of their facilities, promptly sense failures, improve energy efficiency, reduce maintenance costs, and enhance the occupant experience. They can also be used for predictive maintenance, safety, and security analysis. These innovative implementations of Digital Twins form a practical manifestation of BIM higher dimensions of sustainability and management.

With the development of advanced technologies such as the Internet of Things (IoT), machine learning, and artificial intelligence, the use of Digital Twins is expected to become more prevalent in the coming years on a facility scale. In addition, expanding to an urban scale. City Digital Twins are being developed of cities around the world, including Shanghai, New York, Singapore and Helsinki.

It's widely considered that sensors are the basic translation between the physical entity and the digital twin as they provide the digital one with the updated status of the real entity.  Automatically harvesting these data leads to much better failure detection and a full history record of the element! 

## The digital twin of the Binnenhaven Bridge in Rotterdam

An example of how such sensors are used to harvest data and detect failure on a facility, is the case of [The Binnenhaven bridge in Rotterdam](https://www.viktor.ai/customer-cases/9/digital-twin-python-bridge). 

In the summer, metal swells significantly on hot days, making it impossible for the bridge to open or close. To avoid this, the bridge is cooled down using river water. The municipality of Rotterdam has developed a sensor-based early warning system that monitors the bridge and enables proactive cooling, avoiding potential logistic problems for Rotterdam. 

The bridge is equipped with 52 sensors that provide real-time data on temperature distribution with measurements taken every 15 minutes. The information is readily available as a web-based application on the VIKTOR platform, and the sensors are strategically placed on various parts of the bridge, including the deck, sides, primary and secondary stiffeners.  After the data is captured, it is used to run temperature modelling and expulsion simulation to predict the expected dilatation gap based on a weather forecast!

Finally, the measurements bring a structural solution within reach. Even during the hottest days, the bridge remained working perfectly thanks to the 52 warmth sensors. Based on the measurements, at the end of June, the bridge deck was shortened a bit. This measure appeared to be successful and made cooling the bridge unnecessary, and traffic disruptions no longer occur.

## Digital Twins and VIKTOR

![Picture1 DT and Viktor.png](https://cms.viktor.ai/uploads/Picture1_DT_and_Viktor_861a4daab3.png)

VIKTOR can easily offer a web-based app to monitor all the data gathered from the sensors. Additionally, it is easy to access all historical records of the sensed elements, effortlessly identifying overused ones. Overused elements in buildings, such as HVAC systems, elevators, plumbing and doors will inevitably require maintenance and replacement, especially as they approach the end of their lifespan. Digital twins can help foresee potential issues before they become critical, allowing for timely and cost-effective maintenance.

Moreover, a countermeasures plan can be efficiently automated throughout the VIKTOR platform. Just with a few clicks! Potentially defective elements are predicted, human repair is planned, and suppliers are contacted to deliver replacements at time. All is done before the issue gets critical!

## Conclusion

Fundamentally, building information modelling (BIM) aims to optimize the building process. By utilizing digital twins: building owners and managers can monitor and manage their buildings' maintenance more efficiently, making it easier to identify issues and carry out repairs before they become major problems. Interestingly, BIM digital twins are accessible by the suppliers as well as the data related to new supplements to be installed such as: how long will it take to be manufactured, shipped, installed and at what cost? In short, BIM can help in contextualizing the data harvested from the digital twin. This approach leads to a significantly more efficient way of coordinating and executing a maintenance plan.

In conclusion, digital twins are revolutionizing the way in maintaining buildings. By creating a digital replica of a building, owners and operators can optimize performance, reduce costs, and minimize downtime. VIKTOR is at the forefront of this emerging technology, providing cutting-edge solutions for receiving and managing data from digital twins. With the ability to execute prepared plans with high coordination!

medium_Viktor DIgital Twins Resized.png

small_Viktor DIgital Twins Resized.png

thumbnail_Viktor DIgital Twins Resized.png

Viktor DIgital Twins Resized.png

With the abundance of technological advancements in AEC, embracing innovation is crucial to stay ahead of industry trends. Digital twin technology has been a significant cost-saving and management improvement for facilities. VIKTOR's advanced algorithms make managing digital twins more efficient than ever before.

The Future of AEC: How VIKTOR's Digital Twins are Changing the Game

## What is VIKTOR?

VIKTOR is a cloud-based platform that enables users to automate engineering workflows, integrate processes, and optimize design techniques, like parametric and computational design, machine learning, and artificial intelligence. With VIKTOR, engineers and other domain experts can use Python to create their own applications to:

- Automate repetitive engineering tasks to free up time for engineers to focus on more complex problems.
- Integrate processes to improve collaboration between different stakeholders
- Optimize designs to create better solutions and make better and more informed decisions

## VIKTOR for Building & Construction

In the buildings and construction industry, VIKTOR is used to streamline and optimize structural engineering processes, particularly in the areas of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction), [BIM](https://www.viktor.ai/blog/100/how-BIM-innovations-transform-AEC), and [optimization algorithms](https://www.viktor.ai/blog/37/revit-data-driven-decision-making-app). 

### Parametric design 

With parametric design, engineers can create models that are automatically adjusted based on changes to specific parameters, such as height or width.  
 
### Building Information Modeling
 
BIM allows for the creation of digital models that capture information about a building's construction, operations, and maintenance, enabling teams to collaborate more effectively throughout the project lifecycle.  
 
### Optimization algorithms  

Algorithms can be used to automate repetitive tasks, such as optimizing building energy use or calculating the optimal placement of building components.  
 
### Data interoperability 

VIKTOR allows for data interoperability through the integration of multiple external software programs into one accessible and user-friendly interface that can be used by anyone to leverage the powers of parametric design, BIM, or optimization algorithms. This makes it possible for engineers and other domain experts to, amongst others, generate better designs in less time, be more flexible to change without any errors or delays, collaborate with stakeholders, and make better (design) decisions.  

## Case examples 

Real-world applications of VIKTOR in the buildings sector include projects with companies like Arcadis, J.P. van Eesteren, and W/E adviseurs.  
 
### Arcadis: Next gen structural design engineering tools 

Arcadis uses VIKTOR to automate and optimize structural engineering, particularly in the area of parametric design. With VIKTOR, Arcadis can quickly generate and analyze thousands of design options, allowing them to identify the most efficient and cost-effective solution for their clients. For example, Arcadis used VIKTOR to design a stadium roof that could withstand heavy snow loads while still being lightweight and cost-effective.
 
Read the full case [here](https://www.viktor.ai/customer-cases/45/arcadis-automates-and-optimizes-structural-engineering). 

<div style="padding:78.78% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/818358326?h=91e992e7ad&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Arcadis - Building Structural Design tool"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*The Building Structural Design tool by Arcadis*

</br>

### J.P. van Eesteren: Generating the optimal residential tower 

J.P. van Eesteren uses VIKTOR for the parametric design of residential towers. With VIKTOR, they can quickly generate and analyze many design options, allowing them to identify the most efficient and cost-effective solution for their clients. For example, they used VIKTOR to design the facade of a residential tower, allowing them to optimize the facade for both aesthetics and energy performance. 

Read the full case [here](https://www.viktor.ai/customer-cases/37/parametric-design-residential-towers-Cloud).

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/670120716?h=7298f72eb4&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="J.P. van Eesteren - LinkedIn demo (1 min 25 sec)"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*The High Rise Building Configurator*

</br>

### W/E adviseurs: Selecting optimal energy packages for housing stock
  
W/E adviseurs use VIKTOR to optimize energy packages for housing stock. With VIKTOR, W/E adviseurs can quickly analyze and optimize the energy performance of existing buildings, allowing them to identify the most effective energy-saving measures for their clients. For example, W/E adviseurs used VIKTOR to analyze and optimize the energy performance of an apartment complex, allowing them to reduce energy consumption by up to 50%. 

Read the full case [here](https://www.viktor.ai/customer-cases/44/optimal-energy-packages-for-housing-stock). 

## More cases

VIKTOR is also used to support projects in the buildings sector in other ways, such as with VINCI, Voorbij Funderingstechniek, and Arcadis.  
 
### VINCI: yearly 300 engineering days saved on crane foundation calculations 

VINCI used VIKTOR to create a tool that automates the calculation of crane foundation designs, resulting in substantial time savings. By utilizing VIKTOR, VINCI was able to reduce the time required for these calculations by 300 days annually, improving efficiency in their projects. 

Read the full article [here](https://www.viktor.ai/customer-cases/43/how-vinci-yearly-saves-300-days-calculating-crane-foundation-designs).

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/805460142?h=35f0fa1693&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="VINCI - Crane foundation app"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*The Crane Foundation Design Calculation Tool*

</br> 

### Voorbij Funderingstechniek: Optimal pile foundation designs save tons of CO2 

Voorbij utilized VIKTOR to develop a tool for optimizing foundation designs, aiming to reduce CO2 emissions. This tool enabled Voorbij to automate the process of designing foundations, resulting in more sustainable solutions and significant reductions in CO2 emissions. 

Read the full article [here](https://www.viktor.ai/customer-cases/34/foundations-design-optimization-saves-tons-of-CO2).

![Infographic LinkedIn Voorbij enviromental benefits (1).png](https://cms.viktor.ai/uploads/Infographic_Linked_In_Voorbij_enviromental_benefits_1_867f0bf577.png)

*Infographic results Pile Foundation Application (after one project)*

</br>

### Arcadis: Automating and optimizing construction pit design 

Arcadis uses VIKTOR to accelerate its digital transformation in the area of underwater concrete. With their construction pit tool, they can rapidly generate and analyze numerous design options, resulting in more efficient and cost-effective solutions for their clients.  

Read the full article [here](https://www.viktor.ai/customer-cases/41/arcadis-accelerates-digital-transformation-with-viktor). 

![App4.jpg](https://cms.viktor.ai/uploads/App4_61703132b4.jpg)

*Presentation of the optimization results via a parallel coordinates plot*

![App5.jpg](https://cms.viktor.ai/uploads/App5_b83d2e2694.jpg)

*Alternative representation of the optimization results via a contour plot*

## Software integrations 

VIKTOR integrates with specific software used in the buildings sector, such as IDEA StatiCa, D-Foundations, SCIA, Revit, and Dynamo. Integrating these software programs with the VIKTOR interface allows engineers to use all capabilities of a (or multiple) software programs from any location, together with anyone they want, at any time, and in one central place, without needing to open the interface at all.  

### IDEA StatiCa Concrete 

VIKTOR can be used to automatically generate IDEA StatiCa Concrete models with minimal Python code to perform all kinds of analyses, leading to better and cheaper solutions. 

![Visualization of a reinforced cross-section in VIKTOR (top) and IDEA (bottom](https://cms.viktor.ai/uploads/Visualization_of_a_reinforced_cross_section_in_VIKTOR_top_and_IDEA_bottom_77d13c37f5.png)

*Reinforced cross-section from IDEA StatiCa in VIKTOR*

</br>

### D-Foundations (Deltares)

Integrating VIKTOR with D-Foundations enables you to automate the processing of pile foundations and run more analyses in a shorter time. 

![VIKTOR interface for automation in D-foundations](https://cms.viktor.ai/uploads/VIKTOR_interface_for_automation_in_D_foundations_526f7e67c9.png)

*D-Foundation analayis in a VIKTOR app*

</br>

### SCIA Engineer 

Through the SCIA API, engineers can automatically (re)calculate structural models within a VIKTOR app. Additionally, building blocks from the VIKTOR code library can be used to build (parametric) models that can be exported to XML and read in SCIA.  

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/694319977?h=9b83f627ec&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Pile foundations with D-Foundations and SCIA"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*Visualization of SCIA result processing in a VIKTOR app*

</br>

### Revit & Dynamo

VIKTOR can also be used to automate Python scripts in Revit, improve data-driven decision-making with simplified interactive insights, and easily create accessible and sharable Dynamo scripts that can also be used for parametric design.  

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/513789510?h=cef1da5778&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Arcadis Dynamo Dome Design"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*Dynamo dome in a VIKTOR app*

<br>

## Try it yourself! 

VIKTOR also provides several publicly available applications that could be useful for the buildings sector. These include [shadow calculator](https://cloud.viktor.ai/public/shadow-calculator), which calculates the shadow cast by a building on a specific location and time, [centrality analysis](https://cloud.viktor.ai/public/centrality-analysis), which analyzes the importance of nodes in a network, [beam analysis](https://demo.viktor.ai/public/beam-structural-analysis), which analyzes the structural integrity of beams, [warehouse configurator](https://demo.viktor.ai/public/warehouse-configurator), which optimizes warehouse layouts, and [seismic analysis](https://students-uni-fic-pe.viktor.ai/public/viktor-opensees), which simulates seismic activity on buildings. These applications can be accessed and used through our [Apps Gallery](https://www.viktor.ai/apps-gallery/category/all/tag/all/1). 

![structural engineering apps public.png](https://cms.viktor.ai/uploads/structural_engineering_apps_public_fe4e76adbe.png)

*Some applications from the Apps Gallery*

</br> 

## Start for free or book a demo! 

Can't find what you're looking for in the Apps Gallery? You can explore all the possibilities of the VIKTOR platform, build, and deploy your own apps using our [Free Version](https://www.viktor.ai/start-building-apps). If you prefer talking directly with our experts instead, you can also [Book a Demo](https://www.viktor.ai/book-a-demo) and we will schedule an introduction meeting with you as soon as possible.  


medium_shutterstock_1489933823.jpg

small_shutterstock_1489933823.jpg

thumbnail_shutterstock_1489933823.jpg

shutterstock_1489933823.jpg

Interoperability, AI, Parametric Design, Machine Leaning and optimization algorithms: Automating & Optimizing Structural Engineering processes

Streamlining Structural Engineering: VIKTOR for Building and Construction

## Redefining BIM through AI  
**By Brendan Hasty (ZURU)** 

Brendan Hasty, structural systems lead at ZURU, shares insights into the tools a company can use to optimize its engineering workflows, showing how ZURU is using BIM to transform digital engineering.  

### Digital engineering is crucial for innovation: adapt or die 

In the AEC industry, embracing digital engineering is essential for adapting to innovation and improving efficiency and safety in projects. 
Despite this, many companies start projects using basic tools like Excel, leading to challenges such as managing different file versions and experiencing data loss down the line. Choosing more advanced tools, such as platforms that facilitate application development (e.g., VIKTOR), can prove to be a strategic decision, to have more control and programming power within the company, minimizing errors and enhancing team efficiency. 

Brendan's emphasis on innovating engineering processes aligns with other challenges faced by engineers, particularly in the context of the current state of BIM. The complexity of BIM is a barrier to accessibility, affecting its proper and efficient application in the industry. The lack of interconnected models i a key challenge, calling for a transformative approach. 

### Linking workflows for more efficiency 

To establish a comprehensive digital engineering workflow within a company, it is more effective to integrate tools seamlessly within the BIM software, adopting an end-to-end approach covering the entire process from digital modeling to analysis and design (starting with digital modeling, importing it into the analysis software, transitioning to the design space, and finally returning to BIM). 

For instance, having their workflows linked helped ZURU adapt to last-minute changes in project requirements. This integration not only saved significant time but also enabled them to rectify what could have potentially taken weeks' worth of work in just a couple of hours. 

Incorporating Artificial Intelligence into engineering designs also contributes to making workflows more efficient. Harnessing AI capabilities, such as neural networks, can help to optimize decision-making and achieve highly efficient structure. Moreover, the availability of plugins further helps the integration of AI tools into design processes.  

You can go back to [min 03:25](https://www.youtube.com/watch?v=dJHD4glNhhM&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=6&t=205s) to hear about more reasons to introduce AI tools into workflows.  

 ### Importance of BIM links in AEC 

In the construction sector, BIM models are employed by professionals. However, certain areas have not transitioned to digital space and continue to rely heavily on manual work and paper documentation. 

The segmentation of models and the practice of different departments working independently without integrating their workflows creates challenges. For example, consider the consequences of this lack of integration during the construction phase, where BIM may be used for construction planning, but later processes often revert to conventional paper-based methods. Connecting models can prevent errors, as inconsistencies arise when various professionals work from separate models within the same digital environment. 

### AI-generated BIM architecture 

ZURU strives to create links between architecture and engineering workflows, facilitating a dynamic exchange of information, and remaining in control when multiple parties are involved. Setting up effective design workflows at the project's outset takes time and control, but it pays dividends in sharing information effectively and finding discrepancies within various software platforms early on.  

ZURU's current goal is therefore to develop user-friendly BIM software that integrates with machine learning features. Looking forward, their vision is to achieve end-to-end automation, potentially making AI-generated BIM architecture a reality. ZURU's journey encompasses complete integration from design to production, using machine learning and AI to elevate BIM to new heights. This innovative process empowers clients to customize designs, receive cost estimates, progress through production, and create their dream homes in a snap! 

If you want to know how ZURU is making it possible, go to [min 12:36](https://www.youtube.com/watch?v=dJHD4glNhhM&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=6&t=756s) and check the visual demonstration! 

<iframe width="560" height="515" src="https://www.youtube.com/embed/dJHD4glNhhM?si=oepCNe-_Mt6F_J4a" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## The easiest path to learning Python in the AEC industry  
**By Kris Wojslaw (programminginAEC.com)** 

While learning to code with Python, Kris realized that learning without real-world context is essentially useless. For this reason, he started his own programming course: programminginAEC.com, in which he proposes a practical, purpose-driven approach to learning Python in the AEC industry, sharing a key lesson for a more effective learning journey. 

### 6-step process to learn Python in the AEC Industry 

Kris’ alternative path is a comprehensive 6–step process for AEC professionals to incorporate Python programming in their projects and enhance computational capabilities, automation, and tool development. 

#### Computational thinking 

Everything starts with understanding computational thinking – breaking down complex problems, recognizing patterns, abstraction, and algorithm design. Engineers already do computational thinking in their daily work. For example, when calculating the structural integrity of a building, engineers conduct a global analysis. However, they intelligently split this comprehensive calculation into distinct components, such as foundation calculations, columns, slabs, etc. This parallels the computational thinking process of breaking down complex problems into smaller, more manageable parts. Moreover, engineers recognize and leverage patterns from previous projects. If they have a foundation calculation from a past project with a similar load combination, they apply that knowledge to the current project. This reflects the computational thinking step of pattern recognition, where established solutions are found and reused. 

#### Visual Programming 

In the visual programming step, architects and engineers start crafting algorithms using graphical elements rather than traditional code. It's a practical approach to automate tasks—like creating 3D objects—initially investing a bit more time for long-term efficiency gains. Starting with small, frequent tasks, engineers connect these visual algorithms to existing tools (e.g. Grasshopper or Dynamo) before considering a transition to Python for more advanced scripting, overcoming limitations of visual contexts. It is a progressive journey from graphical automation to coding flexibility. 

#### Text-Based Visual Programming 

Text-based visual programming is the step that engineers take when they need to go beyond the limitations of visual contexts like Grasshopper or Dynamo and start to write their code. Kris explains how engineers can flex their Python muscles within familiar environments, showing simple Python scripts at [min 13:06](https://www.youtube.com/watch?v=LcHsi36p1R8&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=3&t=786s).

#### Text-Based II 

Taking the leap beyond familiar territories, engineers can explore tools like Jupyter for creating visuals and moving outside environments with a platform like VIKTOR. With VIKTOR, for instance, you can use existing libraries and codes to create custom engineering apps and share them with colleagues in your company or with clients. You can go to [min 14:02](https://www.youtube.com/watch?v=LcHsi36p1R8&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=3&t=842s) to find out more about the possibilities unlocked for engineers during this step. 

#### Text-Based IDEs 

Integrated Development Environments (IDEs) mark the transition to text-based programming and a move towards advanced programming capabilities. Here you can access APIs of software such as Revit or Rhino. 

With IDEs, engineers can create more complex code, and with APIs, they gain the power to manipulate and extend the features of existing programs (Revit, Rhino, etc.). 

#### Advanced Programming 

Finally in this step, engineers are empowered to create their own tools, customized for their specific projects and needs, rather than waiting for software updates! 

[Watch Kris’ full presentation to change the way you work with coding!](https://www.youtube.com/watch?v=LcHsi36p1R8&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=3) 

<iframe width="560" height="515" src="https://www.youtube.com/embed/LcHsi36p1R8?si=iBJqSb9H0mkF2lce" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe> 

## BIM link workflows with IDEA StatiCa 
**By Kris Riemens (IDEA StatiCa)**

Kris Riemens, Product Engineer at IDEA StatiCa, presents BIM link capabilities with IDEA StatiCa for steel connection design and shows how these can be used to optimize your structural engineering workflow.  

### Faster tools for better design 

In the industry there is an issue where structural defects often stem from poorly designed joints or details, resulting in financial and material wastage. One specific problem happens with steel connections. Even though only 30% of these connections are complex, they eat up a massive 70% of the time spent designing them. This means we need faster tools to design better. 

### Connecting global analysis and detailed design 

Kris talks about this problem and the need to connect global analysis tools FEA (Finite Element Analysis) with detailed connection design tools. Some companies use global FEA tools like Etabs or SCIA Engineer for overall analysis. However, these tools often lack the details needed for tricky connection designs. On the other hand, detailed design tools like Tekla or Revit are well-suited for connections but struggle with structural calculations. This gap between global FEA analysis and detailed connection design needs to be filled. 

### Boasting BIM links with external packages 

IDEA StatiCa addresses this gap by integrating BIM links with external FEA models. When using an external FEA model, the BIM link facilitates the importation of key structural elements' geometry and internal forces derived from the global analysis. This way, engineers can easily add the design details for connections, enabling swift and exact connection calculations.  

For projects started in CAD models where connections are pre-designed with bolts, welds, and stiffening plates, the BIM link empowers engineers to import the complete design into IDEA StatiCa. Although the load stand needs incorporation, the next steps involve a straightforward process of calculation and code checking for the connection. 

IDEA StatiCa boasts BIM links with various external FEA and CAD packages such as Etabs, Tekla, and Revit among others, with an expanding list of supported software. This collaborative integration ensures a seamless and efficient workflow, allowing engineers to enjoy the benefits of advanced FEA analysis linked with IDEA StatiCa's connection design capabilities. 

[Check the full presentation of Kris at UCODE 2023 to see practical examples of BIM link with external FEA and with CAD!](https://www.youtube.com/watch?v=87-ClIYX-eU&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=5) 

<iframe width="560" height="515" src="https://www.youtube.com/embed/87-ClIYX-eU?si=F9hCgx79JXshtLlG" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe> 

## Integrating Topologic with VIKTOR for energy analysis workflows 

**By Wassim Jabi (Cardiff University)** 

Wassim Jabi, professor of Computational Methods in Architecture at Cardiff University, explores the integration of Topologic with VIKTOR for energy analysis workflows. Drawing on his unique perspective as an expert with a non-software engineering background, Wassim delves into the genesis of Topologic, giving valuable insights for those navigating similar paths in software development. 

### Helping designers and architects at the pre-BIM stage 

Topologic is a software library developed by Wassim Jabi and his Cardiff University's A-Team. It responds to the promises and challenges of BIM and sets itself apart as a versatile library that offers integration with various platforms, including VIKTOR, IFC, Blender, Rhino, and EnergyPlus and incorporates graph machine learning. 

What makes Topologic stand out from other 3D modeling environments, is that it is a representation of objects with multiple manifolds featuring interior subdivisions. In practical terms, its non-manifold structure allows intricate subdivisions. 

The challenges that Topologic aims to address stem from common issues encountered in dealing with BIM data. Data is often incomplete, lacks structure, and is sometimes unconnected or ad hoc, meaning it may not adhere to standards. This inconsistency poses a significant challenge, making it difficult to rely on BIM data consistently. Additionally, BIM was envisioned to be more than just "building" information modeling; it was meant to encompass broader information modeling, and how information is structured and communicated. However, the absence of standardized schemas and information structures often requires users to add plugins or translators, leading to difficulties, errors, and potential data loss.  

Topologic does not limit itself to building information but wants to redefine and enhance BIM with three key elements: geometry, topology, and information. The goal is to provide architects and designers with added value at the pre-BIM stage, to streamline the BIM process, and to deliver more meaningful insights from models before they become entangled in complexity. 

If you want to hear more about Topologic and how it addresses challenges at pre-BIM, you can go at [min 03:03.](https://www.youtube.com/watch?v=LRWG1BSwbVw&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=5&t=183s) 

### Simplicity and accuracy for effective analysis 

According to Wassim, it is all about "Complexity last, not first", which helps understand Topologic's proposal.   
A surplus of detailed information, especially in complex tasks, can in fact be counterproductive, obstructing rather than facilitating analysis. 
The idea behind Topologic is to strip away unnecessary details and focus on geometric simplicity with topological accuracy to have more conductive and effective models to run analysis. 

At [min 05:24](https://www.youtube.com/watch?v=LRWG1BSwbVw&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=5&t=324s) you can hear about Topologic's simplicity proposal. 

### Topologic in a 20-million-euro project 

In collaboration with IPROconsult, Wassim employs Topologic for conceptual model extraction, analysis, and automatic conversion to BIM. This streamlined approach allows extensive iteration and thorough analysis before delving into complex BIM models. The methodology consists of creating a simple yet detailed conceptual model, finding an equilibrium between reduced geometric complexity and enhanced topology and semantic information.  

These models undergo thorough analyses, such as energy and spatial assessments, ensuring high quality, efficiency, sustainability, and value. Once satisfied with the analysis iterations, the model undergoes an automated transformation into a fully detailed BIM model. This automated transition significantly reduces manual efforts, as proven successfully in IPROconsult's €20-million student housing project for optimizing building shape and categorizing student apartments. 

Wassim discussed this, and another case study, in more detail from [min 08:32](https://www.youtube.com/watch?v=LRWG1BSwbVw&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=5&t=512s) of his presentation. 

## Topologic for easy energy analysis 

EnergyViz is an app developed with VIKTOR, using Topologic for energy analysis. Establishing a dedicated server at Cardiff University, Wassim installed Topologic as server software, transforming it into a versatile platform.  

Users can upload .OBJ files of building envelopes or use pre-existing downloadable building models. The app slices the model into floors, applies glazing based on user-defined ratios, and performs comprehensive analyses for cooling, heating, and comfort. It delivers both visualizations and downloadable files, enabling easy access to multiple analyses without the need for repetitive simulations. Once you send the input the process to perform the energy analysis only takes a few minutes, before coming back with a color-coded 3D model that you can rotate.  

This proof-of-concept application takes the complexity out of energy analysis and presents a powerful and user-friendly approach to make energy analyses more accessible and visually intuitive. 

[Watch the full presentation of Wassim at UCODE to discover everything you can do with Topologic and see practical examples!](https://www.youtube.com/watch?v=LRWG1BSwbVw&list=PLSx8-ZCZDELbSWkZwdX4Kb7LbjDjzcen7&index=6) 

<iframe width="560" height="515" src="https://www.youtube.com/embed/LRWG1BSwbVw?si=Z9g7qgKpIV4OBRAC" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe> 

 

 

large_4.png

medium_4.png

small_4.png

thumbnail_4.png

4.png

- What is Building Information Modeling (BIM)? 
- BIM for Architecture, Engineering, and Construction (AEC)
- Trends in BIM
- So, what's next? BIM level 3?
- Solve your BIM challenge with VIKTOR!
- Conclusion


A4 - White Paper COVER.jpg

In the world of Architecture, Engineering, and Construction, Computer-Aided Design (CAD) has been a go-to technology for decades. While it was a significant breakthrough in its time, it has its limitations, and many industries now find it inefficient and lacking in collaboration. This has led to the rise of Building Information Modeling (BIM), which has brought many benefits to the table. Real-life projects such as hospitals, schools, and high-rise buildings have implemented BIM and have seen significant improvements in their project lifecycle across all AEC disciplines. In fact, industry leaders have also recognized the potential of BIM and have embraced it as a way to enhance their performance.

In this White Paper, we will explain VIKTOR's vision in BIM: Efficiently pioneering today's & next-gen BIM cloud-based Automation! We will provide information on the meaning, benefits, challenges, and future of BIM!

Efficiently pioneering today's & next-gen BIM cloud-based Automation! We will provide information on the meaning, benefits, challenges, and future of BIM!

How BIM innovations are transforming the AEC industry

How to use BIM in workflows according to Brendan Hasty (ZURU), Kris Wojslaw (programminginAEC.com), Kris Riemens (IDEA StatiCa), and Wassim Jabi (Cardiff University).  

BIM in AEC for simple, effective and collaborative workflows 

## A troubling relationship with 3D models 

As a structural engineer, I have always had a challenging relationship with 3D models. I either received overly detailed models that required simplification for analysis or had to start from scratch based on 2D drawings. Either way, setting everything up and continuously modifying and analyzing the design to meet the requirements was time-consuming. 

I always wondered if there was a better way. I tried setting up the models parametrically and succeeded to a certain extent. However, as the model became more complex and I started adding operations like extrude, bore, fillet, and pattern to the geometry tree, I could never achieve a truly stable model. Somehow, I would always end up breaking the model after changing some parameters. 

As an engineer and a Python enthusiast, I decided to look for an open-source solution that is easy to use and accessible to anyone familiar with the basic concepts of 3D modeling and Python: CAD as code. 

## The benefits of CAD as code

If you think about it, all 3D modeling software has some kind of geometry engine under the hood (a CAD kernel), which you can access through the user interface. CAD as code generates 3D models by speaking directly to this CAD kernel using code. This is great because now you can build your 3D models based on logic and engineering principles.  

For example, you can define some plate thickness based on a stress formula. Also, because everything is written in code, your models are intrinsically parametric so you can easily modify the model by simply changing a value. On top of that, you get the same benefits of coding in general like version control using Git, quick sharing and re-utilizing of code, and the possibility of using other libraries, like [build123d](https://pypi.org/project/build123d/) and our preferred choice, [CadQuery](https://pypi.org/project/cadquery/).  

## What is CadQuery and how does it work? 

CadQuery is an intuitive, easy-to-use Python library for building parametric 3D CAD models. It works similarly to most 3D modeling software: you select a plane, extrude a geometry, create holes, and so on (as explained in the [documentation](https://cadquery.readthedocs.io)). However, instead of clicking, you achieve this by writing code, as shown in the image below. 

![CodeCAD.png](https://cms.viktor.ai/uploads/Code_CAD_5fb833db3d.png)

</br>

```python
(length, height, bearing_diam, thickness, padding) = (30.0, 40.0, 22.0, 10.0, 8.0) 

result = ( 
    cq.Workplane("XY") 
    .box(length, height, thickness) 
    .faces(">Z") 
    .workplane() 
    .hole(bearing_diam) 
    .faces(">Z") 
    .workplane() 
    .rect(length - padding, height - padding, forConstruction=True) 
    .vertices() 
    .cboreHole(2.4, 4.4, 2.1) 
) 
```

</br>

CadQuery is very powerful and has all the basic functionalities of standard 3D modeling. Because it's based on Python, it enables you to do all kinds of calculations and add logic. You can also use other Python libraries, making this incredibly powerful and suitable for automation. For example, this wind structure is made using CadQuery and [SplineCloud](https://splinecloud.com/) to define the shape of the airfoil. 


![airfoil shape code cad.png](https://cms.viktor.ai/uploads/airfoil_shape_code_cad_869658de66.png)

</br>

## Using CadQuery models for FEM, CDF, CAM and BIM 

You can export your CadQuery 3D CAD models in multiple formats, such as DXF, STL, glTF and many more. This enables you to import them in different packages so you can do Finite Element Analysis (FEM), Fluid Dynamics (CFD), import them into BIM packages like Revit, or use them for manufacturing with CNC machines or 3D printers. You can also use models you already have and combine them, for example, to create a new assembly. 

Of course, you don’t need to import the models manually into your preferred analysis software. If your software has a Python API, you can create the models, send them for analysis, retrieve the results and do the checks you need. 

![block with mesh code cad.png](https://cms.viktor.ai/uploads/block_with_mesh_code_cad_05ad83f46a.png)

</br>

CadQuery is a great library for people who know Python, but what if you want to share your parametric 3D model with people who don’t? 

Using VIKTOR, you can make a user-friendly app for your parametric 3D models and all the logic connected with them, and integrate them with 3rd party software for FEM, CFD, BIM and more. This way, anyone can use your logic through a user-friendly interface. This also gives you a lot of control over how the model is designed as, for example, you can define maximum and minimum limits for user input.  

Additionally, you protect your code and your intellectual property, as users interact with the application without accessing the underlying code.  

To get started making CadQuery is a simple pip install. If you want to start making VIKTOR apps with CadQuery, you only need to add it to your requirements. Converting a CadQuery script into a VIKTOR app might be one of the easiest conversions. Don't have a VIKTOR account yet? Sign up [here](https://www.viktor.ai/start-building-apps).  

Now, you can start by copying your code into a GeometryView. Here, you add some lines for the export and voila, your design is visible in the app: 

```python
@GeometryView("Geometry", duration_guess=1, x_axis_to_right=True) 
    def get_geometry_view(self, params, **kwargs): 
        """ 
        Renders the 3D model. First it (re-)generates the assembly. Then, 
        exports the gltf data to a temporary file, which is passed to
        GeometryResult and displayed as a GeometryView. 
        """ 
        assy = cq.Assembly() 
        body = ( 
            cq.Workplane("XY") 
            .box(30.0, 40.0, 10.0) 
            .faces(">Z")
            .workplane() 
            .hole(22.0) 
            .faces(">Z") 
            .workplane() 
            .rect(40.0 – 8.0, 40.0 – 8.0, forConstruction=True) 
            .vertices() 
            .cboreHole(2.4, 4.4, 2.1) 
            .edges("|Z") 
            .fillet(2.0) 
        ) 

         assy.add(body, color=cq.Color(1, 0.27, 0.0), name="body") 
        glb = File()  # temporary file to store 3D model as gltf data 
        cq.occ_impl.exporters.assembly.exportGLTF(assy, glb.source, True) 
        return GeometryResult(geometry=glb) 
```

Then we make some NumberFields for our parameters in the parametrization: 

```python
class Parametrization(ViktorParametrization): 
    length = NumberField("Length", default=30, suffix="mm") 
    height = NumberField("Height", default=40, suffix="mm") 
    bearing_diam = NumberField("Bearing diameter", default=22, suffix="mm") 
    thickness = NumberField("Thickness", default=10, suffix="mm") 
    padding = NumberField("Padding", default=8, suffix="mm") 
    fillet = NumberField("Fillet", default=2, num_decimals=1, step=0.5, suffix="mm") 
```

And finally, we need to connect these parameters to the view. Due to the nature of CadQuery, this conversion can be done in minutes!  

```python
@GeometryView("Geometry", duration_guess=1, x_axis_to_right=True) 
    def get_geometry_view(self, params, **kwargs): 
        """ 
        Renders the 3D model. First it (re-)generates the assembly. Then, 
        exports the gltf data to a temporary file, which is passed to 
        GeometryResult and displayed as a GeometryView. 
        """ 
        # obtain parametrization fields 
        (length, height, bearing_diam, thickness, padding) = ( 
            params.length, 
            params.height, 
            params.bearing_diam, 
            params.thickness, 
            params.padding, 
        ) 

         assy = cq.Assembly() 

         body = ( 
            cq.Workplane("XY") 
            .box(length, height, thickness) 
            .faces(">Z") 
            .workplane() 
            .hole(bearing_diam) 
            .faces(">Z") 
            .workplane() 
            .rect(length - padding, height - padding, forConstruction=True) 
            .vertices() 
            .cboreHole(2.4, 4.4, 2.1) 
            .edges("|Z") 
            .fillet(params.fillet) 
        ) 
 
        assy.add(body, color=cq.Color(1, 0.27, 0.0), name="body") 
        glb = File()  # temporary file to store 3D model as gltf data 
        cq.occ_impl.exporters.assembly.exportGLTF(assy, glb.source, True) 
        return GeometryResult(geometry=glb) 
```

If you look at the result in your environment, you will see that you have an app that looks very similar to the CAD viewer from CadQuery, only there is no Python code, and it can be shared with a link now! 

![CAD viewer CadQuery VIKTOR.png](https://cms.viktor.ai/uploads/CAD_viewer_Cad_Query_VIKTOR_2699a7a4c3.png)

</br>

For your convenience, find the whole code here: 

```python
from viktor import ViktorController 
from viktor.core import File 
from viktor.parametrization import NumberField, ViktorParametrization 
from viktor.views import GeometryResult, GeometryView 

# OpenCascade library 
import cadquery as cq 

class Parametrization(ViktorParametrization): 
    length = NumberField("Length", default=30, suffix="mm") 
    height = NumberField("Height", default=40, suffix="mm") 
    bearing_diam = NumberField("Bearing diameter", default=22, suffix="mm") 
    thickness = NumberField("Thickness", default=10, suffix="mm") 
    padding = NumberField("Padding", default=8, suffix="mm") 
    fillet = NumberField("Fillet", default=2, num_decimals=1, step=0.5, suffix="mm") 

class Controller(ViktorController): 
    label = "pillow block" 
    parametrization = Parametrization 

    @GeometryView("Geometry", duration_guess=1, x_axis_to_right=True) 
    def get_geometry_view(self, params, **kwargs): 
        """ 
        Renders the 3D model. First it (re-)generates the assembly. Then, 
        exports the gltf data to a temporary file, which is passed to 
        GeometryResult and displayed as a GeometryView. 
        """ 
        # obtain parametrization fields 
        (length, height, bearing_diam, thickness, padding) = ( 
            params.length, 
            params.height, 
            params.bearing_diam, 
            params.thickness, 
            params.padding, 
        ) 

        assy = cq.Assembly() 

        body = ( 
            cq.Workplane("XY") 
            .box(length, height, thickness) 
            .faces(">Z") 
            .workplane() 
            .hole(bearing_diam) 
            .faces(">Z") 
            .workplane() 
            .rect(length - padding, height - padding, forConstruction=True) 
            .vertices() 
            .cboreHole(2.4, 4.4, 2.1) 
            .edges("|Z") 
            .fillet(params.fillet) 
        ) 

        assy.add(body, color=cq.Color(1, 0.27, 0.0), name="body") 
        glb = File()  # temporary file to store 3D model as gltf data 
        cq.occ_impl.exporters.assembly.exportGLTF(assy, glb.source, True) 
        return GeometryResult(geometry=glb) 
```

## Conclusion 

Embracing Python and CadQuery can significantly enhance your efficiency as a CAD engineer. Transitioning to a programmatic approach allows you to create robust, parametric models driven by engineering and the power of Python with CadQuery. That said, keep in mind that with CadQuery, you have to define every part of your model right from the start, which can be a bit tricky and time-consuming, especially for more complex designs. It might feel like a lot of work at first, but once you've got the basics down, the payoff is well worth it. 

Exporting models into various formats and integrating them with other engineering software streamlines workflows, from FEM and CFD to CNC manufacturing. This approach can help you overcome the limitations of traditional CAD systems, making your designs more reliable and adaptable. It also opens the doors to creating custom CAD applications with VIKTOR, meaning the possibilities with CAD have become endless!  










large_CadQuery - Make complex 3D models with Python.png

medium_CadQuery - Make complex 3D models with Python.png

small_CadQuery - Make complex 3D models with Python.png

thumbnail_CadQuery - Make complex 3D models with Python.png

CadQuery - Make complex 3D models with Python.png

Discover how Python and CadQuery can revolutionize your 3D modeling workflow by allowing you to create flexible, parametric designs that are easy to modify and integrate with various engineering tools. 

How to Make Complex 3D Models with Python 

## What is geometry interaction 

Geometry interaction refers to the actions a user can perform with geometric entities such as points, curves, surfaces and solids. Some common forms of geometry interactions are selection, transformation and inspection. Whether a user wants to manipulate a 3D model in CAD or set up a simulation for FEA, being able to interact with a geometry directly impacts the user’s experience and the quality of the output.  

In VIKTOR, geometry interaction starts with geometry selection. The ability to select elements in the view is the starting point for all other actions, which is why you can now leverage the GeometrySelectField in VIKTOR apps.  

## Examples of geometry interaction in VIKTOR apps 

You may associate geometry interaction with large, intricate software but it is also critical for your applications, and it is now easier than ever to implement this into your VIKTOR application’s GeometryView or IFCView.  

Next, you will find some examples of how you can apply and leverage the GeometrySelectField in VIKTOR and create apps with an enhanced user experience.  

### Selecting a node to add loads 

For the first example we have an app that utilizes OpenSeesPy and allows a user to select the nodes on which to impose the loads for the OpenSees analysis.  

</br>

<iframe height="600px" frameborder="0" src="https://demo.viktor.ai/embed/structural-analysis-using-opensees" style="
    transform: translate(-50%);
    width: 90vw;
    max-width: 1028px;
    margin-left: 50%;
    box-shadow: 0px 0 2px 0 #888;
    "></iframe>

</br>

As you can see the app lets you add multiple loads and displays it as an arrow to the view. Now imagine you did not have the ability to select a node but had to enter the node Id manually. In this example it is very easy to see how geometry interaction has greatly improved the user’s experience.  

### Adding elements to a geometry 

In another example, you can use geometry selection to add simple balconies to a model.  

</br>

<iframe height="600px" frameborder="0" src="https://demo.viktor.ai/embed/building-with-geometry-select" style="
    transform: translate(-50%);
    width: 90vw;
    max-width: 1028px;
    margin-left: 50%;
    box-shadow: 0px 0 2px 0 #888;
    "></iframe>


</br>

Instead of selecting a single node as was done in the previous example; by selecting two nodes you can define a length for the balcony. Just like the previous example we have combined geometry selection with a dynamic array to allow for a user to make multiple (sets of) selections.  

### Showcase hidden information 

In both previous examples we have seen how geometry selection is a fantastic tool to use for design and simulation. But what if we were only interested in the underlying information that may be hidden from the user?  

Think of all the information that is stored in an IFC file. The geometric parameters are only a small part of it so what if we want to be able to see the rest of the information related to an element?  

In the IFC viewer we can nicely see that the IFC view lets you click on any of the elements and the element’s properties will pop up in the window. Just like in a GeometryView, you can leverage the geometrySelectionField here, which can again serve as the basis for all other geometry interactions.  

</br>

<iframe height="600px" frameborder="0" src="https://demo.viktor.ai/embed/ifc-viewer" style="
    transform: translate(-50%);
    width: 90vw;
    max-width: 1028px;
    margin-left: 50%;
    box-shadow: 0px 0 2px 0 #888;
    "></iframe>

</br>

## How to implement Geometry Interaction in your VIKTOR apps 

To start implementing geometry interactions in your applications. There are two variations you must consider of the geometry selection input options. VIKTOR offers both the GeometrySelectField and GeometryMultiSelectField. Once added to your parametrization, you can select a geometric object in the view. The geometric object that you choose is returned in the parameters (params) as a list of identifiers (string format). Let's make an example together.  

For this example, you can start by creating an empty app template, installing and starting it.  

We will start by importing viktor as vkt. This will let you use all the viktor components in your apps.  

```python
import viktor as vkt 
```

The next step is to add our **GeometrySelectField** and **GeometryMultiSelectField** to the parametrization.  

```python
class Parametrization(vkt.Parametrization): 

    selected_geometry = vkt.GeometrySelectField("Select a geometry") 

    selected_geometries = vkt.GeometryMultiSelectField("Select geometries") 
```
To use the parameters, let's add a Geometry and data view to the app. You will display the output of the calculation for which you use the geometry selection in the data view.  

Let's also add a simple geometry consisting of 3 square beams:  

```python
   @vkt.GeometryAndDataView('Geometry', x_axis_to_right=True) 

    def get_geometry_and_data_view(self, params, **kwargs): 

        cubes = { 

            'cube1': vkt.SquareBeam(1, 1, 5, identifier="cube1"), 

            'cube2': vkt.SquareBeam(1, 4, 1, identifier="cube2"), 

            'cube3': vkt.SquareBeam(3, 1, 1, identifier="cube3") 

        } 
```

That’s your geometry done. As you may have noticed, you have added unique identifiers for each beam. This is important to be able to differentiate between them at the next stop.  

Next, you want to implement a volume calculation based on the selected geometry. For the **GeometrySelectField**, you can easily use the **.inner_volume** method to calculate the volume of a single beam.  

```python
# Calculate data 

        if selected_geometry := params.selected_geometry: 

            volume = cubes[selected_geometry].inner_volume 

            data_1 = vkt.DataItem('Volume of GeometrySelectField', volume, suffix="m3") 

        else: 

            data_1 = vkt.DataItem('No geometry selected in GeometrySelectField', '') 
```

For the **GeometryMultiSelectField**, you will need to loop over the ‘cubes’ dictionary. This dictionary will contain the identifier of each of the selected geometries:  

```python
if selected_geometries := params.selected_geometries: 

   volume = sum(cubes[selected_geometry].inner_volume for selected_geometry in selected_geometries) 

   data_2 = vkt.DataItem('Volume of GeometryMultiSelectField', volume, suffix="m3") 

else: 

   data_2 = vkt.DataItem('No geometries selected in GeometryMultiSelectField', '') 
```

Finally, you can return the result in your **GeometryAndDataResult**:  

```python
return vkt.GeometryAndDataResult(geometry=cubes.values(), data=vkt.DataGroup(data_1, data_2)) 
```

And this is a simple implementation of how you can implement geometry interaction in your applications! 

## Conclusion 

Geometry interaction is a key part of any application that wants to perform actions on a geometry. Whether it is the set-up of a simulation or an informative pop-up, selection is the basis of all interactions. With the latest additions to VIKTOR’s input fields, you can now easily improve the user experience of your applications that use geometries.  




large_Geometry Interaction.png

medium_Geometry Interaction.png

small_Geometry Interaction.png

thumbnail_Geometry Interaction.png

Geometry Interaction.png

Learn how to implement geometry interaction in your VIKTOR apps to streamline design workflows and improve user experience. Discover examples of geometry selection for simulations, model adjustments, and data retrieval.

Enhance Designs and Simulations with Geometry Interaction in VIKTOR

## Pushing and pulling data with VIKTOR’s Grasshopper worker 

A great way of automating your Grasshopper scripts is by integrating them into your applications. There's just one downside to this: you cut out the Grasshopper user from the workflow. Overall, this is not an issue in mature design phases where the script was set. However, this is different for cases in which a Grasshopper script is still subject to change. Or whenever the model used in a VIKTOR application needs to be updated through a change in Grasshopper. No worries, because we created a solution to this: Grasshopper nodes, which you can use to let users on both sides of the flow push, pull and run analysis on data.  

Keep reading for some examples, including the download files to use in your own apps!

## Pull information from a VIKTOR app into Grasshopper 

Thanks to the VIKTOR API, we can now, using a Grasshopper node, retrieve information from a VIKTOR application in Grasshopper. This information can be anything. In the example video below, you can see that we are retrieving the bridge deck geometry from the VIKTOR application and are able to use it in Rhino and Grasshopper for further analysis or design. When we update and save the bridge deck, we can simply recompute it, and the latest geometry is loaded.  

Download the Grasshopper file used for this example [here](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_get_data.gh). 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1019705358?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Pull data from VIKTOR into Grasshopper"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

## Push data from Grasshopper to VIKTOR for visualization 

Similarly to pulling data from a VIKTOR app into Grasshopper, we can just as simply push Grasshopper data back into an app.  

In this example, we are pushing data for dashboarding. Dashboarding is one of the weak features of Grasshopper. Therefore, we want to push the data to VIKTOR to dashboard it there instead. In VIKTOR, we can use the power of Python and Plotly to make a custom and interactive dashboard of the latest model.  

In this example, we parametrically design a roof structure and push the data to VIKTOR. The VIKTOR application then calculates lengths, volumes and the expected carbon footprint of the structure!  

Download the Grasshopper file used for this example [here](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_push_data.gh).

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1019705441?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="grasshopper-beam-dashboard"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

## Run complex analyses on Grasshopper data 

In some cases, the designer may require information that is stored in VIKTOR. In this case, you can use `VIKTOR compute` to run an analysis and use the VIKTOR application as the calculator for your Grasshopper script.  

In this next example, we have a simple application that uses a VIKTOR app to calculate the cost and carbon footprint of the beam. Using this app, you can make more complex calculations in Grasshopper than before! Additionally, it introduces many options for optimization in Grasshopper. 

Download the Grasshopper file used for this example [here](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_compute.gh).

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1019705425?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="grasshopper-viktor-compute"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

## Push geometry from Grasshopper into VIKTOR and perform analyses 

Although this fourth example may seem similar to the second example, pushing data and pushing geometry are done slightly differently. In this example, we are showing that the user of the VIKTOR application (in this case a structural engineer) can perform an analysis using OpenSeesPy – a finite element package designed for structural engineering.  

In this application, the user creates the model using the grid in Grasshopper and pushes it to the VIKTOR application. In the VIKTOR application, the load case is added to the geometry and OpenSees creates a beautiful visual of the displacements. Updating the model takes just a few seconds! 

Download the Grasshopper file used for this example [here](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_push_geometry.gh). 

You can also find the full application [here](https://github.com/viktor-platform/grasshopper-to-opensees). 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1019705380?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="grasshopper-viktor-push-geometry"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

## What's coming next?  

These examples pave the way for many more features. As more examples and use cases are realized, we work towards creating even more seamless, collaborative tools for Grasshopper users and other domain experts.  Want to try Grasshopper and VIKTOR yourself? Join our community and [start building your own custom web apps](https://www.viktor.ai/start-building-apps) today! 

**Download links:**
- [grasshopper_viktor_get_data.gh](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_get_data.gh)
- [grasshopper_viktor_push_data.gh](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_push_data.gh)
- [grasshopper_viktor_compute.gh](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_compute.gh)
- [grasshopper_viktor_push_geometry.gh](https://github.com/viktor-platform/grasshopper-to-opensees/raw/refs/heads/main/grasshopper-files/grasshopper_viktor_push_geometry.gh)
- [Grasshopper to OpenSees template](https://github.com/viktor-platform/grasshopper-to-opensees)



large_Grasshopper.png

medium_Grasshopper.png

small_Grasshopper.png

thumbnail_Grasshopper.png

Grasshopper.png

Learn how integrating VIKTOR into Grasshopper nodes eliminates data loss, enhances collaboration, and streamlines complex workflows for engineers, architects, and parametric designers. Discover the benefits of seamless data flow and workflow efficiency.

Connecting Grasshopper & VIKTOR apps  

## What is SkyCiv?

If you are a structural or civil engineer, you might know SkyCiv. SkyCiv is a powerful cloud-based structural design software focusing on efficiency and innovation for the modern engineer. On top of that, it also has a fantastic API, supporting many modern programming languages, including python. Today, professionals in more than 160 countries use SkyCiv structural analysis and design software, and API technology to solve their projects. 

Visit the [SkyCiv](https://skyciv.com/) website for more information.


### What we like most about SkyCiv

With the same level of functionality as traditional structural analysis software, or maybe more, SkyCiv has many things we are enthusiastic about. However, we want to highlight these functionalities in particular:

- All calculations are done in the cloud, making it super easy to integrate SkyCiv into your web application. You don't need software running on your computer or company's servers, making company-wide licensing and distribution issues a thing of the past. We really liked that! 
- Having a Python-enabled API is great! It enables you to use the complete Python ecosystem and powerful libraries such as NumPy, Plotly, and Pandas for your calculations.
- The model you make using the SkyCiv API is also a Python object and not just a text input file, meaning you can interact directly with it, read, and change its properties, and more!  
- You can ask SkyCiv to render your model and results in HTML, making it possible to embed the completely interactive 3D model in your website or VIKTOR app. Enabling you, for example, to adjust the view, get information about the materials or sections, and calculate the distance between nodes inside your app. 
- SkyCiv has a database with all kinds of section and material properties, and much cooler; you can also get the wind and snow load based on a GPS location. 


## SkyCiv and VIKTOR: A powerful combination

You hear us being quite positive about SkyCiv. So, why should you want to use it in combination with VIKTOR?

Like any FEM software, SkyCiv is powerful but requires specialist knowledge to make the most of it. Many processes can be automated, but that means working with an elaborate Python script using the SkyCiv API. Will all your colleagues be able to? Maybe, but probably not.

If you are looking for a way to make custom tools people can pick up and use quickly, you need a user-friendly interface on top of SkyCiv. Yes, we know you can make a product configurator directly with SkyCiv, but for this, you need to be quite handy with HTML and JavaScript. Here is where VIKTOR comes in handy.

With VIKTOR, you can quickly create a complete web-based user interface using nothing but Python, and it is easy too! On top of that, VIKTOR allows you to automate a larger part of your workflow by integrating your SkyCiv model with all kinds of other software packages. And what about the hosting? VIKTOR takes care of that too.     
     
<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/729982382?h=305d479fc4&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv &amp;lt; &amp;gt; VIKTOR"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*Select fullscreen for a better view of the application*

</br>

### The benefits of SkyCiv and VIKTOR

Integrating SkyCiv with VIKTOR brings out the best features of both software. Below, we have listed why we think SkyCiv and VIKTOR complement each other perfectly: 

**Accessibility:** VIKTOR has an intuitive user interface, which makes it easy for other people to interact with your app. This makes building your SkyCiv model in an automated way much more accessible for people without (lots of) coding experience.

For example, this is a VIKTOR interface:

![MicrosoftTeams-image (11).png](https://cms.viktor.ai/uploads/Microsoft_Teams_image_11_9b22b4f850.png)

</br>

And this is the code you need to build a SkyCiv model:

```python
def _build_model_from_parameters(num_floors,
            grid_num_width, grid_num_length, 
            nodes_per_plain, corner_positions, 
            neighbours, grid_size_length, 
            grid_size_width, add_braces
        ) -> skyciv.Model:
    """Builds a SkyCiv model with the chosen parameters"""
    model = skyciv.Model("metric")  # Initialise an empty model

    # Member ids:
    # 1: Column
    # 2: Beams
    # 3: Braces

    current_y = 0  # Would be the current height
    for current_floor in range(num_floors + 1):
        current_z = 0  # Would be the current "width"
        for _ in range(grid_num_width):
            current_x = 0  # Would be the current "length"
            for _ in range(grid_num_length):
                uid = int(
                    model.nodes.add(current_x, current_y, current_z)
                )  # Add the node to the model and record the id tag
                # If the node ID is bigger then the nodes per plain
                #   then there is a node below it
                if uid > nodes_per_plain:  
                    # Connect the node to the node below
                    model.members.add(uid - nodes_per_plain, uid, 1)  
                    # If the column is not the first in its row
                    if (uid - 1) % grid_num_length > 0:
                        # Connect beam in x direction  
                        model.members.add(uid, uid - 1, 2)  
                    # The id on its own floor
                    floor_position = (uid - 1) % nodes_per_plain
                    # If the column is not in the in the first row
                    if floor_position >= grid_num_length:  
                        # Connect beam in z direction
                        model.members.add(uid, uid - grid_num_length, 2)  
                    if add_braces:  # Enable braces on the model
                        # Check for corners
                        for c, n in zip(corner_positions, neighbours): 
                            if floor_position == c:  # This is a corner
                                for sn in n: # Check every neighbour of corner
                                    # Get the id of the neighbour
                                    nid = sn+current_floor*nodes_per_plain+1  
                                    model.members.add(
                                        nid, uid - nodes_per_plain, 3
                                    )# Brace from neighbour to column of corner
                                    model.members.add(
                                        nid - nodes_per_plain, uid, 3
                                    )# Brace from column of neighbour to corner
                else:  # These nodes are on the floor
                    # Add support to the floor node
                    model.supports.add(uid, "FFFFFF")  
                current_x += grid_size_length  # Increment on the x-axis
            current_z += grid_size_width  # Increment on the z-axis
        current_y += FLOOR_HEIGHT  # Increment on the y-axis
    return model
```

</br>

**Speed:** VIKTOR is like a box of digital building blocks you can assemble to create your own apps. With Python, you can use the full functionality of SkyCiv and VIKTOR, making it easy to build powerful and user-friendly applications quickly.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/729945922?h=557e8fb532&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv &amp;amp; VIKTOR - Adding parameter"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*Adding a parameter*

</br>

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/729945794?h=811668fa56&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv &amp;amp; VIKTOR - Adding control"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*Adding a control*


</br>


**Integrate with other software:** VIKTOR makes it easy to use SkyCiv in combination with (multiple) different ready-to-use integrations with industry-leading software, Like Excel sheets, Geotechnical Software, 3D modeling software, and much more. You can also generate custom reports based on your own templates.

**Interactive visualizations:** You can embed a completely interactive SkyCiv model into your VIKTOR app. Select, for example, which parts of the design you would like to show and which parts you would like to hide. You can also see information about the materials used for each member, forces, and calculate the distance between nodes. On top of that, you can use VIKTOR Views to enrich your app with maps, interactive graphs, other 3D models, and more. 

For example, this is the web view in your VIKTOR app:

<div style="padding:56.3% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/731261594?h=23f0446916& autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv results and interactive renderer"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

And this is the code used to create an HTML page for your VIKTOR web view:

```python
def get_html_render(model, mode: str = "model", results: str = None):
        """The SkyCiv render is written in javascript. We can use the 
        webview to use it. However the webview only uses a single
        html file. We therefor use the jinja utility to build the html 
        file.
        """

        # Build the html file
        url = (
            "https://api.skyciv.com/dist/v3/javascript/skyciv-renderer-dist-2.0.0.js" 
        ) # The url to the skyciv renderer
        renderer = get_renderer(url)  # Request the renderer
        context = {
            "renderer": renderer,
            "model": model.get(),
            "mode": mode,
            "results": results,
        }  # Create the context to use with jinja
        path = Path(__file__).parent.parent / "lib" # Template location
        # Open the html file to be used as jinja template 
        with open(path / "renderer.html.jinja", "rb") as template:
            # Build the html file using the template and context  
            filedata = render_jinja_template(template, context)  

        # The return type of the jinja utility is already an 
        # viktor.core.File so it can be directly used in WebResult
        return filedata  
```

</br>

**Easy parametrization:** It is super easy to create parametric structures with SkyCiv in VIKTOR. Simply connect the InputField, Sliders, and other features to your SkyCiv model, and see it change at the click of a button.  

<div style="padding:56.3% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/731261579?h=88632d1b91&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv model in VIKTOR"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

**Total flexibility:** You can create a parametric model in VIKTOR, but what happens if you want to add some specific details for a project? No worries, The SkyCiv API lets you save the models you send in their own cloud environment. So, if you want to edit details after designing your model, you can continue inside the SkyCiv editor.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/729946100?h=665a8c0a89&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv &amp;amp; VIKTOR - Dashboard"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

*The dashboard*

</br>


## Try SkyCiv in VIKTOR

In this video, you can see the SkyCiv API integrated with a VIKTOR web application. With only a handful of input parameters, a structural model is created and analyzed in no time.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/729982382?h=305d479fc4&autoplay=1&loop=1&autopause=0&amp;badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen style="position:absolute;top:0;left:0;width:100%;height:100%;" title="SkyCiv &amp;lt; &amp;gt; VIKTOR"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

There are three steps to using the application:

1. **Design the building:** First, insert the input parameters. The input parameters for materials are aligned with the materials in the SkyCiv database. 

2. **Map view:** Second, go to the map view to select a point on the map that you can later use to calculate the snow load through the SkyCiv API.

3. **Analyze:** For this third step, you can choose for yourself which loads you use. There are two things you can do with the API request here: 1) Generate an analysis report from the model that you created that shows typical FEA results like nodal displacements, support reactions, and member forces. 2) View the deformations on the model inside the SkyCiv renderer. These deformations are based on the parameters you have set. This model is then also saved to your SkyCiv dashboard (see: 'Recent files'). 


## What we can conclude

So, what we can conclude is that SkyCiv and VIKTOR together is a powerful combination. Linking SkyCiv's advanced FEM software - which often requires specialist knowledge to use to its full potential - to the user-friendly and intuitive interface of VIKTOR, enables not only specialists but also other (structural) engineers to automate and optimize their workflows! 

With easy accessibility, design and calculation speed, the ability to integrate with other software, interactive visualizations, easy parametrization, and total design flexibility, we invite you to build your own SkyCiV - VIKTOR apps. Download the full code from our [GitHub repository](https://github.com/viktor-platform) and sign up for a [free VIKTOR account](https://www.viktor.ai/start-building-apps) to start building awesome apps!

Blog_skyciv_VIKTOR

Combine SkyCiv and VIKTOR to create powerful and user-friendly parametric design tools. 

Automate and optimize structural workflows with SkyCiv and VIKTOR

SkyCiv and VIKTOR to automate and optimize structural workflows

## What is RFEM? 

If you're reading this, you probably already know what RFEM is. If not, let us explain quickly. 

RFEM is a 3D finite element analysis software by Dlubal, made for structural analysis and design and, amongst others, the generation of steel, and concrete structures. With RFEM, structural engineers can easily create everything from simple to complex models and perform structural and dynamic calculations.

## RFEM’s new WebService 

More frequently, engineers start looking for possibilities to customize and automate their structural analyses and designs. That’s why Dlubal created a WebService that offers remote communication with RFEM over web protocols, using Python or C#. It works like an API and enables engineers to use RFEM beyond, and without, its graphical interface. This way, you can automate (part of) your workflow or even create a custom parametric design web application. 

## Why a parametric RFEM web application? 

Imagine that you are an engineer who is designing warehouses, tanks, silos, staircases, or anything else for that matter. All your designs are different to some extent, but not that much. In the end, you follow the same design process to create and validate every design and make a quotation, some reports, and drawings. With a repeating process like this, would it not be great to have a parametric design tool that does all of this for you? And would it not be even greater if your colleagues could also use this tool all by themselves, so you have more time to focus on other, more challenging, and fun parts of your work? 

If this sounds interesting, we recommend using Python to create a parametric design tool like this. Besides automating large parts of only your ‘boring’ (read: repetitive) work, a user-friendly web application with a custom user interface makes it possible for those without Python experience to automate processes as well. On top of that, an online application is a perfect way to distribute your data. You can authorize anyone with an internet connection to use your app, you can be sure that everyone is always using the correct version of the model, and you keep your intellectual property protected, as you won’t have to share any code. You may be thinking: “That sounds awesome but is this not difficult to manage?”. No worries, not with VIKTOR. Just keep reading… 

## What is VIKTOR? 

VIKTOR is an online application development platform that enables you to create your own web applications using nothing but Python. It seamlessly integrates with RFEM, and so much more software products!  

Here are some of the biggest benefits of VIKTOR: 

**Easy & fast:** VIKTOR is like a box of digital building blocks you can assemble to create your own apps. With Python, you can use the full functionality of RFEM and VIKTOR, making it easy to build powerful and user-friendly applications quickly. 

**Accessibility:** Thanks to the user-friendly and intuitive interface, non-specialists can also use your apps. Anywhere in the world. All you need is an internet connection.  

![RFEM & VIKTOR 1.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_1_50940ca15d.png)

</br>

**Hyper automation:** You can build apps customized to fully automate your workflow, connect with multiple software packages, and include all kinds of visualizations, optimization routines, reporting, and much, much more. 

![RFEM & VIKTOR 2.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_2_16c0cbb923.png)

</br>

**Integrate with other software:** Through VIKTOR, it becomes possible to use RFEM together with (several) other products like Excel sheets, other software for structural engineering, soil mechanics, 3D modeling, and the complete Python ecosystem. 

**Focus on what matters:** VIKTOR takes care of all the non-engineering parts of creating apps, like creating a user management system, hosting and cloud infrastructure, database, backups, and security patches.   

## What about detail engineering and specials? 

We know it is very difficult to create a parametric design tool that covers all cases. Fortunately, this is no big deal if your tool does 95% of the work for you. Once the basic design is finished, you can simply download the RFEM models from the application and work on them via the RFEM user interface like usual. The only difference is that this time, you don’t need to start from scratch! 

Here you can see a simplified version of part of the data from RFEM in the VIKTOR interface: 

![RFEM & VIKTOR 3.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_3_36ba2d4521.png)

</br>

Versus the complete model in RFEM: 

![RFEM & VIKTOR 4.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_4_4485d75543.png)

</br>

## The RFEM-VIKTOR app explained 

Here is a short explanation of how this app works.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/802995926?h=4556d93899&badge=0&autopause=0&player_id=0&app_id=58479/embed" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen frameborder="0" style="position:absolute;top:0;left:0;width:100%;height:100%;"></iframe></div>

</br>

1. **Design in VIKTOR:** Using the app starts with the creation of a frame (truss) design in VIKTOR, which can be seen in the view on the right side of the application. This is a generic model with nodes and members. Users can also optimize designs by selecting a minimum and maximum truss height and the number of steps. Based on this input, the application iterates over these parameters and calculates results using RFEM. After all the calculations you can view the results in both a table and a figure. You can then select the best design. 

2. **Complete calculation with RFEM:** When you are happy with your design you can send the model to RFEM for calculations. In RFEM, the design is processed, and all desired information is automatically separated and returned to VIKTOR in a clear overview.  

3. **Analyze:** When RFEM has finished all the calculations, you can choose the values you want to display on your design model. For example, you can do a unity check to determine the forces on the model (displayed with corresponding numbers and color code in the view). On the right side of the application, you can find data with information retrieved from RFEM. 

Calculations take longer the bigger your model is, also more steps for optimization equals more calculation time. Keep that in mind while running the application for yourself. 

## What is next? 

RFEM is a powerful tool for structural analysis, designs, and calculations. Combining the best qualities of RFEM with an intuitive interface on the VIKTOR platform makes the quick and easy generation of structural models and performance of structural analysis and calculations accessible for anyone. No need for any experience with RFEM or programming (with Python)! 

You can now build your own RFEM – VIKTOR app by signing up for a [free VIKTOR account](https://www.viktor.ai/start-building-apps)!  


large_Group 177.png

Group 177.png

We have integrated RFEM’s Webservice and API with VIKTOR to make building user-friendly applications for structural design and analysis easier than ever!  

VIKTOR Blog

What's new in VIKTOR (December 2024)

Automate frame section creation in SAP2000 using Python and Excel

What's new in VIKTOR (November 2024)

6 Ways to improve your SAP2000 and ETABS workflows

How to use Python to automate SAP2000

VIKTOR Blog

What's new in VIKTOR (December 2024)

Automate frame section creation in SAP2000 using Python and Excel

What's new in VIKTOR (November 2024)

6 Ways to improve your SAP2000 and ETABS workflows

How to use Python to automate SAP2000

Customer Cases

White Papers & Guides