Programmeren van hulpmiddelen bij de berekening van ...

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


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


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: 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

σ

ε


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.


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)


�� 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.


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


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)


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.�.


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�.


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


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


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 invoeren 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.


• 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.


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 /.


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.


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


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


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.


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


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-


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


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.


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.


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.


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.


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.


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.


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


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.


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,


• 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.


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


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


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.


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.


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


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.


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.


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


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


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


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


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)))


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.


• 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.


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.


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


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


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


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


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


*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-


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-


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


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


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:; � �� <=>�� <=>� ��

�� /� ��


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

�� /��


(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�� /� ��

��


(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

Bijlage 2: Programmacode ECCS B

Bijlage 2: Programmacode ECCS

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){


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 }



42 JOptionPane.showMessageDialog(null, "alpha xpp" + getal, "Input was not

correct", JOptionPane.WARNING_MESSAGE);

43 getal = -1;

44 }


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-


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};


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-


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);


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);


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;


150 }

151 else if (lambdaNew < M1_lambda_bar_p){

152 chiNew=1-M1_beta_*(lambdaNew-0.2)/(M1_lambda_bar_p-0.2);


154 }

155 else {

156 if (lambdaNew > 0){chiNew=M1_alpha_xpe/lambdaNew/lambdaNew;}

157 else{chiNew = chiOld;}


-3-


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


181 pOld = 0; pNew = 0; alphaOld=0; alphaNew=0;

182 alphaOld = calc.alpha_xpe(Q, r, M1_h, pOld);


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



200 alphaOld = calc.alpha_xpp(pOld, M1_lambda_bar, r, t, M1_beta_);



203 alphaNew = calc.alpha_xpp(pNew, M1_lambda_bar, r, t, M1_beta_);



206 else {




-4-




209 }

210 }

211 pOld = pNew;


213 }

214

215 //Combination





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;


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;


230 }

231 else {g.setColor(Color.BLUE);}

232


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;


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;


254 lambdaNew = (double)i/loperX*schaalX;

255 if (lambdaNew < 0.2){

256 chiNew = 1;


258 }

259 else if (lambdaNew < M2_lambda_bar_p){

-5-


260 chiNew=1-M2_beta_*(lambdaNew-0.2)/(M2_lambda_bar_p-0.2);


262 }

263 else {

264 if (lambdaNew > 0){chiNew=M2_alpha_xpe/lambdaNew/lambdaNew;}

265 else{chiNew = chiOld;}


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



289 alphaOld = calc.alpha_xpe(Q, r, M2_h, pOld);






295 else {






298 }

299 }

300 pOld = pNew;


302 }

303

304 //Plastic



307 alphaOld = calc.alpha_xpp(pOld, M2_lambda_bar, r, t, M2_beta_);



-6-


310 alphaNew = calc.alpha_xpp(pNew, M2_lambda_bar, r, t, M2_beta_);



313 else {






316 }

317 }

318 pOld = pNew;


320 }

321

322 //Combination





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;


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;


337 }

338 else {g.setColor(Color.BLUE);}

339


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;


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-


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-


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);


1663 }

1664 else {rbQ40.setSelected(!geselecteerd);}

1665 }//GEN-LAST:event_rbQ40ActionPerformed

1666







1672 }



1675







1681 }



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();


1695 }//GEN-LAST:event_rbCLActionPerformed

1696

1697 private void cmdMethode2ActionPerformed(java.awt.event.ActionEvent evt) {

//GEN-FIRST:event_cmdMethode2ActionPerformed

1698 tekenpaneel.tekenen = "M2";


1700 }//GEN-LAST:event_cmdMethode2ActionPerformed

1701

1702 private void cmdMethode1ActionPerformed(java.awt.event.ActionEvent evt) {

//GEN-FIRST:event_cmdMethode1ActionPerformed

1703 tekenpaneel.tekenen = "M1";


1705

1706 }//GEN-LAST:event_cmdMethode1ActionPerformed

1707

-1-


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);


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-


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;


1787 lblM1ElasticPlastic.setText("Elastic-plastic buckling");

