Ecoinformatics, Biometrics and Forest Growth

PhD topic D12


Theory and design of an interactive visual programming system for functional-structural plant models and implementation as an extension of the tools GroIMP and XL


Description:


"Visual programming" means that existing units (sub-programs, called "components") for clearly defined tasks are interactively put together on a graphical window to build some simulation model which the user desires. This component-based approach was recognized as a useful programming paradigm, having advantages for users who are afraid of developing long parts of code (Kramer et al. 1989, Szyperski 1999, Wang & Qian 2005). An example of a component-based system is the software RapidMiner® for the field of digital analysis of texts (RapidMiner 2014).


Functional-structural models of plants (FSPMs) attempt to represent physiological functions, growth and 3-dimensional architecture of plants in a coherent, unifying framework, in order to take into account the dependencies between structure and function (e.g., the architecture of tree crowns has influence on light interception and photosynthesis, and vice versa). Several platforms for designing FSPMs exist (e.g., GroIMP, 2014), but they usually require that code in some specialized or general programming language is written. A system for visual programming with components would have specific advantages for this field:


  • Established components for simulations of well-studied processes (e.g., photosyntesis) could easily be reused in different models,
  • the modular structure of plants makes it plausible to define components for organs occurring many times in a plant, like leaves or fruits,
  • components could easily be exchanged between cooperating teams,
  • the structure of simulation models would become more transparent and easier to reproduce and to publish,
  • modellers could more concentrate on novel aspects of certain components and less on technical details of the implementation,
  • the (intuitive) approach of "aspect-oriented modelling" (Cieslak et al. 2011) could be realized with the components,
  • the design of FSPMs could be learnt more easily by students of forest science or biology who are not acquainted with coding in a computer language.


In this project, the existing simulation platform GroIMP will be taken as a basis (Kniemeyer 2008, Hemmerling et al. 2008). This free software enables the programming of FSPMs with a rule-based language, called XL, which is already adapted to requirements of plant modelling (Kurth 2007). Parts of a component-based system were already implemented in GroIMP in a previous project (Henke et al. 2013). There is also the OpenAlea system for component-based design of FSPMs which is based on the language Python (Pradal et al. 2008), but it has still some shortcomings and disadvantages. The visual programming system to be developed should fulfill the following requirements:


  • implementation in Java as part of the software GroIMP;
  • component graphs should be part of the basic graph structure of GroIMP;
  • the underlying concept of the system (components, connectors and hierarchical, multi-scale structure) should be based on graph-theoretical and algebraic ideas (cf. Barbosa & Barbosa 2004, Bruni et al. 2010a,b, 2011, de Alfaro & Henzinger 2001, Schreiner & Göschka 2007, Tapken 1999),
  • the system should provide different types of connectors between the components (Bishop & Faria 1996),
  • experiences from other component-based systems should be taken into account (e.g., RapidMiner 2014; Armstrong et al. 1999, Blair et al. 2009, OpenAlea: Pradal et al. 2008), and existing standards for graphical representations (like GraphML, Brandes et al. 2002) should be considered,
  • for including existing components written in other languages than Java, the wrapper system Babel (Dahlgren et al. 2009) shall be used,
  • for components written in Java (the "normal" case), a simultaneous updating of the visual representation and of the corresponding code during the development process should be ensured (cf. Tsay et al. 2000).


In the end, the system should be applied and tested at some tree or forest simulation example.


