Pile jacking example in Abaqus

Getting started with CEL simulations

Dominik Zobel

version: November 17, 2020

1 Getting started with Abaqus

Getting used to work with Abaqus may seem very difficult at the beginning. The program offers an overwhelming amount of possibilities—thus the appropriate workflow and the necessary options to simulate a certain problem may not be obvious at all. These notes are meant to help getting started with simulations at the Institute of Geotechnical Engineering and therefore focus on soil mechanics and soil-structure interaction.

There are various numerical methods which are more or less effective depending on the problem to investigate. Whenever soil undergoes great deformations, the Finite Element Method with an Lagrangian analysis may yield unreliable results due to distorted mesh sections or even fail to finish the calculation.

One approach, which is chosen for this tutorial, is to use the Coupled Eulerian-Lagrangian (CEL) method. Here, elements which are expected to flow or change their shape are modelled with Eulerian materials. The mesh of Eulerian elements will stay put and the material can flow within the element boundaries. If combined, Lagrangian and Eulerian elements are promising to model the interaction between soil and structure. In this document a simplified pile jacking CEL simulation will be conducted.

As this document was originally written in 2015, Abaqus 6.14 is used. Nevertheless, this tutorial (i. e. the workflow and all recommondations) is also valid for more recent versions like Abaqus 2020 (last tested version but even newer versions might work).

Upon starting, saving and during work Abaqus will create different files in the working directory.¹ If the model is saved, a model file <model>.cae and a journal file <model>.jnl will be created or updated. Journal files contain all relevant Python commands for the actions taken to create the saved model. If no issues have to be corrected manually, they can be run to automatically recreate the model from scratch.² After successfully creating a finished model, an input file <model>.inp is created. Input files contain all relevant model information and are required to calculate the results in Abaqus (on a local or remote machine). The finished results will be written to the model output database <model>.odb and can be inspected in Abaqus CAE or Viewer. Status reports and messages will be written to <model>.dat, <model>.sta and <model>.msg. Those files are especially useful, if the simulation fails.

Abaqus offers special solvers for certain kind of simulations. For soil-structure interaction (and many other soil mechanic investigations) the Standard/Explicit model option should be chosen in the start dialog (cf. figure 1.1). The decision between Standard and Explicit analysis will be postponed until chapter 6.

Figure 1.2 shows the interface of Abaqus CAE. The main menu is located at the top of the window and has two lines of additional shortcut symbols. On the left hand side is the model tree and its nodes. By default, the initial model will be called Model-1 and its child elements are visible.

The viewport on the right hand side displays the model. The model can be inspected, selected and manipulated within this area. At the left border of the viewport are two columns of symbols which will be called Quick start symbols. Different view modes can be chosen in the drop-down menu right of Module above the viewport. They can also be invoked by selecting the appropriate mode in the model tree.

Messages, warnings and errors are shown in the message log at the bottom part of Abaqus. Beneath the message log is also a command line (in the >>>-tab), where all commands (as shown in the journal file) can also be issued directly. In general, there are many options and commands in Abaqus, which can be invoked in more than one way.

The modules in Abaqus provie a workflow for model creation and simulation. They can either be changed by the drop-down menu named Module above the viewport or by clicking on the corresponding module in the model tree on the left.

At first, all required parts of the model are created individually in the Part module as described in chapter 2. All parts need to have material properties assigned to them, which will be covered in the Material module (chapter 3).

Afterwards the parts are assembled to the final model layout in the Assembly module (see chapter 4). After the assembly, necessary contact and interaction properties are defined (chapter 5) and boundary conditions as well as loads are defined and applied in the Step module (chapter 6).

Before continuing the parts have to be meshed in the Mesh module as described in chapter 7. Meshing can already be done after finishing the part geometries (chapter 2). However if partitions are added or changed in the assembly step, the mesh has to be redone.

In general, all modules can be edited (again) at any point, but sometimes the model has to be regenerated or otherwise updated to fit the changes.

In this document, all general Abaqus hints are highlighted like this.

When everything is done, a job can be created (see chapter 8) and the simulation can be run. Finally, the simulation results can be analyzed in the last module (chapter 9).

Author’s remark:

These notes are based on discussions with my colleagues from the Institute of Geotechnical Engineering at the Hamburg University of Technology. Additionally, the official Abaqus manual(s) (Dassault Systèmes 2014) as well as workshop slides (ABAQUS Inc. 2005) and the scripting notes from Overvelde (2010) were used.

2 Model creation

As Abaqus is starting, all required dependencies are loaded automatically for interactive work. But if a script with commands from a Journal- or Replay-file is run, these dependencies have to be imported at the beginning of the script.

# -*- coding: utf-8 -*-
from part import *
from material import *
from section import *
from assembly import *
from step import *
from interaction import *
from load import *
from mesh import *
from optimization import *
from job import *
from sketch import *
from visualization import *
from connectorBehavior import *

2.1 Create pile object

Abaqus is providing an initial model called Model-1 at startup. First, choose an expressive name to the model like PileJackingModel. Either right click on Model-1 and select Rename or use the main menu (Model->Rename->Model-1). Notice the change in the model tree and in the second drop down menu above the viewport.³

mdb.models.changeKey(fromName='Model-1', toName='PileJackingModel');

Next, we create the parts of the model. To create a part, either right click on Parts and select Create in the model tree, select Part->Create in the main menu or use the Create Part icon () in the top left corner of the quick start symbols. The dialog box in figure 2.1 will open.

Name the part Pile and accept the remaining default values. Since we are interested in a three dimensional analysis, 3D modelling space and a solid (deformable) shape are suitable. The approximate size and the type are used to create a sufficiently sized model out of a two dimensional sketch.

Using Extrusion simply extends the outline of the sketch in the third dimension. Revolution would revolve the sketch around an axis and Sweep allows an outline to follow a (closed) path.

The background of the viewport changes to a grid and the quick start symbol adapt to the Sketch module. To draw a sketch, simple geometric elements can be used. All options can either be executed using the main menu (Add->) or the quick start symbols.

A single point can be drawn (), a polyline (), a rectangle (), a circle () or an ellipse (). Circular arcs can be either drawn tangent to an existing line (), by a center point and two points on the arc () or by three points ().

All coordinates can either be chosen on the visual grid or inserted in the prompt at the bottom of the viewport (above message log). Commands can either be executed by pressing the Enter-key or the middle mouse button (MMB).

A sketch or its segments can also be moved with the cursor icon () or deleted by the eraser icon () in the lower region. To have a proper defined sketch/model, angles and lengths can and should be measured () and constraints imposed (). The constraints function opens a new window with a set of selectable constraints. Sometimes it might be more practical to draw freely and get the right model by measurements and constraints.

Everything can be changed or removed at almost any time, but sometimes not with obvious solutions like Ctrl+Z, Del or Esc.

Abaqus can also try to auto-constrain () and auto-measure () the sketch, but manually imposing at least some values and checking the validity is recommended. A simple rectangle with measurements and constraints representing the profile of the pile is shown in figure 2.2. Its area is 1 units ($x$-direction) by 0.5 units ($y$-direction).⁴

When creating or manipulating objects, Abaqus will snap to the grid, to special points on the sketch and on all intersections.

This can be problematic when working on more complex geometry. As a consequence it may be favourable to draw a construction line () to create additional reference lines or artificial intersections to add additional segments more easily.

Some icons like this have more options to choose from, as hinted by the small black triangle in the lower right corner. Left click on such icons and hold the left mouse button pressed to see all available options. Release above the icon of choice to select it. The last selected symbol will be shown among the quick start symbols.

There are five ways to define a construction line (): Either by two points, or by one point (with horizontal or vertical constraint), or by one point and an angle or as a circle (by defining center point and radius).

If the functionality of an option is not known, move the mouse above the icon. An info box will appear with its name/description.

Another useful function is auto-trimming (). Its main use is the removal of single segments between corners or intersections and will be very useful with more complex geometry made from/with simple elements.

The finished sketch will be extruded to become a part. On exiting the sketch editor the Extrude dialog opens (cf. figure 2.3). Set the depth of extrusion to 10 units and confirm. The main window should now look like figure 2.4.

