PLAXIS 2D 2016.00

Input

Switch to Flow conditions mode

The gotowater command is pending deprecation in favour of the gotoflow command

Tunnel designer

In the tunnel designer a few things changed such that older command logs might not properly work:

• the order of generated elements in Tunnel Designer has changed so this will not generate proper geometry or correct references when assigning e.g. plates, interfaces and line loads to these when using old command logs;
• Names of the generated properties in Tunnel Designer (e.g. lineloads, plates) changed as well, for instance in the tunnel designer a line load was called Lineload_x while now is called TCS_x_LineLoad_x

Phases - dynamics

The time stepping settings for dynamic calculations has changed: we can now choose a new time step determination: "Semi-automatic" which behaves the same as the "Automatic" setting of PLAXIS 2D 2015. The "Automatic" setting is now fully automatic and should choose an appropriate number of dynamic substeps AND number of additional steps.

Output

Phase info inconsistencies with Input

We found a few inconsistencies between Input and Output for some parameter names from the Phase and Step info. Of course we would like to have consistency between the two programs to make sure that the parameters are easy to use and to make sure any scripting/Python programming is easier to make and understand.

The changed parameter names are:

PLAXIS 2D 2015.00

Embedded pile row changes to embedded beam row

The embedded pile row has been changed into embedded beam row to make clear this embedded beam can be used for more than just piles, e.g. grout anchors.

To create a new embedded beam row:
    embeddedbeamrow(x1 y1) (x2 y2)

To create a new embedded beam row material dataset:
    embeddedbeammat

Note: in this version the old commands for the embedded pile rows will be supported, but may become deprecated in later versions

Naming of cutobjects (staged construction)

Due to an issue in the sorting routine of the cut objects (i.e. the intersected result of soils, polygons, lines), and the fact that the source of a cut objects was not clear in its naming, the automatic naming of items in the intersected geometry (mesh mode, flow conditions mode, staged construction) has been changed. This also involves removing the prefix CS_ for these items, see this example:

• PLAXIS 2D AE: CS_Line_1
• PLAXIS 2D 2015: Line_1_1

Multiplier on vector based features

The name for the multiplier userfeature has been changed. For point loads and point prescribed displacements, this userfeature name has been changed from .Multiplier_x/_y/_z to .MultiplierFx/Fy/Fz. To set a LoadMultiplier for a dynamic point load using the command line:

• 2D AE: set DynLineLoad_1_1.Multiplier_x Phase_1 LoadMultiplier_1
• 2D 2015: set DynPointLoad_1_1.MultiplierFx Phase_1 LoadMultiplier_1

For line loads, this userfeature name has been changed from .Multiplier_x/_y_z to .Multiplierx/y/z, and this would be the command line:

• 2D AE: _set DynLineLoad_1_1.Multiplier_x Phase_1 LoadMultiplier_1
• 2D2015: _set DynLineLoad_1_1.Multiplierx Phase_1 LoadMultiplier_1

Linear boundary conditions for head, inflow and outflow

Linear boundary conditions for head, inflow, outflow had inconsistent settings. Now the behaviour can be chosen more explicitely and more consistently by offering these options:

• "Vertical increment"
• "Horizontal increment"
• "Start/end values"

The option Linear is deprecated in 2D 2015, and replaced by the above mentioned options.

PLAXIS 2D AE.02

This page contains an overview of the changes in commands.

Bending moment

Since PLAXIS 2D AE.02, the parameter for the Point Load's bending moment has been changed from BendingMoment to simply M

Interface side

By fixing the issue called Local axis may flip with overlapping lines in PLAXIS 2D AE. the positive and negative interfaces may be on the opposite side of the line (and plate) compared to command log files created in PLAXIS 2D AE.00 or PLAXIS 2D AE.01. This could influence the replaying of these command log files.

Since PLAXIS 2D 2015 and PLAXIS 3D AE, the Output program can also be accessed via REST Http / Remote Scripting in order to retrieve calculation result data via a scripting interface.

Retrieving curve data is one of the possible options for the data retrieval. In this example, we will retrieve the results and store these in a text file.

First, we will need to make sure that the current open PLAXIS Output program is accessible as Remote Scripting server. This can be achieved by activating the Remote scripting server via the Expert menu in the Output program.

Next, we will need to tell the Python script where it can access this Remote scripting server.
This can be done with e.g. this script code:

import imp

plaxis_path =r'C:\PLAXIS'#your PLAXIS installation path
found_module = imp.find_module('plxscripting', [plaxis_path])
plxscripting = imp.load_module('plxscripting', *found_module)
from plxscripting.easy import*

outputport = 10001
s_o,g_o=new_server('localhost', outputport)

