Parametric design

## Confusing structural models

A structural model may vary between its' different subsections. Implementing these variations makes the design process very tedious and time consuming. Besides this, the following problems and questions arise:

- How can the results of a batch calculation of for example 100 tunnel sections be visualised effectively?
- How can the results obtained from different software programmes, in this case SCIA Engineer and IDEA StatiCa, be combined in one clear visualisation?
- What is the amount of effort required to update all individual models whenever a global change in geometry occurs (e.g. a wider tunnel)?

## Parametric design methods

### Automatic generation of structural models

On the VIKTOR platform, an application has been developed that enables the automatic design of a tunnel. Within this application, global parameters can easily be varied, such as the height of the tunnel, thickness of the walls, applied load, and more. Due to the variation in depth along the tunnel, the design is split into subsections (tunnel slices), enabling local overruling of deviations. An integration between the online application and SCIA has been established such that the user can start a (batch) analysis with a single button. The result of this analysis is sent back to VIKTOR and shown in an insightful visualisation. Moreover, the results are stored automatically within the application, making it possible to retrieve and visualise earlier obtained results as well. With this visualisation, the critical locations within the structure can quickly be determined.

![Automatic modelling and analysis of a tunnel consisting of hundreds of subsections.png](/uploads/Automatic_modelling_and_analysis_of_a_tunnel_consisting_of_hundreds_of_subsections_dc3bc918f7.png)

*Automatic modelling and analysis of a tunnel with parametric design methods through an integration with SCIA on the VIKTOR platform*

### Automatic testing of reinforcements

Now that the critical internal forces are known, they can be compared to the capacity of the reinforcement to see whether this reinforcement suffices. The design of the reinforcement is done in a similar way as the tunnel geometry, using [parametric inputs](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction). Each unique reinforced cross-section is tested through an integration with IDEA StatiCa. Similar to the SCIA (batch) analysis, the user is able to start a (batch) analysis in IDEA after which the results are returned and stored on the VIKTOR platform. At this point, all data is centralised in the application and can be combined and visualised in almost any desired way. In the example below, the internal forces (in red and blue) of a tunnel cross-section are shown, along with the reinforcement capacity (in dark and light green).

![The internal forces of a tunnel cross-section and the reinforcement capacity.png](/uploads/The_internal_forces_of_a_tunnel_cross_section_and_the_reinforcement_capacity_f8dc155163.png)

*The internal forces (red/blue) of a tunnel cross-section with the reinforcement capacity (dark green/light green)*

## The benefits of parametric design

### Cost reduction

The development of this application ran parallel to the design process of the tunnel. Initially, the focus was placed on delivering a minimum viable product of which the preliminary design could be simplified and sped up. Now, the amount of tedious and time consuming tasks an engineer would have to perform for each tunnel slice design has significantly been reduced. Also the chance of manual (human) errors has almost completely been mitigated. The time reduction enables faster iteration of designs with more detail, resulting in a tremendous reduction of material cost. All of that for only 500 hours of development time!

### Batch analysis

After making the necessary changes to the preliminary model, the changes have been incorporated in the application code such that it is ready for the detail design phase. This phase cost another 500 hours of development time and with the expansion it was also made possible to do the batch analyses of multiple tunnel slices. Thanks to this, with just a single button click, a large part of the tunnel could be analysed during the night.

### Time-savings

Last but not least, thanks to the [parametric](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) setup, last-minute design changes were easily applied and the complete tunnel was re-analysed in no time. This results in huge time savings for the engineer.

## Potential and future

We can hear you thinking, “What use does the application have when the tunnel is designed completely? Can the code-base now just be flushed down the toilet?” Definitely not! During the development process of an application, features are built with reusability in mind. They are created as “generic” as possible, which means that they may be used in another application as 'digital builiding blocks, in a plug-and-play way.

Besides the integrations with SCIA Engineer and IDEA StatiCa, the application has potential to incorporate an analysis of the foundation piles using an integration with, for example, D-Foundations. Such an integration is quite standard and can be created as a generic feature as described above, making it easy to reuse. In fact, this feature readily exists in other applications and can therefore fairly easy be implemented in this application (meaning no 500 hours development time needed)!