All commands used to create the pile are listed below. First, a ConstrainedSketch element is created and a rectangle, defined by two points, upon it. In Line 23 and 26 measurements are added by HorizontalDimension and VerticalDimension commands.⁵ When the sketch is finished, name, shape and type options as seen in figure 2.1 are chosen. When everything is applied and the part is successfully created, the temporary ConstrainedSketch is removed.⁶

drawing = mdb.models['PileJackingModel'].ConstrainedSketch(name='__profile__', sheetSize=20.0);
drawing.rectangle(point1=(-0.5, -0.25), point2=(0.5, 0.25));
drawing.HorizontalDimension(textPoint=(0.0, 0.5), value=1.0,
   vertex1=drawing.vertices.findAt((-0.5, 0.25), ),
   vertex2=drawing.vertices.findAt((0.5, 0.25), ));
drawing.VerticalDimension(textPoint=(0.75, 0.0), value=0.5,
   vertex1=drawing.vertices.findAt((0.5, -0.25), ),
   vertex2=drawing.vertices.findAt((0.5, 0.25), ));
partPile = mdb.models['PileJackingModel'].Part(dimensionality=THREE_D, name='Pile',
   type=DEFORMABLE_BODY);
partPile.BaseSolidExtrude(depth=10.0, sketch=drawing);
del drawing;

2.2 Create soil object

Now the soil part has to be modelled. The procedure is almost the same as described for the pile in the previous section. Create a new part and name it Soil. To make it an Eulerian part, choose the Eulerian type instead of Deformable in the Create Part window and accept the other default options. The sketch editor will open again and another rectangular profile should be made. This time the dimensions are 4 units ($x$-direction) by 2 units ($y$-direction) and an extrusion depth of 6 units ($z$-direction).

As always, save often to prevent the trouble of losing data.

As a result the part should look like the one shown in figure 2.5. Here the element tree is expanded and in both parts a Solid extrude-1 element and a Section Sketch element can be seen. Right click on Section Sketch and choose Edit to change the sketch of the element or edit Solid extrude-1 to change the extrusion depth. If any changes are made in these settings, the whole part has to be regenerated, as a warning window will indicate. Right click on Features and select Regenerate of the corresponding part. Alternatively activate the corresponding part—if not active—and choose Feature->Regenerate from the main menu.

Active models/parts/instances/… are underlined. To activate an inactive element double click on it.

It should not be surprising, that the journal data for the soil element is very similar to the pile part. The most important difference is the Eulerian part type (line 43-44).

drawing = mdb.models['PileJackingModel'].ConstrainedSketch(name='__profile__', sheetSize=20.0);
drawing.rectangle(point1=(-2.0, -1.0), point2=(2.0, 1.0));
drawing.HorizontalDimension(textPoint=(0.0, 1.5), value=4.0,
   vertex1=drawing.vertices.findAt((-2.0, 1.0), ),
   vertex2=drawing.vertices.findAt((2.0, 1.0), ));
drawing.VerticalDimension(textPoint=(2.5, 0.0), value=2.0,
   vertex1=drawing.vertices.findAt((2.0, -1.0), ),
   vertex2=drawing.vertices.findAt((2.0, 1.0), ));
partSoil = mdb.models['PileJackingModel'].Part(dimensionality=THREE_D, name='Soil',
   type=EULERIAN);
partSoil.BaseSolidExtrude(depth=6.0, sketch=drawing);
del drawing;

2.3 Adding and querying elements

This section applies to the Part module and the Assembly module described in chapter 4. In both modules it may be necessary to create special elements or to obtain information about the geometry. To obtain node coordinates or the distance between nodes—as well as many other useful information—select Tools->Query from the main menu and the Query window will open (cf. left side of figure 2.6).

Sometimes it is useful to create datum points, axis or planes to ease working with partitions or assembling elements later on. To create a datum element, either select Tools->Datum from the main menu to open the Create Datum window (cf. center of figure 2.6) or use the quick start symbols (lower midarea). You can create a datum point (), a datum axis() or a datum plane (). All datum elements can be created in different ways (hence the black triangle in the lower right corner of the icon).

Reference points are similar to datum points, but offer more possibilities. They can be coupled to geometric entities (e. g. sets, parts and instances) to define boundary conditions (movement, loads, …) or obtain measurement data. To create a reference point, use Tools->Reference Point from the main menu.

Figure 2.6: Query dialog on the left hand side and Create Datum window (with datum point options visible) in the center. The Create Partition window (with cell option) can be seen on the right hand side.

Sets in turn are useful to label elements or whole parts. This can be very helpful when imposing boundary conditions or other constraints on (parts of) a geometry. Sets can either be created by selecting Tools->Set->Create in the main menu or by right clicking on Sets in the model tree and choosing Create.

Partitions are essential for multiple material assignments and important for mesh generation. The Create Partition window can be invoked by Tools->Partition (cf. right hand side of figure 2.6).

Additionally, quick start symbols (central, above datum icons) are also available e. g. for creating cell partitions () or face partitions (). It can be useful to sketch and create a face partition and extrude the partition through the cell(s) afterwards ().

Eulerian material can only flow within the given geometry. Therefore creating and assigning partitions with different materials (and void material) may be useful.

Adjusting the pile part

These concepts should now be applied to the PileJackingModel. First, a reference point should be added to control the pile movement later on. Add it at the middle of longest edge on the top of the pile as shown in figure 2.7 and name it RP_Pile.

rp = partPile.ReferencePoint(point=(0.0, -0.25, 10.0));
partPile.features.changeKey(fromName='RP', toName='RP_Pile');

Then two sets should be added for the pile: The whole part (without the reference point) should be represented as a setAll as well as the reference point as setRP.

partPile.Set(name='setAll', cells=partPile.cells);
partPile.Set(name='setRP', referencePoints=(partPile.referencePoints[rp.id], ));

Adjusting the soil part

Next, the soil should be partitioned (e. g. by cutting planes). One possibility to get the desired cutting plane is to create necessary datum point(s) first, which are on this plane.⁷ In chapter 3, the lower two thirds of the soil volume will be filled with a sand material while the top third will contain void material. Additionally, the mesh of the soil around the pile should be denser than in the area farther away to have a better representation of the Eulerian volume near the pile.

So one partition should divide the soil in two equal parts in $y$-direction and two more partitions should separate the outer fourth in $x$-direction.⁸ In the end, a result similar to figure 2.8 should be achieved.

In this scenario, two datum points are sufficient if correctly chosen. Additionally the three principal datum axis should be created.⁹

pt1 = partSoil.DatumPointByCoordinate(coords=(1.0, 1.0, 4.0));
pt2 = partSoil.DatumPointByCoordinate(coords=(-1.0, 0.0, 6.0));
xaxis = partSoil.DatumAxisByPrincipalAxis(principalAxis=XAXIS);
yaxis = partSoil.DatumAxisByPrincipalAxis(principalAxis=YAXIS);
zaxis = partSoil.DatumAxisByPrincipalAxis(principalAxis=ZAXIS);

The Partition can be created by a cutting plane. If one point on the plane is known and a normal can be selected, the option Point and Normal can be chosen.

partSoil.PartitionCellByPlanePointNormal(cells=partSoil.cells,
   normal=partSoil.datums[xaxis.id], point=partSoil.datums[pt1.id]);
partSoil.PartitionCellByPlanePointNormal(cells=partSoil.cells,
   normal=partSoil.datums[zaxis.id], point=partSoil.datums[pt1.id]);
partSoil.PartitionCellByPlanePointNormal(cells=partSoil.cells,
   normal=partSoil.datums[xaxis.id], point=partSoil.datums[pt2.id]);
partSoil.PartitionCellByPlanePointNormal(cells=partSoil.cells,
   normal=partSoil.datums[yaxis.id], point=partSoil.datums[pt2.id]);

Finally, some sets should be created for the soil part. The whole part should also be represented as a set (setAll). Next, all cells in the upper third should form setCellsTop and all cells in the two lower thirds setCellsBottom. Then, all (8) boundary faces in $x$-direction should be gathered in setFacesX, all (12) boundary faces in $y$-direction in setFacesY and all (6) bottom boundary faces in setFacesBottom.¹⁰

When using mouse selection to create sets, the vertices adjoining other cells outside the intended set mustn’t be selected, but all edges and faces within.

