Report Modelling of origami concrete crease pattern and export into Abaqus using open source software – Pyformex Name: Viktoras Jarmolkovicius Home university: University of Sheffield Host institute: RWTH – Institut für Massivbau Project supervisor: Jan Dirk van Der Woerd Duration: 2014.06.09 – 2014.08.01
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Report
Modelling of origami concrete crease pattern and export into Abaqus using open source software – Pyformex
Name: Viktoras Jarmolkovicius
Home university: University of Sheffield
Host institute: RWTH – Institut für Massivbau
Project supervisor: Jan Dirk van Der Woerd
Duration: 2014.06.09 – 2014.08.01
2
Table of Contents
Executive Summary 3
Introduction 3
Exploration of Pyformex functionality 4
General information 4
Features worth mentioning 5
Creation of the crease and export into Abaqus 5
1. Input Parameters 5
2. Reading of data 6
3. Offset 6
4. Creation of crease 7
5. Subdivision (Meshing) 7
6. Assignment of properties and .inp export 8
Analysis of Abaqus 8
Conclusions 9
References 9
Appendix 10
3
Executive Summary
This report focuses on the presentation of the internship project that was undertaken in the Institute
for Structural Concrete, RWTH, Aachen, Germany, under supervision of Mr. Jan Dirr van der Woerd.
The main purpose of the project was to develop a software tool (code) to facilitate the analysis of
Textile Reinforced Concrete plate structures via the Finite Element Method. Firstly, the detailed
scope of the project is introduced and important background information is given to present already
existing and available facilities and to present associated expectations and further development
areas. The main body of the report consists of 3 main sections: exploration of existing Pyformex
software functionality, development of the analysis tool and modelling of laboratory test in Abaqus.
Images and brief explanations are given where appropriate. In the end, the outcome of the project is
concluded and an appendix featuring a full detailed script of the tool is given for reference purposes.
Introduction
Internship material focuses on some specific areas of a major research project which is being carried
out in the Institut für Massivbau in RWTH, Aachen under supervision of the doctoral student Jan Dirk
van Der Woerd and the research assistant Mr. Rotislav Chudoba. So far, a computer simulation
platform was developed which creates a 3D structure consisting of folded TRC concrete plates.
Simulation software is undergoing constant development and in order to achieve satisfying results a
specific definition of the crease pattern that joins TRC plates is necessary. Internship covers explicit
definition and modelling of a crease pattern using open source python-based software Pyformex.
After crease patterned was appropriately modelled, it is expected to be meshed into Finite Elements
and prepared for subsequent analysis in Abaqus. Internship outcome also includes the exploration of
the functionality of Pyformex for the main research application and generally learning how to use
Pyformex and Abaqus and familiarise myself better with Finite Element Analysis for Structural
Engineering Applications. Ultimate goal is to use Abaqus to simulate the laboratory experiment
performed on a real structure.
Pyformex is open source software which is undergoing constant development and changes, yet it is
free and easily accessible to a new user. For the purpose of the research project, Pyformex is
intended to be used as an intermediate step between Oricrete Simulation Platform and Finite
Element Analysis Software Abaqus with an ultimate intention to integrate all the steps as modules
and plugins into Oricrete Simulation Platform.
4
The process could be visualized as follows:
Exploration of Pyformex functionality
General information
The exploration has revealed that Pyformex is very powerful software that is capable of performing
different actions related to objects, their properties with an ultimate intention to create an input file
(.inp) for analysis in Abaqus. A detailed description of all Pyformex functions is available in the
keyword manual accessible at http://nongnu.mirrors.hostinginnederland.nl//pyformex/pyformex.pdf
The manual provides a total overview of the functionality, however does not include any comments
on how to implement the functions, examples should be sought elsewhere. It gives a good idea of
what Pyformex is capable of though: it is possible to perform majority of mathematical and
geometrical operations, since Pyformex has a module called “numpy” in its library.
A very good source of data which was used extensively during the internship is the website called
“nullege”. It contains numerous .py files with all plugins, also working and useful examples, such as
Fe_Abq.py where a random object is created, manipulated, meshed, assigned different properties to
and finally written as a .inp file. This example was extensively referred to while creating a code for
export of .inp file of the crease. The author of the scripts is the creator of the Pyformex himself –
Similar to programing in “Eclipse” various modules and plugins have to be imported in order
to use their functionality.
Pyformex can perform some very useful geometrical and mathematical operations, like
creating a Finite Element Mesh for instance, but certain operations can be performed only on
specific object classes. The most usual ones are “Formex”, “TriSurface”, “Array”, “Mesh”.
Necessity for usage of different classes will be elaborated on in the next section.
Pyformex is similar to CAD software in a way that objects and files can be
imported/created/manipulated/exported both via direct scripting (writing appropriate
commands) and via the usage of graphical user interface (using toolbars and drawing options).
Pyformex has a very convenient and user friendly drawing facility of the “Formex” class which
is the most frequently used one. Command is simply draw(g) where “g” is a “Formex” object.
Also conversion from an “array” to “Formex” is very simple. This is very useful, because it is
convenient to perform mathematical and geometrical operations on “arrays” using “numpy”
functions. A modified object can be easily drawn afterwards.
“Formices” of same plexitude can be superposed to one another by a simple mathematical addition operation (+). Plexitude refers to the number nodes that compose a single element.
Creation of the crease and export into Abaqus
This section is mainly structured in way that a brief explanation of the code will be presented
alongside with illustrative images whereas a detailed version of the code can be found in the
appendix of the report – thus the focus will be kept on the most important aspects and concepts of
the tool that was developed during an internship. The code was run and tested to work properly on
both Pyformex and Abaqus, provided that two input files 'nodes.txt' and 'elements.txt' (described in
more detail in the next section) are given. Although the code addresses a particular crease pattern
arrangement, it is generally multipurpose and is applicable to any number of elements.
1. Input Parameters
This is where the actual work on input data begins. Some very basic user input parameters have to
be specified. Changing one of those values will affect the gaps between elements and the size of
the mesh. These parameters define the outcome of the analysis:
1. Number of elements
2. Number of divisions, or mesh density
3. Crease mesh density
4. Offset distance
Offset distance – is unitless but is essentially of the same units as coordinates. So if coordinates
are implied to be in centimetres then distance will be implied in centimetres too.
6
2. Reading of data
Lists of nodes and nodal connectivity are imported into Pyformex and converted into a “Formex”
class. Files “nodes.txt” and “elements.txt” are essentially the only input parameters and they are
being manipulated later. Nodes file should be structured in a way that numbers are x,y,z
coordinates of each node 0,1,2…,n:
0.0536, 0.0024, 0.0412,
0.0536, 0.4012, 0.0412,
0.0536, 0.8000, 0.0412,
0.3555, 0.0024, 0.2184,
Numbering is implied. Within itself Pyformex counts starting with zero: 0,1,2,…,n. Elements file
would have a very similar structure:
0, 3, 19,
1, 4, 20,
3, 6, 21,
4, 7, 22,
Again, numbering of elements is implied. Numbers show the connectivity of nodes. For example,
element 0 connects nodes 0, 3 and 19 and so on. This essentially means that the output file from
the ‘Oricrete’ Platform should be modified such that all nodes have number values minus one.
Input data can be presented in the visual form:
3. Offset
Now elements are offset by a certain user defined distance specified at the beginning of the script
(mentioned above). Offsetting is based on area coordinate method which ensures that each side
of the triangle is moved by a constant distance. Pyformex by default used unitless numbers.
Therefore the units of the distance are the same as units of length and area of the triangle. This
means that if a user gives nodal coordinate date in centimetres, then offset distance will be
understood in centimetres too.
7
4. Creation of crease
Once triangles are offset, the crease has to be created, joining the gaps between triangles. The
script works in such way that on the lowest level 2 adjacent triangles are analysed at one time: 4
nodes defining a gap between 2 triangles are located and are used to create a new “Formex”.
Once this “Formex” is created, rest of the operations remain the same regardless of which two of
the triangles of the general structure are analysed. A newly created “Formex” is a 4-plex structure
(definition of plexitude is explained above) which is essentially a desired crease assuming the
structure is 3D but consists of 2D plates.
5. Subdivision (Meshing)
By this point there are two objects created: a 3-plex Formex of offset triangles and a 4-plex
Formex consisting of the crease elements. Due to the fact that assignment of properties can be
done to object of same plexitude only, each of the crease elements has to be subdivided into two
triangles. Superposition of the triangles’ Formex and crease Formex gives the desired final
structure, it is, however, convenient to keep them two separate because later different properties
are assigned to them. This is what the final superposed Formex looks like:
8
6. Assignment of properties and .inp export
Last section of the code is creation of the .inp file which itself consists of 3 main subparts: creation
of properties, assignment of properties and export of the .inp file ready for analysis in Abaqus.
First of all, property database is created. It is very important to import properties’ plugin and make
sure that the name of the property database (which can be essentially arbitrary) is consistently
followed through the rest of the process, because this is where all the properties of the entire
structure are stored and read from. Next, final Formex is converted into TriSurface so that nodes
and elements can be easily obtained. These will be required later, during the export of .inp file. It
is important to note here at this point that we are working with one unique Formex by the name
“final” but its constituents – crease and triangles are still having their nodes and elements
indirectly associated with them. We assign two properties: “pa” and “pb” which are nothing else
but colors (1 and 2 in this example) to triangles and crease respectively. This is not used directly
but assists later in creation of two different kinds of element sets that will have different
properties assigned to them. After that, a standard procedure for creating material properties,
section properties and creation of the sections follows. Once that is done, element properties can
be assigned to their respective sets (colours) and saved in the property database. Next, boundary
and loaded node sets are defined by the user. A standard procedure for nodal property
assignment follows. Finally, nodes, elements and property database, also output requests and
loading steps are all put together and an export file of the format .inp is created and run in
Abaqus.
Analysis of Abaqus
An example of loading the crease pattern:
Boundary: edges are pinned
Loading: 6 point loads applied at middle crease gap
Plates are modelled as thin steel shell elements
Crease is modelled as thin glass shell elements
9
Conclusions
This project proved that Pyformex indeed offers great assistance and already existing functionality to
manipulate both simple and complex geometrical objects with the purpose of either performing
Finite Element Analysis directly or preparing the input file for analysis in other FE software programs.
It is important to note that further development of the tool is necessary to account for real geometry
and improve the simulation of the laboratory experiment. Another valuable conclusion is the
reliability aspect of open source software: it was observed that there are multiple errors and
functions that do not work properly and/or are not designed and explained completely. The risks of
using constantly changing open source software have to be properly assessed and evaluated before