Jonas Lintermans - Bewegende Cilinder in OpenFOAM

Het dynamisch maken van een cilinder in
een windtunnel met behulp van

OpenFOAM
Onderzoekstechnieken 3 academiejaar: 2009-2010
Jonas Lintermans
Begeleiders: Dr. Tim De Troyer en Dr. Mark Runacres

2
Inleiding
Tegenwoordig is het gebruikelijk om naast praktisch onderzoek ook een deel van het
onderzoek te simuleren. Dit gebeurt misschien wel het meest in de fluı̈do- en thermo-
dynamica. Het voordeel van deze vorm van onderzoek is de prijs. Wanneer we bijvoor-
beeld naar het onderzoek naar aero-elasticiteit van vliegtuigvleugels kijken, zien we dat
bij tests tijdens de vlucht de kostprijs inderdaad hoog kan oplopen, door ondermeer het
brandstofverbruik etc.
Ook het gevaar voor aero-elastische effecten als flutter zijn logischerwijs afwezig bij
computationele simulatie. Tegenwoordig komen deze simulaties qua correctheid aardig
in de buurt van de werkelijkheid.
Het doel van deze onderzoeksopdracht is om op een zo eenvoudige manier een be-
wegende cilinder te implementeren in OpenFOAM. Dit werd bereikt in verschillende
stappen. Uitgaande van een overgenomen code van David Van Cauteren, zullen we de
basisideeën van OpenFOAM onder de knie proberen te krijgen. Het is van groot belang
om elk element van de OpenFOAM-case voldoende te begrijpen. Dan pas kunnen we
over gaan naar de laatste stap, waar we een lineaire kracht aanbrengen op de gecreëerde
cilinder om deze te doen bewegen volgens een sinisoı̈daal pad.
Tijdens het onderzoek viel ik ook op andere zaken, die niet altijd evenveel te maken
hadden met de onderzoeksopdracht, maar wel van belang kunnen zijn voor de algemene
kennis van OpenFOAM. Ondermeer het opdelen van de case over een aantal processoren
en de snelheidswinst ervan komt aan bod.
i
ii
Inhoudsopgave
Inhoudsopgave ii
1 Literatuurstudie 1
1.1 Aero-elasticiteit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Stabiliteit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Statische Stabiliteit . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Dynamische Stabiliteit . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Flutter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 OpenFOAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.1 Vuistregels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.2 Opdeling in OpenFOAM . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.3 Solver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Algemeen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Onderzoek 15
2.1 Von Karman in OpenFOAM . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1 Begincode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.2 Code met fijnere mesh . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.3 Code compileren in parallelmode . . . . . . . . . . . . . . . . . . . 18
2.2 Dynamische beweging: movingCone-tutorial . . . . . . . . . . . . . . . . . 21
2.2.1 De 0-directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.2 De system-directory . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.3 De constant-directory . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3 Dynamische beweging: movingCylinder-case . . . . . . . . . . . . . . . . . 23
2.3.1 De 0-directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.2 De system-directory . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3.3 De constant-directory . . . . . . . . . . . . . . . . . . . . . . . . . 26
3 Conclusie 29
3.1 Samenvatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2 Verder onderzoek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
iii
A Code van de Dynamische Cilinder 31
A.1 0 -directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
A.1.1 p . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
A.1.2 U . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
A.1.3 pointDisplacement . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
A.2 system-directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
A.2.1 controlDict . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
A.2.2 decomposeParDict . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
A.2.3 fvSchemes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
A.2.4 fvSolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
A.2.5 tetFemSolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
A.3 constant-directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
A.3.1 polyMesh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
A.3.2 dynamicMeshDict . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
A.3.3 transportProperties . . . . . . . . . . . . . . . . . . . . . . . . . . 47
A.3.4 turbulenceProperties . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Bibliografie 49
Hoofdstuk 1
Literatuurstudie
Voor aanvang van het onderzoek naar flutter via een CFD-studie dienen we de verschil-
lende elementen van de te bespreken punten onder de knie te krijgen. Deze worden
hieronder besproken.
1.1 Aero-elasticiteit
Aero-elasticiteit is de studie omtrend de interactie tussen de vervorming van een elas-
tische structuur in een luchtstroom en de resulterende aero-dynamische kracht (Hodges
and Pierce, 2002). Deze studie kunnen we indelen in verschillende vlakken: de in-
teractie tussen elasticiteit en dynamica (structurele dynamica); de interactie tussen
aero-dynamica en elasticiteit (statische aero-elasticiteit) en de interactie tussen aero-
dynamica, elasticiteit en dynamica (dynamische aero-elasticiteit).
Aero-elastische verschijnselen kunnen de vliegprestaties zowel in positieve als negatieve
zin beı̈nvloeden. Bij de ontwikkeling van vliegtuigen moet rekening gehouden worden
met deze aero-elasticiteit. Men zal de negatieve invloeden proberen te beperken, terwijl
men de positieve invloeden zal proberen uit te buiten. Die uitbuiting kan een grote
invloed hebben op de prestaties van de Uninhabited Air Vehicles (UAVs). In de prak-
tijk zien we dat door dit aero-elastisch effect in het begin een kleine wijziging is in het
comfort bij het vliegen. Bij blijvende beweging door de lucht zien we dat er vermoei-
ing optreedt in de structuur. Deze vermoeidheid zal uiteindelijk een catastrofaal gevolg
hebben, zonder enige vorm van waarschuwing vooraf. In theorie hebben deze aero-
elastische problemen een statische en dynamische oorzaak. Dynamische oorzaken liggen
voor de hand. Aero-elastische problemen ontstaan hierbij door de krachtenwerking op
de structuur tijdens de vlucht. Kleine statische traagheidskrachten hebben in theorie
geen invloed op de aero-elastische effecten; grote traagheidskrachten daarentegen mogen
niet verwaarloosd worden. Aangezien dit niet het geval is in de praktijk door , kunnen
sommige aero-elastische fenomenen beschreven worden door kleine vervormingsbeweg-
ingen uit te voeren op de structuur. Deze bewegingen kunnen soms aantonen of de
structuur naar wens zal reageren op de verkregen krachten in vlucht, dan wel dat deze
compleet omgekeerd zou reageren. Het is duidelijk dat de proeven, voorafgaande aan de
1
2 Hoofdstuk 1. Literatuurstudie
constructie en de eerste vlucht van het vliegtuig, belangerijk zijn.

Er is tegenwoordig een grote vraag naar lichte structuren met een groot draagvermo-
gen. Men gaat dus steeds op zoek naar de meest operationeel betrouwbare en structureel
optimale systemen.
Niet alleen spelen aero-elastische fenomenen een rol bij vliegtuigvleugels, maar ook
bij windturbinebladen en zelfs bij versterkers van muziekinstrumenten.
1.2 Stabiliteit
Het meest voorkomende aero-elastisch probleem is die van de stabiliteit (Hodges and
Pierce, 2002). Deze wordt gedefinieerd als de neiging om na verstoring van het even-
wicht terug te keren naar de evenwichtstoestand. Het zijn de aero-dynamische krachten
die markant vergroten in functie van de snelheid, terwijl de elasticiteitsmodulus van
het gebruikte materiaal onafhankelijk is van de snelheid. Wanneer de aero-dynamische
krachten de elastische krachten overwinnen zien we twee mogelijkheden. Wanneer de
iertiekrachten klein zijn, en dus weinig invloed hebben op het systeem, spreken we van
divergentie. Deze kan optreden bij een te grote snelheid of bij een te grote aanvalshoek
(AoA). Bij het bereiken van deze snelheid zal de structuur zodanig belast zijn dat deze
het zal begeven. Bij de constructie van de vliegtuigen zal men dus nauwkeurig moeten
bepalen hoe groot deze divergentiesnelheid is. Zie Figuur 1.1
Figuur 1.1: divergentiesnelheid in functie van de AoA (Hodges and Pierce, 2002)
Daartegenover staat flutter. Deze treedt op wanneer de traagheidskrachten groot