Now we can retrieve the data. For this we will use the command getcurveresults(). Since this command will only return one result value, the script will need to access each step id of the desired phases.

In the example below, the Python script stores a table in a file, and it will store the following columns, using the phase order as specified in the parameter phaseorder:

• phase name
• step number
• time
• u_y for Node A ( g_o.Nodes[0] )
• u_y for Node B ( g_o.Nodes[1] )

Note: You will need to store all steps during your calculation, otherwise it will not be possible to retrieve the time value for any of the unsaved steps.

defgettable_time_vs_uy(filename=None, phaseorder=None):
    #init data for lists
    stepids = [ ]
    uyAs = []
    uyBs = []
    times = []
    phasenames= []

    #look into all phases, all steps:for phase in phaseorder:
        for step in phase.Steps.value:
            phasenames.append( phase.Name.value )
            stepids.append( int(step.Name.value.replace("Step_","")) )
            uyAs.append( g_o.getcurveresults( g_o.Nodes[0],
                                              step,
                                              g_o.ResultTypes.Soil.Uy)
                         )
            uyBs.append( g_o.getcurveresults( g_o.Nodes[1],
                                              step,
                                              g_o.ResultTypes.Soil.Uy)
                         )
            #make sure step info on time is available, then add it:ifhasattr(phase.Steps.value[-1].Info,
                       'EstimatedEndTime'):
                times.append( step.Info.EstimatedEndTime.value )
            else:
                times.append( None )
            
    if filename:
        withopen(filename,"w") asfile:
            file.writelines( [ "{}\t{}\t{}\t{}\t{}\n".format( ph,nr,t,uyA,uyB )
                               for ph,nr,t,uyA,uyB inzip( phasenames,
                                                           stepids,
                                                           times,
                                                           uyAs,
                                                           uyBs )
                           ]
                         )

Now we can make a call to this function in order to save a text file with this data for phases Phase_1 and Phase_2:

gettable_time_vs_uy( filename=r'c:\data\project_curvedata.txt',
                     phaseorder = [ g_o.Phase_1, g_o.Phase_2 ] )

This data can then easily be used in spreadsheet programs to easily create charts or do other sorts of post processing.

Notes

• To retrieve ΣMstage, use step.Info.SumMStage.value
• To retrieve Force Fx, Fy or Fz (for 3D), use step.Info.ReachedForceX.value, step.Info.ReachedForceY.value or step.Info.ReachedForceZ.value respectively
• Time value parameters are named as following (see compatibility notes since 2D 2016):
  • time interval for last step [in project time unit], use phase.Info.TimeInterval.value or step.Info.TimeInterval.value, respectively
  • reached total end time of phase or step [in project time unit], use phase.Info.ReachedTime.value or step.Info.ReachedTime.value, respectively
  • reached total dynamic time in seconds [dynamics only], use phase.Info.ReachedDynTime.value or step.Info.ReachedDynTime.value, respectively

To get this data per step, use step. To get the phase final value, use phase.

PLAXIS has a facility for user-defined (UD) soil models. This facility allows users to implement a wide range of constitutive soil models (stress-strain-time relationship) in PLAXIS. Such models must be programmed in FORTRAN (or another programming language), then compiled as a Dynamic Link Library (DLL) and then added to the PLAXIS program directory.

In principle the user provides information about the current stresses and state variables and PLAXIS provides information about the previous ones and also the strain and time increments. In the material data base of the PLAXIS input program, the required model parameters can be entered in the material data sets.

For more details, please read the attached document and example code.

Location

In PLAXIS 2D 2012, PLAXIS 2D Classic and earlier and in PLAXIS 3D 2012 and earlier, the user-defined soil model's DLL files should be placed in the program's installation folder, e.g.

• PLAXIS 2D: C:\Program Files\Plaxis\Plaxis 2D\
• PLAXIS 3D: C:\Program Files\Plaxis\Plaxis 3D\

Since PLAXIS 3D 2013 and PLAXIS 2D AE, these user-defined soil model's DLL files should be placed in a subfolder called udsm:

• PLAXIS 2D: C:\Program Files\Plaxis\Plaxis 2D\udsm\
• PLAXIS 3D: C:\Program Files\Plaxis\Plaxis 3D\udsm\

Diclaimer: the PLAXIS organization cannot be held responsible for any malfunctioning or wrong results due to the implementation and/or use of user-defined soil models.

Currently it is not possible to directly plot the active load qactive in a curve to generate load-displacement curves for a load-controlled analysis. See the related article How to get a load - displacement curve using SumMstage

In this article, we will show how to use the HTTP REST API / Remote Scripting feature in order to retrieve the necessary values and save them in a text file, so that this data can be used in any spreadsheet software to generate a load-displacement curve..

