Digital transformation

Creating Apps & Python

## Data-driven decision-making with Revit 

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

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

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

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

## Great potential, little accessibility 

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

### Specialists required 

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

### Black box 

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

## Great potential, lots of accessibility! 

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

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

*Turn your knowledge into asset!* 

### Become the specialist 

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

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

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

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

### Unlock full potential 

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

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

*Improve your learning-curve!* 

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

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

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

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

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

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

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

 


small_appRevit - VIKTOR (1).png

thumbnail_appRevit - VIKTOR (1).png

Blog_data_driven_decision_making_revit_2

Data-driven decision-making with Revit

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

## Let’s start automating geotechnical engineering!

PLAXIS is a well-known and widely used software package that executes finite element analyses (FEA) in the field of geotechnical engineering, such as waterflow, deformation and stability.
Due to its easy set-up, geotechnical engineers who are new to the PLAXIS software package will only need a couple hours of training to be able to work with the geotechnical design and analysis software. 

## Create a PLAXIS model with a few lines of Python code 

PLAXIS software supports an API that follows commands from within Python. This means that users can easily optimize their workflow with Python. It requires a Bentley Geotechnical SELECT Entitlement license to be fully functional.
For each action in PLAXIS (e.g. adding materials) a matching Python command can be tracked down. This enables engineers to find out which commands they can use to design models and read out their data.
PLAXIS software also supports addition of Python software packages

## Running the analysis in the VIKTOR web application

In order for PLAXIS to direct a VIKTOR application, the following is needed:
- A VIKTOR application
- A worker
- A server where PLAXIS software is installed with the correct license for analysis

From the VIKTOR application, the Python script is sent to the server via the worker. The worker is a general worker that can carry out executables (e.g. programs, commands) to the server of a customer. In this case the Python script will be activated.
After analysis, the generic worker sends back specific files to the application, which can subsequently process the results (e.g. visualizing, generating downloads etc.)

The script that is being sent to the worker, consists of the following parts:
-	Start-up of the PLAXIS remote scripting service
-	The code to direct, build and read results from the PLAXIS model
-	Creation of output files that have to be written off into the working directory of the worker – these will be send back to the app once the process finishes
Starting up the remote scripting service looks as follows:

```python
import subprocess, time, os
PLAXIS_PATH = r"C:\Program Files\Bentley\Geotechnical\PLAXIS 2D CONNECT Edition V20\\Plaxis2DXInput.exe" # Specify PLAXIS path.
PORT = 10000 # Define a port number.
PASSWORD = 'secret' # Define a password.
subprocess.Popen([PLAXIS_PATH, f'--AppServerPassword={PASSWORD}', f'--AppServerPort={PORT}']) # Start the PLAXIS remote scripting service.
time.sleep(30) # Wait for PLAXIS to boot before sending commands to the scripting service.
# Start the scripting server.
global g_i, s_i
s_i, g_i = new_server('localhost', PORT, password=PASSWORD)
# Execute code.
# Extract required data and write files to working directory.
```

The output files can have a substantial file size. Therefore only the relevant information is being taken out of and sent back to the app, instead of the complete output files.
A clever tip is to store the output files on the server so they can always be inspected later by a geotechnical engineer.

Below, an example is shown of a [parametric design application](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) in which sheet piles are analyzed with PLAXIS software. This application is developed by Nathalie Bouwman, Guido Bongers and Johan van Ede who are engineers at VolkerWessels. 

After reading in the CPTs, a layer structure is automatically generated with associated material sets for the different soil types. In here, ground water levels and hydraulic head can be adjusted.

The construction, loads and phasing can be quickly entered and adjusted. The automated output shows the forces and deformations of the retaining element, with its anchors and props.

In case the starting points change, existing calculations can be easily recalculated at the push of a button.


<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/566539609?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="Plaxis Python VIKTOR web-based appliction integration"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>



### Let’s talk software integration!

Would you like to know how we can support you with integrating PLAXIS or any other software package? Feel free to contact us! 
See how you build your own [Cloud-based parametric design tools](https://www.viktor.ai/parametric-design-software) for automation and optimization. 

[![CTA_Find_Out_More](https://cms.viktor.ai/uploads/solutions_page_banner_7_7bcffae017.svg)](https://www.viktor.ai/parametric-design-software])



small_appPLAXIS in VIKTOR.png

thumbnail_appPLAXIS in VIKTOR.png

Blog_PLAXIS_models_parametric_engineering_python_1

PLAXIS and Python building blocks can be used to design models, analyze data, and export results in the Cloud. Read more on VIKTOR.ai!



How to create PLAXIS models in your app with Python

Integrate PLAXIS models in parametric engineering tools with 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

## Use parametric design   

[What is parametric design?](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction)  In short, parametric design is an approach that uses flexible models, which can be quickly adjusted and solved. The goal is to see the effect of specific choices on your design by just changing the input variables and without creating a new model.

"As a designer, you spend less time performing calculations, which allows you to pay more attention to the interpretation and analysis of the results and how this affects the design. It is more efficient, and you get better solutions." 

![MicrosoftTeams-image (2).png](/uploads/Microsoft_Teams_image_2_77460635c4.png)

## Don't overthink it, just start.

“I remember my first meeting with VIKTOR, where I was with a colleague who was excited about the concept of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction). I, however, was not convinced. I think I spent half of the meeting trying to explain to my colleague and the people at VIKTOR why it was simply impossible to use parametric design in our case. It may work for others, I said, but not on this project. They replied simply: “That is what everyone else tells us as well”.

Looking back, the idea I had of [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) at that time was not realistic. I was thinking of a magic box that you fed a few input files and returned you a perfect solution. I don't think that is achievable, at least not yet. However, as soon as development started for real, I was convinced. We started with automating a few repetitive tasks that require a lot of time and manual work, and I saw how much time and energy that saved. Even those within the engineering team that were very skeptical, were convinced after a few uses. They saw how easy it was to apply a change, that would have cost days before, and how it made their work more interesting by replacing the repetitive tasks with more time for analysis.”

## Think big, but start small

“I think it’s very important to have a goal in mind, something to work towards, even if it seems very complex, or even impossible to achieve. And then, start with the easiest step towards that goal. By starting the process, you will find your way, but keep the focus on the big goal you want to achieve. 

Applications like this need to start small and grow organically. With each step you will learn more about what is possible and what you need. You will also discover new possibilities and start getting more colleagues enthusiastic. It has a snowball effect, by parametrizing part of the design, and then keep adding small bits and pieces, you get closer sooner than you might have expected.”

![MicrosoftTeams-image (1).png](/uploads/Microsoft_Teams_image_1_e7fa3e01b9.png)


## Have a plan but allow yourself to deviate from it.

“Again, I had a different idea about what was possible with [parametric design](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction) at the start of the project. But that happens with new applications as well. I am working on a new and different tool, starting completely from scratch. Contrary to [Wilma](https://www.viktor.ai/customer-cases/24/parametric-design-tool-python-D-series-Plaxis-SCIA-Excel-BIM), where we had no detailed plan, in this case it was very clear what the desired functionality was and which steps had to be taken. But as soon as we started, we had to change it. And even now, towards the end, we are still changing requirements. It is just part of the process.

You need a goal to get you in the right direction, but in the end, you need to keep evaluating if taking the next step is worth the effort. You can spend a lot of time talking, in very abstract terms, about how to reduce the effort you are spending on a task by a few percent. But if that task is only 5% of your work, that doesn't help you much. However, if each step can save 1% on 90% of your work, then you are talking big numbers.”

## Know your process, through and through.

“Another important lesson that I took from Wilma to this new project is that you really have to know your process, every step and detail of it. You have to know it so well that it becomes boring to you. Transferring a process to an application is very different from instructing a colleague. You can’t tell the computer: just figure out the details yourself.
Even if you can always change the protocol later in the process, you don't want to be tweaking your protocol at the same time you are building your tool. That will only make it take much more time and energy than needed. Thinking in standardization is an important part of creating a [parametric design tool](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction)”

## Trust the skills of the developers, but also your own. 

“I remember at one point, we needed to add some geotechnical formula. So, I started to explain all the background and assumptions, until one of the developers asked: what is the formula actually? It turned out to be a simple addition to yield a third parameter. This made me realize: the way developers work is different. A developer doesn’t need to be on point about the details of effective grain tension. Just as I don't need to know the ins and outs of code stability. As a client, I did not know what programming needed to be done, just what the end functionality should be. We each bring our own specialism to the table and we need to trust that the other knows what they are talking about.
On the other hand, we were able to work together in the same room back then. Of course, that makes asking questions easier, but I also think that it was very valuable to see the other work in their own space.  I believe that gives a lot of context to why they do the things they do, even if you don’t follow every detail. In hindsight, I wish I’d gone to the offices of VIKTOR more, instead of them always coming to us.”

![MicrosoftTeams-image (3).png](/uploads/Microsoft_Teams_image_3_2c5332615c.png)


## Join forces

“This kind of tool is very valuable. The market is realizing this too. You see many parties starting their own development. This means that there are many different tools being made that all do essentially the same thing, and in the end only 3-4 of the best will remain. This seems such a waste of resources to me, since I have seen what collaboration can bring in this alliance. Reducing the number of developments early on will give us a better end-product and faster progress. I believe you shouldn’t be afraid to share what you have. With the current development speed in the market, it will be outdated in three years anyway. But the experience and knowledge that you gain from this type of collaboration is much more valuable long term.”

“I think that platforms like VIKTOR are the key to this type of collaboration. VIKTOR makes it easy to centralize data in once place, provide access to it and regulate who uses what. If you share an Excel sheet, you immediately share all your data, create multiple versions and lose control over who can access it. This makes it hard to protect your intellectual property and prone to error. VIKTOR is far more stable in this, having better version control and user management which secures you from accidentally changing or deleting parts of your data.

*Are you inspired to start for your own project? VIKTOR is a platform that enables [parametric design in the cloud](https://www.viktor.ai/parametric-design-software). It empowers engineers to quickly create professional and multidisciplinary parametric design tools and allows you to profit from all the advantages of custom software in the cloud, without the need of software engineering skills in-house. VIKTOR is made for engineering: invest time in standardizing and improving your process. We take care of the rest.*

***Automate the boring, engineer the awesome***


Jaap Wierenga parametric design Wilma Python

large_Jaap Wierenga parametric design Wilma

medium_Jaap Wierenga parametric design Wilma

small_Jaap Wierenga parametric design Wilma

thumbnail_Jaap Wierenga parametric design Wilma

Blog_multimillion_parametric_design_7_lessons_1

A multimillion parametric design project: 7 lessons learned

For my graduation I researched the applicability of design automation for the breakwater design process. Design automation is defined as automating (part of the) design process to make it less time demanding. Because time is of the essence, more concepts need to be explored within the same timeframe. One way to do this is by using a (parametric) design automation tool. However, this tool has to be available first. This was the main problem I encountered during my research. There are several (parametric) design automation tools in existence, but unfortunately none of those were available as open-source tools. Ironically, this is precisely the challenge the construction industry faces as well. This meant that instead of using and further developing an existing tool, I needed to develop my own tool from scratch. This is not only unfortunately time consuming, but also prevents the continuous improvement of such tools.


## The main challenge: open-source design tools

### Where to start open-sourcing tools?
I understand that for companies it is difficult to share their [parametric design tools](https://www.viktor.ai/blog/46/parametric-design-cloud-engineering-construction), especially when the tool helped them to win a tender. Sharing your tool can by many be perceived as giving your competitors the same advantage as you have. Because of that, I will not be focusing on companies from now on. Instead, I will focus on students and universities for this project. Their main goal is not to win tenders, but on the contrary, their main goals is to progress and develop knowledge.
Keeping this in mind, the best place to start open-sourcing tools seemed to be the universities and applied universities. These institutions are based on democratising knowledge. By having the students and researchers from these institutions share their code and tools under an open-source license, their impact can be compounded and a process of continuous improvement that has not been made possible before can be started. 

### Open-source tools for continuous development

If this is a success, existing tools can become digital building blocks for the development of new tools later. It is of great importance that universities encourage their students to open-source their code and tools for this purpose. This can for example be done by sharing tools on a platform like GitHub, or alternatively on a dedicated GitHub to engineers. This way the entire engineering community is enabled to use their tools. And when engineers use these tools in their design processes, they can later provide students and universities again with feedback that can be implemented in the design tool, starting the process of continuous development.

## Design automation in open-source tools

### Integrating the tool

So my breakwater tool is not the first tool, but it is the first tool available under an open-source license . The main design philosophy behind the tool was based on Lawson and Dorst (2005) who explained the importance of experience in a design process, as experienced engineers intuitively and immediately performs the necessary design steps. This statement was also confirmed during the interviews I conducted with breakwater designers, as the interviewees frequently explained their design process by using examples from other projects.
This is an important part of my tool, as the goal of the design automation tool is not to replace the engineer. On the contrary, the design automation tool must mitigate the weaker point of the engineers, which is quickly and repeatedly performing the same computations without making any mistakes. However, the engineers have something the tool does not have; their experience and engineering judgement. By integrating a design automation tool in the design process we get an integrated design process where the main strengths of both the tool and engineer are used together.

### Creating a user-friendly interface

However, my tool is a purely Python based tool and this limits the user base. Not all engineers are skilled, or comfortable, enough to use a Python tool. This raises the threshold for using the tool, which is undesirable as we want to improve the breakwater design process by lowering the threshold as much as possible. Therefore, an easier to use interface is needed. This can for instance be a graphical user interface. The next that has to be taken, is the creation of a web application out of the design tool. This tool can then be accessed through a web browser. Besides the benefit of not requiring a software installation, it will also make the tool available from every location. As long as you have an internet connection of course.
But, creating a web application is a tedious job and requires a lot of time. Time you might not be prepared to invest yet, as the design tool was actually the end goal. To bridge this gap, VIKTOR offers a Python SDK that can be used to create a web application. With this web application engineers who are not familiar, or comfortable, with Python can design breakwater concepts in a matter of seconds. This greatly expands the user base, as everybody can use a website to enter the required values. Thus, knowledge of Python is no longer a requirement!
Opportunities of sharing tools


## Creating the optimal design

The design automation tool, together with the VIKTOR application, can be used to quickly design breakwater concepts. This allows engineers to investigate the influence of parameters on the design and costs, and thus explore more diverse concepts in the same amount of time. Because more concepts are explored by engineers it is credible to assume that the chances of finding the optimal design increase. As a result, the chances of winning the tender increase as well.

## The challenge of open-sourcing

So back to the main challenge: To open-source the tools. My research showed that an open-source tool can help engineers in their design process, and thus increase the chances of winning a tender. Unfortunately, partaking students forgot or did not want to share their tool after they graduated. However, students are still in possession of the missing link: The design automation tools. 
## We need your help!
So, this is a call to remove all the dust from the tool you created during your graduation or research, and to upload it to GitHub under an open-source license. Democratise your knowledge so that the construction industry can improve due to your contribution! And remember, don’t be afraid to share your tools, or that someone will find a bug in your code. The biggest compliment you can get is someone else, maybe even an entire company, using your tool!

See how you can automate design processes by [building your own user-friendly parametric design tool](https://www.viktor.ai/parametric-design-software) that can easily be distributed.

**Sources**

Cederfeldt, M. (2007). Planning Design Automation: A Structured Method and Supporting Tools. PhD thesis, Chalmers University of Technology, Göteborg, Sweden.

Lawson, B. and Dorst, K. (2005). Computational and Cognitive Models of Creative Design VI, chapter

Rustell, M. (2016). Knowledge extraction and the development of a decision support system for the conceptual design of liquefied natural gas terminals under risk and uncertainty. PhD thesis, University of Surrey.

Winkel, S. (2020). Improving the breakwater design process by using a design automation tool. MSc. Thesis, Delft University of Technology. http://resolver.tudelft.nl/uuid:494fa652-2125-4352-aeba-041eebcefde9



large_Breakwater-04.jpg

medium_Breakwater-04.jpg

small_Breakwater-04.jpg

thumbnail_Breakwater-04.jpg

Blog_breakwater

Open-source parametric design tools for breakwaters

## Speed up with VIKTOR and Python

VIKTOR offers a binding with IDEA StatiCa Concrete, as one of its digital building blocks, making it easy to generate such models with minimal Python code and to perform analyses all from within your VIKTOR web application (without the need to open the IDEA interface at all). This makes it even easier to integrate a complete analysis/design process in a single app, and with the tools you are familiar with. For example, by integrating VIKTOR with SCIA and IDEA StatiCa Concrete, a structure can be verified by Finite Element Analysis (FEA) both on a structural scale as well as on a reinforced member-scale. Practice has shown that such VIKTOR web apps contribute to a huge increase in effectiveness and a significant decrease in errors, by providing a common, standardized interface for the engineers involved in the process.

![Visualization of a reinforced cross-section in VIKTOR (top) and IDEA (bottom)](/uploads/Visualization_of_a_reinforced_cross_section_in_VIKTOR_top_and_IDEA_bottom_77d13c37f5.png)
*Visualization of a reinforced cross-section in VIKTOR (top) and IDEA (bottom)*

## Creating the IDEA model with a few lines of Python code

VIKTOR provides two ways of building the IDEA model. One follows IDEA’s Open Model API (*OpenModel* class), the other resembles IDEA’s clickable interface (*Model* class). Both classes can be found in *viktor.external.idea_rcs.*

Creating the model using VIKTOR’s *Model* class is straightforward, since the required code is concise. Below is an example of a simple beam model (dummy) with reinforcement bars under frequent and fundamental extreme cases:

```from viktor.external.idea_rcs import Model
# Initialize the model.
model = model()

# Create the desired material(s). 
cs_mat = model.create_concrete_material(ConcreteMaterial.C12_15)
mat_reinf = model.create_reinforcement_material(ReinforcementMaterial.B_400A)

# Create a beam (or other type of member) to be checked.
cross_section = RectSection(0.5, 1.0)
beam = model.create_beam(cross_section, cs_mat)

# Create bars (and stirrups)_as desired
bar_locations = [(-0.101, -0.175), (0.101, -0.175), (-0.101, 0.175)]
bar_diameters = [0.016, 0.016, 0.016, 0.016]

for coords, diameter in zip(bar_locations, bar_diameters):
	beam.create_bar(coords, diameter, mat_reinf)

# Add extreme(s)
freq = LoadingSLS(ResultOfInternalForces(N=-100000, My=21000))
fund = LoadingURL(ResultOfInternalForces(N=-99999, My=200000))
beam.create_extreme(frequent=freq, fundamental=fund)
```

Creating the (same) model using VIKTOR’s *OpenModel* class feels similar to creating it using IDEA’s Open Model API (but then in Python code). Compared to the *Model* class, it is slightly more verbose and therefore recommended only for people familiar with IDEA’s Open Model API:

```from viktor.external.idea_rcs import OpenModel
# Initialize the model.
model = OpenModel()

# Create the concrete section.
mat = model.create_matconcrete_ec(ConcreteMaterial.C12_15)
cs = model.create_cross_section_parameter(name=‘c’, cross_section_type=CrossSectionType, RECT, 
                                          Material=mat, Width=2.0, Heigth=2.0)

# Create the reinforced cross section.
rcs = model.create_reinforced_cross_section(name=‘rcs’, cross_section=cs)

# Create bars (and stirrups) as desired
mat_reinf = model.create_mareinforcement_ec2(ReinforcementMaterial.B_400A)

bar_locations = [(-0.101, -0.175), (0.101, -0.175), (-0.101, 0.175)]
bar_diameters = [0.016, 0.016, 0.016, 0.016]

for coord, diameter in zip(bar_locations, bar_diameters):
	rcs.create_bar(coords, diameter, mat_reinf)

# Create a CheckMember.
member = model.create_check_member1d()

# ‘Assign’ the CheckMember to a CheckSection with the previously defined reinforced section and add extremes.
check_section = model.add_check_section(description=‘S 1’, check_member=member, reinf_section=rcs)
freq = LoadingSLS(ResultOfInternalForces(N=-100000, My=210000))
fund = LoadingULS(ResultOfInternalForces(N=-99999, My=200000))
check_section.create_extreme(frequent=freq, fundamental=fund)

# ‘Assign’ the necessary additional data to the CheckMember.
model.add_member_data_ec2(member, MemberType, BEAM_SLAB, TwoWaySlabType, SHELL_AS_PLATE)

```

A valid IDEA input file can subsequently be generated by calling *model. generate_xml_input().*

## Running the analysis in the VIKTOR web application

With VIKTOR you can run an IDEA StatiCa Concrete analysis from within your web application, without having to open the IDEA interface manually, so that it can be easily integrated in a fully automated design process. The analysis can be performed using the *IdeaRcsAnalysis* class, by providing an IDEA StatiCa Concrete Open Model input file. This could be an input file generated with *generate_xml_input* (see above), or one obtained in a different way, as long IDEA considers it valid:

```from viktor.external.idea_rcs import IdeaRcsAnalysis
analysis = IdeaRcsAnalysis(mu_idea_input_file, return_rcs_file=True)
analysis.execute()
ouput_file = analysis.get_output_file()
idea_rcs_file = analysis.get_idea_rcs_file()
```

Executing the analysis invokes the input file to be sent to a designated (virtual) [machine](https://www.viktor.ai/blog/40/artificial-intelligence-machine-learning-engineering-construction) that executes the job (on a so-called ‘worker’), using the local IDEA software and license. After execution, the resulting output file (.xml) and/or IDEA StatiCa Concrete file (.rcs) can be retrieved for further processing.

## Parsing the Results
For convenience, VIKTOR is shipped with an output file parser (*OutputFileParser*) that simplifies the extraction of results from the XML output file (obtained from *IdeaRcsAnalysis*, or in any other way). This way, the most common results (e.g. capacity, shear or crack-width results) can be obtained for each of the sections with only a few lines of code:

```from viktor.external.idea_rcs import OutputFileParser
parser = OutputFileParser(output_file)
for section in parser.section_ids:
	capacity_results_section = parser.capacity_results(section)
	shear_results_section = parser.shear_results(section)
	crack_width_results_section = parser.crack_width_results(section)
	detailing_results_section = parser.detailing_results(section)
	stress_limitation_results_section = parser.stress_limitations_results(section)
```

These numerical results can be further processed within your VIKTOR web application and used to create graphs and tables and the like, giving the user valuable (visual) feedback.

## User-friendly web applications
Creating web apps with VIKTOR enables you to cover the full analysis/design cycle, from the parametrization and creation of a (structural) model, to performing FE calculation(s), performing IDEA StatiCa Concrete checks, and providing valuable (visual) feedback to the user, all with the tools you are already familiar with. By having all engineers work in a single, standardized web application, errors in the process can be reduced and effectiveness can be significantly increased as well.

Are you interested in a complete overview of the VIKTOR – IDEA binding and integration possibilities? Please contact us and join the VIKTOR community!

small_app (4).png

thumbnail_app (4).png

app (4).png

See how you can create and IDEA StatiCa Concrete model with Python. Read more on VIKTOR.ai.

IDEA StatiCa Concrete model with Python

How to make an IDEA StatiCa Concrete model with Python 

## Automate where possible!

During my years as a structural (finite element) engineer, working for several different companies, I got to work with various structural software packages as well, including ABAQUS, ANSYS, NASTRAN, RFEM, SCIA, and more. Having experienced the effort and time needed to create finite element models, I became an advocate of automating this (labor-intense and often boring) process whenever possible, an opinion that is widely shared among our clients. 

## RFEM models with a few lines of Python

RFEM is a widely used software program developed by Dlubal for the 3D finite element analysis (FEA) of engineering structures, widely used by civil engineering companies around the world. 

![appRFEM model in VIKTOR.png](https://cms.viktor.ai/uploads/app_RFEM_model_in_VIKTOR_2490f1d2ae.png)


*Creating an RFEM model within RFEM's structural software package*

Creating RFEM models using the VIKTOR SDK (Software Development Kit) is done by witing object-oriented Python code. No knowledge of RFEM’s C# API is required. All the relevant building blocks can be found in the module *viktor.external.rfem*, of which the starting point is the *RFEMModel*, making it easy to implement for developers with basic Python knowledge. It also effortlessly integrates with all other parts of the SDK!

```python
model = Model()
node1 = model.create_node(0, 0, 0)
nide2 = model.create_node(10, 0, 0)
material = mol.get_material("Steel S355 J0")
cross_section = model.create_cross_section("my section", material)
model.create_element(node1, node2, cross_section)
```

*Python code showing how a (dummy) RFEM model is built-up in VIKTOR* 

An RFEM input file *(.rfx)* can be generated by calling *model.get_rfx_file()*, that can then be downloaded (so that it can be manually loaded into RFEM) or sent for analysis to VIKTOR’s RFEM worker.

## Running the analysis in the VIKTOR web app

With VIKTOR you can perform an RFEM analysis from within your web application, without having to open the interface manually at all! This makes the analysis easily integratable into a fully automated design process. The analysis can be performed using the *RFEMAnalysis* class, by specifying the input file *(.rfx)* and working through a set of actions. This could be an input file, generated with *get_rfx_file* (see above), or one obtained some other way, as long as RFEM deems it valid:

```python
from viktor.external.rfem import RFEMAnalysis
rfx_file = model.get_rfx_file()
analysis = RFEMAnalysis(rfx_file, actions)
analysis.execute(timeout=3600)
model_with_results = analysis.get_model()
results_lc_1 = analysis.get_result(load_case=1)
results_lc_2 = analysis.get_result(load_case=2)
```
*RFEM analysis with VIKTOR in your web application*

The worker can perform a series of actions that can be chosen by the developer from a fixed set (this set might be extended by VIKTOR in the future, depending on the demand). For example, a typical energy optimization analysis can be performed on a selected set of load cases, by:

```python
Goal_energy = 10e3 # [Nm]
Accuracy = 0.01 # [m] = 1 cm
Optimize = EnergyOptimizationAction(load_cases=[1, 2], goal =goal_energy, accuracy=accuracy)
Write = WriteResultsAction() # request deformations and internal forces for all load cases
Actions = [optimize, write]
```

*A typical enegry optimization analysis with VIKTOR*

Executing the analysis invokes the input file to be sent to a designated (virtual) machine that executes the job (on a so-called ‘worker’), using the local RFEM software and license. After execution, the model with results *(.rfx)* and/or the requested results per load case can be retrieved in numerical form for further processing (e.g. for plotting graphs and tables in the app’s interface).

## Creating user-friendly web apps with VIKTOR

Python code and RFEM packages can be intimidating for some people. VIKTOR provides the opportunity to create user-friendly web-based applications and run RFEM in the background. In this way, you can make your domain knowledge available to other people while also keeping your intellectual property save.

For example, think in a product configurates that enables a sales representative to design and price a product independently, while remaining the safe boundaries that you have determined as an engineer.

Here you can see the same RFEM model in a VIKTOR application. The person using it does not have to have any knowledge of RFEM or Python, nor a licence installed. It is available everywhere and from any device!

![visualization of a RFEM model in a VIKTOR application](/uploads/RFEM_model_in_a_VIKTOR_application_03a58fa039.png)

*RFEM model in a VIKTOR application*

## RFEM binding with VIKTOR

VIKTOR’s RFEM binding makes it even easier to generate, analyse and post-process your RFEM models in an automated way, using the software you are familiar with. A VIKTOR worker provides a connection between the web application and the software, such that RFEM can be executed from within the browser. After the analysis, the results are returned and can be visualised on top of the model visualisation. This means that the manual tasks of constructing a RFEM model, analysing the model, and assessing the results can all be done with just a simple button click from within the VIKTOR interface!

![Model](/uploads/Model_aa10ef6a21.png)

*An RFEM model, constructed from within the VIKTOR interface*

Do you want to construct and analyse RFEM models quick and easy as well on the VIKTOR platform? Don't hesitate to contact us!


small_appRFEM model in VIKTOR.png

thumbnail_appRFEM model in VIKTOR.png

Blog_RFEM_model_8

Automating RFEM model generation with Python in the Cloud

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