Tutorial 09 02_12

Istituto di Scienza e Tecnologie
dell'Informazione ”A. Faedo”

The NOSA-ITACA Integrated Software:
Some Examples
Author: Vincenzo Binante†
email: vincenzo.binante@isti.cnr.it

Links:
• Mechanics of Materials and Structures Laboratory • Salome CAD/CAE Platform
• Dipartimento di Costruzioni e Restauro (Unifi) • Nosa-Itaca
• Consiglio Nazionale delle Ricerche (CNR) • Regione Toscana

Contents

Part I:
➢
Creating a geometry and mesh in the Salome CAD/CAE platform;
➢
Creating an external python script, for which some variables must
be assigned ( e.g., material property, thickness, loads, boundary
conditions,...);
➢
Generating a Nosa card ”.crd” from the python console of Salome
GUI;
➢
Launching the Nosa solver from the python console of Salome GUI;
➢
Launching a Fortran user-program from the python console of
Salome GUI; this program generates an output MED file from
the ”.t19” result file.
➢
Viewing the numerical results in Salome GUI;
vincenzo.binante@isti.cnr.it 2

Contents

Part II:

➢
Import a Nosa card ”.crd” into Salome GUI, where the mesh,
node/element groups will be created;

➢
Import an output file ”.t19” into Salome GUI to view the numerical
results.


Example 1: 2D plane stress analysis of a squared hollow
panel made of masonry-like material subjected to its own
weight and a surface load
Geometry and Loads
p = 100 Pa

1m

1.5 m
3m

4.5 m


Starting up Salome:
Open a terminal, then type the following command line: runSalome.
The Salome GUI module will start.

Step 1: Create two rectangles of sizes 4.5 x 3 m and 1.5 x 1 m
From Salome GUI, select File → New to create a new study.


Activate the Geometry module by selecting Geometry from the
SALOME pulldown menu:

or by clicking on the icon

Create the outer rectangle through menu New Entity → Primitives →
Rectangle

The Rectangle Construction dialogue box will open.
Type ”pannello” in the Result Name field.


In the same dialogue box type 4.5 and 3 in the Height and Width fields,
respectively. Then in the Orientation field options, select the plane on
which the rectangle is to lie (the default options are OXY, OXY or OZX).
Click Apply and Close to create the rectangle.

Note: If the rectangle is not to lie on one of
the three main planes, select the right-
hand icon (circled in red) to use either a
pre-existing face as the plane or a pre-
existing edge to define the unit outward
normal to the plane.

After clicking Apply and Close, the rectangle will be displayed in the OCC-
viewer window. To change the display mode, right click on the rectangle,
then in the pop-up menu select Display Mode → Shading


In the same way, create the 2nd, 1.5 x 1 m rectangle and name it ”finestra”.

Note: The foregoing procedure creates rectangles whose centers are
coincident and located at the origin of the global system. The 2nd rectangle
can be offset from the first as desired by making a translation through the
menu sequence: Operations → Transformation → Translation.

Step 2: Hollow out the panel by cutting

Select Operations → Boolean → Cut. In the ”Cut Two Objects” dialogue
that opens, accept the default (e.g., Cut_1) in the ”Result Name” field. Then,
in the ”Main Object” field, select ”pannello” from the Object Browser or the
OCC-viewer and in ”Tool Object” select ”finestra”. Click on Apply and
Close to see the results.


To display only the object resulting from the cut operation, right click on
Cut_1 from the Object Browser and select the ”Show Only” option from the
pop-up menu.


Once the hollow panel's geometry has been created, we need to partition it
into several sub-components (such as edges, faces, and/or blocks), to
which the mesh creation algorithms and hypotheses will apply.
First, we need to create 8 faces and 8 points by selecting New Entity →
Basic → Point.
By default, points are created by entering their coordinates. Here we instead
use an alternate procedure: open the ”Point Construction” dialogue and
select the 2nd option:


This will create points by offsetting them one from the other. In the ”Point
with reference” field, insert the left-bottom vertex of the finestra by selecting
it in the OCC-viewer, then type in offset values Dx, Dy and Dz. The resulting
coordinates of the new points will be shown in the ”Result coordinates” field.
Click on Apply and finally Apply and Close. The points to be created are
shown in the figure below