partSoil.Set(cells=partSoil.cells, name='setAll');
cellstop = partSoil.cells[0:0];
cellsbottom = partSoil.cells[0:0];
for singlecell in partSoil.cells:
   if (singlecell.pointOn[0][2] > 4.0):
      cellstop += partSoil.cells[singlecell.index:singlecell.index+1];
   else:
      cellsbottom += partSoil.cells[singlecell.index:singlecell.index+1];
#
partSoil.Set(cells=cellstop, name='setCellsTop');
partSoil.Set(cells=cellsbottom, name='setCellsBottom');
facesX = partSoil.faces[0:0];
facesY = partSoil.faces[0:0];
facesbottom = partSoil.faces[0:0];
for singleface in partSoil.faces:
   if (singleface.pointOn[0][2] <= 0.0):
      facesbottom += partSoil.faces[singleface.index:singleface.index+1];
   if (abs(singleface.pointOn[0][0]) >= 2.0):
      facesX += partSoil.faces[singleface.index:singleface.index+1];
   if (abs(singleface.pointOn[0][1]) >= 1.0):
      facesY += partSoil.faces[singleface.index:singleface.index+1];
#
partSoil.Set(faces=facesX, name='setFacesX');
partSoil.Set(faces=facesY, name='setFacesY');
partSoil.Set(faces=facesbottom, name='setFacesBottom');

Sometimes a single part is too complex to be represented by a simple sketch. But Abaqus supports creating complex part out of multiple simple parts in the assembly as mentioned in chapter 4. Also, geometry can be created in a different program and imported in Abaqus (File->Import->Part).

3 Material assignment

Enter the Material module by either right clicking on Materials in the model tree and selecting Switch context, or by choosing the Property entry in the Module drop-down menu above the viewport. Many quick start symbols change, but the datum and partition option (as well as the feature options which aren’t discussed here) stay the same.

First, we define a new material by either clicking on () or right clicking on Materials in the model tree and selecting Create or by choosing Material->Create in the main menu to open the Edit Material window.

Our first material will be steel. After naming the material, several options can be added to define its behavior. Most importantly its density (General->Density) and its elastic properties (Mechanical->Elasticity->Elastic). As hinted in section 2.1:

All dimensional values need to have fitting units. Choose a consistent system like the SI or the Geotechnics system as shown in table 3.1.

This example will use the Geotechnics system. Every unit for previously set lengths for the model parts created in chapter 2 will be regarded as meters. Accordingly to this unit system, the value for the density of steel will be 7.87 t/m$^3$, the Young’s modulus $210\cdot 10^6$ kPa and Poisson’s ratio 0.3. Enter these values in the respective property tab (cf. figure 3.1) and click Ok to save the properties and close the window.

mdb.models['PileJackingModel'].Material(name='steel');
mdb.models['PileJackingModel'].materials['steel'].Density(table=((7.87, ), ));
mdb.models['PileJackingModel'].materials['steel'].Elastic(table=((210e6, 0.3), ));

Now the sand material has to be defined in the same way. Its density is 1.6 t/m$^3$ and it is assumed to be linear elastic (Young’s modulus $30\cdot 10^3$ kPa and Poisson’s ratio 0.25).

mdb.models['PileJackingModel'].Material(name='sand');
mdb.models['PileJackingModel'].materials['sand'].Density(table=((1.6, ), ));
mdb.models['PileJackingModel'].materials['sand'].Elastic(table=((30e3, 0.25), ));

If a user defined material behavior (e. g. hypoplastic behaviour) should be simulated, the amount of solution-dependent variables has to be defined (General->Depvar) and the values given to the user routine (General->User Material) as shown on the right hand side of figure 3.1. This will not be used in this tutorial.

Figure 3.1: The material dialog with density and elastic behavior options added on the right hand side works internally. On the left hand side is an example of integrating a user defined material (not used in this tutorial).

All necessary materials are defined and after creating sections, they can be applied to the geometry. So for all parts, a new section is created by either right clicking on Sections in the model tree and choosing Create, selecting Section->Create in the main menu or using the quick start symbol ().

As the Create Section window opens, the material name, type and category can be edited. Choose secPile for the section associating the steel material with the pile geometry. Since the pile geometry is homogeneous and solid, no changes are necessary here. Clicking on Continue opens the Edit Section window (cf. figure 3.2).

mdb.models['PileJackingModel'].HomogeneousSolidSection(name='secPile', material='steel',
   thickness=None);

Figure 3.2: The Section Create on the left hand side and two Section Edit dialogs. The dialog in the center is called when homogeneous types are chosen, the dialog on the right hand side for Eulerian types.

Repeat the process but this time name the section secSoil and choose an Eulerian type. This time a base material has to be chosen in the Edit Section window.

mdb.models['PileJackingModel'].EulerianSection(name='secSoil', data={'instsand': 'sand'});

Finally the material sections have to be assigned to the geometry. To assign the pile geometry to the steel material, make the pile the active element (underlined name) and choose Assign->Section in the main menu, right click on Section Assignments and selecting Create or by the quick start symbol (). A new region can be selected or a previously defined set can be loaded below the viewport. Click on Sets to select the setAll set.

Choose the appropriate section (secPile) in the section drop-down menu of the Edit Section Assignment window and the assignment is complete. (see left hand side of figure 3.3). Only applicable sections will be displayed and can be assigned.

Correctly assigned geometry will change its color from grey to pale green.

Generally, the assignment procedure should be repeated for all other elements. When dealing with Eulerian elements (like this soil element), the region is set automatically and a new set is created when an Eulerian material is defined.^{11 12} Eulerian elements can have different materials, which have to be assigned as a predefined field (see chapter 6), but the basic material assignment is done.

partPile.SectionAssignment(sectionName='secPile', region=partPile.sets['setAll'], offset=0.0,
   offsetField='', offsetType=MIDDLE_SURFACE, thicknessAssignment=FROM_SECTION);
partSoil.SectionAssignment(sectionName='secSoil', region=partSoil.sets['setAll'], offset=0.0,
   offsetField='', offsetType=MIDDLE_SURFACE, thicknessAssignment=FROM_SECTION);

Figure 3.3: Section Assignment of steel material for pile and sand material for soil.

4 Assembly

After all parts are finished, the model itself can be assembled. Either right click on Assembly in the model tree and select Switch Context or choose Assembly from the drop-down menu named Module above the viewport. The quick start symbols contain eight special assembly icons and some already known ones (features, datums and partitions).

An assembled model (represented in blue) consists of different instances. One instance can be made from one part, but one part can also be used to create multiple instances. All instances can be transformed (rotation and translation) and aligned with others.

To create an instance, either right click on Instances in the model tree and select Create, choose Instance->Create in the main menu or click on the quick start symbol (). Select both parts in the Create Instance window and click Ok (cf. figure 4.1).¹³

mdb.models['PileJackingModel'].rootAssembly.DatumCsysByDefault(CARTESIAN);
instPile = mdb.models['PileJackingModel'].rootAssembly.Instance(name='instPile', part=partPile,
   dependent=ON);
instSoil = mdb.models['PileJackingModel'].rootAssembly.Instance(name='instSoil', part=partSoil,
   dependent=ON);

Now the instances have to be transformed to get the right model composition. The initial coordinates of the instances are dependent on the corresponding part coordinates. So considering the part’s position in the model when creating it makes assembling the model more convenient.

Later on, the upper third of the soil volume will contain void material and the rest will be filled with sand material. The pile should be positioned just above the soil (aligned with the plane of the horizontal partition), centered in $x$-direction and at the back of the soil in $y$-direction like in figure 4.2.

To translate an instance, either choose Instance->Translate from the main menu or use the quick start symbol (). After selecting the instance(s) to translate, either select start and end point in the viewport or input the coordinates. When using coordinate input, only the relative vector is important.¹⁴

mdb.models['PileJackingModel'].rootAssembly.translate(instanceList=('instPile', ),
   vector=(0.0, -0.75, 4.0));

If a rotation should to be applied, either choose Instance->Rotate from the main menu or use the quick start symbol (). A rotation axis by two points has to be defined, before the rotation angle can be chosen.