1788 }

1789 else{

1790 chi = 1;



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-


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;


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);



1836 lblM2ElasticPlastic.setText("Elastic-plastic buckling");

1837 }

1838 else{

1839 chi = 1;



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-


1868 txtM1DMSR.setText("");

1869 txtM1DMSA.setText("");

1870 txtM1Ratio.setText("");

1871 lblM1ElasticPlastic.setText("");

1872 lblM1Status.setText("");

1873 //Method 2






1879 }

1880

1881 }//GEN-LAST:event_cmdCalcActionPerformed

1882

1883 private double convertToDouble(String tekst,String variabele){


1885 try{

1886 getal = Double.parseDouble(tekst);

1887 if (getal < 0) { throw new Exception();}

1888 }



1891 JOptionPane.showMessageDialog(null, "Wrong input: " + variabele, "Input

was not correct", JOptionPane.WARNING_MESSAGE);

1892 getal = -1;


1894 }


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






1920 //Method 2



-5-





1926 }//GEN-LAST:event_cmdClearActionPerformed

1927

-6-

Bijlage 3: Aanpassingen aan het f2abq.py script C

Bijlage 3: Aanpassingen aan het f2abq.py script

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-


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-


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-


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-


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:


409 if ID!=None:



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:


420 if ID!=None:



423 elif set.upper()=='ALL':

424 fil.write("*NODE OUTPUT, NSET=Nall\n")

425 if IP!=None:


427 if ID!=None:



430 else:

431 warning("The set should be a list of property numbers.")

-1-

Bijlage 4: Programmacode Shell.py script D

Bijlage 4: Programmacode Shell.py script

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-


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-


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


166 b_feModel = True

167 b_Geometry = True

168

169 if b_cy and b_co:

170 res = askItems([

-3-


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:


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:


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-


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



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:


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


263 print "typeOfSupport: %s" %(typeOfSupport)

264 print "n_su: %s" %(n_su)

265 print "w_su: %s" %(w_su)


267

268 elif support == 2:

269 typeOfSupport = ask("Type of support", choices=['Encastre','Pinned'])

270



273

274 else:




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-


, angle

285



288 b_Stiffener = True

289


291 c_st = ask("Select the type of stiffener", choices=['R','U','S'])

292

293 if c_st == 'R':


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':


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],





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:'])



-6-




341




345 print "t_st: %s" %(t_st)





350

351 elif c_st == 'S':


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],





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:'])





372




376 print "b_st: %s" %(angle)





381


383 c_st = 'None'

384 print "This option is not available for watertowers"

385

386 else:





391 else:

392 print "No stiffener has been defined"

393 b_Stiffener = False

394

395 def inputSector():

-7-


396 global b_Sector, b_createMesh, sector,a

397



400 b_Sector = True

401


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


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:




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



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-


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




462



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




477

478 else:




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


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


500 if a_load == 0:

501 a_load = 1000

502 if h_load == 0:

503 h_load == 9810

504


506 ['Total axial load:',True],

507 ['Total axial load [N]:',a_load],

-9-


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:




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:




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-


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:


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)


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:



599 ['Total amount of elements in height (cylinder):',ne_v1],




603 ['% zone 1-3 (circular):',p_h]])

604


606 ne_v1 = res['Total amount of elements in height (cylinder):']




610



613 print "p_v: %s" %(p_v)

614 print "p_h: %s" %(p_h)

615

616 if b_co and not b_cy:



619 ['Total amount of elements in height (cone):',ne_v2],



-11-



623 ['% zone 1-3 (circular):',p_h]])

624


626 ne_v2 = res['Total amount of elements in height (cone):']




630



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:


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],


645 ['Ratio between amount of elements in other zones:',scale],


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:']



655

656 print "algoritme: %s" %(algoritme)

657 print "ne3: %s" %(ne3)

658 print "ne1: %s" %(ne1)


660 print "p_v: %s" %(p_v)

661 print "p_h: %s" %(p_h)

662

663 else:


665 ['Amount of elements of zone 1 in circular direction:',ne3],