We can now create 8 faces from the points defined: select New Entity →
Blocks → Quadrangle Face and select the boundary vertices of a face.


Next we create a shell from the 8 faces. Open New Entity → Build →
Shell, and in the pop-up dialogue, type ”pannello_forato” in the ”Name” field
and select the 8 faces in ”Objects”. Click on Apply and Close.


Now we define the sub-components of the pannello_forato object by
selecting New Entity → Explode.


Likewise, we can explode the geometry of Cut_1. The difference between
the objects Cut_1 and pannello_forato depends on their sub-components.
Therefore, different mesh types can be generated from their geometries . As
will been seen later, only non-structured meshes can be obtained from the
geometry of Cut_1; a structured mesh will instead be generated from the
geometry of pannello_forato .

Step 4: Create a mesh from the geometry of Cut_1

Activate the mesh module from the menu or by clicking the icon
A VTK-viewer window will be created: to display the geometry of Cut_1,
right click on it in the Object Browser, and select ”Show”.
Select Mesh → Create Mesh and the ”Create Mesh” dialogue will open. In
the ”Geometry” field, type Cut_1 by selecting it from the Object Browser and
accept the default mesh name Mesh_1; then select tab 1D.

Then in the ”Algorithm” field, select Wire discretisation and click on the
button next to the ”Hypothesis” field and select Nb. Segments - a new
dialog will open where we can define the ”global” number of sub-intervals
into which which any edge can be split. Thus, in the ”Name” field, type
”algo1D_globale” and in ”Number of Segments” input 10. Accept the
default option (i.e. uniform distribution) for ”Type of distribution”. Select
OK to exit the dialog.

Now, in the ”Create Mesh” dialogue, select the tab 2D and in the
”Algorithm” field select Quadrangle (Mapping) and type in Quadrangle
Parameters into the ”Hypothesis” field - a new dialog will pop up, where
we select ”algo2D_globale” as the ”Name” and ”Quadrangle Preference” in
the ”Type” options. Click OK to exit the dialogue.

Lastly, click on Apply and Close to exit the ”Create Mesh” dialogue.



Now, in the Object Browser, expand the Mesh object, then Mesh_1, where
the algorithms and hypotheses used to create the Cut_1 mesh can be
retrieved . The icon by the Mesh_1 object indicates that the mesh has
not yet been created. Thus, right click on Mesh_1 and in the pop-up menu
select Compute. This is supposed to generate the mesh of Cut_1, but as
can be seen from the message, ”Mesh computation failed”, in the pop-up
dialog, the mesh could not be created. As the dialogue indicates, this is due
to both the shape of Face_9 of Cut_1 and the algorithm chosen.


Different algorithms and hypotheses must thus be chosen to create the
mesh. To do this, in the Object Browser, expand Hypotheses, right click on
algo2D_globale and select Unassign in the pop-up. Likewise, expand
Algorithms, right click on Quadrangle_2D and select Unassign.


Now, right click on Mesh_1 and select Edit Mesh/Submesh - a new
dialogue will open. Select the 2D tab and choose either Netgen 2D or
Triangle (Mefisto) or Netgen 1D-2D as the algorithm. These are the only
viable choices for the shape of Face_9. Click on Apply and Close to exit.


Depending on the algorithm used to create the mesh of Cut_1, we obtain
three different triangular meshes, as shown in the picture belows:

1D Algorithm: algo1D_globale 1D Algorithm: algo1D_globale
2D Algorithm: Mefisto 2D Algorithm: Netgen 2D

2D Algorithm: Netgen 1D-2D


To obtain a quadrangular structured mesh, we must take regular shapes
into account, such as the geometry of pannello_forato. To do this, first
delete the triangular meshes by right clicking on them and selecting Delete.

Step 5: Create a mesh from the geometry of pannello_forato

As before, select Mesh → Create Mesh. Then, in the Name field, type
”Global-Mesh” and selectthe pannello_forato object in ”Geometry” . Use the
prevoiusly defined algorithms (algo1D_globale and algo2D_globale) and
hypotheses for the mesh construction. Right click on Global-Mesh object,
then select Compute. The pop-up dialog ”Mesh computation succeed”
appears, showing the mesh details.


