Creating Apps & Python

Digital transformation

## What is RFEM? 

If you're reading this, you probably already know what RFEM is. If not, let us explain quickly. 

RFEM is a 3D finite element analysis software by Dlubal, made for structural analysis and design and, amongst others, the generation of steel, and concrete structures. With RFEM, structural engineers can easily create everything from simple to complex models and perform structural and dynamic calculations.

## RFEM’s new WebService 

More frequently, engineers start looking for possibilities to customize and automate their structural analyses and designs. That’s why Dlubal created a WebService that offers remote communication with RFEM over web protocols, using Python or C#. It works like an API and enables engineers to use RFEM beyond, and without, its graphical interface. This way, you can automate (part of) your workflow or even create a custom parametric design web application. 

## Why a parametric RFEM web application? 

Imagine that you are an engineer who is designing warehouses, tanks, silos, staircases, or anything else for that matter. All your designs are different to some extent, but not that much. In the end, you follow the same design process to create and validate every design and make a quotation, some reports, and drawings. With a repeating process like this, would it not be great to have a parametric design tool that does all of this for you? And would it not be even greater if your colleagues could also use this tool all by themselves, so you have more time to focus on other, more challenging, and fun parts of your work? 

If this sounds interesting, we recommend using Python to create a parametric design tool like this. Besides automating large parts of only your ‘boring’ (read: repetitive) work, a user-friendly web application with a custom user interface makes it possible for those without Python experience to automate processes as well. On top of that, an online application is a perfect way to distribute your data. You can authorize anyone with an internet connection to use your app, you can be sure that everyone is always using the correct version of the model, and you keep your intellectual property protected, as you won’t have to share any code. You may be thinking: “That sounds awesome but is this not difficult to manage?”. No worries, not with VIKTOR. Just keep reading… 

## What is VIKTOR? 

VIKTOR is an online application development platform that enables you to create your own web applications using nothing but Python. It seamlessly integrates with RFEM, and so much more software products!  

Here are some of the biggest benefits of VIKTOR: 

**Easy & fast:** VIKTOR is like a box of digital building blocks you can assemble to create your own apps. With Python, you can use the full functionality of RFEM and VIKTOR, making it easy to build powerful and user-friendly applications quickly. 

**Accessibility:** Thanks to the user-friendly and intuitive interface, non-specialists can also use your apps. Anywhere in the world. All you need is an internet connection.  

![RFEM & VIKTOR 1.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_1_50940ca15d.png)

</br>

**Hyper automation:** You can build apps customized to fully automate your workflow, connect with multiple software packages, and include all kinds of visualizations, optimization routines, reporting, and much, much more. 

![RFEM & VIKTOR 2.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_2_16c0cbb923.png)

</br>

**Integrate with other software:** Through VIKTOR, it becomes possible to use RFEM together with (several) other products like Excel sheets, other software for structural engineering, soil mechanics, 3D modeling, and the complete Python ecosystem. 

**Focus on what matters:** VIKTOR takes care of all the non-engineering parts of creating apps, like creating a user management system, hosting and cloud infrastructure, database, backups, and security patches.   

## What about detail engineering and specials? 

We know it is very difficult to create a parametric design tool that covers all cases. Fortunately, this is no big deal if your tool does 95% of the work for you. Once the basic design is finished, you can simply download the RFEM models from the application and work on them via the RFEM user interface like usual. The only difference is that this time, you don’t need to start from scratch! 

Here you can see a simplified version of part of the data from RFEM in the VIKTOR interface: 

![RFEM & VIKTOR 3.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_3_36ba2d4521.png)

</br>

Versus the complete model in RFEM: 