Literature:


  • Armstrong, R.; Gannon, D.; Geist, A.; Keahey, K.; Kohn, S.; McInnes, L.; Parker, S.; Smolinski, B. (1999): Toward a common component architecture for high-performance scientific computing. In: Proceedings of the 8th IEEE International Symposium on High Performance Distributed Computing.
  • Barbosa, M. A.; Barbosa, L. S. (2004): A relational model for component interconnection. J. Universal Computer Sci. 10, 808-823.
  • Bishop, J.; Faria, R. (1996): Connectors in configuration programming languages: are they necessary? In: Third International Conference on Configurable Distributed Systems. Proceedings, IEEE, pp. 11-19.
  • Blair, G.; Coupaye, T.; Stefani, J.-B. (2009): Component-based architecture: the Fractal initiative. Ann. Telecommun. 64, 1-4.
  • Brandes, U.; Eiglsperger, M.; Herman, I.; Himsolt, M.; Marshall, M. S. (2002): GraphML progress report ? structural layer proposal. In: Graph Drawing, Springer, Berlin / Heidelberg, pp. 501-512.
  • Bruni, R.; Gadducci, F.; Lluch Lafuente, A. (2010a): An algebra of hierarchical graphs and its application to structural encoding. Scientific Annals in Computer Science 20, 53-96.
  • Bruni, R.; Gadducci, F.; Lluch Lafuente, A. (2010b): An algebra of hierarchical graphs. In: Trustworthly Global Computing. Springer, Berlin / Heidelberg, pp. 205-221.
  • Bruni, R.; Melgratti, H.; Montanari, U. (2011): A connector algebra for P/T nets interactions. In: Katoen JP, König B (eds.): CONCUR 2011, Lecture Notes in Computer Science 6901, Springer, Berlin, pp. 312-326.
  • Cieslak, M.; Seleznyova, A.N.; Prusinkiewicz, P.; Hanan, J. (2011): Towards aspect-oriented functional-structural plant modelling. Annals of Botany 108(6):1025-1041.
  • Dahlgren, T.; Kumfert, G.; Epperly, T.; Leek, K. (2009): Babel user's guide. Technical Report UCRL-SM-230026, Center for Applied Scientific Computing, Lawrence Livermore Nat. Lab., PO Box 808, Livermore, Cal.
  • de Alfaro, Luca; Henzinger, Thomas A. (2001): Interface theories for component-based design. In: Henzinger, T. A.; Kirsch, T. M. (eds.): EMSOFT 2001, Lecture Notes in Computer Science 2211, Springer, Berlin, pp. 148-165.
  • GroIMP (2014): http://www.grogra.de
  • Hemmerling, Reinhard; Kniemeyer, Ole; Lanwert, Dirk; Kurth, Winfried; Buck-Sorlin, Gerhard (2008): The rule-based language XL and the modelling environment GroIMP illustrated with simulated tree competition. Functional Plant Biology 35, 739-750.
  • Henke, Michael; Smole?ová, Katarína; Ong, Yongzhi; Kurth, Winfried (2013): An extension of the graph-grammar based simulator GroIMP for visual specification of plant models using components. In: Sievänen, R.; Nikinmaa, E.; Godin, C.; Lintunen, A.; Nygren, P. (eds.): Proceedings of the 7th International Conference on Functional-Structural Plant Models (FSPM 2013), 9-14 June 2013, Saariselkä, Finland, pp. 217-219.
  • Kniemeyer, Ole (2008): Design and Implementation of a Graph Grammar Based Language for Functional-Structural Plant Modelling. Ph.D. thesis, University of Technology at Cottbus. http://nbn-resolving.de/urn/resolver.pl?urn=urn:nbn:de:kobv:co1-opus-5937
  • Kramer, J.; Magee, J.; Ng, K. (1989): Graphical configuration programming. Computer, 22 (10), 53-58.
  • Kurth, Winfried (2007): Specification of morphological models with L-systems and relational growth grammars. Image, vol. 5 / Themenheft, http://www.uni-forst.gwdg.de/~wkurth/cb/html/ima_lsy.pdf
  • Pradal, C.; Dufour-Kowalski, S.; Boudon, F.; Fournier, C.; Godin, C. (2008): OpenAlea: A visual programming and component-based software platform for plant modeling. Functional Plant Biology 35, 751-760.
  • RapidMiner (2014): http://rapidminer.com/ (last access 7 February, 2014).
  • Schreiner, D.; Göschka, K. M. (2007): Explicit connectors in component based software engineering for distributed embedded systems. In: SOFSEM 2007: Theory and Practice of Computer Science, Springer, Berlin / Heidelberg, pp. 923-934
  • Szyperski, C. (1999): Component Software: Beyond Object-Oriented Programming. Addison-Wesley.
  • Tapken, J. (1999): Implementing hierarchical graph-structures. In: Fundamental Approaches to Software Engineering. Springer, Berlin / Heidelberg, pp. 219-233.
  • Tsay, J.; Hylands, C.; Lee, E. (2000): A code generation framework for Java component-based designs. In: Proceedings of the 2000 international conference on compilers, architecture, and synthesis for embedded systems, ACM, pp. 18-25.
  • Wang, A. J. A.; Qian, K. (2005): Component-oriented Programming. Wiley-Interscience.