Creating Apps & Python

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

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

## Why VIKTOR?

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

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

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

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

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

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

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

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

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

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

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


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

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


large_Dynamo script - tower.PNG

medium_Dynamo script - tower.PNG

small_Dynamo script - tower.PNG

thumbnail_Dynamo script - tower.PNG

Blog_dynamo_python_in_cloud_easy_sharing_accescibility_2

Facilitating design and construction through integration with Dynamo

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

## Building an application 

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

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

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

## Visual programming as introduction to coding

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

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

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

*Visual programming with Scratch*

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

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

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

## Visual programming as a professional tool

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

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

## Building web applications with Python

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

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

## My facade generator as web application

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

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

*Tutorial on how to build a script from scratch*

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

### Integrating Grasshopper with VIKTOR

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

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

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

### Little coding required

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

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

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

*Python code as setup for a VIKTOR application*

### Visualizing the input

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

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

*Visualization of Python code*

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

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

## Grashopper and VIKTOR: A powerful combination

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

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









medium_grasshopper building blocks - resize.png

small_grasshopper building blocks - resize.png

thumbnail_grasshopper building blocks - resize.png

Blog_grasshopper_parametric_design_9

Parametric design in the Cloud with Grasshopper

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

Digital transformation

**In this article you will read about:**

-	Why the GeoTools are created
- How the GeoTools were created
-	The functionalities of GeoTools
- How you can modify the GeoTools
- How you can create your own tools using the GeoTools
-	How you can help us improve the GeoTools 



large_Blog_integrating_geotechnical_data

medium_Blog_integrating_geotechnical_data

small_Blog_integrating_geotechnical_data

thumbnail_Blog_integrating_geotechnical_data

Blog_integrating_geotechnical_data

Automate, integrate, and collaborate on geotechnical processes with GeoTools. Discover the benefits on VIKTOR.ai.

Online app to automate geotechnical processes | VIKTOR.ai

## What are the GeoTools?

Over the years, developers at VIKTOR have worked in several civil projects have seen the amount of time and energy that is wasted interpreting CPTs, creating 2D soil layouts, and setting up models. This isn’t fun work, so we decided to do something about it: We teamed up with geotechnical engineers across the industry to create the best set of tools to help you save time and make your geotechnical data more insightful. We call them: The GeoTools.

Of course, we want everyone to use and help improve GeoTools. That is why at the end of the article you will find a link to request free access.

In this video, you can see a demo of the GeoTools on the VIKTOR platform.

<div style="padding:50.36% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/475043701?h=005feea02b&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="GeoTools Demo"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>
</br>

### Saving time

As the size of civil engineering projects grows and the amount of available data continuous to increase, the average geotechnical engineer is expected to do even more number-crunching on soil data. They must provide an increasingly accurate interpretation of the soil layout and everything that is necessary to perform detailed analysis on foundations, settlements, or other geotechnical projects. However, not every civil engineering project requires the same processes to follow or the same type of soil interpretation.
Since most of these tasks are everyday things, a custom application that solves one task very well isn’t required. However, it would be very useful to have something that can save the geotechnical engineer a lot of time from day one. 

### Centralizing datasets

The GeoTools application is a compilation of several geotechnical tools, functionalities, and digital buildings blocks that can be used in the daily work of any geotechnical engineer. The soil datasets that are at the core of every geotechnical analysis are centralized in the VIKTOR platform, where GeoTools is also hosted. The application provides a variety of tools to reduce the amount of repetitive work for the engineer while also improving their insights based on the ever-expanding datasets.
The GeoTools app provides numerous of tools related to:

-	Storing and interpreting soil data,
-	visualizing and cleaning this data,
-	preparing in-depth geotechnical analyses,
-	and integrating the data with other software packages or databases, such as ArcGIS or the BRO database. 

Continue reading to learn more about how why we have chosen to create the GeoTools as they are, what tools are implemented, which are still to come, and how they are offered to geotechnical engineers.



Introduction to GeoTools

To create an app that helps any geotechnical engineer in their day-to-day work, we needed an overview of the most frequently performed tasks. For this, we contacted many different geotechnical engineers from many different of our existing clients individually to gather their feedback and gain more insight into their daily jobs.

## First Minimum Viable Product

The First Minimum Viable Product was released exclusively to these geotechnical engineers and contained an initial set of tools. To promote transparency, enable sharing feedback, and viewing possibilities of the app from different perspectives, all engineers from different companies were given access to the same app, sharing the same experience and the same data. This allowed them to not only experience how the app works, but also how fellow engineers were using it.
The app contained a section where any used could leave feedback, upload screenshots, and provide new ideas and concepts for improvement. This enabled users to all be very involved in the development process; we work **with** geotechnical engineers, rather than **for** them. 

## By engineers, for engineers

Following the same philosophy, new versions are continuously released and tested. In addition, periodical feedback sessions are organized with geotechnical engineers to agree on upcoming developments to ensure real value for every geotechnical engineer.
The GeoTools is the first app for which we have applied this philosophy, and with great success! Many more applications have already followed, and soon the VIKTOR App Store (see: [demo environment](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment)) will be filled with a wide variety of applications created for engineers and developed by them!

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/678633810?h=0bed07e4a2&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="Demo environment - log in and AHN app"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>
</br>

If you have an idea for an application that you would like to have as part of the app store, or if you would like to develop an application (together with us), please contact us. We are happy to talk with you about all the possibilities!

</br> 

![The GeoTools application](/uploads/The_Geo_Tools_application_d9bc97406c.png)


Requirements of GeoTools

With the GeoTools, geotechnical engineers can manage, structure, and visualize geotechnical data to ensure availability, accessibility, easy classification and interpretation, and better insights. 