![RFEM & VIKTOR 4.png](https://cms.viktor.ai/uploads/RFEM_and_VIKTOR_4_4485d75543.png)

</br>

## The RFEM-VIKTOR app explained 

Here is a short explanation of how this app works.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/802995926?h=4556d93899&badge=0&autopause=0&player_id=0&app_id=58479/embed" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen frameborder="0" style="position:absolute;top:0;left:0;width:100%;height:100%;"></iframe></div>

</br>

1. **Design in VIKTOR:** Using the app starts with the creation of a frame (truss) design in VIKTOR, which can be seen in the view on the right side of the application. This is a generic model with nodes and members. Users can also optimize designs by selecting a minimum and maximum truss height and the number of steps. Based on this input, the application iterates over these parameters and calculates results using RFEM. After all the calculations you can view the results in both a table and a figure. You can then select the best design. 

2. **Complete calculation with RFEM:** When you are happy with your design you can send the model to RFEM for calculations. In RFEM, the design is processed, and all desired information is automatically separated and returned to VIKTOR in a clear overview.  

3. **Analyze:** When RFEM has finished all the calculations, you can choose the values you want to display on your design model. For example, you can do a unity check to determine the forces on the model (displayed with corresponding numbers and color code in the view). On the right side of the application, you can find data with information retrieved from RFEM. 

Calculations take longer the bigger your model is, also more steps for optimization equals more calculation time. Keep that in mind while running the application for yourself. 

## What is next? 

RFEM is a powerful tool for structural analysis, designs, and calculations. Combining the best qualities of RFEM with an intuitive interface on the VIKTOR platform makes the quick and easy generation of structural models and performance of structural analysis and calculations accessible for anyone. No need for any experience with RFEM or programming (with Python)! 

You can now build your own RFEM – VIKTOR app by signing up for a [free VIKTOR account](https://www.viktor.ai/start-building-apps)!  


large_Group 177.png

medium_Group 177.png

small_Group 177.png

thumbnail_Group 177.png

Group 177.png

We have integrated RFEM’s Webservice and API with VIKTOR to make building user-friendly applications for structural design and analysis easier than ever!  

Tailored and accessible structural design and calculation software 

RFEM and VIKTOR: Tailored and accessible structural design and calculation software 

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

VIKTOR updates

Keep reading, this article includes everything you need to know about the VIKTOR platform, our community, and how you can publish and share your own apps for free!

## What is VIKTOR?  

For those who don’t know us yet, VIKTOR is a platform that enables engineers and other domain experts to rapidly create and deploy web apps with nothing but Python. VIKTOR apps are known for their user-friendly interface, and are therefore accessible to a broad audience. This makes VIKTOR the perfect platform to create tools for your organization that virtually anyone can use! 
 
Engineers use VIKTOR to automate workflows and simplify complex tasks, giving them more time and flexibility to analyse different scenarios, reduce risks, and generate better designs. A nice example is this application by COWI for the automation of the design of the world’s longest immersed tunnel that connects Germany to Denmark: [The Fehmarnbelt tunnel](https://www.viktor.ai/customer-cases/33/parametric-design-automation-python-tunnel).  

## Community 

VIKTOR is more than just a tool to create and share engineering apps. We are also a community of like-minded individuals who are passionate about engineering and dedicated to advancing the field.  

> “We invite everyone interested in engineering and Python to join the community and share their apps with the world. Your contribution can make a real difference in advancing the field of digital engineering and inspiring the next generations.” - Anande Bergman, Head of Developer Relations  

We are thrilled to offer this new feature and are looking forward to seeing all the awesome apps created by the community! 

## Create and share your VIKTOR apps, for free! 

For the sake of completeness, let us start the journey of building a web-based app using VIKTOR. Here follows a – albeit condensed – guide to going from an idea of a web app to publishing your application. You can also watch this video to see the steps and follow along. 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/803872551?h=d46b4da04a&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="Tutorial - Publish VIKTOR apps"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

### 1. Getting started

Whether you have a Python script lying around, or a wild idea that still needs to get form in a web interface, to transform your script or idea into a VIKTOR app, you would need to [get your free developer account](https://www.viktor.ai/start-building-apps). 

After creating your account, you will be guided by following the installation steps, experiencing a demo app, and pointing you towards following a tutorial to build your first VIKTOR app.

### 2. Develop your own app 

Now that you have a good understanding of how to build a VIKTOR app, you can take the step to converting your script or idea to a VIKTOR app. Although the demo app and tutorial show you some elements of what the VIKTOR platform provides, there is still much more possible. So, refer to the [documentation ](https://docs.viktor.ai/) to read up on everything that the SDK provides or consult our [Community Forum](https://community.viktor.ai/). 

If not yet clear from the tutorial, you develop your app within the Development tile in the VIKTOR workspaces environment. 

![developer enviroment.png](https://cms.viktor.ai/uploads/developer_enviroment_2e51c0aa12.png)


### 3. Publish your application 

Once you are satisfied with the app you’ve created, it is time to take the next step: get your app online. This process can be defined in three steps: 

1. Create an app on your VIKTOR environment 
2. Publish your code on the created app 
3. Create a workspace to use the app

Now, let us dive into these steps in more detail.

#### 3.1. Create an app

For the VIKTOR platform to be able to host your application, it needs some information. To do that, you need to create an app on your VIKTOR environment. Here are the steps to follow: 

- Go to [cloud.viktor.ai ](https://cloud.viktor.ai/)
- Click on the 'Apps' tab under the 'Develop' section (on the left) 
- Click on the 'Create app' button and follow the instructions. 

![free apps step 1.png](https://cms.viktor.ai/uploads/free_apps_step_1_02e1b4f681.png)

</br>

#### 3.2. Publish your app

Now that you have app “container” available on your VIKTOR environment, you can upload your code from your computer to the cloud. For that, you will open or return to the terminal at the location of your app folder or project. You may recall that you used the `viktor-cli` to install and start your application. You will now use the `viktor-cli` again, though this time for publishing purposes. 

First, check whether the app you just created is listed as available. This can be done by using the following command: 

```bash
viktor-cli apps 
```

This will provide a list of app names on which you can publish your code. 

Next, use the following command to publish: 

```bash
viktor-cli publish --registered-name <app-name> --tag <tag> 
```
So, let’s say that you named your app “my-awesome-app” in the previous step. You would then publish your app using the command: 

```bash
viktor-cli publish --registered-name my-awesome-app --tag v0.1.0 
```

If all goes well, you’ll see the following happen: 

![free apps step 3.png](https://cms.viktor.ai/uploads/free_apps_step_3_48d03a5023.png)

If all went well, you will receive the message that you have successfully published your app. You can also inspect the status of your app by referring to the “Details” of your created app next to the tag you used. 

</br>


#### 3.3. Create a workspace

Congratulations, you have published your first app! But now a few questions pop up: Where can I see my app? What is the link to my app? For this, you need to follow one last step: create a workspace. In your VIKTOR environment, under the “Apps” section, you will see a button on the app that you have created called “Create workspace”. Follow the instructions after clicking on it will create a workspace where your app will reside in. 

![free apps step 2.png](https://cms.viktor.ai/uploads/free_apps_step_2_fe1e2dc3b5.png)

</br>

## How can I share my app?  

You can share your apps by simply copying and sharing your app's URL or using the share button at the top-right corner of your app.   



</br>

## Are my apps public? 

Yes, anyone that has your app's URL can use it. We would love to see a community in which everyone creates and shares apps that others can use too. Sharing your code, however, is not mandatory. But, of course, we really appreciate it if you are open to sharing your code on a public GitHub repository so others can view and use it as well! 

## Which app types can I publish?  

You can publish editor-type apps that consist of a single editor. This means every user gets a ‘fresh’ editor upon entry and data is not saved. This way, your app can easily be used by many people (at the same time)!   

Read more about the different app types [here](https://docs.viktor.ai/docs/create-apps/app-types/). 

## Apps Gallery 

We've already added a couple of public apps to the [Apps Gallery](https://www.viktor.ai/apps-gallery/category/all/1) on our website. If you're looking for inspiration to start new projects, this is a great place to explore, try, and share app templates and the accompanying source code with a wide audience.   

**Your app in the gallery?** 

We'd love to fill the Apps Gallery with awesome apps from the community that can be used as inspiration for other VIKTOR users.  

Please let us know if you are interested in showcasing your work in the gallery by sending an e-mail to support@viktor.ai. 

visual svg.svg

You can now publish your apps for free and share them with anyone you want, even people without a VIKTOR account.

Publish & share awesome engineering apps for free!

Finally everyone can publish & share awesome engineering apps for free!

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

Tutorials

There is potential room for improvement:

1. Create multiple boreholes in a single table.
2. Assign soil properties to each layer automatically.
3. Capability to use repeated soil properties. Of course, this can also be achieved with PLAXIS built-in “.matXdb” to store material database. However, Excel format allows more flexibility to change material properties as per project, as well as having the possibility to link to another master spreadsheet.

This tutorial aims to extend the lesson learned from the 4th tutorial. We will further develop our Excel interface to define soil profiles and assign soil properties in PLAXIS.

1. Read values from Excel using Pandas
2. Input soil depth with Excel and create soil profile
3. Input soil properties with Excel and assign material

As before, this tutorial requires the readers have VS Code and PLAXIS environment installed. If you have not, follow the instructions in the blog [Start Using Python to Automate PLAXIS](https://www.viktor.ai/blog/88/start-using-python-to-automate-plaxis)

Also, we will also need *pandas* installed to the PLAXIS environment. If you haven’t done so, follow the instructions in the blog [PLAXIS output visualization using Python](https://www.viktor.ai/blog/90/plaxis-output-visualization-using-python)

large_Group 167.png

medium_Group 167.png

small_Group 167.png

thumbnail_Group 167.png

Group 167.png

Automate your PLAXIS workflows to build soil profiles and assign correct soil properties.

Automate Soil Profiles in PLAXIS Using Python

Similar to the 4th tutorial, we want to create an Excel input template and create soil profiles in PLAXIS.

We will create an empty excel spreadsheet, call it “Soil_input”. The interface contains two worksheets:

- OHE Ground Profile
- Soil properties

![excel tabs.jpg](https://cms.viktor.ai/uploads/excel_tabs_96cb653361.jpg)

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

## OHE Ground Profile

The purpose of the “OHE Ground Profile” worksheet is to define the name and depth of soil units. These values will be used to create corresponding boreholes in PLAXIS. It involves four input values as shown below:

1. Name: specify the name of each borehole. This row will not be extracted in Python but it’s a good tracker of which boreholes we are working on. For example, column B contains all the input values for “BH1”.
 
2. x coord: define the x coordinate of each borehole.
 
3. Top: define the y coordinate at the top of each borehole. In other words, the top R.L. in terms of geotechnical engineering.
 
4. Soil unit name & layer coordinates: starting from row 4, we will first define the name of soil unit name in column A. Then we input the bottom y coordinate of each unit under each borehole.

It should be emphasised that this template is designed to input the bottom coordinate of each unit. Another important note is that we should input all the units across all the boreholes in column A. Similar to the logic of PLAXIS interface, if we encounter a unit which doesn’t exist in a borehole, we put the same y coordinate as the previous unit.

Take “BH1” as an example, we put 4 m for both “SSIV” and “SSIII”, which means “SSIII” doesn’t exist in “BH1”.

![excel2.webp](https://cms.viktor.ai/uploads/excel2_7204d858e7.webp)

## Soil properties

The purpose of this worksheet is to define the soil properties of each unit. This contains the following columns:

- Name
- Material
- Unit weight (kN/m3)
- Young’s Modulus, E’ (kPa)
- Poisson ratio, v (nu) (-)
- Cohesion, c’ (kPa)
- Friction angle, phi (degree)
- Tensile strength (kPa)
- Interface strength (-)
- K0 auto?: T/F which determines if K0 is calculated automatically in PLAXIS
- K0x = K0y?: T/F to determine if K0x is equivalent to K0y
- K0x (-)
- K0y(-)

![excel3.webp](https://cms.viktor.ai/uploads/excel3_e866b09e00.webp)

These are typical material properties for Mohr-Coulomb model in PLAXIS 2D, just to ensure all input properties are in the correct unit. It should also be noted that this template is only designed for **Drained** condition.

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.


Prepare Your Excel Input Interface

The main goal of Step 1 is to set the soil contour and read the excel input template.

First, we create an empty python file and call it “soil_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

###############################################
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.SoilContour.initializerectangular(-15, -10, 15, 10)
```

##Read Excel File

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

File name: spreadsheet we created earlier which is “Soil_input.xlsx”

Since we want to extract values from “OHE Ground Profile”, 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="Soil_input"+".xlsx"
soilsheet="OHE Ground Profile"
```

Once we have the Excel template set up, we can then use these values to create soil profile.

Step 1: Read Values from Excel Using Pandas

In Step 2, we will extract the borehole values from the “OHE Ground Profile” worksheet and create soil profile accordingly.

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

![excel4.webp](https://cms.viktor.ai/uploads/excel4_6b2c13b035.webp)

We will be using **pandas**‘s methods to extract values from Excel. Detailed explanation can be found in the blog [PLAXIS output visualization using Python](https://www.viktor.ai/blog/90/plaxis-output-visualization-using-python).

First, we need to extract values from “OHE Ground Profile” worksheet and stores as “df_soil”.

```python
#Soil
df_soil = pd.read_excel(file, sheet_name = soilsheet,engine="openpyxl")
```

Then, we need to create the 1st borehole with the X coordinate from the “BH1” column (i.e. df_soil.iloc[0,1]). It should be noted that the first row is skipped from dataframe.

```python
g_i.borehole(df_soil.iloc[0,1]) # Create borehole at x coord
```

Create the first soil layer using PLAXIS command ‘g_i.soillayer(0)’

```python
g_i.soillayer(0) # Create first layer in 1st borehole
```

After that, we will set the top y coordinate of 1st borehole using the command as shown below.

Soillayers[0]: represents the first soil layer. Soillayers[1] will then represent the second layer etc.

Zones[0]: represents the 1st borehole.

Top.set: allows us to specify the top y coordinate of the soil unit. This only needs to be set once for the first layer as the following layers will automatically take the bottom y coordinate from previous layer as their top y coordinate (similar to what PLAXIS does).

```python
g_i.Soillayers[0].Zones[0].Top.set(df_soil.iloc[1,1]) # Set top y coord of 1st Bh
```

Next, we loop through other borehole columns (i.e. BH2–4) to (1) create boreholes with the given x coordinates and (2) set top y coordinates.

```python
for j in range(len(df_soil.columns)-2):
    g_i.borehole(df_soil.iloc[0,j+2]) # X coord for other Bhs
    g_i.Soillayers[0].Zones[j+1].Top.set(df_soil.iloc[1,j+2]) #Top y coord for other Bhs
```
Once we set the top coordinate of each borehole, we then loop through the rest of the layers and set the corresponding bottom coordinates for 1st borehole.

Here we need to check if the loop reaches the last layer. If we don’t reach the last layer, need to create a new layer using the command ‘g_i.soillayer(1)’, otherwise, don’t create a new layer.

```python
for i in range(df_soil.count()[0]-2): # Loop through the number of layers
    if i == df_soil.count()[0]-3: # Don't create new layer if we are at last unit
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1]) #Set bottom y coord for 1st Bh
    else:
        g_i.soillayer(1) #Create new layer if we aren't at last unit
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1])
```

Lastly, we loop through the rest of the boreholes except 1st borehole and set the bottom coordinates with the following code.

```python
for j in range(len(df_soil.columns)-2):
    for i in range(df_soil.count()[0]-2):
        g_i.Soillayers[i].Zones[j+1].Bottom.set(df_soil.iloc[i+2,j+2]) #Set bottom y coord for other Bhs
```

The final script should be as follow:

```python
df_soil = pd.read_excel(file, sheet_name = soilsheet,engine="openpyxl")

g_i.borehole(df_soil.iloc[0,1])
g_i.soillayer(0)
g_i.Soillayers[0].Zones[0].Top.set(df_soil.iloc[1,1])
for j in range(len(df_soil.columns)-2):
    g_i.borehole(df_soil.iloc[0,j+2])
    g_i.Soillayers[0].Zones[j+1].Top.set(df_soil.iloc[1,j+2])

for i in range(df_soil.count()[0]-2):
    if i == df_soil.count()[0]-3:
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1])
    else:
        g_i.soillayer(1)
        g_i.Soillayers[i].Zones[0].Bottom.set(df_soil.iloc[i+2,1])

for j in range(len(df_soil.columns)-2):
    for i in range(df_soil.count()[0]-2):
        g_i.Soillayers[i].Zones[j+1].Bottom.set(df_soil.iloc[i+2,j+2])
```

Once the soil profile is created, we can then define the soil properties for each soil unit.



Step 2: Input soil depth with Excel and create soil profile

In Step 3, we aim to extract the soi properties from the “Soil properties” worksheet and assign these properties to the layer object (i.e. “SZ”, “SSIV” etc) we specified in column A in the previous section.

The information involved in the input table is shown below.

![excel table artikel philip.png](https://cms.viktor.ai/uploads/excel_table_artikel_philip_7b45aeba64.png)

- Similar to the previous step, we first read the values from “Soil properties” and store them as data frame.

```python
soilmatsheet="Soil properties"
df_soilmat = pd.read_excel(file, sheet_name = soilmatsheet,engine="openpyxl")
```

- The typical soil properties for Mohr-Coulomb model are mentioned under “Excel Input Interface”. We will loop through the rows in the table and use iloc to find each value and assign them to corresponding variables.

- To access soil models in PLAXIS using Python, numerical value should be used which is in the order displayed in PLAXIS. For example, the “Linear Elastic” model is represented by 1 and the “Mohr-Coulomb” model is represented by 2, and so forth and so on.

```python
for i in range(df_soilmat.count()[0]):
    name = df_soilmat.iloc[i,1]

    if df_soilmat.iloc[i,2] == 'MC':
        materialmodel=2

    gammaUnsat=df_soilmat.iloc[i,3]
    gammaSat=df_soilmat.iloc[i,3]
    Eref=df_soilmat.iloc[i,4]
    nu=df_soilmat.iloc[i,5]
    cref=df_soilmat.iloc[i,6]
    phi= df_soilmat.iloc[i,7]
    TensileStrength=df_soilmat.iloc[i,8]
```

- Then, we will assign an interface strength ratio if a value is given in the Excel template. To do this, we need to assign “Manual” as a string to ‘InterfaceStrength’ and the given ratio to ‘Rinter’. If no value is provided, “Rigid” will be assigned to ‘InterfaceStrength’ automatically.

```python
if df_soilmat.iloc[i,9] >0:
        InterfaceStrength = 'Manual'
        Rinter=df_soilmat.iloc[i,9]
    else:
        InterfaceStrength = 'Rigid'
```

- Last component of the soil properties is the K0 condition. We need to decide if the K0 determination is “Manual” or “Automatic”. In PLAXIS-Python environment, “Automatic” and “Manual” are represented by 0 and 1 respectively.

- We will also need to check if K0x = K0y based on user input. The checked and unchecked box of “K0x = K0y” are represented by True and False in Python respectively.

```python
  if df_soilmat.iloc[i,10] =='F':
        K0Determination=1
        if df_soilmat.iloc[i,11] == 'T':
            K0PrimaryIsK0Secondary=True
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,12]
        else:
            K0PrimaryIsK0Secondary=False
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,13]
    else:
        K0Determination=0
```

- Then, use PLAXIS command ‘setproperties()’ to set material properties, similar to the 4th tutorial.

```python
    material1 = g_i.soilmat()
    material1.setproperties(
        "Identification",name,
        "SoilModel",materialmodel,
        "gammaUnsat", gammaUnsat,
        "gammaSat", gammaSat,
        "Eref",Eref,
        "nu", nu,
        "cref", cref,
        "phi", phi,
        "TensileStrength",TensileStrength,
        "InterfaceStrengthDetermination",InterfaceStrength,
        "Rinter",Rinter,
        "K0Determination",K0Determination,
        "K0PrimaryIsK0Secondary",K0PrimaryIsK0Secondary,
        "K0Primary",K0Primary,
        "K0Secondary",K0Secondary
    )
```

- After that, we store the soil material as objects to ‘soilmat’.

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

- Last step is to set material to the soil layer according to the “Name” column (i.e. column A) in the “OHE Ground Profile” worksheet. 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 soil layer using ‘Soils.setmaterial()’.

```python
for j in range(df_soil.count()[0]-2):
    for i in range(len(soilmat)):
        if df_soil.iloc[j+2,0] == soilmat[i].Name:
            g_i.Soils[j].setmaterial(soilmat[i])
```

The final script is shown below:

```python
soilmatsheet="Soil properties"
df_soilmat = pd.read_excel(file, sheet_name = soilmatsheet,engine="openpyxl")

for i in range(df_soilmat.count()[0]):
    name = df_soilmat.iloc[i,1]

    if df_soilmat.iloc[i,2] == 'MC':
        materialmodel=2


    gammaUnsat=df_soilmat.iloc[i,3]
    gammaSat=df_soilmat.iloc[i,3]
    Eref=df_soilmat.iloc[i,4]
    nu=df_soilmat.iloc[i,5]
    cref=df_soilmat.iloc[i,6]
    phi= df_soilmat.iloc[i,7]
    TensileStrength=df_soilmat.iloc[i,8]

    if df_soilmat.iloc[i,9] >0:
        InterfaceStrength = 'Manual'
        Rinter=df_soilmat.iloc[i,9]
    else:
        InterfaceStrength = 'Rigid'

    if df_soilmat.iloc[i,10] =='F':
        K0Determination=1
        if df_soilmat.iloc[i,11] == 'T':
            K0PrimaryIsK0Secondary=True
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,12]
        else:
            K0PrimaryIsK0Secondary=False
            K0Primary=df_soilmat.iloc[i,12]
            K0Secondary=df_soilmat.iloc[i,13]
    else:
        K0Determination=0

    material1 = g_i.soilmat()
    material1.setproperties(
        "Identification",name,
        "SoilModel",materialmodel,
        "gammaUnsat", gammaUnsat,
        "gammaSat", gammaSat,
        "Eref",Eref,
        "nu", nu,
        "cref", cref,
        "phi", phi,
        "TensileStrength",TensileStrength,
        "InterfaceStrengthDetermination",InterfaceStrength,
        "Rinter",Rinter,
        "K0Determination",K0Determination,
        "K0PrimaryIsK0Secondary",K0PrimaryIsK0Secondary,
        "K0Primary",K0Primary,
        "K0Secondary",K0Secondary
    )

soilmat=[mat for mat in g_i.Materials[:] if mat.TypeName.value == 'SoilMat']

for j in range(df_soil.count()[0]-2):
    for i in range(len(soilmat)):
        if df_soil.iloc[j+2,0] == soilmat[i].Name:
            g_i.Soils[j].setmaterial(soilmat[i])
```

Run the script with the following:

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

You should see the following is created in PLAXIS 2D. As you see from the soil windows, all boreholes have been created according the inputs from Excel.


![PLAXIS GIF.gif](https://cms.viktor.ai/uploads/PLAXIS_GIF_d64deb774a.gif)

</br>

![PLAXIS screenshot.png](https://cms.viktor.ai/uploads/PLAXIS_screenshot_208d6a8363.png)

</br>

In terms of soil properties, all soil units have been created with the properties we specified in the input table.

![PLAXIS screenshot 2.png](https://cms.viktor.ai/uploads/PLAXIS_screenshot_2_27ed8cb435.png)

</br>

Brilliant! We have just created a soil profile with material definition using a user interface for PLAXIS 2D.

Step 3: Input soil properties with Excel and assign material

That’s all for the fifth tutorial on creating soil profiles including material definitions using Python. After this tutorial, you should be able to obtain soil input from excel and create profile, as well as assign soil 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)

[Tutorial 5: Can the AI chatbot ChatGPT do geotechnical engineering?](https://www.viktor.ai/blog/91/ai-chatGRP-geotechnical-engineering)

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.

What's next?

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.

Create a PLAXIS model based on a Excel sheet using Python

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

With no doubt, Excel is a powerful and well-known software for data visualisation. Though, PLAXIS does not provide full integration with Excel, making the extraction and visualisation process time-consuming. There are three possible areas of improvement in terms of data visualisation:

1. Combine all data into one worksheet for plotting

2. Automate the process of selecting data series in Excel when creating plots

3. Create plots with customised series names and axis titles

This tutorial aims to extend the lesson learnt from the 2nd tutorial. We will extract output from multiple phases and use plots to compare the results. This can be done with the following four steps:

1. Install external module to PLAXIS environment

2. Extract results for multiple phases

3. Compare results at different phases using plots in Excel

4. Formatting with Openpyxl

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. Let's get started!

[Start Using Python to Automate PLAXIS](https://www.viktor.ai/blog/88/python-automate-plaxis)




large_python plaxis cover.png

medium_python plaxis cover.png

small_python plaxis cover.png

thumbnail_python plaxis cover.png

python plaxis cover.png

This article covers three possible areas of improvement in terms of data visualization with PLAXIS using Python. 

PLAXIS output visualization using Python

We will use the same PLAXIS 2D model from 2nd tutorial. Follow the instructions below to set up and calculate the model if you haven't done so.

LINK To SECOND TUTORIAL

Similar to the last tutorial, we will open the PLAXIS file using "open_output.py" such that the API server can be enabled.

As a recap, we use the following code to open the file:

![output tutorial plaxis 3.png](https://cms.viktor.ai/uploads/output_tutorial_plaxis_3_c3cfb23e67.png)

After running the code above, both PLAXIS 2D input and output apps should be opened automatically. From the output app, you should see "SERVER ACTIVE on port 10001".

![tutorial 3 python plaxis.png](https://cms.viktor.ai/uploads/tutorial_3_python_plaxis_4ce336c9ea.png)



PLAXIS example model

Our goal is to extract results from PLAXIS and create comparison plots in excel. In order to do so, we need three external modules:

- Pandas
- Xlsxwriter
- Openpyxl

The process of installing external modules through PLAXIS command prompt has been described in detail in the 2nd tutorial. Make sure you have gone through the process before proceeding with the following steps.

From the last tutorial, both pandas and xlsxwriter should be installed. Note that Python modules are version sensitive, this is because some modules have connections to other modules and hence version updates may cause malfunctions. This is essential to have consistent module dependencies in the PLAXIS environment.

The versions of modules I have used in this tutorial are as follows:

```python 
pandas == 1.5.2
xlsxwriter == 3.0.3
openpyxl == 3.0.9
defusedxml == 0.7.1
```

To check the current version of module, we can use the following command in the PLAXIS command prompt:

```python
python -m pip show pandas
```

![python plaxis 3.png](https://cms.viktor.ai/uploads/python_plaxis_3_abc8125ede.png)

If the versions are not consistent, we can use the following command to upgrade/downgrade the version:

```python
python -m pip install --upgrade pandas==1.5.2
```

Install the rest of the modules:

```python
python -m pip install xlsxwriter==3.0.3
python -m pip install openpyxl==3.0.9
python -m pip install defusedxml==0.7.1
```

In some situations, you may encounter an error when installing defusedxml

```python
ERROR: Could not install packages due to an OSError: [WinError 5] Access is denied
```

If that's your case, try the following code:

```python
python -m pip install --upgrade defusedxml==0.7.1 --user
```

Now that we have installed all the required modules. We can now ready to extract results from different phases in PLAXIS using Python script.




Step 1: Install External Module to PLAXIS Environment

The main goal of Step 2 is to extract results (Bending moment) from three phases in the 'Excavation' model. We will then export the results to Excel in a worksheet called 'combined_Plate_1' with the columns shown below:

![plaxis table.png](https://cms.viktor.ai/uploads/plaxis_table_63ac77a23d.png)

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

## Import Modules and Start Server

```python
from plxscripting.easy import *
import math
import pandas as pd
from openpyxl import load_workbook
from openpyxl.chart import (
    ScatterChart,
    Reference,
    Series,
)
###############################################
PORT_i = 10000  # Define a port number.
PORT_o = 10001
PASSWORD = 'SxDBR<TYKRAX834~'  # Define a password.



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

## Define File Name

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

File name: can be any name you want

```python
EXCEL_PATH=r'C:\Users\phtsang\Desktop\PLAXIS_V22\Script\\'
EXCEL_NAME='Plate_y.xlsx'


FILENAME=EXCEL_PATH+EXCEL_NAME
```

## Input Definition

In this case, we will extract the bending moment for 'Plate_1' from the phases below:
 
- 'Installation of strut [Phase_3]'
- 'Second (submerged) excavation stage [Phase_4]'
- 'Third excavation stage [Phase_5]'

```python
plate=[plt for plt in g_o.Plates[:]]
phase=[p for p in g_o.Phases[:]]


###############################################
#Inputs:
plate_input=['Plate_1']
phase_input=['Installation of strut [Phase_3]','Second (submerged) excavation stage [Phase_4]','Third excavation stage [Phase_5]']
```

Your script should look like:

![code python plaxis.png](https://cms.viktor.ai/uploads/code_python_plaxis_b21b1bae2e.png)


## Result extraction

After pre-processing, we will define a function to extract bending moment (a simplified version from last tutorial) and call it "get_plate()".
def get_plate(plate_o,phase_o):

```python
    plateY=g_o.getresults(plate_o,phase_o,g_o.ResultTypes.Plate.Y, "node")
    plateM=g_o.getresults(plate_o,phase_o,g_o.ResultTypes.Plate.M2D, "node")


    phasename=str(phase_o.Identification).split('[')[0]
    col1='Bending Moment [kNm/m]'+'_'+phasename


    results = {'Y': plateY,col1: plateM}


    plateresults=pd.DataFrame(results)
    plateresults = plateresults.sort_values(by=['Y'],ascending=False)


    return plateresults
```

## Export to Excel

Unlike last tutorial, we want to extract results from multiple phases instead of a single phase. Hence, the "export_excel()" function needs to be modified. Three actions are involved:

1. Loop through the name of the existing phase from the current model

2. Cross-check with the input of the phase by the user (i.e. Phase 3, 4 and 5).

3. Extract results if they match and export to individual worksheet (e.g. Plate_1_Phase_3)

4. Combine the results into a new Dataframe and export to a worksheet ('combined_Plate_1')

These actions can be done with the following code. Let's break it down!

```python
def export_excel(plate_input,phase_input,filename):
    writer = pd.ExcelWriter(filename, engine='xlsxwriter')
    combined=[]
    for i in range(len(phase)):
        for j in range(len(phase_input)):
            if phase[i].Identification == phase_input[j]:
                name=str(phase[i].Identification).split(' [')[1]
                name=name.split(']')[0]
                sheet_name = "%s_%s" % (plate[0].Name, name)
                results = get_plate(plate[0], phase[i])
                combined.append(results)
                results.to_excel(writer,sheet_name=sheet_name,index=False)


    combinedsheet='combined'+'_'+str(plate[0].Name)
    combined=pd.concat(combined, axis=1)
    combined.to_excel(writer,sheet_name=combinedsheet,index=False)
    writer.save()



export_excel(plate_input,phase_input,FILENAME)
```

- We need to first define an empty list 'combined=[ ]'. This allows us to append the extracted results at each phase into a single list such that we can concatenate them in the last step.

- Next step is to loop through the existing phases of the model and see which one matches our input. This is done using PLAXIS command 'phase[i].Identification' which gives the full name of each phase.

```python
for i in range(len(phase)):
        for j in range(len(phase_input)):
            if phase[i].Identification == phase_input[j]:
```

The following code is for naming purpose. For example, 'phase[0].Identification' will give 'Installation of strut [Phase_3]'. I want to get 'Phase_3' which is sitting between the squared bracket [ ]. Then, I combine 'Plate_1' and 'Phase_3' to form the worksheet name.

```python
name=str(phase[i].Identification).split(' [')[1]
name=name.split(']')[0]
sheet_name = "%s_%s" % (plate[0].Name, name)
```

- The bending moment of PLate_1 at each phase is extracted using 'get_plate()' function and stored as results. The results are then appended to the 'combined' list through the method 'combined.append(results)'. Finally, use 'results.to_excel(writer,sheet_name=sheet_name,index=False)' to export results at each phase to individual worksheet.

```python
results = get_plate(plate[0], phase[i])
combined.append(results)
results.to_excel(writer,sheet_name=sheet_name,index=False)
```

- Last four lines aim to combine the results in 'combined' list and export to'combined_Plate_1' worksheet. This is done by pandas's method 'concat()'. It is important to input 'axis=1' as an argument as it tells pandas to combine the results horizontally (by rows). By default, 'axis=0' combines the results vertically (by columns).

```python
combinedsheet='combined'+'_'+str(plate[0].Name
combined=pd.concat(combined, axis=1)
combined.to_excel(writer,sheet_name=combinedsheet,index=False)
writer.save())
```

Your final script should look like:

![python script plaxis 3.png](https://cms.viktor.ai/uploads/python_script_plaxis_3_3e2f10f382.png)

Now that we have extracted results from all phases, we can then proceed with creating plots in Excel using Python.

Step 2: Extract Results for Multiple Phases

Lastly, we will learn about Openpyxl which is a module that allows us to create Excel plot.

We create a function, call it "get_combined_plot()".

- df_inter stores the dataframe obtained from the 'combined_Plate_1'. sheet is where I specify the worksheet 'combined_Plate_1' such that I can create plot there.

```python
def get_combined_plot(filename,sheetname):
    df_inter = pd.read_excel(filename, sheet_name = sheetname,engine="openpyxl")
    wb=load_workbook(filename)
    sheet=wb[sheetname]
```

- Then, create a chart object called 'chart1' which is a scatter chart. After that, we assign axis titles using openpyxl methods (x_axis.title and y_axis.title).

- yvalue stores the Y coordinates of the results using method 'Reference()'.

- position & prow is where I specify the location of the plot

```python
chart1=ScatterChart()
    chart1.x_axis.title = 'Bending Moment (kNm/m)'
    chart1.y_axis.title = 'RL (m)'
    chart={'chart1':chart1} 
    yvalue=Reference(sheet,min_col=1,min_row=2,max_row=len(df_inter)+1)
    position='G'
    prow=1
```

- Then, extract the bending moment values from second column and store them in value.

- Once we have data for x and y axis, we use 'Series()' to create a series and assign it to 'chart1' using 'chart1.series.append(series)'.

```python
  if df_inter.columns.values[1].split(' [')[0] == 'Bending Moment'
        value=Reference(sheet,min_col=2,min_row=2,max_row=len(df_inter)+1)
        series=Series(yvalue,value,title=list(df_inter.columns.values)[1])

        chart1.series.append(series):
```

The code below is mainly for formatting which set plot styles such as height, tick box and legend position etc (like typical excel plot setting). More formatting details are outlined in the official documentation: [Charts](https://openpyxl.readthedocs.io/en/stable/charts/introduction.html)


```python
   charts='chart1'
    chart[charts].height=15
    chart[charts].y_axis.tickLblPos = 'low'
    chart[charts].legend.position = 'b'


    if ord(position)<89 and prow<=2:
        sheet.add_chart(chart[charts], position+str(1))
    position=chr(ord(position)+10)
    prow=prow+1
    wb.save(filename)
```

- The steps above created plot using the first two columns (i.e. 'Y' and 'Bending Moment [kNm/m]_Installation of strut ')

- Final step is to loop through the rest of the columns and add them as two extra series to the existing plot.

- In order to identify if the columns contain Y coordinate or Bending moment, we need to use if-else statement.

- If the column title is 'Y', it will store the column values to yvalue (i.e. y axis). If the column title contains 'Bending Moment', it will store column values to value (i.e. x axis).

```python
   for i in range(3,len(df_inter.columns)+1):
        if df_inter.columns.values[i-1].split('.')[0] != 'Y':
            if df_inter.columns.values[i-1].split(' [')[0] == 'Bending Moment':
                value=Reference(sheet,min_col=i,min_row=2,max_row=len(df_inter)+1)
                series=Series(yvalue,value,title=list(df_inter.columns.values)[i-1])
                chart1.series.append(series)
        elif df_inter.columns.values[i-1].split('.')[0] == 'Y':
            yvalue=Reference(sheet,min_col=i,min_row=2,max_row=len(df_inter)+1)      
    wb.save(filename)
```

The final script is shown below:

```python
def get_combined_plot(filename,sheetname):
    df_inter = pd.read_excel(filename, sheet_name = sheetname,engine="openpyxl")
    wb=load_workbook(filename)
    sheet=wb[sheetname]


    chart1=ScatterChart()
    chart1.x_axis.title = 'Bending Moment (kNm/m)'
    chart1.y_axis.title = 'RL (m)'
    chart={'chart1':chart1} 
    xvalue=Reference(sheet,min_col=1,min_row=2,max_row=len(df_inter)+1)
    position='G'
    prow=1


    if df_inter.columns.values[1].split(' [')[0] == 'Bending Moment':
        value=Reference(sheet,min_col=2,min_row=2,max_row=len(df_inter)+1)
        series=Series(xvalue,value,title=list(df_inter.columns.values)[1])


        chart1.series.append(series)
        
    charts='chart1'
    chart[charts].height=15
    chart[charts].y_axis.tickLblPos = 'low'
    chart[charts].legend.position = 'b'


    if ord(position)<89 and prow<=2:
        sheet.add_chart(chart[charts], position+str(1))
    position=chr(ord(position)+10)
    prow=prow+1
    wb.save(filename)


    for i in range(3,len(df_inter.columns)+1):
        if df_inter.columns.values[i-1].split('.')[0] != 'Y':
            if df_inter.columns.values[i-1].split(' [')[0] == 'Bending Moment':
                value=Reference(sheet,min_col=i,min_row=2,max_row=len(df_inter)+1)
                series=Series(xvalue,value,title=list(df_inter.columns.values)[i-1])
                chart1.series.append(series)
        elif df_inter.columns.values[i-1].split('.')[0] == 'Y':
            xvalue=Reference(sheet,min_col=i,min_row=2,max_row=len(df_inter)+1)      
    wb.save(filename)                    


combinedsheet='combined_Plate_1'
get_combined_plot(FILENAME,combinedsheet)
```

Run the script with the following.

```python
(PLAXIS) C:\Users\phtsang\Desktop\PLAXIS_V22\Script>python plot_plate_combine.py
```

Now if you open the excel spreadsheet in the location you specified earlier and go to 'combined_Plate_1' worksheet. You can see we have extracted the Y coordinate and Bending moment for all three phases. More importantly, we have a plot that contains all results which allow us to compare the bending moment at different phases!

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

Fantastic! You have successfully extracted results from PLAXIS and used them to create a plot in Excel using Python.






Step 3: Compare results at different phases using plots in Excel with Openpyxl

That's all for the third tutorial on PLAXIS output visualisation using Python. By now, you should be able to extract results at multiple phases and create plots in excel for result comparison. This can be further extended to include multiple structural elements at various stages, which means the whole output extraction process can be automated. I will further talk about this in future tutorials.

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.


What's next

PLAXIS result visualization using Python

## Archive your workspaces

Besides creating workspaces yourself, administrators can now also archive old workspaces that are no longer being used.

Archiving a workspace removes it from the workspaces overview, ensuring other users can no longer view or access it. This makes it easier to navigate the list of workspaces that are still in use. Data from an archived workspace will not get deleted. You can always unarchive an already archived workspace.

![archive workspaces.png](https://cms.viktor.ai/uploads/archive_workspaces_959170a48f.png)

</br>

## Publish & share your apps for free


Maybe you have already heard it, but we have some exciting news for the community! From now on, free users can publish and share editor-type apps with anyone they want. This means besides developing apps, you can now also experience how easy it is to share your apps with end-users.

This new feature gives a big boost to our community, enabling all developers to share their creations with the world and providing the opportunity to test and learn from each other's work. 

We are very much looking forward to seeing all the awesome apps from the community being shared. If you want to share your app with a wide audience, we would love to help you out by adding your app to our [Apps Gallery](https://www.viktor.ai/apps-gallery/category/all/1) and promoting it through our network. Let us know by sending a mail to support@viktor.ai.

![share solar panel app.jpg](https://cms.viktor.ai/uploads/share_solar_panel_app_9b378dff36.jpg)

</br>

[![CTA_Join the community](https://cms.viktor.ai/uploads/CTA_Join_the_community_22d97b332e.svg)](https://community.viktor.ai/)

</br>


## View historical jobs in the job log

We are introducing the job log: a new feature in which the results of the last 5 historical jobs are shown. The job log contains details on the starting time of the job, when it was completed, and whether it was successful or not. This allows you to report problems on old non-successful jobs.

![icons 2.png](https://cms.viktor.ai/uploads/icons_2_5745764ac9.png)
![job_log.png](https://cms.viktor.ai/uploads/job_log_ef8293da13.png)

</br>

## Other changes

**SDK**

- SDK version 13.8.0 is now available

**PLATFORM**

- Fixed text not wrapping properly in map popups 
- Fix that workspace-admin can now also rename workspace 

**CLI**

- CLI v0.29.0 is now available 
- Added SDK version to output of ‘apps’ command 
- Added app type, SDK version and python version to output of ‘describe’ command 
- Updated the ‘install’ command to use additional environment variables during installation 
- Support for defining VIKTOR Python dependency in requirements.txt without a leading hashtag- Improved help 'create-app' command
- Bugfix for reload not working for app folder names  starting with "test"

Newsletter img (5).svg

Archiving of workspaces, an overview of historical jobs in the job log, and free publishing & sharing of your apps!

VIKTOR Blog

What's new in VIKTOR? (February 2023)