Creating Apps & Python

Digital transformation

## Pile foundation design with D-Foundations

Most companies that are involved in designing and building pile foundations need to perform many analyses to ensure that their foundation designs meet the safety standards as described in the NEN. Commonly, D-Foundations software is used to perform these calculations. 

D-Foundations is a software-package, created by Deltares: An academic institute that focuses on Hydro- and Geotechnologies. It is mostly used in the Civil and Architecture sectors. With D-Foundations, you can calculate the required depth of a set of specified foundation piles, placed in a particular soil composition (based on GEF files) and under a certain load. Using location-specific soil information, these kind of foundation calculations can be applied to many different constructions in the Building and Infrastructure sector, such as a factory floor for heavy machinery, a tall apartment building, or even the foundations for wind turbines and high voltage pylons. 

![D-foundations software package.jpg](/uploads/D_foundations_software_package_426dca58f8.jpg)

## Analyzing, analyzing, analyzing

Normally, to find the most optimal and cost-effective design, a Geotechnical Engineer needs to analyse a great number of possible designs. This is a time-intensive and tedious process, which is very prone to error as well. With today’s high demands on short delivery times, there is only time to evaluate a handful of designs. Because of that, the best design is not always found within that time frame.

## More analyses in less time 

To be able to run more D-Foundations analyses in shorter time, a binding between the D-Foundations software and the VIKTOR platform is made. The working principle of this binding will be explained in more detail later on in this article. 

With this binding, a D-Foundations analysis can be ran with just a few lines of Python code (see example code below). We can take the necessary input data, which is already centralized in the VIKTOR application upon uploading, and run multiple different D-Foundations analyses, without any human interaction needed. This means: No need for opening the GUI of D-Foundations and going through each of the steps manually!