First, we will need to make sure that the current running PLAXIS Input and PLAXIS Output program are accessible as Remote Scripting server. This can be achieved by activating the Remote scripting server via the Expert menu in both Input and Output programs.
See also: Using PLAXIS Remote scripting with the Python wrapper in order to correctly setup the reference to Plaxis Input (s_i,g_i) and Output (s_o,g_o) using the boilerplate code.

In order to construct the actual load-displacement curve the following quantities are needed for each step:

• qactive , equation to determine qactive:
     q_active = q_{phase_start} + ΣMstage * ( q_{phase_end} - q_{phase_start})
• displacements (specified node)

The steps to achieve in generating a load-displacement curve can be summarize in the following points:

1. create a function that will retrieve the load value
2. create a function that will retrieve the results required for the equation to determine qactive and for the load-displacement curve and add them in tables
3. create a file that will store these information by means of a text file
4. make a quick plot (using matplotlib package)
5. call the function that will execute all above operations

Note in this code example we will use Tutorial Lesson 1 Case B: Flexible footing's case to illustrate the behaviour.

Retrieve load value

To begin with, we will need to retrieve the values for q_{phase_start} and q_{phase_end} for a specified phase, for which the load is active and applied. For this the command that retrieves the load value for a specific phase can be used. For instance:

g_i.LineLoad_1_1.qy_start[g_i.Phase_1]

In order to make the defined script reusable in other conditions, we will write a function that takes the line load name and the phase name as an input, and returns the load object for that phase:

# creating the function that will retrieve# the values later in the scriptdefgetphasevalue (plxobject, phase):
    return plxobject[phase]

Required results for equation and curve

In order to calculate the value of qactive we will need the ΣMstage values from the Output results. Next to that, the displacements of a pre-selected node (A) should be retrieved, too. In the following example, we will create a table with these columns:

• step number
• phase name
• ΣMstage value
• displacement of node A (total): |u|
• q_active-value

# qphase_start is start load value in phase, equal to# the final load value in the preceding phase: the PreviousPhase# qphase_end is the defined final load value for this phaseimport math

defcreate_phases_name_map(phases):
    result = {}
    for phase in phases[:]:
        result[phase.Name.value] = phase
    return result

defget_table_qactive_vs_displacement(filename, phases_i):
    # initial data for eventual table columns
    col_step = ["Step"]
    col_sum_mstage = ["SumMStage"]
    col_phases = ["Phase"]
    col_utot = ["Utot"]
    col_qactive = ["qactive [kN/m2]"]
    col_load = ["Load [kN]"] # load for axisymmetric models
    radius = 1
    area = math.pi * radius**2

    phasesmap_o = create_phases_name_map(g_o.Phases)
    # look into all phases, all steps:
    loadfeature_i = g_i.LineLoad_1_1
    for phase_i in phases_i:
        qphase_end = getphasevalue(loadfeature_i.qy_start, phase_i)
        # check if previous phase has a Line Load# that is deactivated (then load=0)if loadfeature_i.Active[phase_i.PreviousPhase]:
            qphase_start = loadfeature_i.qy_start[phase_i.PreviousPhase]
        else:
            qphase_start = 0
       
        phase_o = phasesmap_o[phase_i.Name.value]
        for step in phase_o.Steps:
            sumMstage = step.Info.SumMStage.value           
            col_phases.append(phase_o.Name.value)
            col_step.append(int(step.Name.value.replace("Step_", "")))
            col_utot.append(g_o.getcurveresults(g_o.Nodes[0], 
                                                step,
                                                g_o.ResultTypes.Soil.Utot))
            col_sum_mstage.append(sumMstage)
            col_qactive.append(-qphase_start + sumMstage * (-qphase_end + qphase_start))
            col_load.append(col_qactive[-1] * area)

---------------------------------------------------------------------------------

Text file with required information

After retrieving the tables of the results, a filename will be created that will be saved as a normal text file (*.txt). The specified path should be given below:

if filename isnotNone:
        withopen(filename,"w") asfile:
            for results inzip(col_phases, col_step, col_utot, col_qactive, col_load):
                print('\t'.join(["{}".format(i) for i in results]), file=file)

Run the function

Now we can make a call to this function in order to save a table with these results for Phase_1 to the text file.

get_table_qactive_vs_displacement(filename =r'C:\data\load_displ_data.txt',
                                  phases_i = [ g_i.Phase_1 ] )

Note that in order to use mathematical functions and constants (e.g. math.pi) a specific module needs to be imported. To import the math module, the following line is included at the beginning of the script:

import math

