Creating Apps & Python

Digital transformation

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.

What's next?

Create a PLAXIS model based on a Excel sheet using Python

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

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

Tutorials

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

PLAXIS, without a doubt, is a powerful FE software. As Geotechnical engineers, we want to focus on the analysis and spend less time on post-processing. Python provides the most extensive possibilities for automating output extraction and visualisation, thanks to the modules developed by the open-source communities. Some common modules include:

- Pandas
- Xlsxwriter
- Matplotlib
- Seaborn

large_1668571956103.png

medium_1668571956103.png

small_1668571956103.png

thumbnail_1668571956103.png

1668571956103.png

Use Python script to extract outputs from a structural element in PLAXIS 2D. Read more on VIKTOR.ai.

Extract PLAXIS results automatically using Python

The ultimate goal of this tutorial is to show you how to use Python script to extract outputs from a structural element in PLAXIS 2D. This can be done with the following four steps.

1. Use IDE to open PLAXIS Output
2. Install external module to PLAXIS environment
3. Extract Plate results from PLAXIS
4. Export as excel spreadsheet

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-staging.viktor.ai/blog/88/python-automate-plaxis)



I used a PLAXIS 2D model published by the official Bentley website as shown below.

In the link, download the command log file from V22.01. To the best of the author's knowledge, the Python commands have changed significantly from V21 to V22. Hence, make sure you got PLAXIS V22 or above (V22.01 and V22.02) installed to ensure the Python script in this tutorial works properly.

[PLAXIS 2D Tutorial 03: Submerged construction of an excavation](https://communities.bentley.com/products/geotech-analysis/w/wiki/45557/plaxis-2d-tutorial-03-submerged-construction-of-an-excavation)

![downloads.png](https://cms.viktor.ai/uploads/downloads_7da86200bc.png)

Once you have run the command using "Run commands...", you should be able to see the following geometry.

![example model.png](https://cms.viktor.ai/uploads/example_model_3b2b942dfb.png)


This example models the construction of an excavation which consists of a diaphragm wall (Plate element). Our goal is to extract the results of the plate element.

Calculate the model and we are ready to extract the results using Python.


PLAXIS Example Model

Unlike first tutorial, this time we will open a PLAXIS file we just downloaded and hence the code for starting the server needs to be slightly modified. You will need to save the calculated model in a preferred working directory.


My location of the PLAXIS file:

C:\Users\phtsang\Desktop\Current_Projects\LinkedIn\Blog_2\Excavation

I will first create an empty python script called "open_output.py".

After that, we write the code below to the python file. The code is very similar to the one from the first tutorial but this time we will be opening an existing PLAXIS file. In order to do this, we made the following three changes:

1. Since this time we need to open a PLAXIS file, the working directory of the file needs to be specified which is stored as "FILE_PATH".
2. We then open the file using PLAXIS command "s_i.open(FILE_PATH)".
3. To open PLAXIS output, we write "g_i.view(g_i.Phases[1])" which allows us to view the results of Phase_1's calculation.

```python
from plxscrpting.easy import *
import subprocess, time
import os


###############################################
PLAXIS_PATH = r'C:\Program Files\Bentley\Geotechnical\PLAXIS 2D CONNECT Edition V22\\Plaxis2DXInput.exe'  # Specify PLAXIS path on server.
FILE_PATH = r'C:\Users\phtsang\Desktop\Current_Projects\LinkedIn\Blog_2\\Excavation'  # Specify PLAXIS file location and name
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.
# global g_i, s_i
s_i, g_i = new_server('localhost', PORT_i, password=PASSWORD)
s_o, g_o = new_server('localhost', PORT_o, password=PASSWORD)


s_i.open(FILE_PATH)


g_i.gotostages()
g_i.view(g_i.Phases[1])
```

To test that the code above is working properly, we will run "open_output.py" in the terminal as shown below. Type "python open_output.py" and click Enter.

![python open output.png](https://cms.viktor.ai/uploads/python_open_output_35edc0028a.png)

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

![server active on port 10001.png](https://cms.viktor.ai/uploads/server_active_on_port_10001_58024c1994.png)

We now have the PLAXIS API connected, we are ready to move to next step.

Step 1: Use IDE to Open PLAXIS Output


When using the PLAXIS scripting environment it is common to use Python modules allowing for extending the functionality of a Python script. Since our goal is to extract results from PLAXIS and export to excel spreadsheet, we need two external modules:

- Pandas
- Xlsxwriter

These modules can be installed through PLAXIS command prompt window as shown in the steps below. Before proceeding, make sure you have gone through Step 1 with PLAXIS Input opened.

Go to the menu option *Expert > Python > Command* prompt. This will open the Windows Command prompt with the PLAXIS set as the current environment.

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

Change the directory to the PLAXIS Python Distribution folder. This can be done with the following command:

```python
pushd C:\ProgramData\Bentley\Geotechnical\PLAXIS Python Distribution V2\python\Lib\site-packages
```

![command prompt plaxis python.png](https://cms.viktor.ai/uploads/command_prompt_plaxis_python_07732a8a80.png)

In the Command prompt you can now install any new Python modules using the command shown in the example below.

For instance, if you want to install the pandas module:

```python
python -m pip install pandas
```

![command prompt install pandas.png](https://cms.viktor.ai/uploads/command_prompt_install_pandas_d077d8de21.png)

Also, install the xlsxwriter module:

```python
python -m pip install xlsxwriter
```

Now that we have installed all the required modules. We can then extract results from PLAXIS using Python script.



Step 2: Install External Module to PLAXIS Environment

Our main goal Step 3 is to extract four result types for the plate element (Diaphragm wall) in the last phase (Third excavation stage [Phase_5]). The result types we will extract are:

- Y Coordinates
- Shear
- Bending Moment
- Axial Force

In Step 4, we will then export the results to excel spreadsheet with the columns shown below.

![spreadsheet.png](https://cms.viktor.ai/uploads/spreadsheet_2449f0cca3.png)

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

### Import Modules and Strat Server

We need to make sure the API is connected, as well as importing the modules we installed earlier.

```python
from plxscripting.easy import *
import subprocess, time
import math
import pandas as pd
import os
import xlsxwriter


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

Since we need to export the results to excel, we need the specify the exported file location and its name.

File location: make sure there is double slash (\\) after your working directory

File name: can be any name you want

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

FILENAME=EXCEL_PATH+EXCEL_NAME
```

### Input Definition

After that, we will input the structural element and the corresponding phase we would like to extract. In this case: 'Plate_1' and 'Third excavation stage [Phase_5]'.

The code underneath is to find the existing plate elements and phases in the model and store them as a list.

```python
plate_input=['Plate_1'] # Input by user
phase_input=['Third excavation stage [Phase_5]'] # Input by user

###############################################
#Exisiting model element:

plate=[plt for plt in g_o.Plates[:]] # Loop through the plate object in existing model
phase=[p for p in g_o.Phases[:]] # Loop through all available phases
```

Two important concepts here:

**For loop:** the action of finding existing elements in PLAXIS requires for loop. This is a very common command in programming. For example in "plate", we have:

```python
for plt in g_o.Plates[:]
```

This line means we are looping through all the plate elements in "g_o.Plates[:]" (which is how PLAXIS stores objects) and naming it as "plt".

**List**: As mentioned in the first tutorial, it is common to store values in a list which is represented by a square bracket [ ]. The syntax has slightly changed compared to the first tutorial as it has been simplified.

This line:

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

Can be extended as: 

```python
plate=[]

for plt in g_o.Plates[:]

   plate.append(plt) 
```

Both code will give the same result but the first one is much neater and is commonly used in Python.

So far, your script should look like:

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


### Result Extraction

After the pre-processing as mentioned above, we can start extracting plate results. To do that, we will define a function to extract results, call is "get_plate()". Few key points here:

- "g_o.getresults()" is the PLAXIS command we use to extract results. It takes in plate element, the corresponding phase and the result type you look for. PLAXIS has its own syntaxes for different result types. In our case:

Y coordinate = ResultTypes.Plate.Y

Shear = ResultTypes.Plate.Q2D

Bending Moment = ResultTypes.Plate.M2D

Axial Force = ResultTypes.Plate.Nx2D

- The next few lines are to create column names as specified in the target spreadsheet.
Results are then stored as "results". Here I introduce a new data type called Dictionary in Python which is represented by curly bracket { }. Dictionary is particularly useful when you want to create a table, it contains a key-value pair. For example:

'Y' is the **key** of dictionary

plateY is the value of dictionary. An array of values can be stored to the specified key.

- Once the dictionary is created, the next line convert dictionary to dataframe. Dataframe is one of most common data structure we use in Python. You can interpret it as a table in excel. This is done by running command: "pd.DataFrame(results)"

- I also sort the results using Y coordinate in a descending order

Make sure the indentation is correct as shown in the screenshot below.

```python
def get_plate(plate_o,phase_o):

    plateY=g_o.getresults(plate_o,phase_o,g_o.ResultTypes.Plate.Y, "node")
    plateQ=g_o.getresults(plate_o,phase_o,g_o.ResultTypes.Plate.Q2D, "node")
    plateM=g_o.getresults(plate_o,phase_o,g_o.ResultTypes.Plate.M2D, "node")
    plateAxial=g_o.getresults(plate_o,phase_o,g_o.ResultTypes.Plate.Nx2D, "node")    

    phasename=str(phase_o.Identification).split('[')[0]
    col1='Shear [kN]'+'_'+phasename
    col2='Bending Moment [kNm/m]'+'_'+phasename
    col3='Axial Force [kN]'+'_'+phasename

    results = {'Y': plateY, col1: plateQ,col2: plateM,col3: plateAxial}


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


    return plateresults
```





Step 3: Extract Plate Results from PLAXIS

Lastly, we will export the dataframe we created to excel.

We create a function, and call it "export_excel()".

- writer is to use the xlsxwriter module we installed to export excel
- name & sheet_name is where I create a worksheet name with format "Plate_1_Phase 5".
- Then, I use the function "get_plate()" we created in earlier to generate the dataframe and store as "results". It should be a dataframe which can then be export to excel using pandas command "results.to_excel()".

```python
def export_excel(plate_input,phase_input,filename):
    writer = pd.ExcelWriter(filename, engine='xlsxwriter')


    name=str(phase[5].Identification).split(' [')[1]
    name=name.split(']')[0]
    sheet_name = "%s_%s" % (plate[0].Name, name)
    results = get_plate(plate[0], phase[5])
    results.to_excel(writer,sheet_name=sheet_name,index=False)
    writer.save()


export_excel(plate_input,phase_input,FILENAME)
```

Run the script with the following.

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

You will see the results we look for have been automatically extracted as shown in the command window.

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

Now if you open the excel spreadsheet in the location you specified earlier, you can see we have extracted the Y coordinate, Shear, Bending moment and Axial force as we want.

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

Well done! You have just extracted results from PLAXIS using Python script.



Step 4: Export As Excel Spreadsheet

That's all for the second tutorial on extracting PLAXIS output using Python. By now, you should be able to extract output for a single structural element from PLAXIS. In future tutorials, I will show how to extract results for multiple structural elements and different structure types such as interfaces and embedded beams.

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.

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

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

> As an engineer, we always want to automate the boring and engineer the awesome.

In this context, programming, more specifically **Python**, is the best available tool to automate repetitive tasks.
Python has been around for many years but only recently get recognised by the larger community because of its ease of use, large extent of applications and support by huge open-source communities. It is a great programming language for data science, workflow automation and web development.

PLAXIS has a well-developed Application Programming Interface (API) which allows users to operate PLAXIS through programming. More details can be seen on the official [Bentley website](https://communities.bentley.com/products/geotech-analysis/w/wiki/45393/api-python-scripting---plaxis).




Linkedin post Export 1200x1200 - Grasshopper.svg

Why Python is the best available tool to automate repetitive tasks in PLAXIS and how you can do this too. 

Start Using Python to Automate PLAXIS

Although the PLAXIS Python API has been developed for a long time, there is still a lack of thorough guidelines to introduce this technique to geotechnical engineers.
This tutorial assumes readers **have zero experience in programming** so I will show how to set up the programming environment from scratch.

*Disclaimer*

There have been a lot of paid courses which teach engineers to use the built-in Python editor in PLAXIS which I agree is quite well-developed. But I personally prefer to use my own programming environment to write scripts because of the following three reasons:

1. A well-developed Integrated Development Environment (IDE) is more user-friendly for coding as it picks up wrong syntaxes and identifies bugs, which is crucial for beginners.

2. Built-in Python editor has less flexibility to import user-developed modules. In the future when you have more programming experience, you will find that a lot of time we need to separate out the functions we write as a module which makes our script less busy. This can be well managed in IDE.

3. We don't want to keep the scripts to ourselves but to share them among colleagues. IDE provides perfect integration with code-sharing platforms such as GitHub, GitLab etc.

The ultimate goal of this tutorial is to show you how to use Python script to create your first structural element in PLAXIS 2D. This can be done with the following four steps.

1. Install Integrated Development Environment (IDE)
2. Activate PLAXIS Environment
3. Connect to PLAXIS API
4. Create first plate element

Lastly, this tutorial assumes readers are using Windows OS and have PLAXIS 2D V22 installed. So let's get started!


IDE is a software application which provides comprehensive facilities for programming, usually consisting of source code editor, build automation tools and debugger.

There are various options for IDE, such as Visual Studio Code (VS Code), PyCharm, Jupyter Notebook etc, which have no difference in functionality and are completely up to users' preference for the choice of IDE. This instruction demonstrates the installation of VS Code.

Install Visual Studio Code (VS Code) with the following instruction:

Download the latest VS code for Windows: https://code.visualstudio.com/download

![download visual studio code.png](https://cms.viktor.ai/uploads/download_visual_studio_code_2825af23a6.png)

Follow the installation wizard, check the options as shown below.

![installation wizard.png](https://cms.viktor.ai/uploads/installation_wizard_f36f70c577.png)

Once installed, open VS Code on Desktop. You will see the following interface.

![vs code on desktop.png](https://cms.viktor.ai/uploads/vs_code_on_desktop_05391e5ca8.png)

Add your work folder in Explorer by right-clicking Explorer -> Add Folder to Workplace...

![add to work folder.png](https://cms.viktor.ai/uploads/add_to_work_folder_e315328cf0.png)

</br>

Step 1: Install Integrated Development Environment (IDE)

Once your virtual environment and IDE are set up, you can start writing Python scripts within IDE.
To write a Python script, you should follow the process below:

- Open IDE terminal
- Direct to your preferred work folder (in terminal)
- Activate PLAXIS Python Environment
- Create .py file in the folder

### Open IDE terminal

Click the highlighted icon:

![click highlighted icon.png](https://cms.viktor.ai/uploads/click_highlighted_icon_94691be353.png)

You will see the Shell comes up:

![shell comes up.png](https://cms.viktor.ai/uploads/shell_comes_up_b91fe2812a.png)

Head to "Terminal" tab. You should see that you are in the work folder.

![terminal tab.png](https://cms.viktor.ai/uploads/terminal_tab_12cad12cf6.png)

</br>

### Direct to your preferred work folder

If it is not the correct work folder. You can type:

cd <your work folder path>

![workfolder.png](https://cms.viktor.ai/uploads/workfolder_7503237247.png)

For example, I am currently in Current Projects folder and I want to locate to 00_Digitalisation->01_Python-FE. The folder path is:

C:\Users\phtsang\Desktop\Current_Projects\00_Digitalisation\01_Python-FE

In IDE terminal:

![IDE terminal.png](https://cms.viktor.ai/uploads/IDE_terminal_115ec8375c.png)

It should show the correct folder name as shown above.

### Activate PLAXIS Python Environment

To activate the PLAXIS Python environment, we will need to select PLAXIS built-in python interpreter which contains all the functionalities required to operate PLAXIS. The python interpreter is automatically installed when PLAXIS is installed.

Location of the Python interpreter:

C:\ProgramData\Bentley\Geotechnical\PLAXIS Python Distribution V2\python\python.exe

To select a specific environment, use the Python: Select Interpreter command from the Command Palette (Ctrl+Shift+P). Click "Enter interpreter path..." , then browse the python.exe in the location mentioned above.

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

In the Terminal tab, select Command Prompt in the drop-down list as highlighted below.

![dropdown list.png](https://cms.viktor.ai/uploads/dropdown_list_b16aa56c17.png)

You should see (PLAXIS) in front of the working directory if the environment is activated successfully.

![plaxis working directory.png](https://cms.viktor.ai/uploads/plaxis_working_directory_0c8c2cdaa3.png)

</br>

### Create .py file in the folder

Click the New file icon:

![new file.png](https://cms.viktor.ai/uploads/new_file_70ac1ae2f9.png)

Create .py file as below:

![create py file.png](https://cms.viktor.ai/uploads/create_py_file_10f80e2ea7.png)

Next section we will start connecting to the PLAXIS API.

Step 2: Activate PLAXIS Environment

I will first create an empty python script and call it "create_plate.py" as shown below.

![empty python script.png](https://cms.viktor.ai/uploads/empty_python_script_a13ca39b97.png)

After that, we write the code below to the python file. Three things are doing here:

1. Import modules from PLAXIS Python environment. In order to operate PLAXIS with Python script, we need to use the functions (more commonly known as methods in terms of programming) developed by PLAXIS. The module we import is called "plxscripting.east"
2. Open PLAXIS 2D desktop application. The path of the Plaxis2DXInput.exe should be the same as listed below if default installation path is adopted. If that's not the case, simply change the path to the correct directory. Port number and Password can stay as default but you can select any values you want.
3. Start the PLAXIS scripting server with the pre-defined port number and password.

```python
from plxscripting.easy import *
import subprocess, time

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 (up to user choice).

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


To test that the code above is working properly, we will run "create_plate.py" in the terminal as shown below. Type "python create_plate.py" and click Enter.

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

The PLAXIS 2D app should be opened automatically. If the server is configured correctly, you should see "SERVER ACTIVE" as shown below.

![plaxis 2d app.png](https://cms.viktor.ai/uploads/plaxis_2d_app_ace0e2ed88.png)

Now that we connect to the PLAXIS API server, we can then create a plate element in PLAXIS using Python script.


Step 3: Connect PLAXIS API

In this part of the tutorial, we aim to create a plate element with positive and negative interfaces. Then we assign "Concrete" material to the element.

First, we define the material name and geometry. I plan to create a line from (-10,0) to (10,0). The square bracket [ ] is called list in python, which is a very common data type to store values. To access the values stored in a list, it is called in the following syntax:

If I want to access the coordinates of first point, I use

x coordinate = -10 = first_point[0]

y coordinate = 10 = first_point[1]

0 and 1 here called index which always starts from 0.

Then we create the material and assign it to the plate material list. To create plate material, the command "g_i.platemat()" is used. The code underneath is to assign the plate object to a list.

```python
material=['Concrete']
first_point=[-10,0]
second_point=[10,0]

# Create material
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']
```

After that, we create plate element with "g_i.plate()" based on the pre-defined coordinates.

```python
plate=g_i.plate(
    (first_point[0],first_point[1]),
    (second_point[0],second_point[1]),
    )
plate1=plate[-1]
```

Then, create interfaces using "g_i.posinterface()" and "g_i.neginterface()".

```python
plate2=plate[-2]
g_i.posinterface(plate2)
g_i.neginterface(plate2)
```

Finally, set "Concrete" to the plate element.

```python
plate1.setmaterial(platematerials[0])
```

If you rerun the script, you will see the following is created in PLAXIS. As you see, the "Concrete" material is created and is assigned to the plate element we created.

![plaxis python app concrete.png](https://cms.viktor.ai/uploads/plaxis_python_app_concrete_11770a0659.png)

Congratulations! You have just created your first plate element in PLAXIS using Python!


Step 4: Create First Plate Element

Of course, we often need to create more than one structural element in PLAXIS. In this section, we aim to create four plate elements which form a rectangle with the following coordinates:

(-10,0), (-10,10), (10,10) and (10,0)

We need to first create a list (call it 'df_plate') which specifies the coordinates of each plate element. The first and second points are stored as (x1,y1) and (x2,y2) respectively. Within the list, I used a new data type called **Dictionary** which is very commonly used in Python. More on that in the next tutorial.

```python
df_plate=[{'x1':-10,'y1':0,'x2':10,'y2':0},{'x1':-10,'y1':10,'x2':-10,'y2':0},{'x1':-10,'y1':10,'x2':10,'y2':10},{'x1':10,'y1':10,'x2':10,'y2':0}]
```
Since this time we need to access multiple elements in a list, we will utilise a concept called **for loop**. It allows us to loop through the elements and create points in PLAXIS accordingly. This can be done with the following code:

```python
for i in range(len(df_plate)):
    plate=g_i.plate(
        (df_plate[i]['x1'],df_plate[i]['y1']),
        (df_plate[i]['x2'],df_plate[i]['y2']),
        )
    plate1=plate[-1]
```

Your final script should look like:

```python
# Plate
#Material name and geometry
material=['Concrete']

df_plate=[{'x1':-10,'y1':0,'x2':10,'y2':0},{'x1':-10,'y1':10,'x2':-10,'y2':0},{'x1':-10,'y1':10,'x2':10,'y2':10},{'x1':10,'y1':10,'x2':10,'y2':0}]

# Create material
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']

#Create Plate
for i in range(len(df_plate)):
    plate=g_i.plate(
        (df_plate[i]['x1'],df_plate[i]['y1']),
        (df_plate[i]['x2'],df_plate[i]['y2']),
        )
    plate1=plate[-1]

#Create Interface

    plate2=plate[-2]
    g_i.posinterface(plate2)
    g_i.neginterface(plate2)
#Set Material

    plate1.setmaterial(platematerials[0])
```
If you rerun the script, you will see the following is created in PLAXIS. Now, you are able to create multiple elements using Python script.

![4 plates in plaxis](https://cms.viktor.ai/uploads/4_plates_in_plaxis_12b7f9dc44.webp)


Bonus: Create 4 Plates Elements

That's the end of the first tutorial on automating PLAXIS with Python. 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 updates

## Improved input validation

We have improved the input validation on multiple parts! See how you can block actions on invalid fields, mark fields as invalid, and easily validate steps. 

### Block actions on invalid fields

In the future, limitations you already annotated (like min/max) will block the user from performing any subsequent actions (such as clicking a button, generating a view, or moving to the next step). Learn how you can activate this now in the [documentation](https://docs.viktor.ai/docs/create-apps/user-input/input-validation/#generic-field-constraints).

### Mark fields as invalid

When you are performing input validation, you can mark fields as invalid. This makes it a lot easier for users to correct mistakes. Visit the [documentation](https://docs.viktor.ai/docs/create-apps/user-input/input-validation/#specific-input-validation) to learn more about this feature.

### Step validation

Enable validation code to prevent users from moving to the next step in case their input is not valid. Visit the [documentation](https://docs.viktor.ai/docs/create-apps/layout-and-styling/steps/#validation-of-user-input) for more information on how to enable step validation.

![step_validation2.png](https://cms.viktor.ai/uploads/step_validation2_9bccc480e0.png)

</br>

## Seamless developer onboarding

We have created a new and seamless onboarding experience in which developers are guided through all the necessary steps to start building apps. In only 5 minutes, you can install VIKTOR and start the demo application!
 
If you haven't installed VIKTOR yet, do not hesitate any longer and log in to [get started](https://docs.viktor.ai/docs/getting-started/).

![Seamless onboarding.gif](https://cms.viktor.ai/uploads/Seamless_onboarding_37a9ef025e.gif)

</br>

## View developer statistics in the activity dashboard

To give better insight into the adoption of VIKTOR within your company, we have added the activity of the developers to the activity dashboard. Here you can find data on the number of developers and how often they log in. 

![Activity Dashboard.png](https://cms.viktor.ai/uploads/Activity_Dashboard_aa77c41d46.png)

</br>

## Other changes

**SDK**

- SDK version 13.7.0 is now available

</br>

**PLATFORM**
- Fixed the file field upload button to be disabled when the editor is locked 
- Fixed that users no longer only have read access on editor-type apps 
- Fixed map view crash when trying to zoom in while already at max zoom level after view load 
- Removed development workspaces from workspaces activity dashboard 
- Fixed that app version manifest are assigned to new workspaces 
- Fixed possible app type mismatch for new app versions 
- Added missing dutch translation on the admin page 
- Custom marker size supported in ```GeoJSONView```
- Daily active users (per day/week/month) calculation based on workspace usage instead of logins on the environment
- Map tile and image provider switched to ESRI

</br>

**WORKER**

- Worker version 5.3.1 is now available 
- Fixed bug where Excel worker raised an error when a timeout was encountered 

</br>

**CLI**

- CLI version 0.26.1 is now available
- Added get-started command for new onboarding flow
- Added support for Python installed through Windows App Store 


large_Newsletter img (2).jpg

medium_Newsletter img (2).jpg

small_Newsletter img (2).jpg

thumbnail_Newsletter img (2).jpg

Newsletter img (2).jpg

Improved input validation, seamless developer onboarding, and track developer in the activity dashboard.

VIKTOR Blog

What's new in VIKTOR (January 2023)