![Blog_automate_processing_with_D-foundations_3](https://cms.viktor.ai/uploads/D_foundations_analysis_ran_in_few_lines_of_code_97269b2df3.png)


## Using D-Foundations

Similar to other software packages of the Geo-technical suite of Deltares, D-Foundations uses a set of input, settings, and dump files to store the in- and- output data of the calculations. These input files can be analyzed by D-Foundations in batch-mode through the command line, which will then create a dump-file with the results of the analysis. These files, however, are not very easy to understand and even harder to write yourself.

Therefore, the following automated workflow was devised:

1. Generate a correct D-Foundations input file using Python
2. Send this file to the server where D-Foundations is installed*
3. Run a D-Foundations analysis on the input file and send the data dump-file back to the application*
4. Visualize or output the data where necessary

*This requires no interaction from the user, nor does it require any coding from a developer, as this functionality is build into the VIKTOR platform

Points 2 to 4 are quite generic, so the focus of this article will be on the first point: Generating the input file. 

## Generating the D-Foundations input file

The combination of the filled-in VIKTOR web interface and the soil information that has been uploaded to the platform database hold all the information needed to perform a D-Foundations calculation. It is a matter of compiling all this data in the correct format into a D-Foundations input file. While the general concept of compiling a text-based input file is quite easy, the hardest part of creating a valid input file was the reverse-engineering of all potential input options and finding which specific pieces of information needed to be put where. 

The current average D-Foundations input file that we work with can easily contain over 100,000 lines of text. Therefore, putting the right information in the right place is essential. Unfortunately, no detailed documentation of the input file layout is available, so this process took significant time to complete. An added complexity was that the layout of the input file would change significantly, depending on which options were selected. This required numerous edge-cases to be evaluated and a lot of logic to be implemented.

In order to ensure the input file is correctly generated, the following steps have been executed:

1. GEF files (containing soil information) are analyzed and corresponding soil layouts are defined
2. The properties of the selected pile type (selected by the user) are extracted from the database
3. The grid of piles is defined, which includes the pile's locations, height, properties and loads 
4. Any additional calculation options, selected by the user in the web interface, are collected
5. All data collected in steps 1 to 4 are inserted into a generic template (.foi file), which is then rendered as the final input file

The innovative part is making the binding generic enough in such a way that it can be applied over a wide range of different projects/designs. This makes the binding future proof and much more valuable to current and future customers. 

## Ways to use the D-Foundations file

Once the D-Foundations file has been created, it can be used in several ways:  

1. The user could download the generated input file, using a download-button in the VIKTOR application. This file could then be imported into D-Foundations manually in order to visually inspect the D-Foundations model and review the report generated by D-Foundations. 
2. The user could also have the VIKTOR application run the D-Foundations analysis on an external server, after which the results are send back to the application and can be output to the screen. This way, the user can quickly analyse a design without ever having to open the D-Foundations software package.

Both these options are generic functions that are part of the generic VIKTOR platform and are therefore available but not limited to the D-Foundations software package.

![Downloading D-foundations input files in a zip-file](/uploads/Downloading_D_foundations_input_files_in_a_zip_file_27781ea934.png)
*Download D-Foundations input files in a zip-file*

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

*Run the D-Foundations analysis directly through the VIKTOR platform and visualize the result*

## Advantages of binding in D-Foundations

Binding D-Foundations with the VIKTOR platform has various advantages, like: 

- **Single source of truth**: By using the input data from the VIKTOR application, there is always a single source of truth for the analysis. This means no more random data files floating around on different computers or drives. Any changes to these files are logged centrally, so everyone has the most up-to-date data available at all times. 
- **Efficiency**: The binding enables running a great number of analyses in series or even in parallel. In most cases, the whole process of building a D-Foundations model, running the model and then processing the results takes around 5 seconds. This is easily 10 times faster than the average Geotechnical Engineer can setup and run a D-Foundations analysis.
- **Risk reduction**: Once validated, the binding performs all required actions consistently, hence significantly reducing the risk of errors made in the calculations.
- **No extra licenses**: The binding uses the clients own software package and licenses, so the client doesn’t need to purchase additional software or licenses. 
- **Easy to use**: Not only is the binding easy to use for the end-user (who now only has to worry about a handful of input parameters), the engineers and/or developers can write a working script in about 10 lines of code. The binding follows the same structure as the D-Foundations user interface, which is familiar for anyone who has used this software before. This allows engineers/developers to quickly build a user-friendly application, enabling any colleague to perform D-Foundations calculations easily.

## Potential for cost and quantity

These advantages offer a lot of potential for a company, both in terms of costs and quantity:

- The reduction in time allows companies to evaluate more foundation designs and find a more cost-effective design in the same time-frame.
- The reduction in time allows companies to increase their output by taking on additional design projects and completing more projects in the same time-frame.

## Endless possibilities

The binding that has been written for D-Foundations has been set up in such a way that it is as generic as possible. This allows it to be applied to many different varieties in the design of pile foundations. This opens up the possibility of evaluating a great many different designs in an optimization scheme. 

The binding is very user-friendly and follows roughly the same steps as setting up a D-Foundations calculation through the D-Foundations user interface. Therefore, writing the code to create a D-Foundations input file should be very straightforward for an engineer or developer who has used the software package before.

## D-Foundations and VIKTOR

The VIKTOR platform ensures that the data required for the D-Foundations calculations is all centralized in a single place. It also handles all data-traffic between the application and the server with the D-Foundations software package. This way, the Geotechnical Engineer doesn’t even need to have the software or the input data installed on his device to be able to perform D-Foundations calculations and analyses!



medium_bijknippen (2).png

small_bijknippen (2).png

thumbnail_bijknippen (2).png

Blog_automate_processing_with_D-foundations_5

Automate the processing of pile foundations with D-Foundations and Python

### Content: 

1. An introduction to developing successful applications
2. Designing and planning your application
3. How to start coding
4. Gathering and processing feedback
5. Increasing the adoption of your app



How to create successful application that ensure adoption

medium_White Papers & guides - Building succesful applications.jpg

small_White Papers & guides - Building succesful applications.jpg

thumbnail_White Papers & guides - Building succesful applications.jpg

WP_pink

How to create a succesful that people will adopt

large_White Papers & Guides - Building Succesful applications

medium_White Papers & Guides - Building Succesful applications

small_White Papers & Guides - Building Succesful applications

thumbnail_White Papers & Guides - Building Succesful applications

WP_pink_2

Do you want to build a successful application? This guide is here to help you make apps that provide real value to your work and that other people will definitely want to use too!

Over the past years, we, the application developers at VIKTOR, have built many apps for many different industries. We have learned a lot from that and now want to share our experiences with you. 

The principles and processes we explain in this guide are the same as we apply daily. They have helped us build anything from simple apps designed to save time to advanced engineering applications that are used to automatically calculate underground tunnels, dikes, and other large structures. 

This guide will provide actionable insights that are useful for anyone involved in creating custom software tools. For example:

- People developing the tools (developers, engineers, data scientists, etc..)
- End-users, who will use the tools when they are released
- Project managers who are interested in workflow automation/optimization
- Program managers, who oversee and stimulate digital transformation initiatives
- Domain experts, who provide their expertise to people creating software tools
- And anyone else interesting in the process of creating awesome software tools

Learn the process to build apps that provide real value to your work and that other people will definitely want to use as well.

Build successful applications

Learn how to build apps that provide real value to your work and that other people will definitely want to use as well.

Building Successful Applications

Parametric design

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

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

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

## No more copy + paste

Roland Snelders has been involved in the development of the concrete slab reinforcement application for Heijmans. “We could read the internal moments from a SCIA file and these were collected in the report, usually in a table. Then those moments could be entered in Excel and the reinforcement was determined and tested in an iterative process. That calculation was therefore copied to the report. ” This way of working could be done more efficiently. It would be easy if copying numbers is no longer necessary, because everything is collected in one place.

## Excel, SCIA, and VIKTOR

That's exactly what the application they created does. Snelders: “From SCIA we can now export an XML file and read it into the application on the VIKTOR platform. The Excel sheet is also linked to this. After selecting the concrete cross-section data and various reinforcement options, I get a picture with colors that indicate where the reinforcement should be.” This ensures that you go directly from the SCIA file with a once-off data entry to a visualisation of the results that come from the Excel sheet, without having to copy anything.

## Centralized Excel sheets

The Excel sheet has not been completely transferred into the application but rather has been linked to it. This has the advantage that it does not have to be recreated, which would then have to be validated. In addition, all manufacturers know how to make a calculation in Excel, you can still continue to do that. “The application ensures that everyone now works with the same Excel sheet, since it can only be opened centrally,” says Snelders. This significantly reduces the risk of errors.

## Automated calculations

The application can be used in any construction that contains a slab, for example a floor, a wall, a roof or a bridge. “Initially, only rectangular slabs could be calculated and analysed, which was a major limitation,” says Snelders, “This has now been improved to allow for all types of slab shapes to be calculated.” 

This is the beginning in terms of automation. "For the time being it is not going to be possible to calculate entire constructions completely, because there is a lot of variation in every project." Snelders explains, "But it is very useful to have components of such a construction that can be automatically calculated." 

![Customer_case_automating_calculation_process_linking_excel_SCIA_2](https://cms.viktor.ai/uploads/Excel_and_SCIA_connected_c24d123297.png)


## More time for complex challenges

There is less variation in the components themselves, so they can be calculated perfectly with an application. This allows the structural engineer to have more time for the more complex and challenging aspects of their work.

Snelders: “The application makes work more fun. I do not find completing an Excel sheet challenging work. ” When filling in cells and copying data, a structural engineer adds little knowledge to the process. Where they do add knowledge is during the schematisation of the construction and the making of a calculation model, in order to subsequently arrive at an optimal and practical choice of reinforcement. "That work still remains, we have mainly automated the repetitive calculations."

small_Heijmans linking Excel (2).png

thumbnail_Heijmans linking Excel (2).png

Blog_automating_concrete_excel_SCIA_1

Automating concrete cross-section calculations by linking Excel sheets to SCIA

Previously, many calculations for fender systems were done with rules of thumb. This is no longer possible, due to the stricter new standards. The calculations now have to be done in more detail, which creates a lot of extra work for the engineers. Calculating all options manually one by one is laborous, so it was decided to automate them. Louis: “The calculation of constructions will be increasingly automated. The time gained from this can then be used to solve complex problems.”

## Automating repetitive tasks

Peltenburg explains: “Repetitive elements are very suitable for programming, and so can be calculated using an application.” With repetitive elements, the same calculation must always be performed, something that an application on the computer can do much faster than a structural engineer by hand. “Once the repetition is found in a construction, letting a computer do that calculation allows one to save a lot of time,” says Peltenburg.

## RFEM and VIKTOR

MH Poly uses the calculation software RFEM to calculate the fender systems. Louis was very interested in creating an application for fender systems and asked Peltenburg to work on this together. The application they created contains an interface between the RFEM software and the VIKTOR platform. Peltenburg: “We offer an API to all our customers, on which applications can be made. This was the first time that it has been taken on in a professional manner.”

![Dlubal and VIKTOR.jpg](/uploads/Dlubal_and_VIKTOR_6fb3708ac2.jpg)

## Automating engineering

In the fall, the application will be presented on the MSc Engineering customer day. “We want to show our customers that the sector is changing and what possibilities there are in terms of automation.” Peltenburg says. Louis, “This application is a pilot to see how it goes, but it is my intention to collaborate more if everything goes well.” 

“The biggest advantage of using VIKTOR is to initiate a change in thinking amongst engineers. There is still a lot of traditional thinking, which has to change to a way that makes better use of ICT developments in the field of engineering”, says Louis. Peltenburg adds, “The nice thing is that you don’t know what will happen in the future. There are so many options it can be used for: [Artificial Intelligence](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction), [Parametric Design](https://www.viktor.ai/parametric-design-software), [Machine Learning](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction).”

*MH Poly is an engineering company that has been using the computational analysis software RFEM from Dlubal for years. This software is provided by MSc Engineering. Emiel Peltenburg is a specialist at MSc Engineering and distributor of the software RFEM and IDEA StatiCa.*

large_The advantages of linking RFEM calculation software to the VIKTOR platform - resize.jpg

medium_The advantages of linking RFEM calculation software to the VIKTOR platform - resize.jpg

small_The advantages of linking RFEM calculation software to the VIKTOR platform - resize.jpg

thumbnail_The advantages of linking RFEM calculation software to the VIKTOR platform - resize.jpg

Customer_case_linking_RFEM_calculation_software_online_platform_2

Advantages of integrating RFEM calculation software with a cloud application

1. Why the Engineering and Construction industry is falling behind
2. Key components for a successful digital transformation
3. Stages of starting a digital transformation
4. Implementing your first digital transformation
5. What digital transformation means for you

large_White Paper - People first, tech second - The way to boost digital transformation in the E&C industry(1).jpg

medium_White Paper - People first, tech second - The way to boost digital transformation in the E&C industry(1).jpg

small_White Paper - People first, tech second - The way to boost digital transformation in the E&C industry(1).jpg

thumbnail_White Paper - People first, tech second - The way to boost digital transformation in the E&C industry(1).jpg

WP_light_blue_1

White Paper People first, tech second_ The way to boost digital transformation in the E&C industry.jpg

large_White Paper People first, tech second_ The way to boost digital transformation in the E&C industry.jpg

medium_White Paper People first, tech second_ The way to boost digital transformation in the E&C industry.jpg

small_White Paper People first, tech second_ The way to boost digital transformation in the E&C industry.jpg

thumbnail_White Paper People first, tech second_ The way to boost digital transformation in the E&C industry.jpg

WP_light_blue_2

By 2021, the Engineering and Construction industry is one of the fastest growing sectors. Even though the sector is growing rapidly, it is still amongst the least digitized industries around the world. This is not due to the lack of supply of digital solutions, but rather due to the fact that the adoption of new technologies is not forthcoming within the industry. Finding ways to boost this adoption is both a big challenge and opportunity. Therefore, it is important we start at the right place.

There are three aspects to digital transformation: first people, then process, and after that technology. Adopting new digital solutions in your organization is impossible when your people are not on board with it. That is why convincing your people about the benefits is the first priority in digitally transforming your organization. Instead of looking at the digital solution from a technology perspective, you have to look at it from a people perspective. Your digital solution should never be implemented for digital’s sake. It is there to help the people in your organization do their job easier, quicker, better, and with more pleasure. After they are convinced that it will do just that, digital transformation can start!

In this white paper, it is explained how you can start digitally transforming your organization whilst keeping people at the centre of your digital solution. 



See how you can boost digital transformation in your company in the E&C industry by putting people first and technology second!

Download the White Paper and get INSPIRED

Read all about how you can boost digital transformation for your company in the Engineering and Construction industry by centralizing digital solutions around people, instead of around technology. 

People First, Tech Second: The Way to Boost Digital Transformation in the E&C Industry

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

## Why a hackathon?

Knowledge development is one reason for the IB decided to organize a hackathon. Addiotionally, besides getting acquainted with programming hands-on, they also wanted to experience what it is like working with VIKTOR. 

As some structural engineers, such as Lester Neijzing, are currenlty part of a pilot project by the Gemeente Amsterdam in which VIKTOR is also being used, some are already a bit familiar with the platform. Now, the hackathon offers a great opportunity for the other structural engineers to get introduced to VIKTOR as well, and for those who are already acquainted to improve their programming skills. 

> "Participating in the hackathon is a fun way to get to know VIKTOR and learn more about programming with Python." - Lester Neijzing

![blog_hackathon_amsterdam](https://cms.viktor.ai/uploads/blog_hackathon_amsterdam_ae737a634c.jpg)

</br>
</br>

## Quay wall applications

During the two-day hackathon, three teams used Python to develop applications on the VIKTOR platform. All of the apps are to some extend related to the parametric design application that Amsterdam is currenlty developing for the renovation of their quay walls. 

The stakes were high during the event: In total, three apps were developed, but only one could be the winner and would thus be further developed eventually. Next, each app will be described in more detail.

![kademuur renoveren.jpg](https://cms.viktor.ai/uploads/kademuur_renoveren_7f4840c190.jpg)

</br>
</br>

### Application 1

Currently, structural engineers at the IB gather data about the state of quay walls in Excel sheets. Even though this process works well for the people who work with these sheets on a daily basis, it is difficult for other to interpret the data. For that reason, team 1 developed an application to make this data more transparent and easily adjustable. 

Of course, the IB could ask their GIS-department to visualize their data for them, but even then it would still remain a static process. With this application, engineers can visualize and adjust project data using different colors on a graphical map themselves. This also helps make it easier to explain to others why the work of the structural engineers is important and how they, for example, estimate workload and project duration.

### Application 2

Justl ike team 1, team 2 also worked on an application for the visualization of project data. With their app, it becomes easier and faster to project geometries on a map view and translate these to the calculation program SCIA, and after that to Word to generate downloadable reports.

Because this app includes a rather far-reaching integration, it was not unfortunately yet at a usable level at the end of the hackathon. On the flip side, this does mean that there is still a lot of room to improve and expand the tool. 

### Application 3

Opposing team 1 and 2, team 3 developed an application not aimed at the visualization of project data, but for the automated design and modelling of foundation piles, channels, and the surrounding soil. For this, the team integrated an Excel calculation sheet with an export to the calculation program SCIA to their VIKTOR application.

Just like with team 2's application, there was still some work to be done before team 3's app was ready to be used on real projects. However, the results were promising so far and made for an interesting concept for further developments.

## Choosing a winner

Based on the judge's critiques, a winner was chosen at the end of the second hackathon day: Application 1. Where the other apps mainly focused on integrating with pre-existing calculation software, application 1 stood out due to its unique use of data-processing and visualization - a nice use of VIKTOR that had not been done that often yet. 

> "I think it was this tool that won the hackathon because the rough outlines were already finished - the application worked in such a way that it produced the results that we were looking for. According to the jury, it was a unique tool, especially thanks to the maps and the visualizations." - Lester Neijzing

## Putting the pieces together

According to team 1 participants Rick and Lester, even though they were part of the same team, they were constantly programming completely different parts of the application. Only within the last few hours of the hackathon, when they began putting all the parts together, it felt like "it magically turned into a working product".

The application consists of several different parts, For example, it shows a graphical map and Excel sheet with risk drilling and assessments of quay walls, using different colors to indicate wether a wall is still sufficient or needs reinforcement. Team 1: "The map view really makes the data come to life". Within the application, it is also possible to adjust source data, link it immediately back to Excel (or the other way around), and export overview reports.

> "We knew what our vision was but did not yet realize how incredible it would be until we put everything together and it actually started working the way we envisioned." - Rick Voortman

![hackathon artikel 2.jpg](https://cms.viktor.ai/uploads/hackathon_artikel_2_b764fb081e.jpg)


</br>
</br>

## What's next?

Following the hackathon, two things are certain:

1. The further development of team 1's winning application
2. A second edition of the hackathon

**Are you also interested in organizing a hackathon with your organization? Don't hesitate to contact us at contact@viktor.ai!**



large_Blog_hackathon_amsterdam_header

medium_Blog_hackathon_amsterdam_header

small_Blog_hackathon_amsterdam_header

thumbnail_Blog_hackathon_amsterdam_header

Blog_hackathon_amsterdam_header

Structural engineers at the engineering firm of the municipality of Amsterdam organized a hackathon to boost their programming skills and learn about building apps with VIKTOR.

Develop programming skills through hackathon | VIKTOR.ai

Hackathon stimulates knowledge development

VIKTOR Blog