The assumptions made in the script are that the project should have the following:

• all steps are stored during calculation to retrieve the results for each step
• a pre-selected node to check the displacements is selected
• a single vertical line load is applied

Example

When executing this Python code on  Tutorial Lesson 1 (Settlement of a circular footing on a sand - Case B: Flexible footing [link]) the described script will result in the following data table:

Figure 1. Text file generated for Lesson 1B

By opening the text file in spreadsheet program (e.g. Microsoft Excel) we can further process the data to generate the following curve:

Figure 2. Load - displacement curve from spreadsheet data

Quick plot for Load-Displacement curve [matplotlib]

At the end of this example, the option to create a quick plot is provided using the matplotlib plotting library, which allows for a quick check of the Load-Displacement curve. This will appear in a separate window. Note that the following code should be used within the previous script, before the command which runs the function.

# Make a quick plot of the Load-Displacement curveimport matplotlib.pyplot as plt
    plt.plot(col_utot[1:], col_load[1:] )
    plt.xlabel('Displacements (m)')
    plt.ylabel('Load (kN)')
    plt.title('Load-Displacement curve')
    plt.grid(True)
    #plt.savefig("load_displ_curve.png")if filename:
        plt.savefig(filename.replace(".txt", ".png"))      
    plt.show()

Figure 3. Example of a load - displacement curve generated by matplotlib's plt.show()

This document describes an example that has been used to verify the natural frequency of vibration of a dam fixed at the base.

Used version:

• PLAXIS 2D 2015.02 - Dynamics Module
• PLAXIS 3D AE.01 - Dynamics Module

This requires a Dynamics module

This document describes an example that has been used to verify that the natural frequency of a vibrating dam, fixed at the base, is calculated correctly in PLAXIS.

Used version:

• PLAXIS 2D 2015.02 - Dynamic Module
• PLAXIS 3D AE.01 - Dynamic Module

This requires a Dynamics module.

Lamb's problem is related to wave propagation in a semi-infinite elastic medium subjected to an impulsive force applied at the surface, Lamb (1904). The problem is simulated in PLAXIS and the results are verified against Lamb's solution, which has been considered by, among others, Miklowitz (1978), Cagniard, Flinn & Dix (1962) and Foinquinos & Roesset (2000). In the present validation, the closed form solution introduced by Foinquinos & Roesset (2000) is adopted as reference.

In this validation, comparison is made between PLAXIS results and results obtained from the closed form solution introduced by Foinquinos & Roesset (2000) for solving Lamb's far field problem.

Used version:

• PLAXIS 2D 2015.02 - Dynamic Module
• PLAXIS 3D AE.01 - Dynamic Module

This requires the Dynamics module.

This document describes an example that has been used to verify the groundwater flow capabilities of PLAXIS. In this example a vertical cross section of an unconfined groundwater flow system in a homogeneous earth dam underlain by an impervious base is considered (see figure). Such a problem is commonly known as the Muskat problem where the free phreatic surface and the seepage face are unknown, leading thus to a set of nonlinear equations.

Used version:

• PLAXIS 2D 2015.02
• PLAXIS 3D AE.01

In this test the natural frequency of a simply supported beam will be determined and compared with the analytical solution. The natural frequency of a system is the frequency that characterises the response of the system in a free vibration condition. The problem is validated in PLAXIS 2D and PLAXIS 3D.

Used version:

• PLAXIS 2D 2015.02 - Dynamics Module
• PLAXIS 3D AE.01 - Dynamics Module

This requires the Dynamics module.

This documents verifies that the principles of consolidation are correctly implemented in PLAXIS. The problem involves the time-dependent solution of one-dimensional (1-D) consolidation.

Used version:

• PLAXIS 2D 2015.02
• PLAXIS 3D AE.01

This document describes an example that has been used to verify that one-dimensional (1-D) wave propagation is correctly implemented in PLAXIS.

Used version:

• PLAXIS 2D 2015.02 - Dynamics Module
• PLAXIS 3D AE.01 - Dynamics Module

This requires the Dynamics module.

This document describes an example that has been used to verify the unsaturated flow capabilities of PLAXIS 2D. The problem involves the steady-state solution of the suction head for the case of uniform constant evaporation in unsaturated media.

Used version:

• PLAXIS 2D 2015.00 - Flow module

This requires a PlaxFlow module for transient groundwater flow

This document describes an example that has been used to verify the unsaturated flow capabilities of PLAXIS 2D. The problem involves the steady-state and transient solutions of the suction head for the case of uniform constant infiltration in unsaturated media.

Used version:

• PLAXIS 2D 2015.00 - PlaxFlow module

This requires a PlaxFlow module for transient groundwater flow