zijn en dus wel belangerijk zijn. Zowel flutter als divergentie kunnen catastrofaal zijn.
Door de studie van het divergentieverschijnsel bij kleine traagheidskrachten kunnen
we de volgende zaken voorspellen:
• Lift voor een gegeven vliegtuig voor een bepaalde aanvalshoek
• Load Factor die een vliegtuig maximaal kan weerstaan.
• Bochtenprestaties
Hoofdstuk 1. Stabiliteit 3
Het flutterverschijnsel, dat optreedt bij grote traagheidskrachten, kan gebruikt worden
voor het volgende:
• Reactie van een vliegtuig bij turbulentie of windvlagen
• Reactie op wervels, die ontstaan na vleugels of andere onderdelen.
1.2.1 Statische Stabiliteit

We spreken van statische stabiliteit wanneer de krachten en momenten op een vleugel,
na verstoring van het evenwicht, er voor zorgen dat het geheel terug keert naar zijn
initiële positie (Anderson, 2008). Het omgekeerde noemen we statische instabiliteit.
Hierbij zullen de krachten en momenten ervoor zorgen dat het geheel verder afwijkt van
de evenwichtstoestand. Neutrale stabiliteit —waar het systeem na verstoring op zijn
huidige positie blijft— komt vrijwel nooit voor bij vliegtuigen. We kunnen besluiten
dat de statische stabiliteit ervoor zorgt dat het geheel al dan niet terug keert naar zijn
initiële positie. Deze zegt echter niets over de manier waarop deze zal terugkeren, dat
doet de dynamische stabiliteit.
1.2.2 Dynamische Stabiliteit

De dynamische stabiliteit wordt bepaald door de geschiedenis van de beweging van het
systeem nadat deze heeft gereageerd op zijn statische stabiliteit (Anderson, 2008). Deze
geeft dus, zoals eerder gezegd, weer op welke manier het systeem al dan niet zal terugk-
eren naar zijn evenwichtspositie.
In evenwichtstoestand zal het syteem (hier een vliegtuig) een zekere begin Angle of
Attack hebben, αe . Bij verstoring van het evenwicht (door bijvoorbeeld een windstoot),
zullen we een vergroting van αe naar α krijgen. We krijgen dus een verplaatsing α − αe ,
gegeven door Figuur 1.2.
Figuur 1.2: Verstoring van de evenwichtsaanvalshoek (Anderson, 2008)
Wanneer we de verplaatsing α − αe in functie van de tijd bekijken onderscheiden

we drie gevallen. Elk geval heeft hetzelfde beginpunt, bij t = 0 zal elk geval dezelfde
aanvalshoek α hebben. Wanneer het systeem statisch stabiel —wat in bijna alle gevallen
zo is— zal de verplaatsing α − αe verkleinen. Bij het eerste geval zal de verplaatsing
meteen uitdoven en het systeem zal meteen naar de evenwichtspositie gaan. Dit noemt
met een aperiodische beweging. Het systeem kan ook dempend oscillerend en na verloop
van tijd uit te doven tot het evenwichtspunt. Deze twee eerste gevallen, weergegeven
op Figuur 1.4 worden dynamisch stabiel genoemd. We kunnen dus concluderen dat
een lichaam statisch stabiel is wanneer het na verloop van tijd terug keert naar zijn
evenwichtspositie.
Figuur 1.3: Aperiodieke oscilatie, dynamisch stabiel (Anderson, 2008)
Figuur 1.4: Gedempte oscilatie, dynamisch stabiel (Anderson, 2008)
Aan de andere kant hebben we in Figuur 1.5 de dynamisch instabiele lichamen. Hier-
bij gaat het lichaam blijven oscileren met stijgende amplitude om uiteindelijk te bezwij-
ken aan deze beweging. De evenwichtspositie wordt bij dynamisch instabiele lichamen
nooit behouden.
Figuur 1.5: Dynamische oscilatie, dynamisch instabiel (Anderson, 2008)
We kunnen besluiten dat een dynamisch stabiel lichaam altijd statisch stabiel moet
zijn. Het omgekeerde geldt wel niet altijd. Het is wel van groot belang om er eerst voor
te zorgen dat een vliegtuig statisch stabiel is.
1.2.3 Flutter
Flutter is de meest gevaarlijke fenomeen dat kan optreden in het aero-elastische studie-
domein. Daarom is het belangerijk om deze volledig te begrijpen en te weten met welke
factoren rekening moet worden gehouden. We kunnen flutter eenvoudig voorstellen door
middel van Figuur 1.6. Hierop zien we dat de flutterbeweging wordt ontbonden in 2
componenten: een wringende component
Figuur 1.6: Fluttermodel volgens Hodges.
Wanneer we flutter gaan bestuderen in het tijdsdomein en frequentiedomein, vallen

er bepaalde dingen op (Dowell, 2004).
In Figuur 1.8 zien we dat de impulsrespons een welbepaalde periodiciteit heeft met
verschillende amplituden. Het willekeurig ingangssignaal wordt door de vleugel gefilterd,
zodat enkel de frequenties die dicht bij de eigenfrequenties van het vliegtuig liggen worden
overgedragen naar het impulsrespons (Dowell, 2004).
Dit fenomeen is duidelijker zichtbaar in het frequentiedomein. Hierbij gaan we de
polen van het reële en imaginaire deel van transferfunctie uitzetten ten opzichte van de
vliegsnelheid. Voor een gebruikelijke vleugeldoorsnede hebben we twee voorname polen,
die bij lage vliegsnelheid samenvallen met de natuurlijke frequenties van de vleugel.
Flutter wordt in figuur 1.9 aangegeven door de laagste snelheid waarvoor een van de
imaginaire frequenties negatief ωI wordt. Fysische betekent dit dat het systeem instabiel
wordt en ongecontroleerd gaat oscilleren.
Bij de uitzetting van het spectrum van de responsfunctie in figuur 1.10 zien we
twee pieken; de eerste bij buigingsfrequentie ωh , de tweede bij wringingsfrequentie ωα .
Wanneer de vliegsnelheid de fluttersnelheid benadert, zullen de pieken als maar meer
samenvallen. In de praktijk moet volgens Theodorsen’s klassieke leer de verhouding
kleiner blijven dan 1,2 (Theodorsen, 1944). Wanneer dit zo is, kunnen we gerust zijn
dat de vleugel niet destructief gaan flutteren.
Figuur 1.7: Exitatie van de vleugel door een willekeurig signaal (Dowell, 2004)
Figuur 1.8: Respons van de vleugel op de willekeurige exitatie (Dowell, 2004)
Figuur 1.9: Reele en imaginaire component van de frequentie in functie van de vliegsnelheid
(Dowell, 2004)
Figuur 1.10: Spectrum van de transferfunctie (Dowell, 2004)

Parameters van flutter (Dowell, 2004)

Gewichtsverdeling Het zwaartepunt van het vliegtuig moet voor het aero-dynamische
centrum te liggen. Wanneer dit het geval is treedt er doorgaans minder makkelijk flutter
op.
Frequentieverhouding De fluttersnelheid is het laagst bij ωωαh ∼= 1. Zoals gezien zullen

de wringings-en buigingsfrequentie elkaar versterken. Zie Figuur 1.11.
Mach-getal Ook hier zal de fluttersnelheid het kleinst zijn bij een benadering aan
1, maar deze keer dan van het Mach-getal. Bij een Mach-getal M 1 krijgen we een
1
verandering in dichtheid van het fluı̈dum. Hierdoor krijgen we dat UF ∼ M 2 bij M 1.
Deze relatie wordt weergegeven in Figuur 1.11.
Figuur 1.11: Fluttersnelheiding in functie van a) wringing-buiging-frequentieverhouding en b)