Notes:
1. As shown in the previous figure, both 1D elements (Edge) and 2D
ones (Face) have been created. This is done automatically by the
Salome mesh generator. More specifically, for each geometry (both
2D and 3D) the mesh generator requires algorithms and hypothesis to
be applied on each of the sub-components of the geometry. Thus, for
3D geometries, algorithms are required for edges, faces and blocks.
The final result is a mesh made up of beam elements for all the edges,
and shell elements for the faces of each solid element, and solid
elements, even though we have a mesh with only solid elements. This
is due to the ”descendent connectivity” that Salome applies to mesh
elements by default (apart from the standard nodal connectivity), by
which each solid element is defined by its edges (arete) and faces
(maille). Clearly, this is also true for each shell element, defined by its
edges.



2.algo1D_globale has been applied for all edges bounding the faces of
pannello_forato. This implies that each segment has been split into 10
sub-segments, regardless of its length. If we wish to obtain a uniform
mesh, we need to define several 1D algorithms, depending on the
geometry.

From the Object Browser, expand the pannello_forato object, select all the
edges (24), right click on them and type in ”Show Only” - the edges of the 8
faces of pannello_forato will be displayed in the VTK-viewer

We now want to split the shorter edges into 5 sub-segments. To do this,
select Mesh → Create Sub-mesh and a new dialogue will open.


Accept the default ”Name”, then in the ”Mesh” field type ”Global-Mesh” and
in ”Geometry”, select the short edge located at the bottom left in the VTK-
viewer. Select the tab ”1D” and in ”Algorithm”, select ”Wire discretisation”
and select ”Nb.Segments” from ”Hypotheses”. In the following dialogue,
type in ”algo1D_locale” in the ”Name” and 5 in the ”Number of Segments”
fields. Click on the OK button, then Apply. Repeat the same procedure for
the other shorter edges and finally click on Apply and Close.

Now, right click on ”Global-Mesh” and select Compute - the new mesh of
pannello_forato will display, as shown in the following picture


As can be seen in the previous figure, the mesh is rather coarse. To refine
it, expand the Hypotheses object in the Object Browser, then right click on
algo1D_globale and select Edit Hypothesis in the pop-up and replace 10
with 20. Likewise, edit algo1D_locale by replacing 5 with 10. Now, right click
on Global-Mesh then select Compute. The resulting finer mesh is shown in
the figure below.



As mentioned in the foregoing, once the mesh has been generated, any
additional elements not required for the analysis but created by the Salome
mesh generator can be removed. In this example, beam elements can be
eliminated, as none are present. To this end, select Modification →
Remove → Elements. To select the edge elements, in the dialog that
opens click on Set Filters and then, in the next dialogue, click on the ”Add”
button (see figure in next slide). In the ”Criterion” field, select ”Geometry
type”, then type ”Edge” into the ”Threshold value” and select ”Mesh” in the
”Source” field. Finally, click on Apply and Close. Now, the VTK-viewer will
show all the edge elements highlighted and the ”Id Elements” of the
”Remove Elements” dialogue will list the identication numbers associated
with these edge elements. Click on Apply and Close to remove the beam
elements.


In the Object Browser, right click on ”Global-Mesh” and select ”Advanced
Mesh Infos” to retrieve information about the mesh.


The current mesh is made up of only quadrangular linear elements (4
nodes). If quadratic elements (8 nodes) are desired, select Modification
→ Convert to/from quadratic, then in the popup dialogue, select
”Global-Mesh” in the ”Mesh” field and check that the option ”Convert to
quadratic” is selected. Click on Apply and Close.
The total number of nodes will be 5640, as can be seen in the ”Advanced
Mesh Infos” window.

Step 6: Renumbering nodes/elements and Reorienting

Once the useless elements have been removed, the next step is to
renumber the nodes and elements. This is necessary because the Nosa
solver does not admit discontinuities in the numbering (analysis will not
converge). Thus, select Modification → Renumbering → Nodes, then
type ”Global-Mesh” in the ”Mesh” field and click on Apply and Close.
The elements must be renumbered in a similar fashion.