Another important function for the model setup is to add geometric constraints between instances (). Either choose an option from Constraint-> in the main menu or use one of the seven quick start symbols () to make faces parallel, move face to face, make edges parallel, move edge to edge, make elements coaxial, coincident point or make some CSYS¹⁵ parallel.

Sometimes a sketched part in the Part module cannot be made as complex as needed, but all geometric features can be created separately. The complex structure can be assembled in the Assembly module by translating, rotating and aligning all parts involved. Using the Merge/Cut function (Instance->Merge/Cut) or the quick start symbol (), a new and more complex part can be created from those instances and used thereafter.

5 Interactions and constraints

General interactions and constraints are accessible in the Interaction module in the Module drop-down menu above the viewport or by right clicking on either Interactions or Constraints in the model tree and choosing Switch Context.

As a first constraint, all movement and velocity (as defined in chapter 6) of the pile should be controlled by the reference point RP_Pile. A quick start symbol for creating reference points () is available in this module, but we have already defined one.

To create a constraint, either click on the quick start symbol (), right click on Constaints in the model tree and choose Create or select Constraint->Create from the main menu. The Create constraint window will open and in this case, a Rigid body constraint should be applied, since the pile is much stiffer than the soil and its deformations are negligible in comparison. As an advantage, the simulation will finish sooner as if the steel pile deformations (and therefore the degrees of freedom of each individual node of the pile) were considered.

To define the Rigid body constraint, a (body) region and a reference point have to be selected by clicking on the cursor symbol. Since the pile and the reference point are already defined as sets, these definitions can be used (cf. figure 5.1).

Figure 5.1: The Create Constraint window on the left hand side and the Edit Constraint window on the right hand side.

mdb.models['PileJackingModel'].RigidBody(bodyRegion=instPile.sets['setAll'],
   name='RigidRPSteelpile', refPointRegion=instPile.sets['setRP']);

All elements or surfaces which (could or should) interact with each other need to have definitions for contact and interaction. Therefore an interaction is added by either selecting Interaction->Create in the main menu, the quick start symbol () or by right clicking on Interactions in the model tree and choosing Create. The Create Interaction window will open as shown in the left hand side of figure 5.2.

Some interactions can be used for Standard and Explicit analysis, but others only for one. For simple FEM examples, surface-to-surface contact is often the best choice, but a simpler (and computationally more expensive way) is General contact. This example will use an Explicit analysis where Eulerian and Lagrangian elements interact (CEL). Therefore General contact (Explicit) has to be selected.

The interactions and the steps in the next chapter have to be chosen consistent with the type of analysis to be done.

Figure 5.2: The Create Interaction window on the left hand side and the Edit Interaction window after defining the interaction property on the right hand side.

For this General contact example, the interaction should be able to have contact with any other element (select All * with self option) Now a global property assignment has to be defined, before the interaction can be created.

Click on the Create Interaction Property icon () and select Contact to define a contact interaction property.¹⁶ To simulate the mechanical interaction between the instances, the normal contact behaviour (Mechanical->Normal behavior) and the tangential contact behavior (Mechanical->Tangential behavior) should be added.¹⁷

In this example the default options for both will do, i. e. frictionless behaviour in tangential direction and hard contact in normal direction (cf. figure 5.3). The resulting model is shown in figure 5.4.

Small circles on the respective geometry symbolize applied constraints.

Figure 5.3: The Create Interaction Property window on the left hand side and the Edit Contact Property window on the right hand side.

mdb.models['PileJackingModel'].ContactProperty('intContact');
mdb.models['PileJackingModel'].interactionProperties['intContact'].NormalBehavior(
   allowSeparation=ON, constraintEnforcementMethod=DEFAULT, pressureOverclosure=HARD);
mdb.models['PileJackingModel'].interactionProperties['intContact'].TangentialBehavior(
   formulation=FRICTIONLESS);
mdb.models['PileJackingModel'].ContactExp(createStepName='Initial', name='intGlobal');
mdb.models['PileJackingModel'].interactions['intGlobal'].includedPairs.setValuesInStep(
   stepName='Initial', useAllstar=ON);
mdb.models['PileJackingModel'].interactions['intGlobal'].contactPropertyAssignments.appendInStep(
   assignments=((GLOBAL, SELF, 'intContact'), ), stepName='Initial');

6 Steps

6.1 Creating steps

After the model geometry is set, it is time to define and apply boundary conditions and loads on the model in the Step module. This module can be accessed by either right clicking on Steps and choosing Switch context in the model tree or choosing Step in the Module drop-down menu above the viewport.

Steps are created to define a sequence of actions performed on the model. A model always has an initial step to define an original state. It is also possible to define boundary conditions, more interactions and predefined fields for this first step. Every additional step has to have a duration¹⁸ and can define custom loads.

To create a new step, either click on Steps and choose Create in the model tree, select Step->Create from the main menu or click on its quick start symbol (). The Create Step window will open (cf. figure 6.1).

The first step will be named Preparation and can be used to set up initial loads like gravity. In this example, its type should be set to Dynamic, Explicit to be compatible with the next step. In the Edit Step window, an optional description can be inserted and the time period has to be chosen (here 0.1 s).

Now the same procedure has to be repeated for another Dynamic, Explicit step named PileJacking, where the pile will be driven into the soil within 3 s. A reasonable duration is depending on the loads applied in a step, especially if they are explicitly time dependent (like velocities).

The decision whether to use Standard or Explicit analysis is depending on the problem itself. As a rule of thumb, Explicit is favored for large, nonlinear problems, fast dynamics, or problems with significant discontinuities, while Standard is rather used for linear (dynamic) and nonlinear static problems (cf. ABAQUS Inc. 2005). To use the CEL method with Lagrangian and Eulerian elements, Explicit has to be chosen.

mdb.models['PileJackingModel'].ExplicitDynamicsStep(name='Preparation', previous='Initial',
   description='Preparation step', timePeriod=0.1);
mdb.models['PileJackingModel'].ExplicitDynamicsStep(name='PileJacking', previous='Preparation',
   description='Jacking the pile into the soil', timePeriod=3.0);

Figure 6.1: The Create Step window and the Edit Step window for the Preparation step.

6.2 Boundary conditions, loads and predefined fields

Within each step, boundary conditions and loads will be applied. Therefore, the Load module has to be selected, either by the drop-down menu above the viewport or by right clicking on Loads or BCs within a step and choosing Switch context. Each step will have its own set of loads and boundary conditions.

Some options like Interactions, Contact, Loads and BCs are available in each step and can be found on a higher level in the model tree below the Steps entry. Within the steps, those options can be defined, turned on and turned off. They are saved within the higher level entries, where they can be defined globally or deleted.

To define boundary conditions, either select BC->Create in the main menu, right click on BCs within the inital step in the model tree and select Create or use the quick start symbol (). The Create Boundary Condition dialog will open (cf. figure 6.2).

The first boundary condition to be defined in the Initial step will be the fixation of the pile in all directions. Thus a Displacement/Rotation boundary condition should be applied. It can be more convenient to create two boundary conditions, one to fix all directions but the vertical one (which is valid for the whole simulation) and one to fix the downward movement in the initial step.¹⁹

The movement of the pile is constrained to the movement of the reference point, so all loads/boundary conditions of the pile will be defined for setRP of instPile. The corresponding dialogs for the permanent fixation (fixPile) are shown in figure 6.2.

mdb.models['PileJackingModel'].DisplacementBC(name='fixPile', createStepName='Initial',
   amplitude=UNSET, distributionType=UNIFORM, fieldName='', region=instPile.sets['setRP'],
   localCsys=None, u1=SET, u2=SET, u3=UNSET, ur1=SET, ur2=SET, ur3=SET);

Figure 6.2: Boundary condition dialogs. After choosing to create a boundary condition, a type must be selected (left hand side), the geometry chosen (middle) and the values selected (right hand side).

When using the default (global) coordinate system CSYS: (GLOBAL), the directions will match the standard coordinates: $1=x$, $2=y$, $3=z$.

Additionally create another Displacement/Rotation boundary condition named fixDownwardMovement in the intial step, which only fixates U3.