666 ['Amount of elements of zone 1 in meridional direction:',ne1],


668 ['Ratio between amount of elements in other zones:',scale],


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:']



677

678 print "ne3 %s" %(ne3)

-12-


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


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 = ['','','','']


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 = ['','','','','']


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-


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 = ['','','','','','','','']


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':



777 elif typeOfAnalysis == 'GNA' or typeOfAnalysis == 'NMA' or

typeOfAnalysis == 'GMNA':



780 elif isinstance(eval(parameters[i]),float) or isinstance(eval(parameters[

i]),int):

781 if typeOfAnalysis == 'LBA' and typeOfSolver == 'SUBSPACE':



784 elif typeOfAnalysis == 'LBA'and typeOfSolver == 'LANCZOS':



787 elif typeOfAnalysis == 'GNA' or typeOfAnalysis == 'NMA' or

-14-


typeOfAnalysis == 'GMNA':



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


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))


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']))


829

830 if res['Include history displacements']:

831 output.append(f2abq.Odb(type='history', variable=None, kind='node', ID=['U3',

'U2','U1']))


833

834 print output

835

836

837 ##############################

838 ### Creating the structure ###

839 ##############################

840

-15-


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


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


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-


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)


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)



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)


-17-


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)


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


970 print "ne_st_l: %s" %(ne_st_l)



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


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-


993 if b_cy:

994 zone13 = square("yz").scale([1,le3,le1]).replic2(ne3,ne1,le3,le1,1,2,0,0).

setProp(0)


setProp(0).translate([0.,p_h*ls,0.])


setProp(0).translate([0.,0.,p_v*h2])


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


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-


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)


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


1053 return shell, shell.translate([0,ls*67.5/45.,0]).cylindrical([0,1,2],[1.,

a/ls,1.])


1055 return shell, shell.translate([0,ls,0]).cylindrical([0,1,2],[1.,a/ls,1.])


1057 return shell, shell.translate([0,2*ls,0]).cylindrical([0,1,2],[1.,a/ls,1.

])


1059 return shell, shell.cylindrical([0,1,2],[1.,a/ls,1.])

1060 else:



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


1089 if b_co:

1090 h = h1 + h2

1091 h0 = h1

1092 else:

-20-


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


1103 h0 = 0

1104 h = h1

1105 if b_cy:

1106 h = h1+h2

1107 print "Continuous %s support" %typeOfSupport

1108


1110 ne_breedte = meshGrid[4]/2

1111 if meshGrid[11] == 0:

1112 ne_hoogte = meshGrid[0]/2

1113


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



1127 else:

1128 if nodes[i,1] <= p_h*ls * 0.99999:

1129 # knopen bovenaan de zone met fijne mesh



1132 elif nodes[i,1] <= p_h*ls * 1.00001:

1133 # knoop overgang fijne en grove mesh



1136 else:

1137 # knopen bovenaan de zone met grove mesh



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-




1152 elif isClose(nodes[i,0],r2+d_st):

1153 # knoop op uiteinde van R-verstijver



1156 elif r2*1.00001 <= nodes[i,0] and nodes[i,0] <= (r2+d_st

)*0.99999:

1157 # overige knopen R-verstijver



1160 elif meshGrid[9] == 0:

1161 # als de R-verstijver samenvalt met symmetrierand



1164 elif isClose(nodes[i,0],r2):

1165 # knopen ondersteunde cilinderwand


1167 # knoop midden van het steunpunt



1170 elif isClose(nodes[i,1],meshGrid[5]*meshGrid[10]):

1171 # knoop uiteinde van het steunpunt



1174 elif 0 <= nodes[i,0] and nodes[i,1] <= meshGrid[5]*

meshGrid[10]*0.99999:

1175 # overige knopen steunpunt



1178 elif isClose(nodes[i,0],r2+d_st) and c_st == "U":

1179 # bijkomende knopen bij ondersteunde U-verstijver


1181 # knoop midden van het steunpunt (midden lijfplaat U-verstijver)