Regarding element connectivity, by default, Salome uses ”descendent
connectivity”, by which each element is defined by nodes/aretes/mailles
(see med documentation med-2.3.6). Moreover, element connectivity is
usually clockwise (blue-coloured in the VTK-viewer), hence a check for
any counter-clockwise connectivity must be performed. A first check can
be made by observing the colour of the elements: elements with right
connectivity are light-blue coloured. In any case, to view all the
information regarding an element, right click on the VTK-viewer and select
Mesh Element Infos. If an element exhibits improper connectivity, it must
be re-oriented. To do this, select Modification → Orientation, then
choose one of the available element selection criteria. In our case, select
all the elements and click on Apply and Close to reorient the elements.
As shown in the Vtk-viewer, the color ofcolourents change.


Note: The procedures for renumbering elements and checking their
connectivity are crucial to the success of a numerical analysis. Therefore,
regardless of the checks made by the user, during generation of the Nosa
card by the python modules, automatic checks are performed. If
improper connectivity is detected, the program prompts the user to
reorient the elements listed in the python console of Salome. Similar
checks are conducted on node and element numbering.

Step 7: Create Groups of nodes and elements
Select Mesh → Create Group: to create a nodal group select ”Node” in
the ”Element Type” field of the pop-up dialog, or ”Edge”, ”Face” or
”Volume” to create groups of 1D or 2D or 3D elements, respectively. It is
also possible to create a group from the mesh and/or geometry by
selecting the ”Standalone group” and/or ”Group on Geometry” types,
respectively. Moreover, there are several filters for node/element
selection. Once the nodes/elements have been selected, click on Apply
and Close to create the group.

Create nodal and element groups as shown in the picture below


Step 8: Create a python file for assigning material property, loads,...
Before proceeding, save the Salome study as Study1. Then, open the
file InputStudy1.py with a text editor and assign the current study
values to the variables defining the mesh data, element type, material
property, thickness, boundary conditions, loads and so on. By so doing,
for other studies and analyses, we can edit the values in same file and
simply rename it as InputXXX.py (where XXX is the name of the current
study). For the sake of convenience, most of the variables are defined
according to the of the Nosa code syntax. A brief comment for each
variable is provided in the file.

In the current study, we aim to perform a static analysis using plane
stress quadratic elements (8 nodes). The material is described by the
masonry-like constitutive model. Clamped boundary conditions are
applied to the bottom edge of the hollow panel and an inertial load and a
surface load on the upper edge will be applied.

Thus, only the following variables in InputStudy1.py are to be edited :

mdist = 2 nel = 1800 kmats = 1
ntype = (2,) maxinc = 1 jmats = (1,)
imaso = 1 miter =100 mvar = 11
nmats = 1 nc = 3 npost = 1
msete = 9 np = 5640 ndist_load = 2
msetn = 3 nfixd = 1 idist = ((1,1),(32,2))
mset = 5640 presc = ((0.,0.),) rdist = ((0.,-18000.,0.),(100.,0.))
nelem = 1800 ifpre = ((1,2),) matno = (1,1,1,1,1,1,1,1,1)
npoin = 5640 ngeom = 9 eltype_geom = (2,2,2,2,2,2,2,2,2)
ncomgr = 9 nmaso = 9 maso = (1,1,1,1,1,1,1,1,1)


props = ((3e+9,.2,1800.,0.,0.,1e+20),)
indvar = (1,2,4,11,12,14,17,31,32,34,37)
nset_boundary = ('incastro',)
geom = ((.025,),(.025,),(.025,),(.025,),(.025,),(.025,),(.025,),(.025,),(.025))
chvar = ('exx','eyy','exy','sxx','syy','sxy','smises','einxx','einyy','einxy','ein_eqv')
elset_maso =
('all_elem','borexsup','borexinf','borinsup','borininf','borinsx','borindx','borexsx','borexdx')
eset_load = ('all_elem','borexsup')
analysis_title = '2-D plane stress analysis of hollow panel with masonry-like material'

As already mentioned, each variable is briefly explained in the file
InputStudy1.py.


Step 9: Generate the Nosa card ”.crd”
Once the problem variables have been assigned, the creation of the Nosa
input file is straightforward: in the python console of Salome, type the
following command line:
execfile(”.../MainPreProcess.py”)

specifying the full path of script file's location (it is a good idea to keep all
the python scripts and modules in the same directory).