See how you can [create your own parametric design tools for automation and optimization](https://www.viktor.ai/parametric-design-software) here.



small_backgroundSCIAVIKTOR.png

thumbnail_backgroundSCIAVIKTOR.png

Blog_parametric_desgin_automated_tunnel_modelling_5

Parametric design for automated tunnel modelling and analysis

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



large_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

medium_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

small_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

thumbnail_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

WP_white

large_parametric_steel_structure.png

medium_parametric_steel_structure.png

small_parametric_steel_structure.png

thumbnail_parametric_steel_structure.png

WP_white_2

The adoption of parametric design grows exponentially thanks to friendly programming languages like Python or visual programming packages like Dynamo or Grasshopper.
 
Our perception is changing. We no longer see parametric design as a model to solve specific technical problems, but rather as a new way of working, in which stakeholders collaborate to find the best solution for a project.

Learn about the latest trends and the future of parametric design in this white paper

Collaborative parametric design models allow you to work together for better solutions

Download the white paper and get INSPIRED

Did you know parametric design models are no longer just used to solve specific technical problems, but rather as a new way of working? Read here how stakeholders use parametric design to collaborate and find the best solutions for their projects!

The Future of Parametric Design is COLLABORATION

Creating Apps & Python

## GRLWEAP

With the software program GRLWEAP you can perform a driveability analysis. To do so, you enter the data of the soil (the probing), the hammer and the pile you want to use. It will then calculate for you how long the pile driving will take and to what extent you can get the pile into the ground. In itself there is nothing wrong with the analysis, it is just that everything has to be manually entered into the program, which is a time-consuming task that is also prone to human error.

## Parametric design

The goal was therefore to design a [parametric design tool](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) in which the input no longer has to be done manually. This means that not every possibility has to be entered separately and therefore multiple analyses can be done in a short period of time. Performing automated batch calculations in GRLWEAP was something that had not been done before, so everything had to be figured out from the start.

### Parameters

First, the input file had to be figured out. Which parameters do you want to control, so which variables are needed? Next, it was figured out how to get them into the input file and then write Python code to automatically build input files. These variables can be adjusted to the wishes of the user.

### Automation

In GRLWEAP a ground structure is used, which is normally filled in manually by a geotechnical technician. He analyses the soil information to define the structure. The [parametric design tool](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) itself can interpret these probes and classify a soil structure. The soil structure is then translated (with some formulas) into a ground structure that GRLWEAP can read. Because a ground structure has to be defined per analysis, it was a time-consuming process to determine it manually. The automation therefore saves time.

![GRLWEAP.png](/uploads/GRLWEAP_cd39f05275.png)

### Optimization

The real time gain lies in the batch analysis. You can enter different probes, types of hammers and types of piles and the tool will calculate all possible combinations. All results are collected and made understandable by means of tables. Here the optimal combinations can be extracted by the engineers.

## Future opportunities

The current tool is suitable for various pile driving problems, such as office buildings, tunnels or houses. To make the tool more interesting and specific for offshore, other soil investigation programs could be added. This is because there are not always probes available, something on which the current tool depends. An example could be Rockworks.

See how you can [create your own parametric design tools for automation and optimization](https://www.viktor.ai/parametric-design-software) as well.



large_GRLWEAP.jpg

medium_GRLWEAP.jpg

small_GRLWEAP.jpg

thumbnail_GRLWEAP.jpg

Blog_pile_drivability_analysis_with_GRLWEAP_python_1

A parametric tool for automated pile drivability analysis with GRLWEAP and Python

## Civil engineering automation

A structural design process consists of several or perhaps many design iterations. For each iteration, a civil engineer designs a structural model and uses structural analysis software, such as SCIA Engineer, to perform an assessment. If the SCIA software indicates that a structure does not meet the requirements or if some input has changed, this cycle is repeated. Therefore, this can be a very time-consuming process. The more manual actions, the greater the risk of errors. 

Time and risk can be significantly reduced by automating the above steps. VIKTOR offers a binding with SCIA Engineer that enables civil engineers to calculate structural models at the push of a button, using a [parametric Python model in the Cloud](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction), without even having to open the SCIA interface. 

## Open-source Python library

VIKTOR developers have encountered multiple civil engineering design projects for which a SCIA Engineer model had to be created. Using all this knowledge, a growing Python library with digital building blocks came to be. At some point this library got included in the [VIKTOR SDK](https://docs.viktor.ai/docs/reference/sdk/intro), making it publicly available.

In addition to the Python library, an integration with SCIA itself was developed that allows the civil engineer to automatically perform analysis within a user-friendly VIKTOR app without having to open the SCIA interface at all. 


## Design automation with SCIA

### Creating a SCIA model with a few lines of Python code

Building SCIA models using the VIKTOR SDK is done by writing object-oriented Python code; no knowledge of the SCIA Engineer API is required. All the relevant Python building blocks can be found in the module [*viktor.external.scia*](https://docs.viktor.ai/docs/reference/sdk/api/external/scia), of which the starting point is the *SciaModel*. 

Let’s start by creating a new instance of this class, to which subsequently desired elements (e.g. nodes, cross-sections, beams, supports, loads etc.) can be added. 

The example below shows what this could look like in Python code:


```python
Def create_scia_model(self, params) --> SciaModel:
Model = SciaModel()


# create nodes
Model.create_node(‘K:1’, 0, 0, 0) # origin
Model.create_node(‘K:2’, params.geometry.piles.x1, 0, 0)
Model.create_node(‘K:3’, params.geometry.piles.x2, 0, 0)
…
Model.create_node(‘K:n’, params.geometry.piles.floor.width, 0, 0)


# create pile beams
Model.create_beam(‘S:pile1’, top_pile_1, bottom_pile_1, cross_section)
…


Return model
```


We often recognise that it is difficult to verify whether the developed Python code actually builds up the correct SCIA Engineer model. That is why we recommend creating a visualization of the model within VIKTOR simultaneously. The visualization is not only helpful for visually verifying the model, it also serves as a very nice design overview for the end user! The method defined above can be used in a generic visualization method as shown below:


```python
@GeometryView(“SCIA model”, duration_guess=3)
def create_visualization_geometries(self, params, **kwargs):
scia_model = self.create_scia_model(params)


# nodes
geometry_group = Group([])
for node in scia_model.nodes:
node_obj = Sphere(Point(node.x, node.y, node.z), 1)
geometry_group.add(node_obj)


# beams
pile_diameter = params.geometry.piles.diameter
for beam in scia_model.beams:
point_top = Point(beam.begin_node.x, beam.begin_node.y, beam.begin_node.z)
point_bottom = Point(beam.end_node.x, beam.end_node.y, beam.end_node.z)
beam_obj = CircularExtrusion(pile_diameter, Line(point_top, point_bottom)
geometry_group.add(beam_obj)


…


return geometry_group
```


By using the geometric VIKTOR Python building blocks [(*viktor.geometry* module)](https://docs.viktor.ai/docs/reference/sdk/api/geometry), the elements of the structural SCIA Engineer model can be easily converted to geometric elements and passed to a geometry result. 


### Visualizing structural models in the SCIA interface

It is always useful to manually load the created SCIA Engineer model in the SCIA Engineer interface, which will help to verify that, for example, all the loads are correctly defined in terms of placement and magnitude.

To visualise the created structural model in the SCIA interface, the following three files are needed:

- model file (*.esa)
- definition file (*.def)
- input file (*.xml)

The model file can simply be an empty project file. The other two files can be easily generated by calling the method *generate_xml_input()* on the SciaModel created above. It is probably a good idea to develop a download functionality such that the end user can manually download the input files as well:


```python
Def download_scia_input_xml(self, params, **kwargs):
Scia_model = self.create_scia_model(params)
Input_xml, _ = scia_model.generate_xml_input


Result = DownlaodResult(input_xml.getvalue(), ‘test.xml’)
Return ViktorResult(download_result=result)
Def download_scia_input_def(self, params, **kwargs):
M = SciaModel()
_, input_def = m.generate_xml_input()
Result = DownloadResult(input_def.getvalue(), ‘viktor.xml.def’)
Return ViktorResult(download_result=result)
```

The next step is to load the three files into the SCIA interface (*File > Update > XML file*) and verify the created model.


## Analyzing the structural SCIA model within VIKTOR

In addition to the binding to build up the SCIA Engineer structural model, the [*viktor.external.scia*](https://docs.viktor.ai/docs/reference/sdk/api/external/scia) module also offers an analysis Python building block (*SciaAnalysis*) which sends the required input files to the so-called *SCIA worker*, which runs on a designated (virtual) machine and executes SCIA. When the analysis has been completed, the worker sends the result file back to the web application. The OutputParser (from viktor.external.scia) can be used to easily extract specific results from the result file. 

Below you can find an example of the result processing and the associated visualisation.

```Python
@GeometryAndDataView(“SCIA Result”, duration_guess=60)
Def run_scia(self, params, **kwargs):
Scia_model = self.create_scia_model(params)


# create input files
Esa_path = Path(__file__).parent / ‘scia’ / ‘model.esa’
Input_esa = BytesI0()
With open(esa_path, “rb”) as esa_file:
Input_esa.write(esa_file.read())


Input_xml, input_def = scia_model.generate_xml_input()


# analyze SCIA model
Scia_analysis = SciaAnalysis(input_xml, input_def, input_esa)
Scia_analysis.execute(300) # timeout after 5 minutes
Scia_result = scia_analaysis.get_xml_output_file()


#parse analysis result
Parser = OutputParser(scia_result)
Table_element = parser.get_table_element_from_name(“Reactions”, parent=’Combinations – C1’)
Df = parser.convert_table_element_to_data_frame(table_element


Max_rz = float(max(df[‘R_z]))
Data_result = DataGroup(
DataItem(‘SCIA results’, ‘, subgroup=DataGroup(
DataItem(‘Maximum pile reaction’, max_rz, suffix=’N’, number_of_decimals=)
))
)


Geometry_group = self.create_visualization_geometries(params, scia_model)
Return GeometryAndDataResult(geometry_group, data_result)
```


*An example of the result processing*

![blog_python_scia_example_associated_processing](https://cms.viktor.ai/uploads/blog_python_scia_example_associated_processing_c130288e81.png)

*The associated visualization*

This video shows how the parametric geometry is build within in VIKTOR and what it looks like when SCIA Engineer is used to analyze the structural design from within the app, using Python. The model is downloadable so that results can be viewed in SCIA Engineer or directly within the web app. With the app, civil engineers are sure to always work with the latest structural model, perform fast structural analysis to save time, and get clear results and rich visualisations. 

<div style="padding:58.68% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/656990782?h=8f1a608832&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="SCIA and Python for parametric models in the Cloud"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>


## A total design solution

The SCIA binding developed by VIKTOR allows for an easy conversion between a [parametric model](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction), to a meaningful input for SCIA Engineer, using only Python. 

A VIKTOR worker takes care of a connection between the web application and the structural design and analysis software, such that SCIA can be executed from within the browser. 

After the structural analysis, the results are returned and can be visualised on top of the model visualization. This means that the manual tasks of constructing the structural design for a SCIA Engineer model in the interface, analysing the structural model, and assessing the results can all be done by the civil engineer with a simple click of a button from within the VIKTOR interface!

See how you can [integrate with your preferred software](https://www.viktor.ai/platform), using only Python and how you can use [parametric design in the Cloud](https://www.viktor.ai/parametric-design-software) to build civil engineering apps!

![SCIA scan.png](/uploads/SCIA_scan_dd8182e4da.png)

See how you can build your own apps to automate civil engineering processes:

[![CTA_try_for_free](https://cms.viktor.ai/uploads/CTA_try_for_free_6af1b46cf2.svg)](https://m.viktor.ai/free_version)

## Related content

A list of articles about integrations with civil engineering software and structural design & analysis software that you might find interesting as well:

- [GeoTools](https://www.viktor.ai/blog/14/web-application-python-geotechnics)
- [RFEM models in the Cloud with Python](https://www.viktor.ai/blog/9/RFEM-automation-python-app)
- [Dynamo and Civil3D](https://www.viktor.ai/customer-cases/14/python-dynamo-civil3D-MXroad)
- [PLAXIS models in the Cloud with Python](https://www.viktor.ai/blog/34/integration-plaxis-python-parametricdesign)
- [Pile foundation processing with D-Foundations and Python](https://www.viktor.ai/blog/21/automation-python-D-foundations-web-application)
- [Pile driveability analysis with GRLWEAP and Python](https://www.viktor.ai/blog/22/parametric-design-python-GRLWEAP-pile-driveability)
- VIKTOR also offers integrations with AutoCAD for civil engineering. Go the our [platform page](https://www.viktor.ai/platform) for more information.




large_SCIA warmtescan.png

medium_SCIA warmtescan.png

small_SCIA warmtescan.png

thumbnail_SCIA warmtescan.png

Blog_python_SCIA_create_parametric_models_cloud_1

Using Python and SCIA to create parametric models in the Cloud

In this blog, the proposed automation strategy for the ongoing design process of the tunnel and its benefit during the detailed design phase compared to traditional methods will be discussed. The present project forms the first application of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) and automation of such magnitude being developed in-house at the BESIX Engineering Department. It reflects our ambition to use these techniques for tackling the ever increasing challenges within the construction industry and simultaneously boosting productivity and the quality of the final product.

## Programming in construction engineering

When encumbered by the limitations of existing software packages, engineering tasks can greatly benefit from customized and automated workflows enabled by custom tools. Though not new, the implementation of programming in construction engineering is rapidly rising. The demand grows due to the ever increasing requirements and complexity of construction projects. In parallel the possibilities increase due to growing computation power, improved availability of Application Programming Interfaces (API’s) and to the rise of visual programming environments that are supported by large online communities, such as Grasshopper or Dynamo.

## Parametric design and automation in engineering

About two years ago the in-house Engineering Department of BESIX –Belgium’s largest construction firm– started to explore the potential of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) and automation to enhance engineering activities. 

### Parametric design for a new highway connection

BESIX is part of joint venture De Groene Boog that will design and construct a new highway connection in the North of Rotterdam for Dutch agency Rijkswaterstaat. The project comprises a 2.2 km long tunnel (excluding its entry ramps) of which the BESIX Engineering Department is currently conducting the structural design. Given the fact that repetition is key to ensure a large positive impact (both in terms of efficiency and quality) of any automation strategy, this tunnel design has from the start proven to be an ideal candidate to benefit from automation: it is a linear project with very repetitive geometry described by straightforward logic. In addition, a preliminary and detailed design phase of more than a year was foreseen, creating a risk for various design changes throughout the process that require rework. The project offered a unique opportunity for new developments thanks to this sufficient availability of time and to the high enthusiasm of all involved parties within the consortium for testing novel techniques. It forms the largest application of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) and automation developed inhouse at our engineering department so far.

The scope of automation for the tunnel design at BESIX comprises three parts:

1. the construction of a 3D Building Information Model (BIM);
2. the extraction of 2D technical drawings from this model;
3. structural calculations of the piles and tunnel section.

## Automated setup of a parametric information model

For purposes of coordination, visualization and communication a Building Information Model (BIM) of the tunnel’s structure needed to be created. This model is in a later phase used as the single source for the extraction of technical drawings.

### Creating the model

To benefit from the high degree of repetition, we decided to create the model through a series of custom programmes or scripts built upon and interconnecting multiple existing software applications. The model is composed of parametric objects of which the parameters easily allow their geometry to adapt to the variations present in the tunnel. The scripts automatically place and update these objects together with their parameters and other information. The location of each object is computed from the central road axis (see picture below), which is delivered by an external party. Consequently, a change in road axis can swiftly be propagated to the entire BIM.

![Three steps in the automated creation of the BIM](/uploads/Three_steps_in_the_automated_creation_of_the_BIM_57af2b2ec8.png)

*Three steps in the automated creation of the BIM: external input, i.e. the road axis and top surfaces with cross fall (top); main lines of the linear geometry (middle); view from the resulting structural model (bottom); screenshots from Dynamo and Revit.*

### Scripts for an efficient and accurate process
The key parameters that together with the road axis drive the geometry of the model are gathered and managed using a set of spreadsheets. These spreadsheets offer the advantages of ease of use and centralization. They simultaneously serve as the interface between the multiple software packages –each selected for its specific strengths– comprising the automation workflow. From this information, each corner of the linear structural components of the tunnel could accurately be computed. The resulting coordinates are stored into a new spreadsheet that forms the basis upon which the entire model is further constructed. Subsequent tools stepwise populate these numerous coordinates with the parametric objects of walls, floors, piles etc. Due to the vast number of coordinates and objects, the custom developed scripts are no longer merely handy, but become indispensable to ensure that this process can be done in an efficient and accurate manner. The entire workflow is illustrated at the end of the blog.

### Perfecting the design
It is important to note that various specialized commercial software packages exist for the modelling of linear infrastructure projects based on one or more road axes and a parametric road or tunnel profile. The coordinates of each corner of each linear structural component can furthermore easily be extracted from these models. The development of a custom tool for this purpose was nevertheless necessitated by the specific segmented tunnel geometry of the present project. The existing software typically creates geometry by sweeping a vertical profile along the road axis. Hence horizontal dimensions are measured normal to the road axis. In contrast, the present project consists of 25m long tunnel segments comprising straight walls, where horizontal dimensions should be measured perpendicular to the walls. A mismatch hence exists at places where the road alignment is bent. Though the difference might be small and mostly fall within construction tolerances, for the detailed design phase (with a minimum requirement of LOD300) we have nevertheless chosen to create a model that accurately corresponds to the design.

## The design of the tunnel

### Trial and error for faster future development

Developing the automation workflow for the creation of the parametric BIM of the tunnel has proven to be a time-consuming act. Multiple iterations of trial and error were required to find a workflow that offers sufficient flexibility to include all design variations throughout the process from model setup to drawing production. Consequently, an initial manual creation of the model within the existing software applications will probably have been faster. Nevertheless, multiple design changes have already taken place throughout the design process that likely have shifted the balance. The lessons learnt will additionally lead to faster developments on future linear construction projects.

### Flexibility in case of changes

Apart from time spent or won, the custom workflow improves accuracy and reduces risk of errors during manual actions. Most importantly is the gain in flexibility. Indeed, even a drastic change such as altering the road axis can now be quite efficiently dealt with by rerunning the various scripts. Nevertheless, the adaptability enabled by the developed tools is not infinite, but confined to a predefined design scope. It is important to consider which design changes should be allowed and included at the start of the modelling process, as changes surpassing the foreseen logic are more difficult to incorporate. The reality of a design project of this magnitude has unfortunately proven that this foresight is not always possible, making some rework inevitable.

## Automated production of technical drawings

From the information model over 2000 of similar, yet not quite identical 2D drawings need to be extracted. This equals one unique set of drawings for each of the 89 tunnel segments. Automation is imperative to ensure an efficient production process and should furthermore ease the handling of late design changes.

### Creating a sample set of drawings

Modern BIM tools greatly facilitate the extraction of drawings from a 3D model. The drawings are views from the 3D model, meaning that a change in the model is directly reflected in any related drawing. Nevertheless, setting up these drawings requires numerous manual actions. The average drawing sheet can easily take up to 8 hours for an experienced draftsman to complete. We have therefore opted to first create a single unique set of drawings of the tunnel to be approved within the project team, which would then serve as an example to be replicated as well as possible through automated procedures.

### Minimizing manual post-processing
Our previous experiences have shown that due to repetitive work connected to drawing production greatly gains in time, standardization and accuracy can be made using custom tools with a short development time, reducing a draftsman’s work from an average of 8 hours to 1 hour per drawing sheet. Our goal for the present project is to further minimize the manual post-processing needed by draftsmen and to entirely eliminate this need for 80% of the drawings.

#### Automatic production and management 
In a first step we automatically produce and manage the creation of drawing sheets and title blocks from a spreadsheet. The spreadsheet containing all drawing sheet information that is needed as input for this automated production is in general readily available for planning purposes. It can hence be efficiently reused for the actual creation of the drawing sheets. During the process, non-textual information can be added to the drawing sheets as well, e.g. QR codes providing a link to the online data management system.

#### Creation and arrangement of views
Once the drawing sheets have been prepared, views are created in the model and arranged on the drawing sheets. This process is straightforward to automate when the arrangement has been wellconsidered in advance. Creating scripts to add dimensions to the 2D drawings has in contrast proven to be elaborate. In search for a generic approach to place context-specific annotation, we have opted to add coded markers to the parametric model objects (inspired by the work of jointventure-partner Mobilis on project RijnlandRoute). Instead of directly dimensioning the objects, their markers are dimensioned, where each marker represents one point in space. The form of annotation is managed in the marker codes, which group points to be added to the same dimension line and define this line’s orientation and relative position. For example markers with a similar code for property X will be added to a linear dimension line for all views oriented along direction Y. Annotation can hence be managed and customized within the modelling environment instead of the scripting environment. Since we have more modellers available than programmers, this is a beneficial feature.

### A promising prospect

Though the actual results are due later this year and the drawing automation workflow is still under development, first tests are promising. Numerous drawing sheets and views can be produced in no time and in a highly standardized manner. Full automation has not yet been reached for any drawing set, where particularly the post-processing of annotation remains crucial. We will continue extending the automated actions where the BIM application’s API makes it possible and the potential time gain versus the required development time of the scripts makes it sensible to do so. For indeed, full automation of all drawings will surely not be useful as most unique technical details will simply be more efficient to produce manually using the standard toolset provided by the BIM application.

## Design automation
The present project equally entails repetitive work for the structural design of the tunnel that could be improved through automation. Several small tools are developed in-house to facilitate geotechnical analysis of the foundation and sheet piles. For the design of the reinforced concrete tunnel structure a tool has been developed together with an external partner on a cloud-based platform.

### Geotechnical design

Over 6000 foundation piles and 4000 sheet piles are to be designed for the tunnel. First, hundreds of CPT measurements need to be interpreted and matched to the piles for calculation. A spreadsheet has been set up for a custom interpretation of the CPT measurements and a VBA routine to run this process in batch.

For the calculation of the piles, the tools typically used in the Dutch market are straightforward to use, though they do not allow to create parametric calculation models. To avoid the need to manually change the model input for each unique set of soil and loading conditions along the tunnel, we created another spreadsheet to mimic parametric behaviour. The desired parameters of each individual calculation model are assembled in a single spreadsheet. As the calculation model can be easily read and edited through a text editor, we then use string manipulation to edit the textual contents of the model and create a unique calculation model for each unique set of parameters. These are in a following step computed in batch and the results automatically gathered – again in a spreadsheet– for post-processing.

### Structural design

For the structural design of the concrete floors, walls and roofs, we have collaborated with an external partner from the Netherlands, VIKTOR. Together we have developed a tailored design tool on their cloud-based platform by combining our engineering expertise with their development skills. This tool in a first step assists in setting up the structural models along the entire length of the tunnel for two different structural analysis software packages: a first to compute the internal forces of the tunnel sections and a second to design the structural reinforcement. The models are defined parametrically to easily set and change the design, while varying loads due to a variable tunnel depth are automatically introduced. The tool subsequently enables batch calculating all models and, most interestingly, afterwards gathers the results from both structural analysis packages and overlays them in a single visual representation (Figure 2). Aside from simply reducing the manual work, the tool hence processes and presents information in new manners providing swift insight for better-informed design decisions.

### Higher precision results and improved insight

To assist the geotechnical design, several small tools have been developed in-house based on spreadsheets. These tools are a typical example of a short development time combined with rapid results and great time savings. Of course spreadsheets have long been widely used in engineering. It is important to be aware of their added strength once they are connected to external files and applications.

For the design of the tunnel’s reinforced concrete structure, the developed cloud-based application drastically speeds up the calculation process and thus allows a change in design approach. Where one would traditionally calculate only a handful of representative tunnel sections, this tool allows calculating hundreds within the same time frame. The tool is hence beneficial to achieve higher precision results and improved insight, which enable fine-tuning the design and reducing material costs.

![design and production automation a16 tunnel rotterdam.png](/uploads/design_and_production_automation_a16_tunnel_rotterdam_36c4f26735.png)
*Visual output of the custom application based on the Viktor platform: single cross-section with bending moments (blue and red) and unity checks (yellow/green lines) (top figure); contour plot visualizing the unity check of the floor along the entire tunnel (results for 8 different segments are shown; bottom figure).*

## A technical challenge or an organizational challenge?
Due to its straightforward, repetitive geometry and its scale, the presented tunnel project offered various opportunities to develop customized tools for automation. Simple and accessible tools such as spreadsheets often play an important role, particularly as interface between existing software applications for an improved interoperability. The interactions between the individual workflows and tools could be further improved (e.g. by using the same centrally-stored geometric parameters for all applications; flowchart below). The variety of actors, information requirements, responsibilities and schedules however make this an organizational challenge rather than a technical challenge.

![Flowchart of the automation workflows](/uploads/Flowchart_of_the_automation_workflows_01f11c97e3.png)
*Flowchart of the automation workflows discussed in the present paper. The road axis is input shared by all workflows. Other input parameters -such as dimensions of the tunnel geometry- are of course equally shared, though they are entered in different formats and at different locations due to the varying information requirements. The dynamic links between the workflows should be improved in future projects.*

### Exploring the potential of small tools

Developing the automated setup of the information model has taken longer than expected, largely due to the incorporation of exceptions on the overall geometrical logic. It should hence always be carefully considered whether these exceptions should be automated in the first place. Once the effort has been made, a huge flexibility for coping with design changes is nevertheless obtained. The various developments for drawing production and geotechnical calculations moreover demonstrated the potential of small tools to have a large profitable effect on time, effort, accuracy and standardisation.

## The value of tools and parametric design
Our enthusiasm about the added value of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) and automation is high and likewise are our ambitions for the present project. Multiple developments are still ongoing and several tools still need to be tested. Their true added value remains to be evaluated to maximally benefit from the present developments in future projects.

[Build your own parametric design tools](https://www.viktor.ai/parametric-design-software) with VIKTOR.

### References
“Parametrisch ontwerpen,” Cement: vakblak over betonconstructies, vol. 70, no. 6, pp 4-55, 2018.
Level Of Development (LOD) Specification Part I & Commentary, BIM Forum, 2019, available on https://bimforum.org/lod/
K. Roovers and F. Snoeck, “Parametric Design and Automation for Contracting,” in Proceedings of the IASS Symposium 2018, C. Mueller and S. Adriaenssens, Eds. Boston: MIT, 2018.

Bron: 2019 IABSE congress New York City


medium_design and production automation a16 tunnel rotterdam.png

small_design and production automation a16 tunnel rotterdam.png

thumbnail_design and production automation a16 tunnel rotterdam.png

Customer_case_a16_tunnel_rotterdam_1

Parametric design and product automation for the A16 tunnel in Rotterdam

## 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

## 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 that is immediately available for trying out in the VIKTOR [demo environment](https://www.viktor.ai/demo-environment). You can also 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 or try the app directly through the [demo environment](https://www.viktor.ai/demo-environment).

When using the sample 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&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>

</br>
</br>

**Apply for a [demo account](https://www.viktor.ai/demo-environment) to get access to this and all other VIKTOR sample applications.**

</br>
</br>

## 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)

</br>

Use the [free version](https://www.viktor.ai/try-for-free) or apply for a [demo account](https://www.viktor.ai/try-for-free) to try the functionality yourself! 




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

Sample app parametric football stadium with Grasshopper

VIKTOR Blog