mdb.models['PileJackingModel'].DisplacementBC(name='fixDownwardMovement', amplitude=UNSET,
   createStepName='Initial', distributionType=UNIFORM, fieldName='', localCsys=None, 
   region=instPile.sets['setRP'], u1=UNSET, u2=UNSET, u3=SET, ur1=UNSET, ur2=UNSET, ur3=UNSET);

In the PileJacking step the pile should be driven down 3 m. The duration for this step is 3 s, so the downward velocity has to be 1 m/s. Since the soil itself is only 4 m high in this example, the boundary effects will notably influence the result. Normally, there is much more space around the pile to minimize all boundary effects.

Right click on fixDownwardMovement (Propagated) in the current step’s boundary conditions in the model tree and select Deactivate to deactivate this boundary condition from this step on forward. This can also be done in the Boundary Condition manager, which can be accessed either by the quick start symbol () next to the create boundary condition icon or by selection BC->Manager in the main menu.

Create a Velocity/Angular velocity boundary condition for setPileRP named drivePile and enter the downward velocity V3: -1.

mdb.models['PileJackingModel'].boundaryConditions['fixDownwardMovement'].deactivate(
   'PileJacking');
mdb.models['PileJackingModel'].VelocityBC(name='drivePile', createStepName='PileJacking',
   amplitude=UNSET, distributionType=UNIFORM, fieldName='', region=instPile.sets['setRP'], 
   localCsys=None, v1=UNSET, v2=UNSET, v3=-1.0, vr1=UNSET, vr2=UNSET, vr3=UNSET);

For the Eulerian material to be able to move through the mesh, a Predefined Fields entry has to be created in the initial step to assign the material for the soil. Either select the quick start symbol (), choose Predefined Field->Create in the main menu or right click on Predefined Fields in the initial step and choose Create. The Create Predefined Field window will open as shown in figure 6.3.

Choose Material assignment in the initial step and select the Eulerian instance. Assign setCellsBottom with soil material and setCellsTop with void to represent sand in the bottom part of the soil element and empty space above.

mdb.models['PileJackingModel'].MaterialAssignment(name='fieldSoilMaterial',
   instanceList=(instSoil, ), assignmentList=((instSoil.sets['setCellsBottom'], (1, )),
   (instSoil.sets['setCellsTop'], (0, ))), useFields=False);

Figure 6.3: Create Predefined Field window on the left hand side and Edit Predefined Field window for Material assignment in the middle. The Edit Predefined Field window for Geostatic stress is shown on the right hand side.

Another predefined field can be used to model the geostatic stress within the sand material. This definition has to be applied in the initial step, too. Choose Mechanical as category to be able to select Geostatic stress. Choose the setCellsBottom set and configure the parameters to have 0 kPa at the upper plane of the sand material volume and 60 kPa at the lower boundary (choose $-60$ since it is pressure and not tension). The lateral coefficient can be set to $K_0=1-\sin{\left(\varphi\right)}\approx 0.5$ (cf. right hand side of figure 6.3).

mdb.models['PileJackingModel'].GeostaticStress(lateralCoeff1=0.5, lateralCoeff2=None,
   name='fieldStress', region=instSoil.sets['setCellsBottom'], vCoord1=4.0, vCoord2=0.0,
   stressMag1=0.0, stressMag2=-60.0);

The movement of the sand at the soil boundaries has to be restricted, so that the material cannot flow out of the soil body. Since Eulerian material can move through the mesh, displacement boundary conditions aren’t useful here. Therefore, three Velocity/Angular velocity boundary conditions are created and applied on the surfaces with the same normal direction. Sets of the boundary surfaces were created in chapter 2, so that e. g. a boundary condition restricting the movement in $x$-direction (fixSoilBoundaryX) can be applied on the corresponding set (setFacesX).

After applying boundary conditions for $x$-direction, $y$-direction and the bottom of the soil, no material should be able to flow in or out of the model except the top. The result can be seen in figure 6.4.

mdb.models['PileJackingModel'].VelocityBC(name='fixSoilBoundaryX', createStepName='Initial',
   amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None, 
   region=instSoil.sets['setFacesX'],
   v1=0.0, v2=UNSET, v3=UNSET, vr1=UNSET, vr2=UNSET, vr3=UNSET);
mdb.models['PileJackingModel'].VelocityBC(name='fixSoilBoundaryY', createStepName='Initial',
   amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None, 
   region=instSoil.sets['setFacesY'],
   v1=UNSET, v2=0.0, v3=UNSET, vr1=UNSET, vr2=UNSET, vr3=UNSET);
mdb.models['PileJackingModel'].VelocityBC(name='fixSoilBoundaryZ', createStepName='Initial',
   amplitude=UNSET, distributionType=UNIFORM, fieldName='', localCsys=None, 
   region=instSoil.sets['setFacesBottom'],
   v1=UNSET, v2=UNSET, v3=0.0, vr1=UNSET, vr2=UNSET, vr3=UNSET);

Similar to boundary conditions loads can be applied. Right click on Loads and choose Create in the model tree, select Load->Create in the main menu or click on its quick start symbol (). The Create Load window will open and like creating boundary conditions, the type of load, the region to apply to and the values need to be selected.

In this example, gravity will be applied to the whole model in the Preparation step by its gravitational acceleration 9.81 m/s$^2$ in the (negative) $z$-direction (cf. figure 6.5).

mdb.models['PileJackingModel'].Gravity(comp3=-9.81, createStepName='Preparation',
   distributionType=UNIFORM, field='', name='Gravity');

Figure 6.5: The Create Load window on the left hand side and the Edit Load window for a gravitational force on the right hand side.

6.3 Output requests

Like boundary conditions, loads and predefined fields, output requests can be issued (in the Step module) either in each step or in general. A default Field Output Request and a default History Output Request will be present. Sometimes it may be useful to create new output requests, either by right clicking on the appropriate name in the model tree and choosing Create, by browsing Output-> in the main menu and choosing Create or by using the quick start symbol for a new field output request () or history output request (). As a rule of thumb, anything visible in the whole 3D-Model must be requested as Field Output and all further investigated time history/results of single points and sets should be requested as History Output.

A field output saves the requested states for certain point(s) in time for all elements. A history output saves the requested states for all time increments but only for the selected element(s).

The present output requests can be edited by the output manager, which is accessible by the quick start symbol next to the output request creation () by the model tree or the main menu (cf. figure 6.6).

Figure 6.6: Default field output request and history output request window.

In this example especially the flow of the material should be observed, which is saved in the Eulerian Volume Fraction (EVF). By default and among others, the Volume-averaged Stresses (SVAVG), the Displacements (U) and the Accelerations (A) for the soil and the Displacements (U) and Reaction Forces (RF) for the pile (i. e. its reference point) will be recorded. Other entries of the field output are of minor importance here and could be removed from the calculation.

Consider which field outputs are necessary since they can generate big output databases very fast. Issuing more output requests at more nodes/elements and increasing the outputs per seconds can also increase the computation time.

If only reference points or a few geometric objects should be observed, it is useful to create separate output requests for them. Choose the objects/sets as Domain instead of the whole model (see figure 6.6).

7 Meshing

Before creating and submitting the job the model has to be meshed. This could also be done much earlier (e. g. before assembling the parts), but has to be after all geometric changes are already applied.

Every time the geometry of a part is changed or partitions are added/removed, the mesh needs to be redone.

There are two meshing viewports: Meshing can be done per part (dependent meshes) or for the assembled model (independent meshes). To mesh dependent meshes per part, first change to the Part module and then to the Mesh module. Otherwise Abaqus will try to mesh the whole assembled model, which—in this case—isn’t desired.

Meshing is used to create nodes for calculating and evaluating the simulation. The meshing can be influenced by seeding the parts as a whole () and edgewise () to get the right amount of seeds per edge/part. Both options can also be accessed by the main menu or the model tree.

Most times it is favorable to have cube-like elements (structured hex) without any dominant direction.

If this kind of mesh can be applied, the element will be colored green. Otherwise if only a sweeped mesh can be applied, the element will be yellow. But if a hex mesh is intended but can’t be applied out of the box, partitions can help to divide the part in more suitable subparts. This can also be done to get a finer mesh locally. To change the mesh type (if possible), open the Assign Mesh Controls window ().