The script MainPreProcess.py calls several user python modules to manage
the mesh and analysis data.



If no warning or error message is
displayed, Study1.crd has been created !

Now, suppose that during Nosa card creation, the mesh contains some
elements with clockwise connectivity. The display will show:

element with wrong
connectivity


As shown in the figure, some warnings display during creation of Study1.cr,
and the user is prompted to reorient the elements listed in the python
console.

Note: the Salome element library contains several element types: triangular
elements with 3 and 6 nodes, quadrangular elements with 4 and 8 nodes
and polygonal elements with any number of nodes are available in the 2D
case. In the 3D case, tetrahedral, hexahedral, prismatic, pyramidal and
polyhedral elements are supplied. Nevertheless, the polygonal and
polyhedral elements (useless in most structural analyses) supplied by
Salome must, at least for the time being, be converted to quadrangular or
hexahedral collapsed elements before the Nosa card is written. This
conversion is done automatically by the user python modules during
execution of MainPreProcess.py.


Step 10: Submit the analysis
To run the current analysis, it is not necessary to exit Salome session. The
Nosa solver can be executed directly from Salome GUI by typing the
following command lines into the python console:

1. from os import system
2. system(”./nosadyn Study1”)

The analysis will run in batch mode and when it has completed the system
command will return an integer number. The process and the status of each
iteration at each load increment can be followed by observing the terminal
running Salome (runSalome).


Note: It may be necessary to have the nosadyn executable in the same
directory from which Salome is launched. Also, the current version of Nosa
has been modified to be launched from Salome GUI. The relevant
changes concern the subroutines mnosa.f, pstres.f and setdaf.f, the last of
which is no longer required.

Step 11: Create the output Med file 'Study1.med'
Once the analysis has completed, the output file Study1.med is obtained
via the result file Study1.t19. To create the output file, execute the Fortran
user-program postMed directly from the python console of Salome GUI
via the command
system(”./postMed Study1 1”)

where the name of the file ”.t19” and the total numer of load
increments must be specified. Once the med file has been created,
the terminal will show the file status.

Step 12: Import the file Stud1.med into Salome GUI

Activate the Post-Pro module of Salome by clicking on the icon , then
import Study1.med by selecting File → Import → MED file, or clicking on
the icon .

Once the file has been loaded, the Object Browser will contain a post-pro
object, which can be expanded to retrieve Study1.med. Expanding
Study1.med and ”orphanMesh” displays three subnodes: Families ,
Groups and Fields. Groups furnishes the node and element sets created
by the mesh module, while Fields contains the output variables required
by InputStudy1.py.



Step 13: Viewing the results

To view the deformed shape, right click on the displacement field ”U”, then
select Deformed Shape and Scalar Map. In the pop-up dialogue, select
the tab Scalar Bar, then in the ”Scalar Mode” field type the 2nd component
of the displacement field. Click on OK. The VTK-viewer will display a plot
of the mesh, together with the deformed shape. To view only the
deformed shape, go to the Object Browser, expand the ”Presentations”
object, right click on ScalarDef.Shape and select ”Show Only” from the
pop-up menu.


Click on the Point Selection icon, then in the VTK-viewer, click on a node -
the values of the displacement field will be evaluated along with the
coordinates of this node.


It is possible to view only the deformed shape without the scalar map: right
click on the field ”U” and select the Deformed Shape option, as shown in the
picture below.


To view the contour plot of the displacement field on the undeformed shape,
right click on ”U” field and select the Scalar Map option.


Now, right click on the ”U” field in the Object Browser to select the Vectors
option. Then, in the ”Vectors” tab of the resulting dialogue, enter 100 in the
”Scale factor” field and select ”Magnitude colouring”. Finally, select the 2 nd
component of ”U” from the ”Scalar Bar” tab and click OK.


Likewise, right click on the ”RF” field in the Object Browser and select
”Vectors” to show the reaction forces, as in the figure below.


Now, to display the normal stress along the y direction as defined at the
element centroid, as shown below, right click on the ”syy” field in the Object
Browser and select ”Scalar Map”.


The values at each Gauss point of each element can be viewed by right
clicking on syy and selecting the option Gauss Points.


In addition, clicking on the button Gauss point selection displays the value at
a Gauss point