Mach-getal (Dowell, 2004)
Hoogte Door een daling van de geluidsnelheid en de relatie tussen de snelheid en

het Mach-getal, nl. U = M aα , kunnen we stellen dat de fluttersnelheid zal stijgen bij
stijgende hoogte en stijgend Mach-getal. Zie Figuur 1.12.
Reynolds Getal Hoe hoger het Reynolds getal, hoe turbulenter de stroming. Deze
turbulentie zorgt voor wervelingen in de stroming. Hoewel flutter een fenomeen is dat
altijd gepaard gaat met het afscheiden van wervels waarvan de frequentie gelijk is aan de
flutter frequentie, is het een fenomeen veroorzaakt door wervel-geı̈nduceerde oscillaties.
Het laatstegenoemde zorgt voor de aero-elastische flow-structure interactie voor stro-
mingssnelheden waarbij de wervel-afscheiding in de buurt komt van de eigenfrequentie
van de structuur (Scanlan and Simiu, 2004).
Hoe flutter tegen gaan

Het is van kapitaal belang dat we steeds onder de fluttersnelheid blijven, om destructieve
gevolgen tegen te gaan. Daartegenover zouden we graag zo snel mogelijk vliegen, dat is
Figuur 1.12: Flutter bij stijgende hoogte en Mach-getal. (Dowell, 2004)
logisch. We kunnen dit bereiken door de fluttersnelheid op te trekken zonder toevoeging

van gewicht. We kunnen dit proberen op de volgende manieren (Dowell, 2004):
• Betere verdeling van het gewicht, zodat het zwaartepunt zeker voor het aero-
elastisch centrum ligt.
• Het vliegtuig trager dan zijn kritische Mach-snelheid laten vliegen.
• Demping aan de structuur toevoegen

ωh
• De ’buiging-wringing’-frequentieverhouding ωα vergroten of verkleinen voor een
constante ωα
• Wringingsstijfheid vergroten (dus ωα vergroten)

1.3 OpenFOAM
Voor het CFD-onderzoek naar de verschillende factoren die flutter beı̈nvloeden maken
we, zoals eerder uitgelegd in de literatuurstudie, gebruik van het Open Source-programma
OpenFOAM. Voor we starten met het echte onderzoek moeten we enkele principes en
algemeenheden begrijpen omtrend OpenFOAM.
1.3.1 Vuistregels
Bij het oplossen van een bepaalde probleemstelling in OpenFOAM maken we telkens ge-
bruik van enkele vuistregels (OpenFoam, 2010). We moeten er voor zorgen de berekenin-
gen zo precies en zo stabiel mogelijk zijn. Dit kunnen we verwezenlijken door rekening
te houden met de zogenaamde Courant number. Deze moeten we lager dan n proberen
te houden.
C0 ≤ 1
We kunnen de Courant number definiëren als:

δt.|U |
C0 = δx
met δt de tijdsstap, |U | de vloeistofsnelheid en δx de celgrootte in de richting van de

stroming. Deze δx hangt af van de plaats die berekend wordt en richting van de stroming.
Wanneer een stuk van de mesh wordt berekend die fijner is zal het courant number groter
worden. Daardoor zijn ook de snelheid en tijdstap belangerijk. Als immers, bij een te
grote tijdstap δt, de snelheid te groot is, zal het stromende vloeistofdeeltje de cel, met
grootte δx, al voorbij de cel gepasseerd zijn voor deze berekend kon worden. Dit zal dan
resulteren in een te groot Courant Number, waardoor we foutieve berekeningen zullen
bekomen. δx kunnen we als volgt berekenen:
d
δx = n
met d de totale afstand van het veld, en n het aantal cellen in de richting van de stroming.
We zien dus dat de tijdsstap een zeker invloed zal hebben op Courant number. Met
de gedachte C0 ≤ 1 in ons achterhoofd, zien we dat de tijdsstap klein genoeg genomen zal
moeten worden om deze C0 klein genoeg te houden. Wanneer we dus de vloeistofsnelheid
willen verhogen zullen we ook de tijdsstap moeten verkleinen om een precies resultaat
te bekomen. Algemeen moeten we dus ten aller tijde rekening houden met het feit dat
C0 ≤ 1 moet zijn.
1.3.2 Opdeling in OpenFOAM

Een standaard OpenFOAM-directory is opgebouwd uit verschillende deelmappen en
bestanden, nl. O, constant en system. Deze worden weergegeven in Figuur 1.13.
Hoofdstuk 1. OpenFOAM 11
Figuur 1.13: OpenFOAM-case met subdirectories en bestanden.
In de O-directory vinden we de verschillende variabelen terug. Veelgebruikte variabe-

len zijn onder andere p (dynamische druk) en U (snelheid). In deze bestanden worden
de eenheden van de variabelen gedeclareerd, alsook hun gedrag ten opzichte van de
verschillende elementen van de case. Tabel 1.1 geeft hierover meer duidelijkheid.
We zien dat de druk in p (Appendix A.1.1) gegeven wordt in [0 2 -2 0 0 0 0]. Aan de
2
hand van tabel 1.1 zien we dat de druk dus gegeven wordt in m s2
. Dezelfde redenering
geldt voor de snelheid (Appendix A.1.2). Deze wordt gegeven in m s.
De constant-directory bevat informatie over de kinematische viscositeitscoëfficiënt ν in
het bestand transportProperties; in de subdirectory polyMesh vinden we de informatie
over de mesh terug in het bestand blockMeshDict.
Hier kunnen we manueel de mesh-eigenschappen ingeven of door middel van voorgeschreven
convertors bijvoorbeeld ANSYS-bestanden omzetten naar bruikbare OpenFOAM-meshen.
Verder vinden we ook nog de system-directory met als belangerijkste bestand controlDict.
De begin- en eindtijd worden hier aangegeven, alsook de hiernet besproken tijdsstap. Een
andere belangerijke eigenschap die vermeld wordt in dit bestand is de gebruikte solver.
Nr Grootheid SI-Eenheid
1 Massa kg
2 Lengte m
3 Tijd s
4 Temperatuur K
5 Hoeveelheid stof kgmol
6 Stroom A
7 Lichtintensiteit cd
Tabel 1.1: Grootheden en Eenheden in OpenFOAM
Deze wordt hieronder besproken (Punt 1.3.3).
1.3.3 Solver
Deze solvers zijn een gesloten verzameling van verschillende oplossingsvergelijkingen en

algoritmes. Er is geen veregaande kennis nodig van deze wiskundige solvers, noch van
de C++-taal waarin deze geschreven zijn. Er is echter wel een zekere kennis nodig voor
het bewerken van deze standaardsolvers tot volwaardige en bruikbare solvers. Voor dit
onderzoek hebben we de keuze om gebruik te maken tussen verschillende solvers. De
bruikbaarste zijn:
• icoFoam: solver voor laminaire en onsamendrukbare Newtoniaanse stroming.

Deze solver zal gebruikt worden in de beginfase van het onderzoek. Dit gebeurt
enkel om de structuur en werkwijze van OpenFOAM te begrijpen. We dienen
wel te onthouden dat de icoFoam-solver enkel gebruikt mag worden voor lami-
naire stromingsgevallen. Wanneer we de snelheid verhogen of met een lagere vis-
cositeitscoëfficiënt werken, zullen we een andere solver moeten gebruiken. De piso-
en pimpleFoam-solver zijn daarbij de juiste keuze. Het verschil tussen beide zit in
het algoritme. Om een dynamische beweging te verkrijgen is deze icoFoam-solver
onbruikbaar en zullen we overstappen op de dynamisch pimpleDyMFoam-solver.
• icoDyMFoam: Dit is een samenraapsel van de piso- en simpleFoam-solver en