![Visualization of geotechnical data in the VIKTOR app](/uploads/Visualization_of_the_geotechnical_data_96ca35c624.png)


## Managing geotechnical data

The GeoTools provide a platform for uploading and storing soil data, in this case a Cone Pressure Test (CPT) dataset. This can be in the form of (the most used) GEF-files, but also as XML-files or even downloaded directly from the [BRO database(https://basisregistratieondergrond.nl/). This ensures that the soil data is centralized and available regardless of the format it is in. In addition, because GeoTools is a web-based app, you and all your colleagues can access the data you are working with always and from anywhere!

![How to automate interpretations and speed up geotechnical calculations.png](/uploads/How_to_automate_interpretations_and_speed_up_geotechnical_calculations_5c9e243a5f.png)

## Structuring geotechnical data

Another module within the GeoTools is about the classification and interpretation of CPT data. This module cleans and filters the data so that it can be used in subsequent analyses. Geotechnical engineers can select the type of classification method that is used. The different options are:

-	The standard Robertson method (also read: [CPT interpretation with Robertson](https://www.viktor.ai/blog/58/open-source-app-CPT-interpretation-Robertson)
-	A table method based on user-provided soil characteristics
-	And a [Machine Learning](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction) algorithm, developed by CRUX (see: [VIKTOR and CRUX announce partnership to develop automation product for Geo Engineers](https://www.viktor.ai/blog/35/automation-digital-transformation-integration-geotechnics-python))

This filtered data is visualized so that geotechnical engineers can easily inspect it and update as needed.

<div style="padding:48.75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/681234027?h=36e532e9dc&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="CPT interpretation with Robertson"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>
</br>

## Visualizing geotechnical data

The GeoTools also provides insights on an even higher level. The location of all CPTs can be shown in map or satellite view. From there, you can select multiple CPT datasets and compare them side-by-side (also see: [open-source CPT comparison app](https://www.viktor.ai/blog/57/open-source-cpt-comparison-geotechnics)) to see how the soil changes from one point to the next. By combining several CPT datasets, a 2- or 3D interpretation of the soil layers can automatically be calculated and visualized in an intuitive and interactive 2- or 3D plot. Additionally, geotechnical engineers can manually modify the automatically generated soil layouts if desired. These visualizations are helpful in many types of civil engineering projects, such as [pile foundations](https://www.viktor.ai/customer-cases/34/foundations-design-optimization-saves-tons-of-CO2), [dykes](https://www.viktor.ai/blog/26/parametric-design-python-dike-improvement) and dams, or [road construction](https://www.viktor.ai/customer-cases/36/parametric-design-Cloud-Python-PLAXIS).

<div style="padding:48.75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/678706977?h=3a02a77e46&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="CPT comparison"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

Functionalities of GeoTools

GeoTools seamlessly integrates with several external software packages. This ensures you that the tedious steps required to set up a calculation in any of these software packages can be reduced to a single click of a button, which reduces time to set up a calculation from a couple of minutes down to a few seconds.

## Deltares software package

By integrating with one of the Deltares software packages, you can use the available soil data and interpolated profiles directly in several geotechnical analyses. 

**D-Settlement**

The current version of the GeoTools application integrates the soil layout data with the D-Settlement, allowing users to quickly set up advanced soil settlement calculations. 

**D-Foundations**

Exporting the soil latyout and properties to D-Foundations is also possible (see: [Automation in D-Foundations](https://www.viktor.ai/blog/21/automation-python-D-foundations-web-application) for more in-depth information on how such an integration works).

![Integration of data in deltares software packages](/uploads/Integration_of_data_in_deltares_software_packages_292a796ce6.png)

*Data integrated from Deltares software packages in the GeoTools*

In the next update of the application, other software packages can be integrated, such as D-Stability, D-Sheetpiling and Plaxis.

## More? 

Don’t hesitate to contact us to let us know which software packages you would like to integrate with, and why! 
If you think that the GeoTools can help you save time and better understand your geotechnical data, apply now for a [demo account](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment) to try it out in the [demo environment](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment).

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/678633810?h=0bed07e4a2&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="Demo environment - log in and AHN app"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

[![Go to the demo environment](https://cms.viktor.ai/uploads/CTA_demo_environment_62925e049b.svg)](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment)



Integrating GeoTools

In this section, we will explain how you can program your own applications using the digital building blocks of the GeoTools. This is an advanced topic for those that know how to use Python. Feel free to go straight to the conclusion of this blog post if you feel like you have enough information now!

## Ready-to-use

With a standard app like the GeoTools, there is no need to go through the process of developing a fully customized application. Clients don’t have to spend time building useful applications either; end users can start using the tool from day one. If you are interested in the full application, you can find it in the [demo environment](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment). More information on the all the technical functionalities of the full GeoTools application can be found [here](https://www.viktor.ai/appstore/geotechnics-automation-python-digital-transformation).

## Source code availability

Fortunately, clients not only have access to a plug-and-play application that is suited to their every need, but they also have access to the source code of the app. This allows any engineer to add additional tooling to customize the GeoTools to their unique process, while having a solid foundation for the basic functionalities. Not only does this make the application extremely customizable, it also helps developers by providing a set of pre-assembled digital building blocks that they can inspect and re-use in different applications. 

An example of the GEF building block, as well as a cross-section building block are provided in the Python code snippet below:

```python
from viktor.geo import GEFFile
from viktor.geo import MapPoint
from viktor.geo import SoilLayout
from viktor.geo import RobertsonMethod

class Project(ViktorController):
	def get_gef_file(self):
		“””Obtain a GEFFile object from the example GEF file”””
		Return GEFFile.from_file(“Example.GEF”) 
	@View(‘Soil Layout’) 
	def visualize_soil_layout(self):
		“””Visualize the Soil Layout in a View in the web-browser”””
		gef_file = self.get_gef_file()

		# Get Soil Layout by classifying GEF using the Robertson Method
		soil_layout = gef_file.classify(RobertsonMethod(soil_properties))
		return soil_layout.get_visualization()

	@View(‘Map’)
	def visualize_gef_on_map(self):
“””Visualize the GEF in a Map in the web-browser”””
gef_file = self.get_gef_file()
return MapPoint(gef_file.coordinates)
```

Each of the modules in the application’s source code is extensively documented and even published as a seperate 'sample application', so that any developer who looks under the application’s hood knows exactly what is going on and can quickly tweak the code to their personal needs. 

Open-source Python code for the following modules is all hosted within the [VIKTOR GitHub repository](https://github.com/viktor-platform). Below are code snippets from the repositories of a couple of the functionality from GeoTools that are also offered as seperate sample application within the [demo environment](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment).

**AHN elevation profiles**

``` python 
@MapView(‘Map’, duration_guess=1) 
def get_map_view(self, params: Munch, **kwargs: dict) -> MapResult: 
  """Set the map view on which the line can be drawn for which the AHN values are wished to be known""" 
  features = [] 
  if params.geo_polyline: 
    features.append(MapPolyline.from_geo_polyline(params.geo_polyline)) 
return MapResult(features) 
```   

**CPT comparison**

``` python 
from viktor.geo import GEFFile 

@ParamsFromFile(file_types=['.gef']) 
def process_file(self, file: File, **kwargs) -> dict: 
 """Process the CPT file when it is first uploaded""" 
 cpt_file = GEFFile(file.getvalue("ISO-8859-1")) 
 return cpt_data_object.serialize() 
``` 

**CPT interpretation with Robertson**

```python 
def classify_cpt_file(cpt_file: GEFFile) -> dict: 
    """Classify an uploaded CPT File based on the selected _ClassificationMethod""" 
    try: 
        # Parse the GEF file content 
        cpt_data_object = cpt_file.parse(additional_columns=ADDITIONAL_COLUMNS, return_gef_data_obj=True) 
        ground_water_level = get_water_level(cpt_data_object) 
 
        # Classify the CPTData object to get a SoilLayout 
        soil_layout_obj = cpt_data_object.classify(method=RobertsonMethod(DEFAULT_ROBERTSON_TABLE), 
                                                   return_soil_layout_obj=True) 
 
    except GEFParsingException as parsing_exception: 
        raise UserException(f"CPT Parsing: {str(parsing_exception)}") from parsing_exception 
    except GEFClassificationError as classification_exception: 
        raise UserException(f"CPT Classification: {str(classification_exception)}") from classification_exception 
 
    # Serialize the parsed CPT File content and update it with the new soil layout 
    cpt_dict = cpt_data_object.serialize() 
    cpt_dict['soil_layout'] = soil_layout_obj 
    cpt_dict["groundwater"] = ground_water_level 
    return cpt_dict 
``` 

Continue reading [here](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment) for an overview of all sample applications. 



Out-of-the-box or custom

The GeoTools application has been developed for any geotechnical engineer who wants to speed up their daily process while increasing the amount of data they use to improve the accuracy of their models. They can reap the benefits from the moment they log in to the VIKTOR platform.

## VIKTOR for geo-engineering

The VIKTOR platform ensures that the data required for the geotechnical calculations is all centralized in one single location. The centralized data is easy to link with many different software packages that a geotechnical engineer uses for in-depth analyses. The tools in the application will significantly reduce the time that is needed to spend on tedious day-to-day tasks. This opens many new possibilities for taking geotechnical engineering to the next level. Geotechnical engineers can now evaluate a great many different designs in an optimization scheme, reduce uncertainty in calculations by using more soil datasets, or simply take on bigger projects.

## Demo environment

VIKTOR offers free access to a continuously growing collection of sample application, including the [GeoTools](https://www.viktor.ai/appstore/geotechnics-automation-python-digital-transformation) including the GeoTools, through the [demo environment](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment). Applications range from functional tools that can be immediately be used for your own projects, to basic ‘template’ applications that contain the result of open-source Python code of specific functionality from our [GitHub repository](https://github.com/viktor-platform). 

[Apply for a demo account](https://www.viktor.ai/blog/56/try-free-apps-in-demo-environment) to test applications and experience working in a VIKTOR environment (together with your colleagues) that contains all your organizations apps. 

Please let us know if you want to add a new digital building block to the GeoTools or to the App Store. Together we can improve the geotechnical community as a whole!

**Other applications you might also find interesting:**

-	[Map-based AHN elevation visualization](https://www.viktor.ai/blog/50/open-source-ground-level-profile-geotechnics)
-	[CPT comparison](https://www.viktor.ai/blog/57/open-source-cpt-comparison-geotechnics)
-	[CPT interpretation with Robertson](https://www.viktor.ai/blog/58/open-source-app-CPT-interpretation-Robertson)
-	[VibraCore](https://www.viktor.ai/appstore/VibraCore-Automation-geotechnics-engineer)
-	[PileCore](https://www.viktor.ai/appstore/pilecore-pile-carrying-capacity-automation-geotechnics)


Conclusion

## Get the white paper

**INDEX**

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

WP_dark_blue

Customer_case_centralizing_data_faster_gravity_based_foundation_analysis_2

Autonomous cars, algorithms that are trading stocks, people having conversations with robots and digital services from the valley make our lives easier. It is already part of many different industries and drives extreme productivity. Considering these benefits of digitalization, there is huge potential in introducing this in the engineering and construction sector.

However, the engineering and construction industry spends way less on digital transformation than other sectors or automotive. So when the benefits are obvious, why have the engineering and construction industry not yet fully embraced new digital technologies? The reasons of lacking behind are understandable and have to do with the characteristics of the industry. But we have come to a time where there are increasing opportunities at hand for 
the sector to speed up digital transformation.

What are these trends in digital transformation and how will it effect the engineering and construction industry? You can read the answers to these questions and more in the white paper.



Learn about the trends on digital transformation and how to take the next step.

Download the White Paper and get INSPIRED

What are the trends in digital transformation and how will it effect the engineering and construction industry? You can read the answers to these questions and more in the white paper.

Digital Transformation Engineering and Construction Industry

Integrating geotechnical data with an online application

## Cone penetration testing
In many construction projects a cone penetration test (CPT) is converted to a soil layout. The data of such a CPT is often filtered based on the layer thickness, because very small layers (e.g. 4 cm) are not realistic. A CPT is a soil measurement, obtained by inserting a probe into the ground which measures the resistance. 

## Algortihm for classification
This resistance varies between different types of soil, allowing identification of the soils that are present. Roeland: “The difficult part is that the slightest measurement deviation can already result in a different type of soil, when the classification consists of many soil types.” In the picture here you can see an example of an unfiltered soil layout on the left. The thin layers are not realistic and have to be filtered. In the old algorithm, the user could specify the minimum soil thickness (e.g. 10 cm) which have to be removed from the soil layout. These layers are replaced by the soil which is present on top, such that there are no gaps in the overall layout. “This method works well, but is rather coarse.”, says Roeland.

![Soil layouts: unfiltered, with old filter, with new filter ](/uploads/Filtering_of_soil_layouts_according_to_the_old_algorithm_134f56efad.jpg)

*Example of filtering of soil layouts respectively without a filter, with the old filter, and with the new filter* 

## Continuous improvement
VIKTOR is continuously improving, so when the request came in to improve this filter algorithm, Roeland accepted the challenge. He explains: “Now we do not simply remove the thin layers, but we mark which layers are smaller than for example 10 cm. These layers are clustered to form individual layers with a maximum thickness equal to the specified filter thickness.”

## Why an algorithm?
The way a cluster is replaced depends on the thickness. If the total thickness of the individual layers is still thinner than the filter thickness, the old algorithm is used. The layers are removed and replaced by the soil present on top. If the cluster thickness is larger than the filter thickness, a new layer is formed. “A soil type has to be assigned to this newly created layer. The soil which is the most occurent within the cluster is automatically selected.” This logic is visualised in this schematic:

![placement of cluster and layers.png](/uploads/placement_of_cluster_and_layers_300649ad2b.png)

## The difference between now and then
Roeland: “With the improved filter, the soil layout is classified less coarse.” The difference between the old and new Python algorithms seems large in the first example, however Roeland states that this is not always the case. “In many cases it is not very likely to see such a large amount of different soil layers.” The old filter will not become obsolete, as many projects do not require the level of detail the improved filter offers.

## Soil layout interpretation
Many projects make use of the soil layout classification, which may become more accurate with the improved filter. However, in the end the technical advisor will always be the one making the decision of how the soil layout should be interpreted. Roeland: “When it comes to classification of a soil layout, a lot of expertise is required. Based on geological knowledge, experience from previous projects, location data, etc. the advisor will determine the soil layout.”

This improved filter will soon be available in the VIKTOR platform. Roeland: “We are trying to continuously improve our product and I think this is a great example of such an improvement.”



Soil layouts: unfiltered, with old filter, with new filter 

large_Filtering of soil layouts according to the old algorithm.jpg

medium_Filtering of soil layouts according to the old algorithm.jpg

small_Filtering of soil layouts according to the old algorithm.jpg

thumbnail_Filtering of soil layouts according to the old algorithm.jpg

Blog_soil_layout_classification_1

An improved algorithm for soil layout classification

small_White Paper Digital Transformation Engineering and construction industry.jpg

thumbnail_White Paper Digital Transformation Engineering and construction industry.jpg

large_gravity-based foundation application.jpg

medium_gravity-based foundation application.jpg

small_gravity-based foundation application.jpg

thumbnail_gravity-based foundation application.jpg

This article was written in collaboration with Peter Konijnenbelt (Arcadis), Johan Tuls (BAM), Kelvin Roovers (BESIX), Tjeerd Hermsen (Sweco), Nynke ter Heide (Vidabo) and Kevin van Giessen (VIKTOR). We have something in common: we create software tools that have a big impact in our organisations and are used by many people. However, none of us have a background in software engineering. We are trained engineers in our different disciplines. We believe you can do this too. You just need to choose the right tools and follow a good method. Here we share our experience. 

## The start of a series
This is the part of a series of articles about [engineering and Python](https://www.viktor.ai/blog/19/digital-transformation-parametric-design-python). Each time we will go deeper into engineering content and talk about solving specific problems. 

### In this article we will talk about:

- The digital transformation and why engineers are programming
- The four components of professional engineering tool: Automation, integration, optimisation, and distribution… and why you should consider all of them when creating your tools.
- Why we recommend using Python for making your own tools and our experience with other languages or software.
- Creating digital building blocks and their impact on the future of engineering
- How to make your code accessible for everyone, even to people that cannot code!
- Why and how engineers are using VIKTOR to create software tools that are accelerating the digital transformation of their companies. 
- Tips & tricks you can apply to your own projects

## The digital transformation
Digitization is growing exponentially thanks to the increasing accessibility to user-friendly software development tools. Gartner defines this movement as the Democratization of Technology. This means providing people with easy access to technical expertise without extensive (and expensive) training. This is often referred to as “citizen access”.

This changes the way software is developed. In construction and engineering companies, for example, there is a transformation. Software is no longer something for the IT department. Engineers are empowered to make their own software applications. Management sees the value of such powerful tools and creating them has become a company policy. Like this example from BAM, to design subway crossing under roads or railways. 

![VIKTOR application for designing subways under roads and railways (BAM)](/uploads/VIKTOR_application_for_designing_subways_under_roads_and_railways_BAM_a72f04e442.png)

## Why are engineers programming?
In engineering, every project is unique, at least that is what most engineers will say. This means you cannot copy one design directly to another project; however, the design techniques will be applied in the same way in each project. For example, a bridge must always comply with same design code, and its beams, foundation and paving are calculated in the same way. In addition, finding the optimal solution requires many calculations. A time-consuming process when done manually and, perhaps worst of all, no fun at all.

Automating these types of repetitive processes can help to quickly find the best solution and make engineering work more fun. This is why most engineers start programming. After all, we did not study engineering to spend our days updating models and copying/pasting results into reports. We want to engineer awesome things.

> “If you don’t learn to automate the repetitive part of your work, someone else will do it for you. You must learn this to stay relevant.” - Kevin van Giessen, VIKTOR

## The four components of a professional engineering tool
I notice that each professional engineering tool created to solve a specific problem, for instance designing a bridge, has four distinguishable components: integrate, automate, optimise, and distribute.

![The four components of a professional engineering tool](/uploads/the_four_components_of_a_professional_engineering_tool_5c1e9e54bf.png)

### Automation
By automation I mean that the program can perform a task automatically, such as generating a report or copying data from one place to another. 

### Integration
Integration is the automatic combining of different sources of information, which could be models, databases, Excel sheets or external software packages. 

### Optimisation
Optimisation is when the software tool calculates different designs or scenarios and helps you find the best solution. 

### Distribution
Distribution makes the software tools available to other. It transforms the tools you use into something anyone can use. As some of us have learned the hard way, processes, software packages and programming languages that seems perfectly suitable for one part become the bottleneck for the other. Distribution is the most underestimated part. For some reason, people often think this is something we can solve later, and that integration and optimisation are much more complex. This is not true; I have seen so many great projects end up in the drawer because they did not think of distribution and usability beforehand. That is why it is important that you consider all components and from the start choose the right tools.

## Which programming language should I use?
Having the computer help you solve engineering problems is not a new concept. Many engineers have their own Excel or Mathcad sheets and VBA or Matlab codes. But there are some drawbacks to those programs, such as the difficulty to do version control, the lack of a user-friendly interface and codes that are hard to understand if you have not written them. Fortunately, a new language is rising in the engineering world that is overcoming these problems, namely Python.

> “Python is very scalable. Each piece of code can be used countless times as it just needs an input and it will create an output. In this way you could solve a large problem by connecting smaller pieces of code; it is like having digital building blocks”. - Johan Tuls, BAM

### Excel, Matchcad, and Python
Peter Konijnenbelt: “Until now we at Arcadis made Excel and Mathcad sheets available with the reason to ensure that all engineers had the same working method to do calculations. But with the introduction of Python we went up to a whole new level: now we calculate a cloud of possible outcomes to find the best one. It also allows us to make a user interface for the tools, where results are presented visually for everyone to use.” This way of working gives more opportunities to find optimal solutions.

Tjeerd Hermsen likes Python because you can command other software and automate tasks, he explains ”we extract cone penetration test (CPT) data stored in Excels sheets and automatically make D-Foundations (geotechnical software) model from it”

## Digital Building Blocks
I observed that the common approach to building scalable software and cooperating with other specialists is to think in digital building blocks that can be interconnected. This make the process versatile and scalable. Some of the benefits of using the building block approach are:

- You can quickly build code by utilizing someone else’s work.
- It enables people to share knowledge in the form of code.
- It makes it easier to replace parts of your code.
- It makes growing the code manageable, as each block has a specific function.

“I like it when you can use the work of others. With fewer people you can make more applications if you have a collection of digital building blocks that you can connect” says Johan Tuls. That is also a good reason why people are using Python, explains Van Giessen: “Python is based on digital building blocks, and there are many available for free, such as libraries for numerical calculus or data science”.

### Creating new building blocks
Companies are also investing in making their own blocks. “Large software products try to provide a total solution; however, they are not always flexible enough to work efficiently. That is why we are transferring the expertise we have into our own software tools, that add to the existing software and which we can make available to further valorise knowledge”, tells Kelvin Roovers.

> “Parametric design will cover a much larger part of the work. In the future you will have modular systems with an application for each part of the construction. The engineer will create, connect,  and validate these apps instead of doing the calculations” - Nynke ter Heide, Vidabo

According to Johan Tuls, software development will have a big impact on construction companies. “Construction companies grow linearly, but programming will make it exponential. Companies will accumulate digital building blocks over time, which will be an important asset of the company. With these blocks you can make better applications faster and faster. This will lead to a new business model that has yet to be developed”.

## How to make your code accessible for everyone
I have observed that many talented people create models and analysis tools that have a big impact in their organization. As the adoption of their tools grow in the organisation, they fall victim to their own success. These tools are often too complex to be used by other people, and the creator does not have enough time to process all the requests from the organisation, which therefore becomes the bottleneck. Worse, what happens with that knowledge if they leave the organisation?

### Controlled distribution
What you want is to distribute the code in a controlled manner. This, however, can be quite challenging when choosing the wrong tools. “Excel does not have a version control. You can download the sheets from the company’s server, but how do you make sure everyone is using the latest version and that upgraded sheets are compatible for each application?”, says Nynke ter Heide. Kelvin Roovers shares a similar experience: “you don’t want to share code in Excel sheets. Everyone starts making their own modifications and it is impossible to keep track of the changes. It is better to keep you code externally, for example using Python”. “There are good solutions for code distribution among programmers when using Python, like GitLab”, says Kevin van Giessen.

### User interface required
The reality is that most people who can benefit from using these codes lack the programming skills necessary to understand them. Part of the solution is “a good user interface with visualisations of results. This makes the application accessible to everyone”, says Johan Tuls. It is useful to have a web-based application because version control is guaranteed, explains Kelvin Roovers. “When improving an application, all you have to do is put it online to make sure everyone works with the latest version right away.”

Web-based applications also have tremendous benefits for the end-users. “This allows different users to access a central point from anywhere, at any time, so they work with the same design or version of the information and make decisions together”, explains Kevin van Giessen. He adds, “It makes distribution of your code also very controlled; the administrator can give users permission to access different parts of it and remove it if desired”.

![Distribution of interface code](/uploads/distribution_of_interface_code_4839e53a6c.png)

Personally, I think technical people can be very critical about their work and think that it is not ready to be used by others; that there is still too much to improve. This is probably true. However, the solution is not to improve the code by yourself, but to make it available to others with a good user interface. You want people to use your software and give you feedback. This is the best way to truly understand what needs to be improved so that people can use it. It could be anything from technical features to greater managerial awareness. The shorter the feedback loop, the more organically your software grows in the organization, and the more likely people will use it.

## Why are engineers using VIKTOR?

### Toolbox
Kevin van Giessen explains: “VIKTOR is an application development platform to build professional web-based applications with Python. It’s easy to use; it’s like having a digital building block toolbox to create your own engineering applications. You can integrate with other engineering software, make user interfaces, create 3D models, use map views, perform optimisations and visualize results. This gives engineers the opportunity to become a professional software developer: the engineer developer. Kevin continues, “By enabling the engineer to build user-friendly software applications, knowledge is turned into an asset that can be distributed within and outside the organisation.”

> “Distribution is one of the biggest advantages of VIKTOR applications: you put it online and everyone can use it.” - Kelvin Roovers, BESIX

### Sharable application
Nynke ter Heide adds “Having Python code is different from an application that you can share with your colleagues”. She continues: “Making a Python script is nice for a proof of concept, but with the VIKTOR platform your code shifts to another level. It’s a way to create applications that everyone can use.”

### Unity
Tjeerd Hermsen: “Colleagues started sharing Python scripts while not all using the same version of the required packages, which made the scripts unusable. A lot of time is wasted trying to find and fix such problems. “The solution was to create a VIKTOR application. He explains:” The VIKTOR application ensures that all users are working with the same version of the external Python package. In addition, the Excel files that are used as input for the calculation are used, centralised in the database and they do not have to go back and forth between colleagues.

> “It’s amazing that we are able to develop an application within 1 day, which ensures that everybody  uses the same analyses and models. This saves time and reduces the chance of errors.” - Tjeerd Hermsen, Sweco

### User-friendly
Kelvin Roovers comments: “What I like is that you can program complex applications with a user-friendly interface and easily present results through different visualisations”. “VIKTOR is also interesting for simple applications. There are many Excel files in a company that can be easily converted into a professional application with version control, user management system and visualizations. It is more user-friendly than a multi-sheet Excel file, and you can perform different calculations to find the best solution, ”says Nynke ter Heide. “As a freelancer, I like to be at the beginning of developments. I regularly see that my customers are enthusiastic about my proof of concepts, but that it is challenging to put them into production in the organization. VIKTOR can help meet this challenge and turn concepts into applications, ” she adds.

### Web-based and automated
Johan Tuls notes that he wanted to “create and host a web-based application; In the perception of management, however, this differs from the main field of work of the engineer and the company. A partnership with VIKTOR has reduced or overcome this risk ”. Peter Konijnenbelt says: “The management and engineers are very positive about VIKTOR and the results we have achieved in a short period of time”. He adds: “Their team has helped us a lot, you notice that they are much more involved with automation and have a different mindset. They help set up a better [parametric model](https://www.viktor.ai/parametric-design-software) and visualize the results so that we can compare different solutions." 

![VIKTOR application for designing subways under roads and railways (BAM)](/uploads/VIKTOR_application_for_designing_subways_under_roads_and_railways_BAM_2_79badeffb2.png)
*VIKTOR application for designing subways under roads and railways (BAM)*

## Want to know more?
This is the first of a series of articles about engineering and Python. The next articles will be published soon. We will talk about how you can make [parametric design tools](https://www.viktor.ai/parametric-design-software) using Python and common engineering software like Grasshopper, Dynamo, SCIA, RFEM and IDEA. To write these articles we interviewed engineers that make these kinds of tools on a daily base. Real pros!

Maybe you wonder why we are writing this. At VIKTOR we are on a mission to unleash the world’s real engineering potential. We are developing a platform where engineers can build their own web-based applications using Python. We work closely together with engineering, construction and manufacturing companies and help them boost their digital transformation. We would love to hear your feedback on our ideas, try out the platform, and help us create the perfect tools for you.

Creation of diverse professional software tools

large_how are engineers creating professional software tools.png

medium_how are engineers creating professional software tools.png

small_how are engineers creating professional software tools.png

thumbnail_how are engineers creating professional software tools.png

Blog_engineers_creating_professional_software_tools_1

How are engineers creating professional software tools?

)In this article I will also share the thoughts of a handful experts, who were willing to be interviewed by Lisa de Kluijver and me and contributed with their experience. 

A special thanks to:

- Lieke Melsen – Assistant Professor Computation Hydrology at Wageningen University
- Thijs Damsma – Data Engineer at Van Oord
- Jacco Hoekstra – Professor CNS/ATM (Communication, Surveillance, Navigation / Air Traffic Management), and former Dean of the faculty of Aerospace Engineering, at Technical University Delft
- Johan Tuls – Structural Engineer at BAM Infraconsult
- Philip Vollet – Senior Data Engineer at KPMG and [Machine Learning](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction) and Natural Language Processing (NLP) Specialist
- Maaike van Putten – IT trainer and developer at Bright Boost

This is part of a series of articles about engineering and Python. Each time we will go deeper into engineering content and talk about solving specific problems. Other articles on this subject are:

- [How are engineerings creating professional software tools?](https://www.viktor.ai/blog/18/digital-transformation-python-BIM-data-analysis--artificial-intelligence)
- [Parametric design in the cloud with Grasshopper](https://www.viktor.ai/blog/13/parametric-design-python-grasshopper-excel)
- [Automating RFEM model generation with Python in a web application](https://www.viktor.ai/blog/9/web-application-automation-python-RFEM)
- [How to make an IDEA StatiCa Concrete model with Python](https://www.viktor.ai/blog/8/web-application-python-IDEA-StatiCa-Concrete)
- [Combine the power of Dynamo and Python in the cloud for easy sharing and accessibility](https://www.viktor.ai/blog/32/parametric-design-web-application-python-dynamo-real-estate)
- [How to integrate a PLAXIS model into a cloud-based parametric engineering tool with a few lines of Python code](https://www.viktor.ai/blog/34/integration-plaxis-python-parametricdesign) 
- [Automated Pile Driveability analysis with GRLWEAP and Python](https://www.viktor.ai/blog/22/parametric-design-python-GRLWEAP-pile-driveability)
- [Using Python to create parametric SCIA models in the cloud](https://www.viktor.ai/blog/10/parametric-design-python-SCIA)
- [An application with custom Python scripts to save time and reduce errors](https://www.viktor.ai/blog/27/web-application-python-D-foundations-Excel)

## Boosting your digital transformation

### The frustration of the iteration
Eight years ago, I graduated from Aerospace Engineering at the University of Technology Delft. During my study I used all kinds of parametric design models, advanced analysis, and optimization techniques. When I started working as a Structural Engineer, I was disappointed: there was never time, budget, and willingness to create professional software tools that could make a big difference in the long term.

Frustrated by the large amount of boring and repetitive tasks of a typical engineering project, I went on making software tools myself, using project hours. This was a little risk-taking and it felt a bit clandestine. I was supposed to just update the models and reports, but it seemed that no one cared as long I was meeting the deadlines. I never regret this decision, as those tools enabled me to react more quickly to the many design changes in a project every time.

### My Python toolbox

It took me a while before I discovered the best programming language to do this. At university, I learned to use Matlab; however, not every engineering company I worked for could afford those expensive licenses. Frustrated by the limitation of my Excel sheets I decided to give it a boost by learning Visual Basic (VBA). What a bad choice. I wish that someone had told me: use Python!

With time, I had a small library with codes. It was like having a box with digital building blocks that I could connect and combine to solve a specific problem, making it easier and quicker to make those programs each time. The advantages of having a software library were obvious, but the question remaind: Why were the companies for whom I was working not building their own libraries?

### Going beyond the project system

It took me some time to understand. Many companies work project-based, and that was exactly the problem. Everything needs to be done between the scope, budget, and limitations of a project. This project-based model does not stimulate creating software as a company, that can later be used in several other projects as well. Due the lack of good software, design changes need to be done individually by each discipline, models are updated manually, and there is a lot of (slow) communication. Therefore, each change has a significant impact on the progress. I call this the sawtooth effect (see figure).

![Graph of the sawtooth effect](/uploads/The_sawtooth_effect_92f0e4b302.png)

### Building digital assets

Starting to build custom software tools as a company requires a change in mentality. It is investing upfront and benefiting later, which may seem risky. Making a proper software tool from scratch is risky as well and can require a huge effort at the beginning of the project. However, when done properly, progress can go exponentially and calculating and reporting a design change can become a matter of minutes (see figure).

At the beginning, progress is hard to track, which makes people nervous. I think this is a big reason why many companies are not taking the first step to creating custom software for their projects. The solution is therefore investing in digital building blocks. Once you have a few of those in your possesion,  you can reutilize and connect them to quickly make software applications and benefit immediately. It is clear: Digital building blocks are assets for the company, that everyone can use, and provide a long-term benefit.

> "Construction companies grow linearly, but programming their own building blocks makes it exponential. Programming building blocks is like building up capital. Each time you can make more, better, quicker and cheaper software applications, allowing you to make a big step forward." - Johan Tuls, BAM


## Some background info about Python

Python was created by Guido van Rossum and first released in the beginning of the nineties. The aim was to help programmers write clear, logical code for both small and large-scale projects. That is exactly the reason Python has grown as big as it is now.

> "Python is the future because it is a lingua franca. It transcends all platforms and domains. You can 
use it for infinitely different software applications. This makes Python unique." - Jacco Hoekstra, Technical University Delft

![Graph_Popularity of Programming Language.svg](https://cms.viktor.ai/uploads/Graph_Popularity_of_Programming_Language_af37efc9c6.svg)


To sum it up, these are the most important reasons for why Python has become so popular:

- **It is free and easy to learn!** Out of all programming languages it is probably the one that resembles English most, meaning you can go from thought to code very fast and intuitive.
- **It is not only about the language.** It is also an amazing open and accessible world of knowledge and available resources.
- **You can do anything with Python**, from simple maths to scientific calculations on a supercomputer, including Data Science, Machine Learning, creating web-based applications, and much more.
- **It is very scalable** and suitable for working together with other people, even from different disciplines. 

With Python, you can start small and slowly build up a digital empire. Do you not believe me? Google, Facebook, Instagram, Spotify, and Netflix; they all use Python as well! Just Google it ;).

## Digital Building Blocks
I noticed that the common approach to build scalable software and cooperate with other specialists is literally thinking in digital building blocks that can be connected to each other. This make the process versatile and scalable. 

Some benefits of using this building block approach are:

- You can build code fast by utilizing someone else's work! No starting from scratch.
- It enables people to share knowledge in the form of code!
- It makes it easier to replace parts of your code!
- It makes growing the code more controllable, as each block has a specific function!

This approach started in the software development community, with object-oriented programming and packages you could use to make your own software tools. Nowadays, it is becoming more popular in Engineering, Data Science, Architecture, and the Scientific Community as well.

Anything you can connect and command can be seen as a building block. It could be from a simple script, from one of the many free Python packages, or from FEM software.

## Objects: The building blocks of Python

Python is object-oriented. This allows you to break down your software into small problems (we call them objects) that you an then solve seperately, one object at a time. It is like building something large out of smaller components. This is a good match since it is very similar to how I, as an engineer, look at physical objects that have to be designed, built and maintained.

### Object creation

To create an object, you need to define a class. A class is a template for creating objects on which you are able to define its' behaviour and properties. A class can be used to make as many objects as you need. The great thing is that you can use properties of different objects for other calculations or for creating a ‘larger’ object as well. For example, you can create many beam objects, and then use their mass and stiffness properties to calculate the deflection in the bridge object.

### Free information flow

Information between objects can flow very freely. This is totally different from scripts typically made when using Visual Basic, Matlab or FEM packages. Here, the code runs top-down, meaning that changing something in the code will affect everything beneath it. This is like playing Jenga. The more complex it gets, the greater the chances become that it will collapse. With Python however, this problem does not exist.

In general, you can see objects as digital building blocks for making a larger software program. Allowing different specialists to build, maintain and improve their objects, and share it with the rest of the world to make something even more awesome!

## Free building blocks
The Python Package Index (PyPI) has 243,692 packages you can use for free! Most are not self-standing software, but building blocks for creating larger software tools. There are packages for visualizations, Machine Learning, Data Science, numerical calculus, and much more. Their quality is very high, so use them well and build your code fast! 

For example: 
- Numpy can be used to do all kind of matrix operations. Its functionalities are comparable to MATLAB. 
- Pandas helps you manipulate and analyse large sets of data without having to learn a specialized data-processing language. 
- PyTorch enables you to use machine learning without being a specialist. 

Which ones do you use the most?

> "There is a democratization of knowledge. It has become easier to use people’s tools and get insight into other disciplines thanks to the many available software packages." - Thijs Damsma, Van Oord

## External software is just another block

Quite often I hear that engineers are facing the limits of the standard software packages they use and this is leading to cause a change in mentality. Nowadays, standard software packages are not considered to be the total solution anymore. These software packages are just part of a greater process and engineers are now searching for connectivity.

These days, a large number of external software packages can also be commanded with Python. This is very powerful, as it enables you to use them like any other digital building block in your code. For example, you can combine a cost model made in Excel with a structural calculation to find the cheapest solution that satisfies the structural requirements. This can also be done with other tools, such as Grasshopper, Dynamo, SCIA, Plaxis, Diana, Excel, ANSYS and Deltares D-Series.

![External software packages that can be commanded with Python](/uploads/External_software_packages_that_can_be_commanded_with_Python_f270df6020.png)

## What’s next?

### Knowledge distribution
As an engineering community we still have a great challenge: the distribution of knowledge. What do you think is the best way of distributing digital building blocks and making knowledge available to others? I would like to hear your opinion about this topic, so don't hesitate to contact me!

Personally, I think there are two groups: the programmer, who can read, understand, and use a code; and the end-user who cannot program, but is going to use the tool. 

For the first group, good distribution channels are still missing. As a result, many of these specialists are programming the same theories or creating programs for solving the same problems over and over again.

> "We lose enormous amounts of time by programming the same models. If there was a central place where these models where available, we could invest that time in going forward."  - Lieke Melsen, Wageningen University

### Marketplaces for software applications

I believe soon there will be marketplaces where specialist can offer the software applications they made, so they can be used as digital building blocks for solving larger or more specific problems. There should be a financial compensation, such that companies and freelancers see this as an investment, and the creation of specific engineering tools is stimulated. If you are interested in this marketplace, let me know as well!

### Additional challenges

For the second group, the ones that cannot read or write code, another solution must be found. I am a strong believer in user interfaces and online software applications. 

> “A big benefit of web-based applications is that the different disciplines have access to a common environment and always can make decisions based on the latest version of the information.” - Philip Vollet, KPMG

## Want to know more?

This is the first of a series of articles about engineering and Python. We will talk about how you can make professional engineering applications that everyone can use, as well as on how you can make [parametric design tools](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) using Python and common engineering software like Grasshopper, Dynamo, SCIA, RFEM and IDEA. To write these articles we interviewed engineers that make these kinds of tools on a daily base. Real pros!

**Stay tuned! Follow us on LinkedIn, so you don't miss anything.**

Maybe you wonder why we are writing this. VIKTOR is on a mission to unleash the world’s real engineering potential. We are developing a platform where engineers can build their own web-based applications using Python. We work closely together with engineering, construction and manufacturing companies and help them boost their digital transformation. We would love to hear your feedback on our ideas, try out the platform, and help us create the perfect tools that enables you to:

AUTOMATE THE BORING. ENGINEER THE AWESOME!

If you are interested in [developing your own parametric design tools](https://www.viktor.ai/parametric-design-software), make sure to [check out our solutions page](https://www.viktor.ai/parametric-design-software).


Accelerate your digital transformation using Python

small_accelerate your digital transformation using python.png

thumbnail_accelerate your digital transformation using python.png

Blog_accelerate_digital_transformation_python_1

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

VIKTOR Blog

Hackathon stimulates knowledge development