Example 2: Analysis of a barrel vault made of masonry-like
material subjected to its own weight

2m
=
R

4m



Step 1: Create the geoemtry of the barrel vault
From New Entity → Basic → Point create 4 points by entering their
coordinates.

x y z
Point 1 2 0 0
Point 2 2 4 0
Point 3 0 0 0
Point 4 0 4 0



Now select New Entity → Basic → Line and create 2 lines by selecting
the previously defined points: one line will be the axis of rotation of the
barrel vault, the other will be the generatrix.

To create the surface of revolution select New Entity → Generation →
Revolution - a pop-up dialogue will open. In the”Object” and ”Axis”
fields, select the generatrix and the other line (via the OCC-viewer). In
the ”Angle” field, enter 180 and click on the ”Reverse” box if the
orientation is clockwise, otherwise do not. Click on Apply and Close.

From the Object Browser, right click on the last object, select ”Show
Only” and rename it to ”volta”.

Now select New Entity → Explode to obtain the free edges of the volta
object.



Step 2: Create the mesh of the barrel vault

Select Mesh → Create Mesh and type ”Global-Mesh” and ”volta” into
the ”Name” and ”Geometry” fields, respectively.
Select the tab ”1D” and choose ”Wire discretisation” as the algorithm,
and ”Nb. Segments” as the hypothesis. In the ”Hypothesis Construction”
dialogue type in ”algo1D_globale” as the name, and enter 80 as the
number of sub-segments into which all free edges of volta must be split.
Select the tab ”2D” and choose ”Quadrangle (Mapping)” as the
algorithm and ”Quadrangle Parameters” as the hypothesis. In the next
dialogue imput ”algo2D_globale” in the ”Name” field and select the
”Quadrangle Preference” option.

Right click on the Global-Mesh from the Object Browser and select
Compute. Then remove all the beam elements (not needed for the
current analysis), and renumber the nodes and elements. Lastly,
check the element connectivity.


Once these operations have been performed, the mesh of the barrel
vault should be depicted as in the following figure.


Now, create node and element sets following to the procedures described in
the previous example. The results are shown in the figure below:



Step 3: Edit the InputStudy1.py file
Edit the file ”InputStudy1.py”, as below, to modify some variables to the
values for the current analysis, then rename this file to InputStudy2.py.
msetn = 5 nfixd = 4 idist = ((1,1),)
mset = 6561 mshel = 5 rdist = ((0.,0.,-18000.),)
nelem = 6400 matno = (1,1,1,1,1)
npoin = 6561 ngeom = 5 eltype_geom = (10,10,10,10,10)
ncomgr = 5 nmaso = 5 maso = (1,1,1,1,1)

props = ((3e+9,.2,1800.,0.,0.,1e+20),)
indvar = (1011,1012,1014,1015,1016,1021,1022,1024,1025,1026,3011,3012,3014,
3015,3016,3021,3022,3024,3025,3026,5011,5012,5014,5015,5016,5021,5022,5024,
5025,5026,51,52,53,54,55,56,57,58)
nset_boundary = ('bordo_-x','bordo_+x','arco_+y','arco_-y')
geom = ((.2,),(.2,),(.2,),(.2,),(.2,))
chvar = ('s11_bot','s22_bot','s12_bot','s23_bot','s13_bot','ie11_bot','ie22_bot','ie12_bot',
'ie23_bot','ie13_bot','s11_med','s22_med','s12_med','s23_med','s13_med','ie11_med','ie22_med','
ie12_med','ie23_med','ie13_med','s11_top','s22_top','s12_top','s23_top','s13_top','ie11_top',
'ie22_top','ie12_top','ie23_top','ie13_top','N11','N22','N12','Q23','Q13','M11','M22','M12')
elset_maso = ('all_elem','bordo_sx','bordo_dx','arc_fron','arc_rear')
eset_load = ('all_elem',)
analysis_title = '2-D analysis of a barrel vault with masonry-like material'
ifpre = ((1,2,3,4,5,6),(1,2,3,4,5,6),(1,2),(1,2))
presc = ((0.,0.,0.,0.,0.,0.),(0.,0.,0.,0.,0.,0.),(0.,0.),(0.,0.))