wordt gebruikt voor eenvoudige bewegende meshen. Deze solver werd echter in
vroegere versies van OpenFOAM gebruikt. In de huidige 1.6.x-versie van Open-
FOAM werd dit packet echter achterwege gelaten. De icoDyMFoam-solver wordt
vervangen door de pimpleDyMFOAM -solver en deze wordt gebruikt in het dy-
namische deel van dit onderzoek.
Voor een beschrijving van alle beschikbare solvers wordt doorverwezen naar de Open-
FOAM User Guide.
Hoofdstuk 1. Algemeen 13
1.4 Algemeen
Algemeen kunnen we dus stellen dat we, bij het opstellen van een OpenFOAM-project,
rekening moeten houden met de volgende zaken:
• Vuistregels in verband met de Courant Number C0 en de daarbij horende tijdsstap

δt .
• De opbouw van een project moet telkens de volgende subfolders hebben:
– 0: de druk p, snelheid U en later ook informatie over de dynamica van de

mesh (pointDisplacement).
– system: controlDict (informatie over de solver, begin- en eindtijd, tijdsstap,...)
en decomposeParDict (code om gebruik te maken van meerdere processoren
(Paragraaf 2.1.3)).
– constant: blockMeshDict (informatie over het uitzicht van de case en de mesh-
ing ervan) en informatie over soort stroming (laminair of turbulent).
• Solver: statische (icoFoam) of dynamische (pimpleDyMFoam) case.

Hoofdstuk 2
Onderzoek
2.1 Von Karman in OpenFOAM

2.1.1 Begincode
Om zeker te zijn van een betrouwbaar verloop van het onderzoek moet ook gebruik
gemaakt worden van een betrouwbare begincode. Deze is verkregen bij David Van
Cauteren die momenteel bezig is met een masterproef in OpenFOAM. De code bestaat
uit een blockdMeshDict-bestand die een cilinder in een windtunnel definiëert. Het geheel
is onderverdeeld in verschillende klein delen; het geheel is dus gemeshed. Deze mesh
zorgt ervoor dat we de case kunnen uitrekenen volgens de eindige elementen methode
en dit zal de complexiteit ervan behoorlijk vereenvoudigen. De eenvoudige mesh is
betrouwbaar genoeg om mee te beginnen, maar zal later nog vernauwd moeten worden
om precisiefouten zo veel mogelijk weg te werken. Hieronder wordt de eenvoudige mesh
visueel voorgesteld (Figuur 2.1).
Figuur 2.1: Voorstelling van de eenvoudige mesh na een tijdsverloop van 6 seconden.
De kinematische viscositeitscoëficiënt ν in het transportProperties-stand is voor gewone

2
lucht bij standaardomstandigheden en op een hoogte van 0 m ongeveer gelijk aan 1, 5.10−5 ms
(Appendix A.3.3). Deze coëficiënt geeft de mate van samenhang van de vloeiende stro-
15
16 Hoofdstuk 2. Onderzoek
ming aan. Uit deze kinematische viscositeitscoëficiënt ν kunnen we ook het Reynoldsgetal
Re halen volgens:
d.|U |
Re = ν
met d de diameter van de cilinder en —U— absolute waarde van de vloeistofsnelheid.

Het Reynoldsgetal geeft de mate van turbulentie in de stroming aan. Hoe groter deze is,
hoe turbulenter de stroming. In ons geval gaan we op zoek naar een eenvoudige weergave
van deze Von Karman-wervelstraten en gaan we de case beperken tot een laminaire
stroming. Ook is de gebruikte solver (icoFoam) beperkt tot het laminaire gebied. Bij
turbulente stroming moet overgeschakeld worden op een andere solver (bijvoorbeeld
pimpleFoam)
De snelheid van de stroming, die aangegeven wordt in het U -bestand van de 0 -
directory, wordt als voorbeeld op 0, 7 ms gezet. Zo zijn we zeker dat we binnen een
beperkte tijd de Von Karman-wervelstraten zien verschijnen. Wanneer we de snelheid
aanpassen moeten we, zoals eerder vermeld in punt 1.3.1 over de vuistregels, ook de
tijdsstap δt aanpassen in het controlDict-bestand.
C0 δx
δt = |U |
met C0 de Courant number en δx de celgrootte van het te berekenen deeltje van de

mesh.
Wanneer we deze code laten lopen zien we een duidelijk (Figuur 2.3 en 2.2) afscheiding
van de stroming waardoor we de Von Karman-wervelstraat zien ontstaan.
We zien echter dat bij de randen van de windtunnel nog te veel invloed hebben op het
verloop van de case. Dit zouden we eventueel kunnen verhelpen door een fijnere mesh
te maken. Dit wordt besproken in paragraaf 2.1.2.
Hoofdstuk 2. Von Karman in OpenFOAM 17
Figuur 2.2: Von Karman-wervels na een tijdsverloop van 4,3 seconden (vloeistofsnelheid)
Figuur 2.3: Von Karman-wervels na een tijdsverloop van 4,3 seconden (druk)
2.1.2 Code met fijnere mesh

De mesh waarmee we begonnen zijn is eenvoudig. Misschien wel iets te eenvoudig om
nauwkeurig genoeg te zijn. Deze eenvoud heeft als voordeel dat de rekentijd, nodig om
de case uit te rekenen, kort blijft. Het nadeel is dan weer dat de case minder nauwkeurig
wordt naarmate de mesh minder nauwkeurig wordt. De case is zo gemeshed dat het
gebied rond de cilinder wordt onderverdeeld in wederom een cilindrisch oppervlak, maar
dan met grotere straal. Door deze onderverdeling krijgen we een cilindervormige mesh
en kunnen we het gebied rond de cilinder fijner opdelen, wat nauwkeurigere resultaten
zou moeten geven. De cilindervormige mesh wordt in figuur 2.4 voorgesteld.
We zien dat de verfijnde mesh (Figuur 2.4) een beter resultaat geeft dan de oor-
spronkelijke mesh (Figuur 2.1). De oorzaak hiervan ligt in de grotere fijnheid van de
eerstgenoemde.
Figuur 2.4: Voorstelling van de verfijnde, cilindrisch opgedeelde mesh na een tijdsverloop van
3 seconden.
2.1.3 Code compileren in parallelmode