1184 elif nodes[i,1] < meshGrid[5]*meshGrid[9]*0.99999:

1185 # andere knopen lijfplaat U-verstijver



1188 elif isClose(nodes[i,1],0) or isClose(nodes[i,1],ls):



1191 else: # Rigide steunpunten


1193 # knoop linkerrand



1196 elif nodes[i,1] <= meshGrid[5]*meshGrid[10]*0.99999:

1197 # knopen tussen linkerrand en breedte steunpunt



1200 elif nodes[i,1] <= meshGrid[5]*meshGrid[10]*1.00001:

1201 # knoop op breedte steunpunt




-22-


1205 # knoop rechterrand




1209 # voor continue ondersteuning


1211 # knoop linkerrand



1214 elif nodes[i,1] <= ls*0.99999:

1215 # knopen tussen de randen




1219 # knoop rechterrand



1222

1223 elif isClose(nodes[i,1],0) or isClose(nodes[i,1],ls):

1224 # randen voor symmetrie



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



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)):



1238 elif isClose(nodes[i,2],meshGrid[1] * math.floor(ne_hoogte*2/3)):






1244





1249 if isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):

1250 # knoop linksbovenaan en rechtsbovenaan



1253 elif (nodes[i,1] <= meshGrid[4]*meshGrid[5]*0.99999) or (2*ls-

meshGrid[4]*meshGrid[5]*0.99999 <= nodes[i,1]):




1257 elif (nodes[i,1] <= meshGrid[4]*meshGrid[5]*1.00001) or (2*ls-

-23-


meshGrid[4]*meshGrid[5]*1.00001 <= nodes[i,1]):

1258 #knopen overgang fijne en grove mesh



1261 elif (meshGrid[4]*meshGrid[5]*1.00001 <= nodes[i,1]) and (nodes[i,1]

<= 2*ls-meshGrid[4]*meshGrid[5]*1.00001):




1265




1269 # knopen voor discrete ondersteuning



1272 if (isClose(nodes[i,1],meshGrid[5]*meshGrid[9])) or (isClose(

nodes[i,1],2*ls-meshGrid[5]*meshGrid[9])):







1279 # knoop op uiteinde van R-verstijer




)*0.99999:

1283 # overige knopern R-verstijve



1286 elif meshGrid[9] == 0:

1287 # als de R-verstijver samenvalt met symmetrierand



1290



1293 if (isClose(nodes[i,1],0)) or (isClose(nodes[i,1],2*ls)):




1297 elif (isClose(nodes[i,1],meshGrid[5]*meshGrid[10])) or (

isClose(nodes[i,1],2*ls-meshGrid[5]*meshGrid[10])):




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):




1305 elif isClose(nodes[i,0],r2+d_st) and c_st=='U':



-24-




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]):




1315

1316 else:

1317 # Rigide steunpunten


1319 # knoop linkerrand en rechterrand



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



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



1330


1332 # knopen voor continue ondersteuning


1334 # knoop rechterrand en linkerrand



1337 else:




1341

1342 elif isClose(nodes[i,1],0) or isClose(nodes[i,1],2*ls):




1346

1347 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],ls) and

isClose(nodes[i,2],h-meshGrid[3]):




1351


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)):






-25-







1363

1364





1369 if isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls): # knoop linksbovenaan

en rechtsbovenaan



1372 elif (-meshGrid[4]*meshGrid[5]*0.99999 <= nodes[i,1]) and (nodes[i,1]

<= meshGrid[4]*meshGrid[5]*0.99999):




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



1380 elif (nodes[i,1] <= -meshGrid[4]*meshGrid[5]*1.00001) or (meshGrid[4

]*meshGrid[5]*1.00001 <= nodes[i,1]):




1384







1391 if (isClose(nodes[i,1],meshGrid[5]*meshGrid[9])) or (isClose(

nodes[i,1],-meshGrid[5]*meshGrid[9])):











)*0.99999:






1407 if (isClose(nodes[i,1],-ls)) or (isClose(nodes[i,1],ls)):


-26-