Step 4: Run the analysis
In the python console of Salome GUI, type the following command lines:
● from os import system

● system(”./nosadyn Study2”)

Step 5: Create the Study2.med output file
In the python console of Salome GUI type the following command line:
● system(”./postMed Study2 1”)



Step 6: Import Study2.med into Salome GUI and view the results
The following figures show the deformed shape of the barrel vault and the
stress and strain fields at the Gauss points


Example 3: Analysis of a groin vault made of masonry-like

6m

3m

R= 2 m

6m



Step 1: Create the geometry of the groin vault
Select New Entity → Basic → Point and create 8 points by entering the
coordinates shown below.
X Y Z
Point 1 2 0 0
Point 2 2 6 0
Point 3 0 0 0
Point 4 0 6 0
Point 5 3 5 0
Point 6 -3 5 0
Point 7 3 3 0
Point 8 -3 3
vincenzo.binante@isti.cnr.it 0 85

Select New Entity → Blocks → Quadrangle Face and create 2
rectangles by entering their vertices.

Face 1 Point 1,...,Point 4
Face 2 Point 5,...,Point 8

Via New Entity → Generation → Revolution create 2 half-cylinders by
rotating the faces defined in the previous step around two lines:

Object to be rotated Axis of rotation Angle
Revolution 1 Face 1 pt3-pt4 180
Revolution 2 Face 2 pt7-pt8 180


Open Operations → Boolean → Cut to create the intersections of the
half-cylinders.
Object to be cut Cutting object
Cut 1 Revolution 1 Revolution 2
Cut 2 Revolution 2 Revolution 1

Hide all objects but Cut_1 and Cut_2 in the Object Browser,.

Select New Entity → Explode to obtain the faces constituting Cut_1 and
Cut_2.
Hide all in the Object Browser, then expand the Cut_1 and Cut_2
objects, and select the faces making up the groin vault and display
them in the OCC-viewer.

Select Operations → Boolean → Fuse to create the unions (fuse) of two
objects.

Object 1 Object 2
Fuse 1 Face 4 Face 14
Fuse 2 Fuse 1 Face 7
Fuse 3 Fuse 2 Face 17

Hide all objects except Fuse 3 in the Object Browser: the resulting
object is shown in the figure below (with the differently-coloured
faces).



Now, we must split the Fuse 3 object into 4 parts (for meshing), so we
create two planes from three points, via New Entity → Basic → Plane.



Now, selecting Operations → Partition create two partitions of the Fuse
3 object by means of two planes, as shown below.
Object 1 Object 2
Partition 1 Fuse 3 Plane 1
Partiton 2 Partition 1 Plane 2

Rename the Partition 2 object to volta_crociera.
Finally, select New Entity → Explode to obtain the edges and faces
constituting the volta_crociera object. The figure below displays the faces
of the volta_crociera object in different colours.


Step 2: Create the mesh of the groin vault

Once the mesh module has been activated, display all the edges of the
volta_crociera object in the VTK-viewer.

Select Mesh → Create Mesh and input ”Global-Mesh” as the name and
select volta_crociera for the geometry .

Select the ”1D” tab and use ”Wire discretisation” as the algorithm and ”Nb-
Segments” as the hypothesis. In the next dialogue, enter
”algo1D_globale” as the name and ”40” as the number of sub-segments
into which to divide all the edges .

Now select the ”2D”tab and use ”Quadrangle (Mapping)” as the algorithm
and ”Quadrangle Parameters” as the hypothesis. In the next dialogue,
enter the name ”algo2D_globale” and select type ”Quadrangle
Preference”.


Now, open Mesh → Create Sub-mesh and enter ”Global-Mesh” for the
mesh and for the geometry select one of the edges which should be split
according to an algorithm other than ”algo1D_globale”.

Select the ”1D” tab and use ”Wire discretisation” as the algorithm and ”Nb-
Segments” as the hypothesis. In the next dialogue, enter ”algo1D_locale”
as the name and ”25” as the number of sub-segments into which the edge
is to be split.

Repeat the procedure for all edges with partitions different from
”algo1D_globale”.



The blue-coloured edges must be split according to the ”algo1D_locale”
algorithm, the others according to ”algo1D_globale”.


In the Object Browser, right click on ”Global-Mesh”, then select Compute.

