Upload
others
View
5
Download
0
Embed Size (px)
Citation preview
Wouter Vanrenterghem
schaalconstructiesProgrammeren van hulpmiddelen bij de berekening van
Academiejaar 2007-2008Faculteit IngenieurswetenschappenVoorzitter: prof. dr. ir. Luc TaerweVakgroep Bouwkundige constructies
Burgerlijk bouwkundig ingenieurScriptie ingediend tot het behalen van de academische graad van
Begeleider: ir. Wesley VanlaerePromotor: prof. dr. ir. Guy Lagae
Wouter Vanrenterghem
schaalconstructiesProgrammeren van hulpmiddelen bij de berekening van
Academiejaar 2007-2008Faculteit IngenieurswetenschappenVoorzitter: prof. dr. ir. Luc TaerweVakgroep Bouwkundige constructies
Burgerlijk bouwkundig ingenieurScriptie ingediend tot het behalen van de academische graad van
Begeleider: ir. Wesley VanlaerePromotor: prof. dr. ir. Guy Lagae
De auteur geeft de toelating deze scriptie voor consultatie beschikbaar te stellen en delen ervan te kopiëren voor persoonlijk gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting uitdrukkelijk de bron te vermelden bij het aanhalen van resultaten uit deze scriptie. Gent, juni 2008 De auteur Wouter Vanrenterghem
Dankwoord
Alvorens over te gaan naar het echte onderwerp van deze scriptie, wil ik alle mensen bedan-ken die mij in de loop van dit jaar hebben geholpen om deze scriptie te verwezenlijken. In de eerste plaats wil ik mijn promotor Prof. dr. ir. Guy Lagae bedanken voor de mogelijk-heid die hij heeft gegeven om een thesis onder zijn vleugels te mogen verwezenlijken. Daarnaast wil ik mijn begeleider dr. ir. Wesley Vanlaere uitgebreid bedanken voor zijn toe-gewijde hulp. Hij stond mij met raad en daad bij en heeft zich steeds de moeite getroost om antwoord te geven op al mijn vragen. Ook prof. dr. ir Benedict Verhegghe verdient hier een bijzondere blijk van waardering voor zijn bijstand in het pyFormex gedeelte van deze thesis. Ik wil mijn vriendin Emmy, mijn ouders, mijn familie en mijn vrienden bedanken voor de steun in dit laatste jaar. Niet alles liep steeds van een leien dakje, maar steeds hebben jullie getracht mij moed in te spreken als het minder ging. Tot slot wil ik ook nog Stefaan Van Innis bedanken om deze thesis na te lezen. Daarom heb ik één maar een veelzeggend woord voor al deze mensen, BEDANKT!
Programmeren van hulpmiddelen bij de berekening van schaalconstructies
Wouter VANRENTERGHEM
Scriptie ingediend tot het behalen van de academische graad van
BURGERLIJK BOUWKUNDIG INGENIEUR OPTIE BOUWKUNDE
Academiejaar 2007–2008
Promotor: Prof.dr.ir. Guy Lagae
Begeleider: dr. ir. Wesley Vanlaere
Faculteit Ingenieurswetenschappen Universiteit Gent
IR14 Vakgroep Bouwkundige Constructies
Voorzitter: Prof. dr. ir. Luc Taerwe Samenvatting
Er is heel wat onderzoek gebeurd naar het bezwijkgedrag van kegelschalen die gevuld zijn met een vloeistof. Op basis van een uitgebreid programma met fysische experimenten en numerieke simulaties was het mogelijk om rekenregels op te stellen. Deze rekenregels zijn neergeschreven in [1] en worden toegelicht in hoofdstuk 2. Om het ontwerp van een derge-lijke constructie te vereenvoudigen is een programma ontwikkeld op basis van deze reken-regels, zodat de gebruiker enkel de juiste parameters dient in te voeren en deze door het programma moet laten verwerken. De uitwerking van dit programma is beschreven in hoofdstuk 3. In hedendaags onderzoek naar het gedrag van schaalconstructies, zijn numerieke simulaties onmisbaar. Om dergelijke simulaties uit te voeren is een goed model nodig. Hoe zo een mo-del er moet uitzien voor een lokaal ondersteunde silo is beschreven in hoofdstuk 4. Het nu-merieke onderzoek in het Laboratorium voor Modelonderzoek gebeurt aan de hand van ABAQUS. Om het model in ABAQUS in te lezen wordt gebruik gemaakt van zogenaamde in-
putfiles. Deze bestanden worden vaak aangepast waardoor er zeer snel fouten insluipen. Het debuggen van dergelijke bestanden neemt vaak heel wat tijd in beslag. In hoofdstuk 5 staat de beschrijving van een programma dat is ontwikkeld om op een eenvoudige manier deze bestanden te genereren. Om dit programma te testen is een kleine parameterstudie aan deze scriptie toegevoegd in hoofdstuk 6 waarbij de invloed van de verhouding van de interstringerafstand tot de breedte van het steunpunt wordt nagegaan. Tot slot worden alle verwezenlijkingen van deze scriptie nog eens opgesomd in hoofdstuk 7. Trefwoorden: Schaalconstructie, eindige elementen, parameterstudie, pyFormex, ABAQUS
Programming tools for calculating shells
Wouter Vanrenterghem
Supervisors: prof. dr. ir. Guy Lagae, prof. dr. ir. Benedict Verhegghe, dr. ir. Wesley Vanlaere
Abstract – Liquid-filled conical shells have been the subject of
an extended experiment program. Based upon these experiments
and numerical simulations, design rules have been developed. In
order to help the designer calculate these structures, a software
program has been developed based upon these rules. Shell struc-
tures composed out of cylindrical and/or conical parts, such as
silos, water towers, storage tanks, etc... on the other hand still
require research to define design rules. This research partially
exists of numerical simulations with finite element software. A
second program that has been developed helps the researcher to
create inputfiles for shell structures which can be used in
ABAQUS. A small parametric study has been executed in order
to test this program.
Keywords – shell, finite element, parametric study, pyFormex,
ABAQUS
I. INTRODUCTION
HE first part of this article handles the creation of a soft-
ware tool that can be used to calculate liquid-filled coni-
cal shells. This web based application gives the designer the
possibility to calculate conical shells based on the rules in [1].
The second part of this article gives more information about
creating numerical models for ABAQUS. The behaviour of
shell structures such as silos, water towers, storage tanks, ect...
needs to be investigated with finite element software. The
creation of models for ABAQUS is a repetitive and error-
sensitive task. Therefore a program has been developed to
create these models.
The last part discusses the influence of the distance between
stiffeners above a support point in case of a discretely sup-
ported cylindrical silo.
II. LIQUID-FILLED CONICAL SHELLS
A. Recommendations
Design rules have been formulated [1] for conical shells
with a vertical axis of revolution and constant wall thickness,
supported at the lower smaller end of the cone.
Figure 1 Geometries of liquid-filled conical shells, a. conical shell
segment, b. cone-cylinder combination
These rules are only valid for geometry shapes as described
in [1].
Local initial dimples and the global out-of-roundness should
be checked according to the fabrication tolerance quality class
Q. Values of the fabrication quality parameter can be found in
table 14-1 in [1].
These design rules are based on the assumption of elastic-
perfectly plastic material, which is characterized by the
Young’s modulus E and the yield stress fy,k.
The load on the conical shell can consist out of three parts:
the hydrostatic liquid pressure γ’, the self-weight of the struc-ture g and an optional additional roof load q.
The three load contributions are represented by the parame-
ters �� and �� . The first parameter is the statical-geometrical parameter. The second one is the more expanded version of
internal pressure parameter ��, because it also includes effects of self-weight and roof loading. These two parameters are
explicitly specified in [1]. In case of other shell forms these
rules cannot be used.
The Recommendation provides two methods to get the de-
sign value of ��. These differ from each other in the way the load safety factor is applied. For the first method the load
factor is applied on the height of the cone h’k, in a specific
way. The second method increases the specific weight of the
fluid γ’.
B. Web based application
The goal of this web based application is to provide a tool
that can be used in combination with [1]. In the applet, the
design rules as given in the Recommendations are imple-
mented. However, only the basic case of a liquid-filled conical
shell (i.e. no cylinder-cone combinations or additional roof
load) is covered. For this loading case (i.e. pure hydrostatic
pressure). the following relationship are valid: �� � �� and �� � ��. The plastic buckling parameters are given the value λ0 =
0,2; β’ = 0,6 and η = 1. With this applet, the designer has the possibility to get a
graphical representation of the shell i.e. a capacity curve and
an α-p curve can be displayed. On these both curves charac-
teristic value of the design point is indicated. These curves can
be displayed for both design methods as mentioned above.
III. NUMERICAL SIMULATIONS OF SHELLS
A. Numerical model
Uniformly supported shells have been the subject of numer-
ous studies for over a few decades. A more recent research
program tries to understand the behaviour of failure of dis-
cretely supported cylindrical shell structures. One of the re-
cent researches in this context is the study by W. Vanlaere [2].
In his doctorate the buckling behaviour of discretely sup-
ported cylindrical shells with stiffeners has been examined.
Both experimental and numerical research have been used to
understand this behaviour. To execute these numerical re-
T
searches a numeric model has been created which is displayed
in Figure 2. This model is written to a file – an inputfile -
which can be imported in ABAQUS.
Figure 2 Model of 1/8th of the cylindrical shell with stiffeners
B. Shell-script
It happens frequently that small errors get stuck in the code
while creating these inputfiles. Sometimes it takes a lot of
time to debug the script. To help the research with numerical
simulations, a pre-processor has been created to generate these
inputfiles automatically based on a Graphical User Interface.
The pre-processor has been written in python and needs to be
loaded in pyFormex to execute it.
With this program it is possible to create inputfiles for silos
that exist out of a cylindrical shell or a cone-cylinder combi-
nation. These structures have local supports with stiffeners. It
is also possible to create inputfiles for water towers. These
structures may exist out of a conical shell or a cone-cylinder
combination. They have a uniform support at the lower edge
of the conical segment. These models are displayed in the
figure underneath.
Figure 3 Available shell structures with the pre-processor
With this program it is possible to add axial loading on top
of the shell and to create inputfiles for different kinds of
analyses, such as linear analyses, buckling analyses and mate-
rial and/or geometrical non linear analyses.
C. Parametric study
The research of locally supported cylindrical shells has led
to a better insight in the behaviour of failure for these struc-
tures. To formulate design rules it is necessary to perform a
lot of numerical simulations to see the influence of every
parameter. One of these parameters is the ratio of the distance
between the longitudinal stiffeners that are placed above each
support point and the width of the support. This ratio is de-
termined by ds/wsup, where ds represent the distance between
the two longitudinal stiffeners and wsup the width of the sup-
ports.
Simulations in [2] indicated a maximum for a certain ratio
for that specific type of geometry. To find a general rule that
indicates what the best ds/wsup ratio is, several new simula-
tions have been calculated.
The new simulations have been executed for cylindrical
shells with a r/t-ratio equal to 500 with r = 350mm, the height
is 4 times the radius. Two types of stiffener have been used,
the R-shaped and the U-shaped stiffener. The width of the
local supports were kept realistic, therefore the support ratio is
kept below 0,2. Each geometrical situation has been modelled
with rigid and flexible supports.
The results of the simulations indicate that the maximum is
reached for a ratio equal to 1 for a support ratio below 0,14.
This means that the distance between the two longitudinal
stiffeners should be chosen the same as the width of the sup-
port point.
Figure 4 Results of the study: r/t = 500; r = 350mm; h = 1400mm,
wsup/r = 0,14; fy = 240MPa, ts/t = 2,5
IV. CONCLUSIONS
The applet gives the user the ability to calculate liquid-filled
conical shells easily, without getting trapped in the jungle of
formulas.
The shell-script makes creating inputfiles a lot easier and
without errors. This will form a handy tool in creating lots of
inputfiles for further research. Because pyFormex is based on
scripts, it is easy to extend this program if other functions are
required. The functionality of this program has been tested by
the scripts that have been used for the parametric study.
A parametric study that researched the influence of the pro-
portion of the width between two longitudinal stiffeners to the
width of the support point, has indicated that for realistic
values of the support ratio the distance between the stiffeners
should be equally wide as the support point. This could be
determined for U-shaped stiffeners for wsup/r ≤ 0,2; for R-
shaped stiffeners for wsup/r ≤ 0,2.
ACKNOWLEDGEMENTS
The author would like to acknowledge the help and support
of Prof. dr. ir G. Lagae, Prof. dr. ir B. Verhegge and dr. ir. W.
Vanlaere.
REFERENCES
[1] ECCS, Buckling of Steel Shells: European Recommendations, 5th Edi-tion, Recommendations: Liquid-filled conical shells supported from be-
low, under preparation.
[2] W. Vanlaere, Plooigedrag van Verstijfde Cilinders op Lokale Steunpun-ten, PhD thesis, Universiteit Gent, 2006.
55,0
65,0
75,0
85,0
95,0
0% 20% 40% 60% 80% 100%
Be
zwij
kb
ela
stin
g [
kN
]
ds/wsup
Rigid R - Cilinderwand
Flexible R - Cilinderwand
Rigid U - Cilinderwand
Flexible U - Cilinderwand
Inhoudsopgave vi
Inhoudsopgave Toelating tot bruikleen ................................................................................................................. i Dankwoord ................................................................................................................................. ii
Inhoudsopgave ........................................................................................................................... vi
Lijst met figuren ......................................................................................................................... ix
Lijst met tabellen ........................................................................................................................ xi
Lijst met symbolen .................................................................................................................... xii
1 Inleiding .............................................................................................................................. 1
2 Met vloeistof gevulde kegelschalen ................................................................................... 3
2.1 Algemeen ..................................................................................................................... 3
2.1.1 Type schaalconstructie ......................................................................................... 3
2.1.2 Geometrie ............................................................................................................ 4
2.1.3 Tolerantie ............................................................................................................. 5
2.1.4 Materiaal .............................................................................................................. 6
2.1.5 Belasting ............................................................................................................... 6
2.1.6 Randvoorwaarden ................................................................................................ 7
2.2 Rekenregels ................................................................................................................. 7
2.2.1 Algemeen ............................................................................................................. 7
2.2.2 Belangrijke parameters ........................................................................................ 8
2.2.3 Elastische kritieke plooiweerstand ...................................................................... 9
2.2.4 Rekenwaarde van de plooiweerstand ................................................................. 9
2.2.5 Rekenwaarde van de belasting ............................................................................ 9
2.2.6 Rekenwaarde van de reactie .............................................................................. 12
3 Uitwerking JAVA-applet ................................................................................................... 16
3.1 Hoofdvenster ............................................................................................................. 17
3.1.1 Invoer basisgegevens ......................................................................................... 17
3.1.2 Resultaten .......................................................................................................... 17
3.1.3 Actieknoppen ..................................................................................................... 17
3.2 Deelvenster Graphs ................................................................................................... 18
3.3 Deelvenster Help ....................................................................................................... 19
3.4 Rekenmodule ............................................................................................................. 20
3.5 Tekenmodule ............................................................................................................. 20
4 Numerieke simulaties van schaalstructuren .................................................................... 24
4.1 Algemeen ................................................................................................................... 24
4.2 Het onverstijfde model .............................................................................................. 24
Inhoudsopgave vii
4.3 Het verstijfde model .................................................................................................. 25
4.3.1 Randvoorwaarden .............................................................................................. 25
4.3.2 Belasting ............................................................................................................. 28
4.3.3 Elementen .......................................................................................................... 29
4.3.4 Elementennet ..................................................................................................... 30
4.3.5 Materiaaleigenschappen.................................................................................... 31
4.4 Soorten analyses ....................................................................................................... 32
4.4.1 Lineair elastische analyse (LA) ........................................................................... 32
4.4.2 Geometrisch niet-lineaire analyse (GNA) .......................................................... 32
4.4.3 Materiaal niet-lineaire analyse (MNA) ............................................................... 32
4.4.4 Geometrisch en materiaal niet-lineaire analyse (GMNA) .................................. 33
4.4.5 Geometrisch en materiaal niet-lineaire analyse waarbij imperfecties in rekening worden gebracht (GMNIA) ............................................................................................... 33
5 Uitwerking van het programma ....................................................................................... 34
5.1 Algemeen ................................................................................................................... 34
5.2 Het programma pyFormex ........................................................................................ 34
5.3 Het pyFormex script Shell .......................................................................................... 36
5.3.1 Invoer parameters .............................................................................................. 36
5.3.2 Creëren van de geometrie ................................................................................. 47
5.3.3 Het abqData-object ............................................................................................ 52
5.3.4 Model ................................................................................................................. 54
5.3.5 Analyse ............................................................................................................... 58
5.3.6 Output ................................................................................................................ 59
5.3.7 Wegschrijven van de inputfile............................................................................ 59
5.3.8 Creëren van de menustructuur .......................................................................... 60
5.3.9 Variabele lus ....................................................................................................... 61
5.4 Controle van het programma .................................................................................... 61
6 Parameterstudie .............................................................................................................. 62
6.1 Model......................................................................................................................... 62
6.2 Verwerken van de analyses ....................................................................................... 64
6.3 Resultaten .................................................................................................................. 65
6.3.1 Bestaande simulaties ......................................................................................... 65
6.3.2 Nieuwe simulaties .............................................................................................. 66
6.4 Conclusie.................................................................................................................... 69
7 Besluit ............................................................................................................................... 70
Bijlage 1: Rekenvoorbeeld ......................................................................................................... A
Inhoudsopgave viii
Bijlage 2: Programmacode ECCS ................................................................................................ B
Bijlage 3: Aanpassingen aan het f2abq.py script ....................................................................... C
Bijlage 4: Programmacode Shell.py script .................................................................................. D
Bijlage 4: Figuren van structuren in pyFormex .......................................................................... E
Bijlage 5: Randvoorwaarden voor de knopen ............................................................................ F
Bijlage 6: Inputfile ...................................................................................................................... G
Bijlage 7: Parameterstudie ......................................................................................................... H
Referenties .................................................................................................................................. I
Lijst met figuren ix
Lijst met figuren Figuur 2.1: Mogelijke geometriën van de kegelschalen, a. zuivere kegelschaal, b. kegelschaal met cilindrisch gedeelte ............................................................................................................. 3
Figuur 2.2: Kegelschaal met a. concave en b. convexe vorm van de beschrijvende in meridionale zin t.o.v. de verticale symmetrieas ........................................................................ 4
Figuur 2.3: Spannings-rek diagram van een perfect elastisch-plastisch materiaal ................... 6
Figuur 2.4: Volume dat bijdraagt tot bezwijken ...................................................................... 10
Figuur 2.5: Capaciteitscurve ..................................................................................................... 12
Figuur 2.6: Capaciteitscurve met lineaire interactie ................................................................ 13
Figuur 2.7: α - grafieken met ECCS ontwerppunt................................................................. 14
Figuur 3.1: Hoofdvenster ......................................................................................................... 16
Figuur 3.2: Foutmelding bij foutieve invoer............................................................................. 18
Figuur 3.3: Deelvenster “Graphs” met de twee soorten grafieken ......................................... 18
Figuur 3.4: Deelvenster “Help” ................................................................................................ 19
Figuur 3.5: Het tekengebied ..................................................................................................... 21
Figuur 4.1: Het deel van de onverstijfde cilinder dat door Guggenberger werd gemodelleerd .................................................................................................................................................. 24
Figuur 4.2: Verstijfde silo met aanduiding van een sector en een halve sector ...................... 25
Figuur 4.3: De randvoorwaarden van het numerieke model - Rigide versus Soepele ondersteuningen ...................................................................................................................... 27
Figuur 4.4: De belasting van het numerieke model - Rigide ondersteuningen versus Soepele ondersteuningen ...................................................................................................................... 28
Figuur 4.5: Onderverdeling van de geometrie in 4 zones voor verschillende dichtheid van het elementennet ........................................................................................................................... 31
Figuur 4.6: Overzicht van de verschillende materiaalgedragingen ......................................... 32
Figuur 5.1: Screenshot van het JAVA programma ................................................................... 35
Figuur 5.2: Menustructuur ....................................................................................................... 36
Figuur 5.3: Keuze van de constructies ..................................................................................... 37
Figuur 5.4: Geometrische parameters van de verstijfde cilinder ............................................ 37
Figuur 5.5: Invoer van de geometrische parameters ............................................................... 38
Figuur 5.6: Invoer van de parameters van het steunpunt ....................................................... 39
Figuur 5.7: Keuze van de soort ondersteuning bij type watertoren ........................................ 39
Figuur 5.8: Invoer van de parameters voor de R en U-vormige verstijvers ............................. 40
Figuur 5.9: Invoer van de parameters voor een schuine R-vormige verstijver ....................... 40
Figuur 5.10: Keuze van de sector ............................................................................................. 41
Figuur 5.11: Invoer van de materiaaleigenschappen .............................................................. 42
Figuur 5.12: Invoer van de parameters voor het elementennet (methode 1) ........................ 43
Figuur 5.13: verband verhoudingsparameter - overgangspercentage .................................... 43
Figuur 5.14: Invoer van de parameters voor het elementennet (methode 2) ........................ 44
Figuur 5.15: Keuze van de soort analyse.................................................................................. 45
Figuur 5.16: Invoer parameters voor een knikanalyse: links voor SUBSPACE – rechts voor LANCZOS ................................................................................................................................... 45
Figuur 5.17: Invoer van de parameters voor een Riks-oplossingsmethode ............................ 46
Figuur 5.18: Invoer van de parameters voor de output .......................................................... 46
Figuur 5.19: Indeling van het elementennet ........................................................................... 47
Lijst met figuren x
Figuur 5.20: Bepalen van de belasting op de bovenrand voor een 1/8ste van de schaalstructuur ......................................................................................................................... 56
Figuur 6.1: Bezwijktype Cilinderwand (links) & Verstijfde zone (rechts) ................................. 64
Figuur 6.2: De invloed van de interstringerafstand op het plooigedrag ................................. 65
Figuur 6.3: Invloed van de verstijvingsratio op het plooigedrag ............................................. 67
Figuur 6.4: Invloed van de verstijvingsratio op het plooigedrag ............................................. 68
Inleiding xi
Lijst met tabellen Tabel 2.1: Grenzen voor de kwaliteitsklassen [1] ...................................................................... 5
Tabel 4.1: Grenzen voor de kwaliteitsklassen .......................................................................... 31
Tabel 5.1: Parameters elementennet ...................................................................................... 49
Tabel 5.2: Parameters langsverstijvers .................................................................................... 50
Tabel 5.3: Parameters ringverstijvers ...................................................................................... 51
Tabel 5.4: Waarden voor de translatie .................................................................................... 51
Tabel 5.5: Lijst met element property-nummers ..................................................................... 52
Tabel 6.1: Parameters van de cilinder ..................................................................................... 62
Tabel 6.2: Afmetingen van de langsverstijver .......................................................................... 62
Tabel 6.3: Afmetingen van de ringverstijvers .......................................................................... 63
Tabel 6.4: Parameters elementennet ...................................................................................... 63
Inleiding xii
Lijst met symbolen Symbool Verklaring Eenheid d Diameter van de cilinder mm �� � Maximaal opgemeten inwendige diameter mm ���� Minimaal opgemeten inwendige diameter mm ���� Nominale inwendige diameter mm
E Elasticiteitsmodulus N/mm² fy Vloeigrens N/mm² g Eigengewicht van de kegelschaal N � Glijdingsmodulus N/mm² � de kleinste waarde van de hoogte van de kegelschaal mm �� de vloeistofhoogte mm ��� de rekenwaarde van de vloeistofhoogte mm ��� Karakteristieke waarde van de vloeistofhoogte mm ������ Lengte van de zone boven de continue ondersteuning van de kegelvormige
schaal mm
��� Lengte van de meelat in meridionale zin om locale vormafwijkingen op te meten
mm
L Meridionale lengte van het kegelsegment mm �� Interne druk parameter - ��� Zelfde als de vorige, waarbij ook het effect van het eigengewicht en de dakbelasting in rekening wordt gebracht
-
q Dakbelasting N ���� � Lijnlast in het schaalgedeelte ter hoogte van het steunpunt bij een verstijf-de silo
N/mm
� �!�"�# �! Lijnlast in de verstijver ter hoogte van het steunpunt bij een verstijfde silo N/mm $ Kwaliteitsparameter - %& Straal ter hoogte van de ondersteuning mm %�' Straal ter hoogte van het niveau tot waar de kegel gevuld is mm ( Dikte van de schaal mm (��� � Dikte van de schaal mm ( �!�"�# �! Dikte van de verstijver mm
U Verplaatsing volgens de R-as mm U0 Parameter ter bepaling van de Dimple kwaliteitsklasse - )*,� � Maximum van de hierboven vermelde tolerantieparameter - )! Parameter ter bepaling van de Out-Of-Roundness kwaliteitsklasse -
Ur,max Maximum van de hierboven vermelde tolerantieparameter - V Verplaatsing volgens de T-as mm Vk Totaal volume van de kegelschaal mm³ ,�& Volume van de kegel buiten de inwendige cilinder mm³ ,�' Volume van de inwendige cilinder mm³ W Verplaatsing volgens de Z-as mm - Elastische imperfectie paramter - -�.� Meridionale elastische imperfectiefactor - -�.. Meridionale plastische imperfectiefactor - / Hoek ingesloten tussen de symmetrieas en de raaklijn aan de kegel in me-
ridionale richting ter hoogte van het steunpunt °
/� Plastic range factor -
Inleiding xiii
χ Relatieve kniksterkte - 0� het volumegewicht van de vloeistof N/mm³ 01 Veiligheidsfactor op de belasting - 02 Veiligheidsfactor op het materiaal - 3 Interactie exponent - 45 Hoekverdraaiingen om de Z-as ° 46 Hoekverdraaiingen om de R-as ° 47 Hoekverdraaiingen om de T-as ° 45 Hoekverdraaiingen om de Z-as 8� Relatieve slankheid - 8�* Slankheid die de grens met de plastische zone aangeeft - 8�. Slankheid die de grens met de elastische zone aangeeft - 9 Coëfficiënt van Poisson - :��� � Spanning in het schaalgedeelte ter hoogte van het steunpunt bij een ver-stijfde silo
N/mm²
:�;� Rekenwaarde van de spanning in meridionale zin van de actie ter hoogte van de ondersteuning van de kegel
N/mm²
:�;�� de rekenwaarde van de spanning in meridionale zin veroorzaakt door het eigengewicht
N/mm²
:�;�. de rekenwaarde van de spanning in meridionale zin veroorzaakt door de hydrostatische belasting
N/mm²
:�;�< de rekenwaarde van de spanning in meridionale zin veroorzaakt door de dakbelasting
N/mm²
:�;� Karakteristieke waarde van de spanning in meridionale zin van de actie ter hoogte van de ondersteuning van de kegel
N/mm²
:�6�! Kritieke elastische kniksterkte N/mm² :�6� Rekenwaarde van de spanning in meridionale zin van de weerstand ter hoogte van de ondersteuning van de kegel
N/mm²
:�6� de spanning in meridionale zin ter hoogte van de ondersteuning N/mm² :�6.� Plastische referentiesterkte N/mm² : �!�"�# �! Spanning in de verstijver ter hoogte van het steunpunt bij een verstijfde silo
N/mm²
:= Spanning in omtrekszin N/mm² �� Statisch-geometrische parameter die afhangt van >of >� - Ψ�� Zelfde als de vorige, waarbij ook het effect van het eigengewicht en de dakbelasting in rekening wordt gebracht
-
> Geometrische parameter - >� Geometrische parameter -
Inleiding 1
1 Inleiding Een silo is een heel handig opslagmedium. Deze cilinder-/kegelvormige opslagplaats is ideaal voor zowel stort- als bulkgoederen. Het kan gebruikt worden om vloeistoffen en vaste stof-fen in op te slaan, denk maar aan veevoer en andere granulaten. Een traditionele silo wordt veelal uitgevoerd in staal. Het ontwerp van zo een silo is echter geen eenvoudige opdracht. Bij het ontwerpen van staalconstructies moet men er steeds met bijzondere zorg op toezien dat er geen instabiliteit kan optreden. Zo een traditionele silo bestaat immers uit een heel dunne staalplaat met aan de onderrand lokale steunpunten. Ter hoogte van deze steunpunten zullen spanningsconcentraties optreden die instabiliteit kun-nen veroorzaken. Om deze instabiliteit tegen te gaan kan de cilinderwand lokaal verstijfd worden ter hoogte van deze steunpunten. Daarnaast wordt een watertoren ook gebruikt om vloeistoffen in op te slaan. Één van de verschillen tussen een silo en watertoren kan opgemerkt worden bij het bestuderen van de manier waarop beide worden ondersteund. Een silo kan beschouwd worden als een cilinder-vormige schaalconstructie die discreet wordt ondersteund, niet noodzakelijk aan de onder-rand. Het is best mogelijk dat de silo bestaat uit een cilindrisch gedeelte dat lokaal onder-steund wordt, met aan de onderrand een kegelvormig gedeelte bevestigd. Daarentegen kan bij een watertoren het kegelvormig gedeelte uniform ondersteund ondersteld worden door de aanwezigheid van de cilindrische schacht. Er is reeds heel wat onderzoek gebeurd naar het bezwijkgedrag van kegelschalen die gevuld zijn met een vloeistof. Op basis van een uitgebreid programma met fysische experimenten en numerieke simulaties was het mogelijk om rekenregels op te stellen. Deze rekenregels zijn neergeschreven in [1]. Bij het berekenen van dergelijke constructies raakt men echter snel verstrikt in heel wat formules die in deze regels zijn opgenomen. Om het ontwerpen van dergelijke constructies gemakkelijker te maken is een programma ontwikkeld op basis van deze rekenregels, zodat de gebruiker enkel de juiste parameters dient in te voeren en ver-volgens het programma moet uitvoeren. De rekenregels en de uitwerking van dit program-ma is in het verdere verloop van deze scriptie uitgewerkt. Daarnaast wordt nog steeds heel wat onderzoek verricht op dunwandige schaalconstructies. Aan de hand van die onderzoeken kan men (steeds betere) ontwerpregels opstellen voor het dimensioneren van dergelijke schaalconstructies. Dit zowel aan de hand van experimenten op schaalmodellen als het simuleren van numerieke simulaties. Experimenten zijn uiteraard onontbeerlijk bij een goed onderzoek, maar de laatste decennia worden computersimulaties steeds belangrijker in dit onderzoeksdomein. Deze numerieke simulaties hebben het voordeel dat heel wat parameters kunnen onderzocht worden. Nu-merieke simulaties kunnen immers relatief snel en goedkoop uitgevoerd worden. Tevens is er een zeker gebruiksgemak om de invloed van talrijke parameters te onderzoeken. Om der-gelijke numerieke simulaties uit te voeren dient echter gestart te worden vanaf een compu-termodel van de schaalconstructie.
Inleiding 2
De software die wordt gebruikt om deze numerieke simulaties uit te voeren aan het Labora-torium voor Modelonderzoek is ABAQUS. Dit is een heel krachtig eindigelementen pakket, maar het heeft als nadeel dat het invoeren van een geometrie in de Graphical User Interface, kortweg GUI, heel tijdrovend is. Daarom wordt voor onderzoek uitsluitend gewerkt aan de hand van inputfiles. Deze bestanden geven een reeks van commando’s mee zodanig dat de geometrie, randvoorwaarden, belastingen, soort analyse, e.d. op een relatief eenvoudige maar zeer consequente manier aan ABAQUS worden meegedeeld. Een nadeel bij het cre-ëren van deze inputfiles is dat ze zeer foutgevoelig zijn. Net aan dit nadeel wil deze thesis een oplossing bieden. Het opzet van dit tweede luik in deze thesis is om een programma te schrijven dat het moge-lijk maakt om op een eenvoudige manier verschillende parameters te kunnen variëren. Aan de hand van een GUI worden enkele basisparameters gevraagd, welke intern in het pro-gramma worden verwerkt en als resultaat wordt een kant en klare inputfile gegenereerd. Op deze manier wordt vermeden dat de inputfile zelf manueel moet worden gewijzigd.
Met vloeistof gevulde kegelschalen 3
2 Met vloeistof gevulde kegelschalen Het doel van dit programma is een praktisch rekenmiddel aan te bieden dat kan gebruikt worden in combinatie met het 14de hoofdstuk van de aanbevelingen van de ECCS [1] om ke-gelvormige schaalconstructies te berekenen, meerbepaald kegelvormige schaalconstructies die gevuld zijn met een vloeistof en die continu ondersteund zijn aan de onderrand. In deze aanbevelingen zijn rekenregels neergeschreven om kegelvormige schaalconstructies te ont-werpen. Deze schalen kunnen bestaan uit een afgeknotte kegel met al dan niet een cilin-drisch gedeelte er bovenop. De mogelijke belastingen die kunnen aangrijpen op deze kegel-schalen zijn: het eigengewicht van de kegel, een neerwaartse belasting aan de bovenrand en/of de hydrostatische druk van een vloeistof die wordt gestockeerd in de kegelschaal. Een gedeelte van de ontwerpregels die in de aanbeveling zijn neergeschreven, zijn geïmple-menteerd in dit programma. Er kan een kegelvormige schaalstructuur berekend worden die bestaat uit een afgeknotte kegel zonder cilindrisch gedeelte. Het programma biedt de mogelijkheid om te controleren of de structuur voldoende weer-stand kan bieden aan de opgegeven belasting, rekening houdend met de nodige veiligheids-factoren. Enkel de hydrostatische druk van de vloeistof is in rekening gebracht. Tevens is er ook de mogelijkheid om zowel de capaciteits- als --p curve te laten tekenen, welke meer info geven over de situering van het ontwerppunt. In het verdere verloop van dit hoofdstuk wordt meer uitleg gegeven over hoe deze rekenre-gels zijn opgebouwd. Daarnaast wordt ook uitleg gegeven over de informatie die uit de bij-horende grafieken kan worden gehaald.
2.1 Algemeen
2.1.1 Type schaalconstructie
Deze rekenregels zijn van toepassing op kegelvormige axiaalsymmetrische kegelschalen met een constante plaatdikte, alsook op schaalstructuren die bestaan uit een combinatie van een afgeknotte kegel met een cilindrisch gedeelte er bovenop zoals weergegeven in Figuur 2.1.
Figuur 2.1: Mogelijke geometriën van de kegelschalen, a. zuivere kegelschaal, b. kegelschaal met cilindrisch
gedeelte
Met vloeistof gevulde kegelschalen 4
2.1.2 Geometrie
Aan de geometrie van de schaalconstructie zijn enkele beperkingen verbonden. De ontwerp-regels gelden slechts voor bepaalde intervallen van enkele geometrische parameters. Deze beperkingen houden in dat:
• de vorm van de kegelschaal niet convex mag zijn ten opzichte van de symmetrieas;
• er geen knikken aanwezig mogen zijn in meridionale richting ter hoogte van de on-dersteuning;
• de hoek ingesloten tussen de symmetrieas en de raaklijn aan de kegel in meridionale richting ter hoogte van het steunpunt moet begrepen zijn tussen:
15° C / C 65° (2.1)
Voor hoeken kleiner dan 15° zijn er geen betrouwbare resultaten, noch door proe-ven, noch door simulaties. Daarom is het bereik van 0° tot 15° niet geldig voor de formules die verder beschreven staan. Daarnaast worden kegelschalen met een hoek groter dan 65° niet opgenomen in deze rekenregels omdat deze een ander bezwijk-gedrag vertonen.
• de meridionale lengte van het kegelsegment groter moet zijn dan 5 · ���. Hierbij is ���
de lengte van de meelat in meridionale zin om locale vormafwijkingen op te meten:
��� � 4G%& · (HIJ/ (2.2)
• de verhouding van de straal ter hoogte van het niveau tot waar de kegel gevuld is tot de straal ter hoogte van de ondersteuning is gelimiteerd tot:
%�'%& C 10 (2.3)
• de verhouding van de vloeistofhoogte tot de straal ter hoogte van de ondersteuning eveneens gelimiteerd is tot:
��%& C 10 (2.4)
Figuur 2.2: Kegelschaal met a. concave en b. convexe vorm van de beschrijvende in meridionale zin t.o.v. de
verticale symmetrieas
Met vloeistof gevulde kegelschalen 5
2.1.3 Tolerantie
Een schaalconstructie is zeer gevoelig aan imperfecties. Bij elke kegelschaal zal men geome-trisch afwijkingen kunnen vaststellen. Dergelijke afwijkingen kunnen opgemeten worden volgens methodes die beschreven staan in de Eurocode [2]. Na het opmeten van de afwij-kingen kan gecontroleerd worden of ze binnen bepaalde grenzen vallen. Aan de hand van een aantal criteria die beschreven staan in de Eurocode kan de schaalconstructie ingedeeld worden in één van de drie onderstaande kwaliteitsklassen.
Tabel 2.1: Grenzen voor de kwaliteitsklassen [1]
Kwaliteitsklasse Omschrijving Q U0,max Ur,max
d ≤ 0,5m 0,5m < d < 1,25m 1,25m ≤ d
A Excellent 40 0,006 0,014 0,007 + 0,0093(1,25 - d) 0,007 B Hoog 25 0,010 0,020 0,010 + 0,0133(1,25 - d) 0,010 C Normaal 16 0,016 0,030 0,015 + 0,0200(1,25 - d) 0,015
Bij het berekenen van de sterkte van de schaalconstructie wordt rekening gehouden met deze imperfecties aan de hand van de kwaliteitsparameter Q. Om te bepalen tot welke klasse de schaalconstructie behoort, dienen onderstaande regels in acht genomen te worden. Elk van onderstaande voorwaarden zal de constructie indelen in de klasse A, B of C, afhankelijk van het hoogste criterium dat voldoet. Wanneer voor één bepaalde constructie de criteria verschillende klassen aanduiden, zal de klasse met de laag-ste kwaliteitsparameter worden weerhouden. Dimple
De lokale builen en deuken die initieel aanwezig zijn in de wand van de kegelschaal kunnen op een heel specifieke wijze worden opgemeten [2]. Door middel van deze meettechniek wordt een parameter U0 bekomen die moet worden vergeleken met de waarde U0,max van elke klasse (zie Tabel 2.1). Indien voldaan is aan onderstaande voorwaarde voor verschillen-de klassen, zal de schaalconstructie tot de klasse behoren met de strengste voorwaarde. )* C )*,� � (2.5) Deze controle dient vooral nagegaan te worden in de zone boven de continue ondersteuning van de kegelvormige schaal. De lengte van deze zone bedraagt ������. ������ � 5 · ��� (2.6)
��� is te bepalen door middel van vergelijking (2.2).
Out-of-Roundness
Deze tolerantie gaat na in welke mate de werkelijke inwendige diameter van de kegelschaal afwijkt van de nominale diameter. Hiervoor wordt een parameter Ur ingevoerd:
)! � �� � L �������� (2.7)
Met vloeistof gevulde kegelschalen 6
met: dmax de maximaal opgemeten inwendige diameter; dmin de minimaal opgemeten inwendige diameter; dnom de nominale inwendige diameter.
Voor elke klasse is een maximum waarde van deze out-of-roundness parameter Ur,max gege-ven (zie Tabel 2.1). Indien voldaan is aan onderstaande voorwaarde voor verschillende klas-sen, zal de schaalconstructie tot de klasse behoren met de strengste voorwaarde. )! C )!,� � (2.8)
2.1.4 Materiaal
Voor deze rekenregels is er vanuit gegaan dat het materiaal perfect elasto-plastisch is. Dit wil zeggen dat het bi-lineaire diagram kan gekarakteriseerd worden door de elasticiteitsmodulus E en de karakteristieke vloeigrens fy,k.
Figuur 2.3: Spannings-rek diagram van een perfect elastisch-plastisch materiaal
2.1.5 Belasting
Deze dunwandige schaalconstructie kan onderhevig zijn aan verschillende krachtswerkingen:
• het eigengewicht van de schaal zelf g;
• de hydrostatische druk van de aanwezige vloeistof 0�; • de dakbelasting q.
De rekenregels van het 14de hoofdstuk van de aanbevelingen mogen slechts toegepast wor-den indien aan onderstaande voorwaarden is voldaan:
0,001 C ��6�h�/r& C 10 (2.9)
Hierin is ��6� de parameter die de interne druk in omtrekszin voorstelt, dit is de verhouding van de spanning in omtrekszin := tot de kritieke elastische kniksterkte :�6�!.
��6� � |:=||:�6�!| (2.10)
fy,k
σ
ε
Met vloeistof gevulde kegelschalen 7
De voorwaarde vermeld in (2.9) is geen theoretische beperking, maar duidt het bereik aan waarin reeds uitgebreid experimenteel onderzoek is verricht door Vandepitte et al (1980) [3]. Er moet ook een zekere verhouding tussen de drie hierboven vermelde belastingen geres-pecteerd worden. Zo mag de belasting van het eigengewicht samen met de dakbelasting niet meer dan 20% van de totale verticale belasting bedragen. Anders geformuleerd moet de belasting van het eigengewicht en de dakbelasting kleiner zijn dan 25% van de hydrostati-sche belasting. :�;�� Q :�;�< C 0,2S:�;�. Q :�;�� Q :�;�<T (2.11)
Of :�;�� Q :�;�< C 0,25:�;�. (2.12)
met: :�;�� de rekenwaarde van de spanning in meridionale zin van het eigengewicht; :�;�< de rekenwaarde van de spanning in meridionale zin van de dakbelasting; :�;�. de rekenwaarde van de spanning in meridionale zin veroorzaakt door de hy-
drostatische belasting.
2.1.6 Randvoorwaarden
De onderrand van de kegelschaal kan ofwel (gedeeltelijk) ingeklemd of scharnierend zijn. De bovenrand van de kegel mag ook verstijfd zijn door middel van ringverstijvers die er voor zorgen dat de bovenrand cirkelvormig blijft, maar die tegelijkertijd verplaatsingen uit het vlak toelaten. Ze mag ook gewoon vrijgelaten worden. Deze laatste situatie stemt ook het best overeen met de randvoorwaarden in laboratorium-omstandigheden. Daar zal immers de kegel geleidelijk gevuld worden met een vloeistof tot wanneer de schaalconstructie bezwijkt.
2.2 Rekenregels
Alvorens meer uitleg wordt gegeven over hoe deze rekenregels zijn opgebouwd, wordt ver-wezen naar Bijlage 1: Rekenvoorbeeld achteraan deze scriptie. In deze bijlage staat een voorbeeld beschreven van een kegelvormige schaalstructuur zonder cilindrisch gedeelte.
2.2.1 Algemeen
Het doel van deze rekenregels is om na te gaan of de plooisterkte wordt overschreden door de aanwezigheid van de belastingen die zijn aangehaald in paragraaf 2.1.5. Volgende voor-waarde dient geverifieerd te worden: :�;� C :�6� (2.13)
met: :�;� de rekenwaarde van de spanning in meridionale zin van de actie; :�6� de rekenwaarde van de spanning in meridionale zin van de weerstand.
Met vloeistof gevulde kegelschalen 8
Wanneer de verhouding van de rekenwaarden van de weerstand tot de actie wordt geno-men, bekomt men een ratio die aangeeft hoe groot de veiligheid van de constructie is. Wan-neer deze ratio groter is dan één heeft men een veilige ontwerpsituatie.
2.2.2 Belangrijke parameters
De bezwijkbelasting van de continu ondersteunde kegelvormige schaalconstructie is recht-evenredig met de totale verticale belasting die op de constructie aangrijpt. De belastingen die in paragraaf 2.1.5 zijn aangehaald kunnen op een eenvoudige manier samengesteld wor-den tot twee parameters. De eerste parameter ��� stelt ook de interne druk parameter voor, maar hier wordt ook het effect van het eigengewicht en de dakbelasting in rekening gebracht. Het verband tussen ��� en �� is hieronder weergegeven. ��� � U1 Q H=V · �� (2.14)
��;� � |:=;�|:�6�! � U0���V� %&/U( · cos/V:�6�! (2.15)
H= � 0�"���0� · ( sin/�� (2.16)
De tweede parameter ��� karakteriseert de geometrie van de kegelvormige schaalconstructie. ��� � U1 Q H�V · �� (2.17)
�� � 16 · >� · \]3 L 2 ���_ U2 Q >�V Q ���` (2.18)
>� � (ab/ · ��%& (2.19)
Wanneer de vloeistofhoogte kleiner is dan de hoogte van de kegelschaal (h’ = h) moet de
parameter ��� bepaald worden aan de hand van de drie bovenstaande formules, waarbij ver-gelijking (2.18) vereenvoudigd kan worden tot vergelijking (2.20). Is dit niet het geval, dan moet vergelijking (2.18) rechtstreeks gebruikt worden.
�� � 16 · >� · U3 Q >�V (2.20)
Om de invloed van het eigengewicht en de dakbelasting in rekening te brengen wordt ge-bruikt gemaakt van de parameter H�. Deze wordt berekend aan de hand van onderstaande vergelijkingen.
H� � H� · ��� Q H< · ��< Q H= · ��=U1 Q H=V · �� (2.21)
Met vloeistof gevulde kegelschalen 9
��� � U1 Q c · sin/2%& V · c · sin/%& (2.22)
��� � U1 Q c · sin/%& V (2.23)
H� � H=sin²/ (2.24)
H< � �0���%& (2.25)
2.2.3 Elastische kritieke plooiweerstand
De formulering van de elastische meridionale plooiweerstand die hier wordt gebruikt, is ge-baseerd op een uitgebreid onderzoek naar de plooisterkte bij kegelvormige schaalconstruc-ties (Vandepitte et al (1980)). De elastische meridionale plooiweerstand van een onverstijfde kegelvormige schaal die belast wordt in de zin van deze beschrijvende wordt gegeven door:
:�6�! � 0,605 · e · ( · HIJ/%& (2.26)
2.2.4 Rekenwaarde van de plooiweerstand
De rekenwaarde van de plooiweerstand volgens meridionale zin :�6� wordt bepaald aan de hand van onderstaande vergelijkingen: :�6� � f�. · :�6.� (2.27)
:�6� � :�6� 02⁄ (2.28)
met: f�. de reductiefactor voor de kniksterkte; :�6.� de plastische referentiesterkte; :�6� de spanning in meridionale zin ter hoogte van de ondersteuning; 02 de veiligheidsfactor op het materiaal. Hierbij wordt de plastische referentiesterkte bepaald door:
:�6.� � ���h1 Q ��� Q ��� ' · ij,� (2.29)
2.2.5 Rekenwaarde van de belasting
Om de rekenwaarde van de spanning in meridionale zin van de belasting σ�;� te berekenen zal niet de volledige inhoud van de kegel in rekening gebracht worden. Enkel het gearceerde gedeelte in Figuur 2.4 zal er voor zorgen dat de schaalstructuur al dan niet bezwijkt.
Met vloeistof gevulde kegelschalen 10
Figuur 2.4: Volume dat bijdraagt tot bezwijken
Het volume van het gearceerde gedeelte kan berekend worden als volgt:
,�& � 2 · l · m%& Q ��� · tan/3 p · ��� ² · tan/2 (2.30)
Het volume van de inwendige cilinder bedraagt: ,�' � l · %&² · ��� (2.31)
Het totale volume van de kegelschaal Vk is de som van de twee bovenstaande formules. Het gewicht wordt bekomen door Vk te vermenigvuldigen met het volumegewicht van de vloei-stof. ,� � ,�& Q ,�' (2.32) �� � 0� · ,� (2.33)
De belasting die op de schaalconstructie aanwezig is wordt omgevormd tot een parameter die de interne druk in de schaal voorstelt. De karakteristieke waarde van deze parameter wordt berekend met vergelijking (2.15). In de aanbevelingen van de ECCS [1] zijn twee re-kenmethodes terug te vinden om de rekenwaarde van de interne druk parameter te bereke-nen. Door twee methoden toe te laten zou er voldoende flexibiliteit moeten zijn zodat elke praktische situatie kan berekend worden. Methode 1:
De rekenwaarde van de meridionale drukspanning σ�;� kan worden berekend aan de hand van onderstaande formulering: σ�;� � ��� · ��;� · :�6�! (2.34)
Voor het berekenen van de rekenwaarde van de interne druk parameter ��;� wordt verwe-zen naar vergelijking (2.14), waar ��;� wordt berekend door onderstaande vergelijking.
��;� � 0�� · ��� · %& U( · HIJ/V⁄ :�6�! (2.35)
r2
r1
h'k
Met vloeistof gevulde kegelschalen 11
In deze vergelijking wordt de karakteristieke waarde van de vloeistofdichtheid 0�� en de re-kenwaarde van de vloeistofhoogte ��� gebruikt. De veiligheidsfactor 01 die van toepassing is op de belasting wordt gebruikt om de vloeistof-hoogte te verhogen. De rekenwaarde van de vloeistofhoogte wordt door onderstaande for-muleringen bepaald voor het geval de schaalstructuur uit een kegel-cilinder combinatie be-staat. Wanneer de schaalconstructie enkel uit een kegel bestaat moet vergelijking (2.36) gebruikt worden. ��� � ��� · 1>�� · mq01 rS1 Q >��T³ L 1t Q 1u L 1p als ��� v ��� v � (2.36)
��� � ��� · w >>�� Q 01 rS1 Q >��T³ L 1t L SU1 Q >V³ L 1T3U1 Q >V² · >�� x als ��� v � v ��� (2.37)
��� � ��� · m01 L U01 L 1V U3>² Q 2>³V3U1 Q >V² · >��p als � v ��� v ��� (2.38)
Hierbij is h’ de hoogte van het vloeistofniveau ten opzichte van de onderrand en h de klein-ste waarde van de hoogte van de kegelschaal of de zonet vermelde hoogte h’. Deze hoogtes zijn aangeduid op Figuur 2.1. Methode 2:
De karakteristieke waarde van de meridionale drukspanning ten gevolge van de vloeistof die aanwezig is in de kegelvormige schaalconstructie :�;�, kan berekend worden aan de hand van onderstaande formulering:
:�;� � 0� · ,�&2 · l · %& · ( · cos/ (2.39)
Om de rekenwaarde van bovenstaande drukspanning σ�;� te berekenen wordt onderstaan-de formule gebruikt: :�;� � 01 · :�;� (2.40)
Voor het berekenen van de rekenwaarde van de interne druk parameter zonder eigenge-wicht en additionale dakbelasting ��;�, wordt bij deze methode de rekenwaarde van de vloeistofdichtheid 0��en de karakteristieke waarde van de vloeistofhoogte ��� gebruikt. De veiligheidscoëfficiënt 01voor de aanwezige belasting wordt toegepast op de vloeistofdicht-heid.
��;� � U010��V · ��� · %& U( · HIJ/V⁄ :�6�! (2.41)
Met vloeistof gevulde kegelschalen 12
2.2.6 Rekenwaarde van de reactie
De weerstandswaarde van de actie wordt bepaald op basis van twee soorten grafieken. Daarom is het nuttig deze twee grafieken eerst toe te lichten alvorens over te gaan tot de bepaling van de weerstandswaarde. Capaciteit curve
De capaciteitscurve geeft weer op welke manier de constructie zal bezwijken in functie van
de relatieve slankheid. Hierbij is 8� de relatieve slankheid van de volledige structuur, geken-merkt door de wortel van de verhouding van de plastische referentie weerstand tot de elas-tische kritieke plooiweerstand. Wanneer de geometrie en de vloeigrens vastliggen, dan ligt de relatieve slankheid ook vast. Deze parameter laat toe om verschillende structuren op een uniforme manier te behandelen.
8� � q:�6.� :�6�!⁄ (2.42)
In Figuur 2.5 is een capaciteitscurve weergeven. Deze curve is opgebouwd uit drie zones die elk aangeven door welk soort bezwijkmechanisme de constructie bezwijkt. In de zone links
van 8�* zal het materiaal zuiver plastisch bezwijken zonder dat de geometrische niet-
lineariteit enige invloed zal hebben. In de zone rechts van 8�. zal net het omgekeerde gebeu-
ren, hier zal de constructie bezwijken ten gevolge van elastische instabiliteit zonder dat het materiaal plastisch zal worden. De zone tussen de twee grenzen geeft de interactie weer tussen de twee vermelde zones: hier zal het bezwijken gebeuren door zowel geometrische niet-lineariteit als plasticiteit.
Figuur 2.5: Capaciteitscurve
Een opmerking dient gemaakt te worden bij Figuur 2.5, de parameter / mag niet verward worden met de openingshoek van de kegelschaal. Hier betreft het één van de parameters die het plastische gebied bepalen. Om verwarring te vermijden zal /� als symbool worden gebruikt. In Figuur 2.5 is langsheen de verticale as de relatieve kniksterkte f weergeven. Deze para-meter is de verhouding tussen de karakteristieke sterkte in meridionale zin ter hoogte van de ondersteuning :�6�en de karakteristieke plastische bezwijkspanning :�6.�.
Met vloeistof gevulde kegelschalen 13
f � :�6�:�6.� (2.43)
De vorm van de capaciteitscurve wordt bepaald door onderstaande uitdrukkingen: f � 1 als 8� C 8�* (2.44)
f � 1 L /� m 8� L 8�*8�. L 8�*py als 8�* C 8� C 8�. (2.45)
f � -8�' als 8�. C 8� (2.46)
Hierbij is - de elastic imperfection factor die verderop wordt geformuleerd in vergelijking (2.48), /� � 0.6 is de plastic range factor, 3 � 1 de interaction exponent en 8{0 � 0.2 is de squash limit slenderness. De slankheid 8{� die de limiet aangeeft voor plasticiteit wordt gege-
ven door onderstaande vergelijking:
8�. � G αU1 L β�V (2.47)
Aangezien de interactie exponent 1 bedraagt, zal de overgangszone lineair benaderd worden zoals in Figuur 2.6 te zien is.
Figuur 2.6: Capaciteitscurve met lineaire interactie
ααααxp - p curven
Bij een lineaire theorie is de kritieke meridionale kniksterkte :�6�! voor schalen onafhanke-lijk van de interne druk die aanwezig is. De aanwezigheid van uniform verdeelde spanningen in omtrekszin zal de waarde van :�6�! niet beïnvloeden (e.g. Flügge, 1973 [4]). Dit omdat de eigenmodes axiaalsymmetrisch zijn en een uniform verdeelde interne druk de kritieke span-ningen van dergelijke modes niet kan veranderen.
0
0,2
0,4
0,6
0,8
1
0 0,2 0,4 0,6 0,8 1
χχχχ
λ_λ_λ_λ_bar
Plastic
Interaction
Elastic
8�* 8�.
Met vloeistof gevulde kegelschalen 14
Voor een imperfecte cilinder kan de elastische meridionale kniksterkte -� · :�6�! opmerke-lijk hogere waarden aannemen indien er interne druk aanwezig is. Dit komt doordat de in-terne druk ervoor zal zorgen dat de geometrische imperfecties een minder schadelijk effect zullen hebben, doordat deze interne druk de zones met samengedrukte membraanspannin-gen die geïnduceerd worden door imperfecties zal beperken of verminderen. (Calladine, 1983 [5]; Rotter and Teng, 1989 [6]). Bij hoge waarden van de interne druk parameter zal de combinatie van de meridionale sa-mendrukking en de spanningen in de omtrekszin lokaal vloeien doen ontstaan. Dit komt doordat de spanningen volgens twee assen kunnen samengesteld worden tot een hogere spanning volgens de methode van von Mises. Op plaatsen die grenzen aan steunpunten, ringen, naden en plaatsen waar de plaatdikte wijzigt, zal er eerder plastische instabiliteit optreden, bekend onder de term elephant’s foot. Dit is te wijten aan de lokale verstoring van de membraanspanningen door de aanwezigheid van lokale buiging ter hoogte van deze kri-tieke plaatsen.
Figuur 2.7: αααα - � grafieken met ECCS ontwerppunt
In Figuur 2.7 is de elastische imperfectiefactor bij aanwezigheid van interne druk uitgezet in
functie van de interne druk -�. � iU�V. De waarde van αxp kan echter niet door een eendui-
dige formule beschreven worden. Dit omdat er een stabiliserend effect optreedt voor de elastische knik, maar een destabiliserend effect omdat er mogelijkheid is tot plastisch be-zwijken onder de vorm van elephant’s foot. De waarde van de elastische imperfectiefactor bij aanwezigheid van interne druk wordt bepaald door het minimum van twee functies: de -�.� en de -�.. functie. De waarde van -�.� geeft de elastische stabilisatie weer in functie
van de toename van de spanningen in omtrekszin, de waarde van -�.. geeft de plastische
destabilisatie weer. Bij de berekening van de constructie zal echter geen rekening gehouden worden met de plastische tak.
-�.� � 0,5 ]1 L 1,50$ _ mtan/>�� · ��p*,&~�r&�&,**� t (2.48)
-�.. � m1 L ��8��p ]1 L 11,12 Q J&,�_ ms² Q 1,218��'JUJ Q 1V p (2.49)
0
0,1
0,2
0,3
0,4
0 0,1 0,2 0,3
αααα
p_bar
alpha_xpe
alpha_xpp
Interaction Elastic
Met vloeistof gevulde kegelschalen 15
J � 1400 %( cos/ (2.50)
Om deze elastische en plastische tak te kunnen plotten zal gebruik gemaakt worden van de formuleringen die hierboven zijn vermeld waarbij �� zal variëren. De vorm van beide functies is te beschouwen in Figuur 2.7. Om daarenboven het interactie gedeelte in deze grafiek te kunnen plotten, is een iets meer ingewikkelde aanpak nodig. Voor een bestaande construc-
tie kan de relatieve slankheid 8� berekend worden. In functie van de interne druk �� die wordt
gevarieerd, zal de parameter 8�. andere waarden krijgen. Aan de hand van de waarde van 8�.
en de vergelijkingen (2.44) tot (2.46) kan de overeenkomstige parameter f worden bepaald. Deze parameter kan dan op zijn beurt ingevuld worden in vergelijking (2.51) om zo tot de waarde van - te komen voor de interactiecurve. -��"�! �"�� � f · 8�² (2.51)
Bepalen van de weerstandswaarde
De weerstandswaarde van de schaalconstructie wordt bepaald door de manier waarop de constructie bezwijkt. Zoals vermeld bij de uitleg over de capaciteitscurve kan de constructie zuiver plastisch, zuiver elastisch of elastisch-plastisch bezwijken. Dit wordt bepaald op basis
van relatieve slankheid 8� en de twee grenswaarden die de plastische en elastische zone af-
bakenen 8�* respectievelijk 8�.. De waarde van de relatieve slankheid 8� wordt bepaald aan de
hand van vergelijking (2.42), de grenswaarde die de zuiver plastische zone afbakent wordt in
dit geval vastgelegd op 8�* � 0,2 en de grenswaarde 8�. die de zuiver elastische zone afba-
kent kan berekend worden op basis van vergelijking (2.47). Om uiteindelijk de karakteristieke weerstandswaarde in meridionale zin te berekenen moet vergelijking (2.43) gebruikt worden. De waarde van de relatieve kniksterkte f wordt bepaald door vergelijking (2.44), (2.45) of (2.46). Om te bepalen welke vergelijking nodig is, moeten de hierboven vermelde slankheden gebruikt worden. De rekenwaarde wordt bekomen door de karakteristieke weerstandswaarde te delen door de materiaalfactor 02.
Uitwerking JAVA-applet 16
3 Uitwerking JAVA-applet In vorig hoofdstuk is aangehaald wat de rekenregels voorschrijven en in welke situaties deze geldig zijn. Op basis van deze rekenregels is het programma gebaseerd, echter niet alle situa-ties zijn mogelijk in het programma. Er wordt slechts één van de 3 vermelde belastingen in rekening gebracht bij dit programma, namelijk de hydrostatische druk van de gestockeerde vloeistof. Ook wat de geometrie betreft is niet alle functionaliteit mogelijk. Er kan enkel een kegelschaal gemodelleerd worden, de optie met cilindrisch gedeelte is niet geïmplemen-teerd. Om dit programma voor iedereen toegankelijk te maken is ervoor gekozen om de rekenap-plicatie in een Java-applet te gieten. Het voordeel van deze toepassing is dat het programma van op een website gedraaid kan worden op eender welke computer, onafhankelijk van het besturingssysteem dat er op draait. Van de code voor het programma was reeds een basisversie geschreven in Java. Hier was enkel de rekenmodule geïmplementeerd en het was niet in een applet-vorm geschreven. Door de keuze om dit programma naar een applet om te vormen kon niet met het bestaan-de Java-programma worden verder gewerkt. De GUI is opnieuw opgesteld, de rekencode zelf kon wel nog voor een deel gerecupereerd worden. Er is wel nog extra functionaliteit toege-voegd om grafieken weer te geven en in de nieuwe versie is er ook een helpfunctie aanwe-zig. Dit programma is opgebouwd uit een aantal vensters. Het eerste venster dat is weergegeven in Figuur 3.1 is het hoofdvenster. In onderstaande paragrafen wordt meer uitleg gegeven over elk deelvenster, over hoe het programma is opgebouwd en welke functie het heeft.
Figuur 3.1: Hoofdvenster
Uitwerking JAVA-applet 17
3.1 Hoofdvenster
In dit hoofdvenster kan de gebruiker de basisgegevens invoeren en de resultaten van de be-rekening terugvinden.
3.1.1 Invoer basisgegevens
Geometry
De basisparameters om de geometrie van de kegelschaal te bepalen kunnen hier ingevoerd worden. Hieronder vallen de straal van de kegelschaal ter hoogte van de onderrand, de vloeistofhoogte ten opzichte van de onderrand, de dikte van de kegelschaal en de hoek die wordt ingesloten tussen de verticale symmetrieas en de beschrijvende in meridionale zin ter hoogte van de onderrand. Material & Quality
De vloeigrens, elasticiteitsmodulus en kwaliteitsklasse kunnen hier ingevoerd worden. Dit zijn de parameters die de materiaaleigenschappen van de schaalconstructie bepalen. Voor de kwaliteitsklasse kan gekozen worden uit de drie gedefinieerde klassen. Naast de materiaaleigenschappen van de schaal kan ook het volumegewicht van de aanwe-zige vloeistof ingegeven worden. Safety
Bij de berekening wordt rekening gehouden met de twee traditionele veiligheidsfactoren. De eerste veiligheidsfactor is deze die wordt toegepast op de sterkte van het materiaal, de tweede is van toepassing op de belasting.
3.1.2 Resultaten
Elastic critical stress
In dit veld wordt de elastische kritieke spanning weergegeven voor de ingevoerde construc-tie. De berekening gebeurt op basis van vergelijking (2.26). Method 1 en method 2
In deze twee zones worden de weerstandswaarde en de rekenwaarde van de acties weerge-geven. Tevens wordt een ratio bepaald die aangeeft of de constructie veilig is volgens de betreffende methode. Naast deze informatie wordt ook aangegeven volgens welke manier de constructie zal bezwijken. Dit is op basis van de relatieve slankheid van de volledige schaalconstructie. De drie mogelijkheden zijn Elastic, Elastic-Plastic of Plastic.
3.1.3 Actieknoppen
Er zijn vier actieknoppen
• Met de Clear-knop zullen alle invoer- en uitvoervelden gewist worden.
• Indien alle invoervelden correct zijn ingevuld kan op de knop Calculate gedrukt wor-den. Wanneer echter een foute parameter is ingevoerd; bvb. geen getal of een getal dat niet voldoet voor de voorwaarden van een bepaalde parameter, dan zal de ge-bruiker hiervan op de hoogte gesteld worden door middel van een foutmelding zoals in Figuur 3.2 is weergegeven.
Uitwerking JAVA-applet 18
• Om de grafieken weer te geven die vermeld zijn in paragraaf 2.2.6 dient op de knop Graph geklikt te worden, er zal dan onmiddellijk een deelvenster verschijnen waarin de grafieken kunnen worden weergegeven. Om deze grafieken weer te geven is het uiteraard noodzakelijk dat de berekening is doorgevoerd. Indien dit echter nog niet is gebeurd zal de berekening automatisch uitgevoerd worden om daaropvolgend het deelvenster Graphs weer te geven.
• Indien de gebruiker meer informatie wenst over hoe dit programma correct wordt gebruikt kan naar het deelvenster Help gegaan worden door op de knop Help te klik-ken. Hier is tevens meer uitleg te vinden betreffende het doel van dit programma, alsook de aansprakelijkheid naar de ontwerpers van dit programma.
Figuur 3.2: Foutmelding bij foutieve invoer
3.2 Deelvenster Graphs
In dit deelvenster kunnen de twee vermelde grafieken worden weergegeven. Dit deelvenster is opgebouwd uit drie zones.
Figuur 3.3: Deelvenster “Graphs” met de twee soorten grafieken
Graph area
Dit is de witte zone waar de grafiek wordt getekend. Bovenaan dit tekengebied wordt steeds neergeschreven welke methode is gebruikt en welke grafiek wordt getekend. Beide grafie-ken bestaan steeds uit een plastisch – interactie – elastisch gedeelte. Deze drie takken zijn steeds in een verschillende kleur weergegeven. De plastische tak is rood, de elastische tak is blauw en de interactie tak is groen getekend. Het ontwerppunt wordt ook steeds aangeduid op beide curven. Omdat dit ontwerppunt buiten het tekengebied kan vallen is een schaal-functie in het programma verwerkt.
Uitwerking JAVA-applet 19
Select Graph
Hier kan de keuze worden gemaakt tussen de twee berekeningsmethode en de soort grafiek die moet weergegeven worden: de capaciteitscurve of de α-p curve. Wanneer één van de opties wordt gewijzigd of indien een andere methode wordt gekozen wordt onmiddellijk de grafiek aangepast aan de gekozen methode. Scaling
Zoals hiervoor reeds is vermeld zit er een schaalfunctie in het programma verwerkt. Dit stelt de gebruiker instaat om zowel de schaal volgens de x-as als volgens de y-as aan te passen. Het bereik waarin geschaald kan worden is 0% tot 200% van de maximale waarde van elke as. Aangezien volgens beide assen de maximale waarde steeds de eenheid bedraagt kan het bereik dus van 0 tot 2 geschaald worden.
3.3 Deelvenster Help
In dit deelvenster kan de gebruiker meer informatie terugvinden over het programma. Dit venster bestaat uit een aantal tabbladen.
Figuur 3.4: Deelvenster “Help”
About
Hierin is het doel van dit programma uitgelegd, samen met de mededeling dat de makers van dit programma in geen geval kunnen verantwoordelijk gesteld worden indien dit pro-gramma geen correcte resultaten geeft. Tevens wordt hier vermeld welke waarde de drie plastische plooiparameters hebben: 8* � 0.2, / � 0.6 en 3 � 1. Geometry
In dit gedeelte wordt meer uitleg geven over de vier geometrische parameters: r1, h, t en /.
Uitwerking JAVA-applet 20
Material
Hier is meer uitleg te vinden over de materiaalparameters fy,k en E en de belastingsparame-
ter γ ’, samen met de tabel van de kwaliteitsklassen waaruit de parameter Q komt. Results
Hier wordt de gebruiker geïnformeerd omtrent het bestaan van twee ontwerpmethodes die zijn neergeschreven in de 5de editie van de Recommendations en wat het verschil is tussen beide methodes. Graph
In dit gedeelte is meer uitleg te vinden over de twee grafieken die kunnen getekend worden. Verder wordt ook uitgelegd wat het ontwerppunt aanduidt.
3.4 Rekenmodule
De berekening in het programma maakt gebruik van de regels die beschreven zijn in para-graaf 2.2. Voor beide methodes worden een aantal parameters berekend. Om een duidelijk beeld te krijgen van de opeenvolging van de formules die gebruikt worden is een rekenvoor-beeld toegevoegd. Dit is terug te vinden in Bijlage 1: Rekenvoorbeeld achteraan deze scrip-tie. De codering van de rekenmodule is terug te vinden in Bijlage 2: Programmacode ECCS
vanaf regel 1756 tot 1878.
3.5 Tekenmodule
Om grafieken toe te voegen aan de applet was er geen bruikerbare klasse1 voor handen. Daarom is een toevlucht gezocht naar de abstracte klasse Graphics [7] van JAVA. Deze klasse laat toe om op JAVA-componenten te tekenen. Omdat de klasse Graphics een abstracte klas-se is, kan er niet zomaar een object2 van gemaakt worden. Daarom zal de functionaliteit van deze klasse moeten overgeërfd3 worden naar een andere klasse waarvan wel een object kan gemaakt worden. Hiervoor is de klasse grafiekPaneel gemaakt, die de functionaliteit van de JAVA-klasse JPanel overerft. Aangezien JPanel ook behoort tot de klasse Container waarin de klasse Graphics zit, zal dus de functionaliteit van de Graphics-klasse aan de klasse grafiekPaneel zijn toegevoegd. Door een object van de JPanel klasse toe te voegen aan het deelvenster Graphs van het pro-gramma, zal een zone in dit deelvenster worden opgenomen waarin kan getekend worden. Het object van de klasse grafiekPaneel dat is toegevoegd heeft de naam tekenpaneel. De exacte codering van de tekenmodule is terug te vinden in Bijlage 1: Rekenvoorbeeld. Hieronder worden de belangrijkste zaken uit de code overlopen en toegelicht.
1 Een klasse is een verzameling van methoden en variabelen die gebruikt kunnen worden om bepaalde functio-
naliteit toe te voegen. 2 Een object is een verzameling van toestandsruimte en operaties die kan gebruikt worden als het programma
draait. 3 Wanneer de functionaliteit van een eerste klasse wordt overgeërfd naar een tweede klasse, zal een object op
basis van deze tweede klasse ook operaties van de eerste klasse kunnen uitvoeren.
Uitwerking JAVA-applet 21
Regel 17 – 47:
Om het tekenen van de --curves op een eenvoudige manier te laten verlopen is een klasse calc aangemaakt die twee functies heeft:
• calc.alpha_xpe() Deze functie geeft de waarde -�.� van vergelijking (2.48).
De parameters die worden meegegeven zijn: $, %&, � en ��.
• calc.alpha_xpe() Deze functie geeft de waarde van -�.. van vergelijking (2.49).
De parameters die worden meegegeven zijn: ��, 8�, %&, ( en /. Regel 49 – 93:
Hier is een klasse assenstelsel gedefinieerd die ervoor zorgt dat een orthogonaal XY-assenstel wordt toegevoegd aan de tekenruimte. Deze klasse bevat één actie:
• tekenAssenstelsel()
De parameters die hier worden meegegeven bepalen onder andere de afmetingen van de tekenruimte die beschikbaar is, welke schaal er wordt gebruikt en welk type grafiek wordt weergegeven. De coödinaten van de oorsprong zijn opgegeven samen met de lengte van de x- en y-as. De eenheid volgens de x-as komt overeen met de bruikbare breedte van het tekengebied. Dit is de breedte vanaf de oorsprong tot een zekere afstand voor het pijltje van de x-as. Analoog wordt de eenheid van de y-as vastgelegd op de volledige bruikbare hoogte. Deze hoogte loopt vanaf de oorsprong tot op enige afstand voor het pijltje van de y-as. De zone waarin de punten van de grafiek kan worden getekend is weergegeven op.
Figuur 3.5: Het tekengebied
Een extra moeilijkheid bij het tekenen van de grafiek is het verschil in definitie van de beeldpunten in het assenstelsel van het tekengebied (groene assenstelsel) en de de-finitie van een beeldpunt in het assenstelsel van de grafiek (rode assenstelsel). Een beeldpunt in het tekengebied is gedefinieerd in een assenstelsel met de oorsprong links boven, een naar rechts georiënteerde x-as en een naar onder georiënteerde y-
TEKENRUIMTE
de zone waarin de grafiek wordt getekend deze ruimte
de oorsprong van de grafiek
de oorsprong van het tekengebied
Uitwerking JAVA-applet 22
as. Het assenstelsel van de grafiek heeft een x-as die naar rechts georiënteerd is, maar de y-as is naar boven georiënteerd.
Regel 95 – 357:
In dit gedeelte is de klasse grafiekPaneel gedefinieerd. Deze klasse heeft één actie, na-melijk paintComponent() waarin verschillende onderdelen zitten vervat. Deze worden hieronder per sectie toegelicht.
• Regel 110 – 113 Dit stuk code zorgt dat de tekenruimte een witte achtergrondkleur krijgt en van een zwarte buitenrand wordt voorzien.
• Regel 115 – 127
Deze regels code zorgen ervoor dat de oorsprong van de grafiek wordt vastgelegd zodanig dat er steeds voldoende marge is ten opzichte van de buitenrand van de te-kenruimte.
• Regel 130 – 136
Met dit stukje code wordt de legende van de verschillende curves in de rechter bo-venhoek van de tekenruimte geplaatst.
• Regel 139 – 174
Dit stuk code tekent de capaciteitscurve voor methode 1 indien deze functie gese-lecteerd is. Eerst wordt bovenaan in de tekenruimte de kop van de figuur aangepast naar Method 1: Capacity Curve.
Vervolgens wordt f in functie van 8� punt per punt getekend in het tekengebied. Om dit te realiseren wordt een lus uitgevoerd die elk beeldpunt in de x-richting over-loopt dat binnen het assenstelsel van de grafiek valt. Voor elke x-waarde die in de
lus wordt doorlopen, wordt een overeenkomstige 8�-waarde berekend, waarbij re-kening wordt gehouden met de schaal. Met de berekende waarde van de relatieve slankheid wordt de overeenkomstige waarde van de relatieve kniksterkte f bere-kend op basis van de vergelijkingen (2.44) tot (2.46).
Bij het doorlopen van de lus, zal bij elke iteratie steeds de 8�- en f-waarde gekend zijn voor twee opeenvolgende x-waarden. Aan de hand van deze vier waarden kun-nen de overeenkomstige x- en y-waarden berekend worden. Bij het omrekenen van
de 8�- en f-waarde naar de overeenstemmende x- en y-waarde zal rekening gehou-den worden met de schaalfactor. Eens deze twee x- en y-waarden berekend zijn, kan een lijn tussen beide getekend worden. Afhankelijk van het feit dat de waarde van de curve tot het zuiver plastisch, zuiver elastisch of het elastisch-plastisch ge-bied behoort, zal de lijn in het rood, blauw of groen getekend worden. Om de werking van deze schaalfactor uit te leggen wordt volgend voorbeeld gege-ven. Als de breedte van het tekengebied uit 100 beeldpunten bestaat, zijn er 100
mogelijke x-waarden. Er zijn dus 100 8�-waarden die elk horen bij een overeenkom-
stige x-waarde. Voor elke 8�-waarde wordt de overeenkomstige 8�-waarde berekend. Deze waarde moet worden uitgezet volgens de y-as. Onderstel nu een schaalfactor
Uitwerking JAVA-applet 23
van 1. Dit houdt in dat voor een x-waarde gelijk aan 100 er een 8�-waarde overeen-
komt gelijk aan 1, analoog komt een x-waarde van 50 overeen met een 8�-waarde gelijk aan 0,5. Wanneer de gebruiker met de schuifbalk kiest om de maximale waar-
de volgens de x-as gelijk te stellen op 8� = 2, dan moet nu voor een x-waarde van 50
de 8�- en f-waarde verschijnen die in het vorige geval hoorde bij een x-waarde van 100. Wanneer dezelfde functie wordt gebruikt om van een x-waarde over te gaan
naar een 8�-waarde, dan moet de x-waarde vermenigvuldigd worden met 2, dit is net de schaalfactor die wordt bekomen door middel van de schuifbalk.
• Regel 176 – 244
Dit stuk code behandelt het tekenen van de - -p curve voor methode 1, maar het zal analoog gebeuren zoals beschreven in regel 139 tot 174. Eerst wordt de grafiek-titel aangepast naar Method 1: alpha-p curve. Vervolgens wordt - uitgezet in functie van ��. Hierbij wordt gebruik gemaakt van de functies calc.alpha_xpe() en calc.alpha_xpe(). De waarden -�.� en -�.. die deze
functies teruggeven kunnen onmiddellijk worden uitgezet in functie van ��. Het wordt wel iets ingewikkelder om het interactiegedeelte te tekenen. Voor een
bestaande constructie kan de relatieve slankheid 8� berekend worden. In functie van
de interne druk �� die varieert, zal de parameter 8�. andere waarden krijgen. Aan de
hand van de waarde van 8�. en de vergelijkingen (2.44) tot (2.46) kan de overeen-
komstige parameter f worden bepaald. Deze parameter kan dan op zijn beurt inge-vuld worden in vergelijking (2.51) om de waarde van - te bekomen voor de interac-tiecurve.
• Regel 246 – 280
Idem als bij regel 139 – 174, behalve dat de in de titel Methode 2 komt te staan.
• Regel 283 – 351
Idem als bij regel 176 – 244, behalve dat de in de titel Methode 2 komt te staan.
• Regel 353 – 355:
Tot slot wordt nog het ontwerppunt op de figuur gezet.
Numerieke simulaties van schaalstructuren 24
4 Numerieke simulaties van schaalstructuren
4.1 Algemeen
Aan de hand van numerieke modellen is het mogelijk om silo’s en watertorens te simuleren en hun bezwijkgedrag te onderzoeken. Het voordeel van deze numerieke simulaties is dat deze snel en op een goedkope manier kunnen uitgevoerd worden. Met behulp van deze si-mulaties kunnen uiteindelijk ontwerpregels worden opgesteld. Om dergelijke numerieke simulaties te kunnen uitvoeren moet een numeriek model opge-steld worden van de schaalconstructie. In het kader van verschillende onderzoeken zijn er reeds een aantal modellen ontwikkeld. In dit hoofdstuk wordt wat meer informatie verschaft over de ontwikkeling van de modellen die nuttig zullen blijken voor het verdere verloop van deze thesis. Nadat een dergelijk model is opgesteld, kunnen hier simulaties worden mee uitgevoerd. Er zijn een aantal types van berekeningsmethoden die relevant zijn voor cilinderschalen. Welke analyses nuttig zijn wordt op het einde van dit hoofdstuk aangehaald.
4.2 Het onverstijfde model
Het mechanische gedrag van onverstijfde cilinderschalen op lokale steunpunten was het onderwerp van het doctoraat van W. Guggenberger. Voor dit onderzoek maakte hij gebruik van een numeriek model in ABAQUS. Dit model tracht een onverstijfde stalen silo te model-leren die ondersteund wordt door middel van vier lokale steunpunten. Om rekentijd te spa-ren wordt gebruik gemaakt van symmetrie volgens de verticale as en zal de helft van één sector4 gemodelleerd worden. Het model zal dus 45° van de silo modelleren. Om rekening te houden met de overige 315° moeten randvoorwaarden ingevoerd worden langsheen de lon-gitudinale randen. Verder wordt slechts de halve cilinderhoogte beschouwd omwille van symmetrie volgens een horizontaal vlak gelegen op halve cilinderhoogte. Het gedeelte van de cilinder dat in het model zit vervat is in Figuur 4.1 gearceerd.
Figuur 4.1: Het deel van de onverstijfde cilinder dat door Guggenberger werd gemodelleerd
4 Hierbij wordt één sector gelijkgesteld aan de zone tussen 2 opeenvolgende lokale steunpunten.
Numerieke simulaties van schaalstructuren 25
In het model van Guggenberger wordt gebruik gemaakt van soepele steunpunten. Hiervoor wordt de totale som van de axiale belasting die bovenaan de schaalconstructie aangrijpt verdeeld over het aantal steunpunten. Aangezien een ideale schaalconstructie wordt onder-steld, zal in elk steunpunt een even grote reactiekracht aanwezig zijn. In dit model wordt één achtste van de volledige omtrek van de constructie gemodelleerd, dus moet de reactiekracht van een half steunpunt aangebracht worden. De kracht moet in tegengestelde zin ten op-zichte van de axiale belasting aangebracht worden. Over de sectie van dit (halve) steunpunt zal een uniform axiale spanning aanwezig zijn. Om dit model te simuleren werden twee elementennetten gebruikt: het ene model was op-gebouwd uit lineaire schaalelementen, het andere model uit kwadratische schaalelementen. Om het aantal elementen te reduceren werd een elementennet gebruikt dat niet uniform is.
4.3 Het verstijfde model
In het doctoraal onderzoek van W. Vanlaere is een model voor het eindige elementenpakket ABAQUS opgesteld voor een verstijfde silo. Net zoals bij het model van Guggenberger is ge-tracht een stalen silo bestaande uit een cilindrisch gedeelte met een kegelvormig dak en een kegelvormige bodem in model te brengen. De silo wordt lokaal ondersteund door middel van vier lokale steunpunten en is verstevigd met verstijvers. De silo is voorzien van twee ringverstijvers met daartussen twee langsverstijvers die bevestigd zijn boven elk steunpunt (zie Figuur 4.2).
Figuur 4.2: Verstijfde silo met aanduiding van een sector en een halve sector
4.3.1 Randvoorwaarden
Bij het modelleren van deze schaalconstructie zijn enkele vereenvoudigingen aangebracht. Hiervoor worden randvoorwaarden toegekend aan bepaalde randen van het model. Deze randvoorwaarden kunnen samengevat worden in twee categorieën. Randvoorwaarden voor de longitudinale randen van de cilinder
Om kleinere rekentijden te verkrijgen is gebruik gemaakt van symmetrie volgens de axiale as en wordt slechts een halve sector gemodelleerd, net zoals in het model van Guggenberger. Dit cirkelsegment zal een hoek van 45° bevatten van de schaalconstructie, vertrekkend van de meridiaan die loopt door het midden van een lokaal steunpunt. Dit is aangeduid op Figuur
Numerieke simulaties van schaalstructuren 26
4.2, een halve sector is begrepen tussen de rode en de zwarte lijn. De twee langsverstijvers die boven elk steunpunt aanwezig zijn, zitten symmetrisch ten opzichte van deze meridiaan. In het model zal dus één van deze twee langsverstijvers vervat zitten. Om rekening te hou-den met het weggelaten gedeelte van de constructie zijn symmetrie randvoorwaarden inge-voerd langsheen de longitudinale randen. Deze randvoorwaarden kunnen niet gedefinieerd worden in het globale assenstelsel van ABAQUS. Om deze te kunnen invoeren is een lokaal assenstelsel nodig waarbij één van de assen moet samenvallen met de horizontale raaklijn aan de cilinder ter plaatse van deze twee longitudinale randen. Dit werd gerealiseerd door deze randen van het model in een lokaal cilindrisch assenstelsel (R,T,Z) te definiëren, waarbij de R-as in radiale richting, de T-as volgens de raaklijn en de Z-as volgens de axiale symmetrie as. De uitdrukking voor de sym-metrie aan deze longitudinale randen in het lokale assenstelsel is: � � 46 � 45 � 0 (4.1)
met T de verplaatsing volgens de T-as en 46 en 45 de hoekverdraaiingen om de R-, en res-pectievelijk Z-as. Randvoorwaarden voor de onder- en bovenrand van de cilinder
Bij het uitvoeren van proeven op schaalmodellen wordt een silo samengesteld uit een cilin-drische schaal waarop langs- en ringverstijvers zijn bevestigd. Er wordt ook een deksel aan-gebracht om de axiale belasting op schaalmodel te kunnen aanbrengen. Bij de proeven is geen cilindervormige bodem aangebracht. Bij het modelleren zullen ook enkele vereenvoudigingen in acht genomen worden. Het cilin-drische gedeelte samen met de langs- en ringverstijvers zijn opgenomen in het model. De kegelvormige bodem samen met het kegelvormig dak zijn niet fysisch aanwezig in het mo-del. Om de invloed van deze beide elementen zo goed mogelijk in rekening te brengen zijn randvoorwaarden ter hoogte van de onder- en bovenrand ingevoerd. Bij een werkelijke silo zal het kegelvormige dak ervoor zorgen dat de bovenrand van het ci-lindrisch gedeelte van de silo zijn vorm behoudt. Dit is ook in overeenstemming met wat wordt ondervonden tijdens proeven. Om dit in het model te simuleren zonder dat het dak mee moet gemodelleerd worden, zal aan de volledige bovenrand een randvoorwaarde inge-voerd worden die verplaatsingen in het vlak loodrecht op de axiale as verhinderd alsook de rotatie rond deze axiale as. Deze voorwaarden kunnen perfect in het globale assenstelsel gedefinieerd worden als volgt: ) � , � 45 � 0 (4.2)
met U en V de verplaatsing volgens de U-as, respectievelijk V-as en 45 de Z-as. De randvoorwaarden van de onderrand zijn iets complexer, er is namelijk een kegelvormige bodem aanwezig samen met enkele lokale steunpunten. Ter hoogte van de overgang van de cilinderwand naar de kegelvormige bodem zal vaak een ringverstijver aanwezig zijn om deze onderrand meer stijfheid te geven. Omdat deze ring rechtstreeks in het model wordt inge-
Numerieke simulaties van schaalstructuren 27
voerd, dient deze dus niet gesimuleerd te worden door extra randvoorwaarden. De verplaat-sing in het vlak loodrecht op de axiale as zal echter wel nog verhinderd worden ter hoogte van de lokale ondersteuning. Hiervoor kan over deze zone dezelfde voorwaarden gebruikt worden als vermeld in vergelijking (4.2). Bij een schaalconstructie die lokaal wordt ondersteund is het heel belangrijk om deze steun-punten zo goed mogelijk te modelleren. De manier waarop de randvoorwaarden zijn toege-kend ter hoogte van deze steunpunten heeft invloed op de spanningsverdeling op die plaats. Er kunnen twee manieren vooropgesteld worden om deze randvoorwaarden te voorzien:
• Stijve steunpunten
Bij deze manier van modelleren wordt ondersteld dat de steunpunten oneindig stijf zijn en helemaal geen verplaatsing toelaten in axiale richting. Deze onderstelling leunt het dichtst aan bij het werkelijke gedrag van de ondersteuningen, maar het blijft een idealisering van de werkelijkheid. De randvoorwaarden die ter hoogte van dit lokaal steunpunt moet worden ingevoerd zijn:
) � , � � � 45 � 0 (4.3)
• Soepele steunpunten
Bij deze manier van modelleren wordt ondersteld dat de steunpunten soepel zijn in axiale richting. Er wordt vanuit gegaan dat ter plaatste van het steunpunt een uni-forme axiale spanningstoestand over de volledige breedte van het steunpunt plaats-vindt. Om dit soort steunpunt te modelleren wordt een uniforme lijnlast aangebracht op het gedeelte van de cilinderschaal dat wordt ondersteund en op de onderzijde van de verstijver. Er wordt voor gezorgd dat de spanningen in de schaal en de verstijver even groot zijn. Om dit te bekomen moet de verhouding tussen de lijnlasten q even-redig zijn met de verhouding tussen de dikte t van de verstijver en de cilinderschaal.
: �!�"�# �! � :��� � (4.4)
� �!�"�# �!( �!�"�# �! � ���� �(��� � (4.5)
Omdat het steunpunt gesimuleerd wordt door het invoeren van krachten, heeft het model nog nergens een voorwaarde die het onbeperkt verplaatsen volgens de axiale as verhinderd. Daarom zal een extra randvoorwaarde W = 0 toegevoegd worden aan de volledige bovenrand, zodanig dat deze onbeperkte verplaatsing wordt verhinderd.
Figuur 4.3: De randvoorwaarden van het numerieke model - Rigide versus Soepele ondersteuningen
Numerieke simulaties van schaalstructuren 28
Deze twee modelleringswijzen hebben elk hun voor- en nadelen. Rigide steunpunten bena-deren het best het gedrag van een praktische ondersteuning, maar het kan soms een onvei-lige aanname zijn. Soepele steunpunten daarentegen geven in de meeste gevallen de veilig-ste oplossing, maar in sommige gevallen té veilig en dus oneconomisch.
4.3.2 Belasting
De belasting die in een traditionele silo optreedt, is in de eerste plaats afkomstig van het opslaggoed dat in de silo wordt opgeslagen. Wanneer een granulaire stof in de silo wordt opgeslagen zal deze onderhevig zijn aan een verticale belasting die gedeeltelijk afkomstig is van de wandwrijving tussen de opgeslagen stof en de cilinderwand. Wanneer in de silo een vloeistof is opgeslagen, is het beter om een trekkracht te modelleren ter hoogte van de on-derrand van de cilinder. De schaalconstructie kan ook belast worden door een drukkracht die wordt aangebracht op de bovenrand. De manier waarop de kracht in de lokaal onder-steunde silo wordt ingeleid is echter van minder belang voor het bezwijken. De vermelde belastingstoestanden zullen immers gelijkaardige drukspanningen veroorzaken in de cilin-derwand in een zone boven de lokale steunpunten. De belastingssituatie is wel belangrijk voor relatief kleine hoogte tot straal ratio [8]. In het numeriek model met rigide steunpunten zal een uniforme neerwaartse lijnlast aange-bracht worden ter hoogte van de bovenrand van de cilinder. Bij de soepele steunpunten zal de verticale belasting over de ondersteunde zone van de onderrand worden aangebracht. Deze kracht zal daarenboven opwaarts gericht zijn. De volledige bovenrand van de cilinder zal de verticale verplaatsing verhinderen zoals vermeld in paragraaf 4.3.1.
Figuur 4.4: De belasting van het numerieke model - Rigide ondersteuningen versus Soepele ondersteuningen
Naast de verticale belasting zal in de silo ook een horizontale belasting optreden als gevolg van het opslaggoed dat in de silo aanwezig is. Ter hoogte van de onderrand zal een inwendi-ge druk aanwezig zijn in de cilinderwand. Deze inwendige druk zal echter de plooiweerstand verhogen in het geval van uniform samengedrukte cilinders. Voor lokaal ondersteunde cilin-ders zal dit een gunstig effect met zich mee brengen. Wanneer de inwendige druk echter te groot wordt zal een ander soort van bezwijken optreden door het plastisch vloeien van het staal [9]. In het doctoraal werk van W. Vanlaere is het effect van de inwendige druk onderzocht. De resultaten van dit onderzoek wijzen uit dat de inwendige druk een gunstig effect heeft [8]. Omwille van deze reden is de horizontale belasting niet opgenomen in het model.
Numerieke simulaties van schaalstructuren 29
4.3.3 Elementen
Om het numerieke model te kunnen berekenen, dient de geometrie opgedeeld te worden in een elementennet. In ABAQUS is er een uitgebreid gamma aan schaalelementen, dat kan onderverdeeld worden in drie grote groepen:
• Schaalelementen voor algemeen gebruik, bvb S4 en S4R elementen. Deze schaalele-menten kunnen gebruikt worden voor zowel dikke als dunne schaalconstructies.
• Dikke schaalelementen, bvb S8R. Deze schaalelementen zijn geschikt wanneer de wanddikte groter is dan 1/15e van de karakteristieke lengte5.
• Dunne schaalelementen, bvb S4R5 en S8R5. Zijn bedoeld voor schalen met een rela-tief kleine wanddikte. Hieraan is voldaan als de wanddikte kleiner is dan 1/15e van de karakteristieke lengte.
In bovenstaande opsomming zijn een aantal courant gebruikte elementen weergegeven. Aan hun naam zijn een aantal typische kenmerken verbonden. De eerste letter S van deze ele-menten slaat op het feit dat het schaalelementen zijn. Het cijfer dat na de S komt duidt op het aantal knopen dat dit soort element heeft, een S4 element heeft vier knopen, een S8 heeft acht knopen. De elementen met vier knopen maken gebruik van lineaire interpolatiefuncties, deze met acht knopen van kwadratische. Onder-zoek naar het verschil bij een model met vier en acht knopen heeft aangeduid dat het model met acht knopen aanleiding heeft tot iets lagere eigenwaarden bij een eigenwaardebereke-ning6. De elementen waar een R in voorkomt maken gebruik van een gereduceerde integratie. Dit houdt in dat bij de numerieke integratie van de stijfheid, voor dat element gebruik wordt gemaakt van een verminderd aantal integratiepunten. Berekeningen aan de hand van dit soort elementen levert lagere eigenwaarden [8]. Het model zal een lagere stijfheid hebben omwille van deze gereduceerde integratie. Dit wordt echter positief ervaren aangezien be-rekeningen met volledige integratie de stijfheid overschatten. Een ander voordeel is dat elementen met een gereduceerde integratie een kleinere rekentijd nodig hebben. Bij deze gereduceerde elementen kan ook nog het aantal vrijheidsgraden beperkt worden. Een normaal element heeft zes vrijheidsgraden per knoop, indien het om een S4R5 of een S8R5 element gaat, zal dit element slechts vijf vrijheidsgraden per knoop in rekening bren-gen. Het voordeel is dat dit soort elementen minder rekentijd nodig hebben en de resultaten wijken slechts weinig af van de berekeningen met elementtypes die zes vrijheidsgraden per knoop hebben. Als conclusie bij de studie naar het meest geschikte elementtype kwamen de S4R5 en S8R5 elementen naar voren [8]. In het uiteindelijke model is gekozen om met S8R5 elementen te rekenen omdat deze een lagere stijfheid aan het model geven en het model dus conserva-tiever maken.
5 Dit is de breedte of de hoogte van het schaalelement.
6 Dit is één van de mogelijke analyses die bij dit soort constructies vaak wordt gedaan. Hier wordt in paragraaf
4.4 verder op ingegaan.
Numerieke simulaties van schaalstructuren 30
4.3.4 Elementennet
Bij cilinderschalen op lokale steunpunten zal het bezwijken lokaal gebeuren door instabili-teit. Deze instabiliteit treedt vooral op net boven het steunpunt in de verstijfde zone en net boven de bovenste ringverstijver. Het is dus belangrijk om een dicht elementennet te voor-zien in deze zones waar deze lokale builen en deuken worden verwacht. Buiten deze zone mag het elementennet ruwer worden uitgevoerd. Indien een uniform elementennet voor het volledige model wordt gebruikt, dan zal een pak meer elementen nodig zijn om de bere-kening uit te voeren, waardoor de rekentijd sterk stijgt. Het is dus zeer interessant om een niet-uniform elementennet te gebruiken, maar men moet er wel over waken dat men niet inboet op de nauwkeurigheid. Om het aantal elementen in dit elementennet te reduceren is het model opgedeeld in vier zones. Deze vier zones zijn aangeduid in Figuur 4.5. Zone 1 zal de hoogste dichtheid hebben qua elementen. In de drie overige zones is het elementennet ruwer. De lengte van zone 1 in axiale richting en omtreksrichting bedraagt 75% van de totale hoogte, respectievelijk omtrek van het beschouwde cirkelsegment. Het elementennet wordt gekarakteriseerd door acht parameters, voor elke zone zullen twee parameters ki gedefinieerd worden die het aantal knopen in axiale richting en omtreksrichting bepalen. De elementennetten van de vier zones moeten echter op elkaar kunnen aansluiten, hierdoor blijven nog vier onafhankelijke para-meters over.
�&, �� � � �' �� � �&,��"!�� � �~,��"!�� �~, �� � � ��, �� � �',��"!�� � ��,��"!��
Bij dit model is gekozen om nog twee parameters te elimineren door volgend verband te gebruiken.
�~, �� � � �&, �� �5
�',��"!�� � �&,��"!��5
Door deze onderlinge verbanden wordt het aantal onafhankelijke parameters gereduceerd tot twee, namelijk �&, �� � en �&,��"!��. In het doctoraal werk van W. Vanlaere is onder-zocht in welke mate deze twee parameters mogen variëren zonder dat dit een noemens-waardige daling van de stijfheid van het model tot gevolg heeft.
Numerieke simulaties van schaalstructuren 31
Figuur 4.5: Onderverdeling van de geometrie in 4 zones voor verschillende dichtheid van het elementennet
Door het aantal knopen te variëren zal echter de geometrie niet altijd perfect kunnen geres-pecteerd worden. Wanneer de afmetingen van een element vastliggen, moet de interstrin-gerafstand7 en de hoogte van de verstijver hier een geheel veelvoud van zijn. De werkelijke afmetingen worden dus benaderd door de bestpassende waarden zodat de afwijkingen be-perkt blijven.
4.3.5 Materiaaleigenschappen
Het materiaal van de cilinder in dit model is staal, met materiaaleigenschappen zoals deze vermeld staan in de Eurocode 3 – Deel 4.1 [10]. De aangenomen materiaaleigenschappen zijn in onderstaande tabel samengevat, waarbij de glijdingsmodulus G wordt bepaald door vergelijking (4.6).
Tabel 4.1: Grenzen voor de kwaliteitsklassen
Materiaaleigenschap Symbool Waarde
Elasticiteitsmodulus e 200000 MPa Getal van Poisson 9 0,3 Glijdingsmodulus � 77000 MPa
� � 0,5 eU1 Q 9V (4.6)
Het materiaalgedrag van het staal werd in het doctoraat van W. Vanlaere op drie manieren voorgesteld.
• Een eerste manier is door het materiaal compleet lineair elastisch te onderstellen, waarbij dus geen vloei van het materiaal optreedt. Het spannings-rek diagram wordt gekarakteriseerd door een doorlopende lijn met als helling de elasticiteitsmodulus E. Dit materiaalgedrag zal gebruikt worden voor lineaire analyses.
• Om een meer realistisch materiaalgedrag te bekomen kan het materiaal elastisch-plastisch worden voorgesteld. In dit geval zal het staal zich elastisch gedragen tot
7 Dit is de afstand tussen twee verstijvers met rechthoekige doorsnede boven eenzelfde steunpunt of de hoog-
te van het U-profiel bij een U-vormige verstijver.
Numerieke simulaties van schaalstructuren 32
wanneer de spanning de vloeigrens fy bereikt. Vanaf dit punt kan de spanning in het materiaal niet verder toenemen en zal de rek onbeperkt toenemen.
• De laatste manier hoe het materiaal kan worden voorgesteld is door het werkelijke materiaalgedrag te bepalen aan de hand van proeven en dit in ABAQUS in te geven. Het spannings-rek diagram dat hoort bij elk van deze drie voorstelwijzen is in Figuur
4.6 verduidelijkt.
4.4 Soorten analyses
Aan de hand van een numeriek model kunnen een aantal berekeningen worden uitgevoerd. ABAQUS stelt de gebruiker in staat om verschillende soorten van analyses uit te voeren. De soorten analyses die relevant zijn voor cilinderschalen worden hier verder besproken.
4.4.1 Lineair elastische analyse (LA)
Dit is de meest eenvoudige soort analyse. Hier wordt het evenwicht van de constructie uit-geschreven in de onvervormde stand. Dit is een eerste orde analyse waar wordt uitgegaan van een lineair elastisch materiaalgedrag.
4.4.2 Geometrisch niet-lineaire analyse (GNA)
Hier wordt ook rekening gehouden met de geometrische niet-lineariteit. Dit wil zeggen dat bij het uitschrijven van de evenwichtsvergelijkingen rekening wordt gehouden met de ver-vormde toestand van de constructie. Bij dit soort analyse wordt eveneens gewerkt met een lineair elastisch materiaalgedrag.
Figuur 4.6: Overzicht van de verschillende materiaalgedragingen
4.4.3 Materiaal niet-lineaire analyse (MNA)
Bij dit soort analyse zal het evenwicht worden uitgeschreven in de onvervormde stand. Dit is opnieuw een eerste orde analyse, maar het materiaalgedrag wordt ofwel ideaal elastisch-plastisch ondersteld ofwel wordt het werkelijk spannings-rek verloop opgemeten en ge-bruikt om het materiaal te karakteriseren.
Numerieke simulaties van schaalstructuren 33
4.4.4 Geometrisch en materiaal niet-lineaire analyse (GMNA)
Bij dit soort analyse worden de twee voorgaande gecombineerd. Hier wordt een geome-trisch niet-lineaire analyse uitgevoerd, dit wil zeggen dat bij het uitschrijven van het even-wicht rekening wordt gehouden met de verplaatsingen. Daarnaast wordt ook het materiaal als niet-lineair aanzien. Dit wil zeggen dat het ideaal elastisch-plastisch diagram of het wer-kelijk opgemeten spannings-rek diagram wordt gebruikt.
4.4.5 Geometrisch en materiaal niet-lineaire analyse waarbij imperfecties
in rekening worden gebracht (GMNIA)
Hier worden de onderstellingen van de GMNA analyse toegepast op een imperfecte schaal-structuur.
Uitwerking van het programma 34
5 Uitwerking van het programma De rekensoftware die wordt gebruikt om numerieke simulaties van schaalconstructies uit te voeren is ABAQUS. Voor onderzoek wordt gewerkt aan de hand van inputfiles om de gege-vens in ABAQUS in te voeren. Dergelijke inputfiles bevatten een reeks van commando’s die de geometrie, de randvoorwaarden, de belastingen, de soort analyse, e.d. vastleggen. Een nadeel bij het creëren van deze inputfiles is dat ze zeer foutgevoelig zijn. Deze thesis tracht op dit probleem in te spelen. Het tweede doel van deze thesis is een pro-gramma te schrijven dat aan de hand van enkele basisparameters een kant en klare inputfile genereert. In dit hoofdstuk wordt meer uitleg gegeven over hoe het programma concreet is uitgewerkt en wat de mogelijkheden ervan zijn.
5.1 Algemeen
In vorig hoofdstuk is vermeld hoe het model in elkaar zit dat door middel van een inputfile in ABAQUS kan gemodelleerd worden. Daar werden twee modellen vermeld en dit had ook zijn specifieke reden. De hoofdbedoeling van het programma is om inputfiles te genereren voor een verstijfde cilinder op basis van het model dat in het doctoraal werk van W. Vanlaere [8] is opgesteld. Dit model heeft zijn degelijkheid reeds bewezen, echter de manier waarop de flexibele steunpunten worden gemodelleerd dient herzien te worden. In het kader van de thesis van Katrien Craeye [11] is onderzoek gedaan naar welke manier van modelleren de meest veilige benadering geeft. Hier is een vergelijkende studie gedaan naar het model met rigide steunpunten en deze met flexibele steunpunten. Om flexibele steunpunten te modelleren waren er twee zienswijzen. De eerste volgens Guggenberger waarbij de belasting op de bovenrand wordt geplaatst en in omgekeerde zin op het steun-punt. Hierbij krijgt één punt de randvoorwaarde om verplaatsing volgens de axiale richting te verhinderen. De andere zienswijze volgens Vanlaere zal de belasting enkel ter hoogte van het steunpunt aanbrengen. De volledige bovenrand zal de randvoorwaarde krijgen om de verplaatsing volgens de axiale richting te verhinderen. Uit dit onderzoek is gebleken dat de methode volgens Guggenberger meestal de laagste bezwijkbelasting gaf, en dus als het meest conservatieve van beide mag beschouwd worden. Omwille van de hierboven vermelde reden zal in dit programma enkel de methode van Gug-genberger gehanteerd worden om flexibele steunpunten te modelleren.
5.2 Het programma pyFormex
Van dit programma bestond al een basisversie voor de start van deze thesis. Deze eerste versie van het programma was geschreven in Java. Dit programma was in staat om een in-putfile te genereren voor een basisgeval: een verstijfde cilinder op vier lokale steunpunten met een axiale bovenbelasting. Het opzet was om meer geavanceerde opties mogelijk te maken, zodat inputfiles kunnen gegenereerd worden voor verschillende soorten van schaal-constructies. Een screenshot van dit programma is weergegeven in Figuur 5.1.
Uitwerking van het programma 35
Figuur 5.1: Screenshot van het JAVA programma
De auteur heeft echter tijdens zijn opleiding kennis gemaakt met het programma pyFormex8 en vond dit programma interessant voor het verdere verloop van deze scriptie. pyFormex laat toe om op een eenvoudige manier 3D-structuren te genereren. Dit gebeurt op basis van opeenvolgende mathematische transformaties. Het programma wordt vooral toegepast als preprocessor voor ABAQUS bij het modelleren van stents9. Het programma is opgebouwd uit verschillende deelscripts die worden geschreven in de programmeertaal python [13]. Zo een script is een stukje programmatuur welke extra functionaliteit aan het programma kan toe-voegen. Zo is er een script dat ervoor zorgt dat een bestaande geometrie, belastingen, rand-voorwaarden, etc. volledig kan worden verwerkt tot een inputfile die vervolgens kan ge-bruikt worden om simulaties mee uit te voeren in ABAQUS. Net omwille van deze bestaande functies is dit programma interessant voor het verdere ver-loop van deze thesis. Aangezien de functies voor de omvorming naar een inputfile reeds be-staan en correct werken, dient enkel nog een script geschreven te worden dat ervoor zorgt dat het volledige model correct wordt ingevoerd in pyFormex. Dit script zal er ook voor moe-ten zorgen dat op een correcte manier gebruik wordt gemaakt van de bestaande functies voor het genereren van een inputfile. In dit hoofdstuk wordt meer uitleg gegeven over het script dat geschreven is in pyFormex om de inputfiles te kunnen genereren.
8 pyFormex [12] is een gratis programma gecreëerd door professor B. Verhegghe en verder ontwikkeld aan het
Instituut voor Biomedische Technologie (IBiTech) van de Universiteit Gent. 9 buisje dat na een doktersingreep in de kransslagader wordt ingebracht om de terugkeer van een vernauwing
te voorkomen
Uitwerking van het programma 36
5.3 Het pyFormex script Shell
Om dit programma te starten dient de gebruiker pyFormex geïnstalleerd te hebben. Dit is een open source programma dat onder Linux draait. Alvorens pyFormex wordt opgestart moet een bestaand script van pyFormex vervangen of aangepast worden. Het f2abq.py script dient vervangen te worden door het gelijknamige script dat op de DVD terug te vinden is die bij deze thesis bijgevoegd is. De wijzigingen aan het f2abq.py script zijn ook terug te vinden in Bijlage 3: Aanpassingen aan het f2abq.py script. Indien deze update gebeurd is kan pyFormex worden opgestart. Wanneer pyFormex is opgestart kan het shell.py script ingelezen worden. Dit gebeurt door via “File – Excecute script” het pythonscript shell.py in te lezen, het programma wordt dan onmiddellijk uitgevoerd. Het script is terug te vinden op de bijgevoegde DVD, de broncode is eveneens toegevoegd in Bijlage 4: Programmacode Shell.py script. Wanneer dit script wordt uitgevoerd zal het item “Shell” in de menubalk worden toegevoegd. Wordt hierop geklikt dan verschijnt er een menu met daarin de acties die kunnen worden uitgevoerd. Deze me-nustructuur bestaat uit een aantal zones zoals in Figuur 5.2 is weergegeven.
Figuur 5.2: Menustructuur
Om dit programma voor iedereen toegankelijk te maken is dit in het Engels geschreven. Ter informatie wordt vermeld dat een aantal structuren zijn gemodelleerd en dat screen-schots hiervan zijn bijgevoegd in Bijlage 5: Figuren van structuren in pyFormex.
5.3.1 Invoer parameters
De eerste zone van het menu groepeert een aantal functies die de gebruiker om informatie vragen.
Uitwerking van het programma 37
Type of structure
Vooreerst moet de soort structuur gedefinieerd worden. Zoals reeds vermeld in de inleiding kan zowel een silo als een watertoren gemodelleerd worden. Figuur 5.3 toont een screens-hot met de keuzemogelijkheden waarover de gebruiker beschikt.
Figuur 5.3: Keuze van de constructies
Bij het kiezen van de soort structuur zal bepaald worden of het programma een cilindrisch en/of kegelvormig gedeelte moet modelleren. Naast het bepalen van de basisvorm zal ook een parameter worden ingesteld die aangeeft op welke manier de structuur is ondersteund: lokaal voor een silo, continu voor een watertoren. Voor de onderdelen die in het verdere verloop van deze paragraaf worden besproken is het essentieel te weten over welk type structuur het gaat. Omwille hiervan is een controle inge-bouwd die nagaat of het soort structuur gekend is alvorens andere basisparameters kunnen worden opgevraagd. Geometry
De schaalstructuur die door dit script in pyFormex wordt gegenereerd is volledig geparame-triseerd. De parameters die worden opgevraagd bij het selecteren van deze menukeuze is afhankelijk van de soort structuur die gekozen is.
Figuur 5.4: Geometrische parameters van de verstijfde cilinder
Bestaat de structuur uitsluitend uit een cilindrisch gedeelte (Silo without cone), dan worden volgende parameters opgevraagd:
• de hoogte van de cilinder h2,
Uitwerking van het programma 38
• de straal van de cilinder r2,
• de dikte van de schaal t2. Bestaat de structuur uitsluitend uit een kegelvormig gedeelte (Watertower without cylinder), dan zijn onderstaande parameters vereist:
• de hoogte van de kegel h1,
• de straal van de kegel ter hoogte van de bodem r1,
• de straal van de kegel ter hoogte van de top r2,
• de dikte van de schaal t1. Wanneer de schaalstructuur uit een cilindrisch en kegelvormig gedeelte bestaat (Silo with
cone & Watertower with cylinder), dan wordt de informatie gevraagd van beide voorgaande gevallen met dit verschil dat voor die situatie de straal ter hoogte van de top van de kegel gelijk is aan de straal van de cilinder. Er wordt dan ook niet meer gevraagd naar de straal ter hoogte van de top van de cilinder. Het invoervenster dat hoort bij deze twee situaties is weergegeven in Figuur 5.5. Heeft de gebruiker echter de soort structuur nog niet gekozen, dan wordt dit meegedeeld zoals daarnet is vermeld. De gebruiker zal gevraagd worden of hij de soort structuur wil defi-niëren. Stemt hij hiermee in dan worden onmiddellijk daaropvolgend de noodzakelijke geo-metrische parameters opgevraagd.
Figuur 5.5: Invoer van de geometrische parameters
Support
Hier worden de parameters opgevraagd die noodzakelijk zijn om de ondersteuning te kun-nen modelleren. Heeft de gebruiker de soort structuur nog niet gekozen, dan zal hij hiervan op de hoogte gesteld worden. Bij een silo zal aan de gebruiker gevraagd worden hoeveel discrete steunpunten er zijn n_su, hoe breed deze zijn w_su en op welke manier deze moeten gemodelleerd worden: rigide of flexibel. Dit is weergegeven in Figuur 5.6.
Uitwerking van het programma 39
Daarnaast is er ook nog een keuzemogelijkheid om onmiddellijk de parameters van de ver-stijver in te voeren. Er is namelijk voor gezorgd dat een silo steeds voorzien is van verstijvers: twee langsverstijvers boven elk steunpunt en twee ringverstijvers. Een eerste ringverstijver zit ter hoogte van de bodem van de cilinder. Tegen deze ringverstijver zitten twee langsver-stijver bevestigd. Het andere uiteinde sluit aan tegen een tweede ringverstijver. De afstand tussen de twee ringverstijvers is dus gelijk aan de lengte van een langsverstijver l_st.
Figuur 5.6: Invoer van de parameters van het steunpunt
Wanneer gekozen is om een watertoren te modelleren dan zal voorgaand venster niet ver-schijnen. Het is immers minder nuttig om verstijvers aan te brengen op een structuur die continu is ondersteund. Bij een watertoren zal de ondersteuning steeds gebeuren ter hoogte van de onderrand van de afgeknotte kegel. Deze ondersteuning kan ingeklemd of scharnie-rend zijn, dit zal dan ook aan de gebruiker gevraagd worden in dit menugedeelte.
Figuur 5.7: Keuze van de soort ondersteuning bij type watertoren
Stiffeners
Dit gedeelte is enkel van toepassing indien het een lokaal ondersteunde silo betreft, zoals in voorgaand onderdeel is vermeld. Indien dit het geval is, zal de gebruiker eerst een venster krijgen met daarin de keuze om het type verstijver te kiezen. Er zijn momenteel 3 soorten verstijvers mogelijk:
• R: rechthoekige verstijver
• U: U-vormige verstijver
• S: Schuine R-vormige verstijver Afhankelijk van het type verstijver dat de gebruiker heeft gekozen, zal een bepaald invoer-venster tevoorschijn komen. Voor de R- en U-vormige verstijver wordt om gelijkaardige pa-rameters gevraagd, namelijk de interstringerafstand w_st, de hoogte d_st, de lengte l_st en
Uitwerking van het programma 40
de dikte van de langsverstijver t_st. Daarnaast wordt nog de hoogte h_tr en de dikte t_tr van de bovenring samen met de hoogte h_br en de dikte t_br van de onderring opgevraagd. Bij de U-vormige verstijver wordt de hoogte van de lijfplaat w_st en de breedte van de flen-zen d_st opgevraagd samen met de andere parameters die horen bij de R-vormige verstijver.
Figuur 5.8: Invoer van de parameters voor de R en U-vormige verstijvers
Bij de schuine R-vormige verstijver zullen een aantal parameters opgevraagd worden.
• De afstand van het midden van het steunpunt tot het beginpunt van de verstijver. Dit is de offset van het steunpunt w_st.
• De hoogte van de R-vormige schuine verstijver d_st
• De lengte van de R-vormige schuine verstijver wordt hier niet gevraagd, er wordt naar de afstand tussen de twee ringverstijvers gevraagd, of dus de hoogte van de verstijfde zone l_st.
• Om de helling van de verstijver vast te leggen wordt de hoek van de verstijver met het horizontale vlak angle opgevraagd.
• Tot slot wordt ook nog de dikte van de verstijver opgevraagd, samen met de hoogte en dikte van beide ringverstijvers.
Figuur 5.9: Invoer van de parameters voor een schuine R-vormige verstijver
Uitwerking van het programma 41
Shell model
Bij de bespreking van de modellen in vorig hoofdstuk is vermeld dat het zeer interessant is om gebruik te maken van symmetrie om de rekentijd te drukken. De schaalconstructies die met dit programma kunnen gemodelleerd worden zijn steeds axiaalsymmetrisch. Daarom wordt aan de gebruiker gevraagd of hij gebruik wil maken van symmetrie. Er zijn vier model-leringswijzen mogelijk:
• een halve sector10,
• één volledige sector tussen 2 steunpunten,
• éen volledige sector met één volledig steunpunt,
• de volledige schaalstructuur.
Figuur 5.10: Keuze van de sector
Wanneer een watertoren wordt gemodelleerd kan de indeling niet meer gebeuren op basis van het aantal steunpunten omdat deze structuur continu wordt ondersteund. Daarom zal aan de gebruiker gevraagd worden om zelf een hoek a te definiëren die de sector van het model bepaald. Material
De schaalconstructie kan opgebouwd zijn uit verschillende onderdelen, namelijk uit de cilin-derschaal, de kegelschaal, de langsverstijver en de twee ringverstijvers. Deze onderdelen zijn niet noodzakelijk uit eenzelfde materiaal vervaardigd. In principe kunnen er vijf verschillende materialen worden gebruikt. Er is echter besloten om slechts twee materialen toe te laten in dit programma. Een eerste set materiaaleigenschappen zal het materiaal van de schaalwan-den karakteriseren, een tweede set met materiaaleigenschappen zal dit van de verstijvers karakteriseren. De materiaaleigenschappen die per set worden gedefinieerd zijn:
• de vloeigrens fy,
• de elasticiteitsmodulus E,
• de coëfficiënt van Poisson 9. Hierbij wordt de opmerking gemaakt dat deze parameters voor elk geval worden opge-vraagd, ongeacht de soort analyse die de gebruiker wil laten uitvoeren. Wanneer de gebrui-ker met één bepaald model verschillende analyses wenst uit te voeren, zullen de materiaal-eigenschappen niet opnieuw opgevraagd worden.
10
Een sector is het gedeelte van de schaalstructuur dat zich tussen 2 opeenvolgende steunpunten bevindt. Dit is reeds vermeld in paragraaf 4.3.1.
Uitwerking van het programma 42
Loads
Wat de belasting betreft enkel de axiale belasting a_load worden ingevoerd. Het betreft hier de totale belasting die op de volledige omtrek van de schaalstructuur komt. Initieel wordt deze op 1000N gezet. Indien de belasting 1kN bedraagt is het achteraf eenvoudig om de cor-recte bezwijkbelasting te weten te komen. In de status-file die bij een berekening van ABAQUS wordt meegeleverd zal bij elke belastingsstap de loadproportionalityfactor worden meegegeven die vermenigvuldigd mag worden met de aangebrachte belasting. Wanneer de aangebrachte belasting de 1kN bedraagt zal de bezwijkbelasting gelijk zijn aan deze loadpro-
portionalityfactor.
Figuur 5.11: Invoer van de materiaaleigenschappen
Elements
In paragraaf 4.3.3 zijn een aantal elementen aangehaald. Bij het programmeren van dit pro-gramma moet een groot onderscheid gemaakt worden tussen elementen met vier knopen en deze met acht knopen. De opbouw van de geometrie en de randvoorwaarden zullen voor beide types knopen op een verschillende manier moeten geïntegreerd worden. Voorafgaand aan het schrijven van dit programma is gekozen om te starten met een programmatuur voor een elementennet bestaande uit elementen met vier knopen. Er werd geopteerd om eerst voor dit elementennet alle functionaliteit te voorzien en pas in een latere fase zou gekeken worden om de achtknoopselementen te integreren. Helaas nam het programmeren van het eerste gedeelte meer tijd in beslag dan verwacht. Daarom is het tweede luik met de acht-knoopselementen achterwege gelaten en dus niet opgenomen in het programma. De gebruiker kan kiezen uit drie soorten elementen met vier knopen: de S4, de S4R en de S4R5. Dit laatste type element is het meest interessant omdat deze minder rekentijd nodig heeft dan de twee andere. Mesh
Een belangrijk onderdeel van elk numeriek model is het elementennet dat de structuur moet modelleren. In paragraaf 4.3.4 is het belang van dit elementennet aangetoond, alsook het nut van een netoptimalisatie en welke implicaties dit heeft op het modelleren van de struc-tuur.
Uitwerking van het programma 43
Om het elementennet te definiëren voor een silo met kegelvormig gedeelte zullen de vol-gende parameters aan de gebruiker worden opgevraagd:
• het aantal elementen in omtrekszin voor zone 1 ne3,
• het aantal elementen in axiale zin voor zone 1 ne1,
• het aantal elementen in axiale zin voor het kegelvormige gedeelte ne5,
• of het elementennet uniform dient te zijn,
• de verhoudingsparameter tussen de verschillende zones scale,
• het percentage dat de overgang van meshdichtheid in axiale zin vastlegt p_v,
• het percentage dat de overgang van meshdichtheid in omtrekszin vastlegt p_h. Bij een silo zonder kegelvormig gedeelte zal de derde optie niet worden opgevraagd.
Figuur 5.12: Invoer van de parameters voor het elementennet (methode 1)
De verhoudingsparameter tussen het aantal knopen in de verschillende zones is zoals ver-meld in paragraaf 4.3.4 niet variabel. Deze parameter had een waarde gelijk aan 5 en hoort bij een overgangspercentage van 75%. In het verdere verloop van deze thesis zal dit percen-tage in axiale zin gewijzigd worden, waardoor deze verhoudingsparameter ook moet gewij-zigd worden. Dit wordt verduidelijkt aan de hand van Figuur 5.13.
Figuur 5.13: verband verhoudingsparameter - overgangspercentage
Voor eenzelfde waarde van de verhoudingsparameter zal in het tweede geval een element optreden dat heel sterk vervormd is, dit moet echter vermeden worden. Wel dient opge-merkt te worden dat er eigenlijk twee verhoudingsparamters zouden moeten gebruikt wor-den, voor elke overgangsparamters één. Het is dus zinvol om zo algemeen mogelijk te wer-ken en deze parameter in het programma op te nemen. Het nadeel bij deze manier van mo-delleren is dat voor een overgangspercentage verschillend van 75% een andere verhou-
10 x 7,5cm 2 x 12,5cm
10 x 5cm 2 x 25cm
100
overgangsparameter = 0,75=> onderlinge schaal elementen = 12,5cm/7,5cm = 1,66
overgangsparameter = 0,5=> onderlinge schaal elementen = 25cm/5cm = 5!
verhoudingsparameter = 5
Uitwerking van het programma 44
dingsparameter dient gekozen te worden. Deze parameter laat zich echter niet steeds even gemakkelijk bepalen.
Figuur 5.14: Invoer van de parameters voor het elementennet (methode 2)
De auteur heeft omwille van deze reden nog een andere manier uitgewerkt, waarbij de ver-houding tussen het fijne en grove elementennet iets duidelijker gekarakteriseerd wordt. Deze verhoudingsparameter zal vervangen worden door een schaalfactor scale die de leng-teverhouding vastlegt voor de elementen in zone11 2 en 3 ten opzichte van de grootte van het element in zone 1. Op deze manier zal, ongeacht het overgangspercentage, de verhou-ding tussen de afmetingen van de elementen ondubbelzinnig bepaald zijn. Verder is ook ge-kozen om de gebruiker te vragen naar het totaal aantal elementen in omtrekszin n_h en axi-ale zin n_v1 van het cilindrisch gedeelte, in plaats van het aantal elementen in axiale zin en omtrekszin van zone 1. De concrete uitwerking van dit verschil in visie wordt besproken in paragraaf 5.3.2. Het invoervenster dat deze gegevens opvraagt is gegeven in Figuur 5.14. Om de gebruiker te laten kiezen tussen de twee modelleringswijzen van het elementennet zal eerst gevraagd worden volgens welke methode hij wil werken. Vervolgens zal één van de twee vermelde vensters tevoorschijn komen, zie Figuur 5.12 en Figuur 5.14. Wordt er geko-zen om met een uniform elementennet te werken dan is de tweede zienswijze handiger aangezien het totale aantal elementen rechtstreeks kan ingegeven worden. Analysis
Met dit programma is het mogelijk om verschillende soorten analyses toe te voegen aan de inputfile. De eerste vier soorten analyses die vermeld zijn in paragraaf 4.4 kunnen worden geselecteerd. Onder de lineaire analyses valt een gewone lineaire berekening en een eigen-waarde berekening. Samen met de drie niet-lineaire analyses zijn er dus vijf mogelijke analy-se waaruit de gebruiker kan kiezen, zoals te zien is in Figuur 5.15.
11
Hier moet wel opgemerkt worden dat zone 2 en 3 zijn omgewisseld ten opzicht van het model dat beschre-ven is in vorig hoofdstuk.
Uitwerking van het programma 45
Figuur 5.15: Keuze van de soort analyse
Voor de gewone lineaire analyse (perturbation) zijn geen verdere parameters nodig, in te-genstelling tot de andere vier:
• LBA
Dit is een eigenwaardeberekening. Wanneer dit in ABAQUS wordt gemodelleerd heeft de gebruiker de keuze om twee types van oplossingsmethodes te gebruiken, namelijk LANCZOS en SUBSPACE. De eerste oplossingsmethode zal zowel negatieve als positieve eigenmodes toelaten, de tweede methode geeft enkel positieve eigen-modes als oplossing. Verder vereisen deze twee oplossingsmethodes enkele specifie-ke parameters, die dan ook worden opgevraagd aan de gebruiker (zie Figuur 5.16). Er wordt eveneens gevraagd of bij de knikanalyses een nodefile moet worden gege-nereerd. Dit is een bestand die de verplaatsing van elke knop wegschrijft voor de be-treffende eigenmode.
• GNA, MNA en GMNA Dit zijn alle drie niet-lineaire analyses. Om deze te berekenen in ABAQUS wordt ge-bruik gemaakt een STATIC berekening volgens het Riksalgoritme12. De parameters die nodig zijn voor het Riksalgoritme worden aan de gebruiker opgevraagd.
Figuur 5.16: Invoer parameters voor een knikanalyse: links voor SUBSPACE – rechts voor LANCZOS
12 Met dit algoritme wordt het evenwichtspad afgelopen door het zoeken naar evenwichtspunten gelegen op
een cirkelrand met een automatisch door het algoritme aangepaste straal.
Uitwerking van het programma 46
Figuur 5.17: Invoer van de parameters voor een Riks-oplossingsmethode
Output
In een inputfile moet steeds vermeld staan welke gegevensresultaten weggeschreven moe-ten worden. Deze resultaten worden opgeslagen in een bestand met de extensie odb
13. Met dit programma is het mogelijk om de verplaatsingen van de knopen en de lokale krachten in elke knoop weg te schrijven. Daarnaast kunnen ook de spanningen worden weggeschreven. Deze output behoort tot de zogenaamde field-output die bij elke belastingsstap kan wegge-schreven worden. Omdat dit kan leiden tot enorm grote odb-bestanden, kan een parameter meegegeven worden die de frequentie bepaald waarmee de gewenste output moet worden weggeschreven. Wanneer bvb. de frequentie 5 is zal om de vijf belastingsstappen de over-eenkomstige resultaten aan het odb-bestand toegevoegd worden. De verschillende invoer-velden zijn te zien in Figuur 5.18.
Figuur 5.18: Invoer van de parameters voor de output
13
De afkorting voor output data base
Uitwerking van het programma 47
5.3.2 Creëren van de geometrie
Indien alle noodzakelijke parameters zijn ingevoerd kan de structuur gecreëerd worden. In pyFormex wordt niet met eenheden gewerkt, daarom heeft de auteur zelf gekozen om de eenheid in pyFormex gelijk te stellen aan 1m. Om de geometrie in pyFormex te tekenen wordt vertrokken van een basisvierkant waarvan de lengte van beide zijden de eenheid is. Dit basiselement wordt verschaald en daarna een aantal keer gekopieerd, afhankelijk van het aantal elementen dat de gebruiker heeft inge-voerd. Daarna wordt dit vlakke elementennet rond een as gekromd. Om dit vlakke elementennet te creëren zal eerst bepaald worden wat de afmetingen van een elementair element is in elke zone. Zoals in paragraaf 5.3.1 is vermeld zijn hier twee metho-des voor. Methode 1
De gebruiker heeft de parameters ne1 en ne3 opgegeven, dit stelt het aantal elementen in axiale zin respectievelijk in omtrekszin voor van zone 1. Daarnaast zijn ook de overgangsper-centages in axiale zin p_v en in omtrekszin p_h gekend samen met de verhoudingsparameter scale. Het elementennet is opgedeeld zoals in Figuur 5.19, waar ne staat voor het aantal elementen (number of elements), le voor de lengte van het element (length of elements) en ls voor de lengte van de sector (length of sector)
Figuur 5.19: Indeling van het elementennet
De afmetingen van het elementennet worden bepaald door onderstaand script. Dit is geba-seerd op wat beschreven staat in paragraaf 4.3.4, waarbij moet opgemerkt worden dat het elementennet hier wordt bepaald door het aantal knopen in elke zone. In Script 5.1 wordt gewerkt op basis van het aantal elementen in elke zone. Eens de waarden van de vier basis-lengtes le1 tot le4 gekend zijn, kan bepaald worden uit hoeveel elementen de lengte van de verstijver l_st, de interstringerafstand w_st en de breedte van het steunpunt w_su bestaat. Het aantal elementen is terug te vinden in de overeenkomstige elementparameters ne_st_l, ne_su en ne_st.
Zone 1
Zone 2 Zone 4
Zone 3
ne3 x le3 ne3 x le3
ne1
x le
1n
e2 x
le2
p_v
x h
1h
1
p_h x ls
ls
Uitwerking van het programma 48
Script 5.1: Bepalen karakteristieke parameters van het elementennet volgens methode 1
ne2 = 2*int(round(((ne1+1)/scale+1)/2)) ne4 = 2*int(round(((ne3+1)/scale+1)/2)) le1 = h2*p_v/ne1 le2 = h2*(1-p_v)/ne2 le3 = ls*p_h/ne3 le4 = ls*(1-p_h)/ne4 ne_st_l = int(l_st/le1+0.5) ne_su = int(math.floor(w_su/2./le3 + 0.5)) ne_st = int(math.floor(w_st/2./le3 + 0.5))
Methode 2
Zoals reeds vermeld is het nadeel van methode 1 dat de verhoudingsparameter scale moei-lijk in te schatten is voor andere waarden van de overgangsparameters p_h en p_v en dat in principe twee verhoudingsparameters nodig zijn. Om hier een oplossing aan te bieden wordt de schaalfactor gedefinieerd, binnen de programmacode wordt deze ook scale genoemd. Deze schaalfactor zal de verhouding van de elementen vastleggen, of dus le1/le2 en le3/le4. Het voordeel van deze methode is dat ze geldt voor elke waarde van de overgangs-parameters p_h en p_v. De lengteverhoudingen van de elementen liggen dus ondubbelzinnig vast. Daarnaast worden de karakteristieke parameters van het elementennet (ne1 tot ne4 en le1 tot le4) op een andere manier bepaald. Dit gebeurt namelijk op basis van het totaal aantal elementen in omtrekszin p_h en axiale zin p_v1. De code die deze parameters berekend is weergegeven in Script 5.2.
Script 5.2: Bepalen karakteristieke parameters van het elementennet volgens methode 2
le1 = h2*(1+p_v*(scale-1))/(ne_v1*scale) ne_st_l = int(math.ceil(l_st/le1)) le1 = l_st/ne_st_l ne1 = int(math.ceil(p_v*h2/le1)) ne2 = int(math.ceil((h2-ne1*le1)/(le1*scale))) le2 = (h2-ne1*le1)/ne2 p_v = le1*ne1/h2 width = w_su le3 = ls*(1+p_h*(scale-1))/(ne_h*scale) ne_s = int(math.ceil(width/2./le3)) if ne_s == 0: ne_s = 1 le3 = (width/2.)/ne_s ne3 = int(math.ceil(p_h*ls/le3)) ne4 = int(math.ceil((ls-ne3*le3)/(le3*scale))) le4 = (ls-ne3*le3)/ne4 p_h = le3*ne3/ls
In het eerste gedeelte worden de afmetingen volgens de verticale richting bepaald. Eerst wordt op basis van de ingevoerde parameters de waarde van le1 berekend. Daarna wordt op basis van deze lengte le1 het aantal elementen bepaald waaruit de langsverstijver bestaat
Uitwerking van het programma 49
ne_st_l. Hierbij is ne_st_l gelijk aan de breuk l_st/le1. Omdat steeds een geheel aantal ele-menten nodig is, zal dit moeten afgerond worden, waardoor de lengte van de verstijver nooit exact kan benaderd worden. Dit probleem werd verholpen door de waarde l_st/le1 naar boven af te ronden tot een geheel getal. Op basis van dit getal kan nu de lengte le1 op-nieuw bepaald worden door l_st/ne_st_l te berekenen. Steunende op deze nieuwe lengte le1 kan het elementennet nu aangepast worden zodat de enige overblijvende voorwaarde, zijnde de hoogte h2 van de cilinder, wordt gerespecteerd. De overgangsparameter zal wor-den aangepast zodat deze overeenkomt met de p_v*h2/le1. Op analoge wijze is een verband tussen de 4 vrij te kiezen parameters le3, ne3, le4 en ne4 vastgelegd. De vier verbanden worden bepaald op basis van de lengte van de sector ls, de schaalfactor scale en de breedte van het steunpunt w_su. Karakteristieke parameters van het elementennet
De hiervoor aangehaalde parameters die het elementennet karakteriseren, bepalen enkel het cilindrisch gedeelte. Om het kegelvormig gedeelte te bepalen wordt een parameter ne5 gebruikt die het aantal elementen volgens de beschrijvende van de kegel bepaalt in meridi-onale zin. Deze parameter kan rechtstreeks door gebruiker worden ingevoerd. Alle karakteristieke parameters van het elementennet worden opgeslagen in de array mesh-
Grid omdat deze parameters nog veel zullen gebruikt worden. Onder andere bij het selecte-ren van de knopen en het berekenen van de belastingen. Creëren van de schaalstructuur
Nu het elementennet vastligt, kan de ontvouwde vorm van de schaalconstructie worden getekend in het yz-assenstelsel van pyFormex, waarbij de z-as de verticale as is. Voor elke zone van Figuur 5.19 zijn nu de afmetingen van een element gekend en hoeveel keer elk element voorkomt in elke zone. Aan de hand van enkele pyFormex functies wordt een ele-ment getekend en een aantal keer gekopieerd in overeenstemming met de parameters in Tabel 5.1.
Tabel 5.1: Parameters elementennet
Elementair
vierkant
Afmeting
volgens y-as
Afmeting
volgens z-as
Aantal elementen
volgens y-as
Aantal elementen
volgens z-as
Zone 1 le3 le1 ne3 ne1 Zone 2 le3 le2 ne3 ne2 Zone 3 le4 le1 ne4 ne1 Zone 4 le4 le2 ne4 ne2 Zone 5 le3 le5 ne3 ne5 Zone 6 le4 le5 ne4 ne5
Zone 5 en 6 worden gebruikt om het kegelvormig gedeelte te tekenen. Zone 5 ligt onder zone 1 en zone 6 onder zone 3. Wanneer de zones getekend zijn, worden ze verschoven door middel van de translate func-tie van pyFormex, zodat de zones op de juiste plaats ten opzichte van elkaar komen te lig-gen. Vervolgens worden de verstijvers getekend indien het een silo betreft. Let wel, de
Uitwerking van het programma 50
langsverstijver wordt getekend in het xz-vlak en de ringverstijvers in het xy-vlak. De parame-ters die de verstijvers bepalen zijn weergegeven in Tabel 5.2 en Tabel 5.3.
Tabel 5.2: Parameters langsverstijvers
Elementair
vierkant
Afmeting
volgens x-as
Afmeting
volgens y-as
Afmeting
volgens z-as
# elementen
volgens x-as
# elementen
volgens y-as
# elementen
volgens z-as
R-verstijver le_st_d - le1 ne_st_d - ne_st_l U-verstijver - le3 le1 - ne_st ne_st_l S-verstijver le_st_d - le_st_s ne_st_d - -
De verstijvers staan loodrecht op het vlak van de schaalwand, omwille hiervan zal in de rich-ting loodrecht op het vlak van deze wand nog een lengte van een elementair vierkantje moe-ten bepaald worden, meerbepaald de waarde le_st_d. Deze afmeting wordt zodanig gekozen dat de elementen van de langsverstijver zo goed mogelijk een vierkant benaderen. De ideale lengte zou dus le1 zijn. Omdat de hoogte van de verstijver d_st nooit exact een geheel veel-voud is van de lengte le1 wordt het aantal elementen afgerond naar boven en wordt met deze waarde opnieuw de lengte van de zijde van het elementair vierkant volgens de x-as bepaald.
Script 5.3: Bepalen karakteristieke parameters van het elementennet voor een schuine verstijver
ne_st_d = int(math.ceil(d_st/le1)) le_st_d = d_st/ne_st_d
Om een U-vormige verstijver te tekenen worden de waarden van de R-verstijver gebruikt om de delen loodrecht op de schaalwand te tekenen. Dit zijn de flenzen van de U-vormige ver-stijver. De waarden die bij de U-verstijver staan dienen om het gedeelte evenwijdig met de schaalwand te tekenen. Dit is de lijfplaat van de U-vormige verstijver. Bij een S-verstijver wordt een element in het xz-vlak getekend. Dit vlakje wordt dan gedraaid rond de x-as over een hoek die de gebruiker kan ingeven. Vervolgens wordt dit element schuin gekopieerd. Omdat de knopen van deze schuine verstijver steeds moeten samenval-len met de knopen van de schaalwand, zal ofwel de hoek van de verstijver moeten aange-past worden aan het elementennet van de schaalwand, ofwel wordt het elementennet be-paald op basis van de schuine verstijver. In beide gevallen zal de tangens van de hoek die de schuine verstijver bepaald moeten overeenkomen met de verhouding le1/le3. Er is gekozen om deze laatste manier te hanteren, zodanig dat de hoek van de verstijver wordt opgelegd, deze parameter wordt ook opgevraagd in het inputvenster. De overeenkomstige parameters van het elementennet worden dan bepaald aan de hand van Script 5.4. De hoek die gevraagd wordt aan de gebruiker is deze tussen de schuine ver-stijver en het horizontale vlak.
Script 5.4: Bepalen karakteristieke parameters van het elementennet voor een schuine verstijver
le1 = le3 * math.tan(math.radians(angle)) l_st_s = math.sqrt(le1**2 + le3**2) ne_st_l = int(math.ceil(l_st/le1)) l_st = le1*ne_st_lne1 = int(math.ceil(p_v*h2/le1)) ne2 = int(math.ceil((h2-ne1*le1)/(le1*scale)))
Uitwerking van het programma 51
le2 = (h2-ne1*le1)/ne2 p_v = le1*ne1/h2
Tabel 5.3: Parameters ringverstijvers
Elementair
vierkant
Afmeting
volgens x-as
Afmeting
volgens y-as
Aantal elementen
volgens x-as
Aantal elementen
volgens y-as
Onderring zone 1 le_st_d le1 ne_st_d ne1 Onderring zone 3 le_st_d le3 ne_st_d ne3 Bovenring zone 1 le_st_d le1 ne_st_d ne1 Bovenring zone 3 le_st_d le3 ne_st_d ne3
De ringverstijvers lopen steeds over de zone 1 en 3 en zullen daarom samengesteld worden uit twee delen met de afmetingen die terug te vinden zijn in Tabel 5.3. De onderring zal twee keer toegevoegd worden, omdat deze aan beide zijden van de schaalwand aanwezig is. Nu alle afzonderlijke delen zijn getekend kunnen deze naar de juiste plaats verschoven wor-den zodat alle onderdelen mooi tegen elkaar aansluiten. Om de verschillende onderdelen te verschuiven wordt gebruikt gemaakt van het commando translate van pyFormex. De afstand waarover alle delen moeten verschoven worden is in Tabel 5.4 samengevat.
Tabel 5.4: Waarden voor de translatie
Verschuiving
volgens x-as
Verschuiving
volgens y-as
Verschuiving
volgens z-as
cilinderwand
Zone 1 - - - Zone 2 - - p_v · h2 Zone 3 - p_h · ls - Zone 4 - p_h · ls p_v · h2
Kegelwand
Zone 5 - - - Zone 6 - p_h · ls -
Langsverstijver
R-verstijver - ne_st · le1 - U-verstijver - - S-verstijver - ne_st · le1 -
Onderring
Onderring1 zone 1 - - - Onderring1 zone 3 - p_h · ls - Onderring2 zone 1 Lne_st_d · le_st_d - - Onderring2 zone 3 Lne_st_d · le_st_d p_h · ls -
Bovenring
Bovenring zone 1 - - Lne_st_l · le1 Bovenring zone 3 - p_h · ls Lne_st_l · le1
Uiteraard zal het van de type constructie afhangen van welke onderdelen uiteindelijk wor-den getekend. Op het elementennet van deze vijf hoofdonderdelen zullen nog een aantal bewerkingen uitgevoerd worden, deze die hieronder kort zijn opgesomd.
Uitwerking van het programma 52
• Cilinder zonder kegel
Alle onderdelen behalve de kegel worden getekend. Deze zullen verschoven worden in de x-richting over een afstand r2, de straal van het cilindrisch gedeelte.
• Kegel zonder cilinder
Enkel het elementennet van de kegel wordt getekend. Dit vlakke elementennet wordt geroteerd rond de y-as, zodanig dat dit vlakke elementennet de openingshoek van de kegel maakt met het verticale yz-vlak. Daarna wordt dit gehelde elementen-net verschoven volgens de x-as over een afstand r1, de straal van de kegel ter hoogte van de onderrand.
• Cilinder met kegel
Als een kegel samen met een cilinder voorkomt, dan worden voorgaande bewerkin-gen allemaal uitgevoerd. Daarenboven zal het cilindrisch gedeelte met de verstijvers verschoven worden volgens de z-richting over een afstand h1, de hoogte van de ke-gelschaal.
Op basis van bovenstaande uitleg zal een vlak elementennet gemodelleerd worden voor een halve sector. Door middel van spiegelen en kopiëren kan een volledige sector of de volledige schaal gemodelleerd worden. Wanneer alle onderdelen zijn gemodelleerd, wordt met het commando cylindrical() dit vlakke elementennet opgerold rond de z-as. Er wordt wel nog een kopie van het vlakke elementennet behouden omdat dit elementennet gemakkelijker hanteerbaar is om er knopen uit te filteren. Dit wordt in 5.3.4 besproken bij het item Proper-
ty-nummers van knopen. Toekennen van property-nummers aan elementen
Bij het tekenen van de structuur kan in principe aan elk basiselement een property-nummer worden toegekend. Op basis van dit property-nummer zullen dan de materiaaleigenschap-pen toegekend worden. Aangezien de structuur bestaat uit vijf onderdelen is er gekozen om elk onderdeel een verschillend property-nummer te geven. In Tabel 5.5 is weergegeven welk property-nummer voor welk onderdeel is gekozen.
Tabel 5.5: Lijst met element property-nummers
Onderdeel Property-nummer
Cilinderwand 0 Kegelwand 1
Langsverstijver 2 Onderring 3 Bovenring 4
5.3.3 Het abqData-object
Op basis van de geometrie die in pyFormex is gecreëerd kan nu een inputfile weggeschreven worden. Om deze inputfile te schrijven zal gebruik gemaakt worden van een script dat mee-geleverd wordt met pyFormex, namelijk f2abq.py. Dit is de afkorting voor file-to-abaqus. Zoals de naam laat vermoeden zal dit script ervoor zorgen dat de gegevens worden wegge-schreven naar een inputfile die bruikbaar is voor ABAQUS.
Uitwerking van het programma 53
Om dergelijke inputfiles te kunnen schrijven moeten een aantal gegevens worden toege-voegd aan een interne dictionary
14 van het f2abq-script die luistert naar de naam abqData. Dit object bestaat uit een aantal andere dicitionaries die hieronder zijn behandeld. Daarna zal in de daaropvolgende onderdelen worden uitgelegd hoe deze gegevens voor het abqDa-
ta-object worden verzameld. Model
In dit object worden alle data verzameld die noodzakelijk zijn om het model te kunnen defi-niëren in de inputfile. De onderdelen van dit object die noodzakelijk zijn voor dit model zijn:
• een lijst met alle knopen,
• een lijst met alle elementen,
• een lijst met het property-nummer van elke knoop,
• een lijst met het property-nummer van elk element. Analysis
In dit object worden alle data verzameld die noodzakelijk zijn om het soort analyse te kun-nen definiëren in de inputfile. Volgende onderdelen van dit object zijn noodzakelijk voor dit programma:
• het type analyse,
• extra parameters horend bij dit type analyse,
• een parameter die aangeeft of het een niet-lineaire berekening betreft,
• een belastingsset voor geconcentreerde krachten. In het f2abq-script waarmee gewerkt is, was enkel de mogelijkheid aanwezig om een STATIC-analyse met een gewone tijdstap weg te schrijven in de inputfile. Omdat voor de berekenin-gen echter gebruik gemaakt wordt van een Riksalgoritme, zal het f2abq-script worden aan-gepast zodat dit soort analyse kan weggeschreven worden naar de inputfile. Daarnaast wordt ook een stuk code toegevoegd om een knikanalyse weg te schrijven. Odb
In dit object worden alle data verzameld die noodzakelijk zijn om de gewenste output in de resultatenfile (odb-file) van ABAQUS te krijgen. Dit object is een verzameling van verschillen-de output-sets. Volgende parameters kunnen aan bod komen bij dit type object:
• of het een field of history output is,
• of het een node of element output is,
• voor welke knopenset de specifieke output van toepassing is,
• welke specifieke output gewenst is (doorbuiging, spanningen, etc.), In het bestaande f2abq-script was het niet mogelijk om volgende zaken weg te schrijven in de inputfile:
• de commandolijn om een nodefile te genereren,
• het integratiepunt voor de specifieke output indien dit van toepassing is.
14
Een dictionary is een datastructuur die verschillende gegevens samenstelt. Het specifieke aan dit soort groe-pering van informatie is dat elk element geïndexeerd wordt door middel van een sleutelwoord.
Uitwerking van het programma 54
Daarom is het script aangepast zodat aan deze noden voldaan is. De uitwerking hiervan is toegevoegd in Bijlage 3: Aanpassingen aan het f2abq.py script
5.3.4 Model
Er zijn dus vier lijsten met gegevens nodig om het geometrische model van de schaalstruc-tuur in de inputfile weg te schrijven. De knopenlijst, welke een dimensie n x 3 heeft. Hierbij komt n overeen met het aantal kno-pen van het model. Elke knoop i zal door drie waarden gekarakteriseerd worden, namelijk de x-,y- en z-coördinaat. De elementenlijst zal een dimensie m x 4 hebben, waarbij m overeenkomt met het aantal elementen van het model. Elk element j zal door vier getallen gekarakteriseerd worden, na-melijk de vier knoopnummers van het element. De twee andere lijsten zullen de property-nummers van elke knoop en elk element bevatten. Deze property-nummers zijn gelinkt aan de eigenschappen die gedefinieerd zijn in twee ob-jecten van het properties.py script, een tweede script waarvan gebruik wordt gemaakt. In dit script zijn een aantal functies aanwezig die het mogelijk maken om materiaaleigenschappen, randvoorwaarden, belastingen e.d. te groeperen in twee dictionaries. Een eerste dictionary voor de knoopeigenschappen, een tweede voor de elementeigenschappen. Aan elke set van eigenschappen die in deze dictionaries wordt meegegeven zal ook een property-nummer worden gekoppeld. Op deze manier zullen de functies van het f2abq-script de overeenkom-stige eigenschappen kunnen terugvinden horend bij elk property-nummer. De property-lijst van de elementen kan met een standaard commando gebeuren, deze voor de knopen zal zelf gemaakt worden. Hiervoor wordt een array n x 1 gecreëerd, waarbij n gelijk is aan het aantal knopen van het eindige elementenmodel. Elke knoop heeft een knoopnummer i, dat zal overeenkomen met een indexnummer van deze array. Voor knoop nummer i zal het pro-perty-nummer worden opgeslagen in de array op plaats i. Hoe deze lijsten worden bekomen wordt verder in detail besproken in deze paragraaf. Knopen en elementen
Als de geometrie van de schaalstructuur getekend is in pyFormex kunnen met het comman-do feModel() twee lijsten gemaakt worden met daarin alle knopen en elementen van de structuur. Deze twee lijsten zijn ook nodig om een abqData-object te maken. Het enige na-deel van dit commando is dat dit enorm tijdrovend is. Daarom zal ervoor gezorgd worden dat dit slechts één keer wordt uitgevoerd bij het creëren van een inputfile voor één bepaalde structuur. Property-nummers van knopen
Om aan ABAQUS duidelijk te maken dat een bepaalde knoop een specifieke randvoorwaarde heeft, zal dit in de inputfile moeten gedefinieerd worden. Omdat heel wat knopen dezelfde randvoorwaarden hebben, is het handig om deze knopen te groeperen in een knopenset. Aan deze knopenset kunnen dezelfde randvoorwaarden worden toegekend zoals aan een
Uitwerking van het programma 55
individuele knoop. Nu bestaat de opdracht er in om de juiste knopen aan de juiste knopen-set toe te kennen. In het f2abq-script zitten een aantal functies die in staat zijn om de knopensets te definiëren en de randvoorwaarden aan de knopensets toe te kennen. De functie die de knopensets wegschrijft, werkt op basis van een lijst waarbij voor elke knoop een property-nummer is gedefinieerd. Aan alle knopen die dezelfde randvoorwaarden moeten krijgen, zal eenzelfde property-nummer toegewezen worden. Om er nu voor te zorgen dat elke knoop het juiste property-nummer krijgt werd een knopen-
filter geschreven die alle knopen van het model overloopt en aftoetst of deze aan bepaalde voorwaarden voldoen. In Bijlage 6: Randvoorwaarden voor de knopen is een figuur weerge-geven die alle knopen aanduidt die uit de structuur worden gefilterd. De knopen die een gekleurd bolletje hebben krijgen een speciaal property-nummer, alle andere knopen krijgen het standaard property-nummer 0. De knopen die moeten geselecteerd worden hangen af van het type constructie, ondersteu-ning en langsverstijver. Daarnaast speelt de grootte van het model ook een belangrijke rol. Wanneer een halve sector wordt gemodelleerd zullen de randknopen moeten gefilterd wor-den om de noodzakelijke symmetrievoorwaarden te kunnen opleggen. Wordt daarentegen de volledige structuuur gemodelleerd, dan zullen enkel de bovenrand en de ondersteunings-rand moeten gefilterd worden. Bij de creatie van de geometrie is vermeld dat zowel een vlak elementennet als een gekromd elementennet is weerhouden. Het uitfilteren van de speciale knopen zal gebeuren op basis van het vlakke elementennet. In dit vlakke elementennet, zie figuur in Bijlage 6: Randvoor-
waarden voor de knopen, kan op basis van de parameters die zijn opgeslagen in de array meshGrid elk punt in het elementennet teruggevonden worden. Op deze manier kunnen de coördinaten van elke speciale knoop worden teruggevonden. De precieze uitwerking hiervan is terug te vinden in het shell.py script. Een kort voorbeeld is terug te vinden in Script 5.5 en wordt hierna toegelicht.
Script 5.5: voorbeeld knopenfilter
if sector == 0: for i in range(len(nodes)): if isClose(nodes[i,2],h): if isClose(nodes[i,1],0): nodeprop[i] = 1 lijst[0].append(i) elif isClose(nodes[i,1],ls): nodeprop[i] = 5 lijst[4].append(i) else: if nodes[i,1] <= p_h*ls * 0.99999: nodeprop[i] = 2 lijst[1].append(i) elif nodes[i,1] <= p_h*ls * 1.00001: nodeprop[i] = 3
Uitwerking van het programma 56
lijst[2].append(i) else: nodeprop[i] = 4 lijst[3].append(i)
In dit voorbeeld worden de knopen gezocht van de bovenrand voor een model bestaande uit een halve sector. De knopen bevinden zich op de bovenrand van de structuur, daarom zal de waarde van h de waarde krijgen dan h1, h2 of h1+h2, afhankelijk van het type constructie. Een eerste voorwaarde om deze knopen terug te vinden in het elementennet is dat de z-waarde gelijk moet zijn aan de waarde van h. Is aan deze voorwaarde voldaan kan gezocht worden volgens de y-as. De twee buitenste knopen zullen gemakkelijk te vinden zijn, hun coördinaat volgens de y-as is 0 en ls (de lengte van de sector). Vervolgens zal nagegaan wor-den of de y-coördinaat kleiner dan, gelijk aan of groter dan de waarde p_h*ls is. Dit is de lengte van zone 1 en zone 2 volgens de y-as, en dus ook de grens met zone 3 en zone 4. In-dien aan één van de hier vermelde voorwaarden is voldaan, zal het overeenkomstige proper-tynummer worden opgeslaan in een array die eveneel elementen kan bevatten als het aan-tal knopen die bestaan. Op deze geselecteerde knopen worden puntkrachten geplaatst, die de axiale belasting in het model moeten inleiden. De belasting die op één knoop komt, wordt duidelijk gemaakt door middel van onderstaande Figuur 5.20. Op de schaalstructuur grijpt een totale axiale kracht aan uitgedrukt in kN, deze wordt omge-zet naar een lijnlast door deze te delen door de volledige omtrek van de bovenrand. Aange-zien het model hier bestaat uit een halve sector, zal 1/8ste van de totale last in dit model op de bovenrand aangrijpen. De lijnlast wordt verdeeld over de verschillende knopen, maar omdat de dichtheid van het elementennet varieert vanaf knooptype 3, zal de puntkracht voor elke rode knoop kleiner zijn dan deze voor de lichtblauwe knoop. De twee buitenste knopen zullen slechts de helft van de belasting krijgen. Op basis van de parameters die de onderlinge afstanden van elke knoop karakteriseren kan de coördinaat van elke knoop be-paald worden. Dit is dan ook geïllustreerd in Script 5.5. Voor alle andere speciale knopen kan analoog tewerk gegaan worden.
Figuur 5.20: Bepalen van de belasting op de bovenrand voor een 1/8
ste van de schaalstructuur
Uitwerking van het programma 57
Property-nummers van elementen
Zoals vermeld in paragraaf 5.3.2 wordt bij het tekenen van de structuur aan de verschillende onderdelen een property-nummer toegekend die eigenschappen van de elementen karakte-riseert. Materiaal
De schaalconstructie bestaat uit verschillende onderdelen: de schaalwanden en de verschil-lende verstijvers. Zoals vermeld in paragraaf 5.3.1 is besloten om slechts twee materialen toe te laten, één soort materiaal voor de schaalwanden en een ander materiaal voor de ver-stijvers. Deze materiaaleigenschappen zullen worden opgenomen in de dictionary voor de elementeigenschappen. In deze dictionary worden echter ook de diktes van de verschillende onderdelen opgeno-men. Dit houdt in dat er toch vijf materialen zullen toegevoegd worden aangezien elk on-derdeel een andere dikte kan hebben. Welke materialen effectief zullen worden toegevoegd hangt af van het type constructie. Voor een watertoren zullen enkel de materiaaleigen-schappen voor de schalen worden opgenomen, voor een silo zullen alle vijf de materialen worden opgenomen. De materiaalparameters die steeds worden toegevoegd zijn de elasticiteitsmodulus en de coëfficiënt van Poisson. De vloeigrens samen met de rek waarbij deze optreedt, zal niet in alle gevallen opgenomen worden. Als het een MNA of een GMNA analyse betreft zal de plas-ticiteit worden toegevoegd, voor de andere drie analyses niet. Het materiaal in dit pro-gramma kan uitsluitend gekarakteriseerd worden door ofwel een lineair ofwel een ideaal elastisch-plastisch spannings-rek diagram, het reële spannings-rek verloop kan niet worden meegegeven. Om de materiaalparameters toe te kennen aan deze dictionary zal gebruik gemaakt worden van de functie ElemProperty() die gedefinieerd is in het properties.py script. De gegevens die deze functie dient mee te krijgen zijn het property-nummer van het element en de materi-aalparameters.
Belastingen en randvoorwaarden
In het onderdeel Property-nummers van knopen in paragraaf 5.3.4 is reeds gesproken over de knopenfilter die er voor zorgt dat de speciale knopen een uniek property-nummer krijgen. Dit nummer zal gebruikt worden om de knopen(sets) te linken aan de dictionary waar de randvoorwaarden worden in opgeslagen. De belasting en randvoorwaarden (symmetrie en verbinding met de buitenwereld) worden hier samen behandeld omdat deze beiden worden toegekend aan de knopen. Een overzicht van alle property-nummers met hun overeenkom-stige randvoorwaarde is gegeven in de tabel die is toegevoegd aan Bijlage 6: Randvoorwaar-
den voor de knopen. De wijze waarop de belasting op de bovenrand wordt aangebracht is reeds geïllustreerd aan de hand van Script 5.5. Bij soepele steunpunten zal echter ook een opwaartse belasting aan-grijpen op de ondersteunde zone van de constructie. Zoals vermeld in paragraaf 4.3.1 bij het
Uitwerking van het programma 58
onderdeel Randvoorwaarden voor de onder- en bovenrand van de cilinder wordt ervoor ge-zorgd dat de spanning in de schaal gelijk is aan deze in de verstijver ter hoogte van dit soepe-le steunpunt. De vergelijking die het verband tussen de lijnlast op beide delen bepaalt is ge-geven door (4.5), maar wordt hier nogmaals herhaald voor de duidelijkheid.
� �!�"�# �!( �!�"�# �! � ���� �(��� � (5.1)
De uitwerking van deze vergelijking in het programma is weergegeven in Script 5.6.
Script 5.6: Bepaling van de belasting bij de soepele steunpunten
tot = sectorload/ (t2*meshGrid[5]*meshGrid[10]+ t_st*meshGrid[13]*meshGrid[12]+ t_st*meshGrid[5]*meshGrid[9]) loadCy = tot*t2*meshGrid[5] loadSt = tot*t_st*meshGrid[13] loadU = tot*t_st*meshGrid[5]
In het bovenstaande script is de variabele tot de spanning die wordt opgelegd aan het steunpunt. Deze wordt bepaald door de belasting van de sector te delen door de totale op-pervlakte van het steunpunt. Deze oppervlakte is de som van de oppervlakte van de onder-steunde schaalwand en de oppervlakte van de verstijver. De uitwerking geldt zowel voor R- als U-vormige verstijvers. Indien het een R-vormige verstijver betreft zal de oppervlakte van de het lijf van de U-verstijver nul zijn, waardoor loadU nul wordt. Hierbij zijn loadCy, loadSt en loadU de puntkrachten die horen bij de knopen met property-nummer 8, 11 en 15. Naast loadsets worden ook boundsets gedefinieerd die de vrijheidsgraden voor de knopen-sets bepalen. De knopenset die hoort bij elk property-nummer is terug te vinden Bijlage 6:
Randvoorwaarden voor de knopen. Om beide sets aan de nodeproperties dicitonary toe te kennen, zal gebruik gemaakt worden van de functie NodeProperty() die gedefinieerd is in het properties.py script. De gegevens die deze functie dient mee te krijgen zijn het property-nummer van de knoop en bijhorende boundset en loadset.
5.3.5 Analyse
Zoals vermeld in het onderdeel Analysis van paragraaf 5.3.1 kan dit programma inputfiles genereren voor vijf verschillende types van analyse. Deze analyses worden aan het abqData-object toegekend door middel van de functie Analysis() van het f2abq.py script. Deze gege-vens zullen in de inputfile worden weggeschreven door middel van de functie writeStep() van ditzelfde script. De functie writeStep() is bijgewerkt zodat het mogelijk wordt om de ABAQUS commandoregels van een knikanalyse en een analyse op basis van het Riksalgoritme weg te schrijven in de inputfile. De commandolijnen die deze writeStep() moet kunnen wegschrijven zijn hieronder opgesomd per type analyse.
• Lineaire berekening
Uitwerking van het programma 59
*STEP, PERTURBATION Perturbatie analyse *STATIC
• Knikanalyse
*BUCKLE, EIGENSOLVER=<eigensolver> *NODE FILE, GLOBAL=YES, LAST MODE=<last mode> (optioneel) u
*static
• Geometrisch niet lineaire analyse op basis van het Riksalogritme
*STEP, NLGEOM=<nlgeom>, INCR=<incr> *STATIC, RIKS <parameters Riksanalyse)
Om deze codelijnen in de inputfile te kunnen wegschrijven zijn dus twee zaken aangepast in het f2abq.py script: de definitie writeStep() en de definitie van de klasse Analysis(). Er zijn drie nieuwe variabelen toegevoegd namelijk nf, incr en nlgeom. Deze wijzigingen zijn te vin-den in Bijlage 3: Aanpassingen aan het f2abq.py script. Daarnaast werd ook nog één regel aangepast in de writeAbqInput() zodanig dat de juiste gegevens worden meegegeven wan-neer de functie writeStep() wordt opgeroepen. De wijziging zijn onderlijnd in onderstaande code.
Script 5.7: wijziging in de definitie writeAbqInput()
writeStep(fil, a.analysistype, a.kind, a.time, a.nf, a.incr, a.nlgeom, a.cloadset, a.opcl, a.dloadset, a. opdl, a.boundset, a.opb, a.dispset, a.op, abqdata.odb, abqdata.dat)
Wat de materiaalplastische analyses betreft, zal ervoor gezorgd worden dat de plasticiteit wordt weggeschreven in de dictionary van de elementeigenschappen zoals vermeld in het onderdeel Materiaal van paragraaf 5.3.4
5.3.6 Output
De output wordt onmiddellijk toegevoegd aan het abqData-object wanneer de basisparame-ters worden opgevraagd aan de gebruiker. De functie die de output toevoegt aan de inputfi-le was niet in staat om het integratiepunt weg te schrijven in de inputfile. Deze optie is toe-gevoegd in de functie writeStepOutput() aan de hand van de variabele IP en de bijhorende definitie van de klasse ODB(). De wijzigingen zijn te vinden in Bijlage 3: Aanpassingen aan het
f2abq.py script.
5.3.7 Wegschrijven van de inputfile
Nu alle noodzakelijke data is weggeschreven kan de inputfile gegenereerd worden. Hoofding
Bij het genereren van het elementennet zullen de afmetingen van de verstijvers soms licht wijzigen. Om de gebruiker een zicht te geven wat de afmetingen zijn van de werkelijk gemo-delleerde structuur wordt een hoofding aan de inputfile toegevoegd. In deze hoofding wor-
Uitwerking van het programma 60
den alle relevante parameters weggeschreven. Voor meer informatie over de parameters die worden weggeschreven wordt verwezen naar waar een gegenereerde inputfile die is toege-voegd in Bijlage 7: Inputfile. Hiervoor is ook een kleine aanpassing gemaakt aan het f2abq.py script, zodat het mogelijk wordt om bij de functie writeAbqInput() een optionele tekst mee te geven. Deze tekst zal gebruikt wordt bij de functie writeHeading() van het f2abq.py script, die zoals laat vermoeden de hoofding van de inputfile wegschrijft. Creëren van het feModel
Zoals vermeld in het onderdeel Knopen en elementen van paragraaf 5.3.4 zal het tekenen van de geometrie niet volstaan om de knopen en elementen weg te schrijven naar de input-file. Alle onderdelen (cilinder, kegel en verstijvers) zijn immers opgebouwd uit elementaire vierkantjes die elk vier knopen hebben. Bij het creëren van een eindig elementenmodel fe-
Model moeten alle knopen aan elkaar geknoopt worden, zodanig dat er geen twee verschil-lende knoopnummers optreden voor eenzelfde plaats in de ruimte. Dit knopen van het ein-dige elementenmodel gebeurt met het commando feModel() dat standaard beschikbaar is in pyFormex. Dit commando heeft echter het nadeel dat het veel rekentijd vergt wanneer een groot aantal knopen en elementen worden gebruikt. Omwille hiervan zal dit commando en-kel worden uitgevoerd bij het wegschrijven van de structuur en niet bij het creëren en teke-nen van de geometrie in pyFormex. Deze tussenstap gebeurt op basis van het commando createMesh() van het shell.py script. Omdat een elementennet alleen kan gecreëerd worden indien alle noodzakelijke geometri-sche parameters en parameters van het elementennet zijn ingevoerd, zal de functie selec-
tor() controleren of alle noodzakelijke invoermenu’s zijn overlopen. Is dit niet het geval, dan worden de vereiste parameters opgevraagd bij de gebruiker. Wegschrijven van de inputfile
Na al dit voorbereidend werk, kan uiteindelijk de inputfile gegenereerd worden. Hiervoor wordt een object van de klasse abqData() van het f2abq.py script gemaakt. Alle data die in dit hoofdstuk zijn bepaald worden gebruikt om dit object te initialiseren. Het enige wat nog ontbreekt is een bestandsnaam. Daarvoor wordt het commando createFi-
le() uit het shell.py script opgeroepen. Er kan gekozen worden om een datum en/of tijd-stempel in de naam toe te voegen. Het laatste commando dat nu moet worden opgeroepen is writeAbqInput(). De parameters die hier worden meegegeven zijn: het abqData-object, de bestandsnaam en de hoofding. De file wordt uiteindelijk weggeschreven in de workdir van pyFormex.
5.3.8 Creëren van de menustructuur
Bij het uitvoeren van het shell.py script wordt een menustructuur toegevoegd. Dit wordt uitgevoerd door middel van de functie create_menu(). Er is ook een menukeuze Close in het shell-menu, dit dient om de menustructuur terug te verwijderen. Wanneer het script wordt aangepast en dit opnieuw moet worden ingelezen zal immers eerst het bestaande menu moeten gesloten worden. Doet men dit niet dan zal het nieuwe script niet uitgevoerd wor-
Uitwerking van het programma 61
den omdat geen twee keer hetzelfde menu kan worden toegevoegd. Bestaat het menu ech-ter nog niet, dan wordt voor het menu-item Help een nieuw item toegevoegd, namelijk Shell.
5.3.9 Variabele lus
In kader van het parameteronderzoek dat in volgend hoofdstuk aan bod komt is een lus ge-creëerd om de verhouding van de interstringerafstand de steunpuntsbreedte gemakkelijk te laten variëren. Hierbij werden een aantal lussen gecombineerd zodat de initiële interstringe-rafstand automatisch van 0 tot 100% werd geschaald in een aantal intervallen. Het uiteinde-lijke aantal intervallen zal wel bepaald worden door het aantal elementen die de breedte van de verstijver modelleren. Daarnaast wordt ook een psf- bestand gegenereerd welke de verschillende uitvoercommando’s van ABAQUS samenzet om de gecreëerde inputfiles in ABAQUS te laten lopen.
5.4 Controle van het programma
Om na te gaan of de inputfiles die gegenereerd worden door het programma correct zijn, werd één bepaalde geometrie gemodelleerd voor verschillende soorten analyses. Daarnaast zijn voor net dezelfde situaties (zowel geometrie, elementennet, belasting, randvoorwaar-den en analyse) inputfiles gegenereerd op basis van reeds bestaande Maple-sheets
15. Deze sheets zijn opgesteld door W. Vanlaere om berekeningen uit te kunnen voeren in functie van zijn doctoraal werk. Er waren sheets beschikbaar voor S4R5-elementen met een rigide on-dersteuning, maar niet met een flexibele ondersteuning. Om bestaande inputfiles te genere-ren voor flexibele ondersteuningen is de toevlucht gezocht naar sheets die gebruik maken van S8R5-elementen. De berekeningen aan de hand van de inputfiles van de Maple-sheets zijn vergeleken met deze gegenereerd door het programma. Hierbij zijn steeds de bezwijkbelasting en het be-zwijkpatroon gecontroleerd. Indien de bezwijkbelasting en het bezwijkpatroon niet signifi-cant afwijkt van elkaar, kan aangenomen worden dat de inputfile correct is opgebouwd en dat het programma werkt. Uit deze vergelijking zijn een aantal fouten aan het licht gekomen, waarvan geen enkel probleem niet is kunnen opgelost worden. Een tweede manier waarop het programma is getest, is door het uitvoeren van een parame-terstudie. Hierbij zijn een aantal fouten aan het licht gekomen die eveneens allemaal gecor-rigeerd zijn. De resultaten van deze parameterstudie komen in volgend hoofdstuk aan bod.
15
Dit zijn bestanden die kunnen geopend worden aan de hand van het wiskundig softwarepakket Maple.
Parameterstudie 62
6 Parameterstudie Deze parameterstudie kadert in het onderzoek naar een ontwerpformule voor silo’s op vier steunpunten. Om dergelijke ontwerpformules te kunnen opstellen moet de invloed van een aantal parameters zeer goed onderzocht worden. In deze parameterstudie wordt de ver-houding van de interstringerafstand tot de breedte van het steunpunt onderzocht. Uit vorig onderzoek is gebleken dat er een optimum optreedt wanneer men de interstringerafstand laat toenemen. In het verdere verloop van dit hoofdstuk wordt gezocht naar dit optimum. Om op een eenvoudige manier naar de verhouding van de interstringerafstand tot de breed-te van het steunpunt te kunnen verwijzen, wordt deze verhouding de verstijvingsratio van het steunpunt genoemd of kortweg verstijvingsratio. In het verdere verloop van dit hoofd-stuk wordt deze ratio gekarakteriseerd door ds/wsup.
6.1 Model
De geometrie van de silo is samengesteld uit een cilindrisch gedeelte met langs- en ringver-stijvers. Om de invloed van de verstijvingsratio te onderzoeken zullen een aantal simulaties worden uitgevoerd op twee cilinders. De straal-tot-dikteverhouding r/t van deze twee cilin-ders bedraagt 500, de hoogte van de cilinder wordt vier keer de straal gekozen. De afmetin-gen van de verschillende onderdelen voor beide cilinders zijn weergegeven in onderstaande tabellen.
Tabel 6.1: Parameters van de cilinder
Parameter Symbool Eenheid Cilinder 1 Cilinder 2 Basis cilinder
Straal r mm 350 350 350 Dikte wand t mm 0,7 0,7 0,7
Hoogte h mm 1400 1400 700 Steunpuntbreedte wsup mm 50 70 80
Aantal steunpunten nsup - 4 4 4
Omdat deze parameterstudie een onderdeel uitmaakt van het opstellen van rekenregels voor verstijfde silo’s, is het dus belangrijk om een realistische ondersteuningsratio te kiezen. De ondersteuningsratio is de verhouding van de steunpuntsbreedte tot de straal. In de litera-tuur [14] is terug te vinden dat een realistische ondersteuningsratio kleiner is dan 0,2. Om-wille hiervan is breedte van het steunpunt 50mm en 70mm gekozen zoals ook is weergege-ven in Tabel 6.2. Dit komt overeen met een ondersteuningsratio van 0,14 respectievelijk 0,2.
Tabel 6.2: Afmetingen van de langsverstijver
Parameter Symbool Eenheid Cilinder 1 Cilinder 2 Basis cilinder
Hoogte langsverstijver hs mm 160 280 280 Dikte langsverstijver ts mm 1,5 1,5 1,5
Breedte langsverstijver ws mm 20 20 20
Parameterstudie 63
Tabel 6.3: Afmetingen van de ringverstijvers
Parameter Symbool Eenheid Cilinder 1 Cilinder 2 Basis cilinder
Breedte bovenring wur mm 20 20 20 Dikte bovenring tur mm 1,5 1,5 1,5
Breedte onderring wlr mm 40 40 45 Dikte onderring tlr mm 1,5 1,5 0,7
De verstijvingsratio wordt onderzocht voor langsverstijvers met een rechthoekig en U-vormig profiel. Daarnaast zijn er ook twee mogelijke modelleringswijzen van het steunpunt. Combineren we deze twee, dan moet per cilinder vier reeksen van analyses uitgevoerd wor-den. De verstijvingsratio wordt in tien intervallen opgedeeld, zodoende zijn er 11 analyses per reeks. Zoals vermeld in paragraaf 4.3.4 zal de interstringerafstand de afmetingen van het elemen-tennet moeten respecteren. Volgens het elementennet voor cilinder 1 zal de breedte van het steunpunt 13 elementen bevatten, voor cilinder 2 zullen dit 18 elementen zijn. Het zal dus niet mogelijk zijn om in stapjes van perfect 10% te werken, maar dit is niet noodzakelijk aangezien er met verhoudingen worden gewerkt die achteraf in grafiek worden gezet. Om de curve hierdoor te bepalen is het van minder belang welke percentages worden gekozen voor de verstijvingsratio. Er moet echter wel op gelet worden dat er gemodelleerd wordt met een gelijkmatige verdeling over het gebied van 0 tot 100%. In paragraaf 4.3.4 is eveneens vermeld dat het zeer nuttig is om te werken met een niet-uniform elementennet. Dit net is gegenereerd op basis van methode 1 met volgende para-meters.
Tabel 6.4: Parameters elementennet
Parameter Cilinder 1 Cilinder 2
ne1 200 200 ne2 120 120 ne3 108 108 ne4 22 22
ne_su 13 18 ne_st_l 46 80 ne_st_d 10 10
De hoogte van deze cilinderwand is relatief groot ten opzichte van de verstijverafstand. De twee zones waar builen worden verwacht bevinden zich net boven de ringverstijver en ter hoogte van het steunpunt tussen de twee verstijvers16. Daarom is gekozen om de grens tus-sen het fijne en grove elementennet in de langsrichting op 50% vast te zetten in plaats van 75%. Dit brengt wel met zich mee dat de verhoudingsfactor van 5 niet kan gebruikt worden. Aangezien de verhouding 50% is gebruikt zou dit willen zeggen dat de elementen in axiale zin 517 keer langer worden, wat heel slechte elementen zou opleveren. Omwille hiervan is
16
Meer informatie over de mogelijke bezwijkpatronen wordt gegeven in paragraaf 6.2. 17
In het geval van een overgangspercentage van 50% komt de verhoudingsfactor van methode 1 overeen met de schaalfactor van methode 2.
Parameterstudie
gekozen voor een verhoudingsfactor van dingsfactor 5. Om de invloed van de verstijvingsratiovan een GMNA analyse.met een ideaal elastischheeft van 240 MPa. Er
6.2 Verwerken van de analyses
Om inzicht te krijgen in de invloed van de stijfde cilinderwand, den. In het doctoraal werk van W. Vanlaere zijn twee grote groepen van bezwijkfenomenen waargenomen [8]. Een eerste groep vertoont stijfde zone. Dit bezwijktype kreeg de naam waargenomen die builen vertoond ipunt. Dit bezwijktype kreeg de naam zwijkpatronen zijn in
Figuur
Om deze bezwijktypes te herkennende vervormingen, de axiale spanningen en de von Mises spanningen. Om de twee vermelde bezwijkpatronen te herkennen zal gen (builen) optreden Bij het bezwijken van de constructie volgens het bezwijkpatroon vervormingen op in de zone boven de bovenringden. Wanneer dit maximum wordt bereikt en woworden net boven de aansluiting van de langsverstijver met de bovenring. Dit weerspiegelt zich ook in de spanningsplot voor de axiale spanning.verhoogde axiale spanning optredenAan de hand van de spanningsplot van de von Mises spanningen kan afgeleid worden dat het materiaal lokaal vloeit op deze plaatsen. Bezwijken volgens het bezwijkpatroon rafstand groot is. Op deze manier is bezwijken van de cilinderwand tussen de twee langsvestijvers boven elk steunpunt mogelijk. Bij dit bezwijkpatroon zullen
gekozen voor een verhoudingsfactor van 1,7 in axiale zin, in omtrekszin blijft de verho
Om de invloed van de verstijvingsratio te kunnen onderzoeken zal gebruik gemaakt worden van een GMNA analyse. Hierbij wordt de materiaal niet-lineariteit met een ideaal elastisch-plastisch spannings-rek diagram, waarbij de vloeigreheeft van 240 MPa. Er worden geen imperfecties in rekening gebracht.
Verwerken van de analyses
Om inzicht te krijgen in de invloed van de verstijvingsratio bij een lokaal ondersteunde ve zullen de analyses op een correcte manier moeten geanalyseerd wo
In het doctoraal werk van W. Vanlaere zijn twee grote groepen van bezwijkfenomenen Een eerste groep vertoont builen in de cilinderwand net boven de ve
stijfde zone. Dit bezwijktype kreeg de naam Cilinderwand. Daarnaast is een tweede groep waargenomen die builen vertoond in de cilinderwand en verstijverspunt. Dit bezwijktype kreeg de naam Verstijfde zone. De vervormingen horend bij beide bzwijkpatronen zijn in Figuur 6.1 weergegeven.
Figuur 6.1: Bezwijktype Cilinderwand (links) & Verstijfde zone (rechts)
deze bezwijktypes te herkennen, zal gebruik gemaakt worden van de contourplots van
de vervormingen, de axiale spanningen en de von Mises spanningen. Om de twee vermelde bezwijkpatronen te herkennen zal worden gelet op de plaats waar lokaal grote vervormigen (builen) optreden en of de vloeispanning ergens wordt bereikt
Bij het bezwijken van de constructie volgens het bezwijkpatroon vervormingen op in de zone boven de bovenring alvorens de maximale spanningden. Wanneer dit maximum wordt bereikt en wordt overschreden zal een buil gevormd worden net boven de aansluiting van de langsverstijver met de bovenring. Dit weerspiegelt zich ook in de spanningsplot voor de axiale spanning. Bij het bezwijken zullen twee zones van verhoogde axiale spanning optreden, namelijk boven het steunpunt en boven de bovenring. Aan de hand van de spanningsplot van de von Mises spanningen kan afgeleid worden dat het materiaal lokaal vloeit op deze plaatsen.
volgens het bezwijkpatroon Verstijfde zone zal optreden wanis. Op deze manier is bezwijken van de cilinderwand tussen de twee langsve
stijvers boven elk steunpunt mogelijk. Bij dit bezwijkpatroon zullen
64
in axiale zin, in omtrekszin blijft de verhou-
te kunnen onderzoeken zal gebruik gemaakt worden lineariteit bepaald op basis van staal
rek diagram, waarbij de vloeigrens een waarde worden geen imperfecties in rekening gebracht.
verstijvingsratio bij een lokaal ondersteunde ver-zullen de analyses op een correcte manier moeten geanalyseerd wor-
In het doctoraal werk van W. Vanlaere zijn twee grote groepen van bezwijkfenomenen builen in de cilinderwand net boven de ver-
. Daarnaast is een tweede groep en verstijvers net boven een steun-
. De vervormingen horend bij beide be-
: Bezwijktype Cilinderwand (links) & Verstijfde zone (rechts)
zal gebruik gemaakt worden van de contourplots van de vervormingen, de axiale spanningen en de von Mises spanningen. Om de twee vermelde
waar lokaal grote vervormin-bereikt.
Bij het bezwijken van de constructie volgens het bezwijkpatroon Cilinderwand treden grote alvorens de maximale spanning is opgetre-
overschreden zal een buil gevormd worden net boven de aansluiting van de langsverstijver met de bovenring. Dit weerspiegelt
Bij het bezwijken zullen twee zones van , namelijk boven het steunpunt en boven de bovenring.
Aan de hand van de spanningsplot van de von Mises spanningen kan afgeleid worden dat het
zal optreden wanneer de interstringe-is. Op deze manier is bezwijken van de cilinderwand tussen de twee langsver-
stijvers boven elk steunpunt mogelijk. Bij dit bezwijkpatroon zullen grote vervormingen op-
Parameterstudie 65
treden in een uitgestrekte zone boven de bovenring alvorens de bezwijkbelasting optreedt. Bij het bereiken van de bezwijkbelasting zal een buil in de cilinderwand ontstaan net boven het steunpunt. De vervorming in deze uitgestrekte zone boven de bovenring is wel nog gro-ter dan de vervorming ter hoogte van de buil. Bij het analyseren van de spanningen blijkt dat ter hoogte van dit steunpunt zowel de axiale spanningen als de von Mises spanningen hier over een uitgebreide zone hoge waarden bereiken. Dit patroon kan zowel bij flexibele als bij rigide steunpunten worden vastgesteld. Bij rigide steunpunten zal boven de bovenring ook een kleine plastische zone optreden die na het vormen van de buil verdwijnt.
6.3 Resultaten
6.3.1 Bestaande simulaties
In het doctoraal werk van W. Vanlaere is de invloed van de interstringerafstand onderzocht [8]. Er zijn een aantal GMNA analyses uitgevoerd op een model dat was opgebouwd uit een cilindrisch gedeelte met ringverstijvers en een R-vormige langsverstijver. Voor dit model zijn de twee soorten steunpunten gemodelleerd; flexibele en rigide. In Figuur 6.2 is voor beide soorten ondersteuning de invloed van de interstringerafstand op de bezwijkbelasting weer-gegeven.
Figuur 6.2: De invloed van de interstringerafstand op het plooigedrag
Bij een modellering met rigide steunpunten zijn 9 analyses uitgevoerd. Twee van deze analy-ses hebben een verstijvingsratio die groter is dan 100%. Dit is geen logische opstelling aan-gezien de langsverstijvers een stuk van hun functionaliteit verliezen. Dit blijkt ook uit de be-rekeningen: de bezwijkbelasting voor de interstringerafstand groter dan 80mm ligt een pak lager dan voor de andere analyses. Voor de andere 7 analyses kan het verloop van de bezwijkbelasting gevat worden door twee rechten. Er treedt een stijgende rechte op voor kleine interstringerafstanden. Deze tak gaat gepaard met het bezwijkpatroon Cilinderwand. Omdat hetzelfde bezwijkpatroon geldt en de bezwijkbelasting groter wordt bij een toename van de interstringerafstand, duidt dit op een stijging van de plooiweerstand in de onverstijfde zone boven de bovenring. Dit is ook logisch aangezien de hoge spanningsconcentraties boven de verstijfde zone veroorzaakt worden
Parameterstudie 66
door de aansluiting van de langsverstijver met de bovenring. Wanneer de afstand tussen de verstijvers toeneemt, zal de kracht over een grotere zone in de schaal ingeleid worden, wat lagere spanningsconcentraties tot gevolg heeft. De dalende rechte treedt op voor grotere afstanden tussen de verstijver, het bezwijken gebeurt volgens het patroon Verstijfde zone. Aangezien er steeds meer ruimte tussen de verstijvers is, zal de zone tussen de langsverstij-vers de zwakste zone worden. Hierdoor zal het bezwijken optreden door builen in de ver-stijfde zone, meerbepaald in de schaalwand tussen de twee langsverstijvers. De interstringe-rafstand die gepaard gaat met de overgang van de stijgende naar de dalende tak is de kritie-
ke interstringerafstand. Dit zelfde verloop treedt op bij het model met soepele steunpunten. De kritieke interstringe-rafstand is echter kleiner dan bij rigide steunpunten. Het bezwijken volgens het type Ver-
stijfde zone zal dus sneller optreden. Voor beide bezwijkfenomenen is de plooiweerstand hoger dan bij rigide steunpunten.
6.3.2 Nieuwe simulaties
Met vorige paragrafen in gedachten kunnen de simulaties worden geanalyseerd. De be-zwijkbelasting per cilinder zal voor elke reeks worden uitgezet. Op basis van de contourplots kan worden nagegaan volgens welk bezwijkpatroon de schaalconstructie bezwijkt. In de gra-fiek wordt voor het bezwijken volgens het type Cilinderwand een driehoekig symbool ge-bruikt, bezwijken volgens het type Verstijfde zone wordt met een cirkel aangeduid. Zoals in paragraaf 6.1 Model is vermeld zijn twee cilinders gemodelleerd. Hieronder worden de resultaten van beide cilinders besproken. Cilinder 1
De breedte van het steunpunt voor deze cilinder werd ingesteld op 50mm. De percentages van de berekening die in de grafiek zijn aangegeven zijn bepaald op basis van de verhouding van het aantal elementen die de breedte van de verstijver bepalen tot het aantal elementen die de breedte van de ondersteuning bepalen. In Figuur 6.3 is weergegeven wat het verloop is van de bezwijkbelasting in functie van de verstijvingsratio. De brongegevens van deze gra-fiek zijn terug te vinden in Bijlage 8: Parameterstudie. Het eerste wat uit de grafiek opvalt, is dat voor beide soorten langsverstijvers geen maxi-mum optreedt. Dit zowel voor het model met rigide als met flexibele steunpunten. Opmer-kelijk is dat het bezwijkpatroon voor elke berekening horend bij deze grafiek hetzelfde is, namelijk van het type Cilinderwand. Op zich is dit niet zo merkwaardig. Zoals reeds vermeld kan er ook nog een tweede bezwijkpatroon optreden, namelijk het type Verstijfde zone. Dit type treedt op wanneer de interstringerafstand voldoende groot is, zodat een buil in de ci-linderwand kan ontstaan tussen de twee langsverstijvers net boven het steunpunt. De verklaring waarom hier geen optimum wordt opgemerkt is dat de interstringerafstand te klein is om bezwijken tussen de langsverstijvers toe te staan. De maximale interstringeraf-stand is immers beperkt door de breedte van het steunpunt aangezien er geen verstijvings-ratios boven de 100% worden beschouwd. Wanneer we naar de bestaande analyse verwij-zen houdt dit in dat de dalende tak die gepaard gaat met bezwijken van het type Verstijfde
zone steeds boven de stijgende tak ligt voor de geometrie die hier is gemodelleerd. Om na te
Parameterstudie 67
gaan of het wel degelijk te wijten is aan de breedte van het steunpunt wordt een tweede cilinder gesimuleerd waarbij het steunpunt breder is. Op deze manier is het mogelijk om deze verklaring te verifiëren.
Figuur 6.3: Invloed van de verstijvingsratio op het plooigedrag
Ondanks het feit dat er geen optimum optreedt, zijn er wel andere interessante zaken op te merken in de grafiek weergegeven in Figuur 6.3.
• Cilinder met Rigide versus flexibele steunpunten
Zoals verwacht resulteren de analyses met flexibele steunpunten in een kleinere be-zwijkbelasting dan deze met rigide steunpunten. Dit onafhankelijk van de vorm van de verstijver.
• Cilinder met R-vormige versus U-vormige verstijvers
Hier is iets merkwaardig waar te nemen. De reden waarom U-vormige verstijvers worden gebruikt, is omdat deze geacht worden de bezwijkbelasting van de construc-tie te doen stijgen. Dit is ook te zien voor rigide steunpunten, de silo met een U-vormige verstijver zal in dit geval een iets grotere bezwijkbelasting hebben. Bij de modellering met flexibele steunpunten is echter het omgekeerde waar te ne-men. Daaruit blijkt dat het model met een R-vormige verstijver een hogere plooi-spanning heeft dan het model met een U-vormige verstijver. Voor deze steuntpunts-aanname is het dus beter om voor R-vormige verstijvers te kiezen. Een verklaring voor dit fenomeen kan zijn dat de U-verstijver een grotere axiale kracht induceert in de verstijver in vergelijking met de R-vormige verstijver. Bij het model met flexibele steunpunten wordt de aangrijpende belasting immers in tegengestelde zin aange-bracht op de cilinderwand en de verstijver. In totaal zal er dus meer kracht op de U-verstijver terecht komen dan op de R-verstijver. Dit impliceert dat bij de U-verstijver een groter deel van de kracht langs de verstijver naar de cilinderwand net boven de bovenring wordt gebracht, waardoor daar een grotere spanningsconcentratie ont-staat en zodoende resulteert in een lagere bezwijklast.
55,0
65,0
75,0
85,0
95,0
0% 20% 40% 60% 80% 100%
Be
zwij
kb
ela
stin
g [
kN
]
ds/wsup
Rigid R - Cilinderwand
Flexible R - Cilinderwand
Rigid U - Cilinderwand
Flexible U - Cilinderwand
Parameterstudie 68
• Cilinder met U-vormige verstijvers en flexibele ondersteuning
Bij het verloop van de bezwijkbelasting voor de cilinder met U-vormige verstijvers en flexibele steunpunten is een minimum waar te nemen. Vermoedelijk spelen hier twee effecten. Het eerste effect is nadelig, door een toename van de kracht in de U-verstijver zal een hogere lokale spanning net boven de bovenring optreden. Door het toenemen van de interstringerafstand zal de zone die de kracht in de U-verstijver overbrengt op de bovenring en in de cilinderschaal groter worden. Door het groter worden van deze zone zal de spanning over een grotere zone verdeeld worden, waardoor dus een gunstig effect optreedt.
Cilinder 2
Zoals vermeld bij de analyse van de simulaties van cilinder 1, was het verloop van de be-zwijkbelasting in functie van de verstijvingsratio niet zoals oorspronkelijk verwacht. Dit ver-loop kan echter wel verklaard worden, maar om dit te bevestigen is nog een tweede reeks simulaties uitgevoerd. De resultaten van deze simulaties zijn in Figuur 6.4 weergegeven. Hierbij duiden CW en VZ op bezwijken volgens het patroon Cilinderwand respectievelijk Ver-
stijfde zone.
Figuur 6.4: Invloed van de verstijvingsratio op het plooigedrag
Bij het bekijken van de curven in Figuur 6.4 valt meteen op dat hier wel een optimum op-treedt. Dit maximum wordt enkel waargenomen bij een R-vormige verstijver.
• Cilinder met R-vormige verstijvers
Bij de R-vormige verstijvers wordt vastgesteld dat de stijgende tak simulaties bevat die bezwijken volgens het type Cilinderwand en de dalende tak van het type Verstijf-
de Zone. Dit is ook wat verwacht werd, deze reeks simulaties ondersteunt dus de ver-klaringen die bij de analyse van cilinder 1 zijn aangegeven.
80,0
90,0
100,0
110,0
120,0
0% 20% 40% 60% 80% 100%
Be
zwij
kb
ela
stin
g [
kN
]
ds/wsup
Rigid R - CW Rigid R - VZ
Flexible R - CW Flexible R - VZ
Rigid U - CW Flexible U - CW
Parameterstudie 69
• Cilinder met U-vormige verstijver en rigide steunpunten
Bij de curve horend bij dit model kan worden vastgesteld dat op het einde van de curve een afname van de helling optreedt. Dit laat ook vermoeden dat er een opti-mum aanwezig is.
• Cilinder met U-vormige verstijver en flexibele steunpunten
Net zoals bij het overeenkomstig model bij cilinder 1 kan worden vastgesteld dat er een minimum aanwezig is. Ook hier wordt dezelfde oorzaak toegekend aan het op-treden van dit minimum.
6.4 Conclusie
Uit de studie van de bestaande simulaties kon men verwachten dat er een optimum aanwe-zig zou zijn. Uit de nieuwe simulaties blijkt echter dat voor de situatie die hier onderzocht is er geen optimum optreedt. De dalende tak wordt niet bereikt, tenzij bij een zeer hoge on-dersteuningsratio. Uit deze parameterstudie kan besloten worden dat voor een silo met ge-lijkaardige afmetingen zoals vermeld in Tabel 6.1, Tabel 6.2 en Tabel 6.3 de optimale inter-stringerafstand gelijk is aan de breedte van het steunpunt. Dit besluit kan genomen worden zowel voor R-vormige als voor U-vormige verstijvers. Dit werd vastgesteld voor het model met flexibele ondersteuning en voor het model met rigide ondersteuning.
Besluit 70
7 Besluit Het bezwijkgedrag van kegelschalen gevuld met een vloeistof is reeds uitvoerig onderzocht door middel van fysische experimenten en numerieke simulaties. De huidige rekenregels voor kegelschalen zijn opgesteld op basis van dit onderzoek. Het berekenen van dergelijke constructies wordt vergemakkelijkt door een rekenapplicatie die in het kader van deze thesis is geschreven. Het voordeel van dit programma is dat het gecreëerd is onder de vorm van een Java-applet, zodat het kan uitgevoerd worden van op een website en op elk besturings-systeem kan toegepast worden. Het ontwikkelde programma vraagt de verschillende para-meters aan de gebruiker op waarna het programma deze verwerkt en het resultaat aan de gebruiker weergeeft. Het werd tevens uitgebreid met een module om de resultaten grafisch voor te stellen. Op deze manier kan de ontwerper op een eenvoudige manier dergelijke con-structies berekenen. Om de numerieke simulaties te kunnen uitvoeren heeft men nood aan een computermodel van de schaalconstructie. In het Laboratorium voor Modelonderzoek van de Universiteit van Gent wordt hiervoor gebruik gemaakt van het eindigelementen programma ABAQUS. Aan-gezien het invoeren van een geometrie zeer veel tijd in beslag neemt, gebeurt het inlezen van het model in ABAQUS aan de hand van inputfiles. Dit heeft als voordelen dat men rede-lijk wat parameters kan onderzoeken en dat het snel en goedkoop kan uitgevoerd worden. Ze zijn echter zeer foutgevoelig zodat in deze scriptie een programma ontwikkeld is om deze eenvoudig te genereren aan de hand van de door de gebruiker ingevoerde gegevens. Dit programma werd ontwikkeld gebruik makende van pyFormex. Met dit programma wordt het mogelijk om eenvoudig verschillende parameters te laten variëren. De gebruiker wordt gevraagd een aantal basisparameters in te geven aan de hand van een GUI. Vervolgens worden deze gegevens door het programma verwerkt en wordt een inputfile voor de gebruiker gegenereerd. Dit vermijdt dat inputfiles manueel moeten gewij-zigd worden wat vroeger vaak tot omslachtige debug procedures leidde. In het kader van het onderzoek naar een ontwerpformule voor een silo op vier steunpunten werd tot slot nog een parameterstudie uitgevoerd met het ontwikkelde programma. Het opstellen van ontwerpformules vereist een zeer goed onderzoek van een aantal parameters. In deze parameterstudie werd een onderzoek geleverd naar de verhouding tussen de inter-stringerafstand en de breedte van het steunpunt. Uit vorig onderzoek is gebleken dat er een optimum optreedt bij het toenemen van de inter-stringerafstand. In dit geval was de geometrie van de silo samengesteld uit een cilindrisch gedeelte met langs- en ringverstijvers. De invloed van de verstijvingsratio werd onderzocht aan de hand van een aantal simulaties die uitgevoerd zijn op 2 cilinders. Voor de onderzoch-te geometrie bleek dat voor een realistische ondersteuningsratio (wsup/r ≤ 0,14) de inter-stringerafstand het best even breed wordt genomen als de breedte van het steunpunt. Om te zien of dit een algemeen fenomeen is wordt aangeraden om nog andere geometriën te onderzoeken.
Bijlage 1: Rekenvoorbeeld A
Bijlage 1: Rekenvoorbeeld
Ter illustratie van de rekenregels is hieronder een rekenvoorbeeld uitgewerkt voor een
schaalconstructie die enkel uit een kegelvormig gedeelte bestaat. Dit rekenvoorbeeld is ge-
baseerd op het eerste voorbeeld dat vermeld staat in het 14de
hoofdstuk van [1].
Het uitgewerkte voorbeeld is gebaseerd op een stalen watertoren die is bezweken. Deze
schaalconstructie bestond uit een kegelvormig gedeelte dat naar onder toe uit een dikkere
plaat was opgebouwd dan het bovenste gedeelte. Er was eveneens een dak aanwezig. De
meridionale membraanspanningen ter hoogte van de ondersteunde rand zijn voornamelijk
te wijten door de aanwezigheid van water in de schaalconstructie. Het eigengewicht van de
kegelvormige tank en de dakbelasting zijn niet in rekening omdat deze slechts een kleine
invloed hadden op de bezwijkbelasting. De membraanspanning ter hoogte van de onderrand
van het dun gedeelte werd geschat op 77 N/mm² wanneer de schaalconstructie bezweek. Bij
deze bezwijkbelasting correspondeerde een waterhoogte h’ van 6215 mm.
Er wordt ondersteld dat het bovenste gedeelte van de kegel cirkelvormig bleef, dat de on-
derrand van deze dunne wand scharnierend was opgelegd en dat de structuur een toleran-
tieklasse A had. Op basis van onderstaande gegevens kan de structuur berekend worden.
�� � ������� � �� �������� �� � ��� � ��������� � � ���� ��� � �������� ��� � � ���� � � � �! � ��
De meridionale plooiweerstand
(2.32) "� � � # � $�� % ��� � &'(�� ) � ��� � � &'(� % �# � ��� � ��� � ������� � # � *���� % � � � &'(� � + � � �� � &'(� % # � ����� � � �
������� �� ���, - �. % ���, - �.
������� �,�/,� - �.���
(2.33) 0� � �1 � "� �� ��� - ��� � �,�/,� - �.
�������� � ��,��2�
(2.39) 345� � �� � "�� � # � �� � �� � 678� � ��� - ��� � �� ���, - �. � # � ���� � �� � 678�
����������� //�/��������
(2.26) 349:; � ����� � � � � <=>��� � ����� � �� �� � � � <=>� ����
������������� �/� �� ������
Bijlage 1: Rekenvoorbeeld A
Methode 1
(2.19) ?�� � �@A� � ����� � �@A� � � ������ ������� ���/
(2.36) ��B � ��� � ?�� � $C�! DE % ?��F� G H % I G )
��������� ���/ � ���/ � $C��EJ % ���/K� G F % I G )
��������� /�����
(2.19) ?B� � �@A� � �B��� � �@A� � /������
������� �,, �
(2.18) LM � � � ?B� N*� G ���+ J % ?B� K % ��1O
������ � � �,, �EJ� G KJ % �,, �K % F
������ � ��
(2.29) 349PQ � LMR % LM % LMS � ���� � � ��R % � �� % � ��S � ��
������������ ,/���/�������
(2.42) TU � V349PQ349:; � V,/���/��/� ��
����� �����
(2.35) WU5B � �1� � �1B � �� J� � <=>�KX 349:; � ��� - ��� � /�� � ���� J� � <=>� KX�/� ��
��������� ������
(2.34) 345B � LM � WU5B � 349:; � � �� � ������ � �/� ��
����������� ����������
- WU5B � �@A�?B� � ������ � � �,� �,, � � ��/��
(2.48) Y4PZ � ��� * G ���[ +$&'(�?�B � WU)\��]^D�_��\\` H
����������� ��� * G ���,� +*� �,� �,, � � ������+\��]^D�_��\\a\ H
����������� ���/��
Bijlage 1: Rekenvoorbeeld A
(2.47) TUP �� V bJ G c1K � V ���/��J G ���K
����������� ���/��
Hierdoor wordt voldaan aan volgende voorwaarde: T\ � �� d T � ����� d TP � ���/��
(2.45) e � G �1 $ TU G TU\TUP G TU\)f � G ��� *����� G �� ���/�� G �� +
�
����������� ��,���
(2.27) 349� � e4P � 349PQ � ��,��� � ,/���/�� ����������� ������������
(2.28) 349B � 349��g � ��������
����������� �,��,�������
(2.13) 349B345B � �,��,�� ����
����������� ��,��� h de constructie is niet veilig
Methode 2
(2.40) 345B � �! � 345� � �� � //�/��
����������� �����������
(2.19) ?B� � �@A� � �B��� � �@A� � � ������ ������ ���/
(2.18) LM � � � ?B� N*� G ���+ J % ?B� K % ��1O
������ � � ���/EJ� G KJ % ���/K % F
������ ����/
(2.29) 349PQ � LMR % LM % LMS � ����
������������ ����/iiiiiiiiiR % ����/iiiiiiiii % ����/S � ��
������������ ������ ������
(2.42) TU � V349PQ349:; � V������ �/� ��
����� ����
Bijlage 1: Rekenvoorbeeld A
(2.41) WU5B � J�! � �1�K � �1B � �� J� � <=>�KX 349:;
��������� J�� � ���� - ���K � � � � ���� J� � <=>� KX�/� ��
��������� ��,��/
WU5B � �@A�?B� � ��,��/ � � �,� ���/ � �� ���
(2.48) Y4PZ � ��� * G ���[ +$&'(�?�B � WU)\��]^D�_��\\` H
����������� ��� * G ���,� +*� �,� ���/ � ��,��/+\��]^D�_��\\a\ H
����������� ��,��
(2.47) TUP �� V bJ G c1K � V ��,��J G ���K
����������� �������
Hierdoor wordt voldaan aan volgende voorwaarde: T\ � �� d T � ���� d TP � �����
Het ontwerppunt bevindt zich dus in het elastisch-plastisch gebied.
(2.45) e � G �1 $ TU G TU\TUP G TU\)f � G ��� *����� G �� ���/�� G �� +
�
����������� ��,���
(2.27) 349� � e � 349PQ � ��,��� � ������ � ����������� ������������
(2.28) 349B � 349��g � �������
����������� ��� �//������
(2.13) 349B345B � ��� �//������
����������� ��,� � h de constructie is niet veilig
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
1 /*
2 * ConeECCS.java
3 *
4 * Created on 11 september 2007, 18:49
5 *
6 * Versie in map Java (bewerkbaar)
7 *
8 * @author User
9 */
10 import javax.swing.*;
11 import java.lang.Exception;
12
13 import java.awt.event.*;
14 import java.awt.*;
15 import java.applet.*;
16
17 class calc {
18 public calc(){};
19
20 public static double alpha_xpe(double Q, double r, double h, double p){
21 double getal = 1;
22 try{
23 getal = 0.5*(1-1.5/Q)*Math.pow(r/h*p,0.135*(1+1/Q));
24 }
25 catch(Exception e){
26 //custom title, warning icon
27 JOptionPane.showMessageDialog(null, "alpha xpe" + getal, "Input was not
correct", JOptionPane.WARNING_MESSAGE);
28 getal = -1;
29 }
30 finally { return getal;}
31 }
32
33 public static double alpha_xpp(double p, double lambda, double r, double t,
double beta_rad){
34 double getal = 1;
35 try{
36 double s;
37 s = 1.0/400.0*r/t/Math.cos(beta_rad);
38 getal = (1-p*p/Math.pow(lambda, 4))*(1-1.0/(1.12+Math.pow(s, 1.5)))*(Math
.pow(s, 2)+1.21*Math.pow(lambda, 2))/(s*(s+1));
39 }
40 catch(Exception e){
41 //custom title, warning icon
42 JOptionPane.showMessageDialog(null, "alpha xpp" + getal, "Input was not
correct", JOptionPane.WARNING_MESSAGE);
43 getal = -1;
44 }
45 finally { return getal;}
46 }
47 }
48
49 class assenstelsel{
50 public assenstelsel(){};
51 public void tekenAssenstelsel(Graphics g, int x0, int y0, int x, int y, int
schaalX, int schaalY, boolean lambdaChi){
52 double interval;
-1-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
53 String labelX = new String();
54 String labelY = new String();
55
56 if (lambdaChi){ labelX = "Lambda"; labelY = "Chi";}
57 else{ labelX = "p"; labelY = "Alpha"; }
58
59 // Pijl Y-as
60 int[] Y_as_xcoord = {x0, x0-5, x0+5};
61 int[] Y_as_ycoord = {y0-y, y0-y+10, y0-y+10};
62 g.setColor(Color.BLACK);
63 g.drawLine(x0, y0, x0, y0-y+10);
64 g.fillPolygon(Y_as_xcoord, Y_as_ycoord, 3);
65 g.drawString(labelY, x0-5-labelY.length()*2, 15);
66
67 // Schaalverdeling Y-as
68 if (schaalY==0) {schaalY=1;}
69 interval = (y-20)/((double)schaalY/10);
70 System.out.println(interval);
71 System.out.println(y);
72 System.out.println(schaalY);
73 for (int i =1;i <=schaalY/10;i++ ){
74 g.drawLine(x0-5, y0-(int)Math.rint(i*interval), x0+5, y0-(int)Math.rint(i
*interval));
75 g.drawString(String.valueOf((double)i/10),x0-25,y0-(int)Math.rint(i*
interval)+5);
76 }
77
78 // Pijl X-as
79 int[] X_as_xcoord = {x0+x,x0+x-10,x0+x-10};
80 int[] X_as_ycoord = {y0,y0-5,y0+5};
81 g.setColor(Color.BLACK);
82 g.drawLine(x0, y0, x0+x-10, y0);
83 g.fillPolygon(X_as_xcoord, X_as_ycoord, 3);
84 g.drawString(labelX, x0+x-8-labelX.length()*7+4, y0-10 );
85
86 // Schaalverdeling X-as
87 interval = (x-20)/((double)schaalX/10);
88 for (int i =1;i <=schaalX/10;i++ ){
89 g.drawLine(x0+(int)Math.rint(i*interval), y0-5, x0+(int)Math.rint(i*
interval), y0+5);
90 g.drawString(String.valueOf((double)i/10),x0+(int)Math.rint(i*interval)-8
,y0+20);
91 }
92 }
93 }
94
95 class grafiekPaneel extends JPanel{
96 public String tekenen;
97 public double r, Q, t, beta, s, lambda_p;
98 public boolean lambdaChi;
99 public double M1_h, M1_p_bar_Ed, M1_alpha_xpe, M1_lambda_bar, M1_lambda_bar_p,
M1_chi, M1_alpha, M1_beta_;
100 public double M2_h, M2_p_bar_Ed, M2_alpha_xpe, M2_lambda_bar, M2_lambda_bar_p,
M2_chi, M2_alpha, M2_beta_;
101 public int schaalXX,schaalYY, designpoint_x, designpoint_y;
102 public double schaalX,schaalY;
103 public int breedte,hoogte, oorsprongX0, oorsprongY0, oorsprongX1, oorsprongY1,
-2-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
breedteX, hoogteY;
104
105 public void paintComponent(Graphics g){
106 double pOld, pNew, alphaOld, alphaNew, lambdaOld, lambdaNew, chiOld, chiNew;
107 super.paintComponent(g);
108
109 //tekengebied met kader
110 g.setColor(Color.WHITE);
111 g.fillRect(0, 0, breedte, hoogte);
112 g.setColor(Color.BLACK);
113 g.drawRect(0, 0, breedte-1, hoogte-1);
114
115 //tekengebied, x_oorsprong, y_oorsprong, lengte x-as, lengte y-as
116 oorsprongX0 = 30;
117 oorsprongY0 = hoogte - 30;
118 oorsprongX1 = breedte - 10;
119 oorsprongY1 = 20;
120 breedteX = oorsprongX1 - oorsprongX0;
121 hoogteY = oorsprongY0 - oorsprongY1;
122 int loperX = (breedteX-20)/10*10;
123 int loperY = (hoogteY-20)/10*10;
124 schaalX = (double)schaalXX/100;
125 schaalY = (double)schaalYY/100;
126 assenstelsel assen = new assenstelsel();
127 assen.tekenAssenstelsel(g,oorsprongX0,oorsprongY0,breedteX,hoogteY,schaalXX,
schaalYY, lambdaChi);
128
129 // legende in kleur
130 g.setColor(Color.RED);
131 g.drawString("Plastic",breedte-60,20);
132 g.setColor(Color.GREEN);
133 g.drawString("Interaction",breedte-60,40);
134 g.setColor(Color.BLUE);
135 g.drawString("Elastic",breedte-60,60);
136 g.setColor(Color.BLACK);
137
138 // tekenen grafieken
139 if (tekenen == "M1" && lambdaChi) {
140 g.drawString("Method 1: Capacity Curve",breedte/2-100,20);
141
142 lambdaOld = 0;
143 chiOld=1;
144 chiNew=1;
145 for (int i = 0; i<=loperX;i++){
146 lambdaNew = (double)i/loperX * schaalX;
147 if (lambdaNew < 0.2){
148 chiNew = 1;
149 g.setColor(Color.RED);
150 }
151 else if (lambdaNew < M1_lambda_bar_p){
152 chiNew=1-M1_beta_*(lambdaNew-0.2)/(M1_lambda_bar_p-0.2);
153 g.setColor(Color.GREEN);
154 }
155 else {
156 if (lambdaNew > 0){chiNew=M1_alpha_xpe/lambdaNew/lambdaNew;}
157 else{chiNew = chiOld;}
158 g.setColor(Color.BLUE);
-3-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
159 }
160 if (chiOld/schaalY > 1){}
161 else {
162 if ((int)Math.rint(lambdaOld*loperX/schaalX+oorsprongX0) == (int)
Math.rint(lambdaNew*loperX/schaalX+oorsprongX0)){ chiNew = chiOld; }
163 else {
164 g.drawLine((int)Math.rint(i-1+oorsprongX0),(int)Math.rint(
oorsprongY0-chiOld*loperY/schaalY), (int)Math.rint(i+oorsprongX0),(int)Math.rint(
oorsprongY0-chiNew*loperY/schaalY));
165 }
166 }
167 lambdaOld = lambdaNew;
168 chiOld = chiNew;
169 }
170
171 //Design point
172 designpoint_x = (int)Math.rint(M1_lambda_bar*loperX/schaalX+oorsprongX0)+10;
173 designpoint_y = (int)Math.rint(oorsprongY0 - M1_chi*loperY/schaalY)+20;
174 }
175
176 else if (tekenen == "M1" && !lambdaChi) {
177 g.drawString("Method 1: Alpha-p graph",breedte/2-100,20);
178
179 //Elastic
180 g.setColor(Color.BLUE);
181 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;
182 alphaOld = calc.alpha_xpe(Q, r, M1_h, pOld);
183 for (int i = 0; i<=loperX;i++){
184 pNew = (double)i/loperX*schaalX;
185 alphaNew = calc.alpha_xpe(Q, r, M1_h, pNew);
186 if (alphaNew >0) {
187 if (alphaOld/schaalY > 1){}
188 else {
189 if ((int)Math.rint(pOld*loperX/schaalX+oorsprongX0) == (int)
Math.rint(pNew*loperX/schaalX+oorsprongX0)){ alphaNew = alphaOld; }
190 else { g.drawLine((int)Math.rint(pOld*loperX/schaalX+
oorsprongX0),(int)Math.rint(oorsprongY0-alphaOld*loperY/schaalY), (int)Math.rint(pNew
*loperX/schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-alphaNew*loperY/schaalY));}
191 }
192 }
193 pOld = pNew;
194 alphaOld = alphaNew;
195 }
196
197 //Plastic
198 g.setColor(Color.RED);
199 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;
200 alphaOld = calc.alpha_xpp(pOld, M1_lambda_bar, r, t, M1_beta_);
201 for (int i = 0; i<=loperX;i++){
202 pNew = (double)i/loperX*schaalX;
203 alphaNew = calc.alpha_xpp(pNew, M1_lambda_bar, r, t, M1_beta_);
204 if (alphaNew >0) {
205 if (alphaOld/schaalY > 1){}
206 else {
207 if ((int)Math.rint(pOld*loperX/schaalX+oorsprongX0) == (int)
Math.rint(pNew*loperX/schaalX+oorsprongX0)){ alphaNew = alphaOld; }
208 else { g.drawLine((int)Math.rint(pOld*loperX/schaalX+
-4-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
oorsprongX0),(int)Math.rint(oorsprongY0-alphaOld*loperY/schaalY), (int)Math.rint(pNew
*loperX/schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-alphaNew*loperY/schaalY));}
209 }
210 }
211 pOld = pNew;
212 alphaOld = alphaNew;
213 }
214
215 //Combination
216 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;
217 for (int i = 0; i<=loperX;i++){
218 pNew = (double)i/loperX*schaalX;
219 alphaNew = calc.alpha_xpe(Q, r, M1_h, pNew);
220 if (alphaNew >= 0) {lambda_p = Math.sqrt(alphaNew/(1-M1_beta_));}
221 else { lambda_p = 0;}
222
223 if (M1_lambda_bar < 0.2){
224 alphaNew = M1_lambda_bar*M1_lambda_bar;
225 g.setColor(Color.RED);
226 }
227 else if (M1_lambda_bar < lambda_p){
228 alphaNew = (1 - M1_beta_*(M1_lambda_bar-0.2)/(lambda_p-0.2))*
M1_lambda_bar*M1_lambda_bar;
229 g.setColor(Color.GREEN);
230 }
231 else {g.setColor(Color.BLUE);}
232
233 if (alphaOld/schaalY > 1){}
234 else {
235 if ((int)Math.rint(pOld*loperX/schaalX+oorsprongX0) == (int)Math.
rint(pNew*loperX/schaalX+oorsprongX0)){ alphaNew = alphaOld; }
236 else { g.drawLine((int)Math.rint(pOld*loperX/schaalX+oorsprongX0),(
int)Math.rint(oorsprongY0-alphaOld*loperY/schaalY), (int)Math.rint(pNew*loperX/
schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-alphaNew*loperY/schaalY));}
237 }
238 pOld = pNew;
239 alphaOld = alphaNew;
240 }
241
242 //Design point
243 designpoint_x = (int)Math.rint(M1_p_bar_Ed*loperX/schaalX+oorsprongX0)+10;
244 designpoint_y = (int)Math.rint(oorsprongY0 - M1_alpha*loperY/schaalY)+20;
245
246 }
247 else if (tekenen == "M2" && lambdaChi) {
248 g.drawString("Method 2: Capacity Curve",breedte/2-100,20);
249
250 lambdaOld = 0;
251 chiOld=1;
252 chiNew=1;
253 for (int i = 0; i<=loperX;i++){
254 lambdaNew = (double)i/loperX*schaalX;
255 if (lambdaNew < 0.2){
256 chiNew = 1;
257 g.setColor(Color.RED);
258 }
259 else if (lambdaNew < M2_lambda_bar_p){
-5-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
260 chiNew=1-M2_beta_*(lambdaNew-0.2)/(M2_lambda_bar_p-0.2);
261 g.setColor(Color.GREEN);
262 }
263 else {
264 if (lambdaNew > 0){chiNew=M2_alpha_xpe/lambdaNew/lambdaNew;}
265 else{chiNew = chiOld;}
266 g.setColor(Color.BLUE);
267 }
268 if (chiOld/schaalY > 1){}
269 else{
270 if ((int)Math.rint(lambdaOld*loperX/schaalX+oorsprongX0) == (int)
Math.rint(lambdaNew*loperX/schaalX+oorsprongX0)){ chiNew = chiOld; }
271 else { g.drawLine((int)Math.rint(lambdaOld*loperX/schaalX+
oorsprongX0),(int)Math.rint(oorsprongY0-chiOld*loperY/schaalY), (int)Math.rint(
lambdaNew*loperX/schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-chiNew*loperY/
schaalY));}
272 }
273 lambdaOld = lambdaNew;
274 chiOld = chiNew;
275 }
276
277 //Design point
278 int lambda, chi;
279 lambda = (int)Math.rint(M2_lambda_bar*loperX/schaalX+oorsprongX0);
280 chi = (int)Math.rint(oorsprongY0 - M2_chi*loperY/schaalY);
281
282 }
283 else if (tekenen == "M2" && !lambdaChi) {
284 g.drawString("Method 2: Alpha-p graph",breedte/2-100,20);
285
286 //Elastic
287 g.setColor(Color.BLUE);
288 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;
289 alphaOld = calc.alpha_xpe(Q, r, M2_h, pOld);
290 for (int i = 0; i<=loperX;i++){
291 pNew = (double)i/loperX*schaalX;
292 alphaNew = calc.alpha_xpe(Q, r, M2_h, pNew);
293 if (alphaNew >0) {
294 if (alphaOld/schaalY > 1){}
295 else {
296 if ((int)Math.rint(pOld*loperX/schaalX+oorsprongX0) == (int)
Math.rint(pNew*loperX/schaalX+oorsprongX0)){ alphaNew = alphaOld; }
297 else { g.drawLine((int)Math.rint(pOld*loperX/schaalX+
oorsprongX0),(int)Math.rint(oorsprongY0-alphaOld*loperY/schaalY), (int)Math.rint(pNew
*loperX/schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-alphaNew*loperY/schaalY));}
298 }
299 }
300 pOld = pNew;
301 alphaOld = alphaNew;
302 }
303
304 //Plastic
305 g.setColor(Color.RED);
306 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;
307 alphaOld = calc.alpha_xpp(pOld, M2_lambda_bar, r, t, M2_beta_);
308 for (int i = 0; i<=loperX;i++){
309 pNew = (double)i/loperX*schaalX;
-6-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
310 alphaNew = calc.alpha_xpp(pNew, M2_lambda_bar, r, t, M2_beta_);
311 if (alphaNew >0) {
312 if (alphaOld/schaalY > 1){}
313 else {
314 if ((int)Math.rint(pOld*loperX/schaalX+oorsprongX0) == (int)
Math.rint(pNew*loperX/schaalX+oorsprongX0)){ alphaNew = alphaOld; }
315 else { g.drawLine((int)Math.rint(pOld*loperX/schaalX+
oorsprongX0),(int)Math.rint(oorsprongY0-alphaOld*loperY/schaalY), (int)Math.rint(pNew
*loperX/schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-alphaNew*loperY/schaalY));}
316 }
317 }
318 pOld = pNew;
319 alphaOld = alphaNew;
320 }
321
322 //Combination
323 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;
324 for (int i = 0; i<=loperX;i++){
325 pNew = (double)i/loperX*schaalX;
326 alphaNew = calc.alpha_xpe(Q, r, M2_h, pNew);
327 if (alphaNew >= 0) {lambda_p = Math.sqrt(alphaNew/(1-M2_beta_));}
328 else { lambda_p = 0;}
329
330 if (M2_lambda_bar < 0.2){
331 alphaNew = M2_lambda_bar*M2_lambda_bar;
332 g.setColor(Color.RED);
333 }
334 else if (M2_lambda_bar < lambda_p){
335 alphaNew = (1 - M2_beta_*(M2_lambda_bar-0.2)/(lambda_p-0.2))*
M2_lambda_bar*M2_lambda_bar;
336 g.setColor(Color.GREEN);
337 }
338 else {g.setColor(Color.BLUE);}
339
340 if (alphaOld/schaalY > 1){}
341 else {
342 if ((int)Math.rint(pOld*loperX/schaalX+oorsprongX0) == (int)Math.
rint(pNew*loperX/schaalX+oorsprongX0)){ alphaNew = alphaOld; }
343 else { g.drawLine((int)Math.rint(pOld*loperX/schaalX+oorsprongX0),(
int)Math.rint(oorsprongY0-alphaOld*loperY/schaalY), (int)Math.rint(pNew*loperX/
schaalX+oorsprongX0),(int)Math.rint(oorsprongY0-alphaNew*loperY/schaalY));}
344 }
345 pOld = pNew;
346 alphaOld = alphaNew;
347 }
348
349 //Design point
350 designpoint_x = (int)Math.rint(M2_p_bar_Ed*loperX/schaalX+oorsprongX0)+10;
351 designpoint_y = (int)Math.rint(oorsprongY0 - M2_alpha*loperY/schaalY)+20;
352 }
353 g.fillOval(designpoint_x-2, designpoint_y-2, 5, 5);
354 g.drawLine(designpoint_x-4,designpoint_y-4,designpoint_x+4,designpoint_y+4);
355 g.drawLine(designpoint_x-4,designpoint_y+4,designpoint_x+4,designpoint_y-4);
356 }
357 }
358
359 public class ConeECCS extends java.applet.Applet {
-7-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:18
360
361 public boolean doorgaan = true;
362 public grafiekPaneel tekenpaneel = new grafiekPaneel();
363 public double r, h, h_d, t, beta, yieldStress, E, Q, rho, PSF, LF, volume1,
volume2, volume, gewicht,
364 sigxEk, sigxRcr, sigxEd, sigxRpl,zeta_k, zeta_d, psi_bar, lambda_bar,
p_bar_Ed, beta_, alpha_xp, lambda_bar_p, chi,
365 sigxRk, sigxRd, ratio;
366 public boolean elastisch, plastisch;
367
368 /** Initializes the applet ConeECCS */
369
370 public void init() {
371 try {
372 java.awt.EventQueue.invokeAndWait(new Runnable() {
373 public void run() {
374 initComponents();
375 //cmdGraph.doClick();
376 //cmdHelp.doClick();
377
378 }
379 });
380 } catch (Exception ex) {
381 ex.printStackTrace();
382 }
383 }
-8-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:20
1658 private void rbQ40ActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_rbQ40ActionPerformed
1659 boolean geselecteerd = rbQ40.isSelected();
1660 if (geselecteerd){
1661 rbQ16.setSelected(!geselecteerd);
1662 rbQ25.setSelected(!geselecteerd);
1663 }
1664 else {rbQ40.setSelected(!geselecteerd);}
1665 }//GEN-LAST:event_rbQ40ActionPerformed
1666
1667 private void rbQ25ActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_rbQ25ActionPerformed
1668 boolean geselecteerd = rbQ25.isSelected();
1669 if (geselecteerd){
1670 rbQ16.setSelected(!geselecteerd);
1671 rbQ40.setSelected(!geselecteerd);
1672 }
1673 else {rbQ25.setSelected(!geselecteerd);}
1674 }//GEN-LAST:event_rbQ25ActionPerformed
1675
1676 private void rbQ16ActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_rbQ16ActionPerformed
1677 boolean geselecteerd = rbQ16.isSelected();
1678 if (geselecteerd){
1679 rbQ25.setSelected(!geselecteerd);
1680 rbQ40.setSelected(!geselecteerd);
1681 }
1682 else {rbQ16.setSelected(!geselecteerd);}
1683 }//GEN-LAST:event_rbQ16ActionPerformed
1684
1685 private void rbPAActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_rbPAActionPerformed
1686 rbCL.setSelected(!rbPA.isSelected());
1687 tekenpaneel.lambdaChi = rbCL.isSelected();
1688 tekenpaneel.update(tekenpaneel.getGraphics());
1689 }//GEN-LAST:event_rbPAActionPerformed
1690
1691 private void rbCLActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_rbCLActionPerformed
1692 rbPA.setSelected(!rbCL.isSelected());
1693 tekenpaneel.lambdaChi = rbCL.isSelected();
1694 tekenpaneel.update(tekenpaneel.getGraphics());
1695 }//GEN-LAST:event_rbCLActionPerformed
1696
1697 private void cmdMethode2ActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_cmdMethode2ActionPerformed
1698 tekenpaneel.tekenen = "M2";
1699 tekenpaneel.update(tekenpaneel.getGraphics());
1700 }//GEN-LAST:event_cmdMethode2ActionPerformed
1701
1702 private void cmdMethode1ActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_cmdMethode1ActionPerformed
1703 tekenpaneel.tekenen = "M1";
1704 tekenpaneel.update(tekenpaneel.getGraphics());
1705
1706 }//GEN-LAST:event_cmdMethode1ActionPerformed
1707
-1-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:20
1708 private void cmdCalcActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_cmdCalcActionPerformed
1709 cmdCalc.setSelected(false);
1710
1711 // Declare variables
1712
1713 doorgaan = true;
1714
1715 // Inlezen parameters, als er één foutief is ingevoerd wordt de berekening niet uitgevoerd (doorgaan = 0)
1716 r = convertToDouble(txtBaseRadius.getText(),"Base Radius");
1717 h = convertToDouble(txtConeHeight.getText(),"Cone Height");
1718
1719 if ( h/r > 10 ) {
1720 JOptionPane.showMessageDialog(null, "Wrong input: The following
geometrical limitations need to be applied Cone Height/Base Radius <= 10" , "Input
was not correct", JOptionPane.WARNING_MESSAGE);
1721 doorgaan = false;}
1722 t = convertToDouble(txtThickness.getText(),"Thickness");
1723
1724 int beta_deg = Integer.parseInt(txtApexHalfAngle.getText());
1725 if (beta_deg >= 15 && beta_deg <= 65){ beta = (double)beta_deg/180*Math.PI;}
1726 else {
1727 JOptionPane.showMessageDialog(null, "Wrong input: the Apex half angle
must be between 15 and 65 degrees", "Input was not correct", JOptionPane.
WARNING_MESSAGE);
1728 doorgaan = false;
1729 }
1730
1731 double l_gx = 5* (4*Math.sqrt(r*t/Math.cos(beta)));
1732 double l = h / Math.cos(beta);
1733 if (l < l_gx) {
1734 JOptionPane.showMessageDialog(null, "Wrong input: the meridional length
of the cone is to small", "Input was not correct", JOptionPane.WARNING_MESSAGE);
1735 doorgaan = false;
1736 }
1737
1738 yieldStress = convertToDouble(txtYieldStress.getText(),"Yield Stress");
1739 E = convertToDouble(txtYoungsModulus.getText(),"Young's Modulus");
1740
1741 if (rbQ16.isSelected()){ Q = 16.;}
1742 else if (rbQ25.isSelected()){ Q = 25.;}
1743 else if (rbQ40.isSelected()){ Q = 40.;}
1744
1745 rho = convertToDouble(txtSpecificWeight.getText(),"Specific Weight")/Math.pow
(10,9);
1746 PSF = convertToDouble(txtPartialSafetyFactor.getText(),"Partial Safety
Factor");
1747 LF = convertToDouble(txtLoadFactor.getText(),"Load Factor");
1748
1749 if (doorgaan) {
1750 // Gegevens voor de grafiek (voor M1 en M2)
1751 tekenpaneel.r = r;
1752 tekenpaneel.Q = Q;
1753 tekenpaneel.t = t;
1754 tekenpaneel.beta = beta;
1755
1756 // Algemene berekening
-2-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:20
1757 volume1 = Math.PI*Math.pow(r/1000,2)*h/1000;
1758 volume2 = 2*Math.PI*(r/1000+h/1000*Math.tan(beta)/3)*Math.pow(h/1000,2)*
Math.tan(beta)/2;
1759 volume = volume1 + volume2;
1760 gewicht = volume*rho*Math.pow(1000,2);
1761 sigxEk = rho*volume2*Math.pow(1000,3) / (2*Math.PI*r*t*Math.cos(beta));
1762 sigxRcr = 0.605*E*t*Math.cos(beta)/r;
1763 zeta_k = Math.tan(beta)*h/r;
1764
1765 // Method 1
1766 h_d = 1/zeta_k*(Math.pow(LF*(Math.pow(1+zeta_k,3)-1)+1,0.3333333333333)-1
)*h;
1767 zeta_d = Math.tan(beta)*h_d/r;
1768 psi_bar = 1.0/6.0*zeta_d*((3-2*h/h)*(2+zeta_d)+h/h);
1769 sigxRpl = psi_bar/Math.sqrt(1+psi_bar+Math.pow(psi_bar,2))*yieldStress;
1770 lambda_bar = Math.sqrt(sigxRpl/sigxRcr);
1771 p_bar_Ed = rho*h_d*r/(t*Math.cos(beta)*sigxRcr);
1772 sigxEd = psi_bar*p_bar_Ed*sigxRcr;
1773 beta_ = 0.6; //1.0-0.5*Math.sqrt(1+psi_bar+Math.pow(psi_bar,2))/psi_bar;
1774 alpha_xp = calc.alpha_xpe(Q, r, h_d, p_bar_Ed);
1775 lambda_bar_p = Math.sqrt(alpha_xp/(1-beta_));
1776
1777 if (lambda_bar > lambda_bar_p){
1778 chi = alpha_xp/Math.pow(lambda_bar,2);
1779 sigxRk = alpha_xp*sigxRcr;
1780 sigxRd = sigxRk/PSF;
1781 lblM1ElasticPlastic.setText("Elastic buckling");
1782 }
1783 else if (lambda_bar > 0.2){
1784 chi = 1-beta_*(lambda_bar-0.2)/(lambda_bar_p-0.2);
1785 sigxRk = chi*sigxRpl;
1786 sigxRd = sigxRk/PSF;
1787 lblM1ElasticPlastic.setText("Elastic-plastic buckling");
1788 }
1789 else{
1790 chi = 1;
1791 sigxRk = chi*sigxRpl;
1792 sigxRd = sigxRk/PSF;
1793 lblM1ElasticPlastic.setText("Plastic buckling");
1794 }
1795
1796 ratio = sigxRd/sigxEd;
1797 if (ratio>=1.0){lblM1Status.setText("Safe!");}
1798 else{lblM1Status.setText("Failure!");}
1799
1800 txtECS.setText(String.valueOf((float)sigxRcr));
1801 txtM1DMSR.setText(String.valueOf((float)sigxRd));
1802 txtM1DMSA.setText(String.valueOf((float)sigxEd));
1803 txtM1Ratio.setText(String.valueOf((float)ratio));
1804
1805 // gegevens overdragen voor grafiek
1806 tekenpaneel.M1_h = h_d;
1807 tekenpaneel.M1_p_bar_Ed = p_bar_Ed;
1808 tekenpaneel.M1_alpha_xpe = alpha_xp;
1809 tekenpaneel.M1_lambda_bar = lambda_bar;
1810 tekenpaneel.M1_lambda_bar_p = lambda_bar_p;
1811 tekenpaneel.M1_chi = sigxEk/sigxRpl;
-3-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:20
1812 tekenpaneel.M1_alpha = sigxEk/sigxRcr;
1813 tekenpaneel.M1_beta_ = beta_;
1814
1815 // Method 2
1816 sigxEd = LF * sigxEk;
1817 zeta_d = zeta_k;
1818 psi_bar = 1.0/6.0*zeta_d*((3-2*h/h)*(2+zeta_d)+r/r);
1819 sigxRpl = psi_bar/Math.sqrt(1+psi_bar+Math.pow(psi_bar,2))*yieldStress;
1820 lambda_bar = Math.sqrt(sigxRpl/sigxRcr);
1821 p_bar_Ed = LF*rho*h*r/(t*Math.cos(beta)*sigxRcr);
1822 beta_ = 0.6; //1.0-0.5*Math.sqrt(1+psi_bar+Math.pow(psi_bar,2))/psi_bar;
1823 alpha_xp = 0.5*(1-1.5/Q)*Math.pow(Math.tan(beta)/zeta_d*p_bar_Ed,0.135*(1
+1/Q));
1824 lambda_bar_p = Math.sqrt(alpha_xp/(1-beta_));
1825
1826 if (lambda_bar > lambda_bar_p){
1827 chi = alpha_xp/Math.pow(lambda_bar,2);
1828 sigxRk = alpha_xp*sigxRcr;
1829 sigxRd = sigxRk/PSF;
1830 lblM2ElasticPlastic.setText("Elastic buckling");
1831 }
1832 else if (lambda_bar > 0.2){
1833 chi = 1-beta_*(lambda_bar-0.2)/(lambda_bar_p-0.2);
1834 sigxRk = chi*sigxRpl;
1835 sigxRd = sigxRk/PSF;
1836 lblM2ElasticPlastic.setText("Elastic-plastic buckling");
1837 }
1838 else{
1839 chi = 1;
1840 sigxRk = chi*sigxRpl;
1841 sigxRd = sigxRk/PSF;
1842 lblM2ElasticPlastic.setText("Plastic buckling");
1843 }
1844
1845 ratio = sigxRd/sigxEd;
1846 if (ratio>=1.0){lblM2Status.setText("Safe!");}
1847 else{lblM2Status.setText("Failure!");}
1848
1849 txtM2DMSR.setText(String.valueOf((float)sigxRd));
1850 txtM2DMSA.setText(String.valueOf((float)sigxEd));
1851 txtM2Ratio.setText(String.valueOf((float)ratio));
1852
1853 // gegevens overdragen voor grafiek
1854 tekenpaneel.M2_h = h;
1855 tekenpaneel.M2_p_bar_Ed = p_bar_Ed;
1856 tekenpaneel.M2_alpha_xpe = alpha_xp;
1857 tekenpaneel.M2_lambda_bar = lambda_bar;
1858 tekenpaneel.M2_lambda_bar_p = lambda_bar_p;
1859 tekenpaneel.M2_chi = sigxEk/sigxRpl;
1860 tekenpaneel.M2_alpha = sigxEk/sigxRcr;
1861 tekenpaneel.M2_beta_ = beta_;
1862
1863 }
1864 else{
1865 //Results
1866 txtECS.setText("");
1867 //Method 1
-4-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:20
1868 txtM1DMSR.setText("");
1869 txtM1DMSA.setText("");
1870 txtM1Ratio.setText("");
1871 lblM1ElasticPlastic.setText("");
1872 lblM1Status.setText("");
1873 //Method 2
1874 txtM2DMSR.setText("");
1875 txtM2DMSA.setText("");
1876 txtM2Ratio.setText("");
1877 lblM2ElasticPlastic.setText("");
1878 lblM2Status.setText("");
1879 }
1880
1881 }//GEN-LAST:event_cmdCalcActionPerformed
1882
1883 private double convertToDouble(String tekst,String variabele){
1884 double getal = 1;
1885 try{
1886 getal = Double.parseDouble(tekst);
1887 if (getal < 0) { throw new Exception();}
1888 }
1889 catch(Exception e){
1890 //custom title, warning icon
1891 JOptionPane.showMessageDialog(null, "Wrong input: " + variabele, "Input
was not correct", JOptionPane.WARNING_MESSAGE);
1892 getal = -1;
1893 doorgaan = false;
1894 }
1895 finally { return getal;}
1896 }
1897
1898 private void cmdClearActionPerformed(java.awt.event.ActionEvent evt) {
//GEN-FIRST:event_cmdClearActionPerformed
1899 cmdClear.setSelected(false);
1900 //Geometry
1901 txtBaseRadius.setText("");
1902 txtConeHeight.setText("");
1903 txtThickness.setText("");
1904 txtApexHalfAngle.setText("");
1905 //Material & Quality
1906 txtYieldStress.setText("");
1907 txtYoungsModulus.setText("");
1908 txtSpecificWeight.setText("");
1909 //Safety
1910 txtPartialSafetyFactor.setText("");
1911 txtLoadFactor.setText("");
1912 //Results
1913 txtECS.setText("");
1914 //Method 1
1915 txtM1DMSR.setText("");
1916 txtM1DMSA.setText("");
1917 txtM1Ratio.setText("");
1918 lblM1ElasticPlastic.setText("");
1919 lblM1Status.setText("");
1920 //Method 2
1921 txtM2DMSR.setText("");
1922 txtM2DMSA.setText("");
-5-
C:\Documents and Settings\Wouter\Bureaublad\Thesis\ConeECCS.java zaterdag 31 mei 2008 1:20
1923 txtM2Ratio.setText("");
1924 lblM2ElasticPlastic.setText("");
1925 lblM2Status.setText("");
1926 }//GEN-LAST:event_cmdClearActionPerformed
1927
-6-
C:\Documents and Settings\Wouter\Bureaublad\f2abq.py maandag 2 juni 2008 15:34
553 class Analysis(Dict):
554 """Contains all data about the analysis."""
555
556 def __init__(self, analysistype='STATIC', kind='', time=[0,0,0,0], nf=None, incr=
None, nlgeom='NO', cloadset='ALL', opcl='NEW', dloadset='ALL', opdl='NEW', boundset=
None, opb=None, dispset='ALL', op='MOD'):
557 """Create new analysis data.
558
559 analysistype is the analysis type. Currently, only STATIC is supported.
560 time is a list which defines the time step.
561 If nlgeom='YES', the analysis will be non-linear.
562 Cloadset is a list of property numbers of which the cloads will be used in
this analysis.
563 Dloadset is a list of property numbers of which the dloads will be used in
this analysis.
564 Boundset is a list of property numbers of which the bounds will be used in
this analysis. Initial boundaries are defined in a Model instance.
565 By default, the load is applied as a new load, i.e. loads
566 from previous steps are removed. The user can set op='MOD'
567 to keep/modify the previous loads.
568 """
569 Dict.__init__(self,{'analysistype':analysistype, 'kind':kind, 'time':time,
'nf':nf, 'incr':incr, 'nlgeom':nlgeom, 'cloadset':cloadset, 'opcl':opcl, 'dloadset':
dloadset, 'opdl':opdl, 'boundset':boundset, 'opb': opb, 'dispset' : dispset , 'op':
op})
570
-1-
C:\Documents and Settings\Wouter\Bureaublad\f2abq.py maandag 2 juni 2008 15:31
465 def writeStep(fil, analysis='STATIC', kind='RIKS', time=[0,0,0,0], nf=None, incr=None
, nlgeom='NO', cloadset='ALL', opcl='NEW', dloadset='ALL', opdl='NEW', boundset=None,
opb=None, dispset='ALL', op='MOD', outp=[], dat=[]):
466 """Write a load step.
467
468 analysistype is the analysis type. Currently, only STATIC is supported.
469 kind is the type of anaysis: '' or 'RIKS'
470 time is a list which defines the time step.
471 riks is a list which defines the riks parameters if the kind is RIKS
472 If nlgeom='YES', the analysis will be non-linear.
473 Cloadset is a list of property numbers of which the cloads will be used in this
analysis.
474 Dloadset is a list of property numbers of which the dloads will be used in this
analysis.
475 Boundset is a list of propery numbers of which the bounds will be used in this
analysis.
476 By default, the load is applied as a new load, i.e. loads
477 from previous steps are removed. The user can set op='MOD'
478 to keep/modify the previous loads.
479 outp is a list of Odb-instances.
480 dat is a list of Dat-instances.
481 """
482 if analysis.upper()=='PERTURBATION':
483 fil.write("""*STEP, PERTURBATION
484 Perturbatie analyse
485 *STATIC
486 """)
487
488 elif analysis.upper()=='BUCKLE':
489 fil.write("""*STEP, NLGEOM=NO
490 Eigenwaardeberekening
491 *BUCKLE, EIGENSOLVER=%s
492 """ % (kind.upper()))
493 if kind.upper() == 'LANCZOS':
494 fil.write("""%s,%s,%s,%s,%s\n""" % (time[0],time[1],time[2],time[3],time[
4]))
495 elif kind.upper() == 'SUBSPACE':
496 fil.write("""%s,%s,%s,%s\n""" % (time[0],time[1],time[2],time[3]))
497 if nf != None:
498 fil.write("""*NODE FILE, GLOBAL=YES, LAST MODE=%s
499 u
500 """ % (nf))
501
502 elif analysis.upper()=='STATIC' and kind.upper()=='RIKS':
503 fil.write("""*STEP, NLGEOM=%s, INCR=%s
504 *STATIC, RIKS
505 %s,%s,%s,%s,%s,%s,%s,%s
506 """ % (nlgeom, incr, time[0], time[1], time[2], time[3], time[4], time[5], time[6],
time[7]))
507
508
509 elif analysis.upper()=='STATIC' and kind.upper()=='':
510 fil.write("""*STEP, NLGEOM=%s
511 *STATIC
512 %s, %s, %s, %s
513 """ % (nlgeom, time[0], time[1], time[2], time[3]))
514
-1-
C:\Documents and Settings\Wouter\Bureaublad\f2abq.py maandag 2 juni 2008 15:31
515 writeBoundaries(fil, boundset, opb)
516 writeDisplacements(fil, dispset,op)
517 writeCloads(fil, cloadset, opcl)
518 writeDloads(fil, dloadset, opdl)
519 for i in range(len(outp)):
520 writeStepOutput(fil, outp[i].type,outp[i].frequency,outp[i].variable,outp[i].
kind,outp[i].set,outp[i].IP,outp[i].ID)
521 for i in range(len(dat)):
522 writeStepData(fil, dat[i].kind, dat[i].set, dat[i].ID, dat[i].globalaxes)
523 fil.write("*END STEP\n")
-2-
C:\Documents and Settings\Wouter\Bureaublad\f2abq.py maandag 2 juni 2008 15:49
572 class Odb(Dict):
573 """Contains all data about the output requests to the .ODB-file."""
574
575 def __init__(self, type='FIELD', frequency=None, variable='PRESELECT', kind = ''
, set='all', IP=None, ID=None):
576 """ Create new ODB data.
577
578 type = 'FIELD' or 'HISTORY'
579 variable = 'ALL' or 'PRESELECT'
580 kind = 'NODE', or 'ELEMENT'
581 set is a list of property numbers of which the data should be written to the
ODB-file.
582 IP is the number of the integration point in case of shell elements
583 ID is a list of output variable identifiers.
584 """
585 Dict.__init__(self, {'type':type, 'frequency':frequency, 'variable':variable,
'kind':kind, 'set':set, 'IP':IP, 'ID': ID})
-1-
C:\Documents and Settings\Wouter\Bureaublad\f2abq.py maandag 2 juni 2008 15:42
377 def writeStepOutput(fil, type='FIELD', frequency=None, variable='PRESELECT', kind=''
, set='ALL', IP=None, ID=None):
378 """Write the step output requests.
379
380 type = 'FIELD' or 'HISTORY'
381 frequency: if is 0, no frequency is appended in the input file
382 variable = 'ALL' or 'PRESELECT'
383 kind = '', 'NODE', or 'ELEMENT'
384 set is a list of property numbers of which the data should be written to the
ODB-file.
385 IP is the number of the integration point in case of shell elements
386 ID is a list of output variable identifiers.
387 """
388 if variable is None:
389 if frequency is not None:
390 fil.write("*OUTPUT, %s, frequency=%s\n" %(type.upper(),frequency))
391 else:
392 fil.write("*OUTPUT, %s\n" %(type.upper()))
393 else:
394 fil.write("*OUTPUT, %s, VARIABLE=%s\n" %(type.upper(),variable.upper()))
395
396 if kind.upper()=='ELEMENT':
397 if isinstance(set,list):
398 for j in range(len(set)):
399 fil.write("*ELEMENT OUTPUT, ELSET=%s\n" % Eset(str(set[j])))
400 if IP!=None:
401 fil.write("%s \n"%IP)
402 if ID!=None:
403 for j in range(len(ID)):
404 fil.write("%s \n"%ID[j])
405 elif set.upper()=='ALL':
406 fil.write("*ELEMENT OUTPUT, ELSET=Eall\n")
407 if IP!=None:
408 fil.write("%s \n"%IP)
409 if ID!=None:
410 for j in range(len(ID)):
411 fil.write("%s \n"%ID[j])
412 else:
413 warning("The set should be a list")
414 if kind.upper()=='NODE':
415 if isinstance(set,list):
416 for j in range(len(set)):
417 fil.write("*NODE OUTPUT, NSET=%s\n"% Nset(str(set[j])))
418 if IP!=None:
419 fil.write("%s \n"%IP)
420 if ID!=None:
421 for j in range(len(ID)):
422 fil.write("%s \n"%ID[j])
423 elif set.upper()=='ALL':
424 fil.write("*NODE OUTPUT, NSET=Nall\n")
425 if IP!=None:
426 fil.write("%s \n"%IP)
427 if ID!=None:
428 for j in range(len(ID)):
429 fil.write("%s \n"%ID[j])
430 else:
431 warning("The set should be a list of property numbers.")
-1-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1 #!/usr/bin/env pyformex --gui
2
3 import time
4 from datetime import datetime
5 from plugins import f2abq
6 from plugins import properties
7
8 X = Formex([[[0.,0.,0.],[1.,0.,0.]]],0)
9 Y = Formex([[[0.,0.,0.],[0.,1.,0.]]],1)
10 Z = Formex([[[0.,0.,0.],[0.,0.,0.280]]],2)
11 XYZ = X+Y+Z
12 print "X: Zwart; Y: Rood; Z: Groen"
13
14 createView('myview1',(120.,-45.,90.))
15 createView('myview2',(-90.,180.,-90.))
16 createView('abq_view',(-135.,152.5,-180.))
17
18 ###############################
19 ### Variables of the script ###
20 ###############################
21
22 b_TypeOfConstruction = False # boolean menu-item Type Of Constructions executed?
23 b_Geometry = False # boolean menu-item Geometry executed?
24 b_Support = False # boolean menu-item Support executed?
25 b_Stiffener = False # boolean menu-item Stiffener executed?
26 b_Sector = False # boolean menu-item Sector executed?
27 b_Material = False # boolean menu-item Material executed?
28 b_Loads = False # boolean menu-item Loads executed?
29 b_Elements = False # boolean menu-item Elements executed?
30 b_Mesh = False # boolean menu-item Mesh executed?
31 b_Analysis = False # boolean menu-item Analysis executed?
32 b_inputOutput = False # boolean menu-item inpuntOutput executed?
33 b_createMesh = False # creatMesh executed?
34 b_feModel = False # feModel() executed?
35
36 b_cy = True # boolean: cylindrical part represented?
37 b_co = False # boolean: conical part represented?
38
39 shell = Formex([[[]]]) # create an empty formex for the shell
40 temp = Formex([[[]]]) # create an empty formex for the temporary shell
41
42 r1 = 0.2 # initial radius of the cone at the bottom
43 r2 = 0.350 # initial radius of the cone at the top and radius of the cylinder
44 h1 = 0.1 # initial height of the cone
45 h2 = 0.700 # initial height of the cylinder
46 t1 = t2 = 0.0007 # initial thickness of the cone and cylinder
47
48 # Support
49 support = 1 # 1-Local support (Silo) / 2-Line support (Cone)
50 typeOfSupport = 'Rigid' # initial type of support
51 n_su = 4 # initial amount of support points
52 w_su = 0.070 # initial width of a support point
53
54 # Sector
55 sector = 0 # initial type of sector (0-3)
56 a = 45. # angle of the sector
57
-1-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
58 # Stiffener
59 c_st = 'R' # initial type of the stiffener
60 ne_st_w = 1 # initial amount of elements between the middle of the support point and the stiffener
61 ne_st_d = 1 # initial amount of elements for the stiffener in radional direction
62 ne_st_l = 1 # initial type of the stiffener
63 l_st = 0.280 # length of the stiffener
64 w_st = 0.064 # width of the stiffener (interstringerafstand) (circumerencial direction)
65 d_st = 0.020 # width of the stiffene (radial direction)
66 t_st = t_tr = t_br = 0.0015 # thickness of the stiffener
67 h_br = h_tr = w_st #height of the stiffener (radional direction)
68 angle = 45. #angle of the S-typed stiffener
69
70 # Mesh
71 algoritme = 2
72 ne_v1 = 50 # amount of elements in vertical direction (cylinder)
73 ne_v2 = 20 # amount of elements in vertical direction (cone)
74 ne_h = 50 # amount of elements in horizontal direction
75 scale = 1.5 # scale factor between the dense and wide mesh
76 p_v = 0.75 # % of the dense zone in vertical direction (height)
77 p_h = 0.75 # % of the dense zone in horizontal direction (radius)
78 ne1 = 50
79 ne3 = 50
80
81 # Elements
82
83 typeOfElement = 'S4R5' # initial type of element
84
85 # Material
86
87 young = [200000000000] * 5 # young modulus for the 5 shell-items
88 poisson = [0.3] * 5 # Poisson ratio for the 5 shell-items
89 yields = [240000000] * 5 # yield stress for the 5 shell-items
90 plasticity = None # boolean plasticity
91 thickenss = [] # empty array which will contain the thickness for the 5 shell-items
92
93 # Loads
94 loads = 0 #
95 a_load = 1000. # axial load [N]
96 h_load = 0. # hydrostatic pressure
97
98 # Analysis
99 typeOfAnalysis = 'LBA' # initial type of analysis
100 typeOfSolver = 'SUBSPACE' # initial type of solver for LBA-analysis
101 parameters1 = ['5','','20','50'] # initial paramters for a SUBSPACE LBA-analysis
102 parameters2 = ['5','0.005','','',''] # initial parameters for a LANCZOS LBA-analysis
103 parameters3 = ['0.3','1','0.001','3','300','','',''] #initial paramters for a Riks analyisis
104 increments = 50 # number of increments for the step
105 lastmode = 5 # amount of eigenmodes wanted in a LBA-analysis
106 analysis = [] # empty array for the type of analysis
107
108 # Output
109 freq = 5
110 int_point = 3
111
112 # Filename
113 directory = GD.cfg['workdir'] # directory where the inputfile is written
114 name = 'shell' # name
-2-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
115 filename = 'shell' # filename
116
117 #############
118 ### Input ###
119 #############
120
121
122 def inputTypeOfConstruction():
123 global b_TypeOfConstruction, b_Geometry, b_Support, b_Stiffener, b_Sector, b_Mesh
, b_createMesh, b_feModel, support, b_cy, b_co
124
125 b_TypeOfConstruction = False
126 b_Geometry = False
127 b_Support = False
128 b_Stiffener = False
129 b_Sector = False
130 b_Mesh = False
131 b_createMesh = False
132 b_feModel = False
133
134 b_TypeOfConstruction = True
135
136 res = ask('Choose the type of shell construction:',
137 ['Silo with cone','Silo without cone',
138 'Watertower with cylinder',
139 'Watertower without cylinder'])
140
141 if res == 'Silo with cone':
142 support = 1
143 b_cy = True
144 b_co = True
145 elif res == 'Silo without cone':
146 support = 1
147 b_cy = True
148 b_co = False
149 elif res == 'Watertower with cylinder':
150 support = 2
151 b_cy = True
152 b_co = True
153 elif res == 'Watertower without cylinder':
154 support = 2
155 b_cy = False
156 b_co = True
157
158 print "support: %s" %(support)
159 print "b_cy: %s" %(b_cy)
160 print "b_co: %s" %(b_co)
161
162 def inputGeometry():
163 global b_Geometry, b_createMesh, r1,r2,h1,h2,t1,t2
164
165 b_createMesh = False
166 b_feModel = True
167 b_Geometry = True
168
169 if b_cy and b_co:
170 res = askItems([
-3-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
171 ['Bottom radius cone:',r1],
172 ['Height cone:',h1],
173 ['Thickness cone:',t1],
174 ['Radius cylinder:',r2],
175 ['Height cylinder:',h2],
176 ['Thickness cylinder:',t2]])
177
178 if res:
179 r1 = float(res['Bottom radius cone:'])
180 h1 = float(res['Height cone:'])
181 t1 = float(res['Thickness cone:'])
182 r2 = float(res['Radius cylinder:'])
183 h2 = float(res['Height cylinder:'])
184 t2 = float(res['Thickness cylinder:'])
185
186 print "r1: %s" %(r1)
187 print "h1: %s" %(h1)
188 print "t1: %s" %(t1)
189 print "r2: %s" %(r2)
190 print "h2: %s" %(h2)
191 print "t2: %s" %(t2)
192
193 if b_cy and not b_co:
194 res = askItems([
195 ['Radius cylinder:',r2],
196 ['Height cylinder:',h2],
197 ['Thickness cylinder:',t2]])
198
199 r2 = float(res['Radius cylinder:'])
200 h2 = float(res['Height cylinder:'])
201 t2 = float(res['Thickness cylinder:'])
202
203 print "r2: %s" %(r2)
204 print "h2: %s" %(h2)
205 print "t2: %s" %(t2)
206
207 if not b_cy and b_co:
208 res = askItems([
209 ['Top radius cone:',r2],
210 ['Bottom radius cone:',r1],
211 ['Height cone:',h1],
212 ['Thickness cone:',t1]])
213
214 r2 = float(res['Top radius cone:'])
215 r1 = float(res['Bottom radius cone:'])
216 h1 = float(res['Height cone:'])
217 t1 = float(res['Thickness cone:'])
218
219 print "r1: %s" %(r1)
220 print "t1: %s" %(t1)
221 print "h1: %s" %(h1)
222 print "r2: %s" %(t2)
223
224 if not b_cy and not b_co:
225 print "Please select the type of construction"
226 if ack("Select the type of construction?"):
227 inputTypeOfConstruction()
-4-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
228 inputGeometry()
229 else:
230 print "No geometry has been defined"
231 b_Geometry = False
232
233 def inputSupport():
234 global b_Support, b_createMesh, n_su, w_su, typeOfSupport
235
236 b_createMesh = False
237 b_feModel = True
238 b_Support = True
239
240 if typeOfSupport == "Rigid":
241 b_tos = True
242 elif typeOfSupport == "Flexible":
243 b_tos = False
244 else:
245 b_tos = True
246
247 if support == 1:
248 res = askItems([
249 ['Amount of support points:',n_su],
250 ['Width of support points:',w_su],
251 ['Rigid (True) / Flexible (False):',b_tos],
252 ['Define stiffener at support points:',True]])
253
254 if res['Rigid (True) / Flexible (False):']:
255 typeOfSupport = 'Rigid'
256 else:
257 typeOfSupport = 'Flexible'
258
259 if res['Define stiffener at support points:']:
260 inputStiffener()
261
262 print "support: %s" %(support)
263 print "typeOfSupport: %s" %(typeOfSupport)
264 print "n_su: %s" %(n_su)
265 print "w_su: %s" %(w_su)
266 print "typeOfSupport: %s" %(typeOfSupport)
267
268 elif support == 2:
269 typeOfSupport = ask("Type of support", choices=['Encastre','Pinned'])
270
271 print "support: %s" %(support)
272 print "typeOfSupport: %s" %(typeOfSupport)
273
274 else:
275 print "Please select the type of construction"
276 if ack("Select the type of construction?"):
277 inputTypeOfConstruction()
278 inputSupport()
279 else:
280 print "No support type has been defined"
281 b_Support = False
282
283 def inputStiffener():
284 global b_Stiffener, b_createMesh, c_st, d_st,w_st,l_st,t_st, h_br,t_br, h_tr,t_tr
-5-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
, angle
285
286 b_createMesh = False
287 b_feModel = True
288 b_Stiffener = True
289
290 if support == 1:
291 c_st = ask("Select the type of stiffener", choices=['R','U','S'])
292
293 if c_st == 'R':
294 res = askItems([
295 ['Width of the Stiffener (circuference):',w_st],
296 ['Width of the Stiffener (radial):',d_st],
297 ['Length of the Stiffener:',l_st],
298 ['Thickness of the Stiffener:',t_st],
299 ['Height of the Bottem Ring:',h_br],
300 ['Thickness of the Bottem Ring:',t_br],
301 ['Height of the Top Ring:',h_tr],
302 ['Thickness of the Top Ring:',t_tr]])
303
304 w_st = float(res['Width of the Stiffener (circuference):'])
305 d_st = float(res['Width of the Stiffener (radial):'])
306 l_st = float(res['Length of the Stiffener:'])
307 t_st = float(res['Thickness of the Stiffener:'])
308 h_br = float(res['Height of the Bottem Ring:'])
309 t_br = float(res['Thickness of the Bottem Ring:'])
310 h_tr = float(res['Height of the Top Ring:'])
311 t_tr = float(res['Thickness of the Top Ring:'])
312
313 print "w_st: %s" %(w_st)
314 print "d_st: %s" %(d_st)
315 print "l_st: %s" %(l_st)
316 print "t_st: %s" %(t_st)
317 print "h_br: %s" %(h_br)
318 print "t_br: %s" %(t_br)
319 print "h_tr: %s" %(h_tr)
320 print "t_tr: %s" %(t_tr)
321
322 elif c_st == 'U':
323 res = askItems([
324 ['Height of the web of the U-shaped Stiffener (circumference):',w_st],
325 ['Width of the flange of the U-shaped Stiffener (radial):',d_st],
326 ['Length of the Stiffener:',l_st],
327 ['Thickness of the Stiffener:',t_st],
328 ['Height of the Bottem Ring:',h_br],
329 ['Thickness of the Bottem Ring:',t_br],
330 ['Height of the Top Ring:',h_tr],
331 ['Thickness of the Top Ring:',t_tr]])
332
333 w_st = float(res['Height of the web of the U-shaped Stiffener
(circumference):'])
334 d_st = float(res['Width of the flange of the U-shaped Stiffener
(radial):'])
335 l_st = float(res['Length of the Stiffener:'])
336 t_st = float(res['Thickness of the Stiffener:'])
337 h_br = float(res['Height of the Bottem Ring:'])
338 t_br = float(res['Thickness of the Bottem Ring:'])
-6-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
339 h_tr = float(res['Height of the Top Ring:'])
340 t_tr = float(res['Thickness of the Top Ring:'])
341
342 print "w_st: %s" %(w_st)
343 print "d_st: %s" %(d_st)
344 print "l_st: %s" %(l_st)
345 print "t_st: %s" %(t_st)
346 print "h_br: %s" %(h_br)
347 print "t_br: %s" %(t_br)
348 print "h_tr: %s" %(h_tr)
349 print "t_tr: %s" %(t_tr)
350
351 elif c_st == 'S':
352 res = askItems([
353 ['Offset from supportpoint:',w_st],
354 ['Height of the slanting Stiffener (radial):',d_st],
355 ['Height of the stiffend zone:',l_st],
356 ['Angle of the stiffer with the horizontal plane:',angle],
357 ['Thickness of the slanting Stiffener:',t_st],
358 ['Height of the Bottem Ring:',h_br],
359 ['Thickness of the Bottem Ring:',t_br],
360 ['Height of the Top Ring:',h_tr],
361 ['Thickness of the Top Ring:',t_tr]])
362
363 w_st = float(res['Offset from supportpoint:'])
364 d_st = float(res['Height of the slanting Stiffener (radial):'])
365 l_st = float(res['Height of the stiffend zone:'])
366 angle = float(res['Angle of the stiffer with the horizontal plane:'])
367 t_st = float(res['Thickness of the slanting Stiffener:'])
368 h_br = float(res['Height of the Bottem Ring:'])
369 t_br = float(res['Thickness of the Bottem Ring:'])
370 h_tr = float(res['Height of the Top Ring:'])
371 t_tr = float(res['Thickness of the Top Ring:'])
372
373 print "w_st: %s" %(w_st)
374 print "d_st: %s" %(d_st)
375 print "l_st: %s" %(l_st)
376 print "b_st: %s" %(angle)
377 print "h_br: %s" %(h_br)
378 print "t_br: %s" %(t_br)
379 print "h_tr: %s" %(h_tr)
380 print "t_tr: %s" %(t_tr)
381
382 elif support == 2:
383 c_st = 'None'
384 print "This option is not available for watertowers"
385
386 else:
387 print "Please select the type of construction"
388 if ack("Select the type of construction?"):
389 inputTypeOfConstruction()
390 inputStiffener()
391 else:
392 print "No stiffener has been defined"
393 b_Stiffener = False
394
395 def inputSector():
-7-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
396 global b_Sector, b_createMesh, sector,a
397
398 b_createMesh = False
399 b_feModel = True
400 b_Sector = True
401
402 if support == 1:
403 res = ask("What part of the shell must be put in model?", choices=['1/2
sector','1 sector (between two support points)','1 sector (one total support)',
'Whole shell'])
404 if res == '1/2 sector':
405 sector = 0
406 elif res == '1 sector (between two support points)':
407 sector = 1
408 elif res == '1 sector (one total support)':
409 sector = 2
410 elif res == 'Whole shell':
411 sector = 3
412
413 print "sector: %s" %(sector)
414
415 elif support == 2:
416 res = askItems([['Angle of the shell segment in degrees:',a]])
417
418 a = float(res['Angle of the shell segment in degrees:'])
419
420 print "a: %s" %(a)
421
422 else:
423 print "Please select the type of construction"
424 if ack("Select the type of construction?"):
425 inputTypeOfConstruction()
426 inputSector()
427 else:
428 print "No model has been defined"
429 b_Sector = False
430
431 def inputMaterial():
432 global b_Material, young, poisson, yields
433
434 b_Material = True
435
436 if support == 1:
437 res = askItems([
438 ['Young modulus Shell:',young[0]],
439 ['Poisson ratio Shell:',poisson[0]],
440 ['Yield stress Shell:',yields[0]],
441 ['Young modulus Stiffeners:',young[2]],
442 ['Poisson ratio Stiffeners:',poisson[2]],
443 ['Yield stress Stiffeners:',yields[2]]])
444
445 for i in range(2):
446 young[i] = float(res['Young modulus Shell:'])
447 poisson[i] = float(res['Poisson ratio Shell:'])
448 yields[i] = float(res['Yield stress Shell:'])
449
450 print "young[%s]: %s" %(i,young[i])
-8-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
451 print "poisson[%s]: %s" %(i,poisson[i])
452 print "yields[%s]: %s" %(i,yields[i])
453
454 for i in range(2,5):
455 young[i] = float(res['Young modulus Stiffeners:'])
456 poisson[i] = float(res['Poisson ratio Stiffeners:'])
457 yields[i] = float(res['Yield stress Stiffeners:'])
458
459 print "young[%s]: %s" %(i,young[i])
460 print "poisson[%s]: %s" %(i,poisson[i])
461 print "yields[%s]: %s" %(i,yields[i])
462
463 elif support == 2:
464 res = askItems([
465 ['Young modulus Shell:',young[0]],
466 ['Poisson ratio Shell:',poisson[0]],
467 ['Yield stress Shell:',yields[0]]])
468
469 for i in range(2):
470 young[i] = float(res['Young modulus Shell:'])
471 poisson[i] = float(res['Poisson ratio Shell:'])
472 yields[i] = float(res['Yield stress Shell:'])
473
474 print "young[%s]: %s" %(i,young[i])
475 print "poisson[%s]: %s" %(i,poisson[i])
476 print "yields[%s]: %s" %(i,yields[i])
477
478 else:
479 print "Please select the type of construction"
480 if ack("Select the type of construction?"):
481 inputTypeOfConstruction()
482 inputMaterial()
483 else:
484 print "No material has been defined"
485 b_Material = False
486
487 def inputLoads():
488 global b_Loads, a_load, u_load, h_load, loads
489
490 b_Loads = True
491
492 if support == 1:
493 res = askItems([['Total axial load [N]:',a_load]])
494 a_load = res['Total axial load [N]:']
495 h_load = 0
496
497 print "a_load: %s" %(a_load)
498
499 elif support == 2:
500 if a_load == 0:
501 a_load = 1000
502 if h_load == 0:
503 h_load == 9810
504
505 res = askItems([
506 ['Total axial load:',True],
507 ['Total axial load [N]:',a_load],
-9-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
508 ['Hydrostatic pressure:',False],
509 ['Density of the liquid [N/m3]:',h_load]])
510
511 if res['Total axial load:']:
512 a_load = res['Total axial load [N]:']
513 else:
514 a_load = 0
515
516 if res['Hydrostatic pressure:']:
517 h_load = res['Density of the liquid [N/m3]:']
518 else:
519 h_load = 0
520
521 if not res['Hydrostatic pressure:'] and not res['Total axial load:']:
522 print "No loads has been defined"
523 b_loads = False
524
525 else:
526 print "Please select the type of construction"
527 if ack("Select the type of construction?"):
528 inputTypeOfConstruction()
529 inputLoads()
530 else:
531 print "No loads has been defined"
532 b_Loads = False
533
534 def inputElements():
535 global typeOfElement
536
537 b_Elements = True
538
539 typeOfElement = ask("Select the type of elements", ['S4','S4R','S4R5'])
540
541 print "typeOfElement: %s" %(typeOfElement)
542
543 def inputMesh():
544 global b_Mesh, b_createMesh, ne_v1,ne_v2,ne_h, ne3, ne1, p_v,p_h,scale, algoritme
545
546 b_createMesh
547 b_Mesh = True
548 algoritme = 2
549
550 if not b_co and not b_cy:
551 print "Please select the type of construction"
552 if ack("Select the type of construction?"):
553 inputTypeOfConstruction()
554 else:
555 print "No mesh can be defined"
556 b_Mesh = False
557
558 elif b_Geometry == False:
559 print "Please define the geometry of the construction"
560 if ack("Select the geometry of the construction?"):
561 inputGeometry()
562 else:
563 print "No mesh can be defined"
564 b_Mesh = False
-10-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
565 else:
566
567 choice = ask("Select the type of mesh algorithm", ['Method 1','Method 2'])
568 if choice == 'Method 2':
569 algortime = 2
570 scale = 1.66
571 if b_co and b_cy:
572 res = askItems([
573 ['Total amount of elements in circular direction:',ne_h],
574 ['Total amount of elements in height (cylinder):',ne_v1],
575 ['Total amount of elements in height (cone):',ne_v2],
576 ['Uniform Mesh',False],
577 ['Scale factor between elements:',scale],
578 ['% zone 1-2 (vertical):',p_v],
579 ['% zone 1-3 (circular):',p_h]])
580
581 ne_h = res['Total amount of elements in circular direction:']
582 ne_v1 = res['Total amount of elements in height (cylinder):']
583 ne_v2 = res['Total amount of elements in height (cone):']
584 scale = res['Scale factor between elements:']
585 p_v = res['% zone 1-2 (vertical):']
586 p_h = res['% zone 1-3 (circular):']
587
588 print "algoritme: %s" %(algortime)
589 print "ne_h: %s" %(ne_h)
590 print "ne_v1: %s" %(ne_v1)
591 print "ne_v2: %s" %(ne_v2)
592 print "scale: %s" %(scale)
593 print "p_v: %s" %(p_v)
594 print "p_h: %s" %(p_h)
595
596 if not b_co and b_cy:
597 res = askItems([
598 ['Total amount of elements in circular direction:',ne_h],
599 ['Total amount of elements in height (cylinder):',ne_v1],
600 ['Uniform Mesh',False],
601 ['Scale factor between elements:',scale],
602 ['% zone 1-2 (vertical):',p_v],
603 ['% zone 1-3 (circular):',p_h]])
604
605 ne_h = res['Total amount of elements in circular direction:']
606 ne_v1 = res['Total amount of elements in height (cylinder):']
607 scale = res['Scale factor between elements:']
608 p_v = res['% zone 1-2 (vertical):']
609 p_h = res['% zone 1-3 (circular):']
610
611 print "ne_h: %s" %(ne_h)
612 print "ne_v1: %s" %(ne_v1)
613 print "p_v: %s" %(p_v)
614 print "p_h: %s" %(p_h)
615
616 if b_co and not b_cy:
617 res = askItems([
618 ['Total amount of elements in circular direction:',ne_h],
619 ['Total amount of elements in height (cone):',ne_v2],
620 ['Uniform Mesh',False],
621 ['Scale factor between elements:',scale],
-11-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
622 ['% zone 1-2 (vertical):',p_v],
623 ['% zone 1-3 (circular):',p_h]])
624
625 ne_h = res['Total amount of elements in circular direction:']
626 ne_v2 = res['Total amount of elements in height (cone):']
627 scale = res['Scale factor between elements:']
628 p_v = res['% zone 1-2 (vertical):']
629 p_h = res['% zone 1-3 (circular):']
630
631 print "ne_h: %s" %(ne_h)
632 print "ne_v2: %s" %(ne_v2)
633 print "p_v: %s" %(p_v)
634 print "p_h: %s" %(p_h)
635
636 else:
637 algoritme = 1
638 scale = 5
639 if b_co:
640 res = askItems([
641 ['Amount of elements of zone 1 in circular direction:',ne3],
642 ['Amount of elements of zone 1 in meridional direction:',ne1],
643 ['Amount of elements in height (cone):',ne_v2],
644 ['Uniform Mesh',False],
645 ['Ratio between amount of elements in other zones:',scale],
646 ['% zone 1-2 (vertical):',p_v],
647 ['% zone 1-3 (circular):',p_h]])
648
649 ne3 = res['Amount of elements of zone 1 in circular direction:']
650 ne1 = res['Amount of elements of zone 1 in meridional direction:']
651 ne_v2 = res['Amount of elements in height (cone):']
652 scale = res['Ratio between amount of elements in other zones:']
653 p_v = res['% zone 1-2 (vertical):']
654 p_h = res['% zone 1-3 (circular):']
655
656 print "algoritme: %s" %(algoritme)
657 print "ne3: %s" %(ne3)
658 print "ne1: %s" %(ne1)
659 print "ne_v2: %s" %(ne_v2)
660 print "p_v: %s" %(p_v)
661 print "p_h: %s" %(p_h)
662
663 else:
664 res = askItems([
665 ['Amount of elements of zone 1 in circular direction:',ne3],
666 ['Amount of elements of zone 1 in meridional direction:',ne1],
667 ['Uniform Mesh',False],
668 ['Ratio between amount of elements in other zones:',scale],
669 ['% zone 1-2 (vertical):',p_v],
670 ['% zone 1-3 (circular):',p_h]])
671
672 ne3 = res['Amount of elements of zone 1 in circular direction:']
673 ne1 = res['Amount of elements of zone 1 in meridional direction:']
674 scale = res['Ratio between amount of elements in other zones:']
675 p_v = res['% zone 1-2 (vertical):']
676 p_h = res['% zone 1-3 (circular):']
677
678 print "ne3 %s" %(ne3)
-12-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
679 print "ne1: %s" %(ne1)
680 print "p_v: %s" %(p_v)
681 print "p_h: %s" %(p_h)
682
683 if res['Uniform Mesh']:
684 scale = 1
685
686 print "scale: %s" %(scale)
687
688 def inputAnalysis():
689 global b_Analysis, typeOfAnalysis, typeOfSolver, parameters1, parameters2,
parameters3, lastmode, increments
690
691 b_Analysis = True
692
693 typeOfAnalysis = ask("Select the type of Analysis:", ['Perturbation','LBA','GNA',
'MNA','GMNA'])
694
695 if typeOfAnalysis.upper() == 'PERTURBATION':
696 typeOfAnalysis = 'PER'
697 return
698
699 elif typeOfAnalysis == 'LBA':
700 typeOfSolver = ask("Select the Eigensolver:", ['SUBSPACE','LANCZOS'])
701 if typeOfSolver == 'SUBSPACE':
702 lastmode = parameters1[0]
703 parameters = ['','','','']
704 res = askItems([
705 ['Number of eigenvalues to be estimated:',parameters1[0]],
706 ['Maximum eigenvalue of interest:',parameters1[1]],
707 ['Number of vectors used in the iteration:', parameters1[2]],
708 ['Maximum number of iterations:',parameters1[3]],
709 ['Create node file',True],
710 ['Number of last mode',lastmode]])
711
712 parameters[0]= res['Number of eigenvalues to be estimated:']
713 parameters[1]= res['Maximum eigenvalue of interest:']
714 parameters[2]= res['Number of vectors used in the iteration:']
715 parameters[3]= res['Maximum number of iterations:']
716
717 elif typeOfSolver == 'LANCZOS':
718 lastmode = parameters2[0]
719 parameters = ['','','','','']
720 res = askItems([
721 ['Number of eigenvalues to be estimated:',parameters2[0]],
722 ['Minimum eigenvalue of interest:',parameters2[1]],
723 ['Maximum eigenvalue of interest:',parameters2[2]],
724 ['Block size:', parameters2[3]],
725 ['Maximum number of block Lanczos steps:',parameters2[4]],
726 ['Create node file',True],
727 ['Number of last mode',lastmode]])
728
729 parameters[0] = res['Number of eigenvalues to be estimated:']
730 parameters[1] = res['Minimum eigenvalue of interest:']
731 parameters[2] = res['Maximum eigenvalue of interest:']
732 parameters[3] = res['Block size:']
733 parameters[4] = res['Maximum number of block Lanczos steps:']
-13-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
734
735 if res['Create node file']:
736 lastmode = res['Number of last mode']
737 else:
738 lastmode = None
739
740 elif typeOfAnalysis == 'GNA' or typeOfAnalysis == 'MNA' or typeOfAnalysis ==
'GMNA':
741 parameters = ['','','','','','','','']
742 res = askItems([
743 ['Maximum number of increments in a step:',increments],
744 ['Initial increment in arc length:',parameters3[0]],
745 ['Total arc length scale factor:',parameters3[1]],
746 ['Minimum arc length increment:',parameters3[2]],
747 ['Maximum arc length increment:', parameters3[3]],
748 ['Maximum value of the load proportionality factor:',parameters3[4]],
749 ['Node number for finishing displacement value:',parameters3[5]],
750 ['Degree of freedom:',parameters3[6]],
751 ['Value of the total displacement:',parameters3[7]]])
752
753 increments = res['Maximum number of increments in a step:']
754 parameters[0] = res['Initial increment in arc length:']
755 parameters[1] = res['Total arc length scale factor:']
756 parameters[2] = res['Minimum arc length increment:']
757 parameters[3] = res['Maximum arc length increment:']
758 parameters[4] = res['Maximum value of the load proportionality factor:']
759 parameters[5] = res['Node number for finishing displacement value:']
760 parameters[6] = res['Degree of freedom:']
761 parameters[7] = res['Value of the total displacement:']
762
763 else:
764 print "No analysis has been defined"
765 b_Analysis = False
766 return
767
768 for i in range(len(parameters)):
769 try:
770 if parameters[i] == '':
771 if typeOfAnalysis == 'LBA' and typeOfSolver == 'SUBSPACE':
772 parameters1[i]=parameters[i]
773 print "parameters1[%s]: %s" %(i,parameters1[i])
774 elif typeOfAnalysis == 'LBA'and typeOfSolver == 'LANCZOS':
775 parameters2[i]=parameters[i]
776 print "parameters2[%s]: %s" %(i,parameters2[i])
777 elif typeOfAnalysis == 'GNA' or typeOfAnalysis == 'NMA' or
typeOfAnalysis == 'GMNA':
778 parameters3[i]=parameters[i]
779 print "parameters3[%s]: %s" %(i,parameters3[i])
780 elif isinstance(eval(parameters[i]),float) or isinstance(eval(parameters[
i]),int):
781 if typeOfAnalysis == 'LBA' and typeOfSolver == 'SUBSPACE':
782 parameters1[i]=parameters[i]
783 print "parameters1[%s]: %s" %(i,parameters1[i])
784 elif typeOfAnalysis == 'LBA'and typeOfSolver == 'LANCZOS':
785 parameters2[i]=parameters[i]
786 print "parameters2[%s]: %s" %(i,parameters2[i])
787 elif typeOfAnalysis == 'GNA' or typeOfAnalysis == 'NMA' or
-14-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
typeOfAnalysis == 'GMNA':
788 parameters3[i]=parameters[i]
789 print "parameters3[%s]: %s" %(i,parameters3[i])
790 else:
791 raise Error
792 except:
793 print "Wrong input"
794 if ack("Select the type of analysis"):
795 inputAnalysis()
796 else:
797 return
798
799 def inputOutput():
800 global b_inputOutput, b_Analysis, output, freq, int_point
801 typesN = []
802 output = []
803 b_inputOutput = True
804
805 res = askItems([
806 ['Frequency of output',freq],
807 ['Displacements',True],
808 ['Concentrated Forces',True],
809 ['Stress components',True],
810 ['Element integration point for stress components',int_point],
811 ['Include history displacements',True]])
812
813 freq = float(res['Frequency of output'])
814
815 if res['Displacements']:
816 typesN.append('U')
817 if res['Concentrated Forces']:
818 typesN.append('CF')
819
820 if typesN != []:
821 for i,typeID in enumerate(typesN):
822 output.append(f2abq.Odb(type='field', frequency=freq, variable=None, kind
='node', ID=typeID))
823 b_inputOutput = True
824
825 if res['Stress components']:
826 int_point = int(res['Element integration point for stress components'])
827 output.append(f2abq.Odb(type='field', frequency=freq, variable=None, kind=
'element', IP=int_point, ID=['S']))
828 b_inputOutput = True
829
830 if res['Include history displacements']:
831 output.append(f2abq.Odb(type='history', variable=None, kind='node', ID=['U3',
'U2','U1']))
832 b_inputOutput = True
833
834 print output
835
836
837 ##############################
838 ### Creating the structure ###
839 ##############################
840
-15-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
841 def square(keuze='yz'):
842 """ Creating a square with size 1x1 in the selected plane """
843 if keuze == "xy" or keuze =="yx":
844 return Formex([[[0.,0.,0.],[1.,0.,0.],[1.,1.,0.],[0.,1.,0.]]])
845 elif keuze == "yz" or keuze =="zy":
846 return Formex([[[0.,0.,0.],[0.,1.,0.],[0.,1.,1.],[0.,0.,1.]]])
847 elif keuze == "zx" or keuze =="xz":
848 return Formex([[[0.,0.,0.],[1.,0.,0.],[1.,0.,1.],[0.,0.,1.]]])
849 else:
850 print "Wrong input of axis: default yz-square created"
851 return Formex([[[0.,0.,0.],[0.,1.,0.],[0.,1.,1.],[0.,0.,1.]]])
852
853 def createShell():
854 """ Creating a cylinder and/or cone with the Z-axis equal to the axis of
revolution """
855
856 global a, b_createMesh, p_v,p_h, ne1,ne3, ne_v1,ne_v2,ne_h, scale, algoritme,
meshGrid,w_st,w_su,l_st, angle
857
858 #define the angle and length of 1/2 sector
859 if support == 1:
860 a = 360./n_su/2. # angle of 1/2 sector
861 ls = math.radians(a)*r2 # length of 1/2 sector
862
863 ########################
864 # Define the mesh size #
865 # _______ _______ #
866 # | 2 | | | | #
867 # |_______| | 3 | 4 | #
868 # | 1 | | | | #
869 # |_______| |___|___| #
870 ########################
871
872 print algoritme
873
874 if support == 2:
875 scale = 1
876 le1 = h2*(1+p_v*(scale-1))/(ne_v1*scale)
877 ne1 = int(math.ceil(p_v*h2/le1))
878 ne2 = int(math.ceil((h2-ne1*le1)/(le1*scale)))
879 le2 = (h2-ne1*le1)/ne2
880 p_v = le1*ne1/h2
881
882 le3 = ls*(1+p_h*(scale-1))/(ne_h*scale)
883 ne3 = int(math.ceil(p_h*ls/le3))
884 ne4 = int(math.ceil((ls-ne3*le3)/(le3*scale)))
885 le4 = (ls-ne3*le3)/ne4
886 p_h = le3*ne3/ls
887
888 elif algoritme == 2:
889 le1 = h2*(1+p_v*(scale-1))/(ne_v1*scale)
890 ne_st_l = int(math.ceil(l_st/le1))
891 le1 = l_st/ne_st_l # length of the elements in vertical direction -
dense
892 ne1 = int(math.ceil(p_v*h2/le1)) # amount of elements in vertical direction -
dense
893 ne2 = int(math.ceil((h2-ne1*le1)/(le1*scale))) # amount of elements in vertical direction -
-16-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
wide
894 le2 = (h2-ne1*le1)/ne2 # length of the elements in vertical direction -
wide
895 p_v = le1*ne1/h2
896
897 le3 = ls*(1+p_h*(scale-1))/(ne_h*scale)
898 ne_s = int(math.ceil(w_su/2./le3))
899 if ne_s == 0: ne_s = 1
900 le3 = (w_su/2.)/ne_s # length of the elements in horizontal
direction - dense
901 ne3 = int(math.ceil(p_h*ls/le3)) # amount of elements in horizontal
direction - dense
902 ne4 = int(math.ceil((ls-ne3*le3)/(le3*scale))) # amount of elements in horizontal
direction - wide
903 le4 = (ls-ne3*le3)/ne4 # length of the elements in horizontal
direction - wide
904 p_h = le3*ne3/ls
905
906 if (w_st/2./le3 - int(w_st/2./le3)) < 0.5:
907 ne_st = int(w_st/2./le3)
908 w_st = ne_st*le3*2.
909 else:
910 ne_st = int(w_st/2./le3)+1
911 w_st = ne_st*le3*2.
912
913 ne_su = int(math.floor(w_su/2./le3 + 0.5))
914
915 if c_st == 'S':
916 le1 = le3 * math.tan(math.radians(angle))
917 l_st_s = math.sqrt(le1**2 + le3**2)
918 ne_st_l = int(math.ceil(l_st/le1))
919 if ne_st_l > ne3-ne_st:
920 ne_st_l = ne3-ne_st
921 l_st = le1*ne_st_l # length of the elements in vertical
direction - dense
922 ne1 = int(math.ceil(p_v*h2/le1)) # amount of elements in vertical
direction - dense
923 ne2 = int(math.ceil((h2-ne1*le1)/(le1*scale))) # amount of elements in vertical
direction - wide
924 le2 = (h2-ne1*le1)/ne2 # length of the elements in vertical
direction - wide
925 p_v = le1*ne1/h2
926 print "l_st_s: %s" %(l_st_s)
927 print "ne_st_l: %s" %(ne_st_l)
928 print "l_st: %s" %(l_st)
929 print "l_st_s: %s" %(l_st_s)
930
931 ne_st_d = int(math.ceil(d_st/le1))
932 le_st_d = d_st/ne_st_d
933
934
935 elif algoritme == 1:
936 print "ne1: %s" %(ne1)
937 print "ne3: %s" %(ne3)
938 print "p_v: %s" %(p_v)
939 print "p_h: %s" %(p_h)
940 print "scale: %s" %(scale)
-17-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
941
942 ne2 = 2*int(round(((ne1+1)/scale+1)/2))
943 ne4 = 2*int(round(((ne3+1)/scale+1)/2))
944
945 le1 = h2*p_v/ne1
946 le2 = h2*(1-p_v)/ne2
947 le3 = ls*p_h/ne3
948 le4 = ls*(1-p_h)/ne4
949
950 ne_st_l = int(l_st/le1+0.5)
951
952 ne_su = int(math.floor(w_su/2./le3 + 0.5))
953 ne_st = int(math.floor(w_st/2./le3 + 0.5))
954
955 if c_st == 'S':
956 le1 = le3 * math.tan(math.radians(angle))
957 l_st_s = math.sqrt(le1**2 + le3**2)
958 ne_st_l = int(math.ceil(l_st/le1))
959 if ne_st_l > ne3-ne_st:
960 ne_st_l = ne3-ne_st
961 l_st = le1*ne_st_l # length of the elements in vertical
direction - dense
962 ne1 = int(math.ceil(p_v*h2/le1)) # amount of elements in vertical
direction - dense
963 ne2 = int(math.ceil((h2-ne1*le1)/(le1*scale))) # amount of elements in vertical
direction - wide
964 le2 = (h2-ne1*le1)/ne2 # length of the elements in vertical
direction - wide
965 p_v = le1*ne1/h2
966
967
968
969 print "l_st_s: %s" %(l_st_s)
970 print "ne_st_l: %s" %(ne_st_l)
971 print "l_st: %s" %(l_st)
972 print "l_st_s: %s" %(l_st_s)
973
974
975 w_st = 2*ne_st*le3
976 w_su = 2*ne_su*le3
977
978 ne_st_d = 10 #int(math.ceil(d_st/le1))
979 le_st_d = d_st/ne_st_d
980
981 if support == 1 and ne_su == 0:
982 ne_su = 1
983 elif support == 2:
984 ne_su = 1
985 ne_st = 1
986 ne_st_l = 1
987 ne_st_d = 1
988 le_st_d =1
989
990 meshGrid = [ne1,le1,ne2,le2,ne3,le3,ne4,le4, ls,ne_st,ne_su, ne_st_l, ne_st_d,
le_st_d]
991 # 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 11 - 12 - 13
992
-18-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
993 if b_cy:
994 zone13 = square("yz").scale([1,le3,le1]).replic2(ne3,ne1,le3,le1,1,2,0,0).
setProp(0)
995 zone14 = square("yz").scale([1,le4,le1]).replic2(ne4,ne1,le4,le1,1,2,0,0).
setProp(0).translate([0.,p_h*ls,0.])
996 zone23 = square("yz").scale([1,le3,le2]).replic2(ne3,ne2,le3,le2,1,2,0,0).
setProp(0).translate([0.,0.,p_v*h2])
997 zone24 = square("yz").scale([1,le4,le2]).replic2(ne4,ne2,le4,le2,1,2,0,0).
setProp(0).translate([0.,p_h*ls,p_v*h2])
998
999 shell = zone13 + zone14 + zone23 + zone24
1000
1001 if support == 1 and (c_st == 'U' or c_st == 'R'):
1002 langs13 = square("xz").scale([le_st_d,1.,le1]).replic2(ne_st_d,ne_st_l,
le_st_d,le1,0,2)
1003 langs13 = langs13.translate([0.,ne_st*le3,0.]).setProp(2) #langsverstijver
1004
1005 if c_st == 'U' and w_st > 0.00001:
1006 langs13 += square("yz").scale([1.,le3,le1]).replic2(ne_st,ne_st_l,le3
,le1,1,2).translate([d_st,0.,0.]).setProp(2)
1007
1008 elif support == 1 and c_st == 'S':
1009 langs13 = square("xz").scale([le_st_d,1,l_st_s]).rotate(-angle,0).replic(
ne_st_d,le_st_d,0)
1010 langs13 = langs13.replic2(1,ne_st_l,le3,le1,1,2,le3).translate([0.,ne_st*
le3,0.]).setProp(2)
1011
1012 if support == 1:
1013 ring13 = square("xy").scale([le_st_d,le3,1.]).replic2(ne_st_d,ne3,le_st_d
,le3,0,1) #ringverstijver
1014 ring14 = square("xy").scale([le_st_d,le4,1.]).replic2(ne_st_d,ne4,le_st_d
,le4,0,1,0,0) #ringverstijver
1015 ring = ring13 + ring14.translate([0.,p_h*ls,0.])
1016
1017 stif = langs13
1018 stif += ring.setProp(3)
1019 stif += ring.translate([-ne_st_d*le_st_d,0,0]).setProp(3)
1020 stif += ring.translate([0,0,ne_st_l*le1]).setProp(4)
1021
1022 shell += stif
1023
1024 shell = shell.translate([r2,0,0])
1025
1026 if b_co:
1027 s_co = math.sqrt(h1**2 + (r2-r1)**2) # slant height s
1028 a_co = math.degrees(math.acos(h1/s_co)) # top angle [°] of a square triangle in the cone
1029 ne5 = ne_v2 # amount of elements in 'vertical' direction
1030 le5 = s_co/ne5 # length of the elements in 'vertical' direction
1031
1032 cone13 = square("yz").scale([1,le3,le5]).replic2(ne3,ne5,le3,le5,1,2,0,0).
setProp(1)
1033 cone14 = square("yz").scale([1,le4,le5]).replic2(ne4,ne5,le4,le5,1,2,0,0).
setProp(1).translate([0.,p_h*ls,0.])
1034 cone = cone13 + cone14
1035 cone = cone.rotate(a_co,1).translate([r1,0,0])
1036
1037 if b_cy:
-19-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1038 shell = shell.translate([0,0,h1]) + cone
1039 else:
1040 shell = cone
1041
1042 if sector == 1:
1043 shell += shell.reflect(1,ls)
1044 elif sector == 2:
1045 shell += shell.reflect(1,0)
1046 elif sector == 3:
1047 shell += shell.reflect(1,ls)
1048 shell = shell.replic(n_su,2*ls,1)
1049
1050 if b_cy or b_co:
1051 b_createMesh = True
1052 if sector == 0:
1053 return shell, shell.translate([0,ls*67.5/45.,0]).cylindrical([0,1,2],[1.,
a/ls,1.])
1054 elif sector == 1:
1055 return shell, shell.translate([0,ls,0]).cylindrical([0,1,2],[1.,a/ls,1.])
1056 elif sector == 2:
1057 return shell, shell.translate([0,2*ls,0]).cylindrical([0,1,2],[1.,a/ls,1.
])
1058 elif sector == 3:
1059 return shell, shell.cylindrical([0,1,2],[1.,a/ls,1.])
1060 else:
1061 b_createMesh = False
1062 b_feModel = True
1063 draw(shell)
1064 return Formex([[[]]]),Formex([[[]]])
1065
1066 def nodeSelector():
1067 global nodelist, nodes, elems, nodeprop, typeOfSupport, nodes_copy
1068
1069 starttime = time.clock()
1070
1071 nodeprop = zeros(len(nodes),int)
1072 lijst = []
1073 nodeLijst = []
1074 nodelist = zeros(16,int)
1075
1076 for i in range(len(nodelist)): # lijst & nodeLijst 0-4: top
1077 lijst.append([]) # lijst & nodeLijst 5: edge
1078 nodeLijst.append([]) # lijst & nodeLijst 6-10: support
1079
1080 #define the angle and length of 1/2 sector
1081 a = 360./n_su/2. # angle of 1/2 sector
1082 ls = math.radians(a)*r2 # length of 1/2 sectory
1083 h0 = 0
1084
1085 ne_breedte = meshGrid[9] #ne_st
1086 ne_hoogte = meshGrid[11] #ne_st_l
1087
1088 if support == 1:
1089 if b_co:
1090 h = h1 + h2
1091 h0 = h1
1092 else:
-20-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1093 h = h2
1094 h0 = 0
1095 print "Discrete %s support" %typeOfSupport
1096
1097 if meshGrid[9] == 0:
1098 ne_breedte = meshGrid[10]
1099 if meshGrid[11] == 0:
1100 ne_hoogte = meshGrid[0]/2
1101
1102 elif support == 2:
1103 h0 = 0
1104 h = h1
1105 if b_cy:
1106 h = h1+h2
1107 print "Continuous %s support" %typeOfSupport
1108
1109 if meshGrid[9] == 0:
1110 ne_breedte = meshGrid[4]/2
1111 if meshGrid[11] == 0:
1112 ne_hoogte = meshGrid[0]/2
1113
1114 if sector == 0:
1115
1116 for i in range(len(nodes)):
1117 if isClose(nodes[i,2],h):
1118 #knopen voor de bovenbelasting
1119 if isClose(nodes[i,1],0):
1120 # knoop linksbovenaan
1121 nodeprop[i] = 1
1122 lijst[0].append(i)
1123 elif isClose(nodes[i,1],ls):
1124 # knoop rechtsbovenaan
1125 nodeprop[i] = 5
1126 lijst[4].append(i)
1127 else:
1128 if nodes[i,1] <= p_h*ls * 0.99999:
1129 # knopen bovenaan de zone met fijne mesh
1130 nodeprop[i] = 2
1131 lijst[1].append(i)
1132 elif nodes[i,1] <= p_h*ls * 1.00001:
1133 # knoop overgang fijne en grove mesh
1134 nodeprop[i] = 3
1135 lijst[2].append(i)
1136 else:
1137 # knopen bovenaan de zone met grove mesh
1138 nodeprop[i] = 4
1139 lijst[3].append(i)
1140
1141 elif isClose(nodes[i,2],h0):
1142 # knopen voor de ondersteuning
1143 if support == 1: #discrete ondersteuning
1144 if typeOfSupport.upper() == "FLEXIBLE":
1145 # Flexibele ondersteuning
1146 if isClose(nodes[i,1],meshGrid[5]*meshGrid[9]):
1147 # knopen van de R-verstijver
1148 if isClose(nodes[i,0],r2):
1149 # knoop die aansluit met cilinderwand
-21-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1150 nodeprop[i] = 10
1151 lijst[9].append(i)
1152 elif isClose(nodes[i,0],r2+d_st):
1153 # knoop op uiteinde van R-verstijver
1154 nodeprop[i] = 12
1155 lijst[11].append(i)
1156 elif r2*1.00001 <= nodes[i,0] and nodes[i,0] <= (r2+d_st
)*0.99999:
1157 # overige knopen R-verstijver
1158 nodeprop[i] = 11
1159 lijst[10].append(i)
1160 elif meshGrid[9] == 0:
1161 # als de R-verstijver samenvalt met symmetrierand
1162 nodeprop[i] = 6
1163 lijst[5].append(i)
1164 elif isClose(nodes[i,0],r2):
1165 # knopen ondersteunde cilinderwand
1166 if isClose(nodes[i,1],0):
1167 # knoop midden van het steunpunt
1168 nodeprop[i] = 7
1169 lijst[6].append(i)
1170 elif isClose(nodes[i,1],meshGrid[5]*meshGrid[10]):
1171 # knoop uiteinde van het steunpunt
1172 nodeprop[i] = 9
1173 lijst[8].append(i)
1174 elif 0 <= nodes[i,0] and nodes[i,1] <= meshGrid[5]*
meshGrid[10]*0.99999:
1175 # overige knopen steunpunt
1176 nodeprop[i] = 8
1177 lijst[7].append(i)
1178 elif isClose(nodes[i,0],r2+d_st) and c_st == "U":
1179 # bijkomende knopen bij ondersteunde U-verstijver
1180 if isClose(nodes[i,1],0):
1181 # knoop midden van het steunpunt (midden lijfplaat U-verstijver)
1182 nodeprop[i] = 16
1183 lijst[15].append(i)
1184 elif nodes[i,1] < meshGrid[5]*meshGrid[9]*0.99999:
1185 # andere knopen lijfplaat U-verstijver
1186 nodeprop[i] = 15
1187 lijst[14].append(i)
1188 elif isClose(nodes[i,1],0) or isClose(nodes[i,1],ls):
1189 nodeprop[i] = 6
1190 lijst[5].append(i)
1191 else: # Rigide steunpunten
1192 if isClose(nodes[i,1],0):
1193 # knoop linkerrand
1194 nodeprop[i] = 7
1195 lijst[6].append(i)
1196 elif nodes[i,1] <= meshGrid[5]*meshGrid[10]*0.99999:
1197 # knopen tussen linkerrand en breedte steunpunt
1198 nodeprop[i] = 8
1199 lijst[7].append(i)
1200 elif nodes[i,1] <= meshGrid[5]*meshGrid[10]*1.00001:
1201 # knoop op breedte steunpunt
1202 nodeprop[i] = 9
1203 lijst[8].append(i)
1204 elif isClose(nodes[i,1],ls):
-22-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1205 # knoop rechterrand
1206 nodeprop[i] = 6
1207 lijst[5].append(i)
1208 elif support == 2:
1209 # voor continue ondersteuning
1210 if isClose(nodes[i,1],0):
1211 # knoop linkerrand
1212 nodeprop[i] = 7
1213 lijst[6].append(i)
1214 elif nodes[i,1] <= ls*0.99999:
1215 # knopen tussen de randen
1216 nodeprop[i] = 8
1217 lijst[7].append(i)
1218 elif isClose(nodes[i,1],ls):
1219 # knoop rechterrand
1220 nodeprop[i] = 7
1221 lijst[6].append(i)
1222
1223 elif isClose(nodes[i,1],0) or isClose(nodes[i,1],ls):
1224 # randen voor symmetrie
1225 nodeprop[i] = 6
1226 lijst[5].append(i)
1227
1228 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],ls-
meshGrid[7]) and isClose(nodes[i,2],h-meshGrid[3]):
1229 # vast punt bij flexibele ondersteuning
1230 nodeprop[i] = 13
1231 lijst[12].append(i)
1232
1233 elif isClose(nodes[i,0],r2) and (isClose(nodes[i,1], meshGrid[5] * math.
ceil(ne_breedte/2)) or isClose(nodes[i,1], meshGrid[5] * math.ceil(ne_breedte*3/2))
or isClose(nodes[i,1],ls-meshGrid[7]*2)):
1234 #knopen voor history output
1235 if isClose(nodes[i,2],meshGrid[1] * math.ceil(ne_hoogte/3)):
1236 nodeprop[i] = 14
1237 lijst[13].append(i)
1238 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*2/3)):
1239 nodeprop[i] = 14
1240 lijst[13].append(i)
1241 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*4/3)):
1242 nodeprop[i] = 14
1243 lijst[13].append(i)
1244
1245 elif sector == 1:
1246 for i in range(len(nodes)):
1247 if isClose(nodes[i,2],h):
1248 #knopen voor de bovenbelasting
1249 if isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):
1250 # knoop linksbovenaan en rechtsbovenaan
1251 nodeprop[i] = 1
1252 lijst[0].append(i)
1253 elif (nodes[i,1] <= meshGrid[4]*meshGrid[5]*0.99999) or (2*ls-
meshGrid[4]*meshGrid[5]*0.99999 <= nodes[i,1]):
1254 # knopen bovenaan de zone met fijne mesh
1255 nodeprop[i] = 2
1256 lijst[1].append(i)
1257 elif (nodes[i,1] <= meshGrid[4]*meshGrid[5]*1.00001) or (2*ls-
-23-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
meshGrid[4]*meshGrid[5]*1.00001 <= nodes[i,1]):
1258 #knopen overgang fijne en grove mesh
1259 nodeprop[i] = 3
1260 lijst[2].append(i)
1261 elif (meshGrid[4]*meshGrid[5]*1.00001 <= nodes[i,1]) and (nodes[i,1]
<= 2*ls-meshGrid[4]*meshGrid[5]*1.00001):
1262 # knopen bovenaan de zone met grove mesh
1263 nodeprop[i] = 4
1264 lijst[3].append(i)
1265
1266 elif isClose(nodes[i,2],h0):
1267 # knopen voor de ondersteuning
1268 if support == 1:
1269 # knopen voor discrete ondersteuning
1270 if typeOfSupport.upper() == "FLEXIBLE":
1271 # Flexibele ondersteuning
1272 if (isClose(nodes[i,1],meshGrid[5]*meshGrid[9])) or (isClose(
nodes[i,1],2*ls-meshGrid[5]*meshGrid[9])):
1273 # knopen van de R-verstijver
1274 if isClose(nodes[i,0],r2):
1275 # knoop die aansluit met cilinderwand
1276 nodeprop[i] = 10
1277 lijst[9].append(i)
1278 elif isClose(nodes[i,0],r2+d_st):
1279 # knoop op uiteinde van R-verstijer
1280 nodeprop[i] = 12
1281 lijst[11].append(i)
1282 elif r2*1.00001 <= nodes[i,0] and nodes[i,0] <= (r2+d_st
)*0.99999:
1283 # overige knopern R-verstijve
1284 nodeprop[i] = 11
1285 lijst[10].append(i)
1286 elif meshGrid[9] == 0:
1287 # als de R-verstijver samenvalt met symmetrierand
1288 nodeprop[i] = 6
1289 lijst[5].append(i)
1290
1291 elif isClose(nodes[i,0],r2):
1292 # knopen ondersteunde cilinderwand
1293 if (isClose(nodes[i,1],0)) or (isClose(nodes[i,1],2*ls)):
1294 # knoop midden van het steunpunt
1295 nodeprop[i] = 7
1296 lijst[6].append(i)
1297 elif (isClose(nodes[i,1],meshGrid[5]*meshGrid[10])) or (
isClose(nodes[i,1],2*ls-meshGrid[5]*meshGrid[10])):
1298 # knoop uiteinde van het steunpunt
1299 nodeprop[i] = 9
1300 lijst[8].append(i)
1301 elif (0 <= nodes[i,1] and nodes[i,1] <= meshGrid[5]*
meshGrid[10]*0.99999) or (2*ls-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1] and
nodes[i,1] <= 2*ls):
1302 # overige knopen steunpunt
1303 nodeprop[i] = 8
1304 lijst[7].append(i)
1305 elif isClose(nodes[i,0],r2+d_st) and c_st=='U':
1306 # bijkomende knopen bij ondersteunde U-verstijver
1307 if isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):
-24-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1308 nodeprop[i] = 16
1309 lijst[15].append(i)
1310 # knoop midden van het steunpunt (midden lijfplaat U-verstijver)
1311 elif (nodes[i,1] < meshGrid[5]*meshGrid[9]*0.99999) or (2
*ls-MeshGrid[5]*meshGrid[9]*0.99999 < nodes[i,1]):
1312 nodeprop[i] = 15
1313 lijst[14].append(i)
1314 # andere knopen lijfplaat U-verstijver
1315
1316 else:
1317 # Rigide steunpunten
1318 if isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):
1319 # knoop linkerrand en rechterrand
1320 nodeprop[i] = 7
1321 lijst[6].append(i)
1322 elif (nodes[i,1] <= meshGrid[5]*meshGrid[10]*0.99999) or (2*
ls-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1]):
1323 # knopen tussen linkerrand en breedte steunpunt en rechterrand en breedte steunpunt
1324 nodeprop[i] = 8
1325 lijst[7].append(i)
1326 elif (nodes[i,1] <= meshGrid[5]*meshGrid[10]*1.00001) or (2*
ls-meshGrid[5]*meshGrid[10]*1.00001 <= nodes[i,1]):
1327 # knoop op breedte steunpunten
1328 nodeprop[i] = 9
1329 lijst[8].append(i)
1330
1331 elif support == 2:
1332 # knopen voor continue ondersteuning
1333 if isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):
1334 # knoop rechterrand en linkerrand
1335 nodeprop[i] = 7
1336 lijst[6].append(i)
1337 else:
1338 # knopen tussen de randen
1339 nodeprop[i] = 8
1340 lijst[7].append(i)
1341
1342 elif isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):
1343 # randen voor symmetrie
1344 nodeprop[i] = 6
1345 lijst[5].append(i)
1346
1347 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],ls) and
isClose(nodes[i,2],h-meshGrid[3]):
1348 # vast punt bij flexibele ondersteuning
1349 nodeprop[i] = 13
1350 lijst[12].append(i)
1351
1352 elif isClose(nodes[i,0],r2) and (isClose(nodes[i,1], meshGrid[5] * math.
ceil(ne_breedte/2)) or isClose(nodes[i,1], 2*ls-meshGrid[5] * math.ceil(ne_breedte/2
)) or isClose(nodes[i,1], meshGrid[5] * math.ceil(ne_breedte*3/2)) or isClose(nodes[i
,1], 2*ls - meshGrid[5] * math.ceil(ne_breedte*3/2)) or isClose(nodes[i,1],ls)):
1353 #knopen voor history output
1354 if isClose(nodes[i,2],meshGrid[1] * math.ceil(ne_hoogte/3)):
1355 nodeprop[i] = 14
1356 lijst[13].append(i)
1357 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*2/3)):
-25-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1358 nodeprop[i] = 14
1359 lijst[13].append(i)
1360 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*4/3)):
1361 nodeprop[i] = 14
1362 lijst[13].append(i)
1363
1364
1365 elif sector == 2:
1366 for i in range(len(nodes)):
1367 if isClose(nodes[i,2],h):
1368 #knopen voor de bovenbelasting
1369 if isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls): # knoop linksbovenaan
en rechtsbovenaan
1370 nodeprop[i] = 5
1371 lijst[4].append(i)
1372 elif (-meshGrid[4]*meshGrid[5]*0.99999 <= nodes[i,1]) and (nodes[i,1]
<= meshGrid[4]*meshGrid[5]*0.99999):
1373 # knopen bovenaan de zone met fijne mesh
1374 nodeprop[i] = 2
1375 lijst[1].append(i)
1376 elif (-meshGrid[4]*meshGrid[5]*1.00001 <= nodes[i,1]) and (nodes[i,1]
<= meshGrid[4]*meshGrid[5]*1.00001):
1377 # knopen overgang fijne en grove mesh
1378 nodeprop[i] = 3
1379 lijst[2].append(i)
1380 elif (nodes[i,1] <= -meshGrid[4]*meshGrid[5]*1.00001) or (meshGrid[4
]*meshGrid[5]*1.00001 <= nodes[i,1]):
1381 # knopen bovenaan de zone met grove mesh
1382 nodeprop[i] = 4
1383 lijst[3].append(i)
1384
1385 elif isClose(nodes[i,2],h0):
1386 # knopen voor de ondersteuning
1387 if support == 1:
1388 # knopen voor discrete ondersteuning
1389 if typeOfSupport.upper() == "FLEXIBLE":
1390 # Flexibele ondersteuning
1391 if (isClose(nodes[i,1],meshGrid[5]*meshGrid[9])) or (isClose(
nodes[i,1],-meshGrid[5]*meshGrid[9])):
1392 # knopen van de R-verstijver
1393 if isClose(nodes[i,0],r2):
1394 # knoop die aansluit met cilinderwand
1395 nodeprop[i] = 10
1396 lijst[9].append(i)
1397 elif isClose(nodes[i,0],r2+d_st):
1398 # knoop op uiteinde van R-verstijver
1399 nodeprop[i] = 12
1400 lijst[11].append(i)
1401 elif r2*1.00001 <= nodes[i,0] and nodes[i,0] <= (r2+d_st
)*0.99999:
1402 # overige knopen R-verstijver
1403 nodeprop[i] = 11
1404 lijst[10].append(i)
1405 elif isClose(nodes[i,0],r2):
1406 # knopen ondersteunde cilinderwand
1407 if (isClose(nodes[i,1],-ls)) or (isClose(nodes[i,1],ls)):
1408 # knoop midden van het steunpunt
-26-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1409 nodeprop[i] = 6
1410 lijst[5].append(i)
1411 elif (isClose(nodes[i,1],meshGrid[5]*meshGrid[10])) or (
isClose(nodes[i,1],-meshGrid[5]*meshGrid[10])):
1412 # knoop uiteinde van het steunpunt
1413 nodeprop[i] = 9
1414 lijst[8].append(i)
1415 elif (-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1] and
nodes[i,1] <= meshGrid[5]*meshGrid[10]*0.99999):
1416 # overige knopen steunpunt
1417 nodeprop[i] = 8
1418 lijst[7].append(i)
1419 elif isClose(nodes[i,0],r2+d_st) and c_st=='U':
1420 # bijkomende knopen bij ondersteunde U-verstijver
1421 if (nodes[i,1] < meshGrid[5]*meshGrid[9]*0.99999) or (-
MeshGrid[5]*meshGrid[9]*0.99999 < nodes[i,1]):
1422 nodeprop[i] = 15
1423 lijst[14].append(i)
1424 # andere knopen lijfplaat U-verstijver
1425
1426 else:
1427 # Rigide steunpunten
1428 if isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls):
1429 # knoop linkerrand en rechterrand
1430 nodeprop[i] = 6
1431 lijst[5].append(i)
1432 elif (-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1]) and (
nodes[i,1] <= meshGrid[5]*meshGrid[10]*0.99999):
1433 # knopen tussen de verstijver
1434 nodeprop[i] = 8
1435 lijst[7].append(i)
1436 elif (-meshGrid[5]*meshGrid[10]*1.00001 <= nodes[i,1]) and (
nodes[i,1] <= meshGrid[5]*meshGrid[10]*1.00001):
1437 # knopen verstijver
1438 nodeprop[i] = 9
1439 lijst[8].append(i) # checken
1440
1441 elif support == 2:
1442 # voor continue ondersteuning
1443 if isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls):
1444 # knoop linkerrand en rechterrand
1445 nodeprop[i] = 7
1446 lijst[6].append(i)
1447 elif (-ls*0.99999 <= nodes[i,1]) and (nodes[i,1] <= ls*0.99999):
1448 # knopen tussen de randen
1449 nodeprop[i] = 8
1450 lijst[7].append(i)
1451
1452 elif isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls):
1453 # randen voor symmetrie
1454 nodeprop[i] = 6
1455 lijst[5].append(i)
1456
1457 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],0) and
isClose(nodes[i,2],h-meshGrid[3]):
1458 # vast punt bij flexibele ondersteuning
1459 nodeprop[i] = 13
-27-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1460 lijst[12].append(i)
1461
1462 elif isClose(nodes[i,0],r2) and (isClose(nodes[i,1], meshGrid[5] * math.
ceil(ne_breedte/2)) or isClose(nodes[i,1], -meshGrid[5] * math.ceil(ne_breedte/2)) or
isClose(nodes[i,1], meshGrid[5] * math.ceil(ne_breedte*3/2)) or isClose(nodes[i,1],
- meshGrid[5] * math.ceil(ne_breedte*3/2)) or isClose(nodes[i,1],ls)):
1463 #knopen voor history output
1464 if isClose(nodes[i,2],meshGrid[1] * math.ceil(ne_hoogte/3)):
1465 nodeprop[i] = 14
1466 lijst[13].append(i)
1467 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*2/3)):
1468 nodeprop[i] = 14
1469 lijst[13].append(i)
1470 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*4/3)):
1471 nodeprop[i] = 14
1472 lijst[13].append(i)
1473
1474 elif sector == 3:
1475 for i in range(len(nodes)):
1476 if isClose(nodes[i,2],h):
1477 #knopen voor de bovenbelasting
1478 for j in range(n_su+1):
1479 if (j*ls*2-meshGrid[4]*meshGrid[5]*0.99999 <= nodes[i,1]) and (
nodes[i,1] <= j*ls*2+meshGrid[4]*meshGrid[5]*0.99999):
1480 # knopen bovenaan de zone met fijne mesh
1481 nodeprop[i] = 2
1482 lijst[1].append(i)
1483 elif (j*ls*2-meshGrid[4]*meshGrid[5]*1.00001 <= nodes[i,1]) and (
nodes[i,1] <= j*ls*2+meshGrid[4]*meshGrid[5]*1.00001):
1484 # knopen overgang fijne en grove mesh
1485 nodeprop[i] = 3
1486 lijst[2].append(i)
1487 elif (j*ls*2-ls*1.00001 <= nodes[i,1]) and (nodes[i,1] <= 2*j*ls+
ls*1.00001):
1488 # knopen bovenaan de zone met grove mesh
1489 nodeprop[i] = 4
1490 lijst[3].append(i)
1491
1492
1493 elif isClose(nodes[i,2],h0):
1494 # knopen voor de ondersteuning
1495 if support == 1:
1496 # knopen voor discrete ondersteuning
1497 if typeOfSupport.upper() == "FLEXIBLE":
1498 # knopen voor flexibele ondersteuning
1499 for j in range(n_su+1):
1500 if (isClose(nodes[i,1],j*ls*2-meshGrid[5]*meshGrid[9]))
or (isClose(nodes[i,1],j*ls*2+meshGrid[5]*meshGrid[9])):
1501 # knopen van de R-verstijver
1502 if isClose(nodes[i,0],r2):
1503 # knoop die aansluit met cilinderwand
1504 nodeprop[i] = 10
1505 lijst[9].append(i)
1506 elif isClose(nodes[i,0],r2+d_st):
1507 # knoop op uiteinde van R-verstijver
1508 nodeprop[i] = 12
1509 lijst[11].append(i)
-28-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1510 elif r2*1.00001 <= nodes[i,0] and nodes[i,0] <= (r2+
d_st)*0.99999:
1511 # overige knopen R-verstijver
1512 nodeprop[i] = 11
1513 lijst[10].append(i)
1514 elif isClose(nodes[i,0],r2):
1515 # knopen ondersteunde cilinderwand
1516 if (j*ls*2-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[
i,1]) and (nodes[i,1] <= j*ls*2+meshGrid[5]*meshGrid[10]*0.99999):
1517 # knopen tussen breedte steunpunt
1518 nodeprop[i] = 8
1519 lijst[7].append(i)
1520 elif (j*ls*2-meshGrid[5]*meshGrid[10]*1.00001 <=
nodes[i,1]) and (nodes[i,1] <= j*ls*2+meshGrid[5]*meshGrid[10]*1.00001):
1521 # knopen breedte steunpunt
1522 nodeprop[i] = 9
1523 lijst[8].append(i)
1524 elif isClose(nodes[i,0],r2+d_st) and c_st=='U':
1525 # bijkomende knopen bij ondersteunde U-verstijver
1526 if (j*ls*2-MeshGrid[5]*meshGrid[9]*0.99999 < nodes[i
,1]) and (nodes[i,1] < j*ls*2+meshGrid[5]*meshGrid[9]*0.99999):
1527 # knopen tussen breedte steunpunt
1528 nodeprop[i] = 15
1529 lijst[14].append(i)
1530 else:
1531 # Rigide steunpunten
1532 for j in range(n_su+1):
1533 if (j*ls*2-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1
]) and (nodes[i,1] <= j*ls*2+meshGrid[5]*meshGrid[10]*0.99999):
1534 # knopen tussen de verstijver
1535 nodeprop[i] = 8
1536 lijst[7].append(i)
1537 elif (j*ls*2-meshGrid[5]*meshGrid[10]*1.00001 <= nodes[i,
1]) and (nodes[i,1] <= j*ls*2+meshGrid[5]*meshGrid[10]*1.00001):
1538 # knopen verstijver
1539 nodeprop[i] = 9
1540 lijst[8].append(i)
1541
1542 elif support == 2:
1543 # knopen voor continue ondersteuning
1544 nodeprop[i] = 8
1545 lijst[7].append(i)
1546
1547 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],0) and
isClose(nodes[i,2],h-meshGrid[3]):
1548 # vast punt bij flexibele ondersteuning
1549 nodeprop[i] = 13
1550 lijst[12].append(i)
1551
1552 elif isClose(nodes[i,0],r2) and (isClose(nodes[i,1], 0) or isClose(nodes[
i,1], meshGrid[5] * math.ceil(ne_breedte/2)) or isClose(nodes[i,1], meshGrid[5] *
math.ceil(ne_breedte*3/2)) or isClose(nodes[i,1],ls)):
1553 #knopen voor history output
1554 if isClose(nodes[i,2],meshGrid[1] * math.ceil(ne_hoogte/3)):
1555 nodeprop[i] = 14
1556 lijst[13].append(i)
1557 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*2/3)):
-29-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1558 nodeprop[i] = 14
1559 lijst[13].append(i)
1560 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*4/3)):
1561 nodeprop[i] = 14
1562 lijst[13].append(i)
1563
1564 if sector == 0:
1565 nodes_copy = nodes.translate([0,ls*67.5/45.,0]).cylindrical([0,1,2],[1.,a/ls,
1.])
1566 elif sector == 1:
1567 nodes_copy = nodes.translate([0,ls,0]).cylindrical([0,1,2],[1.,a/ls,1.])
1568 elif sector == 2:
1569 nodes_copy = nodes.translate([0,2*ls,0]).cylindrical([0,1,2],[1.,a/ls,1.])
1570 elif sector == 3:
1571 nodes_copy = nodes.cylindrical([0,1,2],[1.,a/ls,1.])
1572
1573
1574 for i in range(len(nodelist)):
1575 if lijst[i] != []:
1576 print "nodelist number %s not empty" %i
1577 nodelist[i]=1
1578 for j in lijst[i]:
1579 nodeLijst[i].append(nodes_copy[j])
1580 if len(nodeLijst[i]) != 0:
1581 draw(Formex(nodeLijst[i]).setProp(i))
1582 zoomAll()
1583
1584 def setMaterial():
1585 global support, plasticity, t1, t2, t_st, t_tr, t_br, typeOfElement, b_cy, b_co
1586
1587 thickness=[]
1588 mat = []
1589 steel = []
1590 section = []
1591
1592 thickness.append(t2)
1593 thickness.append(t1)
1594
1595 mat.append({'name': 'cylinder','sectiontype': 'shell','thickness': thickness[0]})
1596 mat.append({'name': 'cone','sectiontype': 'shell','thickness': thickness[1]})
1597
1598 if support == 1:
1599 thickness.append(t_st)
1600 thickness.append(t_tr)
1601 thickness.append(t_br)
1602 mat.append({'name': 'stiffener', 'sectiontype': 'shell','thickness':
thickness[2]})
1603 mat.append({'name': 'bottem_ring','sectiontype': 'shell','thickness':
thickness[3]})
1604 mat.append({'name': 'top_ring','sectiontype': 'shell','thickness': thickness[
4]})
1605
1606 for i in range(len(mat)):
1607 if plasticity:
1608 steel.append({'name': 'steel_%s' %mat[i]['name'],'young_modulus': young[i
],'poisson_ratio': poisson[i],'yield_stress': yields[i],'plastic_strain': 0})
1609 else:
-30-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1610 steel.append({'name': 'steel_%s' %mat[i]['name'],'young_modulus': young[i
],'poisson_ratio': poisson[i]})
1611
1612 section.append(properties.ElemSection(section=mat[i],material=steel[i]))
1613 properties.ElemProperty(i, section[i], elemtype=typeOfElement)
1614
1615 f2abq.elemproperties = properties.elemproperties
1616
1617 def setLoadsAndBoundaries():
1618 global a_load, loads, typeOfSupport, nodelist
1619
1620 coordSet = [0,0,0,0,0,1]
1621 boundSet = [[0]*6]*len(nodelist)
1622 cloadSet = [[0.0]*6]*len(nodelist)
1623
1624 if a_load != 0:
1625 sectorload = a_load/n_su/2. # load per sector
1626 load3 = sectorload/meshGrid[8]*meshGrid[5]
1627 load4 = sectorload/meshGrid[8]*meshGrid[7]
1628
1629 if sector == 0 or sector == 1:
1630 cloadSet[0] = [0.0,0.0,-load3/2.0,0.0,0.0,0.0]
1631
1632 cloadSet[1] = [0.0,0.0,-load3,0.0,0.0,0.0]
1633 cloadSet[2] = [0.0,0.0,-load3/2.0-load4/2.0,0.0,0.0,0.0]
1634 cloadSet[3] = [0.0,0.0,-load4,0.0,0.0,0.0]
1635
1636 if sector == 0 or sector == 2:
1637 cloadSet[4] = [0.0,0.0,-load4/2.0,0.0,0.0,0.0]
1638
1639 if typeOfSupport == 'Flexible':
1640 if c_st == 'U':
1641 tot = sectorload/(t2*meshGrid[5]*meshGrid[10]+t_st*meshGrid[13]*
meshGrid[12]+t_st*meshGrid[5]*meshGrid[9])
1642 loadCy = tot*t2*meshGrid[5]
1643 loadSt = tot*t_st*meshGrid[13]
1644 loadU = tot*t_st*meshGrid[5]
1645 if meshGrid[9] == 0:
1646 loadU = 0
1647
1648 cloadSet[11] = [0.0,0.0,loadSt/2.0+loadU/2.0,0.0,0.0,0.0]
1649 cloadSet[14] = [0.0,0.0,loadU,0.0,0.0,0.0]
1650 cloadSet[15] = [0.0,0.0,loadU/2.0,0.0,0.0,0.0]
1651
1652 else:
1653 tot = sectorload/(t2*meshGrid[5]*meshGrid[10]+t_st*meshGrid[13]*
meshGrid[12])
1654 loadCy = tot*t2*meshGrid[5]
1655 loadSt = tot*t_st*meshGrid[13]
1656
1657 cloadSet[11] = [0.0,0.0,loadSt/2.0,0.0,0.0,0.0]
1658
1659 cloadSet[6] = cloadSet[8] = [0.0,0.0,loadCy/2.0,0.0,0.0,0.0]
1660 cloadSet[7] = [0.0,0.0,loadCy,0.0,0.0,0.0]
1661 cloadSet[9] = [0.0,0.0,loadCy+loadSt/2.0,0.0,0.0,0.0]
1662 if meshGrid[9] ==0 or meshGrid[9] == meshGrid[10]:
1663 cloadSet[9] = [0.0,0.0,loadCy/2.+loadSt/2.,0.0,0.0,0.0]
-31-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1664 cloadSet[10] = [0.0,0.0,loadSt,0.0,0.0,0.0]
1665
1666 if support == 1:
1667 boundSet[0] = boundSet[4] = [1,1,0,1,0,1] # zasymm + ysymm
1668 boundSet[1] = boundSet[2] = boundSet[3] = [1,1,0,0,0,1] # zasymm
1669 boundSet[5] = [0,1,0,1,0,1] # ysymm
1670
1671 if typeOfSupport == 'Rigid':
1672 boundSet[6] = [1,1,1,1,0,1] # ysymm + zasymm + scharnierend
1673 boundSet[7] = boundSet[8] = [1,1,1,0,0,1] # zasymm + scharnierend
1674 elif typeOfSupport == 'Flexible':
1675 boundSet[6] = [1,1,0,1,0,1] # ysymm + zasymm + scharnierend
1676 boundSet[7] = boundSet[8] = boundSet[9] = boundSet[10] = boundSet[11] =
boundSet[14] = boundSet[15] = [1,1,0,0,0,1] # zasymm + scharnierend
1677 #boundSet[4] = [1,1,1,1,0,1] # rechterbovenhoek vast punt
1678 boundSet[12] = [0,0,1,0,0,0] # apart gedefiniëerd vast punt
1679 if meshGrid[9] == 0: #ne_st == 0
1680 boundSet[9] = boundSet[10] = boundSet[11] = [1,1,0,1,0,1] # zasymm + ysymm
1681
1682 elif support == 2:
1683 boundSet[0] = boundSet[4] = boundSet[5] = [0,1,0,1,0,1] # ysymm
1684
1685 if typeOfSupport == 'Pinned':
1686 boundSet[6] = boundSet[9] = [1,1,1,1,0,1] # ysymm + Scharnierend
1687 boundSet[7] = [1,1,1,0,0,0] # Scharnierend
1688 elif typeOfSupport == 'Encastre':
1689 boundSet[6] = boundSet[7] = [1,1,1,1,1,1] # Ingeklemd
1690
1691 for i in range(len(nodelist)):
1692 if nodelist[i] == 1:
1693 properties.NodeProperty(i+1,cload=cloadSet[i], bound=boundSet[i], coords=
"cylindrical", coordset=coordSet)
1694 f2abq.nodeproperties = properties.nodeproperties
1695
1696 def setAnalysis():
1697 global typeOfAnalysis, typeOfSolver, lastmode, parameters1, parameters2,
parameters3, plasticity, increments
1698
1699 analysis = []
1700 if typeOfAnalysis == None:
1701 typeOfAnalysis = 'PER'
1702
1703 if typeOfAnalysis.upper() == 'PER':
1704 analysis.append(f2abq.Analysis(analysistype='PERTURBATION'))
1705 plasticity = False
1706
1707 elif typeOfAnalysis.upper() == 'LBA':
1708 if typeOfSolver.upper() == 'SUBSPACE':
1709 analysis.append(f2abq.Analysis(analysistype = "BUCKLE", kind=typeOfSolver
, time=parameters1, nf=lastmode))
1710 elif typeOfSolver.upper() == 'LANCZOS':
1711 analysis.append(f2abq.Analysis(analysistype = "BUCKLE", kind=typeOfSolver
, time=parameters2, nf=lastmode))
1712 plasticity = False
1713
1714 elif typeOfAnalysis.upper() == 'GNA':
1715 analysis.append(f2abq.Analysis(analysistype = "STATIC", kind='RIKS', time=
-32-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
parameters3, nlgeom="YES", incr=increments))
1716 plasticity = False
1717
1718 elif typeOfAnalysis.upper() == 'MNA':
1719 analysis.append(f2abq.Analysis(analysistype = "STATIC", kind='RIKS', time=
parameters3, nlgeom="NO", incr=increments))
1720 plasticity = True
1721
1722 elif typeOfAnalysis.upper() == 'GMNA':
1723 analysis.append(f2abq.Analysis(analysistype = "STATIC", kind='RIKS', time=
parameters3, nlgeom="YES", incr=increments))
1724 plasticity = True
1725
1726 else:
1727 print "No analysis has been defined"
1728 return []
1729
1730 return analysis
1731
1732 def setHeader():
1733 global b_co,b_cy,support,n_su,w_su,r1,h1,t1,r2,h2,t2,c_st,w_st,d_st,t_st, meshGrid
1734
1735 tekst = """**
1736 ** Properties
1737 ** ----------"""
1738 if b_cy:
1739 tekst +="""
1740 ** Geometry cylinder
1741 ** Radius = %s mm
1742 ** Height = %s mm
1743 ** Thickness = %s mm
1744 **
1745 ** Number of supportpoints = %s
1746 ** Width of supportpoints = %s mm
1747 **""" %(r2*1000,h2*1000,t2*1000,n_su,w_su*1000)
1748
1749 if b_co:
1750 tekst +="""
1751 ** Geometry cone
1752 ** Radius = %s mm
1753 ** Height = %s mm
1754 ** Thickness = %s mm""" %(r1*1000,h1*1000,t1*1000)
1755
1756 if support == 1:
1757 tekst +="""
1758 ** Geometry %s-stiffener
1759 ** Length = %s mm
1760 ** Width (radial direction) = %s mm
1761 ** Width (circumferencial direction) = %s mm
1762 ** Thickness = %s mm""" %(c_st,l_st*1000,d_st*1000,w_st*1000,t_st*1000)
1763
1764 if a_load != 0:
1765 tekst +="""
1766 **
1767 ** Total load on the full cylinder = %s N""" %(a_load)
1768 if h_load != 0:
1769 tekst +="""
-33-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1770 ** Density of the liquid in the watertower = %s N/m³""" %(h_load)
1771
1772 tekst +="""
1773 ** Type of analysis = %s""" %(typeOfAnalysis)
1774 if typeOfAnalysis == "LBA":
1775 if typeOfSolver == "SUBSPACE":
1776 tekst += """
1777 ** EIGENSOLVER = SUBSPACE
1778 ** %s, %s, %s, %s""" %(parameters1[0],parameters1[1],parameters1[2],parameters1[3])
1779 elif typeOfSolver == "LANCZOS":
1780 tekst += """
1781 ** EIGENSOLVER = LANCZOS
1782 ** %s, %s, %s, %s, %s""" %(parameters2[0],parameters2[1],parameters2[2],parameters2
[3],parameters2[4])
1783 elif typeOfAnalysis != "PER":
1784 tekst += """
1785 ** Riks
1786 ** %s, %s, %s, %s, %s, %s, %s, %s""" %(parameters3[0],parameters3[1],parameters3[2
],parameters3[3],parameters3[4],parameters3[5],parameters3[6],parameters3[7])
1787
1788 tekst +="""
1789 ** Young modulus shell = %s MPa
1790 ** Young modulus stiffeners = %s MPa
1791 **""" %(young[0]/10.**6, young[2]/10.**6)
1792
1793 if plasticity:
1794 tekst +="""
1795 ** Yield stress shell = %s MPa
1796 ** Yield stress stiffeners = %s MPa
1797 **""" %(yields[0]/10.**6, yields[2]/10.**6)
1798
1799 tekst +="""** --------------------------------------------------
1800 ** Mesh-Info
1801 ** Number of elements support = %s
1802 ** Number of elements width stiffener = %s
1803 ** Number of elements length stiffener = %s
1804 ** Number of elements depth stiffener = %s
1805 ** length element depth stiffener = %s
1806 **
1807 ** %s x length element 1 = %s mm = %s mm
1808 ** %s x length element 2 = %s mm = %s mm
1809 ** %s x length element 3 = %s mm = %s mm
1810 ** %s x length element 4 = %s mm = %s mm
1811 **
1812 ** --------------------------------------------------""" %(meshGrid[10],meshGrid[9],
meshGrid[11],meshGrid[12],meshGrid[13],meshGrid[0],meshGrid[1]*1000,meshGrid[0]*
meshGrid[1]*1000,meshGrid[2],meshGrid[3]*1000,meshGrid[2]*meshGrid[3]*1000,meshGrid[4
],meshGrid[5]*1000,meshGrid[4]*meshGrid[5]*1000,meshGrid[6],meshGrid[7]*1000,meshGrid
[6]*meshGrid[7]*1000)
1813
1814 return tekst
1815
1816
1817 #######################################
1818 ### Writing the INP-file for ABAQUS ###
1819 #######################################
1820
-34-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1821 # Running with menu
1822 def selector(nr):
1823 global b_TypeOfConstruction, b_Geometry, b_Support, b_Stiffener, b_Sector,
b_Material, b_Loads, b_Mesh, b_Analysis, b_createMesh
1824
1825 if nr == 0:
1826 if b_TypeOfConstruction and b_Geometry and b_Support and b_Stiffener and
b_Sector and b_Mesh:
1827 return True
1828 else:
1829 return False
1830
1831 if nr == 1 or nr == 3:
1832 if not b_TypeOfConstruction:
1833 inputTypeOfConstruction()
1834 if not b_Geometry:
1835 inputGeometry()
1836 if not b_Support:
1837 inputSupport()
1838 if not b_Stiffener:
1839 inputStiffener()
1840 if not b_Sector:
1841 inputSector()
1842 if not b_Mesh:
1843 inputMesh()
1844
1845 if nr == 2:
1846 if selector(0) and b_Material and b_Loads and b_Analysis:
1847 return True
1848 else:
1849 return False
1850
1851 if nr == 3:
1852 if not b_Material:
1853 inputMaterial()
1854 if not b_Loads:
1855 inputLoads()
1856 if not b_Analysis:
1857 inputAnalysis()
1858
1859
1860 def do_feModel():
1861 global temp, nodes, elems
1862 nodes,elems = temp.feModel()
1863 print "#nodes: %s and #elems: %s " %(len(nodes),len(elems))
1864 print "Mesh generated in %s seconds." % (time.clock()-starttime)
1865 b_feModel = True
1866
1867 def createMesh():
1868 global b_createMesh
1869 print selector(0)
1870 if selector(0):
1871 global b_cy, b_co, sector, support, loads, temp, shell, nodes, elems
1872 clear()
1873 starttime = time.clock()
1874 temp, shell = createShell()
1875 draw(shell,view="iso")
-35-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1876 b_createMesh = True
1877 else:
1878 if ack("Query additional information?"):
1879 selector(1)
1880 createMesh()
1881 else:
1882 b_createMesh = False
1883 return
1884
1885 def writeInputFile():
1886 global filename,nodes_copy,elems,shell,b_inputOutput, b_createMesh, typeOfAnalysis
1887
1888 elemprop = shell.p
1889 analysis = setAnalysis()
1890 setMaterial()
1891 setLoadsAndBoundaries()
1892 model = f2abq.Model(nodes_copy,[elems],nodeprop,elemprop)
1893
1894 field_outp1 = f2abq.Odb(type='field', frequency=5, variable=None, kind='node', ID
=['U','CF'])
1895 field_outp2 = f2abq.Odb(type='field', frequency=5, variable=None, kind='element',
IP=3, ID=['S'])
1896
1897 if typeOfAnalysis == 'LBA':
1898 output=[field_outp1,field_outp2]
1899 else:
1900 hist_outp = f2abq.Odb(type='history', frequency=None, variable=None, kind=
'node', set=[14], ID=['U3','U2','U1'])
1901 output=[field_outp1,field_outp2,hist_outp]
1902
1903 if b_inputOutput == False:
1904 inputOutput()
1905 abqdata = f2abq.AbqData(model, analysis=analysis, odb=output)
1906 text = setHeader()
1907 f2abq.writeAbqInput(abqdata,filename,text)
1908 #zoomAll()
1909 print "Inputfile is written"
1910
1911 def createFile():
1912 global b_createMesh, b_feModel, name, filename
1913
1914 name = "inputfile"
1915 res = askItems([['Filename:',name],['Datestamp',False],['Timestamp',False]])
1916 name = res['Filename:']
1917 if not res['Datestamp'] and res['Timestamp']:
1918 filename = name + datetime.now().strftime("_%Hh%M")
1919 elif res['Datestamp'] and not res['Timestamp']:
1920 filename = name + datetime.now().strftime("_%y%m%d")
1921 elif res['Datestamp'] and res['Timestamp']:
1922 filename = name + datetime.now().strftime("_%y%m%d_%Hh%M")
1923 else:
1924 filename = name
1925
1926 if not b_createMesh:
1927 createMesh()
1928 if not b_createMesh:
1929 return
-36-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1930 if not selector(2):
1931 selector(3)
1932 if not selector(2):
1933 return
1934
1935 if not b_feModel:
1936 do_feModel()
1937
1938 nodeSelector()
1939 writeInputFile()
1940
1941
1942 class psf:
1943
1944 def __init__(self):
1945 """Create and start a timer."""
1946 self.jobs = """import os\n"""
1947 self.script = ''
1948
1949 def addJob(self,dir,job):
1950 self.jobs += """os.system('abq671 job=%s interactive cpus=4')
1951 os.system('md "%s"')
1952 os.system('move %s.* "%s"')
1953 """ %(job,dir,job,dir)
1954
1955 def addScript(self,script):
1956 self.script = """os.system('abq671 script=%s')""" %(script)
1957
1958 def writeJobs(self,fn):
1959 if not fn.endswith('.psf'):
1960 fn +=".psf"
1961 fil = file(fn,'w')
1962 fil.write(self.jobs)
1963 if self.script != '':
1964 fil.write(self.script)
1965 fil.close()
1966
1967 class info:
1968
1969 def __init__(self):
1970 """Create and start a timer."""
1971 self.info = """Information file
1972 """
1973
1974 def addInfo(self,tekst):
1975 self.info += """%s
1976 """ %(tekst)
1977
1978 def clearInfo(self):
1979 self.info = """Information file
1980 """
1981
1982 def writeInfo(self,fn):
1983 if not fn.endswith('.info'):
1984 fn +=".info"
1985 fil = file(fn,'w')
1986 fil.write(self.info)
-37-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
1987 fil.close()
1988
1989 #####################
1990 ### Main sequence ###
1991 #####################
1992
1993 def resetProperties():
1994 properties.nodeproperties = properties.CascadingDict()
1995 properties.elemproperties = properties.CascadingDict()
1996
1997 def loopParameter():
1998 global sector, n_su, b_cy, b_co, parameters1, parameters2, parameters3,
increments, lastmode, analysis, r2, h2, t2, w_su, w_st, l_st, d_st, h_tr, h_br, t_st,
t_tr, t_br, c_st, typeOfSupport, typeOfAnalysis, ne_v1, ne_h1, scale, p_v, p_h,
filename, directory
1999
2000 psfFile = psf()
2001 infoFile = info()
2002 loopVerstijver = []
2003
2004 verstijvers = ['R','U']
2005 tos = ['Rigid','Flexible']
2006 analyses = ['GMNA']
2007
2008
2009 sector = 0
2010 n_su = 4
2011 b_cy = True
2012 b_co = False
2013 parameters1 = ['5','','20','50']
2014 parameters2 = ['5','0.005','','','']
2015 parameters3 = ['0.3','1','0.001','3','600','','','']
2016 increments = 75
2017 lastmode = 5
2018 analysis = []
2019
2020 r2 = 0.350
2021 h2 = 1.400
2022 t2 = 0.0007
2023 l_st = 0.160
2024 d_st = h_tr = h_br = 0.020
2025 t_st = t_tr = t_br = 0.0015
2026 c_st = 'U'
2027 typeOfSupport = 'Flexible'
2028 typeOfAnalysis = 'GMNA'
2029
2030 aantalIteraties = 2
2031 for i,c_st in enumerate(verstijvers):
2032 for k in range(aantalIteraties):
2033 b_createMesh = False
2034 p_v = 0.50
2035 p_h = 0.75
2036 w_su = 0.050
2037 if aantalIteraties == 1:
2038 w_st = 0.
2039 else:
2040 w_st=float(k)/float(aantalIteraties-1)*w_su
-38-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
2041
2042 createMesh()
2043
2044 for j,typeOfSupport in enumerate(tos):
2045 clear()
2046 draw(shell,view="iso")
2047 nodeSelector()
2048 val = float(GD.cfg['gui/panfactor']) * GD.canvas.camera.getDist()*20
2049 GD.canvas.camera.translate(-val,-val,0,GD.cfg['draw/localaxes'])
2050 GD.canvas.zoom(1./(5*float(GD.cfg['gui/zoomfactor'])))
2051 GD.canvas.update()
2052
2053 filename = "%s_%s_%s_%s" %(typeOfAnalysis,typeOfSupport,c_st,int(w_st
/w_su*100))
2054 image.saveImage("Screenshot_%s.png" %(filename))
2055 directory = "d:\\Wouter\\Parameterstudie4\\S4R5\\%s_%s\\%s" %(
typeOfSupport,c_st,filename)
2056 writeInputFile()
2057 resetProperties()
2058 #infoFile.addInfo("---------- %s %s %s -------------" %(typeOfSupport, c_st, k))
2059 #infoFile.addInfo(f2abq.nodeproperties)
2060 #infoFile.writeInfo("test_%s.info" %i)
2061 #infoFile.clearInfo()
2062
2063 psfFile.addJob(directory,filename)
2064 psfFile.addScript("copy_5")
2065 psfFile.writeJobs("copy_4")
2066 return
2067
2068 for y in range(1):
2069 scale = 1.5 + 0.5*y
2070 scale = 3
2071
2072 for z in range(1):
2073 ne_v1 = 300
2074 ne_v2 = 0
2075 ne_h = 110
2076 p_v = 0.50
2077 p_h = 0.75
2078
2079 for i,c_st in enumerate(verstijvers):
2080 psfFile = psf()
2081 b_createMesh = False
2082
2083 for j,w_st in enumerate(loopVerstijver):
2084 b_createMesh = False
2085
2086 for i,typeOfSupport in enumerate(tos):
2087
2088 clear()
2089 if not b_createMesh:
2090 createMesh()
2091 draw(shell,view="iso")
2092 nodeSelector()
2093 properties.reset()
2094 image.saveImage("Screenshot_%s_%s_%s_%s.png" %(typeOfSupport,
c_st,scale,int(p_v*100)))
-39-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
2095
2096 for k,analyse in enumerate(analyses):
2097 if analyse == 'SUBSPACE':
2098 typeOfAnalysis = "LBA"
2099 typeOfSolver = "SUBSPACE"
2100 filename = typeOfAnalysis +"_"+str(j) +"_"+
typeOfSolver +"_"+ typeOfSupport +"_"+ c_st
2101 elif analyse == 'LANCZOS':
2102 typeOfAnalysis = "LBA"
2103 typeOfSolver = "LANCZOS"
2104 filename = typeOfAnalysis +"_"+str(j) +"_"+
typeOfSolver +"_"+ typeOfSupport +"_"+ c_st
2105 else:
2106 typeOfAnalysis = analyse
2107 filename = typeOfAnalysis +"_"+str(j) +"_"+
typeOfSupport +"_"+ c_st+"_"+ str(scale) +"_"+ str(int(p_v*100))
2108
2109 directory = "d:\\Wouter\\" + typeOfAnalysis +
"_analysis\\" + filename
2110 psfFile.addJob(directory,filename)
2111 print "Writing %s-analysis" %typeOfAnalysis
2112 print "Verhouding %s/%s" %(w_st,w_su)
2113 writeInputFile()
2114
2115
2116 psfFile.addScript("Reeks_%s" %(i+2))
2117 psfFile.writeJobs("Reeks_%s" %(i+1))
2118
2119 return
2120
2121
2122 def create_menu():
2123 """Create the menu."""
2124 MenuData = [
2125 ("Type of &Construction", inputTypeOfConstruction),
2126 ("&Geometry", inputGeometry),
2127 ("&Support", inputSupport),
2128 ("S&tiffeners", inputStiffener),
2129 ("Shell mo&del", inputSector),
2130 ("&---",None),
2131 ("&Material", inputMaterial),
2132 ("&Loads", inputLoads),
2133 ("&Elements", inputElements),
2134 ("M&esh", inputMesh),
2135 ("Type of &Analysis", inputAnalysis),
2136 ("&Output",inputOutput),
2137 ("---",None),
2138 ("&Create Mesh",createMesh),
2139 ("&Create Inputfile",createFile),
2140 #("&---",None),
2141 #("&Variate parameter",loopParameter),
2142 ("&---",None),
2143 ("C&lose",close_menu)]
2144
2145 return widgets.Menu('S&hell',items=MenuData,parent=GD.gui.menu,before='help')
2146
2147 def close_menu():
-40-
F:\enkele geometriën\shell.py maandag 2 juni 2008 16:58
2148 """Close the Formex menu."""
2149 m = GD.gui.menu.item('S&hell')
2150 if m:
2151 m.remove()
2152 #clear()
2153
2154 def show_menu():
2155 """Show the Formex menu."""
2156 if not GD.gui.menu.item('S&hell'):
2157 create_menu()
2158
2159 if __name__ == "draw":
2160
2161 show_menu()
2162
2163 ###########
2164 ### End ###
2165 ###########
2166
-41-
Bijlage 5: Figuren van structuren in pyFormex
Bijlage 5: Figuren van structuren in pyFormex
Bijlage 5: Figuren van structuren in pyFormex
Figuren van structuren in pyFormex
E
Figuren van structuren in pyFormex
Bij
lag
e 6
: R
an
dvo
orw
aa
rde
n v
oo
r d
e k
no
pe
n
F
Bij
lag
e 6
: R
an
dv
oo
rw
aa
rd
en
vo
or
de
kn
op
en
Sil
o
Wa
tert
ore
n
pro
p
kle
ur
Nse
t O
msc
hri
jvin
g
Loa
d
Rig
id
Fle
xib
le
Pin
ne
d
En
cast
re
1
Zw
art
0
B
ove
nra
nd
[0
,0,-
loa
d3
/2,0
,0,0
] [1
,1,0
,1,0
,1]
[1,1
,0,1
,0,1
] [0
,1,0
,1,0
,1]
[0,1
,0,1
,0,1
]
2
Ro
od
1
B
ove
nra
nd
[0
,0,-
loa
d3
,0,0
,0]
[1,1
,0,0
,0,1
] [1
,1,0
,0,0
,1]
/ /
3
Gro
en
2
B
ove
nra
nd
[0
,0,-
loa
d3
/2-l
oa
d4
/2,0
,0,0
] [1
,1,0
,0,0
,1]
[1,1
,0,0
,0,1
] /
/
4
Bla
uw
3
B
ove
nra
nd
[0
,0,-
loa
d4
,0,0
,0]
[1,1
,0,0
,0,1
] [1
,1,0
,0,0
,1]
/ /
5
Cy
an
4
B
ove
nra
nd
[0
,0,-
loa
d4
/2,0
,0,0
] [1
,1,0
,1,0
,1]
[1,1
,0,1
,0,1
] [0
,1,0
,1,0
,1]
[0,1
,0,1
,0,1
]
6
Ro
ze
5
Me
rid
ion
ale
ra
nd
/
[0,1
,0,1
,0,1
] [0
,1,0
,1,0
,1]
[0,1
,0,1
,0,1
] [0
,1,0
,1,0
,1]
7
Ge
el
6
Ste
un
pu
nt
sch
aa
l [
0,0
,lo
ad
Cy
/2,0
,0,0
] [1
,1,1
,1,0
,1]
[1,1
,0,1
,0,1
] [1
,1,1
,1,0
,1]
[1,1
,1,1
,1,1
]
8
Wit
7
S
teu
np
un
t sc
ha
al
[0
,0,l
oa
dC
y,0
,0,0
] [1
,1,1
,0,0
,1]
[1,1
,0,0
,0,1
] [1
,1,1
,0,0
,0]
[1,1
,1,1
,1,1
]
9
Zw
art
8
S
teu
np
un
t sc
ha
al
[0
,0,l
oa
dC
y/2
,0,0
,0]
[1,1
,1,0
,0,1
] [1
,1,0
,0,0
,1]
/ /
10
R
oo
d
9
Ste
un
pu
nt
R
[0
,0,l
oa
dC
y/2
+ l
oa
dS
t/2
,0,0
,0]
/ [1
,1,0
,0,0
,1]
/ /
11
G
roe
n
10
S
teu
np
un
t R
[
0,0
,lo
ad
St,
0,0
,0]
/ [1
,1,0
,0,0
,1]
/ /
12
B
lau
w
11
S
teu
np
un
t R
[
0,0
,lo
ad
U/2
+ lo
ad
St/
2,0
,0,0
] /
[1,1
,0,0
,0,1
] /
/
13
C
ya
n
12
V
ast
kn
oo
p
/ /
[0,0
,1,0
,0,0
] /
/
14
R
oze
1
3
His
tory
kn
op
en
/
/
/
/
/
15
G
ee
l 1
4
Ste
un
pu
nt
U
[0
,0,l
oa
dU
,0,0
,0]
/ [1
,1,0
,0,0
,1]
/ /
16
w
it
15
S
teu
np
un
t U
[
0,0
,lo
ad
U/2
,0,0
,0]
/ [1
,1,0
,0,0
,1]
/ /
Op
me
rkin
g:
Loa
d:
[a,b
,c,d
,e,f
,g]
Bo
un
d:
[h,i
,j,k
,l,m
]
•
a,b
,c:
kra
cht
vo
lge
ns
de
x,
y, z
-as
•
e,f
,g:
mo
me
nt
om
d
e x
, y
, z-
as
•
h,i
,j:
verp
laa
tsin
g v
olg
en
s d
e x
, y
, z-
as
•
k,l
,m:
ho
ek
rota
tie
om
d
e x
, y
, z-
as
•
0:
de
vri
jhe
idsg
raa
d w
ord
t n
iet
verh
ind
erd
•
1:
de
vri
jhe
idsg
raa
d i
s v
erh
ind
erd
C:\Documents and Settings\Wouter\Bureaublad\GMNA_Flexible_U_100.inp maandag 2 juni 2008 17:05
1 ** Abaqus input file created by pyFormex (c) B.Verhegghe
2 ** (see http://pyformex.berlios.de)
3 **
4 *HEADING
5 **
6 ** Properties
7 ** ----------
8 ** Geometry cylinder
9 ** Radius = 350.0 mm
10 ** Height = 1400.0 mm
11 ** Thickness = 0.7 mm
12 **
13 ** Number of supportpoints = 4
14 ** Width of supportpoints = 68.7223392973 mm
15 **
16 ** Geometry U-stiffener
17 ** Length = 280.0 mm
18 ** Width (radial direction) = 20.0 mm
19 ** Width (circumferencial direction) = 68.7223392973 mm
20 ** Thickness = 1.5 mm
21 **
22 ** Total load on the full cylinder = 1000.0 N
23 ** Type of analysis = GMNA
24 ** Riks
25 ** 0.3, 1, 0.001, 3, 600, , ,
26 ** Young modulus shell = 200000.0 MPa
27 ** Young modulus stiffeners = 200000.0 MPa
28 **
29 ** Yield stress shell = 240.0 MPa
30 ** Yield stress stiffeners = 240.0 MPa
31 **** --------------------------------------------------
32 ** Mesh-Info
33 ** Number of elements support = 18
34 ** Number of elements width stiffener = 18
35 ** Number of elements length stiffener = 80
36 ** Number of elements depth stiffener = 10
37 ** length element depth stiffener = 0.002
38 **
39 ** 200 x length element 1 = 3.5 mm = 700.0 mm
40 ** 120 x length element 2 = 5.83333333333 mm = 700.0 mm
41 ** 108 x length element 3 = 1.90895386937 mm = 206.167017892 mm
42 ** 22 x length element 4 = 3.12374269533 mm = 68.7223392973 mm
43 **
44 ** --------------------------------------------------
45 *NODE, NSET=Nall
46 1, 1.262855e-01, 3.048803e-01, 0.000000e+00
47 ...
48 48193, -1.339392e-01, 3.233579e-01, 1.400000e+00
49 *NSET,NSET=Nset_1
50 48063,
51 *TRANSFORM, NSET=Nset_1, TYPE=C
52 0,0,0,0,0,1
53 *NSET,NSET=Nset_2
54 48064,48065,48066,48067,48068,48069,48070,48071,48072,48073,
55 ...
56 48164,48165,48166,48167,48168,48169,48171,
57 *TRANSFORM, NSET=Nset_2, TYPE=C
-1-
C:\Documents and Settings\Wouter\Bureaublad\GMNA_Flexible_U_100.inp maandag 2 juni 2008 17:05
58 0,0,0,0,0,1
59 *NSET,NSET=Nset_3
60 48170,
61 *TRANSFORM, NSET=Nset_3, TYPE=C
62 0,0,0,0,0,1
63 *NSET,NSET=Nset_4
64 48172,48173,48174,48175,48176,48177,48178,48179,48180,48181,
65 ...
66 48192,
67 *TRANSFORM, NSET=Nset_4, TYPE=C
68 0,0,0,0,0,1
69 *NSET,NSET=Nset_5
70 48193,
71 *TRANSFORM, NSET=Nset_5, TYPE=C
72 0,0,0,0,0,1
73 *NSET,NSET=Nset_6
74 1,2,3,4,5,6,7,8,9,10,
75 ...
76 47800,47801,47802,48059,48060,
77 *TRANSFORM, NSET=Nset_6, TYPE=C
78 0,0,0,0,0,1
79 *NSET,NSET=Nset_7
80 14,
81 *TRANSFORM, NSET=Nset_7, TYPE=C
82 0,0,0,0,0,1
83 *NSET,NSET=Nset_8
84 62,72,74,77,148,156,160,161,222,226,
85 227,293,296,298,301,371,373,
86 *TRANSFORM, NSET=Nset_8, TYPE=C
87 0,0,0,0,0,1
88 *NSET,NSET=Nset_10
89 368,
90 *TRANSFORM, NSET=Nset_10, TYPE=C
91 0,0,0,0,0,1
92 *NSET,NSET=Nset_11
93 367,369,370,379,380,381,382,394,399,
94 *TRANSFORM, NSET=Nset_11, TYPE=C
95 0,0,0,0,0,1
96 *NSET,NSET=Nset_12
97 391,
98 *TRANSFORM, NSET=Nset_12, TYPE=C
99 0,0,0,0,0,1
100 *NSET,NSET=Nset_14
101 6768,6841,10902,10972,20050,20086,
102 *TRANSFORM, NSET=Nset_14, TYPE=C
103 0,0,0,0,0,1
104 *NSET,NSET=Nset_15
105 95,97,98,103,179,181,182,187,245,246,
106 251,325,330,333,336,393,398,
107 *TRANSFORM, NSET=Nset_15, TYPE=C
108 0,0,0,0,0,1
109 *NSET,NSET=Nset_16
110 20,
111 *TRANSFORM, NSET=Nset_16, TYPE=C
112 0,0,0,0,0,1
113 *ELEMENT, TYPE=S4R5, ELSET=Eset_0_0
114 1, 14, 74, 2761, 2753
-2-
C:\Documents and Settings\Wouter\Bureaublad\GMNA_Flexible_U_100.inp maandag 2 juni 2008 17:05
115 ...
116 41600, 48062, 48059, 48193, 48192
117 *ELSET, ELSET=Eall
118 Eset_0_0
119 *ELSET, ELSET=Eset_0
120 Eset_0_0
121 *ELEMENT, TYPE=S4R5, ELSET=Eset_0_2
122 41601, 368, 367, 2819, 2817
123 ...
124 43840, 15404, 15401, 15409, 15406
125 *ELSET, ELSET=Eall
126 Eset_0_2
127 *ELSET, ELSET=Eset_2
128 Eset_0_2
129 *ELEMENT, TYPE=S4R5, ELSET=Eset_0_3
130 43841, 14, 13, 65, 74
131 ...
132 46440, 2729, 2737, 2731, 2728
133 *ELSET, ELSET=Eall
134 Eset_0_3
135 *ELSET, ELSET=Eset_3
136 Eset_0_3
137 *ELEMENT, TYPE=S4R5, ELSET=Eset_0_4
138 46441, 15154, 15156, 15174, 15173
139 ...
140 47740, 16748, 16749, 16753, 16752
141 *ELSET, ELSET=Eall
142 Eset_0_4
143 *ELSET, ELSET=Eset_4
144 Eset_0_4
145 *MATERIAL, NAME=steel_cylinder
146 *ELASTIC
147 200000000000.0,0.3
148 *PLASTIC
149 240000000.0,0.0
150 *SHELL SECTION, ELSET=Eset_0, MATERIAL=steel_cylinder
151 0.0007
152 *MATERIAL, NAME=steel_cone
153 *ELASTIC
154 200000000000.0,0.3
155 *PLASTIC
156 240000000.0,0.0
157 *SHELL SECTION, ELSET=Eset_1, MATERIAL=steel_cone
158 0.0007
159 *MATERIAL, NAME=steel_stiffener
160 *ELASTIC
161 200000000000.0,0.3
162 *PLASTIC
163 240000000.0,0.0
164 *SHELL SECTION, ELSET=Eset_2, MATERIAL=steel_stiffener
165 0.0015
166 *MATERIAL, NAME=steel_bottem_ring
167 *ELASTIC
168 200000000000.0,0.3
169 *PLASTIC
170 240000000.0,0.0
171 *SHELL SECTION, ELSET=Eset_3, MATERIAL=steel_bottem_ring
-3-
C:\Documents and Settings\Wouter\Bureaublad\GMNA_Flexible_U_100.inp maandag 2 juni 2008 17:05
172 0.0015
173 *MATERIAL, NAME=steel_top_ring
174 *ELASTIC
175 200000000000.0,0.3
176 *PLASTIC
177 240000000.0,0.0
178 *SHELL SECTION, ELSET=Eset_4, MATERIAL=steel_top_ring
179 0.0015
180 *BOUNDARY
181 Nset_1, 1
182 Nset_1, 2
183 Nset_1, 4
184 Nset_1, 6
185 Nset_2, 1
186 Nset_2, 2
187 Nset_2, 6
188 Nset_3, 1
189 Nset_3, 2
190 Nset_3, 6
191 Nset_4, 1
192 Nset_4, 2
193 Nset_4, 6
194 Nset_5, 1
195 Nset_5, 2
196 Nset_5, 3
197 Nset_5, 4
198 Nset_5, 6
199 Nset_6, 2
200 Nset_6, 4
201 Nset_6, 6
202 Nset_7, 1
203 Nset_7, 2
204 Nset_7, 4
205 Nset_7, 6
206 Nset_8, 1
207 Nset_8, 2
208 Nset_8, 6
209 Nset_10, 1
210 Nset_10, 2
211 Nset_10, 6
212 Nset_11, 1
213 Nset_11, 2
214 Nset_11, 6
215 Nset_12, 1
216 Nset_12, 2
217 Nset_12, 6
218 Nset_15, 1
219 Nset_15, 2
220 Nset_15, 6
221 Nset_16, 1
222 Nset_16, 2
223 Nset_16, 6
224 *STEP, NLGEOM=YES, INCR=75
225 *STATIC, RIKS
226 0.3,1,0.001,3,600,,,
227 *BOUNDARY, TYPE=DISPLACEMENT, OP=MOD
228 *CLOAD, OP=NEW
-4-
C:\Documents and Settings\Wouter\Bureaublad\GMNA_Flexible_U_100.inp maandag 2 juni 2008 17:05
229 Nset_1, 3, -0.434027777778
230 Nset_2, 3, -0.868055555556
231 Nset_3, 3, -1.14425505051
232 Nset_4, 3, -1.42045454545
233 Nset_5, 3, -0.710227272727
234 Nset_7, 3, 0.790918787136
235 Nset_8, 3, 1.58183757427
236 Nset_10, 3, 3.35749700704
237 Nset_11, 3, 3.55131886554
238 Nset_12, 3, 3.47048540521
239 Nset_15, 3, 3.38965194487
240 Nset_16, 3, 1.69482597244
241 *DLOAD, OP=NEW
242 *OUTPUT, FIELD, frequency=5
243 *NODE OUTPUT, NSET=Nall
244 U
245 CF
246 *OUTPUT, FIELD, frequency=5
247 *ELEMENT OUTPUT, ELSET=Eall
248 3
249 S
250 *OUTPUT, HISTORY
251 *NODE OUTPUT, NSET=Nset_14
252 U3
253 U2
254 U1
255 *END STEP
-5-
Bijlage 8: Parameterstudie H
Bijlage 8: Parameterstudie
Tabellen
Bezwijkbelastingen voor cilinder 1
Verhouding
-verstijver
U-verstijver
Rigide Flexibel Rigide Flexibel
0% 74,6 66,9 74,6 66,9
8% 74,9 66,9 75,2 65,7
23% 75,7 66,9 76,5 63,8
31% 76,4 67,0 76,9 63,2
38% 77,1 67,6 78,2 63,1
54% 78,6 69,5 79,5 63,5
62% 79,4 69,8 80,9 64,1
69% 80,2 71,8 81,8 64,8
77% 81,0 73,2 82,8 66,1
92% 83,0 76,4 85,2 68,9
100% 84,0 78,6 86,5 70,6
Bijlage 8: Parameterstudie
ijlage 8: Parameterstudie
Verplaatsingen
Flexibele
R-
Verstijvingsratio
Verplaatsingen
Flexibele ondersteuning
U
Verstijvingsratio
Verplaatsingen
Rigide
R-
Verstijvingsratio
Verplaatsingen
Rigid
U
Verstijvingsratio
H
Verplaatsingen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Verplaatsingen
Flexibele ondersteuning
U-vormige verstijver
Verstijvingsratio 100%
Verplaatsingen
Rigide ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Verplaatsingen
Rigide ondersteuning
U-vormige verstijver
Verstijvingsratio 100%
Bijlage 8: Parameterstudie
Bijlage 8: Parameterstudie
S22
spanningen volgens de z
Flexibele ondersteuning
R-
Verstijvingsratio
S22
spanningen volgens de z
Flexibele ondersteuning
U
Verstijvin
S22
spanningen volgens de z
Rigide
R-
Verstijvingsratio
S22
spanningen volgens de z
Rigide
U
Verstijvingsratio
H
S22
spanningen volgens de z-as
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 100%
S22
spanningen volgens de z-as
Flexibele ondersteuning
U-vormige verstijver
Verstijvingsratio 100%
S22
spanningen volgens de z-as
Rigide ondersteuning
-vormige verstijver
Verstijvingsratio 100%
S22
spanningen volgens de z-as
Rigide ondersteuning
U-vormige verstijver
Verstijvingsratio 100%
Bijlage 8: Parameterstudie
Bijlage 8: Parameterstudie
Von Mises spanningen
Flexibele onde
R-
Verstijvingsratio
Von Mises spanningen
Flexibele ondersteuning
U
Verstijvingsratio
Von Mises spanningen
Rigide
R-
Verstijvingsratio
Von Mises spa
Rigide
U
Verstijvingsratio
H
Von Mises spanningen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Von Mises spanningen
Flexibele ondersteuning
U-vormige verstijver
Verstijvingsratio 100%
Von Mises spanningen
Rigide ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Von Mises spanningen
Rigide ondersteuning
U-vormige verstijver
Verstijvingsratio 100%
Bijlage 8: Parameterstudie H
Cilinder 2
Bezwijkbelastingen voor cilinder 2
Verhouding R-verstijver U-verstijver
Rigide Flexibel Rigide Flexibel
0% 91,8 87,3 91,8 87,3
11% 92,3 87,4 91,9 84,9
22% 93,1 87,8 91,9 83,4
33% 94,7 88,7 93,2 82,6
39% 95,7 89,7 94,0 82,5
50% 97,9 92,1 96,7 84,1
61% 101,0 95,4 99,9 86,6
72% 103,0 99,5 104,0 90,0
83% 105,0 104,0 109,0 94,2
94% 103,0 103,0 115,0 99,5
100% 101,0 102,0 117,0 103,0
Bijlage 8: Parameterstudie
Bijlage 8: Parameterstudie
Verplaatsingen
Flexib
R-
Verstijvingsratio 0%
Verplaatsingen
Flexibele ondersteuning
R-
Verstijvingsratio
Verplaatsingen
Flexibele ondersteuning
R-
Verstijvingsratio
H
Verplaatsingen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 0%
Verplaatsingen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 83%
Verplaatsingen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Bijlage 8: Parameterstudie
Bijlage 8: Parameterstudie
S22
spanninge
Flexibele ondersteuning
R-
Verstijvingsratio 0%
S22
spanningen volgens de z
Flexibele ondersteuning
R-
Verstijvingsratio
S22
spanningen volgens de z
Flexibele ondersteuning
R-
Verstijvingsratio
H
S22
spanningen volgens de z-as
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 0%
S22
spanningen volgens de z-as
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 83%
S22
spanningen volgens de z-as
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Bijlage 8: Parameterstudie
Bijlage 8: Parameterstudie
Von Mises spanningen
Flexibele ondersteuning
R-
Verstijvingsratio 0%
Von Mises spanningen
Flexibele ondersteuning
R-
Verstijvingsratio
S22
spanningen volgens de
Flexibele ondersteuning
R-
Verstijvingsratio
H
Von Mises spanningen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 0%
Von Mises spanningen
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 83%
S22
spanningen volgens de z-as
Flexibele ondersteuning
-vormige verstijver
Verstijvingsratio 100%
Referenties I
Referenties
[1] ECCS, Buckling of Steel Shells: European Recommendations, 5th Edition, Recommenda-
tions: Liquid-filled conical shells supported from below, under preparation.
[2] EN 1993-1-6, Eurocode 3:Design of steel structures-part 1-6: Strength and Stability of
Shell Structures, CEN, European Committee for Standardization, Central Secretariat: rue
de Stassart 36, (2007).
[3] Vandepitte, D., Van den Steen, A., Van Impe, R, Lagae, G and Rathé, J., Elastic and
elastic-plastic buckling of liquid-filled conical shells, Buckling of Structures; Theory and
Experiment; The Josef Singer Anniversary Volume, pp. 443-449, Elsevier Science Publi-
eshers, Amsterdam, (1988).
[4] Flügge, W., Stresses in shells, 2nd ed., Springer, New York/HeidelBerg/Berlin, (1973).
[5] Calladine, C.R., Theory of Shell Structures, Cambrigde University Press, Cambridge,
(1983).
[6] Rotter, J.M. and Teng, J.G., Elastic Stability of Cylindrical Shells with Weld Depres-
sions, Journal of Structural Engineering, American Society of Civil Engineers, Vol 115,
No.5, pp 1244-1263, (1989).
[7] http://java.sun.com/j2se/1.4.2/docs/api/java/awt/Graphics.html
[8] Wesley Vanlaere, Plooigedrag van Verstijfde Cilinders op Lokale Steunpunten, PhD the-
sis, Universiteit Gent, (2006).
[9] W. Guggenberger, R. Greiner, en J.M. Rotter, “Cylindrical Shells above local supports,”
in Buckling of Thin Metal Shells, J.G. Teng en J.M. Rotter, Eds., Hoofstuk 3. Spon Press
Londen, (2004).
[10] EN 1993-4-1, Eurocode 3:Design of steel structures-part 4: Silos, CEN, European
Committee for Standardization, Central Secretariat: rue de Stassart 36, (2007).
[11] Katrien Craeye, Numerieke simulaties van verstijfde silo’s, thesis, Universiteit Gent,
(2007).
[12] http://pyformex.berlios.de/
[13] http://www.python.org
[14] Guggenberger, W., Greiner, R., Rotter, J.M., Cylindrival shells above local supports,
J.G. Teng, J.M. Rotter (Eds.), Buckling of Thin Metal Shells (pp. 88-128), Spon Press
London,( 2007).