1411 elif (isClose(nodes[i,1],meshGrid[5]*meshGrid[10])) or (

isClose(nodes[i,1],-meshGrid[5]*meshGrid[10])):




1415 elif (-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1] and

nodes[i,1] <= meshGrid[5]*meshGrid[10]*0.99999):






1421 if (nodes[i,1] < meshGrid[5]*meshGrid[9]*0.99999) or (-

MeshGrid[5]*meshGrid[9]*0.99999 < nodes[i,1]):




1425

1426 else:


1428 if isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls):




1432 elif (-meshGrid[5]*meshGrid[10]*0.99999 <= nodes[i,1]) and (


1433 # knopen tussen de verstijver



1436 elif (-meshGrid[5]*meshGrid[10]*1.00001 <= nodes[i,1]) and (


1437 # knopen verstijver


1439 lijst[8].append(i) # checken

1440


1442 # voor continue ondersteuning

1443 if isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls):




1447 elif (-ls*0.99999 <= nodes[i,1]) and (nodes[i,1] <= ls*0.99999):




1451

1452 elif isClose(nodes[i,1],-ls) or isClose(nodes[i,1],ls):




1456

1457 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],0) and




-27-



1461


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)):











1473





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):




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



1487 elif (j*ls*2-ls*1.00001 <= nodes[i,1]) and (nodes[i,1] <= 2*j*ls+

ls*1.00001):




1491

1492






1498 # knopen voor flexibele ondersteuning


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])):










-28-


1510 elif r2*1.00001 <= nodes[i,0] and nodes[i,0] <= (r2+

d_st)*0.99999:






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



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





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



1530 else:



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



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



1541


1543 # knopen voor continue ondersteuning



1546

1547 elif typeOfSupport.upper() == "FLEXIBLE" and isClose(nodes[i,1],0) and





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)):






-29-







1563


1565 nodes_copy = nodes.translate([0,ls*67.5/45.,0]).cylindrical([0,1,2],[1.,a/ls,

1.])


1567 nodes_copy = nodes.translate([0,ls,0]).cylindrical([0,1,2],[1.,a/ls,1.])


1569 nodes_copy = nodes.translate([0,2*ls,0]).cylindrical([0,1,2],[1.,a/ls,1.])


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


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-


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]


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-


1664 cloadSet[10] = [0.0,0.0,loadSt,0.0,0.0,0.0]

1665


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


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))


1713

1714 elif typeOfAnalysis.upper() == 'GNA':

1715 analysis.append(f2abq.Analysis(analysistype = "STATIC", kind='RIKS', time=

-32-


parameters3, nlgeom="YES", incr=increments))


1717

1718 elif typeOfAnalysis.upper() == 'MNA':


parameters3, nlgeom="NO", incr=increments))

1720 plasticity = True

1721

1722 elif typeOfAnalysis.upper() == 'GMNA':


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


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-


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




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-


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:


1834 if not b_Geometry:

1835 inputGeometry()

1836 if not b_Support:

1837 inputSupport()

1838 if not b_Stiffener:


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)


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-


1876 b_createMesh = True

1877 else:

1878 if ack("Query additional information?"):

1879 selector(1)

1880 createMesh()

1881 else:


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()


1929 return

-36-


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-


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):


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-


2041

2042 createMesh()

2043

2044 for j,typeOfSupport in enumerate(tos):

2045 clear()


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)


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()


2082

2083 for j,w_st in enumerate(loopVerstijver):


2085

2086 for i,typeOfSupport in enumerate(tos):

2087

2088 clear()


2090 createMesh()


2092 nodeSelector()

2093 properties.reset()

2094 image.saveImage("Screenshot_%s_%s_%s_%s.png" %(typeOfSupport,

c_st,scale,int(p_v*100)))

-39-


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"


typeOfSolver +"_"+ typeOfSupport +"_"+ c_st

2105 else:

2106 typeOfAnalysis = analyse


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)


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-


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



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

Bijlage 6: Randvoorwaarden voor de knopen F

Locatie van de knopen in de structuur

Bijlage 7: Inputfile G

Bijlage 7: Inputfile

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




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