Een van de voordelen van OpenFOAM is de mogelijkheid om de case op te delen over
verschillende deelprocessen, die elk afzonderlijk berekend kunnen worden door verschil-
lende processoren. Dit voordeel kan uitgespeeld worden bij multicore-systemen. Door
een bijkomende decomposeParDict-file toe te voegen aan de system-subdirectory van
de case, kunnen we de verfijnde mesh even snel of zelf sneller berekenen als de oor-
spronkelijke mesh, terwijl we een nauwkeuriger resultaat bekomen! In dit bestand kun-
nen we het aantal processen (en dus ook het aantal processoren) aangeven evenals de
“gewichtsverdeling” van de processen over de processoren. Dit vereist echter wel een
krachtige computer met meerdere processoren, wat niet altijd voordelig uitkomt qua
prijs.
Tijdens het uitvoeren van mijn project heb ik echter wel het geluk gehad in het bezit
te zijn van een krachtige computer. De machine bevat een Intel Core i5 op 2,26 GHz
en 8 GB RAM; de overige onderdelen hebben weinig invloed op de rekentijd. Doordat
er gebruik gemaakt werd van een 64-bit Linux Operating System wordt al het geheugen
ook ondersteunt. Dit is niet het geval bij gebruik van een 32-bit OS, waar maar 3,2
GB RAM ondersteund kan worden. Deze Core i5 bestaat uit twee processorkernen die
elk twee threads kunnen berekenen. Het gebruikte Operating System ondersteunt deze
technologie waardoor we vier processen tegelijk kunnen uitrekenen.
Dit voordeel kan dus worden uitgebuit met het decomposePar -commando in de bash-
terminal. Door het invoeren van dit commando wordt de mesh van de case opgedeeld over
het opgegeven aantal subdomains in het decomposeParDict-bestand. Vervolgens voeren
we het volgende commando in de terminal in om de berekening te starten: mpirun -np
“x” “solver” -parallel. Hierbij geeft x het aantal processoren aan (bvb. n = 4) en geeft
solver de gebruikte solver aan (in het statische geval: icoFoam). Aan het einde van de
berekeningen moeten de resultaten van elke processor samengevoegd worden door het
reconstructPar -commando.
Samengevat moeten achtereenvolgende de volgende commando’s worden ingegeven in de
terminal om de case uit te rekenen en grafisch te analyseren:
Hoofdstuk 2. Von Karman in OpenFOAM 19
blockMesh
decomposePar
mpirun -np “x ” “solver ” -parallel
reconstructPar
paraFoam
Om een idee te geven van de tijdswinst door gebruik te maken van een verschillend
aantal processoren, is dit in tabel 2.1 en grafieken 2.5 en 2.6 weergegeven. Hier werd
een eenvoudige case (figuur 2.4) uitgerekend over een tijdspanne van 0.6 s en met een
tijdsstap 0.00005 s.
Aantal processoren Rekeningtijd Tijdswinst
1 2848 1
2 1804 1.58
3 1941 1.47
4 1995 1.43
Tabel 2.1: Rekentijd en snelheidswinst in functie van het aantal processoren
We zien dat de optimale rekentijd wordt bereikt bij het gebruik van twee processoren.
Dit moet echter met een korrel zout genomen worden. Er zijn verschillende manieren om
de case op te splitsen. Bij het aantonen van deze rekentijd hebben we gebruik gemaakt
van de eenvoudigste manier. Het is logisch dat bij gebruik van een betere en dus meer
ingewikkelde verdeling, we ook snellere rekentijden kunnen en hoogstwaarschijnlijk zullen
verkrijgen. Dit valt echter niet in het bestek van het onderzoek en daarom gaan we hier
niet verder op in. We gaan voor het berekenen van de dynamische cilinder de eenvoudige
manier van opsplitsen van de mesh over de processoren gebruiken en dus enkel gebruik
maken van twee processoren.
Figuur 2.5: Tijd per processor, benodigd om case uit te rekenen
Figuur 2.6: Snelheidswinst van meerdere processoren t.o.v. n processor

Hoofdstuk 2. Dynamische beweging: movingCone-tutorial 21
2.2 Dynamische beweging: movingCone-tutorial

Om de eerste stap te zetten naar het bewegend maken van de verfijnde mesh, zullen we
gebruik maken van de movingCone-tutorial. Deze movingCone-case bevindt zich in de
/OpenFOAM/OpenFOAM-1.6.x/tutorials/incompressible/pimpleDyMFoam-directory.
Deze dynamische case beschrijft een bewegend object in een windtunnel met een open
inlet en gesloten outlet. We kunnen hier de druk en snelheid van het stromende fluı̈dum
bestuderen, maar dit valt buiten het bestek van dit onderzoek. Het onderzoek kan eerder
verder geholpen worden door de code voor het laten bewegen van de mesh. Bij het
compileren van de case, d.w.z. bij het invoeren van het blockMesh-, pimpleDyMFoam-
en paraFoam-commando in de linux-terminal, krijgen we de volgende visuele voorstelling
te zien van de case. Enkel het gedrag en de onderverdeling van de dynamische mesh
wordt bekeken en resulteert in het volgende:
Figuur 2.7: movingCone-mesh bij t = 0 s
Figuur 2.8: movingCone-mesh bij t = 0.001 s
We zien dat bij het bewegen van het voorwerp, de mesh links van de muur uitgerokken
wordt (en dus minder nauwkeurige resultaten zal geven) en de rechterkant ervan zal
krimpen (en dus nauwkeurigere resulaten zal geven).
Nu we dit principe onder de knie hebben, kunnen we de meer algemene eigenschap-
pen van de case bestuderen. Deze eigenschappen vinden we terug in de movingCone-
directory. We vinden, zoals bij elke OpenFOAM-case drie subdirectories terug: 0, system
en constant. Een screenshot hiervan geeft een duidelijker beeld (figuur 2.11).
Figuur 2.11: Bestanden in de movingCone-directory
2.2.1 De 0-directory
Deze directory bevat gegevens over het stromende fluı̈dum.
• U -bestand: dit bestand bevat de gegevens over hoe een fluı̈dum zal reageren op de
verschillende delen van case, zoals de cilinder en wanden van de windtunnel, maar
ook op de onzichtbare denkbeeldige delen van het geheel.
• p-bestand: dit bevat dezelfde soort gegevens als het U -bestand maar dan in ver-
band met de druk.
• pointMotionUx - en cellMotionUx -bestand.
2.2.2 De system-directory
Ook hier vinden we verschillende bestanden, die elk een deel van de bruikbare informatie
bevatten van de case. Van al deze bestanden is het controlDict-bestand het belangrijkste.
Deze bevat informatie over het soort solver er gebruikt wordt (in dit geval de pimpleDyM-
Foam-solver), de starten stoptijd, de tijdsstap, die gevonden wordt aan de hand van de
Hoofdstuk 2. Dynamische beweging: movingCylinder-case 23
vuistregel in paragraaf 1.3.1, en het schrijfinterval; deze geeft aan aan welke frequentie
de berekeningen daadwerkelijk weggeschreven moeten worden in de case-directory.
2.2.3 De constant-directory
Deze directory bevat de informatie over de opbouw van de case. Het blockMeshDict-
bestand deelt het geheel op in verschillende delen. Bij het meshen werd geen rekening
gehouden met de kwaliteit van de uitkomst. Door de grove opdeling is het resultaat
onnauwkeurig. We dienen dit dus te vermijden bij het implementeren van onze case.
2.3 Dynamische beweging: movingCylinder-case

Voor het bereiken een dynamische beweging van een cilinder starten we met twee gekende
cases:
• De cilindrische mesh van David Van Cauteren en
• De movingCone-tutorial, die inbegrepen is in het OpenFOAM-1.6.x-pakket.
Oorspronkelijk was het de bedoeling om de code van de statische cilinder te laten lijken
op de code van de movingCone-tutorial om de cilinder op soortgelijke manier te laten
oscilleren. De oscillatie bleek op deze manier onmogelijk. Daarbij kwam nog eens dat
bij het aanpassen en compileren van de statische mesh telkens een andere error werd
gegeven. Daarom werd een andere manier gezocht voor het implementeren van deze
beweging. Het was een topic op het CFD-online-forum (OpenCFD, 2008) dat nuttige
informatie bevatte.
2.3.1 De 0-directory
p
De inhoud van deze file wordt weergegeven in Appendix A.1.1. Deze file bevat de in-
formatie in verband met de druk. We zien aan de class volScalarField dat we met een
scalaire grootheid te maken hebben, waarvan dus enkel de grootte van belang is. We zien
2
dat de druk gegeven wordt in m s2
. Dit gebeurt volgens tabel 1.1.De druk gedraagt zich
aan alle wanden van de windtunnel en aan de cilinder overal gelijk en wordt aangegeven
door zeroGradient. De gradiënt geeft, zoals gezien in Wiskunde voor Ingenı̈eurs (2de
jaar), de richting aan van de maximale stijging van de stromingsfunctie. zeroGradiënt
geeft dat de functie zijn maximum al heeft bereikt. De wanden krijgen de opdracht
om de druk onaangetast te laten, waardoor de druk als het ware kan ontsnappen uit
de windtunnel. Dit is beter visualiseerbaar wanneer we de case visualiseren en enkel de
druk in beschouwing nemen.
De outlet en voor- en achterkant (frontAndBack) worden anders beschreven. De out-