A coarser mesh has less nodes and needs less time to calculate. At the same time, the result might not be as precise as desired or not available at interesting points.

First, the pile should be meshed. If not done already, switch to the Mesh module and activate the pile part. Seed the whole part and choose an approximate global size of 1.0 (cf. left hand side of figure 7.1). Apply and mesh the part by the quick start symbol (), the model tree or the main menu.

partPile.seedPart(deviationFactor=0.1, minSizeFactor=0.1, size=1.0);
partPile.generateMesh();

Figure 7.1: Global Seeds window and Local Seeds window.

The meshing of the soil part will be a bit different. After making the soil element active, a global seed with an approximate global size of 0.4 will be set. Now the edges close to the pile jacking volume will be seeded () as shown in the bottom of figure 7.2. Choose in the Local Seeds window (cf. right hand side of figure 7.1) an approximate element size of 0.1.²⁰ Apply the mesh to the geometry to have a finer mesh region where the material flow is important and a coarser one everywhere else.

partSoil.seedPart(deviationFactor=0.1, minSizeFactor=0.1, size=0.4);
fineredges = partSoil.edges[0:0];
for singleedge in partSoil.edges:
   if ((singleedge.pointOn[0][1] <= 0.0) and (abs(singleedge.pointOn[0][0]) <= 1.0)):
      fineredges += partSoil.edges[singleedge.index:singleedge.index+1];
#
partSoil.seedEdgeBySize(constraint=FINER, deviationFactor=0.1, edges=fineredges,
   minSizeFactor=0.1, size=0.1);
partSoil.generateMesh();

Figure 7.2: Viewport of meshed pile (above) and meshed soil element (below). The viewport of the soil element also shows the global seeds (white circles) and the manually set edge seeds (purple triangles lines).

8 Getting the job done

8.1 Job creation and submission

All preparations are done and a new job can be created in the Job module. Either right click on Jobs and choose Create, select Job->Create in the main menu or use the quick start symbol (). The Create Job window will open as shown in figure 8.1 and the new job has to be named (this will be the name of the input file). Give a short description in the Edit Job window and for longer/critical calculations, always change the precision in the Precision tab to Double Precision. If using a user routine (e. g. user defined material), the file needs to be added in the General tab.

Figure 8.1: Create Job window (left hand side) and Edit Job window (right hand side).

Right click on the newly created job and choose Write Input to create an input file. After creating a job a stand-alone text file with all configuration is written—the input file <model>.inp. Abaqus can run this file to do the simulation.

mdb.Job(activateLoadBalancing=False, atTime=None, contactPrint=OFF,
   description='Jacking the pile into the soil (3.1s total)', echoPrint=OFF,
   explicitPrecision=DOUBLE_PLUS_PACK, historyPrint=OFF, memory=90, memoryUnits=PERCENTAGE,
   model='PileJackingModel', modelPrint=OFF, multiprocessingMode=DEFAULT,
   name='job_PileJacking', nodalOutputPrecision=FULL, numCpus=1, numDomains=1,
   parallelizationMethodExplicit=DOMAIN, queue=None, resultsFormat=ODB, scratch='',
   type=ANALYSIS, userSubroutine='', waitHours=0, waitMinutes=0);
mdb.jobs['job_PileJacking'].writeInput(consistencyChecking=OFF);

After creating a job and before submission, it is advisable to run a data check. Either select Job->Data Check-> in the main menu or right click on the job and choose Data Check. Most formal errors in the model can be found and will be reported. A successfull data check is a prerequisite for running the simulation.

Always run a data check before submission to exclude most formal errors before starting the simulation.

Data checks and simulations always create additional status files, especially <model>.dat and <model>.sta. Both text files can be used to gather information about the calculation as well as warnings and error messages. They can also be accessed by right clicking on the job name and choosing Monitor. If problems are encountered, try to correct them and rerun the data check/simulation.

Small jobs can be run in the Abaqus CAE gui while bigger jobs are preferably outsourced to a computation cluster (if available).

8.2 Concerning Input files

This section will show and discuss the input file created by this tutorial. The only difference is that a much coarser mesh is used for the soil body than described in chapter 7 to prevent an unnecessary data overhead for the discussion. The mesh applied to the pile has an approximate global size of 2, the mesh for the soil consists only of the global seeds with a size of 1 resulting in a model shown in figure 8.2. The input file looks like this:

*Heading
 Jacking the pile into the soil (3s total)
** Job name: job_PileJacking Model name: PileJackingModel
** Generated by: Abaqus/CAE 6.14-1
*Preprint, echo=NO, model=NO, history=NO, contact=NO
**
** PARTS
**

*Part, name=Pile
*Node
      1,          0.5,         0.25,          10.
      2,          0.5,        -0.25,          10.
      3,          0.5,         0.25,           8.
      4,          0.5,        -0.25,           8.
      5,          0.5,         0.25,           6.
      6,          0.5,        -0.25,           6.
      7,          0.5,         0.25,           4.
      8,          0.5,        -0.25,           4.
      9,          0.5,         0.25,           2.
     10,          0.5,        -0.25,           2.
     11,          0.5,         0.25,           0.
     12,          0.5,        -0.25,           0.
     13,         -0.5,         0.25,          10.
     14,         -0.5,        -0.25,          10.
     15,         -0.5,         0.25,           8.
     16,         -0.5,        -0.25,           8.
     17,         -0.5,         0.25,           6.
     18,         -0.5,        -0.25,           6.
     19,         -0.5,         0.25,           4.
     20,         -0.5,        -0.25,           4.
     21,         -0.5,         0.25,           2.
     22,         -0.5,        -0.25,           2.
     23,         -0.5,         0.25,           0.
     24,         -0.5,        -0.25,           0.

*Element, type=C3D8R
1, 13, 14, 16, 15,  1,  2,  4,  3
2, 15, 16, 18, 17,  3,  4,  6,  5
3, 17, 18, 20, 19,  5,  6,  8,  7
4, 19, 20, 22, 21,  7,  8, 10,  9
5, 21, 22, 24, 23,  9, 10, 12, 11

*Node
     25,           0.,        -0.25,          10.
*Nset, nset=Pile-RefPt_, internal
25,
*Nset, nset=setAll, generate
  1,  24,   1
*Elset, elset=setAll, generate
 1,  5,  1
*Nset, nset=setRP
 25,

** Section: secPile
*Solid Section, elset=setAll, material=steel
,
*End Part
**