54 48064,48065,48066,48067,48068,48069,48070,48071,48072,48073,

55 ...

56 48164,48165,48166,48167,48168,48169,48171,


-1-


58 0,0,0,0,0,1


60 48170,


62 0,0,0,0,0,1


64 48172,48173,48174,48175,48176,48177,48178,48179,48180,48181,

65 ...

66 48192,


68 0,0,0,0,0,1


70 48193,


72 0,0,0,0,0,1


74 1,2,3,4,5,6,7,8,9,10,

75 ...

76 47800,47801,47802,48059,48060,


78 0,0,0,0,0,1


80 14,


82 0,0,0,0,0,1


84 62,72,74,77,148,156,160,161,222,226,

85 227,293,296,298,301,371,373,


87 0,0,0,0,0,1


89 368,


91 0,0,0,0,0,1


93 367,369,370,379,380,381,382,394,399,


95 0,0,0,0,0,1


97 391,


99 0,0,0,0,0,1


101 6768,6841,10902,10972,20050,20086,


103 0,0,0,0,0,1


105 95,97,98,103,179,181,182,187,245,246,

106 251,325,330,333,336,393,398,


108 0,0,0,0,0,1


110 20,


112 0,0,0,0,0,1

113 *ELEMENT, TYPE=S4R5, ELSET=Eset_0_0

114 1, 14, 74, 2761, 2753

-2-


115 ...

116 41600, 48062, 48059, 48193, 48192

117 *ELSET, ELSET=Eall

118 Eset_0_0

119 *ELSET, ELSET=Eset_0

120 Eset_0_0


122 41601, 368, 367, 2819, 2817

123 ...

124 43840, 15404, 15401, 15409, 15406


126 Eset_0_2


128 Eset_0_2


130 43841, 14, 13, 65, 74

131 ...

132 46440, 2729, 2737, 2731, 2728


134 Eset_0_3


136 Eset_0_3


138 46441, 15154, 15156, 15174, 15173

139 ...

140 47740, 16748, 16749, 16753, 16752


142 Eset_0_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-


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-


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


ijlage 8: Parameterstudie

Verplaatsingen

Flexibele

R-

Verstijvingsratio

Verplaatsingen

Flexibele ondersteuning

U

Verstijvingsratio

Verplaatsingen

Rigide

R-

Verstijvingsratio

Verplaatsingen

Rigid

U

Verstijvingsratio

H

Verplaatsingen


-vormige verstijver

Verstijvingsratio 100%

Verplaatsingen


U-vormige verstijver


Verplaatsingen

Rigide ondersteuning

-vormige verstijver


Verplaatsingen






S22

spanningen volgens de z


R-

Verstijvingsratio

S22



U

Verstijvin

S22


Rigide

R-

Verstijvingsratio

S22


Rigide

U

Verstijvingsratio

H

S22

spanningen volgens de z-as


-vormige verstijver


S22





S22



-vormige verstijver


S22







Von Mises spanningen

Flexibele onde

R-

Verstijvingsratio



U

Verstijvingsratio


Rigide

R-

Verstijvingsratio

Von Mises spa

Rigide

U

Verstijvingsratio

H



-vormige verstijver








-vormige verstijver






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



Verplaatsingen

Flexib

R-


Verplaatsingen


R-

Verstijvingsratio

Verplaatsingen


R-

Verstijvingsratio

H

Verplaatsingen


-vormige verstijver


Verplaatsingen


-vormige verstijver


Verplaatsingen


-vormige verstijver




S22

spanninge


R-


S22



R-

Verstijvingsratio

S22



R-

Verstijvingsratio

H

S22



-vormige verstijver


S22



-vormige verstijver


S22



-vormige verstijver






R-




R-

Verstijvingsratio

S22

spanningen volgens de


R-

Verstijvingsratio

H



-vormige verstijver




-vormige verstijver


S22



-vormige verstijver


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).

Programmeren van hulpmiddelen bij de berekening van ...

Documents

Transcript of Programmeren van hulpmiddelen bij de berekening van ...