Case Studies in Using MATLAB to Build Model Calibration Tools for Multiscale Modeling

This chapter illustrates the versatility of MATLAB for building interactive end-user software applications to support the pedagogy of a multiscale modeling approach to computational materials engineering. The case studies presented here demonstrate how preexisting codes that model complex material behavior, even if written in compiled computer languages such as Fortran or C++, may be utilized as computational libraries for model calibration software tools built with MATLAB. Intended for students in computational engineering (mechanics and materials), these tools execute on personal computers without MATLAB if the MATLAB Runtime shared libraries are installed. Publications coauthored by students using these tools to calibrate material models and to investigate the performance of engineering materials indicate that the tools enable advances in engineering design from a computational engineering perspective

Quantum Computers and Quantum Computer Languages: Quantum Assembly Language and Quantum C

We show a representation of Quantum Computers defines Quantum Turing Machines with associated Quantum Grammars. We then create examples of Quantum Grammars. Lastly we develop an algebraic approach to high level Quantum Languages using Quantum Assembly language and Quantum C language as examples

Development of CAVLAB—A Control-Oriented MATLAB Based Simulator for an Underground Coal Gasification Process

The Cavity Simulation Model (CAVSIM) is a 3D, parameterisable simulator of the Underground Coal Gasification Process (UCG) that serves as a benchmark for UCG prediction. Despite yielding accurate outputs, CAVSIM has some limitations, which chiefly include inadequate graphical capabilities to visualise cavity geometry and gas production, time-ineffectiveness in terms of parametrisation, i.e., it involves editing, compiling multiple files and checking for errors, and lack of tools to synthesise a controller. Therefore, to compensate for these shortcomings, the services of third-party software, such as MATLAB, must be procured. CAVSIM was integrated with MATLAB to utilise its functionalities and toolboxes such as System Identification, Neural Network, and Optimization Toolbox etc. The integration was accomplished by designing C-mex files, and furthermore, the simulation results in both environments exhibit the same behaviour, demonstrating successful integration. Consequently, CAVSIM has also acquired a controllable structure, wherein parametrisation is now a single-click process; this is demonstrated by a case study outlining the implementation of Model Predictive Control (MPC) on a UCG plant. Moreover, the performance metrics, i.e., Mean Average Error (MAE) and Root Mean Square Error (RMSE) of 0.13, 0.23 for syngas heating value, and 0.012, 0.02 for flowrate quantitatively establishes the efficacy of CAVLAB in designing MPC for the UCG system. The novelty of this work lies in making the software package open-source with the aim of streamlining the research of multiple aspects of the UCG process

An Advanced, Three-Dimensional Plotting Library for Astronomy

We present a new, three-dimensional (3D) plotting library with advanced features, and support for standard and enhanced display devices. The library - S2PLOT - is written in C and can be used by C, C++ and FORTRAN programs on GNU/Linux and Apple/OSX systems. S2PLOT draws objects in a 3D (x,y,z) Cartesian space and the user interactively controls how this space is rendered at run time. With a PGPLOT inspired interface, S2PLOT provides astronomers with elegant techniques for displaying and exploring 3D data sets directly from their program code, and the potential to use stereoscopic and dome display devices. The S2PLOT architecture supports dynamic geometry and can be used to plot time-evolving data sets, such as might be produced by simulation codes. In this paper, we introduce S2PLOT to the astronomical community, describe its potential applications, and present some example uses of the library.Comment: 12 pages, 10 eps figures (higher resolution versions available from http://astronomy.swin.edu.au/s2plot/paperfigures). The S2PLOT library is available for download from http://astronomy.swin.edu.au/s2plo

Parallel computing on heterogeneous Networks: Challenges and Responses

In the paper, we analyse challenges associated with parallel programming for common networks of computers (NoCs) that are, unlike dedicated parallel computer systems, inherently heterogeneous and unreliable. This analysis results in description of main features of an ideal parallel program for NoCs. We also outline some recent parallel programming tools, which try and respond to some of the challenges

Doctor of Philosophy

dissertationIn the static analysis of functional programs, control- ow analysis (k-CFA) is a classic method of approximating program behavior as a infinite state automata. CFA2 and abstract garbage collection are two recent, yet orthogonal improvements, on k-CFA. CFA2 approximates program behavior as a pushdown system, using summarization for the stack. CFA2 can accurately approximate arbitrarily-deep recursive function calls, whereas k-CFA cannot. Abstract garbage collection removes unreachable values from the store/heap. If unreachable values are not removed from a static analysis, they can become reachable again, which pollutes the final analysis and makes it less precise. Unfortunately, as these two techniques were originally formulated, they are incompatible. CFA2's summarization technique for managing the stack obscures the stack such that abstract garbage collection is unable to examine the stack for reachable values. This dissertation presents introspective pushdown control-flow analysis, which manages the stack explicitly through stack changes (pushes and pops). Because this analysis is able to examine the stack by how it has changed, abstract garbage collection is able to examine the stack for reachable values. Thus, introspective pushdown control-flow analysis merges successfully the benefits of CFA2 and abstract garbage collection to create a more precise static analysis. Additionally, the high-performance computing community has viewed functional programming techniques and tools as lacking the efficiency necessary for their applications. Nebo is a declarative domain-specific language embedded in C++ for discretizing partial differential equations for transport phenomena. For efficient execution, Nebo exploits a version of expression templates, based on the C++ template system, which is a type-less, completely-pure, Turing-complete functional language with burdensome syntax. Nebo's declarative syntax supports functional tools, such as point-wise lifting of complex expressions and functional composition of stencil operators. Nebo's primary abstraction is mathematical assignment, which separates what a calculation does from how that calculation is executed. Currently Nebo supports single-core execution, multicore (thread-based) parallel execution, and GPU execution. With single-core execution, Nebo performs on par with the loops and code that it replaces in Wasatch, a pre-existing high-performance simulation project. With multicore (thread-based) execution, Nebo can linearly scale (with roughly 90% efficiency) up to 6 processors, compared to its single-core execution. Moreover, Nebo's GPU execution can be up to 37x faster than its single-core execution. Finally, Wasatch (the pre-existing high-performance simulation project which uses Nebo) can scale up to 262K cores