let heeft de vorm fixedValue mee gekregen, met als uniformiteit nul. Dit wil zeggen dat
de tegenwerkende druk gelijk is aan een vaste waarde, aangegeven door nul. frontAnd-
Back heeft als type empty. Hierdoor wordt deze aanzien als zijnde niets. De windtunnel
is dus als het ware oneindig breed.
U
De inhoud van deze file wordt weergegeven in Appendix A.1.2.
De U-file bevat informatie over de snelheid van de stroming over de verschillende on-
derdelen van de case. In het begin van de file wordt de klasse van U gedeclareerd als
zijnde vectoriel (volVectorField ). De snelheid kan dus een bepaalde grootte en zin in
x-, y- en z-richting hebben. De ruimte tussen de wanden wordt beschouwd als open
en ideaal —dus wrijvingsloos—, waardoor de stroming hier vrij zal kunnen stromen.
Opnieuw treffen we het type empty aan voor de frontAndBack van de case.
De outlet wordt aangegeven als zeroGradı̈ent. Deze krijgt dus de opdracht om de stro-
mingssnelheid niet te veranderen, waardoor de stroming vrij kan wegstromen uit de
windtunnel.
De overige componenten, waarvan het type overigens gedeclareerd wordt in de block-
MeshDict-file (Appendix A.3.1) en beschreven wordt in een later onderdeel van deze
paper (Paragraaf 2.3.3), zijn van het type fixedValue. Enkel de inlet heeft een snelheid-
scomponent meegekregen, nl.(5 0 0). Dit wil zeggen dat er een stroming vloeit aan 5 m s
in de x-richting. De overige fixedValue-componenten bevatten geen snelheidsvectoren,
waardoor de stroming aan de rand van deze componenten nul zal zijn en dus stil staat.
Dit komt overeen met de werkelijkheid, waar de stroperigheid van de stroming ervoor
zorgt dat de stroming stil staat aan de wanden. Wanneer er gepoogd wordt de case te
simuleren op zo een manier dat de randen geen vertragend effect zouden hebben op de
stroming, dan zouden we het type zeroGradiënt moeten gebruiken, waarvan de betekenis
eerder werd aangehaald.
pointDisplacement
Dit is het bestand dat voor de beweging van de mesh zorgt en kan teruggevonden worden
in Appendix A.1.3. Deze is wellicht het belangrijkste bestand van het hele project. Als
de opbouw en functie van dit bestand begrepen wordt, is ons streefdoel, de dynamische
cilinder, bijzonder dichtbij.
We zien dat de klasse van dit bestand vectoriëel is. Dit is logisch, aangezien de cilinder
in verschillende richtingen kan oscilleren. De gewenste beweging is een sinusoı̈dale be-
weging volgens de y-as. Het OpenFOAM-packet bevat een voorschreven functie die deze
sinusoı̈dale functie kan verwezenlijken, nl. oscillatingDisplacement. Dit type wordt dus
meegegeven aan de te oscilleren cilinder. Enkel de hoeksnelheid ω en de amplitude dienen
meegegeven te worden. In deze case heb ik gepoogd de cilinder te laten bewegen met een
hoeksnelheid van 12 rad ω 12
s . Omgerekend naar frequentie geeft dit f = 2×π = 2×π = 1.91Hz.
Deze open neergaande beweging heeft een amplitude in de y-richting (0 -0.055 0).
Bij deze amplitudegrootte (-0.055 in de y-richting) moet rekening houden met de con-
vertToMeters-factor die aangegeven wordt in de /constant/polymesh/blockMeshDict-
directory. Deze is, voor deze case althans, gezet op 0.4825. Dit wil zeggen dat 1 meter
aangegeven in de blockMeshDict-file gelijk is aan 0.4825 meter in werkelijkheid. De os-
cillatingDisplacement houdt echter geen rekening met deze schalingsfactor, waardoor we
manueel moeten uitrekenen wat de amplitude moet zijn voor deze case. Dit alles kan
natuurlijk vermeden worden door de convertToMeters-factor gelijk te stellen aan 1.
obstacle
{
type oscillatingDisplacement;
omega 12;
amplitude (0 -0.055 0);
value uniform (0 0 0);
}
Verder zien we dat de overige componenten van de case allen fixedValues zijn met
waarde nul. Deze zullen dus niet bewegen gedurende het hele tijdsverloop.
2.3.2 De system-directory
controlDict
Deze file is als het ware de controlerende file van de case. De code ervan kan teruggevon-
den worden in Appendix A.2.1.
De controlDict-file is van het type dictionary. Letterlijk vertaald is dit woordenboek.
Bij het oplossen van de case zal OpenFOAM rekening moeten houden met de gegevens
die in deze dictionaries worden opgegeven.
Een van de belangrijkste gegevens in dit bestand is zonder twijfel de gebruikte Solver.
De solver is een voorgeschreven code voor een bepaald geval. Het verkeerd gebruiken
van een solver resulteert in een foutieve uitkomst. Zoals al opgegeven in paragraaf 1.3.3
zullen we voor deze case gebruik maken van pimpleDyMFoam-solver.
Niet enkel de soort solver wordt gegeven in dit bestand. Ook begin- en eindtijd wordt
gegeven, net als de grootte van de tijdstap en wegschrijffrequentie. Zoals uitgelegd in
de paragraaf over de Vuistregels in OpenFOAM (1.3.1) moet deze tijdstap klein genoeg
zijn om de case oplosbaar te maken.
decomposeParDict
Dit bestand wordt gebruikt in verband met het oplossen van de case over verschillende
processoren. Een uitgebreide bespreking hiervan werd reeds gedaan in paragraaf 2.1.3.
De code wordt gegeven in Appendix A.2.2.
fvSchemes, fvSolution en tetFemSolution

De code voor de fvSchemes wordt gegeven in Appendix A.2.3, die van fvSolution in
Appendix A.2.4 en die van tetFemSolution in Appendix A.2.5. In deze file kan bij
het uitrekenen gekeken worden naar hoe de case opgelost moet worden. Een uitgebreide
beschrijving van wat er allemaal beschreven staat in deze files wordt gegeven in paragraaf
4.4 van de OpenFOAM User Guide.
2.3.3 De constant-directory
polymesh/blockMeshDict
De blockMeshDict-file geeft het uitzicht van de case weer (Appendix A.3.1). De code
bestaat uit vijf belangrijke onderdelen.
1. convertToMeters – Hier wordt aangegeven wat de schaling is van de case ten
opzichte van de werkelijkheid. In deze blockMeshDict-file wordt de schaling op
0.4825 gezet. Dit betekent dat 1m in de case 0.4825m in werkelijkheid is.
2. vertices – Dit is het deel waar de basiscoördinaten van de case worden gedecla-
reerd. Deze coördinaten bestaan uit een x-, y- en z-component. Elke case moet
in 3 dimensies worden opgesteld, aangezien we met een vloeiende stroming werken
waarvan de onderdelen ook 3 dimensies hebben.
3. blocks – Hier worden verschillende coördinaten samengevoegd tot “blokken”. hex
geeft aan dat de verdeling gebeurt volgens een Hexahedron. Voor meer verdel-
ingswijzen wordt doorverwezen naar de OpenFOAM User Guide (Tabel 5.1).
4. edges – Om afgeronde randen te verkrijgen, kunnen we een rechte lijn laten omvor-
men tot een cirkelboog. Deze cirkelboog wordt in het edges-deel gedeclareerd.
5. patches – Hier worden de verschillende oppervlakteblokken samengevoegd tot een
volume-eenheid en een type toegekend.
dynamicMeshDict
Appendix A.3.2 geeft weer wat er in dit bestand wordt beschreven. Hier wordt
aangegeven welk algoritme gebruikt moet worden om de dynamische cilinder te verwezen-
lijken. Voor deze case wordt verwezen naar dynamicMotionSolverMesh. De gebruikte
solver voor deze beweging zal de displacementLaplacian zijn. Voor meer informatie over
de soorten solvers wordt doorverwezen naar de OpenFOAM User Guide.
transportProperties
Via dit bestand kunnen we de stroperigheid van de stromende vloeistof bepalen. Dit
doen we door de kinematische viscositeitscoëfficiënt ν te declareren. Zoals gezegd in
2
paragraaf 2.1.1 wordt deze in standaardomstandigheden gelijk gesteld aan 1, 5.10−5 ms .
Hoe de code er verder uit ziet vindt u in Appendix A.3.3.
turbulenceProperties
Deze file bevat de informatie over de turbulentie van de stroming. We houden het
eenvoudig en werken dus enkel met een laminaire stroming. De code kan teruggevonden
worden in Appendix A.3.4.
Hoofdstuk 3
Conclusie
3.1 Samenvatting
De doelstellingen van dit onderzoek is behaald. Er is een zo duidelijk mogelijke beschrijv-
ing gegeven van de werking van OpenFOAM. Het is nu geweten welke de basisbestanden
en -mappen zijn van een eenvoudige OpenFOAM-case en met welke vuistregels men
rekening zal moeten houden.
Met deze kennis is de ultieme doelstelling met succes tot een goed einde gebracht.
Deze bestond er in een eenvoudige cilinder in een windtunnel te laten oscilleren. De code
hiervan kan terug gevonden worden in de bijlage.
3.2 Verder onderzoek

Voor verder onderzoek bestaan verschillende mogelijkheden. Zo lijkt het in de eerste
plaats interessant om de oscillerende cilinder te vervangen door een oscillerende vleugel-
profiel. Vervolgens ligt het aanleggen van een oscillatie ten opzichte van het aerody-
namisch centrum van de vleugel tot de mogelijkheden.
Om flutter zelf te creëren moet meer literair onderzoek verricht worden en is ook
meer ervaring en kennis van OpenFOAM vereist.
29
30 Hoofdstuk 3. Conclusie
Bijlage A
Code van de Dynamische Cilinder
A.1 0 -directory
A.1.1 p
/*--------------------------------*- C++ -*----------------------------------*\

| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6.x |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 0;
boundaryField
{
upperWall
{
type zeroGradient;
31
32 Hoofdstuk A. Code van de Dynamische Cilinder
lowerWall
{
type zeroGradient;
}
obstacle
{
type zeroGradient;
}
inlet
{
type zeroGradient;
}
outlet
{
type fixedValue;
value uniform 0;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //
A.1.2 U
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
Hoofdstuk A. 0-directory 33
format ascii;
class volVectorField;
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
upperWall
{
type fixedValue;
}
lowerWall
{
type fixedValue;
}
obstacle
{
type fixedValue;
}
inlet
{
type fixedValue;
}
outlet
{
type zeroGradient;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //
A.1.3 pointDisplacement
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class pointVectorField;
object pointMotionU;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
obstacle
{
type oscillatingDisplacement;
omega 12;
amplitude (0 -0.055 0);
}
upperWall
{
type fixedValue;
}
Hoofdstuk A. 0-directory 35
lowerWall
{
type fixedValue;
}
inlet
{
type fixedValue;
}
outlet
{
type fixedValue;
}
frontAndBack
{
type empty;
}
// ************************************************************************* //
A.2 system-directory
A.2.1 controlDict
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application pimpleDyMFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 3;
deltaT 0.00005;
writeControl timeStep;
writeInterval 50;
purgeWrite 0;
writeFormat ascii;
writePrecision 6;
writeCompression uncompressed;
Hoofdstuk A. system-directory 37
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
adjustTimeStep no;
maxCo 1;
// ************************************************************************* //
A.2.2 decomposeParDict
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / A nd | Web: www.OpenFOAM.org |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 2;
method simple;
simpleCoeffs
{
n ( 2 1 1 );
delta 0.001;
}
hierarchicalCoeffs
{
n ( 3 1 1 );
delta 0.001;
order xyz;
}
metisCoeffs
{
processorWeights ( 1 1 1 1 );
}
manualCoeffs
{
dataFile "";
}
distributed no;
roots ( );
// ************************************************************************* //
A.2.3 fvSchemes
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
grad(p) Gauss linear;
}
divSchemes
{
default none;
div(phi,U) Gauss linear;
div((nuEff*dev(grad(U).T()))) Gauss linear uncorrected;
}
laplacianSchemes
{
default none;
laplacian(nu,U) Gauss linear corrected;
laplacian((1|A(U)),p) Gauss linear corrected;
laplacian(diffusivity,cellDisplacement) Gauss linear uncorrected;
laplacian(nuEff,U) Gauss linear corrected;
laplacian(rAU,p) Gauss linear corrected;
interpolationSchemes
{
default linear;
interpolate(HbyA) linear;
}
snGradSchemes
{
default corrected;
}
fluxRequired
{
default no;
p;
}
// ************************************************************************* //
A.2.4 fvSolution
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
pcorr
{
solver PCG;
preconditioner DIC;
tolerance 0.01;
relTol 0;
}
p
{
solver PCG;
preconditioner DIC;
tolerance 1e-06;
relTol 0.05;
}
pFinal
{
solver PCG;
preconditioner DIC;
tolerance 1e-06;
relTol 0;
}
U
{
solver PBiCG;
preconditioner DILU;
tolerance 1e-05;
relTol 0;
}
cellDisplacement
{
solver PCG;
preconditioner DIC;
tolerance 1e-08;
relTol 0;
}
}
PIMPLE
{
nOuterCorrectors 2;
nCorrectors 1;
nNonOrthogonalCorrectors 0;
}
// ************************************************************************* //
A.2.5 tetFemSolution
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format binary;
class dictionary;
location "system";
object tetFemSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
motionU ICCG 1e-06 0;
}
// ************************************************************************* //
Hoofdstuk A. constant-directory 43
A.3 constant-directory
A.3.1 polyMesh
blockMeshDict
/*--------------------------------*- C++ -*----------------------------------*\

| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 0.4825;
vertices
(
//Achterkant
(0 0 -0.01) //0
(0 1.5 -0.01) //1
(1.5 1.5 -0.01) //2
(5 1.5 -0.01) //3
(5 0 -0.01) //4
(1.5 0 -0.01) //5
(0.467157287525381 0.467157287525381 -0.01) //6
(0.467157287525381 1.032842712474619 -0.01) //7
(1.032842712474619 1.032842712474619 -0.01) //8
(1.032842712474619 0.467157287525381 -0.01) //9
(0.714644660940673 0.714644660940673 -0.01) //10
(0.714644660940673 0.785355339059327 -0.01) //11
(0.785355339059327 0.785355339059327 -0.01) //12
(0.785355339059327 0.714644660940673 -0.01) //13
//Voorkant
(0 0 0.01) //14
(0 1.5 0.01) //15

(1.5 1.5 0.01) //16
(5 1.5 0.01) //17
(5 0 0.01) //18
(1.5 0 0.01) //19
(0.467157287525381 0.467157287525381 0.01) //20
(0.467157287525381 1.032842712474619 0.01) //21
(1.032842712474619 1.032842712474619 0.01) //22
(1.032842712474619 0.467157287525381 0.01) //23
(0.714644660940673 0.714644660940673 0.01) //24
(0.714644660940673 0.785355339059327 0.01) //25
(0.785355339059327 0.785355339059327 0.01) //26
(0.785355339059327 0.714644660940673 0.01) //27
);
blocks
(
hex (0 6 7 1 14 20 21 15) (40 40 1) simpleGrading (1 1 1)
);
edges
(
arc 11 12 (0.75 0.8 -0.01)
arc 25 26 (0.75 0.8 0.01)
arc 12 13 (0.8 0.75 -0.01)
arc 26 27 (0.8 0.75 0.01)
arc 13 10 (0.75 0.7 -0.01)
arc 27 24 (0.75 0.7 0.01)
arc 10 11 (0.7 0.75 -0.01)
arc 24 25 (0.7 0.75 0.01)
arc 7 8 (0.75 1.15 -0.01)
arc 21 22 (0.75 1.15 0.01)
arc 8 9 (1.15 0.75 -0.01)
arc 22 23 (1.15 0.75 0.01)
arc 9 6 (0.75 0.35 -0.01)
arc 23 20 (0.75 0.35 0.01)

arc 6 7 (0.35 0.75 -0.01)
arc 20 21 (0.35 0.75 0.01)
arc 2 5 (1.810660171779821 0.75 -0.01)
arc 16 19 (1.810660171779821 0.75 0.01)
);
patches
(
wall upperWall
(
(1 15 16 2)
(2 16 17 3)
)
wall lowerWall
(
(0 5 19 14)
(5 4 18 19)
)
wall obstacle
(
(10 11 25 24)
(11 12 26 25)
(13 27 26 12)
(10 24 27 13)
)
patch inlet
(
(0 14 15 1)
)
patch outlet
(
(4 3 17 18)
)
empty frontAndBack
(
(0 1 7 6)
(6 7 11 10)
(7 1 2 8)
(11 7 8 12)
(13 12 8 9)
(9 8 2 5)
(6 10 13 9)
(0 6 9 5)
(5 2 3 4)
(14 20 21 15)
(20 24 25 21)
(21 22 16 15)
(25 26 22 21)
(27 23 22 26)
(23 19 16 22)
(20 23 27 24)
(14 19 23 20)
(19 18 17 16)
)
);
mergePatchPairs
(
);
// ************************************************************************* //
A.3.2 dynamicMeshDict
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format binary;
class dictionary;
location "constant";
object dynamicMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dynamicFvMesh dynamicMotionSolverFvMesh;
motionSolverLibs ( "libfvMotionSolvers.so" );
solver displacementLaplacian;
diffusivity uniform ( 1 200 0 );
// ************************************************************************* //
A.3.3 transportProperties
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// [kg m s K A mol cd] => kinematische viscositeit
transportModel Newtonian;
nu nu [0 2 -1 0 0 0 0] 1.5e-05;
// ************************************************************************* //
A.3.4 turbulenceProperties
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType laminar;
// ************************************************************************* //
Bibliografie
Anderson, J. D. (2008). Introduction to Flight. McGraw-Hill Professional, 6th edition.
Dowell, E. H. (2004). Dynamic aeroelasticity. In A Modern Course in Aeroelasticity,

pages 53–168.
Hodges, D. H. and Pierce, G. A. (2002). Introduction to Structural Dynamics and

Aeroelasticity. Cambridge University Press.
OpenCFD (2008). Using version 1.5 - oscillating cylinder. http://www.cfd-

online.com/Forums/openfoam-solving/57896-using-version-15-oscillating-
cylinder.html, Laatst bekeken: 13 April 2010.
OpenFoam (2010). User Guide.
Scanlan, R. and Simiu, E. (2004). Aeroelasticity in civil engineering. In A Modern

Course in Aeroelasticity, pages 299–376.
Theodorsen, T. (1944). Experiments on drag of revolving disks, cylinders, and streamline

rods at high speeds.
49

Jonas Lintermans - Bewegende Cilinder in OpenFOAM

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Jonas Lintermans - Bewegende Cilinder in OpenFOAM

Hochgeladen von

Copyright:

Verfügbare Formate

Het dynamisch maken van een cilinder in

een windtunnel met behulp van

Begeleiders: Dr. Tim De Troyer en Dr. Mark Runacres

constructie en de eerste vlucht van het vliegtuig, belangerijk zijn.

Daartegenover staat flutter. Deze treedt op wanneer de traagheidskrachten groot

• Lift voor een gegeven vliegtuig voor een bepaalde aanvalshoek

• Load Factor die een vliegtuig maximaal kan weerstaan.

• Reactie van een vliegtuig bij turbulentie of windvlagen

• Reactie op wervels, die ontstaan na vleugels of andere onderdelen.

1.2.1 Statische Stabiliteit

1.2.2 Dynamische Stabiliteit

Figuur 1.2: Verstoring van de evenwichtsaanvalshoek (Anderson, 2008)

Wanneer we de verplaatsing α − αe in functie van de tijd bekijken onderscheiden

Figuur 1.3: Aperiodieke oscilatie, dynamisch stabiel (Anderson, 2008)

Figuur 1.4: Gedempte oscilatie, dynamisch stabiel (Anderson, 2008)

Figuur 1.5: Dynamische oscilatie, dynamisch instabiel (Anderson, 2008)

Figuur 1.6: Fluttermodel volgens Hodges.

Wanneer we flutter gaan bestuderen in het tijdsdomein en frequentiedomein, vallen

Figuur 1.8: Respons van de vleugel op de willekeurige exitatie (Dowell, 2004)

Figuur 1.10: Spectrum van de transferfunctie (Dowell, 2004)

Parameters van flutter (Dowell, 2004)

Frequentieverhouding De fluttersnelheid is het laagst bij ωωαh ∼= 1. Zoals gezien zullen

Figuur 1.11: Fluttersnelheiding in functie van a) wringing-buiging-frequentieverhouding en b)

Hoogte Door een daling van de geluidsnelheid en de relatie tussen de snelheid en

Hoe flutter tegen gaan

Figuur 1.12: Flutter bij stijgende hoogte en Mach-getal. (Dowell, 2004)

logisch. We kunnen dit bereiken door de fluttersnelheid op te trekken zonder toevoeging

• Het vliegtuig trager dan zijn kritische Mach-snelheid laten vliegen.

• Demping aan de structuur toevoegen

• Wringingsstijfheid vergroten (dus ωα vergroten)

We kunnen de Courant number definiëren als:

met δt de tijdsstap, |U | de vloeistofsnelheid en δx de celgrootte in de richting van de

1.3.2 Opdeling in OpenFOAM

Figuur 1.13: OpenFOAM-case met subdirectories en bestanden.

In de O-directory vinden we de verschillende variabelen terug. Veelgebruikte variabe-

Tabel 1.1: Grootheden en Eenheden in OpenFOAM

Deze wordt hieronder besproken (Punt 1.3.3).

Deze solvers zijn een gesloten verzameling van verschillende oplossingsvergelijkingen en

• icoFoam: solver voor laminaire en onsamendrukbare Newtoniaanse stroming.

• icoDyMFoam: Dit is een samenraapsel van de piso- en simpleFoam-solver en

• Vuistregels in verband met de Courant Number C0 en de daarbij horende tijdsstap

• De opbouw van een project moet telkens de volgende subfolders hebben:

– 0: de druk p, snelheid U en later ook informatie over de dynamica van de

• Solver: statische (icoFoam) of dynamische (pimpleDyMFoam) case.

2.1 Von Karman in OpenFOAM

De kinematische viscositeitscoëficiënt ν in het transportProperties-stand is voor gewone

met d de diameter van de cilinder en —U— absolute waarde van de vloeistofsnelheid.

met C0 de Courant number en δx de celgrootte van het te berekenen deeltje van de

2.1.2 Code met fijnere mesh

2.1.3 Code compileren in parallelmode

mpirun -np “x ” “solver ” -parallel

Aantal processoren Rekeningtijd Tijdswinst

Tabel 2.1: Rekentijd en snelheidswinst in functie van het aantal processoren

Figuur 2.5: Tijd per processor, benodigd om case uit te rekenen

Figuur 2.6: Snelheidswinst van meerdere processoren t.o.v. n processor

2.2 Dynamische beweging: movingCone-tutorial

Figuur 2.7: movingCone-mesh bij t = 0 s

Figuur 2.8: movingCone-mesh bij t = 0.001 s

Figuur 2.9: movingCone-mesh bij t = 0.002 s

Figuur 2.10: movingCone-mesh bij t = 0.003 s

Figuur 2.11: Bestanden in de movingCone-directory

• pointMotionUx - en cellMotionUx -bestand.

2.3 Dynamische beweging: movingCylinder-case

/--------------------------------- C++ -----------------------------------\

/--------------------------------- C++ -----------------------------------\