*Part, name=Soil
*Node
      1,           2.,           0.,           4.
      2,           2.,           0.,           0.
      3,           2.,           1.,           0.
      4,           2.,           1.,           4.
      5,           1.,           0.,           4.
      6,           1.,           0.,           0.
      7,           1.,           1.,           0.
      8,           1.,           1.,           4.
      9,          -1.,           0.,           0.
     10,          -1.,           1.,           0.
     11,          -1.,           0.,           4.
     12,          -1.,           1.,           4.
     13,          -2.,           0.,           6.
     14,          -1.,           0.,           6.
     15,          -1.,           1.,           6.
     16,          -2.,           1.,           6.
     17,          -2.,           0.,           4.
     18,          -2.,           1.,           4.
     19,           2.,           0.,           6.
     20,           2.,           1.,           6.
     21,           1.,           0.,           6.
     22,           1.,           1.,           6.
     23,          -2.,           1.,           0.
     24,          -2.,           0.,           0.
     25,          -1.,          -1.,           0.
     26,          -1.,          -1.,           4.
     27,          -2.,          -1.,           4.
     28,          -2.,          -1.,           0.
     29,          -1.,          -1.,           6.
     30,           1.,          -1.,           4.
     31,           1.,          -1.,           6.
     32,           2.,          -1.,           6.
     33,           2.,          -1.,           4.
     34,          -2.,          -1.,           6.
     35,           1.,          -1.,           0.
     36,           2.,          -1.,           0.
     37,           2.,           0.,           3.
     38,           2.,           0.,           2.
     39,           2.,           0.,           1.
     40,           2.,           1.,           1.
     41,           2.,           1.,           2.
     42,           2.,           1.,           3.
     43,           1.,           0.,           3.
     44,           1.,           0.,           2.
     45,           1.,           0.,           1.
     46,           1.,           1.,           1.
     47,           1.,           1.,           2.
     48,           1.,           1.,           3.
     49,           0.,           0.,           0.
     50,           0.,           1.,           0.
     51,           0.,           0.,           4.
     52,           0.,           1.,           4.
     53,          -1.,           1.,           1.
     54,          -1.,           1.,           2.
     55,          -1.,           1.,           3.
     56,          -1.,           0.,           3.

     57,          -1.,           0.,           2.
     58,          -1.,           0.,           1.
     59,          -2.,           1.,           5.
     60,          -2.,           0.,           5.
     61,          -1.,           1.,           5.
     62,          -1.,           0.,           5.
     63,           2.,           0.,           5.
     64,           2.,           1.,           5.
     65,           1.,           0.,           5.
     66,           1.,           1.,           5.
     67,           0.,           0.,           6.
     68,           0.,           1.,           6.
     69,          -2.,           1.,           3.
     70,          -2.,           1.,           2.
     71,          -2.,           1.,           1.
     72,          -2.,           0.,           1.
     73,          -2.,           0.,           2.
     74,          -2.,           0.,           3.
     75,          -1.,          -1.,           1.
     76,          -1.,          -1.,           2.
     77,          -1.,          -1.,           3.
     78,          -2.,          -1.,           3.
     79,          -2.,          -1.,           2.
     80,          -2.,          -1.,           1.
     81,          -1.,          -1.,           5.
     82,           0.,          -1.,           4.
     83,           1.,          -1.,           5.
     84,           0.,          -1.,           6.
     85,           2.,          -1.,           5.
     86,          -2.,          -1.,           5.
     87,           0.,          -1.,           0.
     88,           1.,          -1.,           1.
     89,           1.,          -1.,           2.
     90,           1.,          -1.,           3.
     91,           2.,          -1.,           3.
     92,           2.,          -1.,           2.
     93,           2.,          -1.,           1.
     94,           0.,           0.,           1.
     95,           0.,           0.,           2.
     96,           0.,           0.,           3.
     97,           0.,           1.,           1.
     98,           0.,           1.,           2.
     99,           0.,           1.,           3.
    100,           0.,           0.,           5.
    101,           0.,           1.,           5.
    102,           0.,          -1.,           5.
    103,           0.,          -1.,           3.
    104,           0.,          -1.,           2.
    105,           0.,          -1.,           1.

*Element, type=EC3D8R
 1,  5, 43, 48,  8,  1, 37, 42,  4
 2, 43, 44, 47, 48, 37, 38, 41, 42
 3, 44, 45, 46, 47, 38, 39, 40, 41
 4, 45,  6,  7, 46, 39,  2,  3, 40
 5, 45, 94, 97, 46,  6, 49, 50,  7
 6, 94, 58, 53, 97, 49,  9, 10, 50
 7, 44, 95, 98, 47, 45, 94, 97, 46
 8, 95, 57, 54, 98, 94, 58, 53, 97

 9, 43, 96, 99, 48, 44, 95, 98, 47
10, 96, 56, 55, 99, 95, 57, 54, 98
11,  5, 51, 52,  8, 43, 96, 99, 48
12, 51, 11, 12, 52, 96, 56, 55, 99
13, 60, 62, 61, 59, 13, 14, 15, 16
14, 17, 11, 12, 18, 60, 62, 61, 59
15, 21, 65, 66, 22, 19, 63, 64, 20
16, 65,  5,  8, 66, 63,  1,  4, 64
17,  11,  51,  52,  12,  62, 100, 101,  61
18,  51,   5,   8,  52, 100,  65,  66, 101
19,  62, 100, 101,  61,  14,  67,  68,  15
20, 100,  65,  66, 101,  67,  21,  22,  68
21, 74, 56, 55, 69, 17, 11, 12, 18
22, 73, 57, 54, 70, 74, 56, 55, 69
23, 72, 58, 53, 71, 73, 57, 54, 70
24, 24,  9, 10, 23, 72, 58, 53, 71
25,  9, 58, 72, 24, 25, 75, 80, 28
26, 58, 57, 73, 72, 75, 76, 79, 80
27, 57, 56, 74, 73, 76, 77, 78, 79
28, 56, 11, 17, 74, 77, 26, 27, 78
29,  14,  62, 100,  67,  29,  81, 102,  84
30,  62,  11,  51, 100,  81,  26,  82, 102
31,  67, 100,  65,  21,  84, 102,  83,  31
32, 100,  51,   5,  65, 102,  82,  30,  83
33,  5, 65, 83, 30,  1, 63, 85, 33
34, 65, 21, 31, 83, 63, 19, 32, 85
35, 11, 62, 60, 17, 26, 81, 86, 27
36, 62, 14, 13, 60, 81, 29, 34, 86
37,  11,  56,  96,  51,  26,  77, 103,  82
38,  56,  57,  95,  96,  77,  76, 104, 103
39,  57,  58,  94,  95,  76,  75, 105, 104
40,  58,   9,  49,  94,  75,  25,  87, 105
41,  51,  96,  43,   5,  82, 103,  90,  30
42,  96,  95,  44,  43, 103, 104,  89,  90
43,  95,  94,  45,  44, 104, 105,  88,  89
44,  94,  49,   6,  45, 105,  87,  35,  88
45,  6, 45, 88, 35,  2, 39, 93, 36
46, 45, 44, 89, 88, 39, 38, 92, 93
47, 44, 43, 90, 89, 38, 37, 91, 92
48, 43,  5, 30, 90, 37,  1, 33, 91

*Nset, nset=setAll, generate
   1,  105,    1
*Elset, elset=setAll, generate
  1,  48,   1
*Nset, nset=setCellsTop
   1,  4,  5,  8, 11, 12, 13, 14, 15, 16,  17,  18,  19, 20, 21, 22
  26, 27, 29, 30, 31, 32, 33, 34, 51, 52,  59,  60,  61, 62, 63, 64
  65, 66, 67, 68, 81, 82, 83, 84, 85, 86, 100, 101, 102
*Elset, elset=setCellsTop
 13, 14, 15, 16, 17, 18, 19, 20, 29, 30, 31, 32, 33, 34, 35, 36
*Nset, nset=setCellsBottom
   1,  2,  3,  4,  5,  6,  7,  8,   9,  10,  11, 12, 17, 18, 23, 24
  25, 26, 27, 28, 30, 33, 35, 36,  37,  38,  39, 40, 41, 42, 43, 44
  45, 46, 47, 48, 49, 50, 51, 52,  53,  54,  55, 56, 57, 58, 69, 70
  71, 72, 73, 74, 75, 76, 77, 78,  79,  80,  82, 87, 88, 89, 90, 91
  92, 93, 94, 95, 96, 97, 98, 99, 103, 104, 105
*Elset, elset=setCellsBottom
  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 21, 22, 23, 24
 25, 26, 27, 28, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48

*Nset, nset=setFacesX
  1,  2,  3,  4, 13, 16, 17, 18, 19, 20, 23, 24, 27, 28, 32, 33
 34, 36, 37, 38, 39, 40, 41, 42, 59, 60, 63, 64, 69, 70, 71, 72
 73, 74, 78, 79, 80, 85, 86, 91, 92, 93
*Elset, elset=setFacesX
  1,  2,  3,  4, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 27, 28
 33, 34, 35, 36, 45, 46, 47, 48
*Nset, nset=setFacesY
   3,   4,   7,   8,  10,  12, 15, 16, 18, 20, 22, 23, 25, 26, 27, 28
  29,  30,  31,  32,  33,  34, 35, 36, 40, 41, 42, 46, 47, 48, 50, 52
  53,  54,  55,  59,  61,  64, 66, 68, 69, 70, 71, 75, 76, 77, 78, 79
  80,  81,  82,  83,  84,  85, 86, 87, 88, 89, 90, 91, 92, 93, 97, 98
  99, 101, 102, 103, 104, 105
*Elset, elset=setFacesY, generate
  1,  48,   1
*Nset, nset=setFacesBottom
  2,  3,  6,  7,  9, 10, 23, 24, 25, 28, 35, 36, 49, 50, 87
*Elset, elset=setFacesBottom
  4,  5,  6, 24, 25, 40, 44, 45

