Tutorial „Modelling in the language XL“ University of Göttingen (Germany), September 21/22, 2009 Winfried Kurth Some basic examples in XL (part 2) related.

Slides:



Advertisements
Similar presentations
Semantics Static semantics Dynamic semantics attribute grammars
Advertisements

Chapter 2: Using Objects Part 1. To learn about variables To understand the concepts of classes and objects To be able to call methods To learn about.
Grammars, constituency and order A grammar describes the legal strings of a language in terms of constituency and order. For example, a grammar for a fragment.
Chapter 5: Elementary Data Types Properties of types and objects –Data objects, variables and constants –Data types –Declarations –Type checking –Assignment.
FUNCTIONS AND MODELS Chapter 1. Preparation for calculus :  The basic ideas concerning functions  Their graphs  Ways of transforming and combining.
CS 330 Programming Languages 09 / 13 / 2007 Instructor: Michael Eckmann.
Tutorial 6 & 7 Symbol Table
Simulating Trees with Fractals and L-Systems Eric M. Upchurch CS 579.
Chapter 3 Program translation1 Chapt. 3 Language Translation Syntax and Semantics Translation phases Formal translation models.
Syntactic Pattern Recognition Statistical PR:Find a feature vector x Train a system using a set of labeled patterns Classify unknown patterns Ignores relational.
1 Chapter 5: Introduction To Form Builder. 2 Forms  Why Do We Use Form Builder?  Why Don’t We Use SQL Only?!
Chapter 4 Sec. 4.1, 4.2, 4.4 Procedures (User-defined)
C++ Programming: Program Design Including Data Structures, Third Edition Chapter 20: Binary Trees.
(2.1) Grammars  Definitions  Grammars  Backus-Naur Form  Derivation – terminology – trees  Grammars and ambiguity  Simple example  Grammar hierarchies.
Language Translation Principles Part 1: Language Specification.
CSC 8310 Programming Languages Meeting 2 September 2/3, 2014.
Functional-Structural Plant Modelling with GroIMP and XL Tutorial and Workshop at Agrocampus Ouest, Angers, 5-7 May, 2015 Winfried Kurth University of.
IlliDOL: A Framework for Exploration of L- Systems in Three Dimensions Vilas Dhar Math 198 Spring 2003.
Summer School „Modelling and Simulation with GroIMP“ / Tutorial for beginners University of Göttingen (Germany), September, 2010 Winfried Kurth Modelling.
XL as an extension of the L-system formalism Tutorial "Modelling Plants with GroIMP", Cottbus, March 11-12, 2008 Winfried Kurth Ole Kniemeyer Reinhard.
Chapter 2 Syntax A language that is simple to parse for the compiler is also simple to parse for the human programmer. N. Wirth.
Functional-Structural Plant Modelling with GroIMP and XL Tutorial and Workshop at Agrocampus Ouest, Angers, 5-7 May, 2015 Winfried Kurth University of.
Summer School „Modelling and Simulation with GroIMP“ / Tutorial for beginners University of Göttingen (Germany), September, 2010 Winfried Kurth Some.
Tutorial „Modelling in the language XL“ University of Göttingen (Germany), September 21/22, 2009 Winfried Kurth Some basic examples in XL (part 1) related.
Modelling of Ecosystems by Tools from Computer Science Summer School at Czech University of Life Sciences, Prague, September, 2013 Winfried Kurth.
L-Systems and Procedural Plants CSE 3541 Matt Boggus.
Lecture # 3 Chapter #3: Lexical Analysis. Role of Lexical Analyzer It is the first phase of compiler Its main task is to read the input characters and.
Tutorial and workshop „Modelling with GroIMP and XL“ / Tutorial for beginners University of Göttingen, 27 February, 2012 Winfried Kurth Basic examples.
A sentence (S) is composed of a noun phrase (NP) and a verb phrase (VP). A noun phrase may be composed of a determiner (D/DET) and a noun (N). A noun phrase.
Languages, Grammars, and Regular Expressions Chuck Cusack Based partly on Chapter 11 of “Discrete Mathematics and its Applications,” 5 th edition, by Kenneth.
Copyright © 2006 The McGraw-Hill Companies, Inc. Programming Languages 2nd edition Tucker and Noonan Chapter 2 Syntax A language that is simple to parse.
Summer School „Modelling and Simulation with GroIMP“ / Tutorial for beginners University of Göttingen (Germany), September, 2010 Winfried Kurth Some.
Summer School „Modelling and Simulation with GroIMP“ / Tutorial for beginners University of Göttingen (Germany), September, 2010 Winfried Kurth Some.
Chapter 13. Procedural programming vs OOP  Procedural programming focuses on accomplishing tasks (“verbs” are important).  Object-oriented programming.
TextBook Concepts of Programming Languages, Robert W. Sebesta, (10th edition), Addison-Wesley Publishing Company CSCI18 - Concepts of Programming languages.
1 10/27/ :26 UML Simplicity in Complexity. 2 10/27/ :26 UML Rewriting Systems Classic Example: Koch 1905 Initiator Generator.
Functional-Structural Plant Modelling with GroIMP and XL Tutorial and Workshop at Agrocampus Ouest, Angers, 5-7 May, 2015 Winfried Kurth University of.
Summer School „Modelling and Simulation with GroIMP“ / Tutorial for beginners University of Göttingen (Germany), September, 2010 Winfried Kurth Some.
Functional-Structural Plant Modelling with GroIMP and XL Tutorial and Workshop at Agrocampus Ouest, Angers, 5-7 May, 2015 Winfried Kurth University of.
Object-Oriented Program Development Using Java: A Class-Centered Approach, Enhanced Edition.
Modelling of Ecosystems by Tools from Computer Science Summer School at Czech University of Life Sciences, Prague, September, 2013 Winfried Kurth.
CMSC 330: Organization of Programming Languages Context-Free Grammars.
C++ Programming: From Problem Analysis to Program Design, Fourth Edition Chapter 6: User-Defined Functions I.
Tutorial and workshop „Modelling with GroIMP and XL“ / Tutorial for beginners University of Göttingen, 27 February, 2012 Winfried Kurth Introduction to.
Applications Development
Chapter 3 Part II Describing Syntax and Semantics.
Language Translation A programming language processor is any system that manipulates programs expressed in a PL A source program in some source language.
Adding functionality to a growth model; A tutorial on queries in GroImp Basic plant.gsz Adding function using queries.
Mathematical Preliminaries
CE 221 Data Structures and Algorithms Chapter 4: Trees (Binary) Text: Read Weiss, §4.1 – 4.2 1Izmir University of Economics.
LESSON 04.
Tutorial and workshop „Modelling with GroIMP and XL“ / Tutorial for beginners University of Göttingen, 27 February, 2012 Gerhard Buck-Sorlin and Winfried.
1 A Simple Syntax-Directed Translator CS308 Compiler Theory.
Copyright © 2006 The McGraw-Hill Companies, Inc. Programming Languages 2nd edition Tucker and Noonan Chapter 2 Syntax A language that is simple to parse.
Concepts and Realization of a Diagram Editor Generator Based on Hypergraph Transformation Author: Mark Minas Presenter: Song Gu.
Modelling of Ecosystems by Tools from Computer Science Summer School at Czech University of Life Sciences, Prague, September, 2013 Winfried Kurth.
Modelling of Ecosystems by Tools from Computer Science Summer School at Czech University of Life Sciences, Prague, September, 2013 Winfried Kurth.
Functional-Structural Plant Modelling with GroIMP and XL Tutorial and Workshop at Agrocampus Ouest, Angers, 5-7 May, 2015 Winfried Kurth University of.
Haskell Basics CSCE 314 Spring CSCE 314 – Programming Studio Using GHC and GHCi Log in to unix.cse.tamu.edu (or some other server) From a shell.
Copyright © Curt Hill Other Trees Applications of the Tree Structure.
Overview of Previous Lesson(s) Over View  A token is a pair consisting of a token name and an optional attribute value.  A pattern is a description.
Grammars, L-Systems Jim Whitehead UC Santa Cruz School of Engineering courses.soe.ucsc.edu/courses/cmps265/Spring14/01 23 Apr 2014.
Chapter 1 INTRODUCTION TO THE THEORY OF COMPUTATION.
Graph-Based Operational Semantics
Chapter 5 Classes.
Structural testing, Path Testing
Introduction to the C Language
Interpretive rules and instantiation rules
COMPILER CONSTRUCTION
Visual Programming Languages ICS 539 Icon System Visual Languages & Visual Programming, Chapter 1, Editor Chang, 1990 ICS Department KFUPM Sept. 1,
Presentation transcript:

Tutorial „Modelling in the language XL“ University of Göttingen (Germany), September 21/22, 2009 Winfried Kurth Some basic examples in XL (part 2) related material: XL code files sm09_e??.rgg URL and drive T:\rgg on CIP pool stations

interpretive rules insertion of a further phase of rule application directly preceding graphical interpretation (without effect on the next generation) application of interpretive rules interpretation by turtle

Example: module MainBud(int x) extends Sphere(3) {{setShader(GREEN);}}; module LBud extends Sphere(2) {{setShader(RED);}}; module LMeris; module AMeris; module Flower; const float d = 30; const float crit_dist = 21; protected void init() [ Axiom ==> MainBud(10); ] public void run() { [ MainBud(x) ==> F(20, 2, 15) if (x > 0) ( RH(180) [ LMeris ] MainBud(x-1) ) else ( AMeris ); LMeris ==> RU(random(50, 70)) F(random(15, 18), 2, 14) LBud; LBud ==> RL(90) [ Flower ]; AMeris ==> Scale(1.5) RL(90) Flower; /* Flower: here only a symbol */ ] applyInterpretation(); /* call of the execution of interpretive rules (to be done in the imperative part {... } !) */ } protected void interpret() /* block with interpretive rules */ [ Flower ==> RH(30) for ((1:5)) ( RH(72) [ RL(80) F(8, 1, 9) ] ); ]

public void run() { [ Axiom ==> A; A ==> Scale(0.3333) for (int i:(-1:1)) for (int j:(-1:1)) if ((i+1)*(j+1) != 1) ( [ Translate(i, j, 0) A ] ); ] applyInterpretation(); } public void interpret() [ A ==> Box; ] further example: generates the so-called „Menger sponge“ (a fractal)

public void run() { [ Axiom ==> A; A ==> Scale(0.3333) for (int i:(-1:1)) for (int j:(-1:1)) if ((i+1)*(j+1) != 1) ( [ Translate(i, j, 0) A ] ); ] applyInterpretation(); } public void interpret() [ A ==> Box; ] (a) (b)(c) A ==> Sphere(0.5); A ==> Box(0.1, 0.5, 0.1) Translate(0.1, 0.25, 0) Sphere(0.2);

what is generated by this example? public void run() { [ Axiom ==> [ A(0, 0.5) D(0.7) F(60) ] A(0, 6) F(100); A(t, speed) ==> A(t+1, speed); ] applyInterpretation(); } public void interpret() [ A(t, speed) ==> RU(speed*t); ]

The step towards graph grammars drawback of L-systems: in L-systems with branches (by turtle commands) only 2 possible relations between objects: "direct successor" and "branch" extensions: to permit additional types of relations to permit cycles  graph grammar

a string: a very simple graph  a string can be interpreted as a 1-dimensional graph with only one type of edges  successor edges (successor relation) A B A A A C C A B

graph grammars example rule: to make graphs dynamic, i.e., to let them change over time:

A relational growth grammar (RGG) (special type of Graph grammar) contains:  an alphabet –the definition of all allowed node types edge types (types of relations)  the Axiom –an initial graph, composed of elements of the alphabet  a set of graph replacement rules.

How an RGG rule is applied  each left-hand side of a rule describes a subgraph (a pattern of nodes and edges, which is looked for in the whole graph), which is replaced when the rule is applied.  each right-hand side of a rule defines a new subgraph which is inserted as substitute for the removed subgraph.

a complete RGG rule can have 5 parts: (* context *), left-hand side, ( condition ) ==> right-hand side { imperative XL code }

in text form we write (user-defined) edges as -edgetype-> edges of the special type "successor" are usually written as a blank (instead of -successor-> ) also possible: >

2 types of rules for graph replacement in XL: ● L-system rule, symbol: ==> provides an embedding of the right-hand side into the graph (i.e., incoming and outgoing edges are maintained) ● SPO rule, symbol: ==>> incoming and outgoing edges are deleted (if their maintenance is not explicitely prescribed in the rule) „SPO“ from „single pushout“ – a notion from universal algebra

a:A ==>> a:A C (SPO rule) B ==> D E (L-system rules) C ==> A start graph: ABC example:

a:A ==>> a:A C (SPO rule) B ==> D E (L-system rules) C ==> A ABC DEA

a:A ==>> a:A C (SPO rule) B ==> D E (L-system rules) C ==> A ABC DEA a:

a:A ==>> a:A C (SPO rule) B ==> D E (L-system rules) C ==> A AADE a: C = final result

test the example sm09_e27.rgg : module A extends Sphere(3); protected void init() [ Axiom ==> F(20, 4) A; ] public void runL() [ A ==> RU(20) F(20, 4) A; ] public void runSPO() [ A ==>> ^ RU(20) F(20, 4, 5) A; ] ( ^ denotes the root node in the current graph)

Mathematical background: see Chapter 4 of Ole Kniemeyer‘s doctoral dissertation ( opus-5937 ).

The language XL specification: Kniemeyer (2008)  extension of Java  allows also specification of L-systems and RGGs (graph grammars) in an intuitive rule notation procedural blocks, like in Java: {... } rule-oriented blocks (RGG blocks): [... ]

example: XL programme for the Koch curve (see part 1) public void derivation() [ Axiom ==> RU(90) F(10); F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3); ] Features of the language XL: ● nodes of the graph are Java objects (including geometry objects) nodes of the graph edges (type „successor“)

special nodes: geometry objects Box, Sphere, Cylinder, Cone, Frustum, Parallelogram... access to attributes by parameter list: Box(x, y, z) (length, width, height) or with special functions: Box(...).(setColor(0x007700)) (colour)

special nodes: geometry objects Box, Sphere, Cylinder, Cone, Frustum, Parallelogram... transformation nodes Translate(x, y, z), Scale(cx, cy, cz), Scale(c), Rotate(a, b, c), RU(a), RL(a), RH(a), RV(c), RG,... light sources PointLight, DirectionalLight, SpotLight, AmbientLight

Features of the language XL: ● rules organized in blocks [...], control of application by control structures example: rules for the stochastic tree Axiom ==> L(100) D(5) A; A ==> F0 LMul(0.7) DMul(0.7) if (probability(0.5)) ( [ RU(50) A ] [ RU(-10) A ] ) else ( [ RU(-50) A ] [ RU(10) A ] );

Features of the language XL: ● parallel application of the rules (can be modified: sequential mode can be switched on, see below)

Features of the language XL: ● parallel execution of assignments possible special assignment operator := besides the normal = quasi-parallel assignment to the variables x and y: x := f(x, y); y := g(x, y);

Features of the language XL: ● operator overloading (e.g., „+“ for vectors as for numbers)

Features of the language XL: ● set-valued expressions (more precisely: producer instead of sets) ● graph queries to analyze the actual structure

example for a graph query: binary tree, growth shall start only if there is enough distance to other F objects Axiom ==> F(100) [ RU(-30) A(70) ] RU(30) A(100); a:A(s) ==> if ( forall(distance(a, (* F *)) > 60) ) ( RH(180) F(s) [ RU(-30) A(70) ] RU(30) A(100) ) without the „if“ condition with the „if“ condition

query syntax: a query is enclosed by (* *) The elements are given in their expected order, e.g.: (* A A B *) searches for a subgraph which consists of a sequence of nodes of the types A A B, connected by successor edges. test the examples sm09_e28.rgg, sm09_e29.rgg, sm09_e30.rgg, sm09_e31.rgg, sm09_e35.rgg, sm09_e36.rgg

Features of the language XL: ● aggregating operators (e.g., „sum“, „mean“, „empty“, „forall“, „selectWhereMin“) can be applied to set-valued results of a query

Queries and aggregating operators provide possibilities to connect structure and function example: search for all leaves which are successors of node c and sum up their surface areas transitive closure aggregation operator result can be transferred to an imperative calculation query

Queries in XL test the examples sm09_e28.rgg, sm09_e29.rgg, sm09_e30.rgg, sm09_e31.rgg, sm09_e35.rgg, sm09_e36.rgg

Representation of graphs in XL ● node types must be declared with „ module “ ● nodes can be all Java objects. In user-made module declarations, methods (functions) and additional variables can be introduced, like in Java ● notation for nodes in a graph: Node_type, optionally preceded by: label: Examples: A, Meristem(t), b:Bud ● notation for edges in a graph: - edgetype ->, <- edgetype - ● special edge types: successor edge: -successor->, > or (blank) branch edge: -branch->, +> or [ refinement edge: />

Notations for special edge types > successor edge forward < successor edge backward --- successor edge forward or backward +> branch edge forward <+ branch edge backward -+- branch edge forward or backward /> refinement edge forward </ refinement edge backward --> arbitrary edge forward <-- arbitrary edge backward -- arbitrary edge forward or backward (cf. Kniemeyer 2008, p. 150 and 403)

user-defined edge types const int xxx = EDGE_0; // oder EDGE_1,..., EDGE_14... usage in the graph: -xxx->, <-xxx-, -xxx- Notation of graphs in XL example: is represented in programme code as (the representation is not unique!) ( >: successor edge, +: branch edge)

derived relations relation between nodes connected by several edges (one after the other) of the same type: „transitive hull“ of the original relation (edge)

Notation for the transitive hull in XL: (-edgetype->)+ reflexive-transitive hull („node stands in relation to itself“ also permitted): (-edgetype->)* e.g., for the successor relation: (>)* common transitive hull of the special relations „successor“ and „branch“, in reverse direction: -ancestor-> interpretation: this relation is valid to all „preceding nodes“ in a tree along the path to the root. nearest successors of a certain node type: -minDescendants-> (nodes of other types are skipped)

successor edge branch edge relation „ancestor“ minDescendants

The current graph GroIMP maintains always a graph which contains the complete current structural information. This graph is transformed by application of the rules. Attention: Not all nodes are visible objects in the 3-D view of the structure! - F0, F(x), Box, Sphere : yes - RU(30), A, B : normally not (if not derived by „ extends “ from visible objects) The graph can be completely visualized in the 2-D graph view (in GroIMP: Panels - 2D - Graph).

Load an example RGG file in GroIMP and execute some steps (do not work with a too complex structure). Open the 2-D graph view, fix the window with the mouse in the GroIMP user interface and test different layouts (Layout - Edit): Tree Sugiyama Square Circle Random SimpleEdgeBased Fruchterman Keep track of the changes of the graph when you apply the rules (click on „redraw“)!

which parts of the current graph of GroIMP are visible (in the 3-D view) ? all geometry nodes which can be accessed from the root (denoted ^) of the graph by exactly one path, which consists only of "successor" and "branch" edges How to enforce that an object is visible in any case: ==>> ^ Object

Derivation modes in XL default: parallel application of rules (like in L-systems) to switch into sequential mode (then, in each step at most one rule is applied at one match): setDerivationMode(SEQUENTIAL_MODE) to switch back to parallel mode: setDerivationMode(PARALLEL_MODE) test the example sm09_e32.rgg

a further type of rules: actualization rules often, nothing at the graph structure has to be changed, but only attributes of one single node are to be modified (e.g., calculation of photosynthesis in one leaf). For this purpose, there is an extra rule type: A ::> { imperative code }; Test the examples sm09_e25.rgg, sm09_e16.rgg, sm09_e17.gsz, sm09_e18.rgg and concerning the access to node attributes: sm09_e26.rgg

Modelling diameter growth in plants frequently used approaches: - regression diameter ~ length for new growth units - then, diameter increment dependent from age, branch order, etc. e.g., use rule with fixed annual growth Shoot(l, d) ==> Shoot(l, d+delta_d); interpretive rule for Shoot: Shoot(d) ==> F(l, d); - or: “pipe model“ assumption

“pipe model“ (SHINOZAKI et al. 1964) : parallel “unit pipes“ cross section area ~ leaf mass ~ fine root mass

conclusion: „Leonardo rule“ (da Vinci, about 1500) d  didi  In each branching node we have d 2 =  d i 2 (invariance of cross section area)

A = A 1 + A 2 d 2 = d d 2 2 A A1A1 A2A2 realization in an XL-based model: see examples sm09_e33.rgg, sm09_e34.rgg there, first the structural and length growth is simulated, then in separate steps the diameter growth, calculated top-down (also a – more realistic – combination is possible)