In deze interactieve module leer je wat een simulatie is, wat een simulatie nodig heeft om te functioneren, welke soorten er zijn en de toepassing ervan. Daarna leer je ook hoe je zelf een simulatie kunt bouwen.
Onderstaand filmpje geeft een voorbeeld van een simulatie.
Zo werkt het
Je bent begonnen in de module Simulaties.
Naast een inleiding bestaat de module uit vijf onderdelen: “Wat is een simulatie?”, “Soorten simulaties”, “Toepassingen”, “Een simulatie maken theorie” en “Een simulatie maken praktijk”. In ieder onderdeel vind je, verdeeld over verschillende pagina's, informatie in de vorm van teksten, afbeeldingen en video's.
Daarnaast ga je zelf aan de slag, er staan in deze module oefeningen en je gaat zelf een simulatie bouwen.
Succes met de module Simulaties.
Voor wie is deze module bedoeld?
Gemiddeld gesproken zul je in havo 5 zitten als je aan dit materiaal toe bent.
Leerdoelen
Na verwerking van deze module:
Kun je uitleggen wat een simulatie is
Kun je diverse soorten simulaties benoemen
Kun je uitleggen waarvoor simulaties worden toegepast
Weet je in welke vakgebieden simulaties worden gebruikt
Kun je aangeven met welke simulaties je al hebt gewerkt
Heb je zelf een simulatie gebouwd
Vereisten
Voor het praktijkgedeelte van deze module heb je NetLogo nodig.
Als het goed is krijg je hierna dit scherm te zien:
Sla het invullen van het formulier over en druk op Download.
Nu krijg je een schema te zien met verschillende versies.
Kies de versie die bij jouw computer past.
Voer na het downloaden het bestand uit en installeer daarmee NetLogo.
B. Wat is een simulatie?
1. Simulatie
Om goed te snappen wat een simulatie is, worden er twee onderwerpen uitgelegd, simulaties en modellen. Dit zijn twee onderdelen die nauw samenhangen bij het bouwen van een simulatie.
Een simulatie is een manier om de werkelijkheid na te bootsen. Dit doe je om inzicht te krijgen in de situatie.
Stel dat je een brug wilt bouwen. Het is dan erg praktisch om vooraf te weten of je ontwerp goed is en de brug die je gaat maken niet zal instorten. Je kan dit testen met een simulatie. In het plaatje is een voorbeeld van een gesimuleerde brug te zien (gemaakt met West Point Bridge designer).
Een simulatie van een situatie bootst de werkelijkheid na. De simulatie is nooit precies hetzelfde als de werkelijkheid, maar geeft wel een heel goede indicatie ervoor. Je zou nu echt niet die brug gaan bouwen die je voor ogen had na deze simulatie!
Maar hoe simuleer je dan? De simulatie van de brug in het plaatje is gemaakt met het programma West Point Bridge designer. Maar hoe weet het programma wat wel en niet mag? Wanneer zakt een brug in? Hoe zwaar is de vrachtwagen? Zonder dergelijke gegevens kan de simulatie niet werken. Een simulatieprogramma heeft dus ook een soort omgeving en een set regels nodig om uitgevoerd te kunnen worden.
2. Model
Regels en omgeving
Voor een simulatie kan functioneren, heeft deze dus een set regels en een omgeving nodig. Een dergelijke set regels en omgeving heet een model.
Een model is een representatie van de werkelijkheid. In het voorbeeld uit 1. simulatie bestaat het model onder andere uit gegevens over de manier hoe de krachten worden doorgerekend op iedere balk en het gewicht en de snelheid van de vrachtwagen. Verder hoort de hoogte van het landschap ook bij het model.
Versimpeling werkelijkheid
Een model is altijd een versimpelde versie van de werkelijkheid. Niet alle uiterlijkheden en niet alle eigenschappen van de werkelijkheid worden in het model verwerkt.
Een goed model is essentieel
Goede modellen zijn essentieel voor simulaties, zij verschaffen namelijk de basis: het is de omgeving waarin de simulatie zich bevindt. Zonder regels en omgeving kan de simulatie niet functioneren, want dan kan de simulatie niet de regels 'toepassen' op de situatie die je wil nabootsen. Bijvoorbeeld:
Op de afbeelding zie je een voorbeeld van een model: een modeltrein. Uiteraard geen volledige verkleinde werkelijkheid maar een versimpelde. Zo zit er geen miniatuurmotortje in de bus en kunnen de mensen die je ziet staan niet bewegen.
Voor een modelspoorbaanenthousiast is dat geen enkel probleem. Zo iemand is namelijk geïnteresseerd in het maken van spoorwegemplacementen, het ontwerpen van dienstregelingen en het zorgen dat verschillende treinen op dezelfde rails kunnen rijden zonder met elkaar in botsing te komen of te ontsporen. Hij wil weten hoe hard iedere trein kan rijden, hoeveel iedere locomotief kan trekken, hoe hard een trein een bocht kan nemen en ongetwijfeld nog een groot aantal andere eigenschappen. De bus en de voetgangers zijn voor hem 'aankleding': ze spelen verder geen rol bij zijn simulatie,
Maar stel je nu eens voor dat een dergelijk model zou moeten dienen om het gedrag van mensen bij overwegen te simuleren. Je hebt nu niets meer aan een stilstaande bus en vastgelijmde voetgangers. De bus en de voetgangers moeten een actieve rol gaan spelen bij de simulatie en het model zal daarop moeten worden aangepast.
Het bepalen van welke aspecten van de werkelijkheid onderdeel gaan uitmaken van je model en welke aspecten je kunt weglaten is essentieel voor je simulatie. Fouten in je model kunnen dus leiden tot heel andere conclusies bij het simuleren.
Om bij bovenstaand voorbeeld te blijven: met een niet rijdende bus en voetgangers die niet kunnen bewegen is iedere spoorwegoverweg even veilig.
C. Soorten simulaties
1. Continue simulatie
Er zijn verschillende soorten simulaties. Je hebt nu een voorbeeld gezien van een virtuele simulatie van een brug gezien, met behulp van een computer en een voorbeeld van een fysieke simulatie: de modeltrein. Dit is nogal een verschil! Bij simulaties wordt onderscheid gemaakt tussen continue en discrete simulaties.
Continue simulatie
Een continue simulatie houdt in dat op elk tijdstip gesimuleerd wordt als deze aan staat. Dit klinkt erg logisch, maar dat is niet altijd het geval. Als een simulatie op elk moment gaande is, betekent dit ook dat deze moeilijk 'op pauze' te zetten is. Een momentopname is dan niet zo gemakkelijk gemaakt. Vergelijk het met een multiplayer vs singleplayer game. In multiplayer kan je vaak het spel niet zomaar op pauze zetten, want het spel speelt zich in real time af. In een singleplayer game is dit niet zo van belang, dus is het vaker mogelijk het stil te zetten.
Een goed voorbeeld van een continue simulatie is het maken van een model van de situatie in hardware. Bekijk het filmpje voor een voorbeeld hiervan.
Een simulatie door de situatie na te bouwen
Zoals het filmpje laat zien is een simulatie als deze niet gemakkelijk op pauze te zetten. Er wordt op elk moment gesimuleerd omdat de simulatie zich continu afspeelt.
In het filmpje wordt gezegd dat simulaties tegenwoordig allemaal met computers worden gedaan: dit is namelijk goedkoper en sneller omdat veel minder mankracht en materiaal nodig is.
Van belang hierbij is het volgende: computers kunnen alleen discreet simuleren.
2. Discrete simulatie
Een computer kan alleen maar discreet simuleren. Dit houdt in dat, in tegenstelling tot continue simulaties niet op ieder tijdstip wordt gesimuleerd. Bijvoorbeeld alleen iedere seconde, maar daartussen niet.
Dit komt omdat door met een computer te simuleren alles doorgerekend moet worden.
Discreet simuleren in plaats van continu hoeft geen probleem te zijn. Als je een computer een vallende steen laat simuleren, kan je bijvoorbeeld instellen dat de computer iedere keer op één gegeven tijdstip simuleert. Dus door t=0s in te vullen geeft de simulatie de maximale hoogte voor de steen. Door t=3s in te vullen, geeft de simulatie een lagere hoogte voor de steen (de steen is gevallen). Door telkens een nieuwe waarde voor t in te voeren, simuleert de computer de plek waar de steen zich bevindt op dat tijdstip. Dit heet een stationaire simulatie.
Het is alleen lastig als je het gehele verloop van een vallende steen wil simuleren. Dan moet je iedere keer een nieuw tijdstip invullen, natuurlijk kan je de computer dit ook laten doen. In dat geval spreek je van een dynamische simulatie.
De juiste tijdstippen
Het is voor een computer niet te doen om op ieder tijdstip te simuleren, maar wel op een heleboel tijdstippen (bijvoorbeeld iedere ms). Daardoor is de discrete simulatie nog wel nuttig. Dit zorgt er wel voor dat er altijd in gedachten gehouden moet worden hoeveel tijdstippen er gesimuleerd moeten worden, want een discrete simulatie kan bij te weinig tijdstippen of te grote stappen in de tijd (bijvoorbeeld een tijdstap van een uur) een grote afwijking krijgen.
Bij complexe situaties is nog steeds heel veel rekenkracht nodig.Er zijn immers heel veel tijdstippen en heel veel verschillende dingen door te rekenen. Het filmpje hieronder is een gesimuleerde situatie waarbij de witte vloeistof zwaarder is dan de zwarte. Omdat wit zwaarder is dan zwart gaat het mengen, dit mengen is gesimuleerd. Voor deze simulatie heeft een supercomputer meerdere dagen moeten rekenen, omdat voor iedere pixel doorgerekend is hoe de vloeistof is gaan mengen op enorm veel tijdstippen.
Voorbeeld discrete simulatie
Het voorbeeld hierboven rekent voor iedere plek door welke vloeistof zich op dat moment op welke pixel bevindt. Dit wordt zoals net uitgelegd, in tijdstappen gedaan. Maar het is belangrijk om in de gaten te houden dat de simulatie door middel van een computer dus niet alleen discreet is in tijd, maar ook in ruimte. Het beeld is opgedeeld in pixels en er wordt een berekening gedaan voor iedere pixel. Een pixel stelt dus een klein oppervlakje voor, in de werkelijkheid zijn de vloeistoffen niet opgebouwd uit pixels. Door dus alles te verdelen (kwantiseren) in pixels, maken we de simulatie discreet in ruimte.
D. Toepassingen
Er zijn enorm veel verschillende toepassingen voor simulaties. Weersvoorspelling wordt bijvoorbeeld gedaan door middel van simulaties en op grotere schaal wordt klimaatverandering voorspeld met behulp van simulaties. Simulaties worden veel toegepast in de onderzoekswereld en bij het ontwikkelen van nieuwe technologieën. Verder wordt er in de bouwkunde gebruik van gemaakt om te testen of bepaalde materialen in gebouwen gebruikt kunnen worden. Hieronder staan een paar voorbeelden uit verschillende vakgebieden.
Onderzoek
Bouwkunde
Weer
E. Een simulatie maken theorie
Je hebt verschillende voorbeelden gezien van simulaties. Het wordt nu tijd dat je zelf aan de slag gaat om een eigen simulatie te maken. Dit ga je doen met behulp van NetLogo, een programma
voor het ontwikkelen van computersimulaties.
Dit zijn op agent-gebaseerde modellen. Dat wil zeggen een computermodel waarin het effect van de actie en de interactie van de afzonderlijke onderdelen op het systeem in het geheel worden bestudeerd.
0. Wanneer te simuleren
Bij het maken van een simulatie is de allereerste stap dat je jezelf moet afvragen of je een simulatie wil bouwen.
Dat kan een lastige vraag zijn, het is daarom gemakkelijker een aantal regels te volgen om te bepalen wanneer niet te simuleren.
Simuleer niet wanneer:
het probleem opgelost kan worden met "common sense"
het probleem analytisch opgelost kan worden (dus met behulp van de wiskunde bijvoorbeeld)
het makkelijker is om het direct te testen op de situatie
de kosten van het simuleren groter zijn dan de uitkomst zou kunnen besparen
er geen middelen zijn om te simuleren
er niet genoeg tijd is voor de uitkomst om nuttig te zijn
er geen data is, zelfs geen schattingen van de situatie
het model niet te verifiëren of te valideren (testen) is
de verwachtingen in het project niet gehaald kunnen worden
het te simuleren systeem te complex is of niet gedefinieerd kan worden
Zoals misschien duidelijk wordt in de hierboven opgesomde punten, gebeurt het bouwen van een simulatie in veel gevallen binnen een project, voorafgaand aan de werkelijke uitvoering. Dat is logisch, omdat je, zoals eerder is uitgelegd, een voorspelling doet van de werkelijkheid.
1. Probleembeschrijving
Probleemstelling: wolven en schapen
Vanuit de biologie ken je het misschien wel: populatiedynamiek. Populatiedynamiek is de verandering van populaties* in een ecosysteem. De aantallen binnen de populatie nemen toe of nemen af. Soorten veranderen of soorten verdwijnen.
Met behulp van een simulatie van een versimpeld ecosysteem ga je de populatiedynamiek bestuderen van een systeem met daarin wolven en schapen. De wolven eten de schapen en krijgen daar energie van, waardoor de hoeveelheid schapen vermindert. Als een wolf genoeg te eten heeft, zal hij zich uiteindelijk voortplanten, waardoor er meer wolven in het gebied komen. Echter. wanneer er te weinig schapen zijn, zullen de wolven dan ook sterven van de honger. Schapen eten gras, daar krijgen ze energie van. Als de schapen genoeg gras kunnen eten, zullen ook zij zich uiteindelijk voortplanten. Alleen heeft het gras ook weer tijd nodig om te groeien. Als er te weinig gras is, zal het schaap ook omkomen van de honger.
Objecten
Er zijn in dit model dus drie belangrijke 'objecten':
Wolven
Schapen
Gras
*Populatie = een groep organismen van dezelfde soort die niet in tijd of plaats van elkaar gescheiden zijn en zich dus (theoretisch) met elkaar kunnen voortplanten,
2. Belangrijke parameters
Bij een model is het belangrijk de juiste parameters te kiezen. Een parameter is een variabele. Ken je die parameter een waarde toe, dan zegt die waarde iets over de toestand van het systeem.
De juiste parameters
Bij het maken van het model is het nodig de juiste parameters te kiezen, omdat je anders een model krijgt wat de werkelijkheid niet of onjuist benaderd. Echter, wanneer er teveel parameters worden gekozen, kan een model ook nodeloos ingewikkeld worden, wat voor een juiste benadering niet nodig is.
De juiste waardes
Je zult begrijpen, dat wanneer je parameters niet reeële waarden toekent, ook je simulatie geen reeël beeld zal opleveren.
Voorbeeld
Als voorbeeld gaan we hierbij terugkijken naar de brug die we gezien hebben bij onderdeel D. Toepassingen.
Er zijn hier drie soorten parameters die van belang zijn:
Bouwkundige parameters:
Dit zijn parameters die de structuur van de brug bepalen. Bijvoorbeeld de lengte van de brug. Maar ook wat voor soort brug het betreft. Een hangbrug werkt weer heel anders dan een brug met een boogconstructie.
Technische parameters:
Dit zijn parameters die gaan over de technische aspecten van de brug. Bijvoorbeeld van welk materiaal de brug gemaakt is. Een brug van steen en cement zal een andere stevigheid hebben dan een brug van staal.
Gebruiks parameters:
Dit zijn parameters die iets vertellen over wat de brug te verduren krijgt. Een brug voor voetgangers wordt heel anders belast dan een brug met een tweebaans snelweg.
Los van het kiezen van parameters, moet er ook een afbakening gedaan worden met betrekking tot de simulatie zelf. Dit is belangrijk omdat een computer een beperkte rekencapaciteit heeft. Als bepaalde doorgerekende waarden te groot worden, kan dit een probleem vormen. Afbakening voorkomt dit, want dan wordt er gesteld dat bij bepaalde waardes gestopt moet worden met simuleren.
Een voorbeeld hiervan is afbakenen op tijd, door bijvoorbeeld in te stellen dat er slechts 10 seconden gesimuleerd wordt.
F. Een simulatie maken praktijk
1. Eerste instellingen
Nu je in E2 de belangrijkste parameters hebt bepaald is het tijd om het model ook echt te gaan bouwen.
Open het programma NetLogo.
Als het goed is, is er nu al een leeg model te zien. Bovenin zie je drie tabbladen: Interface, Info en Code.
Bij het tabje 'Interface' ga je het model laten zien aan de gebruiker. In het zwarte vierkant zal het model worden uitgevoerd en worden gevisualiseerd. In dit geval zullen hier straks dus de schapen en wolven rond rennen. In het witte gedeelte is nog plek voor knoppen, schuifbalkjes, grafieken, ect. Dit geeft de gebruiker de mogelijkheid nog dingen in te stellen en het model beter af te lezen.
Onder het tabje 'Info', kan informatie over het model worden geplaatst. Dit is vooral handig wanneer je je model aan andere laat zien. Zo kunnen zij precies begrijpen wat je hebt gedaan en wat het model doet.
Onder het tabje 'Code' komt de uiteindelijke code voor het model. In deze code vertel je het programma wat hij moet doen, om tot de uiteindelijke simulatie te komen. Deze code lijkt al een beetje op wat je gewent bent in de informatica lessen te doen, alleen dan net even anders. Daarom zullen we ook stap voor stap uitleggen wat je moet doen.
Klik op het tabje 'Code' om aan de slag te gaan.
Aan de slag
Je begint met de eerste instelling van het model in de code te typen
Uitleg:
In de simulatie willen we de hoeveelheid schapen die op je scherm verschijnt niet teveel laten worden. Wordt deze namelijk wel te groot, dan kan de simulatie vastlopen. Daarom benoemen we nu eerst een globale variable die de maximale hoeveelheid schapen bepaald.
Zowel de schapen als wolven zijn beide soorten (breeds) turtles. Met behulp van breed [ schaap a-sheep ] , benoemen we een schaap als een turtle.
Hetzelfde als voor de schapen, alleen dan voor de wolven.
Zowel de schapen als wolven (beide turtles) hebben de parameter energie
Patches zijn de stukjes achtergrond, hier zetten we een parameter neer die telt hoelang het duurt voordat het gras weer gegroeid is.
Met behulp van een ' ; ' kun je opmerkingen plaatsen achter en code. Dit is zinvol om voor jezelf, maar ook voor andere de code leesbaar te houden.
Typ dit stukje code nu over in NetLogo
2. Overige globale variabelen
Nu je de eerste globale variabele hebt gedefinieerd, is het tijd ook de andere globale variabelen te definiëren die de gebruiker zelf mag instellen. Dit doe je onder het kopje ‘Interface’. Je gaat nu eerst de globale variabele toevoegen voor het begin aantal schapen in de simulaite. Dit doen we als volgt:
Voeg een ‘slider’ toe:
Vul bij ‘Global variable’: oorspronkelijk-aantal-schapen in. Vervolgens kun je instellen tot wat voor bereik de gebruiker kan gaan met deze schuifbalk. Neem hier 0 tot 250 schapen met een toename van 1. Hier is gekozen voor een standaard van 10 schapen, zo opent het programma. Kies zelf een schapen aantal waarmee je wil dat de gebruiker start.
Maak ook de volgende sliders met de volgende instellingen:
Begin hoeveelheid wolven in de simulatie: oorspronkelijk-aantal-wolven
0 tot 250 met toename van 1
Kies zelf het aantal wolven waarmee je wil dat de gebruiker start.
Hoe snel het gras groeit in de simulatie: gras-groei-tijd
0 tot 100 met toename van 1
Hoeveel energie een schaap krijgt van het eten van gras profijt-van-voedsel-schaap
0 tot 50 met toename van 1
Hoeveel energie een wolf krijgt van het eten van een schaap profijt-van-voedsel-wolf
0 tot 100 met toename van 1
Hoe groot de kans is dat een schaap zich kan vermenigvuldigen reproductie-schaap
0 tot 20 met toename van 1. Vul bij ‘Units’ % in.
Hoe groot de kans is dat een wolf zich kan vermenigvuldigen reproductie-wolf
0 tot 20 met toename van 1. Vul bij ‘Units’ % in.
Vervolgens maak je ook nog een globale variable die het mogelijk maakt de energie van de wolven en schapen weer te geven. Kies hiervoor de ‘Switch’. En vul in 'show-energie?'
Tot slot maak je ook nog twee keer een ‘Button’. Eentje zorgt ervoor dat de setup wordt gerund wanneer op de button wordt geklikt. Vul daarom bij Agent(s) observer onder het command window setup in. Daarnaast hebben we ook nog een knop nodig die ervoor zorgt dat de simulatie gaat lopen. Maakt daarom nog een button en vul dan onder Agent(s) observer onder het command window go in. Vink tevens het vakje Forever aan.
Je interface scherm ziet er dus nu ongeveer als volgt uit:
Tip: ben je niet tevreden met de positie, wil je nog iets wijzigen aan de instellingen of het object verwijderen. Door er met behulp van je linkermuisknop een vakje overheen te slepen selecteer je het object. Je kunt hem dan vervolgens verplaatsen. Wanneer je het object hebt geselecteerd kun je met het knopje ‘edit’ de instellingen nog wijzigen of verwijderen met ‘delete’ indien nodig.
3. Setup maken
Nu is het tijd de setup te maken. Dit draait het programma één maal wanneer op de knop ‘setup’ wordt gedrukt in het interface scherm.
Het eerste stukje code van de setup is hieronder weer gegeven:
Uitleg:
Wanneer een programma al eens heeft gedraaid, hebben veel variabelen al een waarde. Clear-all wist al deze waarden
Wanneer er teveel schapen in het scherm zijn loopt de computer vast. Wanneer het programma op een internetpagina wordt gedraaid gebeurd dit eerder dan wanneer het programma in NetLogo zelf wordt gedraaid. Daarom wordt de maximale hoeveelheid schapen vastgesteld afhankelijk van waar het programma wordt gedraaid. Een if..else werkt als volgt in Netlogo: ifelse waarde [commando 1] [commando2]
Wanneer de waarde waar(true) is runt het programma commando1, wanneer de waarde onjuist(false) is runt hij commando2.
Hier worden de patches (dus de stukjes gras) aangeroepen
???
Wanneer de kleur van het gras groen is:
Stel de counter ‘aftellen’ in en roep de ingestelde gras groei tijd op
Wanneer de kleur van het gras niet groen is (dus bruin), dan stel de counter ‘aftellen’ in en neem nog een random gedeelte van de gras groei tijd. (Het zou niet logisch zijn namelijk als al het bruine gras er even lang over zou doen van de start van de simulatie om weer groen te worden.)
Neem nu dit stukje code, met de juiste ingevulde waarden voor max-schaap over in Netlogo
----------------------
Schapen
Voor het volgende stukje van de setup gaan we de schapen maken:
Uitleg:
Je creërt hier het schaap. Je plaatst het oorspronkelijk aantal ingestelde schapen in de simulatie.
Hier ken je een plaatje in de vorm schaap toe aan het schaap
Deze schapen-vorm maak je wit
Met een grootte van 1,5 zodat hij voor de gebruiker wat beter zichtbaar is.
De kleur van het label van het schaap (dat de energie aan kan geven) wordt ingesteld op donkerblauw. Deze labels zijn standaard ingesteld op wit, maar aangezien het schaap al wit is, is dit niet zo handig.
De energie van het schaap wordt ingesteld op een willekeurige hoeveelheid van twee keer het profijt dat een schaap heeft van voedsel. Zo beginnen niet alle schapen met eenzelfde hoeveelheid energie.
Dit plaatst de oorspronkelijke hoeveelheid schapen willekeurig over het landje in de simualtie.
Neem dit stukje code nu over in NetLogo
Tot slot hebben we nog het laatste stukje code van de setup:
Uitleg:
Maakt het mogelijk de labels te tonen bij de schapen en wolven.
Reset de ticks. De ticks houd als het waren de tijd bij van de simulatie. In het begin van de simulatie worden deze dus weer terug gezet.
Tot slot sluiten we de setup hier af door de end.
Neem dit stukje code nu nog over.
De setup is nu klaar!
4. Go-loop maken
Je gaat nu het stukje to go maken. Dit stukje code blijft de hele simulatie door lopen. Het eerste stukje ziet er alsvolgt uit:
Alle losse commando's onder ask sheep worden verderop in de code beschreven. Hier wordt dan precies beschreven wat dit commando moet doen.
Neem dit stukje code nu over in Netlogo.
Tot slot het laatste stukje code van de go-loop:
Uitleg:
Hier roep je de patches aan, dus de achtergrond vlakjes gras
Dit zorgt ervoor dat het gras gaat groeien. Ook dit commando wordt verderop in de code nog uitgebreid beschreven.
Iedere keer dat de go-loop wordt doorlopen is één tick. Door in het interface-tabje de tick snelheid in te stellen, bepaal je hoevaak de go-loop wordt doorlopen voordat de nieuwe stand van de wolven, schapen en gras wordt weergegeven op het scherm. Zo lijken de wolven en schapen bij een hogere tick snelheid ook sneller te bewegen, maar in feiten versnel je de tijd. Het kan in simulaties erg handig zijn de tijd te versnellen. Sommige processen duren namelijk erg lang. Door de tijd te versnellen zie je eerder wat voor resultaat je simulatie heeft.
Dit zorgt ervoor dat de energielevels van de wolven en schapen wel of niet worden weergegeven. Ook dit commando wordt verderop in de code nog uitgebreid beschreven.
Tot slot sluit je de go-loop af met end.
Neem dit stukje code nu over in Netlogo.
5. Commando's vormgeven
In de go-loop hebben we eigenlijk allemaal commando's aangeroepen waarvan we nog niet echt hebben beschreven wat deze moeten doen. Dit gaan we nu doen.
Commando move
We beginnen met het commando move:
Uitleg:
Hier benoemen we dat wat gaat volgen behoort bij het commando move. Dit wordt ook wel een turtle-procedure genoemd.
De turtle draait random tot 50 graden naar rechts.
De turtle draait random tot 50 graden naar links.
Vervolgens zet de turtle 1 stapje.
Hier wordt de turtle-procedure weer afgesloten, en is het move commando dus beschreven.
Neem dit stukje code over het move-commando nu over.
Commando Eet-gras
We gaan nu aan de slag met een schaap procedure; het commando eet-gras. Deze procedure beschrijft commando eet-gras. Als het schaap gras eet, wordt het gras bruin en krijgt het schaap de afgesproken hoeveelheid energie.
Commando Schaap-reproductie & Wolf-reproductie
Je gaat nu aan de slag met een schaap-proceduren; namelijk schaap-reproductie. Deze procedrure beschrijft hoe het schaap zich reproduceert. Hieronder is het bijbehorende stukje code weergegeven:
Uitleg:
Hier benoem je dat wat gaat volgen bij het commando schaap hoort
Hier start de if-loop. Er wordt een random getal gekozen tot honderd. Wanneer dit getal kleiner is dan de ingestelde globale variable reproductie schaap, dan:
Wordt de nieuwe energie van het schaap de hoeveelheid energie die het schaap had delen door twee. De energie wordt zo verdeelt over moeder en kind.
Ook wordt er één schaap geboren. Deze draait random tot 360 naar rechts en vervolgens zet het pas geboren schaap één stap.
Met deze haak wordt de if-loop afgesloten.
En ten slotte wordt ook nog de procedure afgesloten.
Neem dit stukje code nu over.
Commando eet-schaap
Het volgende commando wat we gaan beschrijven is een wolf procedure, namelijk het eet-schaap commando. Dit beschrijft dat de wolf een schaap vangt, deze opeet en vervolgens de afgesproken hoeveelheid energie krijgt.
Hieronder is het stukje code voor het commando van eet-schaap weergegeven. Sleep de juiste stukjes uitleg naar de juiste nummers.
Uitleg:
Hier benoem je dat wat gaat volgen bij het commando eet-schaap hoort.
Maak een tijdelijke variabele 'prooi. Kijk of en een schaap in hetzelfde vakje is als de wolf.
Is 'prooi' ongelijk aan niets, dan:
Maak het schaap in het vakje dood.
Roep de energie van de wolf aan en maak deze de oude energie plus het afgesproken energie-profijt van het eten van schapen.
Het volgende commando is het dood commando. Dit is een turtle-procedure. Hieronder is het stukje code weergegeven:
Commando groeien-gras
Hierna komt nog een commando. Dit is een patches procedure, namelijk het commando groeien-gras. Deze beschrijft hoe het gras moet groeien. Hieronder is het stukje code weergegeven:
Hierna volgt nog het laatste commando. Dit commando maakt het mogelijk het energielevel van de schapen en wolven te tonen in een label. Het stukje code is hier weergegeven:
Reporter procedure
Nu alle commando's af zijn, is er nog één stukje code wat we moeten toevoegen. Namelijk het volgende:
Dit kleine stukje code maakt het mogelijk straks de groene stukjes gras te tellen.
Uitleg:
Hier wordt de reporter procedure gestart van het gras.
Er wordt 'gerapporteerd aan gras' hoeveel stukjes gras ook echt groen zijn.
Hierna wordt de reporter procedure weer afgesloten.
Wanneer we nu bijvoorbeeld 'count gras' zouden uitvoeren, telt hij het aantal stukjes groen gras bij elkaar.
Neem dit stukje code nu over in Netlogo
6. Weergave van het model
Tot slot maak je het weergeven van het model nog iets gemakkelijker. Daarna is het model klaar voor gebruik.
Het is handig als je kunt zien hoeveel schapen en wolven er tegelijkertijd op het scherm zijn. Een paar zijn nog wel gemakkelijk te tellen, maar als het er heel veel worden, is het gemakkelijker wanneer dit in een getal wordt weergegeven. Hetzelfde geldt voor de hoeveelheid groen gras. Daarom gaan we een drietal monitoren maken, die dit weergeven.
Maak daarom een Monitor door deze aan te klikken.
Vul bij reporter het volgende in: count schaap . Dit telt dus het aantal schapen en geeft dit weer. Vul bij display name, de naam van het display in, bijvoorbeeld 'schapen'.
Doe hetzelfde, maar nu voor de wolven en voor het gras. (Count wolven en count gras)
Een grafiekje van deze getallen over de tijd, geeft visueel ook goed weer hoe de populatie zich ontwikkeld en het gras. Maak daarom een plot:
Vul vervolgens de volgende gegevens in:
Name: Populatie
X axis label: tijd
X min: 0 & X max 100
Y axis label: populatie
Y min: 0 & Y max 100
Vink zowel het vakje Auto scale? als Show legend? aan.
Klik op het potloodje en vul onder pen update commands plot count schaap in. Klik daarna op OK. Door te dubbelklikken links langs de tekst op default name, kun je de naam veranderen. Vul hier 'schapen' in. Ook kun je een kleur kiezen dat het lijntje in de grafiek gaat hebben, dubbelklik op het zwarte color vakje en kies een passende kleur.
Door op Add Pen te klikken, voeg je een regel toe en dus een lijn in de grafiek. Maak zelf ook de twee lijnen voor wolven en de hoeveelheid gras. Deel de hoeveelheid gras door 4. Hieronder is een overzicht weergegeven:
Je model interface ziet er nu ongeveer alsvolgt uit:
We willen nu nog een stukje code maken dat de groene stukjes gras telt:
Dit stukje geeft aan te raporteren naar de variabele gras. Vervolgens raporteert hij het aantal patches met de kleur groen. Dit telt dus alle stukjes groen gras. Neem dit stukje code nu over.
Tot slot willen we nog een stukje code schrijven wat het mogelijk maakt energielabels te tonen bij de schapen en wolven. Dit geeft aan hoeveel energie ze (nog) hebben. Dit stukje code wordt hieronder weergegeven:
Gefeliciteerd! Je model is klaar voor gebruik!
7. Testen van het model
Het is natuurlijk ook belangrijk om te weten of je model naar behoren werkt. Wanneer je alle stappen in deze les juist hebt uitgevoerd zou je simulatie nu moeten werken. Mocht je simulatie nu niet werken dan kun je zelf met het knopje 'Check' je code en interface nalopen en/of met behulp van deze les je code handmatig nalopen.
NetLogo vertelt dan zelf al waar het probleem ligt. Tot op zekere hoogte althans. Wanneer je bijvoorbeeld bij de laatste stap bent vergeten de round functie te gebruiken. Dan worden de getalen in de labels niet afgerond. Dat vind NetLogo verder niet erg en zal dit ook niet opmerken als fout. Voor ons maakt nog niet zo heel veel uit, het wordt hooguit minder overzichtelijk, maar het model klopt nog steeds.Wanneer je nu dit hele blok code bent vergeten, zal NetLogo daar wel problemen mee hebben. Hij zal een error geven dat niets met display-label is gedefineerd:
De simulatie werkt dan helemaal niet meer.
NetLogo heeft alleen geen verstand van de simulatie die jij in gedachten had te maken. Hij filtert programeerfoutjes er wel uit, maar als je iets heel anders codeert dan eigenlijk de bedoeling is, zal je simulatie dus niet naar behoren werken. Het is dus heel belangrijk vooraf een goed omschreven en uitgewerkt idee te hebben van je simulatie en deze achteraf te controleren. Dit doe je door de code te controleren of deze klopt met wat je hebt bedacht en te bekijken of de simulatie ook werkt zoals je verwacht. Dit laatste is natuurlijk niet altijd mogelijk, maar in veel gevallen wel. Gelukkig voldoet de code controleren ook al vaak.
Controleer je code nu. Kijk ook of je simulatie doet wat je verwacht.
Oefening: Spot de fout
0%
Kun jij in de volgende stukjes code de fout ontdekken? En wat gebeurt er hierdoor?
Het arrangement Simulaties - Havo 5 is gemaakt met
Wikiwijs van
Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt,
maakt en deelt.
Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding-GelijkDelen 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding en publicatie onder dezelfde licentie vrij bent om:
het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
voor alle doeleinden, inclusief commerciële doeleinden.
Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:
Toelichting
In deze interactieve module leer je wat een simulatie is, wat een simulatie nodig heeft om te functioneren, welke soorten er zijn en de toepassing ervan. Daarna leer je ook hoe je zelf een simulatie kunt bouwen.
Leerniveau
HAVO 4;
VWO 6;
HAVO 5;
VWO 4;
VWO 5;
Leerinhoud en doelen
Informatica;
Eindgebruiker
leerling/student
Moeilijkheidsgraad
gemiddeld
Studiebelasting
4 uur en 0 minuten
Simulaties - Havo 5
nl
Het Hooghuis Mondriaan informatica
2019-01-21 14:22:30
In deze interactieve module leer je wat een simulatie is, wat een simulatie nodig heeft om te functioneren, welke soorten er zijn en de toepassing ervan. Daarna leer je ook hoe je zelf een simulatie kunt bouwen.
Je bent begonnen in de module Simulaties.
Een simulatie is een manier om de werkelijkheid na te bootsen. Dit doe je om inzicht te krijgen in de situatie.
Je hebt verschillende voorbeelden gezien van simulaties. Het wordt nu tijd dat je zelf aan de slag gaat om een eigen simulatie te maken. Dit ga je doen met behulp van NetLogo, een programma
Bij het maken van een simulatie is de allereerste stap dat je jezelf moet afvragen of je een simulatie wil bouwen.
Vanuit de biologie ken je het misschien wel: populatiedynamiek. Populatiedynamiek is de verandering van populaties* in een ecosysteem. De aantallen binnen de populatie nemen toe of nemen af. Soorten veranderen of soorten verdwijnen.
Los van het kiezen van parameters, moet er ook een afbakening gedaan worden met betrekking tot de simulatie zelf. Dit is belangrijk omdat een computer een beperkte rekencapaciteit heeft. Als bepaalde doorgerekende waarden te groot worden, kan dit een probleem vormen. Afbakening voorkomt dit, want dan wordt er gesteld dat bij bepaalde waardes gestopt moet worden met simuleren.