** Section: secSoil
*Eulerian Section, elset=setAll
sand, instsand
*Surface, type=EULERIAN MATERIAL, name=instsand
instsand
*End Part
**
**

** ASSEMBLY
**
*Assembly, name=Assembly
**
*Instance, name=instPile, part=Pile
          0.,        -0.75,           4.
*End Instance
**
*Instance, name=instSoil, part=Soil
*End Instance
**

** Constraint: RigidRPSteelpile
*Rigid Body, ref node=instPile.setRP, elset=instPile.setAll
*End Assembly
**
** MATERIALS
**

*Material, name=sand
*Density
 1.6,
*Elastic
30000., 0.25
*Material, name=steel
*Density
 7.87,
*Elastic
 2.1e+08, 0.3
**

** INTERACTION PROPERTIES
**
*Surface Interaction, name=intContact
*Friction
0.,
*Surface Behavior, pressure-overclosure=HARD
**

** BOUNDARY CONDITIONS
**
** Name: fixDownwardMovement Type: Displacement/Rotation
*Boundary
instPile.setRP, 3, 3
** Name: fixPile Type: Displacement/Rotation
*Boundary
instPile.setRP, 1, 1
instPile.setRP, 2, 2
instPile.setRP, 4, 4
instPile.setRP, 5, 5
instPile.setRP, 6, 6
** Name: fixSoilBoundaryX Type: Velocity/Angular velocity
*Boundary, type=VELOCITY
instSoil.setFacesX, 1, 1
** Name: fixSoilBoundaryY Type: Velocity/Angular velocity
*Boundary, type=VELOCITY
instSoil.setFacesY, 2, 2
** Name: fixSoilBoundaryZ Type: Velocity/Angular velocity
*Boundary, type=VELOCITY
instSoil.setFacesBottom, 3, 3
**

** PREDEFINED FIELDS
**
** Name: fieldSoilMaterial   Type: Material assignment
*Initial Conditions, type=VOLUME FRACTION
instSoil.setCellsBottom, instSoil.instsand, 1.
** Name: fieldStress   Type: Geostatic stress
*Initial Conditions, type=STRESS, GEOSTATIC
instSoil.setCellsBottom, 0., 4., -60., 0., 0.5, 0.5
**
** INTERACTIONS
**

** Interaction: intGlobal
*Contact, op=NEW
*Contact Inclusions, ALL EXTERIOR
*Contact Property Assignment
 ,  , intContact
** ----------------------------------------------------------------
**

** STEP: Preparation
**
*Step, name=Preparation, nlgeom=YES
Preparation step
*Dynamic, Explicit
, 0.1
*Bulk Viscosity
0.06, 1.2
**

** LOADS
**
** Name: Gravity   Type: Gravity
*Dload
, GRAV, 9.81, 0., 0., -1.
**
** OUTPUT REQUESTS
**
*Restart, write, number interval=1, time marks=NO
**

** FIELD OUTPUT: F-Output-1
**
*Output, field, variable=PRESELECT
**
** HISTORY OUTPUT: H-Output-1
**
*Output, history, variable=PRESELECT
*End Step
** ----------------------------------------------------------------
**

** STEP: PileJacking
**
*Step, name=PileJacking, nlgeom=YES
Jacking the pile into the soil
*Dynamic, Explicit
, 3.
*Bulk Viscosity
0.06, 1.2
**
** BOUNDARY CONDITIONS
**

** Name: drivePile Type: Velocity/Angular velocity
*Boundary, op=NEW, type=VELOCITY
instPile.setRP, 3, 3, -1.
** Name: fixDownwardMovement Type: Displacement/Rotation
*Boundary, op=NEW
** Name: fixPile Type: Displacement/Rotation
*Boundary, op=NEW
instPile.setRP, 1, 1
instPile.setRP, 2, 2
instPile.setRP, 4, 4
instPile.setRP, 5, 5
instPile.setRP, 6, 6
** Name: fixSoilBoundaryX Type: Velocity/Angular velocity
*Boundary, op=NEW, type=VELOCITY
instSoil.setFacesX, 1, 1
** Name: fixSoilBoundaryY Type: Velocity/Angular velocity
*Boundary, op=NEW, type=VELOCITY
instSoil.setFacesY, 2, 2
** Name: fixSoilBoundaryZ Type: Velocity/Angular velocity
*Boundary, op=NEW, type=VELOCITY
instSoil.setFacesBottom, 3, 3
**
** OUTPUT REQUESTS
**
*Restart, write, number interval=1, time marks=NO
**

** FIELD OUTPUT: F-Output-1
**
*Output, field, variable=PRESELECT
**
** HISTORY OUTPUT: H-Output-1
**
*Output, history, variable=PRESELECT
*End Step

9 Visualize the results

The partial or complete results of a simulation can be analyzed and visualized in the Visualization module. The results are stored in the output database file <model>.odb. An arbitrary model output database can be opened by selecting File->Open.²¹

If the output database is in the same directory as the opened model file <model>.cae or if the calculation was small enough and has been run in the graphical interface, it can directly be accessed by right clicking on Jobs and choosing Results. Choosing Visualization in the module drop-down menu above the viewport loads the last used output data base.

If the simulation didn’t successfully finish, check the <model>.sta and <model>.dat files and try to correct all errors.

9.1 Field output

Figure 9.1 shows the deformed model after simulation and with some graphical adaptions described below. Either select Plot->Contours->On Deformed Shape in the main menu, or use its quick start symbol () to view the deformed shape of the model.

The variables selected in field/history output requests can be visualized or plotted here. To view a certain field output variable, either select Result->Field Output in the main menu or the Field Output Dialog symbol () beneath the main menu. Next to this symbol, the output variable can also be selected by three drop-down menus.

Graphical options like which lines are shown and which color spectrum is used can be changed within the Contour Plot Options window and the Common Plot Options window (cf. figure 9.2). To open the Contour Plot Options window, select Options->Contour in the main menu or use its quick start symbol (). The Common Plot Options window can be accessed by Options->Common in the main menu.

Figure 9.2: Viewport Annotation dialog on the left hand side, the Common Plot Options window in the middle and Contour Plot Options dialog on the right hand side.

To show or hide graphical objects like the compass in the viewport, open the Viewport Annotation Options window by selecting Viewport->Viewport Annotation Options in the main menu.

Images of the model which are to be inserted in a thesis or paper should be saved as Encapsulated PostScript (.eps) files, to minimize losing image quality when scaling.

Remove all unwanted elements from the viewport using the Annotation Option window and select File->Print in the main menu. Select the current viewport and eps as output format in the Print window (cf. figure 9.3) and go to the Encapsulated PostScript Options window by clicking on the appropriate icon () to choose 300 dpi as resolution.

Figure 9.3: Print window and Encapsulated PostScript Options window with customized options.

The simulation can also be animated for any state variable, either by using the quick start symbol (), or by selecting Animate->Time History in the main menu. The animation can be saved by selecting Animate->Save As.

In case some variable states beneath the surface are of interest, a cut can be created. Open the View Cut Manager by selecting Tools->View Cut->Manager in the main menu or its icon () next to the Activate View Cut icon (). The principal planes are already available and can be selected or custom planes can be created.

9.2 History output

Plots can be created by using the history output. Open the History Output window by either selecting Result->History Output in the main menu, or by right clicking on XYData in the model tree, choosing Create and selecting ODB history output in the Create XYData window (cf. figure 9.4). As for field output variables, only the selected values in the model output requests can be chosen. To save a data set for plotting elsewhere, choose Report->XY in the main menu and select the XY Data to save.

Figure 9.4: Create XY Data window on the left hand side and History Output window on the right hand side.

Sometimes it may be interesting not only to plot values over time, but over another variable. For every plot a _temp_ variable will be created automatically in the model tree under XYData. The data can also be saved manually by Save As... from the History or Field Output window. Choose the variables and save their results, so that both entries are listed in the model tree under XYData.

Now select Tools->XY Data->Create in the main menu or right click on XYData in the model tree and choose Create. In the Create XYData window select Operate on XY data. Select the combine() Operator and double click on both XY data sets, so that something similar to combine( "dataset1", "dataset2" ) is shown in the upper area. Now the data set can be plotted or saved.

Bibliography