Remove all beam elements (uneeded for the current analysis) by selecting
Modification → Remove → Elements and using the available filters to
select the edge elements.

Then renumber nodes and elements by selecting Modification →
Renumbering → Nodes/Elements.

The following figure shows the mesh of the groin vault.



Now, create the node and element sets via Mesh → Create Group.



Step 3: Edit the InputStudy2.py file
Edit the file ”InputStudy2.py” to modify some variables to the values for the
current analysis, then rename this file to InputStudy3.py
msetn = 9 nfixd = 5 idist = ((1,1),)
mset = 8261 mshel = 5 rdist = ((0.,0.,-18000.),)
nelem = 8000 matno = (1,1,1,1,1,1,1,1,1)
npoin = 8261 ngeom = 9 eltype_geom = (10,10,10,10,10,10,10,10,10)
ncomgr = 9 nmaso = 9 maso = (1,1,1,1,1,1,1,1,1)

props = ((3e+9,.2,1800.,0.,0.,1e+20),)
indvar = (1011,1012,1014,1015,1016,1021,1022,1024,1025,1026,3011,3012,3014,
3015,3016,3021,3022,3024,3025,3026,5011,5012,5014,5015,5016,5021,5022,5024,
5025,5026,51,52,53,54,55,56,57,58)
nset_boundary = ('base','arco_-x','arco_+x','arco_-y','arco_+y')
geom = ((.2,),(.2,),(.2,),(.2,),(.2,),(.2,),(.2,),(.2,),(.2,))
chvar = ('s11_bot','s22_bot','s12_bot','s23_bot','s13_bot','ie11_bot','ie22_bot','ie12_bot',
'ie23_bot','ie13_bot','s11_med','s22_med','s12_med','s23_med','s13_med','ie11_med','ie22_med','
ie12_med','ie23_med','ie13_med','s11_top','s22_top','s12_top','s23_top','s13_top','ie11_top',
'ie22_top','ie12_top','ie23_top','ie13_top','N11','N22','N12','Q23','Q13','M11','M22','M12')
elset_maso = ('all_elem','face1','face2','face3','face4','face5','face6','face7','face8')
eset_load = ('all_elem',)
analysis_title = '2-D analysis of a groin vault with masonry-like material'
ifpre = ((1,2,3,4,5,6),(1,2),(1,2),(1,2),(1,2))
presc = ((0.,0.,0.,0.,0.,0.),(0.,0.),(0.,0.),(0.,0.),(0.,0.))


Step 4: Run the analysis
In the python console of Salome GUI type the following command lines:
● from os import system

● system(”./nosadyn Study3”)

Step 5: Create the Study3.med output file
In the python console of Salome GUI type the following command:
● system(”./postMed Study3 1”)


Step 6: Import Study3.med into Salome GUI and view the results
The following figures show the deformed shape of the groin vault and the
stress and strain fields at the Gauss points



The last figure shows the displacement field by selecting the option Cut
Planes from those available.

Note: The previous figures show results which may not seem symmetrical,
depending on the node positions in the connectivity of any element (the first
node in the connectivity may not be located at the bottom-left, even though
the orientation is counterclockwise). In reality, this is not the case, though it
represents a problem common to many software applications (e.g., MSC
Mentat).

Example 3 completes the first part of this tutorial. We now continue on to
Part 2.


Example 4: Importing a Nosa card *.crd into Salome GUI
Importing a Nosa input file (”*.crd”) requires a python module named
MeshImport.py, which reads the mesh data of the Nosa card and applies
the python commands in Salome to rebuild the fem .

Start a new session of Salome and type the following command lines into
Salome GUI python console:

● import MeshImport

● MeshImport.importNosa(../filename.crd)

where, the full path to filename.crd must to be specified. It is advisable to
have the python module in the same directory where Salome GUI is
executed.
The following example show the results of importing the three Nosa cards
murosud3.crd, ciappei.crd and rognosa.crd

Tutorial 09 02_12

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (9)

Destacado

Destacado (18)

Similar a Tutorial 09 02_12

Similar a Tutorial 09 02_12 (20)

Más de MMSLAB

Más de MMSLAB (11)

Último

Último (20)

Tutorial 09 02_12