Jonas Lintermans - Bewegende cilinder in OpenFOAM

Het dynamisch maken van een cilinder ineen windtunnel met behulp van

OpenFOAM

Onderzoekstechnieken 3 academiejaar: 2009-2010

Jonas Lintermans

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

Inleiding

Tegenwoordig is het gebruikelijk om naast praktisch onderzoek ook een deel van hetonderzoek 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 datbij tests tijdens de vlucht de kostprijs inderdaad hoog kan oplopen, door ondermeer hetbrandstofverbruik etc.

Ook het gevaar voor aero-elastische effecten als flutter zijn logischerwijs afwezig bijcomputationele simulatie. Tegenwoordig komen deze simulaties qua correctheid aardigin 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 verschillendestappen. Uitgaande van een overgenomen code van David Van Cauteren, zullen we debasisideeen van OpenFOAM onder de knie proberen te krijgen. Het is van groot belangom elk element van de OpenFOAM-case voldoende te begrijpen. Dan pas kunnen weover gaan naar de laatste stap, waar we een lineaire kracht aanbrengen op de gecreeerdecilinder om deze te doen bewegen volgens een sinisoıdaal pad.

Tijdens het onderzoek viel ik ook op andere zaken, die niet altijd evenveel te makenhadden met de onderzoeksopdracht, maar wel van belang kunnen zijn voor de algemenekennis van OpenFOAM. Ondermeer het opdelen van de case over een aantal processorenen de snelheidswinst ervan komt aan bod.

i

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 31A.1 0 -directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

A.1.1 p . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31A.1.2 U . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32A.1.3 pointDisplacement . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

A.2 system-directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36A.2.1 controlDict . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36A.2.2 decomposeParDict . . . . . . . . . . . . . . . . . . . . . . . . . . . 37A.2.3 fvSchemes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38A.2.4 fvSolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40A.2.5 tetFemSolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

A.3 constant-directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43A.3.1 polyMesh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43A.3.2 dynamicMeshDict . . . . . . . . . . . . . . . . . . . . . . . . . . . 46A.3.3 transportProperties . . . . . . . . . . . . . . . . . . . . . . . . . . 47A.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 wordenhieronder 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 (Hodgesand Pierce, 2002). Deze studie kunnen we indelen in verschillende vlakken: de in-teractie tussen elasticiteit en dynamica (structurele dynamica); de interactie tussenaero-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 negatievezin beınvloeden. Bij de ontwikkeling van vliegtuigen moet rekening gehouden wordenmet deze aero-elasticiteit. Men zal de negatieve invloeden proberen te beperken, terwijlmen de positieve invloeden zal proberen uit te buiten. Die uitbuiting kan een groteinvloed 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 hetcomfort 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 gevolghebben, zonder enige vorm van waarschuwing vooraf. In theorie hebben deze aero-elastische problemen een statische en dynamische oorzaak. Dynamische oorzaken liggenvoor de hand. Aero-elastische problemen ontstaan hierbij door de krachtenwerking opde structuur tijdens de vlucht. Kleine statische traagheidskrachten hebben in theoriegeen invloed op de aero-elastische effecten; grote traagheidskrachten daarentegen mogenniet verwaarloosd worden. Aangezien dit niet het geval is in de praktijk door , kunnensommige aero-elastische fenomenen beschreven worden door kleine vervormingsbeweg-ingen uit te voeren op de structuur. Deze bewegingen kunnen soms aantonen of destructuur naar wens zal reageren op de verkregen krachten in vlucht, dan wel dat dezecompleet 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 structureeloptimale systemen.

Niet alleen spelen aero-elastische fenomenen een rol bij vliegtuigvleugels, maar ookbij windturbinebladen en zelfs bij versterkers van muziekinstrumenten.

1.2 Stabiliteit

Het meest voorkomende aero-elastisch probleem is die van de stabiliteit (Hodges andPierce, 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 krachtendie markant vergroten in functie van de snelheid, terwijl de elasticiteitsmodulus vanhet gebruikte materiaal onafhankelijk is van de snelheid. Wanneer de aero-dynamischekrachten de elastische krachten overwinnen zien we twee mogelijkheden. Wanneer deiertiekrachten klein zijn, en dus weinig invloed hebben op het systeem, spreken we vandivergentie. 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 dezehet zal begeven. Bij de constructie van de vliegtuigen zal men dus nauwkeurig moetenbepalen 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 grootzijn en dus wel belangerijk zijn. Zowel flutter als divergentie kunnen catastrofaal zijn.

Door de studie van het divergentieverschijnsel bij kleine traagheidskrachten kunnenwe 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 wordenvoor 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 zijninitiele positie (Anderson, 2008). Het omgekeerde noemen we statische instabiliteit.Hierbij zullen de krachten en momenten ervoor zorgen dat het geheel verder afwijkt vande evenwichtstoestand. Neutrale stabiliteit —waar het systeem na verstoring op zijnhuidige positie blijft— komt vrijwel nooit voor bij vliegtuigen. We kunnen besluitendat de statische stabiliteit ervoor zorgt dat het geheel al dan niet terug keert naar zijninitiele positie. Deze zegt echter niets over de manier waarop deze zal terugkeren, datdoet de dynamische stabiliteit.

1.2.2 Dynamische Stabiliteit

De dynamische stabiliteit wordt bepaald door de geschiedenis van de beweging van hetsysteem nadat deze heeft gereageerd op zijn statische stabiliteit (Anderson, 2008). Dezegeeft 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 ofAttack 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 onderscheidenwe drie gevallen. Elk geval heeft hetzelfde beginpunt, bij t = 0 zal elk geval dezelfdeaanvalshoek α hebben. Wanneer het systeem statisch stabiel —wat in bijna alle gevallenzo is— zal de verplaatsing α − αe verkleinen. Bij het eerste geval zal de verplaatsingmeteen uitdoven en het systeem zal meteen naar de evenwichtspositie gaan. Dit noemt


met een aperiodische beweging. Het systeem kan ook dempend oscillerend en na verloopvan tijd uit te doven tot het evenwichtspunt. Deze twee eerste gevallen, weergegevenop Figuur 1.4 worden dynamisch stabiel genoemd. We kunnen dus concluderen dateen lichaam statisch stabiel is wanneer het na verloop van tijd terug keert naar zijnevenwichtspositie.

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 lichamennooit behouden.

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

We kunnen besluiten dat een dynamisch stabiel lichaam altijd statisch stabiel moetzijn. Het omgekeerde geldt wel niet altijd. Het is wel van groot belang om er eerst voorte 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 welkefactoren rekening moet worden gehouden. We kunnen flutter eenvoudig voorstellen doormiddel van Figuur 1.6. Hierop zien we dat de flutterbeweging wordt ontbonden in 2componenten: een wringende component

Figuur 1.6: Fluttermodel volgens Hodges.

Wanneer we flutter gaan bestuderen in het tijdsdomein en frequentiedomein, vallener bepaalde dingen op (Dowell, 2004).

In Figuur 1.8 zien we dat de impulsrespons een welbepaalde periodiciteit heeft metverschillende amplituden. Het willekeurig ingangssignaal wordt door de vleugel gefilterd,zodat enkel de frequenties die dicht bij de eigenfrequenties van het vliegtuig liggen wordenovergedragen naar het impulsrespons (Dowell, 2004).

Dit fenomeen is duidelijker zichtbaar in het frequentiedomein. Hierbij gaan we depolen van het reele en imaginaire deel van transferfunctie uitzetten ten opzichte van devliegsnelheid. 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 deimaginaire frequenties negatief ωI wordt. Fysische betekent dit dat het systeem instabielwordt en ongecontroleerd gaat oscilleren.

Bij de uitzetting van het spectrum van de responsfunctie in figuur 1.10 zien wetwee pieken; de eerste bij buigingsfrequentie ωh, de tweede bij wringingsfrequentie ωα.Wanneer de vliegsnelheid de fluttersnelheid benadert, zullen de pieken als maar meersamenvallen. In de praktijk moet volgens Theodorsen’s klassieke leer de verhoudingkleiner blijven dan 1,2 (Theodorsen, 1944). Wanneer dit zo is, kunnen we gerust zijndat 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-dynamischecentrum te liggen. Wanneer dit het geval is treedt er doorgaans minder makkelijk flutterop.

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 aan1, maar deze keer dan van het Mach-getal. Bij een Mach-getal M � 1 krijgen we eenverandering in dichtheid van het fluıdum. Hierdoor krijgen we dat UF ∼M

12 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 enhet Mach-getal, nl. U = Maα, kunnen we stellen dat de fluttersnelheid zal stijgen bijstijgende hoogte en stijgend Mach-getal. Zie Figuur 1.12.

Reynolds Getal Hoe hoger het Reynolds getal, hoe turbulenter de stroming. Dezeturbulentie zorgt voor wervelingen in de stroming. Hoewel flutter een fenomeen is dataltijd gepaard gaat met het afscheiden van wervels waarvan de frequentie gelijk is aan deflutter 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 eigenfrequentievan de structuur (Scanlan and Simiu, 2004).

Hoe flutter tegen gaan

Het is van kapitaal belang dat we steeds onder de fluttersnelheid blijven, om destructievegevolgen 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 toevoegingvan 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

• De ’buiging-wringing’-frequentieverhouding ωhωα

vergroten of verkleinen voor eenconstante ωα

• Wringingsstijfheid vergroten (dus ωα vergroten)


1.3 OpenFOAM

Voor het CFD-onderzoek naar de verschillende factoren die flutter beınvloeden makenwe, zoals eerder uitgelegd in de literatuurstudie, gebruik van het Open Source-programmaOpenFOAM. Voor we starten met het echte onderzoek moeten we enkele principes enalgemeenheden 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 rekeningte houden met de zogenaamde Courant number. Deze moeten we lager dan n proberente houden.

C0 ≤ 1

We kunnen de Courant number definieren als:

C0 = δt.|U |δx

met δt de tijdsstap, |U | de vloeistofsnelheid en δx de celgrootte in de richting van destroming. 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 groterworden. Daardoor zijn ook de snelheid en tijdstap belangerijk. Als immers, bij een tegrote tijdstap δt, de snelheid te groot is, zal het stromende vloeistofdeeltje de cel, metgrootte δx, al voorbij de cel gepasseerd zijn voor deze berekend kon worden. Dit zal danresulteren in een te groot Courant Number, waardoor we foutieve berekeningen zullenbekomen. δx kunnen we als volgt berekenen:

δx = dn

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. Metde gedachte C0 ≤ 1 in ons achterhoofd, zien we dat de tijdsstap klein genoeg genomen zalmoeten worden om deze C0 klein genoeg te houden. Wanneer we dus de vloeistofsnelheidwillen verhogen zullen we ook de tijdsstap moeten verkleinen om een precies resultaatte bekomen. Algemeen moeten we dus ten aller tijde rekening houden met het feit datC0 ≤ 1 moet zijn.

1.3.2 Opdeling in OpenFOAM

Een standaard OpenFOAM-directory is opgebouwd uit verschillende deelmappen enbestanden, 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 wordende eenheden van de variabelen gedeclareerd, alsook hun gedrag ten opzichte van deverschillende 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

hand van tabel 1.1 zien we dat de druk dus gegeven wordt in m2

s2. Dezelfde redenering

geldt voor de snelheid (Appendix A.1.2). Deze wordt gegeven in ms .

De constant-directory bevat informatie over de kinematische viscositeitscoefficient ν inhet bestand transportProperties; in de subdirectory polyMesh vinden we de informatieover de mesh terug in het bestand blockMeshDict.

Hier kunnen we manueel de mesh-eigenschappen ingeven of door middel van voorgeschrevenconvertors 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. Eenandere belangerijke eigenschap die vermeld wordt in dit bestand is de gebruikte solver.


Nr Grootheid SI-Eenheid

1 Massa kg2 Lengte m3 Tijd s4 Temperatuur K5 Hoeveelheid stof kgmol6 Stroom A7 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 enalgoritmes. Er is geen veregaande kennis nodig van deze wiskundige solvers, noch vande C++-taal waarin deze geschreven zijn. Er is echter wel een zekere kennis nodig voorhet bewerken van deze standaardsolvers tot volwaardige en bruikbare solvers. Voor ditonderzoek hebben we de keuze om gebruik te maken tussen verschillende solvers. Debruikbaarste zijn:

• icoFoam: solver voor laminaire en onsamendrukbare Newtoniaanse stroming.Deze solver zal gebruikt worden in de beginfase van het onderzoek. Dit gebeurtenkel om de structuur en werkwijze van OpenFOAM te begrijpen. We dienenwel te onthouden dat de icoFoam-solver enkel gebruikt mag worden voor lami-naire stromingsgevallen. Wanneer we de snelheid verhogen of met een lagere vis-cositeitscoefficient werken, zullen we een andere solver moeten gebruiken. De piso-en pimpleFoam-solver zijn daarbij de juiste keuze. Het verschil tussen beide zit inhet algoritme. Om een dynamische beweging te verkrijgen is deze icoFoam-solveronbruikbaar en zullen we overstappen op de dynamisch pimpleDyMFoam-solver.

• icoDyMFoam: Dit is een samenraapsel van de piso- en simpleFoam-solver enwordt gebruikt voor eenvoudige bewegende meshen. Deze solver werd echter invroegere versies van OpenFOAM gebruikt. In de huidige 1.6.x-versie van Open-FOAM werd dit packet echter achterwege gelaten. De icoDyMFoam-solver wordtvervangen 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 demesh (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 gebruikgemaakt worden van een betrouwbare begincode. Deze is verkregen bij David VanCauteren die momenteel bezig is met een masterproef in OpenFOAM. De code bestaatuit een blockdMeshDict-bestand die een cilinder in een windtunnel definieert. Het geheelis onderverdeeld in verschillende klein delen; het geheel is dus gemeshed. Deze meshzorgt ervoor dat we de case kunnen uitrekenen volgens de eindige elementen methodeen dit zal de complexiteit ervan behoorlijk vereenvoudigen. De eenvoudige mesh isbetrouwbaar genoeg om mee te beginnen, maar zal later nog vernauwd moeten wordenom precisiefouten zo veel mogelijk weg te werken. Hieronder wordt de eenvoudige meshvisueel voorgesteld (Figuur 2.1).

Figuur 2.1: Voorstelling van de eenvoudige mesh na een tijdsverloop van 6 seconden.

De kinematische viscositeitscoeficient ν in het transportProperties-stand is voor gewonelucht bij standaardomstandigheden en op een hoogte van 0 m ongeveer gelijk aan 1, 5.10−5m

2

s(Appendix A.3.3). Deze coeficient geeft de mate van samenhang van de vloeiende stro-

15

16 Hoofdstuk 2. Onderzoek

ming aan. Uit deze kinematische viscositeitscoeficient ν kunnen we ook het ReynoldsgetalRe halen volgens:

Re = d.|U |ν

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 weergavevan deze Von Karman-wervelstraten en gaan we de case beperken tot een laminairestroming. Ook is de gebruikte solver (icoFoam) beperkt tot het laminaire gebied. Bijturbulente stroming moet overgeschakeld worden op een andere solver (bijvoorbeeldpimpleFoam)

De snelheid van de stroming, die aangegeven wordt in het U -bestand van de 0 -directory, wordt als voorbeeld op 0, 7ms gezet. Zo zijn we zeker dat we binnen eenbeperkte tijd de Von Karman-wervelstraten zien verschijnen. Wanneer we de snelheidaanpassen moeten we, zoals eerder vermeld in punt 1.3.1 over de vuistregels, ook detijdsstap δt aanpassen in het controlDict-bestand.

δt = C0δx|U |

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

Wanneer we deze code laten lopen zien we een duidelijk (Figuur 2.3 en 2.2) afscheidingvan 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 hetverloop van de case. Dit zouden we eventueel kunnen verhelpen door een fijnere meshte 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 omnauwkeurig genoeg te zijn. Deze eenvoud heeft als voordeel dat de rekentijd, nodig omde case uit te rekenen, kort blijft. Het nadeel is dan weer dat de case minder nauwkeurigwordt naarmate de mesh minder nauwkeurig wordt. De case is zo gemeshed dat hetgebied rond de cilinder wordt onderverdeeld in wederom een cilindrisch oppervlak, maardan met grotere straal. Door deze onderverdeling krijgen we een cilindervormige meshen kunnen we het gebied rond de cilinder fijner opdelen, wat nauwkeurigere resultatenzou 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 deeerstgenoemde.


Figuur 2.4: Voorstelling van de verfijnde, cilindrisch opgedeelde mesh na een tijdsverloop van3 seconden.

2.1.3 Code compileren in parallelmode

Een van de voordelen van OpenFOAM is de mogelijkheid om de case op te delen oververschillende deelprocessen, die elk afzonderlijk berekend kunnen worden door verschil-lende processoren. Dit voordeel kan uitgespeeld worden bij multicore-systemen. Dooreen bijkomende decomposeParDict-file toe te voegen aan de system-subdirectory vande 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 eenkrachtige computer met meerdere processoren, wat niet altijd voordelig uitkomt quaprijs.

Tijdens het uitvoeren van mijn project heb ik echter wel het geluk gehad in het bezitte zijn van een krachtige computer. De machine bevat een Intel Core i5 op 2,26 GHzen 8 GB RAM; de overige onderdelen hebben weinig invloed op de rekentijd. Doordater gebruik gemaakt werd van een 64-bit Linux Operating System wordt al het geheugenook ondersteunt. Dit is niet het geval bij gebruik van een 32-bit OS, waar maar 3,2GB RAM ondersteund kan worden. Deze Core i5 bestaat uit twee processorkernen dieelk twee threads kunnen berekenen. Het gebruikte Operating System ondersteunt dezetechnologie 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 overhet opgegeven aantal subdomains in het decomposeParDict-bestand. Vervolgens voerenwe 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 geeftsolver de gebruikte solver aan (in het statische geval: icoFoam). Aan het einde van deberekeningen moeten de resultaten van elke processor samengevoegd worden door hetreconstructPar -commando.

Samengevat moeten achtereenvolgende de volgende commando’s worden ingegeven in determinal 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 verschillendaantal processoren, is dit in tabel 2.1 en grafieken 2.5 en 2.6 weergegeven. Hier werdeen eenvoudige case (figuur 2.4) uitgerekend over een tijdspanne van 0.6 s en met eentijdsstap 0.00005 s.

Aantal processoren Rekeningtijd Tijdswinst

1 2848 12 1804 1.583 1941 1.474 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 omde case op te splitsen. Bij het aantonen van deze rekentijd hebben we gebruik gemaaktvan de eenvoudigste manier. Het is logisch dat bij gebruik van een betere en dus meeringewikkelde verdeling, we ook snellere rekentijden kunnen en hoogstwaarschijnlijk zullenverkrijgen. Dit valt echter niet in het bestek van het onderzoek en daarom gaan we hierniet verder op in. We gaan voor het berekenen van de dynamische cilinder de eenvoudigemanier van opsplitsen van de mesh over de processoren gebruiken en dus enkel gebruikmaken 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 wegebruik 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 openinlet en gesloten outlet. We kunnen hier de druk en snelheid van het stromende fluıdumbestuderen, maar dit valt buiten het bestek van dit onderzoek. Het onderzoek kan eerderverder geholpen worden door de code voor het laten bewegen van de mesh. Bij hetcompileren 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 voorstellingte zien van de case. Enkel het gedrag en de onderverdeling van de dynamische meshwordt 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 uitgerokkenwordt (en dus minder nauwkeurige resultaten zal geven) en de rechterkant ervan zalkrimpen (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, systemen 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 deverschillende delen van case, zoals de cilinder en wanden van de windtunnel, maarook 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 informatiebevatten 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 frequentiede 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 rekeninggehouden met de kwaliteit van de uitkomst. Door de grove opdeling is het resultaatonnauwkeurig. 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 gekendecases:

• 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 lijkenop de code van de movingCone-tutorial om de cilinder op soortgelijke manier te latenoscilleren. De oscillatie bleek op deze manier onmogelijk. Daarbij kwam nog eens datbij het aanpassen en compileren van de statische mesh telkens een andere error werdgegeven. Daarom werd een andere manier gezocht voor het implementeren van dezebeweging. Het was een topic op het CFD-online-forum (OpenCFD, 2008) dat nuttigeinformatie 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 eenscalaire grootheid te maken hebben, waarvan dus enkel de grootte van belang is. We ziendat de druk gegeven wordt in m2

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 aangegevendoor zeroGradient. De gradient geeft, zoals gezien in Wiskunde voor Ingenıeurs (2dejaar), de richting aan van de maximale stijging van de stromingsfunctie. zeroGradientgeeft dat de functie zijn maximum al heeft bereikt. De wanden krijgen de opdrachtom de druk onaangetast te laten, waardoor de druk als het ware kan ontsnappen uitde windtunnel. Dit is beter visualiseerbaar wanneer we de case visualiseren en enkel dedruk 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 datde 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 windtunnelis 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 alszijnde vectoriel (volVectorField). De snelheid kan dus een bepaalde grootte en zin inx-, y- en z-richting hebben. De ruimte tussen de wanden wordt beschouwd als openen 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 dewindtunnel.

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 dezepaper (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 5msin 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 ervoorzorgt dat de stroming stil staat aan de wanden. Wanneer er gepoogd wordt de case tesimuleren op zo een manier dat de randen geen vertragend effect zouden hebben op destroming, dan zouden we het type zeroGradient moeten gebruiken, waarvan de betekeniseerder werd aangehaald.

pointDisplacement

Dit is het bestand dat voor de beweging van de mesh zorgt en kan teruggevonden wordenin Appendix A.1.3. Deze is wellicht het belangrijkste bestand van het hele project. Alsde opbouw en functie van dit bestand begrepen wordt, is ons streefdoel, de dynamischecilinder, bijzonder dichtbij.

We zien dat de klasse van dit bestand vectorieel is. Dit is logisch, aangezien de cilinderin 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 dezesinusoıdale functie kan verwezenlijken, nl. oscillatingDisplacement. Dit type wordt dusmeegegeven aan de te oscilleren cilinder. Enkel de hoeksnelheid ω en de amplitude dienenmeegegeven te worden. In deze case heb ik gepoogd de cilinder te laten bewegen met eenhoeksnelheid van 12 rads . Omgerekend naar frequentie geeft dit f = ω

2×π = 122×π = 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 meteraangegeven in de blockMeshDict-file gelijk is aan 0.4825 meter in werkelijkheid. De os-cillatingDisplacement houdt echter geen rekening met deze schalingsfactor, waardoor wemanueel moeten uitrekenen wat de amplitude moet zijn voor deze case. Dit alles kannatuurlijk 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 metwaarde 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 gegevensdie 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 gebruikenvan een solver resulteert in een foutieve uitkomst. Zoals al opgegeven in paragraaf 1.3.3zullen we voor deze case gebruik maken van pimpleDyMFoam-solver.

Niet enkel de soort solver wordt gegeven in dit bestand. Ook begin- en eindtijd wordtgegeven, net als de grootte van de tijdstap en wegschrijffrequentie. Zoals uitgelegd inde paragraaf over de Vuistregels in OpenFOAM (1.3.1) moet deze tijdstap klein genoegzijn om de case oplosbaar te maken.

decomposeParDict

Dit bestand wordt gebruikt in verband met het oplossen van de case over verschillendeprocessoren. 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 inAppendix A.2.4 en die van tetFemSolution in Appendix A.2.5. In deze file kan bijhet uitrekenen gekeken worden naar hoe de case opgelost moet worden. Een uitgebreidebeschrijving van wat er allemaal beschreven staat in deze files wordt gegeven in paragraaf4.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 codebestaat uit vijf belangrijke onderdelen.

1. convertToMeters – Hier wordt aangegeven wat de schaling is van de case tenopzichte van de werkelijkheid. In deze blockMeshDict-file wordt de schaling op0.4825 gezet. Dit betekent dat 1m in de case 0.4825m in werkelijkheid is.

2. vertices – Dit is het deel waar de basiscoordinaten van de case worden gedecla-reerd. Deze coordinaten bestaan uit een x-, y- en z-component. Elke case moetin 3 dimensies worden opgesteld, aangezien we met een vloeiende stroming werkenwaarvan de onderdelen ook 3 dimensies hebben.

3. blocks – Hier worden verschillende coordinaten samengevoegd tot “blokken”. hexgeeft 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 eenvolume-eenheid en een type toegekend.

dynamicMeshDict

Appendix A.3.2 geeft weer wat er in dit bestand wordt beschreven. Hier wordtaangegeven welk algoritme gebruikt moet worden om de dynamische cilinder te verwezen-lijken. Voor deze case wordt verwezen naar dynamicMotionSolverMesh. De gebruiktesolver voor deze beweging zal de displacementLaplacian zijn. Voor meer informatie overde soorten solvers wordt doorverwezen naar de OpenFOAM User Guide.

transportProperties

Via dit bestand kunnen we de stroperigheid van de stromende vloeistof bepalen. Ditdoen we door de kinematische viscositeitscoefficient ν te declareren. Zoals gezegd inparagraaf 2.1.1 wordt deze in standaardomstandigheden gelijk gesteld aan 1, 5.10−5m

2

s .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 heteenvoudig en werken dus enkel met een laminaire stroming. De code kan teruggevondenworden 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 basisbestandenen -mappen zijn van een eenvoudige OpenFOAM-case en met welke vuistregels menrekening 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 codehiervan kan terug gevonden worden in de bijlage.

3.2 Verder onderzoek

Voor verder onderzoek bestaan verschillende mogelijkheden. Zo lijkt het in de eersteplaats 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 creeren moet meer literair onderzoek verricht worden en is ookmeer 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 andAeroelasticity. 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 ModernCourse in Aeroelasticity, pages 299–376.

Theodorsen, T. (1944). Experiments on drag of revolving disks, cylinders, and streamlinerods at high speeds.

49

Jonas Lintermans - Bewegende cilinder in OpenFOAM

Documents

Transcript of Jonas Lintermans - Bewegende cilinder in OpenFOAM