Creating Apps & Python

Tutorials

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)



Goal

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.

What's next

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

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

## Python and Excel in VIKTOR

With VIKTOR, it is possible to create a web app with Python that integrates with any desired software, just like Excel. This web app functions as a single point of truth with a central database that always contains the latest version of a project (with version history) that all stakeholders can access.

We have written open-source code as an example of such a VIKTOR application for the automated calculation of a simply supported beam under load with Excel. 

## Using the functionality

There are two ways in which you can use the functionality: 

- With VIKTOR, out-of-the-box, using our [free version](https://www.viktor.ai/start-building-apps). 
- Without VIKTOR, in that case you integrate the open-source code with your own Python code 

For a full tutorial on this sample app click [here](https://docs.viktor.ai/docs/guides/tutorials/calculation-spreadsheet). 

This is a snippet of the functionality’s code from the VIKTOR [GitHub repository](https://github.com/viktor-platform/sample-spreadsheet): 

```python
def get_evaluated_spreadsheet(self, params): 
  inputs = [ 
     SpreadsheetCalculationInput('L', params['general']['beam']['length']), 
     SpreadsheetCalculationInput('W', params['general']['beam']['width']), 
     SpreadsheetCalculationInput('H', params['general']['beam']['height']),
     SpreadsheetCalculationInput('E', params['general']['beam']['E']),
     SpreadsheetCalculationInput('aw', params['general']['beam']['aw']), 
     SpreadsheetCalculationInput('wa', params['general']['beam']['wa']),
  ] 
  sheet_path = Path(__file__).parent / 'beam_calculation.xls'
  sheet = SpreadsheetCalculation.from_path(sheet_path, inputs=inputs) 
  result = sheet.evaluate(include_filled_file=True) 
  
  return result 
```

Here you can see it is very easy to send input to your Excel sheet. It is required to have a tab in Excel called ‘viktor-input-sheet'. To get results, you use the evaluate() method. Here, VIKTOR retrieves output from the ‘viktor-output-sheet' Excel tab. 
 
The documentation for the `SpreadsheetCalculation` class can be found [here](https://docs.viktor.ai/docs/guides/services/spreadsheet-calculator) 

In the video, you can see how a simply supported beam under load is calculated through an integration with a spreadsheet in a VIKTOR application in the [demo environment](https://www.viktor.ai/demo-environment). 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/703176976?h=c6d27796c9&autoplay=1&loop=1&autopause=0&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="Automating calculations in Excel with Python in VIKTOR"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

</br> 

## Calculating a beam in 3 steps 

As you can see in the video, the process of automatically calculating a simply supported beam under load consists of 3 steps. 

1. **Insert general information**. Provide information about the beam (length, the width, height, and modulus of elasticity) and loads (starting point and distributed load amplitude).   
2. **Generate results**. View the maximum deflection and maximum bending stress, a schematic visualization, and a 3D visualization of the beam and loads.

</br>
 
![schematic visualization of a beam in Excel](https://cms.viktor.ai/uploads/Blog_sample_app_Excel_73a3917fda.svg)

*Schematic visualization of a simply supported beam under load.* 

 </br>

![3D visualization of a beam in Excel](https://cms.viktor.ai/uploads/Blog_sample_app_Excel_2c9ec5c3b5.png)

*3D visualization of a simply supported beam under load.* 

</br>

3. **Download the report**. Download the calculation sheet to view on your device. 

</br>

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

Blog_sample_app_Excel_Python

Use this open-source sample application to automate calculations with Excel and Python. Read more on VIKTOR.ai.

Automate Excel calculations with this open-source application. VIKTOR.ai.

Sample app automating calculations in Excel

## Using the functionality 
 
There are two ways in which you can use this functionality:  

1. With VIKTOR, out-of-the-box, using our [free version](https://www.viktor.ai/try-for-free).  

2. Without VIKTOR, in that case you integrate with your own Python code and create an integration with SCIA yourself. 
 

This is a snippet of the functionality’s code from the VIKTOR GitHub repository.  

```python
@PDFView("PDF View", duration_guess=20) 
def execute_scia_analysis(self, params, **kwargs): 
    """ Perform an analysis using SCIA on a third-party worker""" 
    scia_model = self.create_scia_model(params) 
    input_file, xml_def_file = scia_model.generate_xml_input() 
    scia_model = self.get_scia_input_esa() 
 
    scia_analysis = SciaAnalysis(input_file=input_file, xml_def_file=xml_def_file, scia_model=scia_model, 
                                 result_type=ResultType.ENGINEERING_REPORT, output_document='Report_1') 
    scia_analysis.execute(timeout=600) 
    engineering_report = scia_analysis.get_engineering_report(as_file=True) 
 
    return PDFResult(file=engineering_report) 
```

This piece of code, located in app/tunnel/controller.py, is used to perform the analysis using SCIA on a third-party worker and generates an engineering report (as shown in the picture) showing the internal stress. The full code can be found in the [repository](https://github.com/viktor-platform). 

In the video you can see the functionality being used in a VIKTOR application in the [demo environment](https://www.viktor.ai/demo-environment). 

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/685852259?h=8ad14a99dc&autoplay=1&loop=1&autopause=0&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="Open-source parametric tunnel design with SCIA"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

<br>  


## Parametric tunnel design in 4 steps 

 As you can see in the video, the process of parametrically designing a tunnel and creating a SCIA model consists of only three easy steps. The step-functionality helps users navigate the application more easily and improves the overall experience: 

1. **Select the location of the tunnel** by drawing the location on a map, using a GeoPolyline field, determining the number of tunnel segments, and visualizing the tunnel on the map 

2. **Define cross-section** by adjusting the width, height, number of sections, and thickness of the roof, floor, and wall, and then visualizing one tunnel segment in a 3D visualization.  

3. **Create the SCIA model** by determining the roof load (kN/m2), soil stiffness (MN/m), visualizing a 2D beam model with the geometry and support. 

4. **Generate egineering report** automatically from SCIA within the VIKTOR application. 

Next, you can simply download the SCIA model (XML). The only requirement to use this sample application is that you have a SCIA worker running. Information on creating and analyzing SCIA models can be found in the [SCIA tutorial](https://github.com/viktor-platform/sample-scia-model/blob/main/README.md) in our GitHub repository. More information on [workers]( https://docs.viktor.ai/docs/worker) can be found in the VIKTOR documentation. 

![Engineering report SCIA tunnel](https://cms.viktor.ai/uploads/Blog_tunnel_with_SCIA_b37eaff47c.png)

*Engineering report showing the internal stress as generated in step 4*

## Writing tests and testing the app

Of course, you want to verify that your application works properly. This can be done by testing your application. To get a better understanding of how tests work in VIKTOR, this application includes some simple tests. With these tests, it is important to know that the params need to be mocked. This means that parts of your to-be-tested application are (temporarily) replaced by ‘fake’ objects within the scope of your test, so that you have full control over the in- and output within a certain test function.  

In the folder tests/tunnel/test_controller.py, you can see that prior to every test, the tunnel_example_1.json is used to mock the params. In the last test that checks if creating the engineering works, some functions are mocked as well:  

```python 
@patch('viktor.external.scia.Model.generate_xml_input', generate_xml_input_mock) 
@patch('app.tunnel.controller.SciaAnalysis.execute', scia_analysis_execute_mock) 
@patch('app.tunnel.controller.SciaAnalysis.get_engineering_report', scia_analysis_get_engineering_report_mock) 
def test_execute_scia_analysis(self): 
    """ Test TunnelController.execute_scia_analysis. It mocks some methods since they are using API calls.""" 
    pdf_result = self.controller.execute_scia_analysis(self.controller, params=self.params) 
    self.assertIsInstance(pdf_result, PDFResult) 
``` 

This part requires making an API call to the SCIA worker. Because this is not possible during a test, we want to tell the test it needs to skip the API call by using the @patch annotation.  

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



medium_Blog_tunnel_with_SCIA_header

small_Blog_tunnel_with_SCIA_header

thumbnail_Blog_tunnel_with_SCIA_header

Blog_tunnel_with_SCIA_header

Use this open-source web app for easy parametric tunnel design. Read more on VIKTOR.ai.

Parametric tunnel design | open-source web app | SCIA

Sample app parametric tunnel design with SCIA

## Automate where possible!

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

## RFEM models with a few lines of Python

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

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


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

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

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

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

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

## Running the analysis in the VIKTOR web app

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

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

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

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

*A typical enegry optimization analysis with VIKTOR*

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

## Creating user-friendly web apps with VIKTOR

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

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

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

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

*RFEM model in a VIKTOR application*

## RFEM binding with VIKTOR

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

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

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

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


small_appRFEM model in VIKTOR.png

thumbnail_appRFEM model in VIKTOR.png

Blog_RFEM_model_8

Automating RFEM model generation with Python in the Cloud

Parametric design

## Building an application 

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

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

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

## Visual programming as introduction to coding

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

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

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

*Visual programming with Scratch*

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

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

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

## Visual programming as a professional tool

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

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

## Building web applications with Python

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

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

## My facade generator as web application

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

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

*Tutorial on how to build a script from scratch*

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

### Integrating Grasshopper with VIKTOR

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

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

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

### Little coding required

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

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

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

*Python code as setup for a VIKTOR application*

### Visualizing the input

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

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

*Visualization of Python code*

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

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

## Grashopper and VIKTOR: A powerful combination

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

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









medium_grasshopper building blocks - resize.png

small_grasshopper building blocks - resize.png

thumbnail_grasshopper building blocks - resize.png

Blog_grasshopper_parametric_design_9

Parametric design in the Cloud with Grasshopper

1. What is parametric design, and how is it evolving
2. Collaborative parametric design: working together for better results
3. How to make tools available to others
4. Active collaboration on parametric design tools
5. Parametric design in a billion-euro project
6. What collaborative parametric design means for you



large_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

medium_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

small_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

thumbnail_Viktor White Paper The future of parametric design is_ COLLABORATION.jpg

WP_white

large_parametric_steel_structure.png

medium_parametric_steel_structure.png

small_parametric_steel_structure.png

thumbnail_parametric_steel_structure.png

WP_white_2

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.


PLAXIS result visualization 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. 

VIKTOR Blog