Creating Apps & Python

Digital transformation

large_AI - geotechnics.jpg

medium_AI - geotechnics.jpg

small_AI - geotechnics.jpg

thumbnail_AI - geotechnics.jpg

AI - geotechnics.jpg

3 Geotechnical engineering tasks ChatGPT can be used for!

Can the AI chatbot ChatGPT do Geotechnical Engineering?

## What is ChatGPT?

This is an AI chatbot developed by OpenAI that specialise in language model, more specifically GPT. It is designed for conversational languages, like a Google search engine but with more human-like features. We can ask any questions (e.g. search on Google) or ask for more complex tasks such as writing code.

## How does it work?

ChatGPT had been trained with massive amounts of data from various sources through 2021 using Reinforcement Learning from Human Feedback (RLHF). In RLHF, humans rate multiple questions and answer pairs, and rank them on quality. This generates a reward function that is used to optimise the GPT model with a reinforcement learning algorithm.
**Since the data was collected up to 2021, ChatGPT has limitation of providing information about current events as the knowledge is compiled from historical data.

## Goal

As a Python geek, I definitely love to try this new AI tool and see how far it can go. I have been playing with ChatGPT over the past few days. Below are the engineering tasks I gave ChatGPT ordered by difficulties:

- Find design standard of pile foundations in Australia and display the formula involved
- Plot a linear regression
- Extract PDF content


ChatGPT

I was curious about how good ChatGPT is in terms of searching for information. Therefore, I asked about how AI would design reinforced soil walls. Here are the two questions I asked:

```python
what standard we use for reinforced soil wall in Australia
```

<iframe src="https://player.vimeo.com/video/780016061?h=b3674ae953" width="640" height="284" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen></iframe>
<p><a href="https://vimeo.com/780016061">rss wall</a> from <a href="https://vimeo.com/user148549091">Philip</a> on <a href="https://vimeo.com">Vimeo</a>.</p>

```python
how to design reinforced soil wall
```

<iframe src="https://player.vimeo.com/video/780016395?h=30bcd2a231" width="640" height="284" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen></iframe>
<p><a href="https://vimeo.com/780016395">rss wall2</a> from <a href="https://vimeo.com/user148549091">Philip</a> on <a href="https://vimeo.com">Vimeo</a>.</p>

ChatGPT provides the correct standards required for designing reinforced soil walls. More impressively, it outlines a thorough procedure for reinforced soil design. It may not provide all formula for the design but it can provide junior engineers with a general design guideline so what design parameters need to be considered.

That was an easy one, let's try something more complicated.

Task 1: Ask about geotechnical design

If you want to plot a linear regression using Python and not sure how the script should be structured, you can simply ask ChatGPT:

```python
plot a linear regression with Python using matplotlib
```

<iframe src="https://player.vimeo.com/video/780011517?h=2b8a7bf8a9" width="640" height="284" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen></iframe>
<p><a href="https://vimeo.com/780011517">linear_regression2</a> from <a href="https://vimeo.com/user148549091">Philip</a> on <a href="https://vimeo.com">Vimeo</a>.</p>

Here is the code created by ChatGPT:

```python
import matplotlib.pyplot as plt
import numpy as np

# Generate some random data to fit a linear regression to
np.random.seed(0)
x = np.random.uniform(-1, 1, size=100)
y = 2 * x + 0.1 * np.random.normal(size=100)

# Fit a linear regression to the data
slope, intercept = np.polyfit(x, y, deg=1)

# Plot the data and the fitted line
plt.scatter(x, y)
plt.plot(x, intercept + slope * x, 'r')
plt.show()
```

Run the script in VS Code and you will get:

![Linear regression chatgpt.png](https://cms.viktor.ai/uploads/Linear_regression_chatgpt_f852601058.png)

This is impressive! First, the code it created includes comments which tell us what each line of code does. Second, it generates sample data and precisely produces a linear regression line as we requested.



Task 2: Plot a linear regression

As geotechnical engineers, we often deal with a massive amount of PDFs. I want to try ChatGPT's capability in creating Python script to extract information from PDFs.

I used a publicly available borehole log as an example, you can find it in the following link:

https://www.environment.act.gov.au/__data/assets/pdf_file/0006/1827384/21-49952-Documents-Document-2-Part-3-2-61-150.pdf

The BH log contains 90 pages and I want to extract all borehole IDs from the log. Ask ChatGPT to write a Python script for us:

```python
extract string using pdfplumber and regex search for string after keyword 'BOREHOLE LOG' 
```

<iframe src="https://player.vimeo.com/video/780020179?h=87bc28c3fb" width="640" height="284" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen></iframe>
<p><a href="https://vimeo.com/780020179">pdf_extract</a> from <a href="https://vimeo.com/user148549091">Philip</a> on <a href="https://vimeo.com">Vimeo</a>.</p>

Below is the script created by ChatGPT:

```python
import re
import pdfplumber


# Open the PDF file using pdfplumber
with pdfplumber.open("document.pdf") as pdf:
  # Loop through each page of the PDF
  for page in pdf.pages:
    # Extract the text from the page
    text = page.extract_text()
    # Use the regex search function to find the string after the keyword "BOREHOLE LOG"
    result = re.search(r"BOREHOLE LOG(.*)", text)
    # If the search was successful, print the extracted string
    if result:
      print(result.group(1))
```

We need to download the PDF to our local directory, if we run the script, you will see the following results:

![pdf chatgpt code.png](https://cms.viktor.ai/uploads/pdf_chatgpt_code_6cc7a55bea.png)


The script has helped to extract all the borehole IDs from the log which is exactly what I want!

Task 3: Extract PDF content

Although ChatGPT is a really powerful tool, I still recommend beginners to write code themselves because of the following three reasons:
Writing code can allow you to come up with your own logic. There is no correct answer for a coding task and it's important to train the mindset of script development.

1. ChatGPT is not perfect in which sometimes I found it requires very specific question to conduct a task. There are a massive amount of external modules in Python and I notice that ChatGPT has default modules which may not lead to the results we want. It's always necessary to learn reading documentations of different modules and understanding the limitation of each module.
2. After few trials, I also found that ChatGPT does not always give the same answers/script to the users. This is because it is an AI model which will constantly change over time. This may cause confusion for people with zero programming experience.

Nevertheless, ChatGPT is still powerful as it provides users with a detailed explanation of how it creates Python scripts which is a perfect way to learn programming.

How I will use ChatGPT:

1. Ask quick questions. ChatGPT can provide you with a broad or even detailed direction to look into which saves you time doing research on Google.
2. Use as your programming consultant, ask if you have doubts about certain tasks. In other words, use it as a Stack Overflow alternative.

Now it's your time to play with ChatGPT!

Conclusion

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

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

The benefits are:

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

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

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

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

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

Download the white paper and get INSPIRED

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

The Future of Parametric Design is COLLABORATION

South-Holland’s InnovationQuarter Capital was involved with VIKTOR from early on in 2017 as a convertible lender and facilitated VIKTOR’s earlier growth. InnovationQuarter Capital is an experienced investor in a wide range of regional start-ups and is converting within this round, making them now join as shareholders. 
VIKTOR is the leading software platform that makes it straightforward for engineers to build their own web applications. Engineers play an important role in solving complex modern challenges, for example regarding climate, energy, nitrogen emissions, and housing shortage. VIKTOR allows engineers to automate, optimize, and share their work by rapidly developing their own professional software applications. For example, for the optimization of building designs. This means that the knowledge of engineers becomes scalable and their solutions smarter. This is not only important for large engineering companies, such as VIKTOR clients [Arcadis](https://www.viktor.ai/customer-cases/41/arcadis-accelerates-digital-transformation-with-viktor) and [WSP](https://www.viktor.ai/customer-cases/42/Python-engineering-Cloud-applications), but also for [SMEs](https://www.viktor.ai/customer-cases/2/web-application-real-estate-artificial-intelligence) and [freelancers](https://www.viktor.ai/appstore/prespector-mtbf-en).   

</br>

## International growth

With this funding, VIKTOR can now further expand its international company catalog. Wouter Riedijk, co-founder and CEO of VIKTOR: “VIKTOR is active in large markets worldwide that are changing fast due to sustainability and technological developments. There is an ever-growing need for digitization and technological solutions that can be used to efficiently organize processes. In this way, VIKTOR contributes to the energy transition by enabling clients to design [projects with much lower energy use and use of energy-intensive materials (like concrete and steel) than conventionally designed projects](https://www.viktor.ai/customer-cases/34/foundations-design-optimization-saves-tons-of-CO2).” 

To reinforce these growth ambitions, the platform is made accessible to every engineer. Within two years, the goal is to have 100,000 app users on the platform. The investments from Newion and APG (ANET) will be used to enhance marketing and sales efforts and to continuously optimize and expand the platform based on users’ needs.  


</br>

## Newion and APG (ANET)

“This combination of investors is not only unique but also very powerful,” says Peter Madlener, co-founder and CCO of VIKTOR. Newion is an experienced B2B SaaS investor with a broad portfolio in IT, SaaS, Cloud, and B2B software companies. A perfect fit with VIKTOR’s profile. As a sustainable pension investor with a dedicated mandate from the ABP pension fund, APG focuses on the (Dutch) energy transition (ANET).  

</br>

## InnovationQuarter Capital

South-Holland’s InnovationQuarter Capital was involved with VIKTOR from early on in 2017 as a convertible lender and facilitated VIKTOR’s earlier growth. InnovationQuarter Capital is an experienced investor in a wide range of regional start-ups and is converting within this round, making them now join as shareholders. 

**Newion IV is supported by the European Union through the InvestEU fund**

medium_press release header wihtout tekst.jpg

small_press release header wihtout tekst.jpg

thumbnail_press release header wihtout tekst.jpg

press release header wihtout tekst.jpg

VIKTOR raises €5.1M in financing. This way, Newion, APG (ANET), and InnovationQuarter Capital – who converts a previous loan in this round – facilitate our international growth ambitions to make the platform accessible for every engineer.

Tech scale-up VIKTOR gets € 5.1 million funding to enable engineers to become software developers

VIKTOR raises € 5.1 million to enable engineers to become software developers

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

small_White Paper Digital Transformation Engineering and construction industry.jpg

thumbnail_White Paper Digital Transformation Engineering and construction industry.jpg

WP_dark_blue

large_gravity-based foundation application.jpg

medium_gravity-based foundation application.jpg

small_gravity-based foundation application.jpg

thumbnail_gravity-based foundation application.jpg

Customer_case_centralizing_data_faster_gravity_based_foundation_analysis_2


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

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

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






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

Download the White Paper and get INSPIRED

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

Digital Transformation: Engineering and Construction Industry

## With Prespector MTBF you can easily:

- **Find your bad actors**: Upload your maintenance work orders and find your bad actors based on their updated failure rates.
- **Optimize maintenance**: Use your updated MTBF to optimize your preventive maintenance. Save costs and increase availability.
- **Create a specific failure database**: Create your own system-specific failure database for future risk analysis.

<div style="padding:50.52% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/771096353?h=7a063f8fec&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="Prespector demo video"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br>

## Discover how it works

For more information about this application, please visit [Prespector MTBF](https://www.viktor.ai/appstore/prespector-mtbf-en). 

> "While working as a Reliability Engineer in Infra and Industry, I noticed that failure data from the field was often not used to embed the knowledge of assets. The Bayesian update is a well-accepted method for this. Hence, I created this application." - Bart Groenenboom, Reliability Engineer | Prespector

medium_Appstore_prespector_thumbnail

small_Appstore_prespector_thumbnail

thumbnail_Appstore_prespector_thumbnail

Appstore_prespector_thumbnail

Update your risk analysis quickly with your own failure data using a Bayesian Update. Easy to use by Reliability or Maintenance Engineers.

Update failure rates with a web app

Prespector MTBF - Update your failure rates easily


>“We are very enthusiastic about this collaboration! Together with our business ProductOwner and a ‘Coding Engineer’ we are exploring this collaboration in the development of the underwater concrete floors application. Quite exciting, with questions as ‘what is generic and suited for shared development?’ versus ‘where do we secure our own IP?’ It is clear that this kind of automation is necessary. The exploration surrounds the question: What can we do together? And with that faster and cheaper?” – Mark van den Brink, Digital Transformation Lead at WSP 

## From idea to proposal
 
In a few sessions with the participating parties, the four ideas have been worked out into the following proposals:

### Crane hardstand

The purpose of this development is enabling engineers to determine the stability of crawler- and outrigger cranes, including the design of possible needed ground improvement, fast and easy to decrease the changes of tripping over. Within the application, cranes can be inserted parametrically, from which the maximal ground pressure can be determined. CPT’s (.gef files) can easily be uploaded as well. These are directly interpreted to a schematized overview of the soil layout. From there on, the stability can be determined through an integration with D-Foundations (shallow foundations). 

### Floor on piles

Many infrastructural objects consist of a concrete foundation- and floor. With this development, an optimal design of the combination floor and piles can easily be generated, including the ideal reinforcement configuration. A constructor can use this application to easily link the force effect from a finite element model (e.g. SCIA) to a cut test (e.g. IDEA StatiCa). Additionally, the pile plan can be varied to find the optimal configuration between plate reinforcement and piles. 

### Sheet piles/Construction pits

To realize construction and (temporarily) turn ground, we use sheet piles and construction pits. The purpose of this development is to parametrically design sheet piles and integrate these with anchors, underwater concrete floors, outrigger frames, etc. Within this application, the sheet pile is tested through an integration with D-SheetPiling, which enables the fast calculation of different cuts and variants.

### Underwater concrete floors

Underwater concrete is, amongst others, used for underground parking garages, underpasses, and tunnels. This development fits nicely with sheet piles/construction pits. With the application, a design of a floor including anchorage is parametrically designed to automatically generate the optimal configuration. The underwater concrete floors are tested conform the CUR77. The carrying capacity of the anchors/piles is determined through an integration with D-Foundations. 

## How to participate? 

To turn the development ideas into concrete proposals, a few in-depth sessions were organized to come up with ‘user stories’ that form the basis of every application’s functionality. Based on the user stories, a development plan and associated estimation of the costs can be determined. In March, the first definitive proposals will be sent to the entire community. Every party that is interested in joining one or more of the development proposals can sign up.

>“It’s like the old saying “many hands make light work”. Especially with crane hardstands. We all have the same goal in mind, which is safety. This is something we should take on together, so that we can quickly develop a good tool that helps us check the stability of cranes.” – Arie-Jan Tol, Team Lead at engineering firm Hektec
 
## What is the DEC?

*Accelerated digitization through collaboration*

The DEC is thé digital meeting point for the construction and infra sector, where ideas for software development come together, are started up, and accelerated. 

We share our knowledge so that we can work together to invent the wheel, make it easier to finance the (engineering) process, and offer smart and high-quality solutions. 

The initiators are Ballast Nedam, BAM, Boskalis Nederland, Dura Vermeer, Heijmans, Mobilis, Van Oord, VIKTOR, VolkerWessels. Antea Group, CRUX, Hektec, RPS, Tauw, and WSP are now a part of the DEC as well.


medium_DEC foto.jpg

small_DEC foto.jpg

thumbnail_DEC foto.jpg

Blog_DEC_development_ideas_2022

The Digital Engineering Community is expanding and has 4 new development proposals for engineering automation apps early 2022. Join now!

4 development proposals for digital engineering community early 2022

Expansion DEC brings 4 development proposals early 2022


## Using the code

There are two ways in which this functionality can be used: 

1. With VIKTOR, out-of-the-box, using our [free version](https://www.viktor.ai/try-for-free).
2. Without VIKTOR, in that case you create the following yourself: Parametrization of geo-location, map view interface, and output visualization.

Here, you see a snippet of the application code. With the following seven lines of Python code you can create map views *(return MapResult(features))* and enable users to put lines on the map *(params.geo_polyline)*. Get the full application code from our [GitHub repository](https://github.com/viktor-platform/sample-ahn-profile).

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

The video shows the functionality being used in a VIKTOR application.

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

<br>



## Ground level profiles in 3 steps

As you can see in the video, the process of creating ground level profiles with the sample application consists of three easy steps: 

1. Drawing a polyline on a map (using a GeoPolylineField) 
2. Filling in the required resolution of the resulting profile 
3. Showing the elevation profile based on AHN3 in a Matplotlib plot 

Use our [free version](https://www.viktor.ai/try-for-free) to start using this app!




geotechnics sample app ground level profile

medium_Blog_sample_app_AHN

small_Blog_sample_app_AHN

thumbnail_Blog_sample_app_AHN

Blog_sample_app_AHN

Get open-source Python code to automatically generate ground level profiles with your own apps for free.

Visualize ground level profiles | Open-source Python app

Open-source map-based AHN elevation visualization sample app

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

This guide will provide actionable insights that are useful for anyone involved in creating custom software tools, such as:

- **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 i in the process of creating awesome software tools**

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. 





Learn how you (developer, engineer, end-user, domain expert, project manager, etc.) can contribute to the creation of apps that provide real value to your work.

Build successful applications

This guide provides actionable insights for anyone involved in the creation of apps, such as engineers, developers, end-users, project managers, and domain experts. Learn how you can contribute to creating apps that provide real value to your work!

Building Successful Applications

Parametric design

*Read the original article on [heijmans.nl](https://www.heijmans.nl/nl/verhalen/digitaal-bouwen-en-ontwerpen-door-samenwerking/)*

A thick mist is hanging over the dark polder near Lage Zwaluwe when they arrive at Heijmans’ construction site. In the distance lie the foundations of six wind turbines, currently under construction, spread over several kilometers: Constructions of piles, reinforcements, and concrete in different stages of completion. Heijmans designed these foundations and is now constructing them.

![Heijmans_VIKTOR_wind_turbine_foundation_app_on_site](https://cms.viktor.ai/uploads/Heijmans_VIKTOR_wind_turbine_foundation_app_Wouter_Marcel_0b31531573.jpg)

*Wouter Riedijk, CEO of VIKTOR and Marcel Simons, manager Energy Design at Heijmans on the construction site of wind turbine park Klaverspoor near Lage Zwaluwe.*

## Calculation work

Noticeable is how the designs came to be: With the help of an application that Geotechnical Advisors and Constructors from Heijmans developed themselves on the low code application development platform VIKTOR. VIKTOR empowers engineers and domain experts at construction companies and engineering firms with basic Python knowledge to build their own technical design applications. Now, engineers at Heijmans used VIKTOR to create an application that takes over a lot of their manual calculation work. 

## Automation

“We have some unique knowledge within the industry”, says VIKTOR co-founder and CEO Wouter Riedijk. “Of the analysis, design, and of software development. In 2017, we decided to combine these into one platform, specifically aimed at the construction and infra sector. To enable engineers to build their own applications for the automated generation of designs. Within these applications, data is centrally stored, and processes are automatized to save time, generate smarter solutions, and turn knowledge into assets.”

![Blog_Heijmans_wind_turbine_foundation_app_interface](https://cms.viktor.ai/uploads/Heijmans_VIKTOR_wind_turbine_foundation_app_interface_3569f8c211.jpg)

## Together

A design consists of many variables that all influence each other. For example, with pile foundations: The width of the piles, the length, the soil, the load, the planning… When you turn one wheel, all the others start to turn as well. Multiple disciplines work on one design with each their own tooling and data sources. In an application, you can bring all of these together and simply press a button to come to one integral design. This is not only very efficient, but also gives them much more control over the process since all design calculations can be performed by Heijmans. 

## Better decisions

“This way, you can calculate many different scenarios much faster to generate different possible solutions”, explains Wouter Riedijk from VIKTOR. “Multiple people can work simultaneously on a design. You create several designs within less time, which leaves more time to judge each design based on costs and risks, which enables better decision-making and improves registration on tenders.”

![Blog_Heijmans_wind_turbine_foundation_app_agile](https://cms.viktor.ai/uploads/Heijmans_VIKTOR_wind_turbine_foundation_app_sprint_meeting_c8103d82a7.jpg)

## Digital Engineering Community

The application for the automated calculation for the design of wind turbine foundations is one example, but there are a lot more. De digitization of design processes is increasing within the engineering and construction world. Construction companies and engineering firms are even collaborating in this. That is also how the [Digital Engineering Community (DEC)](www.digitalengineeringcommunity.nl) came to be: A group of organizations collaborating in the development of design applications for infra objects. 

## Soil bodies

“Within the DEC, there are now four applications that are developed in collaboration on the VIKTOR platform”, tells Marcel Simons. “Geotechnicians at Heijmans, BAM, and Ballast Nedam were the first to build an application for the design of soil bodies. After that, five other constructors got on board as well. Within a year we (further) developed three more applications. Now, engineering firms are joining in as well!”

## Competitive

A collaboration like this is not very common. The engineering and construction world is competitive. Construction companies are heavy competitors whenever they register for a tender. So why would you collaborate in the (co-)development of applications in which you share data and that allow everyone the same chance to generate the optimal design?

## Journey

“It is true that you can see you are collaborating with your competitors. Everyone is in it for a strategic reason”, states Wouter with a fresh look at it from the outside. “We have been through quite a journey together, the trust really had to grow. But once it was there, it quickly accelerated. The set-up is accessible: When someone has a good idea for an application, the other companies can join in voluntarily by in it investing in some way.”

## Higher level

“And if you don’t do it like this, everyone starts building their own applications”, adds Marcel. “That also makes it more difficult for clients to judge designs. Now, the top of our geotechnicians is collaborating and all of this knowledge is put into one application. That takes the whole industry to a higher level.”

## Building blocks

Moreover, the DEC works according to the building blocks principle: Only standard processes are automated within an application. Everyone drives piles, everyone builds soil bodies, everyone pours tarmac. Not one constructor distinguishes themselves with that. “But these building blocks can be used to create your own, distinct application”, says Marcel. “The [wind turbine foundation application](https://www.viktor.ai/customer-cases/35/wind-turbine-foundation-parametric-design-python) is an example of that: It completely belongs to Heijmans.”

## Concrete

A short car ride away, the results of the application can be observed. The foundation of wind turbine number 6 currently consists of only a circle of 40 piles with a wickerwork construction on top. In a few days, they will start pouring concrete. The question arises: Can you also make a *better* foundation with such an application? 

## Optimal design

“You create an optimal design. That is always better”, says Wouter. “Less material, safer, cheaper, less nuisance for the surrounding environment.” “You also become more predictable, which means you are more likely to finish on time”, adds Marcel. Wouter: “And more flexible: Whenever something doesn’t work the way you planned, you simply generate a new design.” Marcel: “Within certain boundaries, of course. You cannot build a foundation using gingerbread.”

![Wind turbine foundation parametric design engineering](https://cms.viktor.ai/uploads/Blog_Heijmans_Wind_Turbine_Foundation_8bb28b6967.jpg)


The sun has come up by now, but the mist is still hanging around. Inside the polder near Lage Zwaluwe lie six wind turbine foundations, waiting to be completed. After that, the wind turbine can be anchored on top. Partly a product of digitization and collaboration; and partly of old-fashioned manual labour. 






Cloud-based design application wind turbine foundations on sight

large_Heijmans_VIKTOR_wind_turbine_foundation_application

medium_Heijmans_VIKTOR_wind_turbine_foundation_application

small_Heijmans_VIKTOR_wind_turbine_foundation_application

thumbnail_Heijmans_VIKTOR_wind_turbine_foundation_application

Heijmans_VIKTOR_wind_turbine_foundation_application

Discover how geotechnical engineers developed their own online parametric design application for wind turbine foundations on VIKTOR.ai.

Parametric design web app for Geotechnical engineering | VIKTOR.ai

All design knowledge within one Cloud-based application

We all love user-friendly interfaces. PLAXIS Input app is certainly a good example of such an interface. With little training, beginners can easily create a pad footing model.

Though, it is very common to use mouse to perform actions in PLAXIS Input which can be a tedious process if we are working on a complex model. There are three limitations in the current input interface:

1. Bulk geometry input is time-consuming. Although array option is available, it is limited to elements with the same geometry.
2. When conducting parametric study on the design, we often need to redraw the geometry which is inefficient.
3. Naming of each element needs to be done manually. Naming could be really useful for staging if we have complex models.

This tutorial aims to extend the lesson learned from the [1st tutorial](https://www.viktor.ai/blog/88/python-automate-plaxis). We will use Excel as an interface to input geometry and material properties and create plate elements in PLAXIS.

1. Read values from Excel using Pandas
2. Input geometry with Excel and create plate element
3. Input material properties with Excel and assign material

As before, this tutorial requires the readers have VS Code and PLAXIS environment installed. Follow the instructions from the article below if you're new to this page.

Also, we will also need pandas installed in the PLAXIS environment. Follow the instructions below to install external modules if you haven't done so.

[Tutorial: PLAXIS Output Visualization using Python](https://www.viktor.ai/blog/90/plaxis-output-visualization-using-python)



large_Using Python to Interact with Excel (plaxis input).png

medium_Using Python to Interact with Excel (plaxis input).png

small_Using Python to Interact with Excel (plaxis input).png

thumbnail_Using Python to Interact with Excel (plaxis input).png

Using Python to Interact with Excel (plaxis input).png

Learn how to extract values from an Excel input template and use them to create structural elements in PLAXIS.

Using Python to Interact with Excel (PLAXIS Input)


The ultimate goal of this tutorial is to extract values from an Excel input template and use them to create structural elements in PLAXIS. Therefore, it is important to define the input interface.

We will create an empty excel spreadsheet, call it "Input_param". The interface contains three worksheets:

- Geometry
- Plates
- PlateMatName

![excel input interface.png](https://cms.viktor.ai/uploads/excel_input_interface_51d9ed9883.png)

when you create the worksheets, ensure they follow the same names as shown above as the naming is case-sensitive.

## Geometry

The purpose of the "Geometry" worksheet is to define the coordinates of the structural elements. The values will be used in the "Plates" worksheet in the next section. It includes four columns as shown below:

1. Dist: define the name of x coordinate for specific structural element. For example, "LDWall" defines the x coordinate of left diaphragm wall.
2. X value: assign the actual x coordinates to the corresponding "Dist". For example, we assigned -5 m to "LDWall" which means the left diaphragm wall will start at x = -5 m.
3. RL: define the name of y coordinate for a specific structural element. Similar to "LDWall", "DWallTop" defines the y coordinate of the top of diaphragm wall.

Y value: assign the actual y coordinates to the corresponding "RL". Similar concept as "X value".

![plates worksheet.png](https://cms.viktor.ai/uploads/plates_worksheet_bd03f27a8a.png)

These coordinate definitions will then be used in the "Plates" worksheet.

## Plates

The purpose of this worksheet is to design the properties of multiple plate elements, including:

- Names: as appear in PLAXIS (any name without space, replace space with underline)
- Interface: decide if positive and negative interfaces should be created for the element or not (Y/N)
- Material: decide what material should be assigned to the specific plate (any name without space, replace space with underline)

X1, Y1, X2 & Y2: Since plate in PLAXIS 2D is a line, it requires coordinates of two points. Last four columns are to specify the coordinates using the definitions from the previous sections.

![Plates worksheet 2.png](https://cms.viktor.ai/uploads/Plates_worksheet_2_06e89993ad.png)

Once this worksheet is created, we can move to the last worksheet "PlateMatName".

##PlateMatName

This worksheet aims to define the material properties we specify in the previous section. It should be noted that the name entered here needs to be exactly the same as the names given in the "Plates" worksheet.

There are five inputs for the plate properties:

- EA (kN/m)
- EI (kNm^2/m)
- Unit weight, w (kN/m/m)
- Poisson ratio, v (nu) (-)
- Prevent punching (Y/N)

![PlateMatName worksheet.png](https://cms.viktor.ai/uploads/Plate_Mat_Name_worksheet_2e77ac74a8.png)

These are typical material properties for PLAXIS 2D, just to ensure all input properties are in the correct unit.

The values used in this example aim to create an excavation model. Make sure you have created the excel spreadsheet with the worksheets and values as outlined above.

Once the input file is created, we are ready to move to the next step.

Goal

The main goal of Step 1 is to extract the coordinates definition from the "Geometry" worksheet and store values as dictionary for later stage.


First, we create an empty python file and call it "excel_geometry.py".

## Import Modules and Start Server

Similar to previous tutorial, we will start off by importing relevant modules and start server.

```python
from plxscripting.easy import *
import subprocess, time
import pandas as pd
import openpyxl


###############################################
PLAXIS_PATH = r'C:\Program Files\Bentley\Geotechnical\PLAXIS 2D CONNECT Edition V22\\Plaxis2DXInput.exe'  # Specify PLAXIS path on server.
PORT_i = 10000  # Define a port number.
PORT_o = 10001
PASSWORD = 'SxDBR<TYKRAX834~'  # Define a password.
subprocess.Popen([PLAXIS_PATH, f'--AppServerPassword={PASSWORD}', f'--AppServerPort={PORT_i}'], shell=False)  # Start the PLAXIS remote scripting service.
time.sleep(5)  # Wait for PLAXIS to boot before sending commands to the scripting service.


# Start the scripting server.
s_i, g_i = new_server('localhost', PORT_i, password=PASSWORD)
s_o, g_o = new_server('localhost', PORT_o, password=PASSWORD)


s_i.new()

g_i.gotostructures()
 ```

## Read Excel File

File location: C:\Users\phtsang\Desktop\PLAXIS_V22\Python_automation


File name: spreadsheet we created earlier which is "Input_param.xlsx"

Since we want to extract values from "Geometry", we will use "pd.read_excel()" and specify the worksheet we want to read using "sheet_name".

```python
source=r"C:\Users\phtsang\Desktop\PLAXIS_V22\Python_automation"
file="Input_param"+".xlsx"
geomsheet="Geometry"
df_geom = pd.read_excel(file, sheet_name = geomsheet,engine="openpyxl")
```

Detailed explanation of dictionary and dataframe can be found in this article: [Goodbye Boring PLAXIS Output with Python](https://www.viktor.ai/blog/89/goodbye-boring-plaxis-output-with-python)

## Read Coordinate Definition

Here, I will demonstrate the first approach to read values from dataframe (think of it as an excel table). Below is the table of the "Geometry " worksheet.

![Geometry worksheet.png](https://cms.viktor.ai/uploads/Geometry_worksheet_9416d28ea1.png)

Let's say we would like to extract columns A and B and stores as dictionary with "X value" as heading. It can be done with the following steps:

- First, we need to locate the columns we want using command 'df_geom.columns[]'. For example, 'df_geom.columns[0]' gives the first column name "Dist". Do the same for column "X value".
- Next step is to extract all rows under the specified column names. This is done using a double squared bracket command in pandas: 'df_geom[[df_geom.columns[0], df_geom.columns[0]]]'

![python plaxis input excel.png](https://cms.viktor.ai/uploads/python_plaxis_input_excel_8a00b273d4.png)

- Since we only want to include "X value" in the dictionary, we will set "Dist" as index.

```python
set_index(df_geom.columns[0])
```

- Finally, we use the pandas command 'to_dict()' to convert the dataframe to dictionary.
After combining the code, it should look like:

```python
geom=[]
for i in range(2):
    geom1=df_geom[[df_geom.columns[i*2],df_geom.columns[i*2+1]]].set_index(df_geom.columns[i*2]).to_dict()
    geom.append(geom1)
```

The output of **geom** list looks like:

```python
[{'X value': {'LDWall': -5.0, 'RDWall': 8.0, 'CentreWall': 1.0}}, {'Y value': {'DWallTop': 9.0, 'DWallBot': -6.0, 'Slab1': 6.5, 'BaseSlab': -1.0}}]
```

By creating a dictionary, it allows us to assign values by names easily. For example, I can assign -5 to a point with the following code. This is specifically useful when conducting parametric study as we can intuitively know which coordinates to change.

```python
geom[0]['X value']['LDWall']
```

  Now that we have stored the coordinates, we can then use these values to create structural elements.

Step 1: Read Values from Excel using Pandas

In Step 2, we will extract the values from the "Plates" worksheet and create plate elements accordingly.

Generally, the steps are similar to 1st tutorial except this time we need to create elements based on the information provided in the input table. It involves the following actions:

1. Find unique material names and create empty material
2. Loop through the number of elements from the table
3. Create plate using the user-input name and coordinate definition
4. Check interface requirement (Y/N) and create positive and negative interfaces if required. Give them an appropriate name.
5. Assign material according to the "Material" column from the table

The information involved in the input table is shown below. We will need this to reference our code.

![excel sheet plaxis.png](https://cms.viktor.ai/uploads/excel_sheet_plaxis_5abba233f1.png)

- First, we need to extract values from "Plates" worksheet and stores as "df_plate".

```python
platesheet="Plates"
df_plate = pd.read_excel(file, sheet_name = platesheet,engine="openpyxl")
```

- Then, we need to read the values from "Material" column and find the unique material (i.e. RC1000 and RC600). To read values from specific cells, we can use pandas command 'df_plate.iloc[row, column]'. It follows the same rule list data type in which indexes should be used.

- For example, if we want to get "RightDWall" and "BaseSlab" from the table. We can use 'df_plate.iloc[1,0]' and 'df_plate.iloc[2,0]'. It should be noted that the first row (heading) is skipped when using iloc. If we want to get all rows, we can write 'df_plate.iloc[:,0]'.

- After that, 'dict.fromkeys()' can be used to find the unique values. Combine the code we have.

```python
material=list(dict.fromkeys(df_plate.iloc[:,2].to_list()))
```

- We can then create empty material with the material name given above. After that, we store the material as objects to 'platematerials'.

```python
for i in range(len(material))
    g_i.platemat('Identification',material[i])


platematerials = [mat for mat in g_i.Materials[:] if mat.TypeName.value == 'PlateMat']:
```

- Next step is to loop through all the input elements from the table.

```python
for i in range(df_plate.count()[0])
```

We need to create plate using the user-input values with 'g_i.plate((X1,Y1),(X2,Y2))'. See below two examples of using iloc to extract specific cell values.

geom[0]['X value'][df_plate.iloc[0,3]] locates D2 from the table and hence gives -5 (our definition of LDWall)

geom[1]['X value'][df_plate.iloc[0,4]] locates E2 from the table and hence gives 9 (our definition of DWallTop)

Using this logic, we can create the two points of the plate element.

```python
plate=g_i.plate(
        (geom[0]['X value'][df_plate.iloc[i,3]],geom[1]['Y value'][df_plate.iloc[i,4]]),
        (geom[0]['X value'][df_plate.iloc[i,5]],geom[1]['Y value'][df_plate.iloc[i,6]])
        )
```

- We then change the name of the plate according to the "Name" column.

```python
plate1=plate[-1]
plate1.rename(df_plate.iloc[i,0])
Use if statement to check if interface is required. If 'Y', use 'g_i.posinterface(plate)' and 'g_i.neginterface(plate)' to create interfaces.
if df_plate.iloc[i,1] == 'Y':
    plate2=plate[-2]
    g_i.posinterface(plate2)
    g_i.neginterface(plate2)
```

- Then, I use the PLAXIS command 'rename()' to name the interfaces such that I have "LeftDWall_PosInterface". Having a specific name for each element is particularly useful for staging.

```python
plate2.PositiveInterface.rename(df_plate.iloc[i,0]+'_PosInterface')
        plate2.NegativeInterface.rename(df_plate.iloc[i,0]+'_NegInterface')
```

- Last step is to set material to the plates according to the "Material" column. Remember we have stored the empty material "RC1000" and "RC600" as objects in 'platematerials'. We will need to use if to check the material name provided in the table. If the name of the material matches the existing material object, assign that material to the plate using 'plate.setmaterial()'.

```python
for j in range(len(material)):
     if df_plate.iloc[i,2] == platematerials[j].Identification:
            plate1.setmaterial(platematerials[j])
```

The final script should be as follow:

```python
platesheet="Plates"
df_plate = pd.read_excel(file, sheet_name = platesheet,engine="openpyxl")


#Material
material=list(dict.fromkeys(df_plate.iloc[:,2].to_list()))


for i in range(len(material)):
    g_i.platemat('Identification',material[i])


platematerials = [mat for mat in g_i.Materials[:] if mat.TypeName.value == 'PlateMat']


for i in range(df_plate.count()[0]):
    plate=g_i.plate(
        (geom[0]['X value'][df_plate.iloc[i,3]],geom[1]['Y value'][df_plate.iloc[i,4]]),
        (geom[0]['X value'][df_plate.iloc[i,5]],geom[1]['Y value'][df_plate.iloc[i,6]])
        )
    plate1=plate[-1]
    plate1.rename(df_plate.iloc[i,0])
    if df_plate.iloc[i,1] == 'Y':
        plate2=plate[-2]
        g_i.posinterface(plate2)
        g_i.neginterface(plate2)
        plate2.PositiveInterface.rename(df_plate.iloc[i,0]+'_PosInterface')
        plate2.NegativeInterface.rename(df_plate.iloc[i,0]+'_NegInterface')
    for j in range(len(material)):
        if df_plate.iloc[i,2] == platematerials[j].Identification:
            plate1.setmaterial(platematerials[j])
```

Once the plate elements are created, we can then define our material properties.


Step 2: Input Geometry with Excel and Create Plate Element

In Step 3, we aim to extract the material properties from "PlateMatName" worksheet and assign these properties to the material object (i.e. "RC1000" and "RC600") we created in the previous section.

The information involved in the input table is shown below.

![Input material properties.png](https://cms.viktor.ai/uploads/Input_material_properties_6872bf3ad9.png)

- Similar to the previous step, we first read the values from "PlateMatName" and store them as dataframe.
platematsheet="PlateMatName"

```python
df_platemat = pd.read_excel(file, sheet_name = platematsheet,engine="openpyxl")
```

- As mentioned under "Excel Input Interface", there are five inputs for plate properties: EA (kN/m), EI (kNm^2/m), Unit weight, w (kN/m/m), Poisson ratio, v (nu) (-) and Prevent punching (Y/N).

- We will loop through the rows in the table and use iloc to find each value and assign them to corresponding variables.
for i in range(df_platemat.count()[0]):

```python
   EA = df_platemat.iloc[i,1]
   EI = df_platemat.iloc[i,2]
   w = df_platemat.iloc[i,3]
   nu = df_platemat.iloc[i,4]
   if df_platemat.iloc[i,5] == 'Y':
       Punch=True
   else:
       Punch=False
```

- We then check the "Name" column. If it matches the name of the material object in PLAXIS, we assign the properties to that object.

```python
platematerials = [mat for mat in g_i.Materials[:] if mat.TypeName.value == 'PlateMat'

for j in range(len(platematerials)):
  if df_platemat.iloc[i,0] == platematerials[j].Identification]
```

- Finally, use PLAXIS command 'setproperties()' to set material properties.

```python
platematerials[j].setproperties("MaterialType","Elastic", "w", w, "EA1", EA, "EI", EI, "StructNu", nu, 'PreventPunching', Punch) 
```

The final script is show below:

```python
platematsheet="PlateMatName"
df_platemat = pd.read_excel(file, sheet_name = platematsheet,engine="openpyxl")


for i in range(df_platemat.count()[0]):
    EA = df_platemat.iloc[i,1]
    EI = df_platemat.iloc[i,2]
    w = df_platemat.iloc[i,3]
    nu = df_platemat.iloc[i,4]
    if df_platemat.iloc[i,5] == 'Y':
        Punch=True
    else:
        Punch=False

    platematerials = [mat for mat in g_i.Materials[:] if mat.TypeName.value == 'PlateMat']

    for j in range(len(platematerials)):
        if df_platemat.iloc[i,0] == platematerials[j].Identification:
            platematerials[j].setproperties("MaterialType","Elastic", "w", w, "EA1", EA, 
            "EI", EI, "StructNu", nu, 'PreventPunching', Punch)
```

Run the script with the following.

```python
(PLAXIS) C:\Users\phtsang\Desktop\PLAXIS_V22\Python_automation>python excel_geometry.py
```

You should see the following is created in PLAXIS 2D. As you see in the Model explorer, all plates we created have the names we specify in the input table.


![plaxis input excel.png](https://cms.viktor.ai/uploads/plaxis_input_excel_27c4d20104.png)

In terms of material, RC1000 and RC600 have been created with the properties we specified in the table.

![plaxis input excel 22.png](https://cms.viktor.ai/uploads/plaxis_input_excel_22_32d62c6056.png)

Wonderful! We have just created a user interface for PLAXIS 2D.

Step 3: Input Material Propertires with Excel and Assign Material

That's all for the fourth tutorial on interacting with Excel using Python. After this tutorial, you should be able to obtain inputs from excel and create multiple structural elements, as well as assign material properties in PLAXIS. Here you can find all tutorials to keep improving your automation skills:

[Tutorial 1: Start Using Python to Automate PLAX ](https://www.viktor.ai/blog/88/start-using-python-to-automate-plaxis)

[Tutorial 2: Extract PLAXIS results automatically using Python](https://www.viktor.ai/blog/89/automatically-extract-plaxis-output-with-python)

[Tutorial 3: PLAXIS result visualization using Python ](https://www.viktor.ai/blog/90/plaxis-result-visualization-using-python)

[Tutorial 4: Create a PLAXIS model based on a Excel sheet using Python](https://www.viktor.ai/blog/92/create-a-plaxis-model-based-on-a-excel-sheet-using-python)

If you're interested in hearing more about Python, PLAXIS and workflow automation, feel free to follow [my LinkedIn page](https://www.linkedin.com/in/philip-chin-fung-tsang-207a8b92/). You can also support me by following me on [Medium](https://medium.com/@philip.studio11) where I will provide source code and more general programming techniques in the future.

VIKTOR Blog

Create a PLAXIS model based on a